Forwards-compatibility changes

This patch modifies the `AbstractPluginManager` constructor to allow the following combination of arguments:

- No arguments (current behavior).
- Single `ConfigInterface` argument (current behavior); used to configure the instance.
- Single `ContainerInterface` argument (v3 behavior); sets the "parent" locator/"creation context"
- `ContainerInterface` as first argument, array as second (v3 behavior); sets the "parent" locator/"creation context", and uses the second argument to configure the instance.

These changes allow developers the ability to continue to use existing plugin managers when upgrading to v3 (though they will also need to implement a `validate()` method, which will be in the migration guide).

The changes presented are backwards compatible (loosens typehint on initial argument; new, second argument is optional).

Author: weierophinney

src/AbstractPluginManager.php

@@ -9,6 +9,7 @@
 
 namespace Zend\ServiceManager;
 
+use Interop\Container\ContainerInterface;
 use Exception as BaseException;
 
 /**
@@ -57,11 +58,56 @@ abstract class AbstractPluginManager extends ServiceManager implements ServiceLo
      * Add a default initializer to ensure the plugin is valid after instance
      * creation.
      *
-     * @param null|ConfigInterface $configuration
+     * Additionally, the constructor provides forwards compatibility with v3 by
+     * overloading the initial argument. v2 usage expects either null or a
+     * ConfigInterface instance, and will ignore any other arguments. v3 expects
+     * a ContainerInterface instance, and will use an array of configuration to
+     * seed the current instance with services. In most cases, you can ignore the
+     * constructor unless you are writing a specialized factory for your plugin
+     * manager or overriding it.
+     *
+     * @param null|ConfigInterface|ContainerInterface $configOrContainerInstance
+     * @param array $v3config If $configOrContainerInstance is a container, this
+     *     value will be passed to the parent constructor.
+     * @throws Exception\InvalidArgumentException if $configOrContainerInstance
+     *     is neither null, nor a ConfigInterface, nor a ContainerInterface.
      */
-    public function __construct(ConfigInterface $configuration = null)
+    public function __construct($configOrContainerInstance = null, array $v3config = [])
     {
-        parent::__construct($configuration);
+        if (null !== $configOrContainerInstance
+            && ! $configOrContainerInstance instanceof ConfigInterface
+            && ! $configOrContainerInstance instanceof ContainerInterface
+        ) {
+            throw new Exception\InvalidArgumentException(sprintf(
+                '%s expects a ConfigInterface instance or ContainerInterface instance; received %s',
+                get_class($this),
+                (is_object($configOrContainerInstance)
+                    ? get_class($configOrContainerInstance)
+                    : gettype($configOrContainerInstance)
+                )
+            ));
+        }
+
+        if ($configOrContainerInstance instanceof ContainerInterface) {
+            if (property_exists($this, 'serviceLocator')) {
+                if (! empty($v3config)) {
+                    parent::__construct(new Config($v3config));
+                }
+                $this->serviceLocator = $configOrContainerInstance;
+            }
+
+            if (property_exists($this, 'creationContext')) {
+                if (! empty($v3config)) {
+                    parent::__construct($v3config);
+                }
+                $this->creationContext = $configOrContainerInstance;
+            }
+        }
+
+        if ($configOrContainerInstance instanceof ConfigInterface) {
+            parent::__construct($configOrContainerInstance);
+        }
+
         $this->addInitializer(function ($instance) {
             if ($instance instanceof ServiceLocatorAwareInterface) {
                 $instance->setServiceLocator($this);

test/AbstractPluginManagerTest.php

@@ -9,9 +9,11 @@
 
 namespace ZendTest\ServiceManager;
 
+use Interop\Container\ContainerInterface;
 use ReflectionClass;
 use ReflectionObject;
 use Zend\ServiceManager\Config;
+use Zend\ServiceManager\Exception\InvalidArgumentException;
 use Zend\ServiceManager\Exception\RuntimeException;
 use Zend\ServiceManager\ServiceManager;
 use ZendTest\ServiceManager\TestAsset\FooPluginManager;
@@ -283,4 +285,52 @@ public function testWillResetAutoInvokableServiceIfNotValid()
             $this->assertTrue($pluginManager->has(__CLASS__));
         }
     }
+
+    /**
+     * @group migration
+     */
+    public function testConstructorAllowsPassingContainerAsFirstArgument()
+    {
+        $container = $this->prophesize(ContainerInterface::class);
+        $pluginManager = new FooPluginManager($container->reveal());
+        $this->assertSame($container->reveal(), $pluginManager->getServiceLocator());
+    }
+
+    /**
+     * @group migration
+     */
+    public function testConstructorAllowsPassingContainerAndConfigurationArrayAsArguments()
+    {
+        $container = $this->prophesize(ContainerInterface::class);
+        $pluginManager = new FooPluginManager($container->reveal(), ['services' => [
+            __CLASS__ => $this,
+        ]]);
+        $this->assertSame($container->reveal(), $pluginManager->getServiceLocator());
+        $this->assertTrue($pluginManager->has(__CLASS__));
+    }
+
+    public function invalidConstructorArguments()
+    {
+        return [
+            'true'       => [true],
+            'false'      => [false],
+            'zero'       => [0],
+            'int'        => [1],
+            'zero-float' => [0.0],
+            'float'      => [1.1],
+            'string'     => ['invalid'],
+            'array'      => [['services' => [__CLASS__ => $this]]],
+            'object'     => [(object) ['services' => [__CLASS__ => $this]]],
+        ];
+    }
+
+    /**
+     * @group migration
+     * @dataProvider invalidConstructorArguments
+     */
+    public function testPassingArgumentsOtherThanNullConfigOrContainerAsFirstConstructorArgRaisesException($arg)
+    {
+        $this->setExpectedException(InvalidArgumentException::class);
+        new FooPluginManager($arg);
+    }
 }