Saxulum\Accessor\AccessorTrait

Complexity

Total Complexity

22

Size/Duplication

Total Lines	171
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__call()	0	4	1
A	__get()	0	4	1
A	__set()	0	4	1
C	__handleCall()	0	30	7
A	__handleGet()	0	6	1
A	__handleSet()	0	6	1
A	_prop()	0	16	3
A	_generatePhpDoc()	0	14	3
A	__getNamespace()	0	10	4
	_initProps()	0	1	?

<?php

namespace Saxulum\Accessor;

use Saxulum\Accessor\Accessors\Get;
use Saxulum\Accessor\Accessors\Set;

trait AccessorTrait
{
    /**
     * @var bool
     */
    private $__initProps = false;

    /**
     * @var Prop[]
     */
    private $__props = array();

    /**
     * @var string
     */
    private $__namespace;

    /**
     * can't be final, cause doctrine proxy
     *
     * @param  string     $name
     * @param  array      $arguments
     * @return mixed
     * @throws \Exception
     */
    public function __call($name, array $arguments = array())
    {
        return $this->__handleCall($name, $arguments);
    }

    /**
     * needed by symfony/property-access
     * can't be final, cause doctrine proxy
     *
     * @param  string $name
     * @return mixed
     */
    public function __get($name)
    {
        return $this->__handleGet($name);
    }

    /**
     * needed by symfony/property-access
     * can't be final, cause doctrine proxy
     *
     * @param  string $name
     * @param  mixed  $value
     * @return mixed
     */
    public function __set($name, $value)
    {
        return $this->__handleSet($name, $value);
    }

    /**
     * @param  string     $name
     * @param  array      $arguments
     * @return mixed
     * @throws \Exception
     */
    private function __handleCall($name, array $arguments)
    {
        if (false === $this->__initProps) {
            $this->__initProps = true;
            $this->_initProps();
        }

        // needed by twig, cause it tries to call a method with the property name
        if (property_exists($this, $name)) {
            $method = Get::PREFIX . ucfirst($name);

            return $this->$method();
        }

        foreach (AccessorRegistry::getAccessors() as $prefix => $accessor) {
            if (strpos($name, $prefix) === 0) {
                $property = lcfirst(substr($name, strlen($prefix)));
                if (isset($this->__props[$property])) {
                    $prop = $this->__props[$property];
                    if ($prop->hasMethod($prefix)) {
                        return $accessor->callback(
                            new CallbackBag($prop, $this, $this->$property, $arguments)
                        );
                    }
                }
            }
        }

        throw new \Exception('Call to undefined method ' . __CLASS__ . '::' . $name . '()');
    }

    /**
     * @param  string $name
     * @return mixed
     */
    private function __handleGet($name)
    {
        $method = Get::PREFIX . ucfirst($name);

        return $this->$method();
    }

    /**
     * @param  string $name
     * @param  mixed  $value
     * @return mixed
     */
    private function __handleSet($name, $value)
    {
        $method = Set::PREFIX . ucfirst($name);

        return $this->$method($value);
    }

    /**
     * @param  Prop       $property
     * @return static
     * @throws \Exception
     */
    final protected function _prop(Prop $property)
    {
        $name = $property->getName();

        if (!property_exists($this, $name)) {
            throw new \InvalidArgumentException("Property does not exists");
        }

        if (isset($this->__props[$name])) {
            throw new \Exception("Override Property is not allowed, to enhance stability!");
        }

        $this->__props[$name] = $property;

        return $this;
    }

    /**
     * @return string
     */
    final public function _generatePhpDoc()
    {
        if (false === $this->__initProps) {
            $this->__initProps = true;
            $this->_initProps();
        }

        $phpDoc = '';
        foreach ($this->__props as $prop) {
            $phpDoc .= $prop->generatePhpDoc($this->__getNamespace());
        }

        return $phpDoc;
    }

    /**
     * @return string
     */
    private function __getNamespace()
    {
        if (null === $this->__namespace) {
            $namespace = __CLASS__;
            $pos = strrpos($namespace, '\\');
            $this->__namespace = (false === $pos || 0 === $pos) ? '' : substr($namespace, 0, $pos);
        }

        return $this->__namespace;
    }

    abstract protected function _initProps();
}