hiqdev\hiart\AbstractRequest

Complexity

Total Complexity

51

Size/Duplication

Total Lines	279
Duplicated Lines	0 %

Test Coverage

Coverage

77.68%

Importance

Changes	3
Bugs	0	Features	0

34 Methods

Rating	Name	Duplication	Size	Complexity
A	build()	0	7	3
A	isFullUri()	0	3	1
A	prepareUserAgent()	0	3	1
A	getHeaders()	0	3	1
A	setFormParams()	0	5	3
A	isRaw()	0	3	1
A	getQuery()	0	3	1
A	getMethod()	0	3	1
A	buildProtocolVersion()	0	3	2
A	createFullUri()	0	3	2
A	buildMethod()	0	3	2
A	getHandler()	0	8	2
A	getDb()	0	3	2
A	buildHeaders()	0	5	2
A	getVersion()	0	3	1
A	getBody()	0	3	1
A	prepareHandlerConfig()	0	3	1
A	buildUri()	0	3	1
A	updateFromQuery()	0	13	1
A	getFullUri()	0	7	2
A	buildFormParams()	0	3	1
A	serialize()	0	3	1
A	getParts()	0	10	3
A	__construct()	0	4	1
A	getDbname()	0	3	1
A	buildAuth()	0	3	1
A	getUri()	0	3	1
A	buildDbname()	0	3	1
A	unserialize()	0	4	2
A	buildQueryParams()	0	8	3
A	buildBody()	0	3	1
A	createHandler()	0	5	1
A	addHeader()	0	9	2
A	isSupported()	0	3	1

<?php
/**
 * ActiveRecord for API
 *
 * @link      https://github.com/hiqdev/yii2-hiart
 * @package   yii2-hiart
 * @license   BSD-3-Clause
 * @copyright Copyright (c) 2015-2019, HiQDev (http://hiqdev.com/)
 */

namespace hiqdev\hiart;

abstract class AbstractRequest implements RequestInterface
{
    /**
     * @var string response implementation to be specified in concrete implementation
     */
    protected $responseClass;

    /**
     * @var string request handler implementation to be specified in concrete implementation
     */
    protected $handlerClass;

    /**
     * @var QueryBuilderInterface
     */
    protected $builder;

    /**
     * @var Query
     */
    protected $query;

    /**
     * @var string Connection name
     */
    protected $dbname;

    /**
     * @var array request method
     */
    protected $method;
    protected $uri;
    protected $headers = [];
    protected $body;
    protected $version;

    protected $isBuilt;
    protected $parts = [];
    protected $fullUri;

    abstract public function send($options = []);

    public function __construct(QueryBuilderInterface $builder, Query $query)
    {
        $this->builder = $builder;
        $this->query = $query;
    }

    public function getDbname()
    {
        return $this->dbname;
    }

    public function getMethod()
    {
        return $this->method;

The expression return $this->method returns the type array which is incompatible with the return type mandated by hiqdev\hiart\RequestInterface::getMethod() of string.

    }

    public function getUri()
    {
        return $this->uri;
    }

    public function getFullUri()
    {
        if ($this->fullUri === null) {
            $this->fullUri = $this->createFullUri();
        }

        return $this->fullUri;
    }

    public function createFullUri()
    {
        return ($this->isFullUri($this->uri) ? '' : $this->getDb()->getBaseUri()) . $this->uri;

The method getBaseUri() does not exist on hiqdev\hiart\ConnectionInterface. It seems like you code against a sub-type of said class. However, the method does not exist in hiqdev\hiart\github\ConnectionInterface. Are you sure you never get one of those?

    }

    public function isFullUri($uri)
    {
        return preg_match('/^https?:\\/\\//i', $uri);
    }

    public function getHeaders()
    {
        return $this->headers;
    }

    public function getBody()
    {
        return $this->body;
    }

    public function getVersion()
    {
        return $this->version;
    }

    /**
     * @return Query
     */
    public function getQuery()
    {
        return $this->query;
    }

    public function build()
    {
        if ($this->isBuilt === null) {
            if (!empty($this->query)) {
                $this->updateFromQuery();
            }
            $this->isBuilt = true;
        }
    }

    protected function updateFromQuery()
    {
        $this->builder->prepare($this->query);

        $this->buildDbname();
        $this->buildAuth();
        $this->buildMethod();
        $this->buildUri();
        $this->buildQueryParams();
        $this->buildHeaders();
        $this->buildBody();
        $this->buildFormParams();
        $this->buildProtocolVersion();
    }

    protected function buildDbname()
    {
        $this->dbname = $this->getDb()->name;
    }

    protected function buildAuth()
    {
        $this->builder->buildAuth($this->query);
    }

    protected function buildMethod()
    {
        $this->method = $this->builder->buildMethod($this->query) ?: 'GET';

It seems like $this->builder->buildMethod($this->query) ?: 'GET' can also be of type string. However, the property $method is declared as type array. Maybe add an additional type check?

    }

    protected function buildUri()
    {
        $this->uri = $this->builder->buildUri($this->query);
    }

    protected function buildQueryParams()
    {
        $params = $this->builder->buildQueryParams($this->query);
        if (is_array($params)) {
            $params = http_build_query($params, '', '&');
        }
        if (!empty($params)) {
            $this->uri .= '?' . $params;
        }
    }

    protected function buildHeaders()
    {
        $this->headers = $this->builder->buildHeaders($this->query);
        if (empty($this->headers['User-Agent'])) {
            $this->headers['User-Agent'] = $this->prepareUserAgent();
        }
    }

    protected function buildBody()
    {
        $this->body = $this->builder->buildBody($this->query);
    }

    protected function buildFormParams()
    {
        $this->setFormParams($this->builder->buildFormParams($this->query));
    }

    protected function setFormParams($params)
    {
        if (!empty($params)) {
            $this->body = is_array($params) ? http_build_query($params, '', '&') : $params;
            $this->headers['Content-Type'] = 'application/x-www-form-urlencoded';
        }
    }

    protected function buildProtocolVersion()
    {
        $this->version = $this->builder->buildProtocolVersion($this->query) ?: '1.1';
    }

    public function serialize()
    {
        return serialize($this->getParts());
    }

    public function unserialize($string)
    {
        foreach (unserialize($string) as $key => $value) {
            $this->{$key} = $value;
        }
    }

    public function getParts()
    {
        if (empty($this->parts)) {
            $this->build();
            foreach (['dbname', 'method', 'uri', 'headers', 'body', 'version'] as $key) {
                $this->parts[$key] = $this->{$key};
            }
        }

        return $this->parts;
    }

    public function isRaw()
    {
        return !empty($this->query->options['raw']);
    }

    protected function getHandler()
    {
        $handler = $this->getDb()->getHandler();

The method getHandler() does not exist on hiqdev\hiart\ConnectionInterface. It seems like you code against a sub-type of said class. However, the method does not exist in hiqdev\hiart\github\ConnectionInterface. Are you sure you never get one of those?

        if ($handler === null) {
            $handler = $this->createHandler();
        }

        return $handler;
    }

    protected function createHandler()
    {
        $config = $this->prepareHandlerConfig($this->getDb()->config);

        return new $this->handlerClass($config);
    }

    protected function prepareHandlerConfig($config)
    {
        return $config;
    }

    protected function prepareUserAgent()
    {
        return $this->getDb()->getUserAgent();

The method getUserAgent() does not exist on hiqdev\hiart\ConnectionInterface. It seems like you code against a sub-type of said class. However, the method does not exist in hiqdev\hiart\github\ConnectionInterface. Are you sure you never get one of those?

    }

    /**
     * @return AbstractConnection|ConnectionInterface
     */
    public function getDb()
    {
        return isset($this->builder) ? $this->builder->db : AbstractConnection::getDb($this->dbname);

Accessing db on the interface hiqdev\hiart\QueryBuilderInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    /**
     * @param string $header
     * @param string $value
     * @return $this
     */
    public function addHeader($header, $value)
    {
        if (!isset($this->headers[$header])) {
            $this->headers[$header] = [];
        }

        $this->headers[$header][] = $value;

        return $this;
    }

    /**
     * {@inheritdoc}
     * Should be declared abstract, but it is not supported in PHP5.
     */
    public static function isSupported()
    {
        return false;
    }
}