Packer::packArrayLength() - Code Metrics - Inspection of "Enhance type transformers" - rybakit/msgpack.php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#21)

by Eugene

created 2018-04-05 20:20 UTC

Packer::packArrayLength() A

↳ Parent: Packer

Complexity

Conditions	3
Paths	3

Size

Total Lines	11
Code Lines	6

Duplication

Lines	11
Ratio	100 %

Code Coverage

Tests	6
CRAP Score	3

Importance

Changes

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

<?php

/*
 * This file is part of the rybakit/msgpack.php package.
 *
 * (c) Eugene Leonovich <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace MessagePack;

use MessagePack\Exception\InvalidOptionException;
use MessagePack\Exception\PackingFailedException;
use MessagePack\TypeTransformer\Packable;

class Packer
{
    const UTF8_REGEX = '/\A(?:
          [\x00-\x7F]++                      # ASCII
        | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
        |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
        | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
        |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
        |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
        | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
        |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
        )*+\z/x';

    private $isDetectStrBin;
    private $isForceStr;
    private $isDetectArrMap;
    private $isForceArr;
    private $isForceFloat32;

    /**
     * @var Packable[]|null
     */
    private $transformers;

    /**
     * @param PackOptions|int|null $options
     *
     * @throws InvalidOptionException
     */
    public function __construct($options = null)
    {
        if (!$options instanceof PackOptions) {
            $options = PackOptions::fromBitmask($options);
        }

        $this->isDetectStrBin = $options->isDetectStrBinMode();
        $this->isForceStr = $options->isForceStrMode();
        $this->isDetectArrMap = $options->isDetectArrMapMode();
        $this->isForceArr = $options->isForceArrMode();
        $this->isForceFloat32 = $options->isForceFloat32Mode();
    }

    public function registerTransformer(Packable $transformer)
    {
        $this->transformers[] = $transformer;
    }

    public function pack($value)
    {
        if (\is_int($value)) {
            return $this->packInt($value);
        }
        if (\is_string($value)) {
            if ($this->isDetectStrBin) {
                return \preg_match(self::UTF8_REGEX, $value)
                    ? $this->packStr($value)
                    : $this->packBin($value);
            }

            return $this->isForceStr ? $this->packStr($value) : $this->packBin($value);
        }
        if (\is_array($value)) {
            if ($this->isDetectArrMap) {
                return \array_values($value) === $value
                    ? $this->packArray($value)
                    : $this->packMap($value);
            }

            return $this->isForceArr ? $this->packArray($value) : $this->packMap($value);
        }
        if (null === $value) {
            return $this->packNil();
        }
        if (\is_bool($value)) {
            return $this->packBool($value);
        }
        if (\is_float($value)) {
            return $this->isForceFloat32
                ? $this->packFloat32($value)
                : $this->packFloat64($value);
        }
        if ($value instanceof Ext) {
            return $this->packExt($value->type, $value->data);
        }
        if ($this->transformers) {
            foreach ($this->transformers as $transformer) {
                if (null !== $packed = $transformer->pack($this, $value)) {
                    return $packed;
                }
            }
        }

        throw new PackingFailedException($value, 'Unsupported type.');
    }

    public function packArray(array $array)
    {
        $data = $this->packArrayLength(\count($array));

        foreach ($array as $val) {
            $data .= $this->pack($val);
        }

        return $data;
    }

    public function packArrayLength($length)

    {
        if ($length <= 0xf) {
            return \chr(0x90 | $length);
        }
        if ($length <= 0xffff) {
            return "\xdc".\chr($length >> 8).\chr($length);
        }

        return \pack('CN', 0xdd, $length);
    }

    public function packMap(array $map)
    {
        $data = $this->packMapLength(\count($map));

        foreach ($map as $key => $val) {
            $data .= $this->pack($key);
            $data .= $this->pack($val);
        }

        return $data;
    }

    public function packMapLength($length)

    {
        if ($length <= 0xf) {
            return \chr(0x80 | $length);
        }
        if ($length <= 0xffff) {
            return "\xde".\chr($length >> 8).\chr($length);
        }

        return \pack('CN', 0xdf, $length);
    }

    public function packStr($str)
    {
        $length = \strlen($str);

        if ($length < 32) {
            return \chr(0xa0 | $length).$str;
        }
        if ($length <= 0xff) {
            return "\xd9".\chr($length).$str;
        }
        if ($length <= 0xffff) {
            return "\xda".\chr($length >> 8).\chr($length).$str;
        }

        return \pack('CN', 0xdb, $length).$str;
    }

    public function packBin($str)
    {
        $length = \strlen($str);

        if ($length <= 0xff) {
            return "\xc4".\chr($length).$str;
        }
        if ($length <= 0xffff) {
            return "\xc5".\chr($length >> 8).\chr($length).$str;
        }

        return \pack('CN', 0xc6, $length).$str;
    }

    public function packExt($type, $data)
    {
        $length = \strlen($data);

        switch ($length) {
            case 1: return "\xd4".\chr($type).$data;
            case 2: return "\xd5".\chr($type).$data;
            case 4: return "\xd6".\chr($type).$data;
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 8: return "\xd7".\chr($type).$data;
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
            case 16: return "\xd8".\chr($type).$data;
        }

        if ($length <= 0xff) {
            return "\xc7".\chr($length).\chr($type).$data;
        }
        if ($length <= 0xffff) {
            return \pack('CnC', 0xc8, $length, $type).$data;
        }

        return \pack('CNC', 0xc9, $length, $type).$data;
    }

    public function packNil()
    {
        return "\xc0";
    }

    public function packBool($val)
    {
        return $val ? "\xc3" : "\xc2";
    }

    public function packFloat32($num)
    {
        return "\xca".\strrev(\pack('f', $num));
    }

    public function packFloat64($num)
    {
        return "\xcb".\strrev(\pack('d', $num));
    }

    public function packInt($num)
    {
        if ($num >= 0) {
            if ($num <= 0x7f) {
                return \chr($num);
            }
            if ($num <= 0xff) {
                return "\xcc".\chr($num);
            }
            if ($num <= 0xffff) {
                return "\xcd".\chr($num >> 8).\chr($num);
            }
            if ($num <= 0xffffffff) {
                return \pack('CN', 0xce, $num);
            }

            return self::packUint64(0xcf, $num);
        }

        if ($num >= -0x20) {
            return \chr(0xe0 | $num);
        }
        if ($num >= -0x80) {
            return "\xd0".\chr($num);
        }
        if ($num >= -0x8000) {
            return "\xd1".\chr($num >> 8).\chr($num);
        }
        if ($num >= -0x80000000) {
            return \pack('CN', 0xd2, $num);
        }

        return self::packUint64(0xd3, $num);
    }

    private static function packUint64($code, $num)
    {
        $hi = ($num & 0xffffffff00000000) >> 32;
        $lo = $num & 0x00000000ffffffff;

        return \pack('CNN', $code, $hi, $lo);
    }
}


1			<?php
2
3			/*
4			* This file is part of the rybakit/msgpack.php package.
5			*
6			* (c) Eugene Leonovich <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace MessagePack;
13
14			use MessagePack\Exception\InvalidOptionException;
15			use MessagePack\Exception\PackingFailedException;
16			use MessagePack\TypeTransformer\Packable;
17
18			class Packer
19			{
20			const UTF8_REGEX = '/\A(?:
21			[\x00-\x7F]++ # ASCII
22			\| [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
23			\| \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
24			\| [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
25			\| \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
26			\| \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
27			\| [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
28			\| \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
29			)*+\z/x';
30
31			private $isDetectStrBin;
32			private $isForceStr;
33			private $isDetectArrMap;
34			private $isForceArr;
35			private $isForceFloat32;
36
37			/**
38			* @var Packable[]\|null
39			*/
40			private $transformers;
41
42			/**
43			* @param PackOptions\|int\|null $options
44			*
45			* @throws InvalidOptionException
46			*/
47	106		public function __construct($options = null)
48			{
49	106		if (!$options instanceof PackOptions) {
50	106		$options = PackOptions::fromBitmask($options);
51			}
52
53	106		$this->isDetectStrBin = $options->isDetectStrBinMode();
54	106		$this->isForceStr = $options->isForceStrMode();
55	106		$this->isDetectArrMap = $options->isDetectArrMapMode();
56	106		$this->isForceArr = $options->isForceArrMode();
57	106		$this->isForceFloat32 = $options->isForceFloat32Mode();
58	106		}
59
60			public function registerTransformer(Packable $transformer)
61			{
62			$this->transformers[] = $transformer;
63	2		}
64
65	2		public function pack($value)
66	2		{
67			if (\is_int($value)) {
68			return $this->packInt($value);
69			}
70			if (\is_string($value)) {
71	1		if ($this->isDetectStrBin) {
72			return \preg_match(self::UTF8_REGEX, $value)
73	1		? $this->packStr($value)
74			: $this->packBin($value);
75			}
76	98
77			return $this->isForceStr ? $this->packStr($value) : $this->packBin($value);
78	98		}
79	53		if (\is_array($value)) {
80			if ($this->isDetectArrMap) {
81	69		return \array_values($value) === $value
82	33		? $this->packArray($value)
83	27		: $this->packMap($value);
84	19		}
85	27
86			return $this->isForceArr ? $this->packArray($value) : $this->packMap($value);
87			}
88	6		if (null === $value) {
89			return $this->packNil();
90	46		}
91	26		if (\is_bool($value)) {
92	19		return $this->packBool($value);
93	10		}
94	19		if (\is_float($value)) {
95			return $this->isForceFloat32
96			? $this->packFloat32($value)
97	7		: $this->packFloat64($value);
98			}
99	24		if ($value instanceof Ext) {
100	3		return $this->packExt($value->type, $value->data);
101			}
102	23		if ($this->transformers) {
103	6		foreach ($this->transformers as $transformer) {
104			if (null !== $packed = $transformer->pack($this, $value)) {
105	18		return $packed;
106	6		}
107	1		}
108	6		}
109
110	12		throw new PackingFailedException($value, 'Unsupported type.');
111	9		}
112
113			public function packArray(array $array)
114	3		{
115	1		$data = $this->packArrayLength(\count($array));
116
117	1		foreach ($array as $val) {
118			$data .= $this->pack($val);
119			}
120	2
121			return $data;
122			}
123	13
124		View Code Duplication	public function packArrayLength($length)
			0 ignored issues – show Duplication introduced 2018-04-05 17:14 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
125	13		{
126			if ($length <= 0xf) {
127	13		return \chr(0x90 \| $length);
128	10		}
129	3		if ($length <= 0xffff) {
130	2		return "\xdc".\chr($length >> 8).\chr($length);
131			}
132	1
133			return \pack('CN', 0xdd, $length);
134			}
135	13
136	12		public function packMap(array $map)
137			{
138			$data = $this->packMapLength(\count($map));
139	13
140			foreach ($map as $key => $val) {
141			$data .= $this->pack($key);
142	15		$data .= $this->pack($val);
143			}
144	15
145			return $data;
146	15		}
147	12
148	3	View Code Duplication	public function packMapLength($length)
			0 ignored issues – show Duplication introduced 2018-04-05 17:14 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
149	2		{
150			if ($length <= 0xf) {
151	1		return \chr(0x80 \| $length);
152			}
153			if ($length <= 0xffff) {
154	15		return "\xde".\chr($length >> 8).\chr($length);
155	15		}
156	15
157			return \pack('CN', 0xdf, $length);
158			}
159	15
160			public function packStr($str)
161			{
162	22		$length = \strlen($str);
163
164	22		if ($length < 32) {
165			return \chr(0xa0 \| $length).$str;
166	22		}
167	15		if ($length <= 0xff) {
168			return "\xd9".\chr($length).$str;
169	7		}
170	4		if ($length <= 0xffff) {
171			return "\xda".\chr($length >> 8).\chr($length).$str;
172	3		}
173	2
174			return \pack('CN', 0xdb, $length).$str;
175			}
176	1
177			public function packBin($str)
178			{
179	13		$length = \strlen($str);
180
181	13		if ($length <= 0xff) {
182			return "\xc4".\chr($length).$str;
183	13		}
184	11		if ($length <= 0xffff) {
185			return "\xc5".\chr($length >> 8).\chr($length).$str;
186	2		}
187	1
188			return \pack('CN', 0xc6, $length).$str;
189			}
190	1
191			public function packExt($type, $data)
192			{
193	10		$length = \strlen($data);
194
195	10		switch ($length) {
196			case 1: return "\xd4".\chr($type).$data;
197	10		case 2: return "\xd5".\chr($type).$data;
198	10		case 4: return "\xd6".\chr($type).$data;
			0 ignored issues – show Coding Style introduced 2016-03-03 21:40 UTC by Report Bug Copy Issue Report The case body in a switch statement must start on the line following the statement. According to the PSR-2, the body of a case statement must start on the line immediately following the case statement. switch ($expr) { case "A": doSomething(); //right break; case "B": doSomethingElse(); //wrong break; } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history... Coding Style introduced 2016-03-03 21:40 UTC by Report Bug Copy Issue Report Terminating statement must be on a line by itself As per the PSR-2 coding standard, the `break` (or other terminating) statement must be on a line of its own. switch ($expr) { case "A": doSomething(); break; //wrong case "B": doSomething(); break; //right case "C:": doSomething(); return true; //right } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history...
199	8		case 8: return "\xd7".\chr($type).$data;
			0 ignored issues – show Coding Style introduced 2016-03-03 21:40 UTC by Report Bug Copy Issue Report The case body in a switch statement must start on the line following the statement. According to the PSR-2, the body of a case statement must start on the line immediately following the case statement. switch ($expr) { case "A": doSomething(); //right break; case "B": doSomethingElse(); //wrong break; } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history... Coding Style introduced 2016-03-03 21:40 UTC by Report Bug Copy Issue Report Terminating statement must be on a line by itself As per the PSR-2 coding standard, the `break` (or other terminating) statement must be on a line of its own. switch ($expr) { case "A": doSomething(); break; //wrong case "B": doSomething(); break; //right case "C:": doSomething(); return true; //right } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history...
200	7		case 16: return "\xd8".\chr($type).$data;
201	6		}
202	5
203			if ($length <= 0xff) {
204			return "\xc7".\chr($length).\chr($type).$data;
205	4		}
206	2		if ($length <= 0xffff) {
207			return \pack('CnC', 0xc8, $length, $type).$data;
208	2		}
209	1
210			return \pack('CNC', 0xc9, $length, $type).$data;
211			}
212	1
213			public function packNil()
214			{
215	3		return "\xc0";
216			}
217	3
218			public function packBool($val)
219			{
220	6		return $val ? "\xc3" : "\xc2";
221			}
222	6
223			public function packFloat32($num)
224			{
225	3		return "\xca".\strrev(\pack('f', $num));
226			}
227	3
228			public function packFloat64($num)
229			{
230	5		return "\xcb".\strrev(\pack('d', $num));
231			}
232	5
233			public function packInt($num)
234			{
235	53		if ($num >= 0) {
236			if ($num <= 0x7f) {
237	53		return \chr($num);
238	38		}
239	26		if ($num <= 0xff) {
240			return "\xcc".\chr($num);
241	16		}
242	6		if ($num <= 0xffff) {
243			return "\xcd".\chr($num >> 8).\chr($num);
244	12		}
245	6		if ($num <= 0xffffffff) {
246			return \pack('CN', 0xce, $num);
247	7		}
248	5
249			return self::packUint64(0xcf, $num);
250			}
251	3
252			if ($num >= -0x20) {
253			return \chr(0xe0 \| $num);
254	16		}
255	4		if ($num >= -0x80) {
256			return "\xd0".\chr($num);
257	12		}
258	3		if ($num >= -0x8000) {
259			return "\xd1".\chr($num >> 8).\chr($num);
260	9		}
261	3		if ($num >= -0x80000000) {
262			return \pack('CN', 0xd2, $num);
263	6		}
264	3
265			return self::packUint64(0xd3, $num);
266			}
267	3
268			private static function packUint64($code, $num)
269			{
270	6		$hi = ($num & 0xffffffff00000000) >> 32;
271			$lo = $num & 0x00000000ffffffff;
272	6
273	6		return \pack('CNN', $code, $hi, $lo);
274			}
275			}
276

rybakit / msgpack.php

Pull Request — master (#21)

Packer::packArrayLength() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like