jaxon-php / jaxon-mono

jaxon-core/src/Plugin/Request/CallableClass/ComponentOptions.php

Spacing +22 added lines, -25 removed lines

@@ -106,18 +106,18 @@ 
         $sSeparator = $aOptions['separator'] ?? '.';
         $this->sSeparator = $sSeparator === '_' ? '_' : '.';
         $this->addProtectedMethods($aOptions['protected'] ?? []);
-        foreach($aOptions['functions'] ?? [] as $sNames => $aFunctionOptions)
+        foreach ($aOptions['functions'] ?? [] as $sNames => $aFunctionOptions)
         {
             // Names are in a comma-separated list.
             $aFunctionNames = explode(',', $sNames);
-            foreach($aFunctionNames as $sFunctionName)
+            foreach ($aFunctionNames as $sFunctionName)
             {
                 $this->addFunctionOptions($sFunctionName, $aFunctionOptions);
             }
         }
 
         // Options from the attributes or annotations.
-        if($xMetadata !== null)
+        if ($xMetadata !== null)
         {
             $this->readMetadataOptions($xMetadata);
         }
@@ -133,8 +133,7 @@ 
     private function addProtectedMethods(array|string $xMethods): void
     {
         $this->aExportMethods['except'] = array_merge($this->aExportMethods['except'],
-            !is_array($xMethods) ? [trim((string)$xMethods)] :
-            array_map(fn($sMethod) => trim((string)$sMethod), $xMethods));
+            !is_array($xMethods) ? [trim((string)$xMethods)] : array_map(fn($sMethod) => trim((string)$sMethod), $xMethods));
     }
 
     /**
@@ -149,7 +148,7 @@ 
         $aExportMethods['except'] = array_unique(array_merge(
             $aExportMethods['except'] ?? [], $this->aExportMethods['except']));
         $this->aExportMethods = $aExportMethods;
-        foreach($xMetadata->getProperties() as $sFunctionName => $aFunctionOptions)
+        foreach ($xMetadata->getProperties() as $sFunctionName => $aFunctionOptions)
         {
             $this->addFunctionOptions($sFunctionName, $aFunctionOptions);
         }
@@ -162,7 +161,7 @@ 
      */
     private function filterPublicMethods(array $aMethods): array
     {
-        if($this->bExcluded || in_array('*', $this->aExportMethods['except']))
+        if ($this->bExcluded || in_array('*', $this->aExportMethods['except']))
         {
             return [];
         }
@@ -170,12 +169,12 @@ 
         $aBaseMethods = $aMethods[1];
         $aNoMethods = $aMethods[2];
         $aMethods = $aMethods[0];
-        if(isset($this->aExportMethods['only']))
+        if (isset($this->aExportMethods['only']))
         {
             $aMethods = array_intersect($aMethods, $this->aExportMethods['only']);
         }
         $aMethods = array_diff($aMethods, $this->aExportMethods['except']);
-        if(count($aBaseMethods) > 0 && isset($this->aExportMethods['base']))
+        if (count($aBaseMethods) > 0 && isset($this->aExportMethods['base']))
         {
             $aBaseMethods = array_diff($aBaseMethods, $this->aExportMethods['base']);
         }
@@ -261,19 +260,19 @@ 
      */
     private function setHookMethods(array &$aHookMethods, $xValue): void
     {
-        foreach($xValue as $sCalledMethod => $xMethodToCall)
+        foreach ($xValue as $sCalledMethod => $xMethodToCall)
         {
-            if(!isset($aHookMethods[$sCalledMethod]))
+            if (!isset($aHookMethods[$sCalledMethod]))
             {
                 $aHookMethods[$sCalledMethod] = [];
             }
-            if(is_array($xMethodToCall))
+            if (is_array($xMethodToCall))
             {
                 $aHookMethods[$sCalledMethod] =
                     array_merge($aHookMethods[$sCalledMethod], $xMethodToCall);
                 continue;
             }
-            if(is_string($xMethodToCall))
+            if (is_string($xMethodToCall))
             {
                 $aHookMethods[$sCalledMethod][] = $xMethodToCall;
             }
@@ -298,7 +297,7 @@ 
      */
     private function addOption(string $sName, $xValue): void
     {
-        switch($sName)
+        switch ($sName)
         {
         // Set the methods to call before processing the request
         case '__before':
@@ -326,11 +325,11 @@ 
      */
     private function _addJsArrayOption(string $sFunctionName, string $sOptionName, $xOptionValue): void
     {
-        if(is_string($xOptionValue))
+        if (is_string($xOptionValue))
         {
             $xOptionValue = [$xOptionValue];
         }
-        if(!is_array($xOptionValue))
+        if (!is_array($xOptionValue))
         {
             return; // Do not save.
         }
@@ -360,10 +359,10 @@ 
      */
     private function addJsOption(string $sFunctionName, string $sOptionName, $xOptionValue): void
     {
-        switch($sOptionName)
+        switch ($sOptionName)
         {
         case 'excluded':
-            if((bool)$xOptionValue)
+            if ((bool)$xOptionValue)
             {
                 $this->addProtectedMethods($sFunctionName);
             }
@@ -387,12 +386,11 @@ 
      */
     private function addFunctionOptions(string $sFunctionName, array $aFunctionOptions): void
     {
-        foreach($aFunctionOptions as $sOptionName => $xOptionValue)
+        foreach ($aFunctionOptions as $sOptionName => $xOptionValue)
         {
             substr($sOptionName, 0, 2) === '__' ?
                 // Options for PHP classes. They start with "__".
-                $this->addOption($sOptionName, [$sFunctionName => $xOptionValue]) :
-                // Options for javascript code.
+                $this->addOption($sOptionName, [$sFunctionName => $xOptionValue]) : // Options for javascript code.
                 $this->addJsOption($sFunctionName, $sOptionName, $xOptionValue);
         }
     }
@@ -408,16 +406,15 @@ 
         $aOptions = array_merge($this->aJsOptions['*'] ?? []); // Clone the array
         // Then add the method options.
         $aMethodOptions = $this->aJsOptions[$sMethodName] ?? [];
-        foreach($aMethodOptions as $sOptionName => $xOptionValue)
+        foreach ($aMethodOptions as $sOptionName => $xOptionValue)
         {
             // For databags and callbacks, merge the values in a single array.
             // For all the other options, keep the last value.
             $aOptions[$sOptionName] = !in_array($sOptionName, ['bags', 'callback']) ?
-                $xOptionValue :
-                array_unique(array_merge($aOptions[$sOptionName] ?? [], $xOptionValue));
+                $xOptionValue : array_unique(array_merge($aOptions[$sOptionName] ?? [], $xOptionValue));
         }
         // Since callbacks are js object names, they need a special formatting.
-        if(isset($aOptions['callback']))
+        if (isset($aOptions['callback']))
         {
             $aOptions['callback'] = str_replace('"', '', json_encode($aOptions['callback']));
         }

jaxon-attributes/src/Attribute/Inject.php

Spacing +8 added lines, -8 removed lines

@@ -21,8 +21,8 @@ 
 
 use function ltrim;
 
-#[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY |
-    Attribute::TARGET_METHOD | Attribute::IS_REPEATABLE)]
+#[Attribute(Attribute::TARGET_CLASS|Attribute::TARGET_PROPERTY|
+    Attribute::TARGET_METHOD|Attribute::IS_REPEATABLE)]
 class Inject extends AbstractAttribute
 {
     /**
@@ -78,17 +78,17 @@ 
      */
     public function validate(): void
     {
-        if($this->nTarget === Attribute::TARGET_CLASS)
+        if ($this->nTarget === Attribute::TARGET_CLASS)
         {
-            if(!$this->attr || !$this->type)
+            if (!$this->attr || !$this->type)
             {
                 throw new SetupException('When applied to a class, the Inject attribute requires two arguments.');
             }
             return;
         }
-        if($this->nTarget === Attribute::TARGET_METHOD)
+        if ($this->nTarget === Attribute::TARGET_METHOD)
         {
-            if(!$this->attr)
+            if (!$this->attr)
             {
                 throw new SetupException('When applied to a method, the Inject attribute requires the "attr" argument.');
             }
@@ -100,13 +100,13 @@ 
      */
     private function getFullClassName(): void
     {
-        if(!$this->type)
+        if (!$this->type)
         {
             // If no type is provided, take the attribute type.
             $this->type = $this->aTypes[$this->attr] ?? '';
             return;
         }
-        if($this->type[0] === '\\')
+        if ($this->type[0] === '\\')
         {
             $this->type = ltrim($this->type, '\\');
         }

jaxon-attributes/src/AttributeReader.php

Spacing +19 added lines, -21 removed lines

@@ -82,19 +82,19 @@ 
     private function readTypes(ReflectionClass $xClass)
     {
         $sClass = $xClass->getName();
-        if(isset($this->aTypes[$sClass]))
+        if (isset($this->aTypes[$sClass]))
         {
             return;
         }
 
         $this->aTypes[$sClass] = [];
-        $aProperties = $xClass->getProperties(ReflectionProperty::IS_PUBLIC |
+        $aProperties = $xClass->getProperties(ReflectionProperty::IS_PUBLIC|
             ReflectionProperty::IS_PROTECTED);
-        foreach($aProperties as $xReflectionProperty)
+        foreach ($aProperties as $xReflectionProperty)
         {
             $xType = $xReflectionProperty->getType();
             // Check that the property has a valid type defined
-            if(is_a($xType, ReflectionNamedType::class) &&
+            if (is_a($xType, ReflectionNamedType::class) &&
                 ($sType = $xType->getName()) !== '')
             {
                 $this->aTypes[$sClass][$xReflectionProperty->getName()] = $sType;
@@ -112,7 +112,7 @@ 
     private function initAttribute(AbstractAttribute $xAttribute,
         ReflectionClass $xClass, ReflectionAttribute $xReflectionAttribute): void
     {
-        if(is_a($xAttribute, InjectAttribute::class))
+        if (is_a($xAttribute, InjectAttribute::class))
         {
             $this->readTypes($xClass);
             $xAttribute->setTarget($xReflectionAttribute->getTarget());
@@ -160,7 +160,7 @@ 
         $aAttributes = $xClass->getAttributes();
         $aAttributes = array_filter($aAttributes, fn($xReflectionAttribute) =>
             $this->isBaseClassAttribute($xReflectionAttribute));
-        foreach($aAttributes as $xReflectionAttribute)
+        foreach ($aAttributes as $xReflectionAttribute)
         {
             $xReflectionAttribute->newInstance()->saveValue($this->xMetadata);
         }
@@ -177,7 +177,7 @@ 
         $aAttributes = array_filter($aAttributes, fn($xReflectionAttribute) =>
             $this->isJaxonAttribute($xReflectionAttribute) &&
             !$this->isBaseClassAttribute($xReflectionAttribute));
-        foreach($aAttributes as $xReflectionAttribute)
+        foreach ($aAttributes as $xReflectionAttribute)
         {
             $xAttribute = $xReflectionAttribute->newInstance();
             $this->initAttribute($xAttribute, $xClass, $xReflectionAttribute);
@@ -195,17 +195,16 @@ 
      */
     private function readPropertyAttributes(ReflectionClass $xClass, string $sProperty): void
     {
-        $aAttributes = !$xClass->hasProperty($sProperty) ? [] :
-            $xClass->getProperty($sProperty)->getAttributes();
+        $aAttributes = !$xClass->hasProperty($sProperty) ? [] : $xClass->getProperty($sProperty)->getAttributes();
         $aAttributes = array_filter($aAttributes, fn($xReflectionAttribute) =>
             $this->isPropertyAttribute($xReflectionAttribute));
         // Only Inject attributes are allowed on properties
-        if(count($aAttributes) > 1)
+        if (count($aAttributes) > 1)
         {
             throw new SetupException('Only one Inject attribute is allowed on a property');
         }
 
-        foreach($aAttributes as $xReflectionAttribute)
+        foreach ($aAttributes as $xReflectionAttribute)
         {
             /** @var InjectAttribute */
             $xAttribute = $xReflectionAttribute->newInstance();
@@ -224,11 +223,10 @@ 
      */
     private function readMethodAttributes(ReflectionClass $xClass, string $sMethod): void
     {
-        $aAttributes = !$xClass->hasMethod($sMethod) ? [] :
-            $xClass->getMethod($sMethod)->getAttributes();
+        $aAttributes = !$xClass->hasMethod($sMethod) ? [] : $xClass->getMethod($sMethod)->getAttributes();
         $aAttributes = array_filter($aAttributes, fn($xReflectionAttribute) =>
             $this->isJaxonAttribute($xReflectionAttribute));
-        foreach($aAttributes as $xReflectionAttribute)
+        foreach ($aAttributes as $xReflectionAttribute)
         {
             $xAttribute = $xReflectionAttribute->newInstance();
             $this->initAttribute($xAttribute, $xClass, $xReflectionAttribute);
@@ -263,33 +261,33 @@ 
             $this->readBaseClassAttributes($xClass);
 
             $aClasses = [$xClass];
-            while(($xClass = $this->getParentClass($xClass)) !== null)
+            while (($xClass = $this->getParentClass($xClass)) !== null)
             {
                 $aClasses[] = $xClass;
             }
             $aClasses = array_reverse($aClasses);
 
-            foreach($aClasses as $xClass)
+            foreach ($aClasses as $xClass)
             {
                 // Processing class attributes
                 $this->readClassAttributes($xClass);
                 // Processing properties attributes
-                foreach($xInput->getProperties() as $sProperty)
+                foreach ($xInput->getProperties() as $sProperty)
                 {
                     $this->readPropertyAttributes($xClass, $sProperty);
                 }
             }
 
             // The methods attributes are not taken for excluded classes.
-            if($this->xMetadata->isExcluded())
+            if ($this->xMetadata->isExcluded())
             {
                 return $this->xMetadata;
             }
 
-            foreach($aClasses as $xClass)
+            foreach ($aClasses as $xClass)
             {
                 // Processing methods attributes
-                foreach($xInput->getMethods() as $sMethod)
+                foreach ($xInput->getMethods() as $sMethod)
                 {
                     $this->readMethodAttributes($xClass, $sMethod);
                 }
@@ -297,7 +295,7 @@ 
 
             return $this->xMetadata;
         }
-        catch(Exception|Error $e)
+        catch (Exception|Error $e)
         {
             throw new SetupException($e->getMessage());
         }

jaxon-annotations/src/AnnotationReader.php

Spacing +13 added lines, -13 removed lines

@@ -116,21 +116,21 @@ 
             fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
         );
         // First check if the class is excluded.
-        foreach($aAnnotations as $xAnnotation)
+        foreach ($aAnnotations as $xAnnotation)
         {
-            if(is_a($xAnnotation, ExcludeAnnotation::class))
+            if (is_a($xAnnotation, ExcludeAnnotation::class))
             {
                 $xAnnotation->saveValue($this->xMetadata);
             }
         }
-        if($this->xMetadata->isExcluded())
+        if ($this->xMetadata->isExcluded())
         {
             return;
         }
 
-        foreach($aAnnotations as $xAnnotation)
+        foreach ($aAnnotations as $xAnnotation)
         {
-            if(!is_a($xAnnotation, ExcludeAnnotation::class))
+            if (!is_a($xAnnotation, ExcludeAnnotation::class))
             {
                 $xAnnotation->saveValue($this->xMetadata);
             }
@@ -152,7 +152,7 @@ 
             $this->xManager->getPropertyAnnotations($sClass, $sProperty),
             function($xAnnotation) use($sProperty) {
                 // Save the property type
-                if(is_a($xAnnotation, VarAnnotation::class))
+                if (is_a($xAnnotation, VarAnnotation::class))
                 {
                     $this->aPropTypes[$sProperty] = $xAnnotation->type;
                 }
@@ -160,12 +160,12 @@ 
                 return is_a($xAnnotation, ContainerAnnotation::class);
             }
         );
-        if(count($aAnnotations) > 1)
+        if (count($aAnnotations) > 1)
         {
             throw new AnnotationException('Only one @di annotation is allowed on a property');
         }
 
-        foreach($aAnnotations as $xAnnotation)
+        foreach ($aAnnotations as $xAnnotation)
         {
             $xAnnotation->setAttr($sProperty);
             $xAnnotation->saveValue($this->xMetadata);
@@ -187,7 +187,7 @@ 
             $this->xManager->getMethodAnnotations($sClass, $sMethod),
             fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
         );
-        foreach($aAnnotations as $xAnnotation)
+        foreach ($aAnnotations as $xAnnotation)
         {
             $xAnnotation->saveValue($this->xMetadata, $sMethod);
         }
@@ -214,13 +214,13 @@ 
             $this->sCurrMemberType = AnnotationManager::MEMBER_PROPERTY;
 
             // Properties annotations
-            foreach($xInput->getProperties() as $sProperty)
+            foreach ($xInput->getProperties() as $sProperty)
             {
                 $this->readPropertyAnnotations($sClass, $sProperty);
             }
 
             // The methods annotations are not taken for excluded classes.
-            if($this->xMetadata->isExcluded())
+            if ($this->xMetadata->isExcluded())
             {
                 return $this->xMetadata;
             }
@@ -228,14 +228,14 @@ 
             // Processing methods annotations
             $this->sCurrMemberType = AnnotationManager::MEMBER_METHOD;
 
-            foreach($xInput->getMethods() as $sMethod)
+            foreach ($xInput->getMethods() as $sMethod)
             {
                 $this->readMethodAnnotations($sClass, $sMethod);
             }
 
             return $this->xMetadata;
         }
-        catch(AnnotationException $e)
+        catch (AnnotationException $e)
         {
             throw new SetupException($e->getMessage());
         }