Recognise missing models in ClassRegistry::init() (#26)

Recognise model-less tables in ClassRegistry::init()

* Uses schema to understand database structure

#16

Author: ariddlestone

composer.json

@@ -29,7 +29,7 @@
             "ARiddlestone\\PHPStanCakePHP2\\Test\\": "tests/"
         },
         "classmap": [
-            "tests/classes",
+            "tests/Feature/classes",
             "vendor/cakephp/cakephp/lib/Cake/Cache",
             "vendor/cakephp/cakephp/lib/Cake/Config",
             "vendor/cakephp/cakephp/lib/Cake/Console/Shell.php",

extension.neon

@@ -5,6 +5,9 @@ parameters:
       - lib/Cake/Model/Behavior/*.php
       - app/Plugin/*/Model/Behavior/*.php
       - app/Model/Behavior/*.php
+  SchemaService:
+    schemaPaths:
+      - app/Config/Schema/*.php
   stubFiles:
     - stubs/Utility.php
 services:
@@ -14,6 +17,9 @@ services:
   - class: ARiddlestone\PHPStanCakePHP2\ClassModelsExtension
     tags:
       - phpstan.broker.propertiesClassReflectionExtension
+  - class: ARiddlestone\PHPStanCakePHP2\ClassRegistryInitExtension
+    tags:
+      - phpstan.broker.dynamicStaticMethodReturnTypeExtension
   - class: ARiddlestone\PHPStanCakePHP2\ClassTasksExtension
     tags:
       - phpstan.broker.propertiesClassReflectionExtension
@@ -22,7 +28,13 @@ services:
       behaviorPaths: %ModelBehaviorsExtension.behaviorPaths%
     tags:
       - phpstan.broker.methodsClassReflectionExtension
+  - class: ARiddlestone\PHPStanCakePHP2\Service\SchemaService
+    arguments:
+      schemaPaths: %SchemaService.schemaPaths%
 parametersSchema:
   ModelBehaviorsExtension: structure([
     behaviorPaths: listOf(string())
   ])
+  SchemaService: structure([
+    schemaPaths: listOf(string())
+  ])

phpstan.neon.dist

@@ -4,4 +4,4 @@ parameters:
     - src
     - tests
   excludePaths:
-    - tests/data/*
+    - tests/Feature/data/*

src/ClassReflectionFinder.php

@@ -11,16 +11,10 @@
 /**
  * Finds class reflections for all classes at specified glob paths, optionally
  * restricted to children of certain classes.
- *
- * Assumes classes have no namespace, and are named the same as their files, eg.
- * "MyClass" is in a file called "MyClass.php".
  */
 final class ClassReflectionFinder
 {
-    /**
-     * @var ReflectionProvider
-     */
-    private $reflectionProvider;
+    private ReflectionProvider $reflectionProvider;
 
     public function __construct(ReflectionProvider $reflectionProvider)
     {
@@ -36,11 +30,12 @@ public function __construct(ReflectionProvider $reflectionProvider)
      */
     public function getClassReflections(
         array $paths,
-        string $isA = 'stdClass'
+        string $isA = 'stdClass',
+        ?callable $pathToClassName = null
     ): array {
         $classReflections = array_map(
             [$this->reflectionProvider, 'getClass'],
-            $this->getClassNamesFromPaths($paths)
+            $this->getClassNamesFromPaths($paths, $pathToClassName)
         );
         return array_filter(
             $classReflections,
@@ -59,8 +54,10 @@ static function (
      *
      * @throws Exception
      */
-    private function getClassNamesFromPaths(array $paths): array
-    {
+    private function getClassNamesFromPaths(
+        array $paths,
+        ?callable $pathToClassName
+    ): array {
         $classPaths = [];
         foreach ($paths as $path) {
             $filePaths = glob($path);
@@ -69,12 +66,15 @@ private function getClassNamesFromPaths(array $paths): array
             }
             $classPaths = array_merge($classPaths, $filePaths);
         }
-        $classNames = array_map(static function ($classPath) {
-            return basename($classPath, '.php');
-        }, $classPaths);
+        $classNames = array_map($pathToClassName ?? [$this, 'getClassNameFromFileName'], $classPaths);
         return array_filter(
             $classNames,
             [$this->reflectionProvider, 'hasClass']
         );
     }
+
+    private function getClassNameFromFileName(string $fileName): string
+    {
+        return basename($fileName, '.php');
+    }
 }

src/ClassRegistryInitExtension.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace ARiddlestone\PHPStanCakePHP2;
+
+use ARiddlestone\PHPStanCakePHP2\Service\SchemaService;
+use Inflector;
+use PhpParser\ConstExprEvaluator;
+use PhpParser\Node\Expr\StaticCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Type\BooleanType;
+use PHPStan\Type\DynamicStaticMethodReturnTypeExtension;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\ObjectWithoutClassType;
+use PHPStan\Type\Type;
+use PHPStan\Type\UnionType;
+
+class ClassRegistryInitExtension implements DynamicStaticMethodReturnTypeExtension
+{
+    private ReflectionProvider $reflectionProvider;
+
+    private SchemaService $schemaService;
+
+    public function __construct(
+        ReflectionProvider $reflectionProvider,
+        SchemaService $schemaService)
+    {
+        $this->reflectionProvider = $reflectionProvider;
+        $this->schemaService = $schemaService;
+    }
+
+    public function getClass(): string
+    {
+        return 'ClassRegistry';
+    }
+
+    public function isStaticMethodSupported(MethodReflection $methodReflection): bool
+    {
+        return $methodReflection->getName() === 'init';
+    }
+
+    public function getTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, Scope $scope): ?Type
+    {
+        $arg1 = $methodCall->getArgs()[0]->value;
+        $evaluator = new ConstExprEvaluator();
+        $arg1 = $evaluator->evaluateSilently($arg1);
+        if (! is_string($arg1)) {
+            return $this->getDefaultType();
+        }
+        if ($this->reflectionProvider->hasClass($arg1)) {
+            return new ObjectType($arg1);
+        }
+        if ($this->schemaService->hasTable(Inflector::tableize($arg1))) {
+            return new ObjectType('Model');
+        }
+        return $this->getDefaultType();
+    }
+
+    private function getDefaultType(): Type
+    {
+        return new UnionType([
+            new BooleanType(),
+            new ObjectWithoutClassType()
+        ]);
+    }
+}

src/Service/SchemaService.php

@@ -0,0 +1,124 @@
+<?php
+
+namespace ARiddlestone\PHPStanCakePHP2\Service;
+
+use ARiddlestone\PHPStanCakePHP2\ClassReflectionFinder;
+use Exception;
+use PHPStan\BetterReflection\Reflection\Adapter\ReflectionProperty;
+use PHPStan\Reflection\ReflectionProvider;
+use ReflectionProperty as CoreReflectionProperty;
+
+/**
+ * Identifies schema files, and uses them to provide information about tables
+ * and columns in the database.
+ *
+ * @phpstan-type table_schema mixed
+ * @phpstan-type column_schema mixed
+ */
+final class SchemaService
+{
+    private ReflectionProvider $reflectionProvider;
+
+    /**
+     * @var array<string>
+     */
+    private array $schemaPaths;
+
+    /**
+     * @var array<string, table_schema>
+     */
+    private ?array $tableSchemas = null;
+
+    /**
+     * @param ReflectionProvider $reflectionProvider
+     * @param array<string> $schemaPaths
+     */
+    public function __construct(
+        ReflectionProvider $reflectionProvider,
+        array $schemaPaths
+    ) {
+        $this->reflectionProvider = $reflectionProvider;
+        $this->schemaPaths = $schemaPaths;
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function hasTable(string $table): bool
+    {
+        return array_key_exists($table, $this->getTableSchemas());
+    }
+
+    /**
+     * @param string $table
+     * @return table_schema|null
+     * @throws Exception
+     */
+    public function getTableSchema(string $table)
+    {
+        $tableSchemas = $this->getTableSchemas();
+        return array_key_exists($table, $tableSchemas)
+            ? $tableSchemas[$table]
+            : null;
+    }
+
+    /**
+     * @return array<string, table_schema>
+     *
+     * @throws Exception
+     */
+    private function getTableSchemas(): array
+    {
+        if (is_array($this->tableSchemas)) {
+            return $this->tableSchemas;
+        }
+        $cakeSchemaPropertyNames = array_map(
+            function (ReflectionProperty $reflectionProperty) {
+                return $reflectionProperty->getName();
+            },
+            $this->reflectionProvider->getClass('CakeSchema')->getNativeReflection()->getProperties()
+        );
+        $this->tableSchemas = [];
+        $classReflectionFinder = new ClassReflectionFinder(
+            $this->reflectionProvider
+        );
+        $schemaReflections = $classReflectionFinder->getClassReflections(
+            $this->schemaPaths,
+            'CakeSchema',
+            function (string $fileName) {
+                return $this->fileNameToClassName($fileName);
+            }
+        );
+        foreach ($schemaReflections as $schemaReflection) {
+            $propertyNames = array_map(
+                function (ReflectionProperty $reflectionProperty) {
+                    return $reflectionProperty->getName();
+                },
+                $schemaReflection->getNativeReflection()
+                    ->getProperties(CoreReflectionProperty::IS_PUBLIC)
+            );
+            $tableProperties = array_diff($propertyNames, $cakeSchemaPropertyNames);
+            $this->tableSchemas += array_intersect_key(
+                $schemaReflection->getNativeReflection()->getDefaultProperties(),
+                array_fill_keys($tableProperties, null)
+            );
+        }
+
+        return $this->tableSchemas;
+    }
+
+    private function fileNameToClassName(string $fileName): string
+    {
+        return str_replace(
+            ' ',
+            '',
+            ucwords(
+                str_replace(
+                    ['_', '-'],
+                    ' ',
+                    basename($fileName, '.php')
+                )
+            )
+        ) . 'Schema';
+    }
+}

tests/Stubs/UtilityTest.php renamed to tests/Feature/ClassRegistryInitTest.php

@@ -1,17 +1,17 @@
 <?php
 
-namespace ARiddlestone\PHPStanCakePHP2\Test\Stubs;
+namespace ARiddlestone\PHPStanCakePHP2\Test\Feature;
 
 use PHPStan\Testing\TypeInferenceTestCase;
 
-class UtilityTest extends TypeInferenceTestCase
+class ClassRegistryInitTest extends TypeInferenceTestCase
 {
     /**
      * @return mixed[]
      */
     public function dataFileAsserts(): iterable
     {
-        yield from $this->gatherAssertTypes(__DIR__ . '/../data/stubs/class_registry_init.php');
+        yield from $this->gatherAssertTypes(__DIR__ . '/data/class_registry_init.php');
     }
 
     /**
@@ -26,7 +26,7 @@ public function testControllerExtensions(string $assertType, string $file, ...$a
     public static function getAdditionalConfigFiles(): array
     {
         return [
-            __DIR__ . '/../data/phpstan.neon',
+            __DIR__ . '/data/phpstan.neon',
         ];
     }
 }

tests/ComponentExtensionsTest.php renamed to tests/Feature/ComponentExtensionsTest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace ARiddlestone\PHPStanCakePHP2\Test;
+namespace ARiddlestone\PHPStanCakePHP2\Test\Feature;
 
 use PHPStan\Testing\TypeInferenceTestCase;
 

tests/ControllerExtensionsTest.php renamed to tests/Feature/ControllerExtensionsTest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace ARiddlestone\PHPStanCakePHP2\Test;
+namespace ARiddlestone\PHPStanCakePHP2\Test\Feature;
 
 use PHPStan\Testing\TypeInferenceTestCase;
 

tests/ModelExtensionsTest.php renamed to tests/Feature/ModelExtensionsTest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace ARiddlestone\PHPStanCakePHP2\Test;
+namespace ARiddlestone\PHPStanCakePHP2\Test\Feature;
 
 use PHPStan\Testing\TypeInferenceTestCase;
 

tests/ShellExtensionsTest.php renamed to tests/Feature/ShellExtensionsTest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace ARiddlestone\PHPStanCakePHP2\Test;
+namespace ARiddlestone\PHPStanCakePHP2\Test\Feature;
 
 use PHPStan\Testing\TypeInferenceTestCase;