jaxon-php / jaxon-mono

jaxon-core/src/Response/AbstractResponse.php

Switch Indentation +58 added lines, -58 removed lines

@@ -30,68 +30,68 @@ 
 
 abstract class AbstractResponse
 {
-    /**
+/**
      * @var ResponseManager
      */
-    protected $xManager;
+protected $xManager;
 
-    /**
+/**
      * @var PluginManager
      */
-    protected $xPluginManager;
+protected $xPluginManager;
 
-    /**
+/**
      * The constructor
      *
      * @param ResponseManager $xManager
      * @param PluginManager $xPluginManager
      */
-    public function __construct(ResponseManager $xManager, PluginManager $xPluginManager)
-    {
-        $this->xManager = $xManager;
-        $this->xPluginManager = $xPluginManager;
-    }
+public function __construct(ResponseManager $xManager, PluginManager $xPluginManager)
+{
+$this->xManager = $xManager;
+$this->xPluginManager = $xPluginManager;
+}
 
-    /**
+/**
      * @inheritDoc
      */
-    abstract public function getContentType(): string;
+abstract public function getContentType(): string;
 
-    /**
+/**
      * @inheritDoc
      */
-    abstract public function getOutput(): string;
+abstract public function getOutput(): string;
 
-    /**
+/**
      * Convert this response to a PSR7 response object
      *
      * @return PsrResponseInterface
      */
-    abstract public function toPsr(): PsrResponseInterface;
+abstract public function toPsr(): PsrResponseInterface;
 
-    /**
+/**
      * Convert to string
      *
      * @param mixed $xData
      *
      * @return string
      */
-    protected function str($xData): string
-    {
-        return $this->xManager->str($xData);
-    }
+protected function str($xData): string
+{
+return $this->xManager->str($xData);
+}
 
-    /**
+/**
      * Get the error message
      *
      * @return string
      */
-    public function getErrorMessage(): string
-    {
-        return $this->xManager->getErrorMessage();
-    }
+public function getErrorMessage(): string
+{
+return $this->xManager->getErrorMessage();
+}
 
-     /**
+/**
      * Add a response command to the array of commands
      *
      * @param string $sName    The command name
@@ -100,43 +100,43 @@ 
      *
      * @return Command
      */
-    public function addCommand(string $sName, array|JsonSerializable $aArgs = [],
-        bool $bRemoveEmpty = false): Command
-    {
-        return $this->xManager->addCommand($sName, $aArgs, $bRemoveEmpty);
-    }
+public function addCommand(string $sName, array|JsonSerializable $aArgs = [],
+bool $bRemoveEmpty = false): Command
+{
+return $this->xManager->addCommand($sName, $aArgs, $bRemoveEmpty);
+}
 
-    /**
+/**
      * Get the commands in the response
      *
      * @return array
      */
-    public function getCommands(): array
-    {
-        return $this->xManager->getCommands();
-    }
+public function getCommands(): array
+{
+return $this->xManager->getCommands();
+}
 
-    /**
+/**
      * Get the number of commands in the response
      *
      * @return int
      */
-    public function getCommandCount(): int
-    {
-        return $this->xManager->getCommandCount();
-    }
+public function getCommandCount(): int
+{
+return $this->xManager->getCommandCount();
+}
 
-    /**
+/**
      * Clear all the commands already added to the response
      *
      * @return void
      */
-    public function clearCommands(): void
-    {
-        $this->xManager->clearCommands();
-    }
+public function clearCommands(): void
+{
+$this->xManager->clearCommands();
+}
 
-    /**
+/**
      * Find a response plugin by name or class name
      *
      * @template R of ResponsePluginInterface
@@ -144,13 +144,13 @@ 
      *
      * @return ($sName is class-string ? R|null : ResponsePluginInterface|null)
      */
-    public function plugin(string $sName): ?ResponsePluginInterface
-    {
-        $xResponsePlugin = $this->xPluginManager->getResponsePlugin($sName);
-        return !$xResponsePlugin ? null : $xResponsePlugin->initPlugin($this);
-    }
+public function plugin(string $sName): ?ResponsePluginInterface
+{
+$xResponsePlugin = $this->xPluginManager->getResponsePlugin($sName);
+return !$xResponsePlugin ? null : $xResponsePlugin->initPlugin($this);
+}
 
-    /**
+/**
      * Magic PHP function
      *
      * Used to permit plugins to be called as if they were native members of the Response instance.
@@ -159,8 +159,8 @@ 
      *
      * @return null|ResponsePluginInterface
      */
-    public function __get(string $sPluginName)
-    {
-        return $this->plugin($sPluginName);
-    }
+public function __get(string $sPluginName)
+{
+return $this->plugin($sPluginName);
+}
 }

jaxon-core/src/Response/Response.php

Switch Indentation +169 added lines, -169 removed lines

@@ -26,7 +26,7 @@ 
 
 class Response extends AjaxResponse
 {
-    /**
+/**
      * Add a command to assign the specified value to the given element's attribute
      *
      * @param string $sTarget    The id of the html element on the browser
@@ -35,17 +35,17 @@ 
      *
      * @return self
      */
-    public function assign(string $sTarget, string $sAttribute, string $sValue): self
-    {
-        $this->xManager->addCommand('node.assign', [
-            'id' => $this->str($sTarget),
-            'attr' => $this->str($sAttribute),
-            'value' => $this->str($sValue),
-        ]);
-        return $this;
-    }
+public function assign(string $sTarget, string $sAttribute, string $sValue): self
+{
+$this->xManager->addCommand('node.assign', [
+'id' => $this->str($sTarget),
+'attr' => $this->str($sAttribute),
+'value' => $this->str($sValue),
+]);
+return $this;
+}
 
-    /**
+/**
      * Add a command to assign the specified HTML content to the given element
      *
      * This is a shortcut for assign() on the innerHTML attribute.
@@ -55,12 +55,12 @@ 
      *
      * @return self
      */
-    public function html(string $sTarget, string $sValue): self
-    {
-        return $this->assign($sTarget, 'innerHTML', $sValue);
-    }
+public function html(string $sTarget, string $sValue): self
+{
+return $this->assign($sTarget, 'innerHTML', $sValue);
+}
 
-    /**
+/**
      * Add a command to assign the specified value to the given CSS attribute
      *
      * @param string $sTarget    The id of the html element on the browser
@@ -69,12 +69,12 @@ 
      *
      * @return self
      */
-    public function style(string $sTarget, string $sCssAttribute, string $sValue): self
-    {
-        return $this->assign($sTarget, "style.$sCssAttribute", $sValue);
-    }
+public function style(string $sTarget, string $sCssAttribute, string $sValue): self
+{
+return $this->assign($sTarget, "style.$sCssAttribute", $sValue);
+}
 
-    /**
+/**
      * Add a command to append the specified data to the given element's attribute
      *
      * @param string $sTarget    The id of the element to be updated
@@ -83,17 +83,17 @@ 
      *
      * @return self
      */
-    public function append(string $sTarget, string $sAttribute, string $sValue): self
-    {
-        $this->xManager->addCommand('node.append', [
-            'id' => $this->str($sTarget),
-            'attr' => $this->str($sAttribute),
-            'value' => $this->str($sValue),
-        ]);
-        return $this;
-    }
+public function append(string $sTarget, string $sAttribute, string $sValue): self
+{
+$this->xManager->addCommand('node.append', [
+'id' => $this->str($sTarget),
+'attr' => $this->str($sAttribute),
+'value' => $this->str($sValue),
+]);
+return $this;
+}
 
-    /**
+/**
      * Add a command to prepend the specified data to the given element's attribute
      *
      * @param string $sTarget    The id of the element to be updated
@@ -102,17 +102,17 @@ 
      *
      * @return self
      */
-    public function prepend(string $sTarget, string $sAttribute, string $sValue): self
-    {
-        $this->xManager->addCommand('node.prepend', [
-            'id' => $this->str($sTarget),
-            'attr' => $this->str($sAttribute),
-            'value' => $this->str($sValue),
-        ]);
-        return $this;
-    }
+public function prepend(string $sTarget, string $sAttribute, string $sValue): self
+{
+$this->xManager->addCommand('node.prepend', [
+'id' => $this->str($sTarget),
+'attr' => $this->str($sAttribute),
+'value' => $this->str($sValue),
+]);
+return $this;
+}
 
-    /**
+/**
      * Add a command to replace a specified value with another value within the given element's attribute
      *
      * @param string $sTarget    The id of the element to update
@@ -122,19 +122,19 @@ 
      *
      * @return self
      */
-    public function replace(string $sTarget, string $sAttribute,
-        string $sSearch, string $sReplace): self
-    {
-        $this->xManager->addCommand('node.replace', [
-            'id' => $this->str($sTarget),
-            'attr' => $this->str($sAttribute),
-            'search' => $this->str($sSearch),
-            'replace' => $this->str($sReplace),
-        ]);
-        return $this;
-    }
+public function replace(string $sTarget, string $sAttribute,
+string $sSearch, string $sReplace): self
+{
+$this->xManager->addCommand('node.replace', [
+'id' => $this->str($sTarget),
+'attr' => $this->str($sAttribute),
+'search' => $this->str($sSearch),
+'replace' => $this->str($sReplace),
+]);
+return $this;
+}
 
-    /**
+/**
      * Add a command to clear the specified attribute of the given element
      *
      * @param string $sTarget    The id of the element to be updated.
@@ -142,31 +142,31 @@ 
      *
      * @return self
      */
-    public function clear(string $sTarget, string $sAttribute = 'innerHTML'): self
-    {
-        $this->xManager->addCommand('node.clear', [
-            'id' => $this->str($sTarget),
-            'attr' => $this->str($sAttribute),
-        ]);
-        return $this;
-    }
+public function clear(string $sTarget, string $sAttribute = 'innerHTML'): self
+{
+$this->xManager->addCommand('node.clear', [
+'id' => $this->str($sTarget),
+'attr' => $this->str($sAttribute),
+]);
+return $this;
+}
 
-    /**
+/**
      * Add a command to remove an element from the document
      *
      * @param string $sTarget    The id of the element to be removed
      *
      * @return self
      */
-    public function remove(string $sTarget): self
-    {
-        $this->xManager->addCommand('node.remove', [
-            'id' => $this->str($sTarget),
-        ]);
-        return $this;
-    }
+public function remove(string $sTarget): self
+{
+$this->xManager->addCommand('node.remove', [
+'id' => $this->str($sTarget),
+]);
+return $this;
+}
 
-    /**
+/**
      * Add a command to bind an element to a component
      *
      * @param string $sTarget   The id of the element
@@ -175,21 +175,21 @@ 
      *
      * @return self
      */
-    public function bind(string $sTarget, JxnCall $xCall, string $sItem = ''): self
-    {
-        $this->xManager->addCommand('node.bind', [
-            'id' => $this->str($sTarget),
-            'component' => !$sItem ? [
-                'name' => $xCall->_class(),
-            ] : [
-                'name' => $xCall->_class(),
-                'item' => $this->str($sItem),
-            ],
-        ]);
-        return $this;
-    }
+public function bind(string $sTarget, JxnCall $xCall, string $sItem = ''): self
+{
+$this->xManager->addCommand('node.bind', [
+'id' => $this->str($sTarget),
+'component' => !$sItem ? [
+    'name' => $xCall->_class(),
+] : [
+    'name' => $xCall->_class(),
+    'item' => $this->str($sItem),
+],
+]);
+return $this;
+}
 
-    /**
+/**
      * Add a command to create a new element on the browser
      * @deprecated DOM element creation functions are deprecated
      *
@@ -199,19 +199,19 @@ 
      *
      * @return self
      */
-    public function create(string $sParent, string $sTag, string $sId): self
-    {
-        $this->xManager->addCommand('node.create', [
-            'id' => $this->str($sParent),
-            'tag' => [
-                'name' => $this->str($sTag),
-                'id' => $this->str($sId),
-            ],
-        ]);
-        return $this;
-    }
+public function create(string $sParent, string $sTag, string $sId): self
+{
+$this->xManager->addCommand('node.create', [
+'id' => $this->str($sParent),
+'tag' => [
+    'name' => $this->str($sTag),
+    'id' => $this->str($sId),
+],
+]);
+return $this;
+}
 
-    /**
+/**
      * Add a command to insert a new element just prior to the specified element
      * @deprecated DOM element creation functions are deprecated
      *
@@ -221,19 +221,19 @@ 
      *
      * @return self
      */
-    public function insertBefore(string $sBefore, string $sTag, string $sId): self
-    {
-        $this->xManager->addCommand('node.insert.before', [
-            'id' => $this->str($sBefore),
-            'tag' => [
-                'name' => $this->str($sTag),
-                'id' => $this->str($sId),
-            ],
-        ]);
-        return $this;
-    }
+public function insertBefore(string $sBefore, string $sTag, string $sId): self
+{
+$this->xManager->addCommand('node.insert.before', [
+'id' => $this->str($sBefore),
+'tag' => [
+    'name' => $this->str($sTag),
+    'id' => $this->str($sId),
+],
+]);
+return $this;
+}
 
-    /**
+/**
      * Add a command to insert a new element just prior to the specified element
      * This is an alias for insertBefore.
      * @deprecated DOM element creation functions are deprecated
@@ -244,12 +244,12 @@ 
      *
      * @return self
      */
-    public function insert(string $sBefore, string $sTag, string $sId): self
-    {
-        return $this->insertBefore($sBefore, $sTag, $sId);
-    }
+public function insert(string $sBefore, string $sTag, string $sId): self
+{
+return $this->insertBefore($sBefore, $sTag, $sId);
+}
 
-    /**
+/**
      * Add a command to insert a new element after the specified
      * @deprecated DOM element creation functions are deprecated
      *
@@ -259,19 +259,19 @@ 
      *
      * @return self
      */
-    public function insertAfter(string $sAfter, string $sTag, string $sId): self
-    {
-        $this->xManager->addCommand('node.insert.after', [
-            'id' => $this->str($sAfter),
-            'tag' => [
-                'name' => $this->str($sTag),
-                'id' => $this->str($sId),
-            ],
-        ]);
-        return $this;
-    }
+public function insertAfter(string $sAfter, string $sTag, string $sId): self
+{
+$this->xManager->addCommand('node.insert.after', [
+'id' => $this->str($sAfter),
+'tag' => [
+    'name' => $this->str($sTag),
+    'id' => $this->str($sId),
+],
+]);
+return $this;
+}
 
-    /**
+/**
      * Add a command to set an event handler on the specified element
      * This handler can take custom parameters, and is is executed in a specific context.
      * @deprecated Event handler functions are deprecated
@@ -282,17 +282,17 @@ 
      *
      * @return self
      */
-    public function setEventHandler(string $sTarget, string $sEvent, JsExpr $xCall): self
-    {
-        $this->xManager->addCommand('handler.event.set', [
-            'id' => $this->str($sTarget),
-            'event' => $this->str($sEvent),
-            'func' => $xCall,
-        ]);
-        return $this;
-    }
+public function setEventHandler(string $sTarget, string $sEvent, JsExpr $xCall): self
+{
+$this->xManager->addCommand('handler.event.set', [
+'id' => $this->str($sTarget),
+'event' => $this->str($sEvent),
+'func' => $xCall,
+]);
+return $this;
+}
 
-    /**
+/**
      * Add a command to set a click handler on the browser
      * @deprecated Event handler functions are deprecated
      *
@@ -301,12 +301,12 @@ 
      *
      * @return self
      */
-    public function onClick(string $sTarget, JsExpr $xCall): self
-    {
-        return $this->setEventHandler($sTarget, 'onclick', $xCall);
-    }
+public function onClick(string $sTarget, JsExpr $xCall): self
+{
+return $this->setEventHandler($sTarget, 'onclick', $xCall);
+}
 
-    /**
+/**
      * Add a command to add an event handler on the specified element
      * This handler can take custom parameters, and is is executed in a specific context.
      * @deprecated Event handler functions are deprecated
@@ -317,17 +317,17 @@ 
      *
      * @return self
      */
-    public function addEventHandler(string $sTarget, string $sEvent, JsExpr $xCall): self
-    {
-        $this->xManager->addCommand('handler.event.add', [
-            'id' => $this->str($sTarget),
-            'event' => $this->str($sEvent),
-            'func' => $xCall,
-        ]);
-        return $this;
-    }
+public function addEventHandler(string $sTarget, string $sEvent, JsExpr $xCall): self
+{
+$this->xManager->addCommand('handler.event.add', [
+'id' => $this->str($sTarget),
+'event' => $this->str($sEvent),
+'func' => $xCall,
+]);
+return $this;
+}
 
-    /**
+/**
      * Add a command to install an event handler on the specified element
      * You can add more than one event handler to an element's event using this method.
      * @deprecated Event handler functions are deprecated
@@ -338,17 +338,17 @@ 
      *
      * @return self
      */
-    public function addHandler(string $sTarget, string $sEvent, string $sHandler): self
-    {
-        $this->xManager->addCommand('handler.add', [
-            'id' => $this->str($sTarget),
-            'event' => $this->str($sEvent),
-            'func' => $this->str($sHandler),
-        ]);
-        return $this;
-    }
+public function addHandler(string $sTarget, string $sEvent, string $sHandler): self
+{
+$this->xManager->addCommand('handler.add', [
+'id' => $this->str($sTarget),
+'event' => $this->str($sEvent),
+'func' => $this->str($sHandler),
+]);
+return $this;
+}
 
-    /**
+/**
      * Add a command to remove an event handler from an element
      * @deprecated Event handler functions are deprecated
      *
@@ -358,13 +358,13 @@ 
      *
      * @return self
      */
-    public function removeHandler(string $sTarget, string $sEvent, string $sHandler): self
-    {
-        $this->xManager->addCommand('handler.remove', [
-            'id' => $this->str($sTarget),
-            'event' => $this->str($sEvent),
-            'func' => $this->str($sHandler),
-        ]);
-        return $this;
-    }
+public function removeHandler(string $sTarget, string $sEvent, string $sHandler): self
+{
+$this->xManager->addCommand('handler.remove', [
+'id' => $this->str($sTarget),
+'event' => $this->str($sEvent),
+'func' => $this->str($sHandler),
+]);
+return $this;
+}
 }

jaxon-core/src/Plugin/AbstractResponsePlugin.php

Switch Indentation +4 added lines, -4 removed lines

@@ -27,13 +27,13 @@
 
 abstract class AbstractResponsePlugin extends AbstractPlugin implements ResponsePluginInterface
 {
-    use ResponsePluginTrait;
+use ResponsePluginTrait;
 
-    /**
+/**
      * Initialize the plugin
      *
      * @return void
      */
-    protected function init(): void
-    {}
+protected function init(): void
+{}
 }

jaxon-core/src/Plugin/PluginInterface.php

Switch Indentation +2 added lines, -2 removed lines

@@ -4,10 +4,10 @@
 
 interface PluginInterface
 {
-    /**
+/**
      * Get a unique name to identify the plugin.
      *
      * @return string
      */
-    public function getName(): string;
+public function getName(): string;
 }

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

Switch Indentation +140 added lines, -140 removed lines

@@ -26,144 +26,144 @@ 
 
 class CallbackManager
 {
-    /**
+/**
      * The callbacks to run after booting the library
      *
      * @var callable[]
      */
-    protected $aBootCallbacks = [];
+protected $aBootCallbacks = [];
 
-    /**
+/**
      * The callbacks to run before processing the request
      *
      * @var callable[]
      */
-    protected $aBeforeCallbacks = [];
+protected $aBeforeCallbacks = [];
 
-    /**
+/**
      * The callbacks to run after processing the request
      *
      * @var callable[]
      */
-    protected $aAfterCallbacks = [];
+protected $aAfterCallbacks = [];
 
-    /**
+/**
      * The callbacks to run in case of invalid request
      *
      * @var callable[]
      */
-    protected $aInvalidCallbacks = [];
+protected $aInvalidCallbacks = [];
 
-    /**
+/**
      * The callbacks to run in case of error
      *
      * @var callable[]
      */
-    protected $aErrorCallbacks = [];
+protected $aErrorCallbacks = [];
 
-    /**
+/**
      * The callbacks to run in case of exception
      *
      * @var callable[][]
      */
-    protected $aExceptionCallbacks = [];
+protected $aExceptionCallbacks = [];
 
-    /**
+/**
      * The callbacks to run when a class is instanced
      *
      * @var callable[]
      */
-    protected $aInitCallbacks = [];
+protected $aInitCallbacks = [];
 
-    /**
+/**
      * Get the library booting callbacks, and reset the array.
      *
      * @return callable[]
      */
-    public function popBootCallbacks(): array
-    {
-        if(empty($this->aBootCallbacks))
-        {
-            return [];
-        }
-        $aCallbacks = $this->aBootCallbacks;
-        $this->aBootCallbacks = [];
-        return $aCallbacks;
-    }
+public function popBootCallbacks(): array
+{
+if(empty($this->aBootCallbacks))
+{
+return [];
+}
+$aCallbacks = $this->aBootCallbacks;
+$this->aBootCallbacks = [];
+return $aCallbacks;
+}
 
-    /**
+/**
      * Get the exception callbacks.
      *
      * @param Exception $xException      The exception class
      *
      * @return callable[]
      */
-    private function getExceptionCallbacks(Exception $xException): array
-    {
-        $aExceptionCallbacks = [];
-        foreach($this->aExceptionCallbacks as $sExClass => $aCallbacks)
-        {
-            if(is_a($xException, $sExClass))
-            {
-                $aExceptionCallbacks = array_merge($aExceptionCallbacks, $aCallbacks);
-            }
-        }
-        return array_values($aExceptionCallbacks);
-    }
+private function getExceptionCallbacks(Exception $xException): array
+{
+$aExceptionCallbacks = [];
+foreach($this->aExceptionCallbacks as $sExClass => $aCallbacks)
+{
+if(is_a($xException, $sExClass))
+{
+    $aExceptionCallbacks = array_merge($aExceptionCallbacks, $aCallbacks);
+}
+}
+return array_values($aExceptionCallbacks);
+}
 
-    /**
+/**
      * Add a library booting callback.
      *
      * @param callable $xCallable    The callback function
      *
      * @return CallbackManager
      */
-    public function boot(callable $xCallable): CallbackManager
-    {
-        $this->aBootCallbacks[] = $xCallable;
-        return $this;
-    }
+public function boot(callable $xCallable): CallbackManager
+{
+$this->aBootCallbacks[] = $xCallable;
+return $this;
+}
 
-    /**
+/**
      * Add a pre-request processing callback.
      *
      * @param callable $xCallable    The callback function
      *
      * @return CallbackManager
      */
-    public function before(callable $xCallable): CallbackManager
-    {
-        $this->aBeforeCallbacks[] = $xCallable;
-        return $this;
-    }
+public function before(callable $xCallable): CallbackManager
+{
+$this->aBeforeCallbacks[] = $xCallable;
+return $this;
+}
 
-    /**
+/**
      * Add a post-request processing callback.
      *
      * @param callable $xCallable    The callback function
      *
      * @return CallbackManager
      */
-    public function after(callable $xCallable): CallbackManager
-    {
-        $this->aAfterCallbacks[] = $xCallable;
-        return $this;
-    }
+public function after(callable $xCallable): CallbackManager
+{
+$this->aAfterCallbacks[] = $xCallable;
+return $this;
+}
 
-    /**
+/**
      * Add a invalid request callback.
      *
      * @param callable $xCallable    The callback function
      *
      * @return CallbackManager
      */
-    public function invalid(callable $xCallable): CallbackManager
-    {
-        $this->aInvalidCallbacks[] = $xCallable;
-        return $this;
-    }
+public function invalid(callable $xCallable): CallbackManager
+{
+$this->aInvalidCallbacks[] = $xCallable;
+return $this;
+}
 
-    /**
+/**
      * Add a processing error callback.
      *
      * @param callable $xCallable   The callback function
@@ -171,74 +171,74 @@ 
      *
      * @return CallbackManager
      */
-    public function error(callable $xCallable, string $sExClass = ''): CallbackManager
-    {
-        if($sExClass === '' || $sExClass === Exception::class)
-        {
-            $this->aErrorCallbacks[] = $xCallable;
-            return $this;
-        }
-        // Callback for a given exception class
-        if(isset($this->aExceptionCallbacks[$sExClass]))
-        {
-            $this->aExceptionCallbacks[$sExClass][] = $xCallable;
-            return $this;
-        }
-        $this->aExceptionCallbacks[$sExClass] = [$xCallable];
-        return $this;
-    }
+public function error(callable $xCallable, string $sExClass = ''): CallbackManager
+{
+if($sExClass === '' || $sExClass === Exception::class)
+{
+$this->aErrorCallbacks[] = $xCallable;
+return $this;
+}
+// Callback for a given exception class
+if(isset($this->aExceptionCallbacks[$sExClass]))
+{
+$this->aExceptionCallbacks[$sExClass][] = $xCallable;
+return $this;
+}
+$this->aExceptionCallbacks[$sExClass] = [$xCallable];
+return $this;
+}
 
-    /**
+/**
      * Add a class initialisation callback.
      *
      * @param callable $xCallable    The callback function
      *
      * @return CallbackManager
      */
-    public function init(callable $xCallable): CallbackManager
-    {
-        $this->aInitCallbacks[] = $xCallable;
-        return $this;
-    }
+public function init(callable $xCallable): CallbackManager
+{
+$this->aInitCallbacks[] = $xCallable;
+return $this;
+}
 
-    /**
+/**
      * @param callable $xCallback
      * @param array $aParameters
      *
      * @return void
      */
-    private function executeCallback(callable $xCallback, array $aParameters): void
-    {
-        call_user_func_array($xCallback, $aParameters);
-    }
+private function executeCallback(callable $xCallback, array $aParameters): void
+{
+call_user_func_array($xCallback, $aParameters);
+}
 
-    /**
+/**
      * @param array $aCallbacks
      * @param array $aParameters
      *
      * @return void
      */
-    private function executeCallbacks(array $aCallbacks, array $aParameters): void
-    {
-        foreach($aCallbacks as $xCallback)
-        {
-            $this->executeCallback($xCallback, $aParameters);
-        }
-    }
+private function executeCallbacks(array $aCallbacks, array $aParameters): void
+{
+foreach($aCallbacks as $xCallback)
+{
+$this->executeCallback($xCallback, $aParameters);
+}
+}
 
-    /**
+/**
      * Execute the class initialisation callbacks.
      *
      * @param mixed $xComponent
      *
      * @return void
      */
-    public function onInit($xComponent): void
-    {
-        $this->executeCallbacks($this->aInitCallbacks, [$xComponent]);
-    }
+public function onInit($xComponent): void
+{
+$this->executeCallbacks($this->aInitCallbacks, [$xComponent]);
+}
 
-    /**
+/**
      * These are the pre-request processing callbacks passed to the Jaxon library.
      *
      * @param Target $xTarget
@@ -247,20 +247,20 @@ 
      * @return void
      * @throws RequestException
      */
-    public function onBefore(Target $xTarget, bool &$bEndRequest): void
-    {
-        // Call the user defined callback
-        foreach($this->aBeforeCallbacks as $xCallback)
-        {
-            $this->executeCallback($xCallback, [$xTarget, &$bEndRequest]);
-            if($bEndRequest)
-            {
-                return;
-            }
-        }
-    }
+public function onBefore(Target $xTarget, bool &$bEndRequest): void
+{
+// Call the user defined callback
+foreach($this->aBeforeCallbacks as $xCallback)
+{
+$this->executeCallback($xCallback, [$xTarget, &$bEndRequest]);
+if($bEndRequest)
+{
+    return;
+}
+}
+}
 
-    /**
+/**
      * These are the post-request processing callbacks passed to the Jaxon library.
      *
      * @param Target $xTarget
@@ -269,12 +269,12 @@ 
      * @return void
      * @throws RequestException
      */
-    public function onAfter(Target $xTarget, bool $bEndRequest): void
-    {
-        $this->executeCallbacks($this->aAfterCallbacks, [$xTarget, $bEndRequest]);
-    }
+public function onAfter(Target $xTarget, bool $bEndRequest): void
+{
+$this->executeCallbacks($this->aAfterCallbacks, [$xTarget, $bEndRequest]);
+}
 
-    /**
+/**
      * These callbacks are called whenever an invalid request is processed.
      *
      * @param RequestException $xException
@@ -282,13 +282,13 @@ 
      * @return void
      * @throws RequestException
      */
-    public function onInvalid(RequestException $xException): void
-    {
-        $this->executeCallbacks($this->aInvalidCallbacks, [$xException]);
-        throw $xException;
-    }
+public function onInvalid(RequestException $xException): void
+{
+$this->executeCallbacks($this->aInvalidCallbacks, [$xException]);
+throw $xException;
+}
 
-    /**
+/**
      * These callbacks are called whenever an invalid request is processed.
      *
      * @param Exception $xException
@@ -296,17 +296,17 @@ 
      * @return void
      * @throws Exception
      */
-    public function onError(Exception $xException): void
-    {
-        $aExceptionCallbacks = $this->getExceptionCallbacks($xException);
-        $this->executeCallbacks($aExceptionCallbacks, [$xException]);
-        if(count($aExceptionCallbacks) > 0)
-        {
-            // Do not throw the exception if a custom handler is defined
-            return;
-        }
+public function onError(Exception $xException): void
+{
+$aExceptionCallbacks = $this->getExceptionCallbacks($xException);
+$this->executeCallbacks($aExceptionCallbacks, [$xException]);
+if(count($aExceptionCallbacks) > 0)
+{
+// Do not throw the exception if a custom handler is defined
+return;
+}
 
-        $this->executeCallbacks($this->aErrorCallbacks, [$xException]);
-        throw $xException;
-    }
+$this->executeCallbacks($this->aErrorCallbacks, [$xException]);
+throw $xException;
+}
 }

jaxon-core/src/Script/ParameterFactory.php

Switch Indentation +45 added lines, -45 removed lines

@@ -19,109 +19,109 @@
 
 class ParameterFactory
 {
-    /**
+/**
      * Make a parameter of type form values
      *
      * @param string $sFormId    The id of the HTML form
      *
      * @return array
      */
-    public function form(string $sFormId): array
-    {
-        return (new HtmlReader($sFormId))->form();
-    }
+public function form(string $sFormId): array
+{
+return (new HtmlReader($sFormId))->form();
+}
 
-    /**
+/**
      * Make a parameter of type input value
      *
      * @param string $sInputId    the id of the HTML input element
      *
      * @return TypedValue
      */
-    public function input(string $sInputId): TypedValue
-    {
-        return (new HtmlReader($sInputId))->input();
-    }
+public function input(string $sInputId): TypedValue
+{
+return (new HtmlReader($sInputId))->input();
+}
 
-    /**
+/**
      * Make a parameter of type checked value
      *
      * @param string $sInputId    the name of the HTML form element
      *
      * @return array
      */
-    public function checked(string $sInputId): array
-    {
-        return (new HtmlReader($sInputId))->checked();
-    }
+public function checked(string $sInputId): array
+{
+return (new HtmlReader($sInputId))->checked();
+}
 
-    /**
+/**
      * Make a parameter of type select
      *
      * @param string $sInputId    the name of the HTML form element
      *
      * @return TypedValue
      */
-    public function select(string $sInputId): TypedValue
-    {
-        return $this->input($sInputId);
-    }
+public function select(string $sInputId): TypedValue
+{
+return $this->input($sInputId);
+}
 
-    /**
+/**
      * Make a parameter of type inner html
      *
      * @param string $sElementId    the id of the HTML element
      *
      * @return TypedValue
      */
-    public function html(string $sElementId): TypedValue
-    {
-        return (new HtmlReader($sElementId))->html();
-    }
+public function html(string $sElementId): TypedValue
+{
+return (new HtmlReader($sElementId))->html();
+}
 
-    /**
+/**
      * Make a parameter of type quoted string
      *
      * @param string $sValue    the value of the parameter
      *
      * @return TypedValue
      */
-    public function string(string $sValue): TypedValue
-    {
-        return TypedValue::make($sValue);
-    }
+public function string(string $sValue): TypedValue
+{
+return TypedValue::make($sValue);
+}
 
-    /**
+/**
      * Make a parameter of type numeric
      *
      * @param int $nValue    the value of the parameter
      *
      * @return TypedValue
      */
-    public function numeric(int $nValue): TypedValue
-    {
-        return TypedValue::make($nValue);
-    }
+public function numeric(int $nValue): TypedValue
+{
+return TypedValue::make($nValue);
+}
 
-    /**
+/**
      * Make a parameter of type numeric
      *
      * @param int $nValue    the value of the parameter
      *
      * @return TypedValue
      */
-    public function int(int $nValue): TypedValue
-    {
-        return $this->numeric($nValue);
-    }
+public function int(int $nValue): TypedValue
+{
+return $this->numeric($nValue);
+}
 
-    /**
+/**
      * Make a parameter of type page number
      *
      * @return TypedValue
      */
-    public function page(): TypedValue
-    {
-        return TypedValue::page();
-    }
+public function page(): TypedValue
+{
+return TypedValue::page();
+}
 }

jaxon-core/src/Script/JsExpr.php

Switch Indentation +206 added lines, -206 removed lines

@@ -29,77 +29,77 @@ 
 
 class JsExpr extends TypedValue implements Stringable
 {
-    /**
+/**
      * The actions to be applied on the selected element
      *
      * @var array
      */
-    protected $aCalls = [];
+protected $aCalls = [];
 
-    /**
+/**
      * The arguments of the else() calls
      *
      * @var array
      */
-    protected $aAlert = [];
+protected $aAlert = [];
 
-    /**
+/**
      * A condition to check before making the call
      *
      * @var array
      */
-    protected $aCondition = [];
+protected $aCondition = [];
 
-    /**
+/**
      * The arguments of the confirm() call
      *
      * @var array
      */
-    protected $aConfirm = [];
+protected $aConfirm = [];
 
-    /**
+/**
      * @var DialogCommand
      */
-    private static DialogCommand $xDialogCommand;
+private static DialogCommand $xDialogCommand;
 
-    /**
+/**
      * The constructor
      */
-    public function __construct(...$aCalls)
-    {
-        $this->aCalls = $aCalls;
-    }
+public function __construct(...$aCalls)
+{
+$this->aCalls = $aCalls;
+}
 
-    /**
+/**
      * Set the dialog command
      *
      * @param DialogCommand $xDialogCommand
      *
      * @return void
      */
-    public static function setDialogCommand(DialogCommand $xDialogCommand): void
-    {
-        self::$xDialogCommand = $xDialogCommand;
-    }
+public static function setDialogCommand(DialogCommand $xDialogCommand): void
+{
+self::$xDialogCommand = $xDialogCommand;
+}
 
-    /**
+/**
      * Get the first function in the calls
      *
      * @return Func|null
      */
-    public function func(): ?Func
-    {
-        foreach($this->aCalls as $xCall)
-        {
-            if(is_a($xCall, Func::class))
-            {
-                return $xCall;
-            }
-        }
-        return null;
-    }
-
-    /**
+public function func(): ?Func
+{
+foreach($this->aCalls as $xCall)
+{
+if(is_a($xCall, Func::class))
+{
+    return $xCall;
+}
+}
+return null;
+}
+
+/**
      * Add a call to a js function on the current object
      *
      * @param string  $sMethod
@@ -107,28 +107,28 @@ 
      *
      * @return self
      */
-    public function __call(string $sMethod, array $aArguments): self
-    {
-        // Append the action into the array
-        $this->aCalls[] = new Func($sMethod, $aArguments);
-        return $this;
-    }
+public function __call(string $sMethod, array $aArguments): self
+{
+// Append the action into the array
+$this->aCalls[] = new Func($sMethod, $aArguments);
+return $this;
+}
 
-    /**
+/**
      * Get the value of an attribute of the current object
      *
      * @param string  $sAttribute
      *
      * @return self
      */
-    public function __get(string $sAttribute): self
-    {
-        // Append the action into the array
-        $this->aCalls[] = Attr::get($sAttribute);
-        return $this;
-    }
+public function __get(string $sAttribute): self
+{
+// Append the action into the array
+$this->aCalls[] = Attr::get($sAttribute);
+return $this;
+}
 
-    /**
+/**
      * Set the value of an attribute of the current object
      *
      * @param string $sAttribute
@@ -136,14 +136,14 @@ 
      *
      * @return void
      */
-    public function __set(string $sAttribute, $xValue)
-    {
-        // Append the action into the array
-        $this->aCalls[] = Attr::set($sAttribute, $xValue);
-        return $this;
-    }
+public function __set(string $sAttribute, $xValue)
+{
+// Append the action into the array
+$this->aCalls[] = Attr::set($sAttribute, $xValue);
+return $this;
+}
 
-    /**
+/**
      * Set an event handler on the selected elements
      *
      * @param string $sMode    The event mode: 'jq' or 'js'
@@ -152,13 +152,13 @@ 
      *
      * @return self
      */
-    public function event(string $sMode, string $sName, JsExpr $xHandler): self
-    {
-        $this->aCalls[] = new Event($sMode, $sName, $xHandler);
-        return $this;
-    }
+public function event(string $sMode, string $sName, JsExpr $xHandler): self
+{
+$this->aCalls[] = new Event($sMode, $sName, $xHandler);
+return $this;
+}
 
-    /**
+/**
      * Show a message if the condition to the call is not met
      *
      * @param string $sMessage  The message to show
@@ -166,13 +166,13 @@ 
      *
      * @return self
      */
-    public function elseShow(string $sMessage, ...$aArgs): self
-    {
-        $this->aAlert = self::$xDialogCommand->warning($sMessage, $aArgs);
-        return $this;
-    }
+public function elseShow(string $sMessage, ...$aArgs): self
+{
+$this->aAlert = self::$xDialogCommand->warning($sMessage, $aArgs);
+return $this;
+}
 
-    /**
+/**
      * Show an information message if the condition to the call is not met
      *
      * @param string $sMessage  The message to show
@@ -180,13 +180,13 @@ 
      *
      * @return self
      */
-    public function elseInfo(string $sMessage, ...$aArgs): self
-    {
-        $this->aAlert = self::$xDialogCommand->info($sMessage, $aArgs);
-        return $this;
-    }
+public function elseInfo(string $sMessage, ...$aArgs): self
+{
+$this->aAlert = self::$xDialogCommand->info($sMessage, $aArgs);
+return $this;
+}
 
-    /**
+/**
      * Show a success message if the condition to the call is not met
      *
      * @param string $sMessage  The message to show
@@ -194,13 +194,13 @@ 
      *
      * @return self
      */
-    public function elseSuccess(string $sMessage, ...$aArgs): self
-    {
-        $this->aAlert = self::$xDialogCommand->success($sMessage, $aArgs);
-        return $this;
-    }
+public function elseSuccess(string $sMessage, ...$aArgs): self
+{
+$this->aAlert = self::$xDialogCommand->success($sMessage, $aArgs);
+return $this;
+}
 
-    /**
+/**
      * Show a warning message if the condition to the call is not met
      *
      * @param string $sMessage  The message to show
@@ -208,13 +208,13 @@ 
      *
      * @return self
      */
-    public function elseWarning(string $sMessage, ...$aArgs): self
-    {
-        $this->aAlert = self::$xDialogCommand->warning($sMessage, $aArgs);
-        return $this;
-    }
+public function elseWarning(string $sMessage, ...$aArgs): self
+{
+$this->aAlert = self::$xDialogCommand->warning($sMessage, $aArgs);
+return $this;
+}
 
-    /**
+/**
      * Show an error message if the condition to the call is not met
      *
      * @param string $sMessage  The message to show
@@ -222,13 +222,13 @@ 
      *
      * @return self
      */
-    public function elseError(string $sMessage, ...$aArgs): self
-    {
-        $this->aAlert = self::$xDialogCommand->error($sMessage, $aArgs);
-        return $this;
-    }
+public function elseError(string $sMessage, ...$aArgs): self
+{
+$this->aAlert = self::$xDialogCommand->error($sMessage, $aArgs);
+return $this;
+}
 
-    /**
+/**
      * Add a confirmation question to the request
      *
      * @param string $sQuestion The question to ask
@@ -236,13 +236,13 @@ 
      *
      * @return self
      */
-    public function confirm(string $sQuestion, ...$aArgs): self
-    {
-        $this->aConfirm = self::$xDialogCommand->confirm($sQuestion, $aArgs);
-        return $this;
-    }
+public function confirm(string $sQuestion, ...$aArgs): self
+{
+$this->aConfirm = self::$xDialogCommand->confirm($sQuestion, $aArgs);
+return $this;
+}
 
-    /**
+/**
      * Check if a value is equal to another before sending the request
      *
      * @param mixed $xValue1    The first value to compare
@@ -250,13 +250,13 @@ 
      *
      * @return self
      */
-    public function ifeq($xValue1, $xValue2): self
-    {
-        $this->aCondition = ['eq', TypedValue::make($xValue1), TypedValue::make($xValue2)];
-        return $this;
-    }
+public function ifeq($xValue1, $xValue2): self
+{
+$this->aCondition = ['eq', TypedValue::make($xValue1), TypedValue::make($xValue2)];
+return $this;
+}
 
-    /**
+/**
      * Check if a value is equal to another before sending the request
      *
      * @param mixed $xValue1    The first value to compare
@@ -264,13 +264,13 @@ 
      *
      * @return self
      */
-    public function ifteq($xValue1, $xValue2): self
-    {
-        $this->aCondition = ['teq', TypedValue::make($xValue1), TypedValue::make($xValue2)];
-        return $this;
-    }
+public function ifteq($xValue1, $xValue2): self
+{
+$this->aCondition = ['teq', TypedValue::make($xValue1), TypedValue::make($xValue2)];
+return $this;
+}
 
-    /**
+/**
      * Check if a value is not equal to another before sending the request
      *
      * @param mixed $xValue1    The first value to compare
@@ -278,13 +278,13 @@ 
      *
      * @return self
      */
-    public function ifne($xValue1, $xValue2): self
-    {
-        $this->aCondition = ['ne', TypedValue::make($xValue1), TypedValue::make($xValue2)];
-        return $this;
-    }
+public function ifne($xValue1, $xValue2): self
+{
+$this->aCondition = ['ne', TypedValue::make($xValue1), TypedValue::make($xValue2)];
+return $this;
+}
 
-    /**
+/**
      * Check if a value is not equal to another before sending the request
      *
      * @param mixed $xValue1    The first value to compare
@@ -292,13 +292,13 @@ 
      *
      * @return self
      */
-    public function ifnte($xValue1, $xValue2): self
-    {
-        $this->aCondition = ['nte', TypedValue::make($xValue1), TypedValue::make($xValue2)];
-        return $this;
-    }
+public function ifnte($xValue1, $xValue2): self
+{
+$this->aCondition = ['nte', TypedValue::make($xValue1), TypedValue::make($xValue2)];
+return $this;
+}
 
-    /**
+/**
      * Check if a value is greater than another before sending the request
      *
      * @param mixed $xValue1    The first value to compare
@@ -306,13 +306,13 @@ 
      *
      * @return self
      */
-    public function ifgt($xValue1, $xValue2): self
-    {
-        $this->aCondition = ['gt', TypedValue::make($xValue1), TypedValue::make($xValue2)];
-        return $this;
-    }
+public function ifgt($xValue1, $xValue2): self
+{
+$this->aCondition = ['gt', TypedValue::make($xValue1), TypedValue::make($xValue2)];
+return $this;
+}
 
-    /**
+/**
      * Check if a value is greater or equal to another before sending the request
      *
      * @param mixed $xValue1    The first value to compare
@@ -320,13 +320,13 @@ 
      *
      * @return self
      */
-    public function ifge($xValue1, $xValue2): self
-    {
-        $this->aCondition = ['ge', TypedValue::make($xValue1), TypedValue::make($xValue2)];
-        return $this;
-    }
+public function ifge($xValue1, $xValue2): self
+{
+$this->aCondition = ['ge', TypedValue::make($xValue1), TypedValue::make($xValue2)];
+return $this;
+}
 
-    /**
+/**
      * Check if a value is lower than another before sending the request
      *
      * @param mixed $xValue1    The first value to compare
@@ -334,13 +334,13 @@ 
      *
      * @return self
      */
-    public function iflt($xValue1, $xValue2): self
-    {
-        $this->aCondition = ['lt', TypedValue::make($xValue1), TypedValue::make($xValue2)];
-        return $this;
-    }
+public function iflt($xValue1, $xValue2): self
+{
+$this->aCondition = ['lt', TypedValue::make($xValue1), TypedValue::make($xValue2)];
+return $this;
+}
 
-    /**
+/**
      * Check if a value is lower or equal to another before sending the request
      *
      * @param mixed $xValue1    The first value to compare
@@ -348,13 +348,13 @@ 
      *
      * @return self
      */
-    public function ifle($xValue1, $xValue2): self
-    {
-        $this->aCondition = ['le', TypedValue::make($xValue1), TypedValue::make($xValue2)];
-        return $this;
-    }
+public function ifle($xValue1, $xValue2): self
+{
+$this->aCondition = ['le', TypedValue::make($xValue1), TypedValue::make($xValue2)];
+return $this;
+}
 
-    /**
+/**
      * Add a condition to the request
      *
      * The request is sent only if the condition is true.
@@ -363,12 +363,12 @@ 
      *
      * @return self
      */
-    public function when($xCondition): self
-    {
-        return $this->ifeq(true, $xCondition);
-    }
+public function when($xCondition): self
+{
+return $this->ifeq(true, $xCondition);
+}
 
-    /**
+/**
      * Add a condition to the request
      *
      * The request is sent only if the condition is false.
@@ -377,78 +377,78 @@ 
      *
      * @return self
      */
-    public function unless($xCondition): self
-    {
-        return $this->ifeq(false, $xCondition);
-    }
+public function unless($xCondition): self
+{
+return $this->ifeq(false, $xCondition);
+}
 
-    /**
+/**
      * @return self
      */
-    public function toInt(): self
-    {
-        $this->aCalls[] = [
-            '_type' => 'func',
-            '_name' => 'toInt',
-        ];
-        return $this;
-    }
+public function toInt(): self
+{
+$this->aCalls[] = [
+'_type' => 'func',
+'_name' => 'toInt',
+];
+return $this;
+}
 
-    /**
+/**
      * @return self
      */
-    public function trim(): self
-    {
-        $this->aCalls[] = [
-            '_type' => 'func',
-            '_name' => 'trim',
-        ];
-        return $this;
-    }
+public function trim(): self
+{
+$this->aCalls[] = [
+'_type' => 'func',
+'_name' => 'trim',
+];
+return $this;
+}
 
-    /**
+/**
      * @inheritDoc
      */
-    public function getType(): string
-    {
-        return 'expr';
-    }
+public function getType(): string
+{
+return 'expr';
+}
 
-    /**
+/**
      * Convert this call to array, when converting the response into json.
      *
      * @return array
      */
-    public function jsonSerialize(): array
-    {
-        $aJsExpr = [
-            '_type' => $this->getType(),
-            'calls' => array_map(fn(JsonSerializable|array $xCall) =>
-                is_array($xCall) ? $xCall : $xCall->jsonSerialize(), $this->aCalls),
-        ];
-        if(($this->aConfirm))
-        {
-            $aJsExpr['confirm'] = $this->aConfirm;
-        }
-        if(($this->aCondition))
-        {
-            $aJsExpr['condition'] = $this->aCondition;
-        }
-        if(($this->aAlert))
-        {
-            $aJsExpr['alert'] = $this->aAlert;
-        }
-
-        return $aJsExpr;
-    }
-
-    /**
+public function jsonSerialize(): array
+{
+$aJsExpr = [
+'_type' => $this->getType(),
+'calls' => array_map(fn(JsonSerializable|array $xCall) =>
+    is_array($xCall) ? $xCall : $xCall->jsonSerialize(), $this->aCalls),
+];
+if(($this->aConfirm))
+{
+$aJsExpr['confirm'] = $this->aConfirm;
+}
+if(($this->aCondition))
+{
+$aJsExpr['condition'] = $this->aCondition;
+}
+if(($this->aAlert))
+{
+$aJsExpr['alert'] = $this->aAlert;
+}
+
+return $aJsExpr;
+}
+
+/**
      * Returns a call to jaxon as a string
      *
      * @return string
      */
-    public function __toString(): string
-    {
-        return 'jaxon.exec(' . json_encode($this->jsonSerialize()) . ')';
-    }
+public function __toString(): string
+{
+return 'jaxon.exec(' . json_encode($this->jsonSerialize()) . ')';
+}
 }

jaxon-dialogs/src/Dialog/AbstractLibrary.php

Switch Indentation +41 added lines, -41 removed lines

@@ -20,94 +20,94 @@
 
 abstract class AbstractLibrary
 {
-    /**
+/**
      * The dialog library helper
      *
      * @var LibraryHelper|null
      */
-    private $xHelper = null;
+private $xHelper = null;
 
-    /**
+/**
      * The css files
      *
      * @var array
      */
-    protected $aCssFiles = [];
+protected $aCssFiles = [];
 
-    /**
+/**
      * The js files
      *
      * @var array
      */
-    protected $aJsFiles = [];
+protected $aJsFiles = [];
 
-    /**
+/**
      * Get the library name
      *
      * @return string
      */
-    abstract public function getName(): string;
+abstract public function getName(): string;
 
-    /**
+/**
      * Get the helper
      *
      * @return LibraryHelper
      */
-    public function helper(): LibraryHelper
-    {
-        return $this->xHelper ?:
-            $this->xHelper = dialog()->getLibraryHelper($this->getName());
-    }
+public function helper(): LibraryHelper
+{
+return $this->xHelper ?:
+$this->xHelper = dialog()->getLibraryHelper($this->getName());
+}
 
-    /**
+/**
      * Get the library base URI
      *
      * @return string
      */
-    public function getUri(): string
-    {
-        return '';
-    }
+public function getUri(): string
+{
+return '';
+}
 
-    /**
+/**
      * Get the CSS header code and file includes
      *
      * @return string
      */
-    public function getJs(): string
-    {
-        return $this->helper()->getJs($this->aJsFiles);
-    }
+public function getJs(): string
+{
+return $this->helper()->getJs($this->aJsFiles);
+}
 
-    /**
+/**
      * Get the javascript header code and file includes
      *
      * @return string
      */
-    public function getCss(): string
-    {
-        return $this->helper()->getCss($this->aCssFiles);
-    }
+public function getCss(): string
+{
+return $this->helper()->getCss($this->aCssFiles);
+}
 
-    /**
+/**
      * Get the javascript code to be printed into the page
      *
      * @return string
      */
-    public function getScript(): string
-    {
-        return '';
-    }
+public function getScript(): string
+{
+return '';
+}
 
-    /**
+/**
      * Get the javascript code to be executed on page load
      *
      * @return JsCode|null
      */
-    public function getJsCode(): ?JsCode
-    {
-        $xJsCode = new JsCode();
-        $xJsCode->sJs = $this->helper()->getScript();
-        return $xJsCode;
-    }
+public function getJsCode(): ?JsCode
+{
+$xJsCode = new JsCode();
+$xJsCode->sJs = $this->helper()->getScript();
+return $xJsCode;
+}
 }

jaxon-upload/src/register.php

Switch Indentation +66 added lines, -66 removed lines

@@ -22,63 +22,63 @@ 
  */
 function registerUpload(): void
 {
-    $jaxon = jaxon();
-    $di = $jaxon->di();
-    if($di->h(UploadHandler::class))
-    {
-        return;
-    }
+$jaxon = jaxon();
+$di = $jaxon->di();
+if($di->h(UploadHandler::class))
+{
+return;
+}
 
-    // Upload file and dir name generator
-    $di->set(FileNameInterface::class, function() {
-        return new class implements FileNameInterface
-        {
-            public function random(int $nLength): string
-            {
-                return bin2hex(random_bytes((int)($nLength / 2)));
-            }
-        };
-    });
-    // Upload validator
-    $di->set(Validator::class, function($c) {
-        return new Validator($c->g(ConfigManager::class), $c->g(Translator::class));
-    });
-    // File storage
-    $di->set(FileStorage::class, function($c) {
-        return  new FileStorage($c->g(ConfigManager::class), $c->g(Translator::class));
-    });
-    // File upload manager
-    $di->set(UploadManager::class, function($c) {
-        // Translation directory
-        $sTranslationDir = dirname(__DIR__) . '/translations';
-        // Load the upload translations
-        $xTranslator = $c->g(Translator::class);
-        $xTranslator->loadTranslations("$sTranslationDir/en/upload.php", 'en');
-        $xTranslator->loadTranslations("$sTranslationDir/fr/upload.php", 'fr');
-        $xTranslator->loadTranslations("$sTranslationDir/es/upload.php", 'es');
+// Upload file and dir name generator
+$di->set(FileNameInterface::class, function() {
+return new class implements FileNameInterface
+{
+public function random(int $nLength): string
+{
+    return bin2hex(random_bytes((int)($nLength / 2)));
+}
+};
+});
+// Upload validator
+$di->set(Validator::class, function($c) {
+return new Validator($c->g(ConfigManager::class), $c->g(Translator::class));
+});
+// File storage
+$di->set(FileStorage::class, function($c) {
+return  new FileStorage($c->g(ConfigManager::class), $c->g(Translator::class));
+});
+// File upload manager
+$di->set(UploadManager::class, function($c) {
+// Translation directory
+$sTranslationDir = dirname(__DIR__) . '/translations';
+// Load the upload translations
+$xTranslator = $c->g(Translator::class);
+$xTranslator->loadTranslations("$sTranslationDir/en/upload.php", 'en');
+$xTranslator->loadTranslations("$sTranslationDir/fr/upload.php", 'fr');
+$xTranslator->loadTranslations("$sTranslationDir/es/upload.php", 'es');
 
-        return new UploadManager($c->g(LoggerInterface::class), $c->g(Validator::class),
-            $xTranslator, $c->g(FileStorage::class),
-            $c->g(FileNameInterface::class));
-    });
-    // File upload plugin
-    $di->set(UploadHandler::class, function($c) {
-        return new UploadHandler($c->g(FileStorage::class), $c->g(UploadManager::class));
-    });
-    // Set alias on the interface
-    $di->alias(UploadHandlerInterface::class, UploadHandler::class);
+return new UploadManager($c->g(LoggerInterface::class), $c->g(Validator::class),
+$xTranslator, $c->g(FileStorage::class),
+$c->g(FileNameInterface::class));
+});
+// File upload plugin
+$di->set(UploadHandler::class, function($c) {
+return new UploadHandler($c->g(FileStorage::class), $c->g(UploadManager::class));
+});
+// Set alias on the interface
+$di->alias(UploadHandlerInterface::class, UploadHandler::class);
 
-    // Set a callback to process uploaded files in the incoming requests.
-    $jaxon->callback()->before(function() use($di) {
-        /** @var UploadHandler */
-        $xUploadHandler = $di->g(UploadHandler::class);
-        // The HTTP request
-        $xRequest = $di->getRequest();
-        if($xUploadHandler->canProcessRequest($xRequest))
-        {
-            $xUploadHandler->processRequest($xRequest);
-        }
-    });
+// Set a callback to process uploaded files in the incoming requests.
+$jaxon->callback()->before(function() use($di) {
+/** @var UploadHandler */
+$xUploadHandler = $di->g(UploadHandler::class);
+// The HTTP request
+$xRequest = $di->getRequest();
+if($xUploadHandler->canProcessRequest($xRequest))
+{
+$xUploadHandler->processRequest($xRequest);
+}
+});
 }
 
 /**
@@ -88,22 +88,22 @@ 
  */
 function _register(): void
 {
-    $jaxon = jaxon();
-    $jaxon->callback()->boot(function() use($jaxon) {
-        if($jaxon->getOption('core.upload.enabled'))
-        {
-            registerUpload();
-        }
-    });
+$jaxon = jaxon();
+$jaxon->callback()->boot(function() use($jaxon) {
+if($jaxon->getOption('core.upload.enabled'))
+{
+registerUpload();
+}
+});
 }
 
 function register()
 {
-    // Do nothing if running in cli.
-    if(php_sapi_name() !== 'cli')
-    {
-        _register();
-    };
+// Do nothing if running in cli.
+if(php_sapi_name() !== 'cli')
+{
+_register();
+};
 }
 
 register();