ListenerResolver::resolveListeners() - Code Metrics - Inspection of "Merge pull request #23 from SergiX44/master" - badfarm/zanzara - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — develop ( c9c887...c18356 )

by Michele

created 2020-12-22 11:14 UTC

ListenerResolver::resolveListeners() C

↳ Parent: ListenerResolver

Complexity

Conditions	13
Paths	35

Size

Total Lines	71
Code Lines	49

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	13
eloc	49
c	0
b	0
f	0
nc	35
nop	1
dl	0
loc	71
rs	6.6166

How to fix Long Method Complexity

<?php

declare(strict_types=1);

namespace Zanzara\Listener;

use React\Promise\Deferred;
use React\Promise\PromiseInterface;
use Zanzara\ConversationManager;
use Zanzara\Telegram\Type\CallbackQuery;
use Zanzara\Telegram\Type\Message;
use Zanzara\Telegram\Type\Update;

/**
 *
 */
abstract class ListenerResolver extends ListenerCollector
{

    /**
     * @var ConversationManager
     */
    protected $conversationManager;

    /**
     * @param Update $update
     * @return PromiseInterface
     */
    public function resolveListeners(Update $update): PromiseInterface
    {
        $deferred = new Deferred();
        $listeners = [];
        $updateType = $update->getUpdateType();
        $this->mergeListenersByType($listeners, $updateType);
        $this->mergeListenersByType($listeners, Update::class);

        switch ($updateType) {

            case CallbackQuery::class:
                $callbackQuery = $update->getCallbackQuery();
                $text = $callbackQuery->getMessage() ? $callbackQuery->getMessage()->getText() : null;
                if ($text) {
                    $this->findListenerAndPush($listeners, 'cb_query_texts', $text);
                }
                if ($callbackQuery->getData()) {
                    $this->findListenerAndPush($listeners, 'cb_query_data', $callbackQuery->getData());
                }
                $chatId = $update->getEffectiveChat() ? $update->getEffectiveChat()->getId() : null;
                if ($chatId) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
                    $this->conversationManager->getConversationHandler($chatId)
                        ->then(function ($handler) use ($deferred, &$listeners) {
                            if ($handler) {
                                $listeners[] = new Listener($handler, $this->container);
                            }
                            $deferred->resolve($listeners);
                        });
                } else {
                    $deferred->resolve($listeners);
                }
                break;

            case Message::class:
                $text = $update->getMessage()->getText();
                if ($text) {
                    $chatId = $update->getEffectiveChat()->getId();
                    $this->conversationManager->getConversationHandler($chatId)
                        ->then(function ($handlerInfo) use ($chatId, $text, $deferred, &$listeners) {
                            if (!$handlerInfo) {
                                $this->findListenerAndPush($listeners, 'messages', $text);
                                $deferred->resolve($listeners);
                                return;
                            }

                            $skipListeners = $handlerInfo[1];
                            if ($skipListeners) {
                                $listeners[] = new Listener($handlerInfo[0], $this->container);
                            } else {
                                $listener = $this->findListenerAndPush($listeners, 'messages', $text);
                                if (!$listener) {
                                    $listeners[] = new Listener($handlerInfo[0], $this->container);
                                } else {
                                    $this->conversationManager->deleteConversationCache($chatId);
                                }
                            }

                            $deferred->resolve($listeners);
                        });

                } else {
                    $deferred->resolve($listeners);
                }
                break;

            default:
                $deferred->resolve($listeners);

        }

        return $deferred->promise();
    }

    /**
     * @param Listener[] $listeners
     * @param string $listenerType
     * @param string $listenerId
     * @return Listener|null
     */
    private function findListenerAndPush(array &$listeners, string $listenerType, string $listenerId): ?Listener
    {
        $typedListeners = $this->listeners[$listenerType] ?? [];
        foreach ($typedListeners as $regex => $listener) {
            if (preg_match($regex, $listenerId)) {
                $listeners[] = $listener;
                return $listener;
            }
        }
        return null;
    }

    /**
     * @param Listener[] $listeners
     * @param string $listenerType
     */
    private function mergeListenersByType(array &$listeners, string $listenerType)
    {
        $toMerge = $this->listeners[$listenerType] ?? null;
        if ($toMerge) {
            $listeners = array_merge($listeners, $toMerge);
        }
    }

}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Zanzara\Listener;
6
7			use React\Promise\Deferred;
8			use React\Promise\PromiseInterface;
9			use Zanzara\ConversationManager;
10			use Zanzara\Telegram\Type\CallbackQuery;
11			use Zanzara\Telegram\Type\Message;
12			use Zanzara\Telegram\Type\Update;
13
14			/**
15			*
16			*/
17			abstract class ListenerResolver extends ListenerCollector
18			{
19
20			/**
21			* @var ConversationManager
22			*/
23			protected $conversationManager;
24
25			/**
26			* @param Update $update
27			* @return PromiseInterface
28			*/
29			public function resolveListeners(Update $update): PromiseInterface
30			{
31			$deferred = new Deferred();
32			$listeners = [];
33			$updateType = $update->getUpdateType();
34			$this->mergeListenersByType($listeners, $updateType);
35			$this->mergeListenersByType($listeners, Update::class);
36
37			switch ($updateType) {
38
39			case CallbackQuery::class:
40			$callbackQuery = $update->getCallbackQuery();
41			$text = $callbackQuery->getMessage() ? $callbackQuery->getMessage()->getText() : null;
42			if ($text) {
43			$this->findListenerAndPush($listeners, 'cb_query_texts', $text);
44			}
45			if ($callbackQuery->getData()) {
46			$this->findListenerAndPush($listeners, 'cb_query_data', $callbackQuery->getData());
47			}
48			$chatId = $update->getEffectiveChat() ? $update->getEffectiveChat()->getId() : null;
49			if ($chatId) {
			0 ignored issues – show Bug Best Practice introduced 2020-12-20 00:30 UTC by Report Bug Copy Issue Report The expression `$chatId` of type `integer\|null` is loosely compared to `true`; this is ambiguous if the integer can be 0. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
50			$this->conversationManager->getConversationHandler($chatId)
51			->then(function ($handler) use ($deferred, &$listeners) {
52			if ($handler) {
53			$listeners[] = new Listener($handler, $this->container);
54			}
55			$deferred->resolve($listeners);
56			});
57			} else {
58			$deferred->resolve($listeners);
59			}
60			break;
61
62			case Message::class:
63			$text = $update->getMessage()->getText();
64			if ($text) {
65			$chatId = $update->getEffectiveChat()->getId();
66			$this->conversationManager->getConversationHandler($chatId)
67			->then(function ($handlerInfo) use ($chatId, $text, $deferred, &$listeners) {
68			if (!$handlerInfo) {
69			$this->findListenerAndPush($listeners, 'messages', $text);
70			$deferred->resolve($listeners);
71			return;
72			}
73
74			$skipListeners = $handlerInfo[1];
75			if ($skipListeners) {
76			$listeners[] = new Listener($handlerInfo[0], $this->container);
77			} else {
78			$listener = $this->findListenerAndPush($listeners, 'messages', $text);
79			if (!$listener) {
80			$listeners[] = new Listener($handlerInfo[0], $this->container);
81			} else {
82			$this->conversationManager->deleteConversationCache($chatId);
83			}
84			}
85
86			$deferred->resolve($listeners);
87			});
88
89			} else {
90			$deferred->resolve($listeners);
91			}
92			break;
93
94			default:
95			$deferred->resolve($listeners);
96
97			}
98
99			return $deferred->promise();
100			}
101
102			/**
103			* @param Listener[] $listeners
104			* @param string $listenerType
105			* @param string $listenerId
106			* @return Listener\|null
107			*/
108			private function findListenerAndPush(array &$listeners, string $listenerType, string $listenerId): ?Listener
109			{
110			$typedListeners = $this->listeners[$listenerType] ?? [];
111			foreach ($typedListeners as $regex => $listener) {
112			if (preg_match($regex, $listenerId)) {
113			$listeners[] = $listener;
114			return $listener;
115			}
116			}
117			return null;
118			}
119
120			/**
121			* @param Listener[] $listeners
122			* @param string $listenerType
123			*/
124			private function mergeListenersByType(array &$listeners, string $listenerType)
125			{
126			$toMerge = $this->listeners[$listenerType] ?? null;
127			if ($toMerge) {
128			$listeners = array_merge($listeners, $toMerge);
129			}
130			}
131
132			}
133

badfarm / zanzara

Push — develop ( c9c887...c18356 )

ListenerResolver::resolveListeners() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like