gravityview / GravityView

vendor/squizlabs/php_codesniffer/src/Standards/Generic/Sniffs/Formatting/SpaceAfterNotSniff.php

Indentation +114 added lines, -114 removed lines

@@ -16,120 +16,120 @@
 class SpaceAfterNotSniff implements Sniff
 {
 
-    /**
-     * A list of tokenizers this sniff supports.
-     *
-     * @var array
-     */
-    public $supportedTokenizers = [
-        'PHP',
-        'JS',
-    ];
-
-    /**
-     * The number of spaces desired after the NOT operator.
-     *
-     * @var integer
-     */
-    public $spacing = 1;
-
-    /**
-     * Allow newlines instead of spaces.
-     *
-     * @var boolean
-     */
-    public $ignoreNewlines = false;
-
-
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        return [T_BOOLEAN_NOT];
-
-    }//end register()
-
-
-    /**
-     * Processes this test, when one of its tokens is encountered.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
-     * @param int                         $stackPtr  The position of the current token in
-     *                                               the stack passed in $tokens.
-     *
-     * @return void
-     */
-    public function process(File $phpcsFile, $stackPtr)
-    {
-        $tokens        = $phpcsFile->getTokens();
-        $this->spacing = (int) $this->spacing;
-
-        $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true);
-        if ($nextNonEmpty === false) {
-            return;
-        }
-
-        if ($this->ignoreNewlines === true
-            && $tokens[$stackPtr]['line'] !== $tokens[$nextNonEmpty]['line']
-        ) {
-            return;
-        }
-
-        if ($this->spacing === 0 && $nextNonEmpty === ($stackPtr + 1)) {
-            return;
-        }
-
-        $nextNonWhitespace = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true);
-        if ($nextNonEmpty !== $nextNonWhitespace) {
-            $error = 'Expected %s space(s) after NOT operator; comment found';
-            $data  = [$this->spacing];
-            $phpcsFile->addError($error, $stackPtr, 'CommentFound', $data);
-            return;
-        }
-
-        $found = 0;
-        if ($tokens[$stackPtr]['line'] !== $tokens[$nextNonEmpty]['line']) {
-            $found = 'newline';
-        } else if ($tokens[($stackPtr + 1)]['code'] === T_WHITESPACE) {
-            $found = $tokens[($stackPtr + 1)]['length'];
-        }
-
-        if ($found === $this->spacing) {
-            return;
-        }
-
-        $error = 'Expected %s space(s) after NOT operator; %s found';
-        $data  = [
-            $this->spacing,
-            $found,
-        ];
-
-        $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Incorrect', $data);
-        if ($fix === true) {
-            $padding = str_repeat(' ', $this->spacing);
-            if ($found === 0) {
-                $phpcsFile->fixer->addContent($stackPtr, $padding);
-            } else {
-                $phpcsFile->fixer->beginChangeset();
-                $start = ($stackPtr + 1);
-
-                if ($this->spacing > 0) {
-                    $phpcsFile->fixer->replaceToken($start, $padding);
-                    ++$start;
-                }
-
-                for ($i = $start; $i < $nextNonWhitespace; $i++) {
-                    $phpcsFile->fixer->replaceToken($i, '');
-                }
-
-                $phpcsFile->fixer->endChangeset();
-            }
-        }
-
-    }//end process()
+	/**
+	 * A list of tokenizers this sniff supports.
+	 *
+	 * @var array
+	 */
+	public $supportedTokenizers = [
+		'PHP',
+		'JS',
+	];
+
+	/**
+	 * The number of spaces desired after the NOT operator.
+	 *
+	 * @var integer
+	 */
+	public $spacing = 1;
+
+	/**
+	 * Allow newlines instead of spaces.
+	 *
+	 * @var boolean
+	 */
+	public $ignoreNewlines = false;
+
+
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		return [T_BOOLEAN_NOT];
+
+	}//end register()
+
+
+	/**
+	 * Processes this test, when one of its tokens is encountered.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
+	 * @param int                         $stackPtr  The position of the current token in
+	 *                                               the stack passed in $tokens.
+	 *
+	 * @return void
+	 */
+	public function process(File $phpcsFile, $stackPtr)
+	{
+		$tokens        = $phpcsFile->getTokens();
+		$this->spacing = (int) $this->spacing;
+
+		$nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true);
+		if ($nextNonEmpty === false) {
+			return;
+		}
+
+		if ($this->ignoreNewlines === true
+			&& $tokens[$stackPtr]['line'] !== $tokens[$nextNonEmpty]['line']
+		) {
+			return;
+		}
+
+		if ($this->spacing === 0 && $nextNonEmpty === ($stackPtr + 1)) {
+			return;
+		}
+
+		$nextNonWhitespace = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true);
+		if ($nextNonEmpty !== $nextNonWhitespace) {
+			$error = 'Expected %s space(s) after NOT operator; comment found';
+			$data  = [$this->spacing];
+			$phpcsFile->addError($error, $stackPtr, 'CommentFound', $data);
+			return;
+		}
+
+		$found = 0;
+		if ($tokens[$stackPtr]['line'] !== $tokens[$nextNonEmpty]['line']) {
+			$found = 'newline';
+		} else if ($tokens[($stackPtr + 1)]['code'] === T_WHITESPACE) {
+			$found = $tokens[($stackPtr + 1)]['length'];
+		}
+
+		if ($found === $this->spacing) {
+			return;
+		}
+
+		$error = 'Expected %s space(s) after NOT operator; %s found';
+		$data  = [
+			$this->spacing,
+			$found,
+		];
+
+		$fix = $phpcsFile->addFixableError($error, $stackPtr, 'Incorrect', $data);
+		if ($fix === true) {
+			$padding = str_repeat(' ', $this->spacing);
+			if ($found === 0) {
+				$phpcsFile->fixer->addContent($stackPtr, $padding);
+			} else {
+				$phpcsFile->fixer->beginChangeset();
+				$start = ($stackPtr + 1);
+
+				if ($this->spacing > 0) {
+					$phpcsFile->fixer->replaceToken($start, $padding);
+					++$start;
+				}
+
+				for ($i = $start; $i < $nextNonWhitespace; $i++) {
+					$phpcsFile->fixer->replaceToken($i, '');
+				}
+
+				$phpcsFile->fixer->endChangeset();
+			}
+		}
+
+	}//end process()
 
 
 }//end class

Spacing +26 added lines, -26 removed lines

@@ -48,7 +48,7 @@ 
      */
     public function register()
     {
-        return [T_BOOLEAN_NOT];
+        return [ T_BOOLEAN_NOT ];
 
     }//end register()
 
@@ -62,42 +62,42 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
+    public function process( File $phpcsFile, $stackPtr )
     {
         $tokens        = $phpcsFile->getTokens();
-        $this->spacing = (int) $this->spacing;
+        $this->spacing = (int)$this->spacing;
 
-        $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true);
-        if ($nextNonEmpty === false) {
+        $nextNonEmpty = $phpcsFile->findNext( Tokens::$emptyTokens, ( $stackPtr + 1 ), null, true );
+        if ( $nextNonEmpty === false ) {
             return;
         }
 
-        if ($this->ignoreNewlines === true
-            && $tokens[$stackPtr]['line'] !== $tokens[$nextNonEmpty]['line']
+        if ( $this->ignoreNewlines === true
+            && $tokens[ $stackPtr ][ 'line' ] !== $tokens[ $nextNonEmpty ][ 'line' ]
         ) {
             return;
         }
 
-        if ($this->spacing === 0 && $nextNonEmpty === ($stackPtr + 1)) {
+        if ( $this->spacing === 0 && $nextNonEmpty === ( $stackPtr + 1 ) ) {
             return;
         }
 
-        $nextNonWhitespace = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true);
-        if ($nextNonEmpty !== $nextNonWhitespace) {
+        $nextNonWhitespace = $phpcsFile->findNext( T_WHITESPACE, ( $stackPtr + 1 ), null, true );
+        if ( $nextNonEmpty !== $nextNonWhitespace ) {
             $error = 'Expected %s space(s) after NOT operator; comment found';
-            $data  = [$this->spacing];
-            $phpcsFile->addError($error, $stackPtr, 'CommentFound', $data);
+            $data  = [ $this->spacing ];
+            $phpcsFile->addError( $error, $stackPtr, 'CommentFound', $data );
             return;
         }
 
         $found = 0;
-        if ($tokens[$stackPtr]['line'] !== $tokens[$nextNonEmpty]['line']) {
+        if ( $tokens[ $stackPtr ][ 'line' ] !== $tokens[ $nextNonEmpty ][ 'line' ] ) {
             $found = 'newline';
-        } else if ($tokens[($stackPtr + 1)]['code'] === T_WHITESPACE) {
-            $found = $tokens[($stackPtr + 1)]['length'];
+        } else if ( $tokens[ ( $stackPtr + 1 ) ][ 'code' ] === T_WHITESPACE ) {
+            $found = $tokens[ ( $stackPtr + 1 ) ][ 'length' ];
         }
 
-        if ($found === $this->spacing) {
+        if ( $found === $this->spacing ) {
             return;
         }
 
@@ -107,22 +107,22 @@ 
             $found,
         ];
 
-        $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Incorrect', $data);
-        if ($fix === true) {
-            $padding = str_repeat(' ', $this->spacing);
-            if ($found === 0) {
-                $phpcsFile->fixer->addContent($stackPtr, $padding);
+        $fix = $phpcsFile->addFixableError( $error, $stackPtr, 'Incorrect', $data );
+        if ( $fix === true ) {
+            $padding = str_repeat( ' ', $this->spacing );
+            if ( $found === 0 ) {
+                $phpcsFile->fixer->addContent( $stackPtr, $padding );
             } else {
                 $phpcsFile->fixer->beginChangeset();
-                $start = ($stackPtr + 1);
+                $start = ( $stackPtr + 1 );
 
-                if ($this->spacing > 0) {
-                    $phpcsFile->fixer->replaceToken($start, $padding);
+                if ( $this->spacing > 0 ) {
+                    $phpcsFile->fixer->replaceToken( $start, $padding );
                     ++$start;
                 }
 
-                for ($i = $start; $i < $nextNonWhitespace; $i++) {
-                    $phpcsFile->fixer->replaceToken($i, '');
+                for ( $i = $start; $i < $nextNonWhitespace; $i++ ) {
+                    $phpcsFile->fixer->replaceToken( $i, '' );
                 }
 
                 $phpcsFile->fixer->endChangeset();

Braces +3 added lines, -6 removed lines

@@ -13,8 +13,7 @@ 
 use PHP_CodeSniffer\Files\File;
 use PHP_CodeSniffer\Util\Tokens;
 
-class SpaceAfterNotSniff implements Sniff
-{
+class SpaceAfterNotSniff implements Sniff {
 
     /**
      * A list of tokenizers this sniff supports.
@@ -46,8 +45,7 @@ 
      *
      * @return array
      */
-    public function register()
-    {
+    public function register() {
         return [T_BOOLEAN_NOT];
 
     }//end register()
@@ -62,8 +60,7 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
-    {
+    public function process(File $phpcsFile, $stackPtr) {
         $tokens        = $phpcsFile->getTokens();
         $this->spacing = (int) $this->spacing;
 

vendor/squizlabs/php_codesniffer/src/Standards/Generic/Sniffs/Formatting/SpaceBeforeCastSniff.php

Indentation +51 added lines, -51 removed lines

@@ -17,57 +17,57 @@
 {
 
 
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        return Tokens::$castTokens;
-
-    }//end register()
-
-
-    /**
-     * Processes this test, when one of its tokens is encountered.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
-     * @param int                         $stackPtr  The position of the current token in
-     *                                               the stack passed in $tokens.
-     *
-     * @return void
-     */
-    public function process(File $phpcsFile, $stackPtr)
-    {
-        $tokens = $phpcsFile->getTokens();
-
-        if ($tokens[$stackPtr]['column'] === 1) {
-            return;
-        }
-
-        if ($tokens[($stackPtr - 1)]['code'] !== T_WHITESPACE) {
-            $error = 'A cast statement must be preceded by a single space';
-            $fix   = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpace');
-            if ($fix === true) {
-                $phpcsFile->fixer->addContentBefore($stackPtr, ' ');
-            }
-
-            $phpcsFile->recordMetric($stackPtr, 'Spacing before cast statement', 0);
-            return;
-        }
-
-        $phpcsFile->recordMetric($stackPtr, 'Spacing before cast statement', $tokens[($stackPtr - 1)]['length']);
-
-        if ($tokens[($stackPtr - 1)]['column'] !== 1 && $tokens[($stackPtr - 1)]['length'] !== 1) {
-            $error = 'A cast statement must be preceded by a single space';
-            $fix   = $phpcsFile->addFixableError($error, $stackPtr, 'TooMuchSpace');
-            if ($fix === true) {
-                $phpcsFile->fixer->replaceToken(($stackPtr - 1), ' ');
-            }
-        }
-
-    }//end process()
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		return Tokens::$castTokens;
+
+	}//end register()
+
+
+	/**
+	 * Processes this test, when one of its tokens is encountered.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
+	 * @param int                         $stackPtr  The position of the current token in
+	 *                                               the stack passed in $tokens.
+	 *
+	 * @return void
+	 */
+	public function process(File $phpcsFile, $stackPtr)
+	{
+		$tokens = $phpcsFile->getTokens();
+
+		if ($tokens[$stackPtr]['column'] === 1) {
+			return;
+		}
+
+		if ($tokens[($stackPtr - 1)]['code'] !== T_WHITESPACE) {
+			$error = 'A cast statement must be preceded by a single space';
+			$fix   = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpace');
+			if ($fix === true) {
+				$phpcsFile->fixer->addContentBefore($stackPtr, ' ');
+			}
+
+			$phpcsFile->recordMetric($stackPtr, 'Spacing before cast statement', 0);
+			return;
+		}
+
+		$phpcsFile->recordMetric($stackPtr, 'Spacing before cast statement', $tokens[($stackPtr - 1)]['length']);
+
+		if ($tokens[($stackPtr - 1)]['column'] !== 1 && $tokens[($stackPtr - 1)]['length'] !== 1) {
+			$error = 'A cast statement must be preceded by a single space';
+			$fix   = $phpcsFile->addFixableError($error, $stackPtr, 'TooMuchSpace');
+			if ($fix === true) {
+				$phpcsFile->fixer->replaceToken(($stackPtr - 1), ' ');
+			}
+		}
+
+	}//end process()
 
 
 }//end class

Spacing +12 added lines, -12 removed lines

@@ -38,32 +38,32 @@
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
+    public function process( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
-        if ($tokens[$stackPtr]['column'] === 1) {
+        if ( $tokens[ $stackPtr ][ 'column' ] === 1 ) {
             return;
         }
 
-        if ($tokens[($stackPtr - 1)]['code'] !== T_WHITESPACE) {
+        if ( $tokens[ ( $stackPtr - 1 ) ][ 'code' ] !== T_WHITESPACE ) {
             $error = 'A cast statement must be preceded by a single space';
-            $fix   = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpace');
-            if ($fix === true) {
-                $phpcsFile->fixer->addContentBefore($stackPtr, ' ');
+            $fix   = $phpcsFile->addFixableError( $error, $stackPtr, 'NoSpace' );
+            if ( $fix === true ) {
+                $phpcsFile->fixer->addContentBefore( $stackPtr, ' ' );
             }
 
-            $phpcsFile->recordMetric($stackPtr, 'Spacing before cast statement', 0);
+            $phpcsFile->recordMetric( $stackPtr, 'Spacing before cast statement', 0 );
             return;
         }
 
-        $phpcsFile->recordMetric($stackPtr, 'Spacing before cast statement', $tokens[($stackPtr - 1)]['length']);
+        $phpcsFile->recordMetric( $stackPtr, 'Spacing before cast statement', $tokens[ ( $stackPtr - 1 ) ][ 'length' ] );
 
-        if ($tokens[($stackPtr - 1)]['column'] !== 1 && $tokens[($stackPtr - 1)]['length'] !== 1) {
+        if ( $tokens[ ( $stackPtr - 1 ) ][ 'column' ] !== 1 && $tokens[ ( $stackPtr - 1 ) ][ 'length' ] !== 1 ) {
             $error = 'A cast statement must be preceded by a single space';
-            $fix   = $phpcsFile->addFixableError($error, $stackPtr, 'TooMuchSpace');
-            if ($fix === true) {
-                $phpcsFile->fixer->replaceToken(($stackPtr - 1), ' ');
+            $fix   = $phpcsFile->addFixableError( $error, $stackPtr, 'TooMuchSpace' );
+            if ( $fix === true ) {
+                $phpcsFile->fixer->replaceToken( ( $stackPtr - 1 ), ' ' );
             }
         }
 

Braces +3 added lines, -6 removed lines

@@ -13,8 +13,7 @@ 
 use PHP_CodeSniffer\Files\File;
 use PHP_CodeSniffer\Util\Tokens;
 
-class SpaceBeforeCastSniff implements Sniff
-{
+class SpaceBeforeCastSniff implements Sniff {
 
 
     /**
@@ -22,8 +21,7 @@ 
      *
      * @return array
      */
-    public function register()
-    {
+    public function register() {
         return Tokens::$castTokens;
 
     }//end register()
@@ -38,8 +36,7 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
-    {
+    public function process(File $phpcsFile, $stackPtr) {
         $tokens = $phpcsFile->getTokens();
 
         if ($tokens[$stackPtr]['column'] === 1) {

vendor/squizlabs/php_codesniffer/src/Standards/Generic/Sniffs/Formatting/MultipleStatementAlignmentSniff.php

Indentation +363 added lines, -363 removed lines

@@ -19,369 +19,369 @@
 class MultipleStatementAlignmentSniff implements Sniff
 {
 
-    /**
-     * A list of tokenizers this sniff supports.
-     *
-     * @var array
-     */
-    public $supportedTokenizers = [
-        'PHP',
-        'JS',
-    ];
-
-    /**
-     * If true, an error will be thrown; otherwise a warning.
-     *
-     * @var boolean
-     */
-    public $error = false;
-
-    /**
-     * The maximum amount of padding before the alignment is ignored.
-     *
-     * If the amount of padding required to align this assignment with the
-     * surrounding assignments exceeds this number, the assignment will be
-     * ignored and no errors or warnings will be thrown.
-     *
-     * @var integer
-     */
-    public $maxPadding = 1000;
-
-
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        $tokens = Tokens::$assignmentTokens;
-        unset($tokens[T_DOUBLE_ARROW]);
-        return $tokens;
-
-    }//end register()
-
-
-    /**
-     * Processes this test, when one of its tokens is encountered.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
-     * @param int                         $stackPtr  The position of the current token
-     *                                               in the stack passed in $tokens.
-     *
-     * @return int
-     */
-    public function process(File $phpcsFile, $stackPtr)
-    {
-        $tokens = $phpcsFile->getTokens();
-
-        // Ignore assignments used in a condition, like an IF or FOR.
-        if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) {
-            foreach ($tokens[$stackPtr]['nested_parenthesis'] as $start => $end) {
-                if (isset($tokens[$start]['parenthesis_owner']) === true) {
-                    return;
-                }
-            }
-        }
-
-        $lastAssign = $this->checkAlignment($phpcsFile, $stackPtr);
-        return ($lastAssign + 1);
-
-    }//end process()
-
-
-    /**
-     * Processes this test, when one of its tokens is encountered.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
-     * @param int                         $stackPtr  The position of the current token
-     *                                               in the stack passed in $tokens.
-     * @param int                         $end       The token where checking should end.
-     *                                               If NULL, the entire file will be checked.
-     *
-     * @return int
-     */
-    public function checkAlignment($phpcsFile, $stackPtr, $end=null)
-    {
-        $tokens = $phpcsFile->getTokens();
-
-        $assignments = [];
-        $prevAssign  = null;
-        $lastLine    = $tokens[$stackPtr]['line'];
-        $maxPadding  = null;
-        $stopped     = null;
-        $lastCode    = $stackPtr;
-        $lastSemi    = null;
-        $arrayEnd    = null;
-
-        if ($end === null) {
-            $end = $phpcsFile->numTokens;
-        }
-
-        $find = Tokens::$assignmentTokens;
-        unset($find[T_DOUBLE_ARROW]);
-
-        $scopes = Tokens::$scopeOpeners;
-        unset($scopes[T_CLOSURE]);
-        unset($scopes[T_ANON_CLASS]);
-        unset($scopes[T_OBJECT]);
-
-        for ($assign = $stackPtr; $assign < $end; $assign++) {
-            if ($tokens[$assign]['level'] < $tokens[$stackPtr]['level']) {
-                // Statement is in a different context, so the block is over.
-                break;
-            }
-
-            if (isset($scopes[$tokens[$assign]['code']]) === true
-                && isset($tokens[$assign]['scope_opener']) === true
-                && $tokens[$assign]['level'] === $tokens[$stackPtr]['level']
-            ) {
-                break;
-            }
-
-            if ($assign === $arrayEnd) {
-                $arrayEnd = null;
-            }
-
-            if (isset($find[$tokens[$assign]['code']]) === false) {
-                // A blank line indicates that the assignment block has ended.
-                if (isset(Tokens::$emptyTokens[$tokens[$assign]['code']]) === false
-                    && ($tokens[$assign]['line'] - $tokens[$lastCode]['line']) > 1
-                    && $tokens[$assign]['level'] === $tokens[$stackPtr]['level']
-                    && $arrayEnd === null
-                ) {
-                    break;
-                }
-
-                if ($tokens[$assign]['code'] === T_CLOSE_TAG) {
-                    // Breaking out of PHP ends the assignment block.
-                    break;
-                }
-
-                if ($tokens[$assign]['code'] === T_OPEN_SHORT_ARRAY
-                    && isset($tokens[$assign]['bracket_closer']) === true
-                ) {
-                    $arrayEnd = $tokens[$assign]['bracket_closer'];
-                }
-
-                if ($tokens[$assign]['code'] === T_ARRAY
-                    && isset($tokens[$assign]['parenthesis_opener']) === true
-                    && isset($tokens[$tokens[$assign]['parenthesis_opener']]['parenthesis_closer']) === true
-                ) {
-                    $arrayEnd = $tokens[$tokens[$assign]['parenthesis_opener']]['parenthesis_closer'];
-                }
-
-                if (isset(Tokens::$emptyTokens[$tokens[$assign]['code']]) === false) {
-                    $lastCode = $assign;
-
-                    if ($tokens[$assign]['code'] === T_SEMICOLON) {
-                        if ($tokens[$assign]['conditions'] === $tokens[$stackPtr]['conditions']) {
-                            if ($lastSemi !== null && $prevAssign !== null && $lastSemi > $prevAssign) {
-                                // This statement did not have an assignment operator in it.
-                                break;
-                            } else {
-                                $lastSemi = $assign;
-                            }
-                        } else if ($tokens[$assign]['level'] < $tokens[$stackPtr]['level']) {
-                            // Statement is in a different context, so the block is over.
-                            break;
-                        }
-                    }
-                }//end if
-
-                continue;
-            } else if ($assign !== $stackPtr && $tokens[$assign]['line'] === $lastLine) {
-                // Skip multiple assignments on the same line. We only need to
-                // try and align the first assignment.
-                continue;
-            }//end if
-
-            if ($assign !== $stackPtr) {
-                if ($tokens[$assign]['level'] > $tokens[$stackPtr]['level']) {
-                    // Has to be nested inside the same conditions as the first assignment.
-                    // We've gone one level down, so process this new block.
-                    $assign   = $this->checkAlignment($phpcsFile, $assign);
-                    $lastCode = $assign;
-                    continue;
-                } else if ($tokens[$assign]['level'] < $tokens[$stackPtr]['level']) {
-                    // We've gone one level up, so the block we are processing is done.
-                    break;
-                } else if ($arrayEnd !== null) {
-                    // Assignments inside arrays are not part of
-                    // the original block, so process this new block.
-                    $assign   = ($this->checkAlignment($phpcsFile, $assign, $arrayEnd) - 1);
-                    $arrayEnd = null;
-                    $lastCode = $assign;
-                    continue;
-                }
-
-                // Make sure it is not assigned inside a condition (eg. IF, FOR).
-                if (isset($tokens[$assign]['nested_parenthesis']) === true) {
-                    foreach ($tokens[$assign]['nested_parenthesis'] as $start => $end) {
-                        if (isset($tokens[$start]['parenthesis_owner']) === true) {
-                            break(2);
-                        }
-                    }
-                }
-            }//end if
-
-            $var = $phpcsFile->findPrevious(
-                Tokens::$emptyTokens,
-                ($assign - 1),
-                null,
-                true
-            );
-
-            // Make sure we wouldn't break our max padding length if we
-            // aligned with this statement, or they wouldn't break the max
-            // padding length if they aligned with us.
-            $varEnd    = $tokens[($var + 1)]['column'];
-            $assignLen = $tokens[$assign]['length'];
-            if ($assign !== $stackPtr) {
-                if ($prevAssign === null) {
-                    // Processing an inner block but no assignments found.
-                    break;
-                }
-
-                if (($varEnd + 1) > $assignments[$prevAssign]['assign_col']) {
-                    $padding      = 1;
-                    $assignColumn = ($varEnd + 1);
-                } else {
-                    $padding = ($assignments[$prevAssign]['assign_col'] - $varEnd + $assignments[$prevAssign]['assign_len'] - $assignLen);
-                    if ($padding <= 0) {
-                        $padding = 1;
-                    }
-
-                    if ($padding > $this->maxPadding) {
-                        $stopped = $assign;
-                        break;
-                    }
-
-                    $assignColumn = ($varEnd + $padding);
-                }//end if
-
-                if (($assignColumn + $assignLen) > ($assignments[$maxPadding]['assign_col'] + $assignments[$maxPadding]['assign_len'])) {
-                    $newPadding = ($varEnd - $assignments[$maxPadding]['var_end'] + $assignLen - $assignments[$maxPadding]['assign_len'] + 1);
-                    if ($newPadding > $this->maxPadding) {
-                        $stopped = $assign;
-                        break;
-                    } else {
-                        // New alignment settings for previous assignments.
-                        foreach ($assignments as $i => $data) {
-                            if ($i === $assign) {
-                                break;
-                            }
-
-                            $newPadding = ($varEnd - $data['var_end'] + $assignLen - $data['assign_len'] + 1);
-                            $assignments[$i]['expected']   = $newPadding;
-                            $assignments[$i]['assign_col'] = ($data['var_end'] + $newPadding);
-                        }
-
-                        $padding      = 1;
-                        $assignColumn = ($varEnd + 1);
-                    }
-                } else if ($padding > $assignments[$maxPadding]['expected']) {
-                    $maxPadding = $assign;
-                }//end if
-            } else {
-                $padding      = 1;
-                $assignColumn = ($varEnd + 1);
-                $maxPadding   = $assign;
-            }//end if
-
-            $found = 0;
-            if ($tokens[($var + 1)]['code'] === T_WHITESPACE) {
-                $found = $tokens[($var + 1)]['length'];
-                if ($found === 0) {
-                    // This means a newline was found.
-                    $found = 1;
-                }
-            }
-
-            $assignments[$assign] = [
-                'var_end'    => $varEnd,
-                'assign_len' => $assignLen,
-                'assign_col' => $assignColumn,
-                'expected'   => $padding,
-                'found'      => $found,
-            ];
-
-            $lastLine   = $tokens[$assign]['line'];
-            $prevAssign = $assign;
-        }//end for
-
-        if (empty($assignments) === true) {
-            return $stackPtr;
-        }
-
-        $numAssignments = count($assignments);
-
-        $errorGenerated = false;
-        foreach ($assignments as $assignment => $data) {
-            if ($data['found'] === $data['expected']) {
-                continue;
-            }
-
-            $expectedText = $data['expected'].' space';
-            if ($data['expected'] !== 1) {
-                $expectedText .= 's';
-            }
-
-            if ($data['found'] === null) {
-                $foundText = 'a new line';
-            } else {
-                $foundText = $data['found'].' space';
-                if ($data['found'] !== 1) {
-                    $foundText .= 's';
-                }
-            }
-
-            if ($numAssignments === 1) {
-                $type  = 'Incorrect';
-                $error = 'Equals sign not aligned correctly; expected %s but found %s';
-            } else {
-                $type  = 'NotSame';
-                $error = 'Equals sign not aligned with surrounding assignments; expected %s but found %s';
-            }
-
-            $errorData = [
-                $expectedText,
-                $foundText,
-            ];
-
-            if ($this->error === true) {
-                $fix = $phpcsFile->addFixableError($error, $assignment, $type, $errorData);
-            } else {
-                $fix = $phpcsFile->addFixableWarning($error, $assignment, $type.'Warning', $errorData);
-            }
-
-            $errorGenerated = true;
-
-            if ($fix === true && $data['found'] !== null) {
-                $newContent = str_repeat(' ', $data['expected']);
-                if ($data['found'] === 0) {
-                    $phpcsFile->fixer->addContentBefore($assignment, $newContent);
-                } else {
-                    $phpcsFile->fixer->replaceToken(($assignment - 1), $newContent);
-                }
-            }
-        }//end foreach
-
-        if ($numAssignments > 1) {
-            if ($errorGenerated === true) {
-                $phpcsFile->recordMetric($stackPtr, 'Adjacent assignments aligned', 'no');
-            } else {
-                $phpcsFile->recordMetric($stackPtr, 'Adjacent assignments aligned', 'yes');
-            }
-        }
-
-        if ($stopped !== null) {
-            return $this->checkAlignment($phpcsFile, $stopped);
-        } else {
-            return $assign;
-        }
-
-    }//end checkAlignment()
+	/**
+	 * A list of tokenizers this sniff supports.
+	 *
+	 * @var array
+	 */
+	public $supportedTokenizers = [
+		'PHP',
+		'JS',
+	];
+
+	/**
+	 * If true, an error will be thrown; otherwise a warning.
+	 *
+	 * @var boolean
+	 */
+	public $error = false;
+
+	/**
+	 * The maximum amount of padding before the alignment is ignored.
+	 *
+	 * If the amount of padding required to align this assignment with the
+	 * surrounding assignments exceeds this number, the assignment will be
+	 * ignored and no errors or warnings will be thrown.
+	 *
+	 * @var integer
+	 */
+	public $maxPadding = 1000;
+
+
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		$tokens = Tokens::$assignmentTokens;
+		unset($tokens[T_DOUBLE_ARROW]);
+		return $tokens;
+
+	}//end register()
+
+
+	/**
+	 * Processes this test, when one of its tokens is encountered.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
+	 * @param int                         $stackPtr  The position of the current token
+	 *                                               in the stack passed in $tokens.
+	 *
+	 * @return int
+	 */
+	public function process(File $phpcsFile, $stackPtr)
+	{
+		$tokens = $phpcsFile->getTokens();
+
+		// Ignore assignments used in a condition, like an IF or FOR.
+		if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) {
+			foreach ($tokens[$stackPtr]['nested_parenthesis'] as $start => $end) {
+				if (isset($tokens[$start]['parenthesis_owner']) === true) {
+					return;
+				}
+			}
+		}
+
+		$lastAssign = $this->checkAlignment($phpcsFile, $stackPtr);
+		return ($lastAssign + 1);
+
+	}//end process()
+
+
+	/**
+	 * Processes this test, when one of its tokens is encountered.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
+	 * @param int                         $stackPtr  The position of the current token
+	 *                                               in the stack passed in $tokens.
+	 * @param int                         $end       The token where checking should end.
+	 *                                               If NULL, the entire file will be checked.
+	 *
+	 * @return int
+	 */
+	public function checkAlignment($phpcsFile, $stackPtr, $end=null)
+	{
+		$tokens = $phpcsFile->getTokens();
+
+		$assignments = [];
+		$prevAssign  = null;
+		$lastLine    = $tokens[$stackPtr]['line'];
+		$maxPadding  = null;
+		$stopped     = null;
+		$lastCode    = $stackPtr;
+		$lastSemi    = null;
+		$arrayEnd    = null;
+
+		if ($end === null) {
+			$end = $phpcsFile->numTokens;
+		}
+
+		$find = Tokens::$assignmentTokens;
+		unset($find[T_DOUBLE_ARROW]);
+
+		$scopes = Tokens::$scopeOpeners;
+		unset($scopes[T_CLOSURE]);
+		unset($scopes[T_ANON_CLASS]);
+		unset($scopes[T_OBJECT]);
+
+		for ($assign = $stackPtr; $assign < $end; $assign++) {
+			if ($tokens[$assign]['level'] < $tokens[$stackPtr]['level']) {
+				// Statement is in a different context, so the block is over.
+				break;
+			}
+
+			if (isset($scopes[$tokens[$assign]['code']]) === true
+				&& isset($tokens[$assign]['scope_opener']) === true
+				&& $tokens[$assign]['level'] === $tokens[$stackPtr]['level']
+			) {
+				break;
+			}
+
+			if ($assign === $arrayEnd) {
+				$arrayEnd = null;
+			}
+
+			if (isset($find[$tokens[$assign]['code']]) === false) {
+				// A blank line indicates that the assignment block has ended.
+				if (isset(Tokens::$emptyTokens[$tokens[$assign]['code']]) === false
+					&& ($tokens[$assign]['line'] - $tokens[$lastCode]['line']) > 1
+					&& $tokens[$assign]['level'] === $tokens[$stackPtr]['level']
+					&& $arrayEnd === null
+				) {
+					break;
+				}
+
+				if ($tokens[$assign]['code'] === T_CLOSE_TAG) {
+					// Breaking out of PHP ends the assignment block.
+					break;
+				}
+
+				if ($tokens[$assign]['code'] === T_OPEN_SHORT_ARRAY
+					&& isset($tokens[$assign]['bracket_closer']) === true
+				) {
+					$arrayEnd = $tokens[$assign]['bracket_closer'];
+				}
+
+				if ($tokens[$assign]['code'] === T_ARRAY
+					&& isset($tokens[$assign]['parenthesis_opener']) === true
+					&& isset($tokens[$tokens[$assign]['parenthesis_opener']]['parenthesis_closer']) === true
+				) {
+					$arrayEnd = $tokens[$tokens[$assign]['parenthesis_opener']]['parenthesis_closer'];
+				}
+
+				if (isset(Tokens::$emptyTokens[$tokens[$assign]['code']]) === false) {
+					$lastCode = $assign;
+
+					if ($tokens[$assign]['code'] === T_SEMICOLON) {
+						if ($tokens[$assign]['conditions'] === $tokens[$stackPtr]['conditions']) {
+							if ($lastSemi !== null && $prevAssign !== null && $lastSemi > $prevAssign) {
+								// This statement did not have an assignment operator in it.
+								break;
+							} else {
+								$lastSemi = $assign;
+							}
+						} else if ($tokens[$assign]['level'] < $tokens[$stackPtr]['level']) {
+							// Statement is in a different context, so the block is over.
+							break;
+						}
+					}
+				}//end if
+
+				continue;
+			} else if ($assign !== $stackPtr && $tokens[$assign]['line'] === $lastLine) {
+				// Skip multiple assignments on the same line. We only need to
+				// try and align the first assignment.
+				continue;
+			}//end if
+
+			if ($assign !== $stackPtr) {
+				if ($tokens[$assign]['level'] > $tokens[$stackPtr]['level']) {
+					// Has to be nested inside the same conditions as the first assignment.
+					// We've gone one level down, so process this new block.
+					$assign   = $this->checkAlignment($phpcsFile, $assign);
+					$lastCode = $assign;
+					continue;
+				} else if ($tokens[$assign]['level'] < $tokens[$stackPtr]['level']) {
+					// We've gone one level up, so the block we are processing is done.
+					break;
+				} else if ($arrayEnd !== null) {
+					// Assignments inside arrays are not part of
+					// the original block, so process this new block.
+					$assign   = ($this->checkAlignment($phpcsFile, $assign, $arrayEnd) - 1);
+					$arrayEnd = null;
+					$lastCode = $assign;
+					continue;
+				}
+
+				// Make sure it is not assigned inside a condition (eg. IF, FOR).
+				if (isset($tokens[$assign]['nested_parenthesis']) === true) {
+					foreach ($tokens[$assign]['nested_parenthesis'] as $start => $end) {
+						if (isset($tokens[$start]['parenthesis_owner']) === true) {
+							break(2);
+						}
+					}
+				}
+			}//end if
+
+			$var = $phpcsFile->findPrevious(
+				Tokens::$emptyTokens,
+				($assign - 1),
+				null,
+				true
+			);
+
+			// Make sure we wouldn't break our max padding length if we
+			// aligned with this statement, or they wouldn't break the max
+			// padding length if they aligned with us.
+			$varEnd    = $tokens[($var + 1)]['column'];
+			$assignLen = $tokens[$assign]['length'];
+			if ($assign !== $stackPtr) {
+				if ($prevAssign === null) {
+					// Processing an inner block but no assignments found.
+					break;
+				}
+
+				if (($varEnd + 1) > $assignments[$prevAssign]['assign_col']) {
+					$padding      = 1;
+					$assignColumn = ($varEnd + 1);
+				} else {
+					$padding = ($assignments[$prevAssign]['assign_col'] - $varEnd + $assignments[$prevAssign]['assign_len'] - $assignLen);
+					if ($padding <= 0) {
+						$padding = 1;
+					}
+
+					if ($padding > $this->maxPadding) {
+						$stopped = $assign;
+						break;
+					}
+
+					$assignColumn = ($varEnd + $padding);
+				}//end if
+
+				if (($assignColumn + $assignLen) > ($assignments[$maxPadding]['assign_col'] + $assignments[$maxPadding]['assign_len'])) {
+					$newPadding = ($varEnd - $assignments[$maxPadding]['var_end'] + $assignLen - $assignments[$maxPadding]['assign_len'] + 1);
+					if ($newPadding > $this->maxPadding) {
+						$stopped = $assign;
+						break;
+					} else {
+						// New alignment settings for previous assignments.
+						foreach ($assignments as $i => $data) {
+							if ($i === $assign) {
+								break;
+							}
+
+							$newPadding = ($varEnd - $data['var_end'] + $assignLen - $data['assign_len'] + 1);
+							$assignments[$i]['expected']   = $newPadding;
+							$assignments[$i]['assign_col'] = ($data['var_end'] + $newPadding);
+						}
+
+						$padding      = 1;
+						$assignColumn = ($varEnd + 1);
+					}
+				} else if ($padding > $assignments[$maxPadding]['expected']) {
+					$maxPadding = $assign;
+				}//end if
+			} else {
+				$padding      = 1;
+				$assignColumn = ($varEnd + 1);
+				$maxPadding   = $assign;
+			}//end if
+
+			$found = 0;
+			if ($tokens[($var + 1)]['code'] === T_WHITESPACE) {
+				$found = $tokens[($var + 1)]['length'];
+				if ($found === 0) {
+					// This means a newline was found.
+					$found = 1;
+				}
+			}
+
+			$assignments[$assign] = [
+				'var_end'    => $varEnd,
+				'assign_len' => $assignLen,
+				'assign_col' => $assignColumn,
+				'expected'   => $padding,
+				'found'      => $found,
+			];
+
+			$lastLine   = $tokens[$assign]['line'];
+			$prevAssign = $assign;
+		}//end for
+
+		if (empty($assignments) === true) {
+			return $stackPtr;
+		}
+
+		$numAssignments = count($assignments);
+
+		$errorGenerated = false;
+		foreach ($assignments as $assignment => $data) {
+			if ($data['found'] === $data['expected']) {
+				continue;
+			}
+
+			$expectedText = $data['expected'].' space';
+			if ($data['expected'] !== 1) {
+				$expectedText .= 's';
+			}
+
+			if ($data['found'] === null) {
+				$foundText = 'a new line';
+			} else {
+				$foundText = $data['found'].' space';
+				if ($data['found'] !== 1) {
+					$foundText .= 's';
+				}
+			}
+
+			if ($numAssignments === 1) {
+				$type  = 'Incorrect';
+				$error = 'Equals sign not aligned correctly; expected %s but found %s';
+			} else {
+				$type  = 'NotSame';
+				$error = 'Equals sign not aligned with surrounding assignments; expected %s but found %s';
+			}
+
+			$errorData = [
+				$expectedText,
+				$foundText,
+			];
+
+			if ($this->error === true) {
+				$fix = $phpcsFile->addFixableError($error, $assignment, $type, $errorData);
+			} else {
+				$fix = $phpcsFile->addFixableWarning($error, $assignment, $type.'Warning', $errorData);
+			}
+
+			$errorGenerated = true;
+
+			if ($fix === true && $data['found'] !== null) {
+				$newContent = str_repeat(' ', $data['expected']);
+				if ($data['found'] === 0) {
+					$phpcsFile->fixer->addContentBefore($assignment, $newContent);
+				} else {
+					$phpcsFile->fixer->replaceToken(($assignment - 1), $newContent);
+				}
+			}
+		}//end foreach
+
+		if ($numAssignments > 1) {
+			if ($errorGenerated === true) {
+				$phpcsFile->recordMetric($stackPtr, 'Adjacent assignments aligned', 'no');
+			} else {
+				$phpcsFile->recordMetric($stackPtr, 'Adjacent assignments aligned', 'yes');
+			}
+		}
+
+		if ($stopped !== null) {
+			return $this->checkAlignment($phpcsFile, $stopped);
+		} else {
+			return $assign;
+		}
+
+	}//end checkAlignment()
 
 
 }//end class

Spacing +100 added lines, -100 removed lines

@@ -56,7 +56,7 @@ 
     public function register()
     {
         $tokens = Tokens::$assignmentTokens;
-        unset($tokens[T_DOUBLE_ARROW]);
+        unset( $tokens[ T_DOUBLE_ARROW ] );
         return $tokens;
 
     }//end register()
@@ -71,21 +71,21 @@ 
      *
      * @return int
      */
-    public function process(File $phpcsFile, $stackPtr)
+    public function process( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
         // Ignore assignments used in a condition, like an IF or FOR.
-        if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) {
-            foreach ($tokens[$stackPtr]['nested_parenthesis'] as $start => $end) {
-                if (isset($tokens[$start]['parenthesis_owner']) === true) {
+        if ( isset( $tokens[ $stackPtr ][ 'nested_parenthesis' ] ) === true ) {
+            foreach ( $tokens[ $stackPtr ][ 'nested_parenthesis' ] as $start => $end ) {
+                if ( isset( $tokens[ $start ][ 'parenthesis_owner' ] ) === true ) {
                     return;
                 }
             }
         }
 
-        $lastAssign = $this->checkAlignment($phpcsFile, $stackPtr);
-        return ($lastAssign + 1);
+        $lastAssign = $this->checkAlignment( $phpcsFile, $stackPtr );
+        return ( $lastAssign + 1 );
 
     }//end process()
 
@@ -101,88 +101,88 @@ 
      *
      * @return int
      */
-    public function checkAlignment($phpcsFile, $stackPtr, $end=null)
+    public function checkAlignment( $phpcsFile, $stackPtr, $end = null )
     {
         $tokens = $phpcsFile->getTokens();
 
-        $assignments = [];
+        $assignments = [ ];
         $prevAssign  = null;
-        $lastLine    = $tokens[$stackPtr]['line'];
+        $lastLine    = $tokens[ $stackPtr ][ 'line' ];
         $maxPadding  = null;
         $stopped     = null;
         $lastCode    = $stackPtr;
         $lastSemi    = null;
         $arrayEnd    = null;
 
-        if ($end === null) {
+        if ( $end === null ) {
             $end = $phpcsFile->numTokens;
         }
 
         $find = Tokens::$assignmentTokens;
-        unset($find[T_DOUBLE_ARROW]);
+        unset( $find[ T_DOUBLE_ARROW ] );
 
         $scopes = Tokens::$scopeOpeners;
-        unset($scopes[T_CLOSURE]);
-        unset($scopes[T_ANON_CLASS]);
-        unset($scopes[T_OBJECT]);
+        unset( $scopes[ T_CLOSURE ] );
+        unset( $scopes[ T_ANON_CLASS ] );
+        unset( $scopes[ T_OBJECT ] );
 
-        for ($assign = $stackPtr; $assign < $end; $assign++) {
-            if ($tokens[$assign]['level'] < $tokens[$stackPtr]['level']) {
+        for ( $assign = $stackPtr; $assign < $end; $assign++ ) {
+            if ( $tokens[ $assign ][ 'level' ] < $tokens[ $stackPtr ][ 'level' ] ) {
                 // Statement is in a different context, so the block is over.
                 break;
             }
 
-            if (isset($scopes[$tokens[$assign]['code']]) === true
-                && isset($tokens[$assign]['scope_opener']) === true
-                && $tokens[$assign]['level'] === $tokens[$stackPtr]['level']
+            if ( isset( $scopes[ $tokens[ $assign ][ 'code' ] ] ) === true
+                && isset( $tokens[ $assign ][ 'scope_opener' ] ) === true
+                && $tokens[ $assign ][ 'level' ] === $tokens[ $stackPtr ][ 'level' ]
             ) {
                 break;
             }
 
-            if ($assign === $arrayEnd) {
+            if ( $assign === $arrayEnd ) {
                 $arrayEnd = null;
             }
 
-            if (isset($find[$tokens[$assign]['code']]) === false) {
+            if ( isset( $find[ $tokens[ $assign ][ 'code' ] ] ) === false ) {
                 // A blank line indicates that the assignment block has ended.
-                if (isset(Tokens::$emptyTokens[$tokens[$assign]['code']]) === false
-                    && ($tokens[$assign]['line'] - $tokens[$lastCode]['line']) > 1
-                    && $tokens[$assign]['level'] === $tokens[$stackPtr]['level']
+                if ( isset( Tokens::$emptyTokens[ $tokens[ $assign ][ 'code' ] ] ) === false
+                    && ( $tokens[ $assign ][ 'line' ] - $tokens[ $lastCode ][ 'line' ] ) > 1
+                    && $tokens[ $assign ][ 'level' ] === $tokens[ $stackPtr ][ 'level' ]
                     && $arrayEnd === null
                 ) {
                     break;
                 }
 
-                if ($tokens[$assign]['code'] === T_CLOSE_TAG) {
+                if ( $tokens[ $assign ][ 'code' ] === T_CLOSE_TAG ) {
                     // Breaking out of PHP ends the assignment block.
                     break;
                 }
 
-                if ($tokens[$assign]['code'] === T_OPEN_SHORT_ARRAY
-                    && isset($tokens[$assign]['bracket_closer']) === true
+                if ( $tokens[ $assign ][ 'code' ] === T_OPEN_SHORT_ARRAY
+                    && isset( $tokens[ $assign ][ 'bracket_closer' ] ) === true
                 ) {
-                    $arrayEnd = $tokens[$assign]['bracket_closer'];
+                    $arrayEnd = $tokens[ $assign ][ 'bracket_closer' ];
                 }
 
-                if ($tokens[$assign]['code'] === T_ARRAY
-                    && isset($tokens[$assign]['parenthesis_opener']) === true
-                    && isset($tokens[$tokens[$assign]['parenthesis_opener']]['parenthesis_closer']) === true
+                if ( $tokens[ $assign ][ 'code' ] === T_ARRAY
+                    && isset( $tokens[ $assign ][ 'parenthesis_opener' ] ) === true
+                    && isset( $tokens[ $tokens[ $assign ][ 'parenthesis_opener' ] ][ 'parenthesis_closer' ] ) === true
                 ) {
-                    $arrayEnd = $tokens[$tokens[$assign]['parenthesis_opener']]['parenthesis_closer'];
+                    $arrayEnd = $tokens[ $tokens[ $assign ][ 'parenthesis_opener' ] ][ 'parenthesis_closer' ];
                 }
 
-                if (isset(Tokens::$emptyTokens[$tokens[$assign]['code']]) === false) {
+                if ( isset( Tokens::$emptyTokens[ $tokens[ $assign ][ 'code' ] ] ) === false ) {
                     $lastCode = $assign;
 
-                    if ($tokens[$assign]['code'] === T_SEMICOLON) {
-                        if ($tokens[$assign]['conditions'] === $tokens[$stackPtr]['conditions']) {
-                            if ($lastSemi !== null && $prevAssign !== null && $lastSemi > $prevAssign) {
+                    if ( $tokens[ $assign ][ 'code' ] === T_SEMICOLON ) {
+                        if ( $tokens[ $assign ][ 'conditions' ] === $tokens[ $stackPtr ][ 'conditions' ] ) {
+                            if ( $lastSemi !== null && $prevAssign !== null && $lastSemi > $prevAssign ) {
                                 // This statement did not have an assignment operator in it.
                                 break;
                             } else {
                                 $lastSemi = $assign;
                             }
-                        } else if ($tokens[$assign]['level'] < $tokens[$stackPtr]['level']) {
+                        } else if ( $tokens[ $assign ][ 'level' ] < $tokens[ $stackPtr ][ 'level' ] ) {
                             // Statement is in a different context, so the block is over.
                             break;
                         }
@@ -190,36 +190,36 @@ 
                 }//end if
 
                 continue;
-            } else if ($assign !== $stackPtr && $tokens[$assign]['line'] === $lastLine) {
+            } else if ( $assign !== $stackPtr && $tokens[ $assign ][ 'line' ] === $lastLine ) {
                 // Skip multiple assignments on the same line. We only need to
                 // try and align the first assignment.
                 continue;
             }//end if
 
-            if ($assign !== $stackPtr) {
-                if ($tokens[$assign]['level'] > $tokens[$stackPtr]['level']) {
+            if ( $assign !== $stackPtr ) {
+                if ( $tokens[ $assign ][ 'level' ] > $tokens[ $stackPtr ][ 'level' ] ) {
                     // Has to be nested inside the same conditions as the first assignment.
                     // We've gone one level down, so process this new block.
-                    $assign   = $this->checkAlignment($phpcsFile, $assign);
+                    $assign   = $this->checkAlignment( $phpcsFile, $assign );
                     $lastCode = $assign;
                     continue;
-                } else if ($tokens[$assign]['level'] < $tokens[$stackPtr]['level']) {
+                } else if ( $tokens[ $assign ][ 'level' ] < $tokens[ $stackPtr ][ 'level' ] ) {
                     // We've gone one level up, so the block we are processing is done.
                     break;
-                } else if ($arrayEnd !== null) {
+                } else if ( $arrayEnd !== null ) {
                     // Assignments inside arrays are not part of
                     // the original block, so process this new block.
-                    $assign   = ($this->checkAlignment($phpcsFile, $assign, $arrayEnd) - 1);
+                    $assign   = ( $this->checkAlignment( $phpcsFile, $assign, $arrayEnd ) - 1 );
                     $arrayEnd = null;
                     $lastCode = $assign;
                     continue;
                 }
 
                 // Make sure it is not assigned inside a condition (eg. IF, FOR).
-                if (isset($tokens[$assign]['nested_parenthesis']) === true) {
-                    foreach ($tokens[$assign]['nested_parenthesis'] as $start => $end) {
-                        if (isset($tokens[$start]['parenthesis_owner']) === true) {
-                            break(2);
+                if ( isset( $tokens[ $assign ][ 'nested_parenthesis' ] ) === true ) {
+                    foreach ( $tokens[ $assign ][ 'nested_parenthesis' ] as $start => $end ) {
+                        if ( isset( $tokens[ $start ][ 'parenthesis_owner' ] ) === true ) {
+                            break( 2 );
                         }
                     }
                 }
@@ -227,7 +227,7 @@ 
 
             $var = $phpcsFile->findPrevious(
                 Tokens::$emptyTokens,
-                ($assign - 1),
+                ( $assign - 1 ),
                 null,
                 true
             );
@@ -235,70 +235,70 @@ 
             // Make sure we wouldn't break our max padding length if we
             // aligned with this statement, or they wouldn't break the max
             // padding length if they aligned with us.
-            $varEnd    = $tokens[($var + 1)]['column'];
-            $assignLen = $tokens[$assign]['length'];
-            if ($assign !== $stackPtr) {
-                if ($prevAssign === null) {
+            $varEnd    = $tokens[ ( $var + 1 ) ][ 'column' ];
+            $assignLen = $tokens[ $assign ][ 'length' ];
+            if ( $assign !== $stackPtr ) {
+                if ( $prevAssign === null ) {
                     // Processing an inner block but no assignments found.
                     break;
                 }
 
-                if (($varEnd + 1) > $assignments[$prevAssign]['assign_col']) {
+                if ( ( $varEnd + 1 ) > $assignments[ $prevAssign ][ 'assign_col' ] ) {
                     $padding      = 1;
-                    $assignColumn = ($varEnd + 1);
+                    $assignColumn = ( $varEnd + 1 );
                 } else {
-                    $padding = ($assignments[$prevAssign]['assign_col'] - $varEnd + $assignments[$prevAssign]['assign_len'] - $assignLen);
-                    if ($padding <= 0) {
+                    $padding = ( $assignments[ $prevAssign ][ 'assign_col' ] - $varEnd + $assignments[ $prevAssign ][ 'assign_len' ] - $assignLen );
+                    if ( $padding <= 0 ) {
                         $padding = 1;
                     }
 
-                    if ($padding > $this->maxPadding) {
+                    if ( $padding > $this->maxPadding ) {
                         $stopped = $assign;
                         break;
                     }
 
-                    $assignColumn = ($varEnd + $padding);
+                    $assignColumn = ( $varEnd + $padding );
                 }//end if
 
-                if (($assignColumn + $assignLen) > ($assignments[$maxPadding]['assign_col'] + $assignments[$maxPadding]['assign_len'])) {
-                    $newPadding = ($varEnd - $assignments[$maxPadding]['var_end'] + $assignLen - $assignments[$maxPadding]['assign_len'] + 1);
-                    if ($newPadding > $this->maxPadding) {
+                if ( ( $assignColumn + $assignLen ) > ( $assignments[ $maxPadding ][ 'assign_col' ] + $assignments[ $maxPadding ][ 'assign_len' ] ) ) {
+                    $newPadding = ( $varEnd - $assignments[ $maxPadding ][ 'var_end' ] + $assignLen - $assignments[ $maxPadding ][ 'assign_len' ] + 1 );
+                    if ( $newPadding > $this->maxPadding ) {
                         $stopped = $assign;
                         break;
                     } else {
                         // New alignment settings for previous assignments.
-                        foreach ($assignments as $i => $data) {
-                            if ($i === $assign) {
+                        foreach ( $assignments as $i => $data ) {
+                            if ( $i === $assign ) {
                                 break;
                             }
 
-                            $newPadding = ($varEnd - $data['var_end'] + $assignLen - $data['assign_len'] + 1);
-                            $assignments[$i]['expected']   = $newPadding;
-                            $assignments[$i]['assign_col'] = ($data['var_end'] + $newPadding);
+                            $newPadding = ( $varEnd - $data[ 'var_end' ] + $assignLen - $data[ 'assign_len' ] + 1 );
+                            $assignments[ $i ][ 'expected' ]   = $newPadding;
+                            $assignments[ $i ][ 'assign_col' ] = ( $data[ 'var_end' ] + $newPadding );
                         }
 
                         $padding      = 1;
-                        $assignColumn = ($varEnd + 1);
+                        $assignColumn = ( $varEnd + 1 );
                     }
-                } else if ($padding > $assignments[$maxPadding]['expected']) {
+                } else if ( $padding > $assignments[ $maxPadding ][ 'expected' ] ) {
                     $maxPadding = $assign;
                 }//end if
             } else {
                 $padding      = 1;
-                $assignColumn = ($varEnd + 1);
+                $assignColumn = ( $varEnd + 1 );
                 $maxPadding   = $assign;
             }//end if
 
             $found = 0;
-            if ($tokens[($var + 1)]['code'] === T_WHITESPACE) {
-                $found = $tokens[($var + 1)]['length'];
-                if ($found === 0) {
+            if ( $tokens[ ( $var + 1 ) ][ 'code' ] === T_WHITESPACE ) {
+                $found = $tokens[ ( $var + 1 ) ][ 'length' ];
+                if ( $found === 0 ) {
                     // This means a newline was found.
                     $found = 1;
                 }
             }
 
-            $assignments[$assign] = [
+            $assignments[ $assign ] = [
                 'var_end'    => $varEnd,
                 'assign_len' => $assignLen,
                 'assign_col' => $assignColumn,
@@ -306,37 +306,37 @@ 
                 'found'      => $found,
             ];
 
-            $lastLine   = $tokens[$assign]['line'];
+            $lastLine   = $tokens[ $assign ][ 'line' ];
             $prevAssign = $assign;
         }//end for
 
-        if (empty($assignments) === true) {
+        if ( empty( $assignments ) === true ) {
             return $stackPtr;
         }
 
-        $numAssignments = count($assignments);
+        $numAssignments = count( $assignments );
 
         $errorGenerated = false;
-        foreach ($assignments as $assignment => $data) {
-            if ($data['found'] === $data['expected']) {
+        foreach ( $assignments as $assignment => $data ) {
+            if ( $data[ 'found' ] === $data[ 'expected' ] ) {
                 continue;
             }
 
-            $expectedText = $data['expected'].' space';
-            if ($data['expected'] !== 1) {
+            $expectedText = $data[ 'expected' ] . ' space';
+            if ( $data[ 'expected' ] !== 1 ) {
                 $expectedText .= 's';
             }
 
-            if ($data['found'] === null) {
+            if ( $data[ 'found' ] === null ) {
                 $foundText = 'a new line';
             } else {
-                $foundText = $data['found'].' space';
-                if ($data['found'] !== 1) {
+                $foundText = $data[ 'found' ] . ' space';
+                if ( $data[ 'found' ] !== 1 ) {
                     $foundText .= 's';
                 }
             }
 
-            if ($numAssignments === 1) {
+            if ( $numAssignments === 1 ) {
                 $type  = 'Incorrect';
                 $error = 'Equals sign not aligned correctly; expected %s but found %s';
             } else {
@@ -349,34 +349,34 @@ 
                 $foundText,
             ];
 
-            if ($this->error === true) {
-                $fix = $phpcsFile->addFixableError($error, $assignment, $type, $errorData);
+            if ( $this->error === true ) {
+                $fix = $phpcsFile->addFixableError( $error, $assignment, $type, $errorData );
             } else {
-                $fix = $phpcsFile->addFixableWarning($error, $assignment, $type.'Warning', $errorData);
+                $fix = $phpcsFile->addFixableWarning( $error, $assignment, $type . 'Warning', $errorData );
             }
 
             $errorGenerated = true;
 
-            if ($fix === true && $data['found'] !== null) {
-                $newContent = str_repeat(' ', $data['expected']);
-                if ($data['found'] === 0) {
-                    $phpcsFile->fixer->addContentBefore($assignment, $newContent);
+            if ( $fix === true && $data[ 'found' ] !== null ) {
+                $newContent = str_repeat( ' ', $data[ 'expected' ] );
+                if ( $data[ 'found' ] === 0 ) {
+                    $phpcsFile->fixer->addContentBefore( $assignment, $newContent );
                 } else {
-                    $phpcsFile->fixer->replaceToken(($assignment - 1), $newContent);
+                    $phpcsFile->fixer->replaceToken( ( $assignment - 1 ), $newContent );
                 }
             }
         }//end foreach
 
-        if ($numAssignments > 1) {
-            if ($errorGenerated === true) {
-                $phpcsFile->recordMetric($stackPtr, 'Adjacent assignments aligned', 'no');
+        if ( $numAssignments > 1 ) {
+            if ( $errorGenerated === true ) {
+                $phpcsFile->recordMetric( $stackPtr, 'Adjacent assignments aligned', 'no' );
             } else {
-                $phpcsFile->recordMetric($stackPtr, 'Adjacent assignments aligned', 'yes');
+                $phpcsFile->recordMetric( $stackPtr, 'Adjacent assignments aligned', 'yes' );
             }
         }
 
-        if ($stopped !== null) {
-            return $this->checkAlignment($phpcsFile, $stopped);
+        if ( $stopped !== null ) {
+            return $this->checkAlignment( $phpcsFile, $stopped );
         } else {
             return $assign;
         }

Braces +4 added lines, -8 removed lines

@@ -16,8 +16,7 @@ 
 use PHP_CodeSniffer\Files\File;
 use PHP_CodeSniffer\Util\Tokens;
 
-class MultipleStatementAlignmentSniff implements Sniff
-{
+class MultipleStatementAlignmentSniff implements Sniff {
 
     /**
      * A list of tokenizers this sniff supports.
@@ -53,8 +52,7 @@ 
      *
      * @return array
      */
-    public function register()
-    {
+    public function register() {
         $tokens = Tokens::$assignmentTokens;
         unset($tokens[T_DOUBLE_ARROW]);
         return $tokens;
@@ -71,8 +69,7 @@ 
      *
      * @return int
      */
-    public function process(File $phpcsFile, $stackPtr)
-    {
+    public function process(File $phpcsFile, $stackPtr) {
         $tokens = $phpcsFile->getTokens();
 
         // Ignore assignments used in a condition, like an IF or FOR.
@@ -101,8 +98,7 @@ 
      *
      * @return int
      */
-    public function checkAlignment($phpcsFile, $stackPtr, $end=null)
-    {
+    public function checkAlignment($phpcsFile, $stackPtr, $end=null) {
         $tokens = $phpcsFile->getTokens();
 
         $assignments = [];

vendor/squizlabs/php_codesniffer/src/Standards/Generic/Sniffs/PHP/ClosingPHPTagSniff.php

Indentation +30 added lines, -30 removed lines

@@ -16,36 +16,36 @@
 {
 
 
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        return [T_OPEN_TAG];
-
-    }//end register()
-
-
-    /**
-     * Processes this sniff, when one of its tokens is encountered.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
-     * @param int                         $stackPtr  The position of the current token in
-     *                                               the stack passed in $tokens.
-     *
-     * @return void
-     */
-    public function process(File $phpcsFile, $stackPtr)
-    {
-        $closeTag = $phpcsFile->findNext(T_CLOSE_TAG, $stackPtr);
-        if ($closeTag === false) {
-            $error = 'The PHP open tag does not have a corresponding PHP close tag';
-            $phpcsFile->addError($error, $stackPtr, 'NotFound');
-        }
-
-    }//end process()
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		return [T_OPEN_TAG];
+
+	}//end register()
+
+
+	/**
+	 * Processes this sniff, when one of its tokens is encountered.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
+	 * @param int                         $stackPtr  The position of the current token in
+	 *                                               the stack passed in $tokens.
+	 *
+	 * @return void
+	 */
+	public function process(File $phpcsFile, $stackPtr)
+	{
+		$closeTag = $phpcsFile->findNext(T_CLOSE_TAG, $stackPtr);
+		if ($closeTag === false) {
+			$error = 'The PHP open tag does not have a corresponding PHP close tag';
+			$phpcsFile->addError($error, $stackPtr, 'NotFound');
+		}
+
+	}//end process()
 
 
 }//end class

Spacing +5 added lines, -5 removed lines

@@ -23,7 +23,7 @@ 
      */
     public function register()
     {
-        return [T_OPEN_TAG];
+        return [ T_OPEN_TAG ];
 
     }//end register()
 
@@ -37,12 +37,12 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
+    public function process( File $phpcsFile, $stackPtr )
     {
-        $closeTag = $phpcsFile->findNext(T_CLOSE_TAG, $stackPtr);
-        if ($closeTag === false) {
+        $closeTag = $phpcsFile->findNext( T_CLOSE_TAG, $stackPtr );
+        if ( $closeTag === false ) {
             $error = 'The PHP open tag does not have a corresponding PHP close tag';
-            $phpcsFile->addError($error, $stackPtr, 'NotFound');
+            $phpcsFile->addError( $error, $stackPtr, 'NotFound' );
         }
 
     }//end process()

Braces +3 added lines, -6 removed lines

@@ -12,8 +12,7 @@ 
 use PHP_CodeSniffer\Sniffs\Sniff;
 use PHP_CodeSniffer\Files\File;
 
-class ClosingPHPTagSniff implements Sniff
-{
+class ClosingPHPTagSniff implements Sniff {
 
 
     /**
@@ -21,8 +20,7 @@ 
      *
      * @return array
      */
-    public function register()
-    {
+    public function register() {
         return [T_OPEN_TAG];
 
     }//end register()
@@ -37,8 +35,7 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
-    {
+    public function process(File $phpcsFile, $stackPtr) {
         $closeTag = $phpcsFile->findNext(T_CLOSE_TAG, $stackPtr);
         if ($closeTag === false) {
             $error = 'The PHP open tag does not have a corresponding PHP close tag';

vendor/squizlabs/php_codesniffer/src/Standards/Generic/Sniffs/PHP/CharacterBeforePHPOpeningTagSniff.php

Indentation +58 added lines, -58 removed lines

@@ -15,73 +15,73 @@
 class CharacterBeforePHPOpeningTagSniff implements Sniff
 {
 
-    /**
-     * List of supported BOM definitions.
-     *
-     * Use encoding names as keys and hex BOM representations as values.
-     *
-     * @var array
-     */
-    protected $bomDefinitions = [
-        'UTF-8'       => 'efbbbf',
-        'UTF-16 (BE)' => 'feff',
-        'UTF-16 (LE)' => 'fffe',
-    ];
+	/**
+	 * List of supported BOM definitions.
+	 *
+	 * Use encoding names as keys and hex BOM representations as values.
+	 *
+	 * @var array
+	 */
+	protected $bomDefinitions = [
+		'UTF-8'       => 'efbbbf',
+		'UTF-16 (BE)' => 'feff',
+		'UTF-16 (LE)' => 'fffe',
+	];
 
 
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        return [T_OPEN_TAG];
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		return [T_OPEN_TAG];
 
-    }//end register()
+	}//end register()
 
 
-    /**
-     * Processes this sniff, when one of its tokens is encountered.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
-     * @param int                         $stackPtr  The position of the current token in
-     *                                               the stack passed in $tokens.
-     *
-     * @return void
-     */
-    public function process(File $phpcsFile, $stackPtr)
-    {
-        $expected = 0;
-        if ($stackPtr > 0) {
-            // Allow a byte-order mark.
-            $tokens = $phpcsFile->getTokens();
-            foreach ($this->bomDefinitions as $bomName => $expectedBomHex) {
-                $bomByteLength = (strlen($expectedBomHex) / 2);
-                $htmlBomHex    = bin2hex(substr($tokens[0]['content'], 0, $bomByteLength));
-                if ($htmlBomHex === $expectedBomHex) {
-                    $expected++;
-                    break;
-                }
-            }
+	/**
+	 * Processes this sniff, when one of its tokens is encountered.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
+	 * @param int                         $stackPtr  The position of the current token in
+	 *                                               the stack passed in $tokens.
+	 *
+	 * @return void
+	 */
+	public function process(File $phpcsFile, $stackPtr)
+	{
+		$expected = 0;
+		if ($stackPtr > 0) {
+			// Allow a byte-order mark.
+			$tokens = $phpcsFile->getTokens();
+			foreach ($this->bomDefinitions as $bomName => $expectedBomHex) {
+				$bomByteLength = (strlen($expectedBomHex) / 2);
+				$htmlBomHex    = bin2hex(substr($tokens[0]['content'], 0, $bomByteLength));
+				if ($htmlBomHex === $expectedBomHex) {
+					$expected++;
+					break;
+				}
+			}
 
-            // Allow a shebang line.
-            $tokens = $phpcsFile->getTokens();
-            if (substr($tokens[0]['content'], 0, 2) === '#!') {
-                $expected++;
-            }
-        }
+			// Allow a shebang line.
+			$tokens = $phpcsFile->getTokens();
+			if (substr($tokens[0]['content'], 0, 2) === '#!') {
+				$expected++;
+			}
+		}
 
-        if ($stackPtr !== $expected) {
-            $error = 'The opening PHP tag must be the first content in the file';
-            $phpcsFile->addError($error, $stackPtr, 'Found');
-        }
+		if ($stackPtr !== $expected) {
+			$error = 'The opening PHP tag must be the first content in the file';
+			$phpcsFile->addError($error, $stackPtr, 'Found');
+		}
 
-        // Skip the rest of the file so we don't pick up additional
-        // open tags, typically embedded in HTML.
-        return $phpcsFile->numTokens;
+		// Skip the rest of the file so we don't pick up additional
+		// open tags, typically embedded in HTML.
+		return $phpcsFile->numTokens;
 
-    }//end process()
+	}//end process()
 
 
 }//end class

Spacing +10 added lines, -10 removed lines

@@ -36,7 +36,7 @@ 
      */
     public function register()
     {
-        return [T_OPEN_TAG];
+        return [ T_OPEN_TAG ];
 
     }//end register()
 
@@ -50,16 +50,16 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
+    public function process( File $phpcsFile, $stackPtr )
     {
         $expected = 0;
-        if ($stackPtr > 0) {
+        if ( $stackPtr > 0 ) {
             // Allow a byte-order mark.
             $tokens = $phpcsFile->getTokens();
-            foreach ($this->bomDefinitions as $bomName => $expectedBomHex) {
-                $bomByteLength = (strlen($expectedBomHex) / 2);
-                $htmlBomHex    = bin2hex(substr($tokens[0]['content'], 0, $bomByteLength));
-                if ($htmlBomHex === $expectedBomHex) {
+            foreach ( $this->bomDefinitions as $bomName => $expectedBomHex ) {
+                $bomByteLength = ( strlen( $expectedBomHex ) / 2 );
+                $htmlBomHex    = bin2hex( substr( $tokens[ 0 ][ 'content' ], 0, $bomByteLength ) );
+                if ( $htmlBomHex === $expectedBomHex ) {
                     $expected++;
                     break;
                 }
@@ -67,14 +67,14 @@ 
 
             // Allow a shebang line.
             $tokens = $phpcsFile->getTokens();
-            if (substr($tokens[0]['content'], 0, 2) === '#!') {
+            if ( substr( $tokens[ 0 ][ 'content' ], 0, 2 ) === '#!' ) {
                 $expected++;
             }
         }
 
-        if ($stackPtr !== $expected) {
+        if ( $stackPtr !== $expected ) {
             $error = 'The opening PHP tag must be the first content in the file';
-            $phpcsFile->addError($error, $stackPtr, 'Found');
+            $phpcsFile->addError( $error, $stackPtr, 'Found' );
         }
 
         // Skip the rest of the file so we don't pick up additional

Braces +3 added lines, -6 removed lines

@@ -12,8 +12,7 @@ 
 use PHP_CodeSniffer\Sniffs\Sniff;
 use PHP_CodeSniffer\Files\File;
 
-class CharacterBeforePHPOpeningTagSniff implements Sniff
-{
+class CharacterBeforePHPOpeningTagSniff implements Sniff {
 
     /**
      * List of supported BOM definitions.
@@ -34,8 +33,7 @@ 
      *
      * @return array
      */
-    public function register()
-    {
+    public function register() {
         return [T_OPEN_TAG];
 
     }//end register()
@@ -50,8 +48,7 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
-    {
+    public function process(File $phpcsFile, $stackPtr) {
         $expected = 0;
         if ($stackPtr > 0) {
             // Allow a byte-order mark.

vendor/squizlabs/php_codesniffer/src/Standards/Generic/Sniffs/PHP/LowerCaseKeywordSniff.php

Indentation +113 added lines, -113 removed lines

@@ -17,126 +17,126 @@
 {
 
 
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        return [
-            T_HALT_COMPILER,
-            T_ABSTRACT,
-            T_ARRAY,
-            T_AS,
-            T_BREAK,
-            T_CALLABLE,
-            T_CASE,
-            T_CATCH,
-            T_CLASS,
-            T_CLONE,
-            T_CLOSURE,
-            T_CONST,
-            T_CONTINUE,
-            T_DECLARE,
-            T_DEFAULT,
-            T_DO,
-            T_ECHO,
-            T_ELSE,
-            T_ELSEIF,
-            T_EMPTY,
-            T_ENDDECLARE,
-            T_ENDFOR,
-            T_ENDFOREACH,
-            T_ENDIF,
-            T_ENDSWITCH,
-            T_ENDWHILE,
-            T_EVAL,
-            T_EXIT,
-            T_EXTENDS,
-            T_FINAL,
-            T_FINALLY,
-            T_FOR,
-            T_FOREACH,
-            T_FUNCTION,
-            T_GLOBAL,
-            T_GOTO,
-            T_IF,
-            T_IMPLEMENTS,
-            T_INCLUDE,
-            T_INCLUDE_ONCE,
-            T_INSTANCEOF,
-            T_INSTEADOF,
-            T_INTERFACE,
-            T_ISSET,
-            T_LIST,
-            T_LOGICAL_AND,
-            T_LOGICAL_OR,
-            T_LOGICAL_XOR,
-            T_NAMESPACE,
-            T_NEW,
-            T_PARENT,
-            T_PRINT,
-            T_PRIVATE,
-            T_PROTECTED,
-            T_PUBLIC,
-            T_REQUIRE,
-            T_REQUIRE_ONCE,
-            T_RETURN,
-            T_SELF,
-            T_STATIC,
-            T_SWITCH,
-            T_THROW,
-            T_TRAIT,
-            T_TRY,
-            T_UNSET,
-            T_USE,
-            T_VAR,
-            T_WHILE,
-            T_YIELD,
-            T_YIELD_FROM,
-        ];
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		return [
+			T_HALT_COMPILER,
+			T_ABSTRACT,
+			T_ARRAY,
+			T_AS,
+			T_BREAK,
+			T_CALLABLE,
+			T_CASE,
+			T_CATCH,
+			T_CLASS,
+			T_CLONE,
+			T_CLOSURE,
+			T_CONST,
+			T_CONTINUE,
+			T_DECLARE,
+			T_DEFAULT,
+			T_DO,
+			T_ECHO,
+			T_ELSE,
+			T_ELSEIF,
+			T_EMPTY,
+			T_ENDDECLARE,
+			T_ENDFOR,
+			T_ENDFOREACH,
+			T_ENDIF,
+			T_ENDSWITCH,
+			T_ENDWHILE,
+			T_EVAL,
+			T_EXIT,
+			T_EXTENDS,
+			T_FINAL,
+			T_FINALLY,
+			T_FOR,
+			T_FOREACH,
+			T_FUNCTION,
+			T_GLOBAL,
+			T_GOTO,
+			T_IF,
+			T_IMPLEMENTS,
+			T_INCLUDE,
+			T_INCLUDE_ONCE,
+			T_INSTANCEOF,
+			T_INSTEADOF,
+			T_INTERFACE,
+			T_ISSET,
+			T_LIST,
+			T_LOGICAL_AND,
+			T_LOGICAL_OR,
+			T_LOGICAL_XOR,
+			T_NAMESPACE,
+			T_NEW,
+			T_PARENT,
+			T_PRINT,
+			T_PRIVATE,
+			T_PROTECTED,
+			T_PUBLIC,
+			T_REQUIRE,
+			T_REQUIRE_ONCE,
+			T_RETURN,
+			T_SELF,
+			T_STATIC,
+			T_SWITCH,
+			T_THROW,
+			T_TRAIT,
+			T_TRY,
+			T_UNSET,
+			T_USE,
+			T_VAR,
+			T_WHILE,
+			T_YIELD,
+			T_YIELD_FROM,
+		];
 
-    }//end register()
+	}//end register()
 
 
-    /**
-     * Processes this sniff, when one of its tokens is encountered.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
-     * @param int                         $stackPtr  The position of the current token in the
-     *                                               stack passed in $tokens.
-     *
-     * @return void
-     */
-    public function process(File $phpcsFile, $stackPtr)
-    {
-        $tokens  = $phpcsFile->getTokens();
-        $keyword = $tokens[$stackPtr]['content'];
-        if (strtolower($keyword) !== $keyword) {
-            if ($keyword === strtoupper($keyword)) {
-                $phpcsFile->recordMetric($stackPtr, 'PHP keyword case', 'upper');
-            } else {
-                $phpcsFile->recordMetric($stackPtr, 'PHP keyword case', 'mixed');
-            }
+	/**
+	 * Processes this sniff, when one of its tokens is encountered.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
+	 * @param int                         $stackPtr  The position of the current token in the
+	 *                                               stack passed in $tokens.
+	 *
+	 * @return void
+	 */
+	public function process(File $phpcsFile, $stackPtr)
+	{
+		$tokens  = $phpcsFile->getTokens();
+		$keyword = $tokens[$stackPtr]['content'];
+		if (strtolower($keyword) !== $keyword) {
+			if ($keyword === strtoupper($keyword)) {
+				$phpcsFile->recordMetric($stackPtr, 'PHP keyword case', 'upper');
+			} else {
+				$phpcsFile->recordMetric($stackPtr, 'PHP keyword case', 'mixed');
+			}
 
-            $messageKeyword = Util\Common::prepareForOutput($keyword);
+			$messageKeyword = Util\Common::prepareForOutput($keyword);
 
-            $error = 'PHP keywords must be lowercase; expected "%s" but found "%s"';
-            $data  = [
-                strtolower($messageKeyword),
-                $messageKeyword,
-            ];
+			$error = 'PHP keywords must be lowercase; expected "%s" but found "%s"';
+			$data  = [
+				strtolower($messageKeyword),
+				$messageKeyword,
+			];
 
-            $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Found', $data);
-            if ($fix === true) {
-                $phpcsFile->fixer->replaceToken($stackPtr, strtolower($keyword));
-            }
-        } else {
-            $phpcsFile->recordMetric($stackPtr, 'PHP keyword case', 'lower');
-        }//end if
+			$fix = $phpcsFile->addFixableError($error, $stackPtr, 'Found', $data);
+			if ($fix === true) {
+				$phpcsFile->fixer->replaceToken($stackPtr, strtolower($keyword));
+			}
+		} else {
+			$phpcsFile->recordMetric($stackPtr, 'PHP keyword case', 'lower');
+		}//end if
 
-    }//end process()
+	}//end process()
 
 
 }//end class

Spacing +12 added lines, -12 removed lines

@@ -109,31 +109,31 @@
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
+    public function process( File $phpcsFile, $stackPtr )
     {
         $tokens  = $phpcsFile->getTokens();
-        $keyword = $tokens[$stackPtr]['content'];
-        if (strtolower($keyword) !== $keyword) {
-            if ($keyword === strtoupper($keyword)) {
-                $phpcsFile->recordMetric($stackPtr, 'PHP keyword case', 'upper');
+        $keyword = $tokens[ $stackPtr ][ 'content' ];
+        if ( strtolower( $keyword ) !== $keyword ) {
+            if ( $keyword === strtoupper( $keyword ) ) {
+                $phpcsFile->recordMetric( $stackPtr, 'PHP keyword case', 'upper' );
             } else {
-                $phpcsFile->recordMetric($stackPtr, 'PHP keyword case', 'mixed');
+                $phpcsFile->recordMetric( $stackPtr, 'PHP keyword case', 'mixed' );
             }
 
-            $messageKeyword = Util\Common::prepareForOutput($keyword);
+            $messageKeyword = Util\Common::prepareForOutput( $keyword );
 
             $error = 'PHP keywords must be lowercase; expected "%s" but found "%s"';
             $data  = [
-                strtolower($messageKeyword),
+                strtolower( $messageKeyword ),
                 $messageKeyword,
             ];
 
-            $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Found', $data);
-            if ($fix === true) {
-                $phpcsFile->fixer->replaceToken($stackPtr, strtolower($keyword));
+            $fix = $phpcsFile->addFixableError( $error, $stackPtr, 'Found', $data );
+            if ( $fix === true ) {
+                $phpcsFile->fixer->replaceToken( $stackPtr, strtolower( $keyword ) );
             }
         } else {
-            $phpcsFile->recordMetric($stackPtr, 'PHP keyword case', 'lower');
+            $phpcsFile->recordMetric( $stackPtr, 'PHP keyword case', 'lower' );
         }//end if
 
     }//end process()

Braces +3 added lines, -6 removed lines

@@ -13,8 +13,7 @@ 
 use PHP_CodeSniffer\Files\File;
 use PHP_CodeSniffer\Util;
 
-class LowerCaseKeywordSniff implements Sniff
-{
+class LowerCaseKeywordSniff implements Sniff {
 
 
     /**
@@ -22,8 +21,7 @@ 
      *
      * @return array
      */
-    public function register()
-    {
+    public function register() {
         return [
             T_HALT_COMPILER,
             T_ABSTRACT,
@@ -109,8 +107,7 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
-    {
+    public function process(File $phpcsFile, $stackPtr) {
         $tokens  = $phpcsFile->getTokens();
         $keyword = $tokens[$stackPtr]['content'];
         if (strtolower($keyword) !== $keyword) {

vendor/squizlabs/php_codesniffer/src/Standards/Generic/Sniffs/PHP/UpperCaseConstantSniff.php

Indentation +46 added lines, -46 removed lines

@@ -16,58 +16,58 @@
 {
 
 
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        return [
-            T_TRUE,
-            T_FALSE,
-            T_NULL,
-        ];
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		return [
+			T_TRUE,
+			T_FALSE,
+			T_NULL,
+		];
 
-    }//end register()
+	}//end register()
 
 
-    /**
-     * Processes this sniff, when one of its tokens is encountered.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
-     * @param int                         $stackPtr  The position of the current token in the
-     *                                               stack passed in $tokens.
-     *
-     * @return void
-     */
-    public function process(File $phpcsFile, $stackPtr)
-    {
-        $tokens   = $phpcsFile->getTokens();
-        $keyword  = $tokens[$stackPtr]['content'];
-        $expected = strtoupper($keyword);
-        if ($keyword !== $expected) {
-            if ($keyword === strtolower($keyword)) {
-                $phpcsFile->recordMetric($stackPtr, 'PHP constant case', 'lower');
-            } else {
-                $phpcsFile->recordMetric($stackPtr, 'PHP constant case', 'mixed');
-            }
+	/**
+	 * Processes this sniff, when one of its tokens is encountered.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
+	 * @param int                         $stackPtr  The position of the current token in the
+	 *                                               stack passed in $tokens.
+	 *
+	 * @return void
+	 */
+	public function process(File $phpcsFile, $stackPtr)
+	{
+		$tokens   = $phpcsFile->getTokens();
+		$keyword  = $tokens[$stackPtr]['content'];
+		$expected = strtoupper($keyword);
+		if ($keyword !== $expected) {
+			if ($keyword === strtolower($keyword)) {
+				$phpcsFile->recordMetric($stackPtr, 'PHP constant case', 'lower');
+			} else {
+				$phpcsFile->recordMetric($stackPtr, 'PHP constant case', 'mixed');
+			}
 
-            $error = 'TRUE, FALSE and NULL must be uppercase; expected "%s" but found "%s"';
-            $data  = [
-                $expected,
-                $keyword,
-            ];
+			$error = 'TRUE, FALSE and NULL must be uppercase; expected "%s" but found "%s"';
+			$data  = [
+				$expected,
+				$keyword,
+			];
 
-            $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Found', $data);
-            if ($fix === true) {
-                $phpcsFile->fixer->replaceToken($stackPtr, $expected);
-            }
-        } else {
-            $phpcsFile->recordMetric($stackPtr, 'PHP constant case', 'upper');
-        }
+			$fix = $phpcsFile->addFixableError($error, $stackPtr, 'Found', $data);
+			if ($fix === true) {
+				$phpcsFile->fixer->replaceToken($stackPtr, $expected);
+			}
+		} else {
+			$phpcsFile->recordMetric($stackPtr, 'PHP constant case', 'upper');
+		}
 
-    }//end process()
+	}//end process()
 
 
 }//end class

Spacing +11 added lines, -11 removed lines

@@ -41,16 +41,16 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
+    public function process( File $phpcsFile, $stackPtr )
     {
         $tokens   = $phpcsFile->getTokens();
-        $keyword  = $tokens[$stackPtr]['content'];
-        $expected = strtoupper($keyword);
-        if ($keyword !== $expected) {
-            if ($keyword === strtolower($keyword)) {
-                $phpcsFile->recordMetric($stackPtr, 'PHP constant case', 'lower');
+        $keyword  = $tokens[ $stackPtr ][ 'content' ];
+        $expected = strtoupper( $keyword );
+        if ( $keyword !== $expected ) {
+            if ( $keyword === strtolower( $keyword ) ) {
+                $phpcsFile->recordMetric( $stackPtr, 'PHP constant case', 'lower' );
             } else {
-                $phpcsFile->recordMetric($stackPtr, 'PHP constant case', 'mixed');
+                $phpcsFile->recordMetric( $stackPtr, 'PHP constant case', 'mixed' );
             }
 
             $error = 'TRUE, FALSE and NULL must be uppercase; expected "%s" but found "%s"';
@@ -59,12 +59,12 @@ 
                 $keyword,
             ];
 
-            $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Found', $data);
-            if ($fix === true) {
-                $phpcsFile->fixer->replaceToken($stackPtr, $expected);
+            $fix = $phpcsFile->addFixableError( $error, $stackPtr, 'Found', $data );
+            if ( $fix === true ) {
+                $phpcsFile->fixer->replaceToken( $stackPtr, $expected );
             }
         } else {
-            $phpcsFile->recordMetric($stackPtr, 'PHP constant case', 'upper');
+            $phpcsFile->recordMetric( $stackPtr, 'PHP constant case', 'upper' );
         }
 
     }//end process()

Braces +3 added lines, -6 removed lines

@@ -12,8 +12,7 @@ 
 use PHP_CodeSniffer\Sniffs\Sniff;
 use PHP_CodeSniffer\Files\File;
 
-class UpperCaseConstantSniff implements Sniff
-{
+class UpperCaseConstantSniff implements Sniff {
 
 
     /**
@@ -21,8 +20,7 @@ 
      *
      * @return array
      */
-    public function register()
-    {
+    public function register() {
         return [
             T_TRUE,
             T_FALSE,
@@ -41,8 +39,7 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
-    {
+    public function process(File $phpcsFile, $stackPtr) {
         $tokens   = $phpcsFile->getTokens();
         $keyword  = $tokens[$stackPtr]['content'];
         $expected = strtoupper($keyword);

vendor/squizlabs/php_codesniffer/src/Standards/Generic/Sniffs/PHP/SyntaxSniff.php

Indentation +41 added lines, -41 removed lines

@@ -17,55 +17,55 @@
 class SyntaxSniff implements Sniff
 {
 
-    /**
-     * The path to the PHP version we are checking with.
-     *
-     * @var string
-     */
-    private $phpPath = null;
+	/**
+	 * The path to the PHP version we are checking with.
+	 *
+	 * @var string
+	 */
+	private $phpPath = null;
 
 
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        return [T_OPEN_TAG];
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		return [T_OPEN_TAG];
 
-    }//end register()
+	}//end register()
 
 
-    /**
-     * Processes this test, when one of its tokens is encountered.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
-     * @param int                         $stackPtr  The position of the current token in
-     *                                               the stack passed in $tokens.
-     *
-     * @return void
-     */
-    public function process(File $phpcsFile, $stackPtr)
-    {
-        if ($this->phpPath === null) {
-            $this->phpPath = Config::getExecutablePath('php');
-        }
+	/**
+	 * Processes this test, when one of its tokens is encountered.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
+	 * @param int                         $stackPtr  The position of the current token in
+	 *                                               the stack passed in $tokens.
+	 *
+	 * @return void
+	 */
+	public function process(File $phpcsFile, $stackPtr)
+	{
+		if ($this->phpPath === null) {
+			$this->phpPath = Config::getExecutablePath('php');
+		}
 
-        $fileName = escapeshellarg($phpcsFile->getFilename());
-        $cmd      = escapeshellcmd($this->phpPath)." -l -d display_errors=1 -d error_prepend_string='' $fileName 2>&1";
-        $output   = shell_exec($cmd);
-        $matches  = [];
-        if (preg_match('/^.*error:(.*) in .* on line ([0-9]+)/m', trim($output), $matches) === 1) {
-            $error = trim($matches[1]);
-            $line  = (int) $matches[2];
-            $phpcsFile->addErrorOnLine("PHP syntax error: $error", $line, 'PHPSyntax');
-        }
+		$fileName = escapeshellarg($phpcsFile->getFilename());
+		$cmd      = escapeshellcmd($this->phpPath)." -l -d display_errors=1 -d error_prepend_string='' $fileName 2>&1";
+		$output   = shell_exec($cmd);
+		$matches  = [];
+		if (preg_match('/^.*error:(.*) in .* on line ([0-9]+)/m', trim($output), $matches) === 1) {
+			$error = trim($matches[1]);
+			$line  = (int) $matches[2];
+			$phpcsFile->addErrorOnLine("PHP syntax error: $error", $line, 'PHPSyntax');
+		}
 
-        // Ignore the rest of the file.
-        return ($phpcsFile->numTokens + 1);
+		// Ignore the rest of the file.
+		return ($phpcsFile->numTokens + 1);
 
-    }//end process()
+	}//end process()
 
 
 }//end class

Spacing +13 added lines, -13 removed lines

@@ -32,7 +32,7 @@ 
      */
     public function register()
     {
-        return [T_OPEN_TAG];
+        return [ T_OPEN_TAG ];
 
     }//end register()
 
@@ -46,24 +46,24 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
+    public function process( File $phpcsFile, $stackPtr )
     {
-        if ($this->phpPath === null) {
-            $this->phpPath = Config::getExecutablePath('php');
+        if ( $this->phpPath === null ) {
+            $this->phpPath = Config::getExecutablePath( 'php' );
         }
 
-        $fileName = escapeshellarg($phpcsFile->getFilename());
-        $cmd      = escapeshellcmd($this->phpPath)." -l -d display_errors=1 -d error_prepend_string='' $fileName 2>&1";
-        $output   = shell_exec($cmd);
-        $matches  = [];
-        if (preg_match('/^.*error:(.*) in .* on line ([0-9]+)/m', trim($output), $matches) === 1) {
-            $error = trim($matches[1]);
-            $line  = (int) $matches[2];
-            $phpcsFile->addErrorOnLine("PHP syntax error: $error", $line, 'PHPSyntax');
+        $fileName = escapeshellarg( $phpcsFile->getFilename() );
+        $cmd      = escapeshellcmd( $this->phpPath ) . " -l -d display_errors=1 -d error_prepend_string='' $fileName 2>&1";
+        $output   = shell_exec( $cmd );
+        $matches  = [ ];
+        if ( preg_match( '/^.*error:(.*) in .* on line ([0-9]+)/m', trim( $output ), $matches ) === 1 ) {
+            $error = trim( $matches[ 1 ] );
+            $line  = (int)$matches[ 2 ];
+            $phpcsFile->addErrorOnLine( "PHP syntax error: $error", $line, 'PHPSyntax' );
         }
 
         // Ignore the rest of the file.
-        return ($phpcsFile->numTokens + 1);
+        return ( $phpcsFile->numTokens + 1 );
 
     }//end process()
 

Braces +3 added lines, -6 removed lines

@@ -14,8 +14,7 @@ 
 use PHP_CodeSniffer\Files\File;
 use PHP_CodeSniffer\Config;
 
-class SyntaxSniff implements Sniff
-{
+class SyntaxSniff implements Sniff {
 
     /**
      * The path to the PHP version we are checking with.
@@ -30,8 +29,7 @@ 
      *
      * @return array
      */
-    public function register()
-    {
+    public function register() {
         return [T_OPEN_TAG];
 
     }//end register()
@@ -46,8 +44,7 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
-    {
+    public function process(File $phpcsFile, $stackPtr) {
         if ($this->phpPath === null) {
             $this->phpPath = Config::getExecutablePath('php');
         }

vendor/squizlabs/php_codesniffer/src/Standards/Generic/Sniffs/PHP/DisallowShortOpenTagSniff.php

Indentation +146 added lines, -146 removed lines

@@ -17,152 +17,152 @@
 {
 
 
-    /**
-     * Returns an array of tokens this test wants to listen for.
-     *
-     * @return array
-     */
-    public function register()
-    {
-        $targets = [
-            T_OPEN_TAG,
-            T_OPEN_TAG_WITH_ECHO,
-        ];
-
-        $shortOpenTags = (bool) ini_get('short_open_tag');
-        if ($shortOpenTags === false) {
-            $targets[] = T_INLINE_HTML;
-        }
-
-        return $targets;
-
-    }//end register()
-
-
-    /**
-     * Processes this test, when one of its tokens is encountered.
-     *
-     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
-     * @param int                         $stackPtr  The position of the current token
-     *                                               in the stack passed in $tokens.
-     *
-     * @return void
-     */
-    public function process(File $phpcsFile, $stackPtr)
-    {
-        $tokens = $phpcsFile->getTokens();
-        $token  = $tokens[$stackPtr];
-
-        if ($token['code'] === T_OPEN_TAG && $token['content'] === '<?') {
-            $error = 'Short PHP opening tag used; expected "<?php" but found "%s"';
-            $data  = [$token['content']];
-            $fix   = $phpcsFile->addFixableError($error, $stackPtr, 'Found', $data);
-            if ($fix === true) {
-                $correctOpening = '<?php';
-                if (isset($tokens[($stackPtr + 1)]) === true && $tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) {
-                    // Avoid creation of invalid open tags like <?phpecho if the original was <?echo .
-                    $correctOpening .= ' ';
-                }
-
-                $phpcsFile->fixer->replaceToken($stackPtr, $correctOpening);
-            }
-
-            $phpcsFile->recordMetric($stackPtr, 'PHP short open tag used', 'yes');
-        } else {
-            $phpcsFile->recordMetric($stackPtr, 'PHP short open tag used', 'no');
-        }
-
-        if ($token['code'] === T_OPEN_TAG_WITH_ECHO) {
-            $nextVar = $tokens[$phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true)];
-            $error   = 'Short PHP opening tag used with echo; expected "<?php echo %s ..." but found "%s %s ..."';
-            $data    = [
-                $nextVar['content'],
-                $token['content'],
-                $nextVar['content'],
-            ];
-            $fix     = $phpcsFile->addFixableError($error, $stackPtr, 'EchoFound', $data);
-            if ($fix === true) {
-                if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) {
-                    $phpcsFile->fixer->replaceToken($stackPtr, '<?php echo ');
-                } else {
-                    $phpcsFile->fixer->replaceToken($stackPtr, '<?php echo');
-                }
-            }
-        }
-
-        if ($token['code'] === T_INLINE_HTML) {
-            $content     = $token['content'];
-            $openerFound = strpos($content, '<?');
-
-            if ($openerFound === false) {
-                return;
-            }
-
-            $closerFound = false;
-
-            // Inspect current token and subsequent inline HTML token to find a close tag.
-            for ($i = $stackPtr; $i < $phpcsFile->numTokens; $i++) {
-                if ($tokens[$i]['code'] !== T_INLINE_HTML) {
-                    break;
-                }
-
-                $closerFound = strrpos($tokens[$i]['content'], '?>');
-                if ($closerFound !== false) {
-                    if ($i !== $stackPtr) {
-                        break;
-                    } else if ($closerFound > $openerFound) {
-                        break;
-                    } else {
-                        $closerFound = false;
-                    }
-                }
-            }
-
-            if ($closerFound !== false) {
-                $error   = 'Possible use of short open tags detected; found: %s';
-                $snippet = $this->getSnippet($content, '<?');
-                $data    = ['<?'.$snippet];
-
-                $phpcsFile->addWarning($error, $stackPtr, 'PossibleFound', $data);
-
-                // Skip forward to the token containing the closer.
-                if (($i - 1) > $stackPtr) {
-                    return $i;
-                }
-            }
-        }//end if
-
-    }//end process()
-
-
-    /**
-     * Get a snippet from a HTML token.
-     *
-     * @param string $content The content of the HTML token.
-     * @param string $start   Partial string to use as a starting point for the snippet.
-     * @param int    $length  The target length of the snippet to get. Defaults to 40.
-     *
-     * @return string
-     */
-    protected function getSnippet($content, $start='', $length=40)
-    {
-        $startPos = 0;
-
-        if ($start !== '') {
-            $startPos = strpos($content, $start);
-            if ($startPos !== false) {
-                $startPos += strlen($start);
-            }
-        }
-
-        $snippet = substr($content, $startPos, $length);
-        if ((strlen($content) - $startPos) > $length) {
-            $snippet .= '...';
-        }
-
-        return $snippet;
-
-    }//end getSnippet()
+	/**
+	 * Returns an array of tokens this test wants to listen for.
+	 *
+	 * @return array
+	 */
+	public function register()
+	{
+		$targets = [
+			T_OPEN_TAG,
+			T_OPEN_TAG_WITH_ECHO,
+		];
+
+		$shortOpenTags = (bool) ini_get('short_open_tag');
+		if ($shortOpenTags === false) {
+			$targets[] = T_INLINE_HTML;
+		}
+
+		return $targets;
+
+	}//end register()
+
+
+	/**
+	 * Processes this test, when one of its tokens is encountered.
+	 *
+	 * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
+	 * @param int                         $stackPtr  The position of the current token
+	 *                                               in the stack passed in $tokens.
+	 *
+	 * @return void
+	 */
+	public function process(File $phpcsFile, $stackPtr)
+	{
+		$tokens = $phpcsFile->getTokens();
+		$token  = $tokens[$stackPtr];
+
+		if ($token['code'] === T_OPEN_TAG && $token['content'] === '<?') {
+			$error = 'Short PHP opening tag used; expected "<?php" but found "%s"';
+			$data  = [$token['content']];
+			$fix   = $phpcsFile->addFixableError($error, $stackPtr, 'Found', $data);
+			if ($fix === true) {
+				$correctOpening = '<?php';
+				if (isset($tokens[($stackPtr + 1)]) === true && $tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) {
+					// Avoid creation of invalid open tags like <?phpecho if the original was <?echo .
+					$correctOpening .= ' ';
+				}
+
+				$phpcsFile->fixer->replaceToken($stackPtr, $correctOpening);
+			}
+
+			$phpcsFile->recordMetric($stackPtr, 'PHP short open tag used', 'yes');
+		} else {
+			$phpcsFile->recordMetric($stackPtr, 'PHP short open tag used', 'no');
+		}
+
+		if ($token['code'] === T_OPEN_TAG_WITH_ECHO) {
+			$nextVar = $tokens[$phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true)];
+			$error   = 'Short PHP opening tag used with echo; expected "<?php echo %s ..." but found "%s %s ..."';
+			$data    = [
+				$nextVar['content'],
+				$token['content'],
+				$nextVar['content'],
+			];
+			$fix     = $phpcsFile->addFixableError($error, $stackPtr, 'EchoFound', $data);
+			if ($fix === true) {
+				if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) {
+					$phpcsFile->fixer->replaceToken($stackPtr, '<?php echo ');
+				} else {
+					$phpcsFile->fixer->replaceToken($stackPtr, '<?php echo');
+				}
+			}
+		}
+
+		if ($token['code'] === T_INLINE_HTML) {
+			$content     = $token['content'];
+			$openerFound = strpos($content, '<?');
+
+			if ($openerFound === false) {
+				return;
+			}
+
+			$closerFound = false;
+
+			// Inspect current token and subsequent inline HTML token to find a close tag.
+			for ($i = $stackPtr; $i < $phpcsFile->numTokens; $i++) {
+				if ($tokens[$i]['code'] !== T_INLINE_HTML) {
+					break;
+				}
+
+				$closerFound = strrpos($tokens[$i]['content'], '?>');
+				if ($closerFound !== false) {
+					if ($i !== $stackPtr) {
+						break;
+					} else if ($closerFound > $openerFound) {
+						break;
+					} else {
+						$closerFound = false;
+					}
+				}
+			}
+
+			if ($closerFound !== false) {
+				$error   = 'Possible use of short open tags detected; found: %s';
+				$snippet = $this->getSnippet($content, '<?');
+				$data    = ['<?'.$snippet];
+
+				$phpcsFile->addWarning($error, $stackPtr, 'PossibleFound', $data);
+
+				// Skip forward to the token containing the closer.
+				if (($i - 1) > $stackPtr) {
+					return $i;
+				}
+			}
+		}//end if
+
+	}//end process()
+
+
+	/**
+	 * Get a snippet from a HTML token.
+	 *
+	 * @param string $content The content of the HTML token.
+	 * @param string $start   Partial string to use as a starting point for the snippet.
+	 * @param int    $length  The target length of the snippet to get. Defaults to 40.
+	 *
+	 * @return string
+	 */
+	protected function getSnippet($content, $start='', $length=40)
+	{
+		$startPos = 0;
+
+		if ($start !== '') {
+			$startPos = strpos($content, $start);
+			if ($startPos !== false) {
+				$startPos += strlen($start);
+			}
+		}
+
+		$snippet = substr($content, $startPos, $length);
+		if ((strlen($content) - $startPos) > $length) {
+			$snippet .= '...';
+		}
+
+		return $snippet;
+
+	}//end getSnippet()
 
 
 }//end class

Spacing +45 added lines, -45 removed lines

@@ -29,9 +29,9 @@ 
             T_OPEN_TAG_WITH_ECHO,
         ];
 
-        $shortOpenTags = (bool) ini_get('short_open_tag');
-        if ($shortOpenTags === false) {
-            $targets[] = T_INLINE_HTML;
+        $shortOpenTags = (bool)ini_get( 'short_open_tag' );
+        if ( $shortOpenTags === false ) {
+            $targets[ ] = T_INLINE_HTML;
         }
 
         return $targets;
@@ -48,69 +48,69 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
+    public function process( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
-        $token  = $tokens[$stackPtr];
+        $token  = $tokens[ $stackPtr ];
 
-        if ($token['code'] === T_OPEN_TAG && $token['content'] === '<?') {
+        if ( $token[ 'code' ] === T_OPEN_TAG && $token[ 'content' ] === '<?' ) {
             $error = 'Short PHP opening tag used; expected "<?php" but found "%s"';
-            $data  = [$token['content']];
-            $fix   = $phpcsFile->addFixableError($error, $stackPtr, 'Found', $data);
-            if ($fix === true) {
+            $data  = [ $token[ 'content' ] ];
+            $fix   = $phpcsFile->addFixableError( $error, $stackPtr, 'Found', $data );
+            if ( $fix === true ) {
                 $correctOpening = '<?php';
-                if (isset($tokens[($stackPtr + 1)]) === true && $tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) {
+                if ( isset( $tokens[ ( $stackPtr + 1 ) ] ) === true && $tokens[ ( $stackPtr + 1 ) ][ 'code' ] !== T_WHITESPACE ) {
                     // Avoid creation of invalid open tags like <?phpecho if the original was <?echo .
                     $correctOpening .= ' ';
                 }
 
-                $phpcsFile->fixer->replaceToken($stackPtr, $correctOpening);
+                $phpcsFile->fixer->replaceToken( $stackPtr, $correctOpening );
             }
 
-            $phpcsFile->recordMetric($stackPtr, 'PHP short open tag used', 'yes');
+            $phpcsFile->recordMetric( $stackPtr, 'PHP short open tag used', 'yes' );
         } else {
-            $phpcsFile->recordMetric($stackPtr, 'PHP short open tag used', 'no');
+            $phpcsFile->recordMetric( $stackPtr, 'PHP short open tag used', 'no' );
         }
 
-        if ($token['code'] === T_OPEN_TAG_WITH_ECHO) {
-            $nextVar = $tokens[$phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true)];
+        if ( $token[ 'code' ] === T_OPEN_TAG_WITH_ECHO ) {
+            $nextVar = $tokens[ $phpcsFile->findNext( Tokens::$emptyTokens, ( $stackPtr + 1 ), null, true ) ];
             $error   = 'Short PHP opening tag used with echo; expected "<?php echo %s ..." but found "%s %s ..."';
             $data    = [
-                $nextVar['content'],
-                $token['content'],
-                $nextVar['content'],
+                $nextVar[ 'content' ],
+                $token[ 'content' ],
+                $nextVar[ 'content' ],
             ];
-            $fix     = $phpcsFile->addFixableError($error, $stackPtr, 'EchoFound', $data);
-            if ($fix === true) {
-                if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) {
-                    $phpcsFile->fixer->replaceToken($stackPtr, '<?php echo ');
+            $fix = $phpcsFile->addFixableError( $error, $stackPtr, 'EchoFound', $data );
+            if ( $fix === true ) {
+                if ( $tokens[ ( $stackPtr + 1 ) ][ 'code' ] !== T_WHITESPACE ) {
+                    $phpcsFile->fixer->replaceToken( $stackPtr, '<?php echo ' );
                 } else {
-                    $phpcsFile->fixer->replaceToken($stackPtr, '<?php echo');
+                    $phpcsFile->fixer->replaceToken( $stackPtr, '<?php echo' );
                 }
             }
         }
 
-        if ($token['code'] === T_INLINE_HTML) {
-            $content     = $token['content'];
-            $openerFound = strpos($content, '<?');
+        if ( $token[ 'code' ] === T_INLINE_HTML ) {
+            $content     = $token[ 'content' ];
+            $openerFound = strpos( $content, '<?' );
 
-            if ($openerFound === false) {
+            if ( $openerFound === false ) {
                 return;
             }
 
             $closerFound = false;
 
             // Inspect current token and subsequent inline HTML token to find a close tag.
-            for ($i = $stackPtr; $i < $phpcsFile->numTokens; $i++) {
-                if ($tokens[$i]['code'] !== T_INLINE_HTML) {
+            for ( $i = $stackPtr; $i < $phpcsFile->numTokens; $i++ ) {
+                if ( $tokens[ $i ][ 'code' ] !== T_INLINE_HTML ) {
                     break;
                 }
 
-                $closerFound = strrpos($tokens[$i]['content'], '?>');
-                if ($closerFound !== false) {
-                    if ($i !== $stackPtr) {
+                $closerFound = strrpos( $tokens[ $i ][ 'content' ], '?>' );
+                if ( $closerFound !== false ) {
+                    if ( $i !== $stackPtr ) {
                         break;
-                    } else if ($closerFound > $openerFound) {
+                    } else if ( $closerFound > $openerFound ) {
                         break;
                     } else {
                         $closerFound = false;
@@ -118,15 +118,15 @@ 
                 }
             }
 
-            if ($closerFound !== false) {
+            if ( $closerFound !== false ) {
                 $error   = 'Possible use of short open tags detected; found: %s';
-                $snippet = $this->getSnippet($content, '<?');
-                $data    = ['<?'.$snippet];
+                $snippet = $this->getSnippet( $content, '<?' );
+                $data    = [ '<?' . $snippet ];
 
-                $phpcsFile->addWarning($error, $stackPtr, 'PossibleFound', $data);
+                $phpcsFile->addWarning( $error, $stackPtr, 'PossibleFound', $data );
 
                 // Skip forward to the token containing the closer.
-                if (($i - 1) > $stackPtr) {
+                if ( ( $i - 1 ) > $stackPtr ) {
                     return $i;
                 }
             }
@@ -144,19 +144,19 @@ 
      *
      * @return string
      */
-    protected function getSnippet($content, $start='', $length=40)
+    protected function getSnippet( $content, $start = '', $length = 40 )
     {
         $startPos = 0;
 
-        if ($start !== '') {
-            $startPos = strpos($content, $start);
-            if ($startPos !== false) {
-                $startPos += strlen($start);
+        if ( $start !== '' ) {
+            $startPos = strpos( $content, $start );
+            if ( $startPos !== false ) {
+                $startPos += strlen( $start );
             }
         }
 
-        $snippet = substr($content, $startPos, $length);
-        if ((strlen($content) - $startPos) > $length) {
+        $snippet = substr( $content, $startPos, $length );
+        if ( ( strlen( $content ) - $startPos ) > $length ) {
             $snippet .= '...';
         }
 

Braces +4 added lines, -8 removed lines

@@ -13,8 +13,7 @@ 
 use PHP_CodeSniffer\Files\File;
 use PHP_CodeSniffer\Util\Tokens;
 
-class DisallowShortOpenTagSniff implements Sniff
-{
+class DisallowShortOpenTagSniff implements Sniff {
 
 
     /**
@@ -22,8 +21,7 @@ 
      *
      * @return array
      */
-    public function register()
-    {
+    public function register() {
         $targets = [
             T_OPEN_TAG,
             T_OPEN_TAG_WITH_ECHO,
@@ -48,8 +46,7 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
-    {
+    public function process(File $phpcsFile, $stackPtr) {
         $tokens = $phpcsFile->getTokens();
         $token  = $tokens[$stackPtr];
 
@@ -144,8 +141,7 @@ 
      *
      * @return string
      */
-    protected function getSnippet($content, $start='', $length=40)
-    {
+    protected function getSnippet($content, $start='', $length=40) {
         $startPos = 0;
 
         if ($start !== '') {