Risan\OAuth1\Config\UriConfig

Complexity

Total Complexity

24

Size/Duplication

Total Lines	217
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getParser()	0	4	1
A	setFromArray()	0	18	3
A	validateUris()	0	16	3
A	setBase()	0	10	2
A	base()	0	4	2
A	hasBase()	0	4	1
A	forTemporaryCredentials()	0	4	1
A	forAuthorization()	0	4	1
A	forTokenCredentials()	0	4	1
A	callback()	0	4	2
A	hasCallback()	0	4	1
A	build()	0	10	3
A	shouldBeResolvedToAbsoluteUri()	0	4	2

<?php

namespace Risan\OAuth1\Config;

use InvalidArgumentException;
use Psr\Http\Message\UriInterface;
use Risan\OAuth1\Request\UriParserInterface;

class UriConfig implements UriConfigInterface
{
    /**
     * The UriParserInterface implementation.
     *
     * @return \Risan\OAuth1\Request\UriParserInterface
     */
    protected $parser;

    /**
     * The base URI.
     *
     * @var \Psr\Http\Message\UriInterface|null
     */
    protected $base;

    /**
     * The URI for obtaining temporary credentials. Also known as request token
     * URI.
     *
     * @var \Psr\Http\Message\UriInterface
     */
    protected $temporaryCredentials;

    /**
     * The URI for asking user to authorize the request.
     *
     * @var \Psr\Http\Message\UriInterface
     */
    protected $authorization;

    /**
     * The URI for obtaining token credentials. Also known as access token
     * URI.
     *
     * @var \Psr\Http\Message\UriInterface
     */
    protected $tokenCredentials;

    /**
     * The callback URI.
     *
     * @var \Psr\Http\Message\UriInterface|null
     */
    protected $callback;

    /**
     * Create UriConfig instance.
     *
     * @param array $uris
     * @param \Risan\OAuth1\Request\UriParserInterface $parser
     */
    public function __construct(array $uris, UriParserInterface $parser)
    {
        $this->parser = $parser;
        $this->setFromArray($uris);
    }

    /**
     * {@inheritDoc}
     */
    public function getParser()
    {
        return $this->parser;
    }

    /**
     * Set URIs from an array.
     *
     * @param array $uris
     * @return \Risan\OAuth1\Config\UriConfig
     */
    public function setFromArray(array $uris)
    {
        $this->validateUris($uris);

        $this->temporaryCredentials = $this->parser->toPsrUri($uris['temporary_credentials_uri']);
        $this->authorization = $this->parser->toPsrUri($uris['authorization_uri']);
        $this->tokenCredentials = $this->parser->toPsrUri($uris['token_credentials_uri']);

        if (isset($uris['base_uri'])) {
            $this->setBase($this->parser->toPsrUri($uris['base_uri']));
        }

        if (isset($uris['callback_uri'])) {
            $this->callback = $this->parser->toPsrUri($uris['callback_uri']);
        }

        return $this;
    }

    /**
     * Validate the given URI array.
     *
     * @param  array  $uris
     * @return boolean
     * @throws \InvalidArgumentException
     */
    public function validateUris(array $uris)
    {
        $requiredParams = [
            'temporary_credentials_uri',
            'authorization_uri',
            'token_credentials_uri',
        ];

        foreach ($requiredParams as $param) {
            if (! isset($uris[$param])) {
                throw new InvalidArgumentException("Missing URI configuration: {$param}.");
            }
        }

        return true;
    }

    /**
     * Set the base URI.
     *
     * @param  \Psr\Http\Message\UriInterface $uri
     * @return \Risan\OAuth1\Config\UriConfig
     * @throws \InvalidArgumentException
     */
    public function setBase(UriInterface $uri)
    {
        if (! $this->parser->isAbsolute($uri)) {
            throw new InvalidArgumentException('The base URI must be absolute.');
        }

        $this->base = $uri;

        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function base()
    {
        return $this->hasBase() ? $this->base : null;
    }

    /**
     * {@inheritDoc}
     */
    public function hasBase()
    {
        return $this->base !== null;
    }

    /**
     * {@inheritDoc}
     */
    public function forTemporaryCredentials()
    {
        return $this->build($this->temporaryCredentials);
    }

    /**
     * {@inheritDoc}
     */
    public function forAuthorization()
    {
        return $this->build($this->authorization);
    }

    /**
     * {@inheritDoc}
     */
    public function forTokenCredentials()
    {
        return $this->build($this->tokenCredentials);
    }

    /**
     * {@inheritDoc}
     */
    public function callback()
    {
        return $this->hasCallback() ? $this->build($this->callback) : null;

It seems like $this->callback can be null; however, build() does not accept null, maybe add an additional type check?

    }

    /**
     * {@inheritDoc}
     */
    public function hasCallback()
    {
        return $this->callback !== null;
    }

    /**
     * Parse and build the given URI.
     *
     * @param  \Psr\Http\Message\UriInterface|string $uri
     * @return \Psr\Http\Message\UriInterface
     */
    public function build($uri)
    {
        $uri = $this->parser->toPsrUri($uri);

        if ($this->shouldBeResolvedToAbsoluteUri($uri)) {
            $uri = $this->parser->resolve($this->base(), $uri);

It seems like $this->base() can be null; however, resolve() does not accept null, maybe add an additional type check?

        }

        return $this->parser->isMissingScheme($uri) ? $uri->withScheme('http') : $uri;
    }

    /**
     * Check if the given URI should be resolved to absolute URI.
     *
     * @param  \Psr\Http\Message\UriInterface $uri
     * @return boolean
     */
    public function shouldBeResolvedToAbsoluteUri(UriInterface $uri)
    {
        return ! $this->parser->isAbsolute($uri) && $this->hasBase();
    }
}