CallableWrapper.php

<?php
/*
    This file is part of Erebot, a modular IRC bot written in PHP.

    Copyright © 2010 François Poirotte

    Erebot is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Erebot is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Erebot.  If not, see <http://www.gnu.org/licenses/>.
*/

namespace Erebot;

abstract class CallableWrapper implements \Erebot\CallableInterface
{
    protected $callable;

    protected $representation;

    protected function __construct($callable)
    {
        $this->callable = $callable;
    }

    public function __toString()
    {
        return static::represent($this->callable);
    }

    public static function wrap($callable)
    {
        $parts          = explode('::', static::represent($callable));
        if (count($parts) == 1) {
            // We wrapped a function.
            $reflector = new \ReflectionFunction($callable);
        } else {
            if (!is_array($callable)) {
                // We wrapped a Closure or some invokable object.
                $callable = array($callable, $parts[1]);
            }
            $reflector = new \ReflectionMethod($callable[0], $callable[1]);
        }

        // References are lost, unless __invoke()'s signature also requires them.
        // We must also make sure default values are preserved.
        $args = array();
        foreach ($reflector->getParameters() as $argReflect) {
            $arg = '';
            if ($argReflect->isPassedByReference()) {
                $arg .= '&';
            }
            $arg .= '$a' . count($args);
            if ($argReflect->isOptional()) {
                $arg .= '=' . var_export($argReflect->getDefaultValue(), true);
            } else {
                $arg .= '=null';
            }
            $args[] = $arg;
        }

        $args   = implode(',', $args);
        $class  = 'Wrapped_' . sha1($args);
        if (!class_exists("\\Erebot\\CallableWrapper\\$class", false)) {
            $tpl = "
                namespace Erebot\\CallableWrapper {
                    class $class extends \\Erebot\\CallableWrapper
                    {
                        public function __invoke($args)
                        {
                            // HACK: we use debug_backtrace() to get (and pass along)
                            // references for call_user_func_array().

                            // Starting with PHP 5.4.0, it is possible to limit
                            // the number of stack frames returned.
                            if (version_compare(PHP_VERSION, '5.4', '>='))
                                \$bt = debug_backtrace(0, 1);
                            // Starting with PHP 5.3.6, the first argument
                            // to debug_backtrace() is a bitmask of options.
                            else if (version_compare(PHP_VERSION, '5.3.6', '>='))
                                \$bt = debug_backtrace(0);
                            else
                                \$bt = debug_backtrace(FALSE);

                            if (isset(\$bt[0]['args']))
                                \$args =& \$bt[0]['args'];
                            else
                                \$args = array();
                            return call_user_func_array(\$this->callable, \$args);
                        }
                    }
                }
            ";
            eval($tpl);
        }
        $class = "\\Erebot\\CallableWrapper\\$class";
        return new $class($callable);
    }

    public static function initialize()
    {
        static $initialized = false;
        static $structures  = array();

        if (defined('T_CALLABLE'))
            return;

        if (!$initialized) {
            spl_autoload_register(
                function ($class) {
                    $parts  = array_map('strrev', explode('\\', strrev($class), 2));
                    $short  = array_shift($parts);
                    $ns     = (string) array_shift($parts);

                    if ($short === 'callable') {
                        // The class to load is "callable", inject the alias.
                        if (class_alias('\\Erebot\\CallableInterface', $class, true) !== true) {
                            throw new \RuntimeException('Could not load wrapper');
                        }
                        return true;
                    }

                    // Otherwise, inject the alias in the namespace
                    // of the class being loaded.
                    class_exists("$ns\\callable");
                    return false;
                },
                true
            );
            $initialized = true;
        }

        // Inject the alias in existing namespaces.
        $funcs  = get_defined_functions();
        $new    = array_merge(
            $funcs['user'],
            get_declared_classes(),
            get_declared_interfaces()
        );

        if ($new != $structures) {
            $newNS = array();
            foreach (array_diff($new, $structures) as $structure) {
                    $parts = explode('\\', strrev($structure), 2);
                    array_shift($parts); // Remove class/interface name.
                    $newNS[] = (string) array_shift($parts);
            }
            $structures = $new;
            $newNS      = array_unique($newNS);
            foreach ($newNS as $ns) {
                class_exists(strrev($ns) . '\\callable');
            }
        }
    }

    public static function represent($callable)
    {
        if (!is_callable($callable, false, $representation)) {
            throw new \InvalidArgumentException('Not a valid callable');
        }

        // This happens for anonymous functions
        // created with create_function().
        if (is_string($callable) && $representation == "") {
            $representation = $callable;
        }
        return $representation;
    }
}