gravityview / GravityView

wpcs/WordPress/AbstractArrayAssignmentRestrictionsSniff.php

Spacing +15 added lines, -15 removed lines

@@ -141,9 +141,9 @@ 
 
 		$token = $this->tokens[ $stackPtr ];
 
-		if ( \T_CLOSE_SQUARE_BRACKET === $token['code'] ) {
+		if ( \T_CLOSE_SQUARE_BRACKET === $token[ 'code' ] ) {
 			$equal = $this->phpcsFile->findNext( \T_WHITESPACE, ( $stackPtr + 1 ), null, true );
-			if ( \T_EQUAL !== $this->tokens[ $equal ]['code'] ) {
+			if ( \T_EQUAL !== $this->tokens[ $equal ][ 'code' ] ) {
 				return; // This is not an assignment!
 			}
 		}
@@ -156,28 +156,28 @@ 
 		 * $foo = array( 'bar' => 'taz' );
 		 * $foo['bar'] = $taz;
 		 */
-		if ( \in_array( $token['code'], array( \T_CLOSE_SQUARE_BRACKET, \T_DOUBLE_ARROW ), true ) ) {
+		if ( \in_array( $token[ 'code' ], array( \T_CLOSE_SQUARE_BRACKET, \T_DOUBLE_ARROW ), true ) ) {
 			$operator = $stackPtr; // T_DOUBLE_ARROW.
-			if ( \T_CLOSE_SQUARE_BRACKET === $token['code'] ) {
+			if ( \T_CLOSE_SQUARE_BRACKET === $token[ 'code' ] ) {
 				$operator = $this->phpcsFile->findNext( \T_EQUAL, ( $stackPtr + 1 ) );
 			}
 
 			$keyIdx = $this->phpcsFile->findPrevious( array( \T_WHITESPACE, \T_CLOSE_SQUARE_BRACKET ), ( $operator - 1 ), null, true );
-			if ( ! is_numeric( $this->tokens[ $keyIdx ]['content'] ) ) {
-				$key            = $this->strip_quotes( $this->tokens[ $keyIdx ]['content'] );
+			if ( ! is_numeric( $this->tokens[ $keyIdx ][ 'content' ] ) ) {
+				$key            = $this->strip_quotes( $this->tokens[ $keyIdx ][ 'content' ] );
 				$valStart       = $this->phpcsFile->findNext( array( \T_WHITESPACE ), ( $operator + 1 ), null, true );
 				$valEnd         = $this->phpcsFile->findNext( array( \T_COMMA, \T_SEMICOLON ), ( $valStart + 1 ), null, false, null, true );
 				$val            = $this->phpcsFile->getTokensAsString( $valStart, ( $valEnd - $valStart ) );
 				$val            = $this->strip_quotes( $val );
-				$inst[ $key ][] = array( $val, $token['line'] );
+				$inst[ $key ][ ] = array( $val, $token[ 'line' ] );
 			}
-		} elseif ( \in_array( $token['code'], array( \T_CONSTANT_ENCAPSED_STRING, \T_DOUBLE_QUOTED_STRING ), true ) ) {
+		} elseif ( \in_array( $token[ 'code' ], array( \T_CONSTANT_ENCAPSED_STRING, \T_DOUBLE_QUOTED_STRING ), true ) ) {
 			// $foo = 'bar=taz&other=thing';
-			if ( preg_match_all( '#(?:^|&)([a-z_]+)=([^&]*)#i', $this->strip_quotes( $token['content'] ), $matches ) <= 0 ) {
+			if ( preg_match_all( '#(?:^|&)([a-z_]+)=([^&]*)#i', $this->strip_quotes( $token[ 'content' ] ), $matches ) <= 0 ) {
 				return; // No assignments here, nothing to check.
 			}
-			foreach ( $matches[1] as $i => $_k ) {
-				$inst[ $_k ][] = array( $matches[2][ $i ], $token['line'] );
+			foreach ( $matches[ 1 ] as $i => $_k ) {
+				$inst[ $_k ][ ] = array( $matches[ 2 ][ $i ], $token[ 'line' ] );
 			}
 		}
 
@@ -191,13 +191,13 @@ 
 				continue;
 			}
 
-			$callback = ( isset( $group['callback'] ) && is_callable( $group['callback'] ) ) ? $group['callback'] : array( $this, 'callback' );
+			$callback = ( isset( $group[ 'callback' ] ) && is_callable( $group[ 'callback' ] ) ) ? $group[ 'callback' ] : array( $this, 'callback' );
 
 			foreach ( $inst as $key => $assignments ) {
 				foreach ( $assignments as $occurance ) {
 					list( $val, $line ) = $occurance;
 
-					if ( ! \in_array( $key, $group['keys'], true ) ) {
+					if ( ! \in_array( $key, $group[ 'keys' ], true ) ) {
 						continue;
 					}
 
@@ -206,7 +206,7 @@ 
 					if ( ! isset( $output ) || false === $output ) {
 						continue;
 					} elseif ( true === $output ) {
-						$message = $group['message'];
+						$message = $group[ 'message' ];
 					} else {
 						$message = $output;
 					}
@@ -214,7 +214,7 @@ 
 					$this->addMessage(
 						$message,
 						$stackPtr,
-						( 'error' === $group['type'] ),
+						( 'error' === $group[ 'type' ] ),
 						$this->string_to_errorcode( $groupName . '_' . $key ),
 						array( $key, $val )
 					);

vendor/phpcompatibility/php-compatibility/PHPCompatibility/Sniff.php

Spacing +418 added lines, -418 removed lines

@@ -109,39 +109,39 @@ 
     {
         static $arrTestVersions = array();
 
-        $default     = array(null, null);
-        $testVersion = trim(PHPCSHelper::getConfigData('testVersion'));
+        $default     = array( null, null );
+        $testVersion = trim( PHPCSHelper::getConfigData( 'testVersion' ) );
 
-        if (empty($testVersion) === false && isset($arrTestVersions[$testVersion]) === false) {
+        if ( empty( $testVersion ) === false && isset( $arrTestVersions[ $testVersion ] ) === false ) {
 
-            $arrTestVersions[$testVersion] = $default;
+            $arrTestVersions[ $testVersion ] = $default;
 
-            if (preg_match('`^\d+\.\d+$`', $testVersion)) {
-                $arrTestVersions[$testVersion] = array($testVersion, $testVersion);
-                return $arrTestVersions[$testVersion];
+            if ( preg_match( '`^\d+\.\d+$`', $testVersion ) ) {
+                $arrTestVersions[ $testVersion ] = array( $testVersion, $testVersion );
+                return $arrTestVersions[ $testVersion ];
             }
 
-            if (preg_match('`^(\d+\.\d+)?\s*-\s*(\d+\.\d+)?$`', $testVersion, $matches)) {
-                if (empty($matches[1]) === false || empty($matches[2]) === false) {
+            if ( preg_match( '`^(\d+\.\d+)?\s*-\s*(\d+\.\d+)?$`', $testVersion, $matches ) ) {
+                if ( empty( $matches[ 1 ] ) === false || empty( $matches[ 2 ] ) === false ) {
                     // If no lower-limit is set, we set the min version to 4.0.
                     // Whilst development focuses on PHP 5 and above, we also accept
                     // sniffs for PHP 4, so we include that as the minimum.
                     // (It makes no sense to support PHP 3 as this was effectively a
                     // different language).
-                    $min = empty($matches[1]) ? '4.0' : $matches[1];
+                    $min = empty( $matches[ 1 ] ) ? '4.0' : $matches[ 1 ];
 
                     // If no upper-limit is set, we set the max version to 99.9.
-                    $max = empty($matches[2]) ? '99.9' : $matches[2];
+                    $max = empty( $matches[ 2 ] ) ? '99.9' : $matches[ 2 ];
 
-                    if (version_compare($min, $max, '>')) {
+                    if ( version_compare( $min, $max, '>' ) ) {
                         trigger_error(
                             "Invalid range in testVersion setting: '" . $testVersion . "'",
                             \E_USER_WARNING
                         );
                         return $default;
                     } else {
-                        $arrTestVersions[$testVersion] = array($min, $max);
-                        return $arrTestVersions[$testVersion];
+                        $arrTestVersions[ $testVersion ] = array( $min, $max );
+                        return $arrTestVersions[ $testVersion ];
                     }
                 }
             }
@@ -153,8 +153,8 @@ 
             return $default;
         }
 
-        if (isset($arrTestVersions[$testVersion])) {
-            return $arrTestVersions[$testVersion];
+        if ( isset( $arrTestVersions[ $testVersion ] ) ) {
+            return $arrTestVersions[ $testVersion ];
         }
 
         return $default;
@@ -173,13 +173,13 @@ 
      *              is equal to or higher than the highest supported PHP version
      *              in testVersion. False otherwise.
      */
-    public function supportsAbove($phpVersion)
+    public function supportsAbove( $phpVersion )
     {
         $testVersion = $this->getTestVersion();
-        $testVersion = $testVersion[1];
+        $testVersion = $testVersion[ 1 ];
 
-        if (\is_null($testVersion)
-            || version_compare($testVersion, $phpVersion) >= 0
+        if ( \is_null( $testVersion )
+            || version_compare( $testVersion, $phpVersion ) >= 0
         ) {
             return true;
         } else {
@@ -200,13 +200,13 @@ 
      *              supported PHP version in testVersion.
      *              False otherwise or if no testVersion is provided.
      */
-    public function supportsBelow($phpVersion)
+    public function supportsBelow( $phpVersion )
     {
         $testVersion = $this->getTestVersion();
-        $testVersion = $testVersion[0];
+        $testVersion = $testVersion[ 0 ];
 
-        if (\is_null($testVersion) === false
-            && version_compare($testVersion, $phpVersion) <= 0
+        if ( \is_null( $testVersion ) === false
+            && version_compare( $testVersion, $phpVersion ) <= 0
         ) {
             return true;
         } else {
@@ -231,12 +231,12 @@ 
      *
      * @return void
      */
-    public function addMessage(File $phpcsFile, $message, $stackPtr, $isError, $code = 'Found', $data = array())
+    public function addMessage( File $phpcsFile, $message, $stackPtr, $isError, $code = 'Found', $data = array() )
     {
-        if ($isError === true) {
-            $phpcsFile->addError($message, $stackPtr, $code, $data);
+        if ( $isError === true ) {
+            $phpcsFile->addError( $message, $stackPtr, $code, $data );
         } else {
-            $phpcsFile->addWarning($message, $stackPtr, $code, $data);
+            $phpcsFile->addWarning( $message, $stackPtr, $code, $data );
         }
     }
 
@@ -250,9 +250,9 @@ 
      *
      * @return string
      */
-    public function stringToErrorCode($baseString)
+    public function stringToErrorCode( $baseString )
     {
-        return preg_replace('`[^a-z0-9_]`i', '_', strtolower($baseString));
+        return preg_replace( '`[^a-z0-9_]`i', '_', strtolower( $baseString ) );
     }
 
 
@@ -265,9 +265,9 @@ 
      *
      * @return string String without quotes around it.
      */
-    public function stripQuotes($string)
+    public function stripQuotes( $string )
     {
-        return preg_replace('`^([\'"])(.*)\1$`Ds', '$2', $string);
+        return preg_replace( '`^([\'"])(.*)\1$`Ds', '$2', $string );
     }
 
 
@@ -280,13 +280,13 @@ 
      *
      * @return string String without variables in it.
      */
-    public function stripVariables($string)
+    public function stripVariables( $string )
     {
-        if (strpos($string, '$') === false) {
+        if ( strpos( $string, '$' ) === false ) {
             return $string;
         }
 
-        return preg_replace(self::REGEX_COMPLEX_VARS, '', $string);
+        return preg_replace( self::REGEX_COMPLEX_VARS, '', $string );
     }
 
 
@@ -297,9 +297,9 @@ 
      *
      * @return array Same array, but with all lowercase top level keys.
      */
-    public function arrayKeysToLowercase($array)
+    public function arrayKeysToLowercase( $array )
     {
-        return array_change_key_case($array, \CASE_LOWER);
+        return array_change_key_case( $array, \CASE_LOWER );
     }
 
 
@@ -320,29 +320,29 @@ 
      *
      * @return bool
      */
-    public function doesFunctionCallHaveParameters(File $phpcsFile, $stackPtr)
+    public function doesFunctionCallHaveParameters( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
         // Check for the existence of the token.
-        if (isset($tokens[$stackPtr]) === false) {
+        if ( isset( $tokens[ $stackPtr ] ) === false ) {
             return false;
         }
 
         // Is this one of the tokens this function handles ?
-        if (\in_array($tokens[$stackPtr]['code'], array(\T_STRING, \T_ARRAY, \T_OPEN_SHORT_ARRAY, \T_VARIABLE), true) === false) {
+        if ( \in_array( $tokens[ $stackPtr ][ 'code' ], array( \T_STRING, \T_ARRAY, \T_OPEN_SHORT_ARRAY, \T_VARIABLE ), true ) === false ) {
             return false;
         }
 
-        $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, $stackPtr + 1, null, true, null, true);
+        $nextNonEmpty = $phpcsFile->findNext( Tokens::$emptyTokens, $stackPtr + 1, null, true, null, true );
 
         // Deal with short array syntax.
-        if ($tokens[$stackPtr]['code'] === \T_OPEN_SHORT_ARRAY) {
-            if (isset($tokens[$stackPtr]['bracket_closer']) === false) {
+        if ( $tokens[ $stackPtr ][ 'code' ] === \T_OPEN_SHORT_ARRAY ) {
+            if ( isset( $tokens[ $stackPtr ][ 'bracket_closer' ] ) === false ) {
                 return false;
             }
 
-            if ($nextNonEmpty === $tokens[$stackPtr]['bracket_closer']) {
+            if ( $nextNonEmpty === $tokens[ $stackPtr ][ 'bracket_closer' ] ) {
                 // No parameters.
                 return false;
             } else {
@@ -352,18 +352,18 @@ 
 
         // Deal with function calls & long arrays.
         // Next non-empty token should be the open parenthesis.
-        if ($nextNonEmpty === false && $tokens[$nextNonEmpty]['code'] !== \T_OPEN_PARENTHESIS) {
+        if ( $nextNonEmpty === false && $tokens[ $nextNonEmpty ][ 'code' ] !== \T_OPEN_PARENTHESIS ) {
             return false;
         }
 
-        if (isset($tokens[$nextNonEmpty]['parenthesis_closer']) === false) {
+        if ( isset( $tokens[ $nextNonEmpty ][ 'parenthesis_closer' ] ) === false ) {
             return false;
         }
 
-        $closeParenthesis = $tokens[$nextNonEmpty]['parenthesis_closer'];
-        $nextNextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, $nextNonEmpty + 1, $closeParenthesis + 1, true);
+        $closeParenthesis = $tokens[ $nextNonEmpty ][ 'parenthesis_closer' ];
+        $nextNextNonEmpty = $phpcsFile->findNext( Tokens::$emptyTokens, $nextNonEmpty + 1, $closeParenthesis + 1, true );
 
-        if ($nextNextNonEmpty === $closeParenthesis) {
+        if ( $nextNextNonEmpty === $closeParenthesis ) {
             // No parameters.
             return false;
         }
@@ -390,13 +390,13 @@ 
      *
      * @return int
      */
-    public function getFunctionCallParameterCount(File $phpcsFile, $stackPtr)
+    public function getFunctionCallParameterCount( File $phpcsFile, $stackPtr )
     {
-        if ($this->doesFunctionCallHaveParameters($phpcsFile, $stackPtr) === false) {
+        if ( $this->doesFunctionCallHaveParameters( $phpcsFile, $stackPtr ) === false ) {
             return 0;
         }
 
-        return \count($this->getFunctionCallParameters($phpcsFile, $stackPtr));
+        return \count( $this->getFunctionCallParameters( $phpcsFile, $stackPtr ) );
     }
 
 
@@ -418,9 +418,9 @@ 
      *
      * @return array
      */
-    public function getFunctionCallParameters(File $phpcsFile, $stackPtr)
+    public function getFunctionCallParameters( File $phpcsFile, $stackPtr )
     {
-        if ($this->doesFunctionCallHaveParameters($phpcsFile, $stackPtr) === false) {
+        if ( $this->doesFunctionCallHaveParameters( $phpcsFile, $stackPtr ) === false ) {
             return array();
         }
 
@@ -429,74 +429,74 @@ 
         $tokens = $phpcsFile->getTokens();
 
         // Mark the beginning and end tokens.
-        if ($tokens[$stackPtr]['code'] === \T_OPEN_SHORT_ARRAY) {
+        if ( $tokens[ $stackPtr ][ 'code' ] === \T_OPEN_SHORT_ARRAY ) {
             $opener = $stackPtr;
-            $closer = $tokens[$stackPtr]['bracket_closer'];
+            $closer = $tokens[ $stackPtr ][ 'bracket_closer' ];
 
             $nestedParenthesisCount = 0;
 
         } else {
-            $opener = $phpcsFile->findNext(Tokens::$emptyTokens, $stackPtr + 1, null, true, null, true);
-            $closer = $tokens[$opener]['parenthesis_closer'];
+            $opener = $phpcsFile->findNext( Tokens::$emptyTokens, $stackPtr + 1, null, true, null, true );
+            $closer = $tokens[ $opener ][ 'parenthesis_closer' ];
 
             $nestedParenthesisCount = 1;
         }
 
         // Which nesting level is the one we are interested in ?
-        if (isset($tokens[$opener]['nested_parenthesis'])) {
-            $nestedParenthesisCount += \count($tokens[$opener]['nested_parenthesis']);
+        if ( isset( $tokens[ $opener ][ 'nested_parenthesis' ] ) ) {
+            $nestedParenthesisCount += \count( $tokens[ $opener ][ 'nested_parenthesis' ] );
         }
 
         $parameters = array();
         $nextComma  = $opener;
         $paramStart = $opener + 1;
         $cnt        = 1;
-        while (($nextComma = $phpcsFile->findNext(array(\T_COMMA, $tokens[$closer]['code'], \T_OPEN_SHORT_ARRAY, \T_CLOSURE), $nextComma + 1, $closer + 1)) !== false) {
+        while ( ( $nextComma = $phpcsFile->findNext( array( \T_COMMA, $tokens[ $closer ][ 'code' ], \T_OPEN_SHORT_ARRAY, \T_CLOSURE ), $nextComma + 1, $closer + 1 ) ) !== false ) {
             // Ignore anything within short array definition brackets.
-            if ($tokens[$nextComma]['type'] === 'T_OPEN_SHORT_ARRAY'
-                && (isset($tokens[$nextComma]['bracket_opener'])
-                    && $tokens[$nextComma]['bracket_opener'] === $nextComma)
-                && isset($tokens[$nextComma]['bracket_closer'])
+            if ( $tokens[ $nextComma ][ 'type' ] === 'T_OPEN_SHORT_ARRAY'
+                && ( isset( $tokens[ $nextComma ][ 'bracket_opener' ] )
+                    && $tokens[ $nextComma ][ 'bracket_opener' ] === $nextComma )
+                && isset( $tokens[ $nextComma ][ 'bracket_closer' ] )
             ) {
                 // Skip forward to the end of the short array definition.
-                $nextComma = $tokens[$nextComma]['bracket_closer'];
+                $nextComma = $tokens[ $nextComma ][ 'bracket_closer' ];
                 continue;
             }
 
             // Skip past closures passed as function parameters.
-            if ($tokens[$nextComma]['type'] === 'T_CLOSURE'
-                && (isset($tokens[$nextComma]['scope_condition'])
-                    && $tokens[$nextComma]['scope_condition'] === $nextComma)
-                && isset($tokens[$nextComma]['scope_closer'])
+            if ( $tokens[ $nextComma ][ 'type' ] === 'T_CLOSURE'
+                && ( isset( $tokens[ $nextComma ][ 'scope_condition' ] )
+                    && $tokens[ $nextComma ][ 'scope_condition' ] === $nextComma )
+                && isset( $tokens[ $nextComma ][ 'scope_closer' ] )
             ) {
                 // Skip forward to the end of the closure declaration.
-                $nextComma = $tokens[$nextComma]['scope_closer'];
+                $nextComma = $tokens[ $nextComma ][ 'scope_closer' ];
                 continue;
             }
 
             // Ignore comma's at a lower nesting level.
-            if ($tokens[$nextComma]['type'] === 'T_COMMA'
-                && isset($tokens[$nextComma]['nested_parenthesis'])
-                && \count($tokens[$nextComma]['nested_parenthesis']) !== $nestedParenthesisCount
+            if ( $tokens[ $nextComma ][ 'type' ] === 'T_COMMA'
+                && isset( $tokens[ $nextComma ][ 'nested_parenthesis' ] )
+                && \count( $tokens[ $nextComma ][ 'nested_parenthesis' ] ) !== $nestedParenthesisCount
             ) {
                 continue;
             }
 
             // Ignore closing parenthesis/bracket if not 'ours'.
-            if ($tokens[$nextComma]['type'] === $tokens[$closer]['type'] && $nextComma !== $closer) {
+            if ( $tokens[ $nextComma ][ 'type' ] === $tokens[ $closer ][ 'type' ] && $nextComma !== $closer ) {
                 continue;
             }
 
             // Ok, we've reached the end of the parameter.
-            $parameters[$cnt]['start'] = $paramStart;
-            $parameters[$cnt]['end']   = $nextComma - 1;
-            $parameters[$cnt]['raw']   = trim($phpcsFile->getTokensAsString($paramStart, ($nextComma - $paramStart)));
+            $parameters[ $cnt ][ 'start' ] = $paramStart;
+            $parameters[ $cnt ][ 'end' ]   = $nextComma - 1;
+            $parameters[ $cnt ][ 'raw' ]   = trim( $phpcsFile->getTokensAsString( $paramStart, ( $nextComma - $paramStart ) ) );
 
             // Check if there are more tokens before the closing parenthesis.
             // Prevents code like the following from setting a third parameter:
             // functionCall( $param1, $param2, );
-            $hasNextParam = $phpcsFile->findNext(Tokens::$emptyTokens, $nextComma + 1, $closer, true, null, true);
-            if ($hasNextParam === false) {
+            $hasNextParam = $phpcsFile->findNext( Tokens::$emptyTokens, $nextComma + 1, $closer, true, null, true );
+            if ( $hasNextParam === false ) {
                 break;
             }
 
@@ -525,14 +525,14 @@ 
      *
      * @return array|false
      */
-    public function getFunctionCallParameter(File $phpcsFile, $stackPtr, $paramOffset)
+    public function getFunctionCallParameter( File $phpcsFile, $stackPtr, $paramOffset )
     {
-        $parameters = $this->getFunctionCallParameters($phpcsFile, $stackPtr);
+        $parameters = $this->getFunctionCallParameters( $phpcsFile, $stackPtr );
 
-        if (isset($parameters[$paramOffset]) === false) {
+        if ( isset( $parameters[ $paramOffset ] ) === false ) {
             return false;
         } else {
-            return $parameters[$paramOffset];
+            return $parameters[ $paramOffset ];
         }
     }
 
@@ -555,26 +555,26 @@ 
      *              If the $scopeTypes are set: True if *one* of the conditions is a
      *              valid scope, false otherwise.
      */
-    public function tokenHasScope(File $phpcsFile, $stackPtr, $validScopes = null)
+    public function tokenHasScope( File $phpcsFile, $stackPtr, $validScopes = null )
     {
         $tokens = $phpcsFile->getTokens();
 
         // Check for the existence of the token.
-        if (isset($tokens[$stackPtr]) === false) {
+        if ( isset( $tokens[ $stackPtr ] ) === false ) {
             return false;
         }
 
         // No conditions = no scope.
-        if (empty($tokens[$stackPtr]['conditions'])) {
+        if ( empty( $tokens[ $stackPtr ][ 'conditions' ] ) ) {
             return false;
         }
 
         // Ok, there are conditions, do we have to check for specific ones ?
-        if (isset($validScopes) === false) {
+        if ( isset( $validScopes ) === false ) {
             return true;
         }
 
-        return $phpcsFile->hasCondition($stackPtr, $validScopes);
+        return $phpcsFile->hasCondition( $stackPtr, $validScopes );
     }
 
 
@@ -589,19 +589,19 @@ 
      *
      * @return bool True if within class scope, false otherwise.
      */
-    public function inClassScope(File $phpcsFile, $stackPtr, $strict = true)
+    public function inClassScope( File $phpcsFile, $stackPtr, $strict = true )
     {
-        $validScopes = array(\T_CLASS);
-        if (\defined('T_ANON_CLASS') === true) {
-            $validScopes[] = \T_ANON_CLASS;
+        $validScopes = array( \T_CLASS );
+        if ( \defined( 'T_ANON_CLASS' ) === true ) {
+            $validScopes[ ] = \T_ANON_CLASS;
         }
 
-        if ($strict === false) {
-            $validScopes[] = \T_INTERFACE;
-            $validScopes[] = \T_TRAIT;
+        if ( $strict === false ) {
+            $validScopes[ ] = \T_INTERFACE;
+            $validScopes[ ] = \T_TRAIT;
         }
 
-        return $phpcsFile->hasCondition($stackPtr, $validScopes);
+        return $phpcsFile->hasCondition( $stackPtr, $validScopes );
     }
 
 
@@ -615,31 +615,31 @@ 
      *
      * @return string
      */
-    public function getFQClassNameFromNewToken(File $phpcsFile, $stackPtr)
+    public function getFQClassNameFromNewToken( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
         // Check for the existence of the token.
-        if (isset($tokens[$stackPtr]) === false) {
+        if ( isset( $tokens[ $stackPtr ] ) === false ) {
             return '';
         }
 
-        if ($tokens[$stackPtr]['code'] !== \T_NEW) {
+        if ( $tokens[ $stackPtr ][ 'code' ] !== \T_NEW ) {
             return '';
         }
 
-        $start = $phpcsFile->findNext(Tokens::$emptyTokens, $stackPtr + 1, null, true, null, true);
-        if ($start === false) {
+        $start = $phpcsFile->findNext( Tokens::$emptyTokens, $stackPtr + 1, null, true, null, true );
+        if ( $start === false ) {
             return '';
         }
 
         // Bow out if the next token is a variable as we don't know where it was defined.
-        if ($tokens[$start]['code'] === \T_VARIABLE) {
+        if ( $tokens[ $start ][ 'code' ] === \T_VARIABLE ) {
             return '';
         }
 
         // Bow out if the next token is the class keyword.
-        if ($tokens[$start]['type'] === 'T_ANON_CLASS' || $tokens[$start]['code'] === \T_CLASS) {
+        if ( $tokens[ $start ][ 'type' ] === 'T_ANON_CLASS' || $tokens[ $start ][ 'code' ] === \T_CLASS ) {
             return '';
         }
 
@@ -650,11 +650,11 @@ 
             \T_WHITESPACE,
         );
 
-        $end       = $phpcsFile->findNext($find, ($start + 1), null, true, null, true);
-        $className = $phpcsFile->getTokensAsString($start, ($end - $start));
-        $className = trim($className);
+        $end       = $phpcsFile->findNext( $find, ( $start + 1 ), null, true, null, true );
+        $className = $phpcsFile->getTokensAsString( $start, ( $end - $start ) );
+        $className = trim( $className );
 
-        return $this->getFQName($phpcsFile, $stackPtr, $className);
+        return $this->getFQName( $phpcsFile, $stackPtr, $className );
     }
 
 
@@ -669,28 +669,28 @@ 
      *
      * @return string
      */
-    public function getFQExtendedClassName(File $phpcsFile, $stackPtr)
+    public function getFQExtendedClassName( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
         // Check for the existence of the token.
-        if (isset($tokens[$stackPtr]) === false) {
+        if ( isset( $tokens[ $stackPtr ] ) === false ) {
             return '';
         }
 
-        if ($tokens[$stackPtr]['code'] !== \T_CLASS
-            && $tokens[$stackPtr]['type'] !== 'T_ANON_CLASS'
-            && $tokens[$stackPtr]['type'] !== 'T_INTERFACE'
+        if ( $tokens[ $stackPtr ][ 'code' ] !== \T_CLASS
+            && $tokens[ $stackPtr ][ 'type' ] !== 'T_ANON_CLASS'
+            && $tokens[ $stackPtr ][ 'type' ] !== 'T_INTERFACE'
         ) {
             return '';
         }
 
-        $extends = PHPCSHelper::findExtendedClassName($phpcsFile, $stackPtr);
-        if (empty($extends) || \is_string($extends) === false) {
+        $extends = PHPCSHelper::findExtendedClassName( $phpcsFile, $stackPtr );
+        if ( empty( $extends ) || \is_string( $extends ) === false ) {
             return '';
         }
 
-        return $this->getFQName($phpcsFile, $stackPtr, $extends);
+        return $this->getFQName( $phpcsFile, $stackPtr, $extends );
     }
 
 
@@ -705,37 +705,37 @@ 
      *
      * @return string
      */
-    public function getFQClassNameFromDoubleColonToken(File $phpcsFile, $stackPtr)
+    public function getFQClassNameFromDoubleColonToken( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
         // Check for the existence of the token.
-        if (isset($tokens[$stackPtr]) === false) {
+        if ( isset( $tokens[ $stackPtr ] ) === false ) {
             return '';
         }
 
-        if ($tokens[$stackPtr]['code'] !== \T_DOUBLE_COLON) {
+        if ( $tokens[ $stackPtr ][ 'code' ] !== \T_DOUBLE_COLON ) {
             return '';
         }
 
         // Nothing to do if previous token is a variable as we don't know where it was defined.
-        if ($tokens[$stackPtr - 1]['code'] === \T_VARIABLE) {
+        if ( $tokens[ $stackPtr - 1 ][ 'code' ] === \T_VARIABLE ) {
             return '';
         }
 
         // Nothing to do if 'parent' or 'static' as we don't know how far the class tree extends.
-        if (\in_array($tokens[$stackPtr - 1]['code'], array(\T_PARENT, \T_STATIC), true)) {
+        if ( \in_array( $tokens[ $stackPtr - 1 ][ 'code' ], array( \T_PARENT, \T_STATIC ), true ) ) {
             return '';
         }
 
         // Get the classname from the class declaration if self is used.
-        if ($tokens[$stackPtr - 1]['code'] === \T_SELF) {
-            $classDeclarationPtr = $phpcsFile->findPrevious(\T_CLASS, $stackPtr - 1);
-            if ($classDeclarationPtr === false) {
+        if ( $tokens[ $stackPtr - 1 ][ 'code' ] === \T_SELF ) {
+            $classDeclarationPtr = $phpcsFile->findPrevious( \T_CLASS, $stackPtr - 1 );
+            if ( $classDeclarationPtr === false ) {
                 return '';
             }
-            $className = $phpcsFile->getDeclarationName($classDeclarationPtr);
-            return $this->getFQName($phpcsFile, $classDeclarationPtr, $className);
+            $className = $phpcsFile->getDeclarationName( $classDeclarationPtr );
+            return $this->getFQName( $phpcsFile, $classDeclarationPtr, $className );
         }
 
         $find = array(
@@ -745,16 +745,16 @@ 
             \T_WHITESPACE,
         );
 
-        $start = $phpcsFile->findPrevious($find, $stackPtr - 1, null, true, null, true);
-        if ($start === false || isset($tokens[($start + 1)]) === false) {
+        $start = $phpcsFile->findPrevious( $find, $stackPtr - 1, null, true, null, true );
+        if ( $start === false || isset( $tokens[ ( $start + 1 ) ] ) === false ) {
             return '';
         }
 
-        $start     = ($start + 1);
-        $className = $phpcsFile->getTokensAsString($start, ($stackPtr - $start));
-        $className = trim($className);
+        $start     = ( $start + 1 );
+        $className = $phpcsFile->getTokensAsString( $start, ( $stackPtr - $start ) );
+        $className = trim( $className );
 
-        return $this->getFQName($phpcsFile, $stackPtr, $className);
+        return $this->getFQName( $phpcsFile, $stackPtr, $className );
     }
 
 
@@ -770,21 +770,21 @@ 
      *
      * @return string
      */
-    public function getFQName(File $phpcsFile, $stackPtr, $name)
+    public function getFQName( File $phpcsFile, $stackPtr, $name )
     {
-        if (strpos($name, '\\') === 0) {
+        if ( strpos( $name, '\\' ) === 0 ) {
             // Already fully qualified.
             return $name;
         }
 
         // Remove the namespace keyword if used.
-        if (strpos($name, 'namespace\\') === 0) {
-            $name = substr($name, 10);
+        if ( strpos( $name, 'namespace\\' ) === 0 ) {
+            $name = substr( $name, 10 );
         }
 
-        $namespace = $this->determineNamespace($phpcsFile, $stackPtr);
+        $namespace = $this->determineNamespace( $phpcsFile, $stackPtr );
 
-        if ($namespace === '') {
+        if ( $namespace === '' ) {
             return '\\' . $name;
         } else {
             return '\\' . $namespace . '\\' . $name;
@@ -800,13 +800,13 @@ 
      *
      * @return bool True if namespaced, false if global.
      */
-    public function isNamespaced($FQName)
+    public function isNamespaced( $FQName )
     {
-        if (strpos($FQName, '\\') !== 0) {
-            throw new PHPCS_Exception('$FQName must be a fully qualified name');
+        if ( strpos( $FQName, '\\' ) !== 0 ) {
+            throw new PHPCS_Exception( '$FQName must be a fully qualified name' );
         }
 
-        return (strpos(substr($FQName, 1), '\\') !== false);
+        return ( strpos( substr( $FQName, 1 ), '\\' ) !== false );
     }
 
 
@@ -818,21 +818,21 @@ 
      *
      * @return string Namespace name or empty string if it couldn't be determined or no namespace applies.
      */
-    public function determineNamespace(File $phpcsFile, $stackPtr)
+    public function determineNamespace( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
         // Check for the existence of the token.
-        if (isset($tokens[$stackPtr]) === false) {
+        if ( isset( $tokens[ $stackPtr ] ) === false ) {
             return '';
         }
 
         // Check for scoped namespace {}.
-        if (empty($tokens[$stackPtr]['conditions']) === false) {
-            $namespacePtr = $phpcsFile->getCondition($stackPtr, \T_NAMESPACE);
-            if ($namespacePtr !== false) {
-                $namespace = $this->getDeclaredNamespaceName($phpcsFile, $namespacePtr);
-                if ($namespace !== false) {
+        if ( empty( $tokens[ $stackPtr ][ 'conditions' ] ) === false ) {
+            $namespacePtr = $phpcsFile->getCondition( $stackPtr, \T_NAMESPACE );
+            if ( $namespacePtr !== false ) {
+                $namespace = $this->getDeclaredNamespaceName( $phpcsFile, $namespacePtr );
+                if ( $namespace !== false ) {
                     return $namespace;
                 }
 
@@ -851,19 +851,19 @@ 
         $previousNSToken = $stackPtr;
         $namespace       = false;
         do {
-            $previousNSToken = $phpcsFile->findPrevious(\T_NAMESPACE, ($previousNSToken - 1));
+            $previousNSToken = $phpcsFile->findPrevious( \T_NAMESPACE, ( $previousNSToken - 1 ) );
 
             // Stop if we encounter a scoped namespace declaration as we already know we're not in one.
-            if (empty($tokens[$previousNSToken]['scope_condition']) === false && $tokens[$previousNSToken]['scope_condition'] === $previousNSToken) {
+            if ( empty( $tokens[ $previousNSToken ][ 'scope_condition' ] ) === false && $tokens[ $previousNSToken ][ 'scope_condition' ] === $previousNSToken ) {
                 break;
             }
 
-            $namespace = $this->getDeclaredNamespaceName($phpcsFile, $previousNSToken);
+            $namespace = $this->getDeclaredNamespaceName( $phpcsFile, $previousNSToken );
 
-        } while ($namespace === false && $previousNSToken !== false);
+        } while ( $namespace === false && $previousNSToken !== false );
 
         // If we still haven't got a namespace, return an empty string.
-        if ($namespace === false) {
+        if ( $namespace === false ) {
             return '';
         } else {
             return $namespace;
@@ -882,26 +882,26 @@ 
      * @return string|false Namespace name or false if not a namespace declaration.
      *                      Namespace name can be an empty string for global namespace declaration.
      */
-    public function getDeclaredNamespaceName(File $phpcsFile, $stackPtr)
+    public function getDeclaredNamespaceName( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
         // Check for the existence of the token.
-        if ($stackPtr === false || isset($tokens[$stackPtr]) === false) {
+        if ( $stackPtr === false || isset( $tokens[ $stackPtr ] ) === false ) {
             return false;
         }
 
-        if ($tokens[$stackPtr]['code'] !== \T_NAMESPACE) {
+        if ( $tokens[ $stackPtr ][ 'code' ] !== \T_NAMESPACE ) {
             return false;
         }
 
-        if ($tokens[($stackPtr + 1)]['code'] === \T_NS_SEPARATOR) {
+        if ( $tokens[ ( $stackPtr + 1 ) ][ 'code' ] === \T_NS_SEPARATOR ) {
             // Not a namespace declaration, but use of, i.e. namespace\someFunction();
             return false;
         }
 
-        $nextToken = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true, null, true);
-        if ($tokens[$nextToken]['code'] === \T_OPEN_CURLY_BRACKET) {
+        $nextToken = $phpcsFile->findNext( Tokens::$emptyTokens, ( $stackPtr + 1 ), null, true, null, true );
+        if ( $tokens[ $nextToken ][ 'code' ] === \T_OPEN_CURLY_BRACKET ) {
             // Declaration for global namespace when using multiple namespaces in a file.
             // I.e.: namespace {}
             return '';
@@ -915,8 +915,8 @@ 
         );
 
         $namespaceName = '';
-        while (isset($validTokens[$tokens[$nextToken]['code']]) === true) {
-            $namespaceName .= trim($tokens[$nextToken]['content']);
+        while ( isset( $validTokens[ $tokens[ $nextToken ][ 'code' ] ] ) === true ) {
+            $namespaceName .= trim( $tokens[ $nextToken ][ 'content' ] );
             $nextToken++;
         }
 
@@ -939,43 +939,43 @@ 
      *                   no return type was found or the passed token was
      *                   not of the correct type.
      */
-    public function getReturnTypeHintToken(File $phpcsFile, $stackPtr)
+    public function getReturnTypeHintToken( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
-        if (\defined('T_RETURN_TYPE') && $tokens[$stackPtr]['code'] === \T_RETURN_TYPE) {
+        if ( \defined( 'T_RETURN_TYPE' ) && $tokens[ $stackPtr ][ 'code' ] === \T_RETURN_TYPE ) {
             return $stackPtr;
         }
 
-        if ($tokens[$stackPtr]['code'] !== \T_FUNCTION && $tokens[$stackPtr]['code'] !== \T_CLOSURE) {
+        if ( $tokens[ $stackPtr ][ 'code' ] !== \T_FUNCTION && $tokens[ $stackPtr ][ 'code' ] !== \T_CLOSURE ) {
             return false;
         }
 
-        if (isset($tokens[$stackPtr]['parenthesis_closer']) === false) {
+        if ( isset( $tokens[ $stackPtr ][ 'parenthesis_closer' ] ) === false ) {
             return false;
         }
 
         // Allow for interface and abstract method declarations.
         $endOfFunctionDeclaration = null;
-        if (isset($tokens[$stackPtr]['scope_opener'])) {
-            $endOfFunctionDeclaration = $tokens[$stackPtr]['scope_opener'];
+        if ( isset( $tokens[ $stackPtr ][ 'scope_opener' ] ) ) {
+            $endOfFunctionDeclaration = $tokens[ $stackPtr ][ 'scope_opener' ];
         } else {
-            $nextSemiColon = $phpcsFile->findNext(\T_SEMICOLON, ($tokens[$stackPtr]['parenthesis_closer'] + 1), null, false, null, true);
-            if ($nextSemiColon !== false) {
+            $nextSemiColon = $phpcsFile->findNext( \T_SEMICOLON, ( $tokens[ $stackPtr ][ 'parenthesis_closer' ] + 1 ), null, false, null, true );
+            if ( $nextSemiColon !== false ) {
                 $endOfFunctionDeclaration = $nextSemiColon;
             }
         }
 
-        if (isset($endOfFunctionDeclaration) === false) {
+        if ( isset( $endOfFunctionDeclaration ) === false ) {
             return false;
         }
 
         $hasColon = $phpcsFile->findNext(
-            array(\T_COLON, \T_INLINE_ELSE),
-            ($tokens[$stackPtr]['parenthesis_closer'] + 1),
+            array( \T_COLON, \T_INLINE_ELSE ),
+            ( $tokens[ $stackPtr ][ 'parenthesis_closer' ] + 1 ),
             $endOfFunctionDeclaration
         );
-        if ($hasColon === false) {
+        if ( $hasColon === false ) {
             return false;
         }
 
@@ -996,7 +996,7 @@ 
             \T_STRING,
         );
 
-        return $phpcsFile->findPrevious($unrecognizedTypes, ($endOfFunctionDeclaration - 1), $hasColon);
+        return $phpcsFile->findPrevious( $unrecognizedTypes, ( $endOfFunctionDeclaration - 1 ), $hasColon );
     }
 
 
@@ -1018,37 +1018,37 @@ 
      *
      * @return string|false The name of the return type token.
      */
-    public function getReturnTypeHintName(File $phpcsFile, $stackPtr)
+    public function getReturnTypeHintName( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
         // In older PHPCS versions, the nullable indicator will turn a return type colon into a T_INLINE_ELSE.
-        $colon = $phpcsFile->findPrevious(array(\T_COLON, \T_INLINE_ELSE, \T_FUNCTION, \T_CLOSE_PARENTHESIS), ($stackPtr - 1));
-        if ($colon === false
-            || ($tokens[$colon]['code'] !== \T_COLON && $tokens[$colon]['code'] !== \T_INLINE_ELSE)
+        $colon = $phpcsFile->findPrevious( array( \T_COLON, \T_INLINE_ELSE, \T_FUNCTION, \T_CLOSE_PARENTHESIS ), ( $stackPtr - 1 ) );
+        if ( $colon === false
+            || ( $tokens[ $colon ][ 'code' ] !== \T_COLON && $tokens[ $colon ][ 'code' ] !== \T_INLINE_ELSE )
         ) {
             // Shouldn't happen, just in case.
             return;
         }
 
         $returnTypeHint = '';
-        for ($i = ($colon + 1); $i <= $stackPtr; $i++) {
+        for ( $i = ( $colon + 1 ); $i <= $stackPtr; $i++ ) {
             // As of PHPCS 3.3.0+, all tokens are tokenized as "normal", so T_CALLABLE, T_SELF etc are
             // all possible, just exclude anything that's regarded as empty and the nullable indicator.
-            if (isset(Tokens::$emptyTokens[$tokens[$i]['code']])) {
+            if ( isset( Tokens::$emptyTokens[ $tokens[ $i ][ 'code' ] ] ) ) {
                 continue;
             }
 
-            if ($tokens[$i]['type'] === 'T_NULLABLE') {
+            if ( $tokens[ $i ][ 'type' ] === 'T_NULLABLE' ) {
                 continue;
             }
 
-            if (\defined('T_NULLABLE') === false && $tokens[$i]['code'] === \T_INLINE_THEN) {
+            if ( \defined( 'T_NULLABLE' ) === false && $tokens[ $i ][ 'code' ] === \T_INLINE_THEN ) {
                 // Old PHPCS.
                 continue;
             }
 
-            $returnTypeHint .= $tokens[$i]['content'];
+            $returnTypeHint .= $tokens[ $i ][ 'content' ];
         }
 
         return $returnTypeHint;
@@ -1069,11 +1069,11 @@ 
      *
      * @return bool
      */
-    public function isClassProperty(File $phpcsFile, $stackPtr)
+    public function isClassProperty( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
-        if (isset($tokens[$stackPtr]) === false || $tokens[$stackPtr]['code'] !== \T_VARIABLE) {
+        if ( isset( $tokens[ $stackPtr ] ) === false || $tokens[ $stackPtr ][ 'code' ] !== \T_VARIABLE ) {
             return false;
         }
 
@@ -1084,17 +1084,17 @@ 
             'T_TRAIT'      => true,
         );
 
-        $scopePtr = $this->validDirectScope($phpcsFile, $stackPtr, $validScopes);
-        if ($scopePtr !== false) {
+        $scopePtr = $this->validDirectScope( $phpcsFile, $stackPtr, $validScopes );
+        if ( $scopePtr !== false ) {
             // Make sure it's not a method parameter.
-            if (empty($tokens[$stackPtr]['nested_parenthesis']) === true) {
+            if ( empty( $tokens[ $stackPtr ][ 'nested_parenthesis' ] ) === true ) {
                 return true;
             } else {
-                $parenthesis = array_keys($tokens[$stackPtr]['nested_parenthesis']);
-                $deepestOpen = array_pop($parenthesis);
-                if ($deepestOpen < $scopePtr
-                    || isset($tokens[$deepestOpen]['parenthesis_owner']) === false
-                    || $tokens[$tokens[$deepestOpen]['parenthesis_owner']]['code'] !== \T_FUNCTION
+                $parenthesis = array_keys( $tokens[ $stackPtr ][ 'nested_parenthesis' ] );
+                $deepestOpen = array_pop( $parenthesis );
+                if ( $deepestOpen < $scopePtr
+                    || isset( $tokens[ $deepestOpen ][ 'parenthesis_owner' ] ) === false
+                    || $tokens[ $tokens[ $deepestOpen ][ 'parenthesis_owner' ] ][ 'code' ] !== \T_FUNCTION
                 ) {
                     return true;
                 }
@@ -1114,11 +1114,11 @@ 
      *
      * @return bool
      */
-    public function isClassConstant(File $phpcsFile, $stackPtr)
+    public function isClassConstant( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
-        if (isset($tokens[$stackPtr]) === false || $tokens[$stackPtr]['code'] !== \T_CONST) {
+        if ( isset( $tokens[ $stackPtr ] ) === false || $tokens[ $stackPtr ][ 'code' ] !== \T_CONST ) {
             return false;
         }
 
@@ -1128,7 +1128,7 @@ 
             'T_ANON_CLASS' => true,
             'T_INTERFACE'  => true,
         );
-        if ($this->validDirectScope($phpcsFile, $stackPtr, $validScopes) !== false) {
+        if ( $this->validDirectScope( $phpcsFile, $stackPtr, $validScopes ) !== false ) {
             return true;
         }
 
@@ -1152,25 +1152,25 @@ 
      *
      * @return int|bool StackPtr to the scope if valid, false otherwise.
      */
-    protected function validDirectScope(File $phpcsFile, $stackPtr, $validScopes)
+    protected function validDirectScope( File $phpcsFile, $stackPtr, $validScopes )
     {
         $tokens = $phpcsFile->getTokens();
 
-        if (empty($tokens[$stackPtr]['conditions']) === true) {
+        if ( empty( $tokens[ $stackPtr ][ 'conditions' ] ) === true ) {
             return false;
         }
 
         /*
          * Check only the direct wrapping scope of the token.
          */
-        $conditions = array_keys($tokens[$stackPtr]['conditions']);
-        $ptr        = array_pop($conditions);
+        $conditions = array_keys( $tokens[ $stackPtr ][ 'conditions' ] );
+        $ptr        = array_pop( $conditions );
 
-        if (isset($tokens[$ptr]) === false) {
+        if ( isset( $tokens[ $ptr ] ) === false ) {
             return false;
         }
 
-        if (isset($validScopes[$tokens[$ptr]['type']]) === true) {
+        if ( isset( $validScopes[ $tokens[ $ptr ][ 'type' ] ] ) === true ) {
             return $ptr;
         }
 
@@ -1194,34 +1194,34 @@ 
      *               - no type hints were found
      *               - or the passed token was not of the correct type.
      */
-    public function getTypeHintsFromFunctionDeclaration(File $phpcsFile, $stackPtr)
+    public function getTypeHintsFromFunctionDeclaration( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
-        if ($tokens[$stackPtr]['code'] !== \T_FUNCTION && $tokens[$stackPtr]['code'] !== \T_CLOSURE) {
+        if ( $tokens[ $stackPtr ][ 'code' ] !== \T_FUNCTION && $tokens[ $stackPtr ][ 'code' ] !== \T_CLOSURE ) {
             return array();
         }
 
-        $parameters = PHPCSHelper::getMethodParameters($phpcsFile, $stackPtr);
-        if (empty($parameters) || \is_array($parameters) === false) {
+        $parameters = PHPCSHelper::getMethodParameters( $phpcsFile, $stackPtr );
+        if ( empty( $parameters ) || \is_array( $parameters ) === false ) {
             return array();
         }
 
         $typeHints = array();
 
-        foreach ($parameters as $param) {
-            if ($param['type_hint'] === '') {
+        foreach ( $parameters as $param ) {
+            if ( $param[ 'type_hint' ] === '' ) {
                 continue;
             }
 
             // Strip off potential nullable indication.
-            $typeHint = ltrim($param['type_hint'], '?');
+            $typeHint = ltrim( $param[ 'type_hint' ], '?' );
 
             // Strip off potential (global) namespace indication.
-            $typeHint = ltrim($typeHint, '\\');
+            $typeHint = ltrim( $typeHint, '\\' );
 
-            if ($typeHint !== '') {
-                $typeHints[] = $typeHint;
+            if ( $typeHint !== '' ) {
+                $typeHints[ ] = $typeHint;
             }
         }
 
@@ -1238,36 +1238,36 @@ 
      * @return string|false The algorithm name without quotes if this was a relevant hash
      *                      function call or false if it was not.
      */
-    public function getHashAlgorithmParameter(File $phpcsFile, $stackPtr)
+    public function getHashAlgorithmParameter( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
         // Check for the existence of the token.
-        if (isset($tokens[$stackPtr]) === false) {
+        if ( isset( $tokens[ $stackPtr ] ) === false ) {
             return false;
         }
 
-        if ($tokens[$stackPtr]['code'] !== \T_STRING) {
+        if ( $tokens[ $stackPtr ][ 'code' ] !== \T_STRING ) {
             return false;
         }
 
-        $functionName   = $tokens[$stackPtr]['content'];
-        $functionNameLc = strtolower($functionName);
+        $functionName   = $tokens[ $stackPtr ][ 'content' ];
+        $functionNameLc = strtolower( $functionName );
 
         // Bow out if not one of the functions we're targetting.
-        if (isset($this->hashAlgoFunctions[$functionNameLc]) === false) {
+        if ( isset( $this->hashAlgoFunctions[ $functionNameLc ] ) === false ) {
             return false;
         }
 
         // Get the parameter from the function call which should contain the algorithm name.
-        $algoParam = $this->getFunctionCallParameter($phpcsFile, $stackPtr, $this->hashAlgoFunctions[$functionNameLc]);
-        if ($algoParam === false) {
+        $algoParam = $this->getFunctionCallParameter( $phpcsFile, $stackPtr, $this->hashAlgoFunctions[ $functionNameLc ] );
+        if ( $algoParam === false ) {
             return false;
         }
 
         // Algorithm is a text string, so we need to remove the quotes.
-        $algo = strtolower(trim($algoParam['raw']));
-        $algo = $this->stripQuotes($algo);
+        $algo = strtolower( trim( $algoParam[ 'raw' ] ) );
+        $algo = $this->stripQuotes( $algo );
 
         return $algo;
     }
@@ -1281,36 +1281,36 @@ 
      *
      * @return bool
      */
-    public function isUseOfGlobalConstant(File $phpcsFile, $stackPtr)
+    public function isUseOfGlobalConstant( File $phpcsFile, $stackPtr )
     {
         static $isLowPHPCS, $isLowPHP;
 
         $tokens = $phpcsFile->getTokens();
 
         // Check for the existence of the token.
-        if (isset($tokens[$stackPtr]) === false) {
+        if ( isset( $tokens[ $stackPtr ] ) === false ) {
             return false;
         }
 
         // Is this one of the tokens this function handles ?
-        if ($tokens[$stackPtr]['code'] !== \T_STRING) {
+        if ( $tokens[ $stackPtr ][ 'code' ] !== \T_STRING ) {
             return false;
         }
 
         // Check for older PHP, PHPCS version so we can compensate for misidentified tokens.
-        if (isset($isLowPHPCS, $isLowPHP) === false) {
+        if ( isset( $isLowPHPCS, $isLowPHP ) === false ) {
             $isLowPHP   = false;
             $isLowPHPCS = false;
-            if (version_compare(\PHP_VERSION_ID, '50400', '<')) {
+            if ( version_compare( \PHP_VERSION_ID, '50400', '<' ) ) {
                 $isLowPHP   = true;
-                $isLowPHPCS = version_compare(PHPCSHelper::getVersion(), '2.4.0', '<');
+                $isLowPHPCS = version_compare( PHPCSHelper::getVersion(), '2.4.0', '<' );
             }
         }
 
-        $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true);
-        if ($next !== false
-            && ($tokens[$next]['code'] === \T_OPEN_PARENTHESIS
-                || $tokens[$next]['code'] === \T_DOUBLE_COLON)
+        $next = $phpcsFile->findNext( Tokens::$emptyTokens, ( $stackPtr + 1 ), null, true );
+        if ( $next !== false
+            && ( $tokens[ $next ][ 'code' ] === \T_OPEN_PARENTHESIS
+                || $tokens[ $next ][ 'code' ] === \T_DOUBLE_COLON )
         ) {
             // Function call or declaration.
             return false;
@@ -1338,30 +1338,30 @@ 
             'T_PRIVATE'         => true,
         );
 
-        $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true);
-        if ($prev !== false
-            && (isset($tokensToIgnore[$tokens[$prev]['type']]) === true
-                || ($tokens[$prev]['code'] === \T_STRING
-                    && (($isLowPHPCS === true
-                        && $tokens[$prev]['content'] === 'trait')
-                    || ($isLowPHP === true
-                        && $tokens[$prev]['content'] === 'insteadof'))))
+        $prev = $phpcsFile->findPrevious( Tokens::$emptyTokens, ( $stackPtr - 1 ), null, true );
+        if ( $prev !== false
+            && ( isset( $tokensToIgnore[ $tokens[ $prev ][ 'type' ] ] ) === true
+                || ( $tokens[ $prev ][ 'code' ] === \T_STRING
+                    && ( ( $isLowPHPCS === true
+                        && $tokens[ $prev ][ 'content' ] === 'trait' )
+                    || ( $isLowPHP === true
+                        && $tokens[ $prev ][ 'content' ] === 'insteadof' ) ) ) )
         ) {
             // Not the use of a constant.
             return false;
         }
 
-        if ($prev !== false
-            && $tokens[$prev]['code'] === \T_NS_SEPARATOR
-            && $tokens[($prev - 1)]['code'] === \T_STRING
+        if ( $prev !== false
+            && $tokens[ $prev ][ 'code' ] === \T_NS_SEPARATOR
+            && $tokens[ ( $prev - 1 ) ][ 'code' ] === \T_STRING
         ) {
             // Namespaced constant of the same name.
             return false;
         }
 
-        if ($prev !== false
-            && $tokens[$prev]['code'] === \T_CONST
-            && $this->isClassConstant($phpcsFile, $prev) === true
+        if ( $prev !== false
+            && $tokens[ $prev ][ 'code' ] === \T_CONST
+            && $this->isClassConstant( $phpcsFile, $prev ) === true
         ) {
             // Class constant declaration of the same name.
             return false;
@@ -1370,21 +1370,21 @@ 
         /*
          * Deal with a number of variations of use statements.
          */
-        for ($i = $stackPtr; $i > 0; $i--) {
-            if ($tokens[$i]['line'] !== $tokens[$stackPtr]['line']) {
+        for ( $i = $stackPtr; $i > 0; $i-- ) {
+            if ( $tokens[ $i ][ 'line' ] !== $tokens[ $stackPtr ][ 'line' ] ) {
                 break;
             }
         }
 
-        $firstOnLine = $phpcsFile->findNext(Tokens::$emptyTokens, ($i + 1), null, true);
-        if ($firstOnLine !== false && $tokens[$firstOnLine]['code'] === \T_USE) {
-            $nextOnLine = $phpcsFile->findNext(Tokens::$emptyTokens, ($firstOnLine + 1), null, true);
-            if ($nextOnLine !== false) {
-                if (($tokens[$nextOnLine]['code'] === \T_STRING && $tokens[$nextOnLine]['content'] === 'const')
-                    || $tokens[$nextOnLine]['code'] === \T_CONST // Happens in some PHPCS versions.
+        $firstOnLine = $phpcsFile->findNext( Tokens::$emptyTokens, ( $i + 1 ), null, true );
+        if ( $firstOnLine !== false && $tokens[ $firstOnLine ][ 'code' ] === \T_USE ) {
+            $nextOnLine = $phpcsFile->findNext( Tokens::$emptyTokens, ( $firstOnLine + 1 ), null, true );
+            if ( $nextOnLine !== false ) {
+                if ( ( $tokens[ $nextOnLine ][ 'code' ] === \T_STRING && $tokens[ $nextOnLine ][ 'content' ] === 'const' )
+                    || $tokens[ $nextOnLine ][ 'code' ] === \T_CONST // Happens in some PHPCS versions.
                 ) {
-                    $hasNsSep = $phpcsFile->findNext(\T_NS_SEPARATOR, ($nextOnLine + 1), $stackPtr);
-                    if ($hasNsSep !== false) {
+                    $hasNsSep = $phpcsFile->findNext( \T_NS_SEPARATOR, ( $nextOnLine + 1 ), $stackPtr );
+                    if ( $hasNsSep !== false ) {
                         // Namespaced const (group) use statement.
                         return false;
                     }
@@ -1419,15 +1419,15 @@ 
      *              False if not or if it could not be reliably determined
      *              (variable or calculations and such).
      */
-    public function isPositiveNumber(File $phpcsFile, $start, $end, $allowFloats = false)
+    public function isPositiveNumber( File $phpcsFile, $start, $end, $allowFloats = false )
     {
-        $number = $this->isNumber($phpcsFile, $start, $end, $allowFloats);
+        $number = $this->isNumber( $phpcsFile, $start, $end, $allowFloats );
 
-        if ($number === false) {
+        if ( $number === false ) {
             return false;
         }
 
-        return ($number > 0);
+        return ( $number > 0 );
     }
 
 
@@ -1451,15 +1451,15 @@ 
      *              False if not or if it could not be reliably determined
      *              (variable or calculations and such).
      */
-    public function isNegativeNumber(File $phpcsFile, $start, $end, $allowFloats = false)
+    public function isNegativeNumber( File $phpcsFile, $start, $end, $allowFloats = false )
     {
-        $number = $this->isNumber($phpcsFile, $start, $end, $allowFloats);
+        $number = $this->isNumber( $phpcsFile, $start, $end, $allowFloats );
 
-        if ($number === false) {
+        if ( $number === false ) {
             return false;
         }
 
-        return ($number < 0);
+        return ( $number < 0 );
     }
 
     /**
@@ -1488,89 +1488,89 @@ 
      *                        number or if it could not be reliably determined
      *                        (variable or calculations and such).
      */
-    protected function isNumber(File $phpcsFile, $start, $end, $allowFloats = false)
+    protected function isNumber( File $phpcsFile, $start, $end, $allowFloats = false )
     {
         $stringTokens = Tokens::$heredocTokens + Tokens::$stringTokens;
 
         $validTokens             = array();
-        $validTokens[\T_LNUMBER] = true;
-        $validTokens[\T_TRUE]    = true; // Evaluates to int 1.
-        $validTokens[\T_FALSE]   = true; // Evaluates to int 0.
-        $validTokens[\T_NULL]    = true; // Evaluates to int 0.
+        $validTokens[ \T_LNUMBER ] = true;
+        $validTokens[ \T_TRUE ]    = true; // Evaluates to int 1.
+        $validTokens[ \T_FALSE ]   = true; // Evaluates to int 0.
+        $validTokens[ \T_NULL ]    = true; // Evaluates to int 0.
 
-        if ($allowFloats === true) {
-            $validTokens[\T_DNUMBER] = true;
+        if ( $allowFloats === true ) {
+            $validTokens[ \T_DNUMBER ] = true;
         }
 
         $maybeValidTokens = $stringTokens + $validTokens;
 
         $tokens         = $phpcsFile->getTokens();
-        $searchEnd      = ($end + 1);
+        $searchEnd      = ( $end + 1 );
         $negativeNumber = false;
 
-        if (isset($tokens[$start], $tokens[$searchEnd]) === false) {
+        if ( isset( $tokens[ $start ], $tokens[ $searchEnd ] ) === false ) {
             return false;
         }
 
-        $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, $start, $searchEnd, true);
-        while ($nextNonEmpty !== false
-            && ($tokens[$nextNonEmpty]['code'] === \T_PLUS
-            || $tokens[$nextNonEmpty]['code'] === \T_MINUS)
+        $nextNonEmpty = $phpcsFile->findNext( Tokens::$emptyTokens, $start, $searchEnd, true );
+        while ( $nextNonEmpty !== false
+            && ( $tokens[ $nextNonEmpty ][ 'code' ] === \T_PLUS
+            || $tokens[ $nextNonEmpty ][ 'code' ] === \T_MINUS )
         ) {
 
-            if ($tokens[$nextNonEmpty]['code'] === \T_MINUS) {
-                $negativeNumber = ($negativeNumber === false) ? true : false;
+            if ( $tokens[ $nextNonEmpty ][ 'code' ] === \T_MINUS ) {
+                $negativeNumber = ( $negativeNumber === false ) ? true : false;
             }
 
-            $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($nextNonEmpty + 1), $searchEnd, true);
+            $nextNonEmpty = $phpcsFile->findNext( Tokens::$emptyTokens, ( $nextNonEmpty + 1 ), $searchEnd, true );
         }
 
-        if ($nextNonEmpty === false || isset($maybeValidTokens[$tokens[$nextNonEmpty]['code']]) === false) {
+        if ( $nextNonEmpty === false || isset( $maybeValidTokens[ $tokens[ $nextNonEmpty ][ 'code' ] ] ) === false ) {
             return false;
         }
 
         $content = false;
-        if ($tokens[$nextNonEmpty]['code'] === \T_LNUMBER
-            || $tokens[$nextNonEmpty]['code'] === \T_DNUMBER
+        if ( $tokens[ $nextNonEmpty ][ 'code' ] === \T_LNUMBER
+            || $tokens[ $nextNonEmpty ][ 'code' ] === \T_DNUMBER
         ) {
-            $content = (float) $tokens[$nextNonEmpty]['content'];
-        } elseif ($tokens[$nextNonEmpty]['code'] === \T_TRUE) {
+            $content = (float)$tokens[ $nextNonEmpty ][ 'content' ];
+        } elseif ( $tokens[ $nextNonEmpty ][ 'code' ] === \T_TRUE ) {
             $content = 1.0;
-        } elseif ($tokens[$nextNonEmpty]['code'] === \T_FALSE
-            || $tokens[$nextNonEmpty]['code'] === \T_NULL
+        } elseif ( $tokens[ $nextNonEmpty ][ 'code' ] === \T_FALSE
+            || $tokens[ $nextNonEmpty ][ 'code' ] === \T_NULL
         ) {
             $content = 0.0;
-        } elseif (isset($stringTokens[$tokens[$nextNonEmpty]['code']]) === true) {
+        } elseif ( isset( $stringTokens[ $tokens[ $nextNonEmpty ][ 'code' ] ] ) === true ) {
 
-            if ($tokens[$nextNonEmpty]['code'] === \T_START_HEREDOC
-                || $tokens[$nextNonEmpty]['code'] === \T_START_NOWDOC
+            if ( $tokens[ $nextNonEmpty ][ 'code' ] === \T_START_HEREDOC
+                || $tokens[ $nextNonEmpty ][ 'code' ] === \T_START_NOWDOC
             ) {
                 // Skip past heredoc/nowdoc opener to the first content.
-                $firstDocToken = $phpcsFile->findNext(array(\T_HEREDOC, \T_NOWDOC), ($nextNonEmpty + 1), $searchEnd);
-                if ($firstDocToken === false) {
+                $firstDocToken = $phpcsFile->findNext( array( \T_HEREDOC, \T_NOWDOC ), ( $nextNonEmpty + 1 ), $searchEnd );
+                if ( $firstDocToken === false ) {
                     // Live coding or parse error.
                     return false;
                 }
 
-                $stringContent = $content = $tokens[$firstDocToken]['content'];
+                $stringContent = $content = $tokens[ $firstDocToken ][ 'content' ];
 
                 // Skip forward to the end in preparation for the next part of the examination.
-                $nextNonEmpty = $phpcsFile->findNext(array(\T_END_HEREDOC, \T_END_NOWDOC), ($nextNonEmpty + 1), $searchEnd);
-                if ($nextNonEmpty === false) {
+                $nextNonEmpty = $phpcsFile->findNext( array( \T_END_HEREDOC, \T_END_NOWDOC ), ( $nextNonEmpty + 1 ), $searchEnd );
+                if ( $nextNonEmpty === false ) {
                     // Live coding or parse error.
                     return false;
                 }
             } else {
                 // Gather subsequent lines for a multi-line string.
-                for ($i = $nextNonEmpty; $i < $searchEnd; $i++) {
-                    if ($tokens[$i]['code'] !== $tokens[$nextNonEmpty]['code']) {
+                for ( $i = $nextNonEmpty; $i < $searchEnd; $i++ ) {
+                    if ( $tokens[ $i ][ 'code' ] !== $tokens[ $nextNonEmpty ][ 'code' ] ) {
                         break;
                     }
-                    $content .= $tokens[$i]['content'];
+                    $content .= $tokens[ $i ][ 'content' ];
                 }
 
                 $nextNonEmpty  = --$i;
-                $content       = $this->stripQuotes($content);
+                $content       = $this->stripQuotes( $content );
                 $stringContent = $content;
             }
 
@@ -1581,40 +1581,40 @@ 
             $regexInt   = '`^\s*[0-9]+`';
             $regexFloat = '`^\s*(?:[+-]?(?:(?:(?P<LNUM>[0-9]+)|(?P<DNUM>([0-9]*\.(?P>LNUM)|(?P>LNUM)\.[0-9]*)))[eE][+-]?(?P>LNUM))|(?P>DNUM))`';
 
-            $intString   = preg_match($regexInt, $content, $intMatch);
-            $floatString = preg_match($regexFloat, $content, $floatMatch);
+            $intString   = preg_match( $regexInt, $content, $intMatch );
+            $floatString = preg_match( $regexFloat, $content, $floatMatch );
 
             // Does the text string start with a number ? If so, PHP would juggle it and use it as a number.
-            if ($allowFloats === false) {
-                if ($intString !== 1 || $floatString === 1) {
-                    if ($floatString === 1) {
+            if ( $allowFloats === false ) {
+                if ( $intString !== 1 || $floatString === 1 ) {
+                    if ( $floatString === 1 ) {
                         // Found float. Only integers targetted.
                         return false;
                     }
 
                     $content = 0.0;
                 } else {
-                    $content = (float) trim($intMatch[0]);
+                    $content = (float)trim( $intMatch[ 0 ] );
                 }
             } else {
-                if ($intString !== 1 && $floatString !== 1) {
+                if ( $intString !== 1 && $floatString !== 1 ) {
                     $content = 0.0;
                 } else {
-                    $content = ($floatString === 1) ? (float) trim($floatMatch[0]) : (float) trim($intMatch[0]);
+                    $content = ( $floatString === 1 ) ? (float)trim( $floatMatch[ 0 ] ) : (float)trim( $intMatch[ 0 ] );
                 }
             }
 
             // Allow for different behaviour for hex numeric strings between PHP 5 vs PHP 7.
-            if ($intString === 1 && trim($intMatch[0]) === '0'
-                && preg_match('`^\s*(0x[A-Fa-f0-9]+)`', $stringContent, $hexNumberString) === 1
-                && $this->supportsBelow('5.6') === true
+            if ( $intString === 1 && trim( $intMatch[ 0 ] ) === '0'
+                && preg_match( '`^\s*(0x[A-Fa-f0-9]+)`', $stringContent, $hexNumberString ) === 1
+                && $this->supportsBelow( '5.6' ) === true
             ) {
                 // The filter extension still allows for hex numeric strings in PHP 7, so
                 // use that to get the numeric value if possible.
                 // If the filter extension is not available, the value will be zero, but so be it.
-                if (function_exists('filter_var')) {
-                    $filtered = filter_var($hexNumberString[1], \FILTER_VALIDATE_INT, \FILTER_FLAG_ALLOW_HEX);
-                    if ($filtered !== false) {
+                if ( function_exists( 'filter_var' ) ) {
+                    $filtered = filter_var( $hexNumberString[ 1 ], \FILTER_VALIDATE_INT, \FILTER_FLAG_ALLOW_HEX );
+                    if ( $filtered !== false ) {
                         $content = $filtered;
                     }
                 }
@@ -1622,17 +1622,17 @@ 
         }
 
         // OK, so we have a number, now is there still more code after it ?
-        $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($nextNonEmpty + 1), $searchEnd, true);
-        if ($nextNonEmpty !== false) {
+        $nextNonEmpty = $phpcsFile->findNext( Tokens::$emptyTokens, ( $nextNonEmpty + 1 ), $searchEnd, true );
+        if ( $nextNonEmpty !== false ) {
             return false;
         }
 
-        if ($negativeNumber === true) {
+        if ( $negativeNumber === true ) {
             $content = -$content;
         }
 
-        if ($allowFloats === false) {
-            return (int) $content;
+        if ( $allowFloats === false ) {
+            return (int)$content;
         }
 
         return $content;
@@ -1656,66 +1656,66 @@ 
      *
      * @return bool
      */
-    protected function isNumericCalculation(File $phpcsFile, $start, $end)
+    protected function isNumericCalculation( File $phpcsFile, $start, $end )
     {
         $arithmeticTokens = Tokens::$arithmeticTokens;
 
         // phpcs:disable PHPCompatibility.Constants.NewConstants.t_powFound
-        if (\defined('T_POW') && isset($arithmeticTokens[\T_POW]) === false) {
+        if ( \defined( 'T_POW' ) && isset( $arithmeticTokens[ \T_POW ] ) === false ) {
             // T_POW was not added to the arithmetic array until PHPCS 2.9.0.
-            $arithmeticTokens[\T_POW] = \T_POW;
+            $arithmeticTokens[ \T_POW ] = \T_POW;
         }
         // phpcs:enable
 
         $skipTokens   = Tokens::$emptyTokens;
-        $skipTokens[] = \T_MINUS;
-        $skipTokens[] = \T_PLUS;
+        $skipTokens[ ] = \T_MINUS;
+        $skipTokens[ ] = \T_PLUS;
 
         // Find the first arithmetic operator, but skip past +/- signs before numbers.
-        $nextNonEmpty = ($start - 1);
+        $nextNonEmpty = ( $start - 1 );
         do {
-            $nextNonEmpty       = $phpcsFile->findNext($skipTokens, ($nextNonEmpty + 1), ($end + 1), true);
-            $arithmeticOperator = $phpcsFile->findNext($arithmeticTokens, ($nextNonEmpty + 1), ($end + 1));
-        } while ($nextNonEmpty !== false && $arithmeticOperator !== false && $nextNonEmpty === $arithmeticOperator);
+            $nextNonEmpty       = $phpcsFile->findNext( $skipTokens, ( $nextNonEmpty + 1 ), ( $end + 1 ), true );
+            $arithmeticOperator = $phpcsFile->findNext( $arithmeticTokens, ( $nextNonEmpty + 1 ), ( $end + 1 ) );
+        } while ( $nextNonEmpty !== false && $arithmeticOperator !== false && $nextNonEmpty === $arithmeticOperator );
 
-        if ($arithmeticOperator === false) {
+        if ( $arithmeticOperator === false ) {
             return false;
         }
 
         $tokens      = $phpcsFile->getTokens();
         $subsetStart = $start;
-        $subsetEnd   = ($arithmeticOperator - 1);
+        $subsetEnd   = ( $arithmeticOperator - 1 );
 
-        while ($this->isNumber($phpcsFile, $subsetStart, $subsetEnd, true) !== false
-            && isset($tokens[($arithmeticOperator + 1)]) === true
+        while ( $this->isNumber( $phpcsFile, $subsetStart, $subsetEnd, true ) !== false
+            && isset( $tokens[ ( $arithmeticOperator + 1 ) ] ) === true
         ) {
             // Recognize T_POW for PHPCS < 2.4.0 on low PHP versions.
-            if (\defined('T_POW') === false
-                && $tokens[$arithmeticOperator]['code'] === \T_MULTIPLY
-                && $tokens[($arithmeticOperator + 1)]['code'] === \T_MULTIPLY
-                && isset($tokens[$arithmeticOperator + 2]) === true
+            if ( \defined( 'T_POW' ) === false
+                && $tokens[ $arithmeticOperator ][ 'code' ] === \T_MULTIPLY
+                && $tokens[ ( $arithmeticOperator + 1 ) ][ 'code' ] === \T_MULTIPLY
+                && isset( $tokens[ $arithmeticOperator + 2 ] ) === true
             ) {
                 // Move operator one forward to the second * in T_POW.
                 ++$arithmeticOperator;
             }
 
-            $subsetStart  = ($arithmeticOperator + 1);
+            $subsetStart  = ( $arithmeticOperator + 1 );
             $nextNonEmpty = $arithmeticOperator;
             do {
-                $nextNonEmpty       = $phpcsFile->findNext($skipTokens, ($nextNonEmpty + 1), ($end + 1), true);
-                $arithmeticOperator = $phpcsFile->findNext($arithmeticTokens, ($nextNonEmpty + 1), ($end + 1));
-            } while ($nextNonEmpty !== false && $arithmeticOperator !== false && $nextNonEmpty === $arithmeticOperator);
+                $nextNonEmpty       = $phpcsFile->findNext( $skipTokens, ( $nextNonEmpty + 1 ), ( $end + 1 ), true );
+                $arithmeticOperator = $phpcsFile->findNext( $arithmeticTokens, ( $nextNonEmpty + 1 ), ( $end + 1 ) );
+            } while ( $nextNonEmpty !== false && $arithmeticOperator !== false && $nextNonEmpty === $arithmeticOperator );
 
-            if ($arithmeticOperator === false) {
+            if ( $arithmeticOperator === false ) {
                 // Last calculation operator already reached.
-                if ($this->isNumber($phpcsFile, $subsetStart, $end, true) !== false) {
+                if ( $this->isNumber( $phpcsFile, $subsetStart, $end, true ) !== false ) {
                     return true;
                 }
 
                 return false;
             }
 
-            $subsetEnd = ($arithmeticOperator - 1);
+            $subsetEnd = ( $arithmeticOperator - 1 );
         }
 
         return false;
@@ -1741,22 +1741,22 @@ 
      *
      * @return bool True if short ternary, or false otherwise.
      */
-    public function isShortTernary(File $phpcsFile, $stackPtr)
+    public function isShortTernary( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
-        if (isset($tokens[$stackPtr]) === false
-            || $tokens[$stackPtr]['code'] !== \T_INLINE_THEN
+        if ( isset( $tokens[ $stackPtr ] ) === false
+            || $tokens[ $stackPtr ][ 'code' ] !== \T_INLINE_THEN
         ) {
             return false;
         }
 
-        $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true);
-        if ($nextNonEmpty === false) {
+        $nextNonEmpty = $phpcsFile->findNext( Tokens::$emptyTokens, ( $stackPtr + 1 ), null, true );
+        if ( $nextNonEmpty === false ) {
             // Live coding or parse error.
             return false;
         }
 
-        if ($tokens[$nextNonEmpty]['code'] === \T_INLINE_ELSE) {
+        if ( $tokens[ $nextNonEmpty ][ 'code' ] === \T_INLINE_ELSE ) {
             return true;
         }
 
@@ -1775,39 +1775,39 @@ 
      *
      * @return bool
      */
-    public function isShortList(File $phpcsFile, $stackPtr)
+    public function isShortList( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
         // Check for the existence of the token.
-        if (isset($tokens[$stackPtr]) === false) {
+        if ( isset( $tokens[ $stackPtr ] ) === false ) {
             return false;
         }
 
         // Is this one of the tokens this function handles ?
-        if ($tokens[$stackPtr]['code'] !== \T_OPEN_SHORT_ARRAY
-            && $tokens[$stackPtr]['code'] !== \T_CLOSE_SHORT_ARRAY
+        if ( $tokens[ $stackPtr ][ 'code' ] !== \T_OPEN_SHORT_ARRAY
+            && $tokens[ $stackPtr ][ 'code' ] !== \T_CLOSE_SHORT_ARRAY
         ) {
             return false;
         }
 
-        switch ($tokens[$stackPtr]['code']) {
+        switch ( $tokens[ $stackPtr ][ 'code' ] ) {
             case \T_OPEN_SHORT_ARRAY:
-                if (isset($tokens[$stackPtr]['bracket_closer']) === true) {
+                if ( isset( $tokens[ $stackPtr ][ 'bracket_closer' ] ) === true ) {
                     $opener = $stackPtr;
-                    $closer = $tokens[$stackPtr]['bracket_closer'];
+                    $closer = $tokens[ $stackPtr ][ 'bracket_closer' ];
                 }
                 break;
 
             case \T_CLOSE_SHORT_ARRAY:
-                if (isset($tokens[$stackPtr]['bracket_opener']) === true) {
-                    $opener = $tokens[$stackPtr]['bracket_opener'];
+                if ( isset( $tokens[ $stackPtr ][ 'bracket_opener' ] ) === true ) {
+                    $opener = $tokens[ $stackPtr ][ 'bracket_opener' ];
                     $closer = $stackPtr;
                 }
                 break;
         }
 
-        if (isset($opener, $closer) === false) {
+        if ( isset( $opener, $closer ) === false ) {
             // Parse error, live coding or real square bracket.
             return false;
         }
@@ -1816,42 +1816,42 @@ 
          * PHPCS cross-version compatibility: work around for square brackets misidentified
          * as short array when preceded by a variable variable in older PHPCS versions.
          */
-        $prevNonEmpty = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($opener - 1), null, true, null, true);
+        $prevNonEmpty = $phpcsFile->findPrevious( Tokens::$emptyTokens, ( $opener - 1 ), null, true, null, true );
 
-        if ($prevNonEmpty !== false
-            && $tokens[$prevNonEmpty]['code'] === \T_CLOSE_CURLY_BRACKET
-            && isset($tokens[$prevNonEmpty]['bracket_opener']) === true
+        if ( $prevNonEmpty !== false
+            && $tokens[ $prevNonEmpty ][ 'code' ] === \T_CLOSE_CURLY_BRACKET
+            && isset( $tokens[ $prevNonEmpty ][ 'bracket_opener' ] ) === true
         ) {
             $maybeVariableVariable = $phpcsFile->findPrevious(
                 Tokens::$emptyTokens,
-                ($tokens[$prevNonEmpty]['bracket_opener'] - 1),
+                ( $tokens[ $prevNonEmpty ][ 'bracket_opener' ] - 1 ),
                 null,
                 true,
                 null,
                 true
             );
 
-            if ($tokens[$maybeVariableVariable]['code'] === \T_VARIABLE
-                || $tokens[$maybeVariableVariable]['code'] === \T_DOLLAR
+            if ( $tokens[ $maybeVariableVariable ][ 'code' ] === \T_VARIABLE
+                || $tokens[ $maybeVariableVariable ][ 'code' ] === \T_DOLLAR
             ) {
                 return false;
             }
         }
 
-        $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($closer + 1), null, true, null, true);
+        $nextNonEmpty = $phpcsFile->findNext( Tokens::$emptyTokens, ( $closer + 1 ), null, true, null, true );
 
-        if ($nextNonEmpty !== false && $tokens[$nextNonEmpty]['code'] === \T_EQUAL) {
+        if ( $nextNonEmpty !== false && $tokens[ $nextNonEmpty ][ 'code' ] === \T_EQUAL ) {
             return true;
         }
 
-        if ($prevNonEmpty !== false
-            && $tokens[$prevNonEmpty]['code'] === \T_AS
-            && isset($tokens[$prevNonEmpty]['nested_parenthesis']) === true
+        if ( $prevNonEmpty !== false
+            && $tokens[ $prevNonEmpty ][ 'code' ] === \T_AS
+            && isset( $tokens[ $prevNonEmpty ][ 'nested_parenthesis' ] ) === true
         ) {
-            $parentheses = array_reverse($tokens[$prevNonEmpty]['nested_parenthesis'], true);
-            foreach ($parentheses as $open => $close) {
-                if (isset($tokens[$open]['parenthesis_owner'])
-                    && $tokens[$tokens[$open]['parenthesis_owner']]['code'] === \T_FOREACH
+            $parentheses = array_reverse( $tokens[ $prevNonEmpty ][ 'nested_parenthesis' ], true );
+            foreach ( $parentheses as $open => $close ) {
+                if ( isset( $tokens[ $open ][ 'parenthesis_owner' ] )
+                    && $tokens[ $tokens[ $open ][ 'parenthesis_owner' ] ][ 'code' ] === \T_FOREACH
                 ) {
                     return true;
                 }
@@ -1862,48 +1862,48 @@ 
         $parentOpener = $opener;
         do {
             $parentOpener = $phpcsFile->findPrevious(
-                array(\T_OPEN_SHORT_ARRAY, \T_OPEN_SQUARE_BRACKET),
-                ($parentOpener - 1),
+                array( \T_OPEN_SHORT_ARRAY, \T_OPEN_SQUARE_BRACKET ),
+                ( $parentOpener - 1 ),
                 null,
                 false,
                 null,
                 true
             );
 
-            if ($parentOpener === false) {
+            if ( $parentOpener === false ) {
                 return false;
             }
 
-        } while (isset($tokens[$parentOpener]['bracket_closer']) === true
-            && $tokens[$parentOpener]['bracket_closer'] < $opener
+        } while ( isset( $tokens[ $parentOpener ][ 'bracket_closer' ] ) === true
+            && $tokens[ $parentOpener ][ 'bracket_closer' ] < $opener
         );
 
-        if (isset($tokens[$parentOpener]['bracket_closer']) === true
-            && $tokens[$parentOpener]['bracket_closer'] > $closer
+        if ( isset( $tokens[ $parentOpener ][ 'bracket_closer' ] ) === true
+            && $tokens[ $parentOpener ][ 'bracket_closer' ] > $closer
         ) {
             // Work around tokenizer issue in PHPCS 2.0 - 2.7.
             $phpcsVersion = PHPCSHelper::getVersion();
-            if ((version_compare($phpcsVersion, '2.0', '>') === true
-                && version_compare($phpcsVersion, '2.8', '<') === true)
-                && $tokens[$parentOpener]['code'] === \T_OPEN_SQUARE_BRACKET
+            if ( ( version_compare( $phpcsVersion, '2.0', '>' ) === true
+                && version_compare( $phpcsVersion, '2.8', '<' ) === true )
+                && $tokens[ $parentOpener ][ 'code' ] === \T_OPEN_SQUARE_BRACKET
             ) {
                 $nextNonEmpty = $phpcsFile->findNext(
                     Tokens::$emptyTokens,
-                    ($tokens[$parentOpener]['bracket_closer'] + 1),
+                    ( $tokens[ $parentOpener ][ 'bracket_closer' ] + 1 ),
                     null,
                     true,
                     null,
                     true
                 );
 
-                if ($nextNonEmpty !== false && $tokens[$nextNonEmpty]['code'] === \T_EQUAL) {
+                if ( $nextNonEmpty !== false && $tokens[ $nextNonEmpty ][ 'code' ] === \T_EQUAL ) {
                     return true;
                 }
 
                 return false;
             }
 
-            return $this->isShortList($phpcsFile, $parentOpener);
+            return $this->isShortList( $phpcsFile, $parentOpener );
         }
 
         return false;
@@ -1922,14 +1922,14 @@ 
      *
      * @return bool
      */
-    public function isVariable(File $phpcsFile, $start, $end, $targetNestingLevel)
+    public function isVariable( File $phpcsFile, $start, $end, $targetNestingLevel )
     {
         static $tokenBlackList, $bracketTokens;
 
         // Create the token arrays only once.
-        if (isset($tokenBlackList, $bracketTokens) === false) {
+        if ( isset( $tokenBlackList, $bracketTokens ) === false ) {
 
-            $tokenBlackList  = array(
+            $tokenBlackList = array(
                 \T_OPEN_PARENTHESIS => \T_OPEN_PARENTHESIS,
                 \T_STRING_CONCAT    => \T_STRING_CONCAT,
             );
@@ -1954,43 +1954,43 @@ 
         $tokens = $phpcsFile->getTokens();
 
         // If no variable at all was found, then it's definitely a no-no.
-        $hasVariable = $phpcsFile->findNext(\T_VARIABLE, $start, $end);
-        if ($hasVariable === false) {
+        $hasVariable = $phpcsFile->findNext( \T_VARIABLE, $start, $end );
+        if ( $hasVariable === false ) {
             return false;
         }
 
         // Check if the variable found is at the right level. Deeper levels are always an error.
-        if (isset($tokens[$hasVariable]['nested_parenthesis'])
-            && \count($tokens[$hasVariable]['nested_parenthesis']) !== $targetNestingLevel
+        if ( isset( $tokens[ $hasVariable ][ 'nested_parenthesis' ] )
+            && \count( $tokens[ $hasVariable ][ 'nested_parenthesis' ] ) !== $targetNestingLevel
         ) {
                 return false;
         }
 
         // Ok, so the first variable is at the right level, now are there any
         // blacklisted tokens within the empty() ?
-        $hasBadToken = $phpcsFile->findNext($tokenBlackList, $start, $end);
-        if ($hasBadToken === false) {
+        $hasBadToken = $phpcsFile->findNext( $tokenBlackList, $start, $end );
+        if ( $hasBadToken === false ) {
             return true;
         }
 
         // If there are also bracket tokens, the blacklisted token might be part of a variable
         // variable, but if there are no bracket tokens, we know we have an error.
-        $hasBrackets = $phpcsFile->findNext($bracketTokens, $start, $end);
-        if ($hasBrackets === false) {
+        $hasBrackets = $phpcsFile->findNext( $bracketTokens, $start, $end );
+        if ( $hasBrackets === false ) {
             return false;
         }
 
         // Ok, we have both a blacklisted token as well as brackets, so we need to walk
         // the tokens of the variable variable.
-        for ($i = $start; $i < $end; $i++) {
+        for ( $i = $start; $i < $end; $i++ ) {
             // If this is a bracket token, skip to the end of the bracketed expression.
-            if (isset($bracketTokens[$tokens[$i]['code']], $tokens[$i]['bracket_closer'])) {
-                $i = $tokens[$i]['bracket_closer'];
+            if ( isset( $bracketTokens[ $tokens[ $i ][ 'code' ] ], $tokens[ $i ][ 'bracket_closer' ] ) ) {
+                $i = $tokens[ $i ][ 'bracket_closer' ];
                 continue;
             }
 
             // If it's a blacklisted token, not within brackets, we have an error.
-            if (isset($tokenBlackList[$tokens[$i]['code']])) {
+            if ( isset( $tokenBlackList[ $tokens[ $i ][ 'code' ] ] ) ) {
                 return false;
             }
         }
@@ -2016,56 +2016,56 @@ 
      * @return bool True if the token passed is a unary operator.
      *              False otherwise or if the token is not a T_PLUS/T_MINUS token.
      */
-    public static function isUnaryPlusMinus(File $phpcsFile, $stackPtr)
+    public static function isUnaryPlusMinus( File $phpcsFile, $stackPtr )
     {
         $tokens = $phpcsFile->getTokens();
 
-        if (isset($tokens[$stackPtr]) === false
-            || ($tokens[$stackPtr]['code'] !== \T_PLUS
-            && $tokens[$stackPtr]['code'] !== \T_MINUS)
+        if ( isset( $tokens[ $stackPtr ] ) === false
+            || ( $tokens[ $stackPtr ][ 'code' ] !== \T_PLUS
+            && $tokens[ $stackPtr ][ 'code' ] !== \T_MINUS )
         ) {
             return false;
         }
 
-        $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true);
-        if ($next === false) {
+        $next = $phpcsFile->findNext( Tokens::$emptyTokens, ( $stackPtr + 1 ), null, true );
+        if ( $next === false ) {
             // Live coding or parse error.
             return false;
         }
 
-        if (isset(Tokens::$operators[$tokens[$next]['code']]) === true) {
+        if ( isset( Tokens::$operators[ $tokens[ $next ][ 'code' ] ] ) === true ) {
             // Next token is an operator, so this is not a unary.
             return false;
         }
 
-        $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true);
+        $prev = $phpcsFile->findPrevious( Tokens::$emptyTokens, ( $stackPtr - 1 ), null, true );
 
-        if ($tokens[$prev]['code'] === \T_RETURN) {
+        if ( $tokens[ $prev ][ 'code' ] === \T_RETURN ) {
             // Just returning a positive/negative value; eg. (return -1).
             return true;
         }
 
-        if (isset(Tokens::$operators[$tokens[$prev]['code']]) === true) {
+        if ( isset( Tokens::$operators[ $tokens[ $prev ][ 'code' ] ] ) === true ) {
             // Just trying to operate on a positive/negative value; eg. ($var * -1).
             return true;
         }
 
-        if (isset(Tokens::$comparisonTokens[$tokens[$prev]['code']]) === true) {
+        if ( isset( Tokens::$comparisonTokens[ $tokens[ $prev ][ 'code' ] ] ) === true ) {
             // Just trying to compare a positive/negative value; eg. ($var === -1).
             return true;
         }
 
-        if (isset(Tokens::$booleanOperators[$tokens[$prev]['code']]) === true) {
+        if ( isset( Tokens::$booleanOperators[ $tokens[ $prev ][ 'code' ] ] ) === true ) {
             // Just trying to compare a positive/negative value; eg. ($var || -1 === $b).
             return true;
         }
 
-        if (isset(Tokens::$assignmentTokens[$tokens[$prev]['code']]) === true) {
+        if ( isset( Tokens::$assignmentTokens[ $tokens[ $prev ][ 'code' ] ] ) === true ) {
             // Just trying to assign a positive/negative value; eg. ($var = -1).
             return true;
         }
 
-        if (isset(Tokens::$castTokens[$tokens[$prev]['code']]) === true) {
+        if ( isset( Tokens::$castTokens[ $tokens[ $prev ][ 'code' ] ] ) === true ) {
             // Just casting a positive/negative value; eg. (string) -$var.
             return true;
         }
@@ -2084,7 +2084,7 @@ 
             \T_STRING_CONCAT       => true,
         );
 
-        if (isset($invalidTokens[$tokens[$prev]['code']]) === true) {
+        if ( isset( $invalidTokens[ $tokens[ $prev ][ 'code' ] ] ) === true ) {
             // Just trying to use a positive/negative value; eg. myFunction($var, -2).
             return true;
         }

vendor/phpcompatibility/php-compatibility/PHPCompatibility/AbstractComplexVersionSniff.php

Spacing +12 added lines, -12 removed lines

@@ -33,13 +33,13 @@ 
      *
      * @return void
      */
-    public function handleFeature(File $phpcsFile, $stackPtr, array $itemInfo)
+    public function handleFeature( File $phpcsFile, $stackPtr, array $itemInfo )
     {
-        $itemArray = $this->getItemArray($itemInfo);
-        $errorInfo = $this->getErrorInfo($itemArray, $itemInfo);
+        $itemArray = $this->getItemArray( $itemInfo );
+        $errorInfo = $this->getErrorInfo( $itemArray, $itemInfo );
 
-        if ($this->shouldThrowError($errorInfo) === true) {
-            $this->addError($phpcsFile, $stackPtr, $itemInfo, $errorInfo);
+        if ( $this->shouldThrowError( $errorInfo ) === true ) {
+            $this->addError( $phpcsFile, $stackPtr, $itemInfo, $errorInfo );
         }
     }
 
@@ -51,7 +51,7 @@ 
      *
      * @return bool
      */
-    abstract protected function shouldThrowError(array $errorInfo);
+    abstract protected function shouldThrowError( array $errorInfo );
 
 
     /**
@@ -73,9 +73,9 @@ 
      *
      * @return array Array with only the version information.
      */
-    protected function getVersionArray(array $itemArray)
+    protected function getVersionArray( array $itemArray )
     {
-        return array_diff_key($itemArray, array_flip($this->getNonVersionArrayKeys()));
+        return array_diff_key( $itemArray, array_flip( $this->getNonVersionArrayKeys() ) );
     }
 
 
@@ -87,9 +87,9 @@ 
      *
      * @return string
      */
-    protected function getItemName(array $itemInfo, array $errorInfo)
+    protected function getItemName( array $itemInfo, array $errorInfo )
     {
-        return $itemInfo['name'];
+        return $itemInfo[ 'name' ];
     }
 
 
@@ -110,7 +110,7 @@ 
      *
      * @return string
      */
-    protected function filterErrorMsg($error, array $itemInfo, array $errorInfo)
+    protected function filterErrorMsg( $error, array $itemInfo, array $errorInfo )
     {
         return $error;
     }
@@ -125,7 +125,7 @@ 
      *
      * @return array
      */
-    protected function filterErrorData(array $data, array $itemInfo, array $errorInfo)
+    protected function filterErrorData( array $data, array $itemInfo, array $errorInfo )
     {
         return $data;
     }

vendor/phpcompatibility/php-compatibility/PHPCompatibility/AbstractNewFeatureSniff.php

Spacing +16 added lines, -16 removed lines

@@ -29,9 +29,9 @@ 
      *
      * @return bool
      */
-    protected function shouldThrowError(array $errorInfo)
+    protected function shouldThrowError( array $errorInfo )
     {
-        return ($errorInfo['not_in_version'] !== '');
+        return ( $errorInfo[ 'not_in_version' ] !== '' );
     }
 
 
@@ -43,21 +43,21 @@ 
      *
      * @return array
      */
-    public function getErrorInfo(array $itemArray, array $itemInfo)
+    public function getErrorInfo( array $itemArray, array $itemInfo )
     {
         $errorInfo = array(
             'not_in_version' => '',
             'error'          => true,
         );
 
-        $versionArray = $this->getVersionArray($itemArray);
+        $versionArray = $this->getVersionArray( $itemArray );
 
-        if (empty($versionArray) === false) {
-            foreach ($versionArray as $version => $present) {
-                if ($errorInfo['not_in_version'] === '' && $present === false
-                    && $this->supportsBelow($version) === true
+        if ( empty( $versionArray ) === false ) {
+            foreach ( $versionArray as $version => $present ) {
+                if ( $errorInfo[ 'not_in_version' ] === '' && $present === false
+                    && $this->supportsBelow( $version ) === true
                 ) {
-                    $errorInfo['not_in_version'] = $version;
+                    $errorInfo[ 'not_in_version' ] = $version;
                 }
             }
         }
@@ -89,20 +89,20 @@ 
      *
      * @return void
      */
-    public function addError(File $phpcsFile, $stackPtr, array $itemInfo, array $errorInfo)
+    public function addError( File $phpcsFile, $stackPtr, array $itemInfo, array $errorInfo )
     {
-        $itemName = $this->getItemName($itemInfo, $errorInfo);
+        $itemName = $this->getItemName( $itemInfo, $errorInfo );
         $error    = $this->getErrorMsgTemplate();
 
-        $errorCode = $this->stringToErrorCode($itemName) . 'Found';
+        $errorCode = $this->stringToErrorCode( $itemName ) . 'Found';
         $data      = array(
             $itemName,
-            $errorInfo['not_in_version'],
+            $errorInfo[ 'not_in_version' ],
         );
 
-        $error = $this->filterErrorMsg($error, $itemInfo, $errorInfo);
-        $data  = $this->filterErrorData($data, $itemInfo, $errorInfo);
+        $error = $this->filterErrorMsg( $error, $itemInfo, $errorInfo );
+        $data  = $this->filterErrorData( $data, $itemInfo, $errorInfo );
 
-        $this->addMessage($phpcsFile, $error, $stackPtr, $errorInfo['error'], $errorCode, $data);
+        $this->addMessage( $phpcsFile, $error, $stackPtr, $errorInfo[ 'error' ], $errorCode, $data );
     }
 }

vendor/phpcompatibility/php-compatibility/PHPCompatibility/ComplexVersionInterface.php

Spacing +4 added lines, -4 removed lines

@@ -37,7 +37,7 @@ 
      *
      * @return void
      */
-    public function handleFeature(File $phpcsFile, $stackPtr, array $itemInfo);
+    public function handleFeature( File $phpcsFile, $stackPtr, array $itemInfo );
 
 
     /**
@@ -47,7 +47,7 @@ 
      *
      * @return array Version and other information about the item.
      */
-    public function getItemArray(array $itemInfo);
+    public function getItemArray( array $itemInfo );
 
 
     /**
@@ -58,7 +58,7 @@ 
      *
      * @return array
      */
-    public function getErrorInfo(array $itemArray, array $itemInfo);
+    public function getErrorInfo( array $itemArray, array $itemInfo );
 
 
     /**
@@ -73,5 +73,5 @@ 
      *
      * @return void
      */
-    public function addError(File $phpcsFile, $stackPtr, array $itemInfo, array $errorInfo);
+    public function addError( File $phpcsFile, $stackPtr, array $itemInfo, array $errorInfo );
 }

vendor/phpcompatibility/php-compatibility/PHPCompatibility/Sniffs/InitialValue/NewConstantScalarExpressionsSniff.php

Spacing +106 added lines, -106 removed lines

@@ -125,7 +125,7 @@ 
      */
     protected function bowOutEarly()
     {
-        return ($this->supportsBelow('5.5') !== true);
+        return ( $this->supportsBelow( '5.5' ) !== true );
     }
 
 
@@ -138,57 +138,57 @@ 
      *
      * @return void|int Null or integer stack pointer to skip forward.
      */
-    public function process(File $phpcsFile, $stackPtr)
+    public function process( File $phpcsFile, $stackPtr )
     {
-        if ($this->bowOutEarly() === true) {
+        if ( $this->bowOutEarly() === true ) {
             return;
         }
 
         $tokens = $phpcsFile->getTokens();
 
-        switch ($tokens[$stackPtr]['type']) {
+        switch ( $tokens[ $stackPtr ][ 'type' ] ) {
             case 'T_FUNCTION':
             case 'T_CLOSURE':
-                $params = PHPCSHelper::getMethodParameters($phpcsFile, $stackPtr);
-                if (empty($params)) {
+                $params = PHPCSHelper::getMethodParameters( $phpcsFile, $stackPtr );
+                if ( empty( $params ) ) {
                     // No parameters.
                     return;
                 }
 
-                $funcToken = $tokens[$stackPtr];
+                $funcToken = $tokens[ $stackPtr ];
 
-                if (isset($funcToken['parenthesis_owner'], $funcToken['parenthesis_opener'], $funcToken['parenthesis_closer']) === false
-                    || $funcToken['parenthesis_owner'] !== $stackPtr
-                    || isset($tokens[$funcToken['parenthesis_opener']], $tokens[$funcToken['parenthesis_closer']]) === false
+                if ( isset( $funcToken[ 'parenthesis_owner' ], $funcToken[ 'parenthesis_opener' ], $funcToken[ 'parenthesis_closer' ] ) === false
+                    || $funcToken[ 'parenthesis_owner' ] !== $stackPtr
+                    || isset( $tokens[ $funcToken[ 'parenthesis_opener' ] ], $tokens[ $funcToken[ 'parenthesis_closer' ] ] ) === false
                 ) {
                     // Hmm.. something is going wrong as these should all be available & valid.
                     return;
                 }
 
-                $opener = $funcToken['parenthesis_opener'];
-                $closer = $funcToken['parenthesis_closer'];
+                $opener = $funcToken[ 'parenthesis_opener' ];
+                $closer = $funcToken[ 'parenthesis_closer' ];
 
                 // Which nesting level is the one we are interested in ?
                 $nestedParenthesisCount = 1;
-                if (isset($tokens[$opener]['nested_parenthesis'])) {
-                    $nestedParenthesisCount += \count($tokens[$opener]['nested_parenthesis']);
+                if ( isset( $tokens[ $opener ][ 'nested_parenthesis' ] ) ) {
+                    $nestedParenthesisCount += \count( $tokens[ $opener ][ 'nested_parenthesis' ] );
                 }
 
-                foreach ($params as $param) {
-                    if (isset($param['default']) === false) {
+                foreach ( $params as $param ) {
+                    if ( isset( $param[ 'default' ] ) === false ) {
                         continue;
                     }
 
-                    $end = $param['token'];
-                    while (($end = $phpcsFile->findNext(array(\T_COMMA, \T_CLOSE_PARENTHESIS), ($end + 1), ($closer + 1))) !== false) {
-                        $maybeSkipTo = $this->isRealEndOfDeclaration($tokens, $end, $nestedParenthesisCount);
-                        if ($maybeSkipTo !== true) {
+                    $end = $param[ 'token' ];
+                    while ( ( $end = $phpcsFile->findNext( array( \T_COMMA, \T_CLOSE_PARENTHESIS ), ( $end + 1 ), ( $closer + 1 ) ) ) !== false ) {
+                        $maybeSkipTo = $this->isRealEndOfDeclaration( $tokens, $end, $nestedParenthesisCount );
+                        if ( $maybeSkipTo !== true ) {
                             $end = $maybeSkipTo;
                             continue;
                         }
 
                         // Ignore closing parenthesis/bracket if not 'ours'.
-                        if ($tokens[$end]['code'] === \T_CLOSE_PARENTHESIS && $end !== $closer) {
+                        if ( $tokens[ $end ][ 'code' ] === \T_CLOSE_PARENTHESIS && $end !== $closer ) {
                             continue;
                         }
 
@@ -196,8 +196,8 @@ 
                         break;
                     }
 
-                    if ($this->isValidAssignment($phpcsFile, $param['token'], $end) === false) {
-                        $this->throwError($phpcsFile, $param['token'], 'default', $param['content']);
+                    if ( $this->isValidAssignment( $phpcsFile, $param[ 'token' ], $end ) === false ) {
+                        $this->throwError( $phpcsFile, $param[ 'token' ], 'default', $param[ 'content' ] );
                     }
                 }
 
@@ -213,75 +213,75 @@ 
                 $type = 'const';
 
                 // Filter out non-property declarations.
-                if ($tokens[$stackPtr]['code'] === \T_VARIABLE) {
-                    if ($this->isClassProperty($phpcsFile, $stackPtr) === false) {
+                if ( $tokens[ $stackPtr ][ 'code' ] === \T_VARIABLE ) {
+                    if ( $this->isClassProperty( $phpcsFile, $stackPtr ) === false ) {
                         return;
                     }
 
                     $type = 'property';
 
                     // Move back one token to have the same starting point as the others.
-                    $stackPtr = ($stackPtr - 1);
+                    $stackPtr = ( $stackPtr - 1 );
                 }
 
                 // Filter out late static binding and class properties.
-                if ($tokens[$stackPtr]['code'] === \T_STATIC) {
-                    $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true, null, true);
-                    if ($next === false || $tokens[$next]['code'] !== \T_VARIABLE) {
+                if ( $tokens[ $stackPtr ][ 'code' ] === \T_STATIC ) {
+                    $next = $phpcsFile->findNext( Tokens::$emptyTokens, ( $stackPtr + 1 ), null, true, null, true );
+                    if ( $next === false || $tokens[ $next ][ 'code' ] !== \T_VARIABLE ) {
                         // Late static binding.
                         return;
                     }
 
-                    if ($this->isClassProperty($phpcsFile, $next) === true) {
+                    if ( $this->isClassProperty( $phpcsFile, $next ) === true ) {
                         // Class properties are examined based on the T_VARIABLE token.
                         return;
                     }
-                    unset($next);
+                    unset( $next );
 
                     $type = 'staticvar';
                 }
 
-                $endOfStatement = $phpcsFile->findNext(array(\T_SEMICOLON, \T_CLOSE_TAG), ($stackPtr + 1));
-                if ($endOfStatement === false) {
+                $endOfStatement = $phpcsFile->findNext( array( \T_SEMICOLON, \T_CLOSE_TAG ), ( $stackPtr + 1 ) );
+                if ( $endOfStatement === false ) {
                     // No semi-colon - live coding.
                     return;
                 }
 
                 $targetNestingLevel = 0;
-                if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) {
-                    $targetNestingLevel = \count($tokens[$stackPtr]['nested_parenthesis']);
+                if ( isset( $tokens[ $stackPtr ][ 'nested_parenthesis' ] ) === true ) {
+                    $targetNestingLevel = \count( $tokens[ $stackPtr ][ 'nested_parenthesis' ] );
                 }
 
                 // Examine each variable/constant in multi-declarations.
                 $start = $stackPtr;
                 $end   = $stackPtr;
-                while (($end = $phpcsFile->findNext(array(\T_COMMA, \T_SEMICOLON, \T_OPEN_SHORT_ARRAY, \T_CLOSE_TAG), ($end + 1), ($endOfStatement + 1))) !== false) {
+                while ( ( $end = $phpcsFile->findNext( array( \T_COMMA, \T_SEMICOLON, \T_OPEN_SHORT_ARRAY, \T_CLOSE_TAG ), ( $end + 1 ), ( $endOfStatement + 1 ) ) ) !== false ) {
 
-                    $maybeSkipTo = $this->isRealEndOfDeclaration($tokens, $end, $targetNestingLevel);
-                    if ($maybeSkipTo !== true) {
+                    $maybeSkipTo = $this->isRealEndOfDeclaration( $tokens, $end, $targetNestingLevel );
+                    if ( $maybeSkipTo !== true ) {
                         $end = $maybeSkipTo;
                         continue;
                     }
 
-                    $start = $phpcsFile->findNext(Tokens::$emptyTokens, ($start + 1), $end, true);
-                    if ($start === false
-                        || ($tokens[$stackPtr]['code'] === \T_CONST && $tokens[$start]['code'] !== \T_STRING)
-                        || ($tokens[$stackPtr]['code'] !== \T_CONST && $tokens[$start]['code'] !== \T_VARIABLE)
+                    $start = $phpcsFile->findNext( Tokens::$emptyTokens, ( $start + 1 ), $end, true );
+                    if ( $start === false
+                        || ( $tokens[ $stackPtr ][ 'code' ] === \T_CONST && $tokens[ $start ][ 'code' ] !== \T_STRING )
+                        || ( $tokens[ $stackPtr ][ 'code' ] !== \T_CONST && $tokens[ $start ][ 'code' ] !== \T_VARIABLE )
                     ) {
                         // Shouldn't be possible.
                         continue;
                     }
 
-                    if ($this->isValidAssignment($phpcsFile, $start, $end) === false) {
+                    if ( $this->isValidAssignment( $phpcsFile, $start, $end ) === false ) {
                         // Create the "found" snippet.
                         $content    = '';
-                        $tokenCount = ($end - $start);
-                        if ($tokenCount < 20) {
+                        $tokenCount = ( $end - $start );
+                        if ( $tokenCount < 20 ) {
                             // Prevent large arrays from being added to the error message.
-                            $content = $phpcsFile->getTokensAsString($start, ($tokenCount + 1));
+                            $content = $phpcsFile->getTokensAsString( $start, ( $tokenCount + 1 ) );
                         }
 
-                        $this->throwError($phpcsFile, $start, $type, $content);
+                        $this->throwError( $phpcsFile, $start, $type, $content );
                     }
 
                     $start = $end;
@@ -304,16 +304,16 @@ 
      *
      * @return bool
      */
-    protected function isValidAssignment(File $phpcsFile, $stackPtr, $end)
+    protected function isValidAssignment( File $phpcsFile, $stackPtr, $end )
     {
         $tokens = $phpcsFile->getTokens();
-        $next   = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), $end, true);
-        if ($next === false || $tokens[$next]['code'] !== \T_EQUAL) {
+        $next   = $phpcsFile->findNext( Tokens::$emptyTokens, ( $stackPtr + 1 ), $end, true );
+        if ( $next === false || $tokens[ $next ][ 'code' ] !== \T_EQUAL ) {
             // No value assigned.
             return true;
         }
 
-        return $this->isStaticValue($phpcsFile, $tokens, ($next + 1), ($end - 1));
+        return $this->isStaticValue( $phpcsFile, $tokens, ( $next + 1 ), ( $end - 1 ) );
     }
 
 
@@ -331,20 +331,20 @@ 
      *
      * @return bool
      */
-    protected function isStaticValue(File $phpcsFile, $tokens, $start, $end, $nestedArrays = 0)
+    protected function isStaticValue( File $phpcsFile, $tokens, $start, $end, $nestedArrays = 0 )
     {
-        $nextNonSimple = $phpcsFile->findNext($this->safeOperands, $start, ($end + 1), true);
-        if ($nextNonSimple === false) {
+        $nextNonSimple = $phpcsFile->findNext( $this->safeOperands, $start, ( $end + 1 ), true );
+        if ( $nextNonSimple === false ) {
             return true;
         }
 
         /*
          * OK, so we have at least one token which needs extra examination.
          */
-        switch ($tokens[$nextNonSimple]['code']) {
+        switch ( $tokens[ $nextNonSimple ][ 'code' ] ) {
             case \T_MINUS:
             case \T_PLUS:
-                if ($this->isNumber($phpcsFile, $start, $end, true) !== false) {
+                if ( $this->isNumber( $phpcsFile, $start, $end, true ) !== false ) {
                     // Int or float with sign.
                     return true;
                 }
@@ -355,70 +355,70 @@ 
             case \T_PARENT:
             case \T_SELF:
             case \T_DOUBLE_COLON:
-                $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($nextNonSimple + 1), ($end + 1), true);
+                $nextNonEmpty = $phpcsFile->findNext( Tokens::$emptyTokens, ( $nextNonSimple + 1 ), ( $end + 1 ), true );
 
-                if ($tokens[$nextNonSimple]['code'] === \T_NAMESPACE) {
+                if ( $tokens[ $nextNonSimple ][ 'code' ] === \T_NAMESPACE ) {
                     // Allow only `namespace\...`.
-                    if ($nextNonEmpty === false || $tokens[$nextNonEmpty]['code'] !== \T_NS_SEPARATOR) {
+                    if ( $nextNonEmpty === false || $tokens[ $nextNonEmpty ][ 'code' ] !== \T_NS_SEPARATOR ) {
                         return false;
                     }
-                } elseif ($tokens[$nextNonSimple]['code'] === \T_PARENT
-                    || $tokens[$nextNonSimple]['code'] === \T_SELF
+                } elseif ( $tokens[ $nextNonSimple ][ 'code' ] === \T_PARENT
+                    || $tokens[ $nextNonSimple ][ 'code' ] === \T_SELF
                 ) {
                     // Allow only `parent::` and `self::`.
-                    if ($nextNonEmpty === false || $tokens[$nextNonEmpty]['code'] !== \T_DOUBLE_COLON) {
+                    if ( $nextNonEmpty === false || $tokens[ $nextNonEmpty ][ 'code' ] !== \T_DOUBLE_COLON ) {
                         return false;
                     }
-                } elseif ($tokens[$nextNonSimple]['code'] === \T_DOUBLE_COLON) {
+                } elseif ( $tokens[ $nextNonSimple ][ 'code' ] === \T_DOUBLE_COLON ) {
                     // Allow only `T_STRING::T_STRING`.
-                    if ($nextNonEmpty === false || $tokens[$nextNonEmpty]['code'] !== \T_STRING) {
+                    if ( $nextNonEmpty === false || $tokens[ $nextNonEmpty ][ 'code' ] !== \T_STRING ) {
                         return false;
                     }
 
-                    $prevNonEmpty = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($nextNonSimple - 1), null, true);
+                    $prevNonEmpty = $phpcsFile->findPrevious( Tokens::$emptyTokens, ( $nextNonSimple - 1 ), null, true );
                     // No need to worry about parent/self, that's handled above and
                     // the double colon is skipped over in that case.
-                    if ($prevNonEmpty === false || $tokens[$prevNonEmpty]['code'] !== \T_STRING) {
+                    if ( $prevNonEmpty === false || $tokens[ $prevNonEmpty ][ 'code' ] !== \T_STRING ) {
                         return false;
                     }
                 }
 
                 // Examine what comes after the namespace/parent/self/double colon, if anything.
-                return $this->isStaticValue($phpcsFile, $tokens, ($nextNonEmpty + 1), $end, $nestedArrays);
+                return $this->isStaticValue( $phpcsFile, $tokens, ( $nextNonEmpty + 1 ), $end, $nestedArrays );
 
             case \T_ARRAY:
             case \T_OPEN_SHORT_ARRAY:
                 ++$nestedArrays;
 
-                $arrayItems = $this->getFunctionCallParameters($phpcsFile, $nextNonSimple);
-                if (empty($arrayItems) === false) {
-                    foreach ($arrayItems as $item) {
+                $arrayItems = $this->getFunctionCallParameters( $phpcsFile, $nextNonSimple );
+                if ( empty( $arrayItems ) === false ) {
+                    foreach ( $arrayItems as $item ) {
                         // Check for a double arrow, but only if it's for this array item, not for a nested array.
                         $doubleArrow = false;
 
                         $maybeDoubleArrow = $phpcsFile->findNext(
-                            array(\T_DOUBLE_ARROW, \T_ARRAY, \T_OPEN_SHORT_ARRAY),
-                            $item['start'],
-                            ($item['end'] + 1)
+                            array( \T_DOUBLE_ARROW, \T_ARRAY, \T_OPEN_SHORT_ARRAY ),
+                            $item[ 'start' ],
+                            ( $item[ 'end' ] + 1 )
                         );
-                        if ($maybeDoubleArrow !== false && $tokens[$maybeDoubleArrow]['code'] === \T_DOUBLE_ARROW) {
+                        if ( $maybeDoubleArrow !== false && $tokens[ $maybeDoubleArrow ][ 'code' ] === \T_DOUBLE_ARROW ) {
                             // Double arrow is for this nesting level.
                             $doubleArrow = $maybeDoubleArrow;
                         }
 
-                        if ($doubleArrow === false) {
-                            if ($this->isStaticValue($phpcsFile, $tokens, $item['start'], $item['end'], $nestedArrays) === false) {
+                        if ( $doubleArrow === false ) {
+                            if ( $this->isStaticValue( $phpcsFile, $tokens, $item[ 'start' ], $item[ 'end' ], $nestedArrays ) === false ) {
                                 return false;
                             }
 
                         } else {
                             // Examine array key.
-                            if ($this->isStaticValue($phpcsFile, $tokens, $item['start'], ($doubleArrow - 1), $nestedArrays) === false) {
+                            if ( $this->isStaticValue( $phpcsFile, $tokens, $item[ 'start' ], ( $doubleArrow - 1 ), $nestedArrays ) === false ) {
                                 return false;
                             }
 
                             // Examine array value.
-                            if ($this->isStaticValue($phpcsFile, $tokens, ($doubleArrow + 1), $item['end'], $nestedArrays) === false) {
+                            if ( $this->isStaticValue( $phpcsFile, $tokens, ( $doubleArrow + 1 ), $item[ 'end' ], $nestedArrays ) === false ) {
                                 return false;
                             }
                         }
@@ -432,27 +432,27 @@ 
                  * We already know we will have a valid closer as otherwise we wouldn't have been
                  * able to get the array items.
                  */
-                $closer = ($nextNonSimple + 1);
-                if ($tokens[$nextNonSimple]['code'] === \T_OPEN_SHORT_ARRAY
-                    && isset($tokens[$nextNonSimple]['bracket_closer']) === true
+                $closer = ( $nextNonSimple + 1 );
+                if ( $tokens[ $nextNonSimple ][ 'code' ] === \T_OPEN_SHORT_ARRAY
+                    && isset( $tokens[ $nextNonSimple ][ 'bracket_closer' ] ) === true
                 ) {
-                    $closer = $tokens[$nextNonSimple]['bracket_closer'];
+                    $closer = $tokens[ $nextNonSimple ][ 'bracket_closer' ];
                 } else {
-                    $maybeOpener = $phpcsFile->findNext(Tokens::$emptyTokens, ($nextNonSimple + 1), ($end + 1), true);
-                    if ($tokens[$maybeOpener]['code'] === \T_OPEN_PARENTHESIS) {
+                    $maybeOpener = $phpcsFile->findNext( Tokens::$emptyTokens, ( $nextNonSimple + 1 ), ( $end + 1 ), true );
+                    if ( $tokens[ $maybeOpener ][ 'code' ] === \T_OPEN_PARENTHESIS ) {
                         $opener = $maybeOpener;
-                        if (isset($tokens[$opener]['parenthesis_closer']) === true) {
-                            $closer = $tokens[$opener]['parenthesis_closer'];
+                        if ( isset( $tokens[ $opener ][ 'parenthesis_closer' ] ) === true ) {
+                            $closer = $tokens[ $opener ][ 'parenthesis_closer' ];
                         }
                     }
                 }
 
-                if ($closer === $end) {
+                if ( $closer === $end ) {
                     return true;
                 }
 
                 // Examine what comes after the array, if anything.
-                return $this->isStaticValue($phpcsFile, $tokens, ($closer + 1), $end, $nestedArrays);
+                return $this->isStaticValue( $phpcsFile, $tokens, ( $closer + 1 ), $end, $nestedArrays );
 
         }
 
@@ -471,25 +471,25 @@ 
      *
      * @return void
      */
-    protected function throwError(File $phpcsFile, $stackPtr, $type, $content = '')
+    protected function throwError( File $phpcsFile, $stackPtr, $type, $content = '' )
     {
         $error     = static::ERROR_PHRASE;
         $phrase    = '';
         $errorCode = 'Found';
 
-        if (isset($this->errorPhrases[$type]) === true) {
-            $errorCode = $this->stringToErrorCode($type) . 'Found';
-            $phrase    = $this->errorPhrases[$type];
+        if ( isset( $this->errorPhrases[ $type ] ) === true ) {
+            $errorCode = $this->stringToErrorCode( $type ) . 'Found';
+            $phrase    = $this->errorPhrases[ $type ];
         }
 
-        $data = array($phrase);
+        $data = array( $phrase );
 
-        if (empty($content) === false) {
+        if ( empty( $content ) === false ) {
             $error .= ' Found: %s';
-            $data[] = $content;
+            $data[ ] = $content;
         }
 
-        $phpcsFile->addError($error, $stackPtr, $errorCode, $data);
+        $phpcsFile->addError( $error, $stackPtr, $errorCode, $data );
     }
 
 
@@ -505,26 +505,26 @@ 
      *
      * @return bool|int True if this is the real end. Int stackPtr to skip to if not.
      */
-    private function isRealEndOfDeclaration($tokens, $endPtr, $targetLevel)
+    private function isRealEndOfDeclaration( $tokens, $endPtr, $targetLevel )
     {
         // Ignore anything within short array definition brackets for now.
-        if ($tokens[$endPtr]['code'] === \T_OPEN_SHORT_ARRAY
-            && (isset($tokens[$endPtr]['bracket_opener'])
-                && $tokens[$endPtr]['bracket_opener'] === $endPtr)
-            && isset($tokens[$endPtr]['bracket_closer'])
+        if ( $tokens[ $endPtr ][ 'code' ] === \T_OPEN_SHORT_ARRAY
+            && ( isset( $tokens[ $endPtr ][ 'bracket_opener' ] )
+                && $tokens[ $endPtr ][ 'bracket_opener' ] === $endPtr )
+            && isset( $tokens[ $endPtr ][ 'bracket_closer' ] )
         ) {
             // Skip forward to the end of the short array definition.
-            return $tokens[$endPtr]['bracket_closer'];
+            return $tokens[ $endPtr ][ 'bracket_closer' ];
         }
 
         // Skip past comma's at a lower nesting level.
-        if ($tokens[$endPtr]['code'] === \T_COMMA) {
+        if ( $tokens[ $endPtr ][ 'code' ] === \T_COMMA ) {
             // Check if a comma is at the nesting level we're targetting.
             $nestingLevel = 0;
-            if (isset($tokens[$endPtr]['nested_parenthesis']) === true) {
-                $nestingLevel = \count($tokens[$endPtr]['nested_parenthesis']);
+            if ( isset( $tokens[ $endPtr ][ 'nested_parenthesis' ] ) === true ) {
+                $nestingLevel = \count( $tokens[ $endPtr ][ 'nested_parenthesis' ] );
             }
-            if ($nestingLevel > $targetLevel) {
+            if ( $nestingLevel > $targetLevel ) {
                 return $endPtr;
             }
         }

vendor/phpcompatibility/php-compatibility/PHPCompatibility/Sniffs/InitialValue/NewConstantArraysUsingConstSniff.php

Spacing +8 added lines, -8 removed lines

@@ -35,7 +35,7 @@ 
      */
     public function register()
     {
-        return array(\T_CONST);
+        return array( \T_CONST );
     }
 
     /**
@@ -47,9 +47,9 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
+    public function process( File $phpcsFile, $stackPtr )
     {
-        if ($this->supportsBelow('5.5') !== true) {
+        if ( $this->supportsBelow( '5.5' ) !== true ) {
             return;
         }
 
@@ -59,7 +59,7 @@ 
             \T_OPEN_SHORT_ARRAY => \T_OPEN_SHORT_ARRAY,
         );
 
-        while (($hasArray = $phpcsFile->findNext($find, ($stackPtr + 1), null, false, null, true)) !== false) {
+        while ( ( $hasArray = $phpcsFile->findNext( $find, ( $stackPtr + 1 ), null, false, null, true ) ) !== false ) {
             $phpcsFile->addError(
                 'Constant arrays using the "const" keyword are not allowed in PHP 5.5 or earlier',
                 $hasArray,
@@ -68,10 +68,10 @@ 
 
             // Skip past the content of the array.
             $stackPtr = $hasArray;
-            if ($tokens[$hasArray]['code'] === \T_OPEN_SHORT_ARRAY && isset($tokens[$hasArray]['bracket_closer'])) {
-                $stackPtr = $tokens[$hasArray]['bracket_closer'];
-            } elseif ($tokens[$hasArray]['code'] === \T_ARRAY && isset($tokens[$hasArray]['parenthesis_closer'])) {
-                $stackPtr = $tokens[$hasArray]['parenthesis_closer'];
+            if ( $tokens[ $hasArray ][ 'code' ] === \T_OPEN_SHORT_ARRAY && isset( $tokens[ $hasArray ][ 'bracket_closer' ] ) ) {
+                $stackPtr = $tokens[ $hasArray ][ 'bracket_closer' ];
+            } elseif ( $tokens[ $hasArray ][ 'code' ] === \T_ARRAY && isset( $tokens[ $hasArray ][ 'parenthesis_closer' ] ) ) {
+                $stackPtr = $tokens[ $hasArray ][ 'parenthesis_closer' ];
             }
         }
     }

vendor/phpcompatibility/php-compatibility/PHPCompatibility/Sniffs/InitialValue/NewConstantArraysUsingDefineSniff.php

Spacing +14 added lines, -14 removed lines

@@ -35,7 +35,7 @@ 
      */
     public function register()
     {
-        return array(\T_STRING);
+        return array( \T_STRING );
     }
 
     /**
@@ -47,9 +47,9 @@ 
      *
      * @return void
      */
-    public function process(File $phpcsFile, $stackPtr)
+    public function process( File $phpcsFile, $stackPtr )
     {
-        if ($this->supportsBelow('5.6') !== true) {
+        if ( $this->supportsBelow( '5.6' ) !== true ) {
             return;
         }
 
@@ -62,30 +62,30 @@ 
             \T_CONST           => true,
         );
 
-        $prevToken = $phpcsFile->findPrevious(\T_WHITESPACE, ($stackPtr - 1), null, true);
-        if (isset($ignore[$tokens[$prevToken]['code']]) === true) {
+        $prevToken = $phpcsFile->findPrevious( \T_WHITESPACE, ( $stackPtr - 1 ), null, true );
+        if ( isset( $ignore[ $tokens[ $prevToken ][ 'code' ] ] ) === true ) {
             // Not a call to a PHP function.
             return;
         }
 
-        $functionLc = strtolower($tokens[$stackPtr]['content']);
-        if ($functionLc !== 'define') {
+        $functionLc = strtolower( $tokens[ $stackPtr ][ 'content' ] );
+        if ( $functionLc !== 'define' ) {
             return;
         }
 
-        $secondParam = $this->getFunctionCallParameter($phpcsFile, $stackPtr, 2);
-        if (isset($secondParam['start'], $secondParam['end']) === false) {
+        $secondParam = $this->getFunctionCallParameter( $phpcsFile, $stackPtr, 2 );
+        if ( isset( $secondParam[ 'start' ], $secondParam[ 'end' ] ) === false ) {
             return;
         }
 
         $targetNestingLevel = 0;
-        if (isset($tokens[$secondParam['start']]['nested_parenthesis'])) {
-            $targetNestingLevel = \count($tokens[$secondParam['start']]['nested_parenthesis']);
+        if ( isset( $tokens[ $secondParam[ 'start' ] ][ 'nested_parenthesis' ] ) ) {
+            $targetNestingLevel = \count( $tokens[ $secondParam[ 'start' ] ][ 'nested_parenthesis' ] );
         }
 
-        $array = $phpcsFile->findNext(array(\T_ARRAY, \T_OPEN_SHORT_ARRAY), $secondParam['start'], ($secondParam['end'] + 1));
-        if ($array !== false) {
-            if ((isset($tokens[$array]['nested_parenthesis']) === false && $targetNestingLevel === 0) || \count($tokens[$array]['nested_parenthesis']) === $targetNestingLevel) {
+        $array = $phpcsFile->findNext( array( \T_ARRAY, \T_OPEN_SHORT_ARRAY ), $secondParam[ 'start' ], ( $secondParam[ 'end' ] + 1 ) );
+        if ( $array !== false ) {
+            if ( ( isset( $tokens[ $array ][ 'nested_parenthesis' ] ) === false && $targetNestingLevel === 0 ) || \count( $tokens[ $array ][ 'nested_parenthesis' ] ) === $targetNestingLevel ) {
                 $phpcsFile->addError(
                     'Constant arrays using define are not allowed in PHP 5.6 or earlier',
                     $array,

vendor/phpcompatibility/php-compatibility/PHPCompatibility/Sniffs/InitialValue/NewHeredocSniff.php

Spacing +5 added lines, -5 removed lines

@@ -62,7 +62,7 @@ 
      */
     protected function bowOutEarly()
     {
-        return ($this->supportsBelow('5.2') !== true);
+        return ( $this->supportsBelow( '5.2' ) !== true );
     }
 
 
@@ -76,15 +76,15 @@ 
      *
      * @return bool True if no heredoc (or assignment) is found, false otherwise.
      */
-    protected function isValidAssignment(File $phpcsFile, $stackPtr, $end)
+    protected function isValidAssignment( File $phpcsFile, $stackPtr, $end )
     {
         $tokens = $phpcsFile->getTokens();
-        $next   = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), $end, true);
-        if ($next === false || $tokens[$next]['code'] !== \T_EQUAL) {
+        $next   = $phpcsFile->findNext( Tokens::$emptyTokens, ( $stackPtr + 1 ), $end, true );
+        if ( $next === false || $tokens[ $next ][ 'code' ] !== \T_EQUAL ) {
             // No value assigned.
             return true;
         }
 
-        return ($phpcsFile->findNext(\T_START_HEREDOC, ($next + 1), $end, false, null, true) === false);
+        return ( $phpcsFile->findNext( \T_START_HEREDOC, ( $next + 1 ), $end, false, null, true ) === false );
     }
 }