Make RouteInvokableFactory + RoutePluginManager v2/v3 compatible

- Ensured each extend the appropriate v2 interface/class, and implement
  the required methods for both v2 and v3.
- Added `setInvokableClass()` implementation to `RoutePluginManager` to
  mimic work in `configure()` for v2.

Author: weierophinney

src/Router/RouteInvokableFactory.php

@@ -11,7 +11,8 @@
 
 use Interop\Container\ContainerInterface;
 use Zend\ServiceManager\Exception\ServiceNotCreatedException;
-use Zend\ServiceManager\Factory\AbstractFactoryInterface;
+use Zend\ServiceManager\AbstractFactoryInterface;
+use Zend\ServiceManager\ServiceLocatorInterface;
 
 /**
  * Specialized invokable/abstract factory for use with RoutePluginManager.
@@ -22,15 +23,15 @@
 class RouteInvokableFactory implements AbstractFactoryInterface
 {
     /**
-     * Can we create a route instance with the given name?
+     * Can we create a route instance with the given name? (v3)
      *
      * Only works for FQCN $routeName values, for classes that implement RouteInterface.
      *
      * @param ContainerInterface $container
      * @param string $routeName
      * @return bool
      */
-    public function canCreateServiceWithName(ContainerInterface $container, $routeName)
+    public function canCreate(ContainerInterface $container, $routeName)
     {
         if (! class_exists($routeName)) {
             return false;
@@ -43,6 +44,21 @@ public function canCreateServiceWithName(ContainerInterface $container, $routeNa
         return true;
     }
 
+    /**
+     * Can we create a route instance with the given name? (v2)
+     *
+     * Proxies to canCreate().
+     *
+     * @param ServiceLocatorInterface $container
+     * @param string $normalizedName
+     * @param string $routeName
+     * @return bool
+     */
+    public function canCreateServiceWithName(ServiceLocatorInterface $container, $normalizedName, $routeName)
+    {
+        return $this->canCreate($container, $routeName);
+    }
+
     /**
      * Create and return a RouteInterface instance.
      *
@@ -80,4 +96,19 @@ public function __invoke(ContainerInterface $container, $routeName, array $optio
 
         return $routeName::factory($options);
     }
+
+    /**
+     * Create a route instance with the given name. (v2)
+     *
+     * Proxies to __invoke().
+     *
+     * @param ServiceLocatorInterface $container
+     * @param string $normalizedName
+     * @param string $routeName
+     * @return RouteInterface
+     */
+    public function createServiceWithName(ServiceLocatorInterface $container, $normalizedName, $routeName)
+    {
+        return $this($container, $routeName);
+    }
 }

src/Router/RoutePluginManager.php

@@ -11,6 +11,7 @@
 
 use Interop\Container\ContainerInterface;
 use Zend\ServiceManager\AbstractPluginManager;
+use Zend\ServiceManager\Exception\InvalidServiceException;
 use Zend\Stdlib\ArrayUtils;
 
 /**
@@ -33,32 +34,94 @@ class RoutePluginManager extends AbstractPluginManager
     protected $instanceOf = RouteInterface::class;
 
     /**
-     * Do not share instances.
+     * Do not share instances. (v3)
      *
      * @var bool
      */
     protected $shareByDefault = false;
 
+    /**
+     * Do not share instances. (v2)
+     *
+     * @var bool
+     */
+    protected $sharedByDefault = false;
+
     /**
      * Constructor
      *
      * Ensure that the instance is seeded with the RouteInvokableFactory as an
      * abstract factory.
      *
-     * @param ContainerInterface $container
-     * @param array $config
+     * @param ContainerInterface|\Zend\ServiceManager\ConfigInterface $configOrContainerInstance
+     * @param array $v3config
+     */
+    public function __construct($configOrContainerInstance, array $v3config = [])
+    {
+        $this->addAbstractFactory(RouteInvokableFactory::class);
+        parent::__construct($configOrContainerInstance, $v3config);
+    }
+
+    /**
+     * Validate a route plugin. (v2)
+     *
+     * @param object $plugin
+     * @throws InvalidServiceException
+     */
+    public function validate($plugin)
+    {
+        if (! $plugin instanceof $this->instanceOf) {
+            throw new InvalidServiceException(sprintf(
+                'Plugin of type %s is invalid; must implement %s',
+                (is_object($plugin) ? get_class($plugin) : gettype($plugin)),
+                RouteInterface::class
+            ));
+        }
+    }
+
+    /**
+     * Validate a route plugin. (v2)
+     *
+     * @param object $plugin
+     * @throws Exception\RuntimeException
      */
-    public function __construct(ContainerInterface $container, array $config = [])
+    public function validatePlugin($plugin)
     {
-        $config = ArrayUtils::merge(['abstract_factories' => [
-            RouteInvokableFactory::class,
-        ]], $config);
+        try {
+            $this->validate($plugin);
+        } catch (InvalidServiceException $e) {
+            throw new Exception\RuntimeException(
+                $e->getMessage(),
+                $e->getCode(),
+                $e
+            );
+        }
+    }
+
+    /**
+     * Register an invokable class. (v2)
+     *
+     * Create invokable factories + optional aliases for an invokable class.
+     *
+     * @param string $name
+     * @param string $class
+     * @return self
+     */
+    public function setInvokableClass($name, $class)
+    {
+        foreach ($this->createAliasesForInvokables([$name => $class]) as $name => $class) {
+            $this->setAlias($name, $class);
+        }
+
+        foreach ($this->createFactoriesForInvokables([$name => $class]) as $name => $factory) {
+            $this->setFactory($name, $factory);
+        }
 
-        parent::__construct($container, $config);
+        return $this;
     }
 
     /**
-     * Pre-process configuration.
+     * Pre-process configuration. (v3)
      *
      * Checks for invokables, and, if found, maps them to the
      * component-specific RouteInvokableFactory; removes the invokables entry