PHP CodeSniffer

https://github.com/squizlabs/php_codesniffer
Admin
PHP_CodeSniffer tokenizes PHP, JavaScript and CSS files to detect violations of defined coding...
Tokens:189,861
Snippets:1,238
Trust Score:8.6
License:BSD-3-Clause
Update:1 week ago
Show doc for...
Tokens:
Raw
### Generic.Formatting.MultipleStatementAlignment: Aligned at start example

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

Shows the resulting formatting when alignAtEnd is set to false, with assignment operators aligned at the start.

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

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

### Check file with installed PEAR standard using --standard

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

Use the --standard command line argument to specify an installed coding standard. The example checks myfile.inc against the PEAR standard, which is installed by default.

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

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

### Install with PEAR

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

Installs PHP_CodeSniffer using the PEAR installer. Requires PEAR to be installed first; this makes the phpcs and phpcbf commands immediately available.

```bash
pear install PHP_CodeSniffer
```

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

### Download PHAR files with curl or wget and test

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

Downloads the phpcs.phar and phpcbf.phar files using either curl or wget, then tests them with the -h flag. Use this to get started quickly without a package manager.

```bash
# Download using curl
curl -OL https://squizlabs.github.io/PHP_CodeSniffer/phpcs.phar
curl -OL https://squizlabs.github.io/PHP_CodeSniffer/phpcbf.phar

# Or download using wget
wget https://squizlabs.github.io/PHP_CodeSniffer/phpcs.phar
wget https://squizlabs.github.io/PHP_CodeSniffer/phpcbf.phar

# Then test the downloaded PHARs
php phpcs.phar -h
php phpcbf.phar -h
```

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

### Print installed coding standards with -i

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

Use the -i command line argument to print a list of installed coding standards. The output shows the available standards, e.g., MySource, PEAR, PHPCS, PSR1, PSR2, Squiz and Zend.

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

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

### Scope map output for example file

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

Verbose tokeniser output showing the step-by-step creation of the scope map for the example file. It displays token processing and scope opener/closer detection.

```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 => \n
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 => \n
Process token 15 [opener:7;]: T_CLOSE_CURLY_BRACKET => }
=> Found scope closer for 1 (T_IF)
*** END SCOPE MAP ***
```

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

### Install globally with Composer

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

Installs PHP_CodeSniffer system-wide via Composer. Ensure the composer bin dir (default ~/.composer/vendor/bin/) is in your PATH; check with 'composer global config bin-dir --absolute'.

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

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

### Install with Phive

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

Installs PHP_CodeSniffer as a project tool using Phive. After installation, the tools are available in the tools directory.

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

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

### Generic.Formatting.SpaceAfterCast: No space example

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

Shows an alternative style with no space after the cast.

```php
$var = (int)$foo;
```

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

### Level map output for example file

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

Verbose tokeniser output showing the step-by-step creation of the level map for the example file. It displays token processing with level and condition information.

```text
*** START LEVEL MAP ***
Process token 0 on line 1 [lvl:0;]: T_OPEN_TAG => <?php\n
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 => \n
    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 => \n
    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 => \n
Process token 17 on line 5 [lvl:0;]: T_CLOSE_TAG => ?>
*** END LEVEL MAP ***
```

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

### Sniff path to internal code conversion examples

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

Examples showing how to convert sniff file paths to the internal codes used in ruleset.xml. Drop the 'Sniffs' directory, convert slashes to periods, and remove 'Sniff.php' from the end.

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

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

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

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

### Generic.Formatting.SpaceAfterCast: Default spacing example

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

Shows the default spacing of one space after a type cast.

```php
$var = (int) $foo;
```

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

### Default concatenation spacing example

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

Shows the default zero-space padding around the concatenation operator enforced by Squiz.Strings.ConcatenationSpacing.

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

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

### Run PHP_CodeSniffer from tools directory

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

Runs the phpcs and phpcbf commands from the tools directory after installing with Phive. Use the -h flag to display help.

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

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

### Single-space concatenation example

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

Shows a common alternative with a single space around the concatenation operator, which can be configured via the 'spacing' property.

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

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

### Generic.Formatting.MultipleStatementAlignment: Default alignment example

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

Shows the default alignment enforced by the sniff, where assignment operators are aligned at the end, aligning the assigned values.

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

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

### Create MyStandard directory structure

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

Run these commands to create the coding standard directory structure. The first two commands create the standard outside the main PHP_CodeSniffer directory, so it won't appear with the -i flag. The second set creates it inside the PHP_CodeSniffer install to make it show as installed.

```bash
$ mkdir MyStandard
$ mkdir MyStandard/Sniffs
```

```bash
$ cd /path/to/PHP_CodeSniffer/src/Standards
$ mkdir MyStandard
$ mkdir MyStandard/Sniffs
```

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

### Example of a function comment with only {@inheritdoc}

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

Shows a docblock containing only {@inheritdoc} that the sniff will skip when skipIfInheritdoc is true.

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

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

### Run PHP_CodeSniffer from vendor bin

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

Runs the phpcs and phpcbf commands from the vendor bin directory after installing via Composer. Use the -h flag to display help.

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

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

### Example PHP file for scope map

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

A simple PHP file with an if statement, used to illustrate the scope map output.

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

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

### Generic.Formatting.MultipleStatementAlignment: Set alignAtEnd to false

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

Configures the sniff to align the start of assignment tokens instead of the end by setting alignAtEnd to false.

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

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

### PEAR.Commenting.FunctionComment specialMethods property

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

Specifies methods that do not require a @return tag in their docblock. Default is __construct and __destruct; this example adds 'ignoreThisFunction'.

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

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

### Sample CodingStandard.php getIncludedSniffs() method

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

Example of a CodingStandard.php class method that includes sniffs from other standards. This is the old approach that is replaced by ruleset.xml in version 1.3.0.

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

}//end getIncludedSniffs()
```

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

### PEAR.Formatting.MultiLineAssignment indent property

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

Sets the indentation size for assignments split over multiple lines. Default is 4 spaces; this example sets it to 2.

```xml
<rule ref="PEAR.Formatting.MultiLineAssignment">
    <properties>
        <property name="indent" value="2" />
    </properties>
</rule>
```

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

### PHP example of single-space padding inside parentheses

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

Alternative padding style with a single space inside parenthesis.

```php
$foo = ( $bar !== 'bar' );
```

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

### Reference sniff class by path

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

References sniffs not installed by using an absolute or relative path to the sniff class file instead of the sniff code.

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

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

### Verbose token processing output example

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

Sample output from PHP_CodeSniffer when running with -vvv. Shows each token processed, its ID, type, contents, and the sniffs executed on it with running times.

```text
*** START TOKEN PROCESSING ***
Process token 0: T_OPEN_TAG => <?php\n
    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 => \n
    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 => \n
    Processing Generic_Sniffs_WhiteSpace_DisallowTabIndentSniff... DONE in 0 seconds
Process token 15: T_CLOSE_CURLY_BRACKET => }
Process token 16: T_WHITESPACE => \n
    Processing Generic_Sniffs_WhiteSpace_DisallowTabIndentSniff... DONE in 0 seconds
Process token 17: T_CLOSE_TAG => ?>\n
*** END TOKEN PROCESSING ***
```

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

### PHP example of zero spacing inside parentheses

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

Default behavior of Generic.WhiteSpace.ArbitraryParenthesesSpacing: zero spaces inside parenthesis.

```php
$foo = ($bar !== 'bar');
```

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

### Check file with multiple standards using comma-separated --standard

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

Pass a comma-separated list of standards to check multiple coding standards at once. A mix of external and installed standards is allowed.

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

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

### Generic.Files.LineLength: Disable errors with absoluteLineLimit=0

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

Sets absoluteLineLimit to 0 to disable errors, so only warnings are generated for lines exceeding the lineLimit. This example warns for lines longer than 135 characters and never errors.

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

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

### Run PHP_CodeSniffer interactively with -a and example output

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

Use the -a argument to run PHP_CodeSniffer interactively, showing a report for the first file with errors or warnings and pausing for input. The example output shows the full error report and the prompt to recheck, skip, or quit. Note: interactive mode always prints the full error report and ignores any report types specified on the command line.

```bash
$ phpcs -a /path/to/code
```

```text
    FILE: /path/to/code/classA.php
    --------------------------------------------------------------------------------
    FOUND 4 ERRORS AND 1 WARNING AFFECTING 5 LINES
    --------------------------------------------------------------------------------
      2 | ERROR   | [ ] Missing file doc comment
      4 | ERROR   | [x] TRUE, FALSE and NULL must be lowercase; expected "false"
        |         |     but found "FALSE"
      6 | ERROR   | [x] Line indented incorrectly; expected at least 4 spaces,
        |         |     found 1
      9 | ERROR   | [ ] Missing function doc comment
     11 | WARNING | [x] Inline control structures are discouraged
    --------------------------------------------------------------------------------
    PHPCBF CAN FIX THE 3 MARKED SNIFF VIOLATIONS AUTOMATICALLY
    --------------------------------------------------------------------------------
    
    <ENTER> to recheck, [s] to skip or [q] to quit :
```

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

### New process() definition with File

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

Rewrite the process() declaration to use the new File class.

```php
public function process(File $phpcsFile, $stackPtr) {}
```

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

### Set specialMethods property for Squiz.Commenting.FunctionComment

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

Specifies methods that do not require a @return tag in their docblocks. Defaults to __construct and __destruct; this example adds 'ignoreThisFunction'.

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

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

### Minimal ruleset.xml content

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

The content of the ruleset.xml file. This minimal example defines the standard's name and description. The ruleset.xml can be left quite small; see the Annotated ruleset for other features.

```xml
<?xml version="1.0"?>
<ruleset name="MyStandard">
  <description>A custom coding standard.</description>
</ruleset>
```

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

### View configuration options with --config-show

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

Use the --config-show command line argument to view the currently set configuration options. The output is an array showing option names and values.

```bash
$ phpcs --config-show
Array
(
    [default_standard] => PEAR
    [zend_ca_path] => /path/to/ZendCodeAnalyzer
)
```

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

### Set lineLimit property for Squiz.Commenting.LongConditionClosingComment

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

Configures the minimum number of lines a code block must span before requiring a closing comment. Default is 20; this example sets it to 40.

```xml
<rule ref="Squiz.Commenting.LongConditionClosingComment">
    <properties>
        <property name="lineLimit" value="40" />
    </properties>
</rule>
```

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

### PHP function with no spaces around equals signs

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

Example of a function declaration with zero spaces around the equals signs, as enforced by default by the Squiz.Functions.FunctionDeclarationArgumentSpacing sniff.

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

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

### Create ruleset.xml file

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

Creates an empty ruleset.xml file in the top-level directory of your custom coding standard. The file name must be exactly 'ruleset.xml'.

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

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

### Set indent property for Squiz.Classes.ClassDeclaration

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

Configures the indentation size for class names split over multiple lines. The default is 4 spaces; this example sets it to 2.

```xml
<rule ref="Squiz.Classes.ClassDeclaration">
    <properties>
        <property name="indent" value="2" />
    </properties>
</rule>
```

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

### Selective rules with phpcs-only and phpcbf-only attributes

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

Demonstrates how to apply rules selectively for phpcs or phpcbf. The example is for documentation purposes only and not a working standard. It shows config, exclude-pattern, rule exclusion, severity, and property settings with tool-specific attributes.

```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>
```

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

### PHP function with no spaces inside argument list brackets

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

Example of a function declaration with zero spaces after the opening bracket and before the closing bracket, as enforced by default by the Squiz.Functions.FunctionDeclarationArgumentSpacing sniff.

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

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

### ruleset.xml equivalent for PEAR standard with ControlSignature exclusion

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

XML ruleset that replicates the PHP class example above for version 1.3.0. The rule ref="PEAR" includes the whole standard, and the nested exclude element uses the internal sniff code PEAR.ControlStructures.ControlSignature instead of a file path. Exclusions are grouped with the standard they apply to.

```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>

```

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

### Configure Squiz.WhiteSpace.FunctionSpacing spacing properties

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

Sets the required blank lines before and after function declarations. The spacing property applies generally, while spacingBeforeFirst and spacingAfterLast override it for functions at the start or end of a statement group or control structure. If the latter are not set, they inherit the spacing value.

```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>
```

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

### Add installed standard paths with phpcs --config-set installed_paths

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

Adds one or more paths (comma-separated) where PHP_CodeSniffer looks for installed coding standards. Relative paths must begin with './' and are resolved relative to the top-level install directory.

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

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

### ruleset.xml equivalent for including sniffs

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

Ruleset.xml that replicates the includes from the sample CodingStandard.php. It uses the 'rule' tag and references sniffs by their internal code instead of file paths.

```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>
```

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

### SpaceAfterNot: multiline ! operator

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

Example of breaking a complex statement over multiple lines after `!`.

```php
if (!
    ($foo || $bar)
) {
}
```

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

### NestingLevel: configure nestingLevel and absoluteNestingLevel

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

XML configuration for Generic.Metrics.NestingLevel to set warning and error thresholds.

```xml
<rule ref="Generic.Metrics.NestingLevel">
    <properties>
        <property name="nestingLevel" value="8" />
        <property name="absoluteNestingLevel" value="12" />
    </properties>
</rule>
```

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

### Run phpcs with absolute path to standard

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

Command to run PHP_CodeSniffer using the custom standard by passing the absolute path to the standard directory. This is required when the standard is not installed inside the main PHP_CodeSniffer directory structure.

```bash
$ phpcs --standard=/path/to/MyStandard test.php
```

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

### Create ruleset.xml file

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

Run this command to create the ruleset.xml file inside the MyStandard directory. This file identifies the directory as a coding standard and allows PHP_CodeSniffer to query it.

```bash
$ cd MyStandard
$ touch ruleset.xml
```

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

### Clone repository and run from Git clone

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

Clones the PHP_CodeSniffer repository and runs the phpcs and phpcbf commands directly from the bin directory. Use the -h flag to display help.

```bash
git clone https://github.com/squizlabs/PHP_CodeSniffer.git
cd PHP_CodeSniffer
php bin/phpcs -h
php bin/phpcbf -h
```

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

### Check a directory against PEAR standard

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

Run phpcs on an entire directory to check all files against the default PEAR coding standard.

```bash
phpcs /path/to/code-directory
```

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

### Complete annotated ruleset.xml sample

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

A documentation-only sample showing the full range of ruleset.xml features: name and namespace attributes, description, config values, file and exclude-pattern tags, arg and ini settings, autoload files, and including the PEAR standard. Note that config values cannot override command line arguments like show_warnings and report_format, and file paths are relative to the ruleset's location.

```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"/>
</ruleset>
```

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

### Set skipIfInheritdoc property for Squiz.Commenting.FunctionComment

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

When true, the sniff skips checking function comments that contain only {@inheritdoc}. This example enables that behavior.

```xml
<rule ref="Squiz.Commenting.FunctionComment">
    <properties>
        <property name="skipIfInheritdoc" value="true" />
    </properties>
</rule>
```

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

### Generic.Formatting.SpaceAfterCast: Set spacing to 0

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

Configures the sniff to allow no space after a cast by setting spacing to 0.

```xml
<rule ref="Generic.Formatting.SpaceAfterCast">
    <properties>
        <property name="spacing" value="0" />
    </properties>
</rule>
```

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

### Old process() definition with PHP_CodeSniffer_File

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

The old definition used PHP_CodeSniffer_File as the type hint.

```php
public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr) {}
```

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

### Check a file against PEAR standard

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

Run phpcs on a single file to check it against the default PEAR coding standard.

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

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

### Set configuration option with --config-set

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

Use the --config-set command line argument to set a configuration option. The option and value are written to a global configuration file.

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

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

### Generic.Files.LineLength: Set lineLimit and absoluteLineLimit

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

Configures the line length thresholds for the Generic.Files.LineLength sniff. The lineLimit property sets the warning threshold, and absoluteLineLimit sets the error threshold. The lineLimit value should be 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>
```

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

### PEAR.ControlStructures.MultiLineCondition indent property

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

Sets the indentation size for conditions split over multiple lines. Default is 4 spaces; this example sets it to 2.

```xml
<rule ref="PEAR.ControlStructures.MultiLineCondition">
    <properties>
        <property name="indent" value="2" />
    </properties>
</rule>
```

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

### Show progress by default

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

Sets the show_progress configuration option to 1, enabling progress output by default. This option cannot be set with --runtime-set; use -p for a single run.

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

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

### Add Composer dependency in composer.json

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

Adds squizlabs/php_codesniffer as a require-dev dependency in composer.json. After running composer install, you can run the tools from the vendor bin directory.

```json
{
    "require-dev": {
        "squizlabs/php_codesniffer": "3.*"
    }
}
```

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

### Extending AbstractScopeSniff with new namespace

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

Update your class definition to use the new namespaces when extending AbstractScopeSniff.

```php
namespace StandardName\Sniffs\Category;

use PHP_CodeSniffer\Sniffs\AbstractScopeSniff;
use PHP_CodeSniffer\Files\File;

class TestSniff extends AbstractScopeSniff {}
```

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

### CyclomaticComplexity: configure complexity and absoluteComplexity

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

XML configuration for Generic.Metrics.CyclomaticComplexity to set warning and error thresholds.

```xml
<rule ref="Generic.Metrics.CyclomaticComplexity">
    <properties>
        <property name="complexity" value="15" />
        <property name="absoluteComplexity" value="30" />
    </properties>
</rule>
```

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

### Extending AbstractVariableSniff with new namespace

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

Update your class definition to use the new namespaces when extending AbstractVariableSniff.

```php
namespace StandardName\Sniffs\Category;

use PHP_CodeSniffer\Sniffs\AbstractVariableSniff;
use PHP_CodeSniffer\Files\File;

class TestSniff extends AbstractVariableSniff {}
```

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

### Check .php, .inc, and .lib files with --extensions=php,inc,lib

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

Use the --extensions argument with a comma-separated list to check multiple file extensions, such as .php, .inc, and .lib.

```bash
$ phpcs --extensions=php,inc,lib /path/to/code
```

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

### Multi-line function call with multiple arguments per line (default)

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

Shows the default formatting for multi-line function calls where multiple arguments can appear on each line.

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

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

### Default control structure padding for PSR2.ControlStructures.ControlStructureSpacing

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

Shows the default padding style with zero spaces after the opening bracket and zero spaces before the closing bracket.

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

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

### Old report class definition

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

The pre-3.0 report class definition, which was not namespaced and implemented the old PHP_CodeSniffer_Report interface.

```php
class PHP_CodeSniffer_Reports_ReportName implements PHP_CodeSniffer_Report {}
```

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

### Configure requiredSpacesAfterOpen and requiredSpacesBeforeClose

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

XML rule configuration for PEAR.Functions.FunctionCallSignature to set the required spaces after the opening bracket and before the closing bracket to 1.

```xml
<rule ref="PEAR.Functions.FunctionCallSignature">
    <properties>
        <property name="requiredSpacesAfterOpen" value="1" />
        <property name="requiredSpacesBeforeClose" value="1" />
    </properties>
</rule>
```

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

### Using Common class for utility functions

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

Add a use statement for PHP_CodeSniffer\Util\Common and change references from PHP_CodeSniffer:: to Common::.

```php
namespace StandardName\Sniffs\Category;

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

class TestSniff implements Sniff {}
```

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

### Using Tokens class for comment tokens

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

Add a use statement for PHP_CodeSniffer\Util\Tokens and change references from PHP_CodeSniffer_Tokens:: to Tokens::.

```php
namespace StandardName\Sniffs\Category;

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

class TestSniff implements Sniff
{

    public function register()
    {
        return Tokens::$commentTokens;
    }

    public function process(File $phpcsFile, $stackPtr) {}

}
```

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

### Print multiple reports to screen with --report-full and --report-summary

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

Use multiple --report-[type] arguments to print several reports to the screen in the order specified. This command writes both a full and summary report for the given code path.

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

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

### Required empty processTokenOutsideScope method

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

If you did not previously define processTokenOutsideScope(), you must now add this empty method because it has been marked abstract.

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

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

### Set Google Closure Linter path with gjslint_path

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

Configures the Generic standard's ClosureLinter sniff to locate the Google Closure Linter tool. Run this command before using the sniff.

```bash
$ phpcs --config-set gjslint_path /path/to/gjslint
```

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

### Old method signatures for generateFileReport() and generate()

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

The pre-3.0 signatures for the report methods, using PHP_CodeSniffer_File and without the $interactive parameter.

```php
public function generateFileReport(
    $report,
    PHP_CodeSniffer_File $phpcsFile,
    $showSources=false,
    $width=80
) {
    ...
}

public function generate(
    $cachedData,
    $totalFiles,
    $totalErrors,
    $totalWarnings,
    $totalFixable,
    $showSources=false,
    $width=80,
    $toScreen=true
) {
    ...
}
```

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

### PHP function with single spaces around equals signs

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

Example of a function declaration with a single space around the equals signs, which can be enforced by setting the 'equalsSpacing' property to 1.

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

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

### Configure Squiz.WhiteSpace.MemberVarSpacing spacing properties

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

Sets the required blank lines between member variables and before the first member variable. The spacing property controls the gap between member vars, while spacingBeforeFirst controls the gap before the first one.

```xml
<!--
 Ensure 2 blank lines between member vars,
 but don't require blank lines before the first.
-->
<rule ref="Squiz.WhiteSpace.MemberVarSpacing">
    <properties>
        <property name="spacing" value="2" />
        <property name="spacingBeforeFirst" value="0" />
    </properties>
</rule>
```

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

### Set commentFormat property for Squiz.Commenting.LongConditionClosingComment

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

Changes the format of the closing comment. Default is '//end %s'; this example makes it '// end %s()' to produce comments like '// end foreach()'.

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

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

### Configure Generic.PHP.ForbiddenFunctions forbiddenFunctions array

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

Define an array of forbidden functions with suggested alternatives. Use null as the value when no alternative exists.

```xml
<rule ref="Generic.PHP.ForbiddenFunctions">
    <properties>
        <property name="forbiddenFunctions" type="array">
            <element key="print" value="echo"/>
            <element key="create_function" value="null"/>
        </property>
     </properties>
</rule>
```

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

### Run phpcs with progress output (-p)

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

Use the -p flag to display a single-character status for each file being checked. Status characters: '.' for no errors/warnings, 'E' for errors, 'W' for warnings only, 'S' for skipped files. The output shows progress lines with file counts.

```bash
$ phpcs /path/to/code/CodeSniffer -p
......................S.....................................  60 / 572
..........EEEE.E.E.E.E.E.E.E.E..W..EEE.E.E.E.EE.E.E.E.E.E.E. 120 / 572
E.E.E.E.E.WWWW.E.W..EEE.E.................E.E.E.E...E....... 180 / 572
E.E.E.E.....................E.E.E.E.E.E.E.E.E.E.W.E.E.E.E.E. 240 / 572
E.W......................................................... 300 / 572
..........................................E.E.E.E...E.E.E.E. 360 / 572
E.E.E.E.E.E..E.E.E..E..E..E.E.WW.E.E.EE.E.E................. 420 / 572
...................E.E.EE.E.E.E.S.E.EEEE.E...E...EE.E.E..EEE 480 / 572
.E.EE.E.E..E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E..E 540 / 572
.E.E....E.E.E...E.....E.E.ES....
```

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

### ForLoopDeclaration: Default padding (zero spaces)

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

Shows the default for structure with zero spaces after the opening bracket and before the closing bracket, as enforced by the Squiz.ControlStructures.ForLoopDeclaration sniff.

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

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

### Configure indent for ScopeClosingBrace

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

XML rule configuration for PEAR.WhiteSpace.ScopeClosingBrace to change the indent size for case terminating statements to 2 spaces.

```xml
<rule ref="PEAR.WhiteSpace.ScopeClosingBrace">
    <properties>
        <property name="indent" value="2" />
    </properties>
</rule>
```

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

### SpaceAfterNot: configure spacing property

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

XML configuration for Generic.Formatting.SpaceAfterNot to set `spacing` to `0`.

```xml
<rule ref="Generic.Formatting.SpaceAfterNot">
    <properties>
        <property name="spacing" value="0" />
    </properties>
</rule>
```

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

### New namespaced report class definition

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

The updated report class definition for PHP_CodeSniffer 3.0, using a namespace and the new Report interface.

```php
namespace StandardName\Reports;

use PHP_CodeSniffer\Files\File;

class ReportName implements Report {}
```

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

### PHP function with single spaces inside argument list brackets

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

Example of a function declaration with a single space after the opening bracket and before the closing bracket, which can be enforced by setting 'requiredSpacesAfterOpen' and 'requiredSpacesBeforeClose' to 1.

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

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

### Set configuration option for single run with --runtime-set

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

Use the --runtime-set command line argument to set a configuration option for a single run only. Not all options support this; options that provide defaults for command line arguments cannot be used with --runtime-set.

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

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

### Set different severities for errors and warnings

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

Shows all errors but only warnings with severity 8 or more. Setting warning severity to 0 is equivalent to -n; setting error severity to 0 hides all errors.

```bash
$ phpcs --error-severity=1 --warning-severity=8 /path/to/code
```

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

### Configure Generic.WhiteSpace.ArbitraryParenthesesSpacing spacing property

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

Set spacing to 1 to allow a single space inside parenthesis.

```xml
<rule ref="Generic.WhiteSpace.ArbitraryParenthesesSpacing">
    <properties>
        <property name="spacing" value="1" />
    </properties>
</rule>
```
Tokens:
Raw