Token classifier & refactor filters (#41)

.github/workflows/build.yml

@@ -28,4 +28,4 @@ jobs:
       os: >-
         ['ubuntu-latest', 'windows-latest']
       php: >-
-        ['8.0', '8.1']
+        ['8.1', '8.2']

.github/workflows/composer-require-checker.yml

@@ -30,4 +30,4 @@ jobs:
       os: >-
         ['ubuntu-latest']
       php: >-
-        ['8.0']
+        ['8.1']

.github/workflows/mutation.yml

@@ -26,6 +26,6 @@ jobs:
       os: >-
         ['ubuntu-latest']
       php: >-
-        ['8.1']
+        ['8.2']
     secrets:
       STRYKER_DASHBOARD_API_KEY: ${{ secrets.STRYKER_DASHBOARD_API_KEY }}

.github/workflows/rector.yml

@@ -18,4 +18,4 @@ jobs:
       os: >-
         ['ubuntu-latest']
       php: >-
-        ['8.0']
+        ['8.2']

.github/workflows/static.yml

@@ -28,4 +28,4 @@ jobs:
       os: >-
         ['ubuntu-latest']
       php: >-
-        ['8.0', '8.1']
+        ['8.1', '8.2']

.styleci.yml

@@ -9,6 +9,7 @@ finder:
     - vendor
   not-name:
     - wrong_file.php
+    - namespace.php
 
 enabled:
   - alpha_ordered_traits

composer.json

@@ -28,7 +28,8 @@
     "minimum-stability": "dev",
     "prefer-stable": true,
     "require": {
-        "php": "^8.0",
+        "php": "^8.1",
+        "ext-tokenizer": "*",
         "symfony/finder": "^5.4|^6.0"
     },
     "require-dev": {

src/AbstractClassifier.php

@@ -4,25 +4,24 @@
 
 namespace Yiisoft\Classifier;
 
+use ReflectionClass;
 use Symfony\Component\Finder\Finder;
+use Yiisoft\Classifier\Filter\FilterInterface;
 
 /**
  * Base implementation for {@see ClassifierInterface} with common filters.
  */
 abstract class AbstractClassifier implements ClassifierInterface
 {
     /**
-     * @var string[]
+     * @var array<class-string|trait-string, ReflectionClass>
      */
-    protected array $interfaces = [];
-    /**
-     * @var string[]
-     */
-    protected array $attributes = [];
+    protected static array $reflectionsCache = [];
+
     /**
-     * @psalm-var class-string
+     * @var FilterInterface[]
      */
-    protected ?string $parentClass = null;
+    private array $filters = [];
     /**
      * @var string[]
      */
@@ -33,48 +32,25 @@ public function __construct(string $directory, string ...$directories)
         $this->directories = [$directory, ...array_values($directories)];
     }
 
-    /**
-     * @psalm-param class-string ...$interfaces
-     */
-    public function withInterface(string ...$interfaces): self
-    {
-        $new = clone $this;
-        array_push($new->interfaces, ...array_values($interfaces));
-
-        return $new;
-    }
-
-    /**
-     * @psalm-param class-string $parentClass
-     */
-    public function withParentClass(string $parentClass): self
-    {
-        $new = clone $this;
-        $new->parentClass = $parentClass;
-        return $new;
-    }
-
-    /**
-     * @psalm-param class-string ...$attributes
-     */
-    public function withAttribute(string ...$attributes): self
+    public function withFilter(FilterInterface ...$filter): static
     {
         $new = clone $this;
-        array_push($new->attributes, ...array_values($attributes));
+        array_push($new->filters, ...array_values($filter));
 
         return $new;
     }
 
     /**
-     * @psalm-return iterable<class-string>
+     * @return iterable<class-string>
      */
     public function find(): iterable
     {
-        if (empty($this->interfaces) && empty($this->attributes) && $this->parentClass === null) {
-            return [];
+        foreach ($this->getAvailableDeclarations() as $declaration) {
+            if ($this->skipDeclaration($declaration)) {
+                continue;
+            }
+            yield $declaration;
         }
-
-        yield from $this->getAvailableClasses();
     }
 
     protected function getFiles(): Finder
@@ -87,7 +63,31 @@ protected function getFiles(): Finder
     }
 
     /**
-     * @return iterable<class-string>
+     * @param class-string|trait-string $declaration
+     */
+    private function skipDeclaration(string $declaration): bool
+    {
+        try {
+            $reflectionClass = self::$reflectionsCache[$declaration] ??= new ReflectionClass($declaration);
+        } catch (\Throwable) {
+            return true;
+        }
+
+        if ($reflectionClass->isInternal() || $reflectionClass->isAnonymous()) {
+            return true;
+        }
+
+        foreach ($this->filters as $filter) {
+            if (!$filter->match($reflectionClass)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @return iterable<class-string|trait-string>
      */
-    abstract protected function getAvailableClasses(): iterable;
+    abstract protected function getAvailableDeclarations(): iterable;
 }

src/ClassifierInterface.php

@@ -4,16 +4,19 @@
 
 namespace Yiisoft\Classifier;
 
+use Yiisoft\Classifier\Filter\FilterInterface;
+
 /**
  * `Classifier` is a class finder that represents the classes found.
  */
 interface ClassifierInterface
 {
+    public function withFilter(FilterInterface ...$filter): static;
+
     /**
      * Returns all the class names found.
      *
-     * @return iterable List of class names.
-     * @psalm-return iterable<class-string>
+     * @return iterable<class-string> List of class names.
      */
     public function find(): iterable;
 }

src/Filter/ClassAttributes.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Classifier\Filter;
+
+use ReflectionAttribute;
+use ReflectionClass;
+
+final class ClassAttributes implements FilterInterface
+{
+    private array $attributes;
+
+    public function __construct(string ...$attributes)
+    {
+        $this->attributes = $attributes;
+    }
+
+    public function match(ReflectionClass $reflectionClass): bool
+    {
+        if (empty($this->attributes)) {
+            return false;
+        }
+
+        $attributes = $reflectionClass->getAttributes();
+        $attributeNames = array_map(
+            static fn(ReflectionAttribute $attribute) => $attribute->getName(),
+            $attributes
+        );
+
+        return count(array_intersect($this->attributes, $attributeNames)) === count($this->attributes);
+    }
+}

src/Filter/ClassImplements.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Classifier\Filter;
+
+use ReflectionClass;
+
+final class ClassImplements implements FilterInterface
+{
+    private array $interfaces;
+
+    public function __construct(string ...$interfaces)
+    {
+        $this->interfaces = $interfaces;
+    }
+
+    public function match(ReflectionClass $reflectionClass): bool
+    {
+        if (empty($this->interfaces) || $reflectionClass->isInterface()) {
+            return false;
+        }
+        $interfaces = $reflectionClass->getInterfaceNames();
+
+        return count(array_intersect($this->interfaces, $interfaces)) === count($this->interfaces);
+    }
+}

src/Filter/FilterInterface.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Classifier\Filter;
+
+use ReflectionClass;
+
+interface FilterInterface
+{
+    /**
+     * Tests the filter against class.
+     *
+     * @param ReflectionClass $reflectionClass
+     *
+     * @return bool `true` if class matches against filter. Otherwise, `false`.
+     */
+    public function match(ReflectionClass $reflectionClass): bool;
+}

src/Filter/SubclassOf.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Classifier\Filter;
+
+use ReflectionClass;
+
+final class SubclassOf implements FilterInterface
+{
+    /**
+     * @param class-string $class
+     */
+    public function __construct(private string $class)
+    {
+    }
+
+    public function match(ReflectionClass $reflectionClass): bool
+    {
+        return $reflectionClass->isSubclassOf($this->class);
+    }
+}

src/Filter/TargetAttribute.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Classifier\Filter;
+
+use ReflectionAttribute;
+use ReflectionClass;
+
+final class TargetAttribute implements FilterInterface
+{
+    /**
+     * @param class-string $attribute
+     */
+    public function __construct(private string $attribute)
+    {
+    }
+
+    public function match(ReflectionClass $reflectionClass): bool
+    {
+        $attributes = $reflectionClass->getAttributes($this->attribute, ReflectionAttribute::IS_INSTANCEOF);
+        $attributeNames = array_map(
+            static fn(ReflectionAttribute $attribute) => $attribute->getName(),
+            $attributes
+        );
+
+        return !empty($attributeNames);
+    }
+}