Makes use of callbacks on Generators to define things like characters or prefixes

Author: Robin Cawser

.gitignore

@@ -1,5 +1,6 @@
 ### Composer ###
 composer.phar
+composer.lock
 vendor/
 bin/
 

spec/Vivait/StringGeneratorBundle/EventListener/GeneratorListenerSpec.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace spec\Vivait\StringGeneratorBundle\EventListener;
+
+use Doctrine\Common\Annotations\Reader;
+use PhpSpec\ObjectBehavior;
+use Prophecy\Argument;
+use Vivait\StringGeneratorBundle\Annotation\GeneratorAnnotation;
+use Vivait\StringGeneratorBundle\Generator\StringGenerator;
+use Vivait\StringGeneratorBundle\Registry\Registry;
+
+class GeneratorListenerSpec extends ObjectBehavior
+{
+    function it_is_initializable()
+    {
+        $this->shouldHaveType('Vivait\StringGeneratorBundle\EventListener\GeneratorListener');
+    }
+
+    function let(Reader $reader, Registry $registry)
+    {
+        $this->beConstructedWith($reader, $registry);
+    }
+
+    function it_performs_callbacks_on_the_generator(StringGenerator $generator, Entity $mockEntity)
+    {
+        $annotation = new GeneratorAnnotation([]);
+        $annotation->callbacks = ['setChars' => 'abcdef'];
+        $this->shouldNotThrow('\InvalidArgumentException')->duringPerformCallbacks($generator, $annotation, $mockEntity);
+
+        $annotation->callbacks = ['noMethod' => 'something'];
+        $this->shouldThrow('\InvalidArgumentException')->duringPerformCallbacks($generator, $annotation, $mockEntity);
+    }
+
+    function it_can_get_callback_values_from_annotated_object(StringGenerator $generator, Entity $mockEntity)
+    {
+        $annotation = new GeneratorAnnotation([]);
+        $annotation->callbacks = ['setPrefix' => 'getPrefix'];
+
+        $mockEntity->getPrefix()->willReturn('VIVA_');
+        $generator->setPrefix('VIVA_')->shouldBeCalled();
+        $this->performCallbacks($generator, $annotation, $mockEntity);
+    }
+}
+
+class Entity
+{
+    public function getPrefix()
+    {
+
+    }
+}
+

src/Vivait/StringGeneratorBundle/Annotation/GeneratorAnnotation.php

@@ -12,16 +12,12 @@
  */
 class GeneratorAnnotation extends Annotation
 {
+    public $callbacks = [];
     /**
      * @var
      */
     public $generator;
 
-    /**
-     * @var string
-     */
-    public $prefix;
-
     /**
      * @var int
      */
@@ -31,14 +27,4 @@ class GeneratorAnnotation extends Annotation
      * @var boolean
      */
     public $unique = true;
-
-    /**
-     * @var string
-     */
-    public $separator = "-";
-
-    /**
-     * @var string
-     */
-    public $prefix_callback;
 }

src/Vivait/StringGeneratorBundle/DependencyInjection/Configuration.php

@@ -19,16 +19,17 @@ public function getConfigTreeBuilder()
     {
         $treeBuilder = new TreeBuilder();
         $rootNode = $treeBuilder->root('vivait_string_generator');
+
         $rootNode
-            ->fixXmlConfig('notifier')
+            ->fixXmlConfig('generator')
             ->children()
                 ->arrayNode('generators')
                     ->useAttributeAsKey('class')
-                    ->prototype('scalar')
-                    ->cannotBeEmpty()
+                    ->prototype('scalar')->end()
                 ->end()
-            ->end()
-        ;
+            ->end();
+
+
 
         return $treeBuilder;
     }

src/Vivait/StringGeneratorBundle/EventListener/GeneratorListener.php

@@ -41,56 +41,83 @@ public function prePersist(LifecycleEventArgs $args)
         $meta = $em->getClassMetadata(get_class($entity));
         $this->repo = $em->getRepository($meta->getName());
 
-        $obj = new \ReflectionObject($entity);
+        $object = new \ReflectionObject($entity);
 
-        //Loop through each of entity's properties
-        foreach ($obj->getProperties() as $property) {
-            //Loop through the property's annotations
+        foreach ($object->getProperties() as $property) {
             foreach ($this->reader->getPropertyAnnotations($property) as $annotation) {
 
                 if ($annotation instanceof GeneratorAnnotation) {
-                    if (method_exists($entity, $annotation->prefix_callback) && is_callable([$entity, $annotation->prefix_callback])) {
-                        $callback = $annotation->prefix_callback;
-                        $annotation->prefix = $entity->$callback();
-                    }
-
-                    $id = $this->generateString(
-                        $property->name,
-                        $annotation
-                    );
-                    $meta->getReflectionProperty($property->name)->setValue($entity, $id);
+                    $string = $this->generateString($property->name, $annotation, $object);
+
+                    $meta->getReflectionProperty($property->name)->setValue($entity, $string);
                 }
             }
         }
     }
 
     /**
      * @param $property
-     * @param $annotation
+     * @param GeneratorAnnotation $annotation
+     * @param $object
      * @return string
      */
-    private function generateString($property, GeneratorAnnotation $annotation)
+    private function generateString($property, GeneratorAnnotation $annotation, $object)
     {
+        /** @var GeneratorInterface $generator */
         $generator = $this->registry->get($annotation->generator);
         $generator->setLength($annotation->length);
 
-        $str = $this->generator->generate();
-
-        if ($annotation->prefix) {
-            $str = sprintf("%s%s%s", $annotation->prefix, $annotation->separator, $str);
+        if(!empty($annotation->callbacks)){
+            $this->performCallbacks($generator, $annotation, $object);
         }
 
+        $str = $generator->generate();
+
         if (!$annotation->unique) {
             return $str;
         }
 
 
         if ($this->repo->findOneBy([$property => $str])) {
-            return $this->generateString($property, $annotation);
+            return $this->generateString($property, $annotation, $object);
         } else {
             return $str;
         }
 
     }
 
+    /**
+     * @param GeneratorInterface $generator
+     * @param GeneratorAnnotation $annotation
+     * @param $object
+     */
+    public function performCallbacks(GeneratorInterface $generator, GeneratorAnnotation $annotation, $object)
+    {
+        foreach($annotation->callbacks as $callback => $value){
+            if($this->isMethod($generator, $callback)){
+
+                if($this->isMethod($object, $value)){
+                    $value = $object->$value();
+                }
+                $generator->$callback($value);
+            }
+            else{
+                throw new \InvalidArgumentException(sprintf(
+                    'Callback "%s" does not exist in class "%s"',
+                    $callback,
+                    get_class($generator))
+                );
+            }
+        }
+    }
+
+    /**
+     * @param $class
+     * @param $callback
+     * @return bool
+     */
+    private function isMethod($class, $callback)
+    {
+        return method_exists($class, $callback) && is_callable([$class, $callback]);
+    }
 }

src/Vivait/StringGeneratorBundle/Generator/StringGenerator.php

@@ -16,6 +16,7 @@ class StringGenerator implements GeneratorInterface
      * @var string
      */
     private $chars = 'abcdefjhijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345567890';
+    private $prefix = '';
 
     /**
      * @param string $chars
@@ -44,6 +45,11 @@ public function setLength($length)
         return $this;
     }
 
+    public function setPrefix($prefix)
+    {
+        $this->prefix = $prefix;
+    }
+
     /**
      * Creates a random string based on a length and alphabet
      *
@@ -58,6 +64,6 @@ public function generate()
             $str[] = $this->chars[$n];
         }
 
-        return implode($str);
+        return $this->prefix . implode($str);
     }
 }

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

@@ -2,9 +2,16 @@ services:
     vivait_generator.generator.listener:
         class: Vivait\StringGeneratorBundle\EventListener\GeneratorListener
         public: false
-        arguments: ["@annotation_reader"]
+        arguments: [@annotation_reader, @vivait_generator.registry]
         tags:
             - { name: doctrine.event_listener, event: prePersist }
     vivait_generator.registry:
         class: Vivait\StringGeneratorBundle\Registry\Registry
-        arguments: [@service_container, []]
+        arguments: [@service_container, []]
+
+    vivait_generator.generator.string:
+        class: Vivait\StringGeneratorBundle\Generator\StringGenerator
+
+    vivait_generator.generator.secure_bytes:
+        class: Vivait\StringGeneratorBundle\Generator\SecureBytesGenerator
+        arguments: [@security.secure_random]