PHP Coding Standard Generator

PHP Mess Detector

Ruleset name:

Ruleset description:

Code Size Rules

The Code Size Ruleset contains a collection of rules that find code size related problems.

CyclomaticComplexity

Example

            
// Cyclomatic Complexity = 12
class Foo {
1   public function example()  {
2       if ($a == $b)  {
3           if ($a1 == $b1) {
                fiddle();
4           } else if ($a2 == $b2) {
                fiddle();
            }  else {
                fiddle();
            }
5       } else if ($c == $d) {
6           while ($c == $d) {
                fiddle();
            }
7        } else if ($e == $f) {
8           for ($n = 0; $n < $h; $n++) {
                fiddle();
            }
        } else{
            switch ($z) {
9               case 1:
                    fiddle();
                    break;
10              case 2:
                    fiddle();
                    break;
11              case 3:
                    fiddle();
                    break;
12              default:
                    fiddle();
                    break;
            }
        }
    }
}

Complexity is determined by the number of decision points in a method plus one for the method entry. The decision points are 'if', 'while', 'for', and 'case labels'. Generally, 1-4 is low complexity, 5-7 indicates moderate complexity, 8-10 is high complexity, and 11+ is very high complexity.

reportLevel:

The Cyclomatic Complexity reporting threshold

showClassesComplexity:

Indicate if class average violation should be added to the report

showMethodsComplexity:

Indicate if class average violation should be added to the report

NPathComplexity

Example

            
class Foo {
    function bar() {
        // lots of complicated code
    }
}

The NPath complexity of a method is the number of acyclic execution paths through that method. A threshold of 200 is generally considered the point where measures should be taken to reduce complexity.

minimum:

The npath reporting threshold

ExcessiveMethodLength

Example

            
class Foo {
    public function doSomething() {
        print("Hello world!" . PHP_EOL);
        print("Hello world!" . PHP_EOL);
        // 98 copies omitted for brevity.
    }
}

Violations of this rule usually indicate that the method is doing too much. Try to reduce the method size by creating helper methods and removing any copy/pasted code.

minimum:

The method size reporting threshold

ExcessiveClassLength

Example

            
class Foo {
  public function bar() {
    // 1000 lines of code
  }
}

Long Class files are indications that the class may be trying to do too much. Try to break it down, and reduce the size to something manageable.

minimum:

The class size reporting threshold

ExcessiveParameterList

Example

            
class Foo {
    public function addData(
        $p0, $p1, $p2, $p3, $p4, $p5,
        $p5, $p6, $p7, $p8, $p9, $p10) {
    }
}

Long parameter lists can indicate that a new object should be created to wrap the numerous parameters. Basically, try to group the parameters together.

minimum:

The parameter count reporting threshold

ExcessivePublicCount

Example

            
public class Foo {
    public $value;
    public $something;
    public $var;
    // [... more more public attributes ...]

    public function doWork() {}
    public function doMoreWork() {}
    public function doWorkAgain() {}
    // [... more more public methods ...]
}

A large number of public methods and attributes declared in a class can indicate the class may need to be broken up as increased effort will be required to thoroughly test it.

minimum:

The public item reporting threshold

TooManyFields

Example

            
class Person {
   protected $one;
   private $two;
   private $three;
   [... many more fields ...]
}

Classes that have too many fields could be redesigned to have fewer fields, possibly through some nested object grouping of some of the information. For example, a class with city/state/zip fields could instead have one Address field.

maxfields:

The field count reporting threshold

TooManyMethods

A class with too many methods is probably a good suspect for refactoring, in order to reduce its complexity and find a way to have more fine grained objects.

maxmethods:

The method count reporting threshold

ExcessiveClassComplexity

Example

            
class Foo {
    public function bar()  {
        if ($a == $b)  {
            if ($a1 == $b1) {
                fiddle();
            } else if ($a2 == $b2) {
                fiddle();
            }  else {
            }
        }
    }
    public function baz()  {
        if ($a == $b)  {
            if ($a1 == $b1) {
                fiddle();
            } else if ($a2 == $b2) {
                fiddle();
            }  else {
            }
        }
    }
    // Several other complex methods
}

The WMC of a class is a good indicator of how much time and effort is required to modify and maintain this class. A large number of methods also means that this class has a greater potential impact on derived classes.

maximum:

The maximum WMC tolerable for a class.

Controversial Rules

This ruleset contains a collection of controversial rules.

Superglobals

Example

            
class Foo {
    public function bar() {
        $name = $_POST['foo'];
    }
}

Accessing a super-global variable directly is considered a bad practice. These variables should be encapsulated in objects that are provided by a framework, for instance.

CamelCaseClassName

Example

            
class class_name {
}

It is considered best practice to use the CamelCase notation to name classes.

CamelCasePropertyName

Example

            
class ClassName {
    protected $property_name;
}

It is considered best practice to use the camelCase notation to name attributes.

CamelCaseMethodName

Example

            
class ClassName {
    public function get_name() {
    }
}

It is considered best practice to use the CamelCase notation to name methods.

CamelCaseParameterName

Example

            
class ClassName {
    public function doSomething($user_name) {
    }
}

It is considered best practice to use the camelCase notation to name parameters.

CamelCaseVariableName

Example

            
class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

It is considered best practice to use the camelCase notation to name variables.

Design Rules

The Code Size Ruleset contains a collection of rules that find software design related problems.

ExitExpression

Example

            
class Foo {
    public function bar($param)  {
        if ($param === 42) {
            exit(23);
        }
    }
}

An exit-expression within regular code is untestable and therefore it should be avoided. Consider to move the exit-expression into some kind of startup script where an error/exception code is returned to the calling environment.

EvalExpression

Example

            
class Foo {
    public function bar($param)  {
        if ($param === 42) {
            eval('$param = 23;');
        }
    }
}

An eval-expression is untestable, a security risk and bad practice. Therefore it should be avoided. Consider to replace the eval-expression with regular code.

GotoStatement

Example

            
class Foo {
    public function bar($param)  {
        A:
        if ($param === 42) {
            goto X;
        }
        Y:
        if (time() % 42 === 23) {
            goto Z;
        }
        X:
        if (time() % 23 === 42) {
            goto Y;
        }
        Z:
        return 42;                 
    }
}

Goto makes code harder to read and it is nearly impossible to understand the control flow of an application that uses this language construct. Therefore it should be avoided. Consider to replace Goto with regular control structures and separate methods/function, which are easier to read.

NumberOfChildren

Example

A class with an excessive number of children is an indicator for an unbalanced class hierarchy. You should consider to refactor this class hierarchy.

minimum:

Maximum number of acceptable child classes.

DepthOfInheritance

Example

A class with many parents is an indicator for an unbalanced and wrong class hierarchy. You should consider to refactor this class hierarchy.

minimum:

Maximum number of acceptable parent classes.

CouplingBetweenObjects

Example

            
class Foo {
    /**
     * @var \foo\bar\X
     */
    private $x = null;

    /**
     * @var \foo\bar\Y
     */
    private $y = null;

    /**
     * @var \foo\bar\Z
     */
    private $z = null;

    public function setFoo(\Foo $foo) {}
    public function setBar(\Bar $bar) {}
    public function setBaz(\Baz $baz) {}

    /**
     * @return \SplObjectStorage
     * @throws \OutOfRangeException
     * @throws \InvalidArgumentException
     * @throws \ErrorException
     */
    public function process(Iterator $it) {}

    // ...
}

A class with to many dependencies has negative impacts on several quality aspects of a class. This includes quality criterias like stability, maintainability and understandability

minimum:

Maximum number of acceptable dependencies.

Naming Rules

The Naming Ruleset contains a collection of rules about names - too long, too short, and so forth.

ShortVariable

Example

            
class Something {
    private $q = 15; // VIOLATION - Field
    public static function main( array $as ) {  // VIOLATION - Formal
        $r = 20 + $this->q; // VIOLATION - Local
        for (int $i = 0; $i < 10; $i++) { // Not a Violation (inside FOR)
            $r += $this->q;
        }
    }
}

Detects when a field, local, or parameter has a very short name.

minimum:

Minimum length for a variable, property or parameter name

LongVariable

Example

            
class Something {
    protected $reallyLongIntName = -3;  // VIOLATION - Field
    public static function main( array $argumentsList[] ) { // VIOLATION - Formal
        $otherReallyLongName = -5; // VIOLATION - Local
        for ($interestingIntIndex = 0;  // VIOLATION - For
             $interestingIntIndex < 10;
             $interestingIntIndex++ ) {
        }
    }
}

Detects when a field, formal or local variable is declared with a long name.

maximum:

The variable length reporting threshold

ShortMethodName

Example

            
class ShortMethod {
    public function a( $index ) { // Violation
    }
}

Detects when very short method names are used.

minimum:

Minimum length for a method or function name

ConstructorWithNameAsEnclosingClass

Example

            
class MyClass {
     // this is bad because it is PHP 4 style
    public function MyClass() {}
    // this is good because it is a PHP 5 constructor
    public function __construct() {}
}

A constructor method should not have the same name as the enclosing class, consider to use the PHP 5 __construct method.

ConstantNamingConventions

Example

            
class Foo {
    const MY_NUM = 0; // ok
    const myTest = ""; // fail
}

Class/Interface constant nanmes should always be defined in uppercase.

BooleanGetMethodName

Example

            
class Foo {
    /**
     * @return boolean
     */
    public function getFoo() {} // bad
    /**
     * @return bool
     */
    public function isFoo(); // ok
    /**
     * @return boolean
     */
    public function getFoo($bar); // ok, unless checkParameterizedMethods=true
}

Looks for methods named 'getX()' with 'boolean' as the return type. The convention is to name these methods 'isX()' or 'hasX()'.

checkParameterizedMethods:

Applies only to methods without parameter when set to true

Unused Code Rules

The Unused Code Ruleset contains a collection of rules that find unused code.

UnusedPrivateField

Example


class Something
{
    private static $FOO = 2; // Unused
    private $i = 5; // Unused
    private $j = 6;
    public function addOne()
    {
        return $this->j++;
    }
}

Detects when a private field is declared and/or assigned a value, but not used.

UnusedLocalVariable

Example


class Foo {
    public function doSomething()
    {
        $i = 5; // Unused
    }
}

Detects when a local variable is declared and/or assigned, but not used.

UnusedPrivateMethod

Example


class Something
{
    private function foo() {} // unused
}

Unused Private Method detects when a private method is declared but is unused.

UnusedFormalParameter

Example


class Foo
{
    private function bar($howdy)
    {
        // $howdy is not used
    }
}

Avoid passing parameters to methods or constructors and then not using those parameters.

PHP Code Sniffer

Ruleset name:

Ruleset description:

Generic - Classes

Sniffs related to PHP classes

DuplicateClassName

Example

      
// bar.php
class foo {}
// foo.php
class foo {}

A class or interface must not be defined in multiple files.

Generic - Code Analysis

Sniff for detecting superfluously complex expressions and trivial but harder to spot mistakes

EmptyStatement

Example

      
if($x == 5) {
  // nothing in the statements body
}

Statements may not have an empty body.

ForLoopShouldBeWhileLoop

Example

      
class Foo {
  public function bar($x) {
    for (;$x > 5;) { /* ... */ } // No Init or Update part, may as well be: while ($x > 5)
  }
}

All 'for' loops that could be simplified to a 'while' loop must be simplified.

ForLoopWithTestFunctionCall

Example

      
 class Foo {
   public function bar($x) {
     $a = array(1, 2, 3, 4);
     for ($i = 0; $i < count($a); $i++) {
       $a[$i] *= $i;
     }
   }
 }

For loops test expressions may not have function calls in them.

JumbledIncrementer

Example

      
 function bar($x) {
   for ($i = 0; $i < 10; $i++) {
     for ($k = 0; $k < 20; $i++) {
       echo 'Hello';
     }
   }
 }

Reports cases where incrementer jumbling might happen in 'for' loops.

UnconditionalIfStatement

Example

      
if(true) {
}

If- and elseif-statements may not be unconditional.

UnnecessaryFinalModifier

Example

      
final class Bar {
  final public function() {
  }
}

No unnecessary final modifiers inside of final classes.

UnusedFunctionParameter

Example

      
function bar($x, $y) {
  echo $y; // No $x usage
}

No unused function parameters are allowed.

UselessOverridingMethod

Example

      
class Foo {
  public function __construct($foo, $bar) {
    parent::__construct($foo, $bar);
  }
}

No unnecessary overridden methods, that simply call their parent, are allowed.

Generic - Commenting

Detects patterns in comments

Todo

Example

      
function worldPeace() {
  // TODO: Achieve this
}

There may not be any 'TODO' comments

Fixme

Example

      
function worldPeace() {
  // FIXME: Not working yet
}

There may not be any 'FIXME' comments

Generic - ControlStructures

Sniffs related to control structures

InlineControlStructure

Example

      
// No braces! Gets reported!
while(true) $x++; if($x > 10); break;

// Also not allowed
if($x)
  continue;

//Everything needs braces
if($x) {
  continue;
}

Inline control structures like 'if($a) continue;' are not allowed

error:

If true, an error will be reported; otherwise a warning.

Generic - Debug

Javascript related checking options. Show in general not be needed for phpcs. The named tools have to be installed for these sniffs to work.

ClosureLinter

Runs 'gjslint' on your javascript files.

JSHint

Runs 'jshint' on your javascript files.

CSSLint

Runs 'csslint' on your css files.

Generic - Files

Sniffs related to file layout

ByteOrderMark

Reports cases where a byte order mark is found in any PHP file to avoid application failures.

LineEndings

Example

      
// One of those lines is wrong. $eolChar decides which one
echo "My line";\r\n
echo "My other line";\n

Line endings must be $eolChar. Defaults to making sure that everything has UNIX line endings.

eolChar:

Use \n for UNIX line endings and \r\n for WINDOWS line endings.

LineLength

Lines should not longer than $lineLimit (warning) and must not be longer than $absoluteLineLimit (error). If $lineLimit and $absoluteLineLimit are configured to have the same value only one error is reported. To turn of $absoluteLineLimit '0' can be used.

lineLimit:

Lines longer than this value will raising a warning

absoluteLineLimit:

Lines longer than this value will raising an error

Generic - Formatting

Sniffs related to basic formatting

DisallowMultipleStatements

Example

      
$x = 6; $y = 7; $z = 6 * 7;

There must be only on statement per line.

MultipleStatementAlignment

Example

      
//Valid
$stuff      = 1;
$otherStuff = 2;
//Invalid
$stuff = 1;
$otherStuff = 2;
//Also valid
$myVar           = 1
$myOtherVariable = 2;

$x = 100; // Must not be indeted because of the blank line!
while($x--) {
  echo $x, PHP_EOL;
}

If there are multiple adjacent assignments, the equals signs of each assignment have to be aligned.

error:

If true, an error will be reported; otherwise a warning.

maxPadding:

The maximum amount of padding before the alignment is ignored.

ignoreMultiLine:

If true, multi-line assignments are not checked.

NoSpaceAfterCast

Example

      
//Valid
$x = (string)1;
//Invalid
$x = (string) 1;

There may be no spaces after cast statements.

SpaceAfterCast

Example

      
//Valid
$x = (string) 1;
//Invalid
$x = (string)1;
//Also invalid
$x = (string)  1; // Only 1 space allowed!

There must be a space after a cast statement.

Generic - Functions

Sniffs related to function arguments and brace styles

CallTimePassByReference

Example

      
//Invalid
function foo($bar) {
  $bar++;
}
$x = 1;
foo(&$x);
//Valid
function foo(&$bar) {
  $bar++;
}
$x = 1;
foo($x);

Disallows usage of call-time pass-by-reference. See: http://php.net/manual/en/language.references.pass.php

FunctionCallArgumentSpacing

Example

      
NO SAMPLE AVAILABLE. Contributions welcome.

NO DOCUMENTATION AVAILABLE. Contributions welcome. I didn't want to reverse engineer what this is supposed to do and how it works *exactly*.

OpeningFunctionBraceBsdAllman

Example

      
//Valid
function foo()
{
    // ...
}
//Invalid
function foo() {
    // ...
}

Function declarations must follow the "BSD/Allman style". The function brace is on the line following the function declaration and is indented to the same column as the start of the function declaration.

OpeningFunctionBraceKernighanRitchie

Example

      
//Valid
function foo() {
    // ...
}
//Invalid
function foo()
{
    // ...
}

Function declarations follow the "Kernighan/Ritchie style". The function brace is on the same line as the function declaration. One space is required between the closing parenthesis and the brace.

Generic - Metrics

Sniffs related to code metrics

CyclomaticComplexity

Example

      
Just check Wikipedia for the details

Disallows to complex function determined by the cyclomatic complexity (McCabe, http://en.wikipedia.org/wiki/Cyclomatic_complexity) of that function. If $absoluteComplexity has the same value as $complexity then there will be only errors and no warnings.

complexity:

More complex functions will generate a warning

absoluteComplexity:

More complex functions will generate an error

NestingLevel

Example

      
// Too deep!
if($a) {
  if($b) {
    if($c) {
      if($d) {
        if($e) {
          if($f) {
            echo 'Stuff';
          }
        }
      }
    }
  }
}

Defines a maximum $nestingLevel and $absoluteNestingLevel for functions. If $nestingLevel has the same value as $absoluteNestingLevel then there will be only errors and no warnings.

nestingLevel:

Deeper nested functions will generate a warning

absoluteNestingLevel:

Deeper nested functions will generate a warning

Generic - NamingConventions

Sniffs related to naming things

ConstructorName

Example

      
class foo {
  // Old style constructor is not allowed!
  public function foo() {

  }
}

Disallows usage of PHP 4 style constructors

error:

If true, an error will be reported; otherwise a warning.

UpperCaseConstantName

Example

      
const FOO = 'ok';
define('bad', 7);
x = bad; // Not ok

Constants must be uppercase

CamelCapsFunctionName

Ensures camel case function naming and that only PHP core functions have a double underscore

Generic - PHP

Sniffs related to basic PHP usage

DeprecatedFunctions

Example

      
// Raises error
set_magic_quotes_runtime(false);

Disallows the use of any deprecated functions

DisallowShortOpenTag

Example

      
<? echo 'This is not acceptable!';

Makes sure that shorthand PHP open tags are not used.

ForbiddenFunctions

Example

      
delete($foo);
sizeof($bar);

Disallows the use of alias functions that are kept in PHP for compatibility with older versions. Can be used to forbid the use of any function when creating your own Sniff class extending from this class.

error:

If true, an error will be reported; otherwise a warning.

LowerCaseConstant

Example

      
true, false, null // Good
TRUE, FALSE, NULL // Bad
TrUe, FaLsE, NuLl // Also bad

The constants 'true', 'false' or 'null' must be written in lowercase.

NoSilencedErrors

Example

      
@stuff();
if(@$_GET['stuff']) { }

Disallows usage of the @ operator.

error:

If true, an error will be reported; otherwise a warning.

UpperCaseConstant

Example

      
TRUE, FALSE, NULL // Good
true, false, null // Bad
TrUe, FaLsE, NuLl // Also bad

The constants 'TRUE', 'FALSE' or 'NULL' must be written in uppercase.

Generic - Strings

Sniffs related to string handling

UnnecessaryStringConcat

Example

      
echo "hi" . "ho";
// Also not allowed:
echo "hi"
    ."there"
    ."how"
    ."are"
    ."you?";

Strings must not be concatenated when they could be written as one string.

error:

If true, an error will be reported; otherwise a warning.

Generic - VersionControl

Sniffs related to version control

SubversionProperties

Ensures expected subversion properties exist on files. By default the expected properties are svn:keywords and svn:eol-style.

Generic - WhiteSpace

Sniffs related whitespace usage for structuring source files.

DisallowTabIndent

Example

      
if($x == 1) {
TAB something();
}

Spaces, not tabs, must be used for indentation.

ScopeIndent

Example

      
if($x == 1) {
        echo "hi"; // should be 4 spaces not 8!
}
if($x == 1) {
    if($y == 2) {
      echo "hi"; // should be 8 spaces not 6!
    }
}

Checks that control structures are structured correctly and their content is indented correctly. This sniff will throw errors if tabs are used for indentation rather than spaces.

indent:

The number of spaces code should be indented.

exact:

Does the indent need to be exactly right? If TRUE, indent needs to be exactly $ident spaces. If FALSE indent needs to be at least $ident spaces (but can be more)

DisallowSpaceIndent

Tabs, not spaces, must be used for indentation.

MySource - PHP

Sniffs related to basic PHP usage

EvalObjectFactory

Example

      
// Forbidden
$class = "...";
$args = "1, 'string', 'dynamicBuildingArgs'";
eval("$x = new $bar($args)");
// Use
$x = new $bar($arg1, $arg2); // No eval
// Or use Reflection
$x = new ReflectionClass($bar);
$args = array(1, 'string', 'dynamicBuildingArgs');
$x->newInstanceArgs($args);

Ensures that eval() is not used to create objects.

GetRequestData

Example

      
class foo {
    function bar() {
        $x = $_GET['hi']; // Forbidden!
    }
}

Disallows the direct usage of $_REQUEST, $_GET, $_POST and $_FILES. It's only allowed in a class called "Security" in a function called "getRequestData". The Sniff is very specific and not useful in general but it can be used as template sniff for your own take on it. If you are using a request object instantiated in your bootstrap or a external lib then this sniff will also work for you.

ReturnFunctionValue

Example

      
// Forbidden
function bar() {
    return foo();
}
// Allowed
function bar() {
    $x = foo();
    return $x;
}

Warns when function values are returned directly. The Sniff enforces that the result of a function call should be assigned to a variable before being returned.

AjaxNullComparison

Functions with an @api annotation may not make null comparisons but have to use empty()

PEAR - Classes

PEAR coding standard sniffs related to classes

ClassDeclaration

Example

      
<?php
class Foo_Bar
{

    //... code goes here

}
?>

Classes must have their opening brace on a new line and must indeted by $indent spaces. http://pear.php.net/manual/en/standards.classdef.php

indent:

The number of spaces code should be indented

PEAR - Commenting

Sniffs related to how PEAR thinks structures should be commented.

ClassComment

Example

      
Rules:
- A doc comment must exist.
- There has to be a blank newline after the short description.
- There has to be a blank newline between the long and short description.
- There has to be a blank newline between the long description and tags.
- The tags have to appear in the following order. A question mark denotes optional tags:
  @category, @package, @subpackage?, @author, @copyright?,
  @license?, @version, @link, @see?, @since?, @deprecated?
- Check the indentation of each tag.
- Check required and optional tags and the format of their content.

/**
 * Sample class short comment
 *
 * Sample long desc
 *
 * @category  Something
 * @package   MyPackage
 * @author    name
 * @copyright something
 * @license   BSD Licence
 * @version
 * @link      url
 */
 class TheCommentedClass {
 }

Enforces class comments and their format. For a detailed rule description check the example section.

FileComment

Example

      
Rules:
- A doc comment must exist.
- There has to be a blank newline after the short description.
- There has to be a blank newline between the long and short description.
- There has to be a blank newline between the long description and tags.
- A PHP version must be specified.
- The tags have to appear in the following order. A question mark denotes optional tags:
  @category, @package, @subpackage?, @author, @copyright?,
  @license?, @version, @link, @see?, @since?, @deprecated?
- Check the indentation of each tag.
- Check required and optional tags and the format of their content.

/**
 * Sample file short comment
 *
 * Sample long desc
 *
 * PHP Version: 1.2.3
 *
 * @category  Something
 * @package   MyPackage
 * @author    name
 * @copyright something
 * @license   BSD Licence
 * @version
 * @link      url
 */

/**
 * // class docs
 */
class MyClass {
}

Enforces file comments and their format. For a detailed rule description check the example section.

FunctionComment

Example

      
Rules:
- A comment must exist
- There must be a blank newline after the short description.
- There must be a blank newline between the long and short description.
- There must be a blank newline between the long description and tags.
- Parameter names must represent those in the method.
- Parameter comments must be in the correct order
- Parameter comments must be complete
- A space must be present before the first and after the last parameter
- A return type tag must exists
- There must be one blank line between body and headline comments
- Any throw tag must have an exception class.

Enforces function comments and their format. For a detailed rule description check the example section.

InlineComment

Example

      
function foo {
    # Invalid comment
    // Valid comment
    /* Also valid */
}

Checks that no perl-style comments (#) are used.

PEAR - ControlStructures

Sniffs related to control structures

ControlSignature

Example

      
do {EOL...} while (...);EOL

while (...) {EOL

for (...) {EOL

if (...) {EOL

foreach (...) {EOL

} else if (...) {EOL

} elseif (...) {EOL

} else {EOL

do {EOL'

Enforces show control signatures are spaced. See the examples. Also a great base class to easily specify ow you want your own signatures to be spaced.

ignoreComments:

If true, comments will be ignored if they are found in the code.

MultiLineCondition

Example

      
if (($condition1
    || $condition2)
    && $condition3
    && $condition4
    && $condition5
) {
}

Closing parenthesis of a multi-line IF statement must be on a new line, each line must begin with a boolean operator and there must be a single space between the closing parenthesis and the opening brace.

PEAR - Files

Sniffs related to how file inclusion works in PEAR.

IncludingFile

Example

      
// These are statements and should not have brackets.
require_once('blank.inc');
require('blank.inc');

// Conditionally including a class file: use include_once
if ($test) {
    require_once 'blank.inc';
    require 'blank.inc';
}

// Unconditionally including a class file: use require_once
include_once 'blank.inc';
include 'blank.inc';

// These are ok
if ($test) {
    include_once 'blank.inc';
    include 'blank.inc';
}

Checks that the include_once is used in conditional situations, and require_once is used elsewhere. Also checks that brackets do not surround the file being included.

PEAR - Formatting

Sniffs related to how code should be formatted.

MultiLineAssignment

Example

      
// Valid
$GLOBALS['TSFE']->additionalHeaderData[$this->strApplicationName]
    = $this->xajax->getJavascript(t3lib_extMgm::siteRelPath('nr_xajax'));

// Invalid, wrong indention depth
$GLOBALS['TSFE']->additionalHeaderData[$this->strApplicationName]
     = $this->xajax->getJavascript(t3lib_extMgm::siteRelPath('nr_xajax'));

// Invalid, wrong indention depth
$GLOBALS['TSFE']->additionalHeaderData[$this->strApplicationName]
   = $this->xajax->getJavascript(t3lib_extMgm::siteRelPath('nr_xajax'));

// Invalid, equals sign needs to be on the next line
$GLOBALS['TSFE']->additionalHeaderData[$this->strApplicationName] =
    $this->xajax->getJavascript(t3lib_extMgm::siteRelPath('nr_xajax'));

Assignment that spawn two lines must have their equal sign indented and on the new line

PEAR - Functions

Sniffs related to functions calling and declarations.

FunctionCallSignature

Example

      
// Valid
test($arg, $arg2);
// All invalid
test ();
test( );
test() ;
test( $arg);
test( $arg );
test ( $arg );

// No error for multi line calls
test(
    $a,
    $b
);

// Heredocs dont need to be indented.
test(
<<<EOH
Anyone want to recomment parse errors?

EOH
);

Enforces function call signatures "foo($a, $b, $c)" style reporting all other whitespaces.

indent:

The number of spaces code should be indented.

allowMultipleArguments:

If TRUE, multiple arguments can be defined per line in a multi-line call.

FunctionDeclaration

Example

      
// Valid examples:
function foo($a, $b, $c);

function test(
    $a,
    $b
) {
}

function &testFunction($arg1,
    $arg2,
) {
}

function validateUrl(
    $url,
    $requireScheme=TRUE,
    array $allowedSchemes=array(
                           'http',
                           'https',
                          )
) {
}

Enforces single and multi-line function declarations to defined correctly. Single line declarations follow the Generic BSD-Allman brace sniff. For multi line declarations see the example.

ValidDefaultValue

Example

      
// Valid
function myFunction($arg1, $arg2='hello')
{
}
// Invalid
function myFunction($arg2='hello', $arg1)
{
}

Ensure that parameters defined for a function that have a default value come at the end of the function signature.

PEAR - NamingConventions

Sniffs related to PEAR naming conventions

ValidClassName

Example

      
class VALID_Name {}

class Valid_Name {}

class ValidName {}

class Invalid_name {} // N needs to be uppercase

class invalid_name {}

Class and interface names must start with a capital letter for each part of the name, separated by underscores.

ValidFunctionName

Example

      
//Valid
public function abc() {}
private function _test() {}

//Invalid
public function _abc() {}
private function test() {}

Protected and private functions must start with an underscore. Public functions may not start with an underscore.

ValidVariableName

Example

      
// Valid
private $_foo;
public $bar;

//Invalid
private $foo;
public $_bar;

Private members must have an underscore in front, public members must not.

PEAR - WhiteSpace

Sniffs related to white space and indention in PEAR.

ObjectOperatorIndent

Example

      
$object
    ->setBar($foo)
    ->setFoo($bar);

Object operators must be indented 4 spaces if they are the first thing on a line.

indent:

The number of spaces code should be indented.

ScopeClosingBrace

Example

      
class Test
{
    public function __construct()
    {
    }

    public function test1()
    {
    }

    public function test2()
    {
    }

    private function test3()
    {
    }

}

Closing braces of scopes must be aligned correctly. See the example.

indent:

The number of spaces code should be indented.

ScopeIndent

Example

      
//Valid indentions

/**
 * This is a comment 1.
 * This is a comment 2.
 * This is a comment 3.
 * This is a comment 4.
 */
public function close()
{
    // All ok.
    if (TRUE) {
        if (TRUE) {
        } else if (FALSE) {
            foreach ($tokens as $token) {
                switch ($token) {
                case '1':
                case '2':
                    if (true) {
                        if (false) {
                            if (false) {
                                if (false) {
                                    echo 'hello';
                                }
                            }
                        }
                    }
                break;
                case '5':
                    break;
                }
                do {
                    while (true) {
                        foreach ($tokens as $token) {
                            for ($i = 0; $i < $token; $i++) {
                                echo 'hello';
                            }
                        }
                    }
                } while (true);
            }
        }
    }
}

Checks that control structures are structured correctly, and their content is indented correctly. See the example for details.

PHPUnitStandard - Testing

A coding standard for PHPUnit tests written and mainted by @elblinkin. You will need to install an addition pear package in order to use these Sniffs! See: https://github.com/elblinkin/PHPUnit-CodeSniffer

AllowedFunctionOverride

Example

      
class FooTest extends PHPUnit_Framework_TestCase {
    protected function setUp() {
        // ok
    }

    protected function somethingSomethingTestHelper() {
        // not allowed
    }

}

Only a certain set of protected functions are allowed to be overriden

ClassName

Example

      
// File: project/tests/phpunit/foo/bar/BazTest.php
// Should contain:
class Foo_Bar_BazTest {

}

Class names should match the path within the unit test folder. The folder is currently */tests/phpunit/* and this is not configurable so use only if that convention applies to your project.

ExtraneousClass

Example

      
project/tests/phpunit/foo/bar/BazTest.php // ok
project/tests/otherTool/but/by/accident/containts/a/phpunit/testcase.php // Not ok

Tests are expected to reside somewhere in */tests/phpunit/*. This is not the official PHPUnit recommendation and for now the path is not configurable.

FileNameSuffix

Example

      
project/tests/unit/FooTest.php // ok
project/tests/unit/BarTes.php // not ok!

suffix:

The suffix all PHPUnit test case files should have.

NoInterfaces

No Interfaces may be defined in test cases

NoOutputFunctions

Example

      
class FooTest {
    public function testBar() {
        $this->expectedOutputString('string(3) "foo"');
        var_dump("foo"); // No! Use assertions for compairing!
    }

}

Tests may not contain output functions

NoOutputStatements

Example

      
class FooTest {
    public function testBar() {
        $this->expectedOutputString('foo');
        echo "foo"; // No! Use assertions for compairing!
    }

}

Tests may not contain output statements

NoPrivateMethods

Tests may not have private helper methods. See: http://elblinkin.info/2011/11/an-example-avoid-private-functions-in-unit-tests/

NoReflection

Example

      
class FooTest extends PHPUnit_Framework_TestCase {
    public function testPrivateMethod() {
        $method = new ReflectionMethod( // No! Testing private methods is not allowed!
          'Foo',
          'doSomethingPrivate'
        );
        $method->setAccessible(TRUE);

        $x = new Foo();
        $this->assertEquals(
          'blah',
          $x->doSomethingPrivate();
        );
    }
}

Tests may not use reflection functionality.

ProvenTestCase

Only the default set of PHPUnit test case classes may be used when extending. You can't have your own base classes or you need to extend the test and whitelist them.

TestOrProviderFunctionsOnly

Test cases may only consist of test and data provider functions. No helper methods are allowed. See: http://elblinkin.info/2011/11/an-example-avoid-private-functions-in-unit-tests/

TestOrProviderIsPublic

Example

      
protected function testImportantBehavior() {
    // Will not get executed because it is not public
}

/**
 * @dataProvider provideDataForTest
 */
public function testSomething($a, $b) {

}

protected function provideDataForTest() {
    // Test will fail as there is no executable data provider method
}

Test cases and data providers have to be public. This allows you to find tests that wouldn't get executed by mistake.

UnusedProvider

Data providers must be used at least once. This allows you to find unused code.

ValidFunctionName

Test functions may only start with "test" or "provider" and contain one underscore at most and have to be camelCaps.

PSR1 - Classes

PSR1 class rules

ClassDeclaration

Example

      
// Forbidden
class Foo {

}
class Bar {

}
// Allowed:

// Foo.php
namespace \my\vendor;
class Foo {

}

// Bar.php
namespace \my\vendor;
class Bar {

}

Each class must be in a file by itself and must be in a namespace of at least one level depth.

PSR1 - Files

PSR1 file rules

SideEffects

Example

      
// Forbidden

if (!defined(FOO)) {
  die(1);
}

class Foo {

  // ...

}

Ensures a file declare new symbols and causes no other side effects, or executes logic with side effects, but not both.

PSR2 - Classes

PSR2 class rules

ClassDeclaration

Example

        
- 1 space between keywords
- 1 space after class name
- The keyword must be on the same line as the class name
- Only one interface may be specified per line in a multi-line implements declaration
- The closing braces for interface methods must go on the next line after the body
- Closing brace must be on a line by itself

Check that the class declaration adheres to all PSR2 rules

PropertyDeclaration

Example

      
- Property names should not be prefixed with an underscore to indicate visibility
- The var keyword must not be used to declare a property
- There must not be more than one property declared per statement
- Visibility must be declared on all properties

Check that the property declaration adheres to all PSR2 rules

PSR2 - ControlStructures

PSR2 control structures rules

ControlStructureSpacing

Example

      
- 0 spaces after opening bracket
- 0 spaces before closing bracket

Checks that control structures have PSR2 style spacing around brackets

ElseIfDeclaration

Example

      
// Forbidden
if ($x) {
    // ...
} else if ($y) {
    // ...
}
// Allowed
if ($x) {
    // ...
} elseif ($y) {
    // ...
}

Verifies that there are no else if statements. Elseif should be used instead

SwitchDeclaration

Example

      
- Keywords must be lowercase
- Keywords must be indented $indent spaces from SWITCH keyword
- CASE keyword must be followed by a single space
- There must be no space before the colon in a case statement
- Statements must not be defined using curly braces
- Terminating statement must be indented to the same level as the CASE body
- There must be a comment when fall-through is intentional in a non-empty case body

Ensures that switch statements are defined according to PSR2

indent:

The number of spaces code should be indented

PSR2 - Files

PSR2 file rules

EndFileNewline

Example

      
// Forbidden
// ---------
<?php
  //...
?>EOL

// Allowed
// -------
<?php
  //...
>?\n
EOL

Ensures the file ends with a newline character

PSR2 - Methods

PSR2 method rules

MethodDeclaration

Example

      
- Method name should not be prefixed with an underscore to indicate visibility
- The static declaration must come after the visibility declaration
- The final declaration must precede the visibility declaration
- The abstract declaration must precede the visibility declaration

Check that the method declaration adheres to all PSR2 rules

PSR2 - Namespaces

PSR2 method rules

NamespaceDeclaration

Example

      
// Forbidden
<?php
namespace foo\bar;
class x {
}
// Allowed
<?php
namespace foo\bar;

class x {
}

There must be one blank line after the namespace declaration

UseDeclaration

Example

      
- There must be one USE keyword per declaration
- USE declarations must go after the first namespace declaration
- There must be one blank line after the last USE statement

Ensures USE blocks are declared according to PSR2

Squiz - Files

Squiz coding standard releated to files

FileExtension

Enforces class and interfaces to be in ".inc" files while everything else should go into ".php" files.

Squiz - PHP

Squiz coding standard related to PHP usage

CommentedOutCode

Try to ensure that there is no commented out code

maxPercentage:

If a comment is more than $value percent code, a warning will be shown.

DisallowComparisonAssignment

Example

      
// Forbidden
$var = !$foo;
$var = ($foo || $bar);
$var = ($foo === TRUE);
$var = ($foo === TRUE
        || $bar === FALSE);
$var = (!$foo);

Ensures that the value of a comparison is not assigned to a variable

DisallowInlineIf

Example

      
// Forbidden
$x = $y ? 1 : 2;

Ensures no inline if statements are used

DisallowMultipleAssignments

Example

      
      // Forbidden
$x = $y = 4;
if($x = 5) {}
// Allowed
$x = 4;
$y = $x;
if($x == 5) {}

Ensures that there is only one value assignment on a line, and that it is the first thing on the line.

DisallowObEndFlush

Example

      
// Forbidden
echo "foo";
ob_end_flush();
// Allowed
$output = ob_get_contents();
ob_end_clean();

Ensures that the ob_end_flush function is not used

DisallowSizeFunctionsInLoops

Example

      
// Forbidden
for($i = 0; $i < count($i); ++$i) {

}
// Allowed
$amountOfElements = count($i);
for($i = 0; $i < $amountOfElements; ++$i) {

}

Ensures no size-based functions are used in loop conditions to avoid unneccarry function calls

DiscouragedFunctions

Ensures that there are no `error_log` and `print_r` function calls. The Sniff can be extended used to disallow any function

error:

If true, an error will be thrown; otherwise a warning.

EmbeddedPhp

Example

      
// Forbidden
<?php echo "hi"; ?>
// Allowed
<?php
echo "hi";
?>
// Also forbidden
<?php

echo "hi";
?>

Ensures an style for the indentation of embedded PHP code segments. - No empty embedded tags - No blank lines after the opening tag of the embedded code - No blank lines before the closing tag of the embedded code - Opening tag must be on a new line by its self - Closing tag must be on a line by itself - Indenting inside the php tags

Eval

Warns about usage for the eval() function

ForbiddenFunctions

Example

      
// Forbidden functions
sizeof
delete
print
is_null
create_function

Discourages the use of alias functions that are kept in PHP for compatibility with older versions. Can be subclassed to forbid the use of any function and suggest alternatives.

GlobalKeyword

Example

      
// Forbidden
function bar() {
    global $foo;
}

Ensures that the "global" keyword isn't used.

Heredoc

Example

      
// Forbidden
$x = <<<BAR
    asdf
    jkl;
    BAR;
// Allowed
$x = 'asdf' . PHP_EOL . 'jkl;'

Ensures that no Heredoc statements are used.

InnerFunctions

Example

      
// Forbidden
function bar() {
    function foo() {

    }
}

Ensures that there are no function definitions inside of functions. Closure are ok.

LowercasePHPFunctions

Example

      
      // Forbidden
      Array_Map(...);
      array_Map(...);
      array_maP(...);
      Array_map(...);
      // Allowed
      array_map(...);

Ensures all calls to builtin PHP functions are lowercase.

NonExecutableCode

Example

      
      // Forbidden
      function foo() {
          echo "Hallo";
          return;
          echo "World"; // Dead code
      }

Warns about code that can never been executed. This happens when a function returns before the code, or a break ends execution of a statement etc.

Squiz - Scope

Squiz coding standard related to scoping

MemberVarScope

Example

      
// Forbidden
class foo {
    var $x = 1;
}
// Allowed
class foo {
    public $a = 1;
    protected $b = 2;
    private $c = 3;
}

Ensures that class members have scope modifiers

MethodScope

Example

      
// Forbidden
class foo {
    function bar() {
    }
}
// Allowed
class foo {
    public function bar() {
    }
    protected function baz() {
    }
    private fuction bak() {
    }
}

Ensures that methods have scope modifiers

StaticThisUsage

Example

      
// Forbidden
class foo {
    public static function bar() {
        $this->isNotWorking();
    }
}
// Allowed
class foo {
    public function bar() {
        $this->isWorking();
    }
    public static function baz() {
        self::isAlsoWorking();
    }
}

Ensures that $this is not used in static methods to avoid runtime errors

Squiz - WhiteSpace

Squiz coding standard sniffs related whitespace usage for structuring source files. The sniffs are general and can be widely used.

CastSpacing

Example

      
// Forbidden
$x = ( array)"foo";
$x = (array )"foo";
// Allowed
$x = (array)"foo";

Ensure cast statements dont contain whitespace.

ControlStructureSpacing

Example

      
// No spaces after opening bracket and no spaces before closing bracket
// No blank lines at the start or the end of a control structure

Ensures that control structures have a certain style of spacing around brackets. For other spacing styles there is the possibility of extending PHP_CodeSniffer_Standards_AbstractPatternSniff.

FunctionClosingBraceSpace

Checks that there is one empty line before the closing brace of a function but zero before the closing the brace of nested functions.

FunctionOpeningBraceSpace

Checks that there are no blank lines after a functions opening brace and that opening braces are on the new line.

FunctionSpacing

Example

      
class foo {


    public function bar() {

    }


    public function baz() {

    }
    
    
}

Checks the separation between methods in a class or interface. Methods are expected to have two blank lines between them.

spacing:

The number of blank lines between functions

LanguageConstructSpacing

Example

      
// Forbidden
echo"hi";
echo   "hi";
$x = new   StdClass();
// Allowed
echo "hi";
$x = new StdClass();

Ensures all language constructs (without brackets) contain a single space between themselves and their content.

LogicalOperatorSpacing

Example

      
// Forbidden
if($x&& $y) {}
if($x &&$y) {}
if($x &&   $y) {}
if($x   && $y) {}
// Allowed
if($x && $y) {}

Ensures that there is one space before and after a logical operator.

MemberVarSpacing

Example

      
// Forbidden
class foo {
    private $foo;
    private $bar;
}
// Allowed
class foo {
    private $foo;

    private $bar;
}
// Also allowed
class foo {
    private $foo;

    /**
     * @var string
     */
    private $bar;
}

Ensures that there is one blank lines between each member declaration

ObjectOperatorSpacing

Example

      
// Forbidden
$x = new StdClass();
$x -> foo = 1;
// Allowed
$x = new StdClass();
$x->foo = 1;
echo "foo";

Ensures there is no whitespace before a ObjectOperator ( -> )

OperatorSpacing

Example

      
// Forbidden
$x = $a&$b;
$x=$y;
$x=& $y;
// Allowed
$x = $a & $b;
$x = $y;
$x =& $y;

Ensures that operators have one space surrounding them.

PropertyLabelSpacing

Example

      
// Forbidden
x = {
    a:  'x',
    b : 1,
    c :  2,
    }
// Allowed
x = {
    a: 'x',
    b:  1,
    c: 2,
}

Javascript: Ensures that the colon in a property or label definition has a single space after it and no space before it.

ScopeClosingBrace

Example

      
// Forbidden
function foo() {
   }
function foo() {
    echo "bar"; }
// Allowed
function foo() {
}

Ensures that the closing braces of scopes are on a new line and indented correctly.

ScopeKeywordSpacing

Example

      
// Forbidden
public    function
protected  function
// Allowed
public function
protected function

Ensure there is a single space after scope keywords.

SemicolonSpacing

Example

      
// Forbidden
$x = 1  ;
echo "foo" ;
// Allowed
$x = 1;
echo "foo";

Ensures that there is no whitespace before a semicolon.

SuperfluousWhitespace

Example

      
Checks that no whitespace proceeds the first content of the file, exists after the last content of the file, resides after content on any line, or are two empty lines in functions.

Checks that no whitespace proceeds the first content of the file, exists after the last content of the file, resides after content on any line, or are two empty lines in functions.

ignoreBlankLines:

If TRUE, whitespace rules are not checked for blank lines

Zend - Debug

Zend Studio (The IDE) related sniffs

CodeAnalyzer

Runs the Zend Code Analyzer (from Zend Studio) on the file. No clue what that does but there should be docs for that.

Zend - Files

Sniffs related to files

ClosingTag

Example

      
// Valid
<html>...
<?php
echo "hi!";
?>
...</html>

// Invalid
<?php

class Foo {

}
?> // End of file here

Files must not have closing tags to avoid whitespace issues

Zend - NamingConventions

Zend Framework variable naming conventions

ValidVariableName

Example

      
// Valid
$varName  = 'hello';
$varname  = 'hello';

class MyClass
{
    $varName  = 'hello';
    // This is ok as ZF uses it to denote private vars
    $_varName = 'hello';
}

// Invalid
$var_name = 'hello';

class MyClass
{
    $var_name = 'hello';
}


// Discouraged
$varname2 = 'hello';

class MyClass
{
    $varName2 = 'hello';
}

Variables have to be camel case and should not contain numbers