jaxon-php / jaxon-mono

jaxon-core/src/Di/Traits/ComponentTrait.php

Spacing +14 added lines, -14 removed lines

@@ -151,15 +151,15 @@ 
         $xRegistry->updateHash(false); // Disable hash calculation.
 
         $sComponentId = str_replace('\\', '.', $sClassName);
-        if(!isset($this->aComponents[$sComponentId]))
+        if (!isset($this->aComponents[$sComponentId]))
         {
             $aOptions = $xRegistry->getNamespaceComponentOptions($sClassName);
-            if($aOptions !== null)
+            if ($aOptions !== null)
             {
                 $this->saveComponent($sClassName, $aOptions);
             }
         }
-        if(isset($this->aComponents[$sComponentId]))
+        if (isset($this->aComponents[$sComponentId]))
         {
             return; // The component is found.
         }
@@ -167,11 +167,11 @@ 
         // The component was not found in a registered namespace. We need to parse all
         // the directories to be able to find a component registered without a namespace.
         $sComponentId = str_replace('\\', '_', $sClassName);
-        if(!isset($this->aComponents[$sComponentId]))
+        if (!isset($this->aComponents[$sComponentId]))
         {
             $xRegistry->registerComponentsInDirectories();
         }
-        if(isset($this->aComponents[$sComponentId]))
+        if (isset($this->aComponents[$sComponentId]))
         {
             return; // The component is found.
         }
@@ -189,7 +189,7 @@ 
     public function getCallableObjects(): array
     {
         $aCallableObjects = [];
-        foreach($this->aComponents as $sComponentId => $_)
+        foreach ($this->aComponents as $sComponentId => $_)
         {
             $aCallableObjects[$sComponentId] = $this->makeCallableObject($sComponentId);
         }
@@ -204,7 +204,7 @@ 
      */
     private function setComponentPublicMethods(string $sKey, string $sClass): void
     {
-        if(isset($this->aComponentPublicMethods[$sKey]))
+        if (isset($this->aComponentPublicMethods[$sKey]))
         {
             return;
         }
@@ -253,12 +253,12 @@ 
     {
         /** @var Config|null */
         $xPackageConfig = $aOptions['config'] ?? null;
-        if($xPackageConfig === null || (bool)($aOptions['excluded'] ?? false))
+        if ($xPackageConfig === null || (bool)($aOptions['excluded'] ?? false))
         {
             return null;
         }
         $sMetadataFormat = $xPackageConfig->getOption('metadata.format');
-        if(!in_array($sMetadataFormat, ['attributes', 'annotations']))
+        if (!in_array($sMetadataFormat, ['attributes', 'annotations']))
         {
             return null;
         }
@@ -268,23 +268,23 @@ 
         $xMetadata = null;
         $xMetadataCache = null;
         $xConfig = $di->config();
-        if($xConfig->getAppOption('metadata.cache.enabled', false))
+        if ($xConfig->getAppOption('metadata.cache.enabled', false))
         {
-            if(!$di->h('jaxon_metadata_cache_dir'))
+            if (!$di->h('jaxon_metadata_cache_dir'))
             {
                 $sCacheDir = $xConfig->getAppOption('metadata.cache.dir');
                 $di->val('jaxon_metadata_cache_dir', $sCacheDir);
             }
             $xMetadataCache = $di->getMetadataCache();
             $xMetadata = $xMetadataCache->read($xReflectionClass->getName());
-            if($xMetadata !== null)
+            if ($xMetadata !== null)
             {
                 return $xMetadata;
             }
         }
 
         $aProperties = array_map(fn($xProperty) => $xProperty->getName(),
-            $xReflectionClass->getProperties(ReflectionProperty::IS_PUBLIC |
+            $xReflectionClass->getProperties(ReflectionProperty::IS_PUBLIC|
                 ReflectionProperty::IS_PROTECTED));
 
         $xMetadataReader = $di->getMetadataReader($sMetadataFormat);
@@ -292,7 +292,7 @@ 
         $xMetadata = $xMetadataReader->getAttributes($xInput);
 
         // Try to save the metadata in the cache
-        if($xMetadataCache !== null && $xMetadata !== null)
+        if ($xMetadataCache !== null && $xMetadata !== null)
         {
             $xMetadataCache->save($xReflectionClass->getName(), $xMetadata);
         }

jaxon-core/src/App/Metadata/Data/HookData.php

Spacing +2 added lines, -2 removed lines

@@ -55,7 +55,7 @@ 
      */
     public function addCall(string $sMethod, array $aParams): void
     {
-        if(!$this->validateMethod($sMethod))
+        if (!$this->validateMethod($sMethod))
         {
             $sType = $this->getType();
             throw new SetupException("'$sMethod' is not a valid \"call\" value for $sType.");
@@ -69,7 +69,7 @@ 
     public function encode(string $sVarName): array
     {
         $aCalls = [];
-        foreach($this->aCalls as $sMethod => $aParams)
+        foreach ($this->aCalls as $sMethod => $aParams)
         {
             $sParams = addslashes(json_encode($aParams));
             $aCalls[] = "{$sVarName}->addCall('$sMethod', json_decode(\"$sParams\", true));";

jaxon-core/src/App/Metadata/Data/ExportData.php

Spacing +3 added lines, -3 removed lines

@@ -50,11 +50,11 @@
      */
     public function setMethods(array $aMethods): void
     {
-        foreach(['base', 'only', 'except'] as $sKey)
+        foreach (['base', 'only', 'except'] as $sKey)
         {
-            foreach($aMethods[$sKey] as $sMethod)
+            foreach ($aMethods[$sKey] as $sMethod)
             {
-                if(!is_string($sMethod) || !$this->validateMethod($sMethod))
+                if (!is_string($sMethod) || !$this->validateMethod($sMethod))
                 {
                     throw new SetupException("'$sMethod' is not a valid method name.");
                 }

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

Spacing +4 added lines, -5 removed lines

@@ -73,8 +73,7 @@ 
      */
     public function excluded(?string $sMethodName = null): bool
     {
-        return $sMethodName === null ? $this->xOptions->excluded() :
-            !$this->xOptions->isPublicMethod($sMethodName);
+        return $sMethodName === null ? $this->xOptions->excluded() : !$this->xOptions->isPublicMethod($sMethodName);
     }
 
     /**
@@ -160,11 +159,11 @@ 
         $sMethod = $this->xTarget->getMethodName();
         // The hooks defined at method level are merged with those defined at class level.
         $aMethods = array_merge($aHookMethods['*'] ?? [], $aHookMethods[$sMethod] ?? []);
-        foreach($aMethods as $xKey => $xValue)
+        foreach ($aMethods as $xKey => $xValue)
         {
             $sHookName = $xValue;
             $aHookArgs = [];
-            if(is_string($xKey))
+            if (is_string($xKey))
             {
                 $sHookName = $xKey;
                 $aHookArgs = is_array($xValue) ? $xValue : [$xValue];
@@ -202,7 +201,7 @@ 
             // Warning: dynamic properties will be deprecated in PHP8.2.
             $this->$sAttr = $xDiValue;
         };
-        foreach($aDiOptions as $sAttr => $sClass)
+        foreach ($aDiOptions as $sAttr => $sClass)
         {
             $this->setDiAttribute($xComponent, $sAttr, $this->di->get($sClass), $cSetter);
         }

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

Spacing +24 added lines, -27 removed lines

@@ -107,33 +107,33 @@ 
     {
         $this->bExcluded = ($xMetadata?->isExcluded() ?? false) ||
             (bool)($aOptions['excluded'] ?? false);
-        if($this->bExcluded)
+        if ($this->bExcluded)
         {
             return;
         }
 
         $sSeparator = $aOptions['separator'];
-        if($sSeparator === '_' || $sSeparator === '.')
+        if ($sSeparator === '_' || $sSeparator === '.')
         {
             $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);
             }
         }
 
-        if($xMetadata !== null)
+        if ($xMetadata !== null)
         {
             $this->aExportMethods = $xMetadata->getExportMethods();
             $this->addProtectedMethods($xMetadata->getProtectedMethods());
-            foreach($xMetadata->getProperties() as $sFunctionName => $aFunctionOptions)
+            foreach ($xMetadata->getProperties() as $sFunctionName => $aFunctionOptions)
             {
                 $this->addFunctionOptions($sFunctionName, $aFunctionOptions);
             }
@@ -150,8 +150,7 @@ 
     private function addProtectedMethods(array|string $xMethods): void
     {
         $this->aProtectedMethods = array_merge($this->aProtectedMethods,
-            !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));
     }
 
     /**
@@ -161,7 +160,7 @@ 
      */
     private function filterPublicMethods(array $aMethods): array
     {
-        if($this->bExcluded || in_array('*', $this->aProtectedMethods))
+        if ($this->bExcluded || in_array('*', $this->aProtectedMethods))
         {
             return [];
         }
@@ -169,13 +168,13 @@ 
         $aBaseMethods = $aMethods[1];
         $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->aProtectedMethods,
             $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']);
         }
@@ -253,17 +252,17 @@ 
      */
     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);
             }
-            elseif(is_string($xMethodToCall))
+            elseif (is_string($xMethodToCall))
             {
                 $aHookMethods[$sCalledMethod][] = $xMethodToCall;
             }
@@ -288,7 +287,7 @@ 
      */
     private function addOption(string $sName, $xValue): void
     {
-        switch($sName)
+        switch ($sName)
         {
         // Set the methods to call before processing the request
         case '__before':
@@ -316,11 +315,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.
         }
@@ -350,10 +349,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);
             }
@@ -377,12 +376,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);
         }
     }
@@ -398,16 +396,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/Export.php

Spacing +2 added lines, -2 removed lines

@@ -38,9 +38,9 @@
     public function saveValue(Metadata $xMetadata, string $sMethod = '*'): void
     {
         $aMethods = [];
-        foreach(['base', 'only', 'except'] as $key)
+        foreach (['base', 'only', 'except'] as $key)
         {
-            if($this->$key !== null && count($this->$key) > 0)
+            if ($this->$key !== null && count($this->$key) > 0)
             {
                 $aMethods[$key] = $this->$key;
             }

jaxon-attributes/src/AttributeReader.php

Spacing +19 added lines, -21 removed lines

@@ -69,19 +69,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;
@@ -99,7 +99,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());
@@ -117,7 +117,7 @@ 
         $aClassAttributes = $xClass->getAttributes();
         $aAttributes = array_filter($aClassAttributes, fn($xAttribute) =>
             is_a($xAttribute->getName(), ExcludeAttribute::class, true));
-        foreach($aAttributes as $xReflectionAttribute)
+        foreach ($aAttributes as $xReflectionAttribute)
         {
             $xReflectionAttribute->newInstance()->saveValue($this->xMetadata);
         }
@@ -135,7 +135,7 @@ 
         $aClassAttributes = $xClass->getAttributes();
         $aAttributes = array_filter($aClassAttributes, fn($xAttribute) =>
             is_a($xAttribute->getName(), ExportAttribute::class, true));
-        foreach($aAttributes as $xReflectionAttribute)
+        foreach ($aAttributes as $xReflectionAttribute)
         {
             $xReflectionAttribute->newInstance()->saveValue($this->xMetadata);
         }
@@ -153,7 +153,7 @@ 
             is_a($xAttribute->getName(), AbstractAttribute::class, true) &&
             !is_a($xAttribute->getName(), ExcludeAttribute::class, true) &&
             !is_a($xAttribute->getName(), ExportAttribute::class, true));
-        foreach($aAttributes as $xReflectionAttribute)
+        foreach ($aAttributes as $xReflectionAttribute)
         {
             $xAttribute = $xReflectionAttribute->newInstance();
             $this->initAttribute($xAttribute, $xClass, $xReflectionAttribute);
@@ -172,16 +172,15 @@ 
     private function getPropertyAttrs(ReflectionClass $xClass, string $sProperty): void
     {
         // Only Inject attributes are allowed on properties
-        $aAttributes = !$xClass->hasProperty($sProperty) ? [] :
-            $xClass->getProperty($sProperty)->getAttributes();
+        $aAttributes = !$xClass->hasProperty($sProperty) ? [] : $xClass->getProperty($sProperty)->getAttributes();
         $aAttributes = array_filter($aAttributes, fn($xAttribute) =>
             is_a($xAttribute->getName(), InjectAttribute::class, true));
-        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();
@@ -200,11 +199,10 @@ 
      */
     private function getMethodAttrs(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($xAttribute) =>
             is_a($xAttribute->getName(), AbstractAttribute::class, true));
-        foreach($aAttributes as $xReflectionAttribute)
+        foreach ($aAttributes as $xReflectionAttribute)
         {
             $xAttribute = $xReflectionAttribute->newInstance();
             $this->initAttribute($xAttribute, $xClass, $xReflectionAttribute);
@@ -238,7 +236,7 @@ 
             $xClass = $xInput->getReflectionClass();
             // First check if the class is exluded.
             $this->getClassExcludeAttr($xClass);
-            if($this->xMetadata->isExcluded())
+            if ($this->xMetadata->isExcluded())
             {
                 return $this->xMetadata;
             }
@@ -247,25 +245,25 @@ 
             $this->getBaseClassAttrs($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->getClassAttrs($xClass);
 
                 // Processing properties attributes
-                foreach($xInput->getProperties() as $sProperty)
+                foreach ($xInput->getProperties() as $sProperty)
                 {
                     $this->getPropertyAttrs($xClass, $sProperty);
                 }
 
                 // Processing methods attributes
-                foreach($xInput->getMethods() as $sMethod)
+                foreach ($xInput->getMethods() as $sMethod)
                 {
                     $this->getMethodAttrs($xClass, $sMethod);
                 }
@@ -273,7 +271,7 @@ 
 
             return $this->xMetadata;
         }
-        catch(Exception|Error $e)
+        catch (Exception|Error $e)
         {
             throw new SetupException($e->getMessage());
         }

jaxon-annotations/src/Annotation/ExportAnnotation.php

Spacing +2 added lines, -2 removed lines

@@ -46,9 +46,9 @@
      */
     public function initAnnotation(array $properties)
     {
-        foreach(['base', 'only', 'except'] as $key)
+        foreach (['base', 'only', 'except'] as $key)
         {
-            if(isset($properties[$key]) && is_array($properties[$key]) &&
+            if (isset($properties[$key]) && is_array($properties[$key]) &&
                 count($properties[$key]) > 0)
             {
                 $this->aMethods[$key] = $properties[$key];

jaxon-annotations/tests/TestAnnotation/ExtendAnnotationTest.php

Spacing +1 added lines, -1 removed lines

@@ -45,7 +45,7 @@
         $aFiles = scandir($this->sCacheDir);
         foreach ($aFiles as $sFile)
         {
-            if($sFile !== '.' && $sFile !== '..')
+            if ($sFile !== '.' && $sFile !== '..')
             {
                 @unlink($this->sCacheDir . DIRECTORY_SEPARATOR . $sFile);
             }