TargetRoute::getClassname() - Code Metrics - KSST/KF - Measure and Improve Code Quality continuously with Scrutinizer

TargetRoute::getClassname() A
last analyzed 2017-04-11 14:32 UTC

↳ Parent: TargetRoute
Complexity

Conditions	2
Paths	2
Size

Total Lines	9
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
eloc	5
c	0
b	0
f	0
nc	2
nop	0
dl	0
loc	9
rs	9.6666
<?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

     */
    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()

    {
        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()

    {
        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()

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

    public static function getActionNameWithoutPrefix()

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

        return $action;
    }

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

    public static function getId()

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

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

     */
    public static function getActionName()

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

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

    public static function getMethod()

    {
        // 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()

    {
        // 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()

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

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

    public static function getLayoutMode()

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

    public static function getAjaxMode()

    {
        return HttpRequest::isAjax();
    }

    public static function getRenderEngine()

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

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

    public static function getBackendTheme()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        return (isset($_SESSION['user']['backend_theme'])) ? $_SESSION['user']['backend_theme'] : 'default';
    }

    public static function getFrontendTheme()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        return (isset($_SESSION['user']['frontend_theme']))  ? $_SESSION['user']['frontend_theme'] : 'default';
    }

    public static function getThemeName()

    {
        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') {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
                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()

    {
        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()

    {
        $class  = self::getClassname();
        $file   = self::getFilename();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $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)) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
            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 . ']');

        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();


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

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

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

                    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 = [

            // 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;

    }

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

TargetRoute::getClassname() A
last analyzed 2017-04-11 14:32 UTC

Complexity

Size

Duplication

Importance

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

KSST / KF

TargetRoute::getClassname() A last analyzed 2017-04-11 14:32 UTC

Complexity

Size

Duplication

Importance

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Duplication Side-by-Side

Filter issues like

TargetRoute::getClassname() A
last analyzed 2017-04-11 14:32 UTC
