TraitRoute::getMethod() - Code Metrics - Inspection of "scrutinizer fixed" - Erykai/routes - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Branch — main (533464)

by Alex
created 2022-09-23 18:56 UTC
TraitRoute::getMethod() A

↳ Parent: TraitRoute
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	1	Features	0
Metric	Value
cc	1
eloc	1
c	1
b	1
f	0
nc	1
nop	0
dl	0
loc	3
rs	10
<?php

namespace Erykai\Routes;

use RuntimeException;

/**
 * Trait Controller Router
 */
trait TraitRoute
{
    /**
     * @param array $array
     * @return object
     */
    private function duplicates(array $array): object
    {
        if ($this->getRequest() !== "") {
            foreach ($array as $key => $item) {
                if ($this->verb[$key] !== $this->getMethod()) {
                    unset(
                        $this->controller[$key],
                        $this->middleware[$key],
                        $this->type[$key],
                        $this->verb[$key],
                        $this->route[$key],
                        $this->patterns[$key]
                    );
                }
            }
        }
        return $this;
    }
    /**
     * @return bool
     */
    private function patterns(): bool
    {
        $patterns = array_unique($this->getPatterns());
        if ($this->getRequest() === "") {
            $patterns = (array)$patterns[0];
        }
        foreach ($patterns as $key => $pattern) {
            if ($this->getMethod() === $this->verb[$key]) {
                @preg_match('#' . $pattern . '#', $this->getRequest(), $router);
                /** @scrutinizer ignore-unhandled */ @preg_match('#' . $pattern . '#', $this->getRequest(), $router);
                if (isset($router[0])) {
                    if ($router[0] === $this->getRequest()) {
                        $this->setClass($key, $router);
                    }
                } else if ($this->getRequest() === "") {
                    $this->setClass($key, $router);
                }
            }

        }
        return true;
    }
    /**
     * @param $key
     * @param $router
     */
    private function setClass($key, $router): void
    {
        $classMethod = explode("@", $this->controller[$key]);
        [$class, $method] = $classMethod;
        array_shift($router);
        if (preg_match_all('~{([^}]*)}~', $this->route[$key], $keys) === false) {
            throw new RuntimeException('The route ' . $this->route[$key] . ' not exist.');
        }
        $data = array_combine($keys[1], $router);
        $this->classMethod($class, $method, $data, $key);
    }
    /**
     * @param $class
     * @param $method
     * @param $data
     * @param $key
     * @return bool|void
     */
    private function classMethod($class, $method, $data, $key)
    {
        $argument = $data;
        unset($data);
        $data['argument'] = $argument;
        $class = $this->namespaceArray[$key] . "\\" . $class;
        if (class_exists($class)) {
            $Class = new $class;
            if (method_exists($Class, $method)) {
                $this->setNotFound(false);
                $data['query'] = $this->getQuery();
                if ($this->middleware[$key]) {
                    $Middleware = new Middleware();
                    if (!$Middleware->validate()) {
                        $this->setResponse(
                               setResponse(
                            401,
                            "error",
                            "this access is mandatory to inform the correct Baren Token"
                        );
                        return false;
                    }
                }
                $Class->$method($data, $this->type[$key]);
                return true;
            }
            $this->setResponse(
                405,
                "error",
                "the {$this->controller[$key]} method does not exist",
                dynamic: $this->controller[$key]
            );
            return false;
        }
    }
    /**
     * @return bool
     */
    protected function controller(): bool
    {
        $this->duplicates($this->getPatterns());
        $this->patterns();
        if (empty($this->getPatterns())) {
            return false;
        }
        return true;
    }
    /**
     * @return array
     */
    protected function getPatterns(): array
    {
        return $this->patterns;
    }
    /**
     * @return object
     */
    protected function getResponse(): object
    {
        return $this->response;
    }
    /**
     * @return string
     */
    protected function getMethod(): string
    {
        return $this->method;
    }
    /**
     * @return string
     */
    protected function getRequest(): string
    {
        return $this->request;
    }
    /**
     * @return array|null
     */
    protected function getQuery(): ?array
    {
        return $this->query;
    }
    /**
     * @return string
     */
    protected function getNamespace(): string
    {
        return $this->namespace;
    }
    /**
     * @return array
     */
    protected function getRoute(): array
    {
        return $this->route;
    }
    /**
     * @param bool $notFound
     */
    protected function setNotFound(bool $notFound): void
    {
        $this->notFound = $notFound;

    }
    /**
     * @return bool
     */
    protected function isNotFound(): bool
    {
        return $this->notFound;
    }
}
Erykai / routes

Branch — main (533464)

TraitRoute::getMethod() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
