Ds\Router\Handler\ClassHandler

Complexity

Total Complexity

12

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	add()	0	3	1
A	__construct()	0	6	1
A	resolve()	0	17	4
A	getResponse()	0	11	2
A	resolveController()	0	7	2
A	resolveMethod()	0	6	2

<?php

namespace Ds\Router\Handler;

use Ds\Router\Interfaces\RouteHandlerInterface;
use Psr\Http\Message\ResponseInterface;


class ClassHandler extends Handler implements RouteHandlerInterface
{

    /**
     * @var string
     */
    protected $controller;

    /**
     * @var string
     */
    protected $method;

    /**
     * @param string $controller
     * @param string $method
     * @return ClassHandler
     */
    public static function add($controller, $method){
        return new ClassHandler($controller, $method);
    }

    /**
     *
     * Class Handler Construct.
     * Controller Name and Method name provided as FQN.
     *
     * @param string $controller
     * @param string $method
     *
     * @throws \Exception
     */
    public function __construct($controller = '', $method = '')
    {
        $this->controller = $controller;
        $this->method = $method;
        $this->preResponse = "{$controller}::{$method}";
    }

    /**
     * Resolve Controller and inject Arguments into construct. Normally this this the View.
     * @param array ...$arguments
     * @return $this
     * @throws \Exception
     */
    public function resolve(...$arguments){


        $controllerMethod = explode('::',$this->getPreResponse());

        $this->controller = isset($controllerMethod[0]) ? $controllerMethod[0] : $this->controller;
        $this->method = isset($controllerMethod[1]) ? $controllerMethod[1] : $this->method;

        try{
            $this->resolveController( $this->controller);
            $this->resolveMethod( $this->method );
            $this->resolved = new $this->controller(...$arguments);
        }catch(\Exception $e){
            throw new \Exception($e->getMessage());
        }
        return $this;
    }


    /**
     * Returns Response Object from Handler.
     * @param array $vars
     *
     * @return ResponseInterface
     * @throws \Exception
     */
    public function getResponse($vars = [] ){

        if ($this->resolved === null){
            throw new \Exception("Handler must be resolved before calling getContents().");
        }

        $controller = $this->resolved;
        $method = $this->method;

        return $controller->$method($vars);
    }

    /**
     * Check that controller exists.
     * @param $controller
     *
     * @return bool
     * @throws \Exception controller:{controller} not found
     */
    private function resolveController($controller){

        if ( !class_exists($controller)){
            throw new \Exception("Controller {$controller} not found");
        }
        return true;
    }

    /**
     * Check that the method exists.
     * @param $method
     *
     * @return bool
     * @throws \Exception
     */
    private function resolveMethod($method){
        if (method_exists($this->controller,$method)){
            return true;
        }
        throw new \Exception("method: {$this->controller}::{$method} not found");
    }
}