This package is abandoned and no longer maintained. No replacement package was suggested.

An experiment in compositional programming.

0.4.5 2014-11-06 17:55 UTC

This package is auto-updated.

Last update: 2020-06-19 11:47:35 UTC


An experiment in compositional programming. Inspired by and

Build Status


The two projects listed above are both good ideas, but have serious limitations. The phpProxyBuilder is does not generate correct type-hinting information, which completely stops me from being able to use it.

The ProxyManager is nice, but has issues with how it interacts with other code and seems to make debugging code incredibly hard. I also couldn't see how to implement a caching proxy.

This project is an attempt to allow generating various types of decorated versions of classes with a goal of:

  • Great flexibility on how they're used.

  • Retaining ability to debug code.

  • Low overhead both mentally and by code weight.

  • Keep type-hinting intact to allow Auryn DI to work correctly.


We have a class and we want to be able to time the calls to 'executeQuery'

class TestClass {

    function __construct($statement, $createLine){
        $this->statement = $statement;
        $this->createLine = $createLine;

    function executeQuery($queryString, $foo2) {
        echo "executing query!";
        return 5;

Weaved with a 'class' to that holds a timer:


namespace Weaver\Weave;

use Intahwebz\Timer;

class TimerProxy {

    private $timer;

    function __construct(Timer $timer) {
        $this->timer = $timer;

    function reportTimings() {

And with a tiny bit of glue to bind the two:

$timerWeaving = array(
    'executeQuery' => array(

Produces a decorated class:

namespace Example;

use Intahwebz\Timer;

class TimerProxyXTestClass extends \Example\TestClass

    private $timer = null;

    public function executeQuery($queryString, $foo2)
        $result = parent::executeQuery($queryString, $foo2);

        return $result;

    public function reportTimings()

    public function __construct($statement, $createLine, \Intahwebz\Timer $timer)
        parent::__construct($statement, $createLine);
                $this->timer = $timer;


Because I use a real DI, I can now change my config to include:

$injector->alias(TestClass::class, TimerProxyXTestClass::class);

And the Proxied version of the class with the timer attached will be used everywhere that the original class was used.


  • Figure out what to do about factories, because having to make a new factory for every combination of thing sucks. e.g. CachedTimedStatementWrapperFactory to make a cached, timed, statementWrapper factory.

  • Write about difference between this and monkey patching Short version Monkey patching runtime only, impossible to debug, not much type safety.


  • Source class - the original class that needs to have it's behaviour modified.

  • Decorator class - the class that will be used to decorate the source class.

  • Decorated class - the result of the weaving.


List of examples that I should implement from Ocramius/ProxyManager

Lazy Loading Value Holders (Virtual Proxy) Access Interceptor Value Holder Null Objects Ghost Objects - for lazy loading Lazy References - wat Remote Object

Protection Proxy class APIProtectionProxy extends API { protected $count = 0; public function __construct(API $api, $limit) { $this->api = $api; $this->limit = $limit; }

public function doStuff() {
    return $this->api->doStuff();

private function count() {
    if (++$this->count > $this->limit) {
        throw new RemoteApiLimit('STAHP!');