AbstractConnection::onMessage() - Code Metrics - Inspection of "Woketo Client" - Nekland/Woketo - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#100)

by Maxime

created 2017-06-05 18:18 UTC

AbstractConnection::onMessage() A

↳ Parent: AbstractConnection

Complexity

Conditions	3
Paths	4

Size

Total Lines	16
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes

Metric	Value
dl	0
loc	16
ccs	0
cts	15
cp	0
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	11
nc	4
nop	1
crap	12

<?php

/**
 * This file is a part of Woketo package.
 *
 * (c) Nekland <[email protected]>
 *
 * For the full license, take a look to the LICENSE file
 * on the root directory of this project
 */

namespace Nekland\Woketo\Core;

use Nekland\Woketo\Exception\NoHandlerException;
use Nekland\Woketo\Exception\WebsocketException;
use Nekland\Woketo\Message\MessageHandlerInterface;
use Nekland\Woketo\Rfc6455\Handshake\HandshakeInterface;
use Nekland\Woketo\Rfc6455\Message;
use Nekland\Woketo\Rfc6455\MessageProcessor;
use Psr\Log\LoggerAwareTrait;
use React\EventLoop\LoopInterface;
use React\EventLoop\Timer\TimerInterface;
use React\Socket\Connection;

abstract class AbstractConnection
{
    /**
     * 5 seconds
     */
    const DEFAULT_TIMEOUT = 5;

    use LoggerAwareTrait;

    /**
     * @var Connection
     */
    protected $stream;

    /**
     * @var MessageProcessor
     */
    protected $messageProcessor;

    /**
     * @var \Nekland\Woketo\Rfc6455\Handshake\ServerHandshake|\Nekland\Woketo\Rfc6455\Handshake\ClientHandshake
     */
    protected $handshake;

    /**
     * @var bool
     */
    protected $handshakeDone;

    /**
     * @var string
     */
    protected $uri;

    /**
     * @var MessageHandlerInterface|\Closure
     */
    protected $handler;

    /**
     * @var TimerInterface
     */
    protected $timeout;

    /**
     * @var Message
     */
    protected $currentMessage;

    /**
     * @var LoopInterface
     */
    protected $loop;

    public function __construct(MessageProcessor $messageProcessor, HandshakeInterface $handshake = null)
    {
        $this->handshake = $handshake;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
        $this->messageProcessor = $messageProcessor;
    }

    protected function onMessage(string $data)
    {
        try {
            if (!$this->handshakeDone) {
                $this->processHandshake($data);
            } else {
                $this->processMessage($data);
            }

            return;
        } catch (WebsocketException $e) {
            $this->messageProcessor->close($this->stream);
            $this->logger->notice('Connection to ' . $this->getIp() . ' closed with error : ' . $e->getMessage());
            $this->handler->onError($e, $this);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        }
    }

    protected abstract function processHandshake(string $data);

    protected abstract function processMessage(string $data);


    /**
     * @return string
     */
    public abstract function getIp();


    /**
     * @return \Psr\Log\LoggerInterface
     */
    public function getLogger()
    {
        return $this->logger;
    }

    /**
     * @return MessageHandlerInterface
     * @throws NoHandlerException
     */
    protected function getHandler() : MessageHandlerInterface
    {
        if ($this->handler instanceof \Closure) {
            $handler = $this->handler;
            $handler = $handler($this->uri, $this);

            if (null === $handler) {
                throw new NoHandlerException(sprintf('No handler for request URI %s.', $this->uri));
            }

            $this->handler = $handler;
        }

        return $this->handler;
    }
}


1			<?php
2
3			/**
4			* This file is a part of Woketo package.
5			*
6			* (c) Nekland <[email protected]>
7			*
8			* For the full license, take a look to the LICENSE file
9			* on the root directory of this project
10			*/
11
12			namespace Nekland\Woketo\Core;
13
14			use Nekland\Woketo\Exception\NoHandlerException;
15			use Nekland\Woketo\Exception\WebsocketException;
16			use Nekland\Woketo\Message\MessageHandlerInterface;
17			use Nekland\Woketo\Rfc6455\Handshake\HandshakeInterface;
18			use Nekland\Woketo\Rfc6455\Message;
19			use Nekland\Woketo\Rfc6455\MessageProcessor;
20			use Psr\Log\LoggerAwareTrait;
21			use React\EventLoop\LoopInterface;
22			use React\EventLoop\Timer\TimerInterface;
23			use React\Socket\Connection;
24
25			abstract class AbstractConnection
26			{
27			/**
28			* 5 seconds
29			*/
30			const DEFAULT_TIMEOUT = 5;
31
32			use LoggerAwareTrait;
33
34			/**
35			* @var Connection
36			*/
37			protected $stream;
38
39			/**
40			* @var MessageProcessor
41			*/
42			protected $messageProcessor;
43
44			/**
45			* @var \Nekland\Woketo\Rfc6455\Handshake\ServerHandshake\|\Nekland\Woketo\Rfc6455\Handshake\ClientHandshake
46			*/
47			protected $handshake;
48
49			/**
50			* @var bool
51			*/
52			protected $handshakeDone;
53
54			/**
55			* @var string
56			*/
57			protected $uri;
58
59			/**
60			* @var MessageHandlerInterface\|\Closure
61			*/
62			protected $handler;
63
64			/**
65			* @var TimerInterface
66			*/
67			protected $timeout;
68
69			/**
70			* @var Message
71			*/
72			protected $currentMessage;
73
74			/**
75			* @var LoopInterface
76			*/
77			protected $loop;
78
79			public function __construct(MessageProcessor $messageProcessor, HandshakeInterface $handshake = null)
80			{
81			$this->handshake = $handshake;
			0 ignored issues – show Documentation Bug introduced 2017-02-19 18:54 UTC by Report Bug Copy Issue Report It seems like `$handshake` can also be of type `object<Nekland\Woketo\Rf...ake\HandshakeInterface>`. However, the property `$handshake` is declared as type `object<Nekland\Woketo\Rf...dshake\ClientHandshake>`. Maybe add an additional type check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly. For example, imagine you have a variable `$accountId` that can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to the `id` property of an instance of the `Account` class. This class holds a proper account, so the id value must no longer be false. Either this assignment is in error or a type check should be added for that assignment. class Id { public $id; public function __construct($id) { $this->id = $id; } } class Account { /** @var Id $id */ public $id; } $account_id = false; if (starsAreRight()) { $account_id = new Id(42); } $account = new Account(); if ($account instanceof Id) { $account->id = $account_id; } Loading history...
82			$this->messageProcessor = $messageProcessor;
83			}
84
85			protected function onMessage(string $data)
86			{
87			try {
88			if (!$this->handshakeDone) {
89			$this->processHandshake($data);
90			} else {
91			$this->processMessage($data);
92			}
93
94			return;
95			} catch (WebsocketException $e) {
96			$this->messageProcessor->close($this->stream);
97			$this->logger->notice('Connection to ' . $this->getIp() . ' closed with error : ' . $e->getMessage());
98			$this->handler->onError($e, $this);
			0 ignored issues – show Bug introduced 2017-02-06 21:29 UTC by Report Bug Copy Issue Report The method `onError` does only exist in `Nekland\Woketo\Message\MessageHandlerInterface`, but not in `Closure`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
99			}
100			}
101
102			protected abstract function processHandshake(string $data);
			0 ignored issues – show Coding Style introduced 2017-01-06 22:26 UTC by Report Bug Copy Issue Report The abstract declaration must precede the visibility declaration Loading history...
103			protected abstract function processMessage(string $data);
			0 ignored issues – show Coding Style introduced 2017-01-06 22:26 UTC by Report Bug Copy Issue Report The abstract declaration must precede the visibility declaration Loading history...
104
105			/**
106			* @return string
107			*/
108			public abstract function getIp();
			0 ignored issues – show Coding Style introduced 2017-06-05 18:20 UTC by Report Bug Copy Issue Report The abstract declaration must precede the visibility declaration Loading history...
109
110			/**
111			* @return \Psr\Log\LoggerInterface
112			*/
113			public function getLogger()
114			{
115			return $this->logger;
116			}
117
118			/**
119			* @return MessageHandlerInterface
120			* @throws NoHandlerException
121			*/
122			protected function getHandler() : MessageHandlerInterface
123			{
124			if ($this->handler instanceof \Closure) {
125			$handler = $this->handler;
126			$handler = $handler($this->uri, $this);
127
128			if (null === $handler) {
129			throw new NoHandlerException(sprintf('No handler for request URI %s.', $this->uri));
130			}
131
132			$this->handler = $handler;
133			}
134
135			return $this->handler;
136			}
137			}
138

Nekland / Woketo

Pull Request — master (#100)

AbstractConnection::onMessage() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like