Add custom sniffs to address spacing of operators

.gitignore

@@ -1,4 +1,5 @@
 vendor/
+.phpunit.result.cache
 phpcs.xml
 composer.lock
 tests/input2

.travis.yml

@@ -21,6 +21,7 @@ install: travis_retry composer update --prefer-dist
 script:
   - vendor/bin/phpcs
   - vendor/bin/phpcs $(find tests/input/* | sort) --report=summary --report-file=phpcs.log; diff tests/expected_report.txt phpcs.log
+  - vendor/bin/phpunit
 
 stages:
   - Validate against schema

composer.json

@@ -25,12 +25,20 @@
            "Doctrine\\Sniffs\\": "lib/Doctrine/Sniffs"
        }
     },
+    "autoload-dev": {
+        "psr-4": {
+            "Doctrine\\Tests\\": "tests/"
+        }
+    },
     "require": {
         "php": "^7.2",
         "dealerdirect/phpcodesniffer-composer-installer": "^0.5.0",
         "slevomat/coding-standard": "dev-master#63a8186b129ee96d1277e68c80cf87c8cdb356d1",
         "squizlabs/php_codesniffer": "^3.5.0"
     },
+    "require-dev": {
+        "phpunit/phpunit": "^8.1"
+    },
     "config": {
         "sort-packages": true
     },

lib/Doctrine/Sniffs/Operators/NegationOperatorSpacingSniff.php

@@ -0,0 +1,114 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Sniffs\Operators;
+
+use PHP_CodeSniffer\Files\File;
+use PHP_CodeSniffer\Sniffs\Sniff;
+use SlevomatCodingStandard\Helpers\TokenHelper;
+use function in_array;
+use function strlen;
+use const T_CLOSE_PARENTHESIS;
+use const T_CLOSE_SHORT_ARRAY;
+use const T_CLOSE_SQUARE_BRACKET;
+use const T_CONSTANT_ENCAPSED_STRING;
+use const T_DNUMBER;
+use const T_ENCAPSED_AND_WHITESPACE;
+use const T_LNUMBER;
+use const T_MINUS;
+use const T_NUM_STRING;
+use const T_STRING;
+use const T_VARIABLE;
+use const T_WHITESPACE;
+
+final class NegationOperatorSpacingSniff implements Sniff
+{
+    public const CODE_INVALID_SPACE_AFTER_MINUS = 'InvalidSpaceAfterMinus';
+
+    /** @var bool */
+    public $requireSpace = false;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function register() : array
+    {
+        return [T_MINUS];
+    }
+
+    /**
+     * @param int $pointer
+     *
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingParameterTypeHint
+     */
+    public function process(File $file, $pointer) : void
+    {
+        $tokens = $file->getTokens();
+
+        $previousEffective = TokenHelper::findPreviousEffective($file, $pointer - 1);
+
+        $possibleOperandTypes = [
+            T_CONSTANT_ENCAPSED_STRING,
+            T_CLOSE_PARENTHESIS,
+            T_CLOSE_SHORT_ARRAY,
+            T_CLOSE_SQUARE_BRACKET,
+            T_DNUMBER,
+            T_ENCAPSED_AND_WHITESPACE,
+            T_LNUMBER,
+            T_NUM_STRING,
+            T_STRING,
+            T_VARIABLE,
+        ];
+
+        if (in_array($tokens[$previousEffective]['code'], $possibleOperandTypes, true)) {
+            return;
+        }
+
+        $whitespacePointer = $pointer + 1;
+        if (! isset($tokens[$whitespacePointer])) {
+            return;
+        }
+
+        $numberOfSpaces = $this->numberOfSpaces($tokens[$whitespacePointer]);
+        $expectedSpaces = $this->requireSpace ? 1 : 0;
+
+        if ($numberOfSpaces === $expectedSpaces
+            || ! $this->recordError($file, $pointer, $tokens[$pointer], $expectedSpaces, $numberOfSpaces)) {
+            return;
+        }
+
+        if ($expectedSpaces > $numberOfSpaces) {
+            $file->fixer->addContent($pointer, ' ');
+
+            return;
+        }
+
+        $file->fixer->replaceToken($whitespacePointer, '');
+    }
+
+    /**
+     * @param mixed[] $token
+     */
+    private function numberOfSpaces(array $token) : int
+    {
+        if ($token['code'] !== T_WHITESPACE) {
+            return 0;
+        }
+
+        return strlen($token['content']);
+    }
+
+    /**
+     * @param mixed[] $token
+     */
+    private function recordError(File $file, int $pointer, array $token, int $expected, int $found) : bool
+    {
+        return $file->addFixableError(
+            'Expected exactly %d space after "%s"; %d found',
+            $pointer,
+            self::CODE_INVALID_SPACE_AFTER_MINUS,
+            [$expected, $token['content'], $found]
+        );
+    }
+}

lib/Doctrine/Sniffs/Operators/OperatorSpacingSniff.php

@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Sniffs\Operators;
+
+use PHP_CodeSniffer\Files\File;
+use PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace\OperatorSpacingSniff as SquizOperatorSpacingSniff;
+use PHP_CodeSniffer\Util\Tokens;
+use function in_array;
+use const T_ARRAY_CAST;
+use const T_BOOL_CAST;
+use const T_DOUBLE_CAST;
+use const T_ECHO;
+use const T_INT_CAST;
+use const T_MINUS;
+use const T_OBJECT_CAST;
+use const T_PLUS;
+use const T_PRINT;
+use const T_STRING_CAST;
+use const T_UNSET_CAST;
+use const T_YIELD;
+
+/**
+ * We need this sniff until Squiz accepts fix for unary operands detection
+ * https://github.com/squizlabs/PHP_CodeSniffer/pull/2640
+ */
+final class OperatorSpacingSniff extends SquizOperatorSpacingSniff
+{
+    private const NON_OPERAND_TOKENS = [
+        T_ARRAY_CAST,
+        T_BOOL_CAST,
+        T_DOUBLE_CAST,
+        T_ECHO,
+        T_INT_CAST,
+        T_OBJECT_CAST,
+        T_PRINT,
+        T_STRING_CAST,
+        T_UNSET_CAST,
+        T_YIELD,
+    ];
+
+    /**
+     * @param int $pointer
+     *
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingParameterTypeHint
+     */
+    public function process(File $file, $pointer) : void
+    {
+        if (! $this->isOperator($file, $pointer)) {
+            return;
+        }
+
+        parent::process($file, $pointer);
+    }
+
+    /**
+     * @param int $pointer
+     *
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingParameterTypeHint
+     */
+    protected function isOperator(File $file, $pointer) : bool
+    {
+        if (! parent::isOperator($file, $pointer)) {
+            return false;
+        }
+
+        $tokens = $file->getTokens();
+        if ($tokens[$pointer]['code'] === T_MINUS || $tokens[$pointer]['code'] === T_PLUS) {
+            $prev = $file->findPrevious(Tokens::$emptyTokens, $pointer - 1, null, true);
+            if (in_array($tokens[$prev]['code'], self::NON_OPERAND_TOKENS, true)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

lib/Doctrine/ruleset.xml

@@ -16,6 +16,12 @@
         <exclude name="Squiz.Functions.FunctionDeclarationArgumentSpacing.SpacingAfterVariadic"/>
     </rule>
 
+    <!-- Require spaces around math, comparison, assignment, ... operators -->
+    <rule ref="Doctrine.Operators.OperatorSpacing">
+        <properties>
+            <property name="ignoreNewlines" value="true"/>
+        </properties>
+    </rule>
     <!-- Force array element indentation with 4 spaces -->
     <rule ref="Generic.Arrays.ArrayIndent"/>
     <!-- Forbid `array(...)` -->

phpunit.xml.dist

@@ -0,0 +1,20 @@
+<?xml version="1.0"?>
+<phpunit
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
+    beStrictAboutChangesToGlobalState="true"
+    beStrictAboutOutputDuringTests="true"
+    beStrictAboutTodoAnnotatedTests="true"
+    colors="true"
+    bootstrap="tests/bootstrap.php"
+    executionOrder="random"
+>
+    <testsuite name="Doctrine Coding Standard">
+        <directory>tests</directory>
+    </testsuite>
+    <filter>
+        <whitelist>
+            <directory suffix=".php">src/</directory>
+        </whitelist>
+    </filter>
+</phpunit>

tests/Sniffs/Operators/NegationOperatorSpacingSniffTest.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Sniffs\Operators;
+
+use Doctrine\Tests\TestCase;
+
+class NegationOperatorSpacingSniffTest extends TestCase
+{
+    public function testNoErrors() : void
+    {
+        self::assertNoSniffErrorInFile(self::checkFile(__DIR__ . '/data/NegationOperatorSpacingSniffNoErrors.php'));
+    }
+
+    public function testErrors() : void
+    {
+        $file = self::checkFile(
+            __DIR__ . '/data/NegationOperatorSpacingSniffRequireSpaceErrors.php',
+            ['requireSpace' => true]
+        );
+
+        self::assertSame(97, $file->getErrorCount());
+
+        self::assertAllFixedInFile($file);
+    }
+}

tests/Sniffs/Operators/OperatorSpacingSniffTest.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Sniffs\Operators;
+
+use Doctrine\Tests\TestCase;
+
+class OperatorSpacingSniffTest extends TestCase
+{
+    public function testNoErrors() : void
+    {
+        self::assertNoSniffErrorInFile(
+            self::checkFile(
+                __DIR__ . '/data/OperatorSpacingSniffNoErrors.php',
+                ['ignoreSpacingBeforeAssignments' => false]
+            )
+        );
+    }
+
+    public function testErrors() : void
+    {
+        $file = self::checkFile(
+            __DIR__ . '/data/OperatorSpacingSniffErrors.php',
+            ['ignoreSpacingBeforeAssignments' => false]
+        );
+
+        self::assertSame(67, $file->getErrorCount());
+
+        self::assertAllFixedInFile($file);
+    }
+}