Koch\Router\TargetRoute

Complexity

Total Complexity

61

Size/Duplication

Total Lines	404
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

35 Methods

Rating	Name	Duplication	Size	Complexity
A	instantiate()	0	10	2
A	getApplicationNamespace()	0	4	1
A	setFilename()	0	4	1
A	getFilename()	0	12	2
A	setClassname()	0	4	1
A	getClassname()	0	9	2
A	setController()	0	4	1
A	getController()	0	10	2
A	getModule()	0	4	1
A	setModule()	0	4	1
A	setAction()	0	4	1
A	getAction()	0	4	1
A	getActionNameWithoutPrefix()	0	6	1
A	setId()	0	4	1
A	getId()	0	4	1
A	getActionName()	0	4	1
A	setMethod()	0	4	1
A	getMethod()	0	8	1
A	setParameters()	0	4	1
A	getParameters()	0	12	2
A	getFormat()	0	4	1
A	getRequestMethod()	0	4	1
A	getLayoutMode()	0	4	1
A	getAjaxMode()	0	4	1
A	getRenderEngine()	0	4	1
A	setRenderEngine()	0	4	1
A	getBackendTheme()	0	4	2
A	getFrontendTheme()	0	4	2
A	getThemeName()	0	14	4
A	setThemeName()	0	4	1
A	getModRewriteStatus()	0	4	1
A	dispatchable()	0	20	4
A	getRoute()	0	4	1
F	setSegmentsToTargetRoute()	0	75	14
B	reset()	0	25	1

<?php

/**
 * Koch Framework
 * Jens-André Koch © 2005 - onwards.
 *
 * This file is part of "Koch Framework".
 *
 * License: GNU/GPL v2 or any later version, see LICENSE file.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

namespace Koch\Router;

use Koch\Http\HttpRequest;
use Koch\Mvc\Mapper;

/**
 * Router_TargetRoute (processed RequestObject).
 */
class TargetRoute extends Mapper
{
    public static $parameters = [
        // File
        'filename'  => null,
        'classname' => null,
        // Call
        'module'     => 'index',
        'controller' => null,
        'action'     => 'list',
        'method'     => null,
        'params'     => [],
        // Output
        'format'     => 'html',
        'language'   => 'en',
        'request'    => 'get',
        'layout'     => true,
        'ajax'       => false,
        'renderer'   => 'smarty',
        'themename'  => 'default',
        'modrewrite' => false,
    ];

    /**
     * Get singleton instance of TargetRoute.
     *
     * @return \Koch\Router\TargetRoute

Should the return type not be TargetRoute|null?

     */
    public static function instantiate()
    {
        static $instance = null;

        if ($instance === null) {
            $instance = new self();
        }

        return $instance;
    }

    public static function getApplicationNamespace()
    {
        return Mapper::getApplicationNamespace();
    }

    /**
     * @param string $filename
     */
    public static function setFilename($filename)
    {
        self::$parameters['filename'] = $filename;
    }

    public static function getFilename()

The return type could not be reliably inferred; please add a @return annotation.

    {
        if (empty(self::$parameters['filename'])) {
            $filename = self::mapControllerToFilename(
                self::getModulePath(self::getModule()),
                self::getController()
            );
            self::setFilename(realpath($filename));
        }

        return self::$parameters['filename'];
    }

    /**
     * @param string $classname
     */
    public static function setClassname($classname)
    {
        self::$parameters['classname'] = $classname;
    }

    public static function getClassname()

The return type could not be reliably inferred; please add a @return annotation.

    {
        if (empty(self::$parameters['classname'])) {
            $classname = self::mapControllerToClassname(self::getModule(), self::getController());
            self::setClassname($classname);
        }

        return self::$parameters['classname'];
    }

    public static function setController($controller)
    {
        self::$parameters['controller'] = ucfirst($controller);
    }

    /**
     * Returns Name of the Controller.
     *
     * @return string Controller/Modulename
     */
    public static function getController()
    {
        // the default "controller" name is the "module" name
        // this is the case if a route "/:module", e.g. "/users" is used
        if (empty(self::$parameters['controller'])) {
            self::$parameters['controller'] = self::$parameters['module'];
        }

        return ucfirst(self::$parameters['controller']);
    }

    public static function getModule()
    {
        return ucfirst(self::$parameters['module']);
    }

    public static function setModule($module)
    {
        self::$parameters['module'] = $module;
    }

    public static function setAction($action)
    {
        self::$parameters['action'] = $action;
    }

    public static function getAction()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return self::$parameters['action'];
    }

    public static function getActionNameWithoutPrefix()

The return type could not be reliably inferred; please add a @return annotation.

    {
        $action = str_replace('action', '', self::$parameters['action']);

        return $action;
    }

    public static function setId($id)
    {
        self::$parameters['params']['id'] = $id;
    }

    public static function getId()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return self::$parameters['params']['id'];
    }

    /**
     * Method to get the Action with Prefix.
     *
     * @return $string

The doc-type $string could not be parsed: Unknown type name "$string" at position 0. (view supported doc-types)

     */
    public static function getActionName()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return self::$parameters['method'];
    }

    /**
     * @param string $method
     */
    public static function setMethod($method)
    {
        self::$parameters['method'] = $method;
    }

    public static function getMethod()

The return type could not be reliably inferred; please add a @return annotation.

    {
        // add method prefix (action_)
        $method = self::mapActionToMethodname(self::getAction());
        self::setMethod($method);

        return self::$parameters['method'];
    }

    public static function setParameters($params)
    {
        self::$parameters['params'] = $params;
    }

    public static function getParameters()

The return type could not be reliably inferred; please add a @return annotation.

    {
        // transfer parameters from HttpRequest Object to TargetRoute
        if (HttpRequest::getRequestMethod() === 'POST') {
            $request = new HttpRequest();
            $params  = $request->getPost();

            self::setParameters($params);
        }

        return self::$parameters['params'];
    }

    public static function getFormat()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return self::$parameters['format'];
    }

    public static function getRequestMethod()
    {
        return HttpRequest::getRequestMethod();
    }

    public static function getLayoutMode()

function getLayoutMode() does not seem to conform to the naming convention (^(?:is|has|should|may|supports)).

    {
        return (bool) self::$parameters['layout'];
    }

    public static function getAjaxMode()

function getAjaxMode() does not seem to conform to the naming convention (^(?:is|has|should|may|supports)).

    {
        return HttpRequest::isAjax();
    }

    public static function getRenderEngine()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return self::$parameters['renderer'];
    }

    /**
     * @param string $renderEngineName
     */
    public static function setRenderEngine($renderEngineName)
    {
        self::$parameters['renderer'] = $renderEngineName;
    }

    public static function getBackendTheme()

The return type could not be reliably inferred; please add a @return annotation.

getBackendTheme uses the super-global variable $_SESSION which is generally not recommended.

    {
        return (isset($_SESSION['user']['backend_theme'])) ? $_SESSION['user']['backend_theme'] : 'default';
    }

    public static function getFrontendTheme()

The return type could not be reliably inferred; please add a @return annotation.

getFrontendTheme uses the super-global variable $_SESSION which is generally not recommended.

    {
        return (isset($_SESSION['user']['frontend_theme']))  ? $_SESSION['user']['frontend_theme'] : 'default';
    }

    public static function getThemeName()

The return type could not be reliably inferred; please add a @return annotation.

    {
        if (null === self::$parameters['themename']) {
            // switch automatically to a backend theme
            // in case the "Control Center" or "Backend Controller" is requested
            if (self::getModule() === 'Controlcenter' or self::getController() === 'Admin') {

Using logical operators such as or instead of || is generally not recommended.

                self::setThemeName(self::getBackendTheme());
            } else {
                self::setThemeName(self::getFrontendTheme());
            }
        }

        return self::$parameters['themename'];
    }

    public static function setThemeName($themename)
    {
        self::$parameters['themename'] = $themename;
    }

    public static function getModRewriteStatus()

function getModRewriteStatus() does not seem to conform to the naming convention (^(?:is|has|should|may|supports)).

    {
        return (bool) self::$parameters['modrewrite'];
    }

    /**
     * Dispatchable ensures that the "logical" route is "physically" valid.
     * The method checks, if the TargetRoute relates to correct file, controller and action.
     *
     * @return bool True if TargetRoute is dispatchable, false otherwise.
     */
    public static function dispatchable()

function dispatchable() does not seem to conform to the naming convention (^(?:is|has|should|may|supports)).

    {
        $class  = self::getClassname();
        $file   = self::getFilename();

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

        $method = self::getMethod();

        // prevent redeclaration, by checking "method in class" (implicit class_exist())
        if (method_exists($class, $method)) {
            return true;
        }

        // trigger autoload & check for "class in file / PSR-0" and "method in class"
        if (true === class_exists($class) and true === method_exists($class, $method)) {

This if statement, and the following return statement can be replaced with return true === class_exists($class) and true === method_exists($class, $method);.

Using logical operators such as and instead of && is generally not recommended.

            return true;
        }

        // LEAVE THIS - It shows how many routes were tried before a match happens!
        //#\Koch\Debug\Debug::firebug('Route not found : [ ' . $file .' | '. $class .' | '. $method . ']');

41% of this comment could be valid code. Did you maybe forget this after debugging?

        return false;
    }

    /**
     * setSegmentsToTargetRoute.
     *
     * This takes the requirements array or the uri_segments array
     * and sets the proper parameters on the Target Route,
     * thereby making it dispatchable.
     *
     * URL Examples
     * a) index.php?mod=news=action=archive
     * b) index.php?mod=news&ctrl=admin&action=edit&id=77
     *
     * mod      => controller => <News>Controller.php
     * ctrl     => controller suffix  => News<Admin>Controller.php
     * action   => method     => action_<action>
     * *id*     => additional call params for the method
     */
    public static function setSegmentsToTargetRoute($array)
    {
        /**
         * if array is an found route, it has the following array structure:
         * [regexp], [number_of_segments] and [requirements].
         *
         * for getting the values module, controller, action only the
         * [requirements] array is relevant. overwriting $array drops the keys
         * [regexp] and [number_of_segments] because they are no longer needed.
         */
        if ((isset($array['requirements'])) || (array_key_exists('requirements', $array))) {
            $array = $array['requirements'];
        }

        // Module
        if (isset($array['module'])) {
            self::setModule($array['module']);
            // yes, set the controller of the module, too
            // if it is e.g. AdminController on Module News, then it will be overwritten below
            self::setController($array['module']);
            unset($array['module']);
        }

        // Controller
        if (isset($array['controller'])) {
            self::setController($array['controller']);
            // if a module was not set yet, then set the current controller also as module
            if (self::$parameters['module'] === 'index') {
                self::setModule($array['controller']);
            }
            unset($array['controller']);
        }

        // Action
        if (isset($array['action'])) {
            self::setAction($array['action']);
            unset($array['action']);
        }

        // Id
        if (isset($array['id'])) {
            self::setId($array['id']);

            // if we set an ID and the action is still empty (=default: list),
            // then we automatically set the action name according to the request method
            if (self::$parameters['action'] === 'list') {
                $request_method = self::getRequestMethod();

$request_method does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                if ($request_method === 'GET') {

$request_method does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                    self::setAction('show');
                } elseif ($request_method === 'PUT') {

$request_method does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                    self::setAction('update');
                } elseif ($request_method === 'DELETE') {

$request_method does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                    self::setAction('delete');
                }
            }

            unset($array['id']);
        }

        // if the request method is POST then set the action INSERT
        if ('POST' === self::getRequestMethod()) {
            self::setAction('insert');
        }

        // Parameters
        if (count($array) > 0) {
            self::setParameters($array);
            unset($array);
        }

        # instantiate the target route

        return self::instantiate();
    }

    public static function reset()
    {
        $reset_params = [

$reset_params does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            // File
            'filename'  => null,
            'classname' => null,
            // Call
            'module'     => 'index',
            'controller' => 'index',
            'action'     => 'list',
            'method'     => 'actionList',
            'params'     => [],
            // Output
            'format'     => 'html',
            'language'   => 'en',
            'request'    => 'get',
            'layout'     => true,
            'ajax'       => false,
            'renderer'   => 'smarty',
            'themename'  => 'default',
            'modrewrite' => false,
        ];

        self::$parameters = $reset_params;

$reset_params does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    }

    public static function getRoute()
    {
        return self::$parameters;
    }
}