PHP CodeSniffer

https://github.com/phpcsstandards/php_codesniffer
Admin
PHP CodeSniffer is a set of PHP scripts that tokenizes PHP files to detect violations of defined...
Tokens:211,553
Snippets:1,426
Trust Score:8.5
License:BSD-3-Clause
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Install PHP_CodeSniffer with Phive

Source: https://github.com/phpcsstandards/php_codesniffer/blob/4.x/README.md

Installs phpcs and phpcbf as project tools using Phive, trusting the official GPG key. After installation, run them from the tools directory.

```bash
phive install --trust-gpg-keys 5CB4F778BF9BC4FB67AE511D96E91A992CF22FF4 phpcs
phive install --trust-gpg-keys 5CB4F778BF9BC4FB67AE511D96E91A992CF22FF4 phpcbf
```

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

### Scope map output for the example PHP file

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

This is the verbose tokenizer output showing the step-by-step creation of the scope map for the example PHP file. It displays the processing of each token, including the scope opener and closer for the if statement.

```text
    *** START SCOPE MAP ***
    Start scope map at 2:T_IF => if
    => Begin scope map recursion at token 2 with depth 1
    Process token 3 on line 2 []: T_WHITESPACE =>
    Process token 4 on line 2 []: T_OPEN_PARENTHESIS => (
    Process token 5 on line 2 []: T_VARIABLE => $condition
    Process token 6 on line 2 []: T_CLOSE_PARENTHESIS => )
    Process token 7 on line 2 []: T_WHITESPACE =>
    Process token 8 on line 2 []: T_OPEN_CURLY_BRACKET => {
    => Found scope opener for 2:T_IF
    Process token 9 on line 2 [opener:8;]: T_WHITESPACE => \n
    Process token 10 on line 3 [opener:8;]: T_WHITESPACE =>
    Process token 11 on line 3 [opener:8;]: T_ECHO => echo
    Process token 12 on line 3 [opener:8;]: T_WHITESPACE =>
    Process token 13 on line 3 [opener:8;]: T_CONSTANT_ENCAPSED_STRING => 'Condition was true'
    Process token 14 on line 3 [opener:8;]: T_SEMICOLON => ;
    Process token 15 on line 3 [opener:8;]: T_WHITESPACE => \n
    Process token 16 on line 4 [opener:8;]: T_CLOSE_CURLY_BRACKET => }
    => Found scope closer (16:T_CLOSE_CURLY_BRACKET) for 2:T_IF
    *** END SCOPE MAP ***
```

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

### Example JUnit XML report output

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

Example output from the --report=junit command. Shows the XML structure with testsuites and testcase elements, including failure details.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<testsuites name="PHP_CodeSniffer 4.0.4" errors="0" tests="7" failures="6">
<testsuite name="path/to/code/fileA.php" errors="0" tests="6" failures="6">
 <testcase name="PSR12.Files.FileHeader.SpacingAfterTagBlock at path/to/code/fileA.php (1:1)">
  <failure type="error" message="Header blocks must be separated by a single blank line"/>
 </testcase>
 <testcase name="Squiz.Functions.FunctionDeclarationArgumentSpacing.SpacingAfterOpen at path/to/code/fileA.php (10:24)">
  <failure type="error" message="Expected 0 spaces after opening parenthesis; 1 found"/>
 </testcase>
 <testcase name="Generic.PHP.LowerCaseType.ParamTypeFound at path/to/code/fileA.php (10:26)">
  <failure type="error" message="PHP parameter type declarations must be lowercase; expected &quot;string&quot; but found &quot;String&quot;"/>
 </testcase>
 <testcase name="Squiz.Functions.FunctionDeclarationArgumentSpacing.SpacingAfterHint at path/to/code/fileA.php (10:26)">
  <failure type="error" message="Expected 1 space between type hint and argument &quot;$param&quot;; 2 found"/>
 </testcase>
 <testcase name="Generic.WhiteSpace.ScopeIndent.Incorrect at path/to/code/fileA.php (13:5)">
  <failure type="error" message="Line indented incorrectly; expected at least 8 spaces, found 4"/>
 </testcase>
 <testcase name="Generic.PHP.LowerCaseConstant.Found at path/to/code/fileA.php (13:12)">
  <failure type="error" message="TRUE, FALSE and NULL must be lowercase; expected &quot;false&quot; but found &quot;FALSE&quot;"/>
 </testcase>
</testsuite>
<testsuite name="path/to/code/fileC.php" errors="0" tests="1" failures="0">
 <testcase name="path/to/code/fileC.php"/>
</testsuite>
</testsuites>
```

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

### Example directory structure for MyCompanyStandard

Source: https://github.com/phpcsstandards/php_codesniffer/wiki/About-Standards-for-PHP_CodeSniffer

After creating the ruleset.xml file, the directory structure for a standard named 'MyCompanyStandard' should look like this.

```text
- MyCompanyStandard (directory)
  - ruleset.xml (file)
```

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

### Print installed coding standards using -i

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

Use the -i command line argument to print a list of installed coding standards. The output shows the standards available for use with --standard.

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

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

### Example of aligned assignment operators with alignAtEnd=false

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

Shows the resulting alignment when alignAtEnd is set to false, aligning the start of assignment operators.

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

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

### Example PHP file for scope map debugging

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

This PHP file is used as an example to illustrate the scope map output. It contains a simple if statement with an echo inside curly braces.

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

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

### XML report output example

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

Example XML output from the --report=xml command, showing the structure with file and error elements, including attributes like source, severity, and fixable.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<phpcs version="4.0.4">
<file name="path/to/code/fileA.php" errors="6" warnings="0" fixable="6">
    <error line="1" column="1" source="PSR12.Files.FileHeader.SpacingAfterTagBlock" severity="5" fixable="1">Header blocks must be separated by a single blank line</error>
    <error line="10" column="24" source="Squiz.Functions.FunctionDeclarationArgumentSpacing.SpacingAfterOpen" severity="5" fixable="1">Expected 0 spaces after opening parenthesis; 1 found</error>
    <error line="10" column="26" source="Generic.PHP.LowerCaseType.ParamTypeFound" severity="5" fixable="1">PHP parameter type declarations must be lowercase; expected &quot;string&quot; but found &quot;String&quot;</error>
    <error line="10" column="26" source="Squiz.Functions.FunctionDeclarationArgumentSpacing.SpacingAfterHint" severity="5" fixable="1">Expected 1 space between type hint and argument &quot;$param&quot;; 2 found</error>
    <error line="13" column="5" source="Generic.WhiteSpace.ScopeIndent.Incorrect" severity="5" fixable="1">Line indented incorrectly; expected at least 8 spaces, found 4</error>
    <error line="13" column="12" source="Generic.PHP.LowerCaseConstant.Found" severity="5" fixable="1">TRUE, FALSE and NULL must be lowercase; expected &quot;false&quot; but found &quot;FALSE&quot;</error>
</file>
</phpcs>
```

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

### Check a file against the PSR12 standard using --standard

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

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

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

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

### Install PHP_CodeSniffer globally with Composer

Source: https://github.com/phpcsstandards/php_codesniffer/blob/4.x/README.md

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

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

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

### JSON report output example

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

Example JSON output produced by the --report=json argument. It includes totals for errors, warnings, and fixable issues, plus per-file message details with source, severity, and location.

```json
{
  "totals": {
    "errors": 6,
    "warnings": 0,
    "fixable": 6
  },
  "files": {
    "\/path\/to\/code\/fileA.php": {
      "errors": 6,
      "warnings": 0,
      "messages": [
        {
          "message": "Header blocks must be separated by a single blank line",
          "source": "PSR12.Files.FileHeader.SpacingAfterTagBlock",
          "severity": 5,
          "fixable": true,
          "type": "ERROR",
          "line": 1,
          "column": 1
        },
        {
          "message": "Expected 0 spaces after opening parenthesis; 1 found",
          "source": "Squiz.Functions.FunctionDeclarationArgumentSpacing.SpacingAfterOpen",
          "severity": 5,
          "fixable": true,
          "type": "ERROR",
          "line": 10,
          "column": 24
        },
        {
          "message": "PHP parameter type declarations must be lowercase; expected \"string\" but found \"String\"",
          "source": "Generic.PHP.LowerCaseType.ParamTypeFound",
          "severity": 5,
          "fixable": true,
          "type": "ERROR",
          "line": 10,
          "column": 26
        },
        {
          "message": "Expected 1 space between type hint and argument \"$param\"; 2 found",
          "source": "Squiz.Functions.FunctionDeclarationArgumentSpacing.SpacingAfterHint",
          "severity": 5,
          "fixable": true,
          "type": "ERROR",
          "line": 10,
          "column": 26
        },
        {
          "message": "Line indented incorrectly; expected at least 8 spaces, found 4",
          "source": "Generic.WhiteSpace.ScopeIndent.Incorrect",
          "severity": 5,
          "fixable": true,
          "type": "ERROR",
          "line": 13,
          "column": 5
        },
        {
          "message": "TRUE, FALSE and NULL must be lowercase; expected \"false\" but found \"FALSE\"",
          "source": "Generic.PHP.LowerCaseConstant.Found",
          "severity": 5,
          "fixable": true,
          "type": "ERROR",
          "line": 13,
          "column": 12
        }
      ]
    },
    "\/path\/to\/code\/fileC.php": {
      "errors": 0,
      "warnings": 0,
      "messages": []
    }
  }
}
```

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

### Example diff report output

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

Sample output from the --report=diff command showing suggested changes for fileB.php, such as converting NAMESPACE to lowercase and replacing else if with elseif.

```diff
--- path/to/code/fileB.php
+++ PHP_CodeSniffer
@@ -1,7 +1,7 @@
 <?php

-NAMESPACE Foo;
+namespace Foo;

 if ($foo) {
-} else if ($bar) {
+} elseif ($bar) {
 }

```

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

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

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

Specify multiple file extensions by separating them with commas. This example checks .php, .inc, and .lib files.

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

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

### Single-space control structure padding example

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

Shows an alternative padding style with a single space inside brackets, which can be configured via requiredSpacesAfterOpen and requiredSpacesBeforeClose.

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

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

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

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

Shows the default expected spacing of one space after a type cast for the Generic.Formatting.SpaceAfterCast sniff.

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

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

### Generic.Formatting.SpaceAfterCast: no-space casting example

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

Shows an alternative style with no space after the cast, which can be enforced by setting the 'spacing' property to 0.

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

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

### Squiz.Strings.ConcatenationSpacing default spacing example

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

Shows the default zero-space padding around the concatenation operator enforced by the sniff.

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

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

### Generic.Formatting.SpaceAfterNot: default spacing example

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

Shows the default expected spacing of one space after the '!' operator for the Generic.Formatting.SpaceAfterNot sniff.

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

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

### Default control structure spacing example

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

Shows the default padding (zero spaces) inside bracketed statements enforced by PSR2.ControlStructures.ControlStructureSpacing.

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

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

### Generic.Formatting.SpaceAfterNot: no-space operator example

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

Shows an alternative style with no space after the '!' operator, which can be enforced by setting the 'spacing' property to 0.

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

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

### Register MyStandard as an installed standard

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

Use the phpcs --config-set installed_paths command to register the MyStandard directory as an external standard so it appears in the -i list.

```bash
$ phpcs --config-set installed_paths /path/to/MyStandard
```

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

### CSV report output example

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

Example CSV output produced by the --report=csv command. The first row defines the column order: File, Line, Column, Type, Message, Source, Severity, Fixable. Each subsequent row contains the details of a single issue found in the scanned code.

```csv
File,Line,Column,Type,Message,Source,Severity,Fixable
"path/to/code/fileA.php",1,1,error,"Header blocks must be separated by a single blank line",PSR12.Files.FileHeader.SpacingAfterTagBlock,5,1
"path/to/code/fileA.php",10,24,error,"Expected 0 spaces after opening parenthesis; 1 found",Squiz.Functions.FunctionDeclarationArgumentSpacing.SpacingAfterOpen,5,1
"path/to/code/fileA.php",10,26,error,"PHP parameter type declarations must be lowercase; expected \"string\" but found \"String\"",Generic.PHP.LowerCaseType.ParamTypeFound,5,1
"path/to/code/fileA.php",10,26,error,"Expected 1 space between type hint and argument \"$param\"; 2 found",Squiz.Functions.FunctionDeclarationArgumentSpacing.SpacingAfterHint,5,1
"path/to/code/fileA.php",12,136,warning,"Line exceeds 120 characters; contains 136 characters",Generic.Files.LineLength.TooLong,5,0
"path/to/code/fileA.php",13,5,error,"Line indented incorrectly; expected at least 8 spaces, found 4",Generic.WhiteSpace.ScopeIndent.Incorrect,5,1
"path/to/code/fileA.php",13,12,error,"TRUE, FALSE and NULL must be lowercase; expected \"false\" but found \"FALSE\"",Generic.PHP.LowerCaseConstant.Found,5,1
```

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

### Run PHP_CodeSniffer from vendor bin directory

Source: https://github.com/phpcsstandards/php_codesniffer/blob/4.x/README.md

Runs the phpcs and phpcbf commands from the vendor bin directory after a Composer installation.

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

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

### Squiz.Strings.ConcatenationSpacing single-space example

Source: https://github.com/phpcsstandards/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;
```

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

### Ruleset with Generic.WhiteSpace.DisallowTabIndent sniff

Source: https://github.com/phpcsstandards/php_codesniffer/wiki/About-Standards-for-PHP_CodeSniffer

Add rules to your standard by referencing sniffs. This example enforces space indentation by including the 'Generic.WhiteSpace.DisallowTabIndent' sniff. Replace 'YourStandardName' with your actual standard name.

```xml
<?xml version="1.0"?>
<ruleset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" name="YourStandardName" xsi:noNamespaceSchemaLocation="https://schema.phpcodesniffer.com/phpcs.xsd">

    <rule ref="Generic.WhiteSpace.DisallowTabIndent"/>

</ruleset>
```

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

### Run PHP_CodeSniffer from Phive tools directory

Source: https://github.com/phpcsstandards/php_codesniffer/blob/4.x/README.md

Runs the phpcs and phpcbf commands from the tools directory after a Phive installation.

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

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

### Example of aligned assignment operators in PHP

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

Shows the default alignment style enforced by Generic.Formatting.MultipleStatementAlignment, where the end of assignment operators are aligned.

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

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

### PHP example of zero spacing inside arbitrary parentheses

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

Default style with no spaces inside parentheses for non-function, non-control-structure expressions.

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

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

### Check a file against multiple standards using comma-separated --standard

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

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

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

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

### Generic.Formatting.SpaceAfterNot: multiline condition example

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

Shows a complex condition broken over multiple lines with the '!' operator followed by a newline, which is disallowed by default.

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

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

### goto tokenization changes example

Source: https://github.com/phpcsstandards/php_codesniffer/wiki/Version-4.0-Developer-Upgrade-Guide

Illustrates the new tokenization for goto statements: labels and colons are separate tokens (T_GOTO_LABEL and T_GOTO_COLON), and PHP keywords used as labels are tokenized as T_STRING. The comments show the token sequences before and after the change.

```php
goto bar; // T_GOTO T_WHITESPACE T_STRING.
echo 'hi';

bar: // T_GOTO_LABEL T_GOTO_COLON (was one token, T_GOTO_LABEL, with the colon included in the content).
haveSomeWater();

goto true; // T_GOTO T_WHITESPACE T_STRING (was T_GOTO T_WHITESPACE T_TRUE).
echo 'hi';

true: // T_GOTO_LABEL T_GOTO_COLON (was one token, T_GOTO_LABEL, with the colon included in the content).
doSomething();
```

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

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

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

Alternative style using a single space inside parentheses, which can be enabled by setting the spacing property to 1.

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

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

### Multi-line object chain with balanced indentation

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

Shows an example of multi-line object chain indentation that increases and decreases by one level to show balanced method calls, which is allowed when the multilevel property is set to true.

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

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

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

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

Use the `--config-show` command line argument to display the currently set configuration options. The output includes the path to the configuration file and lists each option with its value.

```bash
$ phpcs --config-show

Using config file: path/to/PHP_CodeSniffer/CodeSniffer.conf

colors:           1
default_standard: PSR12
report_width:     150
```

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

### Example code with empty code block

Source: https://github.com/phpcsstandards/php_codesniffer/blob/4.x/tests/Core/Generators/Expectations/ExpectedOutputInvalidCodeComparisonMismatchedCodeElms.md

A table with two code elements: the first is empty (only a title), the second contains the actual code. The empty block is preserved as-is.

```php
$a = 'Example code';
```

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

### Specify source file encoding with --encoding

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

Use the --encoding command line argument to process source files with a specific encoding instead of the default UTF-8. The example sets the encoding to windows-1251 for the given path.

```bash
$ phpcs --encoding=windows-1251 /path/to/code
```

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

### Valid and Invalid Class Comparison

Source: https://github.com/phpcsstandards/php_codesniffer/blob/4.x/tests/Core/Generators/Expectations/ExpectedOutputStructureDocs.md

Shows a valid class definition and an invalid class definition in a comparison table. The valid example uses 'class Code {}' and the invalid example uses 'class Comparison {}'.

```php
class Code {}
```

```php
class Comparison {}
```

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

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

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

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

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

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

### Align start of assignment operators with alignAtEnd=false

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

Sets alignAtEnd to false so the start of assignment tokens are aligned instead of the end.

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

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

### Write full and summary reports to separate files with --report-full= and --report-summary=

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

Specify a file path after each report argument to write each report to its own file instead of the screen. The full report goes to full.txt and the summary to summary.txt.

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

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

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

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

Adds one or more paths to the installed standards search list. Relative paths must begin with './' and are resolved relative to the top-level PHP_CodeSniffer install directory.

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

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

### Valid and Invalid Echo vs Print Comparison

Source: https://github.com/phpcsstandards/php_codesniffer/blob/4.x/tests/Core/Generators/Expectations/ExpectedOutputStructureDocs.md

Compares the valid use of echo with the invalid use of print for outputting a variable. The valid example uses 'echo $foo;' and the invalid example uses 'print $foo;'.

```php
echo $foo;
```

```php
print $foo;
```

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

### Verbose token processing output from phpcs -vvv

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

Output produced by running phpcs with -vvv and the PEAR standard on the example file. It shows each token with its ID, type, and contents, along with the sniffs executed on it and their running times. Tokens without sniff executions are normal because most sniffs listen for specific tokens and then process subsequent tokens.

```text
    *** START TOKEN PROCESSING ***
    Process token 0: T_OPEN_TAG => <?php
        Processing PHP_CodeSniffer\Standards\PEAR\Sniffs\Commenting\FileCommentSniff... DONE in 0.0002 seconds
        Processing PHP_CodeSniffer\Standards\PEAR\Sniffs\WhiteSpace\ScopeIndentSniff... DONE in 0.0003 seconds
        Processing PHP_CodeSniffer\Standards\Generic\Sniffs\PHP\DisallowShortOpenTagSniff... DONE in 0.0002 seconds
        Processing PHP_CodeSniffer\Standards\Generic\Sniffs\WhiteSpace\DisallowTabIndentSniff... DONE in 0.0004 seconds
        Processing PHP_CodeSniffer\Standards\Generic\Sniffs\Files\LineLengthSniff... DONE in 0.0002 seconds
        Processing PHP_CodeSniffer\Standards\Generic\Sniffs\Files\LineEndingsSniff... DONE in 0.0002 seconds
    Process token 1: T_WHITESPACE => \n
    Process token 2: T_IF => if
        Processing PHP_CodeSniffer\Standards\PEAR\Sniffs\ControlStructures\ControlSignatureSniff... DONE in 0.0002 seconds
        Processing PHP_CodeSniffer\Standards\PEAR\Sniffs\ControlStructures\MultiLineConditionSniff... DONE in 0.0001 seconds
        Processing PHP_CodeSniffer\Standards\PEAR\Sniffs\WhiteSpace\ScopeClosingBraceSniff... DONE in 0.0001 seconds
        Processing PHP_CodeSniffer\Standards\Generic\Sniffs\ControlStructures\InlineControlStructureSniff... DONE in 0.0001 seconds
    Process token 3: T_WHITESPACE =>
    Process token 4: T_OPEN_PARENTHESIS => (
    Process token 5: T_VARIABLE => $condition
        Processing PHP_CodeSniffer\Standards\PEAR\Sniffs\Functions\FunctionCallSignatureSniff... DONE in 0.0001 seconds
        Processing PHP_CodeSniffer\Standards\PEAR\Sniffs\NamingConventions\ValidVariableNameSniff... DONE in 0.001 seconds
        Processing PHP_CodeSniffer\Standards\Generic\Sniffs\Functions\FunctionCallArgumentSpacingSniff... DONE in 0.0001 seconds
    Process token 6: T_CLOSE_PARENTHESIS => )
        Processing PHP_CodeSniffer\Standards\PEAR\Sniffs\Functions\FunctionCallSignatureSniff... DONE in 0.0001 seconds
        Processing PHP_CodeSniffer\Standards\Generic\Sniffs\Functions\FunctionCallArgumentSpacingSniff... DONE in 0.0001 seconds
    Process token 7: T_WHITESPACE =>
    Process token 8: T_OPEN_CURLY_BRACKET => {
    Process token 9: T_WHITESPACE => \n
    Process token 10: T_WHITESPACE =>
    Process token 11: T_ECHO => echo
    Process token 12: T_WHITESPACE =>
    Process token 13: T_CONSTANT_ENCAPSED_STRING => 'Condition was true'
    Process token 14: T_SEMICOLON => ;
    Process token 15: T_WHITESPACE => \n
    Process token 16: T_CLOSE_CURLY_BRACKET => }
        Processing PHP_CodeSniffer\Standards\PEAR\Sniffs\Functions\FunctionCallSignatureSniff... DONE in 0.0001 seconds
        Processing PHP_CodeSniffer\Standards\Generic\Sniffs\Functions\FunctionCallArgumentSpacingSniff... DONE in 0.0002 seconds
    Process token 17: T_WHITESPACE => \n
    Process token 18: T_CLOSE_TAG => ?>
    *** END TOKEN PROCESSING ***
```

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

### Create ruleset.xml file

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

Navigate into the MyStandard directory and create an empty ruleset.xml file. This file identifies the directory as a coding standard.

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

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

### Valid and Invalid Variable Assignment Comparison

Source: https://github.com/phpcsstandards/php_codesniffer/blob/4.x/tests/Core/Generators/Expectations/ExpectedOutputStructureDocs.md

Compares a valid variable assignment using a descriptive variable name with an invalid one using a short, unclear name. The valid example assigns 10 to $one, while the invalid example assigns 10 to $a.

```php
$one = 10;
```

```php
$a = 10;
```

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

### Checkstyle XML report output

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

Example XML output produced by the --report=checkstyle argument. It contains a <checkstyle> root element with a <file> element per scanned file, and each <error> element includes line, column, severity, message, and source attributes.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<checkstyle version="4.0.4">
<file name="path/to/code/fileA.php">
 <error line="1" column="1" severity="error" message="Header blocks must be separated by a single blank line" source="PSR12.Files.FileHeader.SpacingAfterTagBlock"/>
 <error line="10" column="24" severity="error" message="Expected 0 spaces after opening parenthesis; 1 found" source="Squiz.Functions.FunctionDeclarationArgumentSpacing.SpacingAfterOpen"/>
 <error line="10" column="26" severity="error" message="PHP parameter type declarations must be lowercase; expected &quot;string&quot; but found &quot;String&quot;" source="Generic.PHP.LowerCaseType.ParamTypeFound"/>
 <error line="10" column="26" severity="error" message="Expected 1 space between type hint and argument &quot;$param&quot;; 2 found" source="Squiz.Functions.FunctionDeclarationArgumentSpacing.SpacingAfterHint"/>
 <error line="12" column="136" severity="warning" message="Line exceeds 120 characters; contains 136 characters" source="Generic.Files.LineLength.TooLong"/>
 <error line="13" column="5" severity="error" message="Line indented incorrectly; expected at least 8 spaces, found 4" source="Generic.WhiteSpace.ScopeIndent.Incorrect"/>
 <error line="13" column="12" severity="error" message="TRUE, FALSE and NULL must be lowercase; expected &quot;false&quot; but found &quot;FALSE&quot;" source="Generic.PHP.LowerCaseConstant.Found"/>
</file>
</checkstyle>
```

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

### Check code against multiple standards with --report=info

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

Specify all included standards to check your code against a wide range of conventions. This takes longer but provides more information about your code.

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

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

### Generate an information report with --report=info

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

Use the --report=info command line argument to output an information report that inspects code using the sniffs from the standards you pass. The report shows metrics for coding conventions, with the most common variation printed first and other variations indented below. Not all sniffs support recording metrics, so some may not report information.

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

PHP CODE SNIFFER INFORMATION REPORT
--------------------------------------------------------------------------------
Class has doc comment: yes [10/10, 100%]

Class opening brace placement: new line [10/10, 100%]

Constant name case: upper [81/81, 100%]

Control structure defined inline: no [863/863, 100%]

EOL char: \n [10/10, 100%]

File has doc comment: yes [10/10, 100%]

Function has doc comment: yes [130/130, 100%]

Function opening brace placement: new line [111/111, 100%]

Inline comment style: // ... [585/594, 98.48%]
    /* ... */ => 9 (1.52%)

Line indent: spaces [5099/5099, 100%]

Line length: 80 or less [6723/7134, 94.24%]
    81-120 => 397 (5.56%)
    121-150 => 10 (0.14%)
    151 or more => 4 (0.06%)

PHP constant case: lower [684/684, 100%]

PHP short open tag used: no [10/10, 100%]

Private method prefixed with underscore: yes [11/11, 100%]

--------------------------------------------------------------------------------
```

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

### Configure Generic.Files.LineLength with lineLimit and absoluteLineLimit

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

Sets warning threshold to 100 characters and error threshold to 135 characters for the Generic.Files.LineLength sniff. 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>
```

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

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

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

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

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

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

### supportedTokenizers Property Example (PHP_CodeSniffer < 4.0)

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

Example of the $supportedTokenizers property used in sniffs for PHP_CodeSniffer versions prior to 4.0.0. This property tells PHP_CodeSniffer that the sniff can check both PHP and JavaScript code. Note that since PHP_CodeSniffer 4.0.0, scanning JavaScript or CSS files is no longer supported.

```php
/**
 * A list of tokenizers this sniff supports.
 *
 * @var array<string>
 */
public $supportedTokenizers = [
    'PHP',
    'JS',
];
```

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

### Mix screen and file reports: full report to file, summary to screen

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

Combine file and screen output by providing a path for one report and omitting it for another. Here the full report is written to a file while the summary is printed to the screen.

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

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

### Configure requiredSpacesAfterOpen and requiredSpacesBeforeClose

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

XML ruleset configuration to set the padding inside function call brackets to one space for the PEAR.Functions.FunctionCallSignature sniff.

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

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

### Create MyStandard directory structure

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

Run these commands to create the coding standard directory and its Sniffs sub-directory. The directory must follow the required layout for PHP_CodeSniffer standards.

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

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

### Add PHP_CodeSniffer as a Composer dependency

Source: https://github.com/phpcsstandards/php_codesniffer/blob/4.x/README.md

Adds squizlabs/php_codesniffer as a require-dev dependency in composer.json. After installation, run PHP_CodeSniffer from the vendor bin directory.

```json
{
    "require-dev": {
        "squizlabs/php_codesniffer": "^4.0"
    }
}
```

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

### Show source codes with -s and --report=source

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

Add the -s command line argument to display source codes (e.g., Generic.Files.LineLength.TooLong) instead of friendly names in the source report. The output format changes to show only the source and count columns, while still providing totals and PHPCBF fix information.

```bash
$ phpcs -s --report=source /path/to/code

PHP CODE SNIFFER VIOLATION SOURCE SUMMARY
------------------------------------------------------------------------------
    SOURCE                                                               COUNT
------------------------------------------------------------------------------
[ ] Generic.Files.LineLength.TooLong                                     1
[x] Generic.PHP.LowerCaseConstant.Found                                  1
[x] Generic.PHP.LowerCaseType.ParamTypeFound                             1
[x] Generic.WhiteSpace.ScopeIndent.Incorrect                             1
[x] PSR12.Files.FileHeader.SpacingAfterTagBlock                          1
[x] Squiz.Functions.FunctionDeclarationArgumentSpacing.SpacingAfterHint  1
[x] Squiz.Functions.FunctionDeclarationArgumentSpacing.SpacingAfterOpen  1
------------------------------------------------------------------------------
A TOTAL OF 7 SNIFF VIOLATIONS WERE FOUND IN 7 SOURCES
------------------------------------------------------------------------------
PHPCBF CAN FIX THE 6 MARKED SOURCES AUTOMATICALLY (6 VIOLATIONS IN TOTAL)
------------------------------------------------------------------------------
```

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

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

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

Shows a docblock containing only the {@inheritdoc} tag. When 'skipIfInheritdoc' is enabled, this comment will not be checked for missing tags.

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

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

### Include custom bootstrap files with --bootstrap

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

Use the --bootstrap command line argument to include one or more custom bootstrap files before processing begins. Multiple files are separated by commas. Bootstrap files are included after command line arguments and rulesets are parsed, and can be used to manipulate internal PHP_CodeSniffer settings.

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

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

### Generic.Files.LineEndings eolChar property

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

Sets the required line ending character. Default is \n; this example uses \r\n for Windows-style endings.

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

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

### Set indent property for PSR2.ControlStructures.SwitchDeclaration

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

Configures the indent size for the case terminating statement. Default is 4 spaces; set to 2 in this example.

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

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

### Generate Git Blame Report with --report=gitblame

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

Use the --report=gitblame command line argument to generate a Git Blame report that lists each author, the number of violations they committed, and the percentage of error lines to clean lines. The output shows a summary table with author names, percentages, and violation counts. Ensure the git command is in your PATH, otherwise the report will fail to generate.

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

PHP CODE SNIFFER GIT BLAME SUMMARY
----------------------------------------------------------------------
AUTHOR                                    (Author %) (Overall %) COUNT
----------------------------------------------------------------------
jsmith                                        (2.25)     (61.11)    33
jblogs                                        (2.48)     (29.63)    16
pdeveloper                                    (0.78)      (5.56)     3
jscript                                       (1.39)      (1.85)     1
toogood                                       (3.33)      (1.85)     1
----------------------------------------------------------------------
A TOTAL OF 54 SNIFF VIOLATIONS WERE COMMITTED BY 5 AUTHORS
----------------------------------------------------------------------
```

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

### Generic.Arrays.ArrayIndent indent property

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

Sets the indent size for keys in multi-line array declarations. Default is 4 spaces; this example changes it to 2.

```xml
<rule ref="Generic.Arrays.ArrayIndent">
    <properties>
        <property name="indent" value="2" />
    </properties>
</rule>
```

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

### Configure requiredSpacesAfterOpen and requiredSpacesBeforeClose for for loop

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

XML ruleset configuration to set requiredSpacesAfterOpen and requiredSpacesBeforeClose to 1 for Squiz.ControlStructures.ForLoopDeclaration.

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

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

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

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

Specifies methods that do not require a @return tag in their docblocks. The default is ['__construct', '__destruct']; this example adds 'ignoreThisFunction' to the list.

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

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

### Basic ruleset.xml template for a new standard

Source: https://github.com/phpcsstandards/php_codesniffer/wiki/About-Standards-for-PHP_CodeSniffer

Create a file named ruleset.xml in your standard's directory with this content, replacing 'StandardName' with your chosen name. The standard name must not contain spaces, dots, or slashes, and cannot be 'Internal'.

```xml
<?xml version="1.0"?>
<ruleset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" name="StandardName" xsi:noNamespaceSchemaLocation="https://schema.phpcodesniffer.com/phpcs.xsd">

</ruleset>
```

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

### Invalid: class Comparison {}

Source: https://github.com/phpcsstandards/php_codesniffer/blob/4.x/tests/Core/Generators/Expectations/ExpectedOutputInvalidStandardNoContent.md

Invalid example for the standard element, showing a class named Comparison.

```php
class Comparison {}
```

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

### Run PHPCS with --report=performance and --no-cache

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

Use the --report=performance command line argument to generate a sniff performance report. The --no-cache flag is required for accurate timing because the cache interferes with runtime measurement. The output lists each sniff with its time taken and percentage of total sniff processing time, and highlights slow sniffs when --colors is enabled.

```bash
$ phpcs --report=performance /path/to/code --no-cache

PHP CODE SNIFFER SNIFF PERFORMANCE REPORT
--------------------------------------------------------------------------------
SNIFF                                                 TIME TAKEN (SECS)     (%)
--------------------------------------------------------------------------------
Generic.NamingConventions.UpperCaseConstantName               0.074654 ( 44.6 %)
PSR1.Files.SideEffects                                        0.028242 ( 16.9 %)
PSR1.Methods.CamelCapsMethodName                              0.027005 ( 16.2 %)
PSR1.Classes.ClassDeclaration                                 0.021653 ( 13.0 %)
Squiz.Classes.ValidClassName                                  0.010412 (  6.2 %)
Generic.PHP.DisallowAlternativePHPTags                        0.002662 (  1.6 %)
Generic.PHP.DisallowShortOpenTag                              0.002560 (  1.5 %)
Generic.Files.ByteOrderMark                                   0.000012 (  0.0 %)
--------------------------------------------------------------------------------
TOTAL SNIFF PROCESSING TIME                                   0.167201 (100.0 %)
--------------------------------------------------------------------------------
Time taken by sniffs                                          0.167201 (  1.2 %)
Time taken by PHPCS runner                                   13.336752 ( 98.8 %)
--------------------------------------------------------------------------------
TOTAL RUN TIME                                               13.503953 (100.0 %)
--------------------------------------------------------------------------------
```

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

### Valid: class Code {}

Source: https://github.com/phpcsstandards/php_codesniffer/blob/4.x/tests/Core/Generators/Expectations/ExpectedOutputInvalidStandardNoContent.md

Valid example for the standard element, showing a class named Code.

```php
class Code {}
```

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

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

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

Configures the indent size for class names split over multiple lines. Default is 4 spaces; set to 2 in this example.

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

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

### Valid sniff with nested standard directory

Source: https://github.com/phpcsstandards/php_codesniffer/wiki/About-Standards-for-PHP_CodeSniffer

Allows nesting the standard directory deeper inside a project. The same 'namespace' attribute note applies, and 'installed_paths' must point to the MyStandard directory.

```php
<?php
// File: src/Tools/PHPCS/MyStandard/Sniffs/Operators/OperatorSpacingSniff.php

namespace Vendor\Tools\PHPCS\MyStandard\Sniffs\Operators;

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

class OperatorSpacingSniff implements Sniff {...}
```

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

### Exclude a whole category of sniffs

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

Excludes an entire category of sniffs from a standard. This example excludes all sniffs in the Squiz.PHP category.

```xml
<rule ref="Squiz">
 <exclude name="Squiz.PHP"/>
</rule>
```

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

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

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

Use the --runtime-set command line argument to set a configuration option for a single run only. Not all configuration options can be set this way; options that provide defaults for command line arguments (e.g., default standard or report type) cannot be used with --runtime-set.

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

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

### Enable progress output by default with show_progress

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

Sets the show_progress configuration option to 1 so progress is shown by default. Cannot be set with --runtime-set; use -p for a single run.

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

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

### Generic.CodeAnalysis.UnusedFunctionParameter ignoreTypeHints property

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

Configures the sniff to ignore unused parameters with specific type hints. The example shows a function with an unused InputInterface parameter and the XML rule to ignore it.

```php
public function execute(InputInterface $input, OutputInterface $output): int
{
    $output->writeLine('Hello World!');
}
```

```xml
<rule ref="Generic.CodeAnalysis.UnusedFunctionParameter">
    <properties>
         <property name="ignoreTypeHints" type="array">
            <element value="InputInterface"/>
        </property>
    </properties>
</rule>
```

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

### Configure allowMultipleArguments to false

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

XML ruleset configuration to require one argument per line in multi-line function calls for the PEAR.Functions.FunctionCallSignature sniff.

```xml
<rule ref="PEAR.Functions.FunctionCallSignature">
    <properties>
        <property name="allowMultipleArguments" value="false" />
    </properties>
</rule>
```

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

### Invalid: Checking handling of blank lines

Source: https://github.com/phpcsstandards/php_codesniffer/blob/4.x/tests/Core/Generators/Expectations/ExpectedOutputUnsupportedSuperfluousCodeElement.html

Invalid example showing incorrect handling of blank lines in the Superfluous code element standard.

```php
$invalid = true;
```
Tokens:
Raw