better way to determine an attribute prefix

Author: jrushlow

src/Maker/MakeRegistrationForm.php

@@ -372,7 +372,10 @@ public function generate(InputInterface $input, ConsoleStyle $io, Generator $gen
             $userManipulator->setIo($io);
 
             if ($this->doctrineHelper->isDoctrineSupportingAttributes()) {
-                $userManipulator->addAttributeToClass(new ClassNameDetails(UniqueEntity::class, '\\', null), ['fields' => [$usernameField], 'message' => sprintf('There is already an account with this %s', $usernameField)]);
+                $userManipulator->addAttributeToClass(
+                    UniqueEntity::class,
+                    ['fields' => [$usernameField], 'message' => sprintf('There is already an account with this %s', $usernameField)]
+                );
             } else {
                 $userManipulator->addAnnotationToClass(
                     UniqueEntity::class,
@@ -400,7 +403,7 @@ public function generate(InputInterface $input, ConsoleStyle $io, Generator $gen
                 'isVerified',
                 ['@ORM\Column(type="boolean")'],
                 false,
-                [$userManipulator->buildAttributeNode(new ClassNameDetails(Column::class, '\\', null, 'ORM'), ['type' => 'boolean'])]
+                [$userManipulator->buildAttributeNode(Column::class, ['type' => 'boolean'], 'ORM')]
             );
             $userManipulator->addAccessorMethod('isVerified', 'isVerified', 'bool', false);
             $userManipulator->addSetter('isVerified', 'bool', false);

src/Util/ClassNameDetails.php

@@ -18,14 +18,12 @@ final class ClassNameDetails
     private $fullClassName;
     private $namespacePrefix;
     private $suffix;
-    private $substitutePrefix;
 
-    public function __construct(string $fullClassName, string $namespacePrefix, string $suffix = null, string $substitutePrefix = null)
+    public function __construct(string $fullClassName, string $namespacePrefix, string $suffix = null)
     {
         $this->fullClassName = $fullClassName;
         $this->namespacePrefix = trim($namespacePrefix, '\\');
         $this->suffix = $suffix;
-        $this->substitutePrefix = $substitutePrefix;
     }
 
     public function getFullName(): string
@@ -54,20 +52,4 @@ public function getRelativeNameWithoutSuffix(): string
     {
         return Str::removeSuffix($this->getRelativeName(), $this->suffix);
     }
-
-    /**
-     * Returns the Short Name of the class with the substitute prefix.
-     *
-     * E.g. \Doctrine\ORM\Mapping\Column::class and the substitutePrefix = ORM,
-     * the ORM\Column will be returned.
-     */
-    public function getShortNameWithSubstitutePrefix(): string
-    {
-        return sprintf('%s\\%s', $this->substitutePrefix, $this->getShortName());
-    }
-
-    public function hasSubstitutePrefix(): bool
-    {
-        return null !== $this->substitutePrefix;
-    }
 }

src/Util/ClassSourceManipulator.php

@@ -100,7 +100,7 @@ public function addEntityField(string $propertyName, array $columnOptions, array
         $attributes = [];
 
         if ($this->useAttributesForDoctrineMapping) {
-            $attributes[] = $this->buildAttributeNode(new ClassNameDetails(Column::class, '\\', null, 'ORM'), $columnOptions);
+            $attributes[] = $this->buildAttributeNode(Column::class, $columnOptions, 'ORM');
         } else {
             $comments[] = $this->buildAnnotationLine('@ORM\Column', $columnOptions);
         }
@@ -145,10 +145,9 @@ public function addEmbeddedEntity(string $propertyName, string $className): void
         } else {
             $attributes = [
                 $this->buildAttributeNode(
-                    new ClassNameDetails(Embedded::class, '\\', null, 'ORM'),
-                    [
-                        'class' => new ClassNameValue($className, $typeHint),
-                    ]
+                    Embedded::class,
+                    ['class' => new ClassNameValue($className, $typeHint)],
+                    'ORM'
                 ),
             ];
         }
@@ -368,9 +367,9 @@ public function addProperty(string $name, array $annotationLines = [], $defaultV
         $this->addNodeAfterProperties($newPropertyNode);
     }
 
-    public function addAttributeToClass(ClassNameDetails $attributeClass, array $options): void
+    public function addAttributeToClass(string $attributeClass, array $options): void
     {
-        $this->addUseStatementIfNecessary($attributeClass->getFullName());
+        $this->addUseStatementIfNecessary($attributeClass);
 
         $classNode = $this->getClassNode();
 
@@ -551,12 +550,11 @@ private function addSingularRelation(BaseRelation $relation): void
                 ),
             ];
         } else {
-            $relationClass = $relation instanceof RelationManyToOne ? ManyToOne::class : OneToOne::class;
-
             $attributes = [
                 $this->buildAttributeNode(
-                    new ClassNameDetails($relationClass, '\\', null, 'ORM'),
-                    $annotationOptions
+                    $relation instanceof RelationManyToOne ? ManyToOne::class : OneToOne::class,
+                    $annotationOptions,
+                    'ORM'
                 ),
             ];
         }
@@ -567,9 +565,7 @@ private function addSingularRelation(BaseRelation $relation): void
                     'nullable' => false,
                 ]);
             } else {
-                $attributes[] = $this->buildAttributeNode(new ClassNameDetails(JoinColumn::class, '\\', null, 'ORM'), [
-                    'nullable' => false,
-                ]);
+                $attributes[] = $this->buildAttributeNode(JoinColumn::class, ['nullable' => false], 'ORM');
             }
         }
 
@@ -649,12 +645,11 @@ private function addCollectionRelation(BaseCollectionRelation $relation): void
                 ),
             ];
         } else {
-            $relationClassName = $relation instanceof RelationManyToMany ? ManyToMany::class : OneToMany::class;
-
             $attributes = [
                 $this->buildAttributeNode(
-                    new ClassNameDetails($relationClassName, '\\', null, 'ORM'),
-                    $annotationOptions
+                    $relation instanceof RelationManyToMany ? ManyToMany::class : OneToMany::class,
+                    $annotationOptions,
+                    'ORM'
                 ),
             ];
         }
@@ -928,21 +923,21 @@ public function addUseStatementIfNecessary(string $class): string
     /**
      * Builds a PHPParser attribute node.
      *
-     * @param ClassNameDetails $attributeClass The attribute class which should be used for the attribute. If the class has a substitute
+     * @param string $attributeClass The attribute class which should be used for the attribute. If the class has a substitute
      *                                         prefix, the node is built using the prefix. E.g. #[ORM\Column()] Otherwise, the
      *                                         short name is used. E.g. #[Column()]
      * @param array            $options        the named arguments for the attribute ($key = argument name, $value = argument value)
      */
-    public function buildAttributeNode(ClassNameDetails $attributeClass, array $options): Node\Attribute
+    public function buildAttributeNode(string $attributeClass, array $options, string $attributePrefix = null): Node\Attribute
     {
-        $options = $this->sortOptionsByClassConstructorParameters($options, $attributeClass->getFullName());
+        $options = $this->sortOptionsByClassConstructorParameters($options, $attributeClass);
 
         $context = $this;
         $nodeArguments = array_map(static function ($option, $value) use ($context) {
             return new Node\Arg($context->buildNodeExprByValue($value), false, false, [], new Node\Identifier($option));
         }, array_keys($options), array_values($options));
 
-        $class = $attributeClass->hasSubstitutePrefix() ? $attributeClass->getShortNameWithSubstitutePrefix() : $attributeClass->getShortName();
+        $class = $attributePrefix ? sprintf('%s\\%s', $attributePrefix, Str::getShortClassName($attributeClass)) : Str::getShortClassName($attributeClass);
 
         return new Node\Attribute(
             new Node\Name($class),