jaxon-php / jaxon-annotations

src/Annotation/ContainerAnnotation.php

Spacing +21 added lines, -21 removed lines

@@ -105,43 +105,43 @@ 
     {
         $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(self::$sMemberType === AnnotationManager::MEMBER_PROPERTY)
+            if (self::$sMemberType === AnnotationManager::MEMBER_PROPERTY)
             {
                 $sClass = rtrim($aParams[0]);
-                if(substr($sClass, 0, 1) === '$')
+                if (substr($sClass, 0, 1) === '$')
                 {
                     throw new AnnotationException('The only property of the @di annotation must be a class name');
                 }
                 return ['class' => $sClass];
             }
             $sAttr = rtrim($aParams[0]);
-            if(substr($sAttr, 0, 1) !== '$')
+            if (substr($sAttr, 0, 1) !== '$')
             {
                 throw new AnnotationException('The only property of the @di annotation must be a var name');
             }
-            return ['attr' => substr($sAttr,1)];
+            return ['attr' => substr($sAttr, 1)];
         }
-        if($nParamCount === 2)
+        if ($nParamCount === 2)
         {
-            if(self::$sMemberType === AnnotationManager::MEMBER_PROPERTY)
+            if (self::$sMemberType === AnnotationManager::MEMBER_PROPERTY)
             {
                 throw new AnnotationException('The @di annotation accepts only one property on a class attribute');
             }
             $sAttr = rtrim($aParams[0]);
-            if(substr($sAttr, 0, 1) !== '$')
+            if (substr($sAttr, 0, 1) !== '$')
             {
                 throw new AnnotationException('The only property of the @di annotation must be a var name');
             }
             $sClass = rtrim($aParams[1]);
-            if(substr($sClass, 0, 1) === '$')
+            if (substr($sClass, 0, 1) === '$')
             {
                 throw new AnnotationException('The first property of the @di annotation must be a class name');
             }
             // For a property, having 2 parameters is not allowed.
-            return ['attr' => substr($sAttr,1), 'class' => $sClass];
+            return ['attr' => substr($sAttr, 1), 'class' => $sClass];
         }
 
         throw new AnnotationException('The @di annotation only accepts one or two properties');
@@ -153,33 +153,33 @@ 
      */
     public function initAnnotation(array $properties)
     {
-        if(isset($properties['__raw']))
+        if (isset($properties['__raw']))
         {
             $properties = $this->parseValue($properties['__raw']);
         }
         $nCount = count($properties);
-        if($nCount > 2 ||
+        if ($nCount > 2 ||
             ($nCount === 2 && !(isset($properties['attr']) && isset($properties['class']))) ||
             ($nCount === 1 && !(isset($properties['attr']) || isset($properties['class']))))
         {
             throw new AnnotationException('The @di annotation accepts only "attr" or "class" as properties');
         }
 
-        if(isset($properties['attr']))
+        if (isset($properties['attr']))
         {
-            if(self::$sMemberType === AnnotationManager::MEMBER_PROPERTY)
+            if (self::$sMemberType === AnnotationManager::MEMBER_PROPERTY)
             {
                 throw new AnnotationException('The @di annotation does not allow the "attr" property on class attributes');
             }
-            if(!is_string($properties['attr']))
+            if (!is_string($properties['attr']))
             {
                 throw new AnnotationException('The @di annotation requires a property "attr" of type string');
             }
             $this->sAttr = $properties['attr'];
         }
-        if(isset($properties['class']))
+        if (isset($properties['class']))
         {
-            if(!is_string($properties['class']))
+            if (!is_string($properties['class']))
             {
                 throw new AnnotationException('The @di annotation requires a property "class" of type string');
             }
@@ -215,20 +215,20 @@ 
     {
         // 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;

src/AnnotationReader.php

Spacing +15 added lines, -15 removed lines

@@ -78,7 +78,7 @@ 
      */
     public static function register(Container $di, bool $bForce = false)
     {
-        if(!$bForce && $di->h(AnnotationReader::class))
+        if (!$bForce && $di->h(AnnotationReader::class))
         {
             return;
         }
@@ -114,13 +114,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
             }
@@ -141,7 +141,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;
             }
@@ -150,11 +150,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');
         }
@@ -185,10 +185,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;
                 }
@@ -199,19 +199,19 @@ 
             ContainerAnnotation::$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;
             }
@@ -220,21 +220,21 @@ 
             ContainerAnnotation::$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());
         }