Typehint against ContainerInterface and allow merge config

bakura10 · weierophinney · commit 3cda6284157a · 2015-09-14T11:47:09.000-05:00
diff --git a/src/AbstractPluginManager.php b/src/AbstractPluginManager.php
@@ -9,6 +9,7 @@
 
 namespace Zend\ServiceManager;
 
+use Interop\Container\ContainerInterface;
 use Zend\ServiceManager\Exception\InvalidServiceException;
 
 /**
@@ -21,13 +22,13 @@ abstract class AbstractPluginManager extends ServiceManager implements PluginMan
      *
      * @var null|string
      */
-    In $instanceOf = null;
+    protected $instanceOf = null;
 
     /**
-     * @param ServiceLocatorInterface $parentLocator
-     * @param array                   $config
+     * @param ContainerInterface $parentLocator
+     * @param array              $config
      */
-    public function __construct(ServiceLocatorInterface $parentLocator, array $config)
+    public function __construct(ContainerInterface $parentLocator, array $config)
     {
         parent::__construct($config);
         $this->creationContext = $parentLocator;
diff --git a/src/Factory/DelegatorFactoryInterface.php b/src/Factory/DelegatorFactoryInterface.php
@@ -9,7 +9,7 @@
 
 namespace Zend\ServiceManager\Factory;
 
-use Zend\ServiceManager\ServiceLocatorInterface;
+use Interop\Container\ContainerInterface;
 
 /**
  * Delegator factory interface
@@ -19,11 +19,11 @@ interface DelegatorFactoryInterface
     /**
      * A factory that creates delegates of a given service
      *
-     * @param  ServiceLocatorInterface $serviceLocator
-     * @param  string                  $name
-     * @param  callable                $callback
-     * @param  array                   $options
+     * @param  ContainerInterface $container
+     * @param  string             $name
+     * @param  callable           $callback
+     * @param  array              $options
      * @return object
      */
-    public function __invoke(ServiceLocatorInterface $serviceLocator, $name, callable $callback, array $options = []);
+    public function __invoke(ContainerInterface $container, $name, callable $callback, array $options = []);
 }
diff --git a/src/Factory/FactoryInterface.php b/src/Factory/FactoryInterface.php
@@ -9,7 +9,7 @@
 
 namespace Zend\ServiceManager\Factory;
 
-use Zend\ServiceManager\ServiceLocatorInterface;
+use Interop\Container\ContainerInterface;
 
 /**
  * Interface for a factory
@@ -22,10 +22,10 @@ interface FactoryInterface
     /**
      * Create an object
      *
-     * @param  ServiceLocatorInterface $serviceLocator
-     * @param  string                  $requestedName
-     * @param  array                   $options
+     * @param  ContainerInterface $container
+     * @param  string             $requestedName
+     * @param  array              $options
      * @return object
      */
-    public function __invoke(ServiceLocatorInterface $serviceLocator, $requestedName, array $options = []);
+    public function __invoke(ContainerInterface $container, $requestedName, array $options = []);
 }
diff --git a/src/Factory/InvokableFactory.php b/src/Factory/InvokableFactory.php
@@ -9,7 +9,7 @@
 
 namespace Zend\ServiceManager\Factory;
 
-use Zend\ServiceManager\ServiceLocatorInterface;
+use Interop\Container\ContainerInterface;
 
 /**
  * Factory to create newable classes
@@ -19,7 +19,7 @@ final class InvokableFactory implements FactoryInterface
     /**
      * {@inheritDoc}
      */
-    public function __invoke(ServiceLocatorInterface $serviceLocator, $requestedName, array $options = [])
+    public function __invoke(ContainerInterface $container, $requestedName, array $options = [])
     {
         return new $requestedName($options);
     }
diff --git a/src/Factory/LazyServiceFactoryFactory.php b/src/Factory/LazyServiceFactoryFactory.php
@@ -9,12 +9,12 @@
 
 namespace Zend\ServiceManager\Factory;
 
+use Interop\Container\ContainerInterface;
 use ProxyManager\Configuration as ProxyConfiguration;
 use ProxyManager\Factory\LazyLoadingValueHolderFactory;
 use ProxyManager\GeneratorStrategy\EvaluatingGeneratorStrategy;
 use Zend\ServiceManager\Exception;
 use Zend\ServiceManager\Proxy\LazyServiceFactory;
-use Zend\ServiceManager\ServiceLocatorInterface;
 
 /**
  * Factory to create a lazy factory
@@ -24,9 +24,9 @@ class LazyServiceFactoryFactory implements FactoryInterface
     /**
      * {@inheritDoc}
      */
-    public function __invoke(ServiceLocatorInterface $serviceLocator, $requestedName, array $options = [])
+    public function __invoke(ContainerInterface $container, $requestedName, array $options = [])
     {
-        $config = $serviceLocator->get('Config');
+        $config = $container->get('config');
 
         if (!isset($config['lazy_services'])) {
             throw new Exception\InvalidArgumentException('Missing "lazy_services" config key');
diff --git a/src/Initializer/InitializerInterface.php b/src/Initializer/InitializerInterface.php
@@ -9,7 +9,7 @@
 
 namespace Zend\ServiceManager\Initializer;
 
-use Zend\ServiceManager\ServiceLocatorInterface;
+use Interop\Container\ContainerInterface;
 
 /**
  * Interface for an initializer
@@ -22,9 +22,9 @@ interface InitializerInterface
     /**
      * Initialize the given instance
      *
-     * @param  ServiceLocatorInterface $serviceLocator
-     * @param  object                  $instance
+     * @param  ContainerInterface $container
+     * @param  object             $instance
      * @return void
      */
-    public function __invoke(ServiceLocatorInterface $serviceLocator, $instance);
+    public function __invoke(ContainerInterface $container, $instance);
 }
diff --git a/src/ServiceLocatorInterface.php b/src/ServiceLocatorInterface.php
@@ -9,29 +9,22 @@
 
 namespace Zend\ServiceManager;
 
+use Interop\Container\ContainerInterface;
 use Zend\ServiceManager\Exception;
 
 /**
  * Interface for service locator
  */
-interface ServiceLocatorInterface
+interface ServiceLocatorInterface extends ContainerInterface
 {
     /**
-     * Retrieve a service by its name, with optional options
+     * Build a service by its name, using optional options (such services are NEVER cached)
      *
      * @param  string $name
      * @param  array  $options
      * @return object
      * @throws Exception\ServiceNotFoundException If no factory/abstract factory could be found to create the instance
      * @throws Exception\ServiceNotCreatedException If factory/delegator fails to create the instance
      */
-    public function get($name, array $options = []);
-
-    /**
-     * Check if the service locator has a registered service for the given name
-     *
-     * @param  string $name
-     * @return bool
-     */
-    public function has($name);
+    public function build($name, array $options = []);
 }
diff --git a/src/ServiceManager.php b/src/ServiceManager.php
@@ -21,7 +21,7 @@
 /**
  * Service Manager
  */
-class ServiceManager implements ServiceLocatorInterface, ContainerInterface
+class ServiceManager implements ServiceLocatorInterface
 {
     /**
      * A list of factories (either as string name or callable)
@@ -83,7 +83,7 @@ class ServiceManager implements ServiceLocatorInterface, ContainerInterface
     protected $shared = [];
 
     /**
-     * @var ServiceLocatorInterface
+     * @var ContainerInterface
      */
     protected $creationContext;
 
@@ -96,6 +96,24 @@ public function __construct(array $config)
         $this->configure($config);
     }
 
+    /**
+     * Create a new service locator with config's merged
+     *
+     * Note that the original service locator is left untouched (as with PSR-7 interfaces)
+     *
+     * @param  array $config
+     * @return ContainerInterface
+     */
+    public function withConfig(array $config)
+    {
+        $container                  = clone $this;
+        $container->creationContext = $container;
+
+        $container->configure($config);
+
+        return $container;
+    }
+
     /**
      * {@inheritDoc}
      *
@@ -139,6 +157,11 @@ public function get($name, array $options = [])
         return $object;
     }
 
+    public function build($name, array $options = [])
+    {
+
+    }
+
     /**
      * {@inheritDoc}
      */
diff --git a/test/AbstractPluginManagerTest.php b/test/AbstractPluginManagerTest.php
@@ -9,11 +9,11 @@
 
 namespace ZendTest\ServiceManager;
 
+use Interop\Container\ContainerInterface;
 use stdClass;
 use Zend\ServiceManager\Exception\InvalidServiceException;
 use Zend\ServiceManager\Factory\FactoryInterface;
 use Zend\ServiceManager\Factory\InvokableFactory;
-use Zend\ServiceManager\ServiceLocatorInterface;
 use ZendTest\ServiceManager\TestAsset\InvokableObject;
 use ZendTest\ServiceManager\TestAsset\SimplePluginManager;
 
@@ -29,12 +29,12 @@ public function testInjectCreationContextInFactories()
             ]
         ];
 
-        $serviceLocator = $this->getMock(ServiceLocatorInterface::class);
-        $pluginManager  = new SimplePluginManager($serviceLocator, $config);
+        $container     = $this->getMock(ContainerInterface::class);
+        $pluginManager = new SimplePluginManager($container, $config);
 
         $invokableFactory->expects($this->once())
                          ->method('__invoke')
-                         ->with($serviceLocator, InvokableObject::class)
+                         ->with($container, InvokableObject::class)
                          ->will($this->returnValue(new InvokableObject()));
 
         $object = $pluginManager->get(InvokableObject::class);
@@ -51,8 +51,8 @@ public function testValidateInstance()
             ]
         ];
 
-        $serviceLocator = $this->getMock(ServiceLocatorInterface::class);
-        $pluginManager  = new SimplePluginManager($serviceLocator, $config);
+        $container     = $this->getMock(ContainerInterface::class);
+        $pluginManager = new SimplePluginManager($container, $config);
 
         // Assert no exception is triggered because the plugin manager validate ObjectWithOptions
         $pluginManager->get(InvokableObject::class);
diff --git a/test/Factory/InvokableFactoryTest.php b/test/Factory/InvokableFactoryTest.php
@@ -9,18 +9,18 @@
 
 namespace ZendTest\ServiceManager\Factory;
 
+use Interop\Container\ContainerInterface;
 use Zend\ServiceManager\Factory\InvokableFactory;
-use Zend\ServiceManager\ServiceLocatorInterface;
 use ZendTest\ServiceManager\TestAsset\InvokableObject;
 
 class InvokableFactoryTest extends \PHPUnit_Framework_TestCase
 {
     public function testCanCreateObject()
     {
-        $serviceLocator = $this->getMock(ServiceLocatorInterface::class);
-        $factory        = new InvokableFactory();
+        $container = $this->getMock(ContainerInterface::class);
+        $factory   = new InvokableFactory();
 
-        $object = $factory($serviceLocator, InvokableObject::class, ['foo' => 'bar']);
+        $object = $factory($container, InvokableObject::class, ['foo' => 'bar']);
 
         $this->assertInstanceOf(InvokableObject::class, $object);
         $this->assertEquals(['foo' => 'bar'], $object->options);
diff --git a/test/Factory/LazyServiceFactoryFactoryTest.php b/test/Factory/LazyServiceFactoryFactoryTest.php
@@ -9,32 +9,32 @@
 
 namespace ZendTest\ServiceManager\Factory;
 
+use Interop\Container\ContainerInterface;
 use Zend\ServiceManager\Factory\LazyServiceFactoryFactory;
-use Zend\ServiceManager\ServiceLocatorInterface;
 use Zend\ServiceManager\Exception\InvalidArgumentException;
 use ZendTest\ServiceManager\TestAsset\InvokableObject;
 
 class LazyServiceFactoryFactoryTest extends \PHPUnit_Framework_TestCase
 {
     public function testExceptionThrownWhenLazyServiceConfigMissing()
     {
-        $serviceLocator = $this->getMock(ServiceLocatorInterface::class);
-        $factory        = new LazyServiceFactoryFactory();
+        $container = $this->getMock(ContainerInterface::class);
+        $factory   = new LazyServiceFactoryFactory();
 
         $this->setExpectedException(
             InvalidArgumentException::class,
             'Missing "lazy_services" config key'
         );
 
-        $object = $factory($serviceLocator, InvokableObject::class);
+        $object = $factory($container, InvokableObject::class);
     }
 
     public function testExceptionThrownWhenLazyServiceConfigMissingClassMap()
     {
-        $serviceLocator = $this->getMock(ServiceLocatorInterface::class);
-        $serviceLocator->expects($this->once())
+        $container = $this->getMock(ContainerInterface::class);
+        $container->expects($this->once())
             ->method('get')
-            ->with('Config')
+            ->with('config')
             ->will($this->returnValue([
                 'lazy_services' => []
             ]));
@@ -46,6 +46,6 @@ public function testExceptionThrownWhenLazyServiceConfigMissingClassMap()
             'Missing "class_map" config key in "lazy_services"'
         );
 
-        $object = $factory($serviceLocator, InvokableObject::class);
+        $object = $factory($container, InvokableObject::class);
     }
 }
diff --git a/test/ServiceManagerTest.php b/test/ServiceManagerTest.php
@@ -10,6 +10,7 @@
 namespace ZendTest\ServiceManager;
 
 use DateTime;
+use Prophecy\Comparator\Factory;
 use stdClass;
 use Zend\ServiceManager\Exception\ServiceNotCreatedException;
 use Zend\ServiceManager\Factory\FactoryInterface;
@@ -253,4 +254,48 @@ public function testConfigurationTakesPrecedenceWhenMerged()
 
         $serviceManager->get(stdClass::class);
     }
+
+    public function testCanCreateNewLocatorWithMergedConfig()
+    {
+        $serviceManager = new ServiceManager([
+            'factories' => [
+                DateTime::class => InvokableFactory::class
+            ]
+        ]);
+
+        $newServiceManager = $serviceManager->withConfig([
+            'factories' => [
+                stdClass::class => InvokableFactory::class
+            ]
+        ]);
+
+        $this->assertTrue($serviceManager->has(DateTime::class));
+        $this->assertFalse($serviceManager->has(stdClass::class));
+
+        $this->assertTrue($newServiceManager->has(DateTime::class));
+        $this->assertTrue($newServiceManager->has(stdClass::class));
+    }
+
+    public function testOverrideConfigWhenMerged()
+    {
+        $firstFactory  = $this->getMock(FactoryInterface::class);
+        $secondFactory = $this->getMock(FactoryInterface::class);
+
+        $serviceManager = new ServiceManager([
+            'factories' => [
+                DateTime::class => $firstFactory
+            ]
+        ]);
+
+        $newServiceManager = $serviceManager->withConfig([
+            'factories' => [
+                DateTime::class => $secondFactory
+            ]
+        ]);
+
+        $firstFactory->expects($this->never())->method('__invoke');
+        $secondFactory->expects($this->once())->method('__invoke');
+
+        $newServiceManager->get(DateTime::class);
+    }
 }
diff --git a/test/TestAsset/FailingFactory.php b/test/TestAsset/FailingFactory.php
diff --git a/test/TestAsset/SimpleAbstractFactory.php b/test/TestAsset/SimpleAbstractFactory.php

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`
`10`	`10`	`namespace Zend\ServiceManager\Factory;`
`11`	`11`
`12`		`-use Zend\ServiceManager\ServiceLocatorInterface;`
	`12`	`+use Interop\Container\ContainerInterface;`
`13`	`13`
`14`	`14`	`/**`
`15`	`15`	`* Factory to create newable classes`
`@@ -19,7 +19,7 @@ final class InvokableFactory implements FactoryInterface`
`19`	`19`	`/**`
`20`	`20`	`* {@inheritDoc}`
`21`	`21`	`*/`
`22`		`- public function __invoke(ServiceLocatorInterface $serviceLocator, $requestedName, array $options = [])`
	`22`	`+ public function __invoke(ContainerInterface $container, $requestedName, array $options = [])`
`23`	`23`	`{`
`24`	`24`	`return new $requestedName($options);`
`25`	`25`	`}`