jaxon-php / jaxon-core

src/Request/Support/CallableRepository.php

Spacing +37 added lines, -37 removed lines

@@ -84,7 +84,7 @@ 
     {
         // Set the composer autoloader
         $sAutoloadFile = __DIR__ . '/../../../../../autoload.php';
-        if(file_exists($sAutoloadFile))
+        if (file_exists($sAutoloadFile))
         {
             $this->xAutoloader = require($sAutoloadFile);
         }
@@ -115,19 +115,19 @@ 
     private function getClassOptions($sClassName, array $aDirectoryOptions, array $aDefaultOptions = [])
     {
         $aOptions = $aDefaultOptions;
-        if(key_exists('separator', $aDirectoryOptions))
+        if (key_exists('separator', $aDirectoryOptions))
         {
             $aOptions['separator'] = $aDirectoryOptions['separator'];
         }
-        if(key_exists('protected', $aDirectoryOptions))
+        if (key_exists('protected', $aDirectoryOptions))
         {
             $aOptions['protected'] = $aDirectoryOptions['protected'];
         }
-        if(key_exists('*', $aDirectoryOptions))
+        if (key_exists('*', $aDirectoryOptions))
         {
             $aOptions = array_merge($aOptions, $aDirectoryOptions['*']);
         }
-        if(key_exists($sClassName, $aDirectoryOptions))
+        if (key_exists($sClassName, $aDirectoryOptions))
         {
             $aOptions = array_merge($aOptions, $aDirectoryOptions[$sClassName]);
         }
@@ -147,17 +147,17 @@ 
         $itDir = new RecursiveDirectoryIterator($sDirectory);
         $itFile = new RecursiveIteratorIterator($itDir);
         // 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;
             }
 
             $aClassOptions = [];
             // No more classmap autoloading. The file will be included when needed.
-            if(($aOptions['autoload']))
+            if (($aOptions['autoload']))
             {
                 $aClassOptions['include'] = $xFile->getPathname();
             }
@@ -178,26 +178,26 @@ 
     public function addNamespace($sNamespace, array $aOptions)
     {
         // Separator default value
-        if(!key_exists('separator', $aOptions))
+        if (!key_exists('separator', $aOptions))
         {
             $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(!key_exists('autoload', $aOptions))
+        if (!key_exists('autoload', $aOptions))
         {
             $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']);
         }
@@ -214,7 +214,7 @@ 
      */
     private function getOptionsFromClass($sClassName)
     {
-        if(!key_exists($sClassName, $this->aClassOptions))
+        if (!key_exists($sClassName, $this->aClassOptions))
         {
             return null; // Class not registered
         }
@@ -232,18 +232,18 @@ 
     private function getOptionsFromNamespace($sClassName, $sNamespace = null)
     {
         // Find the corresponding namespace
-        if($sNamespace === null)
+        if ($sNamespace === null)
         {
-            foreach(array_keys($this->aNamespaceOptions) as $_sNamespace)
+            foreach (array_keys($this->aNamespaceOptions) as $_sNamespace)
             {
-                if(substr($sClassName, 0, strlen($_sNamespace) + 1) == $_sNamespace . '\\')
+                if (substr($sClassName, 0, strlen($_sNamespace) + 1) == $_sNamespace . '\\')
                 {
                     $sNamespace = $_sNamespace;
                     break;
                 }
             }
         }
-        if($sNamespace === null)
+        if ($sNamespace === null)
         {
             return null; // Class not registered
         }
@@ -251,7 +251,7 @@ 
         // Get the class options
         $aOptions = $this->aNamespaceOptions[$sNamespace];
         $aDefaultOptions = ['namespace' => $sNamespace];
-        if(key_exists('separator', $aOptions))
+        if (key_exists('separator', $aOptions))
         {
             $aDefaultOptions['separator'] = $aOptions['separator'];
         }
@@ -269,11 +269,11 @@ 
     protected function _getCallableObject($sClassName, array $aOptions)
     {
         // Make sure the registered class exists
-        if(key_exists('include', $aOptions))
+        if (key_exists('include', $aOptions))
         {
             require_once($aOptions['include']);
         }
-        if(!class_exists($sClassName))
+        if (!class_exists($sClassName))
         {
             return null;
         }
@@ -281,13 +281,13 @@ 
         // Create the callable object
         $xCallableObject = new CallableObject($sClassName);
         $this->aCallableOptions[$sClassName] = [];
-        foreach($aOptions as $sName => $xValue)
+        foreach ($aOptions as $sName => $xValue)
         {
-            if(in_array($sName, ['separator', 'namespace', 'protected']))
+            if (in_array($sName, ['separator', 'namespace', 'protected']))
             {
                 $xCallableObject->configure($sName, $xValue);
             }
-            elseif(is_array($xValue) && $sName != 'include')
+            elseif (is_array($xValue) && $sName != 'include')
             {
                 // These options are to be included in javascript code.
                 $this->aCallableOptions[$sClassName][$sName] = $xValue;
@@ -324,22 +324,22 @@ 
         // at the beginning and the end of the class name.
         $sClassName = (string)$sClassName;
         $sClassName = trim(str_replace('.', '\\', $sClassName), '\\');
-        if($this->bUsingUnderscore)
+        if ($this->bUsingUnderscore)
         {
             $sClassName = trim(str_replace('_', '\\', $sClassName), '\\');
         }
 
-        if(key_exists($sClassName, $this->aCallableObjects))
+        if (key_exists($sClassName, $this->aCallableObjects))
         {
             return $this->aCallableObjects[$sClassName];
         }
 
         $aOptions = $this->getOptionsFromClass($sClassName);
-        if($aOptions === null)
+        if ($aOptions === null)
         {
             $aOptions = $this->getOptionsFromNamespace($sClassName);
         }
-        if($aOptions === null)
+        if ($aOptions === null)
         {
             return null;
         }
@@ -355,9 +355,9 @@ 
     public function createCallableObjects()
     {
         // Create callable objects for registered classes
-        foreach($this->aClassOptions as $sClassName => $aClassOptions)
+        foreach ($this->aClassOptions as $sClassName => $aClassOptions)
         {
-            if(!key_exists($sClassName, $this->aCallableObjects))
+            if (!key_exists($sClassName, $this->aCallableObjects))
             {
                 $this->_getCallableObject($sClassName, $aClassOptions);
             }
@@ -365,9 +365,9 @@ 
 
         // Create callable objects for registered namespaces
         $sDS = DIRECTORY_SEPARATOR;
-        foreach($this->aNamespaceOptions as $sNamespace => $aOptions)
+        foreach ($this->aNamespaceOptions as $sNamespace => $aOptions)
         {
-            if(key_exists($sNamespace, $this->aNamespaces))
+            if (key_exists($sNamespace, $this->aNamespaces))
             {
                 continue;
             }
@@ -378,10 +378,10 @@ 
             $sDirectory = $aOptions['directory'];
             $itDir = new RecursiveDirectoryIterator($sDirectory);
             $itFile = new RecursiveIteratorIterator($itDir);
-            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;
                 }
@@ -390,7 +390,7 @@ 
                 $sClassPath = $sNamespace;
                 $sRelativePath = substr($xFile->getPath(), strlen($sDirectory));
                 $sRelativePath = trim(str_replace($sDS, '\\', $sRelativePath), '\\');
-                if($sRelativePath != '')
+                if ($sRelativePath != '')
                 {
                     $sClassPath .= '\\' . $sRelativePath;
                 }
@@ -398,10 +398,10 @@ 
                 $this->aNamespaces[$sClassPath] = ['separator' => $aOptions['separator']];
                 $sClassName = $sClassPath . '\\' . $xFile->getBasename('.php');
 
-                if(!key_exists($sClassName, $this->aCallableObjects))
+                if (!key_exists($sClassName, $this->aCallableObjects))
                 {
                     $aClassOptions = $this->getOptionsFromNamespace($sClassName, $sNamespace);
-                    if($aClassOptions !== null)
+                    if ($aClassOptions !== null)
                     {
                         $this->_getCallableObject($sClassName, $aClassOptions);
                     }

Braces +1 added lines, -2 removed lines

@@ -286,8 +286,7 @@
             if(in_array($sName, ['separator', 'namespace', 'protected']))
             {
                 $xCallableObject->configure($sName, $xValue);
-            }
-            elseif(is_array($xValue) && $sName != 'include')
+            } elseif(is_array($xValue) && $sName != 'include')
             {
                 // These options are to be included in javascript code.
                 $this->aCallableOptions[$sClassName][$sName] = $xValue;

src/Request/Support/CallableObject.php

Spacing +13 added lines, -13 removed lines

@@ -138,29 +138,29 @@ 
      */
     public function configure($sName, $sValue)
     {
-        switch($sName)
+        switch ($sName)
         {
         // Set the separator
         case 'separator':
-            if($sValue == '_' || $sValue == '.')
+            if ($sValue == '_' || $sValue == '.')
             {
                 $this->sSeparator = $sValue;
             }
             break;
         // Set the namespace
         case 'namespace':
-            if(is_string($sValue))
+            if (is_string($sValue))
             {
                 $this->sNamespace = $sValue;
             }
             break;
         // Set the protected methods
         case 'protected':
-            if(is_array($sValue))
+            if (is_array($sValue))
             {
                 $this->aProtectedMethods = array_merge($this->aProtectedMethods, $sValue);
             }
-            elseif(is_string($sValue))
+            elseif (is_string($sValue))
             {
                 $this->aProtectedMethods[] = $sValue;
             }
@@ -178,16 +178,16 @@ 
     public function getMethods()
     {
         $aMethods = [];
-        foreach($this->xReflectionClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $xMethod)
+        foreach ($this->xReflectionClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $xMethod)
         {
             $sMethodName = $xMethod->getShortName();
             // Don't take magic __call, __construct, __destruct methods
-            if(strlen($sMethodName) > 2 && substr($sMethodName, 0, 2) == '__')
+            if (strlen($sMethodName) > 2 && substr($sMethodName, 0, 2) == '__')
             {
                 continue;
             }
             // Don't take excluded methods
-            if(in_array($sMethodName, $this->aProtectedMethods))
+            if (in_array($sMethodName, $this->aProtectedMethods))
             {
                 continue;
             }
@@ -203,15 +203,15 @@ 
      */
     public function getRegisteredObject()
     {
-        if($this->xRegisteredObject == null)
+        if ($this->xRegisteredObject == null)
         {
             $di = jaxon()->di();
             // Use the Reflection class to get the parameters of the constructor
-            if(($constructor = $this->xReflectionClass->getConstructor()) != null)
+            if (($constructor = $this->xReflectionClass->getConstructor()) != null)
             {
                 $parameters = $constructor->getParameters();
                 $parameterInstances = [];
-                foreach($parameters as $parameter)
+                foreach ($parameters as $parameter)
                 {
                     // Get the parameter instance from the DI
                     $parameterInstances[] = $di->get($parameter->getClass()->getName());
@@ -224,7 +224,7 @@ 
             }
 
             // Initialize the object
-            if($this->xRegisteredObject instanceof \Jaxon\CallableClass)
+            if ($this->xRegisteredObject instanceof \Jaxon\CallableClass)
             {
                 $this->xRegisteredObject->response = jaxon()->getResponse();
             }
@@ -254,7 +254,7 @@ 
      */
     public function call($sMethod, $aArgs)
     {
-        if(!$this->hasMethod($sMethod))
+        if (!$this->hasMethod($sMethod))
         {
             return;
         }

Braces +2 added lines, -4 removed lines

@@ -159,8 +159,7 @@ 
             if(is_array($sValue))
             {
                 $this->aProtectedMethods = array_merge($this->aProtectedMethods, $sValue);
-            }
-            elseif(is_string($sValue))
+            } elseif(is_string($sValue))
             {
                 $this->aProtectedMethods[] = $sValue;
             }
@@ -217,8 +216,7 @@ 
                     $parameterInstances[] = $di->get($parameter->getClass()->getName());
                 }
                 $this->xRegisteredObject = $this->xReflectionClass->newInstanceArgs($parameterInstances);
-            }
-            else
+            } else
             {
                 $this->xRegisteredObject = $this->xReflectionClass->newInstance();
             }

src/Request/Handler/Argument.php

Spacing +29 added lines, -29 removed lines

@@ -58,17 +58,17 @@ 
         $this->aArgs = [];
         $this->nMethod = self::METHOD_UNKNOWN;
 
-        if(isset($_POST['jxnargs']))
+        if (isset($_POST['jxnargs']))
         {
             $this->nMethod = self::METHOD_POST;
             $this->aArgs = $_POST['jxnargs'];
         }
-        elseif(isset($_GET['jxnargs']))
+        elseif (isset($_GET['jxnargs']))
         {
             $this->nMethod = self::METHOD_GET;
             $this->aArgs = $_GET['jxnargs'];
         }
-        if(get_magic_quotes_gpc() == 1)
+        if (get_magic_quotes_gpc() == 1)
         {
             array_walk($this->aArgs, [&$this, '__argumentStripSlashes']);
         }
@@ -84,17 +84,17 @@ 
      */
     private function __convertStringToBool($sValue)
     {
-        if(strcasecmp($sValue, 'true') == 0)
+        if (strcasecmp($sValue, 'true') == 0)
         {
             return true;
         }
-        if(strcasecmp($sValue, 'false') == 0)
+        if (strcasecmp($sValue, 'false') == 0)
         {
             return false;
         }
-        if(is_numeric($sValue))
+        if (is_numeric($sValue))
         {
-            if($sValue == 0)
+            if ($sValue == 0)
             {
                 return false;
             }
@@ -112,7 +112,7 @@ 
      */
     private function __argumentStripSlashes(&$sArg)
     {
-        if(!is_string($sArg))
+        if (!is_string($sArg))
         {
             return '';
         }
@@ -160,7 +160,7 @@ 
      */
     private function __argumentDecode(&$sArg)
     {
-        if($sArg == '')
+        if ($sArg == '')
         {
             return '';
         }
@@ -169,22 +169,22 @@ 
         $sType = 'multipart/form-data';
         $iLen = strlen($sType);
         $sContentType = '';
-        if(key_exists('CONTENT_TYPE', $_SERVER))
+        if (key_exists('CONTENT_TYPE', $_SERVER))
         {
             $sContentType = substr($_SERVER['CONTENT_TYPE'], 0, $iLen);
         }
-        elseif(key_exists('HTTP_CONTENT_TYPE', $_SERVER))
+        elseif (key_exists('HTTP_CONTENT_TYPE', $_SERVER))
         {
             $sContentType = substr($_SERVER['HTTP_CONTENT_TYPE'], 0, $iLen);
         }
-        if($sContentType == $sType)
+        if ($sContentType == $sType)
         {
             $sArg = urldecode($sArg);
         }
 
         $data = json_decode($sArg, true);
 
-        if($data !== null && $sArg != $data)
+        if ($data !== null && $sArg != $data)
         {
             $sArg = $data;
         }
@@ -203,13 +203,13 @@ 
      */
     private function __argumentDecodeUTF8_iconv(&$mArg)
     {
-        if(is_array($mArg))
+        if (is_array($mArg))
         {
-            foreach($mArg as $sKey => &$xArg)
+            foreach ($mArg as $sKey => &$xArg)
             {
                 $sNewKey = $sKey;
                 $this->__argumentDecodeUTF8_iconv($sNewKey);
-                if($sNewKey != $sKey)
+                if ($sNewKey != $sKey)
                 {
                     $mArg[$sNewKey] = $xArg;
                     unset($mArg[$sKey]);
@@ -218,7 +218,7 @@ 
                 $this->__argumentDecodeUTF8_iconv($xArg);
             }
         }
-        elseif(is_string($mArg))
+        elseif (is_string($mArg))
         {
             $mArg = iconv("UTF-8", $this->getOption('core.encoding') . '//TRANSLIT', $mArg);
         }
@@ -233,13 +233,13 @@ 
      */
     private function __argumentDecodeUTF8_mb_convert_encoding(&$mArg)
     {
-        if(is_array($mArg))
+        if (is_array($mArg))
         {
-            foreach($mArg as $sKey => &$xArg)
+            foreach ($mArg as $sKey => &$xArg)
             {
                 $sNewKey = $sKey;
                 $this->__argumentDecodeUTF8_mb_convert_encoding($sNewKey);
-                if($sNewKey != $sKey)
+                if ($sNewKey != $sKey)
                 {
                     $mArg[$sNewKey] = $xArg;
                     unset($mArg[$sKey]);
@@ -248,7 +248,7 @@ 
                 $this->__argumentDecodeUTF8_mb_convert_encoding($xArg);
             }
         }
-        elseif(is_string($mArg))
+        elseif (is_string($mArg))
         {
             $mArg = mb_convert_encoding($mArg, $this->getOption('core.encoding'), "UTF-8");
         }
@@ -263,14 +263,14 @@ 
      */
     private function __argumentDecodeUTF8_utf8_decode(&$mArg)
     {
-        if(is_array($mArg))
+        if (is_array($mArg))
         {
-            foreach($mArg as $sKey => &$xArg)
+            foreach ($mArg as $sKey => &$xArg)
             {
                 $sNewKey = $sKey;
                 $this->__argumentDecodeUTF8_utf8_decode($sNewKey);
 
-                if($sNewKey != $sKey)
+                if ($sNewKey != $sKey)
                 {
                     $mArg[$sNewKey] = $xArg;
                     unset($mArg[$sKey]);
@@ -280,7 +280,7 @@ 
                 $this->__argumentDecodeUTF8_utf8_decode($xArg);
             }
         }
-        elseif(is_string($mArg))
+        elseif (is_string($mArg))
         {
             $mArg = utf8_decode($mArg);
         }
@@ -305,19 +305,19 @@ 
      */
     public function process()
     {
-        if(($this->getOption('core.decode_utf8')))
+        if (($this->getOption('core.decode_utf8')))
         {
             $sFunction = '';
 
-            if(function_exists('iconv'))
+            if (function_exists('iconv'))
             {
                 $sFunction = "iconv";
             }
-            elseif(function_exists('mb_convert_encoding'))
+            elseif (function_exists('mb_convert_encoding'))
             {
                 $sFunction = "mb_convert_encoding";
             }
-            elseif($this->getOption('core.encoding') == "ISO-8859-1")
+            elseif ($this->getOption('core.encoding') == "ISO-8859-1")
             {
                 $sFunction = "utf8_decode";
             }

Braces +9 added lines, -18 removed lines

@@ -62,8 +62,7 @@ 
         {
             $this->nMethod = self::METHOD_POST;
             $this->aArgs = $_POST['jxnargs'];
-        }
-        elseif(isset($_GET['jxnargs']))
+        } elseif(isset($_GET['jxnargs']))
         {
             $this->nMethod = self::METHOD_GET;
             $this->aArgs = $_GET['jxnargs'];
@@ -172,8 +171,7 @@ 
         if(key_exists('CONTENT_TYPE', $_SERVER))
         {
             $sContentType = substr($_SERVER['CONTENT_TYPE'], 0, $iLen);
-        }
-        elseif(key_exists('HTTP_CONTENT_TYPE', $_SERVER))
+        } elseif(key_exists('HTTP_CONTENT_TYPE', $_SERVER))
         {
             $sContentType = substr($_SERVER['HTTP_CONTENT_TYPE'], 0, $iLen);
         }
@@ -187,8 +185,7 @@ 
         if($data !== null && $sArg != $data)
         {
             $sArg = $data;
-        }
-        else
+        } else
         {
             $sArg = $this->__convertValue($sArg);
         }
@@ -217,8 +214,7 @@ 
                 }
                 $this->__argumentDecodeUTF8_iconv($xArg);
             }
-        }
-        elseif(is_string($mArg))
+        } elseif(is_string($mArg))
         {
             $mArg = iconv("UTF-8", $this->getOption('core.encoding') . '//TRANSLIT', $mArg);
         }
@@ -247,8 +243,7 @@ 
                 }
                 $this->__argumentDecodeUTF8_mb_convert_encoding($xArg);
             }
-        }
-        elseif(is_string($mArg))
+        } elseif(is_string($mArg))
         {
             $mArg = mb_convert_encoding($mArg, $this->getOption('core.encoding'), "UTF-8");
         }
@@ -279,8 +274,7 @@ 
 
                 $this->__argumentDecodeUTF8_utf8_decode($xArg);
             }
-        }
-        elseif(is_string($mArg))
+        } elseif(is_string($mArg))
         {
             $mArg = utf8_decode($mArg);
         }
@@ -312,16 +306,13 @@ 
             if(function_exists('iconv'))
             {
                 $sFunction = "iconv";
-            }
-            elseif(function_exists('mb_convert_encoding'))
+            } elseif(function_exists('mb_convert_encoding'))
             {
                 $sFunction = "mb_convert_encoding";
-            }
-            elseif($this->getOption('core.encoding') == "ISO-8859-1")
+            } elseif($this->getOption('core.encoding') == "ISO-8859-1")
             {
                 $sFunction = "utf8_decode";
-            }
-            else
+            } else
             {
                 throw new \Jaxon\Exception\Error($this->trans('errors.request.conversion'));
             }

src/Request/Handler/Callback.php

Spacing +4 added lines, -4 removed lines

@@ -51,7 +51,7 @@ 
      */
     public function before($xCallable = null)
     {
-        if($xCallable === null)
+        if ($xCallable === null)
         {
             return $this->xBeforeCallback;
         }
@@ -67,7 +67,7 @@ 
      */
     public function after($xCallable = null)
     {
-        if($xCallable === null)
+        if ($xCallable === null)
         {
             return $this->xAfterCallback;
         }
@@ -83,7 +83,7 @@ 
      */
     public function invalid($xCallable = null)
     {
-        if($xCallable === null)
+        if ($xCallable === null)
         {
             return $this->xInvalidCallback;
         }
@@ -99,7 +99,7 @@ 
      */
     public function error($xCallable = null)
     {
-        if($xCallable === null)
+        if ($xCallable === null)
         {
             return $this->xErrorCallback;
         }

src/Request/Plugin/CallableDir.php

Spacing +8 added lines, -8 removed lines

@@ -68,47 +68,47 @@
     public function register($sType, $sDirectory, $aOptions)
     {
         $sType = trim($sType);
-        if($sType != $this->getName())
+        if ($sType != $this->getName())
         {
             return false;
         }
 
-        if(!is_string($sDirectory) || !is_dir($sDirectory))
+        if (!is_string($sDirectory) || !is_dir($sDirectory))
         {
             throw new \Jaxon\Exception\Error($this->trans('errors.objects.invalid-declaration'));
         }
-        if(is_string($aOptions))
+        if (is_string($aOptions))
         {
             $aOptions = ['namespace' => $aOptions];
         }
-        if(!is_array($aOptions))
+        if (!is_array($aOptions))
         {
             throw new \Jaxon\Exception\Error($this->trans('errors.objects.invalid-declaration'));
         }
 
         $sDirectory = rtrim(trim($sDirectory), '/\\');
-        if(!is_dir($sDirectory))
+        if (!is_dir($sDirectory))
         {
             return false;
         }
         $aOptions['directory'] = realpath($sDirectory);
 
         $sNamespace = key_exists('namespace', $aOptions) ? $aOptions['namespace'] : '';
-        if(!($sNamespace = trim($sNamespace, ' \\')))
+        if (!($sNamespace = trim($sNamespace, ' \\')))
         {
             $sNamespace = '';
         }
 
         // Change the keys in $aOptions to have "\" as separator
         $_aOptions = [];
-        foreach($aOptions as $sName => $aOption)
+        foreach ($aOptions as $sName => $aOption)
         {
             $sName = trim(str_replace('.', '\\', $sName), ' \\');
             $_aOptions[$sName] = $aOption;
         }
         $aOptions = $_aOptions;
 
-        if(($sNamespace))
+        if (($sNamespace))
         {
             $this->xRepository->addNamespace($sNamespace, $aOptions);
         }

Braces +1 added lines, -2 removed lines

@@ -111,8 +111,7 @@
         if(($sNamespace))
         {
             $this->xRepository->addNamespace($sNamespace, $aOptions);
-        }
-        else
+        } else
         {
             $this->xRepository->addDirectory($sDirectory, $aOptions);
         }

src/Request/Plugin/CallableClass.php

Spacing +22 added lines, -22 removed lines

@@ -64,19 +64,19 @@ 
     {
         $this->xRepository = $xRepository;
 
-        if(!empty($_GET['jxncls']))
+        if (!empty($_GET['jxncls']))
         {
             $this->sRequestedClass = trim($_GET['jxncls']);
         }
-        if(!empty($_GET['jxnmthd']))
+        if (!empty($_GET['jxnmthd']))
         {
             $this->sRequestedMethod = trim($_GET['jxnmthd']);
         }
-        if(!empty($_POST['jxncls']))
+        if (!empty($_POST['jxncls']))
         {
             $this->sRequestedClass = trim($_POST['jxncls']);
         }
-        if(!empty($_POST['jxnmthd']))
+        if (!empty($_POST['jxnmthd']))
         {
             $this->sRequestedMethod = trim($_POST['jxnmthd']);
         }
@@ -99,7 +99,7 @@ 
      */
     public function getTarget()
     {
-        if(!$this->sRequestedClass || !$this->sRequestedMethod)
+        if (!$this->sRequestedClass || !$this->sRequestedMethod)
         {
             return null;
         }
@@ -118,20 +118,20 @@ 
     public function register($sType, $sClassName, $aOptions)
     {
         $sType = trim($sType);
-        if($sType != $this->getName())
+        if ($sType != $this->getName())
         {
             return false;
         }
 
-        if(!is_string($sClassName))
+        if (!is_string($sClassName))
         {
             throw new \Jaxon\Exception\Error($this->trans('errors.objects.invalid-declaration'));
         }
-        if(is_string($aOptions))
+        if (is_string($aOptions))
         {
             $aOptions = ['include' => $aOptions];
         }
-        if(!is_array($aOptions))
+        if (!is_array($aOptions))
         {
             throw new \Jaxon\Exception\Error($this->trans('errors.objects.invalid-declaration'));
         }
@@ -154,11 +154,11 @@ 
         $aCallableObjects = $this->xRepository->getCallableObjects();
         $sHash = '';
 
-        foreach($aNamespaces as $sNamespace => $aOptions)
+        foreach ($aNamespaces as $sNamespace => $aOptions)
         {
             $sHash .= $sNamespace . $aOptions['separator'];
         }
-        foreach($aCallableObjects as $sClassName => $xCallableObject)
+        foreach ($aCallableObjects as $sClassName => $xCallableObject)
         {
             $sHash .= $sClassName . implode('|', $xCallableObject->getMethods());
         }
@@ -183,21 +183,21 @@ 
 
         $xCallableClass = new \ReflectionClass(UserCallableClass::class);
         $aCallableMethods = [];
-        foreach($xCallableClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $xMethod)
+        foreach ($xCallableClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $xMethod)
         {
             $aCallableMethods[] = $xMethod->getName();
         }
 
-        foreach(array_keys($aNamespaces) as $sNamespace)
+        foreach (array_keys($aNamespaces) as $sNamespace)
         {
             $offset = 0;
             $sJsNamespace = str_replace('\\', '.', $sNamespace);
             $sJsNamespace .= '.Null'; // This is a sentinel. The last token is not processed in the while loop.
-            while(($dotPosition = strpos($sJsNamespace, '.', $offset)) !== false)
+            while (($dotPosition = strpos($sJsNamespace, '.', $offset)) !== false)
             {
                 $sJsClass = substr($sJsNamespace, 0, $dotPosition);
                 // Generate code for this object
-                if(!key_exists($sJsClass, $aJsClasses))
+                if (!key_exists($sJsClass, $aJsClasses))
                 {
                     $sCode .= "$sPrefix$sJsClass = {};\n";
                     $aJsClasses[$sJsClass] = $sJsClass;
@@ -206,17 +206,17 @@ 
             }
         }
 
-        foreach($aCallableObjects as $sClassName => $xCallableObject)
+        foreach ($aCallableObjects as $sClassName => $xCallableObject)
         {
             $aConfig = $aCallableOptions[$sClassName];
             $aCommonConfig = key_exists('*', $aConfig) ? $aConfig['*'] : [];
 
             $aProtectedMethods = is_subclass_of($sClassName, UserCallableClass::class) ? $aCallableMethods : [];
             $aMethods = [];
-            foreach($xCallableObject->getMethods() as $sMethodName)
+            foreach ($xCallableObject->getMethods() as $sMethodName)
             {
                 // Don't export methods of the CallableClass class
-                if(in_array($sMethodName, $aProtectedMethods))
+                if (in_array($sMethodName, $aProtectedMethods))
                 {
                     continue;
                 }
@@ -247,7 +247,7 @@ 
     public function canProcessRequest()
     {
         // Check the validity of the class name
-        if(($this->sRequestedClass !== null && !$this->validateClass($this->sRequestedClass)) ||
+        if (($this->sRequestedClass !== null && !$this->validateClass($this->sRequestedClass)) ||
             ($this->sRequestedMethod !== null && !$this->validateMethod($this->sRequestedMethod)))
         {
             $this->sRequestedClass = null;
@@ -263,14 +263,14 @@ 
      */
     public function processRequest()
     {
-        if(!$this->canProcessRequest())
+        if (!$this->canProcessRequest())
         {
             return false;
         }
 
         // Find the requested method
         $xCallableObject = $this->xRepository->getCallableObject($this->sRequestedClass);
-        if(!$xCallableObject || !$xCallableObject->hasMethod($this->sRequestedMethod))
+        if (!$xCallableObject || !$xCallableObject->hasMethod($this->sRequestedMethod))
         {
             // Unable to find the requested object or method
             throw new \Jaxon\Exception\Error($this->trans('errors.objects.invalid',
@@ -281,7 +281,7 @@ 
         $di = jaxon()->di();
         $aArgs = $di->getRequestHandler()->processArguments();
         $xResponse = $xCallableObject->call($this->sRequestedMethod, $aArgs);
-        if(($xResponse))
+        if (($xResponse))
         {
             $di->getResponseManager()->append($xResponse);
         }

src/Request/Target.php

Indentation +5 added lines, -5 removed lines

@@ -100,11 +100,11 @@
         return new Target(self::TYPE_CLASS, '', $sClassName, $sMethodName);
     }
 
-     /**
-     * Check if the target type is Function.
-     *
-     * @return bool
-     */
+        /**
+         * Check if the target type is Function.
+         *
+         * @return bool
+         */
     public function isFunction()
     {
         return $this->sType == self::TYPE_FUNCTION;

src/Features/View/Namespaces.php

Spacing +1 added lines, -1 removed lines

@@ -60,7 +60,7 @@
     {
         $this->sDirectory = '';
         $this->sExtension = '';
-        if(key_exists($sNamespace, $this->aDirectories))
+        if (key_exists($sNamespace, $this->aDirectories))
         {
             // Make sure there's only one '/' at the end of the string
             $this->sDirectory = rtrim($this->aDirectories[$sNamespace]['path'], '/') . '/';