Merge branch 'builder-pattern'

Builder/BikeBuilder.php

@@ -0,0 +1,43 @@
+<?php
+
+/*
+ * DesignPatternPHP
+ */
+
+namespace DesignPatterns\Builder;
+
+/**
+ * BikeBuilder builds bike
+ */
+class BikeBuilder implements Builder
+{
+
+    protected $bike;
+
+    public function addDoors()
+    {
+        
+    }
+
+    public function addEngine()
+    {
+        $this->bike->setPart('engine', new Parts\Engine());
+    }
+
+    public function addWheel()
+    {
+        $this->bike->setPart('forwardWheel', new Parts\Wheel());
+        $this->bike->setPart('rearWheel', new Parts\Wheel());
+    }
+
+    public function createVehicle()
+    {
+        $this->bike = new Parts\Bike();
+    }
+
+    public function getVehicle()
+    {
+        return $this->bike;
+    }
+
+}

Builder/Builder.php

@@ -0,0 +1,33 @@
+<?php
+
+/*
+ * DesignPatternPHP
+ */
+
+namespace DesignPatterns\Builder;
+
+/**
+ * Builder is an interface that build parts of a complex object.
+ * 
+ * Sometime, if the builder has a better knowledge of what it builds, this 
+ * interface could be an abstract class with default methods (aka adapter)
+ * 
+ * If you have a complex inheritance tree for vehicles, it is logical to have
+ * a complex inheritance tree for builders too.
+ * 
+ * Note: Builders have often a fluent interface, see the mock builder of
+ * PHPUnit for example.
+ */
+interface Builder
+{
+
+    function createVehicle();
+
+    function addWheel();
+
+    function addEngine();
+
+    function addDoors();
+
+    function getVehicle();
+}

Builder/CarBuilder.php

@@ -0,0 +1,46 @@
+<?php
+
+/*
+ * DesignPatternPHP
+ */
+
+namespace DesignPatterns\Builder;
+
+/**
+ * CarBuilder builds car
+ */
+class CarBuilder implements Builder
+{
+
+    protected $car;
+
+    public function addDoors()
+    {
+        $this->car->setPart('rightdoor', new Parts\Door());
+        $this->car->setPart('leftDoor', new Parts\Door());
+    }
+
+    public function addEngine()
+    {
+        $this->car->setPart('engine', new Parts\Engine());
+    }
+
+    public function addWheel()
+    {
+        $this->car->setPart('wheelLF', new Parts\Wheel());
+        $this->car->setPart('wheelRF', new Parts\Wheel());
+        $this->car->setPart('wheelLR', new Parts\Wheel());
+        $this->car->setPart('wheelRR', new Parts\Wheel());
+    }
+
+    public function createVehicle()
+    {
+        $this->car = new Parts\Car();
+    }
+
+    public function getVehicle()
+    {
+        return $this->car;
+    }
+
+}

Builder/Director.php

@@ -0,0 +1,32 @@
+<?php
+
+/*
+ * DesignPatternPHP
+ */
+
+namespace DesignPatterns\Builder;
+
+/**
+ * Director is part of the builder pattern. It knows the interface of the builder
+ * and build a complex object with the help of the builder. 
+ * If you make it abstract, this becomes a "meta-factory-method" very powerfull.
+ * 
+ * You can also inject many builders instead of one to build more complex objects
+ */
+class Director
+{
+
+    /**
+     * The director don't know 'bout concrete part
+     */
+    public function build(Builder $builder)
+    {
+        $builder->createVehicle();
+        $builder->addDoors();
+        $builder->addEngine();
+        $builder->addWheel();
+
+        return $builder->getVehicle();
+    }
+
+}

Builder/Parts/Bike.php

@@ -0,0 +1,15 @@
+<?php
+
+/*
+ * DesignPatternPHP
+ */
+
+namespace DesignPatterns\Builder\Parts;
+
+/**
+ * Bike is a bike
+ */
+class Bike extends Vehicle
+{
+    
+}

Builder/Parts/Car.php

@@ -0,0 +1,15 @@
+<?php
+
+/*
+ * DesignPatternPHP
+ */
+
+namespace DesignPatterns\Builder\Parts;
+
+/**
+ * Car is a car
+ */
+class Car extends Vehicle
+{
+    
+}

Builder/Parts/Door.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace DesignPatterns\Builder\Parts;
+
+class Door
+{
+    
+}

Builder/Parts/Engine.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace DesignPatterns\Builder\Parts;
+
+class Engine
+{
+    
+}

Builder/Parts/Vehicle.php

@@ -0,0 +1,22 @@
+<?php
+
+/*
+ * DesignPatternPHP
+ */
+
+namespace DesignPatterns\Builder\Parts;
+
+/**
+ * Vehicle is a contract for a vehicle
+ */
+abstract class Vehicle
+{
+
+    protected $data;
+
+    public function setPart($key, $value)
+    {
+        $this->data[$key] = $value;
+    }
+
+}

Builder/Parts/Wheel.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace DesignPatterns\Builder\Parts;
+
+class Wheel
+{
+    
+}

Tests/Builder/DirectorTest.php

@@ -0,0 +1,46 @@
+<?php
+
+/*
+ * DesignPatternPHP
+ */
+
+namespace DesignPatterns\Tests\Builder;
+
+use DesignPatterns\Builder\Director;
+use DesignPatterns\Builder\CarBuilder;
+use DesignPatterns\Builder\BikeBuilder;
+
+/**
+ * DirectorTest tests the builder pattern
+ */
+class DirectorTest extends \PHPUnit_Framework_TestCase
+{
+
+    protected $director;
+
+    protected function setUp()
+    {
+        $this->director = new Director();
+    }
+
+    public function getBuilder()
+    {
+        return array(
+            array(new CarBuilder()),
+            array(new BikeBuilder())
+        );
+    }
+
+    /**
+     * Here we test the build process. Notice that the client don't know
+     * anything about the contrete builder.
+     * 
+     * @dataProvider getBuilder
+     */
+    public function testBuild(\DesignPatterns\Builder\Builder $builder)
+    {
+        $newVehicle = $this->director->build($builder);
+        $this->assertInstanceOf('DesignPatterns\Builder\Parts\Vehicle', $newVehicle);
+    }
+
+}