Added fluent interface for class/method creation

- BuilderDefinition now adds "createClass()" method, returning a
  Builder\PhpClass object
- Builder\PhpClass now adds "createInjectionMethod()" method, returning a
  Builder\InjectionMethod object

src/Definition/Builder/PhpClass.php

@@ -4,9 +4,10 @@
 
 class PhpClass
 {
-    protected $name = null;
-    protected $instantiator = '__construct';
-    protected $injectionMethods = array();
+    protected $defaultMethodBuilder = 'Zend\Di\Definition\Builder\InjectionMethod';
+    protected $name                 = null;
+    protected $instantiator         = '__construct';
+    protected $injectionMethods     = array();
 
     public function setName($name)
     {
@@ -46,6 +47,53 @@ public function addInjectionMethod(InjectionMethod $injectionMethod)
         $this->injectionMethods[] = $injectionMethod;
         return $this;
     }
+
+    /**
+     * Create and register an injection method
+     *
+     * Optionally takes the method name.
+     *
+     * This method may be used in lieu of addInjectionMethod() in 
+     * order to provide a more fluent interface for building classes with
+     * injection methods.
+     * 
+     * @param  null|string $name 
+     * @return InjectionMethod
+     */
+    public function createInjectionMethod($name = null)
+    {
+        $builder = $this->defaultMethodBuilder;
+        $method  = new $builder();
+        if (null !== $name) {
+            $method->setName($name);
+        }
+        $this->addInjectionMethod($method);
+        return $method;
+    }
+
+    /**
+     * Override which class will be used by {@link createInjectionMethod()}
+     * 
+     * @param  string $class 
+     * @return PhpClass
+     */
+    public function setMethodBuilder($class)
+    {
+        $this->defaultMethodBuilder = $class;
+        return $this;
+    }
+
+    /**
+     * Determine what class will be used by {@link createInjectionMethod()}
+     *
+     * Mainly to provide the ability to temporarily override the class used.
+     * 
+     * @return string
+     */
+    public function getMethodBuilder()
+    {
+        return $this->defaultMethodBuilder;
+    }
 
     public function getInjectionMethods()
     {

src/Definition/BuilderDefinition.php

@@ -7,7 +7,7 @@
 
 class BuilderDefinition implements Definition
 {
-
+    protected $defaultClassBuilder = 'Zend\Di\Definition\Builder\PhpClass';
     protected $classes = array();
 
     public function createClassesFromArray(array $builderData)
@@ -49,6 +49,51 @@ public function addClass(Builder\PhpClass $phpClass)
         $this->classes[] = $phpClass;
         return $this;
     }
+
+    /**
+     * Create a class builder object using default class builder class
+     *
+     * This method is a factory that can be used in place of addClass().
+     * 
+     * @param  null|string $name Optional name of class to assign
+     * @return Builder\PhpClass
+     */
+    public function createClass($name = null)
+    {
+        $builderClass = $this->defaultClassBuilder;
+        $class = new $builderClass();
+        if (null !== $name) {
+            $class->setName($name);
+        }
+
+        $this->addClass($class);
+        return $class;
+    }
+
+    /**
+     * Set the class to use with {@link createClass()}
+     * 
+     * @param  string $class 
+     * @return BuilderDefinition
+     */
+    public function setClassBuilder($class)
+    {
+        $this->defaultClassBuilder = $class;
+        return $this;
+    }
+
+    /**
+     * Get the class used for {@link createClass()}
+     *
+     * This is primarily to allow developers to temporarily override 
+     * the builder strategy.
+     * 
+     * @return string
+     */
+    public function getClassBuilder()
+    {
+        return $this->defaultClassBuilder;
+    }
 
     public function getClasses()
     {

test/Definition/BuilderDefinitionTest.php

@@ -71,5 +71,50 @@ public function testBuilderCanBuildFromArray()
             );
 
     }
+
+    public function testCanCreateClassFromFluentInterface()
+    {
+        $builder = new BuilderDefinition();
+        $class = $builder->createClass('Foo');
+
+        $this->assertTrue($builder->hasClass('Foo'));
+    }
 
+    public function testCanCreateInjectionMethodsAndPopulateFromFluentInterface()
+    {
+        $builder = new BuilderDefinition();
+        $foo     = $builder->createClass('Foo');
+        $foo->setName('Foo');
+        $foo->createInjectionMethod('setBar')
+            ->addParameter('bar', 'Bar');
+        $foo->createInjectionMethod('setConfig')
+            ->addParameter('config', null);
+
+        $this->assertTrue($builder->hasClass('Foo'));
+        $this->assertTrue($builder->hasInjectionMethod('Foo', 'setBar'));
+        $this->assertTrue($builder->hasInjectionMethod('Foo', 'setConfig'));
+
+        $this->assertEquals(array('bar' => 'Bar'), $builder->getInjectionMethodParameters('Foo', 'setBar'));
+        $this->assertEquals(array('config' => null), $builder->getInjectionMethodParameters('Foo', 'setConfig'));
+    }
+
+    public function testBuilderCanSpecifyClassToUseWithCreateClass()
+    {
+        $builder = new BuilderDefinition();
+        $this->assertEquals('Zend\Di\Definition\Builder\PhpClass', $builder->getClassBuilder());
+
+        $builder->setClassBuilder('Foo');
+        $this->assertEquals('Foo', $builder->getClassBuilder());
+    }
+
+    public function testClassBuilderCanSpecifyClassToUseWhenCreatingInjectionMethods()
+    {
+        $builder = new BuilderDefinition();
+        $class   = $builder->createClass('Foo');
+
+        $this->assertEquals('Zend\Di\Definition\Builder\InjectionMethod', $class->getMethodBuilder());
+
+        $class->setMethodBuilder('Foo');
+        $this->assertEquals('Foo', $class->getMethodBuilder());
+    }
 }