RoomUtility::validateRoom() - Code Metrics - mshamaseen/laravel-ratchet - Measure and Improve Code Quality continuously with Scrutinizer

RoomUtility::validateRoom() A
last analyzed 2020-02-06 23:00 UTC

↳ Parent: RoomUtility

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	11
rs	9.9
c	0
b	0
f	0
cc	3
nc	3
nop	2

<?php
/**
 * Created by PhpStorm.
 * User: shanmaseen
 * Date: 26/03/19
 * Time: 12:09 م
 */

namespace Shamaseen\Laravel\Ratchet\Traits;

use Shamaseen\Laravel\Ratchet\Objects\Clients\Client;
use Shamaseen\Laravel\Ratchet\Objects\Rooms\Room;

/**
 * ###### Use this trait ONLY in classes extend WebSocketController ######
 * Trait RoomUtility
 * @package Shamaseen\Laravel\Ratchet\Traits
 * @property-read $receiver
 * @property $clients
 * @property $userAuthSocketMapper
 * @property $request
 * @property $conn
 * @property $rooms
 */
trait RoomUtility
{

    function createRoom($room_id)

    {
        $this->receiver->rooms[$room_id] = new \Shamaseen\Laravel\Ratchet\Objects\Rooms\Room($room_id);
class MyClass { }

$x = new MyClass();
$x->foo = true;
        return $this;
    }

    function addMember($room_id)

    {
        /** @var Room $room */
        $room = $this->receiver->rooms[$room_id];
        /** @var Client $client */
        $client = $this->receiver->clients[$this->userAuthSocketMapper[\Auth::id()]];
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $room->addMember($client);
        array_push($client->rooms, $room_id);

        return $this;
    }

    /**
     * This function will automatically remove the room if no member still on it.
     * @param $room_id
     * @return RoomUtility

     */
    function removeMember($room_id)

    {
        /** @var Room $room */
        $room = $this->receiver->rooms[$room_id];
        /** @var Client $client */
        $client = $this->receiver->clients[$this->userAuthSocketMapper[\Auth::id()]];
        $room->removeMember($client);

        unset($client->rooms[$room_id]);
        if (count($room->members) == 0) {
            unset($this->receiver->rooms[$room_id]);
        }

        return $this;
    }

    /**
     * @param int $room_id
     * @param int $user_id
     * @return bool
     */
    function hasMember($room_id, $user_id)

    {
        /** @var Room $room */
        $room = $this->receiver->rooms[$room_id];
        $client = $this->clients[$this->userAuthSocketMapper[$user_id]];
class MyClass { }

$x = new MyClass();
$x->foo = true;
        return $room->hasMember($client);
    }

    /**
     * @param $room_id
     * @param bool $createIfNotExist
     * @return bool|Room
     */
    function validateRoom($room_id, $createIfNotExist = false)

    {
        if (!array_key_exists($room_id, $this->receiver->rooms)) {
            if ($createIfNotExist) {
                $room = $this->receiver->rooms[$room_id] = new Room($room_id);
                return $room;
            }
            $this->error($this->request, $this->conn, 'Room is not exist');
class MyClass { }

$x = new MyClass();
$x->foo = true;
        }
        return true;
    }

    /**
     * @param $room_id
     * @param $message
     */
    function sendToRoom($room_id, $message)

    {
        $this->validateRoom($room_id);
        /** @var Room $room */
        $room = $this->rooms[$room_id];
class MyClass { }

$x = new MyClass();
$x->foo = true;

        if (!$this->hasMember($room_id, \Auth::id())) {
            $this->error($this->request, $this->conn, 'You can\'t send a message to room which you are not in !');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

        foreach ($room->members as $member) {
            $this->sendToUser($member->id, $message);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }
    }
}


1			<?php
2			/**
3			* Created by PhpStorm.
4			* User: shanmaseen
5			* Date: 26/03/19
6			* Time: 12:09 م
7			*/
8
9			namespace Shamaseen\Laravel\Ratchet\Traits;
10
11			use Shamaseen\Laravel\Ratchet\Objects\Clients\Client;
12			use Shamaseen\Laravel\Ratchet\Objects\Rooms\Room;
13
14			/**
15			* ###### Use this trait ONLY in classes extend WebSocketController ######
16			* Trait RoomUtility
17			* @package Shamaseen\Laravel\Ratchet\Traits
18			* @property-read $receiver
19			* @property $clients
20			* @property $userAuthSocketMapper
21			* @property $request
22			* @property $conn
23			* @property $rooms
24			*/
25			trait RoomUtility
26			{
27
28			function createRoom($room_id)
			0 ignored issues – show Best Practice introduced 2019-11-18 02:15 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
29			{
30			$this->receiver->rooms[$room_id] = new \Shamaseen\Laravel\Ratchet\Objects\Rooms\Room($room_id);
			0 ignored issues – show Bug introduced 2019-11-18 02:15 UTC by Report Bug Copy Issue Report The property `receiver` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
31			return $this;
32			}
33
34			function addMember($room_id)
			0 ignored issues – show Best Practice introduced 2019-03-26 13:40 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
35			{
36			/** @var Room $room */
37			$room = $this->receiver->rooms[$room_id];
38			/** @var Client $client */
39			$client = $this->receiver->clients[$this->userAuthSocketMapper[\Auth::id()]];
			0 ignored issues – show Bug introduced 2019-03-26 13:40 UTC by Report Bug Copy Issue Report The property `userAuthSocketMapper` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
40			$room->addMember($client);
41			array_push($client->rooms, $room_id);
42
43			return $this;
44			}
45
46			/**
47			* This function will automatically remove the room if no member still on it.
48			* @param $room_id
49			* @return RoomUtility
			0 ignored issues – show Comprehensibility Bug introduced 2019-11-18 02:15 UTC by Report Bug Copy Issue Report The return type `RoomUtility` is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting? In PHP traits cannot be used for type-hinting as they do not define a well-defined structure. This is because any class that uses a trait can rename that trait’s methods. If you would like to return an object that has a guaranteed set of methods, you could create a companion interface that lists these methods explicitly. Loading history...
50			*/
51			function removeMember($room_id)
			0 ignored issues – show Best Practice introduced 2019-03-26 13:40 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
52			{
53			/** @var Room $room */
54			$room = $this->receiver->rooms[$room_id];
55			/** @var Client $client */
56			$client = $this->receiver->clients[$this->userAuthSocketMapper[\Auth::id()]];
57			$room->removeMember($client);
58
59			unset($client->rooms[$room_id]);
60			if (count($room->members) == 0) {
61			unset($this->receiver->rooms[$room_id]);
62			}
63
64			return $this;
65			}
66
67			/**
68			* @param int $room_id
69			* @param int $user_id
70			* @return bool
71			*/
72			function hasMember($room_id, $user_id)
			0 ignored issues – show Best Practice introduced 2019-03-27 09:41 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
73			{
74			/** @var Room $room */
75			$room = $this->receiver->rooms[$room_id];
76			$client = $this->clients[$this->userAuthSocketMapper[$user_id]];
			0 ignored issues – show Bug introduced 2019-03-26 13:40 UTC by Report Bug Copy Issue Report The property `clients` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
77			return $room->hasMember($client);
78			}
79
80			/**
81			* @param $room_id
82			* @param bool $createIfNotExist
83			* @return bool\|Room
84			*/
85			function validateRoom($room_id, $createIfNotExist = false)
			0 ignored issues – show Best Practice introduced 2019-03-26 13:40 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
86			{
87			if (!array_key_exists($room_id, $this->receiver->rooms)) {
88			if ($createIfNotExist) {
89			$room = $this->receiver->rooms[$room_id] = new Room($room_id);
90			return $room;
91			}
92			$this->error($this->request, $this->conn, 'Room is not exist');
			0 ignored issues – show Bug introduced 2019-03-26 13:40 UTC by Report Bug Copy Issue Report The property `request` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history... Bug introduced 2019-03-26 13:40 UTC by Report Bug Copy Issue Report The property `conn` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history... Bug introduced 2019-03-26 13:40 UTC by Report Bug Copy Issue Report It seems like `error()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
93			}
94			return true;
95			}
96
97			/**
98			* @param $room_id
99			* @param $message
100			*/
101			function sendToRoom($room_id, $message)
			0 ignored issues – show Best Practice introduced 2019-03-26 13:40 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
102			{
103			$this->validateRoom($room_id);
104			/** @var Room $room */
105			$room = $this->rooms[$room_id];
			0 ignored issues – show Bug introduced 2019-03-27 09:41 UTC by Report Bug Copy Issue Report The property `rooms` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
106
107			if (!$this->hasMember($room_id, \Auth::id())) {
108			$this->error($this->request, $this->conn, 'You can\'t send a message to room which you are not in !');
			0 ignored issues – show Bug introduced 2019-03-26 13:40 UTC by Report Bug Copy Issue Report It seems like `error()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
109			}
110
111			foreach ($room->members as $member) {
112			$this->sendToUser($member->id, $message);
			0 ignored issues – show Bug introduced 2019-03-26 13:40 UTC by Report Bug Copy Issue Report It seems like `sendToUser()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
113			}
114			}
115			}
116

mshamaseen / laravel-ratchet

RoomUtility::validateRoom() A last analyzed 2020-02-06 23:00 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

RoomUtility::validateRoom() A
last analyzed 2020-02-06 23:00 UTC