Socket - Code Metrics - Inspection of "Update composer with a test command & hide the cov..." - navarr/Sockets - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e54cab...1959bf )

by Navarr

created 2016-04-22 15:33 UTC

Socket C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	510
Duplicated Lines	13.33 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

18.75%

Importance

Changes	18
Bugs	4	Features	2

Metric	Value
wmc	58
c	18
b	4
f	2
lcom	1
cbo	1
dl	68
loc	510
rs	6.3005
ccs	33
cts	176
cp	0.1875

24 Methods

Rating	Name	Duplication	Size	Complexity
A	__toString()	0	4	1
A	__construct()	0	5	1
A	__destruct()	0	5	1
A	accept()	0	10	2
A	bind()	0	10	2
A	close()	0	5	1
A	connect()	0	10	2
A	constructFromResources()	0	10	2
A	create()	0	15	2
A	createListen()	0	13	2
A	createPair()	0	19	3
A	getOption()	0	10	2
A	getPeerName()	0	10	2
A	getSockName()	0	14	3
A	importStream()	0	10	2
A	listen()	0	10	2
A	read()	10	10	2
A	receive()	10	10	2
C	select()	0	49	8
A	mapClassToRawSocket()	0	6	1
A	mapRawSocketToClass()	0	6	1
B	write()	24	24	6
B	send()	24	24	6
A	setBlocking()	0	8	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Socket often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Socket, and based on these observations, apply Extract Interface, too.

<?php

namespace Navarr\Socket;

use Navarr\Socket\Exception\SocketException;

/**
 * Class Socket.
 *
 * A simple wrapper for PHP's socket functions
 */
class Socket
{
    protected $resource = null;
    protected $domain = null;
    protected $type = null;
    protected $protocol = null;
    protected static $map = [];

    /**
     * Sets up the Socket Resource.
     *
     * @param resource $resource
     */
    protected function __construct($resource)
    {
        $this->resource = $resource;
        self::$map[(string) $resource] = $this;
    }

    /**
     * Cleans up the Socket.
     */
    public function __destruct()
    {
        $this->close();
        $this->resource = null;
    }

    /**
     * Return the resource name.
     *
     * @return string
     */
    public function __toString()
    {
        return (string) $this->resource;
    }

    /**
     * Accept a connection.
     *
     * @throws Exception\SocketException
     *
     * @return Socket
     */
    public function accept()
    {
        $return = @socket_accept($this->resource);

        if ($return === false) {
            throw new SocketException($this->resource);
        }

        return new self($return);
    }

    /**
     * @param string $address
     * @param int    $port
     *
     * @throws Exception\SocketException
     *
     * @return bool
     */
    public function bind($address, $port = 0)
    {
        $return = @socket_bind($this->resource, $address, $port);

        if ($return === false) {
            throw new SocketException($this->resource);
        }

        return true;
    }

    /**
     * Close the socket.
     *
     * @return void
     */
    public function close()
    {
        unset(self::$map[(string) $this->resource]);
        @socket_close($this->resource);
    }

    /**
     * Connect to a socket.
     *
     * @param $address
     * @param int $port
     *
     * @throws Exception\SocketException
     *
     * @return bool
     */
    public function connect($address, $port = 0)
    {
        $return = @socket_connect($this->resource, $address, $port);

        if ($return === false) {
            throw new SocketException($this->resource);
        }

        return true;
    }

    /**
     * @param array $resources
     *
     * @return Socket[]
     */
    protected static function constructFromResources(array $resources)
    {
        $sockets = [];

        foreach ($resources as $resource) {
            $sockets[] = new self($resource);
        }

        return $sockets;
    }

    /**
     * Create a socket.
     *
     * @param int $domain
     * @param int $type
     * @param int $protocol
     *
     * @throws Exception\SocketException
     *
     * @return Socket
     */
    public static function create($domain, $type, $protocol)
    {
        $return = @socket_create($domain, $type, $protocol);

        if ($return === false) {
            throw new SocketException();
        }

        $socket = new self($return);
        $socket->domain = $domain;
        $socket->type = $type;
        $socket->protocol = $protocol;

        return $socket;
    }

    /**
     * @param $port
     * @param int $backlog
     *
     * @throws Exception\SocketException
     *
     * @return Socket
     */
    public static function createListen($port, $backlog = 128)
    {
        $return = @socket_create_listen($port, $backlog);

        if ($return === false) {
            throw new SocketException();
        }

        $socket = new self($return);
        $socket->domain = AF_INET;

        return $socket;
    }

    /**
     * @param $domain
     * @param $type
     * @param $protocol
     *
     * @throws Exception\SocketException
     *
     * @return Socket[]
     */
    public static function createPair($domain, $type, $protocol)
    {
        $array = [];
        $return = @socket_create_pair($domain, $type, $protocol, $array);

        if ($return === false) {
            throw new SocketException();
        }

        $sockets = self::constructFromResources($array);

        foreach ($sockets as $socket) {
            $socket->domain = $domain;
            $socket->type = $type;
            $socket->protocol = $protocol;
        }

        return $sockets;
    }

    /**
     * @param $level
     * @param $optname
     *
     * @throws Exception\SocketException
     *
     * @return mixed
     */
    public function getOption($level, $optname)
    {
        $return = @socket_get_option($this->resource, $level, $optname);

        if ($return === false) {
            throw new SocketException($this->resource);
        }

        return $return;
    }

    /**
     * @param $address
     * @param $port
     *
     * @throws Exception\SocketException
     *
     * @return bool
     */
    public function getPeerName(&$address, &$port)
    {
        $return = @socket_getpeername($this->resource, $address, $port);

        if ($return === false) {
            throw new SocketException($this->resource);
        }

        return $return;
    }

    /**
     * @param string $address
     * @param int    $port
     *
     * @throws Exception\SocketException
     *
     * @return bool
     */
    public function getSockName(&$address, &$port)
    {
        if (!in_array($this->domain, [AF_UNIX, AF_INET, AF_INET6])) {
            return false;
        }

        $return = @socket_getsockname($this->resource, $address, $port);

        if ($return === false) {
            throw new SocketException($this->resource);
        }

        return $return;
    }

    /**
     * @param $stream
     *
     * @throws Exception\SocketException
     *
     * @return Socket
     */
    public static function importStream($stream)
    {
        $return = @socket_import_stream($stream);

        if ($return === false) {
            throw new SocketException($stream);
        }

        return new self($return);
    }

    /**
     * @param int $backlog
     *
     * @throws Exception\SocketException
     *
     * @return bool
     */
    public function listen($backlog = 0)
    {
        $return = socket_listen($this->resource, $backlog);

        if ($return === false) {
            throw new SocketException($this->resource);
        }

        return true;
    }

    /**
     * @param int $length
     * @param int $type
     *
     * @throws Exception\SocketException
     *
     * @return string
     */
    public function read($length, $type = PHP_BINARY_READ)
    {
        $return = @socket_read($this->resource, $length, $type);

        if ($return === false) {
            throw new SocketException($this->resource);
        }

        return $return;
    }

    /**
     * @param $buffer
     * @param int $length
     * @param int $flags
     *
     * @throws Exception\SocketException
     *
     * @return int
     */
    public function receive(&$buffer, $length, $flags)
    {
        $return = @socket_recv($this->resource, $buffer, $length, $flags);

        if ($return === false) {
            throw new SocketException($this->resource);
        }

        return $return;
    }

    /**
     * @param Socket[] &$read
     * @param Socket[] &$write
     * @param Socket[] &$except
     * @param int      $timeoutSeconds
     * @param int      $timeoutMilliseconds
     * @param Socket[] $read
     *
     * @throws SocketException
     *
     * @return int
     */
    public static function select(
        &$read,
        &$write,
        &$except,
        $timeoutSeconds,
        $timeoutMilliseconds = 0
    ) {
        $readSockets = null;
        $writeSockets = null;
        $exceptSockets = null;

        if (!is_null($read)) {
            $readSockets = self::mapClassToRawSocket($read);
        }
        if (!is_null($write)) {
            $writeSockets = self::mapClassToRawSocket($write);
        }
        if (!is_null($except)) {
            $exceptSockets = self::mapClassToRawSocket($except);
        }

        $return = @socket_select(
            $readSockets,
            $writeSockets,
            $exceptSockets,
            $timeoutSeconds,
            $timeoutMilliseconds
        );

        if ($return === false) {
            throw new SocketException();
        }

        $read = [];
        $write = [];
        $except = [];

        if ($readSockets) {
            $read = static::mapRawSocketToClass($readSockets);
        }
        if ($writeSockets) {
            $write = static::mapRawSocketToClass($writeSockets);
        }
        if ($exceptSockets) {
            $except = static::mapRawSocketToClass($exceptSockets);
        }

        return $return;
    }

    /**
     * Maps an array of {@see Socket}s to an array of socket resources
     *
     * @param Socket[] $sockets
     * @return resource[]
     */
    protected static function mapClassToRawSocket($sockets)
    {
        return array_map(function(Socket $socket) {
            return $socket->resource;
        }, $sockets);
    }

    /**
     * Maps an array of socket resources to an array of {@see Socket}s
     *
     * @param resource[] $sockets
     * @return Socket[]
     */
    protected static function mapRawSocketToClass($sockets)
    {
        return array_map(function($rawSocket) {
            return self::$map[(string) $rawSocket];
        }, $sockets);
    }

    /**
     * @param $buffer
     * @param int $length
     *
     * @throws Exception\SocketException
     *
     * @return int
     */
    public function write($buffer, $length = null)
    {
        if (null === $length) {
            $length = strlen($buffer);
        }

        // make sure everything is written
        do {
            $return = @socket_write($this->resource, $buffer, $length);

            if (false !== $return && $return < $length) {
                $buffer = substr($buffer, $return);
                $length -= $return;
            } else {
                break;
            }
        } while (true);

        if ($return === false) {
            throw new SocketException($this->resource);
        }

        return $return;
    }

    /**
     * Sends data to a connected socket.
     *
     * @param $buffer
     * @param int $flags
     * @param int $length
     *
     * @throws Exception\SocketException
     *
     * @return int
     */
    public function send($buffer, $flags = 0, $length = null)
    {
        if (null === $length) {
            $length = strlen($buffer);
        }

        // make sure everything is written
        do {
            $return = @socket_send($this->resource, $buffer, $length, $flags);

            if (false !== $return && $return < $length) {
                $buffer = substr($buffer, $return);
                $length -= $return;
            } else {
                break;
            }
        } while (true);

        if ($return === false) {
            throw new SocketException($this->resource);
        }

        return $return;
    }

    /**
     * Set the socket to blocking / non blocking.
     *
     * @param bool
     *
     * @return void
     */
    public function setBlocking($bool)
    {
        if ($bool) {
            @socket_set_block($this->resource);
        } else {
            @socket_set_nonblock($this->resource);
        }
    }
}


1			<?php
2
3			namespace Navarr\Socket;
4
5			use Navarr\Socket\Exception\SocketException;
6
7			/**
8			* Class Socket.
9			*
10			* A simple wrapper for PHP's socket functions
11			*/
12			class Socket
13			{
14			protected $resource = null;
15			protected $domain = null;
16			protected $type = null;
17			protected $protocol = null;
18			protected static $map = [];
19
20			/**
21			* Sets up the Socket Resource.
22			*
23			* @param resource $resource
24			*/
25	3		protected function __construct($resource)
26			{
27	3		$this->resource = $resource;
28	3		self::$map[(string) $resource] = $this;
29	3		}
30
31			/**
32			* Cleans up the Socket.
33			*/
34			public function __destruct()
35			{
36			$this->close();
37			$this->resource = null;
38			}
39
40			/**
41			* Return the resource name.
42			*
43			* @return string
44			*/
45			public function __toString()
46			{
47			return (string) $this->resource;
48			}
49
50			/**
51			* Accept a connection.
52			*
53			* @throws Exception\SocketException
54			*
55			* @return Socket
56			*/
57			public function accept()
58			{
59			$return = @socket_accept($this->resource);
60
61			if ($return === false) {
62			throw new SocketException($this->resource);
63			}
64
65			return new self($return);
66			}
67
68			/**
69			* @param string $address
70			* @param int $port
71			*
72			* @throws Exception\SocketException
73			*
74			* @return bool
75			*/
76	1		public function bind($address, $port = 0)
77			{
78	1		$return = @socket_bind($this->resource, $address, $port);
79
80	1		if ($return === false) {
81			throw new SocketException($this->resource);
82			}
83
84	1		return true;
85			}
86
87			/**
88			* Close the socket.
89			*
90			* @return void
91			*/
92			public function close()
93			{
94			unset(self::$map[(string) $this->resource]);
95			@socket_close($this->resource);
96			}
97
98			/**
99			* Connect to a socket.
100			*
101			* @param $address
102			* @param int $port
103			*
104			* @throws Exception\SocketException
105			*
106			* @return bool
107			*/
108			public function connect($address, $port = 0)
109			{
110			$return = @socket_connect($this->resource, $address, $port);
111
112			if ($return === false) {
113			throw new SocketException($this->resource);
114			}
115
116			return true;
117			}
118
119			/**
120			* @param array $resources
121			*
122			* @return Socket[]
123			*/
124			protected static function constructFromResources(array $resources)
125			{
126			$sockets = [];
127
128			foreach ($resources as $resource) {
129			$sockets[] = new self($resource);
130			}
131
132			return $sockets;
133			}
134
135			/**
136			* Create a socket.
137			*
138			* @param int $domain
139			* @param int $type
140			* @param int $protocol
141			*
142			* @throws Exception\SocketException
143			*
144			* @return Socket
145			*/
146	4		public static function create($domain, $type, $protocol)
147			{
148	4		$return = @socket_create($domain, $type, $protocol);
149
150	4		if ($return === false) {
151	1		throw new SocketException();
152			}
153
154	3		$socket = new self($return);
155	3		$socket->domain = $domain;
156	3		$socket->type = $type;
157	3		$socket->protocol = $protocol;
158
159	3		return $socket;
160			}
161
162			/**
163			* @param $port
164			* @param int $backlog
165			*
166			* @throws Exception\SocketException
167			*
168			* @return Socket
169			*/
170			public static function createListen($port, $backlog = 128)
171			{
172			$return = @socket_create_listen($port, $backlog);
173
174			if ($return === false) {
175			throw new SocketException();
176			}
177
178			$socket = new self($return);
179			$socket->domain = AF_INET;
180
181			return $socket;
182			}
183
184			/**
185			* @param $domain
186			* @param $type
187			* @param $protocol
188			*
189			* @throws Exception\SocketException
190			*
191			* @return Socket[]
192			*/
193			public static function createPair($domain, $type, $protocol)
194			{
195			$array = [];
196			$return = @socket_create_pair($domain, $type, $protocol, $array);
197
198			if ($return === false) {
199			throw new SocketException();
200			}
201
202			$sockets = self::constructFromResources($array);
203
204			foreach ($sockets as $socket) {
205			$socket->domain = $domain;
206			$socket->type = $type;
207			$socket->protocol = $protocol;
208			}
209
210			return $sockets;
211			}
212
213			/**
214			* @param $level
215			* @param $optname
216			*
217			* @throws Exception\SocketException
218			*
219			* @return mixed
220			*/
221			public function getOption($level, $optname)
222			{
223			$return = @socket_get_option($this->resource, $level, $optname);
224
225			if ($return === false) {
226			throw new SocketException($this->resource);
227			}
228
229			return $return;
230			}
231
232			/**
233			* @param $address
234			* @param $port
235			*
236			* @throws Exception\SocketException
237			*
238			* @return bool
239			*/
240			public function getPeerName(&$address, &$port)
241			{
242			$return = @socket_getpeername($this->resource, $address, $port);
243
244			if ($return === false) {
245			throw new SocketException($this->resource);
246			}
247
248			return $return;
249			}
250
251			/**
252			* @param string $address
253			* @param int $port
254			*
255			* @throws Exception\SocketException
256			*
257			* @return bool
258			*/
259	1		public function getSockName(&$address, &$port)
260			{
261	1		if (!in_array($this->domain, [AF_UNIX, AF_INET, AF_INET6])) {
262			return false;
263			}
264
265	1		$return = @socket_getsockname($this->resource, $address, $port);
266
267	1		if ($return === false) {
268			throw new SocketException($this->resource);
269			}
270
271	1		return $return;
272			}
273
274			/**
275			* @param $stream
276			*
277			* @throws Exception\SocketException
278			*
279			* @return Socket
280			*/
281			public static function importStream($stream)
282			{
283			$return = @socket_import_stream($stream);
284
285			if ($return === false) {
286			throw new SocketException($stream);
287			}
288
289			return new self($return);
290			}
291
292			/**
293			* @param int $backlog
294			*
295			* @throws Exception\SocketException
296			*
297			* @return bool
298			*/
299	1		public function listen($backlog = 0)
300			{
301	1		$return = socket_listen($this->resource, $backlog);
302
303	1		if ($return === false) {
304			throw new SocketException($this->resource);
305			}
306
307	1		return true;
308			}
309
310			/**
311			* @param int $length
312			* @param int $type
313			*
314			* @throws Exception\SocketException
315			*
316			* @return string
317			*/
318		View Code Duplication	public function read($length, $type = PHP_BINARY_READ)
319			{
320			$return = @socket_read($this->resource, $length, $type);
321
322			if ($return === false) {
323			throw new SocketException($this->resource);
324			}
325
326			return $return;
327			}
328
329			/**
330			* @param $buffer
331			* @param int $length
332			* @param int $flags
333			*
334			* @throws Exception\SocketException
335			*
336			* @return int
337			*/
338		View Code Duplication	public function receive(&$buffer, $length, $flags)
339			{
340			$return = @socket_recv($this->resource, $buffer, $length, $flags);
341
342			if ($return === false) {
343			throw new SocketException($this->resource);
344			}
345
346			return $return;
347			}
348
349			/**
350			* @param Socket[] &$read
351			* @param Socket[] &$write
352			* @param Socket[] &$except
353			* @param int $timeoutSeconds
354			* @param int $timeoutMilliseconds
355			* @param Socket[] $read
356			*
357			* @throws SocketException
358			*
359			* @return int
360			*/
361			public static function select(
362			&$read,
363			&$write,
364			&$except,
365			$timeoutSeconds,
366			$timeoutMilliseconds = 0
367			) {
368			$readSockets = null;
369			$writeSockets = null;
370			$exceptSockets = null;
371
372			if (!is_null($read)) {
373			$readSockets = self::mapClassToRawSocket($read);
374			}
375			if (!is_null($write)) {
376			$writeSockets = self::mapClassToRawSocket($write);
377			}
378			if (!is_null($except)) {
379			$exceptSockets = self::mapClassToRawSocket($except);
380			}
381
382			$return = @socket_select(
383			$readSockets,
384			$writeSockets,
385			$exceptSockets,
386			$timeoutSeconds,
387			$timeoutMilliseconds
388			);
389
390			if ($return === false) {
391			throw new SocketException();
392			}
393
394			$read = [];
395			$write = [];
396			$except = [];
397
398			if ($readSockets) {
399			$read = static::mapRawSocketToClass($readSockets);
400			}
401			if ($writeSockets) {
402			$write = static::mapRawSocketToClass($writeSockets);
403			}
404			if ($exceptSockets) {
405			$except = static::mapRawSocketToClass($exceptSockets);
406			}
407
408			return $return;
409			}
410
411			/**
412			* Maps an array of {@see Socket}s to an array of socket resources
413			*
414			* @param Socket[] $sockets
415			* @return resource[]
416			*/
417			protected static function mapClassToRawSocket($sockets)
418			{
419			return array_map(function(Socket $socket) {
420			return $socket->resource;
421			}, $sockets);
422			}
423
424			/**
425			* Maps an array of socket resources to an array of {@see Socket}s
426			*
427			* @param resource[] $sockets
428			* @return Socket[]
429			*/
430			protected static function mapRawSocketToClass($sockets)
431			{
432			return array_map(function($rawSocket) {
433			return self::$map[(string) $rawSocket];
434			}, $sockets);
435			}
436
437			/**
438			* @param $buffer
439			* @param int $length
440			*
441			* @throws Exception\SocketException
442			*
443			* @return int
444			*/
445	1	View Code Duplication	public function write($buffer, $length = null)
446			{
447	1		if (null === $length) {
448			$length = strlen($buffer);
449			}
450
451			// make sure everything is written
452			do {
453	1		$return = @socket_write($this->resource, $buffer, $length);
454
455	1		if (false !== $return && $return < $length) {
456			$buffer = substr($buffer, $return);
457			$length -= $return;
458			} else {
459	1		break;
460			}
461			} while (true);
462
463	1		if ($return === false) {
464	1		throw new SocketException($this->resource);
465			}
466
467			return $return;
468			}
469
470			/**
471			* Sends data to a connected socket.
472			*
473			* @param $buffer
474			* @param int $flags
475			* @param int $length
476			*
477			* @throws Exception\SocketException
478			*
479			* @return int
480			*/
481		View Code Duplication	public function send($buffer, $flags = 0, $length = null)
482			{
483			if (null === $length) {
484			$length = strlen($buffer);
485			}
486
487			// make sure everything is written
488			do {
489			$return = @socket_send($this->resource, $buffer, $length, $flags);
490
491			if (false !== $return && $return < $length) {
492			$buffer = substr($buffer, $return);
493			$length -= $return;
494			} else {
495			break;
496			}
497			} while (true);
498
499			if ($return === false) {
500			throw new SocketException($this->resource);
501			}
502
503			return $return;
504			}
505
506			/**
507			* Set the socket to blocking / non blocking.
508			*
509			* @param bool
510			*
511			* @return void
512			*/
513			public function setBlocking($bool)
514			{
515			if ($bool) {
516			@socket_set_block($this->resource);
517			} else {
518			@socket_set_nonblock($this->resource);
519			}
520			}
521			}
522

navarr / Sockets

GitHub Access Token became invalid