jaxon-php / jaxon-mono

jaxon-core/src/Jaxon.php

Switch Indentation +8 added lines, -8 removed lines

@@ -16,23 +16,23 @@
 
 class Jaxon
 {
-    /**
+/**
      * @const string
      */
-    public const VERSION = 'Jaxon 5.x';
+public const VERSION = 'Jaxon 5.x';
 
-    /**
+/**
      * @const string
      */
-    public const CALLABLE_CLASS = 'CallableClass';
+public const CALLABLE_CLASS = 'CallableClass';
 
-    /**
+/**
      * @const string
      */
-    public const CALLABLE_DIR = 'CallableDir';
+public const CALLABLE_DIR = 'CallableDir';
 
-    /**
+/**
      * @const string
      */
-    public const CALLABLE_FUNCTION = 'CallableFunction';
+public const CALLABLE_FUNCTION = 'CallableFunction';
 }

jaxon-core/src/Request/Target.php

Switch Indentation +73 added lines, -73 removed lines

@@ -17,56 +17,56 @@ 
 
 class Target implements TargetInterface
 {
-    /**
+/**
      * The target type for function.
      *
      * @var string
      */
-    const TYPE_FUNCTION = 'TargetFunction';
+const TYPE_FUNCTION = 'TargetFunction';
 
-    /**
+/**
      * The target type for class.
      *
      * @var string
      */
-    const TYPE_CLASS = 'TargetClass';
+const TYPE_CLASS = 'TargetClass';
 
-    /**
+/**
      * The target type.
      *
      * @var string
      */
-    private $sType = '';
+private $sType = '';
 
-    /**
+/**
      * The target function name.
      *
      * @var string
      */
-    private $sFunctionName = '';
+private $sFunctionName = '';
 
-    /**
+/**
      * The target class name.
      *
      * @var string
      */
-    private $sClassName = '';
+private $sClassName = '';
 
-    /**
+/**
      * The target method name.
      *
      * @var string
      */
-    private $sMethodName = '';
+private $sMethodName = '';
 
-    /**
+/**
      * The target method args.
      *
      * @var array
      */
-    private $aMethodArgs = [];
+private $aMethodArgs = [];
 
-    /**
+/**
      * The constructor
      *
      * @param string $sType    The target type
@@ -75,116 +75,116 @@ 
      * @param string $sMethodName    The method name
      * @param array $aMethodArgs    The method args
      */
-    private function __construct(string $sType, string $sFunctionName, string $sClassName, string $sMethodName, array $aMethodArgs = [])
-    {
-        $this->sType = $sType;
-        $this->sFunctionName = $sFunctionName;
-        $this->sClassName = $sClassName;
-        $this->sMethodName = $sMethodName;
-        $this->aMethodArgs = $aMethodArgs;
-    }
+private function __construct(string $sType, string $sFunctionName, string $sClassName, string $sMethodName, array $aMethodArgs = [])
+{
+$this->sType = $sType;
+$this->sFunctionName = $sFunctionName;
+$this->sClassName = $sClassName;
+$this->sMethodName = $sMethodName;
+$this->aMethodArgs = $aMethodArgs;
+}
 
-    /**
+/**
      * Create a target of type Function
      *
      * @param string $sFunctionName    The function name
      *
      * @return Target
      */
-    public static function makeFunction(string $sFunctionName): Target
-    {
-        return new Target(self::TYPE_FUNCTION, $sFunctionName, '', '');
-    }
+public static function makeFunction(string $sFunctionName): Target
+{
+return new Target(self::TYPE_FUNCTION, $sFunctionName, '', '');
+}
 
-    /**
+/**
      * Create a target of type Class
      *
      * @param array $aCall
      *
      * @return Target
      */
-    public static function makeClass(array $aCall): Target
-    {
-        return new Target(self::TYPE_CLASS, '', trim($aCall['name']), trim($aCall['method']));
-    }
+public static function makeClass(array $aCall): Target
+{
+return new Target(self::TYPE_CLASS, '', trim($aCall['name']), trim($aCall['method']));
+}
 
-    /**
+/**
      * Check if the target type is Function.
      *
      * @return bool
      */
-    public function isFunction(): bool
-    {
-        return $this->sType === self::TYPE_FUNCTION;
-    }
+public function isFunction(): bool
+{
+return $this->sType === self::TYPE_FUNCTION;
+}
 
-    /**
+/**
      * Check if the target type is Class.
      *
      * @return bool
      */
-    public function isClass(): bool
-    {
-        return $this->sType === self::TYPE_CLASS;
-    }
+public function isClass(): bool
+{
+return $this->sType === self::TYPE_CLASS;
+}
 
-    /**
+/**
      * The target function name.
      *
      * @return string
      */
-    public function getFunctionName(): string
-    {
-        return $this->sFunctionName;
-    }
+public function getFunctionName(): string
+{
+return $this->sFunctionName;
+}
 
-    /**
+/**
      * The target class name.
      *
      * @return string
      */
-    public function getClassName(): string
-    {
-        return $this->sClassName;
-    }
+public function getClassName(): string
+{
+return $this->sClassName;
+}
 
-    /**
+/**
      * The target method name.
      *
      * @return string
      */
-    public function getMethodName(): string
-    {
-        return $this->sMethodName;
-    }
+public function getMethodName(): string
+{
+return $this->sMethodName;
+}
 
-    /**
+/**
      * Set the target method name.
      *
      * @param array $aMethodArgs
      */
-    public function setMethodArgs(array $aMethodArgs): void
-    {
-        $this->aMethodArgs = $aMethodArgs;
-    }
+public function setMethodArgs(array $aMethodArgs): void
+{
+$this->aMethodArgs = $aMethodArgs;
+}
 
-    /**
+/**
      * The target method name.
      *
      * @return string
      */
-    public function method(): string
-    {
-        return $this->sMethodName;
-    }
+public function method(): string
+{
+return $this->sMethodName;
+}
 
-    /**
+/**
      * The target method args.
      *
      * @return array
      */
-    public function args(): array
-    {
-        return $this->aMethodArgs;
-    }
+public function args(): array
+{
+return $this->aMethodArgs;
+}
 }

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

Switch Indentation +84 added lines, -84 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,110 +46,110 @@ 
      * @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
-    {
-        // Check if there is a plugin to process this request
-        if(!$this->canProcessRequest())
-        {
-            return;
-        }
+public function processRequest(): void
+{
+// 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-annotations/src/Annotation/DatabagAnnotation.php

Switch Indentation +22 added lines, -22 removed lines

@@ -28,40 +28,40 @@
  */
 class DatabagAnnotation extends AbstractAnnotation
 {
-    /**
+/**
      * The data bag name
      *
      * @var string
      */
-    protected $sName = '';
+protected $sName = '';
 
-    /**
+/**
      * @inheritDoc
      */
-    public static function parseAnnotation($value)
-    {
-        $aParams = preg_split('/[\s]+/', $value, 2);
-        return count($aParams) === 1 ? ['name' => $aParams[0]] : ['name' => $aParams[0], 'extra' => $aParams[1]];
-    }
+public static function parseAnnotation($value)
+{
+$aParams = preg_split('/[\s]+/', $value, 2);
+return count($aParams) === 1 ? ['name' => $aParams[0]] : ['name' => $aParams[0], 'extra' => $aParams[1]];
+}
 
-    /**
+/**
      * @inheritDoc
      * @throws AnnotationException
      */
-    public function initAnnotation(array $properties)
-    {
-        if(count($properties) !== 1 || !isset($properties['name']) || !is_string($properties['name']))
-        {
-            throw new AnnotationException('The @databag annotation requires a property "name" of type string');
-        }
-        $this->sName = $properties['name'];
-    }
+public function initAnnotation(array $properties)
+{
+if(count($properties) !== 1 || !isset($properties['name']) || !is_string($properties['name']))
+{
+throw new AnnotationException('The @databag annotation requires a property "name" of type string');
+}
+$this->sName = $properties['name'];
+}
 
-    /**
+/**
      * @inheritDoc
      */
-    public function saveValue(Metadata $xMetadata, string $sMethod = '*'): void
-    {
-        $xMetadata->databag($sMethod)->addValue($this->sName);
-    }
+public function saveValue(Metadata $xMetadata, string $sMethod = '*'): void
+{
+$xMetadata->databag($sMethod)->addValue($this->sName);
+}
 }

jaxon-core/src/App/Databag/DatabagContext.php

Switch Indentation +25 added lines, -25 removed lines

@@ -4,58 +4,58 @@
 
 class DatabagContext
 {
-    /**
+/**
      * @var Databag
      */
-    protected $xDatabag;
+protected $xDatabag;
 
-    /**
+/**
      * @var string
      */
-    protected $sName;
+protected $sName;
 
-    /**
+/**
      * The constructor
      *
      * @param Databag $xDatabag
      * @param string $sName
      */
-    public function __construct(Databag $xDatabag, string $sName)
-    {
-        $this->xDatabag = $xDatabag;
-        $this->sName = $sName;
-    }
+public function __construct(Databag $xDatabag, string $sName)
+{
+$this->xDatabag = $xDatabag;
+$this->sName = $sName;
+}
 
-    /**
+/**
      * @param string $sKey
      * @param mixed $xValue
      *
      * @return void
      */
-    public function set(string $sKey, $xValue): void
-    {
-        $this->xDatabag->set($this->sName, $sKey, $xValue);
-    }
+public function set(string $sKey, $xValue): void
+{
+$this->xDatabag->set($this->sName, $sKey, $xValue);
+}
 
-    /**
+/**
      * @param string $sKey
      * @param mixed $xValue
      *
      * @return void
      */
-    public function new(string $sKey, $xValue): void
-    {
-        $this->xDatabag->new($this->sName, $sKey, $xValue);
-    }
+public function new(string $sKey, $xValue): void
+{
+$this->xDatabag->new($this->sName, $sKey, $xValue);
+}
 
-    /**
+/**
      * @param string $sKey
      * @param mixed $xValue
      *
      * @return mixed
      */
-    public function get(string $sKey, $xValue = null): mixed
-    {
-        return $this->xDatabag->get($this->sName, $sKey, $xValue);
-    }
+public function get(string $sKey, $xValue = null): mixed
+{
+return $this->xDatabag->get($this->sName, $sKey, $xValue);
+}
 }

jaxon-core/src/App/Databag/Databag.php

Switch Indentation +56 added lines, -56 removed lines

@@ -11,110 +11,110 @@
 
 class Databag implements JsonSerializable
 {
-    /**
+/**
      * @var DatabagPlugin
      */
-    protected $xPlugin;
+protected $xPlugin;
 
-    /**
+/**
      * @var array
      */
-    protected $aData = [];
+protected $aData = [];
 
-    /**
+/**
      * @var bool
      */
-    protected $bTouched = false;
+protected $bTouched = false;
 
-    /**
+/**
      * The constructor
      *
      * @param array $aData
      */
-    public function __construct(DatabagPlugin $xPlugin, array $aData)
-    {
-        $this->xPlugin = $xPlugin;
-        // Ensure all contents are arrays.
-        $this->aData = array_map(function($aValue) {
-            return is_array($aValue) ? $aValue : [];
-        }, $aData);
-    }
+public function __construct(DatabagPlugin $xPlugin, array $aData)
+{
+$this->xPlugin = $xPlugin;
+// Ensure all contents are arrays.
+$this->aData = array_map(function($aValue) {
+return is_array($aValue) ? $aValue : [];
+}, $aData);
+}
 
-    /**
+/**
      * @return bool
      */
-    public function touched(): bool
-    {
-        return $this->bTouched;
-    }
+public function touched(): bool
+{
+return $this->bTouched;
+}
 
-    /**
+/**
      * @return array
      */
-    public function getAll(): array
-    {
-        return $this->aData;
-    }
+public function getAll(): array
+{
+return $this->aData;
+}
 
-    /**
+/**
      * @param string $sBag
      *
      * @return void
      */
-    public function clear(string $sBag): void
-    {
-        $this->aData[$sBag] = [];
-        $this->xPlugin->addCommand('databag.clear', ['bag' => $sBag]);
-    }
+public function clear(string $sBag): void
+{
+$this->aData[$sBag] = [];
+$this->xPlugin->addCommand('databag.clear', ['bag' => $sBag]);
+}
 
-    /**
+/**
      * @param string $sBag
      * @param string $sKey
      * @param mixed $xValue
      *
      * @return void
      */
-    public function set(string $sBag, string $sKey, $xValue): void
-    {
-        $this->bTouched = true;
-        $this->aData[$sBag][$sKey] = $xValue;
-    }
+public function set(string $sBag, string $sKey, $xValue): void
+{
+$this->bTouched = true;
+$this->aData[$sBag][$sKey] = $xValue;
+}
 
-    /**
+/**
      * @param string $sBag
      * @param string $sKey
      * @param mixed $xValue
      *
      * @return void
      */
-    public function new(string $sBag, string $sKey, $xValue): void
-    {
-        // Set the value only if it doesn't already exist.
-        if(!isset($this->aData[$sBag]) || !key_exists($sKey, $this->aData[$sBag]))
-        {
-            $this->set($sBag, $sKey, $xValue);
-        }
-    }
+public function new(string $sBag, string $sKey, $xValue): void
+{
+// Set the value only if it doesn't already exist.
+if(!isset($this->aData[$sBag]) || !key_exists($sKey, $this->aData[$sBag]))
+{
+$this->set($sBag, $sKey, $xValue);
+}
+}
 
-    /**
+/**
      * @param string $sBag
      * @param string $sKey
      * @param mixed $xValue
      *
      * @return mixed
      */
-    public function get(string $sBag, string $sKey, $xValue = null): mixed
-    {
-        return $this->aData[$sBag][$sKey] ?? $xValue;
-    }
+public function get(string $sBag, string $sKey, $xValue = null): mixed
+{
+return $this->aData[$sBag][$sKey] ?? $xValue;
+}
 
-    /**
+/**
      * Convert this call to array, when converting the response into json.
      *
      * @return array
      */
-    public function jsonSerialize(): array
-    {
-        return $this->aData;
-    }
+public function jsonSerialize(): array
+{
+return $this->aData;
+}
 }

jaxon-annotations/src/AnnotationReader.php

Switch Indentation +150 added lines, -150 removed lines

@@ -36,206 +36,206 @@
 
 class AnnotationReader implements MetadataReaderInterface
 {
-    /**
+/**
      * @var AnnotationManager
      */
-    protected $xManager;
+protected $xManager;
 
-    /**
+/**
      * @var Metadata
      */
-    protected $xMetadata;
+protected $xMetadata;
 
-    /**
+/**
      * Properties types, read from the "var" annotations.
      *
      * @var array
      */
-    protected $aPropTypes;
+protected $aPropTypes;
 
-    /**
+/**
      * The type of the class member being currently processed.
      *
      * @var string
      */
-    protected $sCurrMemberType;
+protected $sCurrMemberType;
 
-    /**
+/**
      * The constructor
      *
      * @param AnnotationManager $xManager
      */
-    public function __construct(AnnotationManager $xManager)
-    {
-        $this->xManager = $xManager;
-        $this->xManager->registry['upload'] = UploadAnnotation::class;
-        $this->xManager->registry['databag'] = DatabagAnnotation::class;
-        $this->xManager->registry['exclude'] = ExcludeAnnotation::class;
-        $this->xManager->registry['before'] = BeforeAnnotation::class;
-        $this->xManager->registry['after'] = AfterAnnotation::class;
-        $this->xManager->registry['di'] = ContainerAnnotation::class;
-        $this->xManager->registry['callback'] = CallbackAnnotation::class;
-        // Missing standard annotations.
-        // We need to define this, otherwise they throw an exception, and make the whole processing fail.
-        $this->xManager->registry['const'] = false;
-        $this->xManager->registry['inheritDoc'] = false;
-        $this->xManager->registry['template'] = false;
-        $this->xManager->registry['param-closure-this'] = false;
-    }
+public function __construct(AnnotationManager $xManager)
+{
+$this->xManager = $xManager;
+$this->xManager->registry['upload'] = UploadAnnotation::class;
+$this->xManager->registry['databag'] = DatabagAnnotation::class;
+$this->xManager->registry['exclude'] = ExcludeAnnotation::class;
+$this->xManager->registry['before'] = BeforeAnnotation::class;
+$this->xManager->registry['after'] = AfterAnnotation::class;
+$this->xManager->registry['di'] = ContainerAnnotation::class;
+$this->xManager->registry['callback'] = CallbackAnnotation::class;
+// Missing standard annotations.
+// We need to define this, otherwise they throw an exception, and make the whole processing fail.
+$this->xManager->registry['const'] = false;
+$this->xManager->registry['inheritDoc'] = false;
+$this->xManager->registry['template'] = false;
+$this->xManager->registry['param-closure-this'] = false;
+}
 
-    /**
+/**
      * @return array
      */
-    public function getPropTypes(): array
-    {
-        return $this->aPropTypes;
-    }
+public function getPropTypes(): array
+{
+return $this->aPropTypes;
+}
 
-    /**
+/**
      * @return bool
      */
-    public function annotationIsOnProperty(): bool
-    {
-        return $this->sCurrMemberType === AnnotationManager::MEMBER_PROPERTY;
-    }
+public function annotationIsOnProperty(): bool
+{
+return $this->sCurrMemberType === AnnotationManager::MEMBER_PROPERTY;
+}
 
-    /**
+/**
      * @param string $sClass
      *
      * @return void
      * @throws AnnotationException
      */
-    private function getClassAttrs(string $sClass): void
-    {
-        // Only keep the annotations declared in this package.
-        /** @var array<AbstractAnnotation> */
-        $aAnnotations = array_filter(
-            $this->xManager->getClassAnnotations($sClass),
-            fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
-        );
-        // First check if the class is excluded.
-        foreach($aAnnotations as $xAnnotation)
-        {
-            if(is_a($xAnnotation, ExcludeAnnotation::class))
-            {
-                $xAnnotation->saveValue($this->xMetadata);
-            }
-        }
-        if($this->xMetadata->isExcluded())
-        {
-            return;
-        }
-
-        foreach($aAnnotations as $xAnnotation)
-        {
-            if(!is_a($xAnnotation, ExcludeAnnotation::class))
-            {
-                $xAnnotation->saveValue($this->xMetadata);
-            }
-        }
-    }
+private function getClassAttrs(string $sClass): void
+{
+// Only keep the annotations declared in this package.
+/** @var array<AbstractAnnotation> */
+$aAnnotations = array_filter(
+$this->xManager->getClassAnnotations($sClass),
+fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
+);
+// First check if the class is excluded.
+foreach($aAnnotations as $xAnnotation)
+{
+if(is_a($xAnnotation, ExcludeAnnotation::class))
+{
+    $xAnnotation->saveValue($this->xMetadata);
+}
+}
+if($this->xMetadata->isExcluded())
+{
+return;
+}
 
-    /**
+foreach($aAnnotations as $xAnnotation)
+{
+if(!is_a($xAnnotation, ExcludeAnnotation::class))
+{
+    $xAnnotation->saveValue($this->xMetadata);
+}
+}
+}
+
+/**
      * @param string $sClass
      * @param string $sProperty
      *
      * @return void
      * @throws AnnotationException
      */
-    private function getPropertyAttrs(string $sClass, string $sProperty): void
+private function getPropertyAttrs(string $sClass, string $sProperty): void
+{
+/** @var array<ContainerAnnotation> */
+// Only keep the annotations declared in this package.
+$aAnnotations = array_filter(
+$this->xManager->getPropertyAnnotations($sClass, $sProperty),
+function($xAnnotation) use($sProperty) {
+    // Save the property type
+    if(is_a($xAnnotation, VarAnnotation::class))
     {
-        /** @var array<ContainerAnnotation> */
-        // Only keep the annotations declared in this package.
-        $aAnnotations = array_filter(
-            $this->xManager->getPropertyAnnotations($sClass, $sProperty),
-            function($xAnnotation) use($sProperty) {
-                // Save the property type
-                if(is_a($xAnnotation, VarAnnotation::class))
-                {
-                    $this->aPropTypes[$sProperty] = $xAnnotation->type;
-                }
-                // Only container annotations are allowed on properties
-                return is_a($xAnnotation, ContainerAnnotation::class);
-            }
-        );
-        if(count($aAnnotations) > 1)
-        {
-            throw new AnnotationException('Only one @di annotation is allowed on a property');
-        }
-
-        foreach($aAnnotations as $xAnnotation)
-        {
-            $xAnnotation->setAttr($sProperty);
-            $xAnnotation->saveValue($this->xMetadata);
-        }
+        $this->aPropTypes[$sProperty] = $xAnnotation->type;
     }
+    // Only container annotations are allowed on properties
+    return is_a($xAnnotation, ContainerAnnotation::class);
+}
+);
+if(count($aAnnotations) > 1)
+{
+throw new AnnotationException('Only one @di annotation is allowed on a property');
+}
 
-    /**
+foreach($aAnnotations as $xAnnotation)
+{
+$xAnnotation->setAttr($sProperty);
+$xAnnotation->saveValue($this->xMetadata);
+}
+}
+
+/**
      * @param string $sClass
      * @param string $sMethod
      *
      * @return void
      * @throws AnnotationException
      */
-    private function getMethodAttrs(string $sClass, string $sMethod): void
-    {
-        // Only keep the annotations declared in this package.
-        /** @var array<AbstractAnnotation> */
-        $aAnnotations = array_filter(
-            $this->xManager->getMethodAnnotations($sClass, $sMethod),
-            fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
-        );
-        foreach($aAnnotations as $xAnnotation)
-        {
-            $xAnnotation->saveValue($this->xMetadata, $sMethod);
-        }
-    }
+private function getMethodAttrs(string $sClass, string $sMethod): void
+{
+// Only keep the annotations declared in this package.
+/** @var array<AbstractAnnotation> */
+$aAnnotations = array_filter(
+$this->xManager->getMethodAnnotations($sClass, $sMethod),
+fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
+);
+foreach($aAnnotations as $xAnnotation)
+{
+$xAnnotation->saveValue($this->xMetadata, $sMethod);
+}
+}
 
-    /**
+/**
      * @inheritDoc
      * @throws SetupException
      */
-    public function getAttributes(InputData $xInput): Metadata
-    {
-        ContainerAnnotation::$xReader = $this;
-        $this->aPropTypes = [];
-        $this->xMetadata = new Metadata();
-        $sClass = $xInput->getReflectionClass()->getName();
-
-        try
-        {
-            // Processing class annotations
-            $this->sCurrMemberType = AnnotationManager::MEMBER_CLASS;
-
-            $this->getClassAttrs($sClass);
-            if($this->xMetadata->isExcluded())
-            {
-                // The entire class is not to be exported.
-                return $this->xMetadata;
-            }
-
-            // Processing properties annotations
-            $this->sCurrMemberType = AnnotationManager::MEMBER_PROPERTY;
-
-            // Properties annotations
-            foreach($xInput->getProperties() as $sProperty)
-            {
-                $this->getPropertyAttrs($sClass, $sProperty);
-            }
-
-            // Processing methods annotations
-            $this->sCurrMemberType = AnnotationManager::MEMBER_METHOD;
-
-            foreach($xInput->getMethods() as $sMethod)
-            {
-                $this->getMethodAttrs($sClass, $sMethod);
-            }
-
-            return $this->xMetadata;
-        }
-        catch(AnnotationException $e)
-        {
-            throw new SetupException($e->getMessage());
-        }
-    }
+public function getAttributes(InputData $xInput): Metadata
+{
+ContainerAnnotation::$xReader = $this;
+$this->aPropTypes = [];
+$this->xMetadata = new Metadata();
+$sClass = $xInput->getReflectionClass()->getName();
+
+try
+{
+// Processing class annotations
+$this->sCurrMemberType = AnnotationManager::MEMBER_CLASS;
+
+$this->getClassAttrs($sClass);
+if($this->xMetadata->isExcluded())
+{
+    // The entire class is not to be exported.
+    return $this->xMetadata;
+}
+
+// Processing properties annotations
+$this->sCurrMemberType = AnnotationManager::MEMBER_PROPERTY;
+
+// Properties annotations
+foreach($xInput->getProperties() as $sProperty)
+{
+    $this->getPropertyAttrs($sClass, $sProperty);
+}
+
+// Processing methods annotations
+$this->sCurrMemberType = AnnotationManager::MEMBER_METHOD;
+
+foreach($xInput->getMethods() as $sMethod)
+{
+    $this->getMethodAttrs($sClass, $sMethod);
+}
+
+return $this->xMetadata;
+}
+catch(AnnotationException $e)
+{
+throw new SetupException($e->getMessage());
+}
+}
 }