PSR-4 is a PHP standard recommendation that provides guidelines for autoloading classes from file paths. It is managed by the PHP-FIG (PHP Framework Interop Group) and defines a way to map the fully qualified class names to the corresponding file paths. This standard helps streamline class loading, especially in larger projects and frameworks.

Key Principles of PSR-4:

1. Namespace Mapping: PSR-4 requires that the namespace and class name match the directory structure and file name. Each namespace prefix is associated with a base directory, and within that directory, the namespace hierarchy corresponds directly to the directory structure.

2. Base Directory: For each namespace prefix, a base directory is defined. Classes within that namespace are located in subdirectories of the base directory according to their namespace structure. For example:

   • If the namespace is App\Controllers, the file would be located in a folder like /path/to/project/src/Controllers.

3. File Naming: The class name must match the filename exactly, including case sensitivity, and end with .php.

4. Autoloader Compatibility: Implementing PSR-4 ensures compatibility with modern autoloaders like Composer’s, allowing PHP to locate and include classes automatically without manual require or include statements.

Example of PSR-4 Usage:

Suppose you have the namespace App\Controllers\UserController. According to PSR-4, the directory structure would look like:

/path/to/project/src/Controllers/UserController.php

In Composer’s composer.json, this mapping is specified like so:

{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

This configuration tells Composer to load classes in the App namespace from the src/ directory. When you run composer dump-autoload, it sets up the autoloading structure to follow PSR-4 standards.

Advantages of PSR-4:

• Consistency: Enforces a clear and organized file structure.
• Ease of Use: Allows seamless autoloading in large projects.
• Compatibility: Works well with frameworks and libraries that follow the PSR-4 standard.

PSR-4 has replaced the older PSR-0 standard, which had more restrictive rules on directory structure, making PSR-4 the preferred autoloading standard for modern PHP projects.

Composer Unused is a tool for PHP projects that helps identify unused dependencies in the composer.json file. It allows developers to clean up their list of dependencies and ensure that no unnecessary libraries are lingering in the project, which could bloat the codebase.

Features:

• Scan for unused dependencies: Composer Unused scans the project's source code and compares the classes and functions actually used with the dependencies defined in composer.json.
• List unused packages: It lists all the packages that are declared as dependencies in the composer.json but are not used in the project code.
• Clean up composer.json: The tool helps identify and remove unused dependencies, making the project leaner and more efficient.

Usage:

Composer Unused is typically used in PHP projects to ensure that only the necessary dependencies are included. This can lead to better performance and reduced maintenance effort by eliminating unnecessary libraries.

Composer Require Checker is a tool used to verify the consistency of dependencies in PHP projects, particularly when using the Composer package manager. It ensures that all the PHP classes and functions used in a project are covered by the dependencies specified in the composer.json file.

How it works:

• Dependency verification: Composer Require Checker analyzes the project's source code and checks if all the necessary classes and functions used in the code are provided by the installed Composer packages.
• Detect missing dependencies: If the code references libraries or functions that are not defined in the composer.json, the tool will flag them.
• Reduce unnecessary dependencies: It also helps identify dependencies that are declared in the composer.json but are not actually used in the code, helping keep the project lean.

Usage:

This tool is particularly useful for developers who want to ensure that their PHP project is clean and efficient, with no unused or missing dependencies.

CaptainHook is a PHP-based Git hook manager that helps developers automate tasks related to Git repositories. It allows you to easily configure and manage Git hooks, which are scripts that run automatically at certain points during the Git workflow (e.g., before committing or pushing code). This is particularly useful for enforcing coding standards, running tests, validating commit messages, or preventing bad code from being committed.

CaptainHook can be integrated into projects via Composer, and it offers flexibility for customizing hooks and plugins, making it easy to enforce project-specific rules. It supports multiple PHP versions, with the latest requiring PHP 8.0​.