Router::extractReflectionCacheability() - Code Metrics - Inspection of "More improvements in file generation" - psfs/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 70f98a...9ce8e2 )

by Fran
created 2016-11-07 20:39 UTC
Router::extractReflectionCacheability() A

↳ Parent: Router
Complexity

Conditions	2
Paths	2
Size

Total Lines	6
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	3
CRAP Score	2
Importance

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

namespace PSFS\base;

use PSFS\base\config\Config;
use PSFS\base\exception\AccessDeniedException;
use PSFS\base\exception\ConfigException;
use PSFS\base\exception\RouterException;
use PSFS\base\types\SingletonTrait;
use PSFS\controller\base\Admin;
use PSFS\services\AdminServices;
use Symfony\Component\Finder\Finder;


/**
 * Class Router
 * @package PSFS
 */
class Router
{

    use SingletonTrait;

    protected $routing;
    protected $slugs;
    private $domains;
    /**
     * @var Finder $finder
     */
    private $finder;
    /**
     * @var \PSFS\base\Cache $cache
     */
    private $cache;
    /**
     * @var bool headersSent
     */
    protected $headersSent = false;

    /**
     * Constructor Router
     * @throws ConfigException
     */
    public function __construct()
    {
        $this->finder = new Finder();
        $this->cache = Cache::getInstance();
        $this->init();
    }

    /**
     * Inicializador Router
     * @throws ConfigException
     */
    public function init()
    {
        if (!file_exists(CONFIG_DIR . DIRECTORY_SEPARATOR . "urls.json") || Config::getInstance()->getDebugMode()) {
            $this->hydrateRouting();
            $this->simpatize();
        } else {
            list($this->routing, $this->slugs) = $this->cache->getDataFromFile(CONFIG_DIR . DIRECTORY_SEPARATOR . "urls.json", Cache::JSON, TRUE);

            $this->domains = $this->cache->getDataFromFile(CONFIG_DIR . DIRECTORY_SEPARATOR . "domains.json", Cache::JSON, TRUE);

        }
    }

    /**
     * Método que deriva un error HTTP de página no encontrada
     *
     * @param \Exception $e
     *
     * @return string HTML
     */
    public function httpNotFound(\Exception $e = NULL)

    {
        Logger::log('Throw not found exception');
        $template = Template::getInstance()->setStatus($e->getCode());
        if (preg_match('/json/i', Request::getInstance()->getServer('CONTENT_TYPE'))) {
            return $template->output(json_encode(array(
                "success" => FALSE,
                "error" => $e->getMessage(),
            )), 'application/json');
        } else {
            if (NULL === $e) {
                Logger::log('Not found page throwed without previus exception');
                $e = new \Exception(_('Page not found'), 404);
            }

            return $template->render('error.html.twig', array(
                'exception' => $e,
                'trace' => $e->getTraceAsString(),
                'error_page' => TRUE,
            ));
        }
    }

    /**
     * Método que devuelve las rutas
     * @return string|null
     */
    public function getSlugs()
    {
        return $this->slugs;
    }

    /**
     * Method that extract all routes in the platform
     * @return array
     */
    public function getAllRoutes() {
        $routes = [];
        foreach($this->routing as $path => $route) {
            if(array_key_exists('slug', $route)) {
                $routes[$route['slug']] = $path;
            }
        }
        return $routes;
    }

    /**
     * Método que calcula el objeto a enrutar
     *
     * @param string|null $route
     *
     * @throws \Exception
     * @return string HTML

     */
    public function execute($route)
    {
        Logger::log('Executing the request');
        try {
            //Check CORS for requests
            $this->checkCORS();
            // Checks restricted access
            $this->checkRestrictedAccess($route);
            //Search action and execute
            $this->searchAction($route);
        } catch (AccessDeniedException $e) {
            Logger::log(_('Solicitamos credenciales de acceso a zona restringida'));
            if ('login' === Config::getInstance()->get('admin_login')) {
                return $this->redirectLogin($route);
            } else {
                return $this->sentAuthHeader();
            }
        } catch (RouterException $r) {
            if (FALSE !== preg_match('/\/$/', $route)) {
                if (preg_match('/admin/', $route)) {
                    $default = Config::getInstance()->get('admin_action');
                } else {
                    $default = Config::getInstance()->get('home_action');
                }

                return $this->execute($this->getRoute($default));
            }
        } catch (\Exception $e) {
            Logger::log($e->getMessage(), LOG_ERR);
            throw $e;
        }

        return $this->httpNotFound();
    }

    /**
     * Check CROS requests
     */
    private function checkCORS()
    {
        Logger::log('Checking CORS');
        $corsEnabled = Config::getInstance()->get('cors.enabled');
        $request = Request::getInstance();
        if (NULL !== $corsEnabled && null !== $request->getServer('HTTP_REFERER')) {
            if ($corsEnabled == '*' || preg_match($corsEnabled, $request->getServer('HTTP_REFERER'))) {
                if (!$this->headersSent) {
                    // TODO include this headers in Template class output method
                    header("Access-Control-Allow-Credentials: true");
                    header("Access-Control-Allow-Origin: *");
                    header("Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS");
                    header("Access-Control-Allow-Headers: Access-Control-Allow-Methods, Access-Control-Allow-Headers, Access-Control-Allow-Origin, Origin, X-Requested-With, Content-Type, Accept, Authorization, X-API-SEC-TOKEN, X-API-USER-TOKEN");

                    $this->headersSent = true;
                }
                if (Request::getInstance()->getMethod() == 'OPTIONS') {
                    Logger::log('Returning OPTIONS header confirmation for CORS pre flight requests');
                    header("HTTP/1.1 200 OK");
                    exit();
                }
            }
        }
    }

    /**
     * Function that checks if the long of the patterns match
     * @param $routePattern
     * @param $path
     * @return bool
     */
    private function compareSlashes($routePattern, $path)
    {
        $pattern_sep = count(explode('/', $routePattern));
        if (preg_match('/\/$/', $routePattern)) {
            $pattern_sep--;
        }
        $path_sep = count(explode('/', $path));
        if (preg_match('/\/$/', $path)) {
            $path_sep--;
        }
        return abs($pattern_sep - $path_sep) < 1;
    }

    /**
     * Método que busca el componente que ejecuta la ruta
     *
     * @param string $route
     *
     * @throws \PSFS\base\exception\RouterException
     */
    protected function searchAction($route)
    {
        Logger::log('Searching action to execute');
        //Revisamos si tenemos la ruta registrada
        $parts = parse_url($route);
        $path = (array_key_exists('path', $parts)) ? $parts['path'] : $route;
        $httpRequest = Request::getInstance()->getMethod();
        foreach ($this->routing as $pattern => $action) {
            list($httpMethod, $routePattern) = $this->extractHttpRoute($pattern);
            $matched = $this->matchRoutePattern($routePattern, $path);
            if ($matched && ($httpMethod === "ALL" || $httpRequest === $httpMethod) && $this->compareSlashes($routePattern, $path)) {

                $get = $this->extractComponents($route, $routePattern);
                /** @var $class \PSFS\base\types\Controller */
                $class = $this->getClassToCall($action);
                try {
                    $this->executeCachedRoute($route, $action, $class, $get);
                } catch (\Exception $e) {
                    Logger::log($e->getMessage(), LOG_ERR);
                    throw new RouterException($e->getMessage(), 404, $e);
                }
            }
        }
        throw new RouterException(_("Ruta no encontrada"));
    }

    /**
     * Método que manda las cabeceras de autenticación
     * @return string HTML
     */
    protected function sentAuthHeader()
    {
        return AdminServices::getInstance()->setAdminHeaders();
    }

    /**
     * Método que redirige a la pantalla web del login
     *
     * @param string $route
     *
     * @return string HTML
     */
    public function redirectLogin($route)
    {
        return Admin::staticAdminLogon($route);
    }

    /**
     * Método que chequea el acceso a una zona restringida
     *
     * @param string $route
     *
     * @throws AccessDeniedException
     */
    protected function checkRestrictedAccess($route)
    {
        Logger::log('Checking admin zone');
        //Chequeamos si entramos en el admin
        if (!Config::getInstance()->checkTryToSaveConfig()
            && (preg_match('/^\/(admin|setup\-admin)/i', $route) || NULL !== Config::getInstance()->get('restricted'))
        ) {
            if (!Security::getInstance()->checkAdmin()) {
                throw new AccessDeniedException();
            }
            Logger::log('Admin access granted');
        }
    }

    /**
     * Método que extrae de la url los parámetros REST
     *
     * @param string $route
     *
     * @param string $pattern
     *
     * @return array
     */
    protected function extractComponents($route, $pattern)
    {
        Logger::log('Extracting parts for the request to execute');
        $url = parse_url($route);
        $_route = explode("/", $url['path']);
        $_pattern = explode("/", $pattern);
        $get = array();
        if (!empty($_pattern)) foreach ($_pattern as $index => $component) {
            $_get = array();
            preg_match_all('/^\{(.*)\}$/i', $component, $_get);
            if (!empty($_get[1]) && isset($_route[$index])) {
                $get[array_pop($_get[1])] = $_route[$index];
            }
        }

        return $get;
    }

    /**
     * Method that gather all the routes in the project
     */
    private function generateRouting()
    {
        $base = SOURCE_DIR;
        $modules = realpath(CORE_DIR);
        $this->routing = $this->inspectDir($base, "PSFS", array());
        if (file_exists($modules)) {
            $module = "";
            if(file_exists($modules . DIRECTORY_SEPARATOR . 'module.json')) {
                $mod_cfg = json_decode(file_get_contents($modules . DIRECTORY_SEPARATOR . 'module.json'), true);
                $module = $mod_cfg['module'];
            }
            $this->routing = $this->inspectDir($modules, $module, $this->routing);
        }
        $this->cache->storeData(CONFIG_DIR . DIRECTORY_SEPARATOR . "domains.json", $this->domains, Cache::JSON, TRUE);
    }

    /**
     * Método que regenera el fichero de rutas
     * @throws ConfigException
     */
    public function hydrateRouting()
    {
        $this->generateRouting();
        $home = Config::getInstance()->get('home_action');
        if (NULL !== $home || $home !== '') {
            $home_params = NULL;
            foreach ($this->routing as $pattern => $params) {
                list($method, $route) = $this->extractHttpRoute($pattern);
                if (preg_match("/" . preg_quote($route, "/") . "$/i", "/" . $home)) {
                    $home_params = $params;
                }
            }
            if (NULL !== $home_params) {
                $this->routing['/'] = $home_params;
            }
        }
    }

    /**
     * Método que inspecciona los directorios en busca de clases que registren rutas
     *
     * @param string $origen
     * @param string $namespace
     * @param array $routing
     *
     * @return array
     * @throws ConfigException
     */
    private function inspectDir($origen, $namespace = 'PSFS', $routing)
    {
        $files = $this->finder->files()->in($origen)->path('/(controller|api)/i')->name("*.php");
        foreach ($files as $file) {
            $filename = str_replace("/", '\\', str_replace($origen, '', $file->getPathname()));
            $routing = $this->addRouting($namespace . str_replace('.php', '', $filename), $routing);
        }
        $this->finder = new Finder();

        return $routing;
    }

    /**
     * Checks that a namespace exists
     * @param string $namespace
     * @return bool
     */
    public static function exists($namespace) {
        return (class_exists($namespace) || interface_exists($namespace) || trait_exists($namespace));
    }

    /**
     * Método que añade nuevas rutas al array de referencia
     *
     * @param string $namespace
     * @param array $routing
     *
     * @return array
     * @throws ConfigException
     */
    private function addRouting($namespace, &$routing)
    {
        if (self::exists($namespace)) {
            $reflection = new \ReflectionClass($namespace);
            if (FALSE === $reflection->isAbstract() && FALSE === $reflection->isInterface()) {
                $this->extractDomain($reflection);
                $classComments = $reflection->getDocComment();
                preg_match('/@api\ (.*)\n/im', $classComments, $apiPath);
                $api = '';
                if (count($apiPath)) {
                    $api = array_key_exists(1, $apiPath) ? $apiPath[1] : $api;
                }
                foreach ($reflection->getMethods() as $method) {
                    if ($method->isPublic()) {
                        $docComments = $method->getDocComment();
                        preg_match('/@route\ (.*)\n/i', $docComments, $sr);
                        if (count($sr)) {
                            list($regex, $default, $params) = $this->extractReflectionParams($sr, $method);
                            if (strlen($api)) {
                                $regex = str_replace('{__API__}', $api, $regex);
                                $default = str_replace('{__API__}', $api, $default);
                            }
                            $httpMethod = $this->extractReflectionHttpMethod($docComments);
                            $visible = $this->extractReflectionVisibility($docComments);
                            $expiration = $this->extractReflectionCacheability($docComments);
                            $routing[$httpMethod . "#|#" . $regex] = array(
                                "class" => $namespace,
                                "method" => $method->getName(),
                                "params" => $params,
                                "default" => $default,
                                "visible" => $visible,
                                "http" => $httpMethod,
                                "cache" => $expiration,
                            );
                        }
                    }
                }
            }
        }

        return $routing;
    }

    /**
     * Método que extrae de la ReflectionClass los datos necesarios para componer los dominios en los templates
     *
     * @param \ReflectionClass $class
     *
     * @return Router
     * @throws ConfigException
     */
    protected function extractDomain(\ReflectionClass $class)
    {
        //Calculamos los dominios para las plantillas
        if ($class->hasConstant("DOMAIN")) {
            $domain = "@" . $class->getConstant("DOMAIN") . "/";
            $path = dirname($class->getFileName()) . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR;
            $path = realpath($path) . DIRECTORY_SEPARATOR;
            $tpl_path = "templates";
            $public_path = "public";
            $model_path = "models";
            if (!preg_match("/ROOT/", $domain)) {
                $tpl_path = ucfirst($tpl_path);
                $public_path = ucfirst($public_path);
                $model_path = ucfirst($model_path);
            }
            if ($class->hasConstant("TPL")) {
                $tpl_path .= DIRECTORY_SEPARATOR . $class->getConstant("TPL");
            }
            $this->domains[$domain] = array(
                "template" => $path . $tpl_path,
                "model" => $path . $model_path,
                "public" => $path . $public_path,
            );
        }

        return $this;
    }

    /**
     * Método que genera las urls amigables para usar dentro del framework
     * @return Router
     */
    public function simpatize()
    {
        $translationFileName = "translations" . DIRECTORY_SEPARATOR . "routes_translations.php";
        $absoluteTranslationFileName = CACHE_DIR . DIRECTORY_SEPARATOR . $translationFileName;
        $this->generateSlugs($absoluteTranslationFileName);
        Config::createDir(CONFIG_DIR);
        Cache::getInstance()->storeData(CONFIG_DIR . DIRECTORY_SEPARATOR . "urls.json", array($this->routing, $this->slugs), Cache::JSON, TRUE);


        return $this;
    }

    /**
     * Método que devuelve el slug de un string dado
     *
     * @param string $text
     *
     * @return string
     */
    private function slugify($text)
    {
        // replace non letter or digits by -
        $text = preg_replace('~[^\\pL\d]+~u', '-', $text);

        // trim
        $text = trim($text, '-');

        // transliterate
        if (function_exists('iconv')) {
            $text = iconv('utf-8', 'us-ascii//TRANSLIT', $text);
        }

        // lowercase
        $text = strtolower($text);

        // remove unwanted characters
        $text = preg_replace('~[^-\w]+~', '', $text);

        if (empty($text)) {
            return 'n-a';
        }

        return $text;
    }

    /**
     * Método que devuelve una ruta del framework
     *
     * @param string $slug
     * @param boolean $absolute
     * @param array $params
     *
     * @return string|null
     * @throws RouterException
     */
    public function getRoute($slug = '', $absolute = FALSE, $params = [])
    {
        if (strlen($slug) === 0) {
            return ($absolute) ? Request::getInstance()->getRootUrl() . '/' : '/';
        }
        if (NULL === $slug || !array_key_exists($slug, $this->slugs)) {
            throw new RouterException(_("No existe la ruta especificada"));
        }
        $url = ($absolute) ? Request::getInstance()->getRootUrl() . $this->slugs[$slug] : $this->slugs[$slug];
        if (!empty($params)) foreach ($params as $key => $value) {
            $url = str_replace("{" . $key . "}", $value, $url);
        } elseif (!empty($this->routing[$this->slugs[$slug]]["default"])) {
            $url = ($absolute) ? Request::getInstance()->getRootUrl() . $this->routing[$this->slugs[$slug]]["default"] : $this->routing[$this->slugs[$slug]]["default"];

        }

        return preg_replace('/(GET|POST|PUT|DELETE|ALL)\#\|\#/', '', $url);
    }

    /**
     * Método que devuelve las rutas de administración
     * @return array
     */
    public function getAdminRoutes()
    {
        $routes = array();
        foreach ($this->routing as $route => $params) {
            list($httpMethod, $routePattern) = $this->extractHttpRoute($route);
            if (preg_match('/^\/admin(\/|$)/', $routePattern)) {
                if (preg_match('/^\\\?PSFS/', $params["class"])) {
                    $profile = "superadmin";
                } else {
                    $profile = "admin";
                }
                if (!empty($params["default"]) && preg_match('/(GET|ALL)/i', $httpMethod)) {
                    $_profile = ($params["visible"]) ? $profile : 'adminhidden';
                    if (!array_key_exists($_profile, $routes)) {
                        $routes[$_profile] = array();
                    }
                    $routes[$_profile][] = $params["slug"];
                }
            }
        }
        if (array_key_exists("superadmin", $routes)) {
            asort($routes["superadmin"]);
        }
        if (array_key_exists("adminhidden", $routes)) {
            asort($routes["adminhidden"]);
        }
        if (array_key_exists('admin', $routes)) {
            asort($routes["admin"]);
        }
        return $routes;
    }

    /**
     * Método que devuelve le controlador del admin
     * @return Admin
     */
    public function getAdmin()
    {
        return Admin::getInstance();
    }

    /**
     * Método que extrae los dominios
     * @return array
     */
    public function getDomains()
    {
        return $this->domains ?: [];
    }

    /**
     * Método que extrae el controller a invocar
     *
     * @param string $action
     *
     * @return Object
     */
    protected function getClassToCall($action)
    {
        Logger::log('Getting class to call for executing the request action', LOG_DEBUG, $action);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $actionClass = class_exists($action["class"]) ? $action["class"] : "\\" . $action["class"];
        $class = (method_exists($actionClass, "getInstance")) ? $actionClass::getInstance() : new $actionClass;
        return $class;
    }

    /**
     * Método que compara la ruta web con la guardada en la cache
     *
     * @param $routePattern
     * @param $path
     *
     * @return bool
     */
    protected function matchRoutePattern($routePattern, $path)
    {
        $expr = preg_replace('/\{([^}]+)\}/', '###', $routePattern);
        $expr = preg_quote($expr, '/');
        $expr = str_replace('###', '(.*)', $expr);
        $expr2 = preg_replace('/\(\.\*\)$/', '', $expr);
        $matched = preg_match('/^' . $expr . '\/?$/i', $path) || preg_match('/^' . $expr2 . '?$/i', $path);
        return $matched;
    }

    /**
     * @param $pattern
     *
     * @return array
     */
    protected function extractHttpRoute($pattern)
    {
        $httpMethod = "ALL";
        $routePattern = $pattern;
        if (FALSE !== strstr($pattern, "#|#")) {
            list($httpMethod, $routePattern) = explode("#|#", $pattern, 2);
        }

        return array(strtoupper($httpMethod), $routePattern);
    }

    /**
     * Método que extrae los parámetros de una función
     *
     * @param array $sr
     * @param \ReflectionMethod $method
     *
     * @return array
     */
    private function extractReflectionParams($sr, $method)

    {
        $regex = $sr[1] ?: $sr[0];
        $default = '';
        $params = array();
        $parameters = $method->getParameters();
        if (count($parameters) > 0) foreach ($parameters as $param) {
            if ($param->isOptional() && !is_array($param->getDefaultValue())) {
                $params[$param->getName()] = $param->getDefaultValue();
                $default = str_replace('{' . $param->getName() . '}', $param->getDefaultValue(), $regex);
            }
        } else $default = $regex;

        return array($regex, $default, $params);
    }

    /**
     * Método que extrae el método http
     *
     * @param string $docComments
     *
     * @return string
     */
    private function extractReflectionHttpMethod($docComments)
    {
        preg_match('/@(GET|POST|PUT|DELETE)\n/i', $docComments, $routeMethod);

        return (count($routeMethod) > 0) ? $routeMethod[1] : "ALL";
    }

    /**
     * Método que extrae la visibilidad de una ruta
     *
     * @param string $docComments
     *
     * @return bool
     */
    private function extractReflectionVisibility($docComments)
    {
        preg_match('/@visible\ (.*)\n/i', $docComments, $visible);
        return !(array_key_exists(1, $visible) && preg_match('/false/i', $visible[1]));
    }

    /**
     * Método que extrae el parámetro de caché
     *
     * @param string $docComments
     *
     * @return bool
     */
    private function extractReflectionCacheability($docComments)
    {
        preg_match('/@cache\ (.*)\n/i', $docComments, $cache);

        return (count($cache) > 0) ? $cache[1] : "0";
    }

    /**
     * Método que ejecuta una acción del framework y revisa si lo tenemos cacheado ya o no
     *
     * @param string $route
     * @param array|null $action
     * @param types\Controller $class
     * @param array $params

     */
    protected function executeCachedRoute($route, $action, $class, $params = NULL)
    {
        Logger::log('Executing route ' . $route);
        Security::getInstance()->setSessionKey("__CACHE__", $action);
        $cache = Cache::needCache();
        $execute = TRUE;
        if (FALSE !== $cache && Config::getInstance()->getDebugMode() === FALSE) {
            $cacheDataName = $this->cache->getRequestCacheHash();
            $cachedData = $this->cache->readFromCache("templates" . DIRECTORY_SEPARATOR . $cacheDataName,
                $cache, function () {});
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            if (NULL !== $cachedData) {
                $headers = $this->cache->readFromCache("templates" . DIRECTORY_SEPARATOR . $cacheDataName . ".headers",
                    $cache, function () {}, Cache::JSON);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                Template::getInstance()->renderCache($cachedData, $headers);
                $execute = FALSE;
            }
        }
        if ($execute) {
            call_user_func_array(array($class, $action['method']), $params);
        }
    }

    /**
     * Parse slugs to create translations
     *
     * @param string $absoluteTranslationFileName
     */
    private function generateSlugs($absoluteTranslationFileName)
    {
        $translations = $this->generateTranslationsFile($absoluteTranslationFileName);
        foreach ($this->routing as $key => &$info) {
            $keyParts = $key;
            if (FALSE === strstr("#|#", $key)) {
                $keyParts = explode("#|#", $key);
                $keyParts = array_key_exists(1, $keyParts) ? $keyParts[1] : '';
            }
            $slug = $this->slugify($keyParts);
            if (NULL !== $slug && !array_key_exists($slug, $translations)) {
                $translations[$slug] = $key;
                file_put_contents($absoluteTranslationFileName, "\$translations[\"{$slug}\"] = _(\"{$slug}\");\n", FILE_APPEND);

            }
            $this->slugs[$slug] = $key;
            $info["slug"] = $slug;
        }
    }

    /**
     * Create translation file if not exists
     *
     * @param string $absoluteTranslationFileName
     *
     * @return array
     */
    private function generateTranslationsFile($absoluteTranslationFileName)
    {
        $translations = array();
        if (file_exists($absoluteTranslationFileName)) {
            include($absoluteTranslationFileName);
        } else {
            Cache::getInstance()->storeData($absoluteTranslationFileName, "<?php \$translations = array();\n", Cache::TEXT, TRUE);

        }

        return $translations;
    }

}

psfs / core

Push — master ( 70f98a...9ce8e2 )

Router::extractReflectionCacheability() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
