spiral / framework

src/Tokenizer/src/ClassLocator.php

Spacing +8 added lines, -8 removed lines

@@ -23,20 +23,20 @@ 
      */
     public function getClasses($target = null): array
     {
-        if (!empty($target) && (is_object($target) || is_string($target))) {
+        if (!empty($target) && (is_object($target) || is_string($target))){
             $target = new \ReflectionClass($target);
         }
 
         $result = [];
-        foreach ($this->availableClasses() as $class) {
-            try {
+        foreach ($this->availableClasses() as $class){
+            try{
                 $reflection = $this->classReflection($class);
-            } catch (LocatorException $e) {
+            }catch (LocatorException $e){
                 //Ignoring
                 continue;
             }
 
-            if (!$this->isTargeted($reflection, $target) || $reflection->isInterface()) {
+            if (!$this->isTargeted($reflection, $target) || $reflection->isInterface()){
                 continue;
             }
 
@@ -55,7 +55,7 @@ 
     {
         $classes = [];
 
-        foreach ($this->availableReflections() as $reflection) {
+        foreach ($this->availableReflections() as $reflection){
             $classes = array_merge($classes, $reflection->getClasses());
         }
 
@@ -71,11 +71,11 @@ 
      */
     protected function isTargeted(\ReflectionClass $class, \ReflectionClass $target = null): bool
     {
-        if (empty($target)) {
+        if (empty($target)){
             return true;
         }
 
-        if (!$target->isTrait()) {
+        if (!$target->isTrait()){
             //Target is interface or class
             return $class->isSubclassOf($target) || $class->getName() == $target->getName();
         }

src/Tokenizer/src/Tokenizer.php

Spacing +7 added lines, -7 removed lines

@@ -77,9 +77,9 @@ 
      */
     public function createInjection(\ReflectionClass $class, string $context = null)
     {
-        if ($class->isSubclassOf(ClassesInterface::class)) {
+        if ($class->isSubclassOf(ClassesInterface::class)){
             return $this->classLocator();
-        } elseif ($class->isSubclassOf(InvocationsInterface::class)) {
+        } elseif ($class->isSubclassOf(InvocationsInterface::class)){
             return $this->invocationLocator();
         }
 
@@ -97,12 +97,12 @@ 
         $tokens = token_get_all(file_get_contents($filename));
 
         $line = 0;
-        foreach ($tokens as &$token) {
-            if (isset($token[self::LINE])) {
+        foreach ($tokens as &$token){
+            if (isset($token[self::LINE])){
                 $line = $token[self::LINE];
             }
 
-            if (!is_array($token)) {
+            if (!is_array($token)){
                 $token = [$token, $token, $line];
             }
 
@@ -122,11 +122,11 @@ 
     {
         $finder = new Finder();
 
-        if (empty($directories)) {
+        if (empty($directories)){
             $directories = $this->config->getDirectories();
         }
 
-        if (empty($exclude)) {
+        if (empty($exclude)){
             $exclude = $this->config->getExcludes();
         }
 

src/Tokenizer/src/AbstractLocator.php

Spacing +10 added lines, -10 removed lines

@@ -50,10 +50,10 @@ 
         /**
          * @var SplFileInfo
          */
-        foreach ($this->finder->getIterator() as $file) {
+        foreach ($this->finder->getIterator() as $file){
             $reflection = new ReflectionFile((string)$file);
 
-            if ($reflection->hasIncludes()) {
+            if ($reflection->hasIncludes()){
                 //We are not analyzing files which has includes, it's not safe to require such reflections
                 $this->getLogger()->warning(
                     sprintf("File `%s` has includes and excluded from analysis", $file),
@@ -80,8 +80,8 @@ 
      */
     protected function classReflection(string $class): \ReflectionClass
     {
-        $loader = function ($class) {
-            if ($class == LocatorException::class) {
+        $loader = function ($class){
+            if ($class == LocatorException::class){
                 return;
             }
 
@@ -91,12 +91,12 @@ 
         //To suspend class dependency exception
         spl_autoload_register($loader);
 
-        try {
+        try{
             //In some cases reflection can thrown an exception if class invalid or can not be loaded,
             //we are going to handle such exception and convert it soft exception
             return new \ReflectionClass($class);
-        } catch (\Throwable $e) {
-            if ($e instanceof LocatorException && $e->getPrevious() != null) {
+        }catch (\Throwable $e){
+            if ($e instanceof LocatorException && $e->getPrevious() != null){
                 $e = $e->getPrevious();
             }
 
@@ -112,7 +112,7 @@ 
             );
 
             throw new LocatorException($e->getMessage(), $e->getCode(), $e);
-        } finally {
+        }finally{
             spl_autoload_unregister($loader);
         }
     }
@@ -128,13 +128,13 @@ 
     {
         $traits = [];
 
-        while ($class) {
+        while ($class){
             $traits = array_merge(class_uses($class), $traits);
             $class = get_parent_class($class);
         }
 
         //Traits from traits
-        foreach (array_flip($traits) as $trait) {
+        foreach (array_flip($traits) as $trait){
             $traits = array_merge(class_uses($trait), $traits);
         }
 

src/Tokenizer/src/InvocationLocator.php

Spacing +9 added lines, -9 removed lines

@@ -28,8 +28,8 @@ 
     public function getInvocations(\ReflectionFunctionAbstract $function): array
     {
         $result = [];
-        foreach ($this->availableInvocations($function->getName()) as $invocation) {
-            if ($this->isTargeted($invocation, $function)) {
+        foreach ($this->availableInvocations($function->getName()) as $invocation){
+            if ($this->isTargeted($invocation, $function)){
                 $result[] = $invocation;
             }
         }
@@ -46,12 +46,12 @@ 
     protected function availableInvocations(string $signature = ''): \Generator
     {
         $signature = strtolower(trim($signature, '\\'));
-        foreach ($this->availableReflections() as $reflection) {
-            foreach ($reflection->getInvocations() as $invocation) {
+        foreach ($this->availableReflections() as $reflection){
+            foreach ($reflection->getInvocations() as $invocation){
                 if (
                     !empty($signature)
                     && strtolower(trim($invocation->getName(), '\\')) != $signature
-                ) {
+                ){
                     continue;
                 }
 
@@ -68,13 +68,13 @@ 
      */
     protected function isTargeted(ReflectionInvocation $invocation, \ReflectionFunctionAbstract $function): bool
     {
-        if ($function instanceof \ReflectionFunction) {
+        if ($function instanceof \ReflectionFunction){
             return !$invocation->isMethod();
         }
 
-        try {
+        try{
             $reflection = $this->classReflection($invocation->getClass());
-        } catch (LocatorException $e) {
+        }catch (LocatorException $e){
             return false;
         }
 
@@ -83,7 +83,7 @@ 
          */
         $target = $function->getDeclaringClass();
 
-        if ($target->isTrait()) {
+        if ($target->isTrait()){
             //Let's compare traits
             return in_array($target->getName(), $this->fetchTraits($invocation->getClass()));
         }

src/Tokenizer/src/Reflection/ReflectionFile.php

Spacing +61 added lines, -61 removed lines

@@ -168,7 +168,7 @@ 
      */
     public function getClasses(): array
     {
-        if (!isset($this->declarations['T_CLASS'])) {
+        if (!isset($this->declarations['T_CLASS'])){
             return [];
         }
 
@@ -182,7 +182,7 @@ 
      */
     public function getTraits(): array
     {
-        if (!isset($this->declarations['T_TRAIT'])) {
+        if (!isset($this->declarations['T_TRAIT'])){
             return [];
         }
 
@@ -196,7 +196,7 @@ 
      */
     public function getInterfaces(): array
     {
-        if (!isset($this->declarations['T_INTERFACE'])) {
+        if (!isset($this->declarations['T_INTERFACE'])){
             return [];
         }
 
@@ -231,7 +231,7 @@ 
      */
     public function getInvocations(): array
     {
-        if (empty($this->invocations)) {
+        if (empty($this->invocations)){
             $this->locateInvocations($this->getTokens());
         }
 
@@ -263,12 +263,12 @@ 
      */
     protected function locateDeclarations()
     {
-        foreach ($this->getTokens() as $tokenID => $token) {
-            if (!in_array($token[self::TOKEN_TYPE], self::$processTokens)) {
+        foreach ($this->getTokens() as $tokenID => $token){
+            if (!in_array($token[self::TOKEN_TYPE], self::$processTokens)){
                 continue;
             }
 
-            switch ($token[self::TOKEN_TYPE]) {
+            switch ($token[self::TOKEN_TYPE]){
                 case T_NAMESPACE:
                     $this->registerNamespace($tokenID);
                     break;
@@ -284,7 +284,7 @@ 
                 case T_CLASS:
                 case T_TRAIT:
                 case T_INTERFACE:
-                    if ($this->isClassNameConst($tokenID)) {
+                    if ($this->isClassNameConst($tokenID)){
                         //PHP5.5 ClassName::class constant
                         continue 2;
                     }
@@ -301,7 +301,7 @@ 
         }
 
         //Dropping empty namespace
-        if (isset($this->namespaces[''])) {
+        if (isset($this->namespaces[''])){
             $this->namespaces['\\'] = $this->namespaces[''];
             unset($this->namespaces['']);
         }
@@ -317,14 +317,14 @@ 
         $namespace = '';
         $localID = $tokenID + 1;
 
-        do {
+        do{
             $token = $this->tokens[$localID++];
-            if ($token[self::TOKEN_CODE] == '{') {
+            if ($token[self::TOKEN_CODE] == '{'){
                 break;
             }
 
             $namespace .= $token[self::TOKEN_CODE];
-        } while (
+        }while (
             isset($this->tokens[$localID])
             && $this->tokens[$localID][self::TOKEN_CODE] != '{'
             && $this->tokens[$localID][self::TOKEN_CODE] != ';'
@@ -334,13 +334,13 @@ 
         $namespace = trim($namespace);
 
         $uses = [];
-        if (isset($this->namespaces[$namespace])) {
+        if (isset($this->namespaces[$namespace])){
             $uses = $this->namespaces[$namespace];
         }
 
-        if ($this->tokens[$localID][self::TOKEN_CODE] == ';') {
+        if ($this->tokens[$localID][self::TOKEN_CODE] == ';'){
             $endingID = count($this->tokens) - 1;
-        } else {
+        }else{
             $endingID = $this->endingToken($tokenID);
         }
 
@@ -362,20 +362,20 @@ 
 
         $class = '';
         $localAlias = null;
-        for ($localID = $tokenID + 1; $this->tokens[$localID][self::TOKEN_CODE] != ';'; ++$localID) {
-            if ($this->tokens[$localID][self::TOKEN_TYPE] == T_AS) {
+        for ($localID = $tokenID + 1; $this->tokens[$localID][self::TOKEN_CODE] != ';'; ++$localID){
+            if ($this->tokens[$localID][self::TOKEN_TYPE] == T_AS){
                 $localAlias = '';
                 continue;
             }
 
-            if ($localAlias === null) {
+            if ($localAlias === null){
                 $class .= $this->tokens[$localID][self::TOKEN_CODE];
-            } else {
+            }else{
                 $localAlias .= $this->tokens[$localID][self::TOKEN_CODE];
             }
         }
 
-        if (empty($localAlias)) {
+        if (empty($localAlias)){
             $names = explode('\\', $class);
             $localAlias = end($names);
         }
@@ -390,9 +390,9 @@ 
      */
     private function registerFunction(int $tokenID)
     {
-        foreach ($this->declarations as $declarations) {
-            foreach ($declarations as $location) {
-                if ($tokenID >= $location[self::O_TOKEN] && $tokenID <= $location[self::C_TOKEN]) {
+        foreach ($this->declarations as $declarations){
+            foreach ($declarations as $location){
+                if ($tokenID >= $location[self::O_TOKEN] && $tokenID <= $location[self::C_TOKEN]){
                     //We are inside class, function is method
                     return;
                 }
@@ -400,14 +400,14 @@ 
         }
 
         $localID = $tokenID + 1;
-        while ($this->tokens[$localID][self::TOKEN_TYPE] != T_STRING) {
+        while ($this->tokens[$localID][self::TOKEN_TYPE] != T_STRING){
             //Fetching function name
             ++$localID;
         }
 
         $name = $this->tokens[$localID][self::TOKEN_CODE];
-        if (!empty($namespace = $this->activeNamespace($tokenID))) {
-            $name = $namespace . self::NS_SEPARATOR . $name;
+        if (!empty($namespace = $this->activeNamespace($tokenID))){
+            $name = $namespace.self::NS_SEPARATOR.$name;
         }
 
         $this->functions[$name] = [
@@ -426,13 +426,13 @@ 
     private function registerDeclaration(int $tokenID, int $tokenType)
     {
         $localID = $tokenID + 1;
-        while ($this->tokens[$localID][self::TOKEN_TYPE] != T_STRING) {
+        while ($this->tokens[$localID][self::TOKEN_TYPE] != T_STRING){
             ++$localID;
         }
 
         $name = $this->tokens[$localID][self::TOKEN_CODE];
-        if (!empty($namespace = $this->activeNamespace($tokenID))) {
-            $name = $namespace . self::NS_SEPARATOR . $name;
+        if (!empty($namespace = $this->activeNamespace($tokenID))){
+            $name = $namespace.self::NS_SEPARATOR.$name;
         }
 
         $this->declarations[token_name($tokenType)][$name] = [
@@ -480,24 +480,24 @@ 
 
         //Tokens used to re-enable token detection
         $stopTokens = [T_STRING, T_WHITESPACE, T_DOUBLE_COLON, T_OBJECT_OPERATOR, T_NS_SEPARATOR];
-        foreach ($tokens as $tokenID => $token) {
+        foreach ($tokens as $tokenID => $token){
             $tokenType = $token[self::TOKEN_TYPE];
 
             //We are not indexing function declarations or functions called from $objects.
-            if (in_array($tokenType, [T_FUNCTION, T_OBJECT_OPERATOR, T_NEW])) {
+            if (in_array($tokenType, [T_FUNCTION, T_OBJECT_OPERATOR, T_NEW])){
                 if (
                     empty($argumentsTID)
                     && (
                         empty($invocationTID)
                         || $this->getSource($invocationTID, $tokenID - 1) != '$this'
                     )
-                ) {
+                ){
                     //Not a call, function declaration, or object method
                     $ignore = true;
                     continue;
                 }
-            } elseif ($ignore) {
-                if (!in_array($tokenType, $stopTokens)) {
+            } elseif ($ignore){
+                if (!in_array($tokenType, $stopTokens)){
                     //Returning to search
                     $ignore = false;
                 }
@@ -505,13 +505,13 @@ 
             }
 
             //We are inside function, and there is "(", indexing arguments.
-            if (!empty($invocationTID) && ($tokenType == '(' || $tokenType == '[')) {
-                if (empty($argumentsTID)) {
+            if (!empty($invocationTID) && ($tokenType == '(' || $tokenType == '[')){
+                if (empty($argumentsTID)){
                     $argumentsTID = $tokenID;
                 }
 
                 ++$level;
-                if ($level != 1) {
+                if ($level != 1){
                     //Not arguments beginning, but arguments part
                     $arguments[$tokenID] = $token;
                 }
@@ -520,16 +520,16 @@ 
             }
 
             //We are inside function arguments and ")" met.
-            if (!empty($invocationTID) && ($tokenType == ')' || $tokenType == ']')) {
+            if (!empty($invocationTID) && ($tokenType == ')' || $tokenType == ']')){
                 --$level;
-                if ($level == -1) {
+                if ($level == -1){
                     $invocationTID = false;
                     $level = 0;
                     continue;
                 }
 
                 //Function fully indexed, we can process it now.
-                if ($level == 0) {
+                if ($level == 0){
                     $this->registerInvocation(
                         $invocationTID,
                         $argumentsTID,
@@ -541,7 +541,7 @@ 
                     //Closing search
                     $arguments = [];
                     $argumentsTID = $invocationTID = false;
-                } else {
+                }else{
                     //Not arguments beginning, but arguments part
                     $arguments[$tokenID] = $token;
                 }
@@ -550,13 +550,13 @@ 
             }
 
             //Still inside arguments.
-            if (!empty($invocationTID) && !empty($level)) {
+            if (!empty($invocationTID) && !empty($level)){
                 $arguments[$tokenID] = $token;
                 continue;
             }
 
             //Nothing valuable to remember, will be parsed later.
-            if (!empty($invocationTID) && in_array($tokenType, $stopTokens)) {
+            if (!empty($invocationTID) && in_array($tokenType, $stopTokens)){
                 continue;
             }
 
@@ -566,7 +566,7 @@ 
                 || $tokenType == T_STATIC
                 || $tokenType == T_NS_SEPARATOR
                 || ($tokenType == T_VARIABLE && $token[self::TOKEN_CODE] == '$this')
-            ) {
+            ){
                 $invocationTID = $tokenID;
                 $level = 0;
 
@@ -595,13 +595,13 @@ 
         int $endID,
         array $arguments,
         int $invocationLevel
-    ) {
+    ){
         //Nested invocations
         $this->locateInvocations($arguments, $invocationLevel + 1);
 
         list($class, $operator, $name) = $this->fetchContext($invocationID, $argumentsID);
 
-        if (!empty($operator) && empty($class)) {
+        if (!empty($operator) && empty($class)){
             //Non detectable
             return;
         }
@@ -632,17 +632,17 @@ 
         $name = trim($this->getSource($invocationTID, $argumentsTID), '( ');
 
         //Let's try to fetch all information we need
-        if (strpos($name, '->') !== false) {
+        if (strpos($name, '->') !== false){
             $operator = '->';
-        } elseif (strpos($name, '::') !== false) {
+        } elseif (strpos($name, '::') !== false){
             $operator = '::';
         }
 
-        if (!empty($operator)) {
+        if (!empty($operator)){
             list($class, $name) = explode($operator, $name);
 
             //We now have to clarify class name
-            if (in_array($class, ['self', 'static', '$this'])) {
+            if (in_array($class, ['self', 'static', '$this'])){
                 $class = $this->activeDeclaration($invocationTID);
             }
         }
@@ -659,9 +659,9 @@ 
      */
     private function activeDeclaration(int $tokenID): string
     {
-        foreach ($this->declarations as $declarations) {
-            foreach ($declarations as $name => $position) {
-                if ($tokenID >= $position[self::O_TOKEN] && $tokenID <= $position[self::C_TOKEN]) {
+        foreach ($this->declarations as $declarations){
+            foreach ($declarations as $name => $position){
+                if ($tokenID >= $position[self::O_TOKEN] && $tokenID <= $position[self::C_TOKEN]){
                     return $name;
                 }
             }
@@ -680,8 +680,8 @@ 
      */
     private function activeNamespace(int $tokenID): string
     {
-        foreach ($this->namespaces as $namespace => $position) {
-            if ($tokenID >= $position[self::O_TOKEN] && $tokenID <= $position[self::C_TOKEN]) {
+        foreach ($this->namespaces as $namespace => $position){
+            if ($tokenID >= $position[self::O_TOKEN] && $tokenID <= $position[self::C_TOKEN]){
                 return $namespace;
             }
         }
@@ -706,18 +706,18 @@ 
     private function endingToken(int $tokenID): int
     {
         $level = null;
-        for ($localID = $tokenID; $localID < $this->countTokens; ++$localID) {
+        for ($localID = $tokenID; $localID < $this->countTokens; ++$localID){
             $token = $this->tokens[$localID];
-            if ($token[self::TOKEN_CODE] == '{') {
+            if ($token[self::TOKEN_CODE] == '{'){
                 ++$level;
                 continue;
             }
 
-            if ($token[self::TOKEN_CODE] == '}') {
+            if ($token[self::TOKEN_CODE] == '}'){
                 --$level;
             }
 
-            if ($level === 0) {
+            if ($level === 0){
                 break;
             }
         }
@@ -734,7 +734,7 @@ 
      */
     private function lineNumber(int $tokenID): int
     {
-        while (empty($this->tokens[$tokenID][self::TOKEN_LINE])) {
+        while (empty($this->tokens[$tokenID][self::TOKEN_LINE])){
             --$tokenID;
         }
 
@@ -752,7 +752,7 @@ 
     private function getSource(int $startID, int $endID): string
     {
         $result = '';
-        for ($tokenID = $startID; $tokenID <= $endID; ++$tokenID) {
+        for ($tokenID = $startID; $tokenID <= $endID; ++$tokenID){
             //Collecting function usage src
             $result .= $this->tokens[$tokenID][self::TOKEN_CODE];
         }

src/Tokenizer/src/Reflection/ReflectionInvocation.php

Spacing +2 added lines, -2 removed lines

@@ -69,7 +69,7 @@ 
         array $arguments,
         string $source,
         int $level
-    ) {
+    ){
         $this->filename = $filename;
         $this->line = $line;
         $this->class = $class;
@@ -179,7 +179,7 @@ 
      */
     public function getArgument(int $index): ReflectionArgument
     {
-        if (!isset($this->arguments[$index])) {
+        if (!isset($this->arguments[$index])){
             throw new ReflectionException("No such argument with index '{$index}'");
         }
 

src/Tokenizer/src/Reflection/ReflectionArgument.php

Spacing +15 added lines, -15 removed lines

@@ -21,10 +21,10 @@ 
     /**
      * Argument types.
      */
-    public const CONSTANT   = 'constant';   //Scalar constant and not variable.
-    public const VARIABLE   = 'variable';   //PHP variable
+    public const CONSTANT   = 'constant'; //Scalar constant and not variable.
+    public const VARIABLE   = 'variable'; //PHP variable
     public const EXPRESSION = 'expression'; //PHP code (expression).
-    public const STRING     = 'string';     //Simple scalar string, can be fetched using stringValue().
+    public const STRING     = 'string'; //Simple scalar string, can be fetched using stringValue().
 
     /** @var string */
     private $type;
@@ -69,7 +69,7 @@ 
      */
     public function stringValue(): string
     {
-        if ($this->type != self::STRING) {
+        if ($this->type != self::STRING){
             throw new ReflectionException(
                 "Unable to represent value as string, value type is '{$this->type}'"
             );
@@ -91,19 +91,19 @@ 
         $level = 0;
 
         $result = [];
-        foreach ($tokens as $token) {
-            if ($token[ReflectionFile::TOKEN_TYPE] == T_WHITESPACE) {
+        foreach ($tokens as $token){
+            if ($token[ReflectionFile::TOKEN_TYPE] == T_WHITESPACE){
                 continue;
             }
 
-            if (empty($definition)) {
+            if (empty($definition)){
                 $definition = ['type' => self::EXPRESSION, 'value' => '', 'tokens' => []];
             }
 
             if (
                 $token[ReflectionFile::TOKEN_TYPE] == '('
                 || $token[ReflectionFile::TOKEN_TYPE] == '['
-            ) {
+            ){
                 ++$level;
                 $definition['value'] .= $token[ReflectionFile::TOKEN_CODE];
                 continue;
@@ -112,18 +112,18 @@ 
             if (
                 $token[ReflectionFile::TOKEN_TYPE] == ')'
                 || $token[ReflectionFile::TOKEN_TYPE] == ']'
-            ) {
+            ){
                 --$level;
                 $definition['value'] .= $token[ReflectionFile::TOKEN_CODE];
                 continue;
             }
 
-            if ($level) {
+            if ($level){
                 $definition['value'] .= $token[ReflectionFile::TOKEN_CODE];
                 continue;
             }
 
-            if ($token[ReflectionFile::TOKEN_TYPE] == ',') {
+            if ($token[ReflectionFile::TOKEN_TYPE] == ','){
                 $result[] = self::createArgument($definition);
                 $definition = null;
                 continue;
@@ -134,9 +134,9 @@ 
         }
 
         //Last argument
-        if (is_array($definition)) {
+        if (is_array($definition)){
             $definition = self::createArgument($definition);
-            if (!empty($definition->getType())) {
+            if (!empty($definition->getType())){
                 $result[] = $definition;
             }
         }
@@ -155,9 +155,9 @@ 
     {
         $result = new static(self::EXPRESSION, $definition['value']);
 
-        if (count($definition['tokens']) == 1) {
+        if (count($definition['tokens']) == 1){
             //If argument represent by one token we can try to resolve it's type more precisely
-            switch ($definition['tokens'][0][0]) {
+            switch ($definition['tokens'][0][0]){
                 case T_VARIABLE:
                     $result->type = self::VARIABLE;
                     break;

src/Tokenizer/tests/InvocationsTest.php

Spacing +1 added lines, -1 removed lines

@@ -19,7 +19,7 @@
     protected function someFunction()
     {
         $result = $this->sampleMethod('hello world');
-        print_r(self::sampleMethod($result . 'plus'));
+        print_r(self::sampleMethod($result.'plus'));
     }
 
     public function testInstance()

src/Tokenizer/tests/ReflectionFileTest.php

Spacing +4 added lines, -4 removed lines

@@ -22,17 +22,17 @@
         $this->assertContains(TestTrait::class, $reflection->getTraits());
         $this->assertContains(TestInterface::class, $reflection->getInterfaces());
 
-        $this->assertSame([__NAMESPACE__ . '\hello'], $reflection->getFunctions());
+        $this->assertSame([__NAMESPACE__.'\hello'], $reflection->getFunctions());
 
         $functionA = null;
         $functionB = null;
 
-        foreach ($reflection->getInvocations() as $invocation) {
-            if ($invocation->getName() == 'test_function_a') {
+        foreach ($reflection->getInvocations() as $invocation){
+            if ($invocation->getName() == 'test_function_a'){
                 $functionA = $invocation;
             }
 
-            if ($invocation->getName() == 'test_function_b') {
+            if ($invocation->getName() == 'test_function_b'){
                 $functionB = $invocation;
             }
         }