Support for PHP 8.0 class attributes generation

.github/workflows/phpunit.yml

@@ -17,7 +17,6 @@ jobs:
           - "highest"
           - "locked"
         php-version:
-          - "7.4"
           - "8.0"
           - "8.1"
         operating-system:

src/Generator/AttributeGenerator.php

@@ -0,0 +1,82 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Laminas\Code\Generator;
+
+use Laminas\Code\Generator\AttributeGenerator\AttributeAssembler;
+use Laminas\Code\Generator\AttributeGenerator\AttributePrototype;
+use Laminas\Code\Generator\AttributeGenerator\AttributeWithArgumentsAssembler;
+use Laminas\Code\Generator\AttributeGenerator\SimpleAttributeAssembler;
+use ReflectionAttribute;
+use ReflectionClass;
+
+final class AttributeGenerator implements GeneratorInterface
+{
+    private array $assemblers;
+
+    private function __construct(AttributeAssembler ...$assembler)
+    {
+        $this->assemblers = $assembler;
+    }
+
+    public function generate(): string
+    {
+        $generatedAttributes = array_map(fn(AttributeAssembler $attributeAssembler) => $attributeAssembler->assemble(),
+            $this->assemblers,
+        );
+
+        return implode(AbstractGenerator::LINE_FEED, $generatedAttributes);
+    }
+
+    public static function fromPrototype(AttributePrototype ...$attributePrototype): self
+    {
+        $assemblers = [];
+
+        foreach ($attributePrototype as $prototype) {
+            $assemblers[] = self::negotiateAssembler($prototype);
+        }
+
+        return new self(...$assemblers);
+    }
+
+    public static function fromReflection(ReflectionClass $reflectionClass): self
+    {
+        $attributes = $reflectionClass->getAttributes();
+        $assemblers = [];
+
+        foreach ($attributes as $attribute) {
+            $assembler = self::negotiateAssembler($attribute);
+
+            $assemblers[] = $assembler;
+        }
+
+        return new self(...$assemblers);
+    }
+
+    public static function fromArray(array $definitions): self
+    {
+        $assemblers = [];
+
+        foreach ($definitions as $definition) {
+            @list($attributeName, $attributeArguments) = $definition;
+
+            $prototype = new AttributePrototype($attributeName, $attributeArguments ?? []);
+
+            $assemblers[] = self::negotiateAssembler($prototype);
+        }
+
+        return new self(...$assemblers);
+    }
+
+    private static function negotiateAssembler(ReflectionAttribute|AttributePrototype $reflectionPrototype): AttributeAssembler
+    {
+        $hasArguments = !empty($reflectionPrototype->getArguments());
+
+        if ($hasArguments) {
+            return new AttributeWithArgumentsAssembler($reflectionPrototype);
+        }
+
+        return new SimpleAttributeAssembler($reflectionPrototype);
+    }
+}

src/Generator/AttributeGenerator/AbstractAttributeAssembler.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Laminas\Code\Generator\AttributeGenerator;
+
+use ReflectionAttribute;
+
+abstract class AbstractAttributeAssembler implements AttributeAssembler
+{
+    public function __construct(private ReflectionAttribute $attributePrototype)
+    {
+    }
+
+    protected function getName(): string
+    {
+        return $this->attributePrototype->getName();
+    }
+
+    protected function getArguments(): array
+    {
+        return $this->attributePrototype->getArguments();
+    }
+}

src/Generator/AttributeGenerator/AttributeAssembler.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Laminas\Code\Generator\AttributeGenerator;
+
+interface AttributeAssembler
+{
+    public function assemble(): string;
+}

src/Generator/AttributeGenerator/AttributePart.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Laminas\Code\Generator\AttributeGenerator;
+
+//TODO Enum in PHP8.1
+/**
+ * @internal
+ */
+final class AttributePart
+{
+    public const T_ATTR_START = '#[';
+    public const T_ATTR_END = ']';
+
+    public const T_ATTR_ARGUMENTS_LIST_START = '(';
+    public const T_ATTR_ARGUMENTS_LIST_END = ')';
+
+    public const T_ATTR_ARGUMENTS_LIST_ASSIGN_OPERAND = ': ';
+    public const T_ATTR_ARGUMENTS_LIST_SEPARATOR = ', ';
+}

src/Generator/AttributeGenerator/AttributePrototype.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Laminas\Code\Generator\AttributeGenerator;
+
+use ReflectionAttribute;
+
+final class AttributePrototype extends ReflectionAttribute
+{
+    public function __construct(private string $attributeName, private array $arguments = [])
+    {
+    }
+
+    public function getName(): string
+    {
+        return $this->attributeName;
+    }
+
+    public function getArguments(): array
+    {
+        return $this->arguments;
+    }
+}

src/Generator/AttributeGenerator/AttributeWithArgumentsAssembler.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Laminas\Code\Generator\AttributeGenerator;
+
+use Laminas\Code\Generator\AttributeGenerator\Exception\NestedAttributesAreNotSupportedException;
+
+final class AttributeWithArgumentsAssembler extends AbstractAttributeAssembler
+{
+    public function assemble(): string
+    {
+        $attributeName = $this->getName();
+
+        $attributeDefinition = AttributePart::T_ATTR_START . $attributeName . AttributePart::T_ATTR_ARGUMENTS_LIST_START;
+
+        $this->generateArguments($attributeDefinition);
+
+        return $attributeDefinition . AttributePart::T_ATTR_END;
+    }
+
+    private function generateArguments(string &$output): void
+    {
+        $argumentsList = [];
+
+        foreach ($this->getArguments() as $argumentName => $argumentValue) {
+            $argumentsList[] = $argumentName . AttributePart::T_ATTR_ARGUMENTS_LIST_ASSIGN_OPERAND . $this->formatArgumentValue($argumentValue);
+        }
+
+        $output .= implode(AttributePart::T_ATTR_ARGUMENTS_LIST_SEPARATOR, $argumentsList);
+        $output .= AttributePart::T_ATTR_ARGUMENTS_LIST_END;
+    }
+
+    private function formatArgumentValue(mixed $argument): mixed
+    {
+        switch (true) {
+            case is_string($argument):
+                return "'$argument'";
+            case is_bool($argument):
+                return $argument ? 'true' : 'false';
+            case is_array($argument):
+                throw NestedAttributesAreNotSupportedException::create();
+            default:
+                return $argument;
+        }
+    }
+}

src/Generator/AttributeGenerator/Exception/NestedAttributesAreNotSupportedException.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Laminas\Code\Generator\AttributeGenerator\Exception;
+
+use Laminas\Code\Generator\Exception\RuntimeException;
+
+final class NestedAttributesAreNotSupportedException extends RuntimeException
+{
+    public static function create(): self
+    {
+        return new self('Nested attributes are not supported yet');
+    }
+}

src/Generator/AttributeGenerator/Exception/NoSuitableArgumentAssemlberFoundException.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Laminas\Code\Generator\AttributeGenerator\Exception;
+
+use Laminas\Code\Generator\Exception\RuntimeException;
+
+class NoSuitableArgumentAssemblerFoundException extends RuntimeException
+{
+}

src/Generator/AttributeGenerator/Exception/NotEmptyArgumentListException.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Laminas\Code\Generator\AttributeGenerator\Exception;
+
+use Laminas\Code\Generator\Exception\RuntimeException;
+
+final class NotEmptyArgumentListException extends RuntimeException
+{
+}

src/Generator/AttributeGenerator/SimpleAttributeAssembler.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Laminas\Code\Generator\AttributeGenerator;
+
+use Laminas\Code\Generator\AttributeGenerator\Exception\NotEmptyArgumentListException;
+use ReflectionAttribute;
+
+final class SimpleAttributeAssembler extends AbstractAttributeAssembler
+{
+    public function __construct(ReflectionAttribute $attributePrototype)
+    {
+        parent::__construct($attributePrototype);
+
+        $this->assertAttributeWithoutArguments();
+    }
+
+    public function assemble(): string
+    {
+        $attributeName = $this->getName();
+
+        return AttributePart::T_ATTR_START . $attributeName . AttributePart::T_ATTR_END;
+    }
+
+    private function assertAttributeWithoutArguments(): void
+    {
+        $arguments = $this->getArguments();
+
+        if (!empty($arguments)) {
+            throw new NotEmptyArgumentListException('Argument list has to be empty');
+        }
+    }
+}

src/Generator/ClassGenerator.php

@@ -2,6 +2,7 @@
 
 namespace Laminas\Code\Generator;
 
+use Laminas\Code\Generator\AttributeGenerator\AttributeBuilder;
 use Laminas\Code\Reflection\ClassReflection;
 
 use function array_diff;
@@ -68,6 +69,8 @@ class ClassGenerator extends AbstractGenerator implements TraitUsageInterface
     /** @var TraitUsageGenerator Object to encapsulate trait usage logic */
     protected TraitUsageGenerator $traitUsageGenerator;
 
+    private ?AttributeGenerator $attributeGenerator = null;
+
     /**
      * Build a Code Generation Php Object from a Class Reflection
      *
@@ -198,6 +201,10 @@ public static function fromArray(array $array)
                     $docBlock = $value instanceof DocBlockGenerator ? $value : DocBlockGenerator::fromArray($value);
                     $cg->setDocBlock($docBlock);
                     break;
+                case 'attribute':
+                    $generator = $value instanceof AttributeGenerator ? $value : AttributeGenerator::fromArray($value);
+                    $cg->setAttributes($generator);
+                    break;
                 case 'flags':
                     $cg->setFlags($value);
                     break;
@@ -228,17 +235,17 @@ public static function fromArray(array $array)
      * @psalm-param array<class-string>            $interfaces
      * @param PropertyGenerator[]|string[]|array[] $properties
      * @param MethodGenerator[]|string[]|array[]   $methods
-     * @param DocBlockGenerator                    $docBlock
      */
     public function __construct(
-        $name = null,
+        string $name = null,
         $namespaceName = null,
         $flags = null,
         $extends = null,
         array $interfaces = [],
         array $properties = [],
         array $methods = [],
-        $docBlock = null
+        DocBlockGenerator $docBlock = null,
+        AttributeGenerator $attributeGenerator = null,
     ) {
         $this->traitUsageGenerator = new TraitUsageGenerator($this);
 
@@ -266,6 +273,9 @@ public function __construct(
         if ($docBlock !== null) {
             $this->setDocBlock($docBlock);
         }
+        if ($attributeGenerator) {
+            $this->setAttributes($attributeGenerator);
+        }
     }
 
     /**
@@ -336,6 +346,13 @@ public function setDocBlock(DocBlockGenerator $docBlock)
         return $this;
     }
 
+    public function setAttributes(AttributeGenerator $attributeGenerator): self
+    {
+        $this->attributeGenerator = $attributeGenerator;
+
+        return $this;
+    }
+
     /**
      * @return ?DocBlockGenerator
      */
@@ -344,6 +361,11 @@ public function getDocBlock()
         return $this->docBlock;
     }
 
+    public function getAttributes(): ?AttributeGenerator
+    {
+        return $this->attributeGenerator;
+    }
+
     /**
      * @param  int[]|int $flags
      * @return static
@@ -1063,6 +1085,10 @@ public function generate()
             $output .= $docBlock->generate();
         }
 
+        if ($attributeGenerator = $this->getAttributes()) {
+            $output .= $attributeGenerator->generate() . self::LINE_FEED;
+        }
+
         if ($this->isAbstract()) {
             $output .= 'abstract ';
         } elseif ($this->isFinal()) {