Refactor to remove class loader, add filepathLoader

_config/config.yml

@@ -35,9 +35,6 @@ SilverStripe\Core\Injector\Injector:
   SilverStripe\GraphQL\Schema\Storage\NameObfuscator:
     class: SilverStripe\GraphQL\Schema\Storage\HybridObfuscator
 
-  SilverStripe\GraphQL\Schema\BulkLoader\Collection:
-    factory: SilverStripe\GraphQL\Schema\BulkLoader\CollectionFactory
-
 SilverStripe\GraphQL\Schema\Schema:
   schemas: []
 ---

src/Schema/BulkLoader/AbstractBulkLoader.php

@@ -9,6 +9,9 @@
 use SilverStripe\GraphQL\Schema\Interfaces\Identifiable;
 use SilverStripe\GraphQL\Schema\Schema;
 
+/**
+ * Provides base functionality to all bulk loaders. Must define a collect() method.
+ */
 abstract class AbstractBulkLoader implements Identifiable, ConfigurationApplier
 {
     use Injectable;
@@ -40,7 +43,7 @@ public function __construct(array $include = [], array $exclude = [])
      */
     public function include(array $include): self
     {
-        $this->includeList = array_merge($this->includeList, $include);
+        $this->includeList = $include;
 
         return $this;
     }
@@ -51,17 +54,17 @@ public function include(array $include): self
      */
     public function exclude(array $exclude): self
     {
-        $this->excludeList = array_merge($this->excludeList, $exclude);
+        $this->excludeList = $exclude;
 
         return $this;
     }
 
     /**
      * @param array $config
-     * @return mixed|AbstractBulkLoader
+     * @return AbstractBulkLoader
      * @throws SchemaBuilderException
      */
-    public function applyConfig(array $config)
+    public function applyConfig(array $config): self
     {
         Schema::assertValidConfig($config, ['include', 'exclude'], ['include']);
         $include = $config['include'];

src/Schema/BulkLoader/BulkLoaderSet.php

@@ -0,0 +1,69 @@
+<?php
+
+
+namespace SilverStripe\GraphQL\Schema\BulkLoader;
+
+use InvalidArgumentException;
+use SilverStripe\Core\ClassInfo;
+
+class BulkLoaderSet
+{
+    /**
+     * @var AbstractBulkLoader[]
+     */
+    private $loaders;
+
+    /**
+     * @var Collection
+     */
+    private $collection;
+
+    /**
+     * BulkLoaderSet constructor.
+     * @param AbstractBulkLoader[] ...$loaders
+     * @param Collection|null $collection
+     */
+    public function __construct(...$loaders, ?Collection $collection = null)
+    {
+        $this->setLoaders($loaders);
+        if ($collection) {
+            $this->setCollection($collection);
+        } else {
+            $this->collection = Collection::create(ClassInfo::allClasses());
+        }
+    }
+
+    public function addLoader(AbstractBulkLoader $loader)
+    {
+        $this->loaders[] = $loader;
+
+        return $this;
+    }
+
+    public function process(): Collection
+    {
+        foreach ($this->loaders as $loader) {
+            $this->collection = $loader->collect($this->collection);
+        }
+    }
+    public function setLoaders($loaders): self
+    {
+        foreach ($loaders as $loader) {
+            if (!$loader instanceof AbstractBulkLoader) {
+                throw new InvalidArgumentException(sprintf(
+                    '%s only accepts instances of %s',
+                    static::class,
+                    AbstractBulkLoader::class
+                ));
+            }
+        }
+        $this->loaders = $loaders;
+    }
+
+    public function setCollection(Collection $collection): self
+    {
+        $this->collection = $collection;
+
+        return $this;
+    }
+}

src/Schema/BulkLoader/Collection.php

@@ -6,30 +6,27 @@
 use Composer\Autoload\ClassLoader;
 use SilverStripe\Core\Injector\Injectable;
 use Exception;
+use ReflectionClass;
 
 /**
- * Defines a collection of class names paired with
+ * Defines a collection of class names paired with file paths
  */
 class Collection
 {
     use Injectable;
 
-    private $manifest;
-
     /**
-     * @var ClassLoader
+     * @var array
      */
-    private $loader;
+    private $manifest;
 
     /**
      * Collection constructor.
-     * @param ClassLoader $loader
      * @param array $classList
      * @throws Exception
      */
-    public function __construct(ClassLoader $loader, array $classList)
+    public function __construct(array $classList)
     {
-        $this->loader = $loader;
         $this->setClassList($classList);
     }
 
@@ -46,7 +43,8 @@ public function setClassList(array $classList): self
             if (!class_exists($class)) {
                 continue;
             }
-            $filePath = $this->loader->findFile($class);
+            $reflection = new ReflectionClass($class);
+            $filePath = $reflection->getFileName();
             if (!$filePath) {
                 continue;
             }

src/Schema/BulkLoader/ExtensionLoader.php

@@ -7,10 +7,16 @@
 use InvalidArgumentException;
 use SilverStripe\Core\Extension;
 
+/**
+ * Loads classes that have a given extension assigned to them.
+ */
 class ExtensionLoader extends AbstractBulkLoader
 {
     const IDENTIFIER = 'extensionLoader';
 
+    /**
+     * @return string
+     */
     public static function getIdentifier(): string
     {
         return self::IDENTIFIER;

src/Schema/BulkLoader/FilepathLoader.php

@@ -0,0 +1,51 @@
+<?php
+
+
+namespace SilverStripe\GraphQL\Schema\BulkLoader;
+
+use SilverStripe\Core\Path;
+
+/**
+ * Loads classes by fuzzy match (glob), relative to the root e.g. `src/*.model.php`
+ */
+class FilepathLoader extends AbstractBulkLoader
+{
+    const IDENTIFIER = 'filepathLoader';
+
+    public static function getIdentifier(): string
+    {
+        return self::IDENTIFIER;
+    }
+
+    /**
+     * @param Collection $collection
+     * @return Collection
+     */
+    public function collect(Collection $collection): Collection
+    {
+        $includedFiles = [];
+        $excludedFiles = [];
+        foreach ($this->includeList as $include) {
+            foreach (glob(Path::join(BASE_PATH, $include)) as $path) {
+                $includedFiles[$path] = true;
+            }
+        }
+        foreach ($this->excludeList as $exclude) {
+            foreach (glob(Path::join(BASE_PATH, $exclude)) as $path) {
+                $excludedFiles[$path] = true;
+            }
+
+        }
+
+        foreach ($collection->getFiles() as $file) {
+            if (!isset($includedFiles[$file])) {
+                $collection->removeFile($file);
+            }
+            if (isset($excludedFiles[$file])) {
+                $collection->removeFile($file);
+            }
+        }
+
+        return $collection;
+    }
+}

src/Schema/BulkLoader/InheritanceLoader.php

@@ -5,6 +5,9 @@
 
 use InvalidArgumentException;
 
+/**
+ * Loads classes that are in a given inheritance tree, e.g. MyApp\Models\Page
+ */
 class InheritanceLoader extends AbstractBulkLoader
 {
     const IDENTIFIER = 'inheritanceLoader';

src/Schema/BulkLoader/NamespaceLoader.php

@@ -3,6 +3,9 @@
 
 namespace SilverStripe\GraphQL\Schema\BulkLoader;
 
+/**
+ * Loads classes based on fuzzy match of FQCN, e.g. App\Models\*
+ */
 class NamespaceLoader extends AbstractBulkLoader
 {
     const IDENTIFIER = 'namespaceLoader';

src/Schema/BulkLoader/Registry.php

@@ -7,6 +7,9 @@
 use SilverStripe\Core\ClassInfo;
 use SilverStripe\Core\Injector\Injector;
 
+/**
+ * Frontend for creating a cached registry instance based on all the qualifying subclasses.
+ */
 class Registry
 {
     /**

src/Schema/BulkLoader/RegistryBackend.php

@@ -7,6 +7,9 @@
 use SilverStripe\GraphQL\Schema\Interfaces\Identifiable;
 use InvalidArgumentException;
 
+/**
+ * The instance of the registry, as composed by the Registry frontend
+ */
 class RegistryBackend
 {
     use Injectable;