jaxon-php / jaxon-core

src/Request/Support/CallableObject.php

Spacing +22 added lines, -22 removed lines

@@ -102,15 +102,15 @@ 
      */
     public function getRegisteredObject()
     {
-        if($this->registeredObject == null)
+        if ($this->registeredObject == null)
         {
             $di = jaxon()->di();
             // Use the Reflection class to get the parameters of the constructor
-            if(($constructor = $this->reflectionClass->getConstructor()) != null)
+            if (($constructor = $this->reflectionClass->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());
@@ -146,7 +146,7 @@ 
         // The class name without the namespace.
         $name = $this->reflectionClass->getShortName();
         // Append the classpath to the name
-        if(($this->classpath))
+        if (($this->classpath))
         {
             $name = $this->classpath . '\\' . $name;
         }
@@ -193,16 +193,16 @@ 
     public function getMethods()
     {
         $aReturn = [];
-        foreach($this->reflectionClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $xMethod)
+        foreach ($this->reflectionClass->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;
             }
@@ -223,37 +223,37 @@ 
     public function configure($sMethod, $sName, $sValue)
     {
         // Set the namespace
-        if($sName == 'namespace')
+        if ($sName == 'namespace')
         {
-            if($sValue != '')
+            if ($sValue != '')
                 $this->namespace = $sValue;
             return;
         }
         // Set the classpath
-        if($sName == 'classpath')
+        if ($sName == 'classpath')
         {
-            if($sValue != '')
+            if ($sValue != '')
                 $this->classpath = trim($sValue, '\\');
             return;
         }
         // Set the separator
-        if($sName == 'separator')
+        if ($sName == 'separator')
         {
-            if($sValue == '_' || $sValue == '.')
+            if ($sValue == '_' || $sValue == '.')
                 $this->separator = $sValue;
             return;
         }
         // Set the excluded methods
-        if($sName == 'protected')
+        if ($sName == '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;
             return;
         }
 
-        if(!isset($this->aConfiguration[$sMethod]))
+        if (!isset($this->aConfiguration[$sMethod]))
         {
             $this->aConfiguration[$sMethod] = [];
         }
@@ -274,16 +274,16 @@ 
 
         // Common options to be set on all methods
         $aCommonConfig = array_key_exists('*', $this->aConfiguration) ? $this->aConfiguration['*'] : [];
-        foreach($this->reflectionClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $xMethod)
+        foreach ($this->reflectionClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $xMethod)
         {
             $sMethodName = $xMethod->getShortName();
             // Don't export magic __call, __construct, __destruct methods
-            if(strlen($sMethodName) > 0 && substr($sMethodName, 0, 2) == '__')
+            if (strlen($sMethodName) > 0 && substr($sMethodName, 0, 2) == '__')
             {
                 continue;
             }
             // Don't export "protected" methods
-            if(in_array($sMethodName, $this->aProtectedMethods))
+            if (in_array($sMethodName, $this->aProtectedMethods))
             {
                 continue;
             }
@@ -333,14 +333,14 @@ 
      */
     public function call($sMethod, $aArgs)
     {
-        if(!$this->hasMethod($sMethod))
+        if (!$this->hasMethod($sMethod))
         {
             return;
         }
         $reflectionMethod = $this->reflectionClass->getMethod($sMethod);
         $registeredObject = $this->getRegisteredObject();
         $response = $reflectionMethod->invokeArgs($registeredObject, $aArgs);
-        if(($response))
+        if (($response))
         {
             $this->getResponseManager()->append($response);
         }

Braces +15 added lines, -12 removed lines

@@ -116,8 +116,7 @@ 
                     $parameterInstances[] = $di->get($parameter->getClass()->getName());
                 }
                 $this->registeredObject = $this->reflectionClass->newInstanceArgs($parameterInstances);
-            }
-            else
+            } else
             {
                 $this->registeredObject = $this->reflectionClass->newInstance();
             }
@@ -225,31 +224,35 @@ 
         // Set the namespace
         if($sName == 'namespace')
         {
-            if($sValue != '')
-                $this->namespace = $sValue;
+            if($sValue != '') {
+                            $this->namespace = $sValue;
+            }
             return;
         }
         // Set the classpath
         if($sName == 'classpath')
         {
-            if($sValue != '')
-                $this->classpath = trim($sValue, '\\');
+            if($sValue != '') {
+                            $this->classpath = trim($sValue, '\\');
+            }
             return;
         }
         // Set the separator
         if($sName == 'separator')
         {
-            if($sValue == '_' || $sValue == '.')
-                $this->separator = $sValue;
+            if($sValue == '_' || $sValue == '.') {
+                            $this->separator = $sValue;
+            }
             return;
         }
         // Set the excluded methods
         if($sName == 'protected')
         {
-            if(is_array($sValue))
-                $this->aProtectedMethods = array_merge($this->aProtectedMethods, $sValue);
-            elseif(is_string($sValue))
-                $this->aProtectedMethods[] = $sValue;
+            if(is_array($sValue)) {
+                            $this->aProtectedMethods = array_merge($this->aProtectedMethods, $sValue);
+            } elseif(is_string($sValue)) {
+                            $this->aProtectedMethods[] = $sValue;
+            }
             return;
         }
 

src/Request/Plugin/CallableDir.php

Spacing +44 added lines, -44 removed lines

@@ -82,19 +82,19 @@ 
 
     public function __construct()
     {
-        if(!empty($_GET['jxncls']))
+        if (!empty($_GET['jxncls']))
         {
             $this->sRequestedClass = $_GET['jxncls'];
         }
-        if(!empty($_GET['jxnmthd']))
+        if (!empty($_GET['jxnmthd']))
         {
             $this->sRequestedMethod = $_GET['jxnmthd'];
         }
-        if(!empty($_POST['jxncls']))
+        if (!empty($_POST['jxncls']))
         {
             $this->sRequestedClass = $_POST['jxncls'];
         }
-        if(!empty($_POST['jxnmthd']))
+        if (!empty($_POST['jxnmthd']))
         {
             $this->sRequestedMethod = $_POST['jxnmthd'];
         }
@@ -145,34 +145,34 @@ 
      */
     public function register($sType, $sDirectory, $aOptions)
     {
-        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'));
         }
         $sDirectory = trim($sDirectory, DIRECTORY_SEPARATOR);
 
-        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'));
         }
 
-        if(!is_dir(($sDirectory = trim($sDirectory))))
+        if (!is_dir(($sDirectory = trim($sDirectory))))
         {
             return false;
         }
         $aOptions['directory'] = $sDirectory;
 
         $aProtected = key_exists('protected', $aOptions) ? $aOptions['protected'] : [];
-        if(!is_array($aProtected))
+        if (!is_array($aProtected))
         {
             throw new \Jaxon\Exception\Error($this->trans('errors.objects.invalid-declaration'));
         }
@@ -180,14 +180,14 @@ 
 
         $sSeparator = key_exists('separator', $aOptions) ? $aOptions['separator'] : '.';
         // Only '.' and '_' are allowed to be used as separator. Any other value is ignored and '.' is used instead.
-        if(($sSeparator = trim($sSeparator)) != '_')
+        if (($sSeparator = trim($sSeparator)) != '_')
         {
             $sSeparator = '.';
         }
         $aOptions['separator'] = $sSeparator;
 
         $sNamespace = key_exists('namespace', $aOptions) ? $aOptions['namespace'] : '';
-        if(!($sNamespace = trim($sNamespace, ' \\')))
+        if (!($sNamespace = trim($sNamespace, ' \\')))
         {
             $sNamespace = '';
         }
@@ -202,10 +202,10 @@ 
         // }
         // $aOptions['classes'] = $aNewOptions;
 
-        if(($sNamespace))
+        if (($sNamespace))
         {
             // Register the dir with PSR4 autoloading
-            if(($this->xAutoloader))
+            if (($this->xAutoloader))
             {
                 $this->xAutoloader->setPsr4($sNamespace . '\\', $sDirectory);
             }
@@ -221,20 +221,20 @@ 
             $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;
                 }
 
                 $sClassName = $xFile->getBasename('.php');
-                if(($this->xAutoloader))
+                if (($this->xAutoloader))
                 {
                     $this->xAutoloader->addClassMap([$sClassName => $xFile->getPathname()]);
                 }
-                elseif(!class_exists($sClassName))
+                elseif (!class_exists($sClassName))
                 {
                     $aOptions['include'] = $xFile->getPathname();
                 }
@@ -260,27 +260,27 @@ 
         $sClassName = trim(str_replace(['.', '_'], ['\\', '\\'], (string)$sClassName), '\\');
 
         // Make sure the registered class exists
-        if(!class_exists('\\' . $sClassName))
+        if (!class_exists('\\' . $sClassName))
         {
             return null;
         }
 
-        if(key_exists($sClassName, $this->aCallableObjects))
+        if (key_exists($sClassName, $this->aCallableObjects))
         {
             return $this->aCallableObjects[$sClassName];
         }
 
         // Find the corresponding namespace
         $sNamespace = null;
-        foreach(array_keys($this->aNamespaces) as $_sNamespace)
+        foreach (array_keys($this->aNamespaces) as $_sNamespace)
         {
-            if(substr($sClassName, 0, strlen($_sNamespace)) == $_sNamespace)
+            if (substr($sClassName, 0, strlen($_sNamespace)) == $_sNamespace)
             {
                 $sNamespace = $_sNamespace;
                 break;
             }
         }
-        if($sNamespace == null)
+        if ($sNamespace == null)
         {
             return null; // Class not registered
         }
@@ -288,9 +288,9 @@ 
         // Create the callable object
         $xCallableObject = new \Jaxon\Request\Support\CallableObject($sClassName);
         $aOptions = $this->aNamespaces[$sNamespace];
-        foreach($aOptions as $sMethod => $aValue)
+        foreach ($aOptions as $sMethod => $aValue)
         {
-            foreach($aValue as $sName => $sValue)
+            foreach ($aValue as $sName => $sValue)
             {
                 $xCallableObject->configure($sMethod, $sName, $sValue);
             }
@@ -298,12 +298,12 @@ 
 
         $this->aCallableObjects[$sClassName] = $xCallableObject;
         // Register the request factory for this callable object
-        jaxon()->di()->set($sClassName . '\Factory\Rq', function ($di) use ($sClassName) {
+        jaxon()->di()->set($sClassName . '\Factory\Rq', function($di) use ($sClassName) {
             $xCallableObject = $this->aCallableObjects[$sClassName];
             return new \Jaxon\Factory\Request\Portable($xCallableObject);
         });
         // Register the paginator factory for this callable object
-        jaxon()->di()->set($sClassName . '\Factory\Pg', function ($di) use ($sClassName) {
+        jaxon()->di()->set($sClassName . '\Factory\Pg', function($di) use ($sClassName) {
             $xCallableObject = $this->aCallableObjects[$sClassName];
             return new \Jaxon\Factory\Request\Paginator($xCallableObject);
         });
@@ -334,9 +334,9 @@ 
     {
         $sDS = DIRECTORY_SEPARATOR;
 
-        foreach($this->aNamespaces as $sNamespace => $aOptions)
+        foreach ($this->aNamespaces as $sNamespace => $aOptions)
         {
-            if(key_exists($sNamespace, $this->aClassNames))
+            if (key_exists($sNamespace, $this->aClassNames))
             {
                 continue;
             }
@@ -347,10 +347,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;
                 }
@@ -359,11 +359,11 @@ 
                 $sClassPath = $sNamespace;
                 $sRelativePath = substr($xFile->getPath(), strlen($sDirectory));
                 $sRelativePath = trim(str_replace($sDS, '\\', $sClassPath), '\\');
-                if(($sRelativePath))
+                if (($sRelativePath))
                 {
                     $sClassPath .= '\\' . $sRelativePath;
                 }
-                if(!key_exists($sClassPath, $this->aClassNames))
+                if (!key_exists($sClassPath, $this->aClassNames))
                 {
                     $this->aClassNames[$sClassPath] = [];
                 }
@@ -382,7 +382,7 @@ 
      */
     public function generateHash()
     {
-        if(count($this->aNamespaces) == 0)
+        if (count($this->aNamespaces) == 0)
         {
             return '';
         }
@@ -390,11 +390,11 @@ 
         $this->createCallableObjects();
 
         $sHash = '';
-        foreach($this->aNamespaces as $sNamespace => $aOptions)
+        foreach ($this->aNamespaces as $sNamespace => $aOptions)
         {
             $sHash .= $sNamespace . $aOptions['directory'] . $aOptions['separator'];
         }
-        foreach($this->aCallableObjects as $sClassName => $xCallableObject)
+        foreach ($this->aCallableObjects as $sClassName => $xCallableObject)
         {
             $sHash .= $sClassName . implode('|', $xCallableObject->getMethods());
         }
@@ -415,7 +415,7 @@ 
         $sJaxonPrefix = $this->getOption('core.prefix.class');
         $aJsClasses = [];
         $sCode = '';
-        foreach(array_keys($this->aClassNames) as $sNamespace)
+        foreach (array_keys($this->aClassNames) as $sNamespace)
         {
             // if(key_exists('separator', $aOptions) && $aOptions['separator'] != '.')
             // {
@@ -424,11 +424,11 @@ 
             $offset = 0;
             $sJsClasses = str_replace('\\', '.', $sNamespace);
             $sJsClasses .= '.Null'; // This is a sentinel. The last token is not processed in the while loop.
-            while(($dotPosition = strpos($sJsClasses, '.', $offset)) !== false)
+            while (($dotPosition = strpos($sJsClasses, '.', $offset)) !== false)
             {
                 $sJsClass = substr($sJsClasses, 0, $dotPosition);
                 // Generate code for this object
-                if(!key_exists($sJsClass, $aJsClasses))
+                if (!key_exists($sJsClass, $aJsClasses))
                 {
                     $sCode .= "$sJaxonPrefix$sJsClass = {};\n";
                     $aJsClasses[$sJsClass] = $sJsClass;
@@ -436,7 +436,7 @@ 
                 $offset = $dotPosition + 1;
             }
         }
-        foreach($this->aCallableObjects as $xCallableObject)
+        foreach ($this->aCallableObjects as $xCallableObject)
         {
             $sCode .= $xCallableObject->getScript();
         }
@@ -452,13 +452,13 @@ 
     public function canProcessRequest()
     {
         // Check the validity of the class name
-        if(($this->sRequestedClass) && !$this->validateClass($this->sRequestedClass))
+        if (($this->sRequestedClass) && !$this->validateClass($this->sRequestedClass))
         {
             $this->sRequestedClass = null;
             $this->sRequestedMethod = null;
         }
         // Check the validity of the method name
-        if(($this->sRequestedMethod) && !$this->validateMethod($this->sRequestedMethod))
+        if (($this->sRequestedMethod) && !$this->validateMethod($this->sRequestedMethod))
         {
             $this->sRequestedClass = null;
             $this->sRequestedMethod = null;
@@ -473,7 +473,7 @@ 
      */
     public function processRequest()
     {
-        if(!$this->canProcessRequest())
+        if (!$this->canProcessRequest())
         {
             return false;
         }
@@ -482,7 +482,7 @@ 
 
         // Find the requested method
         $xCallableObject = $this->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',

Braces +2 added lines, -4 removed lines

@@ -211,8 +211,7 @@ 
             }
 
             $this->aNamespaces[$sNamespace] = $aOptions;
-        }
-        else
+        } else
         {
             // Get the callable class plugin
             $callableClassPlugin = $this->getPluginManager()->getRequestPlugin(Jaxon::CALLABLE_CLASS);
@@ -233,8 +232,7 @@ 
                 if(($this->xAutoloader))
                 {
                     $this->xAutoloader->addClassMap([$sClassName => $xFile->getPathname()]);
-                }
-                elseif(!class_exists($sClassName))
+                } elseif(!class_exists($sClassName))
                 {
                     $aOptions['include'] = $xFile->getPathname();
                 }

src/Request/Plugin/CallableClass.php

Spacing +25 added lines, -25 removed lines

@@ -61,19 +61,19 @@ 
 
     public function __construct()
     {
-        if(!empty($_GET['jxncls']))
+        if (!empty($_GET['jxncls']))
         {
             $this->sRequestedClass = $_GET['jxncls'];
         }
-        if(!empty($_GET['jxnmthd']))
+        if (!empty($_GET['jxnmthd']))
         {
             $this->sRequestedMethod = $_GET['jxnmthd'];
         }
-        if(!empty($_POST['jxncls']))
+        if (!empty($_POST['jxncls']))
         {
             $this->sRequestedClass = $_POST['jxncls'];
         }
-        if(!empty($_POST['jxnmthd']))
+        if (!empty($_POST['jxnmthd']))
         {
             $this->sRequestedMethod = $_POST['jxnmthd'];
         }
@@ -100,16 +100,16 @@ 
      */
     public function register($sType, $sClassName, $aOptions)
     {
-        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_array($aOptions))
+        if (!is_array($aOptions))
         {
             throw new \Jaxon\Exception\Error($this->trans('errors.objects.invalid-declaration'));
         }
@@ -133,21 +133,21 @@ 
         // at the beginning and the end of the class name.
         $sClassName = trim(str_replace(['.', '_'], ['\\', '\\'], (string)$sClassName), '\\');
 
-        if(!key_exists($sClassName, $this->aClassOptions))
+        if (!key_exists($sClassName, $this->aClassOptions))
         {
             return null; // Class not registered
         }
 
-        if(key_exists($sClassName, $this->aCallableObjects))
+        if (key_exists($sClassName, $this->aCallableObjects))
         {
             return $this->aCallableObjects[$sClassName];
         }
 
         // Create the callable object
         $xCallableObject = new \Jaxon\Request\Support\CallableObject($sClassName);
-        foreach($aOptions as $sMethod => $aValue)
+        foreach ($aOptions as $sMethod => $aValue)
         {
-            foreach($aValue as $sName => $sValue)
+            foreach ($aValue as $sName => $sValue)
             {
                 $xCallableObject->configure($sMethod, $sName, $sValue);
             }
@@ -156,19 +156,19 @@ 
         // Make sure the registered class exists
         // We need to check this after the callable object is configured
         // to take the 'include' option into account.
-        if(!class_exists($sClassName))
+        if (!class_exists($sClassName))
         {
             return null;
         }
 
         $this->aCallableObjects[$sClassName] = $xCallableObject;
         // Register the request factory for this callable object
-        jaxon()->di()->set($sClassName . '\Factory\Rq', function ($di) use ($sClassName) {
+        jaxon()->di()->set($sClassName . '\Factory\Rq', function($di) use ($sClassName) {
             $xCallableObject = $this->aCallableObjects[$sClassName];
             return new \Jaxon\Factory\Request\Portable($xCallableObject);
         });
         // Register the paginator factory for this callable object
-        jaxon()->di()->set($sClassName . '\Factory\Pg', function ($di) use ($sClassName) {
+        jaxon()->di()->set($sClassName . '\Factory\Pg', function($di) use ($sClassName) {
             $xCallableObject = $this->aCallableObjects[$sClassName];
             return new \Jaxon\Factory\Request\Paginator($xCallableObject);
         });
@@ -197,7 +197,7 @@ 
      */
     private function createCallableObjects()
     {
-        foreach(array_keys($this->aClassOptions) as $sClassName)
+        foreach (array_keys($this->aClassOptions) as $sClassName)
         {
             $this->getCallableObject($sClassName);
         }
@@ -213,7 +213,7 @@ 
         $this->createCallableObjects();
 
         $sHash = '';
-        foreach($this->aCallableObjects as $sClassName => $xCallableObject)
+        foreach ($this->aCallableObjects as $sClassName => $xCallableObject)
         {
             $sHash .= $sClassName . implode('|', $xCallableObject->getMethods());
         }
@@ -234,19 +234,19 @@ 
         $sJaxonPrefix = $this->getOption('core.prefix.class');
         $aJsClasses = [];
         $sCode = '';
-        foreach($this->aClassOptions as $sClassName => $aOptions)
+        foreach ($this->aClassOptions as $sClassName => $aOptions)
         {
-            if(key_exists('separator', $aOptions) && $aOptions['separator'] != '.')
+            if (key_exists('separator', $aOptions) && $aOptions['separator'] != '.')
             {
                 continue;
             }
             $offset = 0;
             $sJsClasses = str_replace('\\', '.', $sClassName);
-            while(($dotPosition = strpos($sJsClasses, '.', $offset)) !== false)
+            while (($dotPosition = strpos($sJsClasses, '.', $offset)) !== false)
             {
                 $sJsClass = substr($sJsClasses, 0, $dotPosition);
                 // Generate code for this object
-                if(!key_exists($sJsClass, $aJsClasses))
+                if (!key_exists($sJsClass, $aJsClasses))
                 {
                     $sCode .= "$sJaxonPrefix$sJsClass = {};\n";
                     $aJsClasses[$sJsClass] = $sJsClass;
@@ -254,7 +254,7 @@ 
                 $offset = $dotPosition + 1;
             }
         }
-        foreach($this->aCallableObjects as $xCallableObject)
+        foreach ($this->aCallableObjects as $xCallableObject)
         {
             $sCode .= $xCallableObject->getScript();
         }
@@ -270,13 +270,13 @@ 
     public function canProcessRequest()
     {
         // Check the validity of the class name
-        if(($this->sRequestedClass) && !$this->validateClass($this->sRequestedClass))
+        if (($this->sRequestedClass) && !$this->validateClass($this->sRequestedClass))
         {
             $this->sRequestedClass = null;
             $this->sRequestedMethod = null;
         }
         // Check the validity of the method name
-        if(($this->sRequestedMethod) && !$this->validateMethod($this->sRequestedMethod))
+        if (($this->sRequestedMethod) && !$this->validateMethod($this->sRequestedMethod))
         {
             $this->sRequestedClass = null;
             $this->sRequestedMethod = null;
@@ -292,7 +292,7 @@ 
      */
     public function processRequest()
     {
-        if(!$this->canProcessRequest())
+        if (!$this->canProcessRequest())
         {
             return false;
         }
@@ -301,7 +301,7 @@ 
 
         // Find the requested method
         $xCallableObject = $this->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',