jaxon-php / jaxon-annotations

src/AnnotationReader.php

Spacing +15 added lines, -15 removed lines

@@ -85,7 +85,7 @@ 
      */
     public static function register(Container $di, bool $bForce = false)
     {
-        if(!$bForce && $di->h(AnnotationReader::class))
+        if (!$bForce && $di->h(AnnotationReader::class))
         {
             return;
         }
@@ -129,13 +129,13 @@ 
         });
 
         $aAttributes = [];
-        foreach($aAnnotations as $xAnnotation)
+        foreach ($aAnnotations as $xAnnotation)
         {
             $xAnnotation->setReader($this);
             $sName = $xAnnotation->getName();
             $xAnnotation->setPrevValue($aAttributes[$sName] ?? null);
             $xValue = $xAnnotation->getValue();
-            if($sName === 'protected' && !$xValue)
+            if ($sName === 'protected' && !$xValue)
             {
                 continue; // Ignore annotation @exclude with value false
             }
@@ -156,7 +156,7 @@ 
         // Only keep the annotations declared in this package.
         $aAnnotations = array_filter($aAnnotations, function($xAnnotation) use($sProperty) {
             // Save the property type
-            if(is_a($xAnnotation, VarAnnotation::class))
+            if (is_a($xAnnotation, VarAnnotation::class))
             {
                 $this->aPropTypes[$sProperty] = $xAnnotation->type;
             }
@@ -165,11 +165,11 @@ 
         });
 
         $nCount = count($aAnnotations);
-        if($nCount === 0)
+        if ($nCount === 0)
         {
             return ['', null];
         }
-        if($nCount > 1)
+        if ($nCount > 1)
         {
             throw new AnnotationException('Only one @di annotation is allowed on a property');
         }
@@ -200,10 +200,10 @@ 
             $this->aPropTypes = [];
             $aPropAttrs = [];
             // Properties annotations
-            foreach($aProperties as $sProperty)
+            foreach ($aProperties as $sProperty)
             {
                 [$sName, $xValue] = $this->propAnnotations($sProperty, $this->xManager->getPropertyAnnotations($sClass, $sProperty));
-                if(!$xValue)
+                if (!$xValue)
                 {
                     continue;
                 }
@@ -214,19 +214,19 @@ 
             $this->sMemberType = AnnotationManager::MEMBER_CLASS;
 
             $aClassAttrs = $this->filterAnnotations($this->xManager->getClassAnnotations($sClass));
-            if(isset($aClassAttrs['protected']))
+            if (isset($aClassAttrs['protected']))
             {
                 return [true, [], []]; // The entire class is not to be exported.
             }
 
             // Merge attributes and class annotations
-            foreach($aPropAttrs as $sName => $xValue)
+            foreach ($aPropAttrs as $sName => $xValue)
             {
                 $aClassAttrs[$sName] = array_merge($aClassAttrs[$sName] ?? [], $xValue);
             }
 
             $aAttributes = [];
-            if(count($aClassAttrs) > 0)
+            if (count($aClassAttrs) > 0)
             {
                 $aAttributes['*'] = $aClassAttrs;
             }
@@ -235,21 +235,21 @@ 
             $this->sMemberType = AnnotationManager::MEMBER_METHOD;
 
             $aProtected = [];
-            foreach($aMethods as $sMethod)
+            foreach ($aMethods as $sMethod)
             {
                 $aMethodAttrs = $this->filterAnnotations($this->xManager->getMethodAnnotations($sClass, $sMethod));
-                if(isset($aMethodAttrs['protected']))
+                if (isset($aMethodAttrs['protected']))
                 {
                     $aProtected[] = $sMethod; // The method is not to be exported.
                 }
-                elseif(count($aMethodAttrs) > 0)
+                elseif (count($aMethodAttrs) > 0)
                 {
                     $aAttributes[$sMethod] = $aMethodAttrs;
                 }
             }
             return [false, $aAttributes, $aProtected];
         }
-        catch(AnnotationException $e)
+        catch (AnnotationException $e)
         {
             throw new SetupException($e->getMessage());
         }

src/Annotation/ContainerAnnotation.php

Spacing +19 added lines, -19 removed lines

@@ -134,7 +134,7 @@ 
      */
     private function getFullClassName(string $sClassName): string
     {
-        return ltrim($this->xClassFile->resolveType($sClassName), '\\');;
+        return ltrim($this->xClassFile->resolveType($sClassName), '\\'); ;
     }
 
     /**
@@ -146,38 +146,38 @@ 
         $value = $this->properties['__value__'];
         $aParams = preg_split("/[\s]+/", $value, 3);
         $nParamCount = count($aParams);
-        if($nParamCount === 1)
+        if ($nParamCount === 1)
         {
             // For a property, the only parameter is the class. Otherwise, it is the attribute.
-            if($this->xReader->getMemberType() === AnnotationManager::MEMBER_PROPERTY)
+            if ($this->xReader->getMemberType() === AnnotationManager::MEMBER_PROPERTY)
             {
-                if(substr($aParams[0], 0, 1) === '$')
+                if (substr($aParams[0], 0, 1) === '$')
                 {
                     throw new AnnotationException('The only property of the @di annotation must be a class name');
                 }
                 $this->sClass = $this->getFullClassName($aParams[0]);
                 return;
             }
-            if(substr($aParams[0], 0, 1) !== '$')
+            if (substr($aParams[0], 0, 1) !== '$')
             {
                 throw new AnnotationException('The only property of the @di annotation must be a var name');
             }
             $this->sAttr = substr($aParams[0], 1);
             return;
         }
-        if($nParamCount === 2)
+        if ($nParamCount === 2)
         {
             // For a property, having 2 parameters is not allowed.
-            if($this->xReader->getMemberType() === AnnotationManager::MEMBER_PROPERTY)
+            if ($this->xReader->getMemberType() === AnnotationManager::MEMBER_PROPERTY)
             {
                 throw new AnnotationException('The @di annotation accepts only one property on a class attribute');
             }
 
-            if(substr($aParams[0], 0, 1) !== '$')
+            if (substr($aParams[0], 0, 1) !== '$')
             {
                 throw new AnnotationException('The only property of the @di annotation must be a var name');
             }
-            if(substr($aParams[1], 0, 1) === '$')
+            if (substr($aParams[1], 0, 1) === '$')
             {
                 throw new AnnotationException('The first property of the @di annotation must be a class name');
             }
@@ -196,28 +196,28 @@ 
     private function parseProperties()
     {
         $nCount = count($this->properties);
-        if($nCount > 2 ||
+        if ($nCount > 2 ||
             ($nCount === 2 && !(isset($this->properties['attr']) && isset($this->properties['class']))) ||
             ($nCount === 1 && !(isset($this->properties['attr']) || isset($this->properties['class']))))
         {
             throw new AnnotationException('The @di annotation accepts only "attr" or "class" as properties');
         }
 
-        if(isset($this->properties['attr']))
+        if (isset($this->properties['attr']))
         {
-            if($this->xReader->getMemberType() === AnnotationManager::MEMBER_PROPERTY)
+            if ($this->xReader->getMemberType() === AnnotationManager::MEMBER_PROPERTY)
             {
                 throw new AnnotationException('The @di annotation does not allow the "attr" property on class attributes');
             }
-            if(!is_string($this->properties['attr']))
+            if (!is_string($this->properties['attr']))
             {
                 throw new AnnotationException('The @di annotation requires a property "attr" of type string');
             }
             $this->sAttr = $this->properties['attr'];
         }
-        if(isset($this->properties['class']))
+        if (isset($this->properties['class']))
         {
-            if(!is_string($this->properties['class']))
+            if (!is_string($this->properties['class']))
             {
                 throw new AnnotationException('The @di annotation requires a property "class" of type string');
             }
@@ -235,21 +235,21 @@ 
 
         // The type in the @di annotations can be set from the values in the @var annotations
         $aPropTypes = $this->xReader->getPropTypes();
-        if($this->sClass === '' && isset($aPropTypes[$this->sAttr]))
+        if ($this->sClass === '' && isset($aPropTypes[$this->sAttr]))
         {
             $this->sClass = ltrim($aPropTypes[$this->sAttr], '\\');
         }
 
-        if(!$this->validateAttrName($this->sAttr))
+        if (!$this->validateAttrName($this->sAttr))
         {
             throw new AnnotationException($this->sAttr . ' is not a valid "attr" value for the @di annotation');
         }
-        if(!$this->validateClassName($this->sClass))
+        if (!$this->validateClassName($this->sClass))
         {
             throw new AnnotationException($this->sClass . ' is not a valid "class" value for the @di annotation');
         }
 
-        if(is_array($this->xPrevValue))
+        if (is_array($this->xPrevValue))
         {
             $this->xPrevValue[$this->sAttr] = $this->sClass; // Append the current value to the array
             return $this->xPrevValue;