Slevomat Coding Standard

https://github.com/slevomat/coding-standard
Admin
Slevomat Coding Standard is a PHP_CodeSniffer standard that provides hundreds of sniffs for...
Tokens:10,188
Snippets:184
Trust Score:9
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Project Dependencies

Source: https://github.com/slevomat/coding-standard/blob/master/README.md

Install project dependencies using Composer. This command should be run in the root directory of the repository.

```bash
composer install
```

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

### Configure JumpStatementsSpacing

Source: https://github.com/slevomat/coding-standard/blob/master/doc/control-structures.md

Example configuration for the JumpStatementsSpacing sniff to restrict checks to specific jump keywords.

```xml
<rule ref="SlevomatCodingStandard.ControlStructures.JumpStatementsSpacing">
	<properties>
		<property name="jumpStatements" type="array">
			<element value="continue"/>
			<element value="break"/>
		</property>
	</properties>
</rule>
```

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

### Allow use from root namespace

Source: https://github.com/slevomat/coding-standard/blob/master/doc/namespaces.md

Example of importing a class from the global namespace, which can be configured in UseOnlyWhitelistedNamespaces.

```php
use DateTimeImmutable;
```

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

### Alphabetically sorted use declarations

Source: https://github.com/slevomat/coding-standard/blob/master/doc/namespaces.md

Examples of correctly sorted use declarations using natural sorting and case-sensitive settings.

```php
use LogableTrait;
use LogAware;
use LogFactory;
use LoggerInterface;
use LogLevel;
use LogStandard;
```

```php
use LogAware;
use LogFactory;
use LogLevel;
use LogStandard;
use LogableTrait;
use LoggerInterface;
```

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

### Enforce Return Type Hint Spacing

Source: https://github.com/slevomat/coding-standard/blob/master/doc/type-hints.md

Example of the expected formatting for return type hints enforced by the ReturnTypeHintSpacing sniff.

```php
function foo(): ?int
```

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

### Fully qualified exception references

Source: https://github.com/slevomat/coding-standard/blob/master/doc/namespaces.md

Examples showing ambiguous exception catching versus the required fully qualified name approach.

```php
try {
	$this->foo();
} catch (Exception $e) {
	// Is this the general exception all exceptions must extend from? Or Exception from the current namespace?
}
```

```php
try {
	$this->foo();
} catch (\FooCurrentNamespace\Exception $e) {

} catch (\Exception $e) {

}
```

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

### Prohibit uses from the same namespace

Source: https://github.com/slevomat/coding-standard/blob/master/doc/namespaces.md

Example of a use statement that is redundant because it imports from the current namespace.

```php
namespace Foo;

use Foo\Bar;
```

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

### Configure TypeNameMatchesFileName Sniff

Source: https://github.com/slevomat/coding-standard/blob/master/doc/files.md

Example XML configuration for the TypeNameMatchesFileName sniff, defining root namespaces, skipped directories, and ignored namespaces.

```xml
<rule ref="SlevomatCodingStandard.Files.TypeNameMatchesFileName">
	<properties>
		<property name="rootNamespaces" type="array">
			<element key="app/ui" value="Slevomat\UI"/>
			<element key="app" value="Slevomat"/>
			<element key="build/SlevomatSniffs/Sniffs" value="SlevomatSniffs\Sniffs"/>
			<element key="tests/ui" value="Slevomat\UI"/>
			<element key="tests" value="Slevomat"/>
		</property>
		<property name="skipDirs" type="array">
			<element value="components"/>
			<element value="forms"/>
			<element value="model"/>
			<element value="models"/>
			<element value="services"/>
			<element value="stubs"/>
			<element value="data"/>
			<element value="new"/>
		</property>
		<property name="ignoredNamespaces" type="array">
			<element value="Slevomat\Services"/>
		</property>
	</properties>
</rule>
```

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

### Prohibit multiple uses per line

Source: https://github.com/slevomat/coding-standard/blob/master/doc/namespaces.md

Example of a prohibited use declaration format.

```php
use Foo, Bar;
```

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

### Configure AttributesOrder Sniff

Source: https://github.com/slevomat/coding-standard/blob/master/doc/attributes.md

Example configuration for the AttributesOrder sniff using an XML ruleset file to define the required order of attributes.

```xml
<rule ref="SlevomatCodingStandard.Attributes.AttributesOrder">
	<properties>
		<property name="order" type="array">
			<element value="ORM\Table"/>
			<element value="ORM\"/>
			<element value="One"/>
			<element value="Two"/>
		</property>
	</properties>
</rule>
```

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

### Configure Block Control Structure Spacing - XML

Source: https://github.com/slevomat/coding-standard/blob/master/doc/control-structures.md

Example configuration for BlockControlStructureSpacing to check only 'if' and 'switch' keywords with specific line counts before and after.

```xml
<rule ref="SlevomatCodingStandard.ControlStructures.BlockControlStructureSpacing">
	<properties>
		<property name="controlStructures" type="array">
			<element value="if"/>
			<element value="switch"/>
		</property>
	</properties>
</rule>
```

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

### Install Slevomat Coding Standard via Composer

Source: https://github.com/slevomat/coding-standard/blob/master/README.md

Add Slevomat Coding Standard to your project's development dependencies using Composer. Ensure you are using a compatible version.

```JSON
{
	"require-dev": {
		"slevomat/coding-standard": "~8.0"
	}
}
```

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

### Disallow leading backslash in use statement

Source: https://github.com/slevomat/coding-standard/blob/master/doc/namespaces.md

Example of a use statement that violates the UseDoesNotStartWithBackslash rule.

```php
use \Foo\Bar;
```

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

### Ignore Standalone If in Scope - PHP

Source: https://github.com/slevomat/coding-standard/blob/master/doc/control-structures.md

Example demonstrating an 'if' statement that is ignored by the EarlyExit sniff because it is standalone within its scope.

```php
foreach ($values as $value) {
	if ($value) {
		doSomething();
	}
}
```

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

### Nullable Type Hint for Null Default Value

Source: https://github.com/slevomat/coding-standard/blob/master/doc/type-hints.md

Example of a parameter missing the nullable type hint when assigned a null default value.

```php
function foo(
	int $foo = null, // ? missing
	?int $bar = null // correct
) {

}
```

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

### Reformat Trailing Multi-Line Ternary Operator - PHP

Source: https://github.com/slevomat/coding-standard/blob/master/doc/control-structures.md

Ensures that multi-line ternary operators are reformatted when the operator does not lead the line. The 'wrong' example shows the unformatted style, while the 'correct' example shows the preferred style.

```php
# wrong
$t = $someCondition ?
	$thenThis :
	$otherwiseThis;

# correct
$t = $someCondition
	? $thenThis
	: $otherwiseThis;
```

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

### Ignore Trailing If With One Instruction - PHP

Source: https://github.com/slevomat/coding-standard/blob/master/doc/control-structures.md

Example of an 'if' statement with a single instruction (including a closure) that is ignored by EarlyExit when it's the last statement in scope.

```php
foreach ($values as $value) {
	$value .= 'whatever';

	if ($value) {
		doSomething(function () {
			// Anything
		});
	}
}
```

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

### Ignore One Line Trailing If - PHP

Source: https://github.com/slevomat/coding-standard/blob/master/doc/control-structures.md

Example of an 'if' statement with a single line of content that is ignored by EarlyExit when it's the last statement in scope.

```php
foreach ($values as $value) {
	$value .= 'whatever';

	if ($value) {
		doSomething();
	}
}
```

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

### Run Phing Build Script

Source: https://github.com/slevomat/coding-standard/blob/master/README.md

Execute the Phing build script for tasks such as running tests and checks. This command should be run in the root directory of the repository.

```bash
bin/phing
```

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

### Create Custom Ruleset for Selected Sniffs

Source: https://github.com/slevomat/coding-standard/blob/master/README.md

Define a custom ruleset.xml to include only specific sniffs from Slevomat Coding Standard. This is the recommended approach for running selected sniffs.

```xml
<?xml version="1.0"?>
<ruleset name="AcmeProject">
	<config name="installed_paths" value="../../slevomat/coding-standard"/><!-- relative path from PHPCS source location -->
	<rule ref="SlevomatCodingStandard.Arrays.TrailingArrayComma"/>
	<!-- other sniffs to include -->
</ruleset>
```

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

### Run PHPCS with Custom Ruleset

Source: https://github.com/slevomat/coding-standard/blob/master/README.md

Execute the phpcs command with a custom ruleset.xml file to analyze code with only the specified sniffs.

```bash
vendor/bin/phpcs --standard=ruleset.xml --extensions=php --tab-width=4 -sp src tests
```

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

### Configure ClassStructure Sniff

Source: https://github.com/slevomat/coding-standard/blob/master/doc/classes.md

Define custom method groups and the order of class members using the ClassStructure rule configuration.

```xml
<rule ref="SlevomatCodingStandard.Classes.ClassStructure">
	<properties>
		<property name="methodGroups" type="array">
			<element key="inject method" value="inject"/>
			<element key="inject methods" value="inject*"/>
			<element key="phpunit before" value="setUp, @before, #PHPUnit\Framework\Attributes\Before"/>
			<element key="phpunit data provider" value="*DataProvider"/>
		</property>

		<property name="groups" type="array">
			<element value="uses"/>

			<element value="enum cases"/>

			<!-- Public constants are first, but you don't care about the order of protected or private constants -->
			<element value="public constants"/>
			<element value="constants"/>

			<!-- You don't care about the order among the properties. The same can be done with "properties" shortcut -->
			<element value="public properties, protected properties, private properties"/>

			<!-- Constructor is first -->
			<element value="constructor"/>

			<!-- Then inject method followed by all other inject methods based on their prefix using a custom method group regardless their visibility -->
			<element value="inject method"/>
			<element value="inject methods"/>

			<!-- PHPUnit's before hooks are placed before all other public methods using a custom method group -->
			<element value="phpunit before"/>

			<!-- Then all public methods, followed by protected/private methods -->
			<element value="all public methods"/>
			<element value="methods"/>

			<!-- PHPUnit's data providers are placed after all other public methods using a custom method group -->
			<element value="phpunit data provider"/>

			<!-- Magic methods are last -->
			<element value="magic methods"/>
		</property>
	</properties>
</rule>
```

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

### Configure allowed parameters for UnusedParameter sniff

Source: https://github.com/slevomat/coding-standard/blob/master/doc/functions.md

Use the allowedParameterPatterns setting to define regular expressions for parameters that are permitted to be unused.

```yaml
allowedParameterPatterns: [/^_/]
```

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

### Disallow Empty Function - PHP

Source: https://github.com/slevomat/coding-standard/blob/master/doc/control-structures.md

This sniff disallows the use of the empty() function.

```php
empty($variable)
```

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

### Exclude Sniffs by Referencing Standard

Source: https://github.com/slevomat/coding-standard/blob/master/README.md

An alternative method to exclude specific sniffs by referencing the main Slevomat Coding Standard ruleset and excluding sniffs within your project's ruleset.xml. This method is not recommended due to potential compatibility issues between minor versions.

```xml
<?xml version="1.0"?>
<ruleset name="AcmeProject">
	<rule ref="vendor/slevomat/coding-standard/SlevomatCodingStandard/ruleset.xml"><!-- relative path to your ruleset.xml -->
		<!-- sniffs to exclude -->
	</rule>
</ruleset>
```

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

### SlevomatCodingStandard.Operators.NegationOperatorSpacing

Source: https://github.com/slevomat/coding-standard/blob/master/doc/operators.md

This sniff checks for the correct number of spaces after the negation operator (!). It is configurable via the `spacesCount` setting.

```APIDOC
## SlevomatCodingStandard.Operators.NegationOperatorSpacing

### Description
Checks if there is the same number of spaces after negation operator as expected.

### Method
N/A (This is a coding standard rule, not an API endpoint)

### Endpoint
N/A

### Parameters
#### Configuration
* **spacesCount** (int) - The number of spaces expected after the negation operator.

### Request Example
N/A

### Response
N/A
```

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

### Configure DocComment Spacing with Annotation Groups

Source: https://github.com/slevomat/coding-standard/blob/master/doc/commenting.md

Use this XML configuration to enforce specific spacing rules within PHPDoc comments, including the order of annotation groups and lines between them. This overrides default spacing rules.

```xml
<rule ref="SlevomatCodingStandard.Commenting.DocCommentSpacing">
	<properties>
		<property name="annotationsGroups" type="array">
			<element value="
				@ORM\,
			"/>
			<element value="
				@var,
				@param,
				@return,
			"/>
		</property>
	</properties>
</rule>
```

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

### SlevomatCodingStandard.Operators.SpreadOperatorSpacing

Source: https://github.com/slevomat/coding-standard/blob/master/doc/operators.md

This sniff enforces a configurable number of spaces after the spread operator (...). It is configurable via the `spacesCountAfterOperator` setting.

```APIDOC
## SlevomatCodingStandard.Operators.SpreadOperatorSpacing

### Description
Enforces configurable number of spaces after the `...` operator.

### Method
N/A (This is a coding standard rule, not an API endpoint)

### Endpoint
N/A

### Parameters
#### Configuration
* **spacesCountAfterOperator** (int) - The number of spaces after the `...` operator.

### Request Example
N/A

### Response
N/A
```

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

### SlevomatCodingStandard.Operators.DisallowEqualOperators

Source: https://github.com/slevomat/coding-standard/blob/master/doc/operators.md

This sniff disallows the use of loose equality (==) and inequality (!=) operators, enforcing the use of strict equality (===) and inequality (!==) for better security and predictability.

```APIDOC
## SlevomatCodingStandard.Operators.DisallowEqualOperators

### Description
Disallows using loose `==` and `!=` comparison operators. Use `===` and `!==` instead, they are much more secure and predictable.

### Method
N/A (This is a coding standard rule, not an API endpoint)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### SlevomatCodingStandard.Arrays.MultiLineArrayEndBracketPlacement

Source: https://github.com/slevomat/coding-standard/blob/master/doc/arrays.md

Enforces consistent placement of the closing bracket for multi-line arrays.

```APIDOC
## SlevomatCodingStandard.Arrays.MultiLineArrayEndBracketPlacement

### Description
Enforces reasonable end bracket placement for multi-line arrays, contributing to code readability and consistency.

### Method
N/A (This is a coding standard sniff, not an API endpoint)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### SlevomatCodingStandard.Operators.RequireOnlyStandaloneIncrementAndDecrementOperators

Source: https://github.com/slevomat/coding-standard/blob/master/doc/operators.md

This sniff reports increment (++) and decrement (--) operators that are not used in a standalone manner.

```APIDOC
## SlevomatCodingStandard.Operators.RequireOnlyStandaloneIncrementAndDecrementOperators

### Description
Reports `++` and `--` operators not used standalone.

### Method
N/A (This is a coding standard rule, not an API endpoint)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### Detect unreachable catch blocks

Source: https://github.com/slevomat/coding-standard/blob/master/doc/exceptions.md

Identifies catch blocks that will never be executed due to the order of exception types.

```php
try {
	doStuff();
} catch (\Throwable $e) {
	log($e);
} catch (\InvalidArgumentException $e) {
	// unreachable!
}
```

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

### Configure ForbiddenClasses Sniff in phpcs.xml

Source: https://github.com/slevomat/coding-standard/blob/master/doc/php.md

Defines forbidden classes and traits within the phpcs.xml configuration file to restrict their usage.

```xml
<rule ref="SlevomatCodingStandard.PHP.ForbiddenClasses">
	<properties>
		<property name="forbiddenClasses" type="array">
			<element key="Validator" value="Illuminate\Support\Facades\Validator"/>
		</property>
		<property name="forbiddenTraits" type="array">
			<element key="\AuthTrait" value="null"/>
		</property>
	</properties>
</rule>
```

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

### SlevomatCodingStandard.Operators.DisallowIncrementAndDecrementOperators

Source: https://github.com/slevomat/coding-standard/blob/master/doc/operators.md

This sniff disallows the use of the increment (++) and decrement (--) operators.

```APIDOC
## SlevomatCodingStandard.Operators.DisallowIncrementAndDecrementOperators

### Description
Disallows using `++` and `--` operators.

### Method
N/A (This is a coding standard rule, not an API endpoint)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### SlevomatCodingStandard.Arrays.AlphabeticallySortedByKeys

Source: https://github.com/slevomat/coding-standard/blob/master/doc/arrays.md

Enforces natural sorting of array definitions by key in multi-line arrays to reduce merge conflicts and duplicate entries.

```APIDOC
## SlevomatCodingStandard.Arrays.AlphabeticallySortedByKeys

### Description
Arrays should be defined with keys in alphabetical order. This sniff enforces natural sorting of array definitions by key in multi-line arrays, which helps in defining where new entries should be inserted and reduces merge conflicts and duplicate entries.

### Method
N/A (This is a coding standard sniff, not an API endpoint)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### Fix Coding Standard Violations Automatically

Source: https://github.com/slevomat/coding-standard/blob/master/README.md

Use the phpcbf executable to automatically fix coding standard violations. Always back up your code before running this command.

```bash
vendor/bin/phpcbf --standard=ruleset.xml --extensions=php --tab-width=4 -sp src tests
```

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

### SlevomatCodingStandard.Arrays.DisallowImplicitArrayCreation

Source: https://github.com/slevomat/coding-standard/blob/master/doc/arrays.md

Disallows implicit array creation.

```APIDOC
## SlevomatCodingStandard.Arrays.DisallowImplicitArrayCreation

### Description
Disallows the creation of arrays using implicit methods, encouraging explicit array definition.

### Method
N/A (This is a coding standard sniff, not an API endpoint)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### Enforce class constant visibility

Source: https://github.com/slevomat/coding-standard/blob/master/doc/classes.md

Requires explicit visibility modifiers for all class constants. Fixability can be enabled via the 'fixable' setting.

```php
const FOO = 1; // visibility missing!
public const BAR = 2; // correct
```

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

### SlevomatCodingStandard.Arrays.DisallowPartiallyKeyed

Source: https://github.com/slevomat/coding-standard/blob/master/doc/arrays.md

Ensures that array keys are specified for either all values or none of the values in an array definition.

```APIDOC
## SlevomatCodingStandard.Arrays.DisallowPartiallyKeyed

### Description
An array must have keys specified for either all of its values or none of its values. This prevents mixed key types (numeric and string) in a way that could lead to confusion or unexpected behavior.

### Method
N/A (This is a coding standard sniff, not an API endpoint)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### Disallow Null Safe Object Operator - PHP

Source: https://github.com/slevomat/coding-standard/blob/master/doc/control-structures.md

This sniff disallows the use of the null safe object operator '?->'.

```php
$object?->method()
```

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

### SlevomatCodingStandard.Operators.RequireCombinedAssignmentOperator

Source: https://github.com/slevomat/coding-standard/blob/master/doc/operators.md

This sniff enforces the use of combined assignment operators (e.g., `+=`, `.=`) instead of separate assignment and operation.

```APIDOC
## SlevomatCodingStandard.Operators.RequireCombinedAssignmentOperator

### Description
Requires using combined assignment operators, eg `+=`, `.=` etc.

### Method
N/A (This is a coding standard rule, not an API endpoint)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### SlevomatCodingStandard.Arrays.SingleLineArrayWhitespace

Source: https://github.com/slevomat/coding-standard/blob/master/doc/arrays.md

Checks and enforces whitespace rules within single-line array declarations.

```APIDOC
## SlevomatCodingStandard.Arrays.SingleLineArrayWhitespace

### Description
Checks whitespace in single-line array declarations, including spaces around brackets and commas, to ensure consistent formatting.

### Method
N/A (This is a coding standard sniff, not an API endpoint)

### Endpoint
N/A

### Parameters
#### Query Parameters
- **spacesAroundBrackets** (int) - Optional - Number of spaces required around array brackets.
- **enableEmptyArrayCheck** (bool) - Optional - Enables check for empty arrays. Defaults to `false`.

### Request Example
N/A

### Response
N/A
```

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

### SlevomatCodingStandard.Arrays.ArrayAccess

Source: https://github.com/slevomat/coding-standard/blob/master/doc/arrays.md

Disallows whitespace between array access operator and the variable, or between array access operators.

```APIDOC
## SlevomatCodingStandard.Arrays.ArrayAccess

### Description
Disallows whitespace between the array access operator (`[]`) and the variable it is applied to, or between consecutive array access operators.

### Method
N/A (This is a coding standard sniff, not an API endpoint)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### Disallow Short Ternary Operator - PHP

Source: https://github.com/slevomat/coding-standard/blob/master/doc/control-structures.md

This sniff disallows the short ternary operator (?:). The 'fixable' option can be set to false to prevent automatic fixing.

```php
$variable ?: $defaultValue
```

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

### Ignore unused values in foreach

Source: https://github.com/slevomat/coding-standard/blob/master/doc/variables.md

Configures the UnusedVariable sniff to ignore unused $value variables when only the $key is utilized in a foreach loop.

```php
foreach ($values as $key => $value) {
	echo $key;
}
```

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

### Disallow Continue Without Integer Operand in Switch - PHP

Source: https://github.com/slevomat/coding-standard/blob/master/doc/control-structures.md

This sniff disallows the use of 'continue' without an integer operand within a switch statement, as it can lead to warnings in PHP 7.3+.

```php
continue;
```

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

### SlevomatCodingStandard.Arrays.TrailingArrayComma

Source: https://github.com/slevomat/coding-standard/blob/master/doc/arrays.md

Enforces the use of trailing commas in multi-line arrays for easier version control diffs and element addition.

```APIDOC
## SlevomatCodingStandard.Arrays.TrailingArrayComma

### Description
Ensures that commas are placed after the last element in multi-line arrays. This practice simplifies adding new elements and results in cleaner version control diffs.

### Method
N/A (This is a coding standard sniff, not an API endpoint)

### Endpoint
N/A

### Parameters
#### Query Parameters
- **enableAfterHeredoc** (bool) - Optional - Enables or disables trailing commas after HEREDOC/NOWDOC syntax. The default behavior is based on the PHP version.

### Request Example
N/A

### Response
N/A
```

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

### Suppress Specific Sniff Error Locally

Source: https://github.com/slevomat/coding-standard/blob/master/README.md

Suppress a specific coding standard error for a piece of code by using the @phpcsSuppress annotation with the error code. This is useful when automatic fixing is not desired or possible.

```php
/**
 * @phpcsSuppress SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint
 * @param int $max
 */
public function createProgressBar($max = 0): ProgressBar
{

}
```

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

### Disallow Assignments in Conditions - PHP

Source: https://github.com/slevomat/coding-standard/blob/master/doc/control-structures.md

Prevents assignments within if, elseif, and do-while loop conditions to avoid accidental comparisons. Assignment in while loop conditions is allowed.

```php
if ($file = findFile($path)) {

}
```

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

### Ignore Assignments Inside Function Calls - PHP

Source: https://github.com/slevomat/coding-standard/blob/master/doc/control-structures.md

This setting for AssignmentInCondition allows assignments within function calls, such as in the third parameter of in_array.

```php
if (in_array(1, $haystack, $strict = true)) {

}
```
Tokens:
Raw