Shared coding conventions make it possible for a team to collaborate efficiently. This rule raises issues for failures to comply with formatting
standard. The default parameter values conform to the PSR2 standard.
Noncompliant Code Example
With the default PSR2 parameter values:
use FooClass; // Noncompliant; the "use" declaration should be placed after the "namespace" declaration
namespace Vendor\Package;
use FooClass; // Noncompliant; the "namespace" declaration should be followed by a blank line
$foo = 1; // Noncompliant; the "use" declaration should be followed by a blank line
class ClassA { // Noncompliant; an open curly brace should be at the beginning of a new line for classes and functions
function my_function(){ // Noncompliant; curly brace on wrong line
if ($firstThing) // Noncompliant; an open curly brace should be at the end of line for a control structure
{
...
}
if ($secondThing) { // Noncompliant; there should be exactly one space between the closing parenthesis and the opening curly brace
...
}
if($thirdThing) { // Noncompliant; there should be exactly one space between the control structure keyword and the opening parenthesis
...
}
else { // Noncompliant; the close curly brace and the next "else" (or "catch" or "finally") keyword should be located on the same line
...
}
try{ // Noncompliant; there should be exactly one space between the control structure keyword and the curly brace
...
} catch (Exception $e) {
}
analyse( $fruit ) ; // Noncompliant; there should not be any space after the opening parenthesis and before the closing parenthesis
for ($i = 0;$i < 10; $i++) { // Nomcompliant; there should be exactly one space after each ";" in the {{for}} statement
...
}
pressJuice($apply ,$orange); // Noncompliant; the comma should be followed by one space and not preceded by any
do_something (); // Noncompliant; there should not be any space after the method name
foreach ($fruits as $fruit_key => $fruit) { // Noncompliant; in the foreach statement there should be one space before and after "as" keyword and "=>" operator
...
}
}
}
class ClassB
extends ParentClass // Noncompliant; the class name and the "extends" / "implements" keyword should be on the same line
{
...
}
class ClassC extends ParentClass implements \ArrayAccess, \Countable,
\Serializable // Noncompliant; the list of implemented interfaces should be correctly indented
{
public function aVeryLongMethodName(ClassTypeHint $arg1, // Noncompliant; the arguments in a method declaration should be correctly indented
&$arg2, array $arg3 = []) {
$noArgs_longVars = function () use ($longVar1, // Noncompliant; the arguments in a function declaration should be correctly indented
$longerVar2,
$muchLongerVar3
) {
...
};
$foo->bar($longArgument, // Noncompliant; the arguments in a method call should be correctly indented
$longerArgument,
$muchLongerArgument); // Noncompliant; the closing parenthesis should be placed on the next line
$closureWithArgsAndVars = function($arg1, $arg2)use ($var1, $var2) { // Noncompliant; the closure declaration should be correctly spaced - see (5)
...
};
}
}
Compliant Solution
namespace Vendor\Package; // Compliant; the "namespace" declaration is followed by a blank line
use FooClass; // Compliant; the "use" declaration is placed after the "namespace" declaration
// Compliant; the "use" declaration is followed by a blank line
$foo = 1;
class ClassA
{ // Compliant; the open curly brace is at the beginning of a new line for the class
function my_function()
{ // Compliant; the open curly brace is at the beginning of a new line for the function
if ($firstThing) { // Compliant; the open curly brace is at the end of line for the control structure
...
}
if ($secondThing) { // Compliant; there is exactly one space between the closing parenthesis and the opening curly brace
...
}
if ($thirdThing) { // Compliant; there is exactly one space between the control structure keyword and the opening parenthesis
...
} else { // Compliant; the close curly brace and the next "else" (or "catch" or "finally") keyword are located on the same line
...
}
try { // Compliant; there is exactly one space between the control structure keyword and the curly brace
...
} catch (Exception $e) {
...
}
analyse($fruit); // Compliant: there is no space after the opening parenthesis, nor before the closing parenthesis
for ($i = 0; $i < 10; $i++) { // Compliant: there is exactly one space after each ";" in the {{for}} statement
...
}
pressJuice($apply, $orange); // Compliant; the comma is followed by one space and is not preceded by any
do_something(); // Compliant; there is no space after the method name
foreach ($fruits as $fruit_key => $fruit) { // Compliant; in the foreach statement there is one space before and after "as" keyword and "=>" operator
...
}
}
}
/* The idea here is to make it obvious at first glance that a class extends
* some other classes and/or implements some interfaces. The names of
* extended classes or implemented interfaces can be located on subsequent lines.
*/
class ClassB1 extends ParentClass // Compliant; the class name and the "extends" (or "implements") keyword are located on the same line
{
...
}
class ClassB2 extends // Compliant; the class name and the "extends" (or "implements") keyword are located on the same line
ParentClass {
...
}
/* Lists of implements may be split across multiple lines, where each subsequent line
* is indented once. When doing so, the first item in the list should be on the next line,
* and there should be only one interface per line.
*/
class ClassC extends ParentClass implements
\ArrayAccess, // Compliant; the list of implemented interfaces is correctly indented
\Countable,
\Serializable
{
/* Argument lists may be split across multiple lines, where each subsequent line
* is indented once. When doing so, the first item in the list should be on the next line,
* and there should be only one argument per line. Also, when the argument list is
* split across multiple lines, the closing parenthesis and opening brace should be
* placed together on their own line with one space between them.
*/
public function aVeryLongMethodName(
ClassTypeHint $arg1, // Compliant; the arguments in a method/function declaration are correctly indented
&$arg2,
array $arg3 = []
) {
$noArgs_longVars = function () use (
$longVar1, // Compliant; the arguments in a method/function declaration are correctly indented
$longerVar2,
$muchLongerVar3
) {
...
};
/* Argument lists may be split across multiple lines, where each subsequent line is
* indented once. When doing so, the first item in the list should be on the next line,
* and there should be only one argument per line.
*/
$foo->bar(
$longArgument, // Compliant; the arguments in the method call are be correctly indented
$longerArgument,
$muchLongerArgument
); // Compliant; the closing parenthesis is placed on a separate line
/* Closures should be declared with a space after the "function" keyword,
* and a space before and after the "use" keyword.
*/
$closureWithArgsAndVars = function ($arg1, $arg2) use ($var1, $var2) { // Compliant; the closure declaration is correctly spaced
...
};
}
}
