Karma\System\Gitter\GitterSystem

Complexity

Total Complexity

15

Size/Duplication

Total Lines	157
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

0%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	2
A	getTransformer()	0	4	1
A	onRegister()	0	7	1
A	getClient()	0	4	1
A	auth()	0	12	2
A	has()	0	10	2
A	channel()	0	8	1
A	channels()	0	14	3
A	__debugInfo()	0	6	1
A	getName()	0	4	1

<?php
/**
 * This file is part of Platform package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace Karma\System\Gitter;

use Gitter\Client;
use Karma\Platform\Ast\Transformer;
use Karma\Platform\Io\AbstractSystem;
use Karma\Platform\Io\ChannelInterface;
use Karma\Platform\Io\UserInterface;
use Karma\System\Gitter\Message\Parser;
use Karma\System\Gitter\Message\Renderer;
use Psr\Log\LoggerInterface;
use React\EventLoop\LoopInterface;

/**
 * Class GitterSystem
 * @package Karma\System\Gitter
 */
class GitterSystem extends AbstractSystem
{
    /**
     * System name
     */
    private const SYSTEM_NAME = 'gitter';

    /**
     * @var Client
     */
    private $client;

    /**
     * @var UserInterface|null
     */
    private $auth;

    private $transformer;

    /**
     * GitterSystem constructor.
     * @param string $token
     * @throws \DomainException
     */
    public function __construct(string $token)
    {
        if (! class_exists(Client::class)) {
            throw new \DomainException('"serafim/gitter-api": "~4.0" required');
        }

        $this->client = new Client($token);
        $this->transformer = new Transformer(new Renderer(), new Parser());
    }

    /**
     * @return Transformer
     */
    public function getTransformer(): Transformer
    {
        return $this->transformer;
    }

    /**
     * @param LoopInterface $loop
     * @param null|LoggerInterface $logger
     */
    public function onRegister(LoopInterface $loop, ?LoggerInterface $logger): void
    {
        $this->client->loop($loop);
        $this->client->logger($logger);

        parent::onRegister($loop, $logger);
    }

    /**
     * @return Client
     */
    public function getClient(): Client
    {
        return $this->client;
    }

    /**
     * @return UserInterface
     * @throws \Exception
     * @throws \GuzzleHttp\Exception\ClientException
     * @throws \InvalidArgumentException
     * @throws \RuntimeException
     * @throws \Throwable
     */
    public function auth(): UserInterface
    {
        if ($this->auth === null) {
            $data = $this->client->authUser();

            $this->auth = $this->getUser($data['id'], function () use ($data) {
                return new GitterUser($this, $data);
            });
        }

        return $this->auth;
    }

    /**
     * @param string $channelId
     * @return bool
     */
    public function has(string $channelId): bool
    {
        try {
            $this->channel($channelId);

            return true;
        } catch (\Throwable $e) {
            return false;
        }
    }

    /**
     * @param string $channelId
     * @return ChannelInterface
     * @throws \Throwable
     * @throws \RuntimeException
     * @throws \GuzzleHttp\Exception\ClientException
     * @throws \Exception
     * @throws \InvalidArgumentException
     */
    public function channel(string $channelId): ChannelInterface
    {
        return $this->getChannel($channelId, function () use ($channelId): ChannelInterface {
            $data = $this->client->rooms->join($channelId);

            return new GitterChannel($this, $data);
        });
    }

    /**
     * @return \Traversable|ChannelInterface[]|GitterChannel[]
     * @throws \Exception
     * @throws \GuzzleHttp\Exception\ClientException
     * @throws \InvalidArgumentException
     * @throws \RuntimeException
     * @throws \Throwable
     */
    public function channels(): \Traversable
    {
        foreach ($this->client->rooms->all() as $room) {
            $channel = new GitterChannel($this, $room);

            $this->push(ChannelInterface::class, $channel->getId(), $channel);
        }

        $channels = $this->identities(ChannelInterface::class);

        foreach ($channels as $channel) {
            yield $channel;
        }
    }

    /**
     * @return array
     */
    public function __debugInfo(): array
    {
        return [
            'name' => $this->getName(),
        ];
    }

    /**
     * @return string
     */
    public function getName(): string
    {
        return self::SYSTEM_NAME;
    }
}