AbstractParser::assemble() - Code Metrics - Inspection of "Merge branch '0.9' into develop" - bytic/router - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — master ( 7450ca...e4bb3e )

by Gabriel

created 2019-03-26 08:08 UTC

AbstractParser::assemble() B

↳ Parent: AbstractParser

Complexity

Conditions	9
Paths	6

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	13
CRAP Score	9.5338

Importance

Changes

Metric	Value
dl	0
loc	30
ccs	13
cts	16
cp	0.8125
rs	8.0555
c	0
b	0
f	0
cc	9
nc	6
nop	1
crap	9.5338

<?php

namespace Nip\Router\Parsers;

/**
 * Class AbstractParser
 * @package Nip\Router\Parsers
 */
abstract class AbstractParser
{
    /**
     * @var \Nip\Request
     */
    protected $request;

    /**
     * @var string
     */
    protected $uri;

    /**
     * @var string
     */
    protected $map;

    /**
     * @var array
     */
    protected $parts;

    /**
     * @var array
     */
    protected $params = [];

    /**
     * @var array
     */
    protected $variables = [];

    /**
     * @var array
     */
    protected $matches = [];

    /**
     * AbstractParser constructor.
     * @param bool $map
     * @param array $params
     */
    public function __construct($map = false, $params = [])
    {
        if ($map) {
            $this->setMap($map);
        } elseif ($this->map) {
            $this->parseMap();
        }


        if ($params) {

            $this->setParams($params);
        }
        $this->init();
    }

    protected function parseMap()
    {
        $this->setParts(explode("/", trim($this->map, '/')));
    }

    public function init()
    {
    }

    /**
     * @param $uri
     * @return bool
     */
    public function match($uri)
    {
        $this->setUri($uri);

        return true;
    }

    /**
     * @param mixed $uri
     */
    public function setUri($uri)
    {
        $this->uri = $uri;
    }

    /**
     * @param array $params
     * @return string
     */
    public function assemble($params = [])
    {
        $return = $this->getMap();

        if ($params) {

            foreach ($params as $key => $value) {
                if (stristr($return, ":" . $key) !== false) {
                    $return = str_replace(":" . $key, $value, $return);
                    unset($params[$key]);
                }
                if (array_key_exists($key, $this->params)) {
                    unset($params[$key]);
                }
            }
            if ($params) {

                $return .= "?" . http_build_query($params);
            }
        }

        // set defaults
        if ($this->params) {

            foreach ($this->params as $key => $value) {
                if (is_string($value)) {
                    $return = str_replace(":" . $key, $value, $return);
                }
            }
        }

        return $return;
    }

    /**
     * @return string
     */
    public function getMap()
    {
        return $this->map;
    }

    /**
     * @param boolean $map
     */
    public function setMap($map)
    {
        $this->map = $map;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
        $this->parseMap();
    }

    /**
     * @param $params
     * @return array
     */
    public function stripEmptyParams($params)
    {
        if (is_array($params)) {
            foreach ($params as $key => $param) {
                if (empty($param)) {
                    unset($params[$key]);
                } elseif (is_array($param)) {
                    $newParams = $this->stripEmptyParams($param);
                    if (!is_array($newParams) or count($newParams) < 1) {
// 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);
                        unset($params[$key]);
                    } else {
                        $params[$key] = $newParams;
                    }
                }
            }
        }

        return $params;
    }

    /**
     * @return array
     */
    public function getParts()
    {
        return $this->parts;
    }

    /**
     * @param array $parts
     */
    public function setParts($parts)
    {
        $this->parts = $parts;
    }

    /**
     * @return array
     */
    public function getParams()
    {
        return $this->params;
    }

    /**
     * @param array $params
     */
    public function setParams($params = [])
    {
        if (count($params)) {
            foreach ($params as $key => $value) {
                $this->setParam($key, $value);
            }
        }
    }

    /**
     * @param $name
     * @param $value
     * @return $this
     */
    public function setParam($name, $value)
    {
        $this->params[$name] = $value;

        return $this;
    }

    /**
     * @param string $key
     * @return mixed|null
     */
    public function getParam($key)
    {
        return $this->hasParam($key) ? $this->params[$key] : null;
    }

    /**
     * @param $key
     * @return bool
     */
    public function hasParam($key)
    {
        return isset($this->params[$key]);
    }

    /**
     * @return array
     */
    public function getMatches()
    {
        return $this->matches;
    }

    /**
     * @return array
     */
    public function getVariables()
    {
        return $this->variables;
    }

    /**
     * @param array $variables
     */
    public function setVariables($variables)
    {
        $this->variables = $variables;
    }

//    public function setModule($module)

//    {
//        $this->_module = $module;
//    }
//
//    public function setController($controller)
//    {
//        $this->_controller = $controller;
//    }
//
//    public function setAction($action)
//    {
//        $this->_action = $action;
//    }
}


bytic / router

Push — master ( 7450ca...e4bb3e )

AbstractParser::assemble() B

Complexity

Size

Duplication

Code Coverage

Importance

Logical Operators are used for Control-Flow

Duplication Side-by-Side

Filter issues like