jaxon-php / jaxon-core

src/Plugin/Request/CallableFunction/CallableFunctionPlugin.php

Spacing +11 added lines, -11 removed lines

@@ -128,15 +128,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'));
         }
@@ -157,9 +157,9 @@ 
         $sPhpFunction = trim($sCallable);
         $sFunction = $sPhpFunction;
         // Check if an alias is defined
-        if(isset($aOptions['alias']))
+        if (isset($aOptions['alias']))
         {
-            $sFunction = (string)$aOptions['alias'];
+            $sFunction = (string) $aOptions['alias'];
             unset($aOptions['alias']);
         }
         $this->aFunctions[$sFunction] = $sPhpFunction;
@@ -181,13 +181,13 @@ 
     public function getCallable(string $sCallable)
     {
         $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);
         }
@@ -216,7 +216,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);
@@ -230,7 +230,7 @@ 
     public static function canProcessRequest(ServerRequestInterface $xRequest): bool
     {
         $aBody = $xRequest->getParsedBody();
-        if(is_array($aBody))
+        if (is_array($aBody))
         {
             return isset($aBody['jxnfun']);
         }
@@ -244,7 +244,7 @@ 
     public function setTarget(ServerRequestInterface $xRequest)
     {
         $aBody = $xRequest->getParsedBody();
-        if(is_array($aBody))
+        if (is_array($aBody))
         {
             $this->xTarget = Target::makeFunction(trim($aBody['jxnfun']));
             return;
@@ -262,7 +262,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

src/Plugin/Request/CallableFunction/CallableFunction.php

Spacing +3 added lines, -3 removed lines

@@ -123,7 +123,7 @@ 
      */
     public function configure(string $sName, string $sValue)
     {
-        switch($sName)
+        switch ($sName)
         {
         case 'class': // The user function is a method in the given class
             $this->xPhpFunction = [$sValue, $this->xPhpFunction];
@@ -147,12 +147,12 @@ 
      */
     public function call(array $aArgs = [])
     {
-        if(($this->sInclude))
+        if (($this->sInclude))
         {
             require_once $this->sInclude;
         }
         // If the function is an alias for a class method, then instantiate the class
-        if(is_array($this->xPhpFunction) && is_string($this->xPhpFunction[0]))
+        if (is_array($this->xPhpFunction) && is_string($this->xPhpFunction[0]))
         {
             $sClassName = $this->xPhpFunction[0];
             $this->xPhpFunction[0] = $this->di->h($sClassName) ? $this->di->g($sClassName) : new $sClassName;

src/Plugin/Request/CallableClass/CallableRepository.php

Spacing +15 added lines, -15 removed lines

@@ -110,7 +110,7 @@ 
 
         // The methods of the CallableClass class must not be exported
         $xCallableClass = new ReflectionClass(CallableClass::class);
-        foreach($xCallableClass->getMethods(ReflectionMethod::IS_PUBLIC) as $xMethod)
+        foreach ($xCallableClass->getMethods(ReflectionMethod::IS_PUBLIC) as $xMethod)
         {
             $this->aProtectedMethods[] = $xMethod->getName();
         }
@@ -181,14 +181,14 @@ 
      */
     public function makeClassOptions(string $sClassName, array $aClassOptions, array $aDirectoryOptions): array
     {
-        foreach($this->aDefaultClassOptions as $sOption => $xValue)
+        foreach ($this->aDefaultClassOptions as $sOption => $xValue)
         {
-            if(!isset($aClassOptions[$sOption]))
+            if (!isset($aClassOptions[$sOption]))
             {
                 $aClassOptions[$sOption] = $xValue;
             }
         }
-        if(is_string($aClassOptions['protected']))
+        if (is_string($aClassOptions['protected']))
         {
             $aClassOptions['protected'] = [$aClassOptions['protected']]; // Convert to array.
         }
@@ -199,21 +199,21 @@ 
             $aDirectoryOptions['classes']['*'] ?? [], // Options for all classes
             $aDirectoryOptions['classes'][$sClassName] ?? [], // Options for this specific class
         ];
-        foreach($aOptionGroups as $aOptionGroup)
+        foreach ($aOptionGroups as $aOptionGroup)
         {
-            if(isset($aOptionGroup['separator']))
+            if (isset($aOptionGroup['separator']))
             {
                 $aClassOptions['separator'] = $aOptionGroup['separator'];
             }
-            if(isset($aOptionGroup['protected']))
+            if (isset($aOptionGroup['protected']))
             {
-                if(is_string($aOptionGroup['protected']))
+                if (is_string($aOptionGroup['protected']))
                 {
                     $aOptionGroup['protected'] = [$aOptionGroup['protected']]; // Convert to array.
                 }
                 $aClassOptions['protected'] = array_merge($aClassOptions['protected'], $aOptionGroup['protected']);
             }
-            if(isset($aOptionGroup['functions']))
+            if (isset($aOptionGroup['functions']))
             {
                 $aClassOptions['functions'] = array_merge($aClassOptions['functions'], $aOptionGroup['functions']);
             }
@@ -259,10 +259,10 @@ 
     private function getNamespaceClassOptions(string $sClassName)
     {
         // Find the corresponding namespace
-        foreach($this->aNamespaceOptions as $sNamespace => $aOptions)
+        foreach ($this->aNamespaceOptions as $sNamespace => $aOptions)
         {
             // Check if the namespace matches the class.
-            if(strncmp($sClassName, $sNamespace . '\\', strlen($sNamespace) + 1) === 0)
+            if (strncmp($sClassName, $sNamespace . '\\', strlen($sNamespace) + 1) === 0)
             {
                 // Save the class options
                 $this->aClasses[$sClassName] = $this->makeClassOptions($sClassName,
@@ -283,17 +283,17 @@ 
     public function getClassOptions(string $sClassName): array
     {
         // Find options for a class registered with namespace.
-        if(!isset($this->aClasses[$sClassName]))
+        if (!isset($this->aClasses[$sClassName]))
         {
             $this->getNamespaceClassOptions($sClassName);
-            if(!isset($this->aClasses[$sClassName]))
+            if (!isset($this->aClasses[$sClassName]))
             {
                 // Find options for a class registered without namespace.
                 // We then need to parse all classes to be able to find one.
                 $this->di->getCallableRegistry()->parseDirectories();
             }
         }
-        if(isset($this->aClasses[$sClassName]))
+        if (isset($this->aClasses[$sClassName]))
         {
             return $this->aClasses[$sClassName];
         }
@@ -322,7 +322,7 @@ 
     public function getCallableObjects(): array
     {
         $aCallableObjects = [];
-        foreach($this->aClasses as $sClassName => $aOptions)
+        foreach ($this->aClasses as $sClassName => $aOptions)
         {
             $this->di->registerCallableClass($sClassName, $aOptions);
             $aCallableObjects[$sClassName] = $this->di->getCallableObject($sClassName);

src/Plugin/Request/CallableClass/CallableRegistry.php

Spacing +19 added lines, -19 removed lines

@@ -89,7 +89,7 @@ 
         $this->xRepository = $xRepository;
 
         // Set the composer autoloader
-        if(file_exists(($sAutoloadFile = __DIR__ . '/../../../../../../autoload.php')) ||
+        if (file_exists(($sAutoloadFile = __DIR__ . '/../../../../../../autoload.php')) ||
             file_exists(($sAutoloadFile = __DIR__ . '/../../../../vendor/autoload.php')))
         {
             $this->xAutoloader = require($sAutoloadFile);
@@ -106,7 +106,7 @@ 
     public function addDirectory(string $sDirectory, array $aOptions)
     {
         // Set the autoload option default value
-        if(!isset($aOptions['autoload']))
+        if (!isset($aOptions['autoload']))
         {
             $aOptions['autoload'] = true;
         }
@@ -123,26 +123,26 @@ 
     public function addNamespace(string $sNamespace, array $aOptions)
     {
         // Separator default value
-        if(!isset($aOptions['separator']))
+        if (!isset($aOptions['separator']))
         {
             $aOptions['separator'] = '.';
         }
         $aOptions['separator'] = trim($aOptions['separator']);
-        if(!in_array($aOptions['separator'], ['.', '_']))
+        if (!in_array($aOptions['separator'], ['.', '_']))
         {
             $aOptions['separator'] = '.';
         }
-        if($aOptions['separator'] === '_')
+        if ($aOptions['separator'] === '_')
         {
             $this->bUsingUnderscore = true;
         }
         // Set the autoload option default value
-        if(!isset($aOptions['autoload']))
+        if (!isset($aOptions['autoload']))
         {
             $aOptions['autoload'] = true;
         }
         // Register the dir with PSR4 autoloading
-        if(($aOptions['autoload']) && $this->xAutoloader != null)
+        if (($aOptions['autoload']) && $this->xAutoloader != null)
         {
             $this->xAutoloader->setPsr4($sNamespace . '\\', $aOptions['directory']);
         }
@@ -157,7 +157,7 @@ 
     public function parseDirectories()
     {
         // This is to be done only once.
-        if($this->bDirectoriesParsed)
+        if ($this->bDirectoriesParsed)
         {
             return;
         }
@@ -165,14 +165,14 @@ 
 
         // Browse directories without namespaces and read all the files.
         $aClassMap = [];
-        foreach($this->xRepository->getDirectoryOptions() as $sDirectory => $aOptions)
+        foreach ($this->xRepository->getDirectoryOptions() as $sDirectory => $aOptions)
         {
             $itFile = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($sDirectory));
             // Iterate on dir content
-            foreach($itFile as $xFile)
+            foreach ($itFile as $xFile)
             {
                 // Skip everything except PHP files
-                if(!$xFile->isFile() || $xFile->getExtension() != 'php')
+                if (!$xFile->isFile() || $xFile->getExtension() != 'php')
                 {
                     continue;
                 }
@@ -180,7 +180,7 @@ 
                 $sClassName = $xFile->getBasename('.php');
                 $aClassOptions = ['timestamp' => $xFile->getMTime()];
                 // No more custom classmap autoloading. The file will be included when needed.
-                if(($aOptions['autoload']))
+                if (($aOptions['autoload']))
                 {
                     $aClassMap[$sClassName] = $xFile->getPathname();
                 }
@@ -188,7 +188,7 @@ 
             }
         }
         // Set classmap autoloading
-        if(($aClassMap) && $this->xAutoloader !== null)
+        if (($aClassMap) && $this->xAutoloader !== null)
         {
             $this->xAutoloader->addClassMap($aClassMap);
         }
@@ -202,7 +202,7 @@ 
     public function parseNamespaces()
     {
         // This is to be done only once.
-        if($this->bNamespacesParsed)
+        if ($this->bNamespacesParsed)
         {
             return;
         }
@@ -210,17 +210,17 @@ 
 
         // Browse directories with namespaces and read all the files.
         $sDS = DIRECTORY_SEPARATOR;
-        foreach($this->xRepository->getNamespaceOptions() as $sNamespace => $aOptions)
+        foreach ($this->xRepository->getNamespaceOptions() as $sNamespace => $aOptions)
         {
             $this->xRepository->addNamespace($sNamespace, ['separator' => $aOptions['separator']]);
 
             // Iterate on dir content
             $sDirectory = $aOptions['directory'];
             $itFile = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($sDirectory));
-            foreach($itFile as $xFile)
+            foreach ($itFile as $xFile)
             {
                 // skip everything except PHP files
-                if(!$xFile->isFile() || $xFile->getExtension() != 'php')
+                if (!$xFile->isFile() || $xFile->getExtension() != 'php')
                 {
                     continue;
                 }
@@ -229,7 +229,7 @@ 
                 $sClassPath = $sNamespace;
                 $sRelativePath = substr($xFile->getPath(), strlen($sDirectory));
                 $sRelativePath = trim(str_replace($sDS, '\\', $sRelativePath), '\\');
-                if($sRelativePath !== '')
+                if ($sRelativePath !== '')
                 {
                     $sClassPath .= '\\' . $sRelativePath;
                 }
@@ -256,7 +256,7 @@ 
         // Replace all separators ('.' and '_') with antislashes, and remove the antislashes
         // at the beginning and the end of the class name.
         $sClassName = trim(str_replace('.', '\\', $sClassName), '\\');
-        if($this->bUsingUnderscore)
+        if ($this->bUsingUnderscore)
         {
             $sClassName = trim(str_replace('_', '\\', $sClassName), '\\');
         }

src/Di/Traits/RegisterTrait.php

Spacing +13 added lines, -13 removed lines

@@ -36,15 +36,15 @@ 
     private function getCallableObjectOptions(array $aConfigOptions, array $aAnnotationOptions): array
     {
         $aOptions = [];
-        foreach($aConfigOptions as $sNames => $aFunctionOptions)
+        foreach ($aConfigOptions as $sNames => $aFunctionOptions)
         {
             $aFunctionNames = explode(',', $sNames); // Names are in comma-separated list.
-            foreach($aFunctionNames as $sFunctionName)
+            foreach ($aFunctionNames as $sFunctionName)
             {
                 $aOptions[$sFunctionName] = array_merge($aOptions[$sFunctionName] ?? [], $aFunctionOptions);
             }
         }
-        foreach($aAnnotationOptions as $sFunctionName => $aFunctionOptions)
+        foreach ($aAnnotationOptions as $sFunctionName => $aFunctionOptions)
         {
             $aOptions[$sFunctionName] = array_merge($aOptions[$sFunctionName] ?? [], $aFunctionOptions);
         }
@@ -66,7 +66,7 @@ 
         $aMethods = $xCallableObject->getPublicMethods($aProtectedMethods);
         $aProperties = $xCallableObject->getProperties();
         [$bExcluded, $aAnnotationOptions, $aAnnotationProtected] = $xAnnotationReader->getAttributes($sClassName, $aMethods, $aProperties);
-        if($bExcluded)
+        if ($bExcluded)
         {
             $xCallableObject->configure('excluded', true);
             return;
@@ -78,11 +78,11 @@ 
         // Functions options
         $aCallableOptions = [];
         $aOptions = $this->getCallableObjectOptions($aOptions['functions'], $aAnnotationOptions);
-        foreach($aOptions as $sFunctionName => $aFunctionOptions)
+        foreach ($aOptions as $sFunctionName => $aFunctionOptions)
         {
-            foreach($aFunctionOptions as $sOptionName => $xOptionValue)
+            foreach ($aFunctionOptions as $sOptionName => $xOptionValue)
             {
-                if(substr($sOptionName, 0, 2) !== '__')
+                if (substr($sOptionName, 0, 2) !== '__')
                 {
                     // Options for javascript code.
                     $aCallableOptions[$sFunctionName][$sOptionName] = $xOptionValue;
@@ -111,13 +111,13 @@ 
         $sReflectionClass = $sClassName . '_ReflectionClass';
 
         // Prevent duplication
-        if($this->h($sReflectionClass)) // It's important not to use the class name here.
+        if ($this->h($sReflectionClass)) // It's important not to use the class name here.
         {
             return;
         }
 
         // Make sure the registered class exists
-        if(isset($aOptions['include']))
+        if (isset($aOptions['include']))
         {
             require_once($aOptions['include']);
         }
@@ -126,7 +126,7 @@ 
         {
             $this->val($sReflectionClass, new ReflectionClass($sClassName));
         }
-        catch(ReflectionException $e)
+        catch (ReflectionException $e)
         {
             $xTranslator = $this->g(Translator::class);
             $sMessage = $xTranslator->trans('errors.class.invalid', ['name' => $sClassName]);
@@ -149,7 +149,7 @@ 
         });
 
         // Register the user class, but only if the user already didn't.
-        if(!$this->h($sClassName))
+        if (!$this->h($sClassName))
         {
             $this->set($sClassName, function($c) use($sReflectionClass) {
                 return $this->make($c->g($sReflectionClass));
@@ -157,7 +157,7 @@ 
         }
         // Initialize the user class instance
         $this->extend($sClassName, function($xRegisteredObject, $c) use($sClassName) {
-            if($xRegisteredObject instanceof CallableClass)
+            if ($xRegisteredObject instanceof CallableClass)
             {
                 // Set the protected attributes of the object
                 $cSetter = function($c, $sClassName) {
@@ -170,7 +170,7 @@ 
 
             // Run the callbacks for class initialisation
             $aCallbacks = $c->g(CallbackManager::class)->getInitCallbacks();
-            foreach($aCallbacks as $xCallback)
+            foreach ($aCallbacks as $xCallback)
             {
                 call_user_func($xCallback, $xRegisteredObject);
             }

Braces +4 added lines, -3 removed lines

@@ -111,10 +111,12 @@ 
         $sReflectionClass = $sClassName . '_ReflectionClass';
 
         // Prevent duplication
-        if($this->h($sReflectionClass)) // It's important not to use the class name here.
+        if($this->h($sReflectionClass)) {
+            // It's important not to use the class name here.
         {
             return;
         }
+        }
 
         // Make sure the registered class exists
         if(isset($aOptions['include']))
@@ -125,8 +127,7 @@ 
         try
         {
             $this->val($sReflectionClass, new ReflectionClass($sClassName));
-        }
-        catch(ReflectionException $e)
+        } catch(ReflectionException $e)
         {
             $xTranslator = $this->g(Translator::class);
             $sMessage = $xTranslator->trans('errors.class.invalid', ['name' => $sClassName]);