ApiClients\Client\Twitter\StreamingClient

Complexity

Total Complexity

6

Size/Duplication

Total Lines	78
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

0%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	loopUpHydrateClassConstant()	0	9	2
A	__construct()	0	9	1
A	sample()	0	4	1
A	filtered()	0	4	1
A	stream()	0	19	1

<?php declare(strict_types=1);

namespace ApiClients\Client\Twitter;

use ApiClients\Foundation\Hydrator\CommandBus\Command\BuildSyncFromAsyncCommand;
use ApiClients\Foundation\Resource\ResourceInterface;
use ApiClients\Tools\CommandBus\CommandBusInterface;
use React\EventLoop\LoopInterface;
use ReflectionObject;
use Rx\ObservableInterface;
use Rx\React\Promise;

final class StreamingClient implements StreamingClientInterface
{
    /**
     * @var LoopInterface
     */
    protected $loop;

    /**
     * @var CommandBusInterface
     */
    protected $commandBus;

    /**
     * @var AsyncStreamingClientInterface
     */
    protected $client;

    /**
     * @var array
     */
    protected $hydrateClassConstantCache = [];

The variable name $hydrateClassConstantCache exceeds the maximum configured length of 20.

    /**
     * StreamingClient constructor.
     * @param LoopInterface $loop
     * @param CommandBusInterface $commandBus
     * @param AsyncStreamingClientInterface $client
     */
    public function __construct(
        LoopInterface $loop,
        CommandBusInterface $commandBus,
        AsyncStreamingClientInterface $client
    ) {
        $this->loop = $loop;
        $this->commandBus = $commandBus;
        $this->client = $client;
    }

    public function sample(callable $listener)
    {
        $this->stream($this->client->sample(), $listener);
    }

    public function filtered(callable $listener, array $filter = [])
    {
        $this->stream($this->client->filtered($filter), $listener);
    }

    protected function stream(ObservableInterface $observable, callable $listener)
    {
        $observable->flatMap(function (ResourceInterface $resource) {
            return Promise::toObservable(
                $this->commandBus->handle(
                    new BuildSyncFromAsyncCommand(
                        $this->loopUpHydrateClassConstant($resource),
                        $resource
                    )
                )
            );
        })->subscribeCallback(
            $listener,
            function ($error) {
                throw $error;
            }
        );
        $this->loop->run();
    }

    protected function loopUpHydrateClassConstant(ResourceInterface $resource)
    {
        $class = get_class($resource);
        if (!isset($this->hydrateClassConstantCache[$class])) {
            $this->hydrateClassConstantCache[$class] = (new ReflectionObject($resource))->getConstant('HYDRATE_CLASS');
        }

        return $this->hydrateClassConstantCache[$class];
    }
}