Merge pull request #17 from robcaw/feature/ConfigurableGenerator

Feature/configurable generator

Author: rcwsr

README.md

@@ -31,17 +31,35 @@ vivait_string_generator:
   generators:
     string: vivait_generator.generator.string
     secure_bytes: vivait_generator.generator.secure_bytes
+    secure_string: vivait_generator.generator.secure_bytes
+```
+
+## Bundled generators
+
+### `StringGenerator`
+Generates a random string based on a pool or characters. Defaults:
+
+```php
+@Generate(generator="string", options={"length"=8, "chars"="abcdefjhijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345567890", "prefix"=""})
 ```
-### Bundled generators
-* `StringGenerator` generates a random string based on a pool or characters
-* `SecureBytesGenerator` generates a secure random string using the `Symfony\Component\Security\Core\Util\SecureRandom` class
 
-### Custom generators
-You can use your own generators by implementing `GeneratorInterface` and defining the generator in the configuration,
-using either its service or classname.
 
-## Basic usage
+### `SecureBytesGenerator`
+Generates a secure random byte string using the `Symfony\Component\Security\Core\Util\SecureRandom` class. Defaults:
+
+```php
+@Generate(generator="secure_bytes", options={"length"=8})
+```
+
+### `SecureStringGenerator`
+Generates a secure random string using [ircmaxell's RandomLib](https://github.com/ircmaxell/RandomLib). The library provides three different strengths of
+strings(currently `high` is unavailable), `low` and `medium`. Defaults:
+
+```php
+@Generate(generator="secure_string", options={"length"=32, "chars"="", "strength"="medium"})
+```
 
+## Usage
 Add the `@Generate(generator="generator_name")` annotation to an entity property
 (where `generator_name` is the name of a generator defined in the configuration).
 
@@ -75,24 +93,26 @@ class Api
      */
     private $api_key;
 ```
-## Options
 
-### Length
+### Options
+
+Generators that implement `ConfigurableGeneratorInterface`, such as the bundled generators have options which can be configured.
+
+To do this, set the options parameter on the annotation:
 
-To change the length of the generated string, add `length` to the annotation.
 ```php
-@Generate(length=4)
-```  
+@Generate(generator="string", options={"length"=32, "chars"="ABCDEFG"})
+```
 
 ### Callbacks
 
 It's possible to define callbacks on the `Generator` class that you are using.
-For example, with the bundled StringGenerator, you may wish to set the character pool.
+For example, with the bundled StringGenerator, you may wish to set the a prefix on the generated string
 
 This can be achieved by setting the `callbacks` option. For example:
 
 ```php
-@Generate(generator="string", callbacks={"setChars"="ABCDEFG"})
+@Generate(generator="my_generator", callbacks={"setPrefix"="VIVA_"})
 ```
 
 Here, `setChars()` is called in the `StringGenerator` class, passing `ABCDEFG` as a parameter.
@@ -104,7 +124,7 @@ It's even possible to set a callback value dynamically:
  * @var string
  *
  * @ORM\Column(name="short_id", type="string", length=255, nullable=false)
- * @Generate(generator="string", length=5, callbacks={"setPrefix"="getPrefix"})
+ * @Generate(generator="string", options={"length"=32}, callbacks={"setPrefix"="getPrefix"})
  */
 private $short_id;
 
@@ -133,3 +153,43 @@ However, by setting `override` to false, only null properties will have a string
 ```php
 @Generate(generator="string", override=false)
 ```
+
+
+## Custom generators
+You can use your own generators by implementing `GeneratorInterface` and defining the generator in the configuration,
+using either its service or classname.
+
+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.
+
+Set default options:
+
+```php
+/**
+* @param OptionsResolver $resolver
+* @return mixed
+*/
+public function getDefaultOptions(OptionsResolver $resolver)
+{
+  $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'];
+    $this->length = $options['length'];
+    $this->prefix = $options['prefix'];
+  }
+  ```

composer.json

@@ -14,7 +14,9 @@
         "php": ">=5.3.3",
         "doctrine/common": "~2.2",
         "doctrine/orm": "~2.2",
-        "symfony/security": "~2.1"
+        "symfony/security": "~2.1",
+        "symfony/options-resolver": "~2.1",
+        "ircmaxell/random-lib": "~1.0"
     },
     "require-dev": {
         "phpspec/phpspec": "~2.0"

spec/Vivait/StringGeneratorBundle/EventListener/GeneratorListenerSpec.php

@@ -11,8 +11,11 @@
 use Doctrine\ORM\Mapping\ClassMetadata;
 use PhpSpec\ObjectBehavior;
 use Prophecy\Argument;
+use Symfony\Component\OptionsResolver\OptionsResolver;
 use Vivait\StringGeneratorBundle\Annotation\GeneratorAnnotation;
 use Vivait\StringGeneratorBundle\Generator\StringGenerator;
+use Vivait\StringGeneratorBundle\Model\ConfigurableGeneratorInterface;
+use Vivait\StringGeneratorBundle\Model\GeneratorInterface;
 use Vivait\StringGeneratorBundle\Registry\Registry;
 
 class GeneratorListenerSpec extends ObjectBehavior
@@ -58,7 +61,7 @@ function it_can_get_callback_values_from_annotated_object(StringGenerator $gener
         $this->performCallbacks($generator, $annotation, $this->mockEntity);
     }
 
-    function it_sets_null_properties_if_override_set_to_true(Registry $registry, Reader $reader, LifecycleEventArgs $args, StringGenerator $generator)
+    function it_sets_null_properties_if_override_set_to_true(Registry $registry, Reader $reader, LifecycleEventArgs $args, GeneratorInterface $generator)
     {
         $annotation = new GeneratorAnnotation([]);
         $annotation->override = false;
@@ -72,7 +75,7 @@ function it_sets_null_properties_if_override_set_to_true(Registry $registry, Rea
 
         $this->prePersist($args);
     }
-    function it_wont_set_non_null_properties_if_override_set_to_true(Reader $reader, LifecycleEventArgs $args, StringGenerator $generator)
+    function it_wont_set_non_null_properties_if_override_set_to_true(Reader $reader, LifecycleEventArgs $args, GeneratorInterface $generator)
     {
         $this->mockEntity->setName('Robin');
         $annotation = new GeneratorAnnotation([]);
@@ -84,7 +87,7 @@ function it_wont_set_non_null_properties_if_override_set_to_true(Reader $reader,
         $this->prePersist($args);
     }
 
-    function it_generates_a_string_on_a_property(Registry $registry, Reader $reader, LifecycleEventArgs $args, StringGenerator $generator)
+    function it_generates_a_string_on_a_property(Registry $registry, Reader $reader, LifecycleEventArgs $args, GeneratorInterface $generator)
     {
         $annotation = new GeneratorAnnotation([]);
 
@@ -96,6 +99,24 @@ function it_generates_a_string_on_a_property(Registry $registry, Reader $reader,
 
         $this->prePersist($args);
     }
+
+    function it_can_configure_a_generator(Registry $registry, Reader $reader, LifecycleEventArgs $args, ConfigurableGeneratorInterface $generator)
+    {
+        $annotation = new GeneratorAnnotation([]);
+
+        $reader->getPropertyAnnotations(Argument::any())->willReturn([$annotation]);
+
+        $registry->get(Argument::any())->willReturn($generator);
+        $generator->generate()->shouldBeCalled();
+        $generator->setLength(Argument::any())->shouldBeCalled();
+
+        $resolver = new OptionsResolver();
+
+        $generator->getDefaultOptions($resolver)->shouldBeCalled();
+        $generator->setOptions(Argument::any())->shouldBeCalled();
+
+        $this->prePersist($args);
+    }
 }
 
 class Entity

spec/Vivait/StringGeneratorBundle/Generator/SecureStringGeneratorSpec.php

@@ -0,0 +1,89 @@
+<?php
+
+namespace spec\Vivait\StringGeneratorBundle\Generator;
+
+use PhpSpec\ObjectBehavior;
+use Prophecy\Argument;
+use RandomLib\Factory;
+use RandomLib\Generator;
+use RandomLib\Mixer;
+use SecurityLib\Strength;
+
+class SecureStringGeneratorSpec extends ObjectBehavior
+{
+
+    /**
+     * @var Factory
+     */
+    private $factory;
+
+    function it_is_initializable()
+    {
+        $this->shouldHaveType('Vivait\StringGeneratorBundle\Generator\SecureStringGenerator');
+    }
+
+    function let(Factory $factory, Generator $low, Generator $medium)
+    {
+        $factory->getMediumStrengthGenerator()->willReturn($medium);
+        $factory->getLowStrengthGenerator()->willReturn($low);
+        $this->beConstructedWith($factory);
+
+        $defaults = [
+            'length' => 32,
+            'chars' => '',
+            'strength' => 'medium',
+        ];
+
+        $this->setOptions($defaults);
+    }
+
+    function it_chooses_medium_strength_gen_by_default(Generator $medium)
+    {
+        $this->getGenerator()->shouldReturn($medium);
+    }
+
+    function it_chooses_a_specified_strength_gen(Generator $medium, Generator $low)
+    {
+        $this->getGenerator('medium')->shouldReturn($medium);
+        $this->getGenerator('low')->shouldReturn($low);
+    }
+
+    function it_errors_on_invalid_strength_gen(Generator $medium, Generator $low)
+    {
+        $this->getGenerator('medium')->shouldReturn($medium);
+        $this->getGenerator('low')->shouldReturn($low);
+
+        $this->shouldThrow('\InvalidArgumentException')->duringGetGenerator('high');
+        $this->shouldThrow('\InvalidArgumentException')->duringGetGenerator('invalid');
+    }
+
+    function it_generates_a_random_string(Generator $medium)
+    {
+        $medium->generateString(32, '')->shouldBeCalled();
+        $this->generate();
+    }
+
+    function it_generates_a_random_string_of_set_length(Generator $medium, Generator $low)
+    {
+        $options = [
+            'length' => 8,
+            'chars' => '',
+            'strength' => 'low',
+        ];
+        $this->setOptions($options);
+
+        $medium->generateString(8, '')->shouldNotBeCalled();
+        $low->generateString(8, '')->shouldBeCalled();
+
+        $this->generate();
+    }
+
+    function getMatchers()
+    {
+        return [
+            'haveStrlen' => function($string, $length){
+                return strlen($string) == $length;
+            }
+        ];
+    }
+}

spec/Vivait/StringGeneratorBundle/Generator/StringGeneratorSpec.php

@@ -18,20 +18,6 @@ function it_generates_a_string_based_on_length()
         $this->generate()->shouldHaveStrlen(10);
     }
 
-    function it_should_throw_an_exception_if_it_has_no_chars()
-    {
-        $this->shouldThrow('\OutOfBoundsException')->duringSetChars('');
-        $this->shouldThrow('\OutOfBoundsException')->duringSetChars(null);
-        $this->shouldThrow('\OutOfBoundsException')->duringSetChars(true);
-    }
-
-    function it_should_error_if_its_length_is_set_to_less_than_1()
-    {
-        $this->shouldThrow('\OutOfBoundsException')->duringSetLength(0);
-        $this->shouldThrow('\OutOfBoundsException')->duringSetLength(-1);
-        $this->shouldThrow('\OutOfBoundsException')->duringSetLength("ten");
-    }
-
     function getMatchers()
     {
         return [

src/Vivait/StringGeneratorBundle/Annotation/GeneratorAnnotation.php

@@ -12,7 +12,16 @@
  */
 class GeneratorAnnotation extends Annotation
 {
+    /**
+     * @var array
+     */
     public $callbacks = [];
+
+    /**
+     * @var array
+     */
+    public $options = [];
+
     /**
      * @var
      */
@@ -28,5 +37,8 @@ class GeneratorAnnotation extends Annotation
      */
     public $unique = true;
 
+    /**
+     * @var bool
+     */
     public $override = true;
 }

src/Vivait/StringGeneratorBundle/EventListener/GeneratorListener.php

@@ -6,7 +6,9 @@
 use Doctrine\ORM\EntityRepository;
 use Doctrine\ORM\Event\LifecycleEventArgs;
 use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\OptionsResolver\OptionsResolver;
 use Vivait\StringGeneratorBundle\Annotation\GeneratorAnnotation;
+use Vivait\StringGeneratorBundle\Model\ConfigurableGeneratorInterface;
 use Vivait\StringGeneratorBundle\Model\GeneratorInterface;
 use Vivait\StringGeneratorBundle\Registry\Registry;
 
@@ -88,7 +90,7 @@ public function prePersist(LifecycleEventArgs $args)
      */
     private function generateString($property, GeneratorAnnotation $annotation, $object)
     {
-        /** @var GeneratorInterface $generator */
+        /** @var GeneratorInterface|ConfigurableGeneratorInterface $generator */
         $generator = $this->getRegistry()->get($annotation->generator);
 
         $generator->setLength($annotation->length);
@@ -97,6 +99,10 @@ private function generateString($property, GeneratorAnnotation $annotation, $obj
             $this->performCallbacks($generator, $annotation, $object);
         }
 
+        if($generator instanceof ConfigurableGeneratorInterface){
+            $generator = $this->configureGenerator($generator, $annotation->options);
+        }
+
         $str = $generator->generate();
 
         if (!$annotation->unique) {
@@ -110,6 +116,22 @@ private function generateString($property, GeneratorAnnotation $annotation, $obj
         }
     }
 
+    /**
+     * @param ConfigurableGeneratorInterface $generator
+     * @param $options
+     * @return \Vivait\StringGeneratorBundle\Model\ConfigurableGeneratorInterface
+     */
+    public function configureGenerator(ConfigurableGeneratorInterface $generator, $options)
+    {
+        $resolver = new OptionsResolver();
+        $generator->getDefaultOptions($resolver);
+
+        $options = $resolver->resolve($options);
+        $generator->setOptions($options);
+
+        return $generator;
+    }
+
     /**
      * @param GeneratorInterface $generator
      * @param GeneratorAnnotation $annotation