Merge pull request #9 from thephpleague/develop

dev-1.2.0
thephpleague · Jan 13, 2015 · 2fb01a4 · 2fb01a4
2 parents 68469a2 + c045e22
commit 2fb01a4
Show file tree

Hide file tree

Showing 9 changed files with 305 additions and 94 deletions.
diff --git a/.gitignore b/.gitignore
@@ -1,4 +1,4 @@
 build
 composer.lock
 docs
-vendor
+vendor
diff --git a/src/Container.php b/src/Container.php
@@ -2,15 +2,14 @@
 
 namespace League\Container;
 
+use League\Container\Definition\CallableDefinition;
 use League\Container\Definition\ClassDefinition;
-use League\Container\Definition\ClosureDefinition;
-use League\Container\Definition\DefinitionInterface;
-use League\Container\Definition\Factory;
+use League\Container\Definition\FactoryInterface;
 
 class Container implements ContainerInterface, \ArrayAccess
 {
     /**
-     * @var \League\Container\Definition\Factory
+     * @var \League\Container\Definition\FactoryInterface
      */
     protected $factory;
 
@@ -29,22 +28,17 @@ class Container implements ContainerInterface, \ArrayAccess
      */
     protected $callables = [];
 
-    /**
-     * @var boolean
-     */
-    protected $caching = true;
-
     /**
      * Constructor
      *
-     * @param array|ArrayAccess|ArrayObject        $config
-     * @param \League\Container\Definition\Factory $factory
+     * @param array|ArrayAccess                             $config
+     * @param \League\Container\Definition\FactoryInterface $factory
      */
     public function __construct(
-        $config          = [],
-        Factory $factory = null
+        $config                   = [],
+        FactoryInterface $factory = null
     ) {
-        $this->factory = (is_null($factory)) ? new Factory : $factory;
+        $this->factory = (is_null($factory)) ? new Definition\Factory : $factory;
 
         $this->addItemsFromConfig($config);
 
@@ -90,8 +84,22 @@ public function singleton($alias, $concrete = null)
     /**
      * {@inheritdoc}
      */
-    public function invokable($alias, callable $concrete)
+    public function invokable($alias, callable $concrete = null)
     {
+        if (is_null($concrete)) {
+            $concrete = $alias;
+        }
+
+        if (is_string($concrete) && strpos($concrete, '::') !== false) {
+            $concrete = explode('::', $concrete);
+        }
+
+        if (! is_callable($concrete)) {
+            throw new \InvalidArgumentException(
+                sprintf('Cannot register callable attached to alias [%s]', $alias)
+            );
+        }
+
         $factory = $this->getDefinitionFactory();
         $definition = $factory($alias, $concrete, $this, true);
 
@@ -149,19 +157,19 @@ public function get($alias, array $args = [])
      */
     public function call($alias, array $args = [])
     {
+        if (is_string($alias) && array_key_exists($alias, $this->callables)) {
+            $definition = $this->callables[$alias];
+
+            return $definition($args);
+        }
+
         if (is_callable($alias)) {
             $callable = $this->reflectCallable($alias);
             $args     = $this->resolveCallableArguments($callable, $args);
 
             return call_user_func_array($alias, $args);
         }
 
-        if (array_key_exists($alias, $this->callables)) {
-            $definition = $this->callables[$alias];
-
-            return $definition($args);
-        }
-
         throw new \RuntimeException(
             sprintf('Unable to call callable [%s], does it exist and is it registered with the container?', $alias)
         );
@@ -179,7 +187,7 @@ protected function resolveDefinition($alias, array $args)
         $definition = $this->items[$alias]['definition'];
         $return     = $definition;
 
-        if ($definition instanceof ClosureDefinition || $definition instanceof ClassDefinition) {
+        if ($definition instanceof CallableDefinition || $definition instanceof ClassDefinition) {
             $return = $definition($args);
         }
 

diff --git a/src/ContainerInterface.php b/src/ContainerInterface.php
@@ -26,11 +26,11 @@ public function singleton($alias, $concrete = null);
     /**
      * Add a callable definition to the container
      *
-     * @param  string   $alias
-     * @param  callable $concrete
+     * @param  string          $alias
+     * @param  callable        $concrete
      * @return \League\Container\Definition\DefinitionInterface
      */
-    public function invokable($alias, callable $concrete);
+    public function invokable($alias, callable $concrete = null);
 
     /**
      * Modify the definition of an already defined service

diff --git a/src/Definition/CallableDefinition.php b/src/Definition/CallableDefinition.php
@@ -15,11 +15,11 @@ class CallableDefinition extends AbstractDefinition implements DefinitionInterfa
     /**
      * Constructor
      *
-     * @param string                      $alias
-     * @param callable                    $concrete
+     * @param string                               $alias
+     * @param string|callable                      $concrete
      * @param \League\Container\ContainerInterface $container
      */
-    public function __construct($alias, callable $concrete, ContainerInterface $container)
+    public function __construct($alias, $concrete, ContainerInterface $container)
     {
         parent::__construct($alias, $container);
 
@@ -31,7 +31,18 @@ public function __construct($alias, callable $concrete, ContainerInterface $cont
      */
     public function __invoke(array $args = [])
     {
-        $resolved = $this->resolveArguments($args);
+        $resolved   = $this->resolveArguments($args);
+        $registered = false;
+
+        if (is_array($this->callable) && is_string($this->callable[0])) {
+            $registered = (
+                $this->container->isRegistered($this->callable[0]) ||
+                $this->container->isSingleton($this->callable[0]) ||
+                class_exists($this->callable[0])
+            );
+
+            $this->callable[0] = ($registered === true) ? $this->container->get($this->callable[0]) : $this->callable[0];
+        }
 
         return call_user_func_array($this->callable, $resolved);
     }

diff --git a/src/Definition/ClosureDefinition.php b/src/Definition/ClosureDefinition.php
@@ -2,35 +2,10 @@
 
 namespace League\Container\Definition;
 
-use League\Container\ContainerInterface;
-use League\Container\Exception;
-
-class ClosureDefinition extends AbstractDefinition implements DefinitionInterface
+/**
+ * @deprecated will be removed in favour of `CallableDefinition`
+ */
+class ClosureDefinition extends CallableDefinition
 {
-    /**
-     * @var \Closure
-     */
-    protected $closure;
-
-    /**
-     * Constructor
-     *
-     * @param string                      $alias
-     * @param \Closure                    $closure
-     * @param \League\Container\ContainerInterface $container
-     */
-    public function __construct($alias, \Closure $closure, ContainerInterface $container)
-    {
-        parent::__construct($alias, $container);
-
-        $this->closure = $closure;
-    }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function __invoke(array $args = [])
-    {
-        return call_user_func_array($this->closure, $this->resolveArguments($args));
-    }
 }
diff --git a/src/Definition/Factory.php b/src/Definition/Factory.php
@@ -4,27 +4,17 @@
 
 use League\Container\ContainerInterface;
 
-class Factory
+class Factory implements FactoryInterface
 {
     /**
-     * Return a definition based on type of concrete
-     *
-     * @param  string                       $alias
-     * @param  mixed                        $concrete
-     * @param  \League\Container\ContainerInterface  $container
-     * @param  boolean                      $callable
-     * @return mixed
+     * {@inheritdoc}
      */
     public function __invoke($alias, $concrete, ContainerInterface $container, $callable = false)
     {
-        if ($callable === true) {
+        if ($concrete instanceof \Closure || $callable === true) {
             return new CallableDefinition($alias, $concrete, $container);
         }
 
-        if ($concrete instanceof \Closure) {
-            return new ClosureDefinition($alias, $concrete, $container);
-        }
-
         if (is_string($concrete) && class_exists($concrete)) {
             return new ClassDefinition($alias, $concrete, $container);
         }

diff --git a/src/Definition/FactoryInterface.php b/src/Definition/FactoryInterface.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace League\Container\Definition;
+
+use League\Container\ContainerInterface;
+
+interface FactoryInterface
+{
+    /**
+     * Return a definition based on type of concrete
+     *
+     * @param  string                               $alias
+     * @param  mixed                                $concrete
+     * @param  \League\Container\ContainerInterface $container
+     * @param  boolean                              $callable
+     * @return mixed
+     */
+    public function __invoke($alias, $concrete, ContainerInterface $container, $callable = false);
+}
diff --git a/tests/Asset/functions.php b/tests/Asset/functions.php
@@ -2,7 +2,10 @@
 
 namespace League\Container\Test\Asset;
 
-function sayHi()
-{
+function sayHi() {
     return 'hi';
 }
+
+function withArgument($argument) {
+    return $argument;
+}