LiquidWeb\SslCertificate\Url

Complexity

Total Complexity

18

Size/Duplication

Total Lines	98
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Test Coverage

Coverage

92.5%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getIp()	0	8	2
A	getInputUrl()	0	4	1
A	getHostName()	0	4	1
A	getValidatedURL()	0	4	1
A	getPort()	0	4	2
A	__toString()	0	4	1
A	verifyAndGetDNS()	0	9	2
B	__construct()	0	25	5
A	getTestURL()	0	4	1
A	getValidUrl()	0	8	2

<?php

namespace LiquidWeb\SslCertificate;

use League\Uri\Parser as UriParser;
use LiquidWeb\SslCertificate\Exceptions\InvalidUrl;

class Url
{
    /** @var string */
    protected $inputUrl;

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

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

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

    public function __toString()
    {
        return $this->getInputUrl();
    }

    private static function verifyAndGetDNS($domain): ?string
    {
        $domainIp = gethostbyname($domain);
        if (! filter_var($domainIp, FILTER_VALIDATE_IP)) {
            return null;
        }

        return $domainIp;
    }

    public function __construct(string $url)
    {
        $this->inputUrl = $url;
        $parser = new UriParser();
        $this->parsedUrl = $parser($this->inputUrl);

        // Verify parsing has a host
        if (is_null($this->parsedUrl['host'])) {
            try {
                $this->parsedUrl = $parser('https://'.$this->inputUrl);
            } catch (\Exception $e) {
                throw InvalidUrl::couldNotValidate($url);
            }
            if (is_null($this->parsedUrl['host'])) {
                throw InvalidUrl::couldNotDetermineHost($url);
            }
        }

        if (! filter_var($this->getValidUrl(), FILTER_VALIDATE_URL)) {
            throw InvalidUrl::couldNotValidate($url);
        }

        $this->ipAddress = self::verifyAndGetDNS($this->parsedUrl['host']);
        $this->validatedURL = $url;
    }

    public function getIp(): ?string
    {
        if (null === $this->ipAddress) {
            throw InvalidUrl::couldNotResolveDns($this->inputUrl);
        }

        return $this->ipAddress;
    }

    public function getInputUrl(): string
    {
        return $this->inputUrl;
    }

    public function getHostName(): string
    {
        return $this->parsedUrl['host'];
    }

    public function getValidatedURL(): string
    {
        return $this->validatedURL;
    }

    public function getPort(): string
    {
        return (isset($this->parsedUrl['port'])) ? $this->parsedUrl['port'] : '443';
    }

    public function getTestURL(): string
    {
        return "{$this->getHostName()}:{$this->getPort()}";
    }

    public function getValidUrl(): string
    {
        if ($this->getPort() === '80') {
            return 'http://'.$this->getHostName().'/';
        }

        return 'https://'.$this->getHostName().'/';
    }
}