### Reference sniff by file path

Source: https://github.com/squizlabs/php_codesniffer/wiki/Annotated-Ruleset

This example shows how to reference a sniff using its absolute or relative file path when the sniff is not installed or its code is unknown.

```XML
<rule ref="/path/to/standards/Generic/Sniffs/Commenting/TodoSniff.php"/>
<rule ref="../Generic/Sniffs/ControlStructures/InlineControlStructureSniff.php"/>
```

--------------------------------

### Install PHP_CodeSniffer using PEAR

Source: https://github.com/squizlabs/php_codesniffer/blob/master/README.md

Install PHP_CodeSniffer using the PEAR installer. This makes the phpcs and phpcbf commands available system-wide.

```bash
pear install PHP_CodeSniffer
```

--------------------------------

### Align Assignment Operators by Start

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Demonstrates code formatted with assignment operators aligned by their start.

```PHP
$foo = 'foo';
$foo .= 'bar';
```

--------------------------------

### View Configuration Options Output

Source: https://github.com/squizlabs/php_codesniffer/wiki/Advanced-Usage

This is an example of the output when viewing configuration options.

```text
Array
(
    [default_standard] => PEAR
    [zend_ca_path] => /path/to/ZendCodeAnalyzer
)
```

--------------------------------

### Install PHP_CodeSniffer using Phive

Source: https://github.com/squizlabs/php_codesniffer/blob/master/README.md

Install PHP_CodeSniffer as a project tool using Phive. Commands can then be run from the tools directory.

```bash
phive install phpcs
phive install phpcbf
```

--------------------------------

### PHP Code Example

Source: https://github.com/squizlabs/php_codesniffer/wiki/Advanced-Usage

A simple PHP file used to demonstrate the level map output. This code is for illustrative purposes.

```php
<?php
if ($condition) {
    echo 'Condition was true';
}
?>
```

--------------------------------

### List Installed Coding Standards

Source: https://github.com/squizlabs/php_codesniffer/wiki/Usage

Use the -i flag to display a list of all coding standards currently installed and available for use with PHP_CodeSniffer.

```bash
$ phpcs -i
The installed coding standards are MySource, PEAR, PHPCS, PSR1, PSR2, Squiz and Zend

```

--------------------------------

### PHP String Concatenation Example

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Illustrates the default zero-space padding around concatenation operators in PHP.

```PHP
$foo = $number.'-'.$letter;
```

--------------------------------

### Set Installed Standard Paths

Source: https://github.com/squizlabs/php_codesniffer/wiki/Configuration-Options

Adds custom paths where PHP_CodeSniffer should look for installed coding standards.

```bash
$ phpcs --config-set installed_paths /path/to/one,/path/to/two
```

--------------------------------

### Example of Multi-line Object Chain Indenting (PEAR.WhiteSpace.ObjectOperatorIndent)

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Demonstrates a multi-line object chain where indentation increases and decreases to show balanced method calls.

```php
$rootNode
    ->children()
        ->booleanNode('foo')
            ->defaultTrue()
        ->end()
        ->scalarNode('bar')
            ->defaultValue('default')
        ->end()
    ->end();
```

--------------------------------

### Install PHP_CodeSniffer globally via Composer

Source: https://github.com/squizlabs/php_codesniffer/blob/master/README.md

Install PHP_CodeSniffer globally using Composer. Ensure your composer bin directory is in your PATH.

```bash
composer global require "squizlabs/php_codesniffer=*"
```

--------------------------------

### Include sniffs from other standards using PHP

Source: https://github.com/squizlabs/php_codesniffer/wiki/Version-1.3.0-Upgrade-Guide

Example of a CodingStandard.php class that includes sniffs from PEAR and Generic standards.

```php
public function getIncludedSniffs()
{
  return array(
          'PEAR',
          'Generic/Sniffs/Formatting/MultipleStatementAlignmentSniff.php',
          'Generic/Sniffs/Functions',
         );

}//end getIncludedSniffs()
```

--------------------------------

### Verbose Tokeniser Output - Scope Map Example

Source: https://github.com/squizlabs/php_codesniffer/wiki/Advanced-Usage

This example shows the verbose tokeniser output for the scope map, detailing token processing for a simple PHP if statement.

```php
<?php
if ($condition) {
    echo 'Condition was true';
}
?>
```

```text
*** START SCOPE MAP ***
Start scope map at 1: T_IF => if
Process token 2 []: T_WHITESPACE =>  
Process token 3 []: T_OPEN_PARENTHESIS => (
* skipping parenthesis *
Process token 6 []: T_WHITESPACE =>  
Process token 7 []: T_OPEN_CURLY_BRACKET => {
=> Found scope opener for 1 (T_IF)
Process token 8 [opener:7;]: T_WHITESPACE => 
Process token 9 [opener:7;]: T_WHITESPACE =>     
Process token 10 [opener:7;]: T_ECHO => echo
Process token 11 [opener:7;]: T_WHITESPACE =>  
Process token 12 [opener:7;]: T_CONSTANT_ENCAPSED_STRING => 'Condition was true'
Process token 13 [opener:7;]: T_SEMICOLON => ;
Process token 14 [opener:7;]: T_WHITESPACE => 
Process token 15 [opener:7;]: T_CLOSE_CURLY_BRACKET => }
=> Found scope closer for 1 (T_IF)
*** END SCOPE MAP ***
```

--------------------------------

### Exclude an entire standard

Source: https://github.com/squizlabs/php_codesniffer/wiki/Annotated-Ruleset

This example shows how to include all sniffs from the 'Squiz' standard but exclude any sniffs that originate from the 'Generic' standard.

```XML
<rule ref="Squiz">
  <exclude name="Generic"/>
</rule>
```

--------------------------------

### Show Summary Report with Source Information

Source: https://github.com/squizlabs/php_codesniffer/wiki/Reporting

Use the -s flag with the summary report to get a concise overview of errors and warnings per file.

```bash
phpcs -s --report=summary /path/to/code
```

--------------------------------

### Specify PEAR Coding Standard

Source: https://github.com/squizlabs/php_codesniffer/wiki/Usage

Use the --standard argument to specify the coding standard to use for checking files. This example uses the PEAR standard for a specific file.

```bash
$ phpcs --standard=PEAR /path/to/code/myfile.inc

```

--------------------------------

### Customize multiple messages in a sniff

Source: https://github.com/squizlabs/php_codesniffer/wiki/Annotated-Ruleset

This example shows how to customize different messages within the same sniff, 'Generic.Files.LineLength', by providing unique codes for each message.

```XML
<rule ref="Generic.Files.LineLength.MaxExceeded">
  <message>Line contains %2$s chars, which is more than the limit of %1$s</message>
</rule>
<rule ref="Generic.Files.LineLength.TooLong">
  <message>Line longer than %s characters; contains %s characters</message>
</rule>
```

--------------------------------

### Configure Multiple Statement Alignment (Start Alignment)

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Set 'alignAtEnd' to false to align assignment operators by their start instead of their end.

```XML
<rule ref="Generic.Formatting.MultipleStatementAlignment">
    <properties>
        <property name="alignAtEnd" value="false" />
    </properties>
</rule>
```

--------------------------------

### Sample Ruleset with Selective Rule Application

Source: https://github.com/squizlabs/php_codesniffer/wiki/Annotated-Ruleset

This XML file demonstrates how to use phpcs-only and phpcbf-only attributes to apply rules selectively. It shows examples for configuration, file exclusion, sniff exclusion, message severity, and property values.

```xml
<?xml version="1.0"?>
<ruleset name="Selective Standard">

 <!--
    Use an external tool only when checking coding standards
    and not while fixing a file.
 -->
 <config phpcs-only="true" name="zend_ca_path" value="/path/to/ZendCodeAnalyzer"/>

 <!--
    Exclude some files from being fixed.
 -->
 <exclude-pattern phpcbf-only="true">*/3rdparty/*</exclude-pattern>

 <!--
    Exclude some sniffs when fixing files, but allow them
    to still report errors while checking files.
 -->
 <rule ref="Squiz">
  <exclude phpcbf-only="true" name="Generic.WhiteSpace.ScopeIndent"/>
 </rule>

 <!--
    Exclude some messages when fixing files, but allow them
    to still report errors while checking files.
 -->
 <rule ref="Generic.Commenting.Todo.CommentFound">
  <severity phpcbf-only="true">0</severity>
 </rule>

 <!--
    Set different property values for fixing and checking.
 -->
 <rule ref="Generic.Files.LineLength">
  <properties>
   <property phpcs-only="true" name="lineLimit" value="80"/>
   <property phpcbf-only="true" name="lineLimit" value="120"/>
  </properties>
 </rule>

</ruleset>
```

--------------------------------

### Convert sniff paths to internal codes

Source: https://github.com/squizlabs/php_codesniffer/wiki/Version-1.3.0-Upgrade-Guide

Examples demonstrating the conversion of file paths for sniffs to their internal PHP_CodeSniffer codes for use in ruleset.xml.

```plaintext
BEFORE: Generic/Sniffs/VersionControl/SubversionPropertiesSniff.php
AFTER:  Generic.VersionControl.SubversionProperties

BEFORE: PEAR/Sniffs/ControlStructures/ControlSignatureSniff.php
AFTER:  PEAR.ControlStructures.ControlSignature

BEFORE: Squiz/Sniffs/Strings/DoubleQuoteUsageSniff.php
AFTER:  Squiz.Strings.DoubleQuoteUsage
```

--------------------------------

### Level Map Output Example

Source: https://github.com/squizlabs/php_codesniffer/wiki/Advanced-Usage

The detailed token-by-token output of the level map for the provided PHP code. It shows token type, line number, level, and scope information.

```text
*** START LEVEL MAP ***
Process token 0 on line 1 [lvl:0;]: T_OPEN_TAG => <?php

Process token 1 on line 2 [lvl:0;]: T_IF => if
Process token 2 on line 2 [lvl:0;]: T_WHITESPACE =>  
Process token 3 on line 2 [lvl:0;]: T_OPEN_PARENTHESIS => (
Process token 4 on line 2 [lvl:0;]: T_VARIABLE => $condition
Process token 5 on line 2 [lvl:0;]: T_CLOSE_PARENTHESIS => )
Process token 6 on line 2 [lvl:0;]: T_WHITESPACE =>  
Process token 7 on line 2 [lvl:0;]: T_OPEN_CURLY_BRACKET => {
=> Found scope opener for 1 (T_IF)
    * level increased *
    * token 1 (T_IF) added to conditions array *
    Process token 8 on line 2 [lvl:1;conds;T_IF;]: T_WHITESPACE => 
    Process token 9 on line 3 [lvl:1;conds;T_IF;]: T_WHITESPACE =>     
    Process token 10 on line 3 [lvl:1;conds;T_IF;]: T_ECHO => echo
    Process token 11 on line 3 [lvl:1;conds;T_IF;]: T_WHITESPACE =>  
    Process token 12 on line 3 [lvl:1;conds;T_IF;]: T_CONSTANT_ENCAPSED_STRING => 'Condition was true'
    Process token 13 on line 3 [lvl:1;conds;T_IF;]: T_SEMICOLON => ;
    Process token 14 on line 3 [lvl:1;conds;T_IF;]: T_WHITESPACE => 
    Process token 15 on line 4 [lvl:1;conds;T_IF;]: T_CLOSE_CURLY_BRACKET => }
    => Found scope closer for 7 (T_OPEN_CURLY_BRACKET)
    * token T_IF removed from conditions array *
    * level decreased *
Process token 16 on line 4 [lvl:0;]: T_WHITESPACE => 
Process token 17 on line 5 [lvl:0;]: T_CLOSE_TAG => ?>
*** END LEVEL MAP ***
```

--------------------------------

### Configure FunctionComment specialMethods

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Define special methods that do not require a @return tag in their docblocks. Includes default methods and an example to ignore another function.

```xml
<rule ref="PEAR.Commenting.FunctionComment">
    <properties>
        <property name="specialMethods" type="array">
            <element value="__construct"/>
            <element value="__destruct"/>
            <element value="ignoreThisFunction"/>
        </property>
    </properties>
</rule>
```

--------------------------------

### Run PHP_CodeSniffer from Phive tools directory

Source: https://github.com/squizlabs/php_codesniffer/blob/master/README.md

Execute PHP_CodeSniffer commands after installing them with Phive. The executables are located in the tools directory.

```bash
./tools/phpcs -h
./tools/phpcbf -h
```

--------------------------------

### Run PHP_CodeSniffer from Composer vendor bin

Source: https://github.com/squizlabs/php_codesniffer/blob/master/README.md

If PHP_CodeSniffer is installed as a project dependency via Composer, run the commands from the vendor bin directory.

```bash
./vendor/bin/phpcs -h
./vendor/bin/phpcbf -h
```

--------------------------------

### Customize sniff property for end of line character

Source: https://github.com/squizlabs/php_codesniffer/wiki/Annotated-Ruleset

This example shows how to customize the 'Generic.Files.LineEndings' sniff by specifying the expected end-of-line character.

```XML
<rule ref="Generic.Files.LineEndings">
  <properties>
   <property name="eolChar" value="\r\n"/>
  </properties>
</rule>
```

--------------------------------

### Summary report

Source: https://github.com/squizlabs/php_codesniffer/wiki/Usage

Use the --report=summary argument to get a concise report showing only the count of errors and warnings per file.

```bash
$ phpcs --report=summary /path/to/code
```

--------------------------------

### PHP Function Declaration with Default Arguments

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Example of a PHP function declaration with default argument values, demonstrating the default spacing around the equals sign.

```PHP
function foo($a='a', $b='b') {
    // Body.
}
```

--------------------------------

### Verbose Token Processing Output Example

Source: https://github.com/squizlabs/php_codesniffer/wiki/Advanced-Usage

This output shows the detailed token processing for a PHP code snippet, including token IDs, types, contents, and sniff execution times. It is useful for debugging.

```text
*** START TOKEN PROCESSING ***
Process token 0: T_OPEN_TAG => <?php
    Processing PEAR_Sniffs_Commenting_FileCommentSniff... DONE in 0 seconds
    Processing Generic_Sniffs_PHP_DisallowShortOpenTagSniff... DONE in 0 seconds
    Processing Generic_Sniffs_Files_LineLengthSniff... DONE in 0.0001 seconds
    Processing Generic_Sniffs_Files_LineEndingsSniff... DONE in 0 seconds
Process token 1: T_IF => if
    Processing PEAR_Sniffs_ControlStructures_ControlSignatureSniff... DONE in 0.0001 seconds
    Processing PEAR_Sniffs_ControlStructures_MultiLineConditionSniff... DONE in 0 seconds
    Processing PEAR_Sniffs_WhiteSpace_ScopeClosingBraceSniff... DONE in 0 seconds
    Processing PEAR_Sniffs_WhiteSpace_ScopeIndentSniff... DONE in 0 seconds
    Processing Generic_Sniffs_ControlStructures_InlineControlStructureSniff... DONE in 0 seconds
Process token 2: T_WHITESPACE =>  
    Processing Generic_Sniffs_WhiteSpace_DisallowTabIndentSniff... DONE in 0 seconds
Process token 3: T_OPEN_PARENTHESIS => (
Process token 4: T_VARIABLE => $condition
    Processing PEAR_Sniffs_NamingConventions_ValidVariableNameSniff... DONE in 0 seconds
Process token 5: T_CLOSE_PARENTHESIS => )
Process token 6: T_WHITESPACE =>  
    Processing Generic_Sniffs_WhiteSpace_DisallowTabIndentSniff... DONE in 0 seconds
Process token 7: T_OPEN_CURLY_BRACKET => {
Process token 8: T_WHITESPACE => 
    Processing Generic_Sniffs_WhiteSpace_DisallowTabIndentSniff... DONE in 0 seconds
Process token 9: T_WHITESPACE =>     
    Processing Generic_Sniffs_WhiteSpace_DisallowTabIndentSniff... DONE in 0 seconds
Process token 10: T_ECHO => echo
Process token 11: T_WHITESPACE =>  
    Processing Generic_Sniffs_WhiteSpace_DisallowTabIndentSniff... DONE in 0 seconds
Process token 12: T_CONSTANT_ENCAPSED_STRING => 'Condition was true'
Process token 13: T_SEMICOLON => ;
Process token 14: T_WHITESPACE => 
    Processing Generic_Sniffs_WhiteSpace_DisallowTabIndentSniff... DONE in 0 seconds
Process token 15: T_CLOSE_CURLY_BRACKET => }
Process token 16: T_WHITESPACE => 
    Processing Generic_Sniffs_WhiteSpace_DisallowTabIndentSniff... DONE in 0 seconds
Process token 17: T_CLOSE_TAG => ?>
*** END TOKEN PROCESSING ***
```

--------------------------------

### Change sniff message type

Source: https://github.com/squizlabs/php_codesniffer/wiki/Annotated-Ruleset

This example demonstrates changing the message type of a specific sniff message from its default to 'error' or 'warning'.

```XML
<rule ref="Generic.Commenting.Todo.CommentFound">
  <type>error</type>
</rule>
<rule ref="Squiz.Strings.DoubleQuoteUsage.ContainsVar">
  <type>warning</type>
</rule>
```

--------------------------------

### PHP control structure with alternative syntax and one space before colon

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Example of PHP control structure using alternative syntax, adhering to the default rule of one space before the colon.

```PHP
if ($foo) :
    // IF body.
else :
    // ELSE body.
endif;
```

--------------------------------

### Specify Multiple Coding Standards

Source: https://github.com/squizlabs/php_codesniffer/wiki/Usage

Pass a comma-separated list of standards to the --standard argument to check files against multiple coding standards simultaneously, including a mix of installed and external standards.

```bash
$ phpcs --standard=PEAR,Squiz,/path/to/MyStandard /path/to/code/myfile.inc

```

--------------------------------

### Comprehensive Information Report with Multiple Standards

Source: https://github.com/squizlabs/php_codesniffer/wiki/Reporting

To get a more thorough analysis, specify multiple standards. This command checks your code against a wider range of conventions, providing more detailed information.

```bash
phpcs --standard=Generic,PEAR,Squiz,PSR2,Zend --report=info /path/to/code
```

--------------------------------

### Hard-coding Include Patterns for Sniffs

Source: https://github.com/squizlabs/php_codesniffer/wiki/Annotated-Ruleset

Hard-code include patterns to limit sniffs to specific files. Patterns are checked using absolute paths. This example runs Squiz DoubleQuoteUsage only for files matching '*/templates/*' or '*\.tpl$'.

```XML
<rule ref="Squiz.Strings.DoubleQuoteUsage">
    <include-pattern>*/templates/*</include-pattern>
    <include-pattern>*\.tpl$</include-pattern>
 </rule>
```

--------------------------------

### View Currently Set Configuration Options

Source: https://github.com/squizlabs/php_codesniffer/wiki/Advanced-Usage

Use this command to display all currently set configuration options and their values.

```bash
phpcs --config-show
```

--------------------------------

### Create ruleset.xml file

Source: https://github.com/squizlabs/php_codesniffer/wiki/Version-1.3.0-Upgrade-Guide

Use the 'touch' command to create an empty ruleset.xml file in the top-level directory of your custom coding standard.

```bash
touch MyStandard/ruleset.xml
```

--------------------------------

### Set a Configuration Option

Source: https://github.com/squizlabs/php_codesniffer/wiki/Advanced-Usage

Use this command to set a configuration option globally. Options are written to a global configuration file.

```bash
phpcs --config-set <option> <value>
```

--------------------------------

### Implement processTokenOutsideScope

Source: https://github.com/squizlabs/php_codesniffer/wiki/Version-3.0-Upgrade-Guide

If processTokenOutsideScope was not previously defined, it must now be implemented as an abstract method. Include an empty method if no specific logic is required.

```php
protected function processTokenOutsideScope(File $phpcsFile, $stackPtr)
{
}

```

--------------------------------

### Exclude a specific sniff message

Source: https://github.com/squizlabs/php_codesniffer/wiki/Annotated-Ruleset

This example demonstrates excluding a specific message, 'Squiz.Strings.DoubleQuoteUsage.ContainsVar', from a sniff.

```XML
<rule ref="Squiz">
  <exclude name="Squiz.Strings.DoubleQuoteUsage.ContainsVar"/>
</rule>
```

--------------------------------

### PHP Function Declaration with No Argument Padding

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Example of a PHP function declaration with no padding inside the argument list brackets.

```PHP
function foo($a, $b) {
    // Body.
}
```

--------------------------------

### Set a Runtime Configuration Option

Source: https://github.com/squizlabs/php_codesniffer/wiki/Advanced-Usage

Use this command to set a configuration option for a single run only. Not all options can be set this way.

```bash
phpcs --runtime-set <option> <value> /path/to/code
```

--------------------------------

### PHP code with only @inheritdoc

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Example of a PHP function comment that uses the {@inheritDoc} tag, which can be skipped by the FunctionComment sniff when configured.

```PHP
/**
 * {@inheritDoc}
 */
public function foo($a, $b) {}
```

--------------------------------

### Using --suffix to Create Fixed File Backups

Source: https://github.com/squizlabs/php_codesniffer/wiki/Fixing-Errors-Automatically

Applies `phpcbf` to code paths while creating new files with a specified suffix (e.g., `.fixed`) instead of modifying originals. This is useful for reviewing changes before committing.

```bash
$ phpcbf /path/to/code --suffix=.fixed
Processing init.php [PHP => 7875 tokens in 960 lines]... DONE in 274ms (12 fixable violations)
    => Fixing file: 0/12 violations remaining [made 3 passes]... DONE in 412ms
    => Fixed file written to init.php.fixed
Processing config.php [PHP => 8009 tokens in 957 lines]... DONE in 421ms (155 fixable violations)
    => Fixing file: 0/155 violations remaining [made 7 passes]... DONE in 937ms
    => Fixed file written to config.php.fixed
Fixed 2 files
Time: 2.55 secs, Memory: 25.00Mb
```

--------------------------------

### PHP_CodeSniffer Command Line Help

Source: https://github.com/squizlabs/php_codesniffer/wiki/Usage

Displays all available commands and options for running PHP_CodeSniffer from the command line. Use this to understand the full range of functionalities.

```bash
Usage: phpcs [-nwlsaepqvi] [-d key[=value]] [--colors] [--no-colors]
  [--cache[=<cacheFile>]] [--no-cache] [--tab-width=<tabWidth>]
  [--report=<report>] [--report-file=<reportFile>] [--report-<report>=<reportFile>]
  [--report-width=<reportWidth>] [--basepath=<basepath>] [--bootstrap=<bootstrap>]
  [--severity=<severity>] [--error-severity=<severity>] [--warning-severity=<severity>]
  [--runtime-set key value] [--config-set key value] [--config-delete key] [--config-show]
  [--standard=<standard>] [--sniffs=<sniffs>] [--exclude=<sniffs>]
  [--encoding=<encoding>] [--parallel=<processes>] [--generator=<generator>]
  [--extensions=<extensions>] [--ignore=<patterns>] [--ignore-annotations]
  [--stdin-path=<stdinPath>] [--file-list=<fileList>] [--filter=<filter>] <file> - ...

 -     Check STDIN instead of local files and directories
 -n    Do not print warnings (shortcut for --warning-severity=0)
 -w    Print both warnings and errors (this is the default)
 -l    Local directory only, no recursion
 -s    Show sniff codes in all reports
 -a    Run interactively
 -e    Explain a standard by showing the sniffs it includes
 -p    Show progress of the run
 -q    Quiet mode; disables progress and verbose output
 -m    Stop error messages from being recorded
       (saves a lot of memory, but stops many reports from being used)
 -v    Print processed files
 -vv   Print ruleset and token output
 -vvv  Print sniff processing information
 -i    Show a list of installed coding standards
 -d    Set the [key] php.ini value to [value] or [true] if value is omitted

 --help                Print this help message
 --version             Print version information
 --colors              Use colors in output
 --no-colors           Do not use colors in output (this is the default)
 --cache               Cache results between runs
 --no-cache            Do not cache results between runs (this is the default)
 --ignore-annotations  Ignore all phpcs: annotations in code comments

 <cacheFile>    Use a specific file for caching (uses a temporary file by default)
 <basepath>     A path to strip from the front of file paths inside reports
 <bootstrap>    A comma separated list of files to run before processing begins
 <encoding>     The encoding of the files being checked (default is utf-8)
 <extensions>   A comma separated list of file extensions to check
                The type of the file can be specified using: ext/type
                e.g., module/php,es/js
 <file>         One or more files and/or directories to check
 <fileList>     A file containing a list of files and/or directories to check (one per line)
 <filter>       Use either the "GitModified" or "GitStaged" filter,
                or specify the path to a custom filter class
 <generator>    Use either the "HTML", "Markdown" or "Text" generator
                (forces documentation generation instead of checking)
 <patterns>     A comma separated list of patterns to ignore files and directories
 <processes>    How many files should be checked simultaneously (default is 1)
 <report>       Print either the "full", "xml", "checkstyle", "csv"
                "json", "junit", "emacs", "source", "summary", "diff"
                "svnblame", "gitblame", "hgblame" or "notifysend" report,
                or specify the path to a custom report class
                (the "full" report is printed by default)
 <reportFile>   Write the report to the specified file path
 <reportWidth>  How many columns wide screen reports should be printed
                or set to "auto" to use current screen width, where supported
 <severity>     The minimum severity required to display an error or warning
 <sniffs>       A comma separated list of sniff codes to include or exclude from checking
                (all sniffs must be part of the specified standard)
 <standard>     The name or path of the coding standard to use
 <stdinPath>    If processing STDIN, the file path that STDIN will be processed as
 <tabWidth>     The number of spaces each tab represents
```

--------------------------------

### PHP CodeSniffer Fixer (phpcbf) Help Output

Source: https://github.com/squizlabs/php_codesniffer/wiki/Fixing-Errors-Automatically

Displays the available command-line arguments and options for the `phpcbf` tool. Use this to understand the full range of configuration possibilities.

```bash
Usage: phpcbf [-nwli] [-d key[=value]] [--ignore-annotations] [--stdin-path=<stdinPath>]
  [--standard=<standard>] [--sniffs=<sniffs>] [--exclude=<sniffs>] [--suffix=<suffix>]
  [--severity=<severity>] [--error-severity=<severity>] [--warning-severity=<severity>]
  [--tab-width=<tabWidth>] [--encoding=<encoding>] [--parallel=<processes>]
  [--basepath=<basepath>] [--extensions=<extensions>] [--ignore=<patterns>] <file> - ...

 -     Fix STDIN instead of local files and directories
 -n    Do not fix warnings (shortcut for --warning-severity=0)
 -w    Fix both warnings and errors (on by default)
 -l    Local directory only, no recursion
 -p    Show progress of the run
 -q    Quiet mode; disables progress and verbose output
 -v    Print processed files
 -vv   Print ruleset and token output
 -vvv  Print sniff processing information
 -i    Show a list of installed coding standards
 -d    Set the [key] php.ini value to [value] or [true] if value is omitted

 --help                Print this help message
 --version             Print version information
 --ignore-annotations  Ignore all @codingStandard annotations in code comments

 <basepath>    A path to strip from the front of file paths inside reports
 <file>        One or more files and/or directories to fix
 <encoding>    The encoding of the files being fixed (default is utf-8)
 <extensions>  A comma separated list of file extensions to fix
               (extension filtering only valid when checking a directory)
               The type of the file can be specified using: ext/type
               e.g., module/php,es/js
 <patterns>    A comma separated list of patterns to ignore files and directories
 <processes>   How many files should be fixed simultaneously (default is 1)
 <severity>    The minimum severity required to fix an error or warning
 <sniffs>      A comma separated list of sniff codes to include or exclude from fixing
               (all sniffs must be part of the specified standard)
 <standard>    The name or path of the coding standard to use
 <stdinPath>   If processing STDIN, the file path that STDIN will be processed as
 <suffix>      Write modified files to a filename using this suffix
               ("diff" and "patch" are not used in this mode)
 <tabWidth>    The number of spaces each tab represents

```

--------------------------------

### Default Multi-line Function Call Formatting (PEAR.Functions.FunctionCallSignature)

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Illustrates the default behavior where multiple arguments can appear on each line in multi-line function calls.

```php
$returnValue = foo(
    $a, $b, $c,
    $d, $e
);
```

--------------------------------

### Check multiple files and directories

Source: https://github.com/squizlabs/php_codesniffer/wiki/Usage

Specify multiple files and directories in a single command to check them all.

```bash
$ phpcs /path/to/code/myfile.inc /path/to/code/my_dir
```

--------------------------------

### Set PHP Executable Path

Source: https://github.com/squizlabs/php_codesniffer/wiki/Configuration-Options

Use the 'php_path' configuration option to point to the PHP binary. This is necessary for the Generic coding standard's Syntax sniff to validate PHP file syntax.

```bash
$ phpcs --config-set php_path /path/to/php
```

--------------------------------

### Run Unit Tests

Source: https://github.com/squizlabs/php_codesniffer/blob/master/CONTRIBUTING.md

Execute this command to ensure all unit tests pass. Skipped tests are acceptable as they relate to external tools.

```bash
phpunit
```

--------------------------------

### Show Progress by Default

Source: https://github.com/squizlabs/php_codesniffer/wiki/Configuration-Options

Configure PHP_CodeSniffer to show progress output by default. Use '1' to show, '0' to hide. This cannot be set using --runtime-set.

```bash
$ phpcs --config-set show_progress 1
```

--------------------------------

### PHP Function Declaration with Spaced Argument Padding

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Example of a PHP function declaration with a single space after the opening bracket and before the closing bracket of the argument list.

```PHP
function foo( $a, $b ) {
    // Body.
}
```

--------------------------------

### PHP Function Declaration with Spaced Default Arguments

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Example of a PHP function declaration with default argument values, showing spacing around the equals sign.

```PHP
function foo($a = 'a', $b = 'b') {
    // Body.
}
```

--------------------------------

### Configure Line Length Limits

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Set custom warning and error thresholds for line lengths. Ensure 'lineLimit' is less than or equal to 'absoluteLineLimit'.

```XML
<!--
 Warn about lines longer than 100 chars,
 and error for lines longer than 135 chars.
-->
<rule ref="Generic.Files.LineLength">
    <properties>
        <property name="lineLimit" value="100" />
        <property name="absoluteLineLimit" value="135" />
    </properties>
</rule>
```

--------------------------------

### Set custom comment format for LongConditionClosingComment sniff

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Define a custom format for closing comments in the Squiz.Commenting.LongConditionClosingComment sniff. This example sets the format to '// end %s()'.

```XML
<!-- Have code block comments look like // end foreach() etc. -->
<rule ref="Squiz.Commenting.LongConditionClosingComment">
    <properties>
        <property name="commentFormat" value="// end %s()" />
    </properties>
</rule>
```

--------------------------------

### PHP For Loop with Default Padding

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Demonstrates the default zero-space padding for for loop declarations.

```php
for ($i = 0; $i < 10; $i++) {
    // Body.
}
```

--------------------------------

### Emacs Integration for PHP Mode

Source: https://github.com/squizlabs/php_codesniffer/wiki/Reporting

Configure Emacs to automatically run PHP_CodeSniffer on the current buffer using the compile command. Ensure PHP mode for Emacs is installed.

```emacs-lisp
(require 'compile)
(defun my-php-hook-function ()
 (set (make-local-variable 'compile-command) (format "phpcs --report=emacs --standard=PEAR %s" (buffer-file-name))))
(add-hook 'php-mode-hook 'my-php-hook-function)
```

--------------------------------

### Specify External Coding Standard

Source: https://github.com/squizlabs/php_codesniffer/wiki/Usage

Use the --standard argument with a full path to check files using an external coding standard not installed within PHP_CodeSniffer.

```bash
$ phpcs --standard=/path/to/MyStandard /path/to/code/myfile.inc

```

--------------------------------

### DisallowHashCommentsSniff Implementation

Source: https://github.com/squizlabs/php_codesniffer/wiki/Coding-Standard-Tutorial

This PHP code defines a custom sniff for PHP_CodeSniffer that prohibits the use of Perl-style hash comments. It registers for T_COMMENT tokens and checks if the comment content starts with '#'.

```php
<?php
/**
 * This sniff prohibits the use of Perl style hash comments.
 *
 * PHP version 5
 *
 * @category  PHP
 * @package   PHP_CodeSniffer
 * @author    Your Name <you@domain.net>
 * @license   https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence
 * @link      http://pear.php.net/package/PHP_CodeSniffer
 */

namespace PHP_CodeSniffer\Standards\MyStandard\Sniffs\Commenting;

use PHP_CodeSniffer\Sniffs\Sniff;
use PHP_CodeSniffer\Files\File;

class DisallowHashCommentsSniff implements Sniff
{


    /**
     * Returns the token types that this sniff is interested in.
     *
     * @return array(int)
     */
    public function register()
    {
        return array(T_COMMENT);

    }//end register()


    /**
     * Processes this sniff, when one of its tokens is encountered.
     *
     * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked.
     * @param int                         $stackPtr  The position of the current token in the
     *                                               stack passed in $tokens.
     *
     * @return void
     */
    public function process(File $phpcsFile, $stackPtr)
    {
        $tokens = $phpcsFile->getTokens();
        if ($tokens[$stackPtr]['content']{0} === '#') {
            $error = 'Hash comments are prohibited; found %s';
            $data  = array(trim($tokens[$stackPtr]['content']));
            $phpcsFile->addError($error, $stackPtr, 'Found', $data);
        }

    }//end process()


}//end class

?>

```

--------------------------------

### Print Mixed Reports (File and Screen)

Source: https://github.com/squizlabs/php_codesniffer/wiki/Reporting

Generate some reports to files and others directly to the screen by mixing file path specifications with standard report arguments.

```bash
$ phpcs --report-full=/path/to/full.txt --report-summary /path/to/code
```

--------------------------------

### PHP control structure with alternative syntax and no space before colon

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Example of PHP control structure using alternative syntax, with no space before the colon, which can be enforced by setting requiredSpacesBeforeColon to 0.

```PHP
if ($foo):
    // IF body.
else:
    // ELSE body.
endif;
```

--------------------------------

### PHP Foreach Loop with Single Space Padding

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Illustrates a foreach loop declaration with single-space padding.

```php
foreach ( $foo as $bar ) {
    // Body.
}
```

--------------------------------

### Running phpcbf to Fix Code Violations

Source: https://github.com/squizlabs/php_codesniffer/wiki/Fixing-Errors-Automatically

Executes `phpcbf` on specified code paths to automatically fix detected violations. This example shows the typical output during the fixing process.

```bash
$ phpcbf /path/to/code
Processing init.php [PHP => 7875 tokens in 960 lines]... DONE in 274ms (12 fixable violations)
    => Fixing file: 0/12 violations remaining [made 3 passes]... DONE in 412ms
Processing config.php [PHP => 8009 tokens in 957 lines]... DONE in 421ms (155 fixable violations)
    => Fixing file: 0/155 violations remaining [made 7 passes]... DONE in 937ms
Patched 2 files
Time: 2.55 secs, Memory: 25.00Mb
```

--------------------------------

### Print Multiple Reports to Screen

Source: https://github.com/squizlabs/php_codesniffer/wiki/Reporting

Combine multiple report types by using separate --report-[type] arguments. Reports are printed to the screen in the order specified.

```bash
$ phpcs --report-full --report-summary /path/to/code
```

--------------------------------

### PSR2 Control Structure Spacing: Default

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Illustrates the default zero padding inside control structure brackets.

```PHP
if ($condition === true) {
    // Body.
}

```

--------------------------------

### Custom Coding Standard with Exclusions

Source: https://github.com/squizlabs/php_codesniffer/wiki/Version-1.3.0-Upgrade-Guide

Defines a custom coding standard by including the PEAR standard and excluding a specific sniff. This is useful for creating tailored coding style guides.

```php
public function getIncludedSniffs()
{
  return array(
          'PEAR',
         );

}//end getIncludedSniffs()

public function getExcludedSniffs()
{
  return array(
          'PEAR/Sniffs/ControlStructures/ControlSignatureSniff.php',
         );

}//end getExcludedSniffs()
```

--------------------------------

### Configure Function Spacing for Squiz.WhiteSpace.FunctionSpacing (Specific)

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Set 'spacing', 'spacingBeforeFirst', and 'spacingAfterLast' properties to '1' to enforce one blank line before and after functions, with specific exceptions for the first and last functions in a block.

```XML
<!-- Ensure 1 blank line before and after functions, except at the top and bottom. -->
<rule ref="Squiz.WhiteSpace.FunctionSpacing">
    <properties>
        <property name="spacing" value="1" />
        <property name="spacingBeforeFirst" value="0" />
        <property name="spacingAfterLast" value="0" />
    </properties>
</rule>
```

--------------------------------

### Disabling Specific Error Messages

Source: https://github.com/squizlabs/php_codesniffer/wiki/Annotated-Ruleset

Change the severity of a message to 0 to disable it without excluding the entire sniff. This example disables the 'ContainsVar' error message from the Squiz DoubleQuoteUsage sniff.

```XML
<rule ref="Squiz.Strings.DoubleQuoteUsage.ContainsVar">
  <severity>0</severity>
 </rule>
```

--------------------------------

### Show Full Report with Source Information

Source: https://github.com/squizlabs/php_codesniffer/wiki/Reporting

Use the -s flag to include source information in the full report. This shows the specific sniffs that triggered errors or warnings.

```bash
phpcs -s /path/to/code/myfile.php
```

--------------------------------

### Hard-coding Include Patterns for Messages

Source: https://github.com/squizlabs/php_codesniffer/wiki/Annotated-Ruleset

More specific inclusion of messages. This example shows the 'ContainsVar' error from Squiz DoubleQuoteUsage only for files matching '*/templates/*' or '*\.tpl$'. Patterns are checked using absolute paths.

```XML
<rule ref="Squiz.Strings.DoubleQuoteUsage.ContainsVar">
    <include-pattern>*/templates/*</include-pattern>
    <include-pattern>*\.tpl$</include-pattern>
 </rule>
```

--------------------------------

### Include sniffs from other standards using ruleset.xml

Source: https://github.com/squizlabs/php_codesniffer/wiki/Version-1.3.0-Upgrade-Guide

This ruleset.xml file replicates the sniff inclusions from the sample CodingStandard.php class, using the 'rule' tag and internal sniff codes.

```xml
<?xml version="1.0"?>
    <ruleset name="My Standard">
    <description>My custom coding standard</description>
    <rule ref="PEAR"/>
    <rule ref="Generic.Formatting.MultipleStatementAlignment"/>
    <rule ref="Generic/Sniffs/Functions"/>
</ruleset>
```

--------------------------------

### Configure ForeachLoopDeclaration Padding in XML

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

XML configuration to set one space after the open bracket and before the close bracket for foreach loops.

```xml
<rule ref="Squiz.ControlStructures.ForEachLoopDeclaration">
    <properties>
        <property name="requiredSpacesAfterOpen" value="1" />
        <property name="requiredSpacesBeforeClose" value="1" />
    </properties>
</rule>
```

--------------------------------

### Hard-coding Exclude Patterns for Messages

Source: https://github.com/squizlabs/php_codesniffer/wiki/Annotated-Ruleset

More specific exclusion of messages. This example hides the 'ContainsVar' error from Squiz DoubleQuoteUsage for files matching '*/tests/*' and '*/data/*'. Patterns are checked using absolute paths.

```XML
<rule ref="Squiz.Strings.DoubleQuoteUsage.ContainsVar">
    <exclude-pattern>*/tests/*</exclude-pattern>
    <exclude-pattern>*/data/*</exclude-pattern>
 </rule>
```

--------------------------------

### Ruleset XML for Custom Standard with Exclusions

Source: https://github.com/squizlabs/php_codesniffer/wiki/Version-1.3.0-Upgrade-Guide

Configures a `ruleset.xml` file to implement a custom coding standard that includes the PEAR standard but excludes the `PEAR.ControlStructures.ControlSignature` sniff. This demonstrates how to manage exclusions within the XML configuration.

```xml
<?xml version="1.0"?>
<ruleset name="My Standard">
    <description>My custom coding standard</description>
    <rule ref="PEAR">
        <exclude name="PEAR.ControlStructures.ControlSignature"/>
    </rule>
</ruleset>
```

--------------------------------

### Hard-coding Exclude Patterns for Sniffs

Source: https://github.com/squizlabs/php_codesniffer/wiki/Annotated-Ruleset

Hard-code ignore patterns for specific sniffs. Patterns are checked using absolute paths. This example excludes messages from Squiz DoubleQuoteUsage for files in '*/tests/*' and '*/data/*'.

```XML
<rule ref="Squiz.Strings.DoubleQuoteUsage">
    <exclude-pattern>*/tests/*</exclude-pattern>
    <exclude-pattern>*/data/*</exclude-pattern>
 </rule>
```

--------------------------------

### Basic Ruleset Configuration

Source: https://github.com/squizlabs/php_codesniffer/wiki/Annotated-Ruleset

Defines the name and namespace for a custom coding standard. The name is displayed with verbose output, and the namespace is used for custom sniffs.

```xml
<?xml version="1.0"?>
<ruleset name="Custom Standard" namespace="MyProject\CS\Standard">

 <!--
    The name attribute of the ruleset tag is displayed
    when running PHP_CodeSniffer with the -v command line
    argument.

    If you have custom sniffs, and they use a namespace prefix
    that is different to the name of the directory containing
    your ruleset.xml file, you can set the namespace prefix using
    the namespace attribute of the ruleset tag.

    For example, if your namespace format for sniffs is
    MyProject\CS\Standard\Sniffs\Category, set the namespace to
    MyProject\CS\Standard (everything up to \Sniffs\)
 -->

 <!--
    The content of the description tag is not displayed anywhere
    except in this file, so it can contain information for
    developers who may change this file in the future.
 -->
 <description>A custom coding standard</description>

 <!--
    You can hard-code config values used by sniffs directly
    into your custom standard. Note that this does not work
    for config values that override command line arguments,
    such as show_warnings and report_format.
    
    The following tag is equivalent to the command line argument:
    --runtime-set zend_ca_path /path/to/ZendCodeAnalyzer
 -->
 <config name="zend_ca_path" value="/path/to/ZendCodeAnalyzer"/>

<!--
    If no files or directories are specified on the command line
    your custom standard can specify what files should be checked
    instead.

    Note that file and directory paths specified in a ruleset are
    relative to the ruleset's location, and that specifying any file or
    directory path on the command line will ignore all file tags.
 -->
 <file>./path/to/directory</file>
 <file>./path/to/file.php</file>

 <!--
    You can hard-code ignore patterns directly into your
    custom standard so you don't have to specify the
    patterns on the command line.
    
    The following two tags are equivalent to the command line argument:
    --ignore=*/tests/*,*/data/*
 -->
 <exclude-pattern>*/tests/*</exclude-pattern>
 <exclude-pattern>*/data/*</exclude-pattern>

<!--
    Patterns can be specified as relative if you would
    like the relative path of the file checked instead of the
    full path. This can sometimes help with portability.
    
    The relative path is determined based on the paths you
    pass into PHP_CodeSniffer on the command line.
 -->
 <exclude-pattern type="relative">^/tests/*</exclude-pattern>
 <exclude-pattern type="relative">^/data/*</exclude-pattern>

 <!--
    You can hard-code command line values into your custom standard.
    Note that this does not work for the command line values:
    -v[v][v], -l, -d, --sniffs and --standard
    
    The following tags are equivalent to the command line arguments:
    --extensions=php,inc --report=summary --colors -sp
 -->
 <arg name="extensions" value="php,inc" />
 <arg name="report" value="summary"/>
 <arg name="colors"/>
 <arg value="sp"/>

 <!--
    You can hard-code custom php.ini settings into your custom standard.
    The following tag sets the memory limit to 64M.
 -->
 <ini name="memory_limit" value="64M"/>

 <!--
    If your helper classes need custom autoloading rules that you are
    not able to include in other ways, you can hard-code files to include
    before the ruleset is processed and any sniff classes have been loaded.
    Note that autoload file paths are relative to the ruleset's location.

    This is different to bootstrap files, which are loaded after the ruleset
    has already been processed.
 -->
 <autoload>/path/to/autoload.php</autoload>
 <autoload>/path/to/other/autoload.php</autoload>
 <autoload>./autoload.php</autoload>

 <!--
    Include all sniffs in the PEAR standard. Note that the
    path to the standard does not have to be specified as the
    PEAR standard exists inside the PHP_CodeSniffer install
    directory.
 -->
 <rule ref="PEAR"/>

 <!--
    Include all sniffs in an external standard directory. Note
    that we have to specify the full path to the standard's
    directory because it does not exist inside the PHP_CodeSniffer
    install directory.
 -->
 <rule ref="/home/username/standards/mystandard"/>

 <!--
    Include everything in another ruleset.xml file. This is
    really handy if you want to customise another developer's
    custom standard. They just need to distribute their single
    ruleset file to allow this.
 -->
 <rule ref="/home/username/standards/custom.xml"/>

 <!--
    Relative paths can also be used everywhere absolute paths are used.
    Make sure the reference starts with ./ or ../ so PHP_CodeSniffer
    knows it is a relative path.
 -->
 <rule ref="./standards/mystandard"/>
 <rule ref="../username/custom.xml"/>

 <!--

```

--------------------------------

### Print Multiple Reports to Files

Source: https://github.com/squizlabs/php_codesniffer/wiki/Reporting

Specify output file paths for each report type using --report-[type]=/path/to/file. This allows for separate storage of different report formats.

```bash
$ phpcs --report-full=/path/to/full.txt --report-summary=/path/to/summary.txt /path/to/code
```

--------------------------------

### Configure FunctionComment minimumVisibility

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Set the minimum visibility for functions that require documentation. Use 'public' to only check public functions.

```xml
<rule ref="PEAR.Commenting.FunctionComment">
    <properties>
        <property name="minimumVisibility" value="public" />
    </properties>
</rule>
```

--------------------------------

### Generate Information Report

Source: https://github.com/squizlabs/php_codesniffer/wiki/Reporting

Use this command to generate an information report for your code. This report details how your code is written based on various coding conventions.

```bash
phpcs --report=info /path/to/code
```

--------------------------------

### PHP Foreach Loop with Default Padding

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Shows the default zero-space padding for foreach loop declarations.

```php
foreach ($foo as $bar) {
    // Body.
}
```

--------------------------------

### Include Bootstrap Files

Source: https://github.com/squizlabs/php_codesniffer/wiki/Advanced-Usage

Use the --bootstrap argument to specify one or more custom files to be included before code analysis begins. These files can manipulate PHP_CodeSniffer settings.

```bash
$ phpcs --bootstrap=/path/to/boostrap.1.inc,/path/to/bootstrap.2.inc /path/to/code
```

--------------------------------

### Configure PEAR.WhiteSpace.ScopeIndent Properties

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

Customize tab width, indentation, and ignored tokens for scope indentation rules.

```XML
<arg name="tab-width" value="4"/>
...
<rule ref="PEAR.WhiteSpace.ScopeIndent">
    <properties>
        <property name="exact" value="true" />
        <property name="tabIndent" value="true" />
        <property name="ignoreIndentationTokens" type="array">
            <element value="T_COMMENT"/>
            <element value="T_DOC_COMMENT_OPEN_TAG"/>
        </property>
    </properties>
</rule>
```

--------------------------------

### Configure ForLoopDeclaration Padding in XML

Source: https://github.com/squizlabs/php_codesniffer/wiki/Customisable-Sniff-Properties

XML configuration to set one space after the open bracket and before the close bracket for for loops.

```xml
<rule ref="Squiz.ControlStructures.ForLoopDeclaration">
    <properties>
        <property name="requiredSpacesAfterOpen" value="1" />
        <property name="requiredSpacesBeforeClose" value="1" />
    </properties>
</rule>
```