pax_global_header00006660000000000000000000000064137401460050014512gustar00rootroot0000000000000052 comment=a91e70faeedea5a0b7a4feecb4c0ad8a886e5f17 coding-standard-0.1/000077500000000000000000000000001374014600500144135ustar00rootroot00000000000000coding-standard-0.1/.github/000077500000000000000000000000001374014600500157535ustar00rootroot00000000000000coding-standard-0.1/.github/workflows/000077500000000000000000000000001374014600500200105ustar00rootroot00000000000000coding-standard-0.1/.github/workflows/php.yml000066400000000000000000000013141374014600500213210ustar00rootroot00000000000000name: PHP on: push: branches: [ master ] pull_request: branches: [ master ] jobs: codestyle: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Setup PHP uses: shivammathur/setup-php@v2 with: php-version: '7.4' env: update: true - name: Validate composer.json and composer.lock run: composer validate - name: Install dependencies run: composer install --prefer-dist --no-progress --no-suggest - name: Install Coding Standard run: composer bin phpcs require --dev infinityloop-dev/coding-standard:dev-master - name: Codestyle run: composer run-script codestylecoding-standard-0.1/InfinityloopCodingStandard/000077500000000000000000000000001374014600500217035ustar00rootroot00000000000000coding-standard-0.1/InfinityloopCodingStandard/Sniffs/000077500000000000000000000000001374014600500231335ustar00rootroot00000000000000coding-standard-0.1/InfinityloopCodingStandard/Sniffs/Classes/000077500000000000000000000000001374014600500245305ustar00rootroot00000000000000coding-standard-0.1/InfinityloopCodingStandard/Sniffs/Classes/FinalClassVisibilitySniff.php000066400000000000000000000047541374014600500323300ustar00rootroot00000000000000getTokens(); if (\count($tokens[$variablePointer]['conditions']) === 0) { return; } $classPointer = \array_keys($tokens[$variablePointer]['conditions'])[\count($tokens[$variablePointer]['conditions']) - 1]; \assert(\is_int($classPointer)); if ($tokens[$classPointer]['code'] !== \T_CLASS) { return; } $classVisibilityPointer = TokenHelper::findPreviousEffective($phpcsFile, $classPointer - 1); if ($tokens[$classVisibilityPointer]['code'] !== \T_FINAL) { return; } $extendsPointer = $phpcsFile->findNext(\T_EXTENDS, $classPointer); if ($this->ignoreInheritingClasses && $tokens[$extendsPointer]['code'] === \T_EXTENDS) { return; } $visibilityPointer = $this->findVisibilityPointer($phpcsFile, $variablePointer); if ($visibilityPointer === null || $tokens[$visibilityPointer]['code'] !== \T_PROTECTED) { return; } $fix = $phpcsFile->addFixableError( 'Protected variables and functions inside final class are forbidden', $variablePointer, 'FinalClassVisibility', ); if (!$fix) { return; } $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken($visibilityPointer, 'private'); $phpcsFile->fixer->endChangeset(); } /** * @return int|bool|null */ private function findVisibilityPointer(\PHP_CodeSniffer\Files\File $phpcsFile, $variablePointer) { $visibilityPointer = $phpcsFile->findPrevious([\T_PUBLIC, \T_PROTECTED, \T_PRIVATE], $variablePointer); if (\in_array($phpcsFile->getTokens()[$visibilityPointer]['code'], [\T_PUBLIC, \T_PROTECTED, \T_PRIVATE], true)) { return $visibilityPointer; } return null; } } coding-standard-0.1/InfinityloopCodingStandard/Sniffs/ControlStructures/000077500000000000000000000000001374014600500266575ustar00rootroot00000000000000RequireMultiLineNullCoalesceSniff.php000066400000000000000000000100311374014600500360230ustar00rootroot00000000000000coding-standard-0.1/InfinityloopCodingStandard/Sniffs/ControlStructures */ public function register() : array { return [ \T_COALESCE, ]; } //@phpcs:ignore Squiz.Commenting.FunctionComment.ScalarTypeHintMissing public function process(\PHP_CodeSniffer\Files\File $phpcsFile, $coalescePointer) : void { $tokens = $phpcsFile->getTokens(); $variablePointer = TokenHelper::findPrevious($phpcsFile, \T_VARIABLE, $coalescePointer + 1); \assert(\is_int($variablePointer)); if ($tokens[$coalescePointer]['line'] !== $tokens[$variablePointer]['line']) { return; } $fix = $phpcsFile->addFixableError( 'Null coalesce operator should be reformatted to next line.', $coalescePointer, self::CODE_MULTI_LINE_NULL_COALESCE_OPERATOR_NOT_USED, ); if (!$fix) { return; } $endOfLineBeforeCoalescePointer = $this->getEndOfLineBefore($phpcsFile, $coalescePointer); $indentation = $this->getIndentation($phpcsFile, $endOfLineBeforeCoalescePointer); $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addContentBefore($coalescePointer, $phpcsFile->eolChar . $indentation); $phpcsFile->fixer->endChangeset(); } private function getEndOfLineBefore(\PHP_CodeSniffer\Files\File $phpcsFile, int $pointer) : int { $tokens = $phpcsFile->getTokens(); $endOfLineBefore = null; $startPointer = $pointer - 1; while (true) { $possibleEndOfLinePointer = TokenHelper::findPrevious( $phpcsFile, \array_merge([\T_WHITESPACE, \T_OPEN_TAG, \T_OPEN_TAG_WITH_ECHO], TokenHelper::$inlineCommentTokenCodes), $startPointer, ); if ( $tokens[$possibleEndOfLinePointer]['code'] === \T_WHITESPACE && $tokens[$possibleEndOfLinePointer]['content'] === $phpcsFile->eolChar ) { $endOfLineBefore = $possibleEndOfLinePointer; break; } if ($tokens[$possibleEndOfLinePointer]['code'] === \T_OPEN_TAG || $tokens[$possibleEndOfLinePointer]['code'] === \T_OPEN_TAG_WITH_ECHO) { $endOfLineBefore = $possibleEndOfLinePointer; break; } if ( \in_array($tokens[$possibleEndOfLinePointer]['code'], TokenHelper::$inlineCommentTokenCodes, true) && \substr($tokens[$possibleEndOfLinePointer]['content'], -1) === $phpcsFile->eolChar ) { $endOfLineBefore = $possibleEndOfLinePointer; break; } $startPointer = $possibleEndOfLinePointer - 1; } $endOfLineBefore = $endOfLineBefore; \assert(\is_int($endOfLineBefore)); return $endOfLineBefore; } private function getIndentation(\PHP_CodeSniffer\Files\File $phpcsFile, int $endOfLinePointer) : string { $pointerAfterWhitespace = TokenHelper::findNextExcluding($phpcsFile, \T_WHITESPACE, $endOfLinePointer + 1); $actualIndentation = TokenHelper::getContent($phpcsFile, $endOfLinePointer + 1, $pointerAfterWhitespace - 1); if (\strlen($actualIndentation) !== 0) { return $actualIndentation . (\substr($actualIndentation, -1) === self::TAB_INDENT ? self::TAB_INDENT : self::SPACES_INDENT); } $tabPointer = TokenHelper::findPreviousContent($phpcsFile, \T_WHITESPACE, self::TAB_INDENT, $endOfLinePointer - 1); return $tabPointer !== null ? self::TAB_INDENT : self::SPACES_INDENT; } } SwitchCommentSpacingSniff.php000066400000000000000000000177101374014600500343760ustar00rootroot00000000000000coding-standard-0.1/InfinityloopCodingStandard/Sniffs/ControlStructuresgetTokens(); if (isset($tokens[$stackPtr]['scope_opener']) === false || isset($tokens[$stackPtr]['scope_closer']) === false ) { return; } $switch = $tokens[$stackPtr]; $nextCase = $stackPtr; while (($nextCase = $this->findNextCase($phpcsFile, $nextCase + 1, $switch['scope_closer'])) !== false) { $opener = $tokens[$nextCase]['scope_opener']; $nextCloser = $tokens[$nextCase]['scope_closer']; $nextCode = $phpcsFile->findNext(\T_WHITESPACE, $opener + 1, $nextCloser, true); if ($tokens[$nextCode]['code'] === \T_CASE || $tokens[$nextCode]['code'] === \T_DEFAULT) { continue; } if ($tokens[$nextCode]['code'] === \T_COMMENT && $tokens[$nextCode]['line'] === $tokens[$nextCase]['line']) { $fix = $phpcsFile->addFixableError( 'Fallthrough comment has to be aligned to next line in case without body', $nextCase, self::CODE_SWITCH_COMMENT_INVALID_FORMAT, ); if ($fix) { $indentation = $this->getIndentation($phpcsFile, $this->getEndOfLineBefore($phpcsFile, $nextCase)); $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addContentBefore($nextCode, $phpcsFile->eolChar . $indentation); $phpcsFile->fixer->endChangeset(); } } if ($tokens[$nextCode]['code'] === \T_COMMENT) { continue; } $nextCode = $this->findNextCase($phpcsFile, $opener + 1, $nextCloser); $beforeEndOfCase = $phpcsFile->findPrevious(\T_WHITESPACE, ($nextCode === false ? $nextCloser : $nextCode) - 1, $nextCase, true); if ($tokens[$beforeEndOfCase]['code'] === \T_COMMENT && ($nextCode !== false || $tokens[$nextCloser]['code'] === \T_CLOSE_CURLY_BRACKET)) { $beforeEndOfCase2 = $phpcsFile->findPrevious(\T_WHITESPACE, $beforeEndOfCase - 1, $nextCase, true); $linesBetween = $tokens[$beforeEndOfCase]['line'] - $tokens[$beforeEndOfCase2]['line']; if ($linesBetween === 0 || $linesBetween === 1) { $fix = $phpcsFile->addFixableError( 'Expected one space between comment and last line of case\'s body', $beforeEndOfCase, self::CODE_SWITCH_COMMENT_INVALID_FORMAT, ); if ($fix) { $indentation = $this->getIndentation($phpcsFile, $this->getEndOfLineBefore($phpcsFile, $nextCase)); $phpcsFile->fixer->addContentBefore( $beforeEndOfCase, $linesBetween === 0 ? $phpcsFile->eolChar . $phpcsFile->eolChar . $indentation : $phpcsFile->eolChar . $indentation, ); $phpcsFile->fixer->endChangeset(); } } } if ($nextCode !== false || !\in_array($tokens[$nextCloser]['code'], [\T_BREAK, \T_CONTINUE, \T_RETURN], true)) { continue; } $nextComment = $phpcsFile->findNext(\T_COMMENT, $nextCloser, null); $linesBetween = $tokens[$nextCloser]['line'] - $tokens[$nextComment]['line']; if ($linesBetween !== 0 && $linesBetween !== 1) { continue; } $fix = $phpcsFile->addFixableError( 'Expected one space between comment and last line of case\'s body', $nextComment, self::CODE_SWITCH_COMMENT_INVALID_FORMAT, ); if (!$fix) { continue; } $indentation = $this->getIndentation($phpcsFile, $this->getEndOfLineBefore($phpcsFile, $opener)); $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addContentBefore( $nextComment, $linesBetween === 0 ? $phpcsFile->eolChar . $phpcsFile->eolChar . $indentation : $phpcsFile->eolChar . $indentation, ); $phpcsFile->fixer->endChangeset(); } } /** * @param \PHP_CodeSniffer\Files\File $phpcsFile * @param int|bool|null $stackPtr * @param int|null $end * @return bool|int */ private function findNextCase(\PHP_CodeSniffer\Files\File $phpcsFile, $stackPtr, ?int $end = null) { $tokens = $phpcsFile->getTokens(); while (($stackPtr = $phpcsFile->findNext([\T_CASE, \T_DEFAULT, \T_SWITCH], $stackPtr, $end)) !== false) { // Skip nested SWITCH statements; they are handled on their own. if ($tokens[$stackPtr]['code'] === \T_SWITCH) { $stackPtr = $tokens[$stackPtr]['scope_closer']; continue; } break; } return $stackPtr; } private function getEndOfLineBefore(\PHP_CodeSniffer\Files\File $phpcsFile, int $pointer) : int { $tokens = $phpcsFile->getTokens(); $endOfLineBefore = null; $startPointer = $pointer - 1; while (true) { $possibleEndOfLinePointer = TokenHelper::findPrevious( $phpcsFile, \array_merge([\T_WHITESPACE, \T_OPEN_TAG, \T_OPEN_TAG_WITH_ECHO], TokenHelper::$inlineCommentTokenCodes), $startPointer, ); if ( $tokens[$possibleEndOfLinePointer]['code'] === \T_WHITESPACE && $tokens[$possibleEndOfLinePointer]['content'] === $phpcsFile->eolChar ) { $endOfLineBefore = $possibleEndOfLinePointer; break; } if ($tokens[$possibleEndOfLinePointer]['code'] === \T_OPEN_TAG || $tokens[$possibleEndOfLinePointer]['code'] === \T_OPEN_TAG_WITH_ECHO) { $endOfLineBefore = $possibleEndOfLinePointer; break; } if ( \in_array($tokens[$possibleEndOfLinePointer]['code'], TokenHelper::$inlineCommentTokenCodes, true) && \substr($tokens[$possibleEndOfLinePointer]['content'], -1) === $phpcsFile->eolChar ) { $endOfLineBefore = $possibleEndOfLinePointer; break; } $startPointer = $possibleEndOfLinePointer - 1; } $endOfLineBefore = $endOfLineBefore; \assert(\is_int($endOfLineBefore)); return $endOfLineBefore; } private function getIndentation(\PHP_CodeSniffer\Files\File $phpcsFile, int $endOfLinePointer) : string { $pointerAfterWhitespace = TokenHelper::findNextExcluding($phpcsFile, \T_WHITESPACE, $endOfLinePointer + 1); $actualIndentation = TokenHelper::getContent($phpcsFile, $endOfLinePointer + 1, $pointerAfterWhitespace - 1); if (\strlen($actualIndentation) !== 0) { return $actualIndentation . (\substr($actualIndentation, -1) === self::TAB_INDENT ? self::TAB_INDENT : self::SPACES_INDENT); } $tabPointer = TokenHelper::findPreviousContent($phpcsFile, \T_WHITESPACE, self::TAB_INDENT, $endOfLinePointer - 1); return $tabPointer !== null ? self::TAB_INDENT : self::SPACES_INDENT; } } coding-standard-0.1/InfinityloopCodingStandard/Sniffs/Namespaces/000077500000000000000000000000001374014600500252125ustar00rootroot00000000000000UseDoesNotStartWithBackslashSniff.php000066400000000000000000000036171374014600500343570ustar00rootroot00000000000000coding-standard-0.1/InfinityloopCodingStandard/Sniffs/NamespacesgetTokens(); $nextTokenPointer = TokenHelper::findNextEffective($phpcsFile, $usePointer + 1); \assert(\is_int($nextTokenPointer)); if ($tokens[$nextTokenPointer]['code'] === \T_STRING && ($tokens[$nextTokenPointer]['content'] === 'function' || $tokens[$nextTokenPointer]['content'] === 'const') ) { $nextTokenPointer = TokenHelper::findNextEffective($phpcsFile, $nextTokenPointer + 1); \assert(\is_int($nextTokenPointer)); } if ($tokens[$nextTokenPointer]['code'] === \T_NS_SEPARATOR) { return; } $fix = $phpcsFile->addFixableError( 'Use statement must start with a backslash.', $nextTokenPointer, self::CODE_DOES_NOT_START_WITH_BACKSLASH, ); if (!$fix) { return; } $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addContentBefore($nextTokenPointer, '\\'); $phpcsFile->fixer->endChangeset(); } } coding-standard-0.1/InfinityloopCodingStandard/Sniffs/WhiteSpace/000077500000000000000000000000001374014600500251675ustar00rootroot00000000000000coding-standard-0.1/InfinityloopCodingStandard/Sniffs/WhiteSpace/MemberVarSpacingSniff.php000066400000000000000000000147701374014600500320640ustar00rootroot00000000000000getTokens(); $validPrefixes = \PHP_CodeSniffer\Util\Tokens::$methodPrefixes; $validPrefixes[] = \T_VAR; $startOfStatement = $phpcsFile->findPrevious($validPrefixes, $stackPtr - 1, null, false, null, true); if ($startOfStatement === false) { return; } $endOfStatement = $phpcsFile->findNext(\T_SEMICOLON, $stackPtr + 1, null, false, null, true); $ignore = $validPrefixes; $ignore[] = \T_WHITESPACE; $start = $startOfStatement; $prev = $phpcsFile->findPrevious($ignore, $startOfStatement - 1, null, true); if (isset(\PHP_CodeSniffer\Util\Tokens::$commentTokens[$tokens[$prev]['code']]) === true) { // Assume the comment belongs to the member var if it is on a line by itself. $prevContent = $phpcsFile->findPrevious(\PHP_CodeSniffer\Util\Tokens::$emptyTokens, $prev - 1, null, true); if ($tokens[$prevContent]['line'] !== $tokens[$prev]['line']) { // Check the spacing, but then skip it. $foundLines = $tokens[$startOfStatement]['line'] - $tokens[$prev]['line'] - 1; if ($foundLines > 0) { $error = 'Expected 0 blank lines after member var comment; %s found'; $data = [$foundLines]; $fix = $phpcsFile->addFixableError($error, $prev, 'AfterComment', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); // Inline comments have the newline included in the content but // docblock do not. if ($tokens[$prev]['code'] === \T_COMMENT) { $phpcsFile->fixer->replaceToken($prev, \rtrim($tokens[$prev]['content'])); } for ($i = $prev + 1; $i <= $startOfStatement; $i++) { if ($tokens[$i]['line'] === $tokens[$startOfStatement]['line']) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->addNewline($prev); $phpcsFile->fixer->endChangeset(); } }//end if $start = $prev; }//end if }//end if // There needs to be n blank lines before the var, not counting comments. if ($start === $startOfStatement) { // No comment found. $first = $phpcsFile->findFirstOnLine(\PHP_CodeSniffer\Util\Tokens::$emptyTokens, $start, true); if ($first === false) { $first = $start; } } elseif ($tokens[$start]['code'] === \T_DOC_COMMENT_CLOSE_TAG) { $first = $tokens[$start]['comment_opener']; } else { $first = $phpcsFile->findPrevious(\PHP_CodeSniffer\Util\Tokens::$emptyTokens, $start - 1, null, true); $first = $phpcsFile->findNext(\PHP_CodeSniffer\Util\Tokens::$commentTokens, $first + 1); } // Determine if this is the first member var. $prev = $phpcsFile->findPrevious(\T_WHITESPACE, $first - 1, null, true); if ($tokens[$prev]['code'] === \T_CLOSE_CURLY_BRACKET && isset($tokens[$prev]['scope_condition']) === true && $tokens[$tokens[$prev]['scope_condition']]['code'] === \T_FUNCTION ) { return; } $prevVar = $phpcsFile->findPrevious(\T_VARIABLE, $first - 1); if ($this->ignoreFirstMemberVar && $tokens[$prevVar]['code'] !== \T_VARIABLE) { return; } if ($tokens[$prev]['code'] === \T_OPEN_CURLY_BRACKET && isset(\PHP_CodeSniffer\Util\Tokens::$ooScopeTokens[$tokens[$tokens[$prev]['scope_condition']]['code']]) === true ) { $errorMsg = 'Expected %s blank line(s) before first member var; %s found'; $errorCode = 'FirstIncorrect'; $spacing = (int) $this->spacingBeforeFirst; } else { $errorMsg = 'Expected %s blank line(s) before member var; %s found'; $errorCode = 'Incorrect'; $spacing = (int) $this->spacing; } $foundLines = $tokens[$first]['line'] - $tokens[$prev]['line'] - 1; if ($errorCode === 'FirstIncorrect') { $phpcsFile->recordMetric($stackPtr, 'Member var spacing before first', $foundLines); } else { $phpcsFile->recordMetric($stackPtr, 'Member var spacing before', $foundLines); } if ($foundLines === $spacing) { if ($endOfStatement !== false) { return $endOfStatement; } return; } $data = [ $spacing, $foundLines, ]; $fix = $phpcsFile->addFixableError($errorMsg, $startOfStatement, $errorCode, $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = $prev + 1; $i < $first; $i++) { if ($tokens[$i]['line'] === $tokens[$prev]['line']) { continue; } if ($tokens[$i]['line'] === $tokens[$first]['line']) { for ($x = 1; $x <= $spacing; $x++) { $phpcsFile->fixer->addNewlineBefore($i); } break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); }//end if if ($endOfStatement !== false) { return $endOfStatement; } } //@phpcs:ignore Squiz.Commenting.FunctionComment.ScalarTypeHintMissing protected function processVariable(\PHP_CodeSniffer\Files\File $phpcsFile, $stackPtr) : void { } //@phpcs:ignore Squiz.Commenting.FunctionComment.ScalarTypeHintMissing protected function processVariableInString(\PHP_CodeSniffer\Files\File $phpcsFile, $stackPtr) : void { } } coding-standard-0.1/InfinityloopCodingStandard/ruleset.xml000066400000000000000000000644061374014600500241220ustar00rootroot00000000000000 Coding standard overriding few properties from PSR12 ./../../../../../../app ./../../../../../../bin ./../../../../../../tests ./../../../../../../www */tests/*/data/* */vendor/* */vendor-bin/* Only 1 @return annotation is allowed in a function comment Extra @param annotation Function has no return statement, but annotation @return is present SlevomatCodingStandard/Sniffs/ControlStructures/AbstractControlStructureSpacingSniff.php SlevomatCodingStandard/Sniffs/Namespaces/AbstractFullyQualifiedGlobalReference.php tests/ SlevomatCodingStandard/Sniffs/Exceptions/ReferenceThrowableOnlySniff.php coding-standard-0.1/LICENSE000066400000000000000000000020551374014600500154220ustar00rootroot00000000000000MIT License Copyright (c) 2019 inifnityloop Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. coding-standard-0.1/README.md000066400000000000000000000327521374014600500157030ustar00rootroot00000000000000# Infinityloop Coding-Standard Custom PHP 7.4 ruleset for [PHP_CodeSniffer](https://github.com/squizlabs/PHP_CodeSniffer). It is designed for PHP 7.4 because of its specific property spacing, which is not plausible without typed properties. ## Features - 97% PSR12 compatible - Slevomat rules - [Slevomat coding-standard](https://github.com/slevomat/coding-standard) - Ruleset includes vast majority of Slevomat sniffs as they're great extension of PSR12 with wider scope and stricter requirements. - Custom rules - Package also introduces its own sniffs with more additional checks. ## Installation Recommended way is to install using [composer-bin plugin](https://github.com/bamarni/composer-bin-plugin), so it won't interfere with your project's dependencies. ``` composer require --dev bamarni/composer-bin-plugin composer bin phpcs require infinityloop-dev/coding-standard ``` ## Usage Running phpcs out of the box: ``` // phpcs: php vendor/bin/phpcs\ --parallel=4\ --standard=vendor-bin/phpcs/vendor/infinityloop-dev/coding-standard/InfinityloopCodingStandard/ruleset.xml\ --extensions=php\ app tests // phpcbf: php vendor/bin/phpcbf\ --parallel=4\ --standard=vendor-bin/phpcs/vendor/infinityloop-dev/coding-standard/InfinityloopCodingStandard/ruleset.xml\ --extensions=php\ app tests ``` Feel free to copy ruleset.xml in your project directory, customize configuration and create your own standard with this ruleset as its base. ## Description ### PHPCS sniffs - PSR12 ruleset We use PHP_Codesniffers predefined PSR12 ruleset, but some slight modifications were made. Few sniffs are replaced with more generic/configurable ones and some are configured to achieve different result. - `declare(strict_types = 1);` instead of PSR's `declare(strict_types=1);` - one space around `=` operator - `function abc($param) : ReturnType` instead of PSR's `function abc($param): ReturnType` - one space before and after colon - `function($param) use ($use)` instaed of PSR's `function ($param) use ($use)` - no space after function keyword - `use \Abc\Xyz\Class;` instead of PSR's `use Abc\Xyz\Class` - Leading backslash in use - Although import names must already be fully qualified, we believe that using FQN is more logical here. All other necessary sniffs to enforce remaining PSR12 rules are included. ### Custom sniffs #### InfinityloopCodingStandard.Classes.FinalClassVisibility :wrench: When class is final and doesnt extend any other class, it's safe to change visibility of all protected functions/properties to private. #### InfinityloopCodingStandard.Namespaces.UseDoesStartWithBackslash :wrench: Inverted `SlevomatCodingStandard.Namespaces.UseDoesNotStartWithBackslash` sniff - require imports to start with backslash. #### InfinityloopCodingStandard.ControlStructures.RequireMultiLineNullCoalesce :wrench: Enforces null coalesce operator to be reformatted to new line #### InfinityloopCodingStandard.ControlStructures.SwitchCommentSpacing :wrench: Checks that there is a certain number of blank lines between code and comment ### Slevomat sniffs Detailed list of Slevomat sniffs with configured settings. Some sniffs are not included, either because we dont find them helpful, the are too strict, or collide with their counter-sniff (require/disallow pairs). #### Functional - SlevomatCodingStandard.TypeHints.ReturnTypeHint - enableObjectTypeHint: true - traversableTypeHints: false - SlevomatCodingStandard.TypeHints.UselessConstantTypeHint - SlevomatCodingStandard.Exceptions.ReferenceThrowableOnly - SlevomatCodingStandard.TypeHints.DeclareStrictTypes - newlinesCountBetweenOpenTagAndDeclare: 2 - newlinesCountAfterDeclare: 2 - spacesCountAroundEqualsSign: 1 - SlevomatCodingStandard.Arrays.DisallowImplicitArrayCreation - SlevomatCodingStandard.Classes.UselessLateStaticBinding - SlevomatCodingStandard.Classes.ClassStructure - groups: [uses, public constants, protected constants, private constants, public static properties, protected static properties, private static properties, public properties, protected properties, private properties, constructor, static constructors, destructor, public static methods, public methods, protected static methods, protected methods, private static methods, private methods, public abstract methods, protected abstract methods, public static abstract methods, protected static abstract methods, magic methods] - SlevomatCodingStandard.ControlStructures.AssignmentInCondition - SlevomatCodingStandard.ControlStructures.DisallowContinueWithoutIntegerOperandInSwitch - SlevomatCodingStandard.ControlStructures.DisallowEmpty - SlevomatCodingStandard.ControlStructures.RequireNullCoalesceOperator - SlevomatCodingStandard.ControlStructures.EarlyExit - ignoreStandaloneIfInScope: true - ignoreOneLineTrailingIf: true - SlevomatCodingStandard.ControlStructures.RequireNullCoalesceEqualOperator - SlevomatCodingStandard.Functions.StaticClosure - SlevomatCodingStandard.Operators.DisallowEqualOperators - SlevomatCodingStandard.Operators.RequireOnlyStandaloneIncrementAndDecrementOperators - SlevomatCodingStandard.Operators.RequireCombinedAssignmentOperator Excluded sniffs: - SlevomatCodingStandard.Classes.DisallowLateStaticBindingForConstants - SlevomatCodingStandard.Operators.DisallowIncrementAndDecrementOperators - SlevomatCodingStandard.TypeHints.ParameterTypeHint - SlevomatCodingStandard.TypeHints.PropertyTypeHint - SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification #### Cleaning - SlevomatCodingStandard.Classes.UnusedPrivateElements - alwaysUsedPropertiesAnnotations: false - alwaysUsedPropertiesSuffixes: false - SlevomatCodingStandard.Functions.UnusedInheritedVariablePassedToClosure - SlevomatCodingStandard.Functions.UselessParameterDefaultValue - SlevomatCodingStandard.Namespaces.UnusedUses - searchAnnotations: false - ignoredAnnotationNames: false - ignoredAnnotations: false - SlevomatCodingStandard.Namespaces.UseFromSameNamespace - SlevomatCodingStandard.Namespaces.UselessAlias - SlevomatCodingStandard.PHP.RequireExplicitAssertion - SlevomatCodingStandard.PHP.RequireNowdoc - SlevomatCodingStandard.PHP.UselessParentheses - ignoreComplexTernaryConditions: true - SlevomatCodingStandard.PHP.OptimizedFunctionsWithoutUnpacking - SlevomatCodingStandard.PHP.UselessSemicolon - SlevomatCodingStandard.Variables.DuplicateAssignmentToVariable - SlevomatCodingStandard.Variables.UnusedVariable - ignoreUnusedValuesWhenOnlyKeysAreUsedInForeach: true - SlevomatCodingStandard.Variables.UselessVariable - SlevomatCodingStandard.Exceptions.DeadCatch Excluded sniffs: - SlevomatCodingStandard.PHP.DisallowReference - SlevomatCodingStandard.Functions.DisallowEmptyFunction - SlevomatCodingStandard.Functions.UnusedParameter #### Formatting - SlevomatCodingStandard.Arrays.TrailingArrayComma - enableAfterHeredoc: false - SlevomatCodingStandard.Classes.ModernClassNameReference - SlevomatCodingStandard.Classes.SuperfluousAbstractClassNaming - SlevomatCodingStandard.Classes.SuperfluousInterfaceNaming - SlevomatCodingStandard.Classes.SuperfluousTraitNaming - SlevomatCodingStandard.Classes.SuperfluousExceptionNaming - SlevomatCodingStandard.Classes.TraitUseDeclaration - SlevomatCodingStandard.Classes.TraitUseSpacing - linesCountBeforeFirstUse: 0 - linesCountBetweenUses: 0 - linesCountAfterLastUse: 1 - linesCountAfterLastUseWhenLastInClass: 0 - SlevomatCodingStandard.ControlStructures.BlockControlStructureSpacing - linesCountBeforeControlStructure: 1 - linesCountBeforeFirstControlStructure: 0 - linesCountAfterControlStructure: 1 - linesCountAfterLastControlStructure: 0 - tokensToCheck: [T_SWITCH, T_TRY, T_IF, T_FOR, T_FOREACH, T_WHILE] - SlevomatCodingStandard.ControlStructures.JumpStatementsSpacing - allowSingleLineYieldStacking: whether or not to allow multiple yield/yield from statements in a row without blank lines. - linesCountBeforeControlStructure: 1 - linesCountBeforeFirstControlStructure: 0 - linesCountAfterControlStructure: 0 - linesCountAfterLastControlStructure: 0 - tokensToCheck: default - SlevomatCodingStandard.ControlStructures.LanguageConstructWithParentheses - SlevomatCodingStandard.ControlStructures.NewWithParentheses - SlevomatCodingStandard.ControlStructures.RequireMultiLineTernaryOperator - lineLengthLimit: 0 - SlevomatCodingStandard.ControlStructures.RequireShortTernaryOperator - SlevomatCodingStandard.ControlStructures.RequireTernaryOperator - ignoreMultiLine: false - SlevomatCodingStandard.ControlStructures.DisallowYodaComparison - SlevomatCodingStandard.Functions.DisallowArrowFunction - SlevomatCodingStandard.Functions.TrailingCommaInCall - SlevomatCodingStandard.Namespaces.AlphabeticallySortedUses - psr12Compatible: true - caseSensitive: true - SlevomatCodingStandard.Namespaces.RequireOneNamespaceInFile - SlevomatCodingStandard.Namespaces.NamespaceDeclaration - SlevomatCodingStandard.Namespaces.NamespaceSpacing - linesCountBeforeNamespace: 1 - linesCountAfterNamespace: 1 - SlevomatCodingStandard.Namespaces.UseSpacing - linesCountBeforeFirstUse: 1 - linesCountBetweenUseTypes: 0 - linesCountAfterLastUse: 1 - SlevomatCodingStandard.Numbers.DisallowNumericLiteralSeparator - SlevomatCodingStandard.PHP.ReferenceSpacing - spacesCountAfterReference: 0 - SlevomatCodingStandard.Operators.SpreadOperatorSpacing - spacesCountAfterOperator: 0 - SlevomatCodingStandard.TypeHints.DisallowArrayTypeHintSyntax - traversableTypeHints: default - SlevomatCodingStandard.TypeHints.DisallowMixedTypeHint - SlevomatCodingStandard.TypeHints.LongTypeHints - SlevomatCodingStandard.TypeHints.NullTypeHintOnLastPosition - SlevomatCodingStandard.PHP.ShortList - SlevomatCodingStandard.PHP.TypeCast - SlevomatCodingStandard.Classes.ClassConstantVisibility - fixable: true - SlevomatCodingStandard.TypeHints.ReturnTypeHintSpacing - spacesCountBeforeColon: 1 - SlevomatCodingStandard.TypeHints.NullableTypeForNullDefaultValue - SlevomatCodingStandard.TypeHints.ParameterTypeHintSpacing - SlevomatCodingStandard.TypeHints.PropertyTypeHintSpacing - SlevomatCodingStandard.Namespaces.DisallowGroupUse - SlevomatCodingStandard.Namespaces.FullyQualifiedClassNameAfterKeyword - keywordsToCheck: T_EXTENDS, T_IMPLEMENETS, T_USE, T_NEW, T_THROW - SlevomatCodingStandard.Namespaces.FullyQualifiedExceptions - specialExceptionNames: false - ignoredNames: default - SlevomatCodingStandard.Namespaces.FullyQualifiedGlobalConstants - exclude: false - SlevomatCodingStandard.Namespaces.FullyQualifiedGlobalFunctions - exclude: false - SlevomatCodingStandard.Namespaces.MultipleUsesPerLine - SlevomatCodingStandard.Classes.EmptyLinesAroundClassBraces - linesCountAfterOpeningBrace: 0 - linesCountBeforeClosingBrace: 0 - SlevomatCodingStandard.Namespaces.FullyQualifiedClassNameInAnnotation - SlevomatCodingStandard.Commenting.ForbiddenAnnotations - forbiddenAnnotations: @author, @created, @version, @package, @copyright, @license, @throws - SlevomatCodingStandard.Commenting.EmptyComment - SlevomatCodingStandard.Commenting.InlineDocCommentDeclaration - SlevomatCodingStandard.Commenting.UselessFunctionDocComment - traversableTypeHints: default - SlevomatCodingStandard.Commenting.UselessInheritDocComment - SlevomatCodingStandard.ControlStructures.UselessIfConditionWithReturn - assumeAllConditionExpressionsAreAlreadyBoolean: false - SlevomatCodingStandard.ControlStructures.UselessTernaryOperator - assumeAllConditionExpressionsAreAlreadyBoolean: false - SlevomatCodingStandard.Files.LineLength - lineLengthLimit: 150 - ignoreComments: true - ignoreImports: true - SlevomatCodingStandard.Classes.ParentCallSpacing - linesCountBeforeParentCall: 1 - linesCountBeforeFirstControlParentCall: 0 - linesCountAfterParentCall: 1 - linesCountAfterLastParentCall: 0 - SlevomatCodingStandard.Arrays.MultiLineArrayEndBracketPlacement Excluded sniffs: - SlevomatCodingStandard.Namespaces.UseDoesNotStartWithBackslash - Custom UseDoesStartWithBackslash is used instead. - SlevomatCodingStandard.ControlStructures.NewWithoutParentheses** - NewWithParentheses is used instead. - SlevomatCodingStandard.ControlStructures.DisallowShortTernaryOperator - RequireShortTernaryOperator is used instead. - SlevomatCodingStandard.ControlStructures.RequireYodaComparison - DisallowYodaComparison is used instead. - SlevomatCodingStandard.Functions.RequireArrowFunction - DisallowArrowFunction is used instead. - SlevomatCodingStandard.Numbers.RequireNumericLiteralSeparator - DisallowNumericLiteralSeparator is used instead. - SlevomatCodingStandard.Namespaces.ReferenceUsedNamesOnly - SlevomatCodingStandard.Namespaces.UseOnlyWhitelistedNamespaces - SlevomatCodingStandard.Commenting.ForbiddenComments - SlevomatCodingStandard.Commenting.DocCommentSpacing - This sniff clashed with some other sniffs and caused some FAILED TO FIX errors. - SlevomatCodingStandard.Commenting.RequireOneLinePropertyDocComment - Property doc comments are replaced by typed proeprties. - SlevomatCodingStandard.Commenting.DisallowOneLinePropertyDocComment - Property doc comments are replaced by typed proeprties. - SlevomatCodingStandard.Classes.RequireMultiLineMethodSignature - SlevomatCodingStandard.Classes.RequireSingleLineMethodSignature - SlevomatCodingStandard.Classes.PropertySpacing - SlevomatCodingStandard.Classes.ConstantSpacing - SlevomatCodingStandard.Commenting.RequireOneLineDocComment - SlevomatCodingStandard.Arrays.SingleLineArrayWhitespace - SlevomatCodingStandard.Operators.NegationOperatorSpacing coding-standard-0.1/composer.json000066400000000000000000000012471374014600500171410ustar00rootroot00000000000000{ "name": "infinityloop-dev/coding-standard", "description": "Inifnityloop PHPCS coding standard", "type": "phpcodesniffer-standard", "license": "MIT", "minimum-stability": "dev", "prefer-stable": true, "require": { "php": "^7.4", "squizlabs/php_codesniffer": "~3.5.3", "slevomat/coding-standard": "~6.3.8" }, "require-dev": { "bamarni/composer-bin-plugin": "^1.2" }, "scripts": { "codestyle": "phpcs --standard=vendor-bin/phpcs/vendor/infinityloop-dev/coding-standard/InfinityloopCodingStandard/ruleset.xml --extensions=php InfinityloopCodingStandard" }, "autoload": { "psr-4": { "InfinityloopCodingStandard\\": "InfinityloopCodingStandard" } } }