<?php
/*
 * @category Design Pattern Tutorial
 * @package AbstractFactory Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

// Abstract Factory
// File: ./Widget/Factory/AbstractFactory.php
namespace Widget\Factory;

abstract class AbstractFactory
{
    abstract public function makeDialog();
    abstract public function makeButton();
}

// Concrete Factory
// File: ./Widget/Factory/Desktop.php
namespace Widget\Factory;

class Desktop extends AbstractFactory
{
    public function makeDialog()
    {
        return new \Widget\Dialog\Desktop();
    }
    public function makeButton()
    {
        return new \Widget\Button\Desktop();
    }
}

// Concrete Factory
// File: ./Widget/Factory/Mobile.php
namespace Widget\Factory;

class Mobile extends AbstractFactory
{
    public function makeDialog()
    {
        return new \Widget\Dialog\Mobile();
    }
    public function makeButton()
    {
        return new \Widget\Button\Mobile();
    }
}

// Abstract Product
// File: ./Widget/Dialog/iDialog.php
namespace Widget\Dialog;

interface iDialog
{
    public function render();
}

// Concrete Product
// File: ./Widget/Dialog/Desktop.php
namespace Widget\Dialog;

class Desktop implements \Widget\Dialog\iDialog
{
    public function render()
    {
        print "jQueryUI based dialog\n";
    }
}

// Concrete Product
// File: ./Widget/Dialog/Mobile.php
namespace Widget\Dialog;

class Mobile implements \Widget\Dialog\iDialog
{
    public function render()
    {
        print "jQueryMobile based dialog\n";
    }
}

// Abstract Product
// File: ./Widget/Button/iButton.php
namespace Widget\Button;

interface iButton
{
    public function render();
}

// Concrete Product
// File: ./Widget/Button/Desktop.php
namespace Widget\Button;

class Desktop implements \Widget\Button\iButton
{
    public function render()
    {
        print "jQueryUI based button\n";
    }
}

// Concrete Product
// File: ./Widget/Button/Mobile.php
namespace Widget\Button;

class Mobile implements \Widget\Button\iButton
{
    public function render()
    {
        print "jQueryMobile based button\n";
    }
}


// File: ./Config.php
class Config
{
    public $platform;
}

// Client
// File: ./Application.php
class Application
{
    private $_config;
    public function __construct($config)
    {
        $this->_config = $config;
    }
    private function _createPlaformSpecificFactory()
    {
        $className = "\\Widget\\Factory\\" . ucfirst($this->_config->platform);
        return new $className;
    }
    public function build()
    {
        $factory = $this->_createPlaformSpecificFactory();
        $dialog = $factory->makeDialog();
        $dialog->render();
        $button = $factory->makeButton();
        $button->render();
    }
}

/**
 * Usage
 */
include "./Widget/Factory/AbstractFactory.php";
include "./Widget/Factory/Desktop.php";
include "./Widget/Factory/Mobile.php";
include "./Widget/Dialog/iDialog.php";
include "./Widget/Dialog/Desktop.php";
include "./Widget/Dialog/Mobile.php";
include "./Widget/Button/iButton.php";
include "./Widget/Button/Desktop.php";
include "./Widget/Button/Mobile.php";
include "./Config.php";
include "./Application.php";

$config = new Config();
$config->platform = "mobile";
$app = new Application($config);
$app->build();

// Output:
// jQueryMobile based dialog
// jQueryMobile based button

/*
 * @category Design Pattern Tutorial
 * @package AbstractFactory Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

(function() {
"use strict";

    // Client
var page = (function() {
        return {
            render: function( options ) {
                var widget,
                    factory = ( options.testing ? mockWidgetFactory : widgetFactory );

                if ( factory instanceof AbstractWidgetFactory === false ) {
                    throw new TypeError( "Argument must be an instance of AbstractWidgetFactory" );
                }
                widget = factory.makeCarousel();
                if ( widget instanceof AbstractWidget === false ) {
                    throw new TypeError( "Argument must be an instance of AbstractWidget" );
                }
                widget.render();
            }
        }
    }()),
    // Abstract factory
    AbstractWidgetFactory = function() {
    },
    // Concrete factory
    mockWidgetFactory = Object.create( new AbstractWidgetFactory(), {
        makeCarousel: {
            value: function() {
                return mockCarousel;
            }
        }
    }),
    // Concrete factory
    widgetFactory = Object.create( new AbstractWidgetFactory(), {
        makeCarousel: {
            value: function() {
                return carousel;
            }
        }
    }),
    // Abstract product
    AbstractWidget = function() {

    },
    // Concrete product
    carousel = Object.create( new AbstractWidget(), {
        render: {
            value: function() {
                console.log('Carousel widget rendered');
            }
        }
    }),
    // Concrete product
    mockCarousel = Object.create( new AbstractWidget(), {
        render: {
            value: function() {
                console.log('Mock carousel widget rendered');
            }
        }
    });

/**
 * Usage
 */
page.render({ "testing": true });
page.render({ "testing": false });

// Output
// Mock carousel widget rendered
// Carousel widget rendered

}());

/*
 * @category Design Pattern by JSA Tutorial
 * @package AbstractFactory Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

(function() {
"use strict";
    // Client
var PageClass = function( options ) {
        return {
            render: function() {
                var widget,
                    factory = ( options.testing ?
                        MockWidgetFactory.createInstance() : WidgetFactory.createInstance() );

                widget = factory.makeCarousel();
                widget.render();
            }
        }
    },
    // Abstract factory
    AbstractWidgetFactory = function() {
    },
    // Concrete factory
    MockWidgetFactory = function() {
        return {
            __extends__: AbstractWidgetFactory,
            makeCarousel: function() {
                return MockCarousel.createInstance();
            }
        }
    },
    // Concrete factory
    WidgetFactory = function() {
        return {
            __extends__: AbstractWidgetFactory,
            makeCarousel: function() {
                return Carousel.createInstance();
            }
        }
    },
    WidgetInterface = {
        render: []
    },
    // Abstract product
    AbstractWidget = function() {
    },
    Carousel = function() {
        return {
            __extends__: AbstractWidget,
            __implements__: WidgetInterface,
            render: function() {
                console.log('Carousel widget rendered');
            }
        }
    },
    MockCarousel = function() {
        return {
            __extends__: AbstractWidget,
            __implements__: WidgetInterface,
            render: function() {
                console.log('Mock carousel widget rendered');
            }
        }
    };

/**
 * Usage
 */
PageClass.createInstance({ "testing": true }).render();
PageClass.createInstance({ "testing": false }).render();

// Output
// Mock carousel widget rendered
// Carousel widget rendered

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Builder Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

// File: ./Document/Entity.php
namespace Document;

class Entity
{
    public $author = "George R. R. Martin";
    public $title = "A Song of Ice and Fire";
    public $chapters = array("Chapter 1", "Chapter 2");
}

// Director
// File: ./Document/Reader.php
namespace Document;

class Reader
{
    public function getDocument(\Document\Entity $document
        , \Document\AbstractConvertor $convertor)
    {
        $convertor->setAuthor($document->author);
        $convertor->setTitle($document->title);
        foreach ($document->chapters as $chapter) {
            $convertor->setText($chapter);
        }
        return $convertor->getDocument();
    }

}

// Abstract builder
// File: ./Document/AbstractConvertor.php
namespace Document;

abstract class AbstractConvertor
{
    protected $_buffer;
    abstract public function setAuthor($author);
    abstract public function setTitle($title);
    abstract public function setText($text);
    public function getDocument()
    {
        return$this->_buffer;
    }
}
// Concrete builder
// File: ./Document/Convertor/Pdf.php
namespace Document\Convertor;

class Pdf extends \Document\AbstractConvertor
{
    public function setAuthor($author)
    {
        $this->_buffer .= "PDF: Author info {$author}\n";
    }
    public function setTitle($title)
    {
        $this->_buffer .= "PDF: Title info {$title}\n";
    }
    public function setText($text)
    {
        $this->_buffer .= "PDF: {$text}\n";
    }

}
// Concrete builder
// File: ./Document/Convertor/Epub.php
namespace Document\Convertor;

class Epub extends \Document\AbstractConvertor
{
    public function setAuthor($author)
    {
        $this->_buffer .= "ePub: Author info {$author}\n";
    }
    public function setTitle($title)
    {
        $this->_buffer .= "ePub: Title info {$title}\n";
    }
    public function setText($text)
    {
        $this->_buffer .= "ePub: {$text}\n";
    }
}


/**
 * Usage
 */
include './Document/Entity.php';
include './Document/Reader.php';
include './Document/AbstractConvertor.php';
include './Document/Convertor/Pdf.php';
include './Document/Convertor/Epub.php';

$doc = new \Document\Entity();
$convertor = new \Document\Convertor\Pdf();
$reader = new \Document\Reader();
print $reader->getDocument($doc, $convertor);

// Output
// PDF: Author info George R. R. Martin
// PDF: Title info The Song of Ice and Fire
// PDF: Chapter 1
// PDF: Chapter 2

/*
 * @category Design Pattern Tutorial
 * @package Builder Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {
"use strict";

    // Widget is used to build a product
var AbstractWidget = function() {
    },
    mockWidget = Object.create( new AbstractWidget(), {
        render: {
            value: function() {
                return "The module has widget";
            }
        }
    }),
    // Concrete product
    module = null,
    // Director
    moduleManager = (function() {
        var _options = {
            title: "",
            widget: null,
            isClosable: false,
            isResizable: false
        };
        return {
            init: function( options ) {
                _options = options;
            },
            construct: function( builder ) {
                if ( builder instanceof AbstractBuilder === false ) {
                    throw new TypeError( "Argument must be an instance of AbstractBuilder" );
                }
                builder.buildWindow( _options.title );
                _options.widget %26%26 builder.attachWidget( _options.widget );
                _options.isClosable %26%26 builder.attachCloseButton();
                _options.isResizable %26%26 builder.attachResizeControl();
                return builder.getModule();
            }
        }
    }()),
    // Abstract builder
    AbstractBuilder = function() {
    },
    // Concrete builder
    themeA;
    // Members to be inherited by every theme
    AbstractBuilder.prototype = {
        markup: "",
        getModule: function() {
            return this.markup;
        }
    };

    themeA = Object.create( new AbstractBuilder(), {
        buildWindow: {
            value: function( title ) {
                this.markup += "Module " + title + " represented with ThemeA theme\n";
            }
        },
        attachCloseButton: {
            value: function() {
                this.markup += "The module has close button\n";
            }
        },
        attachWidget: {
            value: function( widget ) {
                if ( widget instanceof AbstractWidget === false ) {
                    throw new TypeError( "Argument must be an instance of AbstractWidget" );
                }
                this.markup += widget.render();
            }
        },
        attachResizeControl: {
            value: function() {
                this.markup += "The module has resize control\n";
            }
        }
    });

/**
 * Usage
 */
    moduleManager.init({
        title: "Example",
        widget: mockWidget,
        isClosable: true,
        isResizable: true
    });

    module = moduleManager.construct( themeA );
    console.log( module );

// Output
// Module Example represented with ThemeA theme
// The module has widgetThe module has close button
// The module has resize control

}());

/*
 * @category Design Pattern by JSA Tutorial
 * @package Builder Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {
"use strict";

    // Widget is used to build a product
var AbstractWidgetClass = function() {},
    MockWidgetClass = function() {
        return {
            __extends__: AbstractWidgetClass,
            render: function() {
                return "The module has widget";
            }
        }
    },
    // Concrete product
    module = null,
    // Abstract builder
    AbstractBuilderClass = function() {
        return {
            markup: "",
            getModule: function() {
                return this.markup;
            }
        }
    },
    DirectorInterface = {
        construct: [ AbstractBuilderClass ]
    },
    // Director
    moduleManagerClass = function( options ) {
        return {
            __implements__: DirectorInterface,
            construct: function( builder ) {
                builder.buildWindow( options.title );
                options.widget %26%26 builder.attachWidget( options.widget );
                options.isClosable %26%26 builder.attachCloseButton();
                options.isResizable %26%26 builder.attachResizeControl();
                return builder.getModule();
            }
        }
    },
    BuilderInterface = {
        buildWindow: [ "string" ],
        attachCloseButton: [],
        attachWidget: [ AbstractWidgetClass ],
        attachResizeControl: []
    },
    // Concrete builder
    ThemeAClass = function() {
        return {
            __extends__: AbstractBuilderClass,
            __implements__: BuilderInterface,
            buildWindow: function( title ) {
                this.markup += "Module " + title + " represented with ThemeA theme\n";
            },
            attachCloseButton: function() {
                this.markup += "The module has close button\n";
            },
            attachWidget: function( widget ) {
                this.markup += widget.render();
            },
            attachResizeControl: function() {
                this.markup += "The module has resize control\n";
            }
        }
    };

/**
 * Usage
 */
    module = moduleManagerClass.createInstance({
        title: "Example",
        widget: MockWidgetClass.createInstance(),
        isClosable: true,
        isResizable: true
    }).construct( ThemeAClass.createInstance() );
    console.log( module );

// Output
// Module Example represented with ThemeA theme
// The module has widgetThe module has close button
// The module has resize control

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Prototype Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

/**
 * Concrete prototype
 */
class Entity_EmailMessage
{
    public $headers = array();
    public $subject = null;
    public $message = null;
    public $to = null;
    public function headersAsString()
    {
        $out = "MIME-Version: 1.0\r\n";
        foreach ($this->headers as $key => $val) {
            $out .= sprintf("%s: %s\r\n", $key, $val);
        }
        return $out;
    }
}
class Lib_PhpNative_Email
{
    public function send(Entity_EmailMessage $message)
    {
        printf ("Following message sent:\n %s\n To: %s\n Subject: %s\n Message: %s\n\n",
            $message->headersAsString(), $message->to, $message->subject
            , $message->message);
    }
}
class Lib_Mailer
{
    private $_messages = array();

    public function enqueue($email, $messagePrototype)
    {
        $message = clone $messagePrototype;
        $message->to = $email;
        $this->_messages[] = $message;
    }
    public function sendToAll()
    {
        $sender = new Lib_PhpNative_Email();
        array_walk ($this->_messages, array($sender, "send"));
    }
}

/**
 * Usage
 */
$prototype = new Entity_EmailMessage();
$prototype->headers = array(
    'From' => 'Our project <[email protected]>',
    'Content-type' => 'text/html; charset="iso-8859-1"',
    'Content-Transfer-Encoding' => '8bit',
);
$prototype->subject = 'Newsletter from our project';
$prototype->message = 'Body text....';

$mailer = new Lib_Mailer();
$mailer->enqueue("[email protected]", $prototype);
$mailer->enqueue("[email protected]", $prototype);
$mailer->sendToAll();

// Output:
// Following message sent:
// MIME-Version: 1.0
// From: Our project <[email protected]>
// Content-type: text/html; charset="iso-8859-1"
// Content-Transfer-Encoding: 8bit
//
// To: [email protected]
// Subject: Newsletter from our project
// Message: Body text....
//
// Following message sent:
// MIME-Version: 1.0
// From: Our project <[email protected]>
// Content-type: text/html; charset="iso-8859-1"
// Content-Transfer-Encoding: 8bit
//
// To: [email protected]
// Subject: Newsletter from our project
// Message: Body text....

/*
 * @category Design Pattern Tutorial
 * @package Prototype Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

(function(){

function Clone() { }
function clone(obj) {
    Clone.prototype = obj;
    return new Clone();
}
/**
 * Concrete prototype
 */
var Row = function(id, title){
    return {
        id: id,
        title: title
    }
};

var TestApp = function() {
    var _private = {
        table: []
    }
    return {
        requestSampleRow: function() {
            return new Row(1, 'Sample');
        },
        pupulateTable: function(sample) {
            _private.table.push(sample);
            for (var i = 1; i < 5; i++) {
                var sampleClone = clone(sample);
                sampleClone.id += i;
                _private.table.push(sampleClone);
            }
        },
        renderTable: function() {
            _private.table.forEach(function(row){
                console.log('id: ' + row.id + ', title: ' + row.title);
            })
        }
    }
};
/**
 * Usage
 */
var app = new TestApp();

var sample = app.requestSampleRow();
app.pupulateTable(sample);
app.renderTable();

// Output:
// id: 1, title: Sample
// id: 2, title: Sample
// id: 3, title: Sample
// id: 4, title: Sample
// id: 5, title: Sample

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Singleton Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

class Registry
{
    private static $_instance = null;
    private $_data = array();

    public static function getInstance()
    {
        if (self::$_instance) {
            return self::$_instance;
        }
        return (self::$_instance = new self());
    }

    public function  __set($name,  $value)
    {
        $this->_data[$name] = $value;
    }
    public function  __get($name)
    {
        return (isset ($this->_data[$name]) ? $this->_data[$name] : null);
    }

}
/**
 * Usage
 */
Registry::getInstance()->aVar = 'aValue';
var_dump(Registry::getInstance()->aVar);

/*
 * @category Design Pattern Tutorial
 * @package Singleton Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {

var Registry = (function(){
    var data = {};
    return {
        set : function(name, value) {
            data[name] = value;
        },
        get : function(name) {
            return data[name];
        }
    }
})();

/*
 * Usage
 */
Registry.set('aVar', 'aValue');
alert(Registry.get('aVar'));

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Delegate Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

/**
 * Delegate
 */

class MockMailer
{
    public function send($to, $subject, $body)
    {
        printf ("Message to: %s, subject: %s, body: %s\n\n", $to, $subject, $body);
    }
}

/**
 * Delegator
 */
class Mailer
{
    public function send($to, $subject, $body)
    {
        $mailer = new MockMailer();
        $mailer->send($to, $subject, $body);
    }
}

/**
 * Usage
 */

$mailer = new Mailer();
$mailer->send("[email protected]", "a subject", "a body");

// Output:
// -> Message to: [email protected], subject: a subject, body: a body

/*
 * @category Design Pattern Tutorial
 * @package Delegate Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {
/**
 * Delegator
 */
var VideoPlayer = function() {
    if (window.navigator.userAgent.toLowerCase().match(/msie [0-8]\./i) !== null) {
        var delegate = new FlashDelegate();
    } else {
        var delegate = new Html5Delegate();
    }
    return {
        render : function(data) {
            return delegate.render(data);
        }
    }
}
/**
 * Concree Delegate 1
 */
var Html5Delegate = function() {
    var _private = {
        getVideoEl : function(width, height, poster) {
            var videoEl = document.createElement('video');
            videoEl.setAttribute('controls', 'controls');
            videoEl.setAttribute('preload', 'none');
            videoEl.setAttribute('poster', poster);
            videoEl.setAttribute('width', width);
            videoEl.setAttribute('height', height);
            return videoEl;
        },
        getSourceEl : function(type, src) {
            var srcEl = document.createElement('source');
            srcEl.setAttribute('type', type);
            srcEl.setAttribute('src', src);
            return srcEl;
        }
    }
    return {
        render : function(data) {
            var videoEl = _private.getVideoEl(
                data.width, data.height, data.poster);
            videoEl.appendChild(_private.getSourceEl('video/mp4', data.mp4Src));
            videoEl.appendChild(_private.getSourceEl('video/webm', data.webmSrc));
            videoEl.appendChild(_private.getSourceEl('video/ogg', data.oggSrc));
            return videoEl;
        }
    }
}
/**
 * Concree Delegate 2
 */
var FlashDelegate = function() {
    var FALLBACK_SWF = 'flashmediaelement.swf';
    var _private = {
        getObjectEl : function(width, height) {
            var objectEl = document.createElement('object');
            objectEl.setAttribute('type', 'application/x-shockwave-flash');
            objectEl.setAttribute('data', FALLBACK_SWF);
            objectEl.setAttribute('width', width);
            objectEl.setAttribute('height', height);
            return objectEl;
        },
        getParamEl : function(name, value) {
            var paramEl = document.createElement('param');
            paramEl.setAttribute('name', name);
            paramEl.setAttribute('value', value);
            return paramEl;
        }
    }
    return {
        render : function(data) {
            var objectEl = _private.getObjectEl(
                data.width, data.height);
            objectEl.appendChild(_private.getParamEl('movie', FALLBACK_SWF));
            objectEl.appendChild(_private.getParamEl('flashvars', 'controls=true%26poster='
                + data.poster + '%26file=' + data.mp4Src));
            return objectEl;
        }
    }
}

/**
 * Usage
 */

var player = new VideoPlayer();

console.log(player.render({
    width : 320,
    height: 240,
    poster: 'poster.jpg',
    mp4Src: 'myvideo.mp4',
    webmSrc: 'myvideo.webm',
    oggSrc: 'myvideo.ogg'
}));

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Bridge Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
/**
 * Implementor
 */
interface Dao_API_Interface
{
    public function fetchProfile($guid);
}
/**
 * Concrete implementor 1
 */
class Dao_RemoteServerApi implements Dao_API_Interface
{
    public function fetchProfile($guid)
    {
        return sprintf ("Profile #%d via remote server API\n", $guid);
    }
}
/**
 * Concrete implementor 2
 */
class Dao_LocalApi implements Dao_API_Interface
{
    public function fetchProfile($guid)
    {
        return sprintf ("Profile #%d via local API\n", $guid);
    }
}
/**
 * Abstraction
 */
class Dao_User
{
    private $_api;
    public function  __construct(Dao_API_Interface $api)
    {
        $this->_api = $api;
    }
    public function fetchProfile($guid)
    {
        return $this->_api->fetchProfile($guid);
    }
}

/**
 * Usage
 */
$dao = new Dao_User(new Dao_RemoteServerApi());
print $dao->fetchProfile(1);

// Output:
// Profile #1 via remote server API

/*
 * @category Design Pattern Tutorial
 * @package Bridge Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function () {
var SessionStorageApi = (function() {
    return {
        save: function (name, value) {
            console.log('Saved in SessionStorage');
            window.sessionStorage[name] = value;
        },
        get: function (name) {
            return window.sessionStorage[name];
        }
    }
}());

var CookieApi = (function() {
    return {
        save: function (name, value) {
            console.log('Saved in Cookies');
            document.cookie = name + "=" + escape(value);
        },
        get: function (name) {
            var key, val, cookieArr = document.cookie.split(";");
            for (var i = 0; i < cookieArr.length; i++) {
                  key = cookieArr[i].substr(0, cookieArr[i].indexOf("="));
                  val = cookieArr[i].substr(cookieArr[i].indexOf("=") + 1);
                  key = key.replace(/^\s+|\s+$/g,"");
                  if (key == name) {
                    return unescape(val);
                  }
              }
        }
    }
}());

var NotepadWidget = function(api) {
    var DATA_ID = 'noteWidgetText';
    return {
        get: function() {
            return api.get(DATA_ID);
        },
        save: function(text) {
            api.save(DATA_ID, text);
        }
    }
}

/**
 * Usage
 */
var notepad = new NotepadWidget(SessionStorageApi);
notepad.save('Lorem ipsum');
console.log(notepad.get());

// Output:
// Saved in SessionStorage
// Lorem ipsum

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Adapter Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

/**
 * Db Factory
 */
class Lib_Db
{
    public function  __construct(Config $config)
    {
        $className = sprintf("Lib_Db_Adapter_%s", $config->driver);
        if (class_exists($className)) {
            $db = new $className();
            $db->connect($config);
            return $db;
        }
    }
}

interface Db_Adapter_Interface
{
    public function connect(Config $config);
    public function fetch($sql);
}
/**
 * MySQLi Adapter
 */
class Lib_Db_Adapter_Mysqli implements Db_Adapter_Interface
{
    private $_mysqli;

    public function connect(Config $config)
    {
        $this->_mysqli = new mysqli($config->host, $config->user, $config->password
            , $config->dbscheme);
    }
    public function fetch($sql)
    {
        return $this->_mysqli->query($sql)->fetch_object();
    }

}
/**
 * MySQLi Pdo
 */
class Lib_Db_Adapter_Pdo implements Db_Adapter_Interface
{
    private $_dbh;

    public function connect(Config $config)
    {
        $dsn = sprintf('msqli::dbname=%s;host=%s', $config->dbscheme, $config->host);
        $this->_dbh = new PDO($dsn, $config->user, $config->password);
    }
    public function fetch($sql)
    {
        $sth = $this->_dbh->prepare($sql);
        $sth->execute();
        return $sth->fetch();
    }
}
/**
 * Usage
 */
class Config
{
    public $driver = 'Mysqli';
    public $host = 'localhost';
    public $user = 'test';
    public $password = 'test';
    public $dbscheme = 'test';
}
$config = new Config();

$db = new Lib_Db($config);
$db->fetch('SELECT * FROM `test`');

/*
 * @category Design Pattern Tutorial
 * @package Adapter Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function($, YUI) {

var jQuery_Adapter = function() {
    var _node;
    return {
        find : function(selector) {
            _node = $(selector);
            return this;
        },
        setAttr : function(attr, value) {
            _node.attr(attr, value);
        },
        getAttr : function(attr) {
            return _node.attr(attr);
        }
    }
}

var YUI_Adapter = function() {
    var _node;
    return {
        find : function(selector) {
            _node = Y.one(selector);
            return this;
        },
        setAttr : function(attr, value) {
            _node.set(attr, value);
        },
        getAttr : function(attr) {
            return _node.get(attr);
        }
    }
}

var Framework = (function() {
    var ADAPTER = jQuery_Adapter;
    return new ADAPTER();
}());

/**
 * Usage
 */
Framework.find('div').set('id', 'something');

}(jQuery, YUI));

<?php
/*
 * @category Design Pattern Tutorial
 * @package Composite Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
/**
 * Component
 */
interface Content_Interface
{
    public function save();
}
/**
 * Composite
 */
class Content_Composite implements Content_Interface
{
    private $_items = array();

    public function addItem(Content_Interface $content)
    {
        $this->_items[spl_object_hash($content)] = $content;
    }
    public function removeItem(Content_Interface $content)
    {
        unset($this->_items[spl_object_hash($content)]);
    }
    public function save()
    {
        foreach ($this->_items as $content) {
            $content->save();
        }
    }
}
/**
 * Leaf
 */
class Article implements Content_Interface
{
    public $id;
    public $title;

    public function  __construct($title)
    {
        static $_id = 1;
        $this->id = $_id ++;
        $this->title = $title;
    }
    public function save()
    {
        printf ("Article #%d, %s saved\n", $this->id, $this->title);
    }
}

/**
 * Usage
 */
$article1 = new Article('Title 1');
$article2 = new Article('Title 2');
$article3 = new Article('Title 3');
$composite1 = new Content_Composite();
$composite11 = new Content_Composite();
$composite12 = new Content_Composite();
$composite11->addItem($article1);
$composite11->addItem($article2);
$composite12->addItem($article3);
$composite1->addItem($composite11);
$composite1->addItem($composite12);
$composite1->save();

// Output:
// Article #1, Title 1 saved
// Article #2, Title 2 saved
// Article #3, Title 3 saved

/*
 * @category Design Pattern Tutorial
 * @package Composite Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {
/**
 * Composite
 */
var ContentComposite = function() {
    var _items = [];
    return {
        addItem: function(content) {
            _items.push(content);
        },
        save: function() {
            for (var i in _items) {
                _items[i].save();
            }
        }

    }
};
/**
 * Leaf
 */
var Article = function(title) {
    Article._id = Article._id || 1;
    this.id = Article._id ++;
    this.title = title;
    this.save = function() {
        console.log("Article #" + this.id + ", " + this.title + " saved");
    }
};

/**
 * Usage
 */
var article1 = new Article('Title 1');
var article2 = new Article('Title 2');
var article3 = new Article('Title 3');
var composite1 = new ContentComposite();
var composite11 = new ContentComposite();
var composite12 = new ContentComposite();

composite11.addItem(article1);
composite11.addItem(article2);
composite12.addItem(article3);
composite1.addItem(composite11);
composite1.addItem(composite12);
composite1.save();

// Output:
// Article #1, Title 1 saved
// Article #2, Title 2 saved
// Article #3, Title 3 saved

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Decorator Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

class ContentRowArray extends ArrayObject
{
}

class Dao_Comment
{
    public function fetchAll()
    {
        return new ContentRowArray(array(
            array("title" => 'Lorem [b]ipsum[/b]', 'body' => 'Lorem ipsum'),
            array("title" => 'Lorem ipsum', 'body' => 'Lorem <script>alert(1);</script>ipsum')
        ));
    }
}

class ContentRowListDecorator
{
    private $_rowArray;
    public function  __construct(ContentRowArray %26$rowArray)
    {
        $this->_rowArray = %26$rowArray;
    }
    public function parseBBCode()
    {
        $this->_rowArray = new ContentRowArray(array_map(function ($li) {
            // do parsing
            return preg_replace("/\[b\](.*?)\[\/b\]/is", "<b>\\1</b>", $li); }
            , $this->_rowArray->getArrayCopy()));
    }
    public function breakLongStrings()
    {
        //..
    }
    public function stripXss()
    {
        $this->_rowArray = new ContentRowArray(array_map(function ($li) {
            // do stripping
            return preg_replace("/(<script.*?>.*?<\/script>)/", "", $li); }
            , $this->_rowArray->getArrayCopy()));
    }
}

/**
 * Usage
 */
$comment = new Dao_Comment();
$rowArray = $comment->fetchAll();
$decorator = new ContentRowListDecorator($rowArray);
$decorator->parseBBCode();
$decorator->stripXss();
print_r($rowArray);

// Output:
// ContentRowArray Object
// (
//    [storage:ArrayObject:private] => Array
//        (
//            [0] => Array
//                (
//                    [title] => Lorem <b>ipsum</b>
//                    [body] => Lorem ipsum
//                )
//
//            [1] => Array
//                (
//                    [title] => Lorem ipsum
//                    [body] => Lorem ipsum
//                )
//
//        )
//
// )

/*
 * @category Design Pattern Tutorial
 * @package Decorator Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {
var Widget = function() {
    return {
        list : ['Lorem ipsum', 'Lorem ipsum'],
        toString: function() {
            return this.list.reduce(function (accum, value) {
                return accum + "\n" + value;
            });
        }
    }
}

var CssShimDecorator = function(widget) {
    return {
        shimCaps : function() {
            widget.list.forEach(function (value, i, arr) {
                arr[i] += '<span>' + value.substr(0,1) + '</span>' + value.substr(1);
            });
        }
    }
}

/**
 * Usage
 */
var wg = new Widget();
console.log(wg.toString());
var shim = new CssShimDecorator(wg);
shim.shimCaps();
console.log(wg.toString());

// Output
// Lorem ipsum
// Lorem ipsum
// Lorem ipsum<span>L</span>orem ipsum
// Lorem ipsum<span>L</span>orem ipsum

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Flyweight Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

/**
 * Flyweight object
 */
class LogEntry
{
    private $_message = null;
    public function  __construct($message)
    {
        $this->_message = $message;
    }
    public function getMessage(LogEntryContext $context)
    {
        return $this->_message . " " . strftime("%b %d, %Y / %H:%M", $context->getTimestamp());
    }
}
class LogEntryContext
{
    private $_timestamp = null;
    public function  __construct($timestamp)
    {
        $this->_timestamp = $timestamp;
    }
    public function  getTimestamp()
    {
        return $this->_timestamp;
    }
}
/**
 * FlyweightFactory object
 */
class LogEntryFactory
{
    private static $_messages = array();
    private static $_callCount = 0;
    public static function make($message)
    {
        $hash = md5($message);
        if (!isset (self::$_messages[$hash])) {
            self::$_messages[$hash] = new LogEntry($message);
        }
        self::$_callCount ++;
        return  self::$_messages[$hash];
    }
    public static function getInstanceCount()
    {
        return count(self::$_messages);
    }
    public static function getRequestCount()
    {
        return self::$_callCount;
    }
}

class Logger
{
    private $_logEntries;
    private $_timeStamps;
    public function  __construct()
    {
        $this->_logEntries = new SplDoublyLinkedList();
        $this->_timeStamps = new SplDoublyLinkedList();
    }
    public function log($message)
    {
        $this->_logEntries->push(LogEntryFactory::make($message));
        $this->_timeStamps->push(new LogEntryContext(time()));
    }
    public function printMessages()
    {
        $len = $this->_logEntries->count();
        for ($i = 0; $i < $len; $i ++) {
            echo $this->_logEntries[$i]->getMessage($this->_timeStamps[$i]), "\n";
        }
    }
}
/**
 * Usage
 */
$logger = new Logger();
$logger->log('Page #1 viewed');
$logger->log('Page #1 updated');
$logger->log('Page #1 viewed');
$logger->log('Page #1 viewed');
$logger->log('Page #1 deleted');
$logger->printMessages();

echo LogEntryFactory::getRequestCount(), " LogEntry instances were requested\n";
echo LogEntryFactory::getInstanceCount(), " LogEntry instances were really created\n";

// Output:
// Page #1 viewed Dec 04, 2011 / 19:04
// Page #1 updated Dec 04, 2011 / 19:04
// Page #1 viewed Dec 04, 2011 / 19:04
// Page #1 viewed Dec 04, 2011 / 19:04
// Page #1 deleted Dec 04, 2011 / 19:04
// 3 LogEntry instances were really created
// 5 LogEntry instances were requested

/*
 * @category Design Pattern Tutorial
 * @package Flyweight Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {

var ERROR_INUSUFFICIENT_ARG_TYPE = 1,
    ERROR_INUSUFFICIENT_ARG_VALUE = 2,
    ERROR_NODE_IS_UNDEFINED = 3;

var ErrorMap = [];
ErrorMap[ERROR_INUSUFFICIENT_ARG_TYPE] = 'Insufficient argument type';
ErrorMap[ERROR_INUSUFFICIENT_ARG_VALUE] = 'Insufficient argument value';
ErrorMap[ERROR_NODE_IS_UNDEFINED] = 'Node is undefined';

/**
 * Flyweight object
 */
var ErrorLogEntry = function(errCode){
    var _errCode = errCode;
    return {
        getMessage: function(context) {
            return ErrorMap[_errCode] + " " + context.getDate();
        }
    }
};
var ErrorLogEntryContext = function(date){
    var _date = date;
    return {
        getDate: function() {
            return _date;
        }
    }
};

/**
 * FlyweightFactory object
 */
var ErrorLogEntryFactory = (function(){
    var _messages = [], _callCount = 0, _creationCount = 0;
    return {
        make : function(errCode) {
            if (typeof _messages[errCode] === 'undefined') {
                _messages[errCode] = new ErrorLogEntry(errCode);
                _creationCount += 1;
            }
            _callCount += 1;
            return _messages[errCode];
        },
        getInstanceCount: function() {

            return _creationCount;
        },
        getRequestCount: function() {
            return _callCount;
        }
    }
}());

var ErrorLogger = function(){
    var _errCodes = [], _dates = [];
    return {
        log: function(errCode) {
            _errCodes.push(ErrorLogEntryFactory.make(errCode));
            _dates.push(new ErrorLogEntryContext(new Date()));
        },
        printMessages: function() {
            _errCodes.forEach(function(logEntry, inx){
                console.log(logEntry.getMessage(_dates[inx]));
            });
        }
    }
};

/**
 * Usage
 */

var logger = new ErrorLogger();
logger.log(ERROR_INUSUFFICIENT_ARG_TYPE);
logger.log(ERROR_INUSUFFICIENT_ARG_TYPE);
logger.log(ERROR_INUSUFFICIENT_ARG_VALUE);
logger.log(ERROR_INUSUFFICIENT_ARG_TYPE);
logger.log(ERROR_NODE_IS_UNDEFINED);

logger.printMessages();

console.log(ErrorLogEntryFactory.getRequestCount() + " ErrorLogEntry instances were requested");
console.log(ErrorLogEntryFactory.getInstanceCount() + " LogEntry instances were really created");

// Output:
// Insufficient argument type Mon Dec 05 2011 13:02:30 GMT+0100
// Insufficient argument type Mon Dec 05 2011 13:02:30 GMT+0100
// Insufficient argument value Mon Dec 05 2011 13:02:30 GMT+0100
// Insufficient argument type Mon Dec 05 2011 13:02:30 GMT+0100
// Node is undefined Mon Dec 05 2011 13:02:30 GMT+0100
// 5 ErrorLogEntry instances were requested
// 3 LogEntry instances were really created

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Facade Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

class Lib_String
{
    public static function parseHomographs($text)
    {
       static $homographs = null;
       if ($homographs === null) {
           // include "../homographs.php"
           $homographs = array(); // TILT
       }
       $text = strtr($text, $homographs);
    }
    public static function removeControlChars($text)
    {
        $text = preg_replace('#(?:[\x00-\x1F\x7F]+|(?:\xC2[\x80-\x9F])+)#', '', $text);
    }
    public static function removeMultipleSpaces($text)
    {
        $text = preg_replace('# {2,}#', ' ', $text);
    }
}

class Model_UserFacade
{
    public function getCleanUsername($username)
    {
        $username = Lib_String::parseHomographs($username);
        $username = Lib_String::removeControlChars($username);
        $username = Lib_String::removeMultipleSpaces($username);
        return trim($username);
    }
}

/*
 * @category Design Pattern Tutorial
 * @package Facade Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {

var NotificationWidget = (function() {
    var _private = {
        data: [],
        populate : function( data ) {
            this.data = data;
        },
        show : function() {
            console.log('Widget displayed with the data:');
            this.data.forEach(function(val){
                console.log(val);
            });
        }
    };
    return {
        facade : function( args ) {
            _private.populate(args.data);
            if ( args.show ) {
                _private.show();
            }
        }
    }
}());

/**
 * Usage
 */

NotificationWidget.facade({show: true, data: ['One gets message', 'Another gets like']});

// Output:
// Widget displayed with the data:
// One gets message
// Another gets like

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Proxy Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
/**
 * Subject interface
 */
interface Entry_Interface
{
    public function get();
}
/**
 * Subject
 */
class Entry implements Entry_Interface
{
    private $_id;
    public function  __construct($id)
    {
        $this->_id;
    }
    public function get()
    {
        return "Entry #{$this->_id} retrieved";
    }
}
/**
 * Proxy
 */
class Entry_ChacheProxy implements Entry_Interface
{
    private $_id;
    public function  __construct($id)
    {
        $this->_id;
    }
    public function get()
    {
        static $entry = null;
        if ($entry === null) {
            $entry = new Entry($this->_id);
        }
        return $entry->get();
    }
}

/**
 * Usage
 */
$entryId = 1;
$entry = new Entry_ChacheProxy($entryId);
echo $entry->get(), "\n"; // loading necessary
echo $entry->get(), "\n"; // loading unnecessary

/*
 * @category Design Pattern Tutorial
 * @package Proxy Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {
/**
 * Abstract object for data source
 */
var DataSource = function(url) {
   this.url = url;
   return {
       makeRequest: function(method, paramString) {
            var _xhr = new XMLHttpRequest(),
            _scope = this;
            _xhr.open(method, this.url, true);
            _xhr.onreadystatechange = function() {
                if (_xhr.readyState === 4 %26%26 _xhr.status == 200 %26%26_xhr.responseText.length) {
                   _scope.onMessageProxy(JSON.parse(_xhr.responseText));
                }
            };
            _xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
            _xhr.setRequestHeader("Content-type","application/x-www-form-urlencoded");
            _xhr.send(paramString);
       },
       get : function(params) {
           this.makeRequest("POST", params);
       },
       onMessageProxy: function(data) {
           this.onMessage(data);
       }
   }
};
/**
 * Concrete data source
 */
// Let's extends PageDataSource with DataSource
var PageDataSource = function(url) {
    this.url = url;
}
PageDataSource.prototype = new DataSource();
PageDataSource.prototype.get = function(pageId) {
    this.makeRequest("POST", 'pageId=' + pageId);
};

/**
 * Proxy object for the data source
 */
// Let's extends PageDataSourceCacheProxy with PageDataSource
var PageDataSourceCacheProxy = function(url)
{
    this.url = url;
    this._storage = [];
}
PageDataSourceCacheProxy.prototype = new PageDataSource();
PageDataSourceCacheProxy.prototype.get = function(pageId) {
    return (this._storage[pageId]
        ? this.onMessageProxy(this._storage[pageId])
        : this.makeRequest("POST", 'pageId=' + pageId));
};
PageDataSourceCacheProxy.prototype.onMessageProxy = function(data) {
    this._storage[data.pageId] = data;
    this.onMessage(data);
};

/**
 * Usage
 */
var pageId = 2,
    src = new PageDataSourceCacheProxy('testController.php');

src.onMessage = function(data) {
   // When first time requested, it is delivered by XMLHttpRequest
   // when the secind time, just taken from cache
   console.log(data);
}
src.get(pageId);
// Let's wait before first request cached and then request
setTimeout(function() {
    src.get(pageId)
}, 1000);

})();

<?php
/*
 * @category Design Pattern Tutorial
 * @package DAO Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

abstract class Dao_Abstract
{
    protected $_connection;
    protected $_primaryKey;
    protected $_tableName;

    public function  __construct($connection)
    {
        $this->_connection = $connection;
    }
    public function find($value, $key = NULL)
    {
        if (is_null($key)) {
            $key = $this->_primaryKey;
        }
        return $this->_connection->fetch(sprintf(
            "SELECT * FROM %s WHERE %s = '%s'", $this->_tableName, $this->_primaryKey, $value));
    }
    public function findAll($value, $key = NULL)
    {
        //..
    }
    public function insert($assocArray)
    {
        //..
    }
    public function update($assocArray)
    {
        //..
    }
    public function delete($key = NULL)
    {
        //..
    }
}

class Dao_User extends Dao_Abstract
{
    protected $_primaryKey = "userId";
    protected $_tableName = "User";

    public function findByEmail($email)
    {
        return $this->find($email, 'email');
    }
}

/**
 * Usage
 */
$user = Dao_User(Lib_Db::getInstance('masterDb'));
$user->findByEmail('[email protected]');

/*
 * @category Design Pattern Tutorial
 * @package DAO Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {
var DataAccess = function() {
    return {
        get: function(controller, params, callback) {
            // Here can be XMLHttpRequest
            callback({
                'userId' : 1,
                'name' : 'Jon Snow',
                'email' : '[email protected]'
            });
        }
    }
}

var Dao_Abstract = function() {
    return {
        fetch : function(value, key) {
            if (typeof key === "undefined") {
                key = this._primaryKey;
            }
            this._dataAccess.get(this._controllerName, {'value' : value, 'key' : key}, this.onMessage);
        }
    }
}

var Dao_User = function(dataAccess, entity) {
    this._dataAccess = new DataAccess();
    this._controllerName = 'UserController';
    this._primaryKey = 'userId';
}
Dao_User.prototype = new Dao_Abstract();
Dao_User.prototype.fetchByEmail = function(email) {
     this.fetch(email, 'email');
}

/**
 * Usage
 */
var user = new Dao_User(new DataAccess());
// User can be retrieved asynchronously, so onMessage handler will server to catch output
user.onMessage = function(user) { console.log(user); };
user.fetchByEmail('[email protected]');

// Output
// -> Object { userId=1, name="Jon Snow", email="[email protected]"}

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Command Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

/**
 * The Receiver classes
 */
abstract class Model_Abstract
{
}
class Model_Search extends Model_Abstract
{
    public function index()
    {
        echo "Site re-indexed\n";
    }
}
class Model_Session extends Model_Abstract
{
    public function cleanup()
    {
        echo "Session cleaned up\n";
    }
}
class Lib_JobQueue extends SplQueue
{
}
/**
 * The Command classes
 */
abstract class Job_Abstract
{
    protected $_receiver;
    public function  __construct(Model_Abstract $receiver) {
        $this->_receiver = $receiver;
    }
    abstract public function execute();
}
class Job_IndexSearch extends Job_Abstract
{
    public function execute()
    {
         $this->_receiver->index();
    }
}
class Job_CleanupSessions extends Job_Abstract
{
    public function execute()
    {
        $this->_receiver->cleanup();
    }
}

/**
 * Usage
 */
$queue = new SplQueue(); // Job Queue
$searchReceiver = new Model_Search();
$sessionReceiver = new Model_Session();
$queue->enqueue(new Job_IndexSearch($searchReceiver));
$queue->enqueue(new Job_CleanupSessions($sessionReceiver));

foreach ($queue as $job) {
    $job->execute();
}

// Output:
// Site re-indexed
// Session cleaned up

/*
 * @category Design Pattern Tutorial
 * @package Command Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {
/**
 * The invoker
 */
var SwitcherConstructor = function(showCommand, hideCommand){
    return {
        show: function() {
            showCommand.execute();
        },
        hide: function() {
            hideCommand.execute();
        }
    }
};
/**
 * The receiver
 */
var Widget = (function(){
    return {
        show : function() {
            console.log('Widget displayed');
        },
        hide : function() {
            console.log('Widget hidden');
        }
    }
}());
/**
 * The command to show given widget
 */
var showCommandConstructor = function(receiver) {
    return {
        execute: function() {
            receiver.show();
        }
    }
};
/**
 * The command to hide given widget
 */
var hideCommandConstructor = function(receiver) {
    return {
        execute: function() {
            receiver.hide();
        }
    }
};

/**
 * Usage
 */
var showCommand = new showCommandConstructor(Widget),
    hideCommand = new hideCommandConstructor(Widget),
    switcher = new SwitcherConstructor(showCommand, hideCommand);

switcher.show();
switcher.hide();

// Output:
// Widget displayed
// Widget hidden

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Chain of Responsibility Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

abstract class Logger
{
    private $_next = null;
    public function setNext(Logger $logger)
    {
        $this->_next = $logger;
        return $this->_next;
    }
    public function log($message)
    {
        $this->_log($message);
        if ($this->_next !== null) {
            $this->_next->log($message);
        }
    }
    abstract protected function _log($message);
}
class EmailLogger extends Logger
{
    public function _log($message)
    {
        echo "Sending via email: ", $message, " \n";
    }
}
class ErrorLogger extends Logger
{
    protected function _log($message)
    {
        echo "Sending to stderr: ", $message, " \n";
    }
}
class StdoutLogger extends Logger
{
    protected function _log($message)
    {
        echo "Writing to stdout: ", $message, " \n";
    }
}


/**
 * Usage
 */
$logger = new StdoutLogger();
$logger->setNext(new ErrorLogger())->setNext(new EmailLogger());
$logger->log('Something happened');

// Output:
// Writing to stdout: Something happened
// Sending to stderr: Something happened
// Sending via email: Something happened

/*
 * @category Design Pattern Tutorial
 * @package Chain of Responsibility Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {
var CommandChain = function() {
    var _commands = [];
    return {
        addCommand: function(command) {
            _commands.push(command);
            return this;
        },
        runCommand: function(args) {
            for (var i in _commands) {
                _commands[i].onCommand(args);
            }
        }
    };
};

var PageMetadata = (function() {
    return {
        onCommand: function(args) {
            console.log('Page title is set to ' + args.title);
        }
    };
}());
var PageMainNavigation = (function() {
    return {
        onCommand: function(args) {
            console.log('Menu refreshed to hihlight page ' + args.pageId);
        }
    };
}());
var PageContent = (function() {
    return {
        onCommand: function(args) {
            console.log('Article title changed to ' + args.title);
            console.log('Article content changed to ' + args.content);
        }
    };
}());
var DataAccess = (function() {
    return {
        get: function(pageId, chain) {
            // Here we request data, let's say it's done
            var data = {
                title: "In the Seven Kingdoms",
                content: "The novel begins with Lord Eddard Stark (Ned) in Winterfell, ancestral home of House Stark, a noble house of the Seven Kingdoms of Westeros and rulers of the North.",
                pageId: pageId
            };
            chain.runCommand(data);
        }
    };
}());
var PageSiblingNavigation = (function() {
    var pageId = 1;
    return {
        getNext : function() {
            var chain = new CommandChain();
            chain.addCommand(PageMetadata)
                .addCommand(PageMainNavigation)
                .addCommand(PageContent);

            DataAccess.get(pageId + 1, chain);
        }
    };
}());

/**
 * Usage
 */
PageSiblingNavigation.getNext();

// Output:
// Page title is set to In the Seven Kingdoms
// Menu refreshed to hihlight page 2
// Article title changed to In the Seven Kingdoms
// Article content changed to The novel begins ...

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Mediator Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

class Model_JobApplication
{
    const STATUS_HIRED = 7;
    private $_mediator;

    public function  __construct(Model_Mediator_Interface $mediator = null)
    {
        $this->_mediator = $mediator;
    }

    public function updateStatus($id, $newStatusId)
    {
        if (!is_null($this->_mediator)) {
            $this->_mediator->update($this, array(
                "statusId" => $newStatusId,
                "appId" => $id,
                "posId" => 1 // TILT
                ));
        }
    }
}
class Model_JobPosition
{
    public function updateAsStatusChanges($data)
    {
        if ($data['statusId'] === Model_JobApplication::STATUS_HIRED) {
            echo 'Number of open vacancies decremented', "\n";
        }
    }
}
class Model_JobPositionObserver
{
    // Observers and job positions on which they are subscibed for status updates
    private $_subscription = array(
        '[email protected]' => array(1 => array(Model_JobApplication::STATUS_HIRED)),
        '[email protected]' => array(1 => array(Model_JobApplication::STATUS_HIRED))
    );

    public function updateAsStatusChanges($data)
    {
        foreach ($this->_subscription as $mail => $positions) {
            if (isset ($positions[$data['posId']])
                %26%26 in_array($data['statusId'], $positions[$data['posId']])) {
                echo $mail . ' notified', "\n";
            }
        }
    }
}
interface Model_Mediator_Interface
{
    public function update($origObject, $data);
}
class Model_Mediator_JobApplicationStatus implements Model_Mediator_Interface
{
    private $_subscribers = array('JobPosition', 'JobPositionObserver');
    public function update($origObject, $data)
    {
        foreach ($this->_subscribers as $subscriber) {
            $subscriberClass = 'Model_' . $subscriber;
            if (!($origObject instanceof $subscriberClass)) {
                $object = new $subscriberClass();
                $object->updateAsStatusChanges($data);
            }
        }
    }
}

/**
 * Usage
 */

$model = new Model_JobApplication(new Model_Mediator_JobApplicationStatus());
$id = 1;
$newStatusId = Model_JobApplication::STATUS_HIRED;
$model->updateStatus($id, $newStatusId);

// Output:
// Number of open vacancies decremented
// [email protected] notified
// [email protected] notified

/*
 * @category Design Pattern Tutorial
 * @package Mediator Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {

// Mediator by Addy Osmani
var mediator = (function(){
    var subscribe = function(channel, fn){
        if (!mediator.channels[channel]) mediator.channels[channel] = [];
        mediator.channels[channel].push({ context: this, callback: fn });
        return this;
    },

    publish = function(channel){
        if (!mediator.channels[channel]) return false;
        var args = Array.prototype.slice.call(arguments, 1);
        for (var i = 0, l = mediator.channels[channel].length; i < l; i++) {
            var subscription = mediator.channels[channel][i];
            subscription.callback.apply(subscription.context, args);
        }
        return this;
    };

    return {
        channels: {},
        publish: publish,
        subscribe: subscribe,
        installTo: function(obj){
            obj.subscribe = subscribe;
            obj.publish = publish;
        }
    };

}());

var ForgetPasswordFormWidget = (function() {
    var _handler = {
        AuthServicesLocked : function(data) {
            console.log('Forget password form locked');
        },
        AuthServicesUnlocked: function(data) {
            console.log('Forget password form unlocked');
        }
    }
    subscribe('AuthServicesLocked', _handler.AuthServicesLocked );
    subscribe('AuthServicesUnlocked', _handler.AuthServicesUnlocked);
    return {

    }
}());
mediator.installTo(ForgetPasswordFormWidget);

var LoginFormWidget = (function() {
    return {
        login : function() {
            // Imagine, it sends here request to the server
            console.log('Login form locked');
            this.publish('AuthServicesLocked', {});
            console.log('Login form unlocked');
            this.publish('AuthServicesUnlocked', {});
        }
    }
}());
mediator.installTo(LoginFormWidget);

/**
 * Usage
 */
LoginFormWidget.login();

// Output
// Login form locked
// Forget password form locked
// Login form unlocked
// Forget password form unlocked

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Iterator Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
class Dao_News
{
    public function fetchAll()
    {
        $raws = array(
            (object)array("id" => 1, "title" => "Title 1"),
            (object)array("id" => 2, "title" => "Title 2"),
            (object)array("id" => 3, "title" => "Title 3"),
        );
        return new ArrayIterator($raws);
    }
}
/**
 * Usage
 */
$dao = new Dao_News();
$newIt = $dao->fetchAll();
for ($newIt->rewind(); $newIt->valid(); $newIt->next()) {
    echo $newIt->current()->title, "\n";
}

// Output:
// Title 1
// Title 2
// Title 3

/*
 * @category Design Pattern Tutorial
 * @package Iterator Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {

var ArrayIterator = function(data) {
    var _key = 0,
        _valid = !!data.length;

    return {
        next: function() {
            var max = data.length - 1;
            _valid = _key < max ? !!(++_key) : false;
        },
        rewind: function() {
            _valid = !!data.length;
            _key = 0;
        },
        valid: function() {
            return _valid;
        },
        current: function() {
            return data[_key];
        },
        key: function() {
            return _key;
        }
    };
};
/**
 * Usage
 */
var it = new ArrayIterator(["first", "second", "third"]);
for (it.rewind(); it.valid(); it.next()) {
    console.log(it.current());
}
// Output:
// first
// second
// third

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Memento Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
/**
 * Memento
 */
class Memento
{
    private $_originator;
    public function  __construct(%26$originator)
    {
        $this->_originator = %26$originator;
    }
    public function save()
    {
        $this->_state = $this->_originator->getState();
    }
    public function restore()
    {
        $this->_originator->setState($this->_state);
    }
}
/**
 * Originator
 */
interface Restorable
{
    public function getState();
    public function setState($state);
}
class RestorableIterator implements Iterator, Restorable
{
    private $_data;
    private $_cursor = 0;
    private $_valid = false;

    public function  __construct(array $data = array())
    {
        $this->_data = $data;
        $this->_valid = (bool)count($this->_data);
    }
    public function current()
    {
        return $this->_data[$this->_cursor];
    }
    public function key()
    {
        return $this->_cursor;
    }
    public function getState()
    {
        return $this->_cursor;
    }
    public function setState($state)
    {
        $this->_cursor = $state;
    }
    public function next()
    {
        $max = count($this->_data) - 1;
        $this->_valid = $this->_cursor < $max ? (bool)(++$this->_cursor) : false;
    }
    public function rewind()
    {
        $this->_valid = (bool)count($this->_data);
        $this->_cursor = 0;
    }
    public function valid()
    {
        return $this->_valid;
    }
}
/**
 * Caretaker
 */
$it = new RestorableIterator(array('a', 'b', 'c', 'd'));
$itMemento = new Memento($it);
$it->next();
$itMemento->save();
$it->next();
$it->next();
echo "Current value ", $it->current(), "\n";
$itMemento->restore();
echo "Current value ", $it->current(), "\n";

// Output:
// Current value d
// Current value b

/*
 * @category Design Pattern Tutorial
 * @package Memento Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {
/**
 * Memento
 */
var PageBookmarker = function(doc) {
    var _private = {
      bookmarks: []
    };
    return {
        savePage : function(name) {
            if (typeof name !== 'string' || name.length ===  0) {
                throw new TypeError('Insufficient type');
            }
            _private.bookmarks[name] = doc.getPage();
        },
        restorePage : function(name) {
            if (typeof _private.bookmarks[name] === 'undefined') {
                throw new Error('Bookmark not found');
            }
            doc.setPage(_private.bookmarks[name]);
        }
    }
};
/**
 * Originator
 */
var OpenDocument = function() {
    var _private = {
      page: 1
    };
    return {
        setPage: function(page) {
            _private.page = page;
        },
        getPage: function() {
            return _private.page;
        }
    }
};

/**
 * Usage
 */

var doc = new OpenDocument(),
    bookmarker = new PageBookmarker(doc);

doc.setPage(2);
bookmarker.savePage('test');
doc.setPage(4);
console.log('Current page ' + doc.getPage());
bookmarker.restorePage('test');
console.log('Saved page ' + doc.getPage());

// Output:
// Current page 4
// Saved page 2

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Observer Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

class Plugin_Bookmark implements SplObserver
{
    public function deleteByUserId($userId)
    {
        printf ("Bookmarks of user %d deleted\n", $userId);
    }
    public function update(SplSubject $subject)
    {
        $userId = $subject->getId();
        $this->deleteByUserId($userId);
    }
}
class Plugin_Liking implements SplObserver
{
    public function deleteByUserId($userId)
    {
        printf ("Likings of user %d deleted\n", $userId);
    }
    public function update(SplSubject $subject)
    {
        $userId = $subject->getId();
        $this->deleteByUserId($userId);
    }
}

abstract class Pluginable_Abstract implements SplSubject
{
    // Array of observers
    private $_observers = array();

    public function attach(SplObserver $observer)
    {
        $hash = spl_object_hash($observer);
        if (!isset ($this->_observers[$hash])) {
            $this->_observers[$hash] = $observer;
        }
    }
    public function detach(SplObserver $observer)
    {
        unset($this->_observers[spl_object_hash($observer)]);
    }
    /**
     * Implement SplSubject method
     */
    public function notify()
    {
        foreach ($this->_observers as $value) {
            $value->update($this);
        }
    }
}

class Model_Abstract extends Pluginable_Abstract
{
    // Common and abstract properies and methods of Models
}
class Model_User extends Model_Abstract
{
    private $_userId;

    public function setId($userId)
    {
        $this->_userId = $userId;
    }

    public function getId()
    {
        return $this->_userId;
    }

    public function delete($userId)
    {
        $this->setId($userId);
        printf ("User %d deleted\n", $userId);
        $this->notify();
    }
}

/**
 * Usage
 */
$userId = 1;
$model = new Model_User();
$model->attach(new Plugin_Bookmark());
$model->attach(new Plugin_Liking());
$model->delete($userId);

// Output
// -> User 1 deleted
// -> Bookmarks of user 1 deleted
// -> Likings of user 1 deleted

/*
 * @category Design Pattern Tutorial
 * @package Observer Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {
/**
 * Concrete observer
 */
var SilverLightFallbackPlugin = function() {}
SilverLightFallbackPlugin.prototype.update = function(subject) {
    // Renders SilverLight embedding into subject.node.viewport element
    console.log('SilverLight fallback is shown');
}
/**
 * Abstract subject
 */
var Subject = function() {
    var _observers = [];
    return {
        attach : function(observer) {
            _observers.push(observer);
        },
        notify : function() {
            for (var i in _observers) {
                _observers[i].update(this);
            }
        }
    };
};
/**
 * Concrete subject
 */
var VideoPlayer = function(settings) {
    // Attaches all given observers
    for (var i in settings.plugins) {
        this.attach(settings.plugins[i]);
    }
    //...
    if (this.isVideoTagSupportAvailable()) {
        this.renderUI();
        this.syncUI();
    } else {
        this.renderFallback();
    }
};
VideoPlayer.prototype = new Subject();
VideoPlayer.prototype.node = {
    viewport : null
};
VideoPlayer.prototype.renderUI = function() {
    //...
}
VideoPlayer.prototype.syncUI = function() {
    //...
}
VideoPlayer.prototype.isVideoTagSupportAvailable = function() {
    //...
    return false;
}
VideoPlayer.prototype.renderFallback = function() {
    //...
    this.notify();
}

/**
 * Usage
 */
new VideoPlayer({ plugins: [ new SilverLightFallbackPlugin() ]});

// Output:
// -> SilverLight fallback is shown

})();

<?php
/*
 * @category Design Pattern Tutorial
 * @package Strategy Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

class Profile
{
    public $data;
    protected $_strategy;

    public function  __construct(array $data)
    {
        $this->data = $data;
    }
    public function setStrategyContext(RichSnippetStrategyAbstract $strategy)
    {
        $this->_strategy = $strategy;
    }
    public function get() {
        return $this->_strategy->get($this);
    }

}


abstract class RichSnippetStrategyAbstract
{
    protected $_cardTemplate;
    protected $_propertyTpls;

    protected function _getReplacePairs($properties)
    {
        $replPairs = array();
        foreach ($properties as $property => $val) {
            if (is_array ($val)) {
                $val = $this->_process($val);
            }
            $replPairs['{' . $property . '}'] =
                strtr($this->_propertyTpls[$property], array('{value}' => $val));
        }
        return $replPairs;
    }

    protected function _process(array $data)
    {
        if (!isset ($data["template"]) || !isset ($data["properties"])) {
            throw new Exception('Input data structure is not correct');
        }
        return strtr($data["template"], $this->_getReplacePairs($data["properties"]));
    }

    public function get(Profile $context)
    {
        $card = $this->_process($context->data);
        return sprintf($this->_cardTpl, $card);
    }
}

class ProfileAsMicrodataStrategy extends RichSnippetStrategyAbstract
{
    protected $_cardTpl = '<div itemscope itemtype="http://data-vocabulary.org/Person">%s</div>';
    protected $_propertyTpls = array(
        'name' => '<span itemprop="name">{value}</span>',
        'nickname' => '<span itemprop="nickname">{value}</span>',
        'url' => '<a href="{value}" itemprop="url">{value}</a>',
        'address' => '<span itemprop="address" itemscope itemtype="http://data-vocabulary.org/Address">{value}</span>',
        'locality' => '<span itemprop="locality">{value}</span>',
        'region' => '<span itemprop="region">{value}</span>',
        'title' => '<span itemprop="title">{value}</span>',
        'org' => '<span itemprop="affiliation">{value}</span>');

}
class ProfileAsMicroformatStrategy extends RichSnippetStrategyAbstract
{
    protected $_cardTpl = '<div class="vcard">%s</div>';
    protected $_propertyTpls = array(
        'name' => '<span class="fn">{value}</span>',
        'nickname' => '<span class="nickname">{value}</span>',
        'url' => '<a href="{value}"class="url">{value}</a>',
        'address' => '<span class="adr">{value}</span>',
        'locality' => '<span class="locality">{value}</span>',
        'region' => '<span class="region">{value}</span>',
        'title' => ' <span class="title">{value}</span>',
        'org' => '<span class="org">{value}</span>');
}
class ProfileAsRdfStrategy extends RichSnippetStrategyAbstract
{
    protected $_cardTpl = '<div xmlns:v="http://rdf.data-vocabulary.org/#" typeof="v:Person">%s</div>';
    protected $_propertyTpls = array(
        'name' => '<span property="v:name">{value}</span>',
        'nickname' => '<span property="v:nickname">{value}</span>',
        'url' => '<a href="{value}" rel="v:url">{value}</a>',
        'address' => '<span rel="v:address"><span typeof="v:Address">{value}</span></span>',
        'locality' => '<span property="v:locality">{value}</span>',
        'region' => '<span property="v:region">{value}</span>',
        'title' => '<span property="v:title">{value}</span>',
        'org' => '<span property="v:affiliation">{value}</span>');
}

/**
 * Usage
 */
$profileData = array (
    'template' =>
        'My name is {name}, but friends call me {nickname}.'
        . ' Here is my home page: {url}.'
        . ' Now I live in {address} and work as a {title} at {org}.',
    'properties' => array (
        'name' => 'Dmitry Sheiko',
        'nickname' => 'Dima',
        'url' => 'http://dsheiko.com',
        'address' => array (
            'template' => '{locality}, {region}',
            'properties' => array (
                'locality' => 'Frankfurt am Main',
                'region' => 'Germany',
            )
        ),
        'title' => 'web-developer',
        'org' => 'Crytek',
    )
);
$profile = new Profile($profileData);
$profile->setStrategyContext(new ProfileAsMicrodataStrategy());
echo $profile->get(), "\n";
$profile->setStrategyContext(new ProfileAsMicroformatStrategy());
echo $profile->get(), "\n";

// Output
// -> <div itemscope itemtype="http://data-vocabulary.org/Person">My ...
// -> <div class="vcard">My name is <span class="fn">Dmitry Sheiko ...

/*
 * @category Design Pattern Tutorial
 * @package Strategy Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {

var VideoPlayer = function(data) {
    var _strategy = null,
        _data = data;
    return {
        data : _data,
        setStrategyContext : function(strategy) {
            _strategy = strategy;
        },
        render : function() {
            return _strategy.render(this);
        }
    }
}
var VideoPlayerViaHTML5 = function() {
    var _private = {
        getVideoEl : function(width, height, poster) {
            var videoEl = document.createElement('video');
            videoEl.setAttribute('controls', 'controls');
            videoEl.setAttribute('preload', 'none');
            videoEl.setAttribute('poster', poster);
            videoEl.setAttribute('width', width);
            videoEl.setAttribute('height', height);
            return videoEl;
        },
        getSourceEl : function(type, src) {
            var srcEl = document.createElement('source');
            srcEl.setAttribute('type', type);
            srcEl.setAttribute('src', src);
            return srcEl;
        }
    }
    return {
        render : function(context) {
            var videoEl = _private.getVideoEl(
                context.data.width, context.data.height, context.data.poster);
            videoEl.appendChild(_private.getSourceEl('video/mp4', context.data.mp4Src));
            videoEl.appendChild(_private.getSourceEl('video/webm', context.data.webmSrc));
            videoEl.appendChild(_private.getSourceEl('video/ogg', context.data.oggSrc));
            return videoEl;
        }
    }
}
var VideoPlayerViaFlash = function() {
    var FALLBACK_SWF = 'flashmediaelement.swf';
    var _private = {
        getObjectEl : function(width, height) {
            var objectEl = document.createElement('object');
            objectEl.setAttribute('type', 'application/x-shockwave-flash');
            objectEl.setAttribute('data', FALLBACK_SWF);
            objectEl.setAttribute('width', width);
            objectEl.setAttribute('height', height);
            return objectEl;
        },
        getParamEl : function(name, value) {
            var paramEl = document.createElement('param');
            paramEl.setAttribute('name', name);
            paramEl.setAttribute('value', value);
            return paramEl;
        }
    }
    return {
        render : function(context) {
            var objectEl = _private.getObjectEl(
                context.data.width, context.data.height);
            objectEl.appendChild(_private.getParamEl('movie', FALLBACK_SWF));
            objectEl.appendChild(_private.getParamEl('flashvars', 'controls=true%26poster='
                + context.data.poster + '%26file=' + context.data.mp4Src));
            return objectEl;
        }
    }
}

var context = new VideoPlayer({
    width : 320,
    height: 240,
    poster: 'poster.jpg',
    mp4Src: 'myvideo.mp4',
    webmSrc: 'myvideo.webm',
    oggSrc: 'myvideo.ogg'
});

if (window.navigator.userAgent.toLowerCase().match(/msie [0-8]\./i) !== null) {
    context.setStrategyContext(new VideoPlayerViaFlash());
} else {
    context.setStrategyContext(new VideoPlayerViaHTML5());
}
console.log(context.render());

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package State Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

/**
 * The state interface and two implementations
 */
interface State_Logging_Interface
{
    public function log(Lib_Logger $context);
}
class State_Logging_File implements State_Logging_Interface
{
    public function log(Lib_Logger $context)
    {
        echo $context->getMessage(), ' logged into file', "\n";
    }
}
class State_Logging_Db implements State_Logging_Interface
{
    private static function _isDbAvailable()
    {
        static $counter = false;
        $counter = !$counter;
        return $counter;
    }
    public function log(Lib_Logger $context)
    {
        if ($this->_isDbAvailable()) {
            echo $context->getMessage(), ' logged into DB', "\n";
        } else {
            $context->setState(new State_Logging_File());
            $context->log($context->getMessage());
            $context->log('DB connection is not available');
        }
    }
}
/**
 * Context class
 */
class Lib_Logger
{
    private $_state;
    private $_message;
    public function  __construct()
    {
        // Default state
        $this->_state = new State_Logging_Db();
    }
    public function setState(State_Logging_Interface $state)
    {
        $this->_state = $state;
    }
    public function getMessage()
    {
        return $this->_message;
    }
    public function log($message )
    {
        $this->_message = $message;
        $this->_state->log($this, $message);
    }
}

/**
 * Usage
 */
$logger = new Lib_Logger();
$logger->log('Message 1');
$logger->log('Message 2');
$logger->log('Message 3');

// Output:
// Message 1 logged into DB
// Message 2 logged into file
// DB connection is not available logged into file
// Message 3 logged into file

/*
 * @category Design Pattern Tutorial
 * @package State Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function(document) {

/**
 * Helps to preserve calling context
 */
var Util = {
    proxy : function (method, context) {
        if (typeof method == 'string') method = context[method];
        var cb = function () {method.apply(context, arguments);}
        return cb;
     }
 };

/**
 * State objects
 */
var ManageUserListBlockState = function(widget) {
    return {
        submit: function() {
            widget.node.form.action = 'BLOCK_CONTROLLER_URI';
            widget.node.form.submit();
        }
    }
}
var ManageUserListDeleteState = function(widget) {
    return {
        submit: function() {
            widget.node.form.action = 'DELETE_CONTROLLER_URI';
            widget.node.form.submit();
        }
    }
}
/**
 * Base constructor for Widgets
 */
var WidgetAbstract = {
    init: function(settings) {
        this.node = {};
        this.node.boundingBox = document.querySelector(settings.boundingBox);
        if (this.hasOwnProperty('PARSE_HTML')) {
            for (var i in this.PARSE_HTML) {
                this.node[i] = document.querySelector(this.PARSE_HTML[i]);
            }
        }
        if (this.hasOwnProperty('syncUI')) {
            this.syncUI();
        }
        if (this.hasOwnProperty('renderUI')) {
            this.renderUI();
        }
    }
}
/**
 * Widget contains submit action depending on states
 */
var ManageUserListWidget = function(settings) {
    var _handler = {
        onUpdateOptionChange : function(e) {
            if (this.node.selectUpdateOptions.value === 'delete') {
                this.setState(new ManageUserListDeleteState(this));
            } else {
                this.setState(new ManageUserListBlockState(this));
            }
        },
        onFormSubmit: function(e) {
            e.preventDefault();
            this.state.submit();
        }
    }
    return {
        state : null,
        init: function() {
            WidgetAbstract.init.call(this, settings);
            this.state = new ManageUserListBlockState(this); // default state
        },
        PARSE_HTML: {
            form : "form",
            selectUpdateOptions: "select"
        },
        syncUI: function() {
            this.node.form.addEventListener('submit', Util.proxy(_handler.onFormSubmit, this), false);
            this.node.selectUpdateOptions.addEventListener('change'
                , Util.proxy(_handler.onUpdateOptionChange, this), false);
        },
        setState: function(state) {
            this.state = state;
        }
    }
}

/**
 * Usage
 */
var widget = new ManageUserListWidget({boundingBox: 'div.userList'});
widget.init();

}(document));

<?php
/*
 * @category Design Pattern Tutorial
 * @package Visitor Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

abstract class Content
{
    public $title;
    abstract public function save();
}
class Book extends Content
{
    public $author;
    public $isbn;
    public $chapters = array();
    public function addItem($chapter)
    {
        $this->chapters[] = $chapter;
    }
    public function save()
    {
        //..
    }
    public function accept(ContentVisitor $visitor)
    {
        $visitor->visit($this);
        array_map(function($element) use ($visitor) {
            $element->accept($visitor);
        }, $this->chapters);
    }
}
class Chapter extends Content
{
    public $articles = array();
    public function addItem($article)
    {
        $this->articles[] = $article;
    }
    public function save()
    {
        //..
    }
    public function accept(ContentVisitor $visitor)
    {
        $visitor->visit($this);
        array_map(function($element) use ($visitor) {
            $element->accept($visitor);
        }, $this->articles);
    }
}
class Artile extends Content
{
    public $text = "...";
    public function save()
    {
        //..
    }
    public function accept(ContentVisitor $visitor)
    {
        $visitor->visit($this);
    }
}

interface ContentVisitor
{
    public function visit(Content $content);
}

class Reporter implements ContentVisitor
{
    public function visit(Content $content)
    {
        echo "\nObject: ", get_class($content), " \n";
        foreach ($content as $property => $value) {
            echo $property . ": ", $value, " \n";
        }
    }
}


/**
 * Usage
 */

$book1 = new Book();
$book1->title = "Clean Code A Handbook of Agile Software Craftsmanship";
$book1->author = "Robert C. Martin";
$book1->isbn = "0132350882";
$chapter1 = new Chapter();
$chapter1->title = "Chapter 17: Smells and Heuristics";
$article1 = new Artile();
$article1->title = "C1: Inappropriate Information";
$article2 = new Artile();
$article2->title = "C2: Obsolete Comment";
$article3 = new Artile();
$article3->title = "C3: Redundant Comment";
$chapter1->addItem($article1);
$chapter1->addItem($article2);
$chapter1->addItem($article3);
$book1->addItem($chapter1);

$book1->accept(new Reporter());

// Output:
// Object: Book
// author: Robert C. Martin
// isbn: 0132350882
// chapters: Array
// title: Clean Code A Handbook of Agile Software Craftsmanship
//
// Object: Chapter
// articles: Array
// title: Chapter 17: Smells and Heuristics
//
// Object: Artile
// text: ...
// title: C1: Inappropriate Information
//
// Object: Artile
// text: ...
// title: C2: Obsolete Comment
//
// Object: Artile
// text: ...
// title: C3: Redundant Comment

/*
 * @category Design Pattern Tutorial
 * @package Visitor Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {
/**
 * Helper function, which performs synchronous XMLHttpRequest
 */
var Gateway = {};
Gateway.post = function(url, data, callback) {
    var _xhr = new XMLHttpRequest();
    _xhr.open("POST", url, false);
    _xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
    _xhr.setRequestHeader("Content-type","application/x-www-form-urlencoded");
    _xhr.send(data);
    if (_xhr.status == 0) {
        callback (JSON.parse(_xhr.responseText));
    }
};

var Session = {
    userId : 1
};

var CommentList = function(article) {
    var _article = article;
    return {
        arrivals : [],
        acceptVisitor : function(visitor) {
            visitor.visitCommentList(this);
        },
        update: function() {
            Gateway.post("/comment/getAllNew", 'articleId=' + _article.id, function(data){
                this.arrivals = data;
            });
        }
    }
}
var NotificationList = function() {
    return {
        list : [],
        visitCommentList : function(commentList) {
            for (var i in commentList.arrivals) {
                var message = commentList.arrivals[i];
                if (message.targetUserId == Session.userId) {
                    this.list.push('New comment from ' + message.targetUserName);
                }
            }
        }
    }
}
var NotificationIndicator = function() {
    return {
        counter: 0,
        visitCommentList : function(commentList) {
            for (var i in commentList.arrivals) {
                var message = commentList.arrivals[i];
                if (message.targetUserId == Session.userId) {
                   this.counter ++;
                }
            }
        }
    }
}

/**
 * Usage
 */
var widget = new CommentList({ id: 1});
widget.update();
widget.acceptVisitor(new NotificationList());
widget.acceptVisitor(new NotificationIndicator());

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Interpreter Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
/**
 * Context
 */
class View
{
    private $_vars;

    public function assign($var, $val)
    {
        $this->_vars[$var] = $val;
    }
    public function getVars()
    {
        return $this->_vars;
    }

}
/**
 * Expression
 */
interface Expression_Interface
{
    public function interpret($expression, View $context);
}
class Web_Template_Interpreter implements Expression_Interface
{
    public function interpret($expression, View $context)
    {
        $assigments = self::_getAssigmentsMap($context->getVars());
        $output = strtr($expression, $assigments);
        if (($errorMsg = self::_isValidXml($output)) === true) {
            return $output;
        } else {
            return "[Error:]\n" . $errorMsg;
        }
    }
    private static function _getAssigmentsMap($vars)
    {
        $keys = array_map(function ($key) { return "{{$key}}"; }, array_keys($vars));
        return array_combine($keys, array_values($vars));
    }
    private static function _isValidXml($xml)
    {
        libxml_use_internal_errors(true);
        $sxe = simplexml_load_string("<?xml version='1.0' standalone='yes'?>{$xml}");
        if (!$sxe) {
            $msgs = array_map(function ($li) { return $li->message; }, libxml_get_errors());
            return implode("", $msgs);
        }
        return true;
    }
}

/**
 * Usage
 */

$view = new View();
$view->assign('title', 'Article Title');
$view->assign('text', 'Lorem ipsum dolor sit amet, consectetur adipisicing elit');

$invalidTpl = <<<'EOD'
<article>
    <header>
        ...
EOD;
$validTpl = <<<'EOD'
<article>
    <header>
      <h2>{title}</h2>
    </header>
    <section>
      {text}
    </section>
</article>
EOD;

$interpreter = new Web_Template_Interpreter();

echo "Invalid template:\n", $interpreter->interpret($invalidTpl, $view), "\n---------------\n\n";
echo "Valid template:\n", $interpreter->interpret($validTpl, $view), "\n---------------\n\n";

// Output:
// Invalid template:
// [Error:]
// Premature end of data in tag header line 2
// Premature end of data in tag article line 1
//
// ---------------
//
// Valid template:
// <article>
//     <header>
//       <h2>Article Title</h2>
//     </header>
//     <section>
//       Lorem ipsum dolor sit amet, consectetur adipisicing elit
//     </section>
// </article>
// ---------------

/*
 * @category Design Pattern Tutorial
 * @package Interpreter Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {

var View_Template = function() {
    var _template = null, _vars = [];

    return {
        assign: function(key, val) {
            _vars[key] = val;
        },
        setTemplate: function (template) {
            _template = template;
        },
        getTemplate: function () {
            return _template;
        },
        getVars: function () {
            return _vars;
        }
    }
}

var Web_Template_Interpreter = function(viewTemplate) {
    var _viewTemplate = viewTemplate;
    return {
        getInterpreted: function() {
            var tpl = _viewTemplate.getTemplate();
            var vars = _viewTemplate.getVars();
            for (var key in vars) {
                var re = new RegExp("\{" + key + "\}", 'g');
                tpl = tpl.replace(re, vars[key]);
            };
            return tpl;
        }
    }
}

/**
 * Usage
 */

var tmp = new View_Template();
tmp.setTemplate('<article><header><h2>{title}</h2></header>'
+ '<section>{text}</section></article>');
tmp.assign('title', 'Article Title');
tmp.assign('text', 'Lorem ipsum dolor sit amet, consectetur adipisicing elit');
var interpreter = new Web_Template_Interpreter(tmp);
console.log(interpreter.getInterpreted());

// Output
// <article><header><h2>Article Title</h2></header>
// <section>Lorem ipsum dolor sit amet, consectetur adipisicing elit</section></article>

}());

<?php
/*
 * @category Design Pattern Tutorial
 * @package Template Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */

class Mock
{
    public static function mail($to, $subject, $body, $headers)
    {
        printf ("Mail to %s\nHeaders: %s\nSubject: %s\nBody: %s\n\n", $to, $headers, $subject, $body);
    }
}
/**
 * Template class
 */
abstract class FeedbackFormTemplate
{
    const FEEDBACK_RECIPIENT_EMAIL = '[email protected]';
    protected $_subject;
    protected $_fromName;
    protected $_fromEmail;

    public function send()
    {
        $body = $this->_getBody() . $this->_getAttachment();
        Mock::mail(self::FEEDBACK_RECIPIENT_EMAIL, $this->_subject, $body, $this->_getHeaders());
    }
    private function _getHeaders()
    {
        return sprintf("From: %s <%s>\r\n", $this->_fromName, $this->_fromEmail);
    }
    private function _getAttachment()
    {
        return strtr('<h2>Session Info</h1><d2>'
            . '<dt>User Id:</dt><dd>{userId}</dd>'
            . '<dt>User Agent:</dt><dd>{userAgent}</dd>'
            . '<dt>URI:</dt><dd>{uri}</dd>'
            . '</dl>', array(
                '{userId}' => (isset ($_SESSION["userId"]) ? $_SESSION["userId"] : "undefined"),
                '{userAgent}' => $_SERVER["HTTP_USER_AGENT"],
                '{uri}' => $_SERVER["REQUEST_URI"],
            ));
    }
    abstract protected function _getBody();
}
/**
 * Concrete implementations
 */
final class SupportFeedbackForm extends FeedbackFormTemplate
{
    protected $_subject = 'Support Request';
    private $_data;

    public function  __construct(SupportFeedbackFormEntity $data)
    {
        $this->_data = $data;
        $this->_fromName = $data->name;
        $this->_fromEmail = $data->email;
    }
    protected function _getBody()
    {
        return strtr('<h1>{title}</h1><dl>'
            . '<dt>Name:</dt><dd>{name}</dd>'
            . '<dt>Email:</dt><dd>{email}</dd>'
            . '<dt>Category:</dt><dd>{city}</dd>'
            . '<dt>Message:</dt><dd>{message}</dd>'
            . '</dl>', array(
                '{title}' => $this->_subject,
                '{name}' => $this->_data->name,
                '{email}' => $this->_data->email,
                '{category}' => $this->_data->category,
                '{message}' => $this->_data->message,
            ));
    }
}


final class ContactFeedbackForm extends FeedbackFormTemplate
{
    protected $_subject = 'Contact Form Request';
    private $_data;

    public function  __construct(ContactFeedbackFormEntity $data)
    {
        $this->_data = $data;
        $this->_fromName = $data->name;
        $this->_fromEmail = $data->email;
    }
    protected function _getBody()
    {
        return srttr('<h1>{title}</h1><dl>'
            . '<dt>Name:</dt><dd>{name}</dd>'
            . '<dt>Email:</dt><dd>{email}</dd>'
            . '<dt>City:</dt><dd>{city}</dd>'
            . '<dt>Address:</dt><dd>{address}</dd>'
            . '<dt>Message:</dt><dd>{message}</dd>'
            . '</dl>', array(
                '{title}' => $this->_subject,
                '{name}' => $this->_data->name,
                '{email}' => $this->_data->email,
                '{city}' => $this->_data->city,
                '{address}' => $this->_data->address,
                '{message}' => $this->_data->message,
            ));
    }

}
/**
 * Data Transfer Objects
 */
abstract class FeedbackFormEntity
{
    public $name;
    public $email;
    public $message;
}
class ContactFeedbackFormEntity extends FeedbackFormEntity
{
    public $city;
    public $address;
}
class SupportFeedbackFormEntity extends FeedbackFormEntity
{
    public $category;
}

/**
 * Usage
 */
$data = new SupportFeedbackFormEntity();
$data->name = "John Snow";
$data->email = "John Snow";
$data->category = "John Snow";
$data->message = "John Snow";
$form = new SupportFeedbackForm($data);
$form->send();

// Output
// Mail to [email protected]
// Headers: From: John Snow <John Snow>
// Subject: Support Request
// Body: <h1>Support Request</h1>..

/*
 * @category Design Pattern Tutorial
 * @package Template Sample
 * @author Dmitry Sheiko <[email protected]>
 * @link http://dsheiko.com
 */
(function() {

var Channel = new WebSocket("ws://site.com/demo");

/**
 * Template object
 */
var EventTemplate = function() {}
EventTemplate.prototype = {
    eventType : null,
    send : function(senderClientId, addresseeClientIds) {
        Channel.send({
            eventType : this.eventType,
            senderClientId : senderClientId,
            addresseeClientIds : addresseeClientIds,
            payload : this.getPayload()
        });
    }
}
/**
 * Concrete implementations
 */
var NotificationEvent = function(notificationType) {
    // Validate input arguments
    this.eventType = 'Notification';
    this.notificationType = notificationType;
}
NotificationEvent.prototype = new EventTemplate();
NotificationEvent.prototype.notificationType = null;
NotificationEvent.prototype.getPayload = function() {
    return {
        notificationType : this.notificationType
    }
}
var MessageEvent = function(messageText) {
    // Validate input arguments
    this.eventType = 'Message';
    this.messageText = messageText;
}
MessageEvent.prototype = new EventTemplate();
MessageEvent.prototype.messageText = null;
MessageEvent.prototype.getPayload = function() {
    return {
        messageText : this.messageText
    }
}

/**
 * Usage
 */
var event = new NotificationEvent('Like');
event.send(1, [2]);
var event = new MessageEvent('Text');
event.send(1, [2]);

})();