ApiClients\Client\Travis\AsyncClient

Complexity

Total Complexity

14

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	17

Test Coverage

Coverage

69.44%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	create()	0	17	2
A	hydrate()	0	6	1
A	extract()	0	12	1
A	createFromClient()	0	4	1
A	repository()	0	4	1
A	repositories()	0	16	2
A	user()	0	4	1
A	sshKey()	0	4	1
A	hooks()	0	6	1
A	accounts()	0	6	1
A	broadcasts()	0	6	1

<?php declare(strict_types=1);

namespace ApiClients\Client\Travis;

use ApiClients\Client\Travis\CommandBus\Command;
use ApiClients\Client\Travis\Resource\HookInterface;
use ApiClients\Foundation\ClientInterface;

This use statement conflicts with another class in this namespace, ApiClients\Client\Travis\ClientInterface.

use ApiClients\Foundation\Factory;
use ApiClients\Foundation\Hydrator\CommandBus\Command\ExtractFQCNCommand;
use ApiClients\Foundation\Hydrator\CommandBus\Command\HydrateFQCNCommand;
use ApiClients\Foundation\Resource\ResourceInterface;
use React\EventLoop\LoopInterface;
use React\Promise\CancellablePromiseInterface;
use React\Promise\PromiseInterface;
use Rx\ObservableInterface;
use Rx\React\Promise;
use Rx\Scheduler;
use function ApiClients\Tools\Rx\unwrapObservableFromPromise;
use function React\Promise\resolve;

final class AsyncClient implements AsyncClientInterface
{
    /**
     * @var ClientInterface
     */
    private $client;

    /**
     * @param ClientInterface $client
     */
    private function __construct(ClientInterface $client)
    {
        $this->client = $client;
    }

    /**
     * Create a new AsyncClient based on the loop and other options pass.
     *
     * @param  LoopInterface $loop
     * @param  string        $token   Instructions to fetch the token: https://blog.travis-ci.com/2013-01-28-token-token-token/
     * @param  array         $options
     * @return AsyncClient
     */
    public static function create(
        LoopInterface $loop,
        string $token = '',
        array $options = []
    ): self {
        try {
            Scheduler::setAsyncFactory(function () use ($loop) {
                return new Scheduler\EventLoopScheduler($loop);

$loop is of type object<React\EventLoop\LoopInterface>, but the function expects a callable.

            });
        } catch (\Throwable $t) {

Consider adding a comment why this CATCH block is empty.

        }

        $options = ApiSettings::getOptions($token, 'Async', $options);
        $client = Factory::create($loop, $options);

        return new self($client);
    }

    public function hydrate(array $resource)
    {
        $class = $resource['class'];
        $json = $resource['json'];
        return $this->client->handle(new HydrateFQCNCommand($class, $json));
    }

    public function extract(ResourceInterface $resource)
    {
        $class = get_class($resource);
        return $this->client->handle(
            new ExtractFQCNCommand($class, $resource)
        )->then(function ($json) use ($class) {
            return resolve([
                'class' => $class,
                'json' => $json,
            ]);
        });
    }

    /**
     * Create an AsyncClient from a ApiClients\Foundation\ClientInterface.
     * Be sure to pass in a client with the options from ApiSettings and the Async namespace suffix.
     *
     * @param  ClientInterface $client
     * @return AsyncClient
     */
    public static function createFromClient(ClientInterface $client): self
    {
        return new self($client);
    }

    /**
     * {@inheritdoc}
     */
    public function repository(string $repository): CancellablePromiseInterface
    {
        return $this->client->handle(new Command\RepositoryCommand($repository));
    }

    /**
     * Warning this a intensive operation as it has to make a call for each hook
     * to turn it into a Repository!!!
     *
     * Take a look at examples/repositories-async.php on how to limit the amount of
     * concurrent requests.
     *
     * {@inheritdoc}
     */
    public function repositories(callable $filter = null): ObservableInterface
    {
        if ($filter === null) {
            $filter = function () {
                return true;
            };
        }

        return $this->hooks()->filter(function ($hook) {
            return $hook->active();
        })->filter($filter)->flatMap(function (HookInterface $hook) {
            return Promise::toObservable($this->client->handle(
                new Command\RepositoryIdCommand($hook->id())
            ));
        });
    }

    /**
     * {@inheritdoc}
     */
    public function user(): PromiseInterface
    {
        return $this->client->handle(new Command\UserCommand());
    }

    /**
     * {@inheritdoc}
     */
    public function sshKey(int $id): PromiseInterface
    {
        return $this->client->handle(new Command\SSHKeyCommand($id));
    }

    /**
     * @return ObservableInterface
     */
    public function hooks(): ObservableInterface
    {
        return unwrapObservableFromPromise($this->client->handle(
            new Command\HooksCommand()
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function accounts(): ObservableInterface
    {
        return unwrapObservableFromPromise($this->client->handle(
            new Command\AccountsCommand()
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function broadcasts(): ObservableInterface
    {
        return unwrapObservableFromPromise($this->client->handle(
            new Command\BroadcastsCommand()
        ));
    }
}