gravityview / GravityView

vendor/squizlabs/php_codesniffer/src/Sniffs/AbstractScopeSniff.php

Indentation +154 added lines, -154 removed lines

@@ -32,160 +32,160 @@
 abstract class AbstractScopeSniff implements Sniff
 {
 
-    /**
-     * The token types that this test wishes to listen to within the scope.
-     *
-     * @var array
-     */
-    private $tokens = [];
-
-    /**
-     * The type of scope opener tokens that this test wishes to listen to.
-     *
-     * @var string
-     */
-    private $scopeTokens = [];
-
-    /**
-     * True if this test should fire on tokens outside of the scope.
-     *
-     * @var boolean
-     */
-    private $listenOutside = false;
-
-
-    /**
-     * Constructs a new AbstractScopeTest.
-     *
-     * @param array   $scopeTokens   The type of scope the test wishes to listen to.
-     * @param array   $tokens        The tokens that the test wishes to listen to
-     *                               within the scope.
-     * @param boolean $listenOutside If true this test will also alert the
-     *                               extending class when a token is found outside
-     *                               the scope, by calling the
-     *                               processTokenOutsideScope method.
-     *
-     * @see    PHP_CodeSniffer.getValidScopeTokeners()
-     * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the specified tokens array is empty.
-     */
-    public function __construct(
-        array $scopeTokens,
-        array $tokens,
-        $listenOutside=false
-    ) {
-        if (empty($scopeTokens) === true) {
-            $error = 'The scope tokens list cannot be empty';
-            throw new RuntimeException($error);
-        }
-
-        if (empty($tokens) === true) {
-            $error = 'The tokens list cannot be empty';
-            throw new RuntimeException($error);
-        }
-
-        $invalidScopeTokens = array_intersect($scopeTokens, $tokens);
-        if (empty($invalidScopeTokens) === false) {
-            $invalid = implode(', ', $invalidScopeTokens);
-            $error   = "Scope tokens [$invalid] can't be in the tokens array";
-            throw new RuntimeException($error);
-        }
-
-        $this->listenOutside = $listenOutside;
-        $this->scopeTokens   = array_flip($scopeTokens);
-        $this->tokens        = $tokens;
-
-    }//end __construct()
-
-
-    /**
-     * The method that is called to register the tokens this test wishes to
-     * listen to.
-     *
-     * DO NOT OVERRIDE THIS METHOD. Use the constructor of this class to register
-     * for the desired tokens and scope.
-     *
-     * @return int[]
-     * @see    __constructor()
-     */
-    final public function register()
-    {
-        return $this->tokens;
-
-    }//end register()
-
-
-    /**
-     * Processes the tokens that this test is listening for.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found.
-     * @param int                         $stackPtr  The position in the stack where this
-     *                                               token was found.
-     *
-     * @return void|int Optionally returns a stack pointer. The sniff will not be
-     *                  called again on the current file until the returned stack
-     *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
-     *                  the rest of the file.
-     * @see    processTokenWithinScope()
-     */
-    final public function process(File $phpcsFile, $stackPtr)
-    {
-        $tokens = $phpcsFile->getTokens();
-
-        $foundScope = false;
-        $skipPtrs   = [];
-        foreach ($tokens[$stackPtr]['conditions'] as $scope => $code) {
-            if (isset($this->scopeTokens[$code]) === true) {
-                $skipPtrs[] = $this->processTokenWithinScope($phpcsFile, $stackPtr, $scope);
-                $foundScope = true;
-            }
-        }
-
-        if ($this->listenOutside === true && $foundScope === false) {
-            $skipPtrs[] = $this->processTokenOutsideScope($phpcsFile, $stackPtr);
-        }
-
-        if (empty($skipPtrs) === false) {
-            return min($skipPtrs);
-        }
-
-        return;
-
-    }//end process()
-
-
-    /**
-     * Processes a token that is found within the scope that this test is
-     * listening to.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found.
-     * @param int                         $stackPtr  The position in the stack where this
-     *                                               token was found.
-     * @param int                         $currScope The position in the tokens array that
-     *                                               opened the scope that this test is
-     *                                               listening for.
-     *
-     * @return void|int Optionally returns a stack pointer. The sniff will not be
-     *                  called again on the current file until the returned stack
-     *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
-     *                  the rest of the file.
-     */
-    abstract protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope);
-
-
-    /**
-     * Processes a token that is found outside the scope that this test is
-     * listening to.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found.
-     * @param int                         $stackPtr  The position in the stack where this
-     *                                               token was found.
-     *
-     * @return void|int Optionally returns a stack pointer. The sniff will not be
-     *                  called again on the current file until the returned stack
-     *                  pointer is reached. Return (count($tokens) + 1) to skip
-     *                  the rest of the file.
-     */
-    abstract protected function processTokenOutsideScope(File $phpcsFile, $stackPtr);
+	/**
+	 * The token types that this test wishes to listen to within the scope.
+	 *
+	 * @var array
+	 */
+	private $tokens = [];
+
+	/**
+	 * The type of scope opener tokens that this test wishes to listen to.
+	 *
+	 * @var string
+	 */
+	private $scopeTokens = [];
+
+	/**
+	 * True if this test should fire on tokens outside of the scope.
+	 *
+	 * @var boolean
+	 */
+	private $listenOutside = false;
+
+
+	/**
+	 * Constructs a new AbstractScopeTest.
+	 *
+	 * @param array   $scopeTokens   The type of scope the test wishes to listen to.
+	 * @param array   $tokens        The tokens that the test wishes to listen to
+	 *                               within the scope.
+	 * @param boolean $listenOutside If true this test will also alert the
+	 *                               extending class when a token is found outside
+	 *                               the scope, by calling the
+	 *                               processTokenOutsideScope method.
+	 *
+	 * @see    PHP_CodeSniffer.getValidScopeTokeners()
+	 * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the specified tokens array is empty.
+	 */
+	public function __construct(
+		array $scopeTokens,
+		array $tokens,
+		$listenOutside=false
+	) {
+		if (empty($scopeTokens) === true) {
+			$error = 'The scope tokens list cannot be empty';
+			throw new RuntimeException($error);
+		}
+
+		if (empty($tokens) === true) {
+			$error = 'The tokens list cannot be empty';
+			throw new RuntimeException($error);
+		}
+
+		$invalidScopeTokens = array_intersect($scopeTokens, $tokens);
+		if (empty($invalidScopeTokens) === false) {
+			$invalid = implode(', ', $invalidScopeTokens);
+			$error   = "Scope tokens [$invalid] can't be in the tokens array";
+			throw new RuntimeException($error);
+		}
+
+		$this->listenOutside = $listenOutside;
+		$this->scopeTokens   = array_flip($scopeTokens);
+		$this->tokens        = $tokens;
+
+	}//end __construct()
+
+
+	/**
+	 * The method that is called to register the tokens this test wishes to
+	 * listen to.
+	 *
+	 * DO NOT OVERRIDE THIS METHOD. Use the constructor of this class to register
+	 * for the desired tokens and scope.
+	 *
+	 * @return int[]
+	 * @see    __constructor()
+	 */
+	final public function register()
+	{
+		return $this->tokens;
+
+	}//end register()
+
+
+	/**
+	 * Processes the tokens that this test is listening for.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found.
+	 * @param int                         $stackPtr  The position in the stack where this
+	 *                                               token was found.
+	 *
+	 * @return void|int Optionally returns a stack pointer. The sniff will not be
+	 *                  called again on the current file until the returned stack
+	 *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
+	 *                  the rest of the file.
+	 * @see    processTokenWithinScope()
+	 */
+	final public function process(File $phpcsFile, $stackPtr)
+	{
+		$tokens = $phpcsFile->getTokens();
+
+		$foundScope = false;
+		$skipPtrs   = [];
+		foreach ($tokens[$stackPtr]['conditions'] as $scope => $code) {
+			if (isset($this->scopeTokens[$code]) === true) {
+				$skipPtrs[] = $this->processTokenWithinScope($phpcsFile, $stackPtr, $scope);
+				$foundScope = true;
+			}
+		}
+
+		if ($this->listenOutside === true && $foundScope === false) {
+			$skipPtrs[] = $this->processTokenOutsideScope($phpcsFile, $stackPtr);
+		}
+
+		if (empty($skipPtrs) === false) {
+			return min($skipPtrs);
+		}
+
+		return;
+
+	}//end process()
+
+
+	/**
+	 * Processes a token that is found within the scope that this test is
+	 * listening to.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found.
+	 * @param int                         $stackPtr  The position in the stack where this
+	 *                                               token was found.
+	 * @param int                         $currScope The position in the tokens array that
+	 *                                               opened the scope that this test is
+	 *                                               listening for.
+	 *
+	 * @return void|int Optionally returns a stack pointer. The sniff will not be
+	 *                  called again on the current file until the returned stack
+	 *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
+	 *                  the rest of the file.
+	 */
+	abstract protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope);
+
+
+	/**
+	 * Processes a token that is found outside the scope that this test is
+	 * listening to.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found.
+	 * @param int                         $stackPtr  The position in the stack where this
+	 *                                               token was found.
+	 *
+	 * @return void|int Optionally returns a stack pointer. The sniff will not be
+	 *                  called again on the current file until the returned stack
+	 *                  pointer is reached. Return (count($tokens) + 1) to skip
+	 *                  the rest of the file.
+	 */
+	abstract protected function processTokenOutsideScope(File $phpcsFile, $stackPtr);
 
 
 }//end class

Spacing +23 added lines, -23 removed lines

@@ -37,14 +37,14 @@ 
      *
      * @var array
      */
-    private $tokens = [];
+    private $tokens = [ ];
 
     /**
      * The type of scope opener tokens that this test wishes to listen to.
      *
      * @var string
      */
-    private $scopeTokens = [];
+    private $scopeTokens = [ ];
 
     /**
      * True if this test should fire on tokens outside of the scope.
@@ -71,27 +71,27 @@ 
     public function __construct(
         array $scopeTokens,
         array $tokens,
-        $listenOutside=false
+        $listenOutside = false
     ) {
-        if (empty($scopeTokens) === true) {
+        if ( empty( $scopeTokens ) === true ) {
             $error = 'The scope tokens list cannot be empty';
-            throw new RuntimeException($error);
+            throw new RuntimeException( $error );
         }
 
-        if (empty($tokens) === true) {
+        if ( empty( $tokens ) === true ) {
             $error = 'The tokens list cannot be empty';
-            throw new RuntimeException($error);
+            throw new RuntimeException( $error );
         }
 
-        $invalidScopeTokens = array_intersect($scopeTokens, $tokens);
-        if (empty($invalidScopeTokens) === false) {
-            $invalid = implode(', ', $invalidScopeTokens);
+        $invalidScopeTokens = array_intersect( $scopeTokens, $tokens );
+        if ( empty( $invalidScopeTokens ) === false ) {
+            $invalid = implode( ', ', $invalidScopeTokens );
             $error   = "Scope tokens [$invalid] can't be in the tokens array";
-            throw new RuntimeException($error);
+            throw new RuntimeException( $error );
         }
 
         $this->listenOutside = $listenOutside;
-        $this->scopeTokens   = array_flip($scopeTokens);
+        $this->scopeTokens   = array_flip( $scopeTokens );
         $this->tokens        = $tokens;
 
     }//end __construct()
@@ -127,25 +127,25 @@ 
      *                  the rest of the file.
      * @see    processTokenWithinScope()
      */
-    final public function process(File $phpcsFile, $stackPtr)
+    final public function process( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
         $foundScope = false;
-        $skipPtrs   = [];
-        foreach ($tokens[$stackPtr]['conditions'] as $scope => $code) {
-            if (isset($this->scopeTokens[$code]) === true) {
-                $skipPtrs[] = $this->processTokenWithinScope($phpcsFile, $stackPtr, $scope);
+        $skipPtrs   = [ ];
+        foreach ( $tokens[ $stackPtr ][ 'conditions' ] as $scope => $code ) {
+            if ( isset( $this->scopeTokens[ $code ] ) === true ) {
+                $skipPtrs[ ] = $this->processTokenWithinScope( $phpcsFile, $stackPtr, $scope );
                 $foundScope = true;
             }
         }
 
-        if ($this->listenOutside === true && $foundScope === false) {
-            $skipPtrs[] = $this->processTokenOutsideScope($phpcsFile, $stackPtr);
+        if ( $this->listenOutside === true && $foundScope === false ) {
+            $skipPtrs[ ] = $this->processTokenOutsideScope( $phpcsFile, $stackPtr );
         }
 
-        if (empty($skipPtrs) === false) {
-            return min($skipPtrs);
+        if ( empty( $skipPtrs ) === false ) {
+            return min( $skipPtrs );
         }
 
         return;
@@ -169,7 +169,7 @@ 
      *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
      *                  the rest of the file.
      */
-    abstract protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope);
+    abstract protected function processTokenWithinScope( File $phpcsFile, $stackPtr, $currScope );
 
 
     /**
@@ -185,7 +185,7 @@ 
      *                  pointer is reached. Return (count($tokens) + 1) to skip
      *                  the rest of the file.
      */
-    abstract protected function processTokenOutsideScope(File $phpcsFile, $stackPtr);
+    abstract protected function processTokenOutsideScope( File $phpcsFile, $stackPtr );
 
 
 }//end class

Braces +3 added lines, -6 removed lines

@@ -29,8 +29,7 @@ 
 use PHP_CodeSniffer\Files\File;
 use PHP_CodeSniffer\Exceptions\RuntimeException;
 
-abstract class AbstractScopeSniff implements Sniff
-{
+abstract class AbstractScopeSniff implements Sniff {
 
     /**
      * The token types that this test wishes to listen to within the scope.
@@ -107,8 +106,7 @@ 
      * @return int[]
      * @see    __constructor()
      */
-    final public function register()
-    {
+    final public function register() {
         return $this->tokens;
 
     }//end register()
@@ -127,8 +125,7 @@ 
      *                  the rest of the file.
      * @see    processTokenWithinScope()
      */
-    final public function process(File $phpcsFile, $stackPtr)
-    {
+    final public function process(File $phpcsFile, $stackPtr) {
         $tokens = $phpcsFile->getTokens();
 
         $foundScope = false;

vendor/squizlabs/php_codesniffer/src/Sniffs/AbstractPatternSniff.php

Indentation +914 added lines, -914 removed lines

@@ -17,920 +17,920 @@
 abstract class AbstractPatternSniff implements Sniff
 {
 
-    /**
-     * If true, comments will be ignored if they are found in the code.
-     *
-     * @var boolean
-     */
-    public $ignoreComments = false;
-
-    /**
-     * The current file being checked.
-     *
-     * @var string
-     */
-    protected $currFile = '';
-
-    /**
-     * The parsed patterns array.
-     *
-     * @var array
-     */
-    private $parsedPatterns = [];
-
-    /**
-     * Tokens that this sniff wishes to process outside of the patterns.
-     *
-     * @var int[]
-     * @see registerSupplementary()
-     * @see processSupplementary()
-     */
-    private $supplementaryTokens = [];
-
-    /**
-     * Positions in the stack where errors have occurred.
-     *
-     * @var array<int, bool>
-     */
-    private $errorPos = [];
-
-
-    /**
-     * Constructs a AbstractPatternSniff.
-     *
-     * @param boolean $ignoreComments If true, comments will be ignored.
-     */
-    public function __construct($ignoreComments=null)
-    {
-        // This is here for backwards compatibility.
-        if ($ignoreComments !== null) {
-            $this->ignoreComments = $ignoreComments;
-        }
-
-        $this->supplementaryTokens = $this->registerSupplementary();
-
-    }//end __construct()
-
-
-    /**
-     * Registers the tokens to listen to.
-     *
-     * Classes extending <i>AbstractPatternTest</i> should implement the
-     * <i>getPatterns()</i> method to register the patterns they wish to test.
-     *
-     * @return int[]
-     * @see    process()
-     */
-    final public function register()
-    {
-        $listenTypes = [];
-        $patterns    = $this->getPatterns();
-
-        foreach ($patterns as $pattern) {
-            $parsedPattern = $this->parse($pattern);
-
-            // Find a token position in the pattern that we can use
-            // for a listener token.
-            $pos           = $this->getListenerTokenPos($parsedPattern);
-            $tokenType     = $parsedPattern[$pos]['token'];
-            $listenTypes[] = $tokenType;
-
-            $patternArray = [
-                'listen_pos'   => $pos,
-                'pattern'      => $parsedPattern,
-                'pattern_code' => $pattern,
-            ];
-
-            if (isset($this->parsedPatterns[$tokenType]) === false) {
-                $this->parsedPatterns[$tokenType] = [];
-            }
-
-            $this->parsedPatterns[$tokenType][] = $patternArray;
-        }//end foreach
-
-        return array_unique(array_merge($listenTypes, $this->supplementaryTokens));
-
-    }//end register()
-
-
-    /**
-     * Returns the token types that the specified pattern is checking for.
-     *
-     * Returned array is in the format:
-     * <code>
-     *   array(
-     *      T_WHITESPACE => 0, // 0 is the position where the T_WHITESPACE token
-     *                         // should occur in the pattern.
-     *   );
-     * </code>
-     *
-     * @param array $pattern The parsed pattern to find the acquire the token
-     *                       types from.
-     *
-     * @return array<int, int>
-     */
-    private function getPatternTokenTypes($pattern)
-    {
-        $tokenTypes = [];
-        foreach ($pattern as $pos => $patternInfo) {
-            if ($patternInfo['type'] === 'token') {
-                if (isset($tokenTypes[$patternInfo['token']]) === false) {
-                    $tokenTypes[$patternInfo['token']] = $pos;
-                }
-            }
-        }
-
-        return $tokenTypes;
-
-    }//end getPatternTokenTypes()
-
-
-    /**
-     * Returns the position in the pattern that this test should register as
-     * a listener for the pattern.
-     *
-     * @param array $pattern The pattern to acquire the listener for.
-     *
-     * @return int The position in the pattern that this test should register
-     *             as the listener.
-     * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If we could not determine a token to listen for.
-     */
-    private function getListenerTokenPos($pattern)
-    {
-        $tokenTypes = $this->getPatternTokenTypes($pattern);
-        $tokenCodes = array_keys($tokenTypes);
-        $token      = Tokens::getHighestWeightedToken($tokenCodes);
-
-        // If we could not get a token.
-        if ($token === false) {
-            $error = 'Could not determine a token to listen for';
-            throw new RuntimeException($error);
-        }
-
-        return $tokenTypes[$token];
-
-    }//end getListenerTokenPos()
-
-
-    /**
-     * Processes the test.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where the
-     *                                               token occurred.
-     * @param int                         $stackPtr  The position in the tokens stack
-     *                                               where the listening token type
-     *                                               was found.
-     *
-     * @return void
-     * @see    register()
-     */
-    final public function process(File $phpcsFile, $stackPtr)
-    {
-        $file = $phpcsFile->getFilename();
-        if ($this->currFile !== $file) {
-            // We have changed files, so clean up.
-            $this->errorPos = [];
-            $this->currFile = $file;
-        }
-
-        $tokens = $phpcsFile->getTokens();
-
-        if (in_array($tokens[$stackPtr]['code'], $this->supplementaryTokens, true) === true) {
-            $this->processSupplementary($phpcsFile, $stackPtr);
-        }
-
-        $type = $tokens[$stackPtr]['code'];
-
-        // If the type is not set, then it must have been a token registered
-        // with registerSupplementary().
-        if (isset($this->parsedPatterns[$type]) === false) {
-            return;
-        }
-
-        $allErrors = [];
-
-        // Loop over each pattern that is listening to the current token type
-        // that we are processing.
-        foreach ($this->parsedPatterns[$type] as $patternInfo) {
-            // If processPattern returns false, then the pattern that we are
-            // checking the code with must not be designed to check that code.
-            $errors = $this->processPattern($patternInfo, $phpcsFile, $stackPtr);
-            if ($errors === false) {
-                // The pattern didn't match.
-                continue;
-            } else if (empty($errors) === true) {
-                // The pattern matched, but there were no errors.
-                break;
-            }
-
-            foreach ($errors as $stackPtr => $error) {
-                if (isset($this->errorPos[$stackPtr]) === false) {
-                    $this->errorPos[$stackPtr] = true;
-                    $allErrors[$stackPtr]      = $error;
-                }
-            }
-        }
-
-        foreach ($allErrors as $stackPtr => $error) {
-            $phpcsFile->addError($error, $stackPtr, 'Found');
-        }
-
-    }//end process()
-
-
-    /**
-     * Processes the pattern and verifies the code at $stackPtr.
-     *
-     * @param array                       $patternInfo Information about the pattern used
-     *                                                 for checking, which includes are
-     *                                                 parsed token representation of the
-     *                                                 pattern.
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile   The PHP_CodeSniffer file where the
-     *                                                 token occurred.
-     * @param int                         $stackPtr    The position in the tokens stack where
-     *                                                 the listening token type was found.
-     *
-     * @return array
-     */
-    protected function processPattern($patternInfo, File $phpcsFile, $stackPtr)
-    {
-        $tokens      = $phpcsFile->getTokens();
-        $pattern     = $patternInfo['pattern'];
-        $patternCode = $patternInfo['pattern_code'];
-        $errors      = [];
-        $found       = '';
-
-        $ignoreTokens = [T_WHITESPACE => T_WHITESPACE];
-        if ($this->ignoreComments === true) {
-            $ignoreTokens += Tokens::$commentTokens;
-        }
-
-        $origStackPtr = $stackPtr;
-        $hasError     = false;
-
-        if ($patternInfo['listen_pos'] > 0) {
-            $stackPtr--;
-
-            for ($i = ($patternInfo['listen_pos'] - 1); $i >= 0; $i--) {
-                if ($pattern[$i]['type'] === 'token') {
-                    if ($pattern[$i]['token'] === T_WHITESPACE) {
-                        if ($tokens[$stackPtr]['code'] === T_WHITESPACE) {
-                            $found = $tokens[$stackPtr]['content'].$found;
-                        }
-
-                        // Only check the size of the whitespace if this is not
-                        // the first token. We don't care about the size of
-                        // leading whitespace, just that there is some.
-                        if ($i !== 0) {
-                            if ($tokens[$stackPtr]['content'] !== $pattern[$i]['value']) {
-                                $hasError = true;
-                            }
-                        }
-                    } else {
-                        // Check to see if this important token is the same as the
-                        // previous important token in the pattern. If it is not,
-                        // then the pattern cannot be for this piece of code.
-                        $prev = $phpcsFile->findPrevious(
-                            $ignoreTokens,
-                            $stackPtr,
-                            null,
-                            true
-                        );
-
-                        if ($prev === false
-                            || $tokens[$prev]['code'] !== $pattern[$i]['token']
-                        ) {
-                            return false;
-                        }
-
-                        // If we skipped past some whitespace tokens, then add them
-                        // to the found string.
-                        $tokenContent = $phpcsFile->getTokensAsString(
-                            ($prev + 1),
-                            ($stackPtr - $prev - 1)
-                        );
-
-                        $found = $tokens[$prev]['content'].$tokenContent.$found;
-
-                        if (isset($pattern[($i - 1)]) === true
-                            && $pattern[($i - 1)]['type'] === 'skip'
-                        ) {
-                            $stackPtr = $prev;
-                        } else {
-                            $stackPtr = ($prev - 1);
-                        }
-                    }//end if
-                } else if ($pattern[$i]['type'] === 'skip') {
-                    // Skip to next piece of relevant code.
-                    if ($pattern[$i]['to'] === 'parenthesis_closer') {
-                        $to = 'parenthesis_opener';
-                    } else {
-                        $to = 'scope_opener';
-                    }
-
-                    // Find the previous opener.
-                    $next = $phpcsFile->findPrevious(
-                        $ignoreTokens,
-                        $stackPtr,
-                        null,
-                        true
-                    );
-
-                    if ($next === false || isset($tokens[$next][$to]) === false) {
-                        // If there was not opener, then we must be
-                        // using the wrong pattern.
-                        return false;
-                    }
-
-                    if ($to === 'parenthesis_opener') {
-                        $found = '{'.$found;
-                    } else {
-                        $found = '('.$found;
-                    }
-
-                    $found = '...'.$found;
-
-                    // Skip to the opening token.
-                    $stackPtr = ($tokens[$next][$to] - 1);
-                } else if ($pattern[$i]['type'] === 'string') {
-                    $found = 'abc';
-                } else if ($pattern[$i]['type'] === 'newline') {
-                    if ($this->ignoreComments === true
-                        && isset(Tokens::$commentTokens[$tokens[$stackPtr]['code']]) === true
-                    ) {
-                        $startComment = $phpcsFile->findPrevious(
-                            Tokens::$commentTokens,
-                            ($stackPtr - 1),
-                            null,
-                            true
-                        );
-
-                        if ($tokens[$startComment]['line'] !== $tokens[($startComment + 1)]['line']) {
-                            $startComment++;
-                        }
-
-                        $tokenContent = $phpcsFile->getTokensAsString(
-                            $startComment,
-                            ($stackPtr - $startComment + 1)
-                        );
-
-                        $found    = $tokenContent.$found;
-                        $stackPtr = ($startComment - 1);
-                    }
-
-                    if ($tokens[$stackPtr]['code'] === T_WHITESPACE) {
-                        if ($tokens[$stackPtr]['content'] !== $phpcsFile->eolChar) {
-                            $found = $tokens[$stackPtr]['content'].$found;
-
-                            // This may just be an indent that comes after a newline
-                            // so check the token before to make sure. If it is a newline, we
-                            // can ignore the error here.
-                            if (($tokens[($stackPtr - 1)]['content'] !== $phpcsFile->eolChar)
-                                && ($this->ignoreComments === true
-                                && isset(Tokens::$commentTokens[$tokens[($stackPtr - 1)]['code']]) === false)
-                            ) {
-                                $hasError = true;
-                            } else {
-                                $stackPtr--;
-                            }
-                        } else {
-                            $found = 'EOL'.$found;
-                        }
-                    } else {
-                        $found    = $tokens[$stackPtr]['content'].$found;
-                        $hasError = true;
-                    }//end if
-
-                    if ($hasError === false && $pattern[($i - 1)]['type'] !== 'newline') {
-                        // Make sure they only have 1 newline.
-                        $prev = $phpcsFile->findPrevious($ignoreTokens, ($stackPtr - 1), null, true);
-                        if ($prev !== false && $tokens[$prev]['line'] !== $tokens[$stackPtr]['line']) {
-                            $hasError = true;
-                        }
-                    }
-                }//end if
-            }//end for
-        }//end if
-
-        $stackPtr          = $origStackPtr;
-        $lastAddedStackPtr = null;
-        $patternLen        = count($pattern);
-
-        for ($i = $patternInfo['listen_pos']; $i < $patternLen; $i++) {
-            if (isset($tokens[$stackPtr]) === false) {
-                break;
-            }
-
-            if ($pattern[$i]['type'] === 'token') {
-                if ($pattern[$i]['token'] === T_WHITESPACE) {
-                    if ($this->ignoreComments === true) {
-                        // If we are ignoring comments, check to see if this current
-                        // token is a comment. If so skip it.
-                        if (isset(Tokens::$commentTokens[$tokens[$stackPtr]['code']]) === true) {
-                            continue;
-                        }
-
-                        // If the next token is a comment, the we need to skip the
-                        // current token as we should allow a space before a
-                        // comment for readability.
-                        if (isset($tokens[($stackPtr + 1)]) === true
-                            && isset(Tokens::$commentTokens[$tokens[($stackPtr + 1)]['code']]) === true
-                        ) {
-                            continue;
-                        }
-                    }
-
-                    $tokenContent = '';
-                    if ($tokens[$stackPtr]['code'] === T_WHITESPACE) {
-                        if (isset($pattern[($i + 1)]) === false) {
-                            // This is the last token in the pattern, so just compare
-                            // the next token of content.
-                            $tokenContent = $tokens[$stackPtr]['content'];
-                        } else {
-                            // Get all the whitespace to the next token.
-                            $next = $phpcsFile->findNext(
-                                Tokens::$emptyTokens,
-                                $stackPtr,
-                                null,
-                                true
-                            );
-
-                            $tokenContent = $phpcsFile->getTokensAsString(
-                                $stackPtr,
-                                ($next - $stackPtr)
-                            );
-
-                            $lastAddedStackPtr = $stackPtr;
-                            $stackPtr          = $next;
-                        }//end if
-
-                        if ($stackPtr !== $lastAddedStackPtr) {
-                            $found .= $tokenContent;
-                        }
-                    } else {
-                        if ($stackPtr !== $lastAddedStackPtr) {
-                            $found            .= $tokens[$stackPtr]['content'];
-                            $lastAddedStackPtr = $stackPtr;
-                        }
-                    }//end if
-
-                    if (isset($pattern[($i + 1)]) === true
-                        && $pattern[($i + 1)]['type'] === 'skip'
-                    ) {
-                        // The next token is a skip token, so we just need to make
-                        // sure the whitespace we found has *at least* the
-                        // whitespace required.
-                        if (strpos($tokenContent, $pattern[$i]['value']) !== 0) {
-                            $hasError = true;
-                        }
-                    } else {
-                        if ($tokenContent !== $pattern[$i]['value']) {
-                            $hasError = true;
-                        }
-                    }
-                } else {
-                    // Check to see if this important token is the same as the
-                    // next important token in the pattern. If it is not, then
-                    // the pattern cannot be for this piece of code.
-                    $next = $phpcsFile->findNext(
-                        $ignoreTokens,
-                        $stackPtr,
-                        null,
-                        true
-                    );
-
-                    if ($next === false
-                        || $tokens[$next]['code'] !== $pattern[$i]['token']
-                    ) {
-                        // The next important token did not match the pattern.
-                        return false;
-                    }
-
-                    if ($lastAddedStackPtr !== null) {
-                        if (($tokens[$next]['code'] === T_OPEN_CURLY_BRACKET
-                            || $tokens[$next]['code'] === T_CLOSE_CURLY_BRACKET)
-                            && isset($tokens[$next]['scope_condition']) === true
-                            && $tokens[$next]['scope_condition'] > $lastAddedStackPtr
-                        ) {
-                            // This is a brace, but the owner of it is after the current
-                            // token, which means it does not belong to any token in
-                            // our pattern. This means the pattern is not for us.
-                            return false;
-                        }
-
-                        if (($tokens[$next]['code'] === T_OPEN_PARENTHESIS
-                            || $tokens[$next]['code'] === T_CLOSE_PARENTHESIS)
-                            && isset($tokens[$next]['parenthesis_owner']) === true
-                            && $tokens[$next]['parenthesis_owner'] > $lastAddedStackPtr
-                        ) {
-                            // This is a bracket, but the owner of it is after the current
-                            // token, which means it does not belong to any token in
-                            // our pattern. This means the pattern is not for us.
-                            return false;
-                        }
-                    }//end if
-
-                    // If we skipped past some whitespace tokens, then add them
-                    // to the found string.
-                    if (($next - $stackPtr) > 0) {
-                        $hasComment = false;
-                        for ($j = $stackPtr; $j < $next; $j++) {
-                            $found .= $tokens[$j]['content'];
-                            if (isset(Tokens::$commentTokens[$tokens[$j]['code']]) === true) {
-                                $hasComment = true;
-                            }
-                        }
-
-                        // If we are not ignoring comments, this additional
-                        // whitespace or comment is not allowed. If we are
-                        // ignoring comments, there needs to be at least one
-                        // comment for this to be allowed.
-                        if ($this->ignoreComments === false
-                            || ($this->ignoreComments === true
-                            && $hasComment === false)
-                        ) {
-                            $hasError = true;
-                        }
-
-                        // Even when ignoring comments, we are not allowed to include
-                        // newlines without the pattern specifying them, so
-                        // everything should be on the same line.
-                        if ($tokens[$next]['line'] !== $tokens[$stackPtr]['line']) {
-                            $hasError = true;
-                        }
-                    }//end if
-
-                    if ($next !== $lastAddedStackPtr) {
-                        $found            .= $tokens[$next]['content'];
-                        $lastAddedStackPtr = $next;
-                    }
-
-                    if (isset($pattern[($i + 1)]) === true
-                        && $pattern[($i + 1)]['type'] === 'skip'
-                    ) {
-                        $stackPtr = $next;
-                    } else {
-                        $stackPtr = ($next + 1);
-                    }
-                }//end if
-            } else if ($pattern[$i]['type'] === 'skip') {
-                if ($pattern[$i]['to'] === 'unknown') {
-                    $next = $phpcsFile->findNext(
-                        $pattern[($i + 1)]['token'],
-                        $stackPtr
-                    );
-
-                    if ($next === false) {
-                        // Couldn't find the next token, so we must
-                        // be using the wrong pattern.
-                        return false;
-                    }
-
-                    $found   .= '...';
-                    $stackPtr = $next;
-                } else {
-                    // Find the previous opener.
-                    $next = $phpcsFile->findPrevious(
-                        Tokens::$blockOpeners,
-                        $stackPtr
-                    );
-
-                    if ($next === false
-                        || isset($tokens[$next][$pattern[$i]['to']]) === false
-                    ) {
-                        // If there was not opener, then we must
-                        // be using the wrong pattern.
-                        return false;
-                    }
-
-                    $found .= '...';
-                    if ($pattern[$i]['to'] === 'parenthesis_closer') {
-                        $found .= ')';
-                    } else {
-                        $found .= '}';
-                    }
-
-                    // Skip to the closing token.
-                    $stackPtr = ($tokens[$next][$pattern[$i]['to']] + 1);
-                }//end if
-            } else if ($pattern[$i]['type'] === 'string') {
-                if ($tokens[$stackPtr]['code'] !== T_STRING) {
-                    $hasError = true;
-                }
-
-                if ($stackPtr !== $lastAddedStackPtr) {
-                    $found            .= 'abc';
-                    $lastAddedStackPtr = $stackPtr;
-                }
-
-                $stackPtr++;
-            } else if ($pattern[$i]['type'] === 'newline') {
-                // Find the next token that contains a newline character.
-                $newline = 0;
-                for ($j = $stackPtr; $j < $phpcsFile->numTokens; $j++) {
-                    if (strpos($tokens[$j]['content'], $phpcsFile->eolChar) !== false) {
-                        $newline = $j;
-                        break;
-                    }
-                }
-
-                if ($newline === 0) {
-                    // We didn't find a newline character in the rest of the file.
-                    $next     = ($phpcsFile->numTokens - 1);
-                    $hasError = true;
-                } else {
-                    if ($this->ignoreComments === false) {
-                        // The newline character cannot be part of a comment.
-                        if (isset(Tokens::$commentTokens[$tokens[$newline]['code']]) === true) {
-                            $hasError = true;
-                        }
-                    }
-
-                    if ($newline === $stackPtr) {
-                        $next = ($stackPtr + 1);
-                    } else {
-                        // Check that there were no significant tokens that we
-                        // skipped over to find our newline character.
-                        $next = $phpcsFile->findNext(
-                            $ignoreTokens,
-                            $stackPtr,
-                            null,
-                            true
-                        );
-
-                        if ($next < $newline) {
-                            // We skipped a non-ignored token.
-                            $hasError = true;
-                        } else {
-                            $next = ($newline + 1);
-                        }
-                    }
-                }//end if
-
-                if ($stackPtr !== $lastAddedStackPtr) {
-                    $found .= $phpcsFile->getTokensAsString(
-                        $stackPtr,
-                        ($next - $stackPtr)
-                    );
-
-                    $lastAddedStackPtr = ($next - 1);
-                }
-
-                $stackPtr = $next;
-            }//end if
-        }//end for
-
-        if ($hasError === true) {
-            $error = $this->prepareError($found, $patternCode);
-            $errors[$origStackPtr] = $error;
-        }
-
-        return $errors;
-
-    }//end processPattern()
-
-
-    /**
-     * Prepares an error for the specified patternCode.
-     *
-     * @param string $found       The actual found string in the code.
-     * @param string $patternCode The expected pattern code.
-     *
-     * @return string The error message.
-     */
-    protected function prepareError($found, $patternCode)
-    {
-        $found    = str_replace("\r\n", '\n', $found);
-        $found    = str_replace("\n", '\n', $found);
-        $found    = str_replace("\r", '\n', $found);
-        $found    = str_replace("\t", '\t', $found);
-        $found    = str_replace('EOL', '\n', $found);
-        $expected = str_replace('EOL', '\n', $patternCode);
-
-        $error = "Expected \"$expected\"; found \"$found\"";
-
-        return $error;
-
-    }//end prepareError()
-
-
-    /**
-     * Returns the patterns that should be checked.
-     *
-     * @return string[]
-     */
-    abstract protected function getPatterns();
-
-
-    /**
-     * Registers any supplementary tokens that this test might wish to process.
-     *
-     * A sniff may wish to register supplementary tests when it wishes to group
-     * an arbitrary validation that cannot be performed using a pattern, with
-     * other pattern tests.
-     *
-     * @return int[]
-     * @see    processSupplementary()
-     */
-    protected function registerSupplementary()
-    {
-        return [];
-
-    }//end registerSupplementary()
-
-
-     /**
-      * Processes any tokens registered with registerSupplementary().
-      *
-      * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where to
-      *                                               process the skip.
-      * @param int                         $stackPtr  The position in the tokens stack to
-      *                                               process.
-      *
-      * @return void
-      * @see    registerSupplementary()
-      */
-    protected function processSupplementary(File $phpcsFile, $stackPtr)
-    {
-
-    }//end processSupplementary()
-
-
-    /**
-     * Parses a pattern string into an array of pattern steps.
-     *
-     * @param string $pattern The pattern to parse.
-     *
-     * @return array The parsed pattern array.
-     * @see    createSkipPattern()
-     * @see    createTokenPattern()
-     */
-    private function parse($pattern)
-    {
-        $patterns   = [];
-        $length     = strlen($pattern);
-        $lastToken  = 0;
-        $firstToken = 0;
-
-        for ($i = 0; $i < $length; $i++) {
-            $specialPattern = false;
-            $isLastChar     = ($i === ($length - 1));
-            $oldFirstToken  = $firstToken;
-
-            if (substr($pattern, $i, 3) === '...') {
-                // It's a skip pattern. The skip pattern requires the
-                // content of the token in the "from" position and the token
-                // to skip to.
-                $specialPattern = $this->createSkipPattern($pattern, ($i - 1));
-                $lastToken      = ($i - $firstToken);
-                $firstToken     = ($i + 3);
-                $i += 2;
-
-                if ($specialPattern['to'] !== 'unknown') {
-                    $firstToken++;
-                }
-            } else if (substr($pattern, $i, 3) === 'abc') {
-                $specialPattern = ['type' => 'string'];
-                $lastToken      = ($i - $firstToken);
-                $firstToken     = ($i + 3);
-                $i += 2;
-            } else if (substr($pattern, $i, 3) === 'EOL') {
-                $specialPattern = ['type' => 'newline'];
-                $lastToken      = ($i - $firstToken);
-                $firstToken     = ($i + 3);
-                $i += 2;
-            }//end if
-
-            if ($specialPattern !== false || $isLastChar === true) {
-                // If we are at the end of the string, don't worry about a limit.
-                if ($isLastChar === true) {
-                    // Get the string from the end of the last skip pattern, if any,
-                    // to the end of the pattern string.
-                    $str = substr($pattern, $oldFirstToken);
-                } else {
-                    // Get the string from the end of the last special pattern,
-                    // if any, to the start of this special pattern.
-                    if ($lastToken === 0) {
-                        // Note that if the last special token was zero characters ago,
-                        // there will be nothing to process so we can skip this bit.
-                        // This happens if you have something like: EOL... in your pattern.
-                        $str = '';
-                    } else {
-                        $str = substr($pattern, $oldFirstToken, $lastToken);
-                    }
-                }
-
-                if ($str !== '') {
-                    $tokenPatterns = $this->createTokenPattern($str);
-                    foreach ($tokenPatterns as $tokenPattern) {
-                        $patterns[] = $tokenPattern;
-                    }
-                }
-
-                // Make sure we don't skip the last token.
-                if ($isLastChar === false && $i === ($length - 1)) {
-                    $i--;
-                }
-            }//end if
-
-            // Add the skip pattern *after* we have processed
-            // all the tokens from the end of the last skip pattern
-            // to the start of this skip pattern.
-            if ($specialPattern !== false) {
-                $patterns[] = $specialPattern;
-            }
-        }//end for
-
-        return $patterns;
-
-    }//end parse()
-
-
-    /**
-     * Creates a skip pattern.
-     *
-     * @param string $pattern The pattern being parsed.
-     * @param string $from    The token content that the skip pattern starts from.
-     *
-     * @return array The pattern step.
-     * @see    createTokenPattern()
-     * @see    parse()
-     */
-    private function createSkipPattern($pattern, $from)
-    {
-        $skip = ['type' => 'skip'];
-
-        $nestedParenthesis = 0;
-        $nestedBraces      = 0;
-        for ($start = $from; $start >= 0; $start--) {
-            switch ($pattern[$start]) {
-            case '(':
-                if ($nestedParenthesis === 0) {
-                    $skip['to'] = 'parenthesis_closer';
-                }
-
-                $nestedParenthesis--;
-                break;
-            case '{':
-                if ($nestedBraces === 0) {
-                    $skip['to'] = 'scope_closer';
-                }
-
-                $nestedBraces--;
-                break;
-            case '}':
-                $nestedBraces++;
-                break;
-            case ')':
-                $nestedParenthesis++;
-                break;
-            }//end switch
-
-            if (isset($skip['to']) === true) {
-                break;
-            }
-        }//end for
-
-        if (isset($skip['to']) === false) {
-            $skip['to'] = 'unknown';
-        }
-
-        return $skip;
-
-    }//end createSkipPattern()
-
-
-    /**
-     * Creates a token pattern.
-     *
-     * @param string $str The tokens string that the pattern should match.
-     *
-     * @return array The pattern step.
-     * @see    createSkipPattern()
-     * @see    parse()
-     */
-    private function createTokenPattern($str)
-    {
-        // Don't add a space after the closing php tag as it will add a new
-        // whitespace token.
-        $tokenizer = new PHP('<?php '.$str.'?>', null);
-
-        // Remove the <?php tag from the front and the end php tag from the back.
-        $tokens = $tokenizer->getTokens();
-        $tokens = array_slice($tokens, 1, (count($tokens) - 2));
-
-        $patterns = [];
-        foreach ($tokens as $patternInfo) {
-            $patterns[] = [
-                'type'  => 'token',
-                'token' => $patternInfo['code'],
-                'value' => $patternInfo['content'],
-            ];
-        }
-
-        return $patterns;
-
-    }//end createTokenPattern()
+	/**
+	 * If true, comments will be ignored if they are found in the code.
+	 *
+	 * @var boolean
+	 */
+	public $ignoreComments = false;
+
+	/**
+	 * The current file being checked.
+	 *
+	 * @var string
+	 */
+	protected $currFile = '';
+
+	/**
+	 * The parsed patterns array.
+	 *
+	 * @var array
+	 */
+	private $parsedPatterns = [];
+
+	/**
+	 * Tokens that this sniff wishes to process outside of the patterns.
+	 *
+	 * @var int[]
+	 * @see registerSupplementary()
+	 * @see processSupplementary()
+	 */
+	private $supplementaryTokens = [];
+
+	/**
+	 * Positions in the stack where errors have occurred.
+	 *
+	 * @var array<int, bool>
+	 */
+	private $errorPos = [];
+
+
+	/**
+	 * Constructs a AbstractPatternSniff.
+	 *
+	 * @param boolean $ignoreComments If true, comments will be ignored.
+	 */
+	public function __construct($ignoreComments=null)
+	{
+		// This is here for backwards compatibility.
+		if ($ignoreComments !== null) {
+			$this->ignoreComments = $ignoreComments;
+		}
+
+		$this->supplementaryTokens = $this->registerSupplementary();
+
+	}//end __construct()
+
+
+	/**
+	 * Registers the tokens to listen to.
+	 *
+	 * Classes extending <i>AbstractPatternTest</i> should implement the
+	 * <i>getPatterns()</i> method to register the patterns they wish to test.
+	 *
+	 * @return int[]
+	 * @see    process()
+	 */
+	final public function register()
+	{
+		$listenTypes = [];
+		$patterns    = $this->getPatterns();
+
+		foreach ($patterns as $pattern) {
+			$parsedPattern = $this->parse($pattern);
+
+			// Find a token position in the pattern that we can use
+			// for a listener token.
+			$pos           = $this->getListenerTokenPos($parsedPattern);
+			$tokenType     = $parsedPattern[$pos]['token'];
+			$listenTypes[] = $tokenType;
+
+			$patternArray = [
+				'listen_pos'   => $pos,
+				'pattern'      => $parsedPattern,
+				'pattern_code' => $pattern,
+			];
+
+			if (isset($this->parsedPatterns[$tokenType]) === false) {
+				$this->parsedPatterns[$tokenType] = [];
+			}
+
+			$this->parsedPatterns[$tokenType][] = $patternArray;
+		}//end foreach
+
+		return array_unique(array_merge($listenTypes, $this->supplementaryTokens));
+
+	}//end register()
+
+
+	/**
+	 * Returns the token types that the specified pattern is checking for.
+	 *
+	 * Returned array is in the format:
+	 * <code>
+	 *   array(
+	 *      T_WHITESPACE => 0, // 0 is the position where the T_WHITESPACE token
+	 *                         // should occur in the pattern.
+	 *   );
+	 * </code>
+	 *
+	 * @param array $pattern The parsed pattern to find the acquire the token
+	 *                       types from.
+	 *
+	 * @return array<int, int>
+	 */
+	private function getPatternTokenTypes($pattern)
+	{
+		$tokenTypes = [];
+		foreach ($pattern as $pos => $patternInfo) {
+			if ($patternInfo['type'] === 'token') {
+				if (isset($tokenTypes[$patternInfo['token']]) === false) {
+					$tokenTypes[$patternInfo['token']] = $pos;
+				}
+			}
+		}
+
+		return $tokenTypes;
+
+	}//end getPatternTokenTypes()
+
+
+	/**
+	 * Returns the position in the pattern that this test should register as
+	 * a listener for the pattern.
+	 *
+	 * @param array $pattern The pattern to acquire the listener for.
+	 *
+	 * @return int The position in the pattern that this test should register
+	 *             as the listener.
+	 * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If we could not determine a token to listen for.
+	 */
+	private function getListenerTokenPos($pattern)
+	{
+		$tokenTypes = $this->getPatternTokenTypes($pattern);
+		$tokenCodes = array_keys($tokenTypes);
+		$token      = Tokens::getHighestWeightedToken($tokenCodes);
+
+		// If we could not get a token.
+		if ($token === false) {
+			$error = 'Could not determine a token to listen for';
+			throw new RuntimeException($error);
+		}
+
+		return $tokenTypes[$token];
+
+	}//end getListenerTokenPos()
+
+
+	/**
+	 * Processes the test.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where the
+	 *                                               token occurred.
+	 * @param int                         $stackPtr  The position in the tokens stack
+	 *                                               where the listening token type
+	 *                                               was found.
+	 *
+	 * @return void
+	 * @see    register()
+	 */
+	final public function process(File $phpcsFile, $stackPtr)
+	{
+		$file = $phpcsFile->getFilename();
+		if ($this->currFile !== $file) {
+			// We have changed files, so clean up.
+			$this->errorPos = [];
+			$this->currFile = $file;
+		}
+
+		$tokens = $phpcsFile->getTokens();
+
+		if (in_array($tokens[$stackPtr]['code'], $this->supplementaryTokens, true) === true) {
+			$this->processSupplementary($phpcsFile, $stackPtr);
+		}
+
+		$type = $tokens[$stackPtr]['code'];
+
+		// If the type is not set, then it must have been a token registered
+		// with registerSupplementary().
+		if (isset($this->parsedPatterns[$type]) === false) {
+			return;
+		}
+
+		$allErrors = [];
+
+		// Loop over each pattern that is listening to the current token type
+		// that we are processing.
+		foreach ($this->parsedPatterns[$type] as $patternInfo) {
+			// If processPattern returns false, then the pattern that we are
+			// checking the code with must not be designed to check that code.
+			$errors = $this->processPattern($patternInfo, $phpcsFile, $stackPtr);
+			if ($errors === false) {
+				// The pattern didn't match.
+				continue;
+			} else if (empty($errors) === true) {
+				// The pattern matched, but there were no errors.
+				break;
+			}
+
+			foreach ($errors as $stackPtr => $error) {
+				if (isset($this->errorPos[$stackPtr]) === false) {
+					$this->errorPos[$stackPtr] = true;
+					$allErrors[$stackPtr]      = $error;
+				}
+			}
+		}
+
+		foreach ($allErrors as $stackPtr => $error) {
+			$phpcsFile->addError($error, $stackPtr, 'Found');
+		}
+
+	}//end process()
+
+
+	/**
+	 * Processes the pattern and verifies the code at $stackPtr.
+	 *
+	 * @param array                       $patternInfo Information about the pattern used
+	 *                                                 for checking, which includes are
+	 *                                                 parsed token representation of the
+	 *                                                 pattern.
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile   The PHP_CodeSniffer file where the
+	 *                                                 token occurred.
+	 * @param int                         $stackPtr    The position in the tokens stack where
+	 *                                                 the listening token type was found.
+	 *
+	 * @return array
+	 */
+	protected function processPattern($patternInfo, File $phpcsFile, $stackPtr)
+	{
+		$tokens      = $phpcsFile->getTokens();
+		$pattern     = $patternInfo['pattern'];
+		$patternCode = $patternInfo['pattern_code'];
+		$errors      = [];
+		$found       = '';
+
+		$ignoreTokens = [T_WHITESPACE => T_WHITESPACE];
+		if ($this->ignoreComments === true) {
+			$ignoreTokens += Tokens::$commentTokens;
+		}
+
+		$origStackPtr = $stackPtr;
+		$hasError     = false;
+
+		if ($patternInfo['listen_pos'] > 0) {
+			$stackPtr--;
+
+			for ($i = ($patternInfo['listen_pos'] - 1); $i >= 0; $i--) {
+				if ($pattern[$i]['type'] === 'token') {
+					if ($pattern[$i]['token'] === T_WHITESPACE) {
+						if ($tokens[$stackPtr]['code'] === T_WHITESPACE) {
+							$found = $tokens[$stackPtr]['content'].$found;
+						}
+
+						// Only check the size of the whitespace if this is not
+						// the first token. We don't care about the size of
+						// leading whitespace, just that there is some.
+						if ($i !== 0) {
+							if ($tokens[$stackPtr]['content'] !== $pattern[$i]['value']) {
+								$hasError = true;
+							}
+						}
+					} else {
+						// Check to see if this important token is the same as the
+						// previous important token in the pattern. If it is not,
+						// then the pattern cannot be for this piece of code.
+						$prev = $phpcsFile->findPrevious(
+							$ignoreTokens,
+							$stackPtr,
+							null,
+							true
+						);
+
+						if ($prev === false
+							|| $tokens[$prev]['code'] !== $pattern[$i]['token']
+						) {
+							return false;
+						}
+
+						// If we skipped past some whitespace tokens, then add them
+						// to the found string.
+						$tokenContent = $phpcsFile->getTokensAsString(
+							($prev + 1),
+							($stackPtr - $prev - 1)
+						);
+
+						$found = $tokens[$prev]['content'].$tokenContent.$found;
+
+						if (isset($pattern[($i - 1)]) === true
+							&& $pattern[($i - 1)]['type'] === 'skip'
+						) {
+							$stackPtr = $prev;
+						} else {
+							$stackPtr = ($prev - 1);
+						}
+					}//end if
+				} else if ($pattern[$i]['type'] === 'skip') {
+					// Skip to next piece of relevant code.
+					if ($pattern[$i]['to'] === 'parenthesis_closer') {
+						$to = 'parenthesis_opener';
+					} else {
+						$to = 'scope_opener';
+					}
+
+					// Find the previous opener.
+					$next = $phpcsFile->findPrevious(
+						$ignoreTokens,
+						$stackPtr,
+						null,
+						true
+					);
+
+					if ($next === false || isset($tokens[$next][$to]) === false) {
+						// If there was not opener, then we must be
+						// using the wrong pattern.
+						return false;
+					}
+
+					if ($to === 'parenthesis_opener') {
+						$found = '{'.$found;
+					} else {
+						$found = '('.$found;
+					}
+
+					$found = '...'.$found;
+
+					// Skip to the opening token.
+					$stackPtr = ($tokens[$next][$to] - 1);
+				} else if ($pattern[$i]['type'] === 'string') {
+					$found = 'abc';
+				} else if ($pattern[$i]['type'] === 'newline') {
+					if ($this->ignoreComments === true
+						&& isset(Tokens::$commentTokens[$tokens[$stackPtr]['code']]) === true
+					) {
+						$startComment = $phpcsFile->findPrevious(
+							Tokens::$commentTokens,
+							($stackPtr - 1),
+							null,
+							true
+						);
+
+						if ($tokens[$startComment]['line'] !== $tokens[($startComment + 1)]['line']) {
+							$startComment++;
+						}
+
+						$tokenContent = $phpcsFile->getTokensAsString(
+							$startComment,
+							($stackPtr - $startComment + 1)
+						);
+
+						$found    = $tokenContent.$found;
+						$stackPtr = ($startComment - 1);
+					}
+
+					if ($tokens[$stackPtr]['code'] === T_WHITESPACE) {
+						if ($tokens[$stackPtr]['content'] !== $phpcsFile->eolChar) {
+							$found = $tokens[$stackPtr]['content'].$found;
+
+							// This may just be an indent that comes after a newline
+							// so check the token before to make sure. If it is a newline, we
+							// can ignore the error here.
+							if (($tokens[($stackPtr - 1)]['content'] !== $phpcsFile->eolChar)
+								&& ($this->ignoreComments === true
+								&& isset(Tokens::$commentTokens[$tokens[($stackPtr - 1)]['code']]) === false)
+							) {
+								$hasError = true;
+							} else {
+								$stackPtr--;
+							}
+						} else {
+							$found = 'EOL'.$found;
+						}
+					} else {
+						$found    = $tokens[$stackPtr]['content'].$found;
+						$hasError = true;
+					}//end if
+
+					if ($hasError === false && $pattern[($i - 1)]['type'] !== 'newline') {
+						// Make sure they only have 1 newline.
+						$prev = $phpcsFile->findPrevious($ignoreTokens, ($stackPtr - 1), null, true);
+						if ($prev !== false && $tokens[$prev]['line'] !== $tokens[$stackPtr]['line']) {
+							$hasError = true;
+						}
+					}
+				}//end if
+			}//end for
+		}//end if
+
+		$stackPtr          = $origStackPtr;
+		$lastAddedStackPtr = null;
+		$patternLen        = count($pattern);
+
+		for ($i = $patternInfo['listen_pos']; $i < $patternLen; $i++) {
+			if (isset($tokens[$stackPtr]) === false) {
+				break;
+			}
+
+			if ($pattern[$i]['type'] === 'token') {
+				if ($pattern[$i]['token'] === T_WHITESPACE) {
+					if ($this->ignoreComments === true) {
+						// If we are ignoring comments, check to see if this current
+						// token is a comment. If so skip it.
+						if (isset(Tokens::$commentTokens[$tokens[$stackPtr]['code']]) === true) {
+							continue;
+						}
+
+						// If the next token is a comment, the we need to skip the
+						// current token as we should allow a space before a
+						// comment for readability.
+						if (isset($tokens[($stackPtr + 1)]) === true
+							&& isset(Tokens::$commentTokens[$tokens[($stackPtr + 1)]['code']]) === true
+						) {
+							continue;
+						}
+					}
+
+					$tokenContent = '';
+					if ($tokens[$stackPtr]['code'] === T_WHITESPACE) {
+						if (isset($pattern[($i + 1)]) === false) {
+							// This is the last token in the pattern, so just compare
+							// the next token of content.
+							$tokenContent = $tokens[$stackPtr]['content'];
+						} else {
+							// Get all the whitespace to the next token.
+							$next = $phpcsFile->findNext(
+								Tokens::$emptyTokens,
+								$stackPtr,
+								null,
+								true
+							);
+
+							$tokenContent = $phpcsFile->getTokensAsString(
+								$stackPtr,
+								($next - $stackPtr)
+							);
+
+							$lastAddedStackPtr = $stackPtr;
+							$stackPtr          = $next;
+						}//end if
+
+						if ($stackPtr !== $lastAddedStackPtr) {
+							$found .= $tokenContent;
+						}
+					} else {
+						if ($stackPtr !== $lastAddedStackPtr) {
+							$found            .= $tokens[$stackPtr]['content'];
+							$lastAddedStackPtr = $stackPtr;
+						}
+					}//end if
+
+					if (isset($pattern[($i + 1)]) === true
+						&& $pattern[($i + 1)]['type'] === 'skip'
+					) {
+						// The next token is a skip token, so we just need to make
+						// sure the whitespace we found has *at least* the
+						// whitespace required.
+						if (strpos($tokenContent, $pattern[$i]['value']) !== 0) {
+							$hasError = true;
+						}
+					} else {
+						if ($tokenContent !== $pattern[$i]['value']) {
+							$hasError = true;
+						}
+					}
+				} else {
+					// Check to see if this important token is the same as the
+					// next important token in the pattern. If it is not, then
+					// the pattern cannot be for this piece of code.
+					$next = $phpcsFile->findNext(
+						$ignoreTokens,
+						$stackPtr,
+						null,
+						true
+					);
+
+					if ($next === false
+						|| $tokens[$next]['code'] !== $pattern[$i]['token']
+					) {
+						// The next important token did not match the pattern.
+						return false;
+					}
+
+					if ($lastAddedStackPtr !== null) {
+						if (($tokens[$next]['code'] === T_OPEN_CURLY_BRACKET
+							|| $tokens[$next]['code'] === T_CLOSE_CURLY_BRACKET)
+							&& isset($tokens[$next]['scope_condition']) === true
+							&& $tokens[$next]['scope_condition'] > $lastAddedStackPtr
+						) {
+							// This is a brace, but the owner of it is after the current
+							// token, which means it does not belong to any token in
+							// our pattern. This means the pattern is not for us.
+							return false;
+						}
+
+						if (($tokens[$next]['code'] === T_OPEN_PARENTHESIS
+							|| $tokens[$next]['code'] === T_CLOSE_PARENTHESIS)
+							&& isset($tokens[$next]['parenthesis_owner']) === true
+							&& $tokens[$next]['parenthesis_owner'] > $lastAddedStackPtr
+						) {
+							// This is a bracket, but the owner of it is after the current
+							// token, which means it does not belong to any token in
+							// our pattern. This means the pattern is not for us.
+							return false;
+						}
+					}//end if
+
+					// If we skipped past some whitespace tokens, then add them
+					// to the found string.
+					if (($next - $stackPtr) > 0) {
+						$hasComment = false;
+						for ($j = $stackPtr; $j < $next; $j++) {
+							$found .= $tokens[$j]['content'];
+							if (isset(Tokens::$commentTokens[$tokens[$j]['code']]) === true) {
+								$hasComment = true;
+							}
+						}
+
+						// If we are not ignoring comments, this additional
+						// whitespace or comment is not allowed. If we are
+						// ignoring comments, there needs to be at least one
+						// comment for this to be allowed.
+						if ($this->ignoreComments === false
+							|| ($this->ignoreComments === true
+							&& $hasComment === false)
+						) {
+							$hasError = true;
+						}
+
+						// Even when ignoring comments, we are not allowed to include
+						// newlines without the pattern specifying them, so
+						// everything should be on the same line.
+						if ($tokens[$next]['line'] !== $tokens[$stackPtr]['line']) {
+							$hasError = true;
+						}
+					}//end if
+
+					if ($next !== $lastAddedStackPtr) {
+						$found            .= $tokens[$next]['content'];
+						$lastAddedStackPtr = $next;
+					}
+
+					if (isset($pattern[($i + 1)]) === true
+						&& $pattern[($i + 1)]['type'] === 'skip'
+					) {
+						$stackPtr = $next;
+					} else {
+						$stackPtr = ($next + 1);
+					}
+				}//end if
+			} else if ($pattern[$i]['type'] === 'skip') {
+				if ($pattern[$i]['to'] === 'unknown') {
+					$next = $phpcsFile->findNext(
+						$pattern[($i + 1)]['token'],
+						$stackPtr
+					);
+
+					if ($next === false) {
+						// Couldn't find the next token, so we must
+						// be using the wrong pattern.
+						return false;
+					}
+
+					$found   .= '...';
+					$stackPtr = $next;
+				} else {
+					// Find the previous opener.
+					$next = $phpcsFile->findPrevious(
+						Tokens::$blockOpeners,
+						$stackPtr
+					);
+
+					if ($next === false
+						|| isset($tokens[$next][$pattern[$i]['to']]) === false
+					) {
+						// If there was not opener, then we must
+						// be using the wrong pattern.
+						return false;
+					}
+
+					$found .= '...';
+					if ($pattern[$i]['to'] === 'parenthesis_closer') {
+						$found .= ')';
+					} else {
+						$found .= '}';
+					}
+
+					// Skip to the closing token.
+					$stackPtr = ($tokens[$next][$pattern[$i]['to']] + 1);
+				}//end if
+			} else if ($pattern[$i]['type'] === 'string') {
+				if ($tokens[$stackPtr]['code'] !== T_STRING) {
+					$hasError = true;
+				}
+
+				if ($stackPtr !== $lastAddedStackPtr) {
+					$found            .= 'abc';
+					$lastAddedStackPtr = $stackPtr;
+				}
+
+				$stackPtr++;
+			} else if ($pattern[$i]['type'] === 'newline') {
+				// Find the next token that contains a newline character.
+				$newline = 0;
+				for ($j = $stackPtr; $j < $phpcsFile->numTokens; $j++) {
+					if (strpos($tokens[$j]['content'], $phpcsFile->eolChar) !== false) {
+						$newline = $j;
+						break;
+					}
+				}
+
+				if ($newline === 0) {
+					// We didn't find a newline character in the rest of the file.
+					$next     = ($phpcsFile->numTokens - 1);
+					$hasError = true;
+				} else {
+					if ($this->ignoreComments === false) {
+						// The newline character cannot be part of a comment.
+						if (isset(Tokens::$commentTokens[$tokens[$newline]['code']]) === true) {
+							$hasError = true;
+						}
+					}
+
+					if ($newline === $stackPtr) {
+						$next = ($stackPtr + 1);
+					} else {
+						// Check that there were no significant tokens that we
+						// skipped over to find our newline character.
+						$next = $phpcsFile->findNext(
+							$ignoreTokens,
+							$stackPtr,
+							null,
+							true
+						);
+
+						if ($next < $newline) {
+							// We skipped a non-ignored token.
+							$hasError = true;
+						} else {
+							$next = ($newline + 1);
+						}
+					}
+				}//end if
+
+				if ($stackPtr !== $lastAddedStackPtr) {
+					$found .= $phpcsFile->getTokensAsString(
+						$stackPtr,
+						($next - $stackPtr)
+					);
+
+					$lastAddedStackPtr = ($next - 1);
+				}
+
+				$stackPtr = $next;
+			}//end if
+		}//end for
+
+		if ($hasError === true) {
+			$error = $this->prepareError($found, $patternCode);
+			$errors[$origStackPtr] = $error;
+		}
+
+		return $errors;
+
+	}//end processPattern()
+
+
+	/**
+	 * Prepares an error for the specified patternCode.
+	 *
+	 * @param string $found       The actual found string in the code.
+	 * @param string $patternCode The expected pattern code.
+	 *
+	 * @return string The error message.
+	 */
+	protected function prepareError($found, $patternCode)
+	{
+		$found    = str_replace("\r\n", '\n', $found);
+		$found    = str_replace("\n", '\n', $found);
+		$found    = str_replace("\r", '\n', $found);
+		$found    = str_replace("\t", '\t', $found);
+		$found    = str_replace('EOL', '\n', $found);
+		$expected = str_replace('EOL', '\n', $patternCode);
+
+		$error = "Expected \"$expected\"; found \"$found\"";
+
+		return $error;
+
+	}//end prepareError()
+
+
+	/**
+	 * Returns the patterns that should be checked.
+	 *
+	 * @return string[]
+	 */
+	abstract protected function getPatterns();
+
+
+	/**
+	 * Registers any supplementary tokens that this test might wish to process.
+	 *
+	 * A sniff may wish to register supplementary tests when it wishes to group
+	 * an arbitrary validation that cannot be performed using a pattern, with
+	 * other pattern tests.
+	 *
+	 * @return int[]
+	 * @see    processSupplementary()
+	 */
+	protected function registerSupplementary()
+	{
+		return [];
+
+	}//end registerSupplementary()
+
+
+	 /**
+	  * Processes any tokens registered with registerSupplementary().
+	  *
+	  * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where to
+	  *                                               process the skip.
+	  * @param int                         $stackPtr  The position in the tokens stack to
+	  *                                               process.
+	  *
+	  * @return void
+	  * @see    registerSupplementary()
+	  */
+	protected function processSupplementary(File $phpcsFile, $stackPtr)
+	{
+
+	}//end processSupplementary()
+
+
+	/**
+	 * Parses a pattern string into an array of pattern steps.
+	 *
+	 * @param string $pattern The pattern to parse.
+	 *
+	 * @return array The parsed pattern array.
+	 * @see    createSkipPattern()
+	 * @see    createTokenPattern()
+	 */
+	private function parse($pattern)
+	{
+		$patterns   = [];
+		$length     = strlen($pattern);
+		$lastToken  = 0;
+		$firstToken = 0;
+
+		for ($i = 0; $i < $length; $i++) {
+			$specialPattern = false;
+			$isLastChar     = ($i === ($length - 1));
+			$oldFirstToken  = $firstToken;
+
+			if (substr($pattern, $i, 3) === '...') {
+				// It's a skip pattern. The skip pattern requires the
+				// content of the token in the "from" position and the token
+				// to skip to.
+				$specialPattern = $this->createSkipPattern($pattern, ($i - 1));
+				$lastToken      = ($i - $firstToken);
+				$firstToken     = ($i + 3);
+				$i += 2;
+
+				if ($specialPattern['to'] !== 'unknown') {
+					$firstToken++;
+				}
+			} else if (substr($pattern, $i, 3) === 'abc') {
+				$specialPattern = ['type' => 'string'];
+				$lastToken      = ($i - $firstToken);
+				$firstToken     = ($i + 3);
+				$i += 2;
+			} else if (substr($pattern, $i, 3) === 'EOL') {
+				$specialPattern = ['type' => 'newline'];
+				$lastToken      = ($i - $firstToken);
+				$firstToken     = ($i + 3);
+				$i += 2;
+			}//end if
+
+			if ($specialPattern !== false || $isLastChar === true) {
+				// If we are at the end of the string, don't worry about a limit.
+				if ($isLastChar === true) {
+					// Get the string from the end of the last skip pattern, if any,
+					// to the end of the pattern string.
+					$str = substr($pattern, $oldFirstToken);
+				} else {
+					// Get the string from the end of the last special pattern,
+					// if any, to the start of this special pattern.
+					if ($lastToken === 0) {
+						// Note that if the last special token was zero characters ago,
+						// there will be nothing to process so we can skip this bit.
+						// This happens if you have something like: EOL... in your pattern.
+						$str = '';
+					} else {
+						$str = substr($pattern, $oldFirstToken, $lastToken);
+					}
+				}
+
+				if ($str !== '') {
+					$tokenPatterns = $this->createTokenPattern($str);
+					foreach ($tokenPatterns as $tokenPattern) {
+						$patterns[] = $tokenPattern;
+					}
+				}
+
+				// Make sure we don't skip the last token.
+				if ($isLastChar === false && $i === ($length - 1)) {
+					$i--;
+				}
+			}//end if
+
+			// Add the skip pattern *after* we have processed
+			// all the tokens from the end of the last skip pattern
+			// to the start of this skip pattern.
+			if ($specialPattern !== false) {
+				$patterns[] = $specialPattern;
+			}
+		}//end for
+
+		return $patterns;
+
+	}//end parse()
+
+
+	/**
+	 * Creates a skip pattern.
+	 *
+	 * @param string $pattern The pattern being parsed.
+	 * @param string $from    The token content that the skip pattern starts from.
+	 *
+	 * @return array The pattern step.
+	 * @see    createTokenPattern()
+	 * @see    parse()
+	 */
+	private function createSkipPattern($pattern, $from)
+	{
+		$skip = ['type' => 'skip'];
+
+		$nestedParenthesis = 0;
+		$nestedBraces      = 0;
+		for ($start = $from; $start >= 0; $start--) {
+			switch ($pattern[$start]) {
+			case '(':
+				if ($nestedParenthesis === 0) {
+					$skip['to'] = 'parenthesis_closer';
+				}
+
+				$nestedParenthesis--;
+				break;
+			case '{':
+				if ($nestedBraces === 0) {
+					$skip['to'] = 'scope_closer';
+				}
+
+				$nestedBraces--;
+				break;
+			case '}':
+				$nestedBraces++;
+				break;
+			case ')':
+				$nestedParenthesis++;
+				break;
+			}//end switch
+
+			if (isset($skip['to']) === true) {
+				break;
+			}
+		}//end for
+
+		if (isset($skip['to']) === false) {
+			$skip['to'] = 'unknown';
+		}
+
+		return $skip;
+
+	}//end createSkipPattern()
+
+
+	/**
+	 * Creates a token pattern.
+	 *
+	 * @param string $str The tokens string that the pattern should match.
+	 *
+	 * @return array The pattern step.
+	 * @see    createSkipPattern()
+	 * @see    parse()
+	 */
+	private function createTokenPattern($str)
+	{
+		// Don't add a space after the closing php tag as it will add a new
+		// whitespace token.
+		$tokenizer = new PHP('<?php '.$str.'?>', null);
+
+		// Remove the <?php tag from the front and the end php tag from the back.
+		$tokens = $tokenizer->getTokens();
+		$tokens = array_slice($tokens, 1, (count($tokens) - 2));
+
+		$patterns = [];
+		foreach ($tokens as $patternInfo) {
+			$patterns[] = [
+				'type'  => 'token',
+				'token' => $patternInfo['code'],
+				'value' => $patternInfo['content'],
+			];
+		}
+
+		return $patterns;
+
+	}//end createTokenPattern()
 
 
 }//end class

Switch Indentation +20 added lines, -20 removed lines

@@ -864,26 +864,26 @@
         $nestedBraces      = 0;
         for ($start = $from; $start >= 0; $start--) {
             switch ($pattern[$start]) {
-            case '(':
-                if ($nestedParenthesis === 0) {
-                    $skip['to'] = 'parenthesis_closer';
-                }
-
-                $nestedParenthesis--;
-                break;
-            case '{':
-                if ($nestedBraces === 0) {
-                    $skip['to'] = 'scope_closer';
-                }
-
-                $nestedBraces--;
-                break;
-            case '}':
-                $nestedBraces++;
-                break;
-            case ')':
-                $nestedParenthesis++;
-                break;
+            	case '(':
+                	if ($nestedParenthesis === 0) {
+                    	$skip['to'] = 'parenthesis_closer';
+                	}
+
+                	$nestedParenthesis--;
+                	break;
+            	case '{':
+                	if ($nestedBraces === 0) {
+                    	$skip['to'] = 'scope_closer';
+                	}
+
+                	$nestedBraces--;
+                	break;
+            	case '}':
+                	$nestedBraces++;
+                	break;
+            	case ')':
+                	$nestedParenthesis++;
+                	break;
             }//end switch
 
             if (isset($skip['to']) === true) {

Spacing +226 added lines, -226 removed lines

@@ -36,7 +36,7 @@ 
      *
      * @var array
      */
-    private $parsedPatterns = [];
+    private $parsedPatterns = [ ];
 
     /**
      * Tokens that this sniff wishes to process outside of the patterns.
@@ -45,14 +45,14 @@ 
      * @see registerSupplementary()
      * @see processSupplementary()
      */
-    private $supplementaryTokens = [];
+    private $supplementaryTokens = [ ];
 
     /**
      * Positions in the stack where errors have occurred.
      *
      * @var array<int, bool>
      */
-    private $errorPos = [];
+    private $errorPos = [ ];
 
 
     /**
@@ -60,10 +60,10 @@ 
      *
      * @param boolean $ignoreComments If true, comments will be ignored.
      */
-    public function __construct($ignoreComments=null)
+    public function __construct( $ignoreComments = null )
     {
         // This is here for backwards compatibility.
-        if ($ignoreComments !== null) {
+        if ( $ignoreComments !== null ) {
             $this->ignoreComments = $ignoreComments;
         }
 
@@ -83,17 +83,17 @@ 
      */
     final public function register()
     {
-        $listenTypes = [];
+        $listenTypes = [ ];
         $patterns    = $this->getPatterns();
 
-        foreach ($patterns as $pattern) {
-            $parsedPattern = $this->parse($pattern);
+        foreach ( $patterns as $pattern ) {
+            $parsedPattern = $this->parse( $pattern );
 
             // Find a token position in the pattern that we can use
             // for a listener token.
-            $pos           = $this->getListenerTokenPos($parsedPattern);
-            $tokenType     = $parsedPattern[$pos]['token'];
-            $listenTypes[] = $tokenType;
+            $pos           = $this->getListenerTokenPos( $parsedPattern );
+            $tokenType     = $parsedPattern[ $pos ][ 'token' ];
+            $listenTypes[ ] = $tokenType;
 
             $patternArray = [
                 'listen_pos'   => $pos,
@@ -101,14 +101,14 @@ 
                 'pattern_code' => $pattern,
             ];
 
-            if (isset($this->parsedPatterns[$tokenType]) === false) {
-                $this->parsedPatterns[$tokenType] = [];
+            if ( isset( $this->parsedPatterns[ $tokenType ] ) === false ) {
+                $this->parsedPatterns[ $tokenType ] = [ ];
             }
 
-            $this->parsedPatterns[$tokenType][] = $patternArray;
+            $this->parsedPatterns[ $tokenType ][ ] = $patternArray;
         }//end foreach
 
-        return array_unique(array_merge($listenTypes, $this->supplementaryTokens));
+        return array_unique( array_merge( $listenTypes, $this->supplementaryTokens ) );
 
     }//end register()
 
@@ -129,13 +129,13 @@ 
      *
      * @return array<int, int>
      */
-    private function getPatternTokenTypes($pattern)
+    private function getPatternTokenTypes( $pattern )
     {
-        $tokenTypes = [];
-        foreach ($pattern as $pos => $patternInfo) {
-            if ($patternInfo['type'] === 'token') {
-                if (isset($tokenTypes[$patternInfo['token']]) === false) {
-                    $tokenTypes[$patternInfo['token']] = $pos;
+        $tokenTypes = [ ];
+        foreach ( $pattern as $pos => $patternInfo ) {
+            if ( $patternInfo[ 'type' ] === 'token' ) {
+                if ( isset( $tokenTypes[ $patternInfo[ 'token' ] ] ) === false ) {
+                    $tokenTypes[ $patternInfo[ 'token' ] ] = $pos;
                 }
             }
         }
@@ -155,19 +155,19 @@ 
      *             as the listener.
      * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If we could not determine a token to listen for.
      */
-    private function getListenerTokenPos($pattern)
+    private function getListenerTokenPos( $pattern )
     {
-        $tokenTypes = $this->getPatternTokenTypes($pattern);
-        $tokenCodes = array_keys($tokenTypes);
-        $token      = Tokens::getHighestWeightedToken($tokenCodes);
+        $tokenTypes = $this->getPatternTokenTypes( $pattern );
+        $tokenCodes = array_keys( $tokenTypes );
+        $token      = Tokens::getHighestWeightedToken( $tokenCodes );
 
         // If we could not get a token.
-        if ($token === false) {
+        if ( $token === false ) {
             $error = 'Could not determine a token to listen for';
-            throw new RuntimeException($error);
+            throw new RuntimeException( $error );
         }
 
-        return $tokenTypes[$token];
+        return $tokenTypes[ $token ];
 
     }//end getListenerTokenPos()
 
@@ -184,55 +184,55 @@ 
      * @return void
      * @see    register()
      */
-    final public function process(File $phpcsFile, $stackPtr)
+    final public function process( File $phpcsFile, $stackPtr )
     {
         $file = $phpcsFile->getFilename();
-        if ($this->currFile !== $file) {
+        if ( $this->currFile !== $file ) {
             // We have changed files, so clean up.
-            $this->errorPos = [];
+            $this->errorPos = [ ];
             $this->currFile = $file;
         }
 
         $tokens = $phpcsFile->getTokens();
 
-        if (in_array($tokens[$stackPtr]['code'], $this->supplementaryTokens, true) === true) {
-            $this->processSupplementary($phpcsFile, $stackPtr);
+        if ( in_array( $tokens[ $stackPtr ][ 'code' ], $this->supplementaryTokens, true ) === true ) {
+            $this->processSupplementary( $phpcsFile, $stackPtr );
         }
 
-        $type = $tokens[$stackPtr]['code'];
+        $type = $tokens[ $stackPtr ][ 'code' ];
 
         // If the type is not set, then it must have been a token registered
         // with registerSupplementary().
-        if (isset($this->parsedPatterns[$type]) === false) {
+        if ( isset( $this->parsedPatterns[ $type ] ) === false ) {
             return;
         }
 
-        $allErrors = [];
+        $allErrors = [ ];
 
         // Loop over each pattern that is listening to the current token type
         // that we are processing.
-        foreach ($this->parsedPatterns[$type] as $patternInfo) {
+        foreach ( $this->parsedPatterns[ $type ] as $patternInfo ) {
             // If processPattern returns false, then the pattern that we are
             // checking the code with must not be designed to check that code.
-            $errors = $this->processPattern($patternInfo, $phpcsFile, $stackPtr);
-            if ($errors === false) {
+            $errors = $this->processPattern( $patternInfo, $phpcsFile, $stackPtr );
+            if ( $errors === false ) {
                 // The pattern didn't match.
                 continue;
-            } else if (empty($errors) === true) {
+            } else if ( empty( $errors ) === true ) {
                 // The pattern matched, but there were no errors.
                 break;
             }
 
-            foreach ($errors as $stackPtr => $error) {
-                if (isset($this->errorPos[$stackPtr]) === false) {
-                    $this->errorPos[$stackPtr] = true;
-                    $allErrors[$stackPtr]      = $error;
+            foreach ( $errors as $stackPtr => $error ) {
+                if ( isset( $this->errorPos[ $stackPtr ] ) === false ) {
+                    $this->errorPos[ $stackPtr ] = true;
+                    $allErrors[ $stackPtr ]      = $error;
                 }
             }
         }
 
-        foreach ($allErrors as $stackPtr => $error) {
-            $phpcsFile->addError($error, $stackPtr, 'Found');
+        foreach ( $allErrors as $stackPtr => $error ) {
+            $phpcsFile->addError( $error, $stackPtr, 'Found' );
         }
 
     }//end process()
@@ -252,37 +252,37 @@ 
      *
      * @return array
      */
-    protected function processPattern($patternInfo, File $phpcsFile, $stackPtr)
+    protected function processPattern( $patternInfo, File $phpcsFile, $stackPtr )
     {
         $tokens      = $phpcsFile->getTokens();
-        $pattern     = $patternInfo['pattern'];
-        $patternCode = $patternInfo['pattern_code'];
-        $errors      = [];
+        $pattern     = $patternInfo[ 'pattern' ];
+        $patternCode = $patternInfo[ 'pattern_code' ];
+        $errors      = [ ];
         $found       = '';
 
-        $ignoreTokens = [T_WHITESPACE => T_WHITESPACE];
-        if ($this->ignoreComments === true) {
+        $ignoreTokens = [ T_WHITESPACE => T_WHITESPACE ];
+        if ( $this->ignoreComments === true ) {
             $ignoreTokens += Tokens::$commentTokens;
         }
 
         $origStackPtr = $stackPtr;
         $hasError     = false;
 
-        if ($patternInfo['listen_pos'] > 0) {
+        if ( $patternInfo[ 'listen_pos' ] > 0 ) {
             $stackPtr--;
 
-            for ($i = ($patternInfo['listen_pos'] - 1); $i >= 0; $i--) {
-                if ($pattern[$i]['type'] === 'token') {
-                    if ($pattern[$i]['token'] === T_WHITESPACE) {
-                        if ($tokens[$stackPtr]['code'] === T_WHITESPACE) {
-                            $found = $tokens[$stackPtr]['content'].$found;
+            for ( $i = ( $patternInfo[ 'listen_pos' ] - 1 ); $i >= 0; $i-- ) {
+                if ( $pattern[ $i ][ 'type' ] === 'token' ) {
+                    if ( $pattern[ $i ][ 'token' ] === T_WHITESPACE ) {
+                        if ( $tokens[ $stackPtr ][ 'code' ] === T_WHITESPACE ) {
+                            $found = $tokens[ $stackPtr ][ 'content' ] . $found;
                         }
 
                         // Only check the size of the whitespace if this is not
                         // the first token. We don't care about the size of
                         // leading whitespace, just that there is some.
-                        if ($i !== 0) {
-                            if ($tokens[$stackPtr]['content'] !== $pattern[$i]['value']) {
+                        if ( $i !== 0 ) {
+                            if ( $tokens[ $stackPtr ][ 'content' ] !== $pattern[ $i ][ 'value' ] ) {
                                 $hasError = true;
                             }
                         }
@@ -297,8 +297,8 @@ 
                             true
                         );
 
-                        if ($prev === false
-                            || $tokens[$prev]['code'] !== $pattern[$i]['token']
+                        if ( $prev === false
+                            || $tokens[ $prev ][ 'code' ] !== $pattern[ $i ][ 'token' ]
                         ) {
                             return false;
                         }
@@ -306,23 +306,23 @@ 
                         // If we skipped past some whitespace tokens, then add them
                         // to the found string.
                         $tokenContent = $phpcsFile->getTokensAsString(
-                            ($prev + 1),
-                            ($stackPtr - $prev - 1)
+                            ( $prev + 1 ),
+                            ( $stackPtr - $prev - 1 )
                         );
 
-                        $found = $tokens[$prev]['content'].$tokenContent.$found;
+                        $found = $tokens[ $prev ][ 'content' ] . $tokenContent . $found;
 
-                        if (isset($pattern[($i - 1)]) === true
-                            && $pattern[($i - 1)]['type'] === 'skip'
+                        if ( isset( $pattern[ ( $i - 1 ) ] ) === true
+                            && $pattern[ ( $i - 1 ) ][ 'type' ] === 'skip'
                         ) {
                             $stackPtr = $prev;
                         } else {
-                            $stackPtr = ($prev - 1);
+                            $stackPtr = ( $prev - 1 );
                         }
                     }//end if
-                } else if ($pattern[$i]['type'] === 'skip') {
+                } else if ( $pattern[ $i ][ 'type' ] === 'skip' ) {
                     // Skip to next piece of relevant code.
-                    if ($pattern[$i]['to'] === 'parenthesis_closer') {
+                    if ( $pattern[ $i ][ 'to' ] === 'parenthesis_closer' ) {
                         $to = 'parenthesis_opener';
                     } else {
                         $to = 'scope_opener';
@@ -336,75 +336,75 @@ 
                         true
                     );
 
-                    if ($next === false || isset($tokens[$next][$to]) === false) {
+                    if ( $next === false || isset( $tokens[ $next ][ $to ] ) === false ) {
                         // If there was not opener, then we must be
                         // using the wrong pattern.
                         return false;
                     }
 
-                    if ($to === 'parenthesis_opener') {
-                        $found = '{'.$found;
+                    if ( $to === 'parenthesis_opener' ) {
+                        $found = '{' . $found;
                     } else {
-                        $found = '('.$found;
+                        $found = '(' . $found;
                     }
 
-                    $found = '...'.$found;
+                    $found = '...' . $found;
 
                     // Skip to the opening token.
-                    $stackPtr = ($tokens[$next][$to] - 1);
-                } else if ($pattern[$i]['type'] === 'string') {
+                    $stackPtr = ( $tokens[ $next ][ $to ] - 1 );
+                } else if ( $pattern[ $i ][ 'type' ] === 'string' ) {
                     $found = 'abc';
-                } else if ($pattern[$i]['type'] === 'newline') {
-                    if ($this->ignoreComments === true
-                        && isset(Tokens::$commentTokens[$tokens[$stackPtr]['code']]) === true
+                } else if ( $pattern[ $i ][ 'type' ] === 'newline' ) {
+                    if ( $this->ignoreComments === true
+                        && isset( Tokens::$commentTokens[ $tokens[ $stackPtr ][ 'code' ] ] ) === true
                     ) {
                         $startComment = $phpcsFile->findPrevious(
                             Tokens::$commentTokens,
-                            ($stackPtr - 1),
+                            ( $stackPtr - 1 ),
                             null,
                             true
                         );
 
-                        if ($tokens[$startComment]['line'] !== $tokens[($startComment + 1)]['line']) {
+                        if ( $tokens[ $startComment ][ 'line' ] !== $tokens[ ( $startComment + 1 ) ][ 'line' ] ) {
                             $startComment++;
                         }
 
                         $tokenContent = $phpcsFile->getTokensAsString(
                             $startComment,
-                            ($stackPtr - $startComment + 1)
+                            ( $stackPtr - $startComment + 1 )
                         );
 
-                        $found    = $tokenContent.$found;
-                        $stackPtr = ($startComment - 1);
+                        $found    = $tokenContent . $found;
+                        $stackPtr = ( $startComment - 1 );
                     }
 
-                    if ($tokens[$stackPtr]['code'] === T_WHITESPACE) {
-                        if ($tokens[$stackPtr]['content'] !== $phpcsFile->eolChar) {
-                            $found = $tokens[$stackPtr]['content'].$found;
+                    if ( $tokens[ $stackPtr ][ 'code' ] === T_WHITESPACE ) {
+                        if ( $tokens[ $stackPtr ][ 'content' ] !== $phpcsFile->eolChar ) {
+                            $found = $tokens[ $stackPtr ][ 'content' ] . $found;
 
                             // This may just be an indent that comes after a newline
                             // so check the token before to make sure. If it is a newline, we
                             // can ignore the error here.
-                            if (($tokens[($stackPtr - 1)]['content'] !== $phpcsFile->eolChar)
-                                && ($this->ignoreComments === true
-                                && isset(Tokens::$commentTokens[$tokens[($stackPtr - 1)]['code']]) === false)
+                            if ( ( $tokens[ ( $stackPtr - 1 ) ][ 'content' ] !== $phpcsFile->eolChar )
+                                && ( $this->ignoreComments === true
+                                && isset( Tokens::$commentTokens[ $tokens[ ( $stackPtr - 1 ) ][ 'code' ] ] ) === false )
                             ) {
                                 $hasError = true;
                             } else {
                                 $stackPtr--;
                             }
                         } else {
-                            $found = 'EOL'.$found;
+                            $found = 'EOL' . $found;
                         }
                     } else {
-                        $found    = $tokens[$stackPtr]['content'].$found;
+                        $found    = $tokens[ $stackPtr ][ 'content' ] . $found;
                         $hasError = true;
                     }//end if
 
-                    if ($hasError === false && $pattern[($i - 1)]['type'] !== 'newline') {
+                    if ( $hasError === false && $pattern[ ( $i - 1 ) ][ 'type' ] !== 'newline' ) {
                         // Make sure they only have 1 newline.
-                        $prev = $phpcsFile->findPrevious($ignoreTokens, ($stackPtr - 1), null, true);
-                        if ($prev !== false && $tokens[$prev]['line'] !== $tokens[$stackPtr]['line']) {
+                        $prev = $phpcsFile->findPrevious( $ignoreTokens, ( $stackPtr - 1 ), null, true );
+                        if ( $prev !== false && $tokens[ $prev ][ 'line' ] !== $tokens[ $stackPtr ][ 'line' ] ) {
                             $hasError = true;
                         }
                     }
@@ -414,38 +414,38 @@ 
 
         $stackPtr          = $origStackPtr;
         $lastAddedStackPtr = null;
-        $patternLen        = count($pattern);
+        $patternLen        = count( $pattern );
 
-        for ($i = $patternInfo['listen_pos']; $i < $patternLen; $i++) {
-            if (isset($tokens[$stackPtr]) === false) {
+        for ( $i = $patternInfo[ 'listen_pos' ]; $i < $patternLen; $i++ ) {
+            if ( isset( $tokens[ $stackPtr ] ) === false ) {
                 break;
             }
 
-            if ($pattern[$i]['type'] === 'token') {
-                if ($pattern[$i]['token'] === T_WHITESPACE) {
-                    if ($this->ignoreComments === true) {
+            if ( $pattern[ $i ][ 'type' ] === 'token' ) {
+                if ( $pattern[ $i ][ 'token' ] === T_WHITESPACE ) {
+                    if ( $this->ignoreComments === true ) {
                         // If we are ignoring comments, check to see if this current
                         // token is a comment. If so skip it.
-                        if (isset(Tokens::$commentTokens[$tokens[$stackPtr]['code']]) === true) {
+                        if ( isset( Tokens::$commentTokens[ $tokens[ $stackPtr ][ 'code' ] ] ) === true ) {
                             continue;
                         }
 
                         // If the next token is a comment, the we need to skip the
                         // current token as we should allow a space before a
                         // comment for readability.
-                        if (isset($tokens[($stackPtr + 1)]) === true
-                            && isset(Tokens::$commentTokens[$tokens[($stackPtr + 1)]['code']]) === true
+                        if ( isset( $tokens[ ( $stackPtr + 1 ) ] ) === true
+                            && isset( Tokens::$commentTokens[ $tokens[ ( $stackPtr + 1 ) ][ 'code' ] ] ) === true
                         ) {
                             continue;
                         }
                     }
 
                     $tokenContent = '';
-                    if ($tokens[$stackPtr]['code'] === T_WHITESPACE) {
-                        if (isset($pattern[($i + 1)]) === false) {
+                    if ( $tokens[ $stackPtr ][ 'code' ] === T_WHITESPACE ) {
+                        if ( isset( $pattern[ ( $i + 1 ) ] ) === false ) {
                             // This is the last token in the pattern, so just compare
                             // the next token of content.
-                            $tokenContent = $tokens[$stackPtr]['content'];
+                            $tokenContent = $tokens[ $stackPtr ][ 'content' ];
                         } else {
                             // Get all the whitespace to the next token.
                             $next = $phpcsFile->findNext(
@@ -457,34 +457,34 @@ 
 
                             $tokenContent = $phpcsFile->getTokensAsString(
                                 $stackPtr,
-                                ($next - $stackPtr)
+                                ( $next - $stackPtr )
                             );
 
                             $lastAddedStackPtr = $stackPtr;
                             $stackPtr          = $next;
                         }//end if
 
-                        if ($stackPtr !== $lastAddedStackPtr) {
+                        if ( $stackPtr !== $lastAddedStackPtr ) {
                             $found .= $tokenContent;
                         }
                     } else {
-                        if ($stackPtr !== $lastAddedStackPtr) {
-                            $found            .= $tokens[$stackPtr]['content'];
+                        if ( $stackPtr !== $lastAddedStackPtr ) {
+                            $found            .= $tokens[ $stackPtr ][ 'content' ];
                             $lastAddedStackPtr = $stackPtr;
                         }
                     }//end if
 
-                    if (isset($pattern[($i + 1)]) === true
-                        && $pattern[($i + 1)]['type'] === 'skip'
+                    if ( isset( $pattern[ ( $i + 1 ) ] ) === true
+                        && $pattern[ ( $i + 1 ) ][ 'type' ] === 'skip'
                     ) {
                         // The next token is a skip token, so we just need to make
                         // sure the whitespace we found has *at least* the
                         // whitespace required.
-                        if (strpos($tokenContent, $pattern[$i]['value']) !== 0) {
+                        if ( strpos( $tokenContent, $pattern[ $i ][ 'value' ] ) !== 0 ) {
                             $hasError = true;
                         }
                     } else {
-                        if ($tokenContent !== $pattern[$i]['value']) {
+                        if ( $tokenContent !== $pattern[ $i ][ 'value' ] ) {
                             $hasError = true;
                         }
                     }
@@ -499,18 +499,18 @@ 
                         true
                     );
 
-                    if ($next === false
-                        || $tokens[$next]['code'] !== $pattern[$i]['token']
+                    if ( $next === false
+                        || $tokens[ $next ][ 'code' ] !== $pattern[ $i ][ 'token' ]
                     ) {
                         // The next important token did not match the pattern.
                         return false;
                     }
 
-                    if ($lastAddedStackPtr !== null) {
-                        if (($tokens[$next]['code'] === T_OPEN_CURLY_BRACKET
-                            || $tokens[$next]['code'] === T_CLOSE_CURLY_BRACKET)
-                            && isset($tokens[$next]['scope_condition']) === true
-                            && $tokens[$next]['scope_condition'] > $lastAddedStackPtr
+                    if ( $lastAddedStackPtr !== null ) {
+                        if ( ( $tokens[ $next ][ 'code' ] === T_OPEN_CURLY_BRACKET
+                            || $tokens[ $next ][ 'code' ] === T_CLOSE_CURLY_BRACKET )
+                            && isset( $tokens[ $next ][ 'scope_condition' ] ) === true
+                            && $tokens[ $next ][ 'scope_condition' ] > $lastAddedStackPtr
                         ) {
                             // This is a brace, but the owner of it is after the current
                             // token, which means it does not belong to any token in
@@ -518,10 +518,10 @@ 
                             return false;
                         }
 
-                        if (($tokens[$next]['code'] === T_OPEN_PARENTHESIS
-                            || $tokens[$next]['code'] === T_CLOSE_PARENTHESIS)
-                            && isset($tokens[$next]['parenthesis_owner']) === true
-                            && $tokens[$next]['parenthesis_owner'] > $lastAddedStackPtr
+                        if ( ( $tokens[ $next ][ 'code' ] === T_OPEN_PARENTHESIS
+                            || $tokens[ $next ][ 'code' ] === T_CLOSE_PARENTHESIS )
+                            && isset( $tokens[ $next ][ 'parenthesis_owner' ] ) === true
+                            && $tokens[ $next ][ 'parenthesis_owner' ] > $lastAddedStackPtr
                         ) {
                             // This is a bracket, but the owner of it is after the current
                             // token, which means it does not belong to any token in
@@ -532,11 +532,11 @@ 
 
                     // If we skipped past some whitespace tokens, then add them
                     // to the found string.
-                    if (($next - $stackPtr) > 0) {
+                    if ( ( $next - $stackPtr ) > 0 ) {
                         $hasComment = false;
-                        for ($j = $stackPtr; $j < $next; $j++) {
-                            $found .= $tokens[$j]['content'];
-                            if (isset(Tokens::$commentTokens[$tokens[$j]['code']]) === true) {
+                        for ( $j = $stackPtr; $j < $next; $j++ ) {
+                            $found .= $tokens[ $j ][ 'content' ];
+                            if ( isset( Tokens::$commentTokens[ $tokens[ $j ][ 'code' ] ] ) === true ) {
                                 $hasComment = true;
                             }
                         }
@@ -545,9 +545,9 @@ 
                         // whitespace or comment is not allowed. If we are
                         // ignoring comments, there needs to be at least one
                         // comment for this to be allowed.
-                        if ($this->ignoreComments === false
-                            || ($this->ignoreComments === true
-                            && $hasComment === false)
+                        if ( $this->ignoreComments === false
+                            || ( $this->ignoreComments === true
+                            && $hasComment === false )
                         ) {
                             $hasError = true;
                         }
@@ -555,32 +555,32 @@ 
                         // Even when ignoring comments, we are not allowed to include
                         // newlines without the pattern specifying them, so
                         // everything should be on the same line.
-                        if ($tokens[$next]['line'] !== $tokens[$stackPtr]['line']) {
+                        if ( $tokens[ $next ][ 'line' ] !== $tokens[ $stackPtr ][ 'line' ] ) {
                             $hasError = true;
                         }
                     }//end if
 
-                    if ($next !== $lastAddedStackPtr) {
-                        $found            .= $tokens[$next]['content'];
+                    if ( $next !== $lastAddedStackPtr ) {
+                        $found            .= $tokens[ $next ][ 'content' ];
                         $lastAddedStackPtr = $next;
                     }
 
-                    if (isset($pattern[($i + 1)]) === true
-                        && $pattern[($i + 1)]['type'] === 'skip'
+                    if ( isset( $pattern[ ( $i + 1 ) ] ) === true
+                        && $pattern[ ( $i + 1 ) ][ 'type' ] === 'skip'
                     ) {
                         $stackPtr = $next;
                     } else {
-                        $stackPtr = ($next + 1);
+                        $stackPtr = ( $next + 1 );
                     }
                 }//end if
-            } else if ($pattern[$i]['type'] === 'skip') {
-                if ($pattern[$i]['to'] === 'unknown') {
+            } else if ( $pattern[ $i ][ 'type' ] === 'skip' ) {
+                if ( $pattern[ $i ][ 'to' ] === 'unknown' ) {
                     $next = $phpcsFile->findNext(
-                        $pattern[($i + 1)]['token'],
+                        $pattern[ ( $i + 1 ) ][ 'token' ],
                         $stackPtr
                     );
 
-                    if ($next === false) {
+                    if ( $next === false ) {
                         // Couldn't find the next token, so we must
                         // be using the wrong pattern.
                         return false;
@@ -595,8 +595,8 @@ 
                         $stackPtr
                     );
 
-                    if ($next === false
-                        || isset($tokens[$next][$pattern[$i]['to']]) === false
+                    if ( $next === false
+                        || isset( $tokens[ $next ][ $pattern[ $i ][ 'to' ] ] ) === false
                     ) {
                         // If there was not opener, then we must
                         // be using the wrong pattern.
@@ -604,50 +604,50 @@ 
                     }
 
                     $found .= '...';
-                    if ($pattern[$i]['to'] === 'parenthesis_closer') {
+                    if ( $pattern[ $i ][ 'to' ] === 'parenthesis_closer' ) {
                         $found .= ')';
                     } else {
                         $found .= '}';
                     }
 
                     // Skip to the closing token.
-                    $stackPtr = ($tokens[$next][$pattern[$i]['to']] + 1);
+                    $stackPtr = ( $tokens[ $next ][ $pattern[ $i ][ 'to' ] ] + 1 );
                 }//end if
-            } else if ($pattern[$i]['type'] === 'string') {
-                if ($tokens[$stackPtr]['code'] !== T_STRING) {
+            } else if ( $pattern[ $i ][ 'type' ] === 'string' ) {
+                if ( $tokens[ $stackPtr ][ 'code' ] !== T_STRING ) {
                     $hasError = true;
                 }
 
-                if ($stackPtr !== $lastAddedStackPtr) {
+                if ( $stackPtr !== $lastAddedStackPtr ) {
                     $found            .= 'abc';
                     $lastAddedStackPtr = $stackPtr;
                 }
 
                 $stackPtr++;
-            } else if ($pattern[$i]['type'] === 'newline') {
+            } else if ( $pattern[ $i ][ 'type' ] === 'newline' ) {
                 // Find the next token that contains a newline character.
                 $newline = 0;
-                for ($j = $stackPtr; $j < $phpcsFile->numTokens; $j++) {
-                    if (strpos($tokens[$j]['content'], $phpcsFile->eolChar) !== false) {
+                for ( $j = $stackPtr; $j < $phpcsFile->numTokens; $j++ ) {
+                    if ( strpos( $tokens[ $j ][ 'content' ], $phpcsFile->eolChar ) !== false ) {
                         $newline = $j;
                         break;
                     }
                 }
 
-                if ($newline === 0) {
+                if ( $newline === 0 ) {
                     // We didn't find a newline character in the rest of the file.
-                    $next     = ($phpcsFile->numTokens - 1);
+                    $next     = ( $phpcsFile->numTokens - 1 );
                     $hasError = true;
                 } else {
-                    if ($this->ignoreComments === false) {
+                    if ( $this->ignoreComments === false ) {
                         // The newline character cannot be part of a comment.
-                        if (isset(Tokens::$commentTokens[$tokens[$newline]['code']]) === true) {
+                        if ( isset( Tokens::$commentTokens[ $tokens[ $newline ][ 'code' ] ] ) === true ) {
                             $hasError = true;
                         }
                     }
 
-                    if ($newline === $stackPtr) {
-                        $next = ($stackPtr + 1);
+                    if ( $newline === $stackPtr ) {
+                        $next = ( $stackPtr + 1 );
                     } else {
                         // Check that there were no significant tokens that we
                         // skipped over to find our newline character.
@@ -658,31 +658,31 @@ 
                             true
                         );
 
-                        if ($next < $newline) {
+                        if ( $next < $newline ) {
                             // We skipped a non-ignored token.
                             $hasError = true;
                         } else {
-                            $next = ($newline + 1);
+                            $next = ( $newline + 1 );
                         }
                     }
                 }//end if
 
-                if ($stackPtr !== $lastAddedStackPtr) {
+                if ( $stackPtr !== $lastAddedStackPtr ) {
                     $found .= $phpcsFile->getTokensAsString(
                         $stackPtr,
-                        ($next - $stackPtr)
+                        ( $next - $stackPtr )
                     );
 
-                    $lastAddedStackPtr = ($next - 1);
+                    $lastAddedStackPtr = ( $next - 1 );
                 }
 
                 $stackPtr = $next;
             }//end if
         }//end for
 
-        if ($hasError === true) {
-            $error = $this->prepareError($found, $patternCode);
-            $errors[$origStackPtr] = $error;
+        if ( $hasError === true ) {
+            $error = $this->prepareError( $found, $patternCode );
+            $errors[ $origStackPtr ] = $error;
         }
 
         return $errors;
@@ -698,14 +698,14 @@ 
      *
      * @return string The error message.
      */
-    protected function prepareError($found, $patternCode)
+    protected function prepareError( $found, $patternCode )
     {
-        $found    = str_replace("\r\n", '\n', $found);
-        $found    = str_replace("\n", '\n', $found);
-        $found    = str_replace("\r", '\n', $found);
-        $found    = str_replace("\t", '\t', $found);
-        $found    = str_replace('EOL', '\n', $found);
-        $expected = str_replace('EOL', '\n', $patternCode);
+        $found    = str_replace( "\r\n", '\n', $found );
+        $found    = str_replace( "\n", '\n', $found );
+        $found    = str_replace( "\r", '\n', $found );
+        $found    = str_replace( "\t", '\t', $found );
+        $found    = str_replace( 'EOL', '\n', $found );
+        $expected = str_replace( 'EOL', '\n', $patternCode );
 
         $error = "Expected \"$expected\"; found \"$found\"";
 
@@ -734,7 +734,7 @@ 
      */
     protected function registerSupplementary()
     {
-        return [];
+        return [ ];
 
     }//end registerSupplementary()
 
@@ -750,7 +750,7 @@ 
       * @return void
       * @see    registerSupplementary()
       */
-    protected function processSupplementary(File $phpcsFile, $stackPtr)
+    protected function processSupplementary( File $phpcsFile, $stackPtr )
     {
 
     }//end processSupplementary()
@@ -765,70 +765,70 @@ 
      * @see    createSkipPattern()
      * @see    createTokenPattern()
      */
-    private function parse($pattern)
+    private function parse( $pattern )
     {
-        $patterns   = [];
-        $length     = strlen($pattern);
+        $patterns   = [ ];
+        $length     = strlen( $pattern );
         $lastToken  = 0;
         $firstToken = 0;
 
-        for ($i = 0; $i < $length; $i++) {
+        for ( $i = 0; $i < $length; $i++ ) {
             $specialPattern = false;
-            $isLastChar     = ($i === ($length - 1));
+            $isLastChar     = ( $i === ( $length - 1 ) );
             $oldFirstToken  = $firstToken;
 
-            if (substr($pattern, $i, 3) === '...') {
+            if ( substr( $pattern, $i, 3 ) === '...' ) {
                 // It's a skip pattern. The skip pattern requires the
                 // content of the token in the "from" position and the token
                 // to skip to.
-                $specialPattern = $this->createSkipPattern($pattern, ($i - 1));
-                $lastToken      = ($i - $firstToken);
-                $firstToken     = ($i + 3);
+                $specialPattern = $this->createSkipPattern( $pattern, ( $i - 1 ) );
+                $lastToken      = ( $i - $firstToken );
+                $firstToken     = ( $i + 3 );
                 $i += 2;
 
-                if ($specialPattern['to'] !== 'unknown') {
+                if ( $specialPattern[ 'to' ] !== 'unknown' ) {
                     $firstToken++;
                 }
-            } else if (substr($pattern, $i, 3) === 'abc') {
-                $specialPattern = ['type' => 'string'];
-                $lastToken      = ($i - $firstToken);
-                $firstToken     = ($i + 3);
+            } else if ( substr( $pattern, $i, 3 ) === 'abc' ) {
+                $specialPattern = [ 'type' => 'string' ];
+                $lastToken      = ( $i - $firstToken );
+                $firstToken     = ( $i + 3 );
                 $i += 2;
-            } else if (substr($pattern, $i, 3) === 'EOL') {
-                $specialPattern = ['type' => 'newline'];
-                $lastToken      = ($i - $firstToken);
-                $firstToken     = ($i + 3);
+            } else if ( substr( $pattern, $i, 3 ) === 'EOL' ) {
+                $specialPattern = [ 'type' => 'newline' ];
+                $lastToken      = ( $i - $firstToken );
+                $firstToken     = ( $i + 3 );
                 $i += 2;
             }//end if
 
-            if ($specialPattern !== false || $isLastChar === true) {
+            if ( $specialPattern !== false || $isLastChar === true ) {
                 // If we are at the end of the string, don't worry about a limit.
-                if ($isLastChar === true) {
+                if ( $isLastChar === true ) {
                     // Get the string from the end of the last skip pattern, if any,
                     // to the end of the pattern string.
-                    $str = substr($pattern, $oldFirstToken);
+                    $str = substr( $pattern, $oldFirstToken );
                 } else {
                     // Get the string from the end of the last special pattern,
                     // if any, to the start of this special pattern.
-                    if ($lastToken === 0) {
+                    if ( $lastToken === 0 ) {
                         // Note that if the last special token was zero characters ago,
                         // there will be nothing to process so we can skip this bit.
                         // This happens if you have something like: EOL... in your pattern.
                         $str = '';
                     } else {
-                        $str = substr($pattern, $oldFirstToken, $lastToken);
+                        $str = substr( $pattern, $oldFirstToken, $lastToken );
                     }
                 }
 
-                if ($str !== '') {
-                    $tokenPatterns = $this->createTokenPattern($str);
-                    foreach ($tokenPatterns as $tokenPattern) {
-                        $patterns[] = $tokenPattern;
+                if ( $str !== '' ) {
+                    $tokenPatterns = $this->createTokenPattern( $str );
+                    foreach ( $tokenPatterns as $tokenPattern ) {
+                        $patterns[ ] = $tokenPattern;
                     }
                 }
 
                 // Make sure we don't skip the last token.
-                if ($isLastChar === false && $i === ($length - 1)) {
+                if ( $isLastChar === false && $i === ( $length - 1 ) ) {
                     $i--;
                 }
             }//end if
@@ -836,8 +836,8 @@ 
             // Add the skip pattern *after* we have processed
             // all the tokens from the end of the last skip pattern
             // to the start of this skip pattern.
-            if ($specialPattern !== false) {
-                $patterns[] = $specialPattern;
+            if ( $specialPattern !== false ) {
+                $patterns[ ] = $specialPattern;
             }
         }//end for
 
@@ -856,24 +856,24 @@ 
      * @see    createTokenPattern()
      * @see    parse()
      */
-    private function createSkipPattern($pattern, $from)
+    private function createSkipPattern( $pattern, $from )
     {
-        $skip = ['type' => 'skip'];
+        $skip = [ 'type' => 'skip' ];
 
         $nestedParenthesis = 0;
         $nestedBraces      = 0;
-        for ($start = $from; $start >= 0; $start--) {
-            switch ($pattern[$start]) {
+        for ( $start = $from; $start >= 0; $start-- ) {
+            switch ( $pattern[ $start ] ) {
             case '(':
-                if ($nestedParenthesis === 0) {
-                    $skip['to'] = 'parenthesis_closer';
+                if ( $nestedParenthesis === 0 ) {
+                    $skip[ 'to' ] = 'parenthesis_closer';
                 }
 
                 $nestedParenthesis--;
                 break;
             case '{':
-                if ($nestedBraces === 0) {
-                    $skip['to'] = 'scope_closer';
+                if ( $nestedBraces === 0 ) {
+                    $skip[ 'to' ] = 'scope_closer';
                 }
 
                 $nestedBraces--;
@@ -886,13 +886,13 @@ 
                 break;
             }//end switch
 
-            if (isset($skip['to']) === true) {
+            if ( isset( $skip[ 'to' ] ) === true ) {
                 break;
             }
         }//end for
 
-        if (isset($skip['to']) === false) {
-            $skip['to'] = 'unknown';
+        if ( isset( $skip[ 'to' ] ) === false ) {
+            $skip[ 'to' ] = 'unknown';
         }
 
         return $skip;
@@ -909,22 +909,22 @@ 
      * @see    createSkipPattern()
      * @see    parse()
      */
-    private function createTokenPattern($str)
+    private function createTokenPattern( $str )
     {
         // Don't add a space after the closing php tag as it will add a new
         // whitespace token.
-        $tokenizer = new PHP('<?php '.$str.'?>', null);
+        $tokenizer = new PHP( '<?php ' . $str . '?>', null );
 
         // Remove the <?php tag from the front and the end php tag from the back.
         $tokens = $tokenizer->getTokens();
-        $tokens = array_slice($tokens, 1, (count($tokens) - 2));
+        $tokens = array_slice( $tokens, 1, ( count( $tokens ) - 2 ) );
 
-        $patterns = [];
-        foreach ($tokens as $patternInfo) {
-            $patterns[] = [
+        $patterns = [ ];
+        foreach ( $tokens as $patternInfo ) {
+            $patterns[ ] = [
                 'type'  => 'token',
-                'token' => $patternInfo['code'],
-                'value' => $patternInfo['content'],
+                'token' => $patternInfo[ 'code' ],
+                'value' => $patternInfo[ 'content' ],
             ];
         }
 

Braces +13 added lines, -26 removed lines

@@ -14,8 +14,7 @@ 
 use PHP_CodeSniffer\Tokenizers\PHP;
 use PHP_CodeSniffer\Exceptions\RuntimeException;
 
-abstract class AbstractPatternSniff implements Sniff
-{
+abstract class AbstractPatternSniff implements Sniff {
 
     /**
      * If true, comments will be ignored if they are found in the code.
@@ -60,8 +59,7 @@ 
      *
      * @param boolean $ignoreComments If true, comments will be ignored.
      */
-    public function __construct($ignoreComments=null)
-    {
+    public function __construct($ignoreComments=null) {
         // This is here for backwards compatibility.
         if ($ignoreComments !== null) {
             $this->ignoreComments = $ignoreComments;
@@ -81,8 +79,7 @@ 
      * @return int[]
      * @see    process()
      */
-    final public function register()
-    {
+    final public function register() {
         $listenTypes = [];
         $patterns    = $this->getPatterns();
 
@@ -129,8 +126,7 @@ 
      *
      * @return array<int, int>
      */
-    private function getPatternTokenTypes($pattern)
-    {
+    private function getPatternTokenTypes($pattern) {
         $tokenTypes = [];
         foreach ($pattern as $pos => $patternInfo) {
             if ($patternInfo['type'] === 'token') {
@@ -155,8 +151,7 @@ 
      *             as the listener.
      * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If we could not determine a token to listen for.
      */
-    private function getListenerTokenPos($pattern)
-    {
+    private function getListenerTokenPos($pattern) {
         $tokenTypes = $this->getPatternTokenTypes($pattern);
         $tokenCodes = array_keys($tokenTypes);
         $token      = Tokens::getHighestWeightedToken($tokenCodes);
@@ -184,8 +179,7 @@ 
      * @return void
      * @see    register()
      */
-    final public function process(File $phpcsFile, $stackPtr)
-    {
+    final public function process(File $phpcsFile, $stackPtr) {
         $file = $phpcsFile->getFilename();
         if ($this->currFile !== $file) {
             // We have changed files, so clean up.
@@ -252,8 +246,7 @@ 
      *
      * @return array
      */
-    protected function processPattern($patternInfo, File $phpcsFile, $stackPtr)
-    {
+    protected function processPattern($patternInfo, File $phpcsFile, $stackPtr) {
         $tokens      = $phpcsFile->getTokens();
         $pattern     = $patternInfo['pattern'];
         $patternCode = $patternInfo['pattern_code'];
@@ -698,8 +691,7 @@ 
      *
      * @return string The error message.
      */
-    protected function prepareError($found, $patternCode)
-    {
+    protected function prepareError($found, $patternCode) {
         $found    = str_replace("\r\n", '\n', $found);
         $found    = str_replace("\n", '\n', $found);
         $found    = str_replace("\r", '\n', $found);
@@ -732,8 +724,7 @@ 
      * @return int[]
      * @see    processSupplementary()
      */
-    protected function registerSupplementary()
-    {
+    protected function registerSupplementary() {
         return [];
 
     }//end registerSupplementary()
@@ -750,8 +741,7 @@ 
       * @return void
       * @see    registerSupplementary()
       */
-    protected function processSupplementary(File $phpcsFile, $stackPtr)
-    {
+    protected function processSupplementary(File $phpcsFile, $stackPtr) {
 
     }//end processSupplementary()
 
@@ -765,8 +755,7 @@ 
      * @see    createSkipPattern()
      * @see    createTokenPattern()
      */
-    private function parse($pattern)
-    {
+    private function parse($pattern) {
         $patterns   = [];
         $length     = strlen($pattern);
         $lastToken  = 0;
@@ -856,8 +845,7 @@ 
      * @see    createTokenPattern()
      * @see    parse()
      */
-    private function createSkipPattern($pattern, $from)
-    {
+    private function createSkipPattern($pattern, $from) {
         $skip = ['type' => 'skip'];
 
         $nestedParenthesis = 0;
@@ -909,8 +897,7 @@ 
      * @see    createSkipPattern()
      * @see    parse()
      */
-    private function createTokenPattern($str)
-    {
+    private function createTokenPattern($str) {
         // Don't add a space after the closing php tag as it will add a new
         // whitespace token.
         $tokenizer = new PHP('<?php '.$str.'?>', null);

vendor/squizlabs/php_codesniffer/src/Sniffs/AbstractArraySniff.php

Indentation +213 added lines, -213 removed lines

@@ -16,219 +16,219 @@
 {
 
 
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    final public function register()
-    {
-        return [
-            T_ARRAY,
-            T_OPEN_SHORT_ARRAY,
-        ];
-
-    }//end register()
-
-
-    /**
-     * Processes this sniff, when one of its tokens is encountered.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked.
-     * @param int                         $stackPtr  The position of the current token in
-     *                                               the stack passed in $tokens.
-     *
-     * @return void
-     */
-    public function process(File $phpcsFile, $stackPtr)
-    {
-        $tokens = $phpcsFile->getTokens();
-
-        if ($tokens[$stackPtr]['code'] === T_ARRAY) {
-            $phpcsFile->recordMetric($stackPtr, 'Short array syntax used', 'no');
-
-            $arrayStart = $tokens[$stackPtr]['parenthesis_opener'];
-            if (isset($tokens[$arrayStart]['parenthesis_closer']) === false) {
-                // Incomplete array.
-                return;
-            }
-
-            $arrayEnd = $tokens[$arrayStart]['parenthesis_closer'];
-        } else {
-            $phpcsFile->recordMetric($stackPtr, 'Short array syntax used', 'yes');
-            $arrayStart = $stackPtr;
-            $arrayEnd   = $tokens[$stackPtr]['bracket_closer'];
-        }
-
-        $lastContent = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($arrayEnd - 1), null, true);
-        if ($tokens[$lastContent]['code'] === T_COMMA) {
-            // Last array item ends with a comma.
-            $phpcsFile->recordMetric($stackPtr, 'Array end comma', 'yes');
-            $lastArrayToken = $lastContent;
-        } else {
-            $phpcsFile->recordMetric($stackPtr, 'Array end comma', 'no');
-            $lastArrayToken = $arrayEnd;
-        }
-
-        if ($tokens[$stackPtr]['code'] === T_ARRAY) {
-            $lastToken = $tokens[$stackPtr]['parenthesis_opener'];
-        } else {
-            $lastToken = $stackPtr;
-        }
-
-        $keyUsed = false;
-        $indices = [];
-
-        for ($checkToken = ($stackPtr + 1); $checkToken <= $lastArrayToken; $checkToken++) {
-            // Skip bracketed statements, like function calls.
-            if ($tokens[$checkToken]['code'] === T_OPEN_PARENTHESIS
-                && (isset($tokens[$checkToken]['parenthesis_owner']) === false
-                || $tokens[$checkToken]['parenthesis_owner'] !== $stackPtr)
-            ) {
-                $checkToken = $tokens[$checkToken]['parenthesis_closer'];
-                continue;
-            }
-
-            if ($tokens[$checkToken]['code'] === T_ARRAY
-                || $tokens[$checkToken]['code'] === T_OPEN_SHORT_ARRAY
-                || $tokens[$checkToken]['code'] === T_CLOSURE
-            ) {
-                // Let subsequent calls of this test handle nested arrays.
-                if ($tokens[$lastToken]['code'] !== T_DOUBLE_ARROW) {
-                    $indices[] = ['value_start' => $checkToken];
-                    $lastToken = $checkToken;
-                }
-
-                if ($tokens[$checkToken]['code'] === T_ARRAY) {
-                    $checkToken = $tokens[$tokens[$checkToken]['parenthesis_opener']]['parenthesis_closer'];
-                } else if ($tokens[$checkToken]['code'] === T_OPEN_SHORT_ARRAY) {
-                    $checkToken = $tokens[$checkToken]['bracket_closer'];
-                } else {
-                    // T_CLOSURE.
-                    $checkToken = $tokens[$checkToken]['scope_closer'];
-                }
-
-                $checkToken = $phpcsFile->findNext(T_WHITESPACE, ($checkToken + 1), null, true);
-                $lastToken  = $checkToken;
-                if ($tokens[$checkToken]['code'] !== T_COMMA) {
-                    $checkToken--;
-                }
-
-                continue;
-            }//end if
-
-            if ($tokens[$checkToken]['code'] !== T_DOUBLE_ARROW
-                && $tokens[$checkToken]['code'] !== T_COMMA
-                && $checkToken !== $arrayEnd
-            ) {
-                continue;
-            }
-
-            if ($tokens[$checkToken]['code'] === T_COMMA
-                || $checkToken === $arrayEnd
-            ) {
-                $stackPtrCount = 0;
-                if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) {
-                    $stackPtrCount = count($tokens[$stackPtr]['nested_parenthesis']);
-                }
-
-                $commaCount = 0;
-                if (isset($tokens[$checkToken]['nested_parenthesis']) === true) {
-                    $commaCount = count($tokens[$checkToken]['nested_parenthesis']);
-                    if ($tokens[$stackPtr]['code'] === T_ARRAY) {
-                        // Remove parenthesis that are used to define the array.
-                        $commaCount--;
-                    }
-                }
-
-                if ($commaCount > $stackPtrCount) {
-                    // This comma is inside more parenthesis than the ARRAY keyword,
-                    // so it is actually a comma used to do things like
-                    // separate arguments in a function call.
-                    continue;
-                }
-
-                if ($keyUsed === false) {
-                    $valueContent = $phpcsFile->findNext(
-                        Tokens::$emptyTokens,
-                        ($lastToken + 1),
-                        $checkToken,
-                        true
-                    );
-
-                    $indices[] = ['value_start' => $valueContent];
-                }
-
-                $lastToken = $checkToken;
-                $keyUsed   = false;
-                continue;
-            }//end if
-
-            if ($tokens[$checkToken]['code'] === T_DOUBLE_ARROW) {
-                $keyUsed = true;
-
-                // Find the start of index that uses this double arrow.
-                $indexEnd   = $phpcsFile->findPrevious(T_WHITESPACE, ($checkToken - 1), $arrayStart, true);
-                $indexStart = $phpcsFile->findStartOfStatement($indexEnd);
-
-                // Find the value of this index.
-                $nextContent = $phpcsFile->findNext(
-                    Tokens::$emptyTokens,
-                    ($checkToken + 1),
-                    $arrayEnd,
-                    true
-                );
-
-                $indices[] = [
-                    'index_start' => $indexStart,
-                    'index_end'   => $indexEnd,
-                    'arrow'       => $checkToken,
-                    'value_start' => $nextContent,
-                ];
-
-                $lastToken = $checkToken;
-            }//end if
-        }//end for
-
-        if ($tokens[$arrayStart]['line'] === $tokens[$arrayEnd]['line']) {
-            $this->processSingleLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices);
-        } else {
-            $this->processMultiLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices);
-        }
-
-    }//end process()
-
-
-    /**
-     * Processes a single-line array definition.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile  The current file being checked.
-     * @param int                         $stackPtr   The position of the current token
-     *                                                in the stack passed in $tokens.
-     * @param int                         $arrayStart The token that starts the array definition.
-     * @param int                         $arrayEnd   The token that ends the array definition.
-     * @param array                       $indices    An array of token positions for the array keys,
-     *                                                double arrows, and values.
-     *
-     * @return void
-     */
-    abstract protected function processSingleLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices);
-
-
-    /**
-     * Processes a multi-line array definition.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile  The current file being checked.
-     * @param int                         $stackPtr   The position of the current token
-     *                                                in the stack passed in $tokens.
-     * @param int                         $arrayStart The token that starts the array definition.
-     * @param int                         $arrayEnd   The token that ends the array definition.
-     * @param array                       $indices    An array of token positions for the array keys,
-     *                                                double arrows, and values.
-     *
-     * @return void
-     */
-    abstract protected function processMultiLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices);
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	final public function register()
+	{
+		return [
+			T_ARRAY,
+			T_OPEN_SHORT_ARRAY,
+		];
+
+	}//end register()
+
+
+	/**
+	 * Processes this sniff, when one of its tokens is encountered.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked.
+	 * @param int                         $stackPtr  The position of the current token in
+	 *                                               the stack passed in $tokens.
+	 *
+	 * @return void
+	 */
+	public function process(File $phpcsFile, $stackPtr)
+	{
+		$tokens = $phpcsFile->getTokens();
+
+		if ($tokens[$stackPtr]['code'] === T_ARRAY) {
+			$phpcsFile->recordMetric($stackPtr, 'Short array syntax used', 'no');
+
+			$arrayStart = $tokens[$stackPtr]['parenthesis_opener'];
+			if (isset($tokens[$arrayStart]['parenthesis_closer']) === false) {
+				// Incomplete array.
+				return;
+			}
+
+			$arrayEnd = $tokens[$arrayStart]['parenthesis_closer'];
+		} else {
+			$phpcsFile->recordMetric($stackPtr, 'Short array syntax used', 'yes');
+			$arrayStart = $stackPtr;
+			$arrayEnd   = $tokens[$stackPtr]['bracket_closer'];
+		}
+
+		$lastContent = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($arrayEnd - 1), null, true);
+		if ($tokens[$lastContent]['code'] === T_COMMA) {
+			// Last array item ends with a comma.
+			$phpcsFile->recordMetric($stackPtr, 'Array end comma', 'yes');
+			$lastArrayToken = $lastContent;
+		} else {
+			$phpcsFile->recordMetric($stackPtr, 'Array end comma', 'no');
+			$lastArrayToken = $arrayEnd;
+		}
+
+		if ($tokens[$stackPtr]['code'] === T_ARRAY) {
+			$lastToken = $tokens[$stackPtr]['parenthesis_opener'];
+		} else {
+			$lastToken = $stackPtr;
+		}
+
+		$keyUsed = false;
+		$indices = [];
+
+		for ($checkToken = ($stackPtr + 1); $checkToken <= $lastArrayToken; $checkToken++) {
+			// Skip bracketed statements, like function calls.
+			if ($tokens[$checkToken]['code'] === T_OPEN_PARENTHESIS
+				&& (isset($tokens[$checkToken]['parenthesis_owner']) === false
+				|| $tokens[$checkToken]['parenthesis_owner'] !== $stackPtr)
+			) {
+				$checkToken = $tokens[$checkToken]['parenthesis_closer'];
+				continue;
+			}
+
+			if ($tokens[$checkToken]['code'] === T_ARRAY
+				|| $tokens[$checkToken]['code'] === T_OPEN_SHORT_ARRAY
+				|| $tokens[$checkToken]['code'] === T_CLOSURE
+			) {
+				// Let subsequent calls of this test handle nested arrays.
+				if ($tokens[$lastToken]['code'] !== T_DOUBLE_ARROW) {
+					$indices[] = ['value_start' => $checkToken];
+					$lastToken = $checkToken;
+				}
+
+				if ($tokens[$checkToken]['code'] === T_ARRAY) {
+					$checkToken = $tokens[$tokens[$checkToken]['parenthesis_opener']]['parenthesis_closer'];
+				} else if ($tokens[$checkToken]['code'] === T_OPEN_SHORT_ARRAY) {
+					$checkToken = $tokens[$checkToken]['bracket_closer'];
+				} else {
+					// T_CLOSURE.
+					$checkToken = $tokens[$checkToken]['scope_closer'];
+				}
+
+				$checkToken = $phpcsFile->findNext(T_WHITESPACE, ($checkToken + 1), null, true);
+				$lastToken  = $checkToken;
+				if ($tokens[$checkToken]['code'] !== T_COMMA) {
+					$checkToken--;
+				}
+
+				continue;
+			}//end if
+
+			if ($tokens[$checkToken]['code'] !== T_DOUBLE_ARROW
+				&& $tokens[$checkToken]['code'] !== T_COMMA
+				&& $checkToken !== $arrayEnd
+			) {
+				continue;
+			}
+
+			if ($tokens[$checkToken]['code'] === T_COMMA
+				|| $checkToken === $arrayEnd
+			) {
+				$stackPtrCount = 0;
+				if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) {
+					$stackPtrCount = count($tokens[$stackPtr]['nested_parenthesis']);
+				}
+
+				$commaCount = 0;
+				if (isset($tokens[$checkToken]['nested_parenthesis']) === true) {
+					$commaCount = count($tokens[$checkToken]['nested_parenthesis']);
+					if ($tokens[$stackPtr]['code'] === T_ARRAY) {
+						// Remove parenthesis that are used to define the array.
+						$commaCount--;
+					}
+				}
+
+				if ($commaCount > $stackPtrCount) {
+					// This comma is inside more parenthesis than the ARRAY keyword,
+					// so it is actually a comma used to do things like
+					// separate arguments in a function call.
+					continue;
+				}
+
+				if ($keyUsed === false) {
+					$valueContent = $phpcsFile->findNext(
+						Tokens::$emptyTokens,
+						($lastToken + 1),
+						$checkToken,
+						true
+					);
+
+					$indices[] = ['value_start' => $valueContent];
+				}
+
+				$lastToken = $checkToken;
+				$keyUsed   = false;
+				continue;
+			}//end if
+
+			if ($tokens[$checkToken]['code'] === T_DOUBLE_ARROW) {
+				$keyUsed = true;
+
+				// Find the start of index that uses this double arrow.
+				$indexEnd   = $phpcsFile->findPrevious(T_WHITESPACE, ($checkToken - 1), $arrayStart, true);
+				$indexStart = $phpcsFile->findStartOfStatement($indexEnd);
+
+				// Find the value of this index.
+				$nextContent = $phpcsFile->findNext(
+					Tokens::$emptyTokens,
+					($checkToken + 1),
+					$arrayEnd,
+					true
+				);
+
+				$indices[] = [
+					'index_start' => $indexStart,
+					'index_end'   => $indexEnd,
+					'arrow'       => $checkToken,
+					'value_start' => $nextContent,
+				];
+
+				$lastToken = $checkToken;
+			}//end if
+		}//end for
+
+		if ($tokens[$arrayStart]['line'] === $tokens[$arrayEnd]['line']) {
+			$this->processSingleLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices);
+		} else {
+			$this->processMultiLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices);
+		}
+
+	}//end process()
+
+
+	/**
+	 * Processes a single-line array definition.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile  The current file being checked.
+	 * @param int                         $stackPtr   The position of the current token
+	 *                                                in the stack passed in $tokens.
+	 * @param int                         $arrayStart The token that starts the array definition.
+	 * @param int                         $arrayEnd   The token that ends the array definition.
+	 * @param array                       $indices    An array of token positions for the array keys,
+	 *                                                double arrows, and values.
+	 *
+	 * @return void
+	 */
+	abstract protected function processSingleLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices);
+
+
+	/**
+	 * Processes a multi-line array definition.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile  The current file being checked.
+	 * @param int                         $stackPtr   The position of the current token
+	 *                                                in the stack passed in $tokens.
+	 * @param int                         $arrayStart The token that starts the array definition.
+	 * @param int                         $arrayEnd   The token that ends the array definition.
+	 * @param array                       $indices    An array of token positions for the array keys,
+	 *                                                double arrows, and values.
+	 *
+	 * @return void
+	 */
+	abstract protected function processMultiLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices);
 
 
 }//end class

Spacing +54 added lines, -54 removed lines

@@ -40,123 +40,123 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
+    public function process( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
-        if ($tokens[$stackPtr]['code'] === T_ARRAY) {
-            $phpcsFile->recordMetric($stackPtr, 'Short array syntax used', 'no');
+        if ( $tokens[ $stackPtr ][ 'code' ] === T_ARRAY ) {
+            $phpcsFile->recordMetric( $stackPtr, 'Short array syntax used', 'no' );
 
-            $arrayStart = $tokens[$stackPtr]['parenthesis_opener'];
-            if (isset($tokens[$arrayStart]['parenthesis_closer']) === false) {
+            $arrayStart = $tokens[ $stackPtr ][ 'parenthesis_opener' ];
+            if ( isset( $tokens[ $arrayStart ][ 'parenthesis_closer' ] ) === false ) {
                 // Incomplete array.
                 return;
             }
 
-            $arrayEnd = $tokens[$arrayStart]['parenthesis_closer'];
+            $arrayEnd = $tokens[ $arrayStart ][ 'parenthesis_closer' ];
         } else {
-            $phpcsFile->recordMetric($stackPtr, 'Short array syntax used', 'yes');
+            $phpcsFile->recordMetric( $stackPtr, 'Short array syntax used', 'yes' );
             $arrayStart = $stackPtr;
-            $arrayEnd   = $tokens[$stackPtr]['bracket_closer'];
+            $arrayEnd   = $tokens[ $stackPtr ][ 'bracket_closer' ];
         }
 
-        $lastContent = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($arrayEnd - 1), null, true);
-        if ($tokens[$lastContent]['code'] === T_COMMA) {
+        $lastContent = $phpcsFile->findPrevious( Tokens::$emptyTokens, ( $arrayEnd - 1 ), null, true );
+        if ( $tokens[ $lastContent ][ 'code' ] === T_COMMA ) {
             // Last array item ends with a comma.
-            $phpcsFile->recordMetric($stackPtr, 'Array end comma', 'yes');
+            $phpcsFile->recordMetric( $stackPtr, 'Array end comma', 'yes' );
             $lastArrayToken = $lastContent;
         } else {
-            $phpcsFile->recordMetric($stackPtr, 'Array end comma', 'no');
+            $phpcsFile->recordMetric( $stackPtr, 'Array end comma', 'no' );
             $lastArrayToken = $arrayEnd;
         }
 
-        if ($tokens[$stackPtr]['code'] === T_ARRAY) {
-            $lastToken = $tokens[$stackPtr]['parenthesis_opener'];
+        if ( $tokens[ $stackPtr ][ 'code' ] === T_ARRAY ) {
+            $lastToken = $tokens[ $stackPtr ][ 'parenthesis_opener' ];
         } else {
             $lastToken = $stackPtr;
         }
 
         $keyUsed = false;
-        $indices = [];
+        $indices = [ ];
 
-        for ($checkToken = ($stackPtr + 1); $checkToken <= $lastArrayToken; $checkToken++) {
+        for ( $checkToken = ( $stackPtr + 1 ); $checkToken <= $lastArrayToken; $checkToken++ ) {
             // Skip bracketed statements, like function calls.
-            if ($tokens[$checkToken]['code'] === T_OPEN_PARENTHESIS
-                && (isset($tokens[$checkToken]['parenthesis_owner']) === false
-                || $tokens[$checkToken]['parenthesis_owner'] !== $stackPtr)
+            if ( $tokens[ $checkToken ][ 'code' ] === T_OPEN_PARENTHESIS
+                && ( isset( $tokens[ $checkToken ][ 'parenthesis_owner' ] ) === false
+                || $tokens[ $checkToken ][ 'parenthesis_owner' ] !== $stackPtr )
             ) {
-                $checkToken = $tokens[$checkToken]['parenthesis_closer'];
+                $checkToken = $tokens[ $checkToken ][ 'parenthesis_closer' ];
                 continue;
             }
 
-            if ($tokens[$checkToken]['code'] === T_ARRAY
-                || $tokens[$checkToken]['code'] === T_OPEN_SHORT_ARRAY
-                || $tokens[$checkToken]['code'] === T_CLOSURE
+            if ( $tokens[ $checkToken ][ 'code' ] === T_ARRAY
+                || $tokens[ $checkToken ][ 'code' ] === T_OPEN_SHORT_ARRAY
+                || $tokens[ $checkToken ][ 'code' ] === T_CLOSURE
             ) {
                 // Let subsequent calls of this test handle nested arrays.
-                if ($tokens[$lastToken]['code'] !== T_DOUBLE_ARROW) {
-                    $indices[] = ['value_start' => $checkToken];
+                if ( $tokens[ $lastToken ][ 'code' ] !== T_DOUBLE_ARROW ) {
+                    $indices[ ] = [ 'value_start' => $checkToken ];
                     $lastToken = $checkToken;
                 }
 
-                if ($tokens[$checkToken]['code'] === T_ARRAY) {
-                    $checkToken = $tokens[$tokens[$checkToken]['parenthesis_opener']]['parenthesis_closer'];
-                } else if ($tokens[$checkToken]['code'] === T_OPEN_SHORT_ARRAY) {
-                    $checkToken = $tokens[$checkToken]['bracket_closer'];
+                if ( $tokens[ $checkToken ][ 'code' ] === T_ARRAY ) {
+                    $checkToken = $tokens[ $tokens[ $checkToken ][ 'parenthesis_opener' ] ][ 'parenthesis_closer' ];
+                } else if ( $tokens[ $checkToken ][ 'code' ] === T_OPEN_SHORT_ARRAY ) {
+                    $checkToken = $tokens[ $checkToken ][ 'bracket_closer' ];
                 } else {
                     // T_CLOSURE.
-                    $checkToken = $tokens[$checkToken]['scope_closer'];
+                    $checkToken = $tokens[ $checkToken ][ 'scope_closer' ];
                 }
 
-                $checkToken = $phpcsFile->findNext(T_WHITESPACE, ($checkToken + 1), null, true);
+                $checkToken = $phpcsFile->findNext( T_WHITESPACE, ( $checkToken + 1 ), null, true );
                 $lastToken  = $checkToken;
-                if ($tokens[$checkToken]['code'] !== T_COMMA) {
+                if ( $tokens[ $checkToken ][ 'code' ] !== T_COMMA ) {
                     $checkToken--;
                 }
 
                 continue;
             }//end if
 
-            if ($tokens[$checkToken]['code'] !== T_DOUBLE_ARROW
-                && $tokens[$checkToken]['code'] !== T_COMMA
+            if ( $tokens[ $checkToken ][ 'code' ] !== T_DOUBLE_ARROW
+                && $tokens[ $checkToken ][ 'code' ] !== T_COMMA
                 && $checkToken !== $arrayEnd
             ) {
                 continue;
             }
 
-            if ($tokens[$checkToken]['code'] === T_COMMA
+            if ( $tokens[ $checkToken ][ 'code' ] === T_COMMA
                 || $checkToken === $arrayEnd
             ) {
                 $stackPtrCount = 0;
-                if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) {
-                    $stackPtrCount = count($tokens[$stackPtr]['nested_parenthesis']);
+                if ( isset( $tokens[ $stackPtr ][ 'nested_parenthesis' ] ) === true ) {
+                    $stackPtrCount = count( $tokens[ $stackPtr ][ 'nested_parenthesis' ] );
                 }
 
                 $commaCount = 0;
-                if (isset($tokens[$checkToken]['nested_parenthesis']) === true) {
-                    $commaCount = count($tokens[$checkToken]['nested_parenthesis']);
-                    if ($tokens[$stackPtr]['code'] === T_ARRAY) {
+                if ( isset( $tokens[ $checkToken ][ 'nested_parenthesis' ] ) === true ) {
+                    $commaCount = count( $tokens[ $checkToken ][ 'nested_parenthesis' ] );
+                    if ( $tokens[ $stackPtr ][ 'code' ] === T_ARRAY ) {
                         // Remove parenthesis that are used to define the array.
                         $commaCount--;
                     }
                 }
 
-                if ($commaCount > $stackPtrCount) {
+                if ( $commaCount > $stackPtrCount ) {
                     // This comma is inside more parenthesis than the ARRAY keyword,
                     // so it is actually a comma used to do things like
                     // separate arguments in a function call.
                     continue;
                 }
 
-                if ($keyUsed === false) {
+                if ( $keyUsed === false ) {
                     $valueContent = $phpcsFile->findNext(
                         Tokens::$emptyTokens,
-                        ($lastToken + 1),
+                        ( $lastToken + 1 ),
                         $checkToken,
                         true
                     );
 
-                    $indices[] = ['value_start' => $valueContent];
+                    $indices[ ] = [ 'value_start' => $valueContent ];
                 }
 
                 $lastToken = $checkToken;
@@ -164,22 +164,22 @@ 
                 continue;
             }//end if
 
-            if ($tokens[$checkToken]['code'] === T_DOUBLE_ARROW) {
+            if ( $tokens[ $checkToken ][ 'code' ] === T_DOUBLE_ARROW ) {
                 $keyUsed = true;
 
                 // Find the start of index that uses this double arrow.
-                $indexEnd   = $phpcsFile->findPrevious(T_WHITESPACE, ($checkToken - 1), $arrayStart, true);
-                $indexStart = $phpcsFile->findStartOfStatement($indexEnd);
+                $indexEnd   = $phpcsFile->findPrevious( T_WHITESPACE, ( $checkToken - 1 ), $arrayStart, true );
+                $indexStart = $phpcsFile->findStartOfStatement( $indexEnd );
 
                 // Find the value of this index.
                 $nextContent = $phpcsFile->findNext(
                     Tokens::$emptyTokens,
-                    ($checkToken + 1),
+                    ( $checkToken + 1 ),
                     $arrayEnd,
                     true
                 );
 
-                $indices[] = [
+                $indices[ ] = [
                     'index_start' => $indexStart,
                     'index_end'   => $indexEnd,
                     'arrow'       => $checkToken,
@@ -190,10 +190,10 @@ 
             }//end if
         }//end for
 
-        if ($tokens[$arrayStart]['line'] === $tokens[$arrayEnd]['line']) {
-            $this->processSingleLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices);
+        if ( $tokens[ $arrayStart ][ 'line' ] === $tokens[ $arrayEnd ][ 'line' ] ) {
+            $this->processSingleLineArray( $phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices );
         } else {
-            $this->processMultiLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices);
+            $this->processMultiLineArray( $phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices );
         }
 
     }//end process()
@@ -212,7 +212,7 @@ 
      *
      * @return void
      */
-    abstract protected function processSingleLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices);
+    abstract protected function processSingleLineArray( $phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices );
 
 
     /**
@@ -228,7 +228,7 @@ 
      *
      * @return void
      */
-    abstract protected function processMultiLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices);
+    abstract protected function processMultiLineArray( $phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices );
 
 
 }//end class

Braces +3 added lines, -6 removed lines

@@ -12,8 +12,7 @@ 
 use PHP_CodeSniffer\Files\File;
 use PHP_CodeSniffer\Util\Tokens;
 
-abstract class AbstractArraySniff implements Sniff
-{
+abstract class AbstractArraySniff implements Sniff {
 
 
     /**
@@ -21,8 +20,7 @@ 
      *
      * @return array
      */
-    final public function register()
-    {
+    final public function register() {
         return [
             T_ARRAY,
             T_OPEN_SHORT_ARRAY,
@@ -40,8 +38,7 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
-    {
+    public function process(File $phpcsFile, $stackPtr) {
         $tokens = $phpcsFile->getTokens();
 
         if ($tokens[$stackPtr]['code'] === T_ARRAY) {

vendor/squizlabs/php_codesniffer/src/Sniffs/AbstractVariableSniff.php

Indentation +204 added lines, -204 removed lines

@@ -22,210 +22,210 @@
 {
 
 
-    /**
-     * List of PHP Reserved variables.
-     *
-     * Used by various naming convention sniffs.
-     *
-     * @var array
-     */
-    protected $phpReservedVars = [
-        '_SERVER'              => true,
-        '_GET'                 => true,
-        '_POST'                => true,
-        '_REQUEST'             => true,
-        '_SESSION'             => true,
-        '_ENV'                 => true,
-        '_COOKIE'              => true,
-        '_FILES'               => true,
-        'GLOBALS'              => true,
-        'http_response_header' => true,
-        'HTTP_RAW_POST_DATA'   => true,
-        'php_errormsg'         => true,
-    ];
-
-
-    /**
-     * Constructs an AbstractVariableTest.
-     */
-    public function __construct()
-    {
-        $scopes = Tokens::$ooScopeTokens;
-
-        $listen = [
-            T_VARIABLE,
-            T_DOUBLE_QUOTED_STRING,
-            T_HEREDOC,
-        ];
-
-        parent::__construct($scopes, $listen, true);
-
-    }//end __construct()
-
-
-    /**
-     * Processes the token in the specified PHP_CodeSniffer\Files\File.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this
-     *                                               token was found.
-     * @param int                         $stackPtr  The position where the token was found.
-     * @param int                         $currScope The current scope opener token.
-     *
-     * @return void|int Optionally returns a stack pointer. The sniff will not be
-     *                  called again on the current file until the returned stack
-     *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
-     *                  the rest of the file.
-     */
-    final protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope)
-    {
-        $tokens = $phpcsFile->getTokens();
-
-        if ($tokens[$stackPtr]['code'] === T_DOUBLE_QUOTED_STRING
-            || $tokens[$stackPtr]['code'] === T_HEREDOC
-        ) {
-            // Check to see if this string has a variable in it.
-            $pattern = '|(?<!\\\\)(?:\\\\{2})*\${?[a-zA-Z0-9_]+}?|';
-            if (preg_match($pattern, $tokens[$stackPtr]['content']) !== 0) {
-                return $this->processVariableInString($phpcsFile, $stackPtr);
-            }
-
-            return;
-        }
-
-        // If this token is nested inside a function at a deeper
-        // level than the current OO scope that was found, it's a normal
-        // variable and not a member var.
-        $conditions = array_reverse($tokens[$stackPtr]['conditions'], true);
-        $inFunction = false;
-        foreach ($conditions as $scope => $code) {
-            if (isset(Tokens::$ooScopeTokens[$code]) === true) {
-                break;
-            }
-
-            if ($code === T_FUNCTION || $code === T_CLOSURE) {
-                $inFunction = true;
-            }
-        }
-
-        if ($scope !== $currScope) {
-            // We found a closer scope to this token, so ignore
-            // this particular time through the sniff. We will process
-            // this token when this closer scope is found to avoid
-            // duplicate checks.
-            return;
-        }
-
-        // Just make sure this isn't a variable in a function declaration.
-        if ($inFunction === false && isset($tokens[$stackPtr]['nested_parenthesis']) === true) {
-            foreach ($tokens[$stackPtr]['nested_parenthesis'] as $opener => $closer) {
-                if (isset($tokens[$opener]['parenthesis_owner']) === false) {
-                    // Check if this is a USE statement for a closure.
-                    $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($opener - 1), null, true);
-                    if ($tokens[$prev]['code'] === T_USE) {
-                        $inFunction = true;
-                        break;
-                    }
-
-                    continue;
-                }
-
-                $owner = $tokens[$opener]['parenthesis_owner'];
-                if ($tokens[$owner]['code'] === T_FUNCTION
-                    || $tokens[$owner]['code'] === T_CLOSURE
-                ) {
-                    $inFunction = true;
-                    break;
-                }
-            }
-        }//end if
-
-        if ($inFunction === true) {
-            return $this->processVariable($phpcsFile, $stackPtr);
-        } else {
-            return $this->processMemberVar($phpcsFile, $stackPtr);
-        }
-
-    }//end processTokenWithinScope()
-
-
-    /**
-     * Processes the token outside the scope in the file.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this
-     *                                               token was found.
-     * @param int                         $stackPtr  The position where the token was found.
-     *
-     * @return void|int Optionally returns a stack pointer. The sniff will not be
-     *                  called again on the current file until the returned stack
-     *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
-     *                  the rest of the file.
-     */
-    final protected function processTokenOutsideScope(File $phpcsFile, $stackPtr)
-    {
-        $tokens = $phpcsFile->getTokens();
-        // These variables are not member vars.
-        if ($tokens[$stackPtr]['code'] === T_VARIABLE) {
-            return $this->processVariable($phpcsFile, $stackPtr);
-        } else if ($tokens[$stackPtr]['code'] === T_DOUBLE_QUOTED_STRING
-            || $tokens[$stackPtr]['code'] === T_HEREDOC
-        ) {
-            // Check to see if this string has a variable in it.
-            $pattern = '|(?<!\\\\)(?:\\\\{2})*\${?[a-zA-Z0-9_]+}?|';
-            if (preg_match($pattern, $tokens[$stackPtr]['content']) !== 0) {
-                return $this->processVariableInString($phpcsFile, $stackPtr);
-            }
-        }
-
-    }//end processTokenOutsideScope()
-
-
-    /**
-     * Called to process class member vars.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this
-     *                                               token was found.
-     * @param int                         $stackPtr  The position where the token was found.
-     *
-     * @return void|int Optionally returns a stack pointer. The sniff will not be
-     *                  called again on the current file until the returned stack
-     *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
-     *                  the rest of the file.
-     */
-    abstract protected function processMemberVar(File $phpcsFile, $stackPtr);
-
-
-    /**
-     * Called to process normal member vars.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this
-     *                                               token was found.
-     * @param int                         $stackPtr  The position where the token was found.
-     *
-     * @return void|int Optionally returns a stack pointer. The sniff will not be
-     *                  called again on the current file until the returned stack
-     *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
-     *                  the rest of the file.
-     */
-    abstract protected function processVariable(File $phpcsFile, $stackPtr);
-
-
-    /**
-     * Called to process variables found in double quoted strings or heredocs.
-     *
-     * Note that there may be more than one variable in the string, which will
-     * result only in one call for the string or one call per line for heredocs.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this
-     *                                               token was found.
-     * @param int                         $stackPtr  The position where the double quoted
-     *                                               string was found.
-     *
-     * @return void|int Optionally returns a stack pointer. The sniff will not be
-     *                  called again on the current file until the returned stack
-     *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
-     *                  the rest of the file.
-     */
-    abstract protected function processVariableInString(File $phpcsFile, $stackPtr);
+	/**
+	 * List of PHP Reserved variables.
+	 *
+	 * Used by various naming convention sniffs.
+	 *
+	 * @var array
+	 */
+	protected $phpReservedVars = [
+		'_SERVER'              => true,
+		'_GET'                 => true,
+		'_POST'                => true,
+		'_REQUEST'             => true,
+		'_SESSION'             => true,
+		'_ENV'                 => true,
+		'_COOKIE'              => true,
+		'_FILES'               => true,
+		'GLOBALS'              => true,
+		'http_response_header' => true,
+		'HTTP_RAW_POST_DATA'   => true,
+		'php_errormsg'         => true,
+	];
+
+
+	/**
+	 * Constructs an AbstractVariableTest.
+	 */
+	public function __construct()
+	{
+		$scopes = Tokens::$ooScopeTokens;
+
+		$listen = [
+			T_VARIABLE,
+			T_DOUBLE_QUOTED_STRING,
+			T_HEREDOC,
+		];
+
+		parent::__construct($scopes, $listen, true);
+
+	}//end __construct()
+
+
+	/**
+	 * Processes the token in the specified PHP_CodeSniffer\Files\File.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this
+	 *                                               token was found.
+	 * @param int                         $stackPtr  The position where the token was found.
+	 * @param int                         $currScope The current scope opener token.
+	 *
+	 * @return void|int Optionally returns a stack pointer. The sniff will not be
+	 *                  called again on the current file until the returned stack
+	 *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
+	 *                  the rest of the file.
+	 */
+	final protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope)
+	{
+		$tokens = $phpcsFile->getTokens();
+
+		if ($tokens[$stackPtr]['code'] === T_DOUBLE_QUOTED_STRING
+			|| $tokens[$stackPtr]['code'] === T_HEREDOC
+		) {
+			// Check to see if this string has a variable in it.
+			$pattern = '|(?<!\\\\)(?:\\\\{2})*\${?[a-zA-Z0-9_]+}?|';
+			if (preg_match($pattern, $tokens[$stackPtr]['content']) !== 0) {
+				return $this->processVariableInString($phpcsFile, $stackPtr);
+			}
+
+			return;
+		}
+
+		// If this token is nested inside a function at a deeper
+		// level than the current OO scope that was found, it's a normal
+		// variable and not a member var.
+		$conditions = array_reverse($tokens[$stackPtr]['conditions'], true);
+		$inFunction = false;
+		foreach ($conditions as $scope => $code) {
+			if (isset(Tokens::$ooScopeTokens[$code]) === true) {
+				break;
+			}
+
+			if ($code === T_FUNCTION || $code === T_CLOSURE) {
+				$inFunction = true;
+			}
+		}
+
+		if ($scope !== $currScope) {
+			// We found a closer scope to this token, so ignore
+			// this particular time through the sniff. We will process
+			// this token when this closer scope is found to avoid
+			// duplicate checks.
+			return;
+		}
+
+		// Just make sure this isn't a variable in a function declaration.
+		if ($inFunction === false && isset($tokens[$stackPtr]['nested_parenthesis']) === true) {
+			foreach ($tokens[$stackPtr]['nested_parenthesis'] as $opener => $closer) {
+				if (isset($tokens[$opener]['parenthesis_owner']) === false) {
+					// Check if this is a USE statement for a closure.
+					$prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($opener - 1), null, true);
+					if ($tokens[$prev]['code'] === T_USE) {
+						$inFunction = true;
+						break;
+					}
+
+					continue;
+				}
+
+				$owner = $tokens[$opener]['parenthesis_owner'];
+				if ($tokens[$owner]['code'] === T_FUNCTION
+					|| $tokens[$owner]['code'] === T_CLOSURE
+				) {
+					$inFunction = true;
+					break;
+				}
+			}
+		}//end if
+
+		if ($inFunction === true) {
+			return $this->processVariable($phpcsFile, $stackPtr);
+		} else {
+			return $this->processMemberVar($phpcsFile, $stackPtr);
+		}
+
+	}//end processTokenWithinScope()
+
+
+	/**
+	 * Processes the token outside the scope in the file.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this
+	 *                                               token was found.
+	 * @param int                         $stackPtr  The position where the token was found.
+	 *
+	 * @return void|int Optionally returns a stack pointer. The sniff will not be
+	 *                  called again on the current file until the returned stack
+	 *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
+	 *                  the rest of the file.
+	 */
+	final protected function processTokenOutsideScope(File $phpcsFile, $stackPtr)
+	{
+		$tokens = $phpcsFile->getTokens();
+		// These variables are not member vars.
+		if ($tokens[$stackPtr]['code'] === T_VARIABLE) {
+			return $this->processVariable($phpcsFile, $stackPtr);
+		} else if ($tokens[$stackPtr]['code'] === T_DOUBLE_QUOTED_STRING
+			|| $tokens[$stackPtr]['code'] === T_HEREDOC
+		) {
+			// Check to see if this string has a variable in it.
+			$pattern = '|(?<!\\\\)(?:\\\\{2})*\${?[a-zA-Z0-9_]+}?|';
+			if (preg_match($pattern, $tokens[$stackPtr]['content']) !== 0) {
+				return $this->processVariableInString($phpcsFile, $stackPtr);
+			}
+		}
+
+	}//end processTokenOutsideScope()
+
+
+	/**
+	 * Called to process class member vars.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this
+	 *                                               token was found.
+	 * @param int                         $stackPtr  The position where the token was found.
+	 *
+	 * @return void|int Optionally returns a stack pointer. The sniff will not be
+	 *                  called again on the current file until the returned stack
+	 *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
+	 *                  the rest of the file.
+	 */
+	abstract protected function processMemberVar(File $phpcsFile, $stackPtr);
+
+
+	/**
+	 * Called to process normal member vars.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this
+	 *                                               token was found.
+	 * @param int                         $stackPtr  The position where the token was found.
+	 *
+	 * @return void|int Optionally returns a stack pointer. The sniff will not be
+	 *                  called again on the current file until the returned stack
+	 *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
+	 *                  the rest of the file.
+	 */
+	abstract protected function processVariable(File $phpcsFile, $stackPtr);
+
+
+	/**
+	 * Called to process variables found in double quoted strings or heredocs.
+	 *
+	 * Note that there may be more than one variable in the string, which will
+	 * result only in one call for the string or one call per line for heredocs.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this
+	 *                                               token was found.
+	 * @param int                         $stackPtr  The position where the double quoted
+	 *                                               string was found.
+	 *
+	 * @return void|int Optionally returns a stack pointer. The sniff will not be
+	 *                  called again on the current file until the returned stack
+	 *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
+	 *                  the rest of the file.
+	 */
+	abstract protected function processVariableInString(File $phpcsFile, $stackPtr);
 
 
 }//end class

Spacing +32 added lines, -32 removed lines

@@ -58,7 +58,7 @@ 
             T_HEREDOC,
         ];
 
-        parent::__construct($scopes, $listen, true);
+        parent::__construct( $scopes, $listen, true );
 
     }//end __construct()
 
@@ -76,17 +76,17 @@ 
      *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
      *                  the rest of the file.
      */
-    final protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope)
+    final protected function processTokenWithinScope( File $phpcsFile, $stackPtr, $currScope )
     {
         $tokens = $phpcsFile->getTokens();
 
-        if ($tokens[$stackPtr]['code'] === T_DOUBLE_QUOTED_STRING
-            || $tokens[$stackPtr]['code'] === T_HEREDOC
+        if ( $tokens[ $stackPtr ][ 'code' ] === T_DOUBLE_QUOTED_STRING
+            || $tokens[ $stackPtr ][ 'code' ] === T_HEREDOC
         ) {
             // Check to see if this string has a variable in it.
             $pattern = '|(?<!\\\\)(?:\\\\{2})*\${?[a-zA-Z0-9_]+}?|';
-            if (preg_match($pattern, $tokens[$stackPtr]['content']) !== 0) {
-                return $this->processVariableInString($phpcsFile, $stackPtr);
+            if ( preg_match( $pattern, $tokens[ $stackPtr ][ 'content' ] ) !== 0 ) {
+                return $this->processVariableInString( $phpcsFile, $stackPtr );
             }
 
             return;
@@ -95,19 +95,19 @@ 
         // If this token is nested inside a function at a deeper
         // level than the current OO scope that was found, it's a normal
         // variable and not a member var.
-        $conditions = array_reverse($tokens[$stackPtr]['conditions'], true);
+        $conditions = array_reverse( $tokens[ $stackPtr ][ 'conditions' ], true );
         $inFunction = false;
-        foreach ($conditions as $scope => $code) {
-            if (isset(Tokens::$ooScopeTokens[$code]) === true) {
+        foreach ( $conditions as $scope => $code ) {
+            if ( isset( Tokens::$ooScopeTokens[ $code ] ) === true ) {
                 break;
             }
 
-            if ($code === T_FUNCTION || $code === T_CLOSURE) {
+            if ( $code === T_FUNCTION || $code === T_CLOSURE ) {
                 $inFunction = true;
             }
         }
 
-        if ($scope !== $currScope) {
+        if ( $scope !== $currScope ) {
             // We found a closer scope to this token, so ignore
             // this particular time through the sniff. We will process
             // this token when this closer scope is found to avoid
@@ -116,12 +116,12 @@ 
         }
 
         // Just make sure this isn't a variable in a function declaration.
-        if ($inFunction === false && isset($tokens[$stackPtr]['nested_parenthesis']) === true) {
-            foreach ($tokens[$stackPtr]['nested_parenthesis'] as $opener => $closer) {
-                if (isset($tokens[$opener]['parenthesis_owner']) === false) {
+        if ( $inFunction === false && isset( $tokens[ $stackPtr ][ 'nested_parenthesis' ] ) === true ) {
+            foreach ( $tokens[ $stackPtr ][ 'nested_parenthesis' ] as $opener => $closer ) {
+                if ( isset( $tokens[ $opener ][ 'parenthesis_owner' ] ) === false ) {
                     // Check if this is a USE statement for a closure.
-                    $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($opener - 1), null, true);
-                    if ($tokens[$prev]['code'] === T_USE) {
+                    $prev = $phpcsFile->findPrevious( Tokens::$emptyTokens, ( $opener - 1 ), null, true );
+                    if ( $tokens[ $prev ][ 'code' ] === T_USE ) {
                         $inFunction = true;
                         break;
                     }
@@ -129,9 +129,9 @@ 
                     continue;
                 }
 
-                $owner = $tokens[$opener]['parenthesis_owner'];
-                if ($tokens[$owner]['code'] === T_FUNCTION
-                    || $tokens[$owner]['code'] === T_CLOSURE
+                $owner = $tokens[ $opener ][ 'parenthesis_owner' ];
+                if ( $tokens[ $owner ][ 'code' ] === T_FUNCTION
+                    || $tokens[ $owner ][ 'code' ] === T_CLOSURE
                 ) {
                     $inFunction = true;
                     break;
@@ -139,10 +139,10 @@ 
             }
         }//end if
 
-        if ($inFunction === true) {
-            return $this->processVariable($phpcsFile, $stackPtr);
+        if ( $inFunction === true ) {
+            return $this->processVariable( $phpcsFile, $stackPtr );
         } else {
-            return $this->processMemberVar($phpcsFile, $stackPtr);
+            return $this->processMemberVar( $phpcsFile, $stackPtr );
         }
 
     }//end processTokenWithinScope()
@@ -160,19 +160,19 @@ 
      *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
      *                  the rest of the file.
      */
-    final protected function processTokenOutsideScope(File $phpcsFile, $stackPtr)
+    final protected function processTokenOutsideScope( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
         // These variables are not member vars.
-        if ($tokens[$stackPtr]['code'] === T_VARIABLE) {
-            return $this->processVariable($phpcsFile, $stackPtr);
-        } else if ($tokens[$stackPtr]['code'] === T_DOUBLE_QUOTED_STRING
-            || $tokens[$stackPtr]['code'] === T_HEREDOC
+        if ( $tokens[ $stackPtr ][ 'code' ] === T_VARIABLE ) {
+            return $this->processVariable( $phpcsFile, $stackPtr );
+        } else if ( $tokens[ $stackPtr ][ 'code' ] === T_DOUBLE_QUOTED_STRING
+            || $tokens[ $stackPtr ][ 'code' ] === T_HEREDOC
         ) {
             // Check to see if this string has a variable in it.
             $pattern = '|(?<!\\\\)(?:\\\\{2})*\${?[a-zA-Z0-9_]+}?|';
-            if (preg_match($pattern, $tokens[$stackPtr]['content']) !== 0) {
-                return $this->processVariableInString($phpcsFile, $stackPtr);
+            if ( preg_match( $pattern, $tokens[ $stackPtr ][ 'content' ] ) !== 0 ) {
+                return $this->processVariableInString( $phpcsFile, $stackPtr );
             }
         }
 
@@ -191,7 +191,7 @@ 
      *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
      *                  the rest of the file.
      */
-    abstract protected function processMemberVar(File $phpcsFile, $stackPtr);
+    abstract protected function processMemberVar( File $phpcsFile, $stackPtr );
 
 
     /**
@@ -206,7 +206,7 @@ 
      *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
      *                  the rest of the file.
      */
-    abstract protected function processVariable(File $phpcsFile, $stackPtr);
+    abstract protected function processVariable( File $phpcsFile, $stackPtr );
 
 
     /**
@@ -225,7 +225,7 @@ 
      *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
      *                  the rest of the file.
      */
-    abstract protected function processVariableInString(File $phpcsFile, $stackPtr);
+    abstract protected function processVariableInString( File $phpcsFile, $stackPtr );
 
 
 }//end class

Braces +4 added lines, -8 removed lines

@@ -18,8 +18,7 @@ 
 use PHP_CodeSniffer\Files\File;
 use PHP_CodeSniffer\Util\Tokens;
 
-abstract class AbstractVariableSniff extends AbstractScopeSniff
-{
+abstract class AbstractVariableSniff extends AbstractScopeSniff {
 
 
     /**
@@ -48,8 +47,7 @@ 
     /**
      * Constructs an AbstractVariableTest.
      */
-    public function __construct()
-    {
+    public function __construct() {
         $scopes = Tokens::$ooScopeTokens;
 
         $listen = [
@@ -76,8 +74,7 @@ 
      *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
      *                  the rest of the file.
      */
-    final protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope)
-    {
+    final protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope) {
         $tokens = $phpcsFile->getTokens();
 
         if ($tokens[$stackPtr]['code'] === T_DOUBLE_QUOTED_STRING
@@ -160,8 +157,7 @@ 
      *                  pointer is reached. Return ($phpcsFile->numTokens + 1) to skip
      *                  the rest of the file.
      */
-    final protected function processTokenOutsideScope(File $phpcsFile, $stackPtr)
-    {
+    final protected function processTokenOutsideScope(File $phpcsFile, $stackPtr) {
         $tokens = $phpcsFile->getTokens();
         // These variables are not member vars.
         if ($tokens[$stackPtr]['code'] === T_VARIABLE) {

vendor/squizlabs/php_codesniffer/src/Standards/Generic/Tests/Formatting/SpaceAfterCastUnitTest.inc

Indentation +2 added lines, -2 removed lines

@@ -56,7 +56,7 @@ 
 	$var2;
 
 if ( (string) // phpcs:ignore Standard.Cat.SniffName -- for reasons.
-    $x === 'test'
+	$x === 'test'
 ) {}
 
 // phpcs:set Generic.Formatting.SpaceAfterCast ignoreNewlines true
@@ -64,7 +64,7 @@ 
 	$var1 + (bool)  $var2;
 
 if ( (string) // phpcs:ignore Standard.Cat.SniffName -- for reasons.
-    $x === 'test'
+	$x === 'test'
 ) {}
 // phpcs:set Generic.Formatting.SpaceAfterCast ignoreNewlines false
 

Spacing +36 added lines, -36 removed lines

@@ -1,95 +1,95 @@
 <?php
 
-$var = (int) $var2;
 $var = (int)$var2;
-$var = (int)  $var2;
+$var = (int)$var2;
+$var = (int)$var2;
 
-$var = (integer) $var2;
 $var = (integer)$var2;
-$var = (integer)  $var2;
+$var = (integer)$var2;
+$var = (integer)$var2;
 
-$var = (string) $var2;
 $var = (string)$var2;
-$var = (string)    $var2;
+$var = (string)$var2;
+$var = (string)$var2;
 
-$var = (float) $var2;
 $var = (float)$var2;
-$var = (float)  $var2;
+$var = (float)$var2;
+$var = (float)$var2;
 
-$var = (double) $var2;
 $var = (double)$var2;
-$var = (double)  $var2;
+$var = (double)$var2;
+$var = (double)$var2;
 
-$var = (real) $var2;
 $var = (real)$var2;
-$var = (real)  $var2;
+$var = (real)$var2;
+$var = (real)$var2;
 
-$var = (array) $var2;
 $var = (array)$var2;
-$var = (array)  $var2;
+$var = (array)$var2;
+$var = (array)$var2;
 
-$var = (bool) $var2;
 $var = (bool)$var2;
-$var = (bool)  $var2;
+$var = (bool)$var2;
+$var = (bool)$var2;
 
-$var = (boolean) $var2;
 $var = (boolean)$var2;
-$var = (boolean)  $var2;
+$var = (boolean)$var2;
+$var = (boolean)$var2;
 
-$var = (object) $var2;
 $var = (object)$var2;
-$var = (object)  $var2;
+$var = (object)$var2;
+$var = (object)$var2;
 
-$var = (unset) $var2;
 $var = (unset)$var2;
-$var = (unset)          $var2;
+$var = (unset)$var2;
+$var = (unset)$var2;
 
 $var = b"binary $foo";
 $var = b"binary string";
 $var = b'binary string';
-$var = (binary) $string;
+$var = (binary)$string;
 $var = (binary)$string;
 
-$var = (boolean) /* comment */ $var2;
+$var = (boolean)/* comment */ $var2;
 
 $var = (int)
 	$var2;
 
-if ( (string) // phpcs:ignore Standard.Cat.SniffName -- for reasons.
+if ( (string)// phpcs:ignore Standard.Cat.SniffName -- for reasons.
     $x === 'test'
 ) {}
 
 // phpcs:set Generic.Formatting.SpaceAfterCast ignoreNewlines true
 $var = (int)
-	$var1 + (bool)  $var2;
+	$var1 + (bool)$var2;
 
-if ( (string) // phpcs:ignore Standard.Cat.SniffName -- for reasons.
+if ( (string)// phpcs:ignore Standard.Cat.SniffName -- for reasons.
     $x === 'test'
 ) {}
 // phpcs:set Generic.Formatting.SpaceAfterCast ignoreNewlines false
 
 // phpcs:set Generic.Formatting.SpaceAfterCast spacing 2
-$var = (int) $var2;
+$var = (int)$var2;
 $var = (string)$var2;
-$var = (array)  $var2;
-$var = (unset)        $var2;
-$var = (boolean) /* comment */ $var2;
+$var = (array)$var2;
+$var = (unset)$var2;
+$var = (boolean)/* comment */ $var2;
 
 $var = (integer)
 	$var2;
 
 // phpcs:set Generic.Formatting.SpaceAfterCast spacing 0
-$var = (int) $var2;
+$var = (int)$var2;
 $var = (string)$var2;
-$var = (array)  $var2;
-$var = (unset)        $var2;
-$var = (boolean) /* comment */ $var2;
+$var = (array)$var2;
+$var = (unset)$var2;
+$var = (boolean)/* comment */ $var2;
 
 $var = (integer)
 	$var2;
 
 // phpcs:set Generic.Formatting.SpaceAfterCast ignoreNewlines true
 $var = (int)
-	$var1 + (bool)  $var2;
+	$var1 + (bool)$var2;
 // phpcs:set Generic.Formatting.SpaceAfterCast ignoreNewlines false
 // phpcs:set Generic.Formatting.SpaceAfterCast spacing 1

vendor/squizlabs/php_codesniffer/src/Standards/Generic/Tests/Formatting/MultipleStatementAlignmentUnitTest.inc

Indentation +159 added lines, -159 removed lines

@@ -83,122 +83,122 @@ 
 
 class MyClass
 {
-    const MODE_DEBUG = 'debug';
-    const MODE_DEBUG2 = 'debug';
+	const MODE_DEBUG = 'debug';
+	const MODE_DEBUG2 = 'debug';
 
-    var $array[$test] = 'anything';
-    var $var          = 'anything';
+	var $array[$test] = 'anything';
+	var $var          = 'anything';
 
-    const MODE_DEBUG3  = 'debug';
-    public $array[$test]    = 'anything';
-    private $vara             = 'anything';
-    protected $array[($test + 1)] = 'anything';
-    var $array[($blah + (10 - $test))] = 'anything';
+	const MODE_DEBUG3  = 'debug';
+	public $array[$test]    = 'anything';
+	private $vara             = 'anything';
+	protected $array[($test + 1)] = 'anything';
+	var $array[($blah + (10 - $test))] = 'anything';
 }
 
 function myFunction($var=true)
 {
-    if ($strict === true) {
-        $length          = strlen($string);
-        $lastCharWasCaps = ($classFormat === false) ? false : true;
-
-        for ($i = 1; $i < $length; $i++) {
-            $isCaps = (strtoupper($string{$i}) === $string{$i}) ? true : false;
-            if ($isCaps === true && $lastCharWasCaps === true) {
-                return false;
-            }
-
-            $lastCharWasCaps = $isCaps;
-        }
-    }
+	if ($strict === true) {
+		$length          = strlen($string);
+		$lastCharWasCaps = ($classFormat === false) ? false : true;
+
+		for ($i = 1; $i < $length; $i++) {
+			$isCaps = (strtoupper($string{$i}) === $string{$i}) ? true : false;
+			if ($isCaps === true && $lastCharWasCaps === true) {
+				return false;
+			}
+
+			$lastCharWasCaps = $isCaps;
+		}
+	}
 }
 
 // Valid
 for ($i = 0; $i < 10; $i += 2) {
-    $i = ($i - 1);
+	$i = ($i - 1);
 }
 
 // Invalid
 foreach ($files as $file) {
-    $saves[$file] = array();
-    $contents = stripslashes(file_get_contents($file));
-    list($assetid, $time, $content) = explode("\n", $contents);
-    $saves[$file]['assetid'] = $assetid;
+	$saves[$file] = array();
+	$contents = stripslashes(file_get_contents($file));
+	list($assetid, $time, $content) = explode("\n", $contents);
+	$saves[$file]['assetid'] = $assetid;
 }
 
 $i = ($i - 10);
 $ip = ($i - 10);
 for ($i = 0; $i < 10; $i += 2) {
-    $i = ($i - 10);
+	$i = ($i - 10);
 }
 
 // Valid
 $variable = 12;
 $var      = a_very(long_line('that', 'contains'),
-                   a_bunch('of long', 'parameters'),
-                   'that_need to be aligned with the equal sign');
+				   a_bunch('of long', 'parameters'),
+				   'that_need to be aligned with the equal sign');
 $var2     = 12;
 
 // Valid
 $variable = 12;
 $var      = 'a very long line of text that contains '
-            .$someVar
-            .' and some other stuff that is too long to fit on one line';
+			.$someVar
+			.' and some other stuff that is too long to fit on one line';
 $var2     = 12;
 
 // Invalid
 $variable = 12;
 $var      = a_very(long_line('that', 'contains'),
-                   a_bunch('of long', 'parameters'),
-                   'that_need to be aligned with the equal sign');
+				   a_bunch('of long', 'parameters'),
+				   'that_need to be aligned with the equal sign');
 $var2 = 12;
 
 // Invalid
 $variable = 12;
 $var      = 'a very long line of text that contains '
-            .$someVar
-            .' and some other stuff that is too long to fit on one line';
+			.$someVar
+			.' and some other stuff that is too long to fit on one line';
 $var2 = 12;
 
 // Valid
 $variable = 12;
 $var     .= 'a very long line of text that contains '
-            .$someVar
-            .' and some other stuff that is too long to fit on one line';
+			.$someVar
+			.' and some other stuff that is too long to fit on one line';
 $var2     = 12;
 
 // Valid
 $variable += 12;
 $var      .= 'a very long line of text that contains '
-            .$someVar
-            .' and some other stuff that is too long to fit on one line';
+			.$someVar
+			.' and some other stuff that is too long to fit on one line';
 $var2      = 12;
 
 // Invalid
 $variable  = 12;
 $var      .= 'a very long line of text that contains '
-            .$someVar
-            .' and some other stuff that is too long to fit on one line';
+			.$someVar
+			.' and some other stuff that is too long to fit on one line';
 $var2      = 12;
 
 // Valid
 $error = false;
 while (list($h, $f) = getKeyAndValue($handle)) {
-    $error = true;
+	$error = true;
 }
 
 // Valid
 $value = false;
 function blah ($value = true) {
-    $value = false;
-    if ($value === true) {
-        $value = false;
-    }
+	$value = false;
+	if ($value === true) {
+		$value = false;
+	}
 }
 
 if (TRUE) {
-    $args = array('foo' => 'foo');
-    $res  = 'bar';
+	$args = array('foo' => 'foo');
+	$res  = 'bar';
 }
 
 // phpcs:set Generic.Formatting.MultipleStatementAlignment maxPadding 8
@@ -234,140 +234,140 @@ 
 $foo = $moooo = 'foo';
 
 $foobarbaz = array_map(
-    function ($n) {
-        return $n * $n;
-    },
-    [1, 2, 3]
+	function ($n) {
+		return $n * $n;
+	},
+	[1, 2, 3]
 );
 $foo       = 5;
 
 $loggerResult = $util->setLogger(new class {
-    public function log($msg)
-    {
-        echo $msg;
-    }
+	public function log($msg)
+	{
+		echo $msg;
+	}
 });
 $foo          = 5;
 
 $foo = array(
-    'a' => 'b',
+	'a' => 'b',
 );
 $barbar = 'bar';
 
 $foo = array(
-    // Some comment.
-    'a' => 'b',
+	// Some comment.
+	'a' => 'b',
 );
 $barbar = 'bar';
 
 $foo = [
-    // phpcs:ignore Standard.Category.Sniff.Code -- for reasons.
-    'a' => 'b',
+	// phpcs:ignore Standard.Category.Sniff.Code -- for reasons.
+	'a' => 'b',
 ];
 $barbar = 'bar';
 
 $foo = [
 
-    'a' => 'b',
+	'a' => 'b',
 ];
 $barbar = 'bar';
 
 function buildForm(FormBuilderInterface $builder, array $options)
 {
-    $transformer = new ContractTransformer($options['contracts']);
-    $types       = ['support.contact.question' => ContactData::QUESTION];
+	$transformer = new ContractTransformer($options['contracts']);
+	$types       = ['support.contact.question' => ContactData::QUESTION];
 
-    [$important, $questions, $incidents, $requests] = $this->createContractBuckets($options['contracts']);
+	[$important, $questions, $incidents, $requests] = $this->createContractBuckets($options['contracts']);
 }
 
 function buildForm(FormBuilderInterface $builder, array $options)
 {
-    $transformer                                    = new ContractTransformer($options['contracts']);
-    $types                                          = ['support.contact.question' => ContactData::QUESTION];
-    [$important, $questions, $incidents, $requests] = $this->createContractBuckets($options['contracts']);
+	$transformer                                    = new ContractTransformer($options['contracts']);
+	$types                                          = ['support.contact.question' => ContactData::QUESTION];
+	[$important, $questions, $incidents, $requests] = $this->createContractBuckets($options['contracts']);
 }
 
 $loggerResult = $util->setLogger(new class {
-    public function log($msg)
-    {
-        $a = $msg;
-        $foobar = $msg;
-        $foo = function() {
-            $a = $msg;
-            $foobar = $msg;
-            $loggerResult = $util->setLogger(new class {
-                public function log($msg)
-                {
-                    $a = $msg;
-                    $foobar = $msg;
-                    $foo = function() {
-                        foo(function() {
-                            foo(function() {
-                                echo 'hi';
-                            });
-                            $a = $msg;
-                            $foobar = $msg;
-
-                            $foo = function() {
-
-                                $foo = 1;
-                                $barbar=2;
-                            };
-                            $barbar = function() {
-                                $foo    = 1;
-                                $barbar = 2;
-                            };
-                        });
-                        $a = $msg;
-                        $foobar      = $msg;
-                    };
-                    $bar = $msg;
-                }
-
-                public function log2($msg)
-                {
-                    $a = $msg;
-                    $foobar = $msg;
-                    $foo = function() {
-                        foo(function() {
-                            foo(function() {
-                                echo 'hi';
-                            });
-                            $a = $msg;
-                            $foobar = $msg;
-
-                            $foo = function() {
-
-                                $foo = 1;
-                                $barbar=2;
-                            };
-                            $barbar = function() {
-                                $foo    = 1;
-                                $barbar = 2;
-                            };
-                        });
-                        $a = $msg;
-                        $foobar      = $msg;
-                    };
-                    $bar = $msg;
-                }
-            });
-            $foo          = 5;
-        };
-        $bar = $msg;
-    }
+	public function log($msg)
+	{
+		$a = $msg;
+		$foobar = $msg;
+		$foo = function() {
+			$a = $msg;
+			$foobar = $msg;
+			$loggerResult = $util->setLogger(new class {
+				public function log($msg)
+				{
+					$a = $msg;
+					$foobar = $msg;
+					$foo = function() {
+						foo(function() {
+							foo(function() {
+								echo 'hi';
+							});
+							$a = $msg;
+							$foobar = $msg;
+
+							$foo = function() {
+
+								$foo = 1;
+								$barbar=2;
+							};
+							$barbar = function() {
+								$foo    = 1;
+								$barbar = 2;
+							};
+						});
+						$a = $msg;
+						$foobar      = $msg;
+					};
+					$bar = $msg;
+				}
+
+				public function log2($msg)
+				{
+					$a = $msg;
+					$foobar = $msg;
+					$foo = function() {
+						foo(function() {
+							foo(function() {
+								echo 'hi';
+							});
+							$a = $msg;
+							$foobar = $msg;
+
+							$foo = function() {
+
+								$foo = 1;
+								$barbar=2;
+							};
+							$barbar = function() {
+								$foo    = 1;
+								$barbar = 2;
+							};
+						});
+						$a = $msg;
+						$foobar      = $msg;
+					};
+					$bar = $msg;
+				}
+			});
+			$foo          = 5;
+		};
+		$bar = $msg;
+	}
 });
 $foo          = 5;
 
 $foo = [
-    0 => function () {
-        $foo = 'foo';
-        $barbar = 'bar';
-    },
-    1 => function () {
-        $foo    = 'foo';
-        $barbar = 'bar';
-    },
+	0 => function () {
+		$foo = 'foo';
+		$barbar = 'bar';
+	},
+	1 => function () {
+		$foo    = 'foo';
+		$barbar = 'bar';
+	},
 ];
 
 $abc = 'something';
@@ -375,31 +375,31 @@ 
 $defghi = 'longer something';
 
 function foo() {
-    $foo = 'foo';
-    $bar = 'bar';
-    ?>
+	$foo = 'foo';
+	$bar = 'bar';
+	?>
 
     <div>
         <?php
-        $foo = 'foo';
-        $bar = 'bar';
-        ?>
+		$foo = 'foo';
+		$bar = 'bar';
+		?>
     </div>
     <?php
 }
 
 $foo = new Foo([
-    $a = new Bar(),
-    $b = new Bar(),
+	$a = new Bar(),
+	$b = new Bar(),
 ]);
 
 $foo = new Foo([
-    $a = new Bar(),
-    $b    = new Bar(),
-    $c  = new Bar(),
+	$a = new Bar(),
+	$b    = new Bar(),
+	$c  = new Bar(),
 ]);
 $foofoo   = new Foo([
-    $a = new Bar(),
-    $b = new Bar(),
-    $c = new Bar(),
+	$a = new Bar(),
+	$b = new Bar(),
+	$c = new Bar(),
 ]);

Spacing +86 added lines, -86 removed lines

@@ -34,7 +34,7 @@ 
 
 // Invalid
 $var1    .= 'var1';
-$var10.= 'var1';
+$var10 .= 'var1';
 $var100 .= 'var1';
 $var1000 .= 'var1';
 
@@ -46,9 +46,9 @@ 
 
 // Invalid
 $var1    = 'var1';
-$var10   .= 'var1';
+$var10 .= 'var1';
 $var100  = 'var1';
-$var1000.= 'var1';
+$var1000 .= 'var1';
 
 // Valid
 $var1  .= 'var1';
@@ -68,43 +68,43 @@ 
 $var = 100;
 
 // InValid
-$var  = 100;
+$var = 100;
 
 $commentStart = $phpcsFile->findPrevious();
 $commentEnd   = $this->_phpcsFile;
 $expected    .= '...';
 
 // Invalid
-$this->okButton    = new Button();
+$this->okButton = new Button();
 $content = new MyClass();
 
 
-$GLOBALS['_PEAR_ERRORSTACK_SINGLETON'] = array();
+$GLOBALS[ '_PEAR_ERRORSTACK_SINGLETON' ] = array();
 
 class MyClass
 {
     const MODE_DEBUG = 'debug';
     const MODE_DEBUG2 = 'debug';
 
-    var $array[$test] = 'anything';
+    var $array[ $test ] = 'anything';
     var $var          = 'anything';
 
-    const MODE_DEBUG3  = 'debug';
-    public $array[$test]    = 'anything';
-    private $vara             = 'anything';
-    protected $array[($test + 1)] = 'anything';
-    var $array[($blah + (10 - $test))] = 'anything';
+    const MODE_DEBUG3 = 'debug';
+    public $array[ $test ] = 'anything';
+    private $vara = 'anything';
+    protected $array[ ( $test + 1 ) ] = 'anything';
+    var $array[ ( $blah + ( 10 - $test ) ) ] = 'anything';
 }
 
-function myFunction($var=true)
+function myFunction( $var = true )
 {
-    if ($strict === true) {
-        $length          = strlen($string);
-        $lastCharWasCaps = ($classFormat === false) ? false : true;
+    if ( $strict === true ) {
+        $length          = strlen( $string );
+        $lastCharWasCaps = ( $classFormat === false ) ? false : true;
 
-        for ($i = 1; $i < $length; $i++) {
-            $isCaps = (strtoupper($string{$i}) === $string{$i}) ? true : false;
-            if ($isCaps === true && $lastCharWasCaps === true) {
+        for ( $i = 1; $i < $length; $i++ ) {
+            $isCaps = ( strtoupper( $string{$i}) === $string{$i}) ? true : false;
+            if ( $isCaps === true && $lastCharWasCaps === true ) {
                 return false;
             }
 
@@ -114,29 +114,29 @@ 
 }
 
 // Valid
-for ($i = 0; $i < 10; $i += 2) {
-    $i = ($i - 1);
+for ( $i = 0; $i < 10; $i += 2 ) {
+    $i = ( $i - 1 );
 }
 
 // Invalid
-foreach ($files as $file) {
-    $saves[$file] = array();
-    $contents = stripslashes(file_get_contents($file));
-    list($assetid, $time, $content) = explode("\n", $contents);
-    $saves[$file]['assetid'] = $assetid;
+foreach ( $files as $file ) {
+    $saves[ $file ] = array();
+    $contents = stripslashes( file_get_contents( $file ) );
+    list( $assetid, $time, $content ) = explode( "\n", $contents );
+    $saves[ $file ][ 'assetid' ] = $assetid;
 }
 
-$i = ($i - 10);
-$ip = ($i - 10);
-for ($i = 0; $i < 10; $i += 2) {
-    $i = ($i - 10);
+$i = ( $i - 10 );
+$ip = ( $i - 10 );
+for ( $i = 0; $i < 10; $i += 2 ) {
+    $i = ( $i - 10 );
 }
 
 // Valid
 $variable = 12;
-$var      = a_very(long_line('that', 'contains'),
-                   a_bunch('of long', 'parameters'),
-                   'that_need to be aligned with the equal sign');
+$var      = a_very( long_line( 'that', 'contains' ),
+                   a_bunch( 'of long', 'parameters' ),
+                   'that_need to be aligned with the equal sign' );
 $var2     = 12;
 
 // Valid
@@ -148,9 +148,9 @@ 
 
 // Invalid
 $variable = 12;
-$var      = a_very(long_line('that', 'contains'),
-                   a_bunch('of long', 'parameters'),
-                   'that_need to be aligned with the equal sign');
+$var      = a_very( long_line( 'that', 'contains' ),
+                   a_bunch( 'of long', 'parameters' ),
+                   'that_need to be aligned with the equal sign' );
 $var2 = 12;
 
 // Invalid
@@ -183,21 +183,21 @@ 
 
 // Valid
 $error = false;
-while (list($h, $f) = getKeyAndValue($handle)) {
+while ( list( $h, $f ) = getKeyAndValue( $handle ) ) {
     $error = true;
 }
 
 // Valid
 $value = false;
-function blah ($value = true) {
+function blah( $value = true ) {
     $value = false;
-    if ($value === true) {
+    if ( $value === true ) {
         $value = false;
     }
 }
 
-if (TRUE) {
-    $args = array('foo' => 'foo');
+if ( TRUE ) {
+    $args = array( 'foo' => 'foo' );
     $res  = 'bar';
 }
 
@@ -217,13 +217,13 @@ 
 
 // phpcs:set Generic.Formatting.MultipleStatementAlignment maxPadding 1000
 
-$filterQuery = SquizRoadmap::getSearchQueryFilter($searchParams);
-Channels::addToBasket('itemid', $filterQuery);
-$query   = DAL::getDALQuery('SquizRoadmapItem', 'getItemIds');
-$results = DAL::getAssoc($query, 0);
+$filterQuery = SquizRoadmap::getSearchQueryFilter( $searchParams );
+Channels::addToBasket( 'itemid', $filterQuery );
+$query   = DAL::getDALQuery( 'SquizRoadmapItem', 'getItemIds' );
+$results = DAL::getAssoc( $query, 0 );
 
-$path  = BaseSystem::getDataDir('SquizRoadmap').'/items/';
-$path .= FileSystem::getHashDir($itemid).'/'.$itemid;
+$path  = BaseSystem::getDataDir( 'SquizRoadmap' ) . '/items/';
+$path .= FileSystem::getHashDir( $itemid ) . '/' . $itemid;
 
 $contents  .= 'if (';
 $conditions = array();
@@ -234,20 +234,20 @@ 
 $foo = $moooo = 'foo';
 
 $foobarbaz = array_map(
-    function ($n) {
+    function( $n ) {
         return $n * $n;
     },
-    [1, 2, 3]
+    [ 1, 2, 3 ]
 );
-$foo       = 5;
+$foo = 5;
 
-$loggerResult = $util->setLogger(new class {
-    public function log($msg)
+$loggerResult = $util->setLogger( new class {
+    public function log( $msg )
     {
         echo $msg;
     }
 });
-$foo          = 5;
+$foo = 5;
 
 $foo = array(
     'a' => 'b',
@@ -272,37 +272,37 @@ 
 ];
 $barbar = 'bar';
 
-function buildForm(FormBuilderInterface $builder, array $options)
+function buildForm( FormBuilderInterface $builder, array $options )
 {
-    $transformer = new ContractTransformer($options['contracts']);
-    $types       = ['support.contact.question' => ContactData::QUESTION];
+    $transformer = new ContractTransformer( $options[ 'contracts' ] );
+    $types       = [ 'support.contact.question' => ContactData::QUESTION ];
 
-    [$important, $questions, $incidents, $requests] = $this->createContractBuckets($options['contracts']);
+    [ $important, $questions, $incidents, $requests ] = $this->createContractBuckets( $options[ 'contracts' ] );
 }
 
-function buildForm(FormBuilderInterface $builder, array $options)
+function buildForm( FormBuilderInterface $builder, array $options )
 {
-    $transformer                                    = new ContractTransformer($options['contracts']);
-    $types                                          = ['support.contact.question' => ContactData::QUESTION];
-    [$important, $questions, $incidents, $requests] = $this->createContractBuckets($options['contracts']);
+    $transformer                                    = new ContractTransformer( $options[ 'contracts' ] );
+    $types                                          = [ 'support.contact.question' => ContactData::QUESTION ];
+    [ $important, $questions, $incidents, $requests ] = $this->createContractBuckets( $options[ 'contracts' ] );
 }
 
-$loggerResult = $util->setLogger(new class {
-    public function log($msg)
+$loggerResult = $util->setLogger( new class {
+    public function log( $msg )
     {
         $a = $msg;
         $foobar = $msg;
         $foo = function() {
             $a = $msg;
             $foobar = $msg;
-            $loggerResult = $util->setLogger(new class {
-                public function log($msg)
+            $loggerResult = $util->setLogger( new class {
+                public function log( $msg )
                 {
                     $a = $msg;
                     $foobar = $msg;
                     $foo = function() {
-                        foo(function() {
-                            foo(function() {
+                        foo( function() {
+                            foo( function() {
                                 echo 'hi';
                             });
                             $a = $msg;
@@ -311,7 +311,7 @@ 
                             $foo = function() {
 
                                 $foo = 1;
-                                $barbar=2;
+                                $barbar = 2;
                             };
                             $barbar = function() {
                                 $foo    = 1;
@@ -319,18 +319,18 @@ 
                             };
                         });
                         $a = $msg;
-                        $foobar      = $msg;
+                        $foobar = $msg;
                     };
                     $bar = $msg;
                 }
 
-                public function log2($msg)
+                public function log2( $msg )
                 {
                     $a = $msg;
                     $foobar = $msg;
                     $foo = function() {
-                        foo(function() {
-                            foo(function() {
+                        foo( function() {
+                            foo( function() {
                                 echo 'hi';
                             });
                             $a = $msg;
@@ -339,7 +339,7 @@ 
                             $foo = function() {
 
                                 $foo = 1;
-                                $barbar=2;
+                                $barbar = 2;
                             };
                             $barbar = function() {
                                 $foo    = 1;
@@ -347,31 +347,31 @@ 
                             };
                         });
                         $a = $msg;
-                        $foobar      = $msg;
+                        $foobar = $msg;
                     };
                     $bar = $msg;
                 }
             });
-            $foo          = 5;
+            $foo = 5;
         };
         $bar = $msg;
     }
 });
-$foo          = 5;
+$foo = 5;
 
 $foo = [
-    0 => function () {
+    0 => function() {
         $foo = 'foo';
         $barbar = 'bar';
     },
-    1 => function () {
+    1 => function() {
         $foo    = 'foo';
         $barbar = 'bar';
     },
 ];
 
 $abc = 'something';
-if ($foo) {}
+if ( $foo ) {}
 $defghi = 'longer something';
 
 function foo() {
@@ -388,18 +388,18 @@ 
     <?php
 }
 
-$foo = new Foo([
+$foo = new Foo( [
     $a = new Bar(),
     $b = new Bar(),
-]);
+] );
 
-$foo = new Foo([
+$foo = new Foo( [
     $a = new Bar(),
     $b    = new Bar(),
-    $c  = new Bar(),
-]);
-$foofoo   = new Foo([
+    $c = new Bar(),
+] );
+$foofoo   = new Foo( [
     $a = new Bar(),
     $b = new Bar(),
     $c = new Bar(),
-]);
+] );

Braces +8 added lines, -16 removed lines

@@ -81,8 +81,7 @@ 
 
 $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'] = array();
 
-class MyClass
-{
+class MyClass {
     const MODE_DEBUG = 'debug';
     const MODE_DEBUG2 = 'debug';
 
@@ -96,8 +95,7 @@ 
     var $array[($blah + (10 - $test))] = 'anything';
 }
 
-function myFunction($var=true)
-{
+function myFunction($var=true) {
     if ($strict === true) {
         $length          = strlen($string);
         $lastCharWasCaps = ($classFormat === false) ? false : true;
@@ -242,8 +240,7 @@ 
 $foo       = 5;
 
 $loggerResult = $util->setLogger(new class {
-    public function log($msg)
-    {
+    public function log($msg) {
         echo $msg;
     }
 });
@@ -272,32 +269,28 @@ 
 ];
 $barbar = 'bar';
 
-function buildForm(FormBuilderInterface $builder, array $options)
-{
+function buildForm(FormBuilderInterface $builder, array $options) {
     $transformer = new ContractTransformer($options['contracts']);
     $types       = ['support.contact.question' => ContactData::QUESTION];
 
     [$important, $questions, $incidents, $requests] = $this->createContractBuckets($options['contracts']);
 }
 
-function buildForm(FormBuilderInterface $builder, array $options)
-{
+function buildForm(FormBuilderInterface $builder, array $options) {
     $transformer                                    = new ContractTransformer($options['contracts']);
     $types                                          = ['support.contact.question' => ContactData::QUESTION];
     [$important, $questions, $incidents, $requests] = $this->createContractBuckets($options['contracts']);
 }
 
 $loggerResult = $util->setLogger(new class {
-    public function log($msg)
-    {
+    public function log($msg) {
         $a = $msg;
         $foobar = $msg;
         $foo = function() {
             $a = $msg;
             $foobar = $msg;
             $loggerResult = $util->setLogger(new class {
-                public function log($msg)
-                {
+                public function log($msg) {
                     $a = $msg;
                     $foobar = $msg;
                     $foo = function() {
@@ -324,8 +317,7 @@ 
                     $bar = $msg;
                 }
 
-                public function log2($msg)
-                {
+                public function log2($msg) {
                     $a = $msg;
                     $foobar = $msg;
                     $foo = function() {

vendor/squizlabs/php_codesniffer/src/Standards/Generic/Tests/Formatting/NoSpaceAfterCastUnitTest.php

Indentation +48 added lines, -48 removed lines

@@ -15,58 +15,58 @@
 {
 
 
-    /**
-     * Returns the lines where errors should occur.
-     *
-     * The key of the array should represent the line number and the value
-     * should represent the number of errors that should occur on that line.
-     *
-     * @return array<int, int>
-     */
-    public function getErrorList()
-    {
-        return [
-            3  => 1,
-            5  => 1,
-            7  => 1,
-            9  => 1,
-            11 => 1,
-            13 => 1,
-            15 => 1,
-            17 => 1,
-            19 => 1,
-            21 => 1,
-            23 => 1,
-            25 => 1,
-            27 => 1,
-            29 => 1,
-            31 => 1,
-            33 => 1,
-            35 => 1,
-            37 => 1,
-            39 => 1,
-            41 => 1,
-            43 => 1,
-            45 => 1,
-            50 => 1,
-        ];
+	/**
+	 * Returns the lines where errors should occur.
+	 *
+	 * The key of the array should represent the line number and the value
+	 * should represent the number of errors that should occur on that line.
+	 *
+	 * @return array<int, int>
+	 */
+	public function getErrorList()
+	{
+		return [
+			3  => 1,
+			5  => 1,
+			7  => 1,
+			9  => 1,
+			11 => 1,
+			13 => 1,
+			15 => 1,
+			17 => 1,
+			19 => 1,
+			21 => 1,
+			23 => 1,
+			25 => 1,
+			27 => 1,
+			29 => 1,
+			31 => 1,
+			33 => 1,
+			35 => 1,
+			37 => 1,
+			39 => 1,
+			41 => 1,
+			43 => 1,
+			45 => 1,
+			50 => 1,
+		];
 
-    }//end getErrorList()
+	}//end getErrorList()
 
 
-    /**
-     * Returns the lines where warnings should occur.
-     *
-     * The key of the array should represent the line number and the value
-     * should represent the number of warnings that should occur on that line.
-     *
-     * @return array<int, int>
-     */
-    public function getWarningList()
-    {
-        return [];
+	/**
+	 * Returns the lines where warnings should occur.
+	 *
+	 * The key of the array should represent the line number and the value
+	 * should represent the number of warnings that should occur on that line.
+	 *
+	 * @return array<int, int>
+	 */
+	public function getWarningList()
+	{
+		return [];
 
-    }//end getWarningList()
+	}//end getWarningList()
 
 
 }//end class

Spacing +1 added lines, -1 removed lines

@@ -64,7 +64,7 @@
      */
     public function getWarningList()
     {
-        return [];
+        return [ ];
 
     }//end getWarningList()
 

Braces +3 added lines, -6 removed lines

@@ -11,8 +11,7 @@ 
 
 use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest;
 
-class NoSpaceAfterCastUnitTest extends AbstractSniffUnitTest
-{
+class NoSpaceAfterCastUnitTest extends AbstractSniffUnitTest {
 
 
     /**
@@ -23,8 +22,7 @@ 
      *
      * @return array<int, int>
      */
-    public function getErrorList()
-    {
+    public function getErrorList() {
         return [
             3  => 1,
             5  => 1,
@@ -62,8 +60,7 @@ 
      *
      * @return array<int, int>
      */
-    public function getWarningList()
-    {
+    public function getWarningList() {
         return [];
 
     }//end getWarningList()

vendor/squizlabs/php_codesniffer/src/Standards/Generic/Tests/Formatting/SpaceBeforeCastUnitTest.inc

Indentation +1 added lines, -1 removed lines

@@ -58,7 +58,7 @@
 $var = array(
 	(bool) $a,
 	array(
-        (int) $b,
+		(int) $b,
 	),
 );
 

Spacing +44 added lines, -44 removed lines

@@ -1,65 +1,65 @@
 <?php
 
-$a = $a+(bool) $b;
-$a = function_call((bool) $b);
-if ((bool) $a ===(bool) $b) {}
+$a = $a + (bool)$b;
+$a = function_call( (bool)$b );
+if ( (bool)$a === (bool)$b ) {}
 
-$var = (int) $var2;
-$var =(int) $var2;
-$var =     (int) $var2;
+$var = (int)$var2;
+$var = (int)$var2;
+$var = (int)$var2;
 
-$var = (integer) $var2;
-$var =(integer) $var2;
-$var =    (integer) $var2;
+$var = (integer)$var2;
+$var = (integer)$var2;
+$var = (integer)$var2;
 
-$var = (string) $var2;
-$var =(string) $var2;
-$var =	 (string) $var2;
+$var = (string)$var2;
+$var = (string)$var2;
+$var = (string)$var2;
 
-$var = (float) $var2;
-$var =(float) $var2;
-$var =			 (float) $var2;
+$var = (float)$var2;
+$var = (float)$var2;
+$var = (float)$var2;
 
-$var = (double) $var2;
-$var =(double) $var2;
-$var =  (double) $var2;
+$var = (double)$var2;
+$var = (double)$var2;
+$var = (double)$var2;
 
-$var = (real) $var2;
-$var =(real) $var2;
-$var =    (real) $var2;
+$var = (real)$var2;
+$var = (real)$var2;
+$var = (real)$var2;
 
-$var = (array) $var2;
-$var =(array) $var2;
-$var =   (array) $var2;
+$var = (array)$var2;
+$var = (array)$var2;
+$var = (array)$var2;
 
-$var = (bool) $var2;
-$var =(bool) $var2;
-$var =    (bool) $var2;
+$var = (bool)$var2;
+$var = (bool)$var2;
+$var = (bool)$var2;
 
-$var = (boolean) $var2;
-$var =(boolean) $var2;
-$var =  (boolean) $var2;
+$var = (boolean)$var2;
+$var = (boolean)$var2;
+$var = (boolean)$var2;
 
-$var = (object) $var2;
-$var =(object) $var2;
-$var =  (object) $var2;
+$var = (object)$var2;
+$var = (object)$var2;
+$var = (object)$var2;
 
-$var = (unset) $var2;
-$var =(unset) $var2;
-$var =   (unset) $var2;
+$var = (unset)$var2;
+$var = (unset)$var2;
+$var = (unset)$var2;
 
 $var = b"binary $foo";
-$var =b"binary string";
-$var =   b'binary string';
-$var = (binary) $string;
-$var =(binary) $string;
-$var =    (binary) $string;
+$var = b"binary string";
+$var = b'binary string';
+$var = (binary)$string;
+$var = (binary)$string;
+$var = (binary)$string;
 
 $var = array(
-	(bool) $a,
+	(bool)$a,
 	array(
-        (int) $b,
+        (int)$b,
 	),
 );
 
-(bool) $a ? echo $b : echo $c;
+(bool)$a ? echo $b : echo $c;

vendor/squizlabs/php_codesniffer/src/Standards/Generic/Tests/Formatting/DisallowMultipleStatementsUnitTest.php

Indentation +34 added lines, -34 removed lines

@@ -15,40 +15,40 @@
 {
 
 
-    /**
-     * Returns the lines where errors should occur.
-     *
-     * The key of the array should represent the line number and the value
-     * should represent the number of errors that should occur on that line.
-     *
-     * @return array<int, int>
-     */
-    public function getErrorList()
-    {
-        return [
-            2  => 1,
-            6  => 1,
-            7  => 1,
-            8  => 2,
-            16 => 2,
-        ];
-
-    }//end getErrorList()
-
-
-    /**
-     * Returns the lines where warnings should occur.
-     *
-     * The key of the array should represent the line number and the value
-     * should represent the number of warnings that should occur on that line.
-     *
-     * @return array<int, int>
-     */
-    public function getWarningList()
-    {
-        return [];
-
-    }//end getWarningList()
+	/**
+	 * Returns the lines where errors should occur.
+	 *
+	 * The key of the array should represent the line number and the value
+	 * should represent the number of errors that should occur on that line.
+	 *
+	 * @return array<int, int>
+	 */
+	public function getErrorList()
+	{
+		return [
+			2  => 1,
+			6  => 1,
+			7  => 1,
+			8  => 2,
+			16 => 2,
+		];
+
+	}//end getErrorList()
+
+
+	/**
+	 * Returns the lines where warnings should occur.
+	 *
+	 * The key of the array should represent the line number and the value
+	 * should represent the number of warnings that should occur on that line.
+	 *
+	 * @return array<int, int>
+	 */
+	public function getWarningList()
+	{
+		return [];
+
+	}//end getWarningList()
 
 
 }//end class

Braces +3 added lines, -6 removed lines

@@ -11,8 +11,7 @@ 
 
 use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest;
 
-class DisallowMultipleStatementsUnitTest extends AbstractSniffUnitTest
-{
+class DisallowMultipleStatementsUnitTest extends AbstractSniffUnitTest {
 
 
     /**
@@ -23,8 +22,7 @@ 
      *
      * @return array<int, int>
      */
-    public function getErrorList()
-    {
+    public function getErrorList() {
         return [
             2  => 1,
             6  => 1,
@@ -44,8 +42,7 @@ 
      *
      * @return array<int, int>
      */
-    public function getWarningList()
-    {
+    public function getWarningList() {
         return [];
 
     }//end getWarningList()

Spacing +1 added lines, -1 removed lines

@@ -64,7 +64,7 @@
      */
     public function getWarningList()
     {
-        return [];
+        return [ ];
 
     }//end getWarningList()