Replace string-based references with targeted parameter attributes

- Detect ComposableParameter via reflection instead of reading
  Composable::$prefixParameter
- Resolve prefix strings from class short names via MethodBuilder::classToPrefix()
  instead of reading pre-resolved Composable::$prefix
- Build FQCN→prefix lookup map for resolving class-string arrays in
  Composable::$without/$with
- Add MethodBuilder::classToPrefix() for suffix-aware class-to-prefix resolution
- Update NotHandler fixture to use self::class

Author: alganet

README.md

@@ -135,7 +135,7 @@ composer require respect/fluent
 ```
 
 The `MixinGenerator` discovers composable prefixes and generates per-prefix
-interfaces. For example, a `Not` class with `#[Composable('not')]` produces a
+interfaces. For example, a `Not` class with `#[Composable(self::class)]` produces a
 `NotBuilder` interface containing `notEmail()`, `notString()`, etc., and a root
 `Builder` interface that extends all prefix interfaces.
 

composer.json

@@ -20,7 +20,7 @@
         "phpstan/phpstan-strict-rules": "^2.0",
         "phpunit/phpunit": "^12.5",
         "respect/coding-standard": "^5.0",
-        "respect/fluent": "^1.0"
+        "respect/fluent": "^2.0"
     },
     "suggest": {
         "respect/fluent": "Enables #[Composable] prefix composition support"

composer.lock

@@ -44,6 +44,15 @@ public function __construct(
     ) {
     }
 
+    public function classToPrefix(string $shortName): string
+    {
+        if ($this->classSuffix !== '' && str_ends_with($shortName, $this->classSuffix)) {
+            $shortName = substr($shortName, 0, -strlen($this->classSuffix));
+        }
+
+        return lcfirst($shortName);
+    }
+
     /** @param ReflectionClass<object> $nodeReflection */
     public function build(
         PhpNamespace $namespace,

src/Fluent/MethodBuilder.php

@@ -14,6 +14,7 @@
 use ReflectionClass;
 use ReflectionParameter;
 use Respect\Fluent\Attributes\Composable;
+use Respect\Fluent\Attributes\ComposableParameter;
 use Respect\FluentGen\CodeGenerator;
 use Respect\FluentGen\Config;
 use Respect\FluentGen\FileRenderer;
@@ -27,6 +28,7 @@
  *     name: string,
  *     prefix: string,
  *     optIn: bool,
+ *     fqcn: class-string,
  *     prefixParameter: ReflectionParameter|null,
  * }
  */
@@ -101,24 +103,28 @@ private function discoverPrefixesAndFilters(array $nodes): array
             $attr = $attributes[0]->newInstance();
             $filters[$name] = $attr;
 
-            if ($attr->prefix === '') {
+            if ($attr->prefix === null) {
                 continue;
             }
 
             $constructor = $reflection->getConstructor();
             $prefixParameter = null;
 
-            if ($attr->prefixParameter && $constructor !== null) {
-                $parameters = $constructor->getParameters();
-                if ($parameters !== []) {
-                    $prefixParameter = $parameters[0];
+            if ($constructor !== null) {
+                foreach ($constructor->getParameters() as $param) {
+                    if ($param->getAttributes(ComposableParameter::class) !== []) {
+                        $prefixParameter = $param;
+                        break;
+                    }
                 }
             }
 
-            $prefixes[$attr->prefix] = [
+            $prefix = $this->methodBuilder->classToPrefix($reflection->getShortName());
+            $prefixes[$prefix] = [
                 'name' => $reflection->getShortName(),
-                'prefix' => $attr->prefix,
+                'prefix' => $prefix,
                 'optIn' => $attr->optIn,
+                'fqcn' => $reflection->getName(),
                 'prefixParameter' => $prefixParameter,
             ];
         }
@@ -149,10 +155,10 @@ private function generateInterface(
             $filter = $filters[$name] ?? null;
 
             if ($prefix['optIn']) {
-                if ($filter === null || !in_array($prefix['prefix'], $filter->with, true)) {
+                if ($filter === null || !in_array($prefix['fqcn'], $filter->with, true)) {
                     continue;
                 }
-            } elseif ($filter !== null && in_array($prefix['prefix'], $filter->without, true)) {
+            } elseif ($filter !== null && in_array($prefix['fqcn'], $filter->without, true)) {
                 continue;
             }
 

src/Fluent/MixinGenerator.php

@@ -10,9 +10,11 @@
 
 namespace Respect\FluentGen\Fluent;
 
+use InvalidArgumentException;
 use Nette\PhpGenerator\PhpNamespace;
 use ReflectionClass;
 use Respect\Fluent\Attributes\Composable;
+use Respect\Fluent\Attributes\ComposableParameter;
 use Respect\FluentGen\CodeGenerator;
 use Respect\FluentGen\Config;
 use Respect\FluentGen\FileRenderer;
@@ -22,7 +24,7 @@
 use function array_keys;
 use function ctype_upper;
 use function ksort;
-use function lcfirst;
+use function sprintf;
 use function str_starts_with;
 use function strlen;
 use function uksort;
@@ -33,6 +35,7 @@ public function __construct(
         private Config $config,
         private NamespaceScanner $scanner,
         private string $outputClassName,
+        private MethodBuilder $methodBuilder = new MethodBuilder(),
         private FileRenderer $renderer = new FileRenderer(),
     ) {
     }
@@ -45,9 +48,10 @@ public function generate(): array
             $this->config->sourceNamespace,
         );
         $prefixes = $this->discoverPrefixes($nodes);
+        $fqcnToPrefixMap = $this->buildFqcnMap($nodes);
         $composable = $this->buildComposable($nodes, $prefixes);
         $composableWithArgument = $this->buildComposableWithArgument($prefixes);
-        $forbidden = $this->buildForbidden($nodes, $prefixes);
+        $forbidden = $this->buildForbidden($nodes, $prefixes, $fqcnToPrefixMap);
 
         $namespace = new PhpNamespace($this->config->outputNamespace);
         $class = $namespace->addClass($this->outputClassName);
@@ -78,13 +82,25 @@ private function discoverPrefixes(array $nodes): array
             }
 
             $attr = $attributes[0]->newInstance();
-            if ($attr->prefix === '') {
+            if ($attr->prefix === null) {
                 continue;
             }
 
-            $prefixes[$attr->prefix] = [
-                'prefix' => $attr->prefix,
-                'prefixParameter' => $attr->prefixParameter,
+            $hasPrefixParameter = false;
+            $constructor = $reflection->getConstructor();
+            if ($constructor !== null) {
+                foreach ($constructor->getParameters() as $param) {
+                    if ($param->getAttributes(ComposableParameter::class) !== []) {
+                        $hasPrefixParameter = true;
+                        break;
+                    }
+                }
+            }
+
+            $prefix = $this->methodBuilder->classToPrefix($reflection->getShortName());
+            $prefixes[$prefix] = [
+                'prefix' => $prefix,
+                'prefixParameter' => $hasPrefixParameter,
             ];
         }
 
@@ -107,7 +123,7 @@ private function buildComposable(array $nodes, array $prefixes): array
             $composable[$prefix] = true;
 
             foreach (array_keys($nodes) as $name) {
-                $lcName = lcfirst($name);
+                $lcName = $this->methodBuilder->classToPrefix($name);
                 if ($lcName === $prefix) {
                     continue;
                 }
@@ -129,13 +145,30 @@ private function buildComposable(array $nodes, array $prefixes): array
         return $composable;
     }
 
+    /**
+     * @param array<string, ReflectionClass<object>> $nodes
+     *
+     * @return array<class-string, string>
+     */
+    private function buildFqcnMap(array $nodes): array
+    {
+        $map = [];
+
+        foreach ($nodes as $reflection) {
+            $map[$reflection->getName()] = $this->methodBuilder->classToPrefix($reflection->getShortName());
+        }
+
+        return $map;
+    }
+
     /**
      * @param array<string, ReflectionClass<object>> $nodes
      * @param array<string, array{prefix: string, prefixParameter: bool}> $prefixes
+     * @param array<class-string, string> $fqcnToPrefixMap
      *
      * @return array<string, array<string, true>>
      */
-    private function buildForbidden(array $nodes, array $prefixes): array
+    private function buildForbidden(array $nodes, array $prefixes, array $fqcnToPrefixMap): array
     {
         $forbidden = [];
         $prefixNames = array_keys($prefixes);
@@ -148,7 +181,9 @@ private function buildForbidden(array $nodes, array $prefixes): array
 
             $attr = $attributes[0]->newInstance();
 
-            $blockedPrefixes = $attr->optIn ? array_diff($prefixNames, $attr->with) : $attr->without;
+            $resolvedWith = $this->resolveClassStrings($attr->with, $fqcnToPrefixMap, $name);
+            $resolvedWithout = $this->resolveClassStrings($attr->without, $fqcnToPrefixMap, $name);
+            $blockedPrefixes = $attr->optIn ? array_diff($prefixNames, $resolvedWith) : $resolvedWithout;
 
             if ($blockedPrefixes === []) {
                 continue;
@@ -189,4 +224,27 @@ private function buildComposableWithArgument(array $prefixes): array
 
         return $composableWithArgument;
     }
+
+    /**
+     * @param list<class-string> $classStrings
+     * @param array<class-string, string> $fqcnToPrefixMap
+     *
+     * @return list<string>
+     */
+    private function resolveClassStrings(array $classStrings, array $fqcnToPrefixMap, string $context): array
+    {
+        $resolved = [];
+
+        foreach ($classStrings as $fqcn) {
+            if (!isset($fqcnToPrefixMap[$fqcn])) {
+                throw new InvalidArgumentException(
+                    sprintf('Composable on %s references unknown class %s', $context, $fqcn),
+                );
+            }
+
+            $resolved[] = $fqcnToPrefixMap[$fqcn];
+        }
+
+        return $resolved;
+    }
 }

src/Fluent/PrefixConstantsGenerator.php

@@ -11,7 +11,7 @@
 
 use Respect\Fluent\Attributes\Composable;
 
-#[Composable('not')]
+#[Composable(self::class)]
 final class NotHandler implements Handler
 {
     public function __construct(