Merge pull request #3 from spaceonfire/definition-tags

feat: support definition tags
spaceonfire · Sep 23, 2020 · 9d33910 · 9d33910
2 parents dca148e + 6b8041d
commit 9d33910
Show file tree

Hide file tree

Showing 19 changed files with 414 additions and 24 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -22,6 +22,10 @@ Updates should follow the [Keep a CHANGELOG](http://keepachangelog.com/) princip
 - Nothing
 -->
 
+## [2.1.0] - 2020-09-23
+### Added
+- Support definition tags
+
 ## [2.0.1] - 2020-06-21
 ### Fixed
 - Resolve definition in `Container` class using parent container

diff --git a/src/Container.php b/src/Container.php
@@ -5,6 +5,7 @@
 namespace spaceonfire\Container;
 
 use InvalidArgumentException;
+use spaceonfire\Collection\CollectionInterface;
 use spaceonfire\Container\Argument\ArgumentResolver;
 use spaceonfire\Container\Argument\ResolverInterface;
 use spaceonfire\Container\Definition\DefinitionAggregate;
@@ -45,7 +46,7 @@ final class Container implements ContainerWithServiceProvidersInterface, Contain
 
     /**
      * Container constructor.
-     * @param DefinitionAggregateInterface $definitions
+     * @param DefinitionAggregateInterface|null $definitions
      * @param ServiceProviderAggregateInterface|null $providers
      */
     public function __construct(
@@ -127,7 +128,7 @@ public function get($id, array $arguments = [])
         if ($this->providers->provides($id)) {
             $this->providers->register($id);
 
-            if (!$this->definitions->hasDefinition($id)) {
+            if (!$this->definitions->hasDefinition($id) || $this->definitions->hasTag($id)) {
                 throw new ContainerException(sprintf('Service provider lied about providing (%s) service', $id));
             }
 
@@ -152,4 +153,24 @@ public function invoke(callable $callable, array $arguments = [])
     {
         return ($this->callableInvoker)($callable, $arguments);
     }
+
+    /**
+     * @inheritDoc
+     */
+    public function hasTagged(string $tag): bool
+    {
+        return $this->definitions->hasTag($tag);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getTagged(string $tag): CollectionInterface
+    {
+        if ($this->providers->provides($tag)) {
+            $this->providers->register($tag);
+        }
+
+        return $this->definitions->resolveTagged($tag, $this->getContainer());
+    }
 }
diff --git a/src/ContainerAwareTrait.php b/src/ContainerAwareTrait.php
@@ -12,9 +12,7 @@ trait ContainerAwareTrait
     protected $container;
 
     /**
-     * Set a container
-     * @param ContainerInterface $container
-     * @return $this|ContainerAwareInterface
+     * @inheritDoc
      */
     public function setContainer(ContainerInterface $container): ContainerAwareInterface
     {
@@ -23,8 +21,7 @@ public function setContainer(ContainerInterface $container): ContainerAwareInter
     }
 
     /**
-     * Get the container
-     * @return ContainerInterface
+     * @inheritDoc
      */
     public function getContainer(): ContainerInterface
     {

diff --git a/src/ContainerChain.php b/src/ContainerChain.php
@@ -5,6 +5,8 @@
 namespace spaceonfire\Container;
 
 use Psr\Container\ContainerInterface as PsrContainerInterface;
+use spaceonfire\Collection\Collection;
+use spaceonfire\Collection\CollectionInterface;
 use spaceonfire\Container\Definition\DefinitionInterface;
 use spaceonfire\Container\Exception\ContainerException;
 use spaceonfire\Container\Exception\NotFoundException;
@@ -185,4 +187,36 @@ public function addServiceProvider($provider): ContainerWithServiceProvidersInte
 
         throw new ContainerException('No container provided with support of service providers');
     }
+
+    /**
+     * @inheritDoc
+     */
+    public function hasTagged(string $tag): bool
+    {
+        foreach ($this->chain as $container) {
+            if ($container instanceof ContainerInterface && $container->hasTagged($tag)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getTagged(string $tag): CollectionInterface
+    {
+        $result = new Collection();
+
+        foreach ($this->chain as $container) {
+            if (!$container instanceof ContainerInterface) {
+                continue;
+            }
+
+            $result = $result->merge($container->getTagged($tag));
+        }
+
+        return $result;
+    }
 }
diff --git a/src/ContainerInterface.php b/src/ContainerInterface.php
@@ -5,6 +5,7 @@
 namespace spaceonfire\Container;
 
 use Psr\Container\ContainerInterface as PsrContainerInterface;
+use spaceonfire\Collection\CollectionInterface;
 use spaceonfire\Container\Definition\DefinitionInterface;
 
 interface ContainerInterface extends PsrContainerInterface
@@ -47,4 +48,16 @@ public function add(string $id, $concrete = null, bool $shared = false): Definit
      * @return DefinitionInterface
      */
     public function share(string $id, $concrete = null): DefinitionInterface;
+
+    /**
+     * @param string $tag
+     * @return bool
+     */
+    public function hasTagged(string $tag): bool;
+
+    /**
+     * @param string $tag
+     * @return mixed[]|CollectionInterface
+     */
+    public function getTagged(string $tag): CollectionInterface;
 }
diff --git a/src/Definition/Definition.php b/src/Definition/Definition.php
@@ -30,6 +30,10 @@ final class Definition implements DefinitionInterface
      * @var array[]
      */
     private $methods = [];
+    /**
+     * @var array<string,string>
+     */
+    private $tags = [];
     /**
      * @var object|null
      */
@@ -152,4 +156,29 @@ public function resolve(ContainerInterface $container)
 
         return $this->resolved = $resolved;
     }
+
+    /**
+     * @inheritDoc
+     */
+    public function addTag(string $tag): DefinitionInterface
+    {
+        $this->tags[$tag] = $tag;
+        return $this;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function hasTag(string $tag): bool
+    {
+        return array_key_exists($tag, $this->tags);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getTags(): array
+    {
+        return array_keys($this->tags);
+    }
 }
diff --git a/src/Definition/DefinitionAggregate.php b/src/Definition/DefinitionAggregate.php
@@ -5,6 +5,7 @@
 namespace spaceonfire\Container\Definition;
 
 use spaceonfire\Collection\AbstractCollectionDecorator;
+use spaceonfire\Collection\Collection;
 use spaceonfire\Collection\CollectionInterface;
 use spaceonfire\Collection\IndexedCollection;
 use spaceonfire\Collection\TypedCollection;
@@ -18,6 +19,10 @@ final class DefinitionAggregate extends AbstractCollectionDecorator implements D
      * @var DefinitionFactoryInterface
      */
     private $definitionFactory;
+    /**
+     * @var array<string,string>
+     */
+    private $tags = [];
 
     /**
      * DefinitionAggregate constructor.
@@ -115,4 +120,38 @@ public function resolve(string $id, ContainerInterface $container)
     {
         return $this->getDefinition($id)->resolve($container);
     }
+
+    /**
+     * @inheritDoc
+     */
+    public function hasTag(string $tag): bool
+    {
+        if (array_key_exists($tag, $this->tags)) {
+            return true;
+        }
+
+        /** @var DefinitionInterface $definition */
+        foreach ($this->getIterator() as $definition) {
+            if ($definition->hasTag($tag)) {
+                $this->tags[$tag] = $tag;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function resolveTagged(string $tag, ContainerInterface $container): CollectionInterface
+    {
+        return (new Collection($this->getIterator()))
+            ->filter(static function (DefinitionInterface $definition) use ($tag) {
+                return $definition->hasTag($tag);
+            })
+            ->map(static function (DefinitionInterface $definition) use ($container) {
+                return $definition->resolve($container);
+            });
+    }
 }
diff --git a/src/Definition/DefinitionAggregateInterface.php b/src/Definition/DefinitionAggregateInterface.php
@@ -5,6 +5,7 @@
 namespace spaceonfire\Container\Definition;
 
 use IteratorAggregate;
+use spaceonfire\Collection\CollectionInterface;
 use spaceonfire\Container\ContainerInterface;
 
 interface DefinitionAggregateInterface extends IteratorAggregate
@@ -46,4 +47,19 @@ public function makeDefinition(string $abstract, $concrete, bool $shared = false
      * @return mixed
      */
     public function resolve(string $id, ContainerInterface $container);
+
+    /**
+     * Checks whether tag exists as definition.
+     * @param string $tag
+     * @return bool
+     */
+    public function hasTag(string $tag): bool;
+
+    /**
+     * Resolve and build a collection of concrete values by given tag.
+     * @param string $tag
+     * @param ContainerInterface $container
+     * @return mixed[]|CollectionInterface
+     */
+    public function resolveTagged(string $tag, ContainerInterface $container): CollectionInterface;
 }
diff --git a/src/Definition/DefinitionInterface.php b/src/Definition/DefinitionInterface.php
@@ -42,15 +42,15 @@ public function addArgument(Argument $argument): self;
     public function addArguments(array $arguments): self;
 
     /**
-     * Add a method to be invoked
+     * Add a method to be invoked.
      * @param string $method
      * @param array<string,mixed> $arguments
      * @return $this
      */
     public function addMethodCall(string $method, array $arguments = []): self;
 
     /**
-     * Add multiple methods to be invoked
+     * Add multiple methods to be invoked.
      * @param array<string,array<string,mixed>> $methods
      * @return $this
      */
@@ -62,4 +62,24 @@ public function addMethodCalls(array $methods = []): self;
      * @return mixed
      */
     public function resolve(ContainerInterface $container);
+
+    /**
+     * Add a tag to the definition.
+     * @param string $tag
+     * @return $this
+     */
+    public function addTag(string $tag): self;
+
+    /**
+     * Does the definition have a tag?
+     * @param string $tag
+     * @return bool
+     */
+    public function hasTag(string $tag): bool;
+
+    /**
+     * Returns tags of the definition.
+     * @return string[]
+     */
+    public function getTags(): array;
 }
diff --git a/src/Definition/DefinitionTag.php b/src/Definition/DefinitionTag.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace spaceonfire\Container\Definition;
+
+/**
+ * List of common definitions tags. Use these constants to prevent collision that can be caused by typos in tag names.
+ * Feel free to suggest tag names of your choice.
+ * @package spaceonfire\Container\Definition
+ */
+final class DefinitionTag
+{
+    /**
+     * Mark symfony/console commands
+     * @var string
+     * @see https://symfony.com/doc/current/reference/dic_tags.html#console-command
+     */
+    public const CONSOLE_COMMAND = 'console.command';
+}
diff --git a/src/ReflectionContainer.php b/src/ReflectionContainer.php
@@ -5,6 +5,8 @@
 namespace spaceonfire\Container;
 
 use BadMethodCallException;
+use spaceonfire\Collection\Collection;
+use spaceonfire\Collection\CollectionInterface;
 use spaceonfire\Container\Argument\ArgumentResolver;
 use spaceonfire\Container\Argument\ResolverInterface;
 use spaceonfire\Container\Definition\DefinitionInterface;
@@ -97,4 +99,20 @@ public function share(string $id, $concrete = null): DefinitionInterface
     {
         throw new BadMethodCallException('ReflectionContainer does not support definitions');
     }
+
+    /**
+     * @inheritDoc
+     */
+    public function hasTagged(string $tag): bool
+    {
+        return false;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getTagged(string $tag): CollectionInterface
+    {
+        return new Collection();
+    }
 }