PHPRealCoverage\Proxy\ProxyBuilder

Complexity

Total Complexity

9

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	setClassName()	0	4	1
A	setNamespace()	0	4	1
A	setParentClass()	0	4	1
A	addMethod()	0	4	1
A	loadProxy()	0	10	2
B	getProxyHeader()	0	36	1
A	getProxyFooter()	0	5	1
A	getProxyMethod()	0	11	1

<?php

namespace PHPRealCoverage\Proxy;

class ProxyBuilder
{
    private $namespace;
    private $className;
    private $parentClass;
    private $methods = array();

    /**
     * @param string $className
     */
    public function setClassName($className)
    {
        $this->className = $className;
    }

    /**
     * @param string $namspace
     */
    public function setNamespace($namspace)
    {
        $this->namespace = $namspace;
    }

    /**
     * @param string $parentClass
     */
    public function setParentClass($parentClass)
    {
        $this->parentClass = $parentClass;
    }

    /**
     * @param string $method
     */
    public function addMethod($method)
    {
        $this->methods[] = $method;
    }

    public function loadProxy()
    {
        $proxyContent = $this->getProxyHeader();
        foreach ($this->methods as $method) {
            $proxyContent .= $this->getProxyMethod($method);
        }
        $proxyContent = $this->getProxyFooter($proxyContent);

        eval($proxyContent);
    }

    /**
     * @return string
     */
    private function getProxyHeader()
    {
        $proxyContent = "
        namespace $this->namespace;
        class $this->className extends $this->parentClass implements \\PHPRealCoverage\\Proxy\\Proxy
        {
            private static \$instanceClass = '$this->parentClass';
            private \$instance;
            private \$constructorArguments;

            public function __construct()
            {
                \$this->constructorArguments = func_get_args();
                \$this->__PROXYcreateInstance(\$this->constructorArguments);
            }

            public function __PROXYcreateInstance(\$constructorArguments)
            {
                \$reflectionClass = new \\ReflectionClass(self::\$instanceClass);
                \$this->instance = \$reflectionClass->newInstanceArgs(\$constructorArguments);
            }

            public static function setInstanceClass(\$instanceClass)
            {
                self::\$instanceClass = \$instanceClass;
            }

            public function __PROXYcheckInstance()
            {
                if (get_class(\$this->instance) !== self::\$instanceClass) {
                    \$this->__PROXYcreateInstance(\$this->constructorArguments);
                }
            }
        ";
        return $proxyContent;
    }

    /**
     * @param string $proxyContent
     * @return string
     */
    private function getProxyFooter($proxyContent)
    {
        $proxyContent .= "}";
        return $proxyContent;
    }

    /**
     * @param string $method
     * @internal param $proxyContent
     * @return string
     */
    public function getProxyMethod($method)
    {
        return "
            public function $method()
            {
                \$this->__PROXYcheckInstance();
                \$reflectionMethod = new \\ReflectionMethod(get_class(\$this->instance), \"$method\");
                return \$reflectionMethod->invokeArgs(\$this->instance, func_get_args());
            }
            ";
    }
}