Adds a compiler pass for generators rather than config (removes need for default configuration)

Author: leightonthomas

README.md

@@ -24,17 +24,6 @@ public function registerBundles()
         new Vivait\StringGeneratorBundle\VivaitStringGeneratorBundle(),
 }
 ```  
-## Configure
-
-The default configuration is shown below:
-
-```yaml
-vivait_string_generator:
-  generators:
-    string: vivait_generator.generator.string
-    secure_bytes: vivait_generator.generator.secure_bytes
-    secure_string: vivait_generator.generator.secure_string
-```
 
 ## Bundled generators
 
@@ -157,8 +146,14 @@ However, by setting `override` to false, only null properties will have a string
 
 
 ## Custom generators
-You can use your own generators by implementing `GeneratorInterface` and defining the generator in the configuration,
-using either its service or classname.
+You can use your own generators by implementing `GeneratorInterface` and defining the generator in your `services.yml` file with the tag `vivait_generator.generator` and an `alias`, which will be used to identify the Generator in annotations.
+
+```yaml
+vivait_generator.generator.secure_bytes:
+    class: Vivait\StringGeneratorBundle\Generator\SecureBytesGenerator
+    tags:
+        - { name: vivait_generator.generator, alias: 'secure_bytes' }
+```
 
 To create configurable generators, implement `ConfigurableGeneratorInterface`. This interface uses
 [`Symfony\Component\OptionsResolver\OptionsResolver`](http://symfony.com/doc/current/components/options_resolver.html) to set the generator configuration.
@@ -167,30 +162,30 @@ Set default options:
 
 ```php
 /**
-* @param OptionsResolver $resolver
-* @return mixed
-*/
+ * @param OptionsResolver $resolver
+ */
 public function getDefaultOptions(OptionsResolver $resolver)
 {
-  $resolver->setDefaults([
-    'chars' => $this->chars,
-    'length' => $this->length,
-    'prefix' => $this->prefix,
-    ]);
-  }
+  $resolver->setDefaults(
+      [
+        'chars'  => $this->chars,
+        'length' => $this->length,
+        'prefix' => $this->prefix,
+      ]
+  );
+}
   ```
 
 Do something with options:
 
-  ```php
-  /**
-  * @param array $options
-  * @return mixed|void
-  */
-  public function setOptions(array $options)
-  {
-    $this->chars = $options['chars'];
+```php
+/**
+ * @param array $options
+ */
+public function setOptions(array $options)
+{
+    $this->chars  = $options['chars'];
     $this->length = $options['length'];
     $this->prefix = $options['prefix'];
-  }
-  ```
+}
+```

composer.json

@@ -17,7 +17,9 @@
         "symfony/polyfill-php70": "^1.3",
         "symfony/security": "^2.8|^3.0",
         "symfony/options-resolver": "^2.8|^3.0",
-        "ircmaxell/random-lib": "~1.0"
+        "ircmaxell/random-lib": "~1.0",
+        "symfony/dependency-injection": "^3.3",
+        "symfony/config": "^3.3"
     },
     "require-dev": {
         "phpspec/phpspec": "~2.0"

src/Vivait/StringGeneratorBundle/DependencyInjection/Compiler/GeneratorPass.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace AppBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+class GeneratorPass implements CompilerPassInterface
+{
+
+    /**
+     * {@inheritdoc}
+     */
+    public function process(ContainerBuilder $container)
+    {
+        if ( ! $container->has('vivait_generator.registry')) {
+            return;
+        }
+
+        $definition    = $container->findDefinition('vivait_generator.registry');
+        $allGenerators = $container->findTaggedServiceIds('vivait_generator.generator');
+
+        // Loop through all service IDs
+        foreach ($allGenerators as $id => $tags) {
+            // Loop through all of the individual tags
+            foreach ($tags as $attributes) {
+                $definition->addMethodCall(
+                    'addGenerator',
+                    [
+                        new Reference($id),
+                        $attributes['alias']
+                    ]
+                );
+            }
+        }
+    }
+}

src/Vivait/StringGeneratorBundle/DependencyInjection/Configuration.php

@@ -7,25 +7,15 @@
 use Symfony\Component\DependencyInjection\Loader;
 use Symfony\Component\HttpKernel\DependencyInjection\ConfigurableExtension;
 
-/**
- * This is the class that loads and manages your bundle configuration
- *
- * To learn more see {@link http://symfony.com/doc/current/cookbook/bundles/extension.html}
- */
 class VivaitStringGeneratorExtension extends ConfigurableExtension
 {
+
     /**
      * {@inheritdoc}
      */
     public function loadInternal(array $mergedConfig, ContainerBuilder $container)
     {
         $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
         $loader->load('services.yml');
-
-        if($mergedConfig['generators'] && $container->hasDefinition('vivait_generator.registry')){
-            $registry = $container->findDefinition('vivait_generator.registry');
-
-            $registry->replaceArgument(1, $mergedConfig['generators']);
-        }
     }
 }

src/Vivait/StringGeneratorBundle/DependencyInjection/VivaitStringGeneratorExtension.php

@@ -2,35 +2,35 @@
 
 namespace Vivait\StringGeneratorBundle\Registry;
 
-use Symfony\Component\DependencyInjection\ContainerInterface;
 use Vivait\StringGeneratorBundle\Model\GeneratorInterface;
 
 class Registry
 {
-    /**
-     * @var array
-     */
-    private $generators;
 
     /**
-     * @var ContainerInterface
+     * @var array
      */
-    private $container;
+    private $generators = [];
 
     /**
-     * @param ContainerInterface $container
-     * @param array $generators
+     * @param GeneratorInterface $generator
+     * @param string             $alias
      */
-    function __construct(ContainerInterface $container, array $generators = [])
+    public function addGenerator(GeneratorInterface $generator, $alias)
     {
-        $this->container = $container;
-        $this->addAll($generators);
+        if (array_key_exists($alias, $this->generators)) {
+            throw new \InvalidArgumentException("The alias {$alias} is already a registered Generator.");
+        }
+
+        $this->generators[$alias] = $generator;
     }
 
     /**
-     * @param $field
-     * @return GeneratorInterface
+     * @param string $field
+     *
      * @throws \OutOfBoundsException
+     *
+     * @return GeneratorInterface
      */
     public function get($field)
     {
@@ -40,44 +40,4 @@ public function get($field)
 
         throw new \OutOfBoundsException(sprintf('Field "%s" not found in registry', $field));
     }
-
-    /**
-     * @param $field
-     * @param $class
-     * @return $this
-     */
-    public function add($field, $class)
-    {
-        $this->generators[$field] = $this->resolveGeneratorType($class);
-        return $this;
-    }
-
-    /**
-     * @param array $generators
-     * @return $this
-     */
-    public function addAll(array $generators)
-    {
-        foreach ($generators as $field => $class) {
-            $this->add($field, $class);
-        }
-        return $this;
-    }
-
-    /**
-     * @param $class
-     * @return GeneratorInterface
-     */
-    private function resolveGeneratorType($class)
-    {
-        if ($class instanceof GeneratorInterface) {
-            return $class;
-        } elseif (($service = $this->container->get($class, ContainerInterface::NULL_ON_INVALID_REFERENCE))) {
-            return $service;
-        } elseif (is_a($class, 'Vivait\StringGeneratorBundle\Generator\GeneratorInterface', true)) {
-            return new $class;
-        }
-
-        throw new \InvalidArgumentException('Invalid Generator');
-    }
 }

src/Vivait/StringGeneratorBundle/Registry/Registry.php

@@ -10,17 +10,23 @@ services:
 
     vivait_generator.registry:
         class: Vivait\StringGeneratorBundle\Registry\Registry
-        arguments: ["@service_container", []]
 
     vivait_generator.generator.string:
         class: Vivait\StringGeneratorBundle\Generator\StringGenerator
+        tags:
+            - { name: vivait_generator.generator, alias: 'string' }
 
     vivait_generator.generator.secure_bytes:
         class: Vivait\StringGeneratorBundle\Generator\SecureBytesGenerator
+        tags:
+            - { name: vivait_generator.generator, alias: 'secure_bytes' }
 
     vivait_generator.generator.secure_string:
         class: Vivait\StringGeneratorBundle\Generator\SecureStringGenerator
-        arguments: ["@vivait_generator.randomlib"]
+        arguments:
+            - "@vivait_generator.randomlib"
+        tags:
+            - { name: vivait_generator.generator, alias: 'secure_string' }
 
     vivait_generator.randomlib:
         class: RandomLib\Factory

src/Vivait/StringGeneratorBundle/Resources/config/services.yml

@@ -2,8 +2,18 @@
 
 namespace Vivait\StringGeneratorBundle;
 
+use AppBundle\DependencyInjection\Compiler\GeneratorPass;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\HttpKernel\Bundle\Bundle;
 
 class VivaitStringGeneratorBundle extends Bundle
 {
+
+    /**
+     * {@inheritdoc}
+     */
+    public function build(ContainerBuilder $container)
+    {
+        $container->addCompilerPass(new GeneratorPass());
+    }
 }