Client::run() - Code Metrics - LaravelRUS/GitterBot - Measure and Improve Code Quality continuously with Scrutinizer

Client::run() A
last analyzed 2016-08-19 11:41 UTC

↳ Parent: Client

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	3
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	6
rs	9.4285

<?php

/**
 * This file is part of GitterBot package.
 *
 * @author Serafim <[email protected]>
 * @author butschster <[email protected]>
 * @date 24.09.2015 00:00
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Interfaces\Slack;

use Domains\Bot\ClientInterface;
use Domains\Message;
use Domains\Middleware\Storage;
use Domains\Room\RoomInterface;
use Domains\User;

/**
 * Class Client
 */
class Client implements ClientInterface
{
    /**
     * @var string
     */
    protected $token;

    /**
     * @var \React\EventLoop\ExtEventLoop|\React\EventLoop\LibEventLoop|\React\EventLoop\LibEvLoop|\React\EventLoop\StreamSelectLoop
     */
    protected $loop;

    /**
     * @var \Slack\RealTimeClient
     */
    protected $client;

    /**
     * @var TextParser
     */
    protected $parser;

    /**
     * Client constructor.
     *
     * @param string $token
     */
    public function __construct($token)
    {
        $this->token = $token;
        $this->loop = \React\EventLoop\Factory::create();
        $this->client = new \Slack\RealTimeClient($this->loop);

        $this->client->setToken($token);
        $this->parser = new TextParser('');

    }

    /**
     * @param RoomInterface $room
     * @param string        $message
     *
     * @return void
     */
    public function sendMessage(RoomInterface $room, $message)
    {
        $this->client->getChannelById($room->id())->then(function (\Slack\Channel $channel) use($message) {
            $this->client->apiCall('chat.postMessage', [
                'text' => (string) $this->parser->parse($message),
                'channel' => $channel->getId(),
                'as_user' => true,
            ]);
        });
    }

    /**
     * @param RoomInterface $room
     *
     * @return void
     */
    public function listen(RoomInterface $room)
    {
        $this->client->on('message', function (\Slack\Payload $msg) use($room) {
            if ($msg->getData()['channel'] != $room->id()) {
                return;
            }

            $this->onMessage(
                $room->middleware(),
                Message::unguarded(function() use($room, $msg) {
                    return new Message(

                        (new MessageMapper($room, $msg->getData()))->toArray(),
                        $room
                    );
                })
            );
        });

        $this->client->on('reaction_added', function (\Slack\Payload $payload) use($room) {
            if ($payload->getData()['item']['type'] != 'message' and $payload->getData()['item']['channel'] != $room->id()) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
                return;
            }

            $this->onMessage(
                $room->middleware(),
                Message::unguarded(function() use($room, $payload) {
                    $message = $payload->getData();
                    $message['mentions'] = [$message['item_user']];
                    $message['text'] = 'Спасибо';

                    return new Message(

                        (new MessageMapper($room, $message))->toArray(),
                        $room
                    );
                })
            );
        });

        $this->client->connect();
    }


    /**
     * @param Storage $middleware
     * @param Message $message
     */
    public function onMessage(Storage $middleware, Message $message)
    {
        try {
            $middleware->handle($message);
        } catch (\Exception $e) {
            $this->logException($e);
        }
    }

    protected function onClose()
    {
        $this->client->disconnect();
    }

    /**
     * @param \Exception $e
     */
    protected function onError(\Exception $e)
    {
        $this->logException($e);
    }
    /**
     * @return string
     */
    public function version()
    {
        return 'SlackBot v0.1b';
    }

    /**
     * @return ClientInterface
     */
    public function run(): ClientInterface
    {
        $this->loop->run();

        return $this;
    }

    /**
     * @param \Exception $e
     */
    protected function logException(\Exception $e)

    {
        \Log::error(
            $e->getMessage() . ' in ' . $e->getFile() . ':' . $e->getLine() . "\n" .
            $e->getTraceAsString() . "\n" .
            str_repeat('=', 80) . "\n"
        );
    }

    /**
     * @param string $id
     *
     * @return User
     */
    public function getUserById($id)
    {
        $user = null;

        $this->client->getUserById($id)->then(function(\Slack\User $slackUser) use(&$user) {
            $user = UserMapper::fromSlackObject(
                $slackUser
            );
        });

        return $user;
    }
}

LaravelRUS / GitterBot

Client::run() A last analyzed 2016-08-19 11:41 UTC

Complexity

Size

Duplication

Importance

Logical Operators are used for Control-Flow

Duplication Side-by-Side

Filter issues like

Client::run() A
last analyzed 2016-08-19 11:41 UTC