Respect\Rest\Routines\AbstractSyncedRoutine

Complexity

Total Complexity

9

Size/Duplication

Total Lines	61
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	getParameters()	0	9	3
A	execute()	0	12	2
A	getReflection()	0	13	4

<?php
/*
 * This file is part of the Respect\Rest package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Respect\Rest\Routines;

use ReflectionFunction;
use ReflectionMethod;
use ReflectionObject;
use ReflectionClass;
use Closure;
use Respect\Rest\Request;

/** Base class for routines that sync parameters */
abstract class AbstractSyncedRoutine extends AbstractRoutine implements ParamSynced
{
    /**
     * @var Reflector
     */
    protected $reflection;

    /**
     * Return parameters that can be used with the routine.
     *
     * @return array
     */
    public function getParameters()
    {
        $reflection = $this->getReflection();
        if (!$reflection instanceof ReflectionObject && !$reflection instanceof ReflectionClass) {
            return $this->getReflection()->getParameters();

The method getParameters does only exist in ReflectionFunction and ReflectionMethod, but not in ReflectionClass.

        }

        return array();
    }

    /**
     * Executes the routine and return its result.
     *
     * @param  Respect\Rest\Request $request
     * @param  array                $params
     * @return mixed
     */
    public function execute(Request $request, $params)

The parameter $request is not used and could be removed.

    {
        $callback = $this->getCallback();
        if (is_string($callback)) {
            $reflection      = $this->getReflection();
            $routineInstance = $reflection->newInstanceArgs($params);

The method newInstanceArgs does only exist in ReflectionClass, but not in ReflectionFunction and ReflectionMethod.

            return $routineInstance();
        }

        return call_user_func_array($callback, $params);
    }

    /**
     * Returns a concrete ReflectionFunctionAbstract for this routine callback.
     *
     * @return Reflector
     */
    protected function getReflection()
    {
        $callback = $this->getCallback();
        if (is_array($callback)) {
            return new ReflectionMethod($callback[0], $callback[1]);
        } elseif ($callback instanceof Closure) {
            return new ReflectionFunction($callback);
        } elseif (is_string($callback)) {
            return new ReflectionClass($callback);
        } else {
            return new ReflectionObject($callback);
        }
    }
}