Merge pull request #29 from weierophinney/feature/invokable-configuration

Re-instate invokables

Author: mwillbanks

doc/book/migration.md

@@ -57,31 +57,10 @@ Configuration for v2 consisted of the following:
 ]
 ```
 
-In v3, the configuration remains roughly the same, with the following changes:
+In v3, the configuration remains the same, with the following additions:
 
 ```php
 [
-    'services' => [
-        // service name => instance pairs
-    ],
-    'aliases' => [
-        // alias => service name pairs
-    ],
-    'factories' => [
-        // service name => factory pairs
-    ],
-    'abstract_factories' => [
-        // abstract factories
-    ],
-    'initializers' => [
-        // initializers
-    ],
-    'delegators' => [
-        // service name => [ delegator factories ]
-    ],
-    'shared' => [
-        // service name => boolean
-    ],
     'lazy_services' => [
         // The class_map is required if using lazy services:
         'class_map' => [
@@ -92,69 +71,29 @@ In v3, the configuration remains roughly the same, with the following changes:
         'proxies_target_dir' => 'path in which to write generated proxy classes',
         'write_proxy_files'  => true, // boolean; false by default
     ],
-    'share_by_default' => boolean,
 ]
 ```
 
-The main changes are that invokables no longer exist, and that lazy service
-configuration is now integrated.
+The main change is the addition of integrated lazy service configuration is now
+integrated.
 
 ### Invokables
 
-*Invokables no longer exist.* As such, that key is no longer relevant. In each
-case, if the service name is also the name of the class, you can use the
-`InvokableFactory` and assign the service as a factory.
-
-As an example, if you previously had the following configuration:
-
-```php
-return [
-    'invokables' => [
-        'MyClass' => 'MyClass',
-    ],
-];
-```
-
-You will now use the following:
-
-```php
-use Zend\ServiceManager\Factory\InvokableFactory;
-
-return [
-    'factories' => [
-        'MyClass' => InvokableFactory::class,
-    ],
-];
-```
-
-What if you were using a service name that differed from the class name?
-
-```php
-return [
-    'invokables' => [
-        'MyClass' => 'AnotherClass',
-    ],
-];
-```
-
-In this case, you will create two separate entries: an invokable factory for the
-actual class, and an alias to it:
+*Invokables no longer exist,* at least, not identically to how they existed in
+ZF2.
 
-```php
-use Zend\ServiceManager\Factory\InvokableFactory;
+Internally, `ServiceManager` now does the following for `invokables` entries:
 
-return [
-    'aliases' => [
-        'MyClass' => 'AnotherClass',
-    ],
-    'invokables' => [
-        'AnotherClass' => InvokableFactory::class,
-    ],
-];
-```
+- If the name and value match, it creates a `factories` entry mapping the
+  service name to `Zend\ServiceManager\Factory\InvokableFactory`.
+- If the name and value *do not* match, it creates an `aliases` entry mapping the
+  service name to the class name, *and* a `factories` entry mapping the class
+  name to `Zend\ServiceManager\Factory\InvokableFactory`.
 
-Alternately, you can create a dedicated factory for `MyClass` that instantiates
-the correct class.
+This means that you can use your existing `invokables` configuration from
+version 2 in version 3. However, we recommend starting to update your
+configuration to remove `invokables` entries in favor of factories (and aliases,
+if needed).
 
 ### Lazy Services
 

src/ServiceManager.php

@@ -212,6 +212,10 @@ public function has($name, $checkAbstractFactories = false)
      * Valid top keys are:
      *
      * - services: service name => service instance pairs
+     * - invokables: service name => class name pairs for classes that do not
+     *   have required constructor arguments; internally, maps the class to an
+     *   InvokableFactory instance, and creates an alias if the service name
+     *   and class name do not match.
      * - factories: service name => factory pairs; factories may be any
      *   callable, string name resolving to an invokable class, or string name
      *   resolving to a FactoryInterface instance.
@@ -245,6 +249,21 @@ protected function configure(array $config)
             $this->services = $config['services'] + $this->services;
         }
 
+        if (isset($config['invokables']) && ! empty($config['invokables'])) {
+            $aliases   = $this->createAliasesForInvokables($config['invokables']);
+            $factories = $this->createFactoriesForInvokables($config['invokables']);
+
+            if (! empty($aliases)) {
+                $config['aliases'] = (isset($config['aliases']))
+                    ? array_merge($config['aliases'], $aliases)
+                    : $aliases;
+            }
+
+            $config['factories'] = (isset($config['factories']))
+                ? array_merge($config['factories'], $factories)
+                : $factories;
+        }
+
         if (isset($config['factories'])) {
             $this->factories = $config['factories'] + $this->factories;
         }
@@ -577,4 +596,50 @@ private function createLazyServiceDelegatorFactory()
 
         return $this->lazyServicesDelegator;
     }
+
+    /**
+     * Create aliases for invokable classes.
+     *
+     * If an invokable service name does not match the class it maps to, this
+     * creates an alias to the class (which will later be mapped as an
+     * invokable factory).
+     *
+     * @param array $invokables
+     * @return array
+     */
+    private function createAliasesForInvokables(array $invokables)
+    {
+        $aliases = [];
+        foreach ($invokables as $name => $class) {
+            if ($name === $class) {
+                continue;
+            }
+            $aliases[$name] = $class;
+        }
+        return $aliases;
+    }
+
+    /**
+     * Create invokable factories for invokable classes.
+     *
+     * If an invokable service name does not match the class it maps to, this
+     * creates an invokable factory entry for the class name; otherwise, it
+     * creates an invokable factory for the entry name.
+     *
+     * @param array $invokables
+     * @return array
+     */
+    private function createFactoriesForInvokables(array $invokables)
+    {
+        $factories = [];
+        foreach ($invokables as $name => $class) {
+            if ($name === $class) {
+                $factories[$name] = Factory\InvokableFactory::class;
+                continue;
+            }
+
+            $factories[$class] = Factory\InvokableFactory::class;
+        }
+        return $factories;
+    }
 }

test/ServiceManagerTest.php

@@ -148,4 +148,35 @@ public function testShareability($sharedByDefault, $serviceShared, $serviceDefin
 
         $this->assertEquals($shouldBeSameInstance, $a === $b);
     }
+
+    public function testMapsOneToOneInvokablesAsInvokableFactoriesInternally()
+    {
+        $config = [
+            'invokables' => [
+                InvokableObject::class => InvokableObject::class,
+            ],
+        ];
+
+        $serviceManager = new ServiceManager($config);
+        $this->assertAttributeSame([
+            InvokableObject::class => InvokableFactory::class,
+        ], 'factories', $serviceManager, 'Invokable object factory not found');
+    }
+
+    public function testMapsNonSymmetricInvokablesAsAliasPlusInvokableFactory()
+    {
+        $config = [
+            'invokables' => [
+                'Invokable' => InvokableObject::class,
+            ],
+        ];
+
+        $serviceManager = new ServiceManager($config);
+        $this->assertAttributeSame([
+            'Invokable' => InvokableObject::class,
+        ], 'aliases', $serviceManager, 'Alias not found for non-symmetric invokable');
+        $this->assertAttributeSame([
+            InvokableObject::class => InvokableFactory::class,
+        ], 'factories', $serviceManager, 'Factory not found for non-symmetric invokable target');
+    }
 }