Api::getDefaultParameters() - Code Metrics - ggoffy/wggithub - Measure and Improve Code Quality continuously with Scrutinizer

Api::getDefaultParameters() A
last analyzed 2025-03-21 14:15 UTC

↳ Parent: Api
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	1	Features	0
Metric	Value
cc	1
eloc	1
c	1
b	1
f	0
nc	1
nop	0
dl	0
loc	3
rs	10
<?php

namespace XoopsModules\Wggithub\Github;


/**
 * Github API client library. Read readme.md in repository {@link http://github.com/milo/github-api}
 *
 * @see https://developer.github.com/v3/
 *
 * @author  Miloslav Hůla (https://github.com/milo)
 */
class Api extends Sanity
{
    /** @var string */
    private $url = 'https://api.github.com';

    /** @var string */
    private $defaultAccept = 'application/vnd.github.v3+json';

    /** @var array|NULL */
    private $defaultParameters = [];

    /** @var Http\IClient */
    private $client;

    /** @var OAuth\Token|NULL */
    private $token;


    public function __construct(Http\IClient $client = NULL)
    {
        $this->client = $client ?: Helpers::createDefaultClient();
    }


    /**
     * @param OAuth\Token|null $token
     * @return self
     */
    public function setToken(OAuth\Token $token = NULL)
    {
        $this->token = $token;
        return $this;
    }


    /**
     * @return OAuth\Token|NULL
     */
    public function getToken()
    {
        return $this->token;
    }


    /**
     * @param  array
     * @return self
     */
    public function setDefaultParameters(array $defaults = NULL)
    {
        $this->defaultParameters = $defaults ?: [];
        return $this;
    }


    /**
     * @return array
     */
    public function getDefaultParameters()
    {
        return $this->defaultParameters;
    }


    /**
     * @param  string
     * @return self
     */
    public function setDefaultAccept($accept)
    {
        $this->defaultAccept = $accept;
        return $this;
    }


    /**
     * @return string
     */
    public function getDefaultAccept()
    {
        return $this->defaultAccept;
    }


    /**
     * @see createRequest()
     * @see request()
     *
     * @param  string
     * @param array $parameters
     * @param array $headers
     * @return Http\Response
     *
     */
    public function delete($urlPath, array $parameters = [], array $headers = [])
    {
        return $this->request(
            $this->createRequest(Http\Request::DELETE, $urlPath, $parameters, $headers)
        );
    }


    /**
     * @see createRequest()
     * @see request()
     *
     * @param  string
     * @param array $parameters
     * @param array $headers
     * @return Http\Response
     *
     */
    public function get($urlPath, array $parameters = [], array $headers = [])
    {
        return $this->request(
            $this->createRequest(Http\Request::GET, $urlPath, $parameters, $headers)
        );
    }


    /**
     * @see createRequest()
     * @see request()
     *
     * @param  string
     * @param array $parameters
     * @param array $headers
     * @return Http\Response
     *
     */
    public function head($urlPath, array $parameters = [], array $headers = [])
    {
        return $this->request(
            $this->createRequest(Http\Request::HEAD, $urlPath, $parameters, $headers)
        );
    }


    /**
     * @see createRequest()
     * @see request()
     *
     * @param $urlPath
     * @param $content
     * @param array $parameters
     * @param array $headers
     * @return Http\Response
     *
     */
    public function patch($urlPath, $content, array $parameters = [], array $headers = [])
    {
        return $this->request(
            $this->createRequest(Http\Request::PATCH, $urlPath, $parameters, $headers, $content)
        );
    }


    /**
     * @see createRequest()
     * @see request()
     *
     * @param $urlPath
     * @param $content
     * @param array $parameters
     * @param array $headers
     * @return Http\Response
     *
     */
    public function post($urlPath, $content, array $parameters = [], array $headers = [])
    {
        return $this->request(
            $this->createRequest(Http\Request::POST, $urlPath, $parameters, $headers, $content)
        );
    }


    /**
     * @see createRequest()
     * @see request()
     *
     * @param $urlPath
     * @param $content
     * @param array $parameters
     * @param array $headers
     * @return Http\Response
     *
     */
    public function put($urlPath, $content = NULL, array $parameters = [], array $headers = [])
    {
        return $this->request(
            $this->createRequest(Http\Request::PUT, $urlPath, $parameters, $headers, $content)
        );
    }


    /**
     * @param Http\Request $request
     * @return Http\Response
     *
     */
    public function request(Http\Request $request)
    {
        $request = clone $request;

        $request->addHeader('Accept', $this->defaultAccept);
        $request->addHeader('Time-Zone', date_default_timezone_get());
        $request->addHeader('User-Agent', 'milo/github-api');

        if ($this->token) {
            /** @todo Distinguish token type? */
            $request->addHeader('Authorization', "token {$this->token->getValue()}");
        }

        return $this->client->request($request);
    }


    /**
     * @param  string  Http\Request::GET|POST|...
     * @param  string  path like '/users/:user/repos' where ':user' is substitution
     * @param  array[name => value]  replaces substitutions in $urlPath, the rest is appended as query string to URL

     * @param  array[name => value]  name is case-insensitive
     * @param  mixed|NULL  arrays and objects are encoded to JSON and Content-Type is set
     * @return Http\Request
     *
     * @throws MissingParameterException  when substitution is used in URL but parameter is missing
     * @throws JsonException  when encoding to JSON fails
     */
    public function createRequest($method, $urlPath, array $parameters = [], array $headers = [], $content = NULL)
    {
        if (stripos($urlPath, $this->url) === 0) {  # Allows non-HTTPS URLs
            $baseUrl = $this->url;
            $urlPath = \substr($urlPath, \strlen($this->url));

        } elseif (\preg_match('#^(https://[^/]+)(/.*)?$#', $urlPath, $m)) {
            $baseUrl = $m[1];
            $urlPath = isset($m[2]) ? $m[2] : '';

        } else {
            $baseUrl = $this->url;
        }

        if (\strpos($urlPath, '{') === FALSE) {
            $urlPath = $this->expandColonParameters($urlPath, $parameters, $this->defaultParameters);
            $urlPath = $this->expandColonParameters($urlPath, $parameters, /** @scrutinizer ignore-type */ $this->defaultParameters);
        } else {
            $urlPath = $this->expandUriTemplate($urlPath, $parameters, $this->defaultParameters);
            $urlPath = $this->expandUriTemplate($urlPath, $parameters, /** @scrutinizer ignore-type */ $this->defaultParameters);
        }

        $url = \rtrim($baseUrl, '/') . '/' . \ltrim($urlPath, '/');

        if ($content !== NULL && (\is_array($content) || \is_object($content))) {
            $headers['Content-Type'] = 'application/json; charset=utf-8';
            $content = Helpers::jsonEncode($content);
        }

        return new Http\Request($method, $url, $headers, $content);
    }


    /**
     * @param  Http\Response
     * @param  array|NULL  these codes are treated as success; code < 300 if NULL
filter:
    dependency_paths: ["lib/*"]
     * @return mixed
     *
     * @throws ApiException
     */
    public function decode(Http\Response $response, array $okCodes = NULL)
    {
        $content = $response->getContent();
        if (\preg_match('~application/json~i', $response->getHeader('Content-Type', ''))) {
            try {
                $content = Helpers::jsonDecode($response->getContent(), true);
            } catch (JsonException $e) {
                throw new InvalidResponseException('JSON decoding failed.', 0, $e, $response);
            }

            if (!\is_array($content) && !\is_object($content)) {

                throw new InvalidResponseException('Decoded JSON is not an array or object.', 0, NULL, $response);
            }
        }

        $code = $response->getCode();
        if (($okCodes === NULL && $code >= 300) || (\is_array($okCodes) && !\in_array($code, $okCodes))) {
            /** @var $content \stdClass */
            switch ($code) {
                case Http\Response::S400_BAD_REQUEST:
                    throw new BadRequestException(self::errorMessage($content), $code, NULL, $response);

                case Http\Response::S401_UNAUTHORIZED:
                    throw new UnauthorizedException(self::errorMessage($content), $code, NULL, $response);

                case Http\Response::S403_FORBIDDEN:
                    if ($response->getHeader('X-RateLimit-Remaining') === '0') {
                        throw new RateLimitExceedException(self::errorMessage($content), $code, NULL, $response);
                    }
                    throw new ForbiddenException(self::errorMessage($content), $code, NULL, $response);

                case Http\Response::S404_NOT_FOUND:
                    throw new NotFoundException('Resource not found or not authorized to access.', $code, NULL, $response);

                case Http\Response::S422_UNPROCESSABLE_ENTITY:
                    throw new UnprocessableEntityException(self::errorMessage($content), $code, NULL, $response);
            }

            $message = $okCodes === NULL ? '< 300' : \implode(' or ', $okCodes);
            throw new UnexpectedResponseException("Expected response with code $message.", $code, NULL, $response);
        }

        return $content;
    }


    /**
     * Creates paginator for HTTP GET requests.
     *
     * @see get()
     *
     * @param  string
     * @param array $parameters
     * @param array $headers
     * @return Paginator
     *
     */
    public function paginator($urlPath, array $parameters = [], array $headers = [])
    {
        return new Paginator(
            $this,
            $this->createRequest(Http\Request::GET, $urlPath, $parameters, $headers)
        );
    }


    /**
     * @return Http\IClient
     */
    public function getClient()
    {
        return $this->client;
    }


    /**
     * @param  string
     * @return Api
     */
    public function withUrl($url)
    {
        $api = clone $this;
        $api->setUrl($url);
        return $api;
    }


    /**
     * @param  string
     * @return self
     */
    public function setUrl($url)
    {
        $this->url = $url;
        return $this;
    }


    /**
     * @return string
     */
    public function getUrl()
    {
        return $this->url;
    }


    /**
     * @param  string
     * @param array $parameters
     * @param array $defaultParameters
     * @return string
     *
     */
    protected function expandColonParameters($url, array $parameters, array $defaultParameters)
    {
        $parameters += $defaultParameters;

        $url = preg_replace_callback('#(^|/|\.):([^/.]+)#', function($m) use ($url, & $parameters) {
            if (!isset($parameters[$m[2]])) {
                throw new MissingParameterException("Missing parameter '$m[2]' for URL path '$url'.");
            }
            $parameter = $parameters[$m[2]];
            unset($parameters[$m[2]]);
            return $m[1] . rawurlencode($parameter);
        }, $url);

        $url = \rtrim($url, '/');

        if (\count($parameters)) {
            $url .= '?' . \http_build_query($parameters);
        }

        return $url;
    }


    /**
     * Expands URI template (RFC 6570).
     *
     * @see http://tools.ietf.org/html/rfc6570
     * @todo Inject remaining default parameters into query string?
     *
     * @param  string
     * @param array $parameters
     * @param array $defaultParameters
     * @return string
     */
    protected function expandUriTemplate($url, array $parameters, array $defaultParameters)
    {
        $parameters += $defaultParameters;

        static $operatorFlags = [
            ''  => ['prefix' => '',  'separator' => ',', 'named' => FALSE, 'ifEmpty' => '',  'reserved' => FALSE],
            '+' => ['prefix' => '',  'separator' => ',', 'named' => FALSE, 'ifEmpty' => '',  'reserved' => TRUE],
            '#' => ['prefix' => '#', 'separator' => ',', 'named' => FALSE, 'ifEmpty' => '',  'reserved' => TRUE],
            '.' => ['prefix' => '.', 'separator' => '.', 'named' => FALSE, 'ifEmpty' => '',  'reserved' => FALSE],
            '/' => ['prefix' => '/', 'separator' => '/', 'named' => FALSE, 'ifEmpty' => '',  'reserved' => FALSE],
            ';' => ['prefix' => ';', 'separator' => ';', 'named' => TRUE,  'ifEmpty' => '',  'reserved' => FALSE],
            '?' => ['prefix' => '?', 'separator' => '&', 'named' => TRUE,  'ifEmpty' => '=', 'reserved' => FALSE],
            '&' => ['prefix' => '&', 'separator' => '&', 'named' => TRUE,  'ifEmpty' => '=', 'reserved' => FALSE],
        ];

        return preg_replace_callback('~{([+#./;?&])?([^}]+?)}~', function($m) use ($url, & $parameters, $operatorFlags) {

            $flags = $operatorFlags[$m[1]];

            $translated = [];
            foreach (\explode(',', $m[2]) as $name) {
                $explode = FALSE;
                $maxLength = NULL;
                if (\preg_match('~^(.+)(?:(\*)|:(\d+))$~', $name, $tmp)) { // TODO: Speed up?
                    $name = $tmp[1];
                    if (isset($tmp[3])) {
                        $maxLength = (int) $tmp[3];
                    } else {
                        $explode = TRUE;
                    }
                }

                if (!isset($parameters[$name])) {  // TODO: Throw exception?
                    continue;
                }

                $value = $parameters[$name];
                if (is_scalar($value)) {
                    $translated[] = $this->prefix($flags, $name, $this->escape($flags, $value, $maxLength));

                } else {
                    $value = (array) $value;
                    $isAssoc = key($value) !== 0;

                    // The '*' (explode) modifier
                    if ($explode) {
                        $parts = [];
                        if ($isAssoc) {
                            $this->walk($value, function ($v, $k) use (& $parts, $flags, $maxLength) {
                                $parts[] = $this->prefix(['named' => TRUE] + $flags, $k, $this->escape($flags, $v, $maxLength));
                            });

                        } elseif ($flags['named']) {
                            $this->walk($value, function ($v) use (& $parts, $flags, $name, $maxLength) {
                                $parts[] = $this->prefix($flags, $name, $this->escape($flags, $v, $maxLength));
                            });

                        } else {
                            $this->walk($value, function ($v) use (& $parts, $flags, $maxLength) {
                                $parts[] = $this->escape($flags, $v, $maxLength);
                            });
                        }

                        if (isset($parts[0])) {
                            if ($flags['named']) {
                                $translated[] = \implode($flags['separator'], $parts);
                            } else {
                                $translated[] = $this->prefix($flags, $name, \implode($flags['separator'], $parts));
                            }
                        }

                    } else {
                        $parts = [];
                        $this->walk($value, function($v, $k) use (& $parts, $isAssoc, $flags, $maxLength) {
                            if ($isAssoc) {
                                $parts[] = $this->escape($flags, $k);
                            }

                            $parts[] = $this->escape($flags, $v, $maxLength);
                        });

                        if (isset($parts[0])) {
                            $translated[] = $this->prefix($flags, $name, \implode(',', $parts));
                        }
                    }
                }
            }

            if (isset($translated[0])) {
                return $flags['prefix'] . \implode($flags['separator'], $translated);
            }

            return '';
        }, $url);
    }


    /**
     * @param  array
     * @param  string
     * @param  string  already escaped
filter:
    dependency_paths: ["lib/*"]
     * @return string
     */
    private function prefix(array $flags, $name, $value)
    {
        $prefix = '';
        if ($flags['named']) {
            $prefix .= $this->escape($flags, $name);
            if (isset($value[0])) {
                $prefix .= '=';
            } else {
                $prefix .= $flags['ifEmpty'];
            }
        }

        return $prefix . $value;
    }


    /**
     * @param  array
     * @param  mixed
     * @param  int|NULL
     * @return string
     */
    private function escape(array $flags, $value, $maxLength = NULL)
    {
        $value = (string) $value;

        if ($maxLength !== NULL) {
            if (\preg_match('~^(.{' . $maxLength . '}).~u', $value, $m)) {
                $value = $m[1];
            } elseif (\strlen($value) > $maxLength) {  # when malformed UTF-8
                $value = \substr($value, 0, $maxLength);
            }
        }

        if ($flags['reserved']) {
            $parts = preg_split('~(%[0-9a-fA-F]{2}|[:/?#[\]@!$&\'()*+,;=])~', $value, -1, PREG_SPLIT_DELIM_CAPTURE);
            $parts[] = '';

            $escaped = '';
            for ($i = 0, $count = \count($parts); $i < $count; $i += 2) {
                $escaped .= rawurlencode($parts[$i]) . $parts[$i + 1];
            }

            return $escaped;
        }

        return rawurlencode($value);
    }


    /**
     * @param  array
     * @param  callable
     */
    private function walk(array $array, $cb)
    {
        foreach ($array as $k => $v) {
            if ($v === NULL) {
                continue;
            }

            $cb($v, $k);
        }
    }


    /**
     * @param  \stdClass
     * @return string
     */
    private static function errorMessage($content)
    {
        $message = isset($content->message)
            ? $content->message
            : 'Unknown error';

        if (isset($content->errors)) {
            $message .= \implode(', ', array_map(function($error) {
                return '[' . \implode(':', (array) $error) . ']';
            }, $content->errors));
        }

        return $message;
    }

}

ggoffy / wggithub

Api::getDefaultParameters() A last analyzed 2025-03-21 14:15 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Api::getDefaultParameters() A
last analyzed 2025-03-21 14:15 UTC
