UriParser - Code Metrics - zicht/url-bundle - Measure and Improve Code Quality continuously with Scrutinizer

UriParser A
last analyzed 2020-01-22 16:05 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	193
Duplicated Lines	0 %

Test Coverage

Coverage

84.29%

Importance

Changes	3
Bugs	1	Features	0

Metric	Value
eloc	63
c	3
b	1
f	0
dl	0
loc	193
ccs	59
cts	70
cp	0.8429
rs	10
wmc	29

9 Methods

Rating	Name	Size	Complexity
B	composeUri()	30	7
A	__construct()	5	1
A	parsePost()	17	5
A	translateKeyOutput()	7	2
A	setTranslator()	3	1
B	parseUri()	23	7
A	translateValueOutput()	7	2
A	translateKeyInput()	7	2
A	translateValueInput()	7	2

<?php
/**
 * @author Gerard van Helden <[email protected]>
 * @copyright Zicht Online <http://zicht.nl>
 */

namespace Zicht\Bundle\UrlBundle\Url\Params;

/**
 * Parser for key/value pairs in the url.
 */
class UriParser implements Translator
{
    private $seperators = array();

    /**
     * @var Translator
     */
    private $translator = null;

    /**
     * Constructor
     *
     * @param string $paramSeparator
     * @param string $keyValueSeparator
     * @param string $valueSeparator
     */
    public function __construct($paramSeparator = '/', $keyValueSeparator = '=', $valueSeparator = ',')
    {
        $this->seperators['param']     = $paramSeparator;
        $this->seperators['key_value'] = $keyValueSeparator;
        $this->seperators['value']     = $valueSeparator;
    }


    /**
     * Translator
     *
     * @param Translator $translator
     * @return void
     */
    public function setTranslator(Translator $translator)
    {
        $this->translator = $translator;
    }

    /**
     * POST keys are not translated, but do translate the values
     *
     * @param array $post
     * @return array
     */
    public function parsePost(array $post)
    {
        $ret = array();
        foreach ($post as $key => $value) {
            if ($key) {
                $external  = $this->translateKeyOutput($key);
                $ret[$key] = array();
                if (strlen($value) > 0) {
                    if ($internal = $this->translateValueInput($external, $value)) {
                        $value = $internal;
                    }
                    $ret[$key][] = $value;
                }
            }
        }

        return $ret;
    }

    /**
     * Parse the uri
     *
     * @param string $uri
     * @return array
     */
    public function parseUri($uri)
    {
        $ret = array();
        foreach (explode($this->seperators['param'], $uri) as $params) {
            if ($params) {
                @list($key, $values) = explode($this->seperators['key_value'], $params, 2);
                $external = $key;
                if ($internal = $this->translateKeyInput($key)) {
                    $key = $internal;
                }
                $ret[$key] = array();
                foreach (explode($this->seperators['value'], $values) as $value) {
                    if (strlen($value) > 0) {
                        if ($internal = $this->translateValueInput($external, $value)) {
                            $value = $internal;
                        }
                        $ret[$key][] = urldecode($value);
                        $ret[$key][] = urldecode(/** @scrutinizer ignore-type */ $value);
                    }
                }
            }
        }

        return $ret;
    }


    /**
     * Compose an URI from the passed params with the local separators
     *
     * @param Params $params
     * @return string
     */
    public function composeUri($params)
    {
        $ret   = '';
        $first = true;

        foreach ($params as $param => $values) {
            if (!$first) {
                $ret .= $this->seperators['param'];
            }
            $first    = false;
            $internal = $param;
            if ($external = $this->translateKeyOutput($param)) {
                $param = $external;
            }
            $ret .= $param . $this->seperators['key_value'];
            $firstValue = true;
            foreach ($values as $value) {
                if ($external = $this->translateValueOutput($internal, $value)) {
                    $value = $external;
                }
                if (!$firstValue) {
                    $ret .= $this->seperators['value'];
                } else {
                    $firstValue = false;
                }
                $ret .= urlencode($value);
            }
        }

        return $ret;
    }


    /**
     * Proxy method for translateKeyInput() of the translator
     *
     * @param string $keyName
     * @return bool
     */
    final public function translateKeyInput($keyName)
    {
        if ($this->translator) {
            return $this->translator->translateKeyInput($keyName);

        }

        return false;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }


    /**
     * Proxy method for translateValueInput() of the translator
     *
     * @param string $keyName
     * @param mixed $value
     * @return bool
     */
    final public function translateValueInput($keyName, $value)
    {
        if ($this->translator) {
            return $this->translator->translateValueInput($keyName, $value);

        }

        return false;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }


    /**
     * Proxy method for translateKeyOutput() of the translator
     *
     * @param string $keyName
     * @return bool
     */
    final public function translateKeyOutput($keyName)
    {
        if ($this->translator) {
            return $this->translator->translateKeyOutput($keyName);

        }

        return false;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    /**
     * Proxy method for translateValueOutput() of the translator
     *
     * @param string $keyName
     * @param string $value
     * @return bool
     */
    final public function translateValueOutput($keyName, $value)
    {
        if ($this->translator) {
            return $this->translator->translateValueOutput($keyName, $value);

        }

        return false;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }
}


zicht / url-bundle

UriParser A last analyzed 2020-01-22 16:05 UTC

Complexity

Size/Duplication

Test Coverage

Importance

9 Methods

Duplication Side-by-Side

Filter issues like

UriParser A
last analyzed 2020-01-22 16:05 UTC