Nymfonya\Component\Http\Kernel

Complexity

Total Complexity

12

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

95.24%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setNameSpace()	0	5	1
A	getBundleClassname()	0	4	1
A	run()	0	21	4
A	setAction()	0	4	2
A	send()	0	22	2
A	shutdown()	0	4	1

<?php

namespace Nymfonya\Component\Http;

use Nymfonya\Component\Http\Interfaces\KernelInterface;
use Nymfonya\Component\Http\Response;
use Nymfonya\Component\Http\Headers;

class Kernel implements KernelInterface
{

    const PATH_CONFIG = '/../config/';

    use \Nymfonya\Component\Http\Reuse\TKernel;

     /**
      * instanciate
      *
      * @param string $env
      * @param string $path
      */
    public function __construct(string $env, string $path)
    {
        $this->init($env, $path);
    }

    /**
     * set controller namespace
     *
     * @param string $ctrlNamespace
     * @return KernelInterface
     */
    public function setNameSpace(string $ctrlNamespace): KernelInterface
    {
        $this->spacename = $ctrlNamespace;
        return $this;
    }

    /**
     * retrieve kernel instance classname from container
     *
     * @return string
     */
    public function getBundleClassname():string
    {
        return get_called_class();
    }

    /**
     * run app
     *
     * @param array $groups
     * @return KernelInterface
     */
    public function run(array $groups = []): KernelInterface
    {
        $routerGroups = (empty($groups))
            ? $this->router->compile()
            : $groups;
        if ($routerGroups) {

The expression $routerGroups of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $this->setClassname($routerGroups);
            if (class_exists($this->className)) {
                $this->setController();
                $this->setReflector();
                $this->setActions();
                $this->setAction($routerGroups);
                //->setActionAnnotations();
                $this->setMiddleware();
            } else {
                $this->error = true;
                $this->errorCode = Response::HTTP_SERVICE_UNAVAILABLE;
            }
        }
        return $this;
    }

    /**
     * set controller action from router groups
     *
     * @param array $routerGrps
     * @return void
     */
    public function setAction(array $routerGrps)
    {
        $this->action = isset($routerGrps[1]) ? strtolower($routerGrps[1]) : '';
    }

    /**
     * dispatch response
     *
     * @return KernelInterface
     */
    public function send(): KernelInterface
    {
        if ($this->getError()) {
            $this->res
                ->setCode($this->errorCode)
                ->setContent([
                    Response::_ERROR => $this->error,
                    Response::_ERROR_CODE => $this->errorCode,
                    Response::_ERROR_MSG => $this->errorMsg,
                ])
                ->getHeaderManager()
                ->add(
                    Headers::CONTENT_TYPE,
                    'application/json; charset=utf-8'
                );
            $this->getLogger()->warning($this->errorMsg);
        } else {
            $this->getLogger()->debug('Response sent');
        }
        $this->getResponse()->send();
        return $this;
    }

    /**
     * shutdown kernel
     *
     * @return void

Consider making the return type a bit more specific; maybe use NoType.

     */
    public function shutdown(int $code = 0)
    {
        throw new \Exception('shutdown', $code);
    }
}