Dispatcher::callFromRequest() - Code Metrics - Inspection of "fix displatcher forward" - bytic/dispatcher - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( eedef1...85765a )

by Gabriel
created 2020-05-17 17:33 UTC
Dispatcher::callFromRequest() A

↳ Parent: Dispatcher
Complexity

Conditions	1
Paths	1
Size

Total Lines	7
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes
Metric	Value
cc	1
eloc	5
c	0
b	0
f	0
nc	1
nop	2
dl	0
loc	7
ccs	0
cts	6
cp	0
crap	2
rs	10
<?php

namespace Nip\Dispatcher;

use Exception;
use Nip\Container\Container;
use Nip\Container\ContainerAwareTrait;
use Nip\Dispatcher\Commands\Command;
use Nip\Dispatcher\Commands\CommandFactory;
use Nip\Dispatcher\Exceptions\ForwardException;
use Nip\Dispatcher\Resolver\HasResolverPipelineTrait;
use Nip\Dispatcher\Resolver\Pipeline\InstanceBuilder;
use Nip\Dispatcher\Traits\HasCommandsCollection;
use Nip\Dispatcher\Traits\HasRequestTrait;
use Nip\Request;
use Psr\Http\Message\ResponseInterface;

/**
 * Class Dispatcher.
 */
class Dispatcher
{
    use ContainerAwareTrait;
    use HasResolverPipelineTrait;
    use HasRequestTrait;
    use HasCommandsCollection;

    /**
     * Create a new controller dispatcher instance.
     *
     * @param  Container $container
     *
     *
     * @return void
     */
    public function __construct(Container $container = null)
    {
        if ($container instanceof Container) {
            $this->setContainer($container);
        }
    }

    /**
     * @param Request|null $request
     * @return ResponseInterface
     * @throws Exception
     *
     * @return null|Response
     */
    public function dispatch(Request $request = null)
    {
        if ($request) {
            $this->setRequest($request);
        }

        $command = CommandFactory::createFromRequest($request);
        $command = CommandFactory::createFromRequest(/** @scrutinizer ignore-type */ $request);
        return $this->dispatchCommand($command)->getReturn();
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
    }


    /**
     * @param $action
     * @param array $params
     * @return mixed
     * @throws Exception
     */
    public function call($action, $params = [])
    {
        $action = is_array($action) ? $action : ['controller' => $action];
        $command = CommandFactory::createFromAction($action);
        if (isset($params['_request'])) {
            $command->setRequest($params['_request']);
            unset($params['_request']);
        }
        $command->setActionParam('params', $params);
        return $this->getResolverPipeline(InstanceBuilder::class)
            ->process($command)
            ->getReturn();
    }

    /**
     * @param Request|null $request
     * @param array $params
     * @return
     * @throws Exception
     */
    public function callFromRequest(Request $request = null, $params = [])
    {
        $command = CommandFactory::createFromRequest($request);
        $command = CommandFactory::createFromRequest(/** @scrutinizer ignore-type */ $request);
        $command->setActionParam('params', $params);
        return $this->getResolverPipeline(InstanceBuilder::class)
            ->process($command)
            ->getReturn();
    }

    /**
     * @param Command $command
     * @return Command
     */
    public function dispatchCommand(Command $command)
    {
        $this->getCommandsCollection()[] = $command;


        try {
            return $this->processCommand($command);
        } catch (ForwardException $exception) {
            $command = CommandFactory::createFromForwardException($exception);
            $command->setRequest($this->getRequest());
            return $this->dispatchCommand($command);
        }
    }

    /**
     * @param bool $params
     * @throws ForwardException
     */
    public function throwError($params = false)
    public function throwError(/** @scrutinizer ignore-unused */ $params = false)
    {
//        $this->getFrontController()->getTrace()->add($params);
        $this->setErrorController();
        $this->forward('index');
        $this->forward(/** @scrutinizer ignore-type */ 'index');
    }

    /**
     * @return $this
     */
    public function setErrorController()
    {
        $this->getRequest()->setActionName('index');
        $this->getRequest()->setControllerName('error');
        $this->getRequest()->setModuleName('default');

        return $this;
    }

    /**
     * @param bool  $action
     * @param bool  $controller
     * @param bool  $module
     * @param array $params
     *
     * @throws ForwardException
     */
    public function forward($action = false, $controller = false, $module = false, $params = [])
    {
        $this->getRequest()->setActionName($action);

        if ($controller) {
            $this->getRequest()->setControllerName($controller);
            $this->getRequest()->setControllerName(/** @scrutinizer ignore-type */ $controller);
        }
        if ($module) {
            $this->getRequest()->setModuleName($module);
            $this->getRequest()->setModuleName(/** @scrutinizer ignore-type */ $module);
        }

        if (is_array($params)) {

            $this->getRequest()->attributes->add($params);
        }

        throw new ForwardException();
    }

    /**
     * @param $module
     * @param $controller
     *
     * @return string
     */
    protected function generateFullControllerNameNamespace($module, $controller)
    {
        $name = app()->get('kernel')->getRootNamespace().'Modules\\';
        $name = /** @scrutinizer ignore-call */ app()->get('kernel')->getRootNamespace().'Modules\\';
        $module = $module == 'Default' ? 'Frontend' : $module;
        $name .= $module.'\Controllers\\';
        $name .= str_replace('_', '\\', $controller).'Controller';

        return $name;
    }

    /**
     * @param string $namespaceClass
     *
     * @return bool
     */
    protected function isValidControllerNamespace($namespaceClass)
    {
        return class_exists($namespaceClass);
    }

    /**
     * @return \Nip\AutoLoader\AutoLoader
filter:
    dependency_paths: ["lib/*"]
     */
    protected function getAutoloader()
    {
        return app('autoloader');
        return /** @scrutinizer ignore-call */ app('autoloader');
    }

    /**
     * @param $module
     * @param $controller
     *
     * @return string
     */
    protected function generateFullControllerNameString($module, $controller)
    {
        return $module.'_'.$controller.'Controller';
    }
}

bytic / dispatcher

Push — master ( eedef1...85765a )

Dispatcher::callFromRequest() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
