OpenStack\Common\Api\OperatorTrait

Complexity

Total Complexity

16

Size/Duplication

Total Lines	139
Duplicated Lines	10.79 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	__debugInfo()	0	14	3
B	__call()	0	24	3
A	getOperation()	0	4	1
A	sendRequest()	0	10	2
A	execute()	0	4	1
A	executeAsync()	0	4	1
A	model()	15	15	4

<?php declare(strict_types=1);

namespace OpenStack\Common\Api;

use GuzzleHttp\Promise\PromiseInterface;
use GuzzleHttp\Psr7\Uri;
use function GuzzleHttp\uri_template;
use GuzzleHttp\ClientInterface;
use GuzzleHttp\Promise\Promise;
use OpenStack\Common\Resource\ResourceInterface;
use OpenStack\Common\Transport\RequestSerializer;
use Psr\Http\Message\ResponseInterface;

trait OperatorTrait
{
    /** @var ClientInterface */
    protected $client;

    /** @var ApiInterface */
    protected $api;

    /**
     * {@inheritDoc}
     */
    public function __construct(ClientInterface $client, ApiInterface $api)
    {
        $this->client = $client;
        $this->api = $api;
    }

    /**
     * Magic method for dictating how objects are rendered when var_dump is called.
     * For the benefit of users, extremely verbose and heavy properties (such as HTTP clients) are
     * removed to provide easier access to normal state, such as resource attributes.
     *
     * @codeCoverageIgnore
     * @return array
     */
    public function __debugInfo()
    {
        $excludedVars = ['client', 'errorBuilder', 'api'];

        $output = [];

        foreach (get_object_vars($this) as $key => $val) {
            if (!in_array($key, $excludedVars)) {
                $output[$key] = $val;
            }
        }

        return $output;
    }

    /**
     * Magic method which intercepts async calls, finds the sequential version, and wraps it in a
     * {@see Promise} object. In order for this to happen, the called methods need to be in the
     * following format: `createAsync`, where `create` is the sequential method being wrapped.
     *
     * @param $methodName The name of the method being invoked.
     * @param $args       The arguments to be passed to the sequential method.
     *
     * @throws \RuntimeException If method does not exist
     *
     * @return Promise
     */
    public function __call($methodName, $args)
    {
        $e = function ($name) {
            return new \RuntimeException(sprintf('%s::%s is not defined', get_class($this), $name));
        };

        if (substr($methodName, -5) === 'Async') {
            $realMethod = substr($methodName, 0, -5);
            if (!method_exists($this, $realMethod)) {
                throw $e($realMethod);
            }

            $promise = new Promise(
                function () use (&$promise, $realMethod, $args) {
                    $value = call_user_func_array([$this, $realMethod], $args);
                    $promise->resolve($value);
                }
            );

            return $promise;
        }

        throw $e($methodName);
    }

    /**
     * {@inheritdoc}
     */
    public function getOperation(array $definition): Operation
    {
        return new Operation($definition);
    }

    /**
     * @param Operation $operation
     * @param array     $userValues
     * @param bool      $async
     *
     * @return mixed
     * @throws \Exception
     */
    protected function sendRequest(Operation $operation, array $userValues = [], bool $async = false)
    {
        $operation->validate($userValues);

        $options = (new RequestSerializer)->serializeOptions($operation, $userValues);
        $method = $async ? 'requestAsync' : 'request';
        $uri = uri_template($operation->getPath(), $userValues);

        return $this->client->$method($operation->getMethod(), $uri, $options);
    }

    /**
     * {@inheritDoc}
     */
    public function execute(array $definition, array $userValues = []): ResponseInterface
    {
        return $this->sendRequest($this->getOperation($definition), $userValues);
    }

    /**
     * {@inheritDoc}
     */
    public function executeAsync(array $definition, array $userValues = []): PromiseInterface
    {
        return $this->sendRequest($this->getOperation($definition), $userValues, true);
    }

    /**
     * {@inheritDoc}
     */
    public function model(string $class, $data = null): ResourceInterface

This method seems to be duplicated in your project.

    {
        $model = new $class($this->client, $this->api);
        // @codeCoverageIgnoreStart
        if (!$model instanceof ResourceInterface) {
            throw new \RuntimeException(sprintf('%s does not implement %s', $class, ResourceInterface::class));
        }
        // @codeCoverageIgnoreEnd
        if ($data instanceof ResponseInterface) {
            $model->populateFromResponse($data);
        } elseif (is_array($data)) {
            $model->populateFromArray($data);
        }
        return $model;
    }
}