ArrayVO::__toString() - Code Metrics - Inspection of "Merge pull request #21 from nark3d/next_release" - nark3d/PhalueObjects - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 975c17...8f2777 )

by Adam

created 2017-03-14 21:38 UTC

ArrayVO::__toString() A

↳ Parent: ArrayVO

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0
crap	1

<?php

namespace BestServedCold\PhalueObjects;

use BestServedCold\PhalueObjects\Contract\Arrayable;
use BestServedCold\PhalueObjects\Contract\Countable;
use BestServedCold\PhalueObjects\Exception\InvalidTypeException;
use BestServedCold\PhalueObjects\Format\Json\Notation;
use Iterator;

/**
 * Class ArrayVO
 *
 * @package   BestServedCold\PhalueObjects\ValueObject
 * @author    Adam Lewis <[email protected]>
 * @copyright Copyright (c) 2015 Best Served Cold Media Limited
 * @license   http://http://opensource.org/licenses/GPL-3.0 GPL License
 * @link      http://bestservedcold.com
 * @since     0.0.1-alpha
 * @version   0.0.2-alpha
 */
class ArrayVO extends ValueObject implements Iterator, Arrayable, Countable
{
    /**
     * ArrayValueObject constructor.
     *
     * @param $value
     */
    public function __construct(array $value)
    {
        parent::__construct($value);
    }

    /**
     * @return string
     */
    public function __toString()
    {
        return (string) serialize($this->getValue());
    }

    /**
     * @return mixed
     */
    public function toArray()
    {
        return $this->getValue();
    }

    /**
     * @param array $array
     * @return static
     */
    public static function fromArray(array $array)
    {
        return new static($array);
    }

    /**
     * @param  $key
     * @return bool
     */
    public function keyExists($key)

    {
        return array_key_exists($key, $this->getValue());
    }

    /**
     * @return static
     */
    public function dropFirst()
    {
        return new static(array_slice($this->getValue(), 1, $this->count()));
    }

    /**
     * @return static
     */
    public function dropLast()
    {
        return new static(array_slice($this->getValue(), 0, -1));
    }

    /**
     * @param  Notation $notation
     * @return bool
     */
    public function findJsonNotation(Notation $notation)

    {
        return $this->findArrayVO($notation->toArrayVO());
    }

    /**
     * @param  array $array
     * @return bool|mixed
     */
    public function findArray(array $array)
    {
        return $this->findArrayVO(ArrayVO::fromArray($array));
    }

    /**
     * Iterates through an array of values and finds a key.  If it makes it to the final value,
     * it returns what ever value matches that key.
     *
     * @param  ArrayValueObject $arrayValueObject

     * @return bool|mixed
     */
    public function findArrayVO(ArrayVO $arrayValueObject)
    {
        if ($key = $this->getKey($arrayValueObject->current())) {
            return $arrayValueObject->isLast() ? $key
                : ArrayVO::fromArray($key)
                    ->findArrayVO($arrayValueObject->dropFirst());
        }

        return false;
    }

    /**
     * @param  string|int $key
     * @return bool|mixed
     */
    public function getKey($key)
    {
        return $this->keyExists($key) ? $this->value[$key] : false;
    }

    /**
     * @return mixed
     */
    public function current()
    {
        return current($this->value);
    }

    /**
     * @return mixed
     */
    public function key()
    {
        return key($this->value);
    }

    /**
     * @return bool
     */
    public function valid()
    {
        return key($this->value) !== null && key($this->value) !== false;
    }

    /**
     * @return $this
     */
    public function next()
    {
        next($this->value);
        return $this;
    }

    /**
     * @return $this
     */
    public function rewind()
    {
        reset($this->value);
        return $this;
    }

    /**
     * @return int
     */
    public function count()
    {
        return count($this->getValue());
    }

    /**
     * @return bool
     */
    public function isEmpty()
    {
        return empty($this->value);
    }

    /**
     * @return mixed
     */
    public function getFirstKey()
    {
        return array_shift(array_keys($this->value));

    }

    /**
     * @return mixed
     */
    public function getLastKey()
    {
        return end(array_keys($this->value));

    }

    /**
     * @return bool
     */
    public function isLast()
    {
        return $this->key() === $this->getLastKey();
    }

    /**
     * @param  ValueObject $object
     * @return bool
     */
    public function equals(ValueObject $object)

    {
        if (! $object instanceof ArrayVO) {
            throw new InvalidTypeException($object, [ ArrayVO::class ]);
        }

        return parent::equals($object);
    }

}


1		<?php
2
3		namespace BestServedCold\PhalueObjects;
4
5		use BestServedCold\PhalueObjects\Contract\Arrayable;
6		use BestServedCold\PhalueObjects\Contract\Countable;
7		use BestServedCold\PhalueObjects\Exception\InvalidTypeException;
8		use BestServedCold\PhalueObjects\Format\Json\Notation;
9		use Iterator;
10
11		/**
12		* Class ArrayVO
13		*
14		* @package BestServedCold\PhalueObjects\ValueObject
15		* @author Adam Lewis <[email protected]>
16		* @copyright Copyright (c) 2015 Best Served Cold Media Limited
17		* @license http://http://opensource.org/licenses/GPL-3.0 GPL License
18		* @link http://bestservedcold.com
19		* @since 0.0.1-alpha
20		* @version 0.0.2-alpha
21		*/
22		class ArrayVO extends ValueObject implements Iterator, Arrayable, Countable
23		{
24		/**
25		* ArrayValueObject constructor.
26		*
27		* @param $value
28		*/
29	48	public function __construct(array $value)
30	1	{
31	48	parent::__construct($value);
32	48	}
33
34		/**
35		* @return string
36		*/
37	1	public function __toString()
38		{
39	1	return (string) serialize($this->getValue());
40		}
41
42		/**
43		* @return mixed
44		*/
45		public function toArray()
46		{
47		return $this->getValue();
48		}
49
50		/**
51		* @param array $array
52		* @return static
53		*/
54	5	public static function fromArray(array $array)
55		{
56	5	return new static($array);
57		}
58
59		/**
60		* @param $key
61		* @return bool
62		*/
63	2	public function keyExists($key)
		0 ignored issues – show Coding Style introduced 2017-03-14 21:36 UTC by Report Bug Copy Issue Report `function keyExists()` does not seem to conform to the naming convention (`^(?:is\|has\|should\|may\|supports)`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
64		{
65	2	return array_key_exists($key, $this->getValue());
66		}
67
68		/**
69		* @return static
70		*/
71	1	public function dropFirst()
72		{
73	1	return new static(array_slice($this->getValue(), 1, $this->count()));
74		}
75
76		/**
77		* @return static
78		*/
79	1	public function dropLast()
80		{
81	1	return new static(array_slice($this->getValue(), 0, -1));
82		}
83
84		/**
85		* @param Notation $notation
86		* @return bool
87		*/
88	1	public function findJsonNotation(Notation $notation)
		0 ignored issues – show Coding Style introduced 2017-03-14 21:36 UTC by Report Bug Copy Issue Report `function findJsonNotation()` does not seem to conform to the naming convention (`^(?:is\|has\|should\|may\|supports)`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
89		{
90	1	return $this->findArrayVO($notation->toArrayVO());
91		}
92
93		/**
94		* @param array $array
95		* @return bool\|mixed
96		*/
97	1	public function findArray(array $array)
98		{
99	1	return $this->findArrayVO(ArrayVO::fromArray($array));
100		}
101
102		/**
103		* Iterates through an array of values and finds a key. If it makes it to the final value,
104		* it returns what ever value matches that key.
105		*
106		* @param ArrayValueObject $arrayValueObject
		0 ignored issues – show Documentation introduced 2017-03-14 21:36 UTC by Report Bug Copy Issue Report Should the type for parameter `$arrayValueObject` not be `ArrayVO`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
107		* @return bool\|mixed
108		*/
109	2	public function findArrayVO(ArrayVO $arrayValueObject)
110		{
111	2	if ($key = $this->getKey($arrayValueObject->current())) {
112	2	return $arrayValueObject->isLast() ? $key
113		: ArrayVO::fromArray($key)
114		->findArrayVO($arrayValueObject->dropFirst());
115		}
116
117		return false;
118		}
119
120		/**
121		* @param string\|int $key
122		* @return bool\|mixed
123		*/
124	2	public function getKey($key)
125		{
126	2	return $this->keyExists($key) ? $this->value[$key] : false;
127		}
128
129		/**
130		* @return mixed
131		*/
132	3	public function current()
133		{
134	3	return current($this->value);
135		}
136
137		/**
138		* @return mixed
139		*/
140	2	public function key()
141		{
142	2	return key($this->value);
143		}
144
145		/**
146		* @return bool
147		*/
148	1	public function valid()
149		{
150	1	return key($this->value) !== null && key($this->value) !== false;
151		}
152
153		/**
154		* @return $this
155		*/
156	2	public function next()
157		{
158	2	next($this->value);
159	2	return $this;
160		}
161
162		/**
163		* @return $this
164		*/
165	1	public function rewind()
166		{
167	1	reset($this->value);
168	1	return $this;
169		}
170
171		/**
172		* @return int
173		*/
174	1	public function count()
175		{
176	1	return count($this->getValue());
177		}
178
179		/**
180		* @return bool
181		*/
182	1	public function isEmpty()
183		{
184	1	return empty($this->value);
185		}
186
187		/**
188		* @return mixed
189		*/
190	1	public function getFirstKey()
191		{
192	1	return array_shift(array_keys($this->value));
		0 ignored issues – show Bug introduced 2017-03-14 21:36 UTC by Report Bug Copy Issue Report `array_keys($this->value)` cannot be passed to `array_shift()` as the parameter `$array` expects a reference. Loading history...
193		}
194
195		/**
196		* @return mixed
197		*/
198	3	public function getLastKey()
199		{
200	3	return end(array_keys($this->value));
		0 ignored issues – show Bug introduced 2017-03-14 21:36 UTC by Report Bug Copy Issue Report `array_keys($this->value)` cannot be passed to `end()` as the parameter `$array` expects a reference. Loading history...
201		}
202
203		/**
204		* @return bool
205		*/
206	2	public function isLast()
207		{
208	2	return $this->key() === $this->getLastKey();
209		}
210
211		/**
212		* @param ValueObject $object
213		* @return bool
214		*/
215	2	public function equals(ValueObject $object)
		0 ignored issues – show Coding Style introduced 2017-03-14 21:36 UTC by Report Bug Copy Issue Report `function equals()` does not seem to conform to the naming convention (`^(?:is\|has\|should\|may\|supports)`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
216		{
217	2	if (! $object instanceof ArrayVO) {
218	1	throw new InvalidTypeException($object, [ ArrayVO::class ]);
219		}
220
221	1	return parent::equals($object);
222		}
223
224		}
225

nark3d / PhalueObjects

Push — master ( 975c17...8f2777 )

ArrayVO::__toString() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like