friendsofphp/php-cs-fixer

The `friendsofphp/php-cs-fixer` package provides a powerful command-line tool known as PHP-CS-Fixer. Its primary purpose is to automatically fix PHP code to conform to various coding standards and conventions, such as PSR-1, PSR-2, PSR-12, Symfony, or custom rule sets.

What it is:
PHP-CS-Fixer is a code style linter and formatter for PHP. It analyzes your PHP code, identifies deviations from a specified coding standard, and then automatically modifies the files to correct those deviations.

Purpose and Benefits:
1. Code Consistency: Ensures all code across a project adheres to a single, predefined style, regardless of who wrote it.
2. Improved Readability: Consistent formatting makes code easier to read, understand, and navigate for all team members.
3. Reduced Manual Effort: Automates the tedious and time-consuming task of manually fixing code style issues, allowing developers to focus on logic and features.
4. Faster Code Reviews: By eliminating style discussions, code reviews can concentrate on architectural design, logic, and potential bugs.
5. Easier Onboarding: New team members can quickly adapt to a project's coding style without having to memorize extensive style guides.
6. Integration: Easily integrates into CI/CD pipelines, pre-commit hooks, and various IDEs (e.g., VS Code, PhpStorm).

How it Works:
1. Installation: Typically installed via Composer as a development dependency.
2. Configuration: You define which rules or rule sets to apply. This can be done via command-line arguments or, more commonly, through a configuration file (e.g., `.php-cs-fixer.dist.php`) at the root of your project.
3. Execution: You run the `php-cs-fixer` command, specifying the files or directories to scan. The tool then processes the files, applies the defined fixers, and modifies the code.

Key Features:
* Predefined Rule Sets: Supports popular standards like `@PSR12`, `@Symfony`, `@PhpCsFixer`, etc.
* Granular Rules: Allows enabling/disabling individual fixers and configuring their behavior (e.g., enforcing short array syntax, trailing commas).
* Dry Run: The `--dry-run` option allows you to see the changes that would be applied without actually modifying your files.
* Diff Output: The `--diff` option displays the differences between the original and fixed code.
* Caching: Uses a cache to speed up subsequent runs by only processing changed files.

In essence, `friendsofphp/php-cs-fixer` is an indispensable tool for any PHP project aiming for high code quality, consistency, and streamlined development workflows.

```php
# 1. Install php-cs-fixer via Composer (as a dev dependency)
composer require --dev friendsofphp/php-cs-fixer

# 2. Create an example PHP file with style violations (e.g., src/BadCode.php)
# file: src/BadCode.php
<?php namespace App\Foo; class BadCode{ private $name; public function __construct($name){$this->name=$name;} public function greet(){echo "Hello, {$this->name}!";}};

# 3. Create a configuration file (e.g., .php-cs-fixer.dist.php) for your project
# This tells php-cs-fixer which rules to apply and which files to scan.
# file: .php-cs-fixer.dist.php
<?php

$finder = PhpCsFixer\Finder::create()
    ->in(__DIR__ . '/src') // Scan files in the 'src' directory
    ->exclude('cache'); // Exclude a 'cache' directory if it existed

return (new PhpCsFixer\Config())
    ->setRules([
        '@PSR12' => true, // Apply the PSR-12 coding standard
        'array_syntax' => ['syntax' => 'short'], // Enforce short array syntax (e.g., [] instead of array())
        'no_unused_imports' => true, // Remove unused 'use' statements
        'ordered_imports' => ['sort_algorithm' => 'alpha'], // Sort imports alphabetically
    ])
    ->setFinder($finder);

# 4. Run php-cs-fixer to fix the code
# The tool will automatically detect the .php-cs-fixer.dist.php configuration file.
vendor/bin/php-cs-fixer fix

# You can also run it for a specific file or directory without a config file,
# specifying rules directly:
# vendor/bin/php-cs-fixer fix src/BadCode.php --rules=@PSR12 --diff

# 5. The 'src/BadCode.php' file after fixing will look like this:
# file: src/BadCode.php (After fix)
<?php

namespace App\Foo;

class BadCode
{
    private $name;

    public function __construct($name)
    {}
        $this->name = $name;
    }

    public function greet()
    {
        echo "Hello, {$this->name}!";
    }
}

# Notice the added newlines, spaces, and curly brace placements conforming to PSR-12.
```