Apix\Entity\EntityClass

Complexity

Total Complexity

14

Size/Duplication

Total Lines	136
Duplicated Lines	7.35 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

0%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	reflectedClass()	0	14	3
A	append()	0	8	2
B	underlineCall()	0	25	1
A	parseDocs()	10	23	3
A	getMethod()	0	12	2
A	setActions()	0	10	2
A	getMethods()	0	6	1

<?php

/**
 *
 * This file is part of the Apix Project.
 *
 * (c) Franck Cassedanne <franck at ouarz.net>
 *
 * @license     http://opensource.org/licenses/BSD-3-Clause  New BSD License
 *
 */

namespace Apix\Entity;

use Apix\Entity,
    Apix\Entity\EntityInterface,
    Apix\Reflection,
    Apix\Router;

/**
 * Represents a class based entity resource.
 */
class EntityClass extends Entity implements EntityInterface
{
    protected $controller;

    private $reflection;

    /**
     * Sets and returns a reflection of the entity class.
     *
     * @return \ReflectionClass|false
     */
    public function reflectedClass()
    {
        if (null === $this->reflection) {
            try {
                $this->reflection = new \ReflectionClass(
                    $this->controller['name']
                );
            } catch (\Exception $Exception) {
                throw new \RuntimeException('Resource entity class not (yet) implemented.', 501);
            }
        }

        return $this->reflection;
    }

    /**
     * {@inheritdoc}
     */
    public function append(array $def)
    {
        parent::_append($def);

It seems like you call parent on a different method (_append() instead of append()). Are you sure this is correct? If so, you might want to change this to $this->_append().

        if (isset($def['controller'])) {
            $this->controller = $def['controller'];
        }
    }

    /**
     * {@inheritdoc}
     */
    public function underlineCall(Router $route)
    {
        $name = $this->controller['name'];
        $args = $this->controller['args'];

        // if (!isset($entity->controller['name'])) {

77% of this comment could be valid code. Did you maybe forget this after debugging?

        //     $entity->controller['name'] = $route->controller_name;

58% of this comment could be valid code. Did you maybe forget this after debugging?

        // }

        // just created a deependency here!!!!!
        // if (!isset($args)) {

75% of this comment could be valid code. Did you maybe forget this after debugging?

        //     $args = $route->controller_args;

45% of this comment could be valid code. Did you maybe forget this after debugging?

        // }

        $method = $this->getMethod($route);

        $params = $this->getValidatedParams($method, $route->getMethod(), $route->getParams());

        return call_user_func_array(
          array(
            new $name($args),
            $route->getAction()),
            $params
          );
    }

    /**
     * {@inheritdoc}
     */
    public function parseDocs()
    {
        // group class doc
        $docs = Reflection::parsePhpDoc(
            $this->reflectedClass()->getDocComment()
        );

        $actions = $this->getActions();

        // doc for all methods
        foreach ($this->getMethods() as $key => $method) {

This code seems to be duplicated across your project.

            if ( $key = array_search($method->name, $actions) ) {

               $_docs = Reflection::parsePhpDoc( $method );
                $_docs['method'] = $key;

                // temp
                $docs['methods'][$key] = $_docs;
            }
        }

        return $docs;
    }

    /**
     * {@inheritdoc}
     */
    public function getMethod(Router $route)
    {
        $name = $route->getAction();
        if (false === $this->reflectedClass()->hasMethod($name)) {
            throw new \InvalidArgumentException(
                "Invalid resource's method ({$route->getMethod()}) specified.",
                405
            );
        }

        return $this->reflectedClass()->getMethod($name);
    }

    /**
     * {@inheritdoc}
     */
    public function setActions(array $asso = null)
    {
        $funcs = array();
        foreach ($this->getMethods() as $ref) {
            $funcs[] = $ref->name;
        }
        $routes = Router::$actions;

        $this->actions = array_intersect($routes, $funcs);
    }

    /**
     * Returns the class methods. Use internalaly.
     * @return array An array of \ReflectionMethod objects.
     */
    public function getMethods()
    {
        return $this->reflectedClass()->getMethods(
            \ReflectionMethod::IS_STATIC | \ReflectionMethod::IS_PUBLIC
        );
    }

}