jaxon-php / jaxon-mono

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/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());
         }

jaxon-annotations/tests/TestAnnotation/ComponentTest.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);
             }

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);
         }
@@ -206,7 +206,7 @@ 
     private function setComponentPublicMethods(string $sKey, string $sClass,
         array $aNeverExported): void
     {
-        if(isset($this->aComponentPublicMethods[$sKey]))
+        if (isset($this->aComponentPublicMethods[$sKey]))
         {
             return;
         }
@@ -259,12 +259,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;
         }
@@ -274,23 +274,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);
@@ -298,7 +298,7 @@ 
         $xMetadata = $xMetadataReader->getAttributes($xInput);
 
         // Try to save the metadata in the cache
-        if($xMetadataCache !== null)
+        if ($xMetadataCache !== null)
         {
             $xMetadataCache->save($xReflectionClass->getName(), $xMetadata);
         }

jaxon-upload/src/Manager/UploadManager.php

Spacing +10 added lines, -10 removed lines

@@ -121,13 +121,13 @@ 
         try

         {

             $xFilesystem->createDirectory($sUploadDir);

-            if(!$xFilesystem->directoryExists($sUploadDir))

+            if (!$xFilesystem->directoryExists($sUploadDir))

             {

                 throw new RequestException($this->xTranslator->trans('errors.upload.access'));

             }

             return $sUploadDir;

         }

-        catch(FilesystemException $e)

+        catch (FilesystemException $e)

         {

             $this->xLogger->error('Filesystem error.', ['message' => $e->getMessage()]);

             throw new RequestException($this->xTranslator->trans('errors.upload.access'));

@@ -162,7 +162,7 @@ 
     {

         // Check the uploaded file validity

         $nErrorCode = $xHttpFile->getError();

-        if($nErrorCode !== UPLOAD_ERR_OK)

+        if ($nErrorCode !== UPLOAD_ERR_OK)

         {

             $this->xLogger->error('File upload error.', [

                 'code' => $nErrorCode,

@@ -176,7 +176,7 @@ 
 

         // Filename without the extension. Needs to be sanitized.

         $sName = pathinfo($xHttpFile->getClientFilename(), PATHINFO_FILENAME);

-        if($this->cNameSanitizer !== null)

+        if ($this->cNameSanitizer !== null)

         {

             $sName = (string)call_user_func($this->cNameSanitizer,

                 $sName, $sField, $this->sUploadFieldId);

@@ -185,7 +185,7 @@ 
         // Set the user file data

         $xFile = File::fromHttpFile($this->xFileStorage->filesystem($sField), $xHttpFile, $sUploadDir, $sName);

         // Verify file validity (format, size)

-        if(!$this->xValidator->validateUploadedFile($sField, $xFile))

+        if (!$this->xValidator->validateUploadedFile($sField, $xFile))

         {

             throw new RequestException($this->xValidator->getErrorMessage());

         }

@@ -209,16 +209,16 @@ 
 

         $aUserFiles = [];

         $aAllFiles = []; // A flat list of all uploaded files

-        foreach($aTempFiles as $sField => $aFiles)

+        foreach ($aTempFiles as $sField => $aFiles)

         {

             $aUserFiles[$sField] = [];

             // Get the path to the upload dir

             $sUploadDir = $this->getUploadDir($sField);

-            if(!is_array($aFiles))

+            if (!is_array($aFiles))

             {

                 $aFiles = [$aFiles];

             }

-            foreach($aFiles as $xHttpFile)

+            foreach ($aFiles as $xHttpFile)

             {

                 $aFile = $this->makeUploadedFile($xHttpFile, $sUploadDir, $sField);

                 $aUserFiles[$sField][] = $aFile['user'];

@@ -229,14 +229,14 @@ 
         // Copy the uploaded files from the temp dir to the user dir

         try

         {

-            foreach($aAllFiles as $aFiles)

+            foreach ($aAllFiles as $aFiles)

             {

                 $sPath = $aFiles['user']->path();

                 $xContent = $aFiles['temp']->getStream();

                 $aFiles['user']->filesystem()->write($sPath, $xContent);

             }

         }

-        catch(FilesystemException $e)

+        catch (FilesystemException $e)

         {

             $this->xLogger->error('Filesystem error.', ['message' => $e->getMessage()]);

             throw new RequestException($this->xTranslator->trans('errors.upload.access'));

jaxon-core/src/Plugin/Request/CallableFunction/CallableFunctionPlugin.php

Spacing +13 added lines, -15 removed lines

@@ -86,15 +86,15 @@ 
      */
     public function checkOptions(string $sCallable, $xOptions): array
     {
-        if(!$this->xValidator->validateFunction(trim($sCallable)))
+        if (!$this->xValidator->validateFunction(trim($sCallable)))
         {
             throw new SetupException($this->xTranslator->trans('errors.objects.invalid-declaration'));
         }
-        if(is_string($xOptions))
+        if (is_string($xOptions))
         {
             $xOptions = ['include' => $xOptions];
         }
-        elseif(!is_array($xOptions))
+        elseif (!is_array($xOptions))
         {
             throw new SetupException($this->xTranslator->trans('errors.objects.invalid-declaration'));
         }
@@ -115,7 +115,7 @@ 
         $sPhpFunction = trim($sCallable);
         $sFunction = $sPhpFunction;
         // Check if an alias is defined
-        if(isset($aOptions['alias']))
+        if (isset($aOptions['alias']))
         {
             $sFunction = (string)$aOptions['alias'];
             unset($aOptions['alias']);
@@ -139,13 +139,13 @@ 
     public function getCallable(string $sCallable): CallableFunction|null
     {
         $sFunction = trim($sCallable);
-        if(!isset($this->aFunctions[$sFunction]))
+        if (!isset($this->aFunctions[$sFunction]))
         {
             return null;
         }
         $xCallable = new CallableFunction($this->di, $sFunction,
             $this->sPrefix . $sFunction, $this->aFunctions[$sFunction]);
-        foreach($this->aOptions[$sFunction] as $sName => $sValue)
+        foreach ($this->aOptions[$sFunction] as $sName => $sValue)
         {
             $xCallable->configure($sName, $sValue);
         }
@@ -162,7 +162,7 @@ 
     private function getCallableScript(CallableFunction $xFunction): string
     {
         $aOptions = [];
-        foreach($xFunction->getOptions() as $sKey => $sValue)
+        foreach ($xFunction->getOptions() as $sKey => $sValue)
         {
             $aOptions[] = "$sKey: $sValue";
         }
@@ -170,8 +170,7 @@ 
         return $this->xTemplateEngine->render('jaxon::callables/function.js', [
             'sName' => $xFunction->getName(),
             'sJsName' => $xFunction->getJsName(),
-            'sArguments' => count($aOptions) === 0 ? 'args' :
-                'args, { ' . implode(',', $aOptions) . ' }',
+            'sArguments' => count($aOptions) === 0 ? 'args' : 'args, { ' . implode(',', $aOptions) . ' }',
         ]);
     }
 
@@ -181,7 +180,7 @@ 
     public function getScript(): string
     {
         $code = '';
-        foreach(array_keys($this->aFunctions) as $sFunction)
+        foreach (array_keys($this->aFunctions) as $sFunction)
         {
             $xFunction = $this->getCallable($sFunction);
             $code .= $this->getCallableScript($xFunction);
@@ -219,8 +218,7 @@ 
     private function throwException(Exception $xException, string $sErrorMessage): void
     {
         $this->di->getLogger()->error($xException->getMessage());
-        throw new RequestException($sErrorMessage . (!$this->bDebug ? '' :
-            "\n" . $xException->getMessage()));
+        throw new RequestException($sErrorMessage . (!$this->bDebug ? '' : "\n" . $xException->getMessage()));
     }
 
     /**
@@ -232,7 +230,7 @@ 
         $sRequestedFunction = $this->xTarget->getFunctionName();
 
         // Security check: make sure the requested function was registered.
-        if(!$this->xValidator->validateFunction($sRequestedFunction) ||
+        if (!$this->xValidator->validateFunction($sRequestedFunction) ||
             !isset($this->aFunctions[$sRequestedFunction]))
         {
             // Unable to find the requested function
@@ -245,7 +243,7 @@ 
             /** @var CallableFunction */
             $xFunction = $this->getCallable($sRequestedFunction);
         }
-        catch(Exception $e)
+        catch (Exception $e)
         {
             // Unable to find the requested function
             $this->throwException($e, $this->xTranslator->trans('errors.functions.invalid',
@@ -255,7 +253,7 @@ 
         {
             $xFunction->call($this->xTarget->args());
         }
-        catch(Exception $e)
+        catch (Exception $e)
         {
             // Unable to execute the requested function
             $this->throwException($e, $this->xTranslator->trans('errors.functions.call',