eventespresso / event-espresso-core

vendor/squizlabs/php_codesniffer/src/Tokenizers/Comment.php

Indentation +238 added lines, -238 removed lines

@@ -15,263 +15,263 @@
 {
 
 
-    /**
-     * Creates an array of tokens when given some PHP code.
-     *
-     * Starts by using token_get_all() but does a lot of extra processing
-     * to insert information about the context of the token.
-     *
-     * @param string $string   The string to tokenize.
-     * @param string $eolChar  The EOL character to use for splitting strings.
-     * @param int    $stackPtr The position of the first token in the file.
-     *
-     * @return array
-     */
-    public function tokenizeString($string, $eolChar, $stackPtr)
-    {
-        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-            echo "\t\t*** START COMMENT TOKENIZING ***".PHP_EOL;
-        }
-
-        $tokens   = [];
-        $numChars = strlen($string);
-
-        /*
+	/**
+	 * Creates an array of tokens when given some PHP code.
+	 *
+	 * Starts by using token_get_all() but does a lot of extra processing
+	 * to insert information about the context of the token.
+	 *
+	 * @param string $string   The string to tokenize.
+	 * @param string $eolChar  The EOL character to use for splitting strings.
+	 * @param int    $stackPtr The position of the first token in the file.
+	 *
+	 * @return array
+	 */
+	public function tokenizeString($string, $eolChar, $stackPtr)
+	{
+		if (PHP_CODESNIFFER_VERBOSITY > 1) {
+			echo "\t\t*** START COMMENT TOKENIZING ***".PHP_EOL;
+		}
+
+		$tokens   = [];
+		$numChars = strlen($string);
+
+		/*
             Doc block comments start with /*, but typically contain an
             extra star when they are used for function and class comments.
         */
 
-        $char    = ($numChars - strlen(ltrim($string, '/*')));
-        $openTag = substr($string, 0, $char);
-        $string  = ltrim($string, '/*');
+		$char    = ($numChars - strlen(ltrim($string, '/*')));
+		$openTag = substr($string, 0, $char);
+		$string  = ltrim($string, '/*');
 
-        $tokens[$stackPtr] = [
-            'content'      => $openTag,
-            'code'         => T_DOC_COMMENT_OPEN_TAG,
-            'type'         => 'T_DOC_COMMENT_OPEN_TAG',
-            'comment_tags' => [],
-        ];
+		$tokens[$stackPtr] = [
+			'content'      => $openTag,
+			'code'         => T_DOC_COMMENT_OPEN_TAG,
+			'type'         => 'T_DOC_COMMENT_OPEN_TAG',
+			'comment_tags' => [],
+		];
 
-        $openPtr = $stackPtr;
-        $stackPtr++;
+		$openPtr = $stackPtr;
+		$stackPtr++;
 
-        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-            $content = Util\Common::prepareForOutput($openTag);
-            echo "\t\tCreate comment token: T_DOC_COMMENT_OPEN_TAG => $content".PHP_EOL;
-        }
+		if (PHP_CODESNIFFER_VERBOSITY > 1) {
+			$content = Util\Common::prepareForOutput($openTag);
+			echo "\t\tCreate comment token: T_DOC_COMMENT_OPEN_TAG => $content".PHP_EOL;
+		}
 
-        /*
+		/*
             Strip off the close tag so it doesn't interfere with any
             of our comment line processing. The token will be added to the
             stack just before we return it.
         */
 
-        $closeTag = [
-            'content'        => substr($string, strlen(rtrim($string, '/*'))),
-            'code'           => T_DOC_COMMENT_CLOSE_TAG,
-            'type'           => 'T_DOC_COMMENT_CLOSE_TAG',
-            'comment_opener' => $openPtr,
-        ];
+		$closeTag = [
+			'content'        => substr($string, strlen(rtrim($string, '/*'))),
+			'code'           => T_DOC_COMMENT_CLOSE_TAG,
+			'type'           => 'T_DOC_COMMENT_CLOSE_TAG',
+			'comment_opener' => $openPtr,
+		];
 
-        if ($closeTag['content'] === false) {
-            $closeTag['content'] = '';
-        }
+		if ($closeTag['content'] === false) {
+			$closeTag['content'] = '';
+		}
 
-        $string = rtrim($string, '/*');
+		$string = rtrim($string, '/*');
 
-        /*
+		/*
             Process each line of the comment.
         */
 
-        $lines    = explode($eolChar, $string);
-        $numLines = count($lines);
-        foreach ($lines as $lineNum => $string) {
-            if ($lineNum !== ($numLines - 1)) {
-                $string .= $eolChar;
-            }
-
-            $char     = 0;
-            $numChars = strlen($string);
-
-            // We've started a new line, so process the indent.
-            $space = $this->collectWhitespace($string, $char, $numChars);
-            if ($space !== null) {
-                $tokens[$stackPtr] = $space;
-                $stackPtr++;
-                if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                    $content = Util\Common::prepareForOutput($space['content']);
-                    echo "\t\tCreate comment token: T_DOC_COMMENT_WHITESPACE => $content".PHP_EOL;
-                }
-
-                $char += strlen($space['content']);
-                if ($char === $numChars) {
-                    break;
-                }
-            }
-
-            if ($string === '') {
-                continue;
-            }
-
-            if ($lineNum > 0 && $string[$char] === '*') {
-                // This is a function or class doc block line.
-                $char++;
-                $tokens[$stackPtr] = [
-                    'content' => '*',
-                    'code'    => T_DOC_COMMENT_STAR,
-                    'type'    => 'T_DOC_COMMENT_STAR',
-                ];
-
-                $stackPtr++;
-
-                if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                    echo "\t\tCreate comment token: T_DOC_COMMENT_STAR => *".PHP_EOL;
-                }
-            }
-
-            // Now we are ready to process the actual content of the line.
-            $lineTokens = $this->processLine($string, $eolChar, $char, $numChars);
-            foreach ($lineTokens as $lineToken) {
-                $tokens[$stackPtr] = $lineToken;
-                if (PHP_CODESNIFFER_VERBOSITY > 1) {
-                    $content = Util\Common::prepareForOutput($lineToken['content']);
-                    $type    = $lineToken['type'];
-                    echo "\t\tCreate comment token: $type => $content".PHP_EOL;
-                }
-
-                if ($lineToken['code'] === T_DOC_COMMENT_TAG) {
-                    $tokens[$openPtr]['comment_tags'][] = $stackPtr;
-                }
-
-                $stackPtr++;
-            }
-        }//end foreach
-
-        $tokens[$stackPtr] = $closeTag;
-        $tokens[$openPtr]['comment_closer'] = $stackPtr;
-        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-            $content = Util\Common::prepareForOutput($closeTag['content']);
-            echo "\t\tCreate comment token: T_DOC_COMMENT_CLOSE_TAG => $content".PHP_EOL;
-        }
-
-        if (PHP_CODESNIFFER_VERBOSITY > 1) {
-            echo "\t\t*** END COMMENT TOKENIZING ***".PHP_EOL;
-        }
-
-        return $tokens;
-
-    }//end tokenizeString()
-
-
-    /**
-     * Process a single line of a comment.
-     *
-     * @param string $string  The comment string being tokenized.
-     * @param string $eolChar The EOL character to use for splitting strings.
-     * @param int    $start   The position in the string to start processing.
-     * @param int    $end     The position in the string to end processing.
-     *
-     * @return array
-     */
-    private function processLine($string, $eolChar, $start, $end)
-    {
-        $tokens = [];
-
-        // Collect content padding.
-        $space = $this->collectWhitespace($string, $start, $end);
-        if ($space !== null) {
-            $tokens[] = $space;
-            $start   += strlen($space['content']);
-        }
-
-        if (isset($string[$start]) === false) {
-            return $tokens;
-        }
-
-        if ($string[$start] === '@') {
-            // The content up until the first whitespace is the tag name.
-            $matches = [];
-            preg_match('/@[^\s]+/', $string, $matches, 0, $start);
-            if (isset($matches[0]) === true
-                && substr(strtolower($matches[0]), 0, 7) !== '@phpcs:'
-            ) {
-                $tagName  = $matches[0];
-                $start   += strlen($tagName);
-                $tokens[] = [
-                    'content' => $tagName,
-                    'code'    => T_DOC_COMMENT_TAG,
-                    'type'    => 'T_DOC_COMMENT_TAG',
-                ];
-
-                // Then there will be some whitespace.
-                $space = $this->collectWhitespace($string, $start, $end);
-                if ($space !== null) {
-                    $tokens[] = $space;
-                    $start   += strlen($space['content']);
-                }
-            }
-        }//end if
-
-        // Process the rest of the line.
-        $eol = strpos($string, $eolChar, $start);
-        if ($eol === false) {
-            $eol = $end;
-        }
-
-        if ($eol > $start) {
-            $tokens[] = [
-                'content' => substr($string, $start, ($eol - $start)),
-                'code'    => T_DOC_COMMENT_STRING,
-                'type'    => 'T_DOC_COMMENT_STRING',
-            ];
-        }
-
-        if ($eol !== $end) {
-            $tokens[] = [
-                'content' => substr($string, $eol, strlen($eolChar)),
-                'code'    => T_DOC_COMMENT_WHITESPACE,
-                'type'    => 'T_DOC_COMMENT_WHITESPACE',
-            ];
-        }
-
-        return $tokens;
-
-    }//end processLine()
-
-
-    /**
-     * Collect consecutive whitespace into a single token.
-     *
-     * @param string $string The comment string being tokenized.
-     * @param int    $start  The position in the string to start processing.
-     * @param int    $end    The position in the string to end processing.
-     *
-     * @return array|null
-     */
-    private function collectWhitespace($string, $start, $end)
-    {
-        $space = '';
-        for ($start; $start < $end; $start++) {
-            if ($string[$start] !== ' ' && $string[$start] !== "\t") {
-                break;
-            }
-
-            $space .= $string[$start];
-        }
-
-        if ($space === '') {
-            return null;
-        }
-
-        $token = [
-            'content' => $space,
-            'code'    => T_DOC_COMMENT_WHITESPACE,
-            'type'    => 'T_DOC_COMMENT_WHITESPACE',
-        ];
-
-        return $token;
-
-    }//end collectWhitespace()
+		$lines    = explode($eolChar, $string);
+		$numLines = count($lines);
+		foreach ($lines as $lineNum => $string) {
+			if ($lineNum !== ($numLines - 1)) {
+				$string .= $eolChar;
+			}
+
+			$char     = 0;
+			$numChars = strlen($string);
+
+			// We've started a new line, so process the indent.
+			$space = $this->collectWhitespace($string, $char, $numChars);
+			if ($space !== null) {
+				$tokens[$stackPtr] = $space;
+				$stackPtr++;
+				if (PHP_CODESNIFFER_VERBOSITY > 1) {
+					$content = Util\Common::prepareForOutput($space['content']);
+					echo "\t\tCreate comment token: T_DOC_COMMENT_WHITESPACE => $content".PHP_EOL;
+				}
+
+				$char += strlen($space['content']);
+				if ($char === $numChars) {
+					break;
+				}
+			}
+
+			if ($string === '') {
+				continue;
+			}
+
+			if ($lineNum > 0 && $string[$char] === '*') {
+				// This is a function or class doc block line.
+				$char++;
+				$tokens[$stackPtr] = [
+					'content' => '*',
+					'code'    => T_DOC_COMMENT_STAR,
+					'type'    => 'T_DOC_COMMENT_STAR',
+				];
+
+				$stackPtr++;
+
+				if (PHP_CODESNIFFER_VERBOSITY > 1) {
+					echo "\t\tCreate comment token: T_DOC_COMMENT_STAR => *".PHP_EOL;
+				}
+			}
+
+			// Now we are ready to process the actual content of the line.
+			$lineTokens = $this->processLine($string, $eolChar, $char, $numChars);
+			foreach ($lineTokens as $lineToken) {
+				$tokens[$stackPtr] = $lineToken;
+				if (PHP_CODESNIFFER_VERBOSITY > 1) {
+					$content = Util\Common::prepareForOutput($lineToken['content']);
+					$type    = $lineToken['type'];
+					echo "\t\tCreate comment token: $type => $content".PHP_EOL;
+				}
+
+				if ($lineToken['code'] === T_DOC_COMMENT_TAG) {
+					$tokens[$openPtr]['comment_tags'][] = $stackPtr;
+				}
+
+				$stackPtr++;
+			}
+		}//end foreach
+
+		$tokens[$stackPtr] = $closeTag;
+		$tokens[$openPtr]['comment_closer'] = $stackPtr;
+		if (PHP_CODESNIFFER_VERBOSITY > 1) {
+			$content = Util\Common::prepareForOutput($closeTag['content']);
+			echo "\t\tCreate comment token: T_DOC_COMMENT_CLOSE_TAG => $content".PHP_EOL;
+		}
+
+		if (PHP_CODESNIFFER_VERBOSITY > 1) {
+			echo "\t\t*** END COMMENT TOKENIZING ***".PHP_EOL;
+		}
+
+		return $tokens;
+
+	}//end tokenizeString()
+
+
+	/**
+	 * Process a single line of a comment.
+	 *
+	 * @param string $string  The comment string being tokenized.
+	 * @param string $eolChar The EOL character to use for splitting strings.
+	 * @param int    $start   The position in the string to start processing.
+	 * @param int    $end     The position in the string to end processing.
+	 *
+	 * @return array
+	 */
+	private function processLine($string, $eolChar, $start, $end)
+	{
+		$tokens = [];
+
+		// Collect content padding.
+		$space = $this->collectWhitespace($string, $start, $end);
+		if ($space !== null) {
+			$tokens[] = $space;
+			$start   += strlen($space['content']);
+		}
+
+		if (isset($string[$start]) === false) {
+			return $tokens;
+		}
+
+		if ($string[$start] === '@') {
+			// The content up until the first whitespace is the tag name.
+			$matches = [];
+			preg_match('/@[^\s]+/', $string, $matches, 0, $start);
+			if (isset($matches[0]) === true
+				&& substr(strtolower($matches[0]), 0, 7) !== '@phpcs:'
+			) {
+				$tagName  = $matches[0];
+				$start   += strlen($tagName);
+				$tokens[] = [
+					'content' => $tagName,
+					'code'    => T_DOC_COMMENT_TAG,
+					'type'    => 'T_DOC_COMMENT_TAG',
+				];
+
+				// Then there will be some whitespace.
+				$space = $this->collectWhitespace($string, $start, $end);
+				if ($space !== null) {
+					$tokens[] = $space;
+					$start   += strlen($space['content']);
+				}
+			}
+		}//end if
+
+		// Process the rest of the line.
+		$eol = strpos($string, $eolChar, $start);
+		if ($eol === false) {
+			$eol = $end;
+		}
+
+		if ($eol > $start) {
+			$tokens[] = [
+				'content' => substr($string, $start, ($eol - $start)),
+				'code'    => T_DOC_COMMENT_STRING,
+				'type'    => 'T_DOC_COMMENT_STRING',
+			];
+		}
+
+		if ($eol !== $end) {
+			$tokens[] = [
+				'content' => substr($string, $eol, strlen($eolChar)),
+				'code'    => T_DOC_COMMENT_WHITESPACE,
+				'type'    => 'T_DOC_COMMENT_WHITESPACE',
+			];
+		}
+
+		return $tokens;
+
+	}//end processLine()
+
+
+	/**
+	 * Collect consecutive whitespace into a single token.
+	 *
+	 * @param string $string The comment string being tokenized.
+	 * @param int    $start  The position in the string to start processing.
+	 * @param int    $end    The position in the string to end processing.
+	 *
+	 * @return array|null
+	 */
+	private function collectWhitespace($string, $start, $end)
+	{
+		$space = '';
+		for ($start; $start < $end; $start++) {
+			if ($string[$start] !== ' ' && $string[$start] !== "\t") {
+				break;
+			}
+
+			$space .= $string[$start];
+		}
+
+		if ($space === '') {
+			return null;
+		}
+
+		$token = [
+			'content' => $space,
+			'code'    => T_DOC_COMMENT_WHITESPACE,
+			'type'    => 'T_DOC_COMMENT_WHITESPACE',
+		];
+
+		return $token;
+
+	}//end collectWhitespace()
 
 
 }//end class

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

Spacing +1 added lines, -1 removed lines

@@ -71,7 +71,7 @@
     public function __construct(
         array $scopeTokens,
         array $tokens,
-        $listenOutside=false
+        $listenOutside = false
     ) {
         if (empty($scopeTokens) === true) {
             $error = 'The scope tokens list cannot be empty';

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.
-     *
-     * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the specified tokens arrays are empty
-     *                                                      or invalid.
-     */
-    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;
-        $skipTokens = [];
-        foreach ($tokens[$stackPtr]['conditions'] as $scope => $code) {
-            if (isset($this->scopeTokens[$code]) === true) {
-                $skipTokens[] = $this->processTokenWithinScope($phpcsFile, $stackPtr, $scope);
-                $foundScope   = true;
-            }
-        }
-
-        if ($this->listenOutside === true && $foundScope === false) {
-            $skipTokens[] = $this->processTokenOutsideScope($phpcsFile, $stackPtr);
-        }
-
-        if (empty($skipTokens) === false) {
-            return min($skipTokens);
-        }
-
-        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.
+	 *
+	 * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the specified tokens arrays are empty
+	 *                                                      or invalid.
+	 */
+	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;
+		$skipTokens = [];
+		foreach ($tokens[$stackPtr]['conditions'] as $scope => $code) {
+			if (isset($this->scopeTokens[$code]) === true) {
+				$skipTokens[] = $this->processTokenWithinScope($phpcsFile, $stackPtr, $scope);
+				$foundScope   = true;
+			}
+		}
+
+		if ($this->listenOutside === true && $foundScope === false) {
+			$skipTokens[] = $this->processTokenOutsideScope($phpcsFile, $stackPtr);
+		}
+
+		if (empty($skipTokens) === false) {
+			return min($skipTokens);
+		}
+
+		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

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

Switch Indentation +20 added lines, -20 removed lines

@@ -866,26 +866,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 +1 added lines, -1 removed lines

@@ -61,7 +61,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) {

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

vendor/squizlabs/php_codesniffer/src/Generators/Generator.php

Indentation +94 added lines, -94 removed lines

@@ -19,100 +19,100 @@
 abstract class Generator
 {
 
-    /**
-     * The ruleset used for the run.
-     *
-     * @var \PHP_CodeSniffer\Ruleset
-     */
-    public $ruleset = null;
-
-    /**
-     * XML documentation files used to produce the final output.
-     *
-     * @var string[]
-     */
-    public $docFiles = [];
-
-
-    /**
-     * Constructs a doc generator.
-     *
-     * @param \PHP_CodeSniffer\Ruleset $ruleset The ruleset used for the run.
-     *
-     * @see generate()
-     */
-    public function __construct(Ruleset $ruleset)
-    {
-        $this->ruleset = $ruleset;
-
-        foreach ($ruleset->sniffs as $className => $sniffClass) {
-            $file    = Autoload::getLoadedFileName($className);
-            $docFile = str_replace(
-                DIRECTORY_SEPARATOR.'Sniffs'.DIRECTORY_SEPARATOR,
-                DIRECTORY_SEPARATOR.'Docs'.DIRECTORY_SEPARATOR,
-                $file
-            );
-            $docFile = str_replace('Sniff.php', 'Standard.xml', $docFile);
-
-            if (is_file($docFile) === true) {
-                $this->docFiles[] = $docFile;
-            }
-        }
-
-    }//end __construct()
-
-
-    /**
-     * Retrieves the title of the sniff from the DOMNode supplied.
-     *
-     * @param \DOMNode $doc The DOMNode object for the sniff.
-     *                      It represents the "documentation" tag in the XML
-     *                      standard file.
-     *
-     * @return string
-     */
-    protected function getTitle(\DOMNode $doc)
-    {
-        return $doc->getAttribute('title');
-
-    }//end getTitle()
-
-
-    /**
-     * Generates the documentation for a standard.
-     *
-     * It's probably wise for doc generators to override this method so they
-     * have control over how the docs are produced. Otherwise, the processSniff
-     * method should be overridden to output content for each sniff.
-     *
-     * @return void
-     * @see    processSniff()
-     */
-    public function generate()
-    {
-        foreach ($this->docFiles as $file) {
-            $doc = new \DOMDocument();
-            $doc->load($file);
-            $documentation = $doc->getElementsByTagName('documentation')->item(0);
-            $this->processSniff($documentation);
-        }
-
-    }//end generate()
-
-
-    /**
-     * Process the documentation for a single sniff.
-     *
-     * Doc generators must implement this function to produce output.
-     *
-     * @param \DOMNode $doc The DOMNode object for the sniff.
-     *                      It represents the "documentation" tag in the XML
-     *                      standard file.
-     *
-     * @return void
-     * @see    generate()
-     */
-    abstract protected function processSniff(\DOMNode $doc);
+	/**
+	 * The ruleset used for the run.
+	 *
+	 * @var \PHP_CodeSniffer\Ruleset
+	 */
+	public $ruleset = null;
+
+	/**
+	 * XML documentation files used to produce the final output.
+	 *
+	 * @var string[]
+	 */
+	public $docFiles = [];
+
+
+	/**
+	 * Constructs a doc generator.
+	 *
+	 * @param \PHP_CodeSniffer\Ruleset $ruleset The ruleset used for the run.
+	 *
+	 * @see generate()
+	 */
+	public function __construct(Ruleset $ruleset)
+	{
+		$this->ruleset = $ruleset;
+
+		foreach ($ruleset->sniffs as $className => $sniffClass) {
+			$file    = Autoload::getLoadedFileName($className);
+			$docFile = str_replace(
+				DIRECTORY_SEPARATOR.'Sniffs'.DIRECTORY_SEPARATOR,
+				DIRECTORY_SEPARATOR.'Docs'.DIRECTORY_SEPARATOR,
+				$file
+			);
+			$docFile = str_replace('Sniff.php', 'Standard.xml', $docFile);
+
+			if (is_file($docFile) === true) {
+				$this->docFiles[] = $docFile;
+			}
+		}
+
+	}//end __construct()
+
+
+	/**
+	 * Retrieves the title of the sniff from the DOMNode supplied.
+	 *
+	 * @param \DOMNode $doc The DOMNode object for the sniff.
+	 *                      It represents the "documentation" tag in the XML
+	 *                      standard file.
+	 *
+	 * @return string
+	 */
+	protected function getTitle(\DOMNode $doc)
+	{
+		return $doc->getAttribute('title');
+
+	}//end getTitle()
+
+
+	/**
+	 * Generates the documentation for a standard.
+	 *
+	 * It's probably wise for doc generators to override this method so they
+	 * have control over how the docs are produced. Otherwise, the processSniff
+	 * method should be overridden to output content for each sniff.
+	 *
+	 * @return void
+	 * @see    processSniff()
+	 */
+	public function generate()
+	{
+		foreach ($this->docFiles as $file) {
+			$doc = new \DOMDocument();
+			$doc->load($file);
+			$documentation = $doc->getElementsByTagName('documentation')->item(0);
+			$this->processSniff($documentation);
+		}
+
+	}//end generate()
+
+
+	/**
+	 * Process the documentation for a single sniff.
+	 *
+	 * Doc generators must implement this function to produce output.
+	 *
+	 * @param \DOMNode $doc The DOMNode object for the sniff.
+	 *                      It represents the "documentation" tag in the XML
+	 *                      standard file.
+	 *
+	 * @return void
+	 * @see    generate()
+	 */
+	abstract protected function processSniff(\DOMNode $doc);
 
 
 }//end class

vendor/squizlabs/php_codesniffer/src/Generators/HTML.php

Indentation +181 added lines, -181 removed lines

@@ -19,47 +19,47 @@ 
 {
 
 
-    /**
-     * Generates the documentation for a standard.
-     *
-     * @return void
-     * @see    processSniff()
-     */
-    public function generate()
-    {
-        ob_start();
-        $this->printHeader();
-        $this->printToc();
-
-        foreach ($this->docFiles as $file) {
-            $doc = new \DOMDocument();
-            $doc->load($file);
-            $documentation = $doc->getElementsByTagName('documentation')->item(0);
-            $this->processSniff($documentation);
-        }
-
-        $this->printFooter();
-
-        $content = ob_get_contents();
-        ob_end_clean();
-
-        echo $content;
-
-    }//end generate()
-
-
-    /**
-     * Print the header of the HTML page.
-     *
-     * @return void
-     */
-    protected function printHeader()
-    {
-        $standard = $this->ruleset->name;
-        echo '<html>'.PHP_EOL;
-        echo ' <head>'.PHP_EOL;
-        echo "  <title>$standard Coding Standards</title>".PHP_EOL;
-        echo '  <style>
+	/**
+	 * Generates the documentation for a standard.
+	 *
+	 * @return void
+	 * @see    processSniff()
+	 */
+	public function generate()
+	{
+		ob_start();
+		$this->printHeader();
+		$this->printToc();
+
+		foreach ($this->docFiles as $file) {
+			$doc = new \DOMDocument();
+			$doc->load($file);
+			$documentation = $doc->getElementsByTagName('documentation')->item(0);
+			$this->processSniff($documentation);
+		}
+
+		$this->printFooter();
+
+		$content = ob_get_contents();
+		ob_end_clean();
+
+		echo $content;
+
+	}//end generate()
+
+
+	/**
+	 * Print the header of the HTML page.
+	 *
+	 * @return void
+	 */
+	protected function printHeader()
+	{
+		$standard = $this->ruleset->name;
+		echo '<html>'.PHP_EOL;
+		echo ' <head>'.PHP_EOL;
+		echo "  <title>$standard Coding Standards</title>".PHP_EOL;
+		echo '  <style>
                     body {
                         background-color: #FFFFFF;
                         font-size: 14px;
@@ -125,146 +125,146 @@ 
                         color: #000000;
                     }
                 </style>'.PHP_EOL;
-        echo ' </head>'.PHP_EOL;
-        echo ' <body>'.PHP_EOL;
-        echo "  <h1>$standard Coding Standards</h1>".PHP_EOL;
-
-    }//end printHeader()
-
-
-    /**
-     * Print the table of contents for the standard.
-     *
-     * The TOC is just an unordered list of bookmarks to sniffs on the page.
-     *
-     * @return void
-     */
-    protected function printToc()
-    {
-        echo '  <h2>Table of Contents</h2>'.PHP_EOL;
-        echo '  <ul class="toc">'.PHP_EOL;
-
-        foreach ($this->docFiles as $file) {
-            $doc = new \DOMDocument();
-            $doc->load($file);
-            $documentation = $doc->getElementsByTagName('documentation')->item(0);
-            $title         = $this->getTitle($documentation);
-            echo '   <li><a href="#'.str_replace(' ', '-', $title)."\">$title</a></li>".PHP_EOL;
-        }
-
-        echo '  </ul>'.PHP_EOL;
-
-    }//end printToc()
-
-
-    /**
-     * Print the footer of the HTML page.
-     *
-     * @return void
-     */
-    protected function printFooter()
-    {
-        // Turn off errors so we don't get timezone warnings if people
-        // don't have their timezone set.
-        $errorLevel = error_reporting(0);
-        echo '  <div class="tag-line">';
-        echo 'Documentation generated on '.date('r');
-        echo ' by <a href="https://github.com/squizlabs/PHP_CodeSniffer">PHP_CodeSniffer '.Config::VERSION.'</a>';
-        echo '</div>'.PHP_EOL;
-        error_reporting($errorLevel);
-
-        echo ' </body>'.PHP_EOL;
-        echo '</html>'.PHP_EOL;
-
-    }//end printFooter()
-
-
-    /**
-     * Process the documentation for a single sniff.
-     *
-     * @param \DOMNode $doc The DOMNode object for the sniff.
-     *                      It represents the "documentation" tag in the XML
-     *                      standard file.
-     *
-     * @return void
-     */
-    public function processSniff(\DOMNode $doc)
-    {
-        $title = $this->getTitle($doc);
-        echo '  <a name="'.str_replace(' ', '-', $title).'" />'.PHP_EOL;
-        echo "  <h2>$title</h2>".PHP_EOL;
-
-        foreach ($doc->childNodes as $node) {
-            if ($node->nodeName === 'standard') {
-                $this->printTextBlock($node);
-            } else if ($node->nodeName === 'code_comparison') {
-                $this->printCodeComparisonBlock($node);
-            }
-        }
-
-    }//end processSniff()
-
-
-    /**
-     * Print a text block found in a standard.
-     *
-     * @param \DOMNode $node The DOMNode object for the text block.
-     *
-     * @return void
-     */
-    protected function printTextBlock(\DOMNode $node)
-    {
-        $content = trim($node->nodeValue);
-        $content = htmlspecialchars($content);
-
-        // Allow em tags only.
-        $content = str_replace('&lt;em&gt;', '<em>', $content);
-        $content = str_replace('&lt;/em&gt;', '</em>', $content);
-
-        echo "  <p class=\"text\">$content</p>".PHP_EOL;
-
-    }//end printTextBlock()
-
-
-    /**
-     * Print a code comparison block found in a standard.
-     *
-     * @param \DOMNode $node The DOMNode object for the code comparison block.
-     *
-     * @return void
-     */
-    protected function printCodeComparisonBlock(\DOMNode $node)
-    {
-        $codeBlocks = $node->getElementsByTagName('code');
-
-        $firstTitle = $codeBlocks->item(0)->getAttribute('title');
-        $first      = trim($codeBlocks->item(0)->nodeValue);
-        $first      = str_replace('<?php', '&lt;?php', $first);
-        $first      = str_replace("\n", '</br>', $first);
-        $first      = str_replace(' ', '&nbsp;', $first);
-        $first      = str_replace('<em>', '<span class="code-comparison-highlight">', $first);
-        $first      = str_replace('</em>', '</span>', $first);
-
-        $secondTitle = $codeBlocks->item(1)->getAttribute('title');
-        $second      = trim($codeBlocks->item(1)->nodeValue);
-        $second      = str_replace('<?php', '&lt;?php', $second);
-        $second      = str_replace("\n", '</br>', $second);
-        $second      = str_replace(' ', '&nbsp;', $second);
-        $second      = str_replace('<em>', '<span class="code-comparison-highlight">', $second);
-        $second      = str_replace('</em>', '</span>', $second);
-
-        echo '  <table class="code-comparison">'.PHP_EOL;
-        echo '   <tr>'.PHP_EOL;
-        echo "    <td class=\"code-comparison-title\">$firstTitle</td>".PHP_EOL;
-        echo "    <td class=\"code-comparison-title\">$secondTitle</td>".PHP_EOL;
-        echo '   </tr>'.PHP_EOL;
-        echo '   <tr>'.PHP_EOL;
-        echo "    <td class=\"code-comparison-code\">$first</td>".PHP_EOL;
-        echo "    <td class=\"code-comparison-code\">$second</td>".PHP_EOL;
-        echo '   </tr>'.PHP_EOL;
-        echo '  </table>'.PHP_EOL;
-
-    }//end printCodeComparisonBlock()
+		echo ' </head>'.PHP_EOL;
+		echo ' <body>'.PHP_EOL;
+		echo "  <h1>$standard Coding Standards</h1>".PHP_EOL;
+
+	}//end printHeader()
+
+
+	/**
+	 * Print the table of contents for the standard.
+	 *
+	 * The TOC is just an unordered list of bookmarks to sniffs on the page.
+	 *
+	 * @return void
+	 */
+	protected function printToc()
+	{
+		echo '  <h2>Table of Contents</h2>'.PHP_EOL;
+		echo '  <ul class="toc">'.PHP_EOL;
+
+		foreach ($this->docFiles as $file) {
+			$doc = new \DOMDocument();
+			$doc->load($file);
+			$documentation = $doc->getElementsByTagName('documentation')->item(0);
+			$title         = $this->getTitle($documentation);
+			echo '   <li><a href="#'.str_replace(' ', '-', $title)."\">$title</a></li>".PHP_EOL;
+		}
+
+		echo '  </ul>'.PHP_EOL;
+
+	}//end printToc()
+
+
+	/**
+	 * Print the footer of the HTML page.
+	 *
+	 * @return void
+	 */
+	protected function printFooter()
+	{
+		// Turn off errors so we don't get timezone warnings if people
+		// don't have their timezone set.
+		$errorLevel = error_reporting(0);
+		echo '  <div class="tag-line">';
+		echo 'Documentation generated on '.date('r');
+		echo ' by <a href="https://github.com/squizlabs/PHP_CodeSniffer">PHP_CodeSniffer '.Config::VERSION.'</a>';
+		echo '</div>'.PHP_EOL;
+		error_reporting($errorLevel);
+
+		echo ' </body>'.PHP_EOL;
+		echo '</html>'.PHP_EOL;
+
+	}//end printFooter()
+
+
+	/**
+	 * Process the documentation for a single sniff.
+	 *
+	 * @param \DOMNode $doc The DOMNode object for the sniff.
+	 *                      It represents the "documentation" tag in the XML
+	 *                      standard file.
+	 *
+	 * @return void
+	 */
+	public function processSniff(\DOMNode $doc)
+	{
+		$title = $this->getTitle($doc);
+		echo '  <a name="'.str_replace(' ', '-', $title).'" />'.PHP_EOL;
+		echo "  <h2>$title</h2>".PHP_EOL;
+
+		foreach ($doc->childNodes as $node) {
+			if ($node->nodeName === 'standard') {
+				$this->printTextBlock($node);
+			} else if ($node->nodeName === 'code_comparison') {
+				$this->printCodeComparisonBlock($node);
+			}
+		}
+
+	}//end processSniff()
+
+
+	/**
+	 * Print a text block found in a standard.
+	 *
+	 * @param \DOMNode $node The DOMNode object for the text block.
+	 *
+	 * @return void
+	 */
+	protected function printTextBlock(\DOMNode $node)
+	{
+		$content = trim($node->nodeValue);
+		$content = htmlspecialchars($content);
+
+		// Allow em tags only.
+		$content = str_replace('&lt;em&gt;', '<em>', $content);
+		$content = str_replace('&lt;/em&gt;', '</em>', $content);
+
+		echo "  <p class=\"text\">$content</p>".PHP_EOL;
+
+	}//end printTextBlock()
+
+
+	/**
+	 * Print a code comparison block found in a standard.
+	 *
+	 * @param \DOMNode $node The DOMNode object for the code comparison block.
+	 *
+	 * @return void
+	 */
+	protected function printCodeComparisonBlock(\DOMNode $node)
+	{
+		$codeBlocks = $node->getElementsByTagName('code');
+
+		$firstTitle = $codeBlocks->item(0)->getAttribute('title');
+		$first      = trim($codeBlocks->item(0)->nodeValue);
+		$first      = str_replace('<?php', '&lt;?php', $first);
+		$first      = str_replace("\n", '</br>', $first);
+		$first      = str_replace(' ', '&nbsp;', $first);
+		$first      = str_replace('<em>', '<span class="code-comparison-highlight">', $first);
+		$first      = str_replace('</em>', '</span>', $first);
+
+		$secondTitle = $codeBlocks->item(1)->getAttribute('title');
+		$second      = trim($codeBlocks->item(1)->nodeValue);
+		$second      = str_replace('<?php', '&lt;?php', $second);
+		$second      = str_replace("\n", '</br>', $second);
+		$second      = str_replace(' ', '&nbsp;', $second);
+		$second      = str_replace('<em>', '<span class="code-comparison-highlight">', $second);
+		$second      = str_replace('</em>', '</span>', $second);
+
+		echo '  <table class="code-comparison">'.PHP_EOL;
+		echo '   <tr>'.PHP_EOL;
+		echo "    <td class=\"code-comparison-title\">$firstTitle</td>".PHP_EOL;
+		echo "    <td class=\"code-comparison-title\">$secondTitle</td>".PHP_EOL;
+		echo '   </tr>'.PHP_EOL;
+		echo '   <tr>'.PHP_EOL;
+		echo "    <td class=\"code-comparison-code\">$first</td>".PHP_EOL;
+		echo "    <td class=\"code-comparison-code\">$second</td>".PHP_EOL;
+		echo '   </tr>'.PHP_EOL;
+		echo '  </table>'.PHP_EOL;
+
+	}//end printCodeComparisonBlock()
 
 
 }//end class

vendor/squizlabs/php_codesniffer/tests/Standards/AllSniffs.php

Spacing +1 added lines, -1 removed lines

@@ -46,7 +46,7 @@
 
         $suite = new TestSuite('PHP CodeSniffer Standards');
 
-        $isInstalled = !is_file(__DIR__.'/../../autoload.php');
+        $isInstalled = ! is_file(__DIR__.'/../../autoload.php');
 
         // Optionally allow for ignoring the tests for one or more standards.
         $ignoreTestsForStandards = getenv('PHPCS_IGNORE_TESTS');

Indentation +100 added lines, -100 removed lines

@@ -18,106 +18,106 @@
 {
 
 
-    /**
-     * Prepare the test runner.
-     *
-     * @return void
-     */
-    public static function main()
-    {
-        TestRunner::run(self::suite());
-
-    }//end main()
-
-
-    /**
-     * Add all sniff unit tests into a test suite.
-     *
-     * Sniff unit tests are found by recursing through the 'Tests' directory
-     * of each installed coding standard.
-     *
-     * @return \PHPUnit\Framework\TestSuite
-     */
-    public static function suite()
-    {
-        $GLOBALS['PHP_CODESNIFFER_SNIFF_CODES']      = [];
-        $GLOBALS['PHP_CODESNIFFER_FIXABLE_CODES']    = [];
-        $GLOBALS['PHP_CODESNIFFER_SNIFF_CASE_FILES'] = [];
-
-        $suite = new TestSuite('PHP CodeSniffer Standards');
-
-        $isInstalled = !is_file(__DIR__.'/../../autoload.php');
-
-        // Optionally allow for ignoring the tests for one or more standards.
-        $ignoreTestsForStandards = getenv('PHPCS_IGNORE_TESTS');
-        if ($ignoreTestsForStandards === false) {
-            $ignoreTestsForStandards = [];
-        } else {
-            $ignoreTestsForStandards = explode(',', $ignoreTestsForStandards);
-        }
-
-        $installedStandards = self::getInstalledStandardDetails();
-
-        foreach ($installedStandards as $standard => $details) {
-            Autoload::addSearchPath($details['path'], $details['namespace']);
-
-            // If the test is running PEAR installed, the built-in standards
-            // are split into different directories; one for the sniffs and
-            // a different file system location for tests.
-            if ($isInstalled === true && is_dir(dirname($details['path']).DIRECTORY_SEPARATOR.'Generic') === true) {
-                $testPath = realpath(__DIR__.'/../../src/Standards/'.$standard);
-            } else {
-                $testPath = $details['path'];
-            }
-
-            if (in_array($standard, $ignoreTestsForStandards, true) === true) {
-                continue;
-            }
-
-            $testsDir = $testPath.DIRECTORY_SEPARATOR.'Tests'.DIRECTORY_SEPARATOR;
-            if (is_dir($testsDir) === false) {
-                // No tests for this standard.
-                continue;
-            }
-
-            $di = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($testsDir));
-
-            foreach ($di as $file) {
-                // Skip hidden files.
-                if (substr($file->getFilename(), 0, 1) === '.') {
-                    continue;
-                }
-
-                // Tests must have the extension 'php'.
-                $parts = explode('.', $file);
-                $ext   = array_pop($parts);
-                if ($ext !== 'php') {
-                    continue;
-                }
-
-                $className = Autoload::loadFile($file->getPathname());
-                $GLOBALS['PHP_CODESNIFFER_STANDARD_DIRS'][$className] = $details['path'];
-                $GLOBALS['PHP_CODESNIFFER_TEST_DIRS'][$className]     = $testsDir;
-                $suite->addTestSuite($className);
-            }
-        }//end foreach
-
-        return $suite;
-
-    }//end suite()
-
-
-    /**
-     * Get the details of all coding standards installed.
-     *
-     * @return array
-     * @see    Standards::getInstalledStandardDetails()
-     */
-    protected static function getInstalledStandardDetails()
-    {
-        return Standards::getInstalledStandardDetails(true);
-
-    }//end getInstalledStandardDetails()
+	/**
+	 * Prepare the test runner.
+	 *
+	 * @return void
+	 */
+	public static function main()
+	{
+		TestRunner::run(self::suite());
+
+	}//end main()
+
+
+	/**
+	 * Add all sniff unit tests into a test suite.
+	 *
+	 * Sniff unit tests are found by recursing through the 'Tests' directory
+	 * of each installed coding standard.
+	 *
+	 * @return \PHPUnit\Framework\TestSuite
+	 */
+	public static function suite()
+	{
+		$GLOBALS['PHP_CODESNIFFER_SNIFF_CODES']      = [];
+		$GLOBALS['PHP_CODESNIFFER_FIXABLE_CODES']    = [];
+		$GLOBALS['PHP_CODESNIFFER_SNIFF_CASE_FILES'] = [];
+
+		$suite = new TestSuite('PHP CodeSniffer Standards');
+
+		$isInstalled = !is_file(__DIR__.'/../../autoload.php');
+
+		// Optionally allow for ignoring the tests for one or more standards.
+		$ignoreTestsForStandards = getenv('PHPCS_IGNORE_TESTS');
+		if ($ignoreTestsForStandards === false) {
+			$ignoreTestsForStandards = [];
+		} else {
+			$ignoreTestsForStandards = explode(',', $ignoreTestsForStandards);
+		}
+
+		$installedStandards = self::getInstalledStandardDetails();
+
+		foreach ($installedStandards as $standard => $details) {
+			Autoload::addSearchPath($details['path'], $details['namespace']);
+
+			// If the test is running PEAR installed, the built-in standards
+			// are split into different directories; one for the sniffs and
+			// a different file system location for tests.
+			if ($isInstalled === true && is_dir(dirname($details['path']).DIRECTORY_SEPARATOR.'Generic') === true) {
+				$testPath = realpath(__DIR__.'/../../src/Standards/'.$standard);
+			} else {
+				$testPath = $details['path'];
+			}
+
+			if (in_array($standard, $ignoreTestsForStandards, true) === true) {
+				continue;
+			}
+
+			$testsDir = $testPath.DIRECTORY_SEPARATOR.'Tests'.DIRECTORY_SEPARATOR;
+			if (is_dir($testsDir) === false) {
+				// No tests for this standard.
+				continue;
+			}
+
+			$di = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($testsDir));
+
+			foreach ($di as $file) {
+				// Skip hidden files.
+				if (substr($file->getFilename(), 0, 1) === '.') {
+					continue;
+				}
+
+				// Tests must have the extension 'php'.
+				$parts = explode('.', $file);
+				$ext   = array_pop($parts);
+				if ($ext !== 'php') {
+					continue;
+				}
+
+				$className = Autoload::loadFile($file->getPathname());
+				$GLOBALS['PHP_CODESNIFFER_STANDARD_DIRS'][$className] = $details['path'];
+				$GLOBALS['PHP_CODESNIFFER_TEST_DIRS'][$className]     = $testsDir;
+				$suite->addTestSuite($className);
+			}
+		}//end foreach
+
+		return $suite;
+
+	}//end suite()
+
+
+	/**
+	 * Get the details of all coding standards installed.
+	 *
+	 * @return array
+	 * @see    Standards::getInstalledStandardDetails()
+	 */
+	protected static function getInstalledStandardDetails()
+	{
+		return Standards::getInstalledStandardDetails(true);
+
+	}//end getInstalledStandardDetails()
 
 
 }//end class

vendor/squizlabs/php_codesniffer/tests/TestSuite7.php

Indentation +14 added lines, -14 removed lines

@@ -16,20 +16,20 @@
 {
 
 
-    /**
-     * Runs the tests and collects their result in a TestResult.
-     *
-     * @param \PHPUnit\Framework\TestResult $result A test result.
-     *
-     * @return \PHPUnit\Framework\TestResult
-     */
-    public function run(TestResult $result=null): TestResult
-    {
-        $result = parent::run($result);
-        printPHPCodeSnifferTestOutput();
-        return $result;
-
-    }//end run()
+	/**
+	 * Runs the tests and collects their result in a TestResult.
+	 *
+	 * @param \PHPUnit\Framework\TestResult $result A test result.
+	 *
+	 * @return \PHPUnit\Framework\TestResult
+	 */
+	public function run(TestResult $result=null): TestResult
+	{
+		$result = parent::run($result);
+		printPHPCodeSnifferTestOutput();
+		return $result;
+
+	}//end run()
 
 
 }//end class

Spacing +1 added lines, -1 removed lines

@@ -23,7 +23,7 @@
      *
      * @return \PHPUnit\Framework\TestResult
      */
-    public function run(TestResult $result=null): TestResult
+    public function run(TestResult $result = null): TestResult
     {
         $result = parent::run($result);
         printPHPCodeSnifferTestOutput();

vendor/squizlabs/php_codesniffer/tests/Core/IsCamelCapsTest.php

Indentation +114 added lines, -114 removed lines

@@ -16,120 +16,120 @@
 {
 
 
-    /**
-     * Test valid public function/method names.
-     *
-     * @return void
-     */
-    public function testValidNotClassFormatPublic()
-    {
-        $this->assertTrue(Common::isCamelCaps('thisIsCamelCaps', false, true, true));
-        $this->assertTrue(Common::isCamelCaps('thisISCamelCaps', false, true, false));
-
-    }//end testValidNotClassFormatPublic()
-
-
-    /**
-     * Test invalid public function/method names.
-     *
-     * @return void
-     */
-    public function testInvalidNotClassFormatPublic()
-    {
-        $this->assertFalse(Common::isCamelCaps('_thisIsCamelCaps', false, true, true));
-        $this->assertFalse(Common::isCamelCaps('thisISCamelCaps', false, true, true));
-        $this->assertFalse(Common::isCamelCaps('ThisIsCamelCaps', false, true, true));
-
-        $this->assertFalse(Common::isCamelCaps('3thisIsCamelCaps', false, true, true));
-        $this->assertFalse(Common::isCamelCaps('*thisIsCamelCaps', false, true, true));
-        $this->assertFalse(Common::isCamelCaps('-thisIsCamelCaps', false, true, true));
-
-        $this->assertFalse(Common::isCamelCaps('this*IsCamelCaps', false, true, true));
-        $this->assertFalse(Common::isCamelCaps('this-IsCamelCaps', false, true, true));
-        $this->assertFalse(Common::isCamelCaps('this_IsCamelCaps', false, true, true));
-        $this->assertFalse(Common::isCamelCaps('this_is_camel_caps', false, true, true));
-
-    }//end testInvalidNotClassFormatPublic()
-
-
-    /**
-     * Test valid private method names.
-     *
-     * @return void
-     */
-    public function testValidNotClassFormatPrivate()
-    {
-        $this->assertTrue(Common::isCamelCaps('_thisIsCamelCaps', false, false, true));
-        $this->assertTrue(Common::isCamelCaps('_thisISCamelCaps', false, false, false));
-        $this->assertTrue(Common::isCamelCaps('_i18N', false, false, true));
-        $this->assertTrue(Common::isCamelCaps('_i18n', false, false, true));
-
-    }//end testValidNotClassFormatPrivate()
-
-
-    /**
-     * Test invalid private method names.
-     *
-     * @return void
-     */
-    public function testInvalidNotClassFormatPrivate()
-    {
-        $this->assertFalse(Common::isCamelCaps('thisIsCamelCaps', false, false, true));
-        $this->assertFalse(Common::isCamelCaps('_thisISCamelCaps', false, false, true));
-        $this->assertFalse(Common::isCamelCaps('_ThisIsCamelCaps', false, false, true));
-        $this->assertFalse(Common::isCamelCaps('__thisIsCamelCaps', false, false, true));
-        $this->assertFalse(Common::isCamelCaps('__thisISCamelCaps', false, false, false));
-
-        $this->assertFalse(Common::isCamelCaps('3thisIsCamelCaps', false, false, true));
-        $this->assertFalse(Common::isCamelCaps('*thisIsCamelCaps', false, false, true));
-        $this->assertFalse(Common::isCamelCaps('-thisIsCamelCaps', false, false, true));
-        $this->assertFalse(Common::isCamelCaps('_this_is_camel_caps', false, false, true));
-
-    }//end testInvalidNotClassFormatPrivate()
-
-
-    /**
-     * Test valid class names.
-     *
-     * @return void
-     */
-    public function testValidClassFormatPublic()
-    {
-        $this->assertTrue(Common::isCamelCaps('ThisIsCamelCaps', true, true, true));
-        $this->assertTrue(Common::isCamelCaps('ThisISCamelCaps', true, true, false));
-        $this->assertTrue(Common::isCamelCaps('This3IsCamelCaps', true, true, false));
-
-    }//end testValidClassFormatPublic()
-
-
-    /**
-     * Test invalid class names.
-     *
-     * @return void
-     */
-    public function testInvalidClassFormat()
-    {
-        $this->assertFalse(Common::isCamelCaps('thisIsCamelCaps', true));
-        $this->assertFalse(Common::isCamelCaps('This-IsCamelCaps', true));
-        $this->assertFalse(Common::isCamelCaps('This_Is_Camel_Caps', true));
-
-    }//end testInvalidClassFormat()
-
-
-    /**
-     * Test invalid class names with the private flag set.
-     *
-     * Note that the private flag is ignored if the class format
-     * flag is set, so these names are all invalid.
-     *
-     * @return void
-     */
-    public function testInvalidClassFormatPrivate()
-    {
-        $this->assertFalse(Common::isCamelCaps('_ThisIsCamelCaps', true, true));
-        $this->assertFalse(Common::isCamelCaps('_ThisIsCamelCaps', true, false));
-
-    }//end testInvalidClassFormatPrivate()
+	/**
+	 * Test valid public function/method names.
+	 *
+	 * @return void
+	 */
+	public function testValidNotClassFormatPublic()
+	{
+		$this->assertTrue(Common::isCamelCaps('thisIsCamelCaps', false, true, true));
+		$this->assertTrue(Common::isCamelCaps('thisISCamelCaps', false, true, false));
+
+	}//end testValidNotClassFormatPublic()
+
+
+	/**
+	 * Test invalid public function/method names.
+	 *
+	 * @return void
+	 */
+	public function testInvalidNotClassFormatPublic()
+	{
+		$this->assertFalse(Common::isCamelCaps('_thisIsCamelCaps', false, true, true));
+		$this->assertFalse(Common::isCamelCaps('thisISCamelCaps', false, true, true));
+		$this->assertFalse(Common::isCamelCaps('ThisIsCamelCaps', false, true, true));
+
+		$this->assertFalse(Common::isCamelCaps('3thisIsCamelCaps', false, true, true));
+		$this->assertFalse(Common::isCamelCaps('*thisIsCamelCaps', false, true, true));
+		$this->assertFalse(Common::isCamelCaps('-thisIsCamelCaps', false, true, true));
+
+		$this->assertFalse(Common::isCamelCaps('this*IsCamelCaps', false, true, true));
+		$this->assertFalse(Common::isCamelCaps('this-IsCamelCaps', false, true, true));
+		$this->assertFalse(Common::isCamelCaps('this_IsCamelCaps', false, true, true));
+		$this->assertFalse(Common::isCamelCaps('this_is_camel_caps', false, true, true));
+
+	}//end testInvalidNotClassFormatPublic()
+
+
+	/**
+	 * Test valid private method names.
+	 *
+	 * @return void
+	 */
+	public function testValidNotClassFormatPrivate()
+	{
+		$this->assertTrue(Common::isCamelCaps('_thisIsCamelCaps', false, false, true));
+		$this->assertTrue(Common::isCamelCaps('_thisISCamelCaps', false, false, false));
+		$this->assertTrue(Common::isCamelCaps('_i18N', false, false, true));
+		$this->assertTrue(Common::isCamelCaps('_i18n', false, false, true));
+
+	}//end testValidNotClassFormatPrivate()
+
+
+	/**
+	 * Test invalid private method names.
+	 *
+	 * @return void
+	 */
+	public function testInvalidNotClassFormatPrivate()
+	{
+		$this->assertFalse(Common::isCamelCaps('thisIsCamelCaps', false, false, true));
+		$this->assertFalse(Common::isCamelCaps('_thisISCamelCaps', false, false, true));
+		$this->assertFalse(Common::isCamelCaps('_ThisIsCamelCaps', false, false, true));
+		$this->assertFalse(Common::isCamelCaps('__thisIsCamelCaps', false, false, true));
+		$this->assertFalse(Common::isCamelCaps('__thisISCamelCaps', false, false, false));
+
+		$this->assertFalse(Common::isCamelCaps('3thisIsCamelCaps', false, false, true));
+		$this->assertFalse(Common::isCamelCaps('*thisIsCamelCaps', false, false, true));
+		$this->assertFalse(Common::isCamelCaps('-thisIsCamelCaps', false, false, true));
+		$this->assertFalse(Common::isCamelCaps('_this_is_camel_caps', false, false, true));
+
+	}//end testInvalidNotClassFormatPrivate()
+
+
+	/**
+	 * Test valid class names.
+	 *
+	 * @return void
+	 */
+	public function testValidClassFormatPublic()
+	{
+		$this->assertTrue(Common::isCamelCaps('ThisIsCamelCaps', true, true, true));
+		$this->assertTrue(Common::isCamelCaps('ThisISCamelCaps', true, true, false));
+		$this->assertTrue(Common::isCamelCaps('This3IsCamelCaps', true, true, false));
+
+	}//end testValidClassFormatPublic()
+
+
+	/**
+	 * Test invalid class names.
+	 *
+	 * @return void
+	 */
+	public function testInvalidClassFormat()
+	{
+		$this->assertFalse(Common::isCamelCaps('thisIsCamelCaps', true));
+		$this->assertFalse(Common::isCamelCaps('This-IsCamelCaps', true));
+		$this->assertFalse(Common::isCamelCaps('This_Is_Camel_Caps', true));
+
+	}//end testInvalidClassFormat()
+
+
+	/**
+	 * Test invalid class names with the private flag set.
+	 *
+	 * Note that the private flag is ignored if the class format
+	 * flag is set, so these names are all invalid.
+	 *
+	 * @return void
+	 */
+	public function testInvalidClassFormatPrivate()
+	{
+		$this->assertFalse(Common::isCamelCaps('_ThisIsCamelCaps', true, true));
+		$this->assertFalse(Common::isCamelCaps('_ThisIsCamelCaps', true, false));
+
+	}//end testInvalidClassFormatPrivate()
 
 
 }//end class

vendor/squizlabs/php_codesniffer/tests/TestSuite.php

Indentation +14 added lines, -14 removed lines

@@ -16,20 +16,20 @@
 {
 
 
-    /**
-     * Runs the tests and collects their result in a TestResult.
-     *
-     * @param \PHPUnit\Framework\TestResult $result A test result.
-     *
-     * @return \PHPUnit\Framework\TestResult
-     */
-    public function run(TestResult $result=null)
-    {
-        $result = parent::run($result);
-        printPHPCodeSnifferTestOutput();
-        return $result;
-
-    }//end run()
+	/**
+	 * Runs the tests and collects their result in a TestResult.
+	 *
+	 * @param \PHPUnit\Framework\TestResult $result A test result.
+	 *
+	 * @return \PHPUnit\Framework\TestResult
+	 */
+	public function run(TestResult $result=null)
+	{
+		$result = parent::run($result);
+		printPHPCodeSnifferTestOutput();
+		return $result;
+
+	}//end run()
 
 
 }//end class

Spacing +1 added lines, -1 removed lines

@@ -23,7 +23,7 @@
      *
      * @return \PHPUnit\Framework\TestResult
      */
-    public function run(TestResult $result=null)
+    public function run(TestResult $result = null)
     {
         $result = parent::run($result);
         printPHPCodeSnifferTestOutput();