Add support for attributes on interfaces

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.1](https://github.com/cspray/annotated-target/tree/v0.1.1) - 2022-06-08
+
+### Fixed
+
+- Fixed a bug where Attributes on interfaces were not properly parsed.
+
 ## [0.1.0](https://github.com/cspray/annotated-target/tree/v0.1.0) - 2022-06-08
 
 ### Added

fixture_src/ClassOnlyAttributeSingleInterface/FooInterface.php

@@ -0,0 +1,10 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture\ClassOnlyAttributeSingleInterface;
+
+use Cspray\AnnotatedTargetFixture\ClassOnly;
+
+#[ClassOnly('foo')]
+interface FooInterface {
+
+}

fixture_src/ClassOnlyAttributeSingleInterfaceFixture.php

@@ -0,0 +1,17 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture;
+
+use Cspray\Typiphy\ObjectType;
+use function Cspray\Typiphy\objectType;
+
+class ClassOnlyAttributeSingleInterfaceFixture implements Fixture {
+
+    public function getPath() : string {
+        return __DIR__ .'/ClassOnlyAttributeSingleInterface';
+    }
+
+    public function fooInterface() : ObjectType {
+        return objectType(ClassOnlyAttributeSingleInterface\FooInterface::class);
+    }
+}

fixture_src/Fixtures.php

@@ -78,4 +78,8 @@ public static function nonPhpFile() : NonPhpFileFixture {
         return new NonPhpFileFixture();
     }
 
+    public static function classOnlyAttributeSingleInterface() : ClassOnlyAttributeSingleInterfaceFixture {
+        return new ClassOnlyAttributeSingleInterfaceFixture();
+    }
+
 }

src/PhpParserAnnotatedTargetParser.php

@@ -83,7 +83,7 @@ public function leaveNode(Node $node) {
                             if (!empty($this->filteredAttributes) && !in_array($attrType, $this->filteredAttributes)) {
                                 continue;
                             }
-                            if ($node instanceof Node\Stmt\Class_) {
+                            if ($node instanceof Node\Stmt\Class_ || $node instanceof Node\Stmt\Interface_) {
                                 ($this->consumer)($this->getAnnotatedTargetFromClassNode($node, $index));
                             } else if ($node instanceof Node\Stmt\Property) {
                                 foreach ($node->props as $prop) {
@@ -106,7 +106,7 @@ public function leaveNode(Node $node) {
                 }
             }
 
-            private function getAnnotatedTargetFromClassNode(Node\Stmt\Class_ $class, int $index) : AnnotatedTarget {
+            private function getAnnotatedTargetFromClassNode(Node\Stmt\Class_|Node\Stmt\Interface_ $class, int $index) : AnnotatedTarget {
                 $classType = $class->namespacedName->toString();
                 return $this->getAnnotatedTarget(fn() => new ReflectionClass($classType), $index);
             }

tests/Unit/ClassOnlyInterfaceAttributeTest.php

@@ -0,0 +1,47 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTarget\Unit;
+
+use Cspray\AnnotatedTargetFixture\ClassOnly;
+use Cspray\AnnotatedTargetFixture\Fixtures;
+use function Cspray\Typiphy\objectType;
+
+uses(AnnotatedTargetParserTestCase::class);
+
+beforeEach()->withFixtures(Fixtures::classOnlyAttributeSingleInterface());
+
+it('counts parsed targets for single class')
+    ->expect(fn() => $this->getTargets())
+    ->toHaveCount(1);
+
+it('ensures all targets are correct type')
+    ->expect(fn() => $this->getTargets())
+    ->toContainOnlyAnnotatedTargets();
+
+it('ensures all targets share target reflection')
+    ->expect(fn() => $this->getTargets())
+    ->toShareTargetReflection();
+
+it('ensures all targets share attribute reflection')
+    ->expect(fn() => $this->getTargets())
+    ->toShareAttributeReflection();
+
+it('ensures all targets share attribute instance')
+    ->expect(fn() => $this->getTargets())
+    ->toShareAttributeInstance();
+
+it('includes target reflection class')
+    ->expect(fn() => $this->getTargets())
+    ->toContainTargetClass(Fixtures::classOnlyAttributeSingleInterface()->fooInterface());
+
+it('includes attribute reflection class')
+    ->expect(fn() => $this->getTargets())
+    ->toContainTargetClassWithAttribute(Fixtures::classOnlyAttributeSingleInterface()->fooInterface(), objectType(ClassOnly::class));
+
+it('includes attribute instance with correct value')
+    ->expect(fn() => $this->getTargets())
+    ->toContainTargetClassWithAttributeInstance(
+        Fixtures::classOnlyAttributeSingleInterface()->fooInterface(),
+        objectType(ClassOnly::class),
+        fn(ClassOnly $classOnly) => $classOnly->value === 'foo'
+    );