phpDocumentor\DomainModel\Dsn

Complexity

Total Complexity

37

Size/Duplication

Total Lines	323
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	__toString()	0	4	1
A	getScheme()	0	4	1
A	getHost()	0	4	1
A	getPort()	0	4	1
A	getUsername()	0	4	1
A	getPassword()	0	4	1
A	getPath()	0	4	1
A	getQuery()	0	4	1
A	getParameters()	0	4	1
C	parse()	0	50	10
A	parseDsn()	0	5	1
A	parseScheme()	0	9	2
A	isValidScheme()	0	5	1
A	parseHostAndPath()	0	12	2
A	parsePort()	0	14	4
A	parseQuery()	0	11	3
A	parseParameters()	0	8	2
A	splitKeyValuePair()	0	11	2

<?php
/**
 * This file is part of phpDocumentor.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @copyright 2010-2015 Mike van Riel<mike@phpdoc.org>
 * @license   http://www.opensource.org/licenses/mit-license.php MIT
 * @link      http://phpdoc.org
 */

namespace phpDocumentor\DomainModel;

/**
 * Value Object for DSN.
 */
final class Dsn
{
    /** @var string */
    private $dsn;

    /** @var string */
    private $scheme;

    /** @var string */
    private $host;

    /** @var int */
    private $port;

    /** @var string */
    private $user;

    /** @var string */
    private $password;

    /** @var string */
    private $path;

    /** @var string[]  */
    private $query = [];

    /** @var string[]  */
    private $parameters = [];

    //@codingStandardsIgnoreStart
    const WINDOWS_DSN = '~(^((?<scheme>file):\\/\\/)?(?<path>((?:[a-z]|[A-Z]):(?=\\\\(?![\\0-\\37<>:"/\\\\|?*])|\\/(?![\\0-\\37<>:"/\\\\|?*])|$)|^\\\\(?=[\\\\\\/][^\\0-\\37<>:"/\\\\|?*]+)|^(?=(\\\\|\\/)$)|^\\.(?=(\\\\|\\/)$)|^\\.\\.(?=(\\\\|\\/)$)|^(?=(\\\\|\\/)[^\\0-\\37<>:"/\\\\|?*]+)|^\\.(?=(\\\\|\\/)[^\\0-\\37<>:"/\\\\|?*]+)|^\\.\\.(?=(\\\\|\\/)[^\\0-\\37<>:"/\\\\|?*]+))((\\\\|\\/)[^\\0-\\37<>:"/\\\\|?*]+|(\\\\|\\/)$)*()))$~';
    //@codingStandardsIgnoreEnd

    /**
     * Initializes the Dsn
     *
     * @param string $dsn
     */
    public function __construct($dsn)
    {
        $this->parse($dsn);
    }

    /**
     * Returns a string representation of the DSN.
     *
     * @return string
     */
    public function __toString()
    {
        return $this->dsn;
    }

    /**
     * Returns the scheme part of the DSN
     *
     * @return string
     */
    public function getScheme()
    {
        return $this->scheme;
    }

    /**
     * Returns the host part of the DSN
     *
     * @return string
     */
    public function getHost()
    {
        return $this->host;
    }

    /**
     * Returns the port part of the DSN
     *
     * @return int
     */
    public function getPort()
    {
        return $this->port;
    }

    /**
     * Returns the username part of the DSN
     *
     * @return string
     */
    public function getUsername()
    {
        return $this->user;
    }

    /**
     * Returns the password part of the DSN
     *
     * @return string
     */
    public function getPassword()
    {
        return $this->password;
    }

    /**
     * Returns the path part of the DSN
     *
     * @return string
     */
    public function getPath()
    {
        return new Path($this->path);
    }

    /**
     * Returns the query part of the DSN
     *
     * @return string[]
     */
    public function getQuery()
    {
        return $this->query;
    }

    /**
     * Returns the parameters part of the DSN
     *
     * @return string[]
     */
    public function getParameters()
    {
        return $this->parameters;
    }

    /**
     * Parses the given DSN
     *
     * @param string $dsn
     * @return void
     */
    private function parse($dsn)
    {
        if (! is_string($dsn)) {
            throw new \InvalidArgumentException(
                sprintf('"%s" is not a valid DSN.', var_export($dsn, true))
            );
        }

        $dsnParts = explode(';', $dsn);
        $location = $dsnParts[0];
        unset($dsnParts[0]);
        $locationParts = parse_url($location);

        if (
            $locationParts === false ||
            (array_key_exists('scheme', $locationParts) && \strlen($locationParts['scheme']) === 1)
        ) {
            preg_match(static::WINDOWS_DSN, $dsn, $locationParts);
        }

        if (
            ! array_key_exists('scheme', $locationParts) ||
            ($locationParts['scheme'] === '' && array_key_exists('path', $locationParts))
        ) {
            $locationParts['scheme'] = 'file';
            $location = 'file://' . $location;
        }

        if (!filter_var($location, FILTER_VALIDATE_URL) && !preg_match(static::WINDOWS_DSN, $location)) {
            throw new \InvalidArgumentException(
                sprintf('"%s" is not a valid DSN.', $dsn)
            );
        }

        $this->parseDsn($location, $dsnParts);

        $this->parseScheme($locationParts);

        $this->parseHostAndPath($locationParts);

        $this->parsePort($locationParts);

        $this->user = $locationParts['user'] ?? "";

        $this->password = $locationParts['pass'] ?? "";

        $this->parseQuery($locationParts);

        $this->parseParameters($dsnParts);
    }

    /**
     * Reconstructs the original DSN but
     * when scheme was omitted in the original DSN, it will now be file://
     *
     * @param string $location
     * @param string[] $dsnParts
     * @return void
     */
    private function parseDsn($location, array $dsnParts)
    {
        array_splice($dsnParts, 0, 0, $location);
        $this->dsn = implode(";", $dsnParts);
    }

    /**
     * validates and sets the scheme property
     *
     * @param string[] $locationParts
     * @return void
     */
    private function parseScheme(array $locationParts)
    {
        if (! $this->isValidScheme($locationParts['scheme'])) {
            throw new \InvalidArgumentException(
                sprintf('"%s" is not a valid scheme.', $locationParts['scheme'])
            );
        }
        $this->scheme = strtolower($locationParts['scheme']);
    }

    /**
     * Validated provided scheme.
     *
     * @param string $scheme
     * @return bool
     */
    private function isValidScheme(string $scheme): bool
    {
        $validSchemes = ['file', 'git+http', 'git+https'];
        return \in_array(\strtolower($scheme), $validSchemes, true);
    }

    /**
     * Validates and sets the host and path properties
     *
     * @param string[] $locationParts
     * @return void
     */
    private function parseHostAndPath(array $locationParts)
    {
        $path = $locationParts['path'] ?? "";
        $host = $locationParts['host'] ?? "";

        if ($this->getScheme() === 'file') {
            $this->path = $host . $path;
        } else {
            $this->host = $host;
            $this->path = $path;
        }
    }

    /**
     * Validates and sets the port property
     *
     * @param string[] $locationParts
     * @return void
     */
    private function parsePort(array $locationParts)
    {
        if (! isset($locationParts['port'])) {
            if ($this->getScheme() === 'git+http') {
                $this->port = 80;
            } elseif ($this->getScheme() === 'git+https') {
                $this->port = 443;
            } else {
                $this->port = 0;
            }
        } else {
            $this->port = $locationParts['port'];

The property $port was declared of type integer, but $locationParts['port'] is of type string. Maybe add a type cast?

        }
    }

    /**
     * validates and sets the query property
     *
     * @param string[] $locationParts
     * @return void
     */
    private function parseQuery(array $locationParts)
    {
        if (isset($locationParts['query'])) {
            $queryParts = explode('&', $locationParts['query']);
            foreach ($queryParts as $part) {
                $option = $this->splitKeyValuePair($part);

                $this->query[$option[0]] = $option[1];
            }
        }
    }

    /**
     * validates and sets the parameters property
     *
     * @param string[] $dsnParts
     * @return void
     */
    private function parseParameters(array $dsnParts)
    {
        foreach ($dsnParts as $part) {
            $option = $this->splitKeyValuePair($part);

            $this->parameters[$option[0]] = $option[1];
        }
    }

    /**
     * Splits a key-value pair
     *
     * @param string $pair
     * @return string[] $option
     */
    private function splitKeyValuePair($pair)
    {
        $option = explode('=', $pair);
        if (count($option) !== 2) {
            throw new \InvalidArgumentException(
                sprintf('"%s" is not a valid query or parameter.', $pair)
            );
        }

        return $option;
    }
}