Feature/target parser

composer.json

@@ -18,7 +18,13 @@
     "psr-4": {
       "Cspray\\AnnotatedTarget\\": "tests",
       "Cspray\\AnnotatedTargetFixture\\": "fixture_src"
-    }
+    },
+    "files": [
+      "fixture_src/FunctionOnlyAttributeSingleFunction/foo.php",
+      "fixture_src/RepeatableFunctionOnlyAttributeSingleFunction/foo.php",
+      "fixture_src/FunctionParameterOnlyAttributeSingleFunction/foo.php",
+      "fixture_src/NonPhpFile/BarClass.txt"
+    ]
   },
   "config": {
     "allow-plugins": {

fixture_src/ClassOnly.php

@@ -7,4 +7,8 @@
 #[Attribute(Attribute::TARGET_CLASS)]
 final class ClassOnly {
 
+    public function __construct(
+        public readonly string $value
+    ) {}
+
 }

fixture_src/ClassOnlyAttributeGroupSingleClass/FooClass.php

@@ -0,0 +1,12 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture\ClassOnlyAttributeGroupSingleClass;
+
+use Cspray\AnnotatedTargetFixture\ClassOnly;
+use Cspray\AnnotatedTargetFixture\RepeatableClassOnly;
+use Cspray\AnnotatedTargetFixture\RepeatablePropertyOnly;
+
+#[ClassOnly('baz')]
+#[RepeatableClassOnly('foo'), RepeatableClassOnly('bar')]
+#[RepeatableClassOnly('qux')]
+class FooClass {}

fixture_src/ClassOnlyAttributeGroupSingleClassFixture.php

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

fixture_src/ClassOnlyAttributeSingleClass/FooClass.php

@@ -4,5 +4,5 @@
 
 use Cspray\AnnotatedTargetFixture\ClassOnly;
 
-#[ClassOnly]
+#[ClassOnly('single-class-foobar')]
 class FooClass {}

fixture_src/ConstantOnly.php

@@ -0,0 +1,10 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture;
+
+#[\Attribute(\Attribute::TARGET_CLASS_CONSTANT)]
+final class ConstantOnly {
+
+    public function __construct(public readonly string $value) {}
+
+}

fixture_src/ConstantOnlyAttributeGroupSingleClass/FooClass.php

@@ -0,0 +1,12 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture\ConstantOnlyAttributeGroupSingleClass;
+
+use Cspray\AnnotatedTargetFixture\ConstantOnly;
+
+class FooClass {
+
+    #[ConstantOnly('getting the constant')]
+    private const BAR = 'baz';
+
+}

fixture_src/ConstantOnlyAttributeGroupSingleClassFixture.php

@@ -0,0 +1,18 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture;
+
+use Cspray\Typiphy\ObjectType;
+use function Cspray\Typiphy\objectType;
+
+final class ConstantOnlyAttributeGroupSingleClassFixture implements Fixture {
+
+    public function getPath() : string {
+        return __DIR__ . '/ConstantOnlyAttributeGroupSingleClass';
+    }
+
+    public function fooClass() : ObjectType {
+        return objectType(ConstantOnlyAttributeGroupSingleClass\FooClass::class);
+    }
+
+}

fixture_src/Fixtures.php

@@ -0,0 +1,81 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture;
+
+final class Fixtures {
+
+    private function __construct() {}
+
+    public static function classOnlyAttributeSingleClass() : ClassOnlyAttributeSingleClassFixture {
+        return new ClassOnlyAttributeSingleClassFixture();
+    }
+
+    public static function repeatableClassOnlyAttributeSingleClass() : RepeatableClassOnlyAttributeSingleFixture {
+        return new RepeatableClassOnlyAttributeSingleFixture();
+    }
+
+    public static function multipleDifferentClassOnlyAttributeSingleClass() : MultipleDifferentClassOnlyAttributeSingleClassFixture {
+        return new MultipleDifferentClassOnlyAttributeSingleClassFixture();
+    }
+
+    public static function propertyOnlyAttributeSingleClass() : PropertyOnlyAttributeSingleClassFixture {
+        return new PropertyOnlyAttributeSingleClassFixture();
+    }
+
+    public static function singleAttributeMultiplePropertiesSingleClass() : SingleAttributeMultiplePropertiesSingleClassFixture {
+        return new SingleAttributeMultiplePropertiesSingleClassFixture();
+    }
+
+    public static function repeatablePropertyOnlyAttributeSingleClass() : RepeatablePropertyOnlyAttributeSingleClassFixture {
+        return new RepeatablePropertyOnlyAttributeSingleClassFixture();
+    }
+
+    public static function classOnlyAttributeGroupSingleClass() : ClassOnlyAttributeGroupSingleClassFixture {
+        return new ClassOnlyAttributeGroupSingleClassFixture();
+    }
+
+    public static function constantOnlyAttributeGroupSingleClass() : ConstantOnlyAttributeGroupSingleClassFixture {
+        return new ConstantOnlyAttributeGroupSingleClassFixture();
+    }
+
+    public static function repeatableConstantOnlyAttributeSingleClass() : RepeatableConstantOnlyAttributeSingleClassFixture {
+        return new RepeatableConstantOnlyAttributeSingleClassFixture();
+    }
+
+    public static function singleAttributeMultipleConstantsSingleClass() : SingleAttributeMultipleConstantsSingleClassFixture {
+        return new SingleAttributeMultipleConstantsSingleClassFixture();
+    }
+
+    public static function methodOnlyAttributeSingleClass() : MethodOnlyAttributeSingleClassFixture {
+        return new MethodOnlyAttributeSingleClassFixture();
+    }
+
+    public static function repeatableMethodOnlyAttributeSingleClass() : RepeatableMethodOnlyAttributeSingleClassFixture {
+        return new RepeatableMethodOnlyAttributeSingleClassFixture();
+    }
+
+    public static function parameterOnlyAttributeSingleClass() : ParameterOnlyAttributeSingleClassFixture {
+        return new ParameterOnlyAttributeSingleClassFixture();
+    }
+
+    public static function repeatableParameterOnlyAttributeSingleClass() : RepeatableParameterOnlyAttributeSingleClassFixture {
+        return new RepeatableParameterOnlyAttributeSingleClassFixture();
+    }
+
+    public static function functionOnlyAttributeSingleFunction() : FunctionOnlyAttributeSingleFunctionFixture {
+        return new FunctionOnlyAttributeSingleFunctionFixture();
+    }
+
+    public static function repeatableFunctionOnlyAttributeSingleFunction() : RepeatableFunctionOnlyAttributeSingleFunctionFixture {
+        return new RepeatableFunctionOnlyAttributeSingleFunctionFixture();
+    }
+
+    public static function functionParameterOnlyAttributeSingleFunction() : FunctionParameterOnlyAttributeSingleFunctionFixture {
+        return new FunctionParameterOnlyAttributeSingleFunctionFixture();
+    }
+
+    public static function nonPhpFile() : NonPhpFileFixture {
+        return new NonPhpFileFixture();
+    }
+
+}

fixture_src/FunctionOnly.php

@@ -0,0 +1,10 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture;
+
+#[\Attribute(\Attribute::TARGET_FUNCTION)]
+final class FunctionOnly {
+
+    public function __construct(public readonly string $value) {}
+
+}

fixture_src/FunctionOnlyAttributeSingleFunction/foo.php

@@ -0,0 +1,10 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture\FunctionOnlyAttributeSingleFunction;
+
+use Cspray\AnnotatedTargetFixture\FunctionOnly;
+
+#[FunctionOnly('would a crazy person do this?')]
+function yes() : void {
+
+}

fixture_src/FunctionOnlyAttributeSingleFunctionFixture.php

@@ -0,0 +1,14 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture;
+
+class FunctionOnlyAttributeSingleFunctionFixture implements Fixture {
+
+    public function getPath() : string {
+        return __DIR__ . '/FunctionOnlyAttributeSingleFunction';
+    }
+
+    public function fooFunction() : string {
+        return 'Cspray\\AnnotatedTargetFixture\\FunctionOnlyAttributeSingleFunction\\yes';
+    }
+}

fixture_src/FunctionParameterOnlyAttributeSingleFunction/foo.php

@@ -0,0 +1,9 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture\FunctionParameterOnlyAttributeSingleFunction;
+
+use Cspray\AnnotatedTargetFixture\ParameterOnly;
+
+function withParam(
+    #[ParameterOnly('awesome')] string $param
+) : void {}

fixture_src/FunctionParameterOnlyAttributeSingleFunctionFixture.php

@@ -0,0 +1,14 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture;
+
+final class FunctionParameterOnlyAttributeSingleFunctionFixture implements Fixture {
+
+    public function getPath() : string {
+        return __DIR__ . '/FunctionParameterOnlyAttributeSingleFunction';
+    }
+
+    public function fooFunction() : string {
+        return 'Cspray\\AnnotatedTargetFixture\\FunctionParameterOnlyAttributeSingleFunction\\withParam';
+    }
+}

fixture_src/MethodOnly.php

@@ -5,4 +5,8 @@
 use Attribute;
 
 #[Attribute(Attribute::TARGET_METHOD)]
-final class MethodOnly {}
+final class MethodOnly {
+
+    public function __construct(public readonly string $value) {}
+
+}

fixture_src/MethodOnlyAttributeSingleClass/FooClass.php

@@ -0,0 +1,14 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture\MethodOnlyAttributeSingleClass;
+
+use Cspray\AnnotatedTargetFixture\MethodOnly;
+
+class FooClass {
+
+    #[MethodOnly('is the coolest method')]
+    public function myMethod() : void {
+
+    }
+
+}

fixture_src/MethodOnlyAttributeSingleClassFixture.php

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

fixture_src/MultipleDifferentClassOnlyAttributeSingleClass/FooClass.php

@@ -0,0 +1,11 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture\MultipleDifferentClassOnlyAttributeSingleClass;
+
+use Cspray\AnnotatedTargetFixture\ClassOnly;
+use Cspray\AnnotatedTargetFixture\RepeatableClassOnly;
+
+#[ClassOnly('foo')]
+#[RepeatableClassOnly('bar')]
+#[RepeatableClassOnly('baz')]
+class FooClass {}

fixture_src/MultipleDifferentClassOnlyAttributeSingleClassFixture.php

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

fixture_src/NonPhpFile/BarClass.txt

@@ -0,0 +1,10 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture\NonPhpFile;
+
+use Cspray\AnnotatedTargetFixture\ClassOnly;
+
+#[ClassOnly('not present')]
+class BarClass {
+
+}

fixture_src/NonPhpFile/FooClass.php

@@ -0,0 +1,10 @@
+<?php declare(strict_types=1);
+
+namespace Cspray\AnnotatedTargetFixture\NonPhpFile;
+
+use Cspray\AnnotatedTargetFixture\ClassOnly;
+
+#[ClassOnly('the one')]
+class FooClass {
+
+}

fixture_src/NonPhpFileFixture.php

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