Comodojo\Dispatcher\Router\Collector

Complexity

Total Complexity

39

Size/Duplication

Total Lines	298
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	11

Importance

Changes	14
Bugs	5	Features	2

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	18	1
A	getType()	0	5	1
A	getService()	0	5	1
A	getParameters()	0	5	1
A	getClassName()	0	5	1
A	getInstance()	0	19	2
A	add()	0	15	2
A	get()	0	5	1
A	remove()	0	5	1
A	bypass()	0	7	1
B	route()	0	23	5
B	compose()	0	49	5
A	loadRoutes()	0	15	3
A	loadFromCache()	0	11	2
A	dumpCache()	0	9	1
B	parse()	0	35	5
B	evalUri()	0	29	6

<?php namespace Comodojo\Dispatcher\Router;

use \Comodojo\Dispatcher\Components\Model as DispatcherClassModel;
use \Comodojo\Dispatcher\Router\RoutingTable;
use \Comodojo\Dispatcher\Components\Timestamp as TimestampTrait;
use \Comodojo\Dispatcher\Request\Model as Request;
use \Comodojo\Dispatcher\Response\Model as Response;
use \Comodojo\Dispatcher\Extra\Model as Extra;
use \Comodojo\Dispatcher\Components\Configuration;
use \Comodojo\Cache\CacheManager;
use \Monolog\Logger;
use \Comodojo\Exception\DispatcherException;
use \Exception;

/**
 * @package     Comodojo Dispatcher
 * @author      Marco Giovinazzi <marco.giovinazzi@comodojo.org>
 * @author      Marco Castiello <marco.castiello@gmail.com>
 * @license     GPL-3.0+
 *
 * LICENSE:
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

class Collector extends DispatcherClassModel {

    use TimestampTrait;

    private $bypass = false;

    private $classname = "";

    private $type = "";

    private $service = "";

    private $cache;

    private $request;

    private $response;

    private $table;

    public function __construct(
        Configuration $configuration,
        Logger $logger,
        CacheManager $cache,
        Extra $extra = null
    ) {

        parent::__construct($configuration, $logger);

        $this->table = new RoutingTable($logger);

        $this->cache = $cache;

        $this->extra = $extra;

The property extra does not exist. Did you maybe forget to declare it?

        $this->setTimestamp();

    }

    public function getType() {

        return $this->type;

    }

    public function getService() {

        return $this->service;

    }

    public function getParameters() {

        return $this->parameters;

The property parameters does not exist. Did you maybe forget to declare it?

    }

    public function getClassName() {

        return $this->classname;

    }

    public function getInstance() {

        $class = $this->classname;

        if (class_exists($class)) {

            return new $class(
                $this->configuration,
                $this->logger,
                $this->request,
                $this,
                $this->response,
                $this->extra
            );

        }
        else return null;

    }

    public function add($route, $type, $class, $parameters = array()) {

        $routeData = $this->get($route);

        if (is_null($routeData)) {

            $this->table->put($route, $type, $class, $parameters);

        } else {

            $this->table->set($route, $type, $class, $parameters);

        }

    }

    public function get($route) {

        return $this->table->get($route);

    }

    public function remove($route) {

        return $this->table->remove($route);

    }

    public function bypass($mode = true) {

        $this->bypass = filter_var($mode, FILTER_VALIDATE_BOOLEAN);

        return $this;

    }

    public function route(Request $request) {

        $method = $request->method()->get();

        $methods = $this->configuration->get('allowed-http-methods');

        if ( ( $methods != null || !empty($methods) ) && in_array($method, $methods) === false ) {

            throw new DispatcherException("Method not allowed", 0, null, 405, array(

The call to DispatcherException::__construct() has too many arguments starting with array('Allow' => implode(',', $methods)).

                "Allow" => implode(",",$methods)
            ));

        }

        $this->request = $request;

        if (!$this->parse()) {

            throw new DispatcherException("Unable to find a valid route for the specified uri", 0, null, 404);

        }

    }

    public function compose(Response $response) {

        $this->response = $response;

        $service = $this->getInstance();

        if (!is_null($service)) {

            $result;

The variable $result seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

            $method = $this->request->method()->get();

            $methods = $service->getImplementedMethods();

            if ( in_array($method, $methods) ) {

                $callable = $service->getMethod($method);

                try {

                    $result = call_user_func(array($service, $callable));

                } catch (DispatcherException $de) {

                    throw new DispatcherException(sprintf("Service '%s' exception for method '%s': %s", $this->service, $method, $de->getMessage()), 0, $de, 500);

                } catch (Exception $e) {

                    throw new DispatcherException(sprintf("Service '%s' execution failed for method '%s': %s", $this->service, $method, $e->getMessage()), 0, $e, 500);

                }

            } else {

                throw new DispatcherException(sprintf("Service '%s' doesn't implement method '%s'", $this->service, $method), 0, null, 501, array(

The call to DispatcherException::__construct() has too many arguments starting with array('Allow' => implode(',', $methods)).

                    "Allow" => implode(",", $methods)
                ));

            }

            $this->response->content()->set($result);

        } else {

            throw new DispatcherException(sprintf("Unable to execute service '%s'", $this->service), 0, null, 500);

        }

    }

    public function loadRoutes($routes) {

        if ( !empty($routes) ) {

            foreach( $routes as $name => $route ) {

                $this->add($route['route'], $route['type'], $route['class'], $route['parameters']);

            }

        }

        return $this->dumpCache();

    }
    
    public function loadFromCache() {
        
        $routes = $this->cache->get("dispatcher_routes");
        
        if (is_null($routes)) return null;
        
        $this->table->routes($routes);
        
        return $this;
        
    }
    
    private function dumpCache() {
        
        $routes = $this->table->routes();
        
        $this->cache->set("dispatcher_routes", $routes, 24 * 60 * 60);
        
        return $this;
        
    }

    private function parse() {

        $path = $this->request->route();
        
        foreach ($this->table->routes() as $regex => $value) {

The expression $this->table->routes() of type array|object<Comodojo\Dispatcher\Router\RoutingTable> is not guaranteed to be traversable. How about adding an additional type check?

            
            // The current uri is checked against all the global regular expressions associated with the routes
            if (preg_match("/" . $regex . "/", $path, $matches)) {

                /* If a route is matched, all the bits of the route string are evalued in order to create
                 * new query parameters which will be available for the service class
                 */
                $this->evalUri($value['query'], $matches);

                // All the route parameters are also added to the query parameters
                foreach ($value['parameters'] as $parameter => $value) {

                    $this->request->query()->set($parameter, $value);

                }

                $this->classname  = $value['class'];
                $this->type       = $value['type'];
                $this->service    = implode('.', $value['service']);
                $this->service    = empty($this->service)?"default":$this->service;

                return true;

            }

        }

        return false;

    }

    private function evalUri($parameters, $bits) {

        $count  = 0;

$count is not used, you could remove the assignment.

        // Because of the nature of the global regular expression, all the bits of the matched route are associated with a parameter key
        foreach ($parameters as $key => $value) {

            if (isset($bits[$key])) {
                /* if it's available a bit associated with the parameter name, it is compared against
                 * it's regular expression in order to extrect backreferences
                 */
                if (preg_match('/^' . $value['regex'] . '$/', $bits[$key], $matches)) {
                    
                    if (count($matches) == 1) $matches = $matches[0]; // This is the case where no backreferences are present or available.
                    
                    // The extracted value (with any backreference available) is added to the query parameters.
                    $this->request->query()->set($key, $matches);

                }

            } elseif ($value['required']) {

                throw new DispatcherException(sprintf("Required parameter '%s' not specified.", $key), 1, null, 500);

            }

        }

    }

}