jaxon-php / jaxon-mono

jaxon-core/src/Di/ComponentContainer.php

Switch Indentation +216 added lines, -216 removed lines

@@ -40,85 +40,85 @@ 
 
 class ComponentContainer
 {
-    use Traits\DiAutoTrait;
-    use Traits\ComponentTrait;
+use Traits\DiAutoTrait;
+use Traits\ComponentTrait;
 
-    /**
+/**
      * The Dependency Injection Container for registered classes
      *
      * @var PimpleContainer
      */
-    private $xContainer;
+private $xContainer;
 
-    /**
+/**
      * This will be set only when getting the object targetted by the ajax request.
      *
      * @var Target|null
      */
-    private $xTarget = null;
+private $xTarget = null;
 
-    /**
+/**
      * The class constructor
      *
      * @param Container $di
      */
-    public function __construct(private Container $di)
-    {
-        $this->xContainer = new PimpleContainer();
-        $this->val(ComponentContainer::class, $this);
-
-        // Register the call factory for registered functions
-        $this->set($this->getRequestFactoryKey(JxnCall::class), fn() =>
-            new JxnCall($this->di->g(ConfigManager::class)
-                ->getOption('core.prefix.function', '')));
-
-        // Register the pagination component, but do not export to js.
-        $this->saveComponent(Pagination::class, [
-            'excluded' => true,
-            'separator' => '.',
-            // The namespace has the same name as the Component class.
-            'namespace' => Component::class,
-        ]);
-
-        // Register the logger component, and export to js.
-        $this->di->callback()->boot(function() {
-            if($this->di->config()->loggingEnabled())
-            {
-                $this->saveComponent(LoggerComponent::class, [
-                    'separator' => '.',
-                    // The namespace has the same name as the Component class.
-                    'namespace' => Component::class,
-                ]);
-            }
-        });
-
-        $this->setComponentPublicMethods('node', NodeComponent::class, ['item', 'html']);
-        $this->setComponentPublicMethods('func', FuncComponent::class, ['paginator']);
-    }
+public function __construct(private Container $di)
+{
+$this->xContainer = new PimpleContainer();
+$this->val(ComponentContainer::class, $this);
+
+// Register the call factory for registered functions
+$this->set($this->getRequestFactoryKey(JxnCall::class), fn() =>
+new JxnCall($this->di->g(ConfigManager::class)
+    ->getOption('core.prefix.function', '')));
+
+// Register the pagination component, but do not export to js.
+$this->saveComponent(Pagination::class, [
+'excluded' => true,
+'separator' => '.',
+// The namespace has the same name as the Component class.
+'namespace' => Component::class,
+]);
+
+// Register the logger component, and export to js.
+$this->di->callback()->boot(function() {
+if($this->di->config()->loggingEnabled())
+{
+    $this->saveComponent(LoggerComponent::class, [
+        'separator' => '.',
+        // The namespace has the same name as the Component class.
+        'namespace' => Component::class,
+    ]);
+}
+});
+
+$this->setComponentPublicMethods('node', NodeComponent::class, ['item', 'html']);
+$this->setComponentPublicMethods('func', FuncComponent::class, ['paginator']);
+}
 
-    /**
+/**
      * The container for parameters
      *
      * @return Container
      */
-    protected function cn(): Container
-    {
-        return $this->di;
-    }
+protected function cn(): Container
+{
+return $this->di;
+}
 
-    /**
+/**
      * Check if a class is defined in the container
      *
      * @param class-string $sClass    The full class name
      *
      * @return bool
      */
-    public function has(string $sClass): bool
-    {
-        return $this->xContainer->offsetExists($sClass);
-    }
+public function has(string $sClass): bool
+{
+return $this->xContainer->offsetExists($sClass);
+}
 
-    /**
+/**
      * Save a closure in the container
      *
      * @param class-string $sClass    The full class name
@@ -126,12 +126,12 @@ 
      *
      * @return void
      */
-    public function set(string $sClass, Closure $xClosure): void
-    {
-        $this->xContainer->offsetSet($sClass, fn() => $xClosure($this));
-    }
+public function set(string $sClass, Closure $xClosure): void
+{
+$this->xContainer->offsetSet($sClass, fn() => $xClosure($this));
+}
 
-    /**
+/**
      * Save a value in the container
      *
      * @param string|class-string $sKey    The key
@@ -139,12 +139,12 @@ 
      *
      * @return void
      */
-    public function val(string $sKey, $xValue): void
-    {
-       $this->xContainer->offsetSet($sKey, $xValue);
-    }
+public function val(string $sKey, $xValue): void
+{
+$this->xContainer->offsetSet($sKey, $xValue);
+}
 
-    /**
+/**
      * Get a class instance
      *
      * @template T
@@ -152,12 +152,12 @@ 
      *
      * @return T
      */
-    public function get(string $sClass): mixed
-    {
-        return $this->xContainer->offsetGet($sClass);
-    }
+public function get(string $sClass): mixed
+{
+return $this->xContainer->offsetGet($sClass);
+}
 
-    /**
+/**
      * Get a component when one of its method needs to be called
      *
      * @template T
@@ -166,17 +166,17 @@ 
      *
      * @return T|null
      */
-    public function getTargetComponent(string $sClassName, Target $xTarget): mixed
-    {
-        // Set the target only when getting the object targetted by the ajax request.
-        $this->xTarget = $xTarget;
-        $xComponent = $this->get($sClassName);
-        $this->xTarget = null;
+public function getTargetComponent(string $sClassName, Target $xTarget): mixed
+{
+// Set the target only when getting the object targetted by the ajax request.
+$this->xTarget = $xTarget;
+$xComponent = $this->get($sClassName);
+$this->xTarget = null;
 
-        return $xComponent;
-    }
+return $xComponent;
+}
 
-    /**
+/**
      * Register a component and its options
      *
      * @param class-string $sClassName    The class name
@@ -184,40 +184,40 @@ 
      *
      * @return void
      */
-    public function saveComponent(string $sClassName, array $aOptions): void
-    {
-        try
-        {
-            // Make sure the registered class exists
-            if(isset($aOptions['include']))
-            {
-                require_once $aOptions['include'];
-            }
-            $xReflectionClass = new ReflectionClass($sClassName);
-            // Check if the class is registrable
-            if(!$xReflectionClass->isInstantiable())
-            {
-                return;
-            }
-
-            $this->_saveClassOptions($sClassName, $aOptions);
-
-            $sClassKey = $this->getReflectionClassKey($sClassName);
-            $this->val($sClassKey, $xReflectionClass);
-            // Register the user class, but only if the user didn't already.
-            if(!$this->has($sClassName))
-            {
-                $this->set($sClassName, fn() => $this->make($this->get($sClassKey)));
-            }
-        }
-        catch(ReflectionException $e)
-        {
-            throw new SetupException($this->cn()->g(Translator::class)
-                ->trans('errors.class.invalid', ['name' => $sClassName]));
-        }
-    }
+public function saveComponent(string $sClassName, array $aOptions): void
+{
+try
+{
+// Make sure the registered class exists
+if(isset($aOptions['include']))
+{
+    require_once $aOptions['include'];
+}
+$xReflectionClass = new ReflectionClass($sClassName);
+// Check if the class is registrable
+if(!$xReflectionClass->isInstantiable())
+{
+    return;
+}
 
-    /**
+$this->_saveClassOptions($sClassName, $aOptions);
+
+$sClassKey = $this->getReflectionClassKey($sClassName);
+$this->val($sClassKey, $xReflectionClass);
+// Register the user class, but only if the user didn't already.
+if(!$this->has($sClassName))
+{
+    $this->set($sClassName, fn() => $this->make($this->get($sClassKey)));
+}
+}
+catch(ReflectionException $e)
+{
+throw new SetupException($this->cn()->g(Translator::class)
+    ->trans('errors.class.invalid', ['name' => $sClassName]));
+}
+}
+
+/**
      * Register a component
      *
      * @param string $sComponentId The component name
@@ -225,74 +225,74 @@ 
      * @return string
      * @throws SetupException
      */
-    private function _registerComponent(string $sComponentId): string
-    {
-        // Replace all separators ('.' or '_') with antislashes, and trim the class name.
-        $sClassName = trim(str_replace(['.', '_'], '\\', $sComponentId), '\\');
-
-        $sComponentObject = $this->getCallableObjectKey($sClassName);
-        // Prevent duplication. It's important not to use the class name here.
-        if($this->has($sComponentObject))
-        {
-            return $sClassName;
-        }
-
-        // Register the helper class
-        $this->set($this->getCallableHelperKey($sClassName), function() use($sClassName) {
-            $xFactory = $this->di->getCallFactory();
-            return new ComponentHelper($this, $xFactory->rq($sClassName),
-                $xFactory, $this->di->getViewRenderer(),
-                $this->di->getLogger(), $this->di->getSessionManager(),
-                $this->di->getStash(), $this->di->getUploadHandler());
-        });
-
-        $this->discoverComponent($sClassName);
-
-        // Register the callable object
-        $this->set($sComponentObject, function() use($sComponentId, $sClassName) {
-            $aOptions = $this->_getClassOptions($sComponentId);
-            $xReflectionClass = $this->get($this->getReflectionClassKey($sClassName));
-            $xOptions = $this->getComponentOptions($xReflectionClass, $aOptions);
-            return new CallableObject($this, $this->di, $xReflectionClass, $xOptions);
-        });
-
-        // Initialize the user class instance
-        $this->xContainer->extend($sClassName, function($xClassInstance) use($sClassName) {
-            if($xClassInstance instanceof AbstractComponent)
-            {
-                $xHelper = $this->get($this->getCallableHelperKey($sClassName));
-                $xHelper->xTarget = $this->xTarget;
-
-                // Call the protected "initComponent()" method of the Component class.
-                $cSetter = function($di, $xHelper) {
-                    $this->initComponent($di, $xHelper);  // "$this" here refers to the Component class.
-                };
-                $cSetter = $cSetter->bindTo($xClassInstance, $xClassInstance);
-                call_user_func($cSetter, $this->di, $xHelper);
-            }
-
-            // Run the callbacks for class initialisation
-            $this->di->g(CallbackManager::class)->onInit($xClassInstance);
-
-            // Set attributes from the DI container.
-            // The class level DI options are set on any component.
-            // The method level DI options are set only on the targetted component.
-            /** @var CallableObject */
-            $xCallableObject = $this->get($this->getCallableObjectKey($sClassName));
-            $xCallableObject->setDiClassAttributes($xClassInstance);
-            if($this->xTarget !== null)
-            {
-                $sMethodName = $this->xTarget->getMethodName();
-                $xCallableObject->setDiMethodAttributes($xClassInstance, $sMethodName);
-            }
-
-            return $xClassInstance;
-        });
-
-        return $sClassName;
-    }
+private function _registerComponent(string $sComponentId): string
+{
+// Replace all separators ('.' or '_') with antislashes, and trim the class name.
+$sClassName = trim(str_replace(['.', '_'], '\\', $sComponentId), '\\');
+
+$sComponentObject = $this->getCallableObjectKey($sClassName);
+// Prevent duplication. It's important not to use the class name here.
+if($this->has($sComponentObject))
+{
+return $sClassName;
+}
+
+// Register the helper class
+$this->set($this->getCallableHelperKey($sClassName), function() use($sClassName) {
+$xFactory = $this->di->getCallFactory();
+return new ComponentHelper($this, $xFactory->rq($sClassName),
+    $xFactory, $this->di->getViewRenderer(),
+    $this->di->getLogger(), $this->di->getSessionManager(),
+    $this->di->getStash(), $this->di->getUploadHandler());
+});
+
+$this->discoverComponent($sClassName);
+
+// Register the callable object
+$this->set($sComponentObject, function() use($sComponentId, $sClassName) {
+$aOptions = $this->_getClassOptions($sComponentId);
+$xReflectionClass = $this->get($this->getReflectionClassKey($sClassName));
+$xOptions = $this->getComponentOptions($xReflectionClass, $aOptions);
+return new CallableObject($this, $this->di, $xReflectionClass, $xOptions);
+});
+
+// Initialize the user class instance
+$this->xContainer->extend($sClassName, function($xClassInstance) use($sClassName) {
+if($xClassInstance instanceof AbstractComponent)
+{
+    $xHelper = $this->get($this->getCallableHelperKey($sClassName));
+    $xHelper->xTarget = $this->xTarget;
+
+    // Call the protected "initComponent()" method of the Component class.
+    $cSetter = function($di, $xHelper) {
+        $this->initComponent($di, $xHelper);  // "$this" here refers to the Component class.
+    };
+    $cSetter = $cSetter->bindTo($xClassInstance, $xClassInstance);
+    call_user_func($cSetter, $this->di, $xHelper);
+}
+
+// Run the callbacks for class initialisation
+$this->di->g(CallbackManager::class)->onInit($xClassInstance);
+
+// Set attributes from the DI container.
+// The class level DI options are set on any component.
+// The method level DI options are set only on the targetted component.
+/** @var CallableObject */
+$xCallableObject = $this->get($this->getCallableObjectKey($sClassName));
+$xCallableObject->setDiClassAttributes($xClassInstance);
+if($this->xTarget !== null)
+{
+    $sMethodName = $this->xTarget->getMethodName();
+    $xCallableObject->setDiMethodAttributes($xClassInstance, $sMethodName);
+}
+
+return $xClassInstance;
+});
+
+return $sClassName;
+}
 
-    /**
+/**
      * Get the callable object for a given class
      * The callable object is registered if it is not already in the DI.
      *
@@ -301,13 +301,13 @@ 
      * @return CallableObject|null
      * @throws SetupException
      */
-    public function makeCallableObject(string $sComponentId): ?CallableObject
-    {
-        $sClassName = $this->_registerComponent($sComponentId);
-        return $this->get($this->getCallableObjectKey($sClassName));
-    }
+public function makeCallableObject(string $sComponentId): ?CallableObject
+{
+$sClassName = $this->_registerComponent($sComponentId);
+return $this->get($this->getCallableObjectKey($sClassName));
+}
 
-    /**
+/**
      * Get an instance of a component by name
      *
      * @template T
@@ -316,53 +316,53 @@ 
      * @return T|null
      * @throws SetupException
      */
-    public function makeComponent(string $sClassName): mixed
-    {
-        $sComponentId = str_replace('\\', '.', $sClassName);
-        $sClassName = $this->_registerComponent($sComponentId);
-        return $this->get($sClassName);
-    }
+public function makeComponent(string $sClassName): mixed
+{
+$sComponentId = str_replace('\\', '.', $sClassName);
+$sClassName = $this->_registerComponent($sComponentId);
+return $this->get($sClassName);
+}
 
-    /**
+/**
      * Get a factory for a call to a registered function.
      *
      * @return JxnCall
      */
-    public function getFunctionRequestFactory(): JxnCall
-    {
-        return $this->get($this->getRequestFactoryKey(JxnCall::class));
-    }
+public function getFunctionRequestFactory(): JxnCall
+{
+return $this->get($this->getRequestFactoryKey(JxnCall::class));
+}
 
-    /**
+/**
      * Get a factory for a call to a registered component.
      *
      * @param class-string $sClassName
      *
      * @return JxnCall|null
      */
-    public function getComponentRequestFactory(string $sClassName): ?JxnCall
+public function getComponentRequestFactory(string $sClassName): ?JxnCall
+{
+$sClassName = trim($sClassName, " \t");
+if($sClassName === '')
+{
+return null;
+}
+
+$sFactoryKey = $this->getRequestFactoryKey($sClassName);
+if(!$this->has($sFactoryKey))
+{
+$this->xContainer->offsetSet($sFactoryKey, function() use($sClassName) {
+    $sComponentId = str_replace('\\', '.', $sClassName);
+    if(!($xCallable = $this->makeCallableObject($sComponentId)))
     {
-        $sClassName = trim($sClassName, " \t");
-        if($sClassName === '')
-        {
-            return null;
-        }
-
-        $sFactoryKey = $this->getRequestFactoryKey($sClassName);
-        if(!$this->has($sFactoryKey))
-        {
-            $this->xContainer->offsetSet($sFactoryKey, function() use($sClassName) {
-                $sComponentId = str_replace('\\', '.', $sClassName);
-                if(!($xCallable = $this->makeCallableObject($sComponentId)))
-                {
-                    return null;
-                }
-
-                $xConfigManager = $this->di->g(ConfigManager::class);
-                $sPrefix = $xConfigManager->getOption('core.prefix.class', '');
-                return new JxnClassCall($sPrefix . $xCallable->getJsName());
-            });
-        }
-        return $this->get($sFactoryKey);
+        return null;
     }
+
+    $xConfigManager = $this->di->g(ConfigManager::class);
+    $sPrefix = $xConfigManager->getOption('core.prefix.class', '');
+    return new JxnClassCall($sPrefix . $xCallable->getJsName());
+});
+}
+return $this->get($sFactoryKey);
+}
 }

jaxon-core/src/Request/Handler/RequestHandler.php

Switch Indentation +86 added lines, -86 removed lines

@@ -30,14 +30,14 @@ 
 
 class RequestHandler
 {
-    /**
+/**
      * The request plugin that is able to process the current request
      *
      * @var RequestHandlerInterface
      */
-    private $xRequestPlugin = null;
+private $xRequestPlugin = null;
 
-    /**
+/**
      * The constructor
      *
      * @param Container $di
@@ -46,113 +46,113 @@ 
      * @param CallbackManager $xCallbackManager
      * @param DatabagPlugin $xDatabagPlugin
      */
-    public function __construct(private Container $di, private PluginManager $xPluginManager,
-        private ResponseManager $xResponseManager, private CallbackManager $xCallbackManager,
-        private DatabagPlugin $xDatabagPlugin)
-    {}
+public function __construct(private Container $di, private PluginManager $xPluginManager,
+private ResponseManager $xResponseManager, private CallbackManager $xCallbackManager,
+private DatabagPlugin $xDatabagPlugin)
+{}
 
-    /**
+/**
      * Check if the current request can be processed
      *
      * Calls each of the request plugins and determines if the current request can be processed by one of them.
      *
      * @return bool
      */
-    public function canProcessRequest(): bool
-    {
-        // Return true if the request plugin was already found
-        if($this->xRequestPlugin !== null)
-        {
-            return true;
-        }
+public function canProcessRequest(): bool
+{
+// Return true if the request plugin was already found
+if($this->xRequestPlugin !== null)
+{
+return true;
+}
 
-        // The HTTP request
-        $xRequest = $this->di->getRequest();
+// The HTTP request
+$xRequest = $this->di->getRequest();
 
-        // Find a plugin to process the request
-        foreach($this->xPluginManager->getRequestHandlers() as $sClassName)
-        {
-            if($sClassName::canProcessRequest($xRequest))
-            {
-                $this->xRequestPlugin = $this->di->g($sClassName);
-                $xTarget = $this->xRequestPlugin->setTarget($xRequest);
-                $xTarget->setMethodArgs($this->di->getRequestArguments());
-                return true;
-            }
-        }
-        return false;
-    }
+// Find a plugin to process the request
+foreach($this->xPluginManager->getRequestHandlers() as $sClassName)
+{
+if($sClassName::canProcessRequest($xRequest))
+{
+    $this->xRequestPlugin = $this->di->g($sClassName);
+    $xTarget = $this->xRequestPlugin->setTarget($xRequest);
+    $xTarget->setMethodArgs($this->di->getRequestArguments());
+    return true;
+}
+}
+return false;
+}
 
-    /**
+/**
      * Process the current request and handle errors and exceptions.
      *
      * @return void
      * @throws RequestException
      */
-    private function _processRequest(): void
-    {
-        // Process the request
-        if($this->xRequestPlugin !== null)
-        {
-            $this->xRequestPlugin->processRequest();
-            // Process the databag
-            $this->xDatabagPlugin->writeCommand();
-        }
-    }
+private function _processRequest(): void
+{
+// Process the request
+if($this->xRequestPlugin !== null)
+{
+$this->xRequestPlugin->processRequest();
+// Process the databag
+$this->xDatabagPlugin->writeCommand();
+}
+}
 
-    /**
+/**
      * Process the current request.
      *
      * @return void
      * @throws RequestException
      */
-    public function processRequest(): void
-    {
-        // We need the library to have been bootstrapped.
-        $this->di->getBootstrap()->onBoot();
+public function processRequest(): void
+{
+// We need the library to have been bootstrapped.
+$this->di->getBootstrap()->onBoot();
 
-        // Check if there is a plugin to process this request
-        if(!$this->canProcessRequest())
-        {
-            return;
-        }
+// Check if there is a plugin to process this request
+if(!$this->canProcessRequest())
+{
+return;
+}
 
-        try
-        {
-            $bEndRequest = false;
-            // Handle before processing event
-            if($this->xRequestPlugin !== null)
-            {
-                $this->xCallbackManager->onBefore($this->xRequestPlugin->getTarget(), $bEndRequest);
-            }
-            if($bEndRequest)
-            {
-                return;
-            }
+try
+{
+$bEndRequest = false;
+// Handle before processing event
+if($this->xRequestPlugin !== null)
+{
+    $this->xCallbackManager->onBefore($this->xRequestPlugin->getTarget(), $bEndRequest);
+}
+if($bEndRequest)
+{
+    return;
+}
 
-            $this->_processRequest();
+$this->_processRequest();
 
-            // Handle after processing event
-            if($this->xRequestPlugin !== null)
-            {
-                $this->xCallbackManager->onAfter($this->xRequestPlugin->getTarget(), $bEndRequest);
-            }
-        }
-        // An exception was thrown while processing the request.
-        // The request missed the corresponding handler function,
-        // or an error occurred while attempting to execute the handler.
-        catch(RequestException $e)
-        {
-            $this->xResponseManager->error($e->getMessage());
-            $this->xCallbackManager->onInvalid($e);
-        }
-        catch(Exception $e)
-        {
-            $this->xResponseManager->error($e->getMessage());
-            $this->xCallbackManager->onError($e);
-        }
+// Handle after processing event
+if($this->xRequestPlugin !== null)
+{
+    $this->xCallbackManager->onAfter($this->xRequestPlugin->getTarget(), $bEndRequest);
+}
+}
+// An exception was thrown while processing the request.
+// The request missed the corresponding handler function,
+// or an error occurred while attempting to execute the handler.
+catch(RequestException $e)
+{
+$this->xResponseManager->error($e->getMessage());
+$this->xCallbackManager->onInvalid($e);
+}
+catch(Exception $e)
+{
+$this->xResponseManager->error($e->getMessage());
+$this->xCallbackManager->onError($e);
+}
 
-        // Print the debug messages
-        $this->xResponseManager->printDebug();
-    }
+// Print the debug messages
+$this->xResponseManager->printDebug();
+}
 }

jaxon-core/src/Plugin/Code/ConfigScriptGenerator.php

Switch Indentation +32 added lines, -32 removed lines

@@ -22,53 +22,53 @@
 
 class ConfigScriptGenerator extends AbstractCodeGenerator
 {
-    /**
+/**
      * The constructor
      *
      * @param ParameterReader $xParameterReader
      * @param TemplateEngine $xTemplateEngine
      * @param ConfigManager $xConfigManager
      */
-    public function __construct(private ParameterReader $xParameterReader,
-        private TemplateEngine $xTemplateEngine, private ConfigManager $xConfigManager)
-    {}
+public function __construct(private ParameterReader $xParameterReader,
+private TemplateEngine $xTemplateEngine, private ConfigManager $xConfigManager)
+{}
 
-    /**
+/**
      * Get the value of a config option
      *
      * @param string $sName The option name
      *
      * @return mixed
      */
-    private function option(string $sName): mixed
-    {
-        return $this->xConfigManager->getOption($sName);
-    }
+private function option(string $sName): mixed
+{
+return $this->xConfigManager->getOption($sName);
+}
 
-    /**
+/**
      * @inheritDoc
      * @throws UriException
      */
-    public function getScript(): string
-    {
-        // It is important to call $this->xParameterReader->uri() only if necessary.
-        $sUri = $this->option('core.request.uri') ?: $this->xParameterReader->uri();
-        $aOptions = [
-            'sResponseType'      => 'JSON',
-            'sVersion'           => $this->option('core.version'),
-            'sLanguage'          => $this->option('core.language'),
-            'sRequestURI'        => $sUri,
-            'sDefaultMode'       => $this->option('core.request.mode'),
-            'sDefaultMethod'     => $this->option('core.request.method'),
-            'sCsrfMetaName'      => $this->option('core.request.csrf_meta'),
-            'bLoggingEnabled'    => $this->xConfigManager->loggingEnabled(),
-            'bDebug'             => $this->option('core.debug.on'),
-            'bVerboseDebug'      => $this->option('core.debug.verbose'),
-            'sDebugOutputID'     => $this->option('core.debug.output_id'),
-            'nResponseQueueSize' => $this->option('js.lib.queue_size'),
-            'sStatusMessages'    => $this->option('js.lib.show_status') ? 'true' : 'false',
-            'sWaitCursor'        => $this->option('js.lib.show_cursor') ? 'true' : 'false',
-        ];
-        return $this->xTemplateEngine->render('jaxon::plugins/config.js', $aOptions);
-    }
+public function getScript(): string
+{
+// It is important to call $this->xParameterReader->uri() only if necessary.
+$sUri = $this->option('core.request.uri') ?: $this->xParameterReader->uri();
+$aOptions = [
+'sResponseType'      => 'JSON',
+'sVersion'           => $this->option('core.version'),
+'sLanguage'          => $this->option('core.language'),
+'sRequestURI'        => $sUri,
+'sDefaultMode'       => $this->option('core.request.mode'),
+'sDefaultMethod'     => $this->option('core.request.method'),
+'sCsrfMetaName'      => $this->option('core.request.csrf_meta'),
+'bLoggingEnabled'    => $this->xConfigManager->loggingEnabled(),
+'bDebug'             => $this->option('core.debug.on'),
+'bVerboseDebug'      => $this->option('core.debug.verbose'),
+'sDebugOutputID'     => $this->option('core.debug.output_id'),
+'nResponseQueueSize' => $this->option('js.lib.queue_size'),
+'sStatusMessages'    => $this->option('js.lib.show_status') ? 'true' : 'false',
+'sWaitCursor'        => $this->option('js.lib.show_cursor') ? 'true' : 'false',
+];
+return $this->xTemplateEngine->render('jaxon::plugins/config.js', $aOptions);
+}
 }

jaxon-core/src/Plugin/Code/AssetManager.php

Switch Indentation +98 added lines, -98 removed lines

@@ -26,142 +26,142 @@
 
 class AssetManager
 {
-    use ConfigTrait;
+use ConfigTrait;
 
-    /**
+/**
      * Default library URL
      *
      * @var string
      */
-    const JS_LIB_URL = 'https://cdn.jsdelivr.net/gh/jaxon-php/jaxon-js@5.0.10/dist';
+const JS_LIB_URL = 'https://cdn.jsdelivr.net/gh/jaxon-php/jaxon-js@5.0.10/dist';
 
-    /**
+/**
      * The constructor
      *
      * @param ConfigManager $xConfigManager
      * @param MinifierInterface $xMinifier
      */
-    public function __construct(private ConfigManager $xConfigManager,
-        private MinifierInterface $xMinifier)
-    {}
+public function __construct(private ConfigManager $xConfigManager,
+private MinifierInterface $xMinifier)
+{}
 
-    /**
+/**
      * @return ConfigManager
      */
-    protected function config(): ConfigManager
-    {
-        return $this->xConfigManager;
-    }
+protected function config(): ConfigManager
+{
+return $this->xConfigManager;
+}
 
-    /**
+/**
      * Get app js options
      *
      * @return string
      */
-    public function getJsOptions(): string
-    {
-        return $this->getLibOption('js.app.options', '');
-    }
+public function getJsOptions(): string
+{
+return $this->getLibOption('js.app.options', '');
+}
 
-    /**
+/**
      * Check if the assets of this plugin shall be included in Jaxon generated code.
      *
      * @param AbstractPlugin $xPlugin
      *
      * @return bool
      */
-    public function shallIncludeAssets(AbstractPlugin $xPlugin): bool
-    {
-        $sPluginOptionName = 'assets.include.' . $xPlugin->getName();
-        if($this->hasLibOption($sPluginOptionName))
-        {
-            return $this->getLibOption($sPluginOptionName);
-        }
-        return $this->getLibOption('assets.include.all', true);
-    }
-
-    /**
+public function shallIncludeAssets(AbstractPlugin $xPlugin): bool
+{
+$sPluginOptionName = 'assets.include.' . $xPlugin->getName();
+if($this->hasLibOption($sPluginOptionName))
+{
+return $this->getLibOption($sPluginOptionName);
+}
+return $this->getLibOption('assets.include.all', true);
+}
+
+/**
      * Get the HTML tags to include Jaxon javascript files into the page
      *
      * @return array
      */
-    public function getJsLibFiles(): array
-    {
-        $sJsExtension = $this->getLibOption('js.app.minify') ? '.min.js' : '.js';
-        // The URI for the javascript library files
-        $sJsLibUri = $this->getLibOption('js.lib.uri', self::JS_LIB_URL);
-        $sJsLibUri = rtrim($sJsLibUri, '/');
-
-        // Add component files to the javascript file array;
-        $aJsFiles = [
-            $this->getLibOption('js.lib.jq', "$sJsLibUri/libs/chibi/chibi$sJsExtension"),
-            "$sJsLibUri/jaxon.core$sJsExtension",
-        ];
-        if($this->getLibOption('core.debug.on'))
-        {
-            $sLanguage = $this->getLibOption('core.language');
-            $aJsFiles[] = "$sJsLibUri/jaxon.debug$sJsExtension";
-            $aJsFiles[] = "$sJsLibUri/lang/jaxon.$sLanguage$sJsExtension";
-        }
-
-        return $aJsFiles;
-    }
-
-    /**
+public function getJsLibFiles(): array
+{
+$sJsExtension = $this->getLibOption('js.app.minify') ? '.min.js' : '.js';
+// The URI for the javascript library files
+$sJsLibUri = $this->getLibOption('js.lib.uri', self::JS_LIB_URL);
+$sJsLibUri = rtrim($sJsLibUri, '/');
+
+// Add component files to the javascript file array;
+$aJsFiles = [
+$this->getLibOption('js.lib.jq', "$sJsLibUri/libs/chibi/chibi$sJsExtension"),
+"$sJsLibUri/jaxon.core$sJsExtension",
+];
+if($this->getLibOption('core.debug.on'))
+{
+$sLanguage = $this->getLibOption('core.language');
+$aJsFiles[] = "$sJsLibUri/jaxon.debug$sJsExtension";
+$aJsFiles[] = "$sJsLibUri/lang/jaxon.$sLanguage$sJsExtension";
+}
+
+return $aJsFiles;
+}
+
+/**
      * Get the javascript file name
      *
      * @return bool
      */
-    public function shallCreateJsFiles(): bool
-    {
-        // Check config options
-        // - The js.app.export option must be set to true
-        // - The js.app.uri and js.app.dir options must be set to non null values
-        if(!$this->getLibOption('js.app.export', false) ||
-            !$this->getLibOption('js.app.uri') || !$this->getLibOption('js.app.dir'))
-        {
-            return false;
-        }
-        return true;
-    }
-
-    /**
+public function shallCreateJsFiles(): bool
+{
+// Check config options
+// - The js.app.export option must be set to true
+// - The js.app.uri and js.app.dir options must be set to non null values
+if(!$this->getLibOption('js.app.export', false) ||
+!$this->getLibOption('js.app.uri') || !$this->getLibOption('js.app.dir'))
+{
+return false;
+}
+return true;
+}
+
+/**
      * Write javascript files and return the corresponding URI
      *
      * @param CodeGenerator $xCodeGenerator
      *
      * @return string
      */
-    public function createJsFiles(CodeGenerator $xCodeGenerator): string
-    {
-        // Check dir access
-        $sJsFileName = $this->getLibOption('js.app.file') ?: $xCodeGenerator->getHash();
-        $sJsDirectory = rtrim($this->getLibOption('js.app.dir'), '\/') . DIRECTORY_SEPARATOR;
-        // - The js.app.dir must be writable
-        if(!$sJsFileName || !is_dir($sJsDirectory) || !is_writable($sJsDirectory))
-        {
-            return '';
-        }
-
-        $sJsFilePath = $sJsDirectory . $sJsFileName . '.js';
-        $sJsMinFilePath = $sJsDirectory . $sJsFileName . '.min.js';
-        $sJsFileUri = rtrim($this->getLibOption('js.app.uri'), '/') . "/$sJsFileName";
-
-        if(!is_file($sJsFilePath) &&
-            !@file_put_contents($sJsFilePath, $xCodeGenerator->getJsScript()))
-        {
-            return '';
-        }
-        if(!$this->getLibOption('js.app.minify', false))
-        {
-            return $sJsFileUri . '.js';
-        }
-        if(!is_file($sJsMinFilePath) &&
-            !$this->xMinifier->minify($sJsFilePath, $sJsMinFilePath))
-        {
-            // If the file cannot be minified, return the plain js file.
-            return $sJsFileUri . '.js';
-        }
-        return $sJsFileUri . '.min.js';
-    }
+public function createJsFiles(CodeGenerator $xCodeGenerator): string
+{
+// Check dir access
+$sJsFileName = $this->getLibOption('js.app.file') ?: $xCodeGenerator->getHash();
+$sJsDirectory = rtrim($this->getLibOption('js.app.dir'), '\/') . DIRECTORY_SEPARATOR;
+// - The js.app.dir must be writable
+if(!$sJsFileName || !is_dir($sJsDirectory) || !is_writable($sJsDirectory))
+{
+return '';
+}
+
+$sJsFilePath = $sJsDirectory . $sJsFileName . '.js';
+$sJsMinFilePath = $sJsDirectory . $sJsFileName . '.min.js';
+$sJsFileUri = rtrim($this->getLibOption('js.app.uri'), '/') . "/$sJsFileName";
+
+if(!is_file($sJsFilePath) &&
+!@file_put_contents($sJsFilePath, $xCodeGenerator->getJsScript()))
+{
+return '';
+}
+if(!$this->getLibOption('js.app.minify', false))
+{
+return $sJsFileUri . '.js';
+}
+if(!is_file($sJsMinFilePath) &&
+!$this->xMinifier->minify($sJsFilePath, $sJsMinFilePath))
+{
+// If the file cannot be minified, return the plain js file.
+return $sJsFileUri . '.js';
+}
+return $sJsFileUri . '.min.js';
+}
 }

jaxon-core/src/Plugin/Code/CodeGenerator.php

Switch Indentation +207 added lines, -207 removed lines

@@ -31,75 +31,75 @@ 
 
 class CodeGenerator
 {
-    /**
+/**
      * @var AssetManager
      */
-    private $xAssetManager;
+private $xAssetManager;
 
-    /**
+/**
      * The classes that generate code
      *
      * @var array<string>
      */
-    protected $aCodeGenerators = [];
+protected $aCodeGenerators = [];
 
-    /**
+/**
      * @var string
      */
-    protected $sJsOptions;
+protected $sJsOptions;
 
-    /**
+/**
      * @var array
      */
-    protected $aCss = [];
+protected $aCss = [];
 
-    /**
+/**
      * @var array
      */
-    protected $aJs = [];
+protected $aJs = [];
 
-    /**
+/**
      * @var array
      */
-    protected $aCodeJs = [];
+protected $aCodeJs = [];
 
-    /**
+/**
      * @var array
      */
-    protected $aCodeJsBefore = [];
+protected $aCodeJsBefore = [];
 
-    /**
+/**
      * @var array
      */
-    protected $aCodeJsAfter = [];
+protected $aCodeJsAfter = [];
 
-    /**
+/**
      * @var array
      */
-    protected $aCodeJsFiles = [];
+protected $aCodeJsFiles = [];
 
-    /**
+/**
      * @var bool
      */
-    protected $bGenerated = false;
+protected $bGenerated = false;
 
-    /**
+/**
      * The constructor
      *
      * @param string $sVersion
      * @param Container $di
      * @param TemplateEngine $xTemplateEngine
      */
-    public function __construct(private string $sVersion, private Container $di,
-        private TemplateEngine $xTemplateEngine)
-    {
-        // The Jaxon library config is on top.
-        $this->addCodeGenerator(ConfigScriptGenerator::class, 0);
-        // The ready script comes after.
-        $this->addCodeGenerator(ReadyScriptGenerator::class, 200);
-    }
-
-    /**
+public function __construct(private string $sVersion, private Container $di,
+private TemplateEngine $xTemplateEngine)
+{
+// The Jaxon library config is on top.
+$this->addCodeGenerator(ConfigScriptGenerator::class, 0);
+// The ready script comes after.
+$this->addCodeGenerator(ReadyScriptGenerator::class, 200);
+}
+
+/**
      * Add a code generator to the list
      *
      * @param string $sClassName    The code generator class
@@ -107,39 +107,39 @@ 
      *
      * @return void
      */
-    public function addCodeGenerator(string $sClassName, int $nPriority): void
-    {
-        while(isset($this->aCodeGenerators[$nPriority]))
-        {
-            $nPriority++;
-        }
-        $this->aCodeGenerators[$nPriority] = $sClassName;
-    }
-
-    /**
+public function addCodeGenerator(string $sClassName, int $nPriority): void
+{
+while(isset($this->aCodeGenerators[$nPriority]))
+{
+$nPriority++;
+}
+$this->aCodeGenerators[$nPriority] = $sClassName;
+}
+
+/**
      * @param string $sClassName
      *
      * @return CodeGeneratorInterface
      */
-    private function getCodeGenerator(string $sClassName): CodeGeneratorInterface
-    {
-        return $this->di->g($sClassName);
-    }
+private function getCodeGenerator(string $sClassName): CodeGeneratorInterface
+{
+return $this->di->g($sClassName);
+}
 
-    /**
+/**
      * Generate a hash for all the javascript code generated by the library
      *
      * @return string
      */
-    public function getHash(): string
-    {
-        $aHashes = array_map(fn($sClassName) =>
-            $this->getCodeGenerator($sClassName)->getHash(), $this->aCodeGenerators);
-        $aHashes[] = $this->sVersion;
-        return md5(implode('', $aHashes));
-    }
-
-    /**
+public function getHash(): string
+{
+$aHashes = array_map(fn($sClassName) =>
+$this->getCodeGenerator($sClassName)->getHash(), $this->aCodeGenerators);
+$aHashes[] = $this->sVersion;
+return md5(implode('', $aHashes));
+}
+
+/**
      * Render a template in the 'plugins' subdir
      *
      * @param string $sTemplate    The template filename
@@ -147,185 +147,185 @@ 
      *
      * @return string
      */
-    private function render(string $sTemplate, array $aVars = []): string
-    {
-        $aVars['sJsOptions'] = $this->sJsOptions;
-        return $this->xTemplateEngine->render("jaxon::plugins/$sTemplate", $aVars);
-    }
+private function render(string $sTemplate, array $aVars = []): string
+{
+$aVars['sJsOptions'] = $this->sJsOptions;
+return $this->xTemplateEngine->render("jaxon::plugins/$sTemplate", $aVars);
+}
 
-    /**
+/**
      * Generate the Jaxon CSS and js codes for a given plugin
      *
      * @param CodeGeneratorInterface $xGenerator
      *
      * @return void
      */
-    private function generatePluginCodes(CodeGeneratorInterface $xGenerator): void
-    {
-        if(!is_subclass_of($xGenerator, AbstractPlugin::class) ||
-            $this->xAssetManager->shallIncludeAssets($xGenerator))
-        {
-            // HTML tags for CSS
-            if(($sCss = trim($xGenerator->getCss(), " \n")) !== '')
-            {
-                $this->aCss[] = $sCss;
-            }
-            // HTML tags for js
-            if(($sJs = trim($xGenerator->getJs(), " \n")) !== '')
-            {
-                $this->aJs[] = $sJs;
-            }
-        }
-
-        // Additional js codes
-        if(($xJsCode = $xGenerator->getJsCode()) !== null)
-        {
-            if(($sJs = trim($xJsCode->sJs, " \n")) !== '')
-            {
-                $this->aCodeJs[] = $sJs;
-            }
-            if(($sJsBefore = trim($xJsCode->sJsBefore, " \n")) !== '')
-            {
-                $this->aCodeJsBefore[] = $sJsBefore;
-            }
-            if(($sJsAfter = trim($xJsCode->sJsAfter, " \n")) !== '')
-            {
-                $this->aCodeJsAfter[] = $sJsAfter;
-            }
-            $this->aCodeJsFiles = array_merge($this->aCodeJsFiles, $xJsCode->aFiles);
-        }
-    }
-
-    /**
+private function generatePluginCodes(CodeGeneratorInterface $xGenerator): void
+{
+if(!is_subclass_of($xGenerator, AbstractPlugin::class) ||
+$this->xAssetManager->shallIncludeAssets($xGenerator))
+{
+// HTML tags for CSS
+if(($sCss = trim($xGenerator->getCss(), " \n")) !== '')
+{
+    $this->aCss[] = $sCss;
+}
+// HTML tags for js
+if(($sJs = trim($xGenerator->getJs(), " \n")) !== '')
+{
+    $this->aJs[] = $sJs;
+}
+}
+
+// Additional js codes
+if(($xJsCode = $xGenerator->getJsCode()) !== null)
+{
+if(($sJs = trim($xJsCode->sJs, " \n")) !== '')
+{
+    $this->aCodeJs[] = $sJs;
+}
+if(($sJsBefore = trim($xJsCode->sJsBefore, " \n")) !== '')
+{
+    $this->aCodeJsBefore[] = $sJsBefore;
+}
+if(($sJsAfter = trim($xJsCode->sJsAfter, " \n")) !== '')
+{
+    $this->aCodeJsAfter[] = $sJsAfter;
+}
+$this->aCodeJsFiles = array_merge($this->aCodeJsFiles, $xJsCode->aFiles);
+}
+}
+
+/**
      * Generate the Jaxon CSS ans js codes
      *
      * @return void
      * @throws UriException
      */
-    private function generateCodes(): void
-    {
-        if($this->bGenerated)
-        {
-            return;
-        }
-
-        // We need the library to have been bootstrapped.
-        $this->di->getBootstrap()->onBoot();
-
-        // Sort the code generators by ascending priority
-        ksort($this->aCodeGenerators);
-
-        // Cannot be injected because of dependency loop.
-        $this->xAssetManager = $this->di->getAssetManager();
-
-        $this->sJsOptions = $this->xAssetManager->getJsOptions();
-        foreach($this->aCodeGenerators as $sClassName)
-        {
-            $this->generatePluginCodes($this->getCodeGenerator($sClassName));
-        }
-
-        // Load the Jaxon lib js files, after the other libs js files.
-        $this->aJs[] = trim($this->render('includes.js', [
-            'aUrls' => $this->xAssetManager->getJsLibFiles(),
-        ]));
-
-        // The codes are already generated.
-        $this->bGenerated = true;
-    }
-
-    /**
+private function generateCodes(): void
+{
+if($this->bGenerated)
+{
+return;
+}
+
+// We need the library to have been bootstrapped.
+$this->di->getBootstrap()->onBoot();
+
+// Sort the code generators by ascending priority
+ksort($this->aCodeGenerators);
+
+// Cannot be injected because of dependency loop.
+$this->xAssetManager = $this->di->getAssetManager();
+
+$this->sJsOptions = $this->xAssetManager->getJsOptions();
+foreach($this->aCodeGenerators as $sClassName)
+{
+$this->generatePluginCodes($this->getCodeGenerator($sClassName));
+}
+
+// Load the Jaxon lib js files, after the other libs js files.
+$this->aJs[] = trim($this->render('includes.js', [
+'aUrls' => $this->xAssetManager->getJsLibFiles(),
+]));
+
+// The codes are already generated.
+$this->bGenerated = true;
+}
+
+/**
      * Get the HTML tags to include Jaxon CSS code and files into the page
      *
      * @return string
      * @throws UriException
      */
-    public function getCss(): string
-    {
-        $this->generateCodes();
-        return implode("\n\n", $this->aCss);
-    }
+public function getCss(): string
+{
+$this->generateCodes();
+return implode("\n\n", $this->aCss);
+}
 
-    /**
+/**
      * Get the HTML tags to include Jaxon javascript files into the page
      *
      * @return string
      * @throws UriException
      */
-    public function getJs(): string
-    {
-        $this->generateCodes();
-        return implode("\n\n", $this->aJs);
-    }
+public function getJs(): string
+{
+$this->generateCodes();
+return implode("\n\n", $this->aJs);
+}
 
-    /**
+/**
      * Get the Javascript code
      *
      * @return string
      */
-    public function getJsScript(): string
-    {
-        $aJsScripts = [];
-        foreach($this->aCodeGenerators as $sClassName)
-        {
-            $xGenerator = $this->getCodeGenerator($sClassName);
-            // Javascript code
-            if(($sJsScript = trim($xGenerator->getScript(), " \n")) !== '')
-            {
-                $aJsScripts[] = $sJsScript;
-            }
-        }
-        return implode("\n\n", $aJsScripts);
-    }
-
-    /**
+public function getJsScript(): string
+{
+$aJsScripts = [];
+foreach($this->aCodeGenerators as $sClassName)
+{
+$xGenerator = $this->getCodeGenerator($sClassName);
+// Javascript code
+if(($sJsScript = trim($xGenerator->getScript(), " \n")) !== '')
+{
+    $aJsScripts[] = $sJsScript;
+}
+}
+return implode("\n\n", $aJsScripts);
+}
+
+/**
      * @param bool $bIncludeJs Also get the JS files
      * @param bool $bIncludeCss Also get the CSS files
      *
      * @return array<string>
      */
-    private function renderCodes(bool $bIncludeJs, bool $bIncludeCss): array
-    {
-        $aCodes = [];
-        if($bIncludeCss)
-        {
-            $aCodes[] = $this->getCss();
-        }
-        if($bIncludeJs)
-        {
-            $aCodes[] = $this->getJs();
-        }
-
-        $sUrl = !$this->xAssetManager->shallCreateJsFiles() ? '' :
-            $this->xAssetManager->createJsFiles($this);
-        // Wrap the js code into the corresponding HTML tag.
-        $aCodes[] = $sUrl !== '' ?
-            $this->render('include.js', ['sUrl' => $sUrl]) :
-            $this->render('wrapper.js', ['sScript' => $this->getJsScript()]);
-
-        // Wrap the js codes into HTML tags.
-        if(count($this->aCodeJsBefore) > 0)
-        {
-            $sScript = implode("\n\n", $this->aCodeJsBefore);
-            $aCodes[] = $this->render('wrapper.js', ['sScript' => $sScript]);
-        }
-        if(count($this->aCodeJs) > 0)
-        {
-            $sScript = implode("\n\n", $this->aCodeJs);
-            $aCodes[] = $this->render('wrapper.js', ['sScript' => $sScript]);
-        }
-        if(count($this->aCodeJsFiles) > 0)
-        {
-            $aCodes[] = $this->render('includes.js', ['aUrls' => $this->aCodeJsFiles]);
-        }
-        if(count($this->aCodeJsAfter) > 0)
-        {
-            $sScript = implode("\n\n", $this->aCodeJsAfter);
-            $aCodes[] = $this->render('wrapper.js', ['sScript' => $sScript]);
-        }
-        return $aCodes;
-    }
-
-    /**
+private function renderCodes(bool $bIncludeJs, bool $bIncludeCss): array
+{
+$aCodes = [];
+if($bIncludeCss)
+{
+$aCodes[] = $this->getCss();
+}
+if($bIncludeJs)
+{
+$aCodes[] = $this->getJs();
+}
+
+$sUrl = !$this->xAssetManager->shallCreateJsFiles() ? '' :
+$this->xAssetManager->createJsFiles($this);
+// Wrap the js code into the corresponding HTML tag.
+$aCodes[] = $sUrl !== '' ?
+$this->render('include.js', ['sUrl' => $sUrl]) :
+$this->render('wrapper.js', ['sScript' => $this->getJsScript()]);
+
+// Wrap the js codes into HTML tags.
+if(count($this->aCodeJsBefore) > 0)
+{
+$sScript = implode("\n\n", $this->aCodeJsBefore);
+$aCodes[] = $this->render('wrapper.js', ['sScript' => $sScript]);
+}
+if(count($this->aCodeJs) > 0)
+{
+$sScript = implode("\n\n", $this->aCodeJs);
+$aCodes[] = $this->render('wrapper.js', ['sScript' => $sScript]);
+}
+if(count($this->aCodeJsFiles) > 0)
+{
+$aCodes[] = $this->render('includes.js', ['aUrls' => $this->aCodeJsFiles]);
+}
+if(count($this->aCodeJsAfter) > 0)
+{
+$sScript = implode("\n\n", $this->aCodeJsAfter);
+$aCodes[] = $this->render('wrapper.js', ['sScript' => $sScript]);
+}
+return $aCodes;
+}
+
+/**
      * Get the javascript code to be sent to the browser
      *
      * @param bool $bIncludeJs Also get the JS files
@@ -334,10 +334,10 @@ 
      * @return string
      * @throws UriException
      */
-    public function getScript(bool $bIncludeJs, bool $bIncludeCss): string
-    {
-        $this->generateCodes();
-        $aCodes = $this->renderCodes($bIncludeJs, $bIncludeCss);
-        return implode("\n\n", $aCodes);
-    }
+public function getScript(bool $bIncludeJs, bool $bIncludeCss): string
+{
+$this->generateCodes();
+$aCodes = $this->renderCodes($bIncludeJs, $bIncludeCss);
+return implode("\n\n", $aCodes);
+}
 }

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

Switch Indentation +210 added lines, -210 removed lines

@@ -46,17 +46,17 @@ 
 
 class CallableClassPlugin extends AbstractRequestPlugin
 {
-    /**
+/**
      * @var array<CallableObject>
      */
-    private array $aCallableObjects = [];
+private array $aCallableObjects = [];
 
-    /**
+/**
      * @var array<string>
      */
-    private array $aCallableNames = [];
+private array $aCallableNames = [];
 
-    /**
+/**
      * The class constructor
      *
      * @param string $sPrefix
@@ -67,150 +67,150 @@ 
      * @param TemplateEngine $xTemplateEngine
      * @param Validator $xValidator
      */
-    public function __construct(private string $sPrefix,
-        private LoggerInterface $xLogger, private ComponentContainer $cdi,
-        private ComponentRegistry $xRegistry, private Translator $xTranslator,
-        private TemplateEngine $xTemplateEngine, private Validator $xValidator)
-    {}
+public function __construct(private string $sPrefix,
+private LoggerInterface $xLogger, private ComponentContainer $cdi,
+private ComponentRegistry $xRegistry, private Translator $xTranslator,
+private TemplateEngine $xTemplateEngine, private Validator $xValidator)
+{}
 
-    /**
+/**
      * @inheritDoc
      */
-    public function getName(): string
-    {
-        return Jaxon::CALLABLE_CLASS;
-    }
+public function getName(): string
+{
+return Jaxon::CALLABLE_CLASS;
+}
 
-    /**
+/**
      * @inheritDoc
      * @throws SetupException
      */
-    public function checkOptions(string $sCallable, $xOptions): array
-    {
-        if(!$this->xValidator->validateClass(trim($sCallable)))
-        {
-            throw new SetupException($this->xTranslator->trans('errors.objects.invalid-declaration'));
-        }
-        if(is_string($xOptions))
-        {
-            $xOptions = ['include' => $xOptions];
-        }
-        elseif(!is_array($xOptions))
-        {
-            throw new SetupException($this->xTranslator->trans('errors.objects.invalid-declaration'));
-        }
-        return $xOptions;
-    }
-
-    /**
+public function checkOptions(string $sCallable, $xOptions): array
+{
+if(!$this->xValidator->validateClass(trim($sCallable)))
+{
+throw new SetupException($this->xTranslator->trans('errors.objects.invalid-declaration'));
+}
+if(is_string($xOptions))
+{
+$xOptions = ['include' => $xOptions];
+}
+elseif(!is_array($xOptions))
+{
+throw new SetupException($this->xTranslator->trans('errors.objects.invalid-declaration'));
+}
+return $xOptions;
+}
+
+/**
      * @inheritDoc
      */
-    public function register(string $sType, string $sCallable, array $aOptions): bool
-    {
-        $sClassName = trim($sCallable);
-        $this->xRegistry->registerComponent($sClassName, $aOptions);
-        return true;
-    }
-
-    /**
+public function register(string $sType, string $sCallable, array $aOptions): bool
+{
+$sClassName = trim($sCallable);
+$this->xRegistry->registerComponent($sClassName, $aOptions);
+return true;
+}
+
+/**
      * @inheritDoc
      * @throws SetupException
      */
-    public function getCallable(string $sCallable): CallableObject|null
-    {
-        return $this->cdi->makeCallableObject($sCallable);
-    }
+public function getCallable(string $sCallable): CallableObject|null
+{
+return $this->cdi->makeCallableObject($sCallable);
+}
 
-    /**
+/**
      * @inheritDoc
      */
-    public function getHash(): string
-    {
-        $this->xRegistry->registerAllComponents();
-        return md5($this->xRegistry->getHash());
-    }
+public function getHash(): string
+{
+$this->xRegistry->registerAllComponents();
+return md5($this->xRegistry->getHash());
+}
 
-    /**
+/**
      * Add a callable object to the script generator
      *
      * @param CallableObject $xCallableObject
      *
      * @return void
      */
-    private function addCallable(CallableObject $xCallableObject): void
-    {
-        $aCallableMethods = $xCallableObject->getCallableMethods();
-        if($xCallableObject->excluded() || count($aCallableMethods) === 0)
-        {
-            return;
-        }
-
-        $aCallableObject = &$this->aCallableObjects;
-        $sJsName = $xCallableObject->getJsName();
-        foreach(explode('.', $sJsName) as $sName)
-        {
-            if(!isset($aCallableObject['children'][$sName]))
-            {
-                $aCallableObject['children'][$sName] = [];
-            }
-            $aCallableObject = &$aCallableObject['children'][$sName];
-        }
-
-        $aCallableObject['methods'] = $aCallableMethods;
-        $aCallableObject['index'] = count($this->aCallableNames);
-        $this->aCallableNames[] = $sJsName;
-    }
-
-    /**
+private function addCallable(CallableObject $xCallableObject): void
+{
+$aCallableMethods = $xCallableObject->getCallableMethods();
+if($xCallableObject->excluded() || count($aCallableMethods) === 0)
+{
+return;
+}
+
+$aCallableObject = &$this->aCallableObjects;
+$sJsName = $xCallableObject->getJsName();
+foreach(explode('.', $sJsName) as $sName)
+{
+if(!isset($aCallableObject['children'][$sName]))
+{
+    $aCallableObject['children'][$sName] = [];
+}
+$aCallableObject = &$aCallableObject['children'][$sName];
+}
+
+$aCallableObject['methods'] = $aCallableMethods;
+$aCallableObject['index'] = count($this->aCallableNames);
+$this->aCallableNames[] = $sJsName;
+}
+
+/**
      * @param string $sIndent
      * @param array $aTemplateVars
      *
      * @return string
      */
-    private function renderMethod(string $sIndent, array $aTemplateVars): string
-    {
-        $aOptions = [];
-        foreach($aTemplateVars['aMethod']['options'] as $sKey => $sValue)
-        {
-            $aOptions[] = "$sKey: $sValue";
-        }
-        $aTemplateVars['sArguments'] = count($aOptions) === 0 ? 'args' :
-            'args, { ' . implode(', ', $aOptions) . ' }';
-
-        return $sIndent . trim($this->xTemplateEngine
-            ->render('jaxon::callables/method.js', $aTemplateVars));
-    }
-
-    /**
+private function renderMethod(string $sIndent, array $aTemplateVars): string
+{
+$aOptions = [];
+foreach($aTemplateVars['aMethod']['options'] as $sKey => $sValue)
+{
+$aOptions[] = "$sKey: $sValue";
+}
+$aTemplateVars['sArguments'] = count($aOptions) === 0 ? 'args' :
+'args, { ' . implode(', ', $aOptions) . ' }';
+
+return $sIndent . trim($this->xTemplateEngine
+->render('jaxon::callables/method.js', $aTemplateVars));
+}
+
+/**
      * @param string $sJsClass
      * @param array $aCallable
      * @param int $nIndent
      *
      * @return string
      */
-    private function renderCallable(string $sJsClass, array $aCallable, int $nIndent): string
-    {
-        $nIndent += 2; // Indentation.
-        $sIndent = str_repeat(' ', $nIndent);
-
-        $fMethodCallback = fn($aMethod) => $this->renderMethod($sIndent, [
-            'aMethod' => $aMethod,
-            'nIndex' => $aCallable['index'] ?? 0,
-        ]);
-        $aMethods = !isset($aCallable['methods']) ? [] :
-            array_map($fMethodCallback, $aCallable['methods']);
-
-        $aChildren = [];
-        foreach($aCallable['children'] ?? [] as $sName => $aChild)
-        {
-            $aChildren[] = $this->renderChild("$sName:", "$sJsClass.$sName",
-                $aChild, $nIndent) . ',';
-        }
-
-        return implode("\n", array_merge($aMethods, $aChildren));
-    }
-
-    /**
+private function renderCallable(string $sJsClass, array $aCallable, int $nIndent): string
+{
+$nIndent += 2; // Indentation.
+$sIndent = str_repeat(' ', $nIndent);
+
+$fMethodCallback = fn($aMethod) => $this->renderMethod($sIndent, [
+'aMethod' => $aMethod,
+'nIndex' => $aCallable['index'] ?? 0,
+]);
+$aMethods = !isset($aCallable['methods']) ? [] :
+array_map($fMethodCallback, $aCallable['methods']);
+
+$aChildren = [];
+foreach($aCallable['children'] ?? [] as $sName => $aChild)
+{
+$aChildren[] = $this->renderChild("$sName:", "$sJsClass.$sName",
+    $aChild, $nIndent) . ',';
+}
+
+return implode("\n", array_merge($aMethods, $aChildren));
+}
+
+/**
      * @param string $sJsVar
      * @param string $sJsClass
      * @param array $aCallable
@@ -218,70 +218,70 @@ 
      *
      * @return string
      */
-    private function renderChild(string $sJsVar, string $sJsClass,
-        array $aCallable, int $nIndent = 0): string
-    {
-        $sIndent = str_repeat(' ', $nIndent);
-        $sScript = $this->renderCallable($sJsClass, $aCallable, $nIndent);
+private function renderChild(string $sJsVar, string $sJsClass,
+array $aCallable, int $nIndent = 0): string
+{
+$sIndent = str_repeat(' ', $nIndent);
+$sScript = $this->renderCallable($sJsClass, $aCallable, $nIndent);
 
-        return <<<CODE
+return <<<CODE
 $sIndent$sJsVar {
 $sScript
 $sIndent}
 CODE;
-    }
+}
 
-    /**
+/**
      * Generate client side javascript code for the registered callable objects
      *
      * @return string
      * @throws SetupException
      */
-    public function getScript(): string
-    {
-        $this->xRegistry->registerAllComponents();
-
-        $this->aCallableNames = [];
-        $this->aCallableObjects = ['children' => []];
-        foreach($this->cdi->getCallableObjects() as $xCallableObject)
-        {
-            $this->addCallable($xCallableObject);
-        }
-
-        $aScripts = [
-            $this->xTemplateEngine ->render('jaxon::callables/objects.js', [
-                'aCallableNames' => $this->aCallableNames,
-            ])
-        ];
-        foreach($this->aCallableObjects['children'] as $sJsClass => $aCallable)
-        {
-            $aScripts[] = $this->renderChild("{$this->sPrefix}$sJsClass =",
-                $sJsClass, $aCallable) . ';';
-        }
-        return implode("\n", $aScripts) . "\n";
-    }
-
-    /**
+public function getScript(): string
+{
+$this->xRegistry->registerAllComponents();
+
+$this->aCallableNames = [];
+$this->aCallableObjects = ['children' => []];
+foreach($this->cdi->getCallableObjects() as $xCallableObject)
+{
+$this->addCallable($xCallableObject);
+}
+
+$aScripts = [
+$this->xTemplateEngine ->render('jaxon::callables/objects.js', [
+    'aCallableNames' => $this->aCallableNames,
+])
+];
+foreach($this->aCallableObjects['children'] as $sJsClass => $aCallable)
+{
+$aScripts[] = $this->renderChild("{$this->sPrefix}$sJsClass =",
+    $sJsClass, $aCallable) . ';';
+}
+return implode("\n", $aScripts) . "\n";
+}
+
+/**
      * @inheritDoc
      */
-    public static function canProcessRequest(ServerRequestInterface $xRequest): bool
-    {
-        $aCall = $xRequest->getAttribute('jxncall');
-        return $aCall !== null && ($aCall['type'] ?? '') === 'class' &&
-            isset($aCall['name']) && isset($aCall['method']) &&
-            is_string($aCall['name']) && is_string($aCall['method']);
-    }
-
-    /**
+public static function canProcessRequest(ServerRequestInterface $xRequest): bool
+{
+$aCall = $xRequest->getAttribute('jxncall');
+return $aCall !== null && ($aCall['type'] ?? '') === 'class' &&
+isset($aCall['name']) && isset($aCall['method']) &&
+is_string($aCall['name']) && is_string($aCall['method']);
+}
+
+/**
      * @inheritDoc
      */
-    public function setTarget(ServerRequestInterface $xRequest): Target
-    {
-        $this->xTarget = Target::makeClass($xRequest->getAttribute('jxncall'));
-        return $this->xTarget;
-    }
+public function setTarget(ServerRequestInterface $xRequest): Target
+{
+$this->xTarget = Target::makeClass($xRequest->getAttribute('jxncall'));
+return $this->xTarget;
+}
 
-    /**
+/**
      * @param string $sExceptionMessage
      * @param string $sErrorCode
      * @param array $aErrorParams
@@ -289,53 +289,53 @@ 
      * @throws RequestException
      * @return void
      */
-    private function throwException(string $sExceptionMessage,
-        string $sErrorCode, array $aErrorParams = []): void
-    {
-        $sMessage = $this->xTranslator->trans($sErrorCode, $aErrorParams) .
-            (!$sExceptionMessage ? '' : "\n$sExceptionMessage");
-        $this->xLogger->error($sMessage);
-        throw new RequestException($sMessage);
-    }
-
-    /**
+private function throwException(string $sExceptionMessage,
+string $sErrorCode, array $aErrorParams = []): void
+{
+$sMessage = $this->xTranslator->trans($sErrorCode, $aErrorParams) .
+(!$sExceptionMessage ? '' : "\n$sExceptionMessage");
+$this->xLogger->error($sMessage);
+throw new RequestException($sMessage);
+}
+
+/**
      * @inheritDoc
      * @throws RequestException
      */
-    public function processRequest(): void
-    {
-        $sClassName = $this->xTarget->getClassName();
-        $sMethodName = $this->xTarget->getMethodName();
-        // Will be used to print a translated error message.
-        $aErrorParams = ['class' => $sClassName, 'method' => $sMethodName];
-
-        if(!$this->xValidator->validateJsObject($sClassName) ||
-            !$this->xValidator->validateMethod($sMethodName))
-        {
-            // Unable to find the requested object or method
-            $this->throwException('', 'errors.objects.invalid', $aErrorParams);
-        }
-
-        // Call the requested method
-        try
-        {
-            $sError = 'errors.objects.find';
-            /** @var CallableObject */
-            $xCallableObject = $this->getCallable($sClassName);
-
-            if($xCallableObject->excluded($sMethodName))
-            {
-                // Unable to find the requested class or method
-                $this->throwException('', 'errors.objects.excluded', $aErrorParams);
-            }
-
-            $sError = 'errors.objects.call';
-            $xCallableObject->call($this->xTarget);
-        }
-        catch(ReflectionException|SetupException $e)
-        {
-            // Unable to execute the requested class or method
-            $this->throwException($e->getMessage(), $sError, $aErrorParams);
-        }
-    }
+public function processRequest(): void
+{
+$sClassName = $this->xTarget->getClassName();
+$sMethodName = $this->xTarget->getMethodName();
+// Will be used to print a translated error message.
+$aErrorParams = ['class' => $sClassName, 'method' => $sMethodName];
+
+if(!$this->xValidator->validateJsObject($sClassName) ||
+!$this->xValidator->validateMethod($sMethodName))
+{
+// Unable to find the requested object or method
+$this->throwException('', 'errors.objects.invalid', $aErrorParams);
+}
+
+// Call the requested method
+try
+{
+$sError = 'errors.objects.find';
+/** @var CallableObject */
+$xCallableObject = $this->getCallable($sClassName);
+
+if($xCallableObject->excluded($sMethodName))
+{
+    // Unable to find the requested class or method
+    $this->throwException('', 'errors.objects.excluded', $aErrorParams);
+}
+
+$sError = 'errors.objects.call';
+$xCallableObject->call($this->xTarget);
+}
+catch(ReflectionException|SetupException $e)
+{
+// Unable to execute the requested class or method
+$this->throwException($e->getMessage(), $sError, $aErrorParams);
+}
+}
 }

jaxon-upload/tests/TestUpload/UploadHandlerTest.php

Switch Indentation +551 added lines, -551 removed lines

@@ -21,605 +21,605 @@
 
 class UploadHandlerTest extends TestCase
 {
-    /**
+/**
      * @var string
      */
-    protected $sNameWhite;
+protected $sNameWhite;
 
-    /**
+/**
      * @var string
      */
-    protected $sPathWhite;
+protected $sPathWhite;
 
-    /**
+/**
      * @var int
      */
-    protected $sSizeWhite;
+protected $sSizeWhite;
 
-    /**
+/**
      * @var string
      */
-    protected $sNameBlue;
+protected $sNameBlue;
 
-    /**
+/**
      * @var string
      */
-    protected $sPathBlue;
+protected $sPathBlue;
 
-    /**
+/**
      * @var int
      */
-    protected $sSizeBlue;
+protected $sSizeBlue;
 
-    /**
+/**
      * @throws SetupException
      */
-    public function setUp(): void
-    {
-        jaxon()->di()->getPluginManager()->registerPlugins();
-        _register();
-        jaxon()->setOption('core.upload.enabled', true);
-        jaxon()->setOption('core.response.send', false);
-
-        $tmpDir = __DIR__ . '/../upload/tmp';
-        @mkdir($tmpDir);
-
-        $sSrcWhite = __DIR__ . '/../upload/src/white.png';
-        $this->sNameWhite = 'white.png';
-        $this->sPathWhite = "$tmpDir/{$this->sNameWhite}";
-        $this->sSizeWhite = filesize($sSrcWhite);
-        // Copy the file to the temp dir.
-        @copy($sSrcWhite, $this->sPathWhite);
-
-        $sSrcBlue = __DIR__ . '/../upload/src/blue.png';
-        $this->sNameBlue = 'blue.png';
-        $this->sPathBlue = "$tmpDir/{$this->sNameBlue}";
-        $this->sSizeBlue = filesize($sSrcBlue);
-        // Copy the file to the temp dir.
-        @copy($sSrcBlue, $this->sPathBlue);
-
-        jaxon()->register(Jaxon::CALLABLE_CLASS, 'SampleUpload', __DIR__ . '/../src/sample.php');
-        jaxon()->di()->getBootstrap()->onBoot();
-    }
-
-    /**
+public function setUp(): void
+{
+jaxon()->di()->getPluginManager()->registerPlugins();
+_register();
+jaxon()->setOption('core.upload.enabled', true);
+jaxon()->setOption('core.response.send', false);
+
+$tmpDir = __DIR__ . '/../upload/tmp';
+@mkdir($tmpDir);
+
+$sSrcWhite = __DIR__ . '/../upload/src/white.png';
+$this->sNameWhite = 'white.png';
+$this->sPathWhite = "$tmpDir/{$this->sNameWhite}";
+$this->sSizeWhite = filesize($sSrcWhite);
+// Copy the file to the temp dir.
+@copy($sSrcWhite, $this->sPathWhite);
+
+$sSrcBlue = __DIR__ . '/../upload/src/blue.png';
+$this->sNameBlue = 'blue.png';
+$this->sPathBlue = "$tmpDir/{$this->sNameBlue}";
+$this->sSizeBlue = filesize($sSrcBlue);
+// Copy the file to the temp dir.
+@copy($sSrcBlue, $this->sPathBlue);
+
+jaxon()->register(Jaxon::CALLABLE_CLASS, 'SampleUpload', __DIR__ . '/../src/sample.php');
+jaxon()->di()->getBootstrap()->onBoot();
+}
+
+/**
      * @throws SetupException
      */
-    public function tearDown(): void
-    {
-        jaxon()->reset();
-        parent::tearDown();
-    }
+public function tearDown(): void
+{
+jaxon()->reset();
+parent::tearDown();
+}
 
-    /**
+/**
      * @throws RequestException
      */
-    public function testAjaxUpload()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-    }
-
-    /**
+public function testAjaxUpload()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+}
+
+/**
      * @throws RequestException
      */
-    public function testAjaxUploadMultipleFiles()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => [
-                        new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                        new UploadedFile($this->sPathBlue, $this->sSizeBlue,
-                            UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
-                    ],
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(2, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-        $xFile = $aFiles['image'][1];
-        $this->assertEquals('blue', $xFile->name());
-        $this->assertEquals($this->sNameBlue, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-    }
-
-    /**
+public function testAjaxUploadMultipleFiles()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => [
+            new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+                UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+            new UploadedFile($this->sPathBlue, $this->sSizeBlue,
+                UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
+        ],
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(2, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+$xFile = $aFiles['image'][1];
+$this->assertEquals('blue', $xFile->name());
+$this->assertEquals($this->sNameBlue, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+}
+
+/**
      * @throws RequestException
      */
-    public function testAjaxUploadMultipleNames()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'white' => [
-                        new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                    ],
-                    'blue' => [
-                        new UploadedFile($this->sPathBlue, $this->sSizeBlue,
-                            UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
-                    ],
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(2, $aFiles);
-        $this->assertCount(1, $aFiles['white']);
-        $this->assertCount(1, $aFiles['blue']);
-        $xFile = $aFiles['white'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-        $xFile = $aFiles['blue'][0];
-        $this->assertEquals('blue', $xFile->name());
-        $this->assertEquals($this->sNameBlue, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-    }
-
-    /**
+public function testAjaxUploadMultipleNames()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'white' => [
+            new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+                UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+        ],
+        'blue' => [
+            new UploadedFile($this->sPathBlue, $this->sSizeBlue,
+                UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
+        ],
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(2, $aFiles);
+$this->assertCount(1, $aFiles['white']);
+$this->assertCount(1, $aFiles['blue']);
+$xFile = $aFiles['white'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+$xFile = $aFiles['blue'][0];
+$this->assertEquals('blue', $xFile->name());
+$this->assertEquals($this->sNameBlue, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+}
+
+/**
      * @throws RequestException
      */
-    public function testAjaxUploadNameSanitizer()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->upload()->sanitizer(function($sFilename, $sVarName) {
-            return $sVarName === 'image' ? 'img_' . $sFilename : $sFilename;
-        });
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('img_white', $xFile->name());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testAjaxUploadNameSanitizer()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->upload()->sanitizer(function($sFilename, $sVarName) {
+return $sVarName === 'image' ? 'img_' . $sFilename : $sFilename;
+});
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('img_white', $xFile->name());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileTypeValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.types', ['png']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileTypeValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.types', ['png']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileTypeValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.types', ['jpg']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileTypeValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.types', ['jpg']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileExtensionValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.extensions', ['png']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileExtensionValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.extensions', ['png']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileExtensionValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.extensions', ['jpg']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileExtensionValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.extensions', ['jpg']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMaxSizeValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.max-size', 30000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileMaxSizeValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.max-size', 30000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMaxSizeValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.max-size', 25000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileMaxSizeValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.max-size', 25000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMinSizeValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.min-size', 25000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileMinSizeValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.min-size', 25000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMinSizeValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.min-size', 30000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileMinSizeValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.min-size', 30000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      * @throws SetupException
      */
-    public function testPsrAjaxUpload()
-    {
-        _register();
-        jaxon()->setOption('core.upload.enabled', true);
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        // Send a request to the registered class
-        $xRequest = jaxon()->di()->g(ServerRequestCreator::class)
-            ->fromGlobals()
-            ->withParsedBody([
-                'jxncall' => json_encode([
-                    'type' => 'class',
-                    'name' => 'SampleUpload',
-                    'method' => 'myMethod',
-                    'args' => [],
-                ]),
-            ])
-            ->withUploadedFiles([
-                'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                    UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-            ])
-            ->withMethod('POST');
-
-        $xPsrConfigMiddleware = jaxon()->psr()->config(__DIR__ . '/../config/psr.php');
-        $xPsrAjaxMiddleware = jaxon()->psr()->ajax();
-        // PSR request handler that does nothing, useful to call the config middleware.
-        $xEmptyRequestHandler = new class implements RequestHandlerInterface
-        {
-            private $xPsr17Factory;
-
-            public function __construct()
-            {
-                $this->xPsr17Factory = new Psr17Factory();
-            }
-
-            public function handle(ServerRequestInterface $request): ResponseInterface
-            {
-                return $this->xPsr17Factory->createResponse();
-            }
-        };
-        // Call the config middleware
-        $xPsrConfigMiddleware->process($xRequest, $xEmptyRequestHandler);
-        // Call the ajax middleware
-        $xPsrResponse = $xPsrAjaxMiddleware->process($xRequest, $xEmptyRequestHandler);
-
-        // Both responses must have the same content and content type
-        $xJaxonResponse = jaxon()->getResponse();
-        $this->assertEquals($xPsrResponse->getBody()->__toString(), $xJaxonResponse->getOutput());
-        $this->assertEquals($xPsrResponse->getHeader('content-type')[0], $xJaxonResponse->getContentType());
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-    }
+public function testPsrAjaxUpload()
+{
+_register();
+jaxon()->setOption('core.upload.enabled', true);
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+// Send a request to the registered class
+$xRequest = jaxon()->di()->g(ServerRequestCreator::class)
+->fromGlobals()
+->withParsedBody([
+    'jxncall' => json_encode([
+        'type' => 'class',
+        'name' => 'SampleUpload',
+        'method' => 'myMethod',
+        'args' => [],
+    ]),
+])
+->withUploadedFiles([
+    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+])
+->withMethod('POST');
+
+$xPsrConfigMiddleware = jaxon()->psr()->config(__DIR__ . '/../config/psr.php');
+$xPsrAjaxMiddleware = jaxon()->psr()->ajax();
+// PSR request handler that does nothing, useful to call the config middleware.
+$xEmptyRequestHandler = new class implements RequestHandlerInterface
+{
+private $xPsr17Factory;
+
+public function __construct()
+{
+    $this->xPsr17Factory = new Psr17Factory();
+}
+
+public function handle(ServerRequestInterface $request): ResponseInterface
+{
+    return $this->xPsr17Factory->createResponse();
+}
+};
+// Call the config middleware
+$xPsrConfigMiddleware->process($xRequest, $xEmptyRequestHandler);
+// Call the ajax middleware
+$xPsrResponse = $xPsrAjaxMiddleware->process($xRequest, $xEmptyRequestHandler);
+
+// Both responses must have the same content and content type
+$xJaxonResponse = jaxon()->getResponse();
+$this->assertEquals($xPsrResponse->getBody()->__toString(), $xJaxonResponse->getOutput());
+$this->assertEquals($xPsrResponse->getHeader('content-type')[0], $xJaxonResponse->getContentType());
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+}
 }

jaxon-upload/tests/TestUpload/UploadFsLocalTest.php

Switch Indentation +133 added lines, -133 removed lines

@@ -19,166 +19,166 @@
 
 class UploadFsLocalTest extends TestCase
 {
-    /**
+/**
      * @var string
      */
-    protected $sNameWhite;
+protected $sNameWhite;
 
-    /**
+/**
      * @var string
      */
-    protected $sPathWhite;
+protected $sPathWhite;
 
-    /**
+/**
      * @var int
      */
-    protected $sSizeWhite;
+protected $sSizeWhite;
 
-    /**
+/**
      * @var string
      */
-    protected $sNameBlue;
+protected $sNameBlue;
 
-    /**
+/**
      * @var string
      */
-    protected $sPathBlue;
+protected $sPathBlue;
 
-    /**
+/**
      * @var int
      */
-    protected $sSizeBlue;
+protected $sSizeBlue;
 
-    /**
+/**
      * @throws SetupException
      */
-    public function setUp(): void
-    {
-        jaxon()->di()->getPluginManager()->registerPlugins();
-        jaxon()->setOption('core.response.send', false);
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        _register();
-
-        $tmpDir = __DIR__ . '/../upload/tmp';
-        @mkdir($tmpDir);
-
-        $sSrcWhite = __DIR__ . '/../upload/src/white.png';
-        $this->sNameWhite = 'white.png';
-        $this->sPathWhite = "$tmpDir/{$this->sNameWhite}";
-        $this->sSizeWhite = filesize($sSrcWhite);
-        // Copy the file to the temp dir.
-        @copy($sSrcWhite, $this->sPathWhite);
-
-        $sSrcBlue = __DIR__ . '/../upload/src/blue.png';
-        $this->sNameBlue = 'blue.png';
-        $this->sPathBlue = "$tmpDir/{$this->sNameBlue}";
-        $this->sSizeBlue = filesize($sSrcBlue);
-        // Copy the file to the temp dir.
-        @copy($sSrcBlue, $this->sPathBlue);
-    }
-
-    /**
+public function setUp(): void
+{
+jaxon()->di()->getPluginManager()->registerPlugins();
+jaxon()->setOption('core.response.send', false);
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+_register();
+
+$tmpDir = __DIR__ . '/../upload/tmp';
+@mkdir($tmpDir);
+
+$sSrcWhite = __DIR__ . '/../upload/src/white.png';
+$this->sNameWhite = 'white.png';
+$this->sPathWhite = "$tmpDir/{$this->sNameWhite}";
+$this->sSizeWhite = filesize($sSrcWhite);
+// Copy the file to the temp dir.
+@copy($sSrcWhite, $this->sPathWhite);
+
+$sSrcBlue = __DIR__ . '/../upload/src/blue.png';
+$this->sNameBlue = 'blue.png';
+$this->sPathBlue = "$tmpDir/{$this->sNameBlue}";
+$this->sSizeBlue = filesize($sSrcBlue);
+// Copy the file to the temp dir.
+@copy($sSrcBlue, $this->sPathBlue);
+}
+
+/**
      * @throws SetupException
      */
-    public function tearDown(): void
-    {
-        jaxon()->reset();
-        parent::tearDown();
-    }
+public function tearDown(): void
+{
+jaxon()->reset();
+parent::tearDown();
+}
 
-    /**
+/**
      * @throws RequestException
      */
-    public function testHttpUploadDisabled()
-    {
-        jaxon()->setOption('core.upload.enabled', false);
-        jaxon()->register(Jaxon::CALLABLE_CLASS, 'SampleUpload', __DIR__ . '/../src/sample.php');
-        jaxon()->di()->getBootstrap()->onBoot();
-
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertFalse(jaxon()->di()->getRequestHandler()->canProcessRequest());
-    }
-
-    /**
+public function testHttpUploadDisabled()
+{
+jaxon()->setOption('core.upload.enabled', false);
+jaxon()->register(Jaxon::CALLABLE_CLASS, 'SampleUpload', __DIR__ . '/../src/sample.php');
+jaxon()->di()->getBootstrap()->onBoot();
+
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertFalse(jaxon()->di()->getRequestHandler()->canProcessRequest());
+}
+
+/**
      * @throws RequestException
      */
-    public function testRequestWithNoPluginNoUpload()
-    {
-        jaxon()->setOption('core.upload.enabled', false);
-        jaxon()->register(Jaxon::CALLABLE_CLASS, 'SampleUpload', __DIR__ . '/../src/sample.php');
-        jaxon()->di()->getBootstrap()->onBoot();
-
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'who' => 'Nobody',
-                        'args' => [],
-                    ]),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertFalse(jaxon()->di()->getRequestHandler()->canProcessRequest());
-    }
-
-    /**
+public function testRequestWithNoPluginNoUpload()
+{
+jaxon()->setOption('core.upload.enabled', false);
+jaxon()->register(Jaxon::CALLABLE_CLASS, 'SampleUpload', __DIR__ . '/../src/sample.php');
+jaxon()->di()->getBootstrap()->onBoot();
+
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'who' => 'Nobody',
+            'args' => [],
+        ]),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertFalse(jaxon()->di()->getRequestHandler()->canProcessRequest());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadInMemoryStorage()
-    {
-        jaxon()->setOption('core.upload.enabled', true);
-        jaxon()->setOption('upload.default.storage', 'memory');
-        jaxon()->register(Jaxon::CALLABLE_CLASS, 'SampleUpload', __DIR__ . '/../src/sample.php');
-        jaxon()->di()->getBootstrap()->onBoot();
-
-        // In memory file system adapter
-        jaxon()->upload()->registerStorageAdapter('memory',
-            fn() => new InMemoryFilesystemAdapter());
-
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-    }
+public function testUploadInMemoryStorage()
+{
+jaxon()->setOption('core.upload.enabled', true);
+jaxon()->setOption('upload.default.storage', 'memory');
+jaxon()->register(Jaxon::CALLABLE_CLASS, 'SampleUpload', __DIR__ . '/../src/sample.php');
+jaxon()->di()->getBootstrap()->onBoot();
+
+// In memory file system adapter
+jaxon()->upload()->registerStorageAdapter('memory',
+fn() => new InMemoryFilesystemAdapter());
+
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+}
 }

jaxon-upload/tests/TestUpload/UploadTest.php

Switch Indentation +508 added lines, -508 removed lines

@@ -16,561 +16,561 @@
 
 class UploadTest extends TestCase
 {
-    /**
+/**
      * @var string
      */
-    protected $sNameWhite;
+protected $sNameWhite;
 
-    /**
+/**
      * @var string
      */
-    protected $sPathWhite;
+protected $sPathWhite;
 
-    /**
+/**
      * @var int
      */
-    protected $sSizeWhite;
+protected $sSizeWhite;
 
-    /**
+/**
      * @var string
      */
-    protected $sNameBlue;
+protected $sNameBlue;
 
-    /**
+/**
      * @var string
      */
-    protected $sPathBlue;
+protected $sPathBlue;
 
-    /**
+/**
      * @var int
      */
-    protected $sSizeBlue;
+protected $sSizeBlue;
 
-    /**
+/**
      * @throws SetupException
      */
-    public function setUp(): void
-    {
-        _register();
-        jaxon()->setOption('core.upload.enabled', true);
-
-        jaxon()->setOption('core.response.send', false);
-        $tmpDir = __DIR__ . '/../upload/tmp';
-        @mkdir($tmpDir);
-
-        $sSrcWhite = __DIR__ . '/../upload/src/white.png';
-        $this->sNameWhite = 'white.png';
-        $this->sPathWhite = "$tmpDir/{$this->sNameWhite}";
-        $this->sSizeWhite = filesize($sSrcWhite);
-        // Copy the file to the temp dir.
-        @copy($sSrcWhite, $this->sPathWhite);
-
-        $sSrcBlue = __DIR__ . '/../upload/src/blue.png';
-        $this->sNameBlue = 'blue.png';
-        $this->sPathBlue = "$tmpDir/{$this->sNameBlue}";
-        $this->sSizeBlue = filesize($sSrcBlue);
-        // Copy the file to the temp dir.
-        @copy($sSrcBlue, $this->sPathBlue);
-
-        jaxon()->register(Jaxon::CALLABLE_CLASS, 'SampleUpload', __DIR__ . '/../src/sample.php');
-        jaxon()->di()->getBootstrap()->onBoot();
-    }
-
-    /**
+public function setUp(): void
+{
+_register();
+jaxon()->setOption('core.upload.enabled', true);
+
+jaxon()->setOption('core.response.send', false);
+$tmpDir = __DIR__ . '/../upload/tmp';
+@mkdir($tmpDir);
+
+$sSrcWhite = __DIR__ . '/../upload/src/white.png';
+$this->sNameWhite = 'white.png';
+$this->sPathWhite = "$tmpDir/{$this->sNameWhite}";
+$this->sSizeWhite = filesize($sSrcWhite);
+// Copy the file to the temp dir.
+@copy($sSrcWhite, $this->sPathWhite);
+
+$sSrcBlue = __DIR__ . '/../upload/src/blue.png';
+$this->sNameBlue = 'blue.png';
+$this->sPathBlue = "$tmpDir/{$this->sNameBlue}";
+$this->sSizeBlue = filesize($sSrcBlue);
+// Copy the file to the temp dir.
+@copy($sSrcBlue, $this->sPathBlue);
+
+jaxon()->register(Jaxon::CALLABLE_CLASS, 'SampleUpload', __DIR__ . '/../src/sample.php');
+jaxon()->di()->getBootstrap()->onBoot();
+}
+
+/**
      * @throws SetupException
      */
-    public function tearDown(): void
-    {
-        jaxon()->reset();
-        parent::tearDown();
-    }
+public function tearDown(): void
+{
+jaxon()->reset();
+parent::tearDown();
+}
 
-    /**
+/**
      * @throws RequestException
      */
-    public function testAjaxUpload()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-    }
-
-    /**
+public function testAjaxUpload()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+}
+
+/**
      * @throws RequestException
      */
-    public function testAjaxUploadMultipleFiles()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => [
-                        new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                        new UploadedFile($this->sPathBlue, $this->sSizeBlue,
-                            UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
-                    ],
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(2, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-        $xFile = $aFiles['image'][1];
-        $this->assertEquals('blue', $xFile->name());
-        $this->assertEquals($this->sNameBlue, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-    }
-
-    /**
+public function testAjaxUploadMultipleFiles()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => [
+            new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+                UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+            new UploadedFile($this->sPathBlue, $this->sSizeBlue,
+                UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
+        ],
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(2, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+$xFile = $aFiles['image'][1];
+$this->assertEquals('blue', $xFile->name());
+$this->assertEquals($this->sNameBlue, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+}
+
+/**
      * @throws RequestException
      */
-    public function testAjaxUploadMultipleNames()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'white' => [
-                        new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                    ],
-                    'blue' => [
-                        new UploadedFile($this->sPathBlue, $this->sSizeBlue,
-                            UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
-                    ],
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(2, $aFiles);
-        $this->assertCount(1, $aFiles['white']);
-        $this->assertCount(1, $aFiles['blue']);
-        $xFile = $aFiles['white'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-        $xFile = $aFiles['blue'][0];
-        $this->assertEquals('blue', $xFile->name());
-        $this->assertEquals($this->sNameBlue, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-    }
-
-    /**
+public function testAjaxUploadMultipleNames()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'white' => [
+            new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+                UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+        ],
+        'blue' => [
+            new UploadedFile($this->sPathBlue, $this->sSizeBlue,
+                UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
+        ],
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(2, $aFiles);
+$this->assertCount(1, $aFiles['white']);
+$this->assertCount(1, $aFiles['blue']);
+$xFile = $aFiles['white'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+$xFile = $aFiles['blue'][0];
+$this->assertEquals('blue', $xFile->name());
+$this->assertEquals($this->sNameBlue, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+}
+
+/**
      * @throws RequestException
      */
-    public function testAjaxUploadNameSanitizer()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->upload()->sanitizer(function($sFilename, $sVarName) {
-            return $sVarName === 'image' ? 'img_' . $sFilename : $sFilename;
-        });
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('img_white', $xFile->name());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testAjaxUploadNameSanitizer()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->upload()->sanitizer(function($sFilename, $sVarName) {
+return $sVarName === 'image' ? 'img_' . $sFilename : $sFilename;
+});
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('img_white', $xFile->name());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileTypeValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.types', ['png']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileTypeValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.types', ['png']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileTypeValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.types', ['jpg']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileTypeValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.types', ['jpg']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileExtensionValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.extensions', ['png']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileExtensionValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.extensions', ['png']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileExtensionValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.extensions', ['jpg']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileExtensionValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.extensions', ['jpg']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMaxSizeValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.max-size', 30000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileMaxSizeValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.max-size', 30000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMaxSizeValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.max-size', 25000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileMaxSizeValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.max-size', 25000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMinSizeValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.min-size', 25000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileMinSizeValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.min-size', 25000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMinSizeValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.min-size', 30000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileMinSizeValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.min-size', 30000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      */
-    public function testRequestWithNoPluginNoUpload()
-    {
-        jaxon()->setOption('core.upload.enabled', false);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'who' => 'Nobody',
-                        'args' => [],
-                    ]),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertFalse(jaxon()->di()->getRequestHandler()->canProcessRequest());
-    }
+public function testRequestWithNoPluginNoUpload()
+{
+jaxon()->setOption('core.upload.enabled', false);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'who' => 'Nobody',
+            'args' => [],
+        ]),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertFalse(jaxon()->di()->getRequestHandler()->canProcessRequest());
+}
 }