Initial commit including creational patterns, registry pattern, and unit tests for registry and singelton.

Author: jeremeamia

.gitignore

@@ -1,12 +1,4 @@
-# Bootstrap
-app/bootstrap*
-
-# Symfony directories
 vendor/*
-*/logs/*
-*/cache/*
-web/uploads/*
-web/bundles/*
-
-# Configuration files
-app/config/parameters.ini
+build/*
+phpunit.xml
+composer.phar

composer.json

@@ -0,0 +1,6 @@
+{
+    "name": "Jeremeamia/PhpPatterns",
+    "autoload": {
+        "psr-0": {"Jeremeamia": "src/"}
+    }
+}

phpunit.xml.dist

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit bootstrap="./test/bootstrap.php"
+         colors="true"
+         processIsolation="false"
+         stopOnFailure="false"
+         syntaxCheck="false"
+         convertErrorsToExceptions="true"
+         convertNoticesToExceptions="true"
+         convertWarningsToExceptions="true"
+         testSuiteLoaderClass="PHPUnit_Runner_StandardTestSuiteLoader">
+
+    <testsuites>
+        <testsuite name="PhpPatterns">
+            <directory>test/Jeremeamia/PhpPatterns/Test</directory>
+        </testsuite>
+    </testsuites>
+
+    <logging>
+        <log type="junit" target="build/logs/junit.xml" logIncompleteSkipped="false" />
+    </logging>
+
+    <filter>
+        <whitelist>
+            <directory suffix=".php">./src/Jeremeamia/PhpPatterns</directory>
+            <exclude>
+                <directory suffix="Interface.php">./src/Jeremeamia/PhpPatterns</directory>
+            </exclude>
+        </whitelist>
+    </filter>
+
+</phpunit>

src/Jeremeamia/PhpPatterns/Collection/RegistryTrait.php

@@ -0,0 +1,113 @@
+<?php
+
+namespace Jeremeamia\PhpPatterns\Collection;
+
+/**
+ * The Registry Pattern
+ *
+ * Common Aliases:   Map, Container, Collection
+ * Related Patterns: Singleton Registry, Map
+ *
+ * Martin Fowler describes the Registry pattern as "A well-known object that
+ * other objects can use to find common objects and services." In other words,
+ * it is an object (whether a static, singleton, or instance) that contains
+ * other objects or data, and keeps a references to those by a name or key. It's
+ * essentially a simplified associative array with an object-oriented interface.
+ *
+ * Registries are commonly used to keep track of objects and data that need to
+ * be accessed in a global or wide context. Because of this, they are often designed
+ * to be a static or singleton class, even though that is not necessary, and is
+ * generally discouraged.
+ *
+ * Also, the basic interface and functionality of a Registry can be re-used to
+ * form the basis of other array-like patterns. Therefore, the RegistryTrait is
+ * used by many other patterns in the PhpPatterns collection.
+ */
+trait RegistryTrait
+{
+    /**
+     * Get an object/value out of the Registry
+     *
+     * @param string $key     The key of the object/value to retrieve
+     * @param mixed  $default The value to return if the key is missing
+     *
+     * @return mixed The object/value from the Registry
+     */
+    public function get($key, $default = null)
+    {
+        return $this->has($key) ? $this->data[$key] : $default;
+    }
+
+    /**
+     * Store an object/value in the Registry
+     *
+     * @param string $key   The key of the object/value being set
+     * @param mixed  $value The object/value to store
+     *
+     * @return self The instance of the Registry for chaining
+     */
+    public function set($key, $value)
+    {
+        $this->data[$key] = $value;
+
+        return $this;
+    }
+
+    /**
+     * Check to see if a key exists in the Registry
+     *
+     * @param  string $key The key of the object/value to check
+     *
+     * @return bool Whether or not the ey exists
+     */
+    public function has($key)
+    {
+        return array_key_exists($key, $this->data);
+    }
+
+    /**
+     * Remove an object/value from the Registry
+     *
+     * @param string $key The key of the object/value to remove
+     *
+     * @return self The instance of the object for chaining
+     */
+    public function remove($key)
+    {
+        unset($this->data[$key]);
+
+        return $this;
+    }
+
+    /**
+     * Removes all objects/values from the Registry
+     *
+     * @return self The instance of the object for chaining
+     */
+    public function clear()
+    {
+        $this->data = [];
+
+        return $this;
+    }
+
+    /**
+     * Returns all objects/values in the Registry as an associative array
+     *
+     * @return array All of the objects/data
+     */
+    public function all()
+    {
+        return $this->data;
+    }
+
+    /**
+     * Checks if the Registry is empty
+     *
+     * @return bool Whether or not its empty
+     */
+    public function isEmpty()
+    {
+        return (0 === count($this->data));
+    }
+}

src/Jeremeamia/PhpPatterns/Creation/BuilderTrait.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Jeremeamia\PhpPatterns\Creation;
+
+/**
+ * This trait establishes the class as a Builder pattern and requires that
+ * the build() method be implemented.
+ */
+trait BuilderTrait
+{
+    /**
+     * Performs the logic for building the desired object and returns the fully-
+     * instantiated object.
+     *
+     * @return mixed
+     */
+    abstract public function build();
+}

src/Jeremeamia/PhpPatterns/Creation/FactoryTrait.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Jeremeamia\PhpPatterns\Creation;
+
+trait FactoryTrait
+{
+    abstract public function create($name, array $context = []);
+}

src/Jeremeamia/PhpPatterns/Creation/FlyweightFactoryTrait.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Jeremeamia\PhpPatterns\Creation;
+
+use Jeremeamia\PhpPatterns\Collection\RegistryTrait;
+
+trait FlyweightFactoryTrait
+{
+    use FactoryTrait;
+    use RegistryTrait;
+
+    public function create($name, array $context = [])
+    {
+        $key = $this->calculateHashKey($name, $context);
+
+        if (!$this->has($key)) {
+            $this->set($key, $this->doCreate($name, $context));
+        }
+
+        return $this->get($key);
+    }
+
+    protected function calculateHashKey($name, array $context)
+    {
+        return $name;
+    }
+
+    abstract protected function doCreate($name, array $context);
+}

src/Jeremeamia/PhpPatterns/Creation/MultitonTrait.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Jeremeamia\PhpPatterns\Creation;
+
+use Jeremeamia\PhpPatterns\Collection\RegistryTrait;
+
+trait MultitonTrait
+{
+    use SingletonTrait;
+
+    public static function getInstance()
+    {
+        return static::getNamedInstance();
+    }
+
+    public static function getNamedInstance($key = '__DEFAULT__')
+    {
+        if (!isset(static::$instance[$key])) {
+            if (!static::$instance) {
+                static::$instance = [];
+            }
+            static::$instance[$key] = new static;
+        }
+
+        return static::$instance[$key];
+    }
+}

src/Jeremeamia/PhpPatterns/Creation/PrototypeTrait.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Jeremeamia\PhpPatterns\Creation;
+
+trait PrototypeTrait
+{
+    public function copy()
+    {
+        return clone $this;
+    }
+
+    public function __clone()
+    {
+        // Default clone method is not required and assumes shallow copying
+    }
+}

src/Jeremeamia/PhpPatterns/Creation/SingleOriginPrototypeTrait.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Jeremeamia\PhpPatterns\Creation;
+
+trait SingleOriginPrototypeTrait
+{
+    use SingletonTrait, PrototypeTrait
+    {
+        PrototypeTrait::__clone insteadof SingletonTrait;
+    }
+
+    public static function getInstance()
+    {
+        if (!static::$instance) {
+            static::$instance = new static;
+        }
+
+        return clone static::$instance;
+    }
+
+    public function copy()
+    {
+        return clone static::$instance;
+    }
+}

src/Jeremeamia/PhpPatterns/Creation/SingletonTrait.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Jeremeamia\PhpPatterns\Creation;
+
+trait SingletonTrait
+{
+    protected static $instance;
+
+    /**
+     * @return self
+     */
+    public static function getInstance()
+    {
+        if (!static::$instance) {
+            static::$instance = (new \ReflectionClass(get_called_class()))
+                ->newInstanceWithoutConstructor();
+        }
+
+        return static::$instance;
+    }
+
+    public function __construct()
+    {
+        throw new \RuntimeException('You may not explicitly instantiate this '
+            . 'object, because it is a singleton.');
+    }
+
+    public function __clone()
+    {
+        throw new \RuntimeException('You may not clone this object, because it '
+            . 'is a singleton.');
+    }
+
+    public function __wakeup()
+    {
+        throw new \RuntimeException('You may not unserialize this object, '
+            . 'because it is a singleton.');
+    }
+
+    public function unserialize($serialized_data)
+    {
+        throw new \RuntimeException('You may not unserialize this object, '
+            . 'because it is a singleton.');
+    }
+}

test/Jeremeamia/PhpPatterns/Test/Collection/RegistryTraitFixture.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Jeremeamia\PhpPatterns\Test\Collection;
+
+use Jeremeamia\PhpPatterns\Collection\RegistryTrait;
+
+class RegistryTraitFixture
+{
+    use RegistryTrait;
+
+    protected $data = [];
+}