spiral / framework

src/Tokenizer/tests/Listener/ClassLocatorByDefinitionTest.php

Braces +5 added lines, -2 removed lines

@@ -105,11 +105,14 @@
         $definition = \iterator_to_array((new AttributesParser(new AttributeReader()))
             ->parse(new $listener))[0];
 
-        if ($definition->scope === null) {
+        if ($definition->scope === null)
+        {
             $this->classes
                 ->shouldReceive('getClasses')
                 ->andReturn($classes);
-        } else {
+        }
+        else
+        {
             $this->scopedClasses
                 ->shouldReceive('getScopedClasses')
                 ->with($definition->scope)

src/Tokenizer/tests/Listener/ListenerInvokerTest.php

Braces +2 added lines, -1 removed lines

@@ -30,7 +30,8 @@
 
         $listener = \Mockery::mock(TokenizationListenerInterface::class);
 
-        foreach ($classes as $class) {
+        foreach ($classes as $class)
+        {
             $listener->shouldReceive('listen')
                 ->once()
                 ->with($class);

src/Tokenizer/src/Bootloader/TokenizerListenerBootloader.php

Braces +8 added lines, -4 removed lines

@@ -57,15 +57,18 @@ 
         ): void {
             // First, we check if the listener has been cached. If it has, we will load the classes
             // from the cache.
-            foreach ($this->listeners as $i => $listener) {
-                if ($cachedClassesLoader->loadClasses($listener)) {
+            foreach ($this->listeners as $i => $listener)
+            {
+                if ($cachedClassesLoader->loadClasses($listener))
+                {
                     unset($this->listeners[$i]);
                 }
             }
 
             // If there are no listeners left, we don't need to use static analysis at all and save
             // valuable time.
-            if ($this->listeners === []) {
+            if ($this->listeners === [])
+            {
                 return;
             }
 
@@ -73,7 +76,8 @@ 
             // Please note that this is a very expensive operation and should be avoided if possible.
             // Use #[ListenForClasses] attribute in your listeners to cache the classes.
             $classes = $classes->getClasses();
-            foreach ($this->listeners as $listener) {
+            foreach ($this->listeners as $listener)
+            {
                 $invoker->invoke($listener, $classes);
             }
 

src/Tokenizer/src/Listener/ClassLocatorByDefinition.php

Braces +36 added lines, -18 removed lines

@@ -45,16 +45,20 @@ 
      */
     private function getClassesForClass(array $classes, \ReflectionClass $target): \Generator
     {
-        foreach ($classes as $class) {
-            if (!$target->isTrait()) {
-                if ($class->isSubclassOf($target) || $class->getName() === $target->getName()) {
+        foreach ($classes as $class)
+        {
+            if (!$target->isTrait())
+            {
+                if ($class->isSubclassOf($target) || $class->getName() === $target->getName())
+                {
                     yield $class->getName();
                     continue;
                 }
             }
 
             // Checking using traits
-            if (\in_array($target->getName(), $this->fetchTraits($class->getName()))) {
+            if (\in_array($target->getName(), $this->fetchTraits($class->getName())))
+            {
                 yield $class->getName();
             }
         }
@@ -68,7 +72,8 @@ 
      */
     private function getClassesForAttribute(array $classes, \ReflectionClass $target, \Attribute $attribute): \Generator
     {
-        foreach ($classes as $class) {
+        foreach ($classes as $class)
+        {
             // If attribute is defined on class level and class has target attribute
             // then we can add it to the list of classes
             if (($attribute->flags & \Attribute::TARGET_CLASS)
@@ -80,9 +85,12 @@ 
 
             // If attribute is defined on method level and class methods has target attribute
             // then we can add it to the list of classes
-            if ($attribute->flags & \Attribute::TARGET_METHOD) {
-                foreach ($class->getMethods() as $method) {
-                    if ($this->reader->firstFunctionMetadata($method, $target->getName())) {
+            if ($attribute->flags & \Attribute::TARGET_METHOD)
+            {
+                foreach ($class->getMethods() as $method)
+                {
+                    if ($this->reader->firstFunctionMetadata($method, $target->getName()))
+                    {
                         yield $class->getName();
                         continue 2;
                     }
@@ -91,9 +99,12 @@ 
 
             // If attribute is defined on property level and class properties has target attribute
             // then we can add it to the list of classes
-            if ($attribute->flags & \Attribute::TARGET_PROPERTY) {
-                foreach ($class->getProperties() as $property) {
-                    if ($this->reader->firstPropertyMetadata($property, $target->getName())) {
+            if ($attribute->flags & \Attribute::TARGET_PROPERTY)
+            {
+                foreach ($class->getProperties() as $property)
+                {
+                    if ($this->reader->firstPropertyMetadata($property, $target->getName()))
+                    {
                         yield $class->getName();
                         continue 2;
                     }
@@ -103,9 +114,12 @@ 
 
             // If attribute is defined on constant level and class constants has target attribute
             // then we can add it to the list of classes
-            if ($attribute->flags & \Attribute::TARGET_CLASS_CONSTANT) {
-                foreach ($class->getReflectionConstants() as $constant) {
-                    if ($this->reader->firstConstantMetadata($constant, $target->getName())) {
+            if ($attribute->flags & \Attribute::TARGET_CLASS_CONSTANT)
+            {
+                foreach ($class->getReflectionConstants() as $constant)
+                {
+                    if ($this->reader->firstConstantMetadata($constant, $target->getName()))
+                    {
                         yield $class->getName();
                         continue 2;
                     }
@@ -115,10 +129,14 @@ 
 
             // If attribute is defined on method parameters level and class method parameter has target attribute
             // then we can add it to the list of classes
-            if ($attribute->flags & \Attribute::TARGET_PARAMETER) {
-                foreach ($class->getMethods() as $method) {
-                    foreach ($method->getParameters() as $parameter) {
-                        if ($this->reader->firstParameterMetadata($parameter, $target->getName())) {
+            if ($attribute->flags & \Attribute::TARGET_PARAMETER)
+            {
+                foreach ($class->getMethods() as $method)
+                {
+                    foreach ($method->getParameters() as $parameter)
+                    {
+                        if ($this->reader->firstParameterMetadata($parameter, $target->getName()))
+                        {
                             yield $class->getName();
                             continue 3;
                         }

src/Tokenizer/src/Listener/ListenerInvoker.php

Braces +2 added lines, -1 removed lines

@@ -13,7 +13,8 @@
 {
     public function invoke(TokenizationListenerInterface $listener, iterable $classes): void
     {
-        foreach ($classes as $class) {
+        foreach ($classes as $class)
+        {
             $listener->listen($class);
         }
 

src/Tokenizer/src/Listener/CachedClassesLoader.php

Braces +6 added lines, -3 removed lines

@@ -22,7 +22,8 @@ 
         $definitions = \iterator_to_array($this->parser->parse($listener));
 
         // If there are no definitions, then listener can't be cached.
-        if ($definitions === []) {
+        if ($definitions === [])
+        {
             return false;
         }
 
@@ -31,9 +32,11 @@ 
         // We decided to load classes for each definition separately.
         // It allows us to cache classes for each definition separately and if we reuse the
         // same target in multiple listeners, we will not have to load classes for the same target.
-        foreach ($definitions as $definition) {
+        foreach ($definitions as $definition)
+        {
             $classes = $this->memory->loadData($definition->getHash());
-            if ($classes === null) {
+            if ($classes === null)
+            {
                 $this->memory->saveData(
                     $definition->getHash(),
                     $classes = $this->cacheBuilder->getClasses($definition)

src/Tokenizer/src/Listener/AttributesParser.php

Braces +4 added lines, -2 removed lines

@@ -25,7 +25,8 @@ 
     {
         $listener = new \ReflectionClass($listener);
 
-        foreach ($this->reader->getClassMetadata($listener, ListenForClasses::class) as $attribute) {
+        foreach ($this->reader->getClassMetadata($listener, ListenForClasses::class) as $attribute)
+        {
             // Analyze the target class from ListenForClasses attribute.
             $refl = new \ReflectionClass($attribute->target);
 
@@ -33,7 +34,8 @@ 
             $attr = $refl->getAttributes(\Attribute::class)[0] ?? null;
 
             // If the target class has no attribute, then it's a normal class or interface.
-            if ($attr === null) {
+            if ($attr === null)
+            {
                 yield new ListenerDefinition(
                     listenerClass: $listener->getName(),
                     target: $refl,