Refine routes list functionality

README.md

@@ -66,6 +66,19 @@
 | `--has-middleware`  | `-w`          | Accepts a comma-separated list of one or more middleware classes, and filters out routes that do not require those classes. The classes can be fully-qualified, unqualified, or a regular expression, supported by the preg_* functions. For example, "\Mezzio\Middleware\LazyLoadingMiddleware,LazyLoadingMiddleware,\Mezzio*". |
 <!-- markdownlint-enable MD037 -->
 
+##### Configuration
+
+By default, `Mezzio\Tooling\Routes\DefaultRoutesConfigLoaderFactory` registers a `ConfigLoaderInterface` service with the application's DI container, which retrieves the application's routes from two sources:
+
+- `config/routes.php`
+- Routes registered by any loaded `ConfigProvider` class
+
+However, this is a default/fallback implementation.
+If you don't store any routes in _config/routes.php_ or need a custom implementation, then you need to do two things:
+
+1. Write a custom loader implementation that implements `Mezzio\Tooling\Routes\ConfigLoaderInterface`
+2. Register it with the application's DI container as an alias for `Mezzio\Tooling\Routes\ConfigLoaderInterface`
+
 ##### Usage Example
 
 Here is an example of what you can expect from running the command.

src/ConfigProvider.php

@@ -25,8 +25,11 @@
 use Mezzio\Tooling\Module\DeregisterCommandFactory;
 use Mezzio\Tooling\Module\RegisterCommand;
 use Mezzio\Tooling\Module\RegisterCommandFactory;
+use Mezzio\Tooling\Routes\ConfigLoaderInterface;
+use Mezzio\Tooling\Routes\DefaultRoutesConfigLoaderFactory;
 use Mezzio\Tooling\Routes\ListRoutesCommand;
 use Mezzio\Tooling\Routes\ListRoutesCommandFactory;
+use Mezzio\Tooling\Routes\RoutesFileConfigLoader;
 
 final class ConfigProvider
 {
@@ -60,11 +63,14 @@
     }
 
     /**
      * @return array{factories: array<class-string, class-string>}
      */
     public function getDependencies(): array
     {
         return [
+            'aliases'   => [
+                ConfigLoaderInterface::class => RoutesFileConfigLoader::class,
+            ],
             'factories' => [
                 Create::class                                   => CreateFactory::class,
                 CreateActionCommand::class                      => CreateActionCommandFactory::class,
@@ -77,6 +83,7 @@
                 MigrateInteropMiddlewareCommand::class          => MigrateInteropMiddlewareCommandFactory::class,
                 MigrateMiddlewareToRequestHandlerCommand::class => MigrateMiddlewareToRequestHandlerCommandFactory::class,
                 RegisterCommand::class                          => RegisterCommandFactory::class,
+                RoutesFileConfigLoader::class                   => DefaultRoutesConfigLoaderFactory::class,
             ],
         ];
     }

src/Routes/DefaultRoutesConfigLoaderFactory.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Mezzio\Tooling\Routes;
+
+use Mezzio\Application;
+use Mezzio\MiddlewareFactory;
+use Psr\Container\ContainerInterface;
+
+/**
+ * This class provides a default factory implementation for retrieving an app's routes
+
+ * The assumption with this "default" config loader factory is that you're
+ * loading routes from config/routes.php in your Mezzio application. So, if
+ * that's not the case in your application, create a custom loader
+ * implementation and override the alias in the DiC.
+ */
+final class DefaultRoutesConfigLoaderFactory
+{
+    public function __invoke(ContainerInterface $container): ConfigLoaderInterface
+    {
+        /** @var Application $application */
+        $application = $container->get(Application::class);
+
+        /** @var MiddlewareFactory $factory */
+        $factory = $container->get(MiddlewareFactory::class);
+
+        return new RoutesFileConfigLoader(
+            'config/routes.php',
+            $application,
+            $factory,
+            $container
+        );
+    }
+}

src/Routes/Filter/RouteFilterOptions.php

@@ -4,85 +4,65 @@
 
 namespace Mezzio\Tooling\Routes\Filter;
 
-use function get_object_vars;
+use function array_filter;
+use function array_map;
 use function in_array;
-use function is_array;
-use function is_string;
+use function strtoupper;
 
-final class RouteFilterOptions
+final class RouteFilterOptions implements RouteFilterOptionsInterface
 {
-    private string $middleware;
-    private string $name;
-    private string $path;
+    private array $allowedFilterOptions = ['methods', 'middleware', 'name', 'path'];
+    private array $methods;
 
-    /** @var array<array-key,string> */
-    private array $methods = [];
-
-    /**
-     * @param string|array<array-key,string> $methods
-     */
+    /** @param list<string> $methods */
     public function __construct(
-        string $middleware = '',
-        string $name = '',
-        string $path = '',
-        $methods = []
+        private string|null $middleware,
+        private string|null $name,
+        private string|null $path,
+        array $methods
     ) {
-        if (is_string($methods)) {
-            $this->methods = [$methods];
-        }
-        if (is_array($methods)) {
-            $this->methods = $methods;
-        }
-        $this->middleware = $middleware;
-        $this->name       = $name;
-        $this->path       = $path;
+        $methods       = array_filter($methods, 'strlen');
+        $this->methods = array_map(static fn(string $value): string => strtoupper($value), $methods);
+    }
+
+    private function getFilterOptionsMinusMethods(): array
+    {
+        return array_filter($this->allowedFilterOptions, fn($value) => $value !== "methods");
     }
 
     public function has(string $filterOption): bool
     {
-        if (in_array($filterOption, ['middleware', 'name', 'path'])) {
-            return $this->$filterOption !== null;
+        if (! in_array($filterOption, $this->allowedFilterOptions)) {
+            return false;
         }
 
-        if ($filterOption === 'methods') {
-            return [] !== $this->methods;
+        if (in_array($filterOption, $this->getFilterOptionsMinusMethods())) {
+            return $this->$filterOption !== null;
         }
 
-        return false;
+        return $this->methods !== [];
     }
 
-    public function getMiddleware(): string
+    public function getMiddleware(): string|null
     {
         return $this->middleware;
     }
 
-    public function getName(): string
+    public function getName(): string|null
     {
         return $this->name;
     }
 
-    public function getPath(): string
+    public function getPath(): string|null
     {
         return $this->path;
     }
 
     /**
-     * @return array<array-key,string>
+     * @return array<array-key, string>
      */
     public function getMethods(): array
     {
         return $this->methods;
     }
-
-    public function toArray(): array
-    {
-        $values = [];
-        foreach (get_object_vars($this) as $key => $value) {
-            if (! empty($value)) {
-                $values[$key] = $value;
-            }
-        }
-
-        return $values;
-    }
 }

src/Routes/Filter/RouteFilterOptionsInterface.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Mezzio\Tooling\Routes\Filter;
+
+interface RouteFilterOptionsInterface
+{
+    /**
+     * Determines if the specified filter ($filterOption) has been set
+     */
+    public function has(string $filterOption): bool;
+
+    /**
+     * Retrieves a route middleware filter the available routing data by
+     */
+    public function getMiddleware(): string|null;
+
+    /**
+     * Retrieves a route name filter the available routing data by
+     */
+    public function getName(): string|null;
+
+    /**
+     * Retrieves a route path to filter the available routing data by
+     */
+    public function getPath(): string|null;
+
+    /**
+     * Returns any route methods to filter the available routing data by
+     *
+     * @return list<string>
+     */
+    public function getMethods(): array;
+}