Nip_Helper_Arrays - Code Metrics - ByTIC/framework - Measure and Improve Code Quality continuously with Scrutinizer

Nip_Helper_Arrays F
last analyzed 2017-08-07 20:36 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	388
Duplicated Lines	6.7 %

Coupling/Cohesion

Components	0
Dependencies	1

Test Coverage

Coverage

Importance

Changes

Metric	Value
dl	26
loc	388
ccs	0
cts	147
cp	0
rs	2.459
c	0
b	0
f	0
wmc	73
lcom	0
cbo	1

16 Methods

Rating	Name	Duplication	Size	Complexity
A	accessible()	0	4	2
A	exists()	0	7	2
B	first()	0	17	6
C	toXLS()	0	39	7
B	get()	0	20	7
A	without()	13	13	3
A	withoutKeys()	13	13	3
A	changeKey()	0	12	3
A	pluck()	0	16	4
A	pluckFromArray()	0	10	3
B	find()	0	19	6
C	findAll()	0	24	7
A	transpose()	0	14	4
C	toXML()	0	46	9
A	isAssoc()	0	4	2
B	merge_distinct()	0	14	5

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 Nip_Helper_Arrays 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 Nip_Helper_Arrays, and based on these observations, apply Extract Interface, too.

<?php

class Nip_Helper_Arrays extends Nip\Helpers\AbstractHelper
namespace YourVendor;

class YourClass { }
{

    /**
     * Determine whether the given value is array accessible.
     *
     * @param  mixed $value
     * @return bool
     */
    public static function accessible($value)
    {
        return is_array($value) || $value instanceof ArrayAccess;
    }

    /**
     * Determine if the given key exists in the provided array.
     *
     * @param  \ArrayAccess|array $array
     * @param  string|int $key
     * @return bool
     */
    public static function exists($array, $key)
    {
        if ($array instanceof ArrayAccess) {
            return $array->offsetExists($key);
        }
        return array_key_exists($key, $array);
    }

    /**
     * Return the first element in an array passing a given truth test.
     *
     * @param  array $array
     * @param  callable|null $callback
     * @param  mixed $default
     * @return mixed
     */
    public static function first($array, callable $callback = null, $default = null)
    {
        if (is_null($callback)) {
            if (empty($array)) {
                return value($default);
            }
            foreach ($array as $item) {
                return $item;
            }
        }
        foreach ($array as $key => $value) {
            if (call_user_func($callback, $value, $key)) {
                return $value;
            }
        }
        return value($default);
    }

    public function toXLS($array, $filename, $labels = array())
    {
        $xls = new Spreadsheet_Excel_Writer();
        $xls->setVersion(8);

        $sheet = $xls->addWorksheet();
        $sheet->setInputEncoding("UTF-8");

        $heading = $xls->addFormat(['bold' => '1', 'align' => 'center']);

        if ($array && !$labels) {

            $labels = array_keys(reset($array));
        }

        $i = 0;
        foreach ($labels as $label) {
            $sheet->write(0, $i, $label, $heading);
            $i++;
        }

        if (count($array)) {
            $line = 1;
            foreach ($array as $item) {
                $column = 0;
                foreach ($labels as $label) {
                    $sheet->write($line, $column, html_entity_decode($item[$label], ENT_QUOTES, 'UTF-8'));
                    $column++;
                }
                $line++;
            }
        }

        header("Cache-Control: private, max-age=1, pre-check=1", true);
        header("Pragma: none", true);

        $xls->send($filename);
        $xls->close();
        exit();

    }

    /**
     * Get an item from an array using "dot" notation.
     *
     * @param  \ArrayAccess|array $array
     * @param  string $key
     * @param  mixed $default
     * @return mixed
     */
    public static function get($array, $key, $default = null)
    {
        if (!static::accessible($array)) {
            return value($default);
        }
        if (is_null($key)) {
            return $array;
        }
        if (static::exists($array, $key)) {
            return $array[$key];
        }
        foreach (explode('.', $key) as $segment) {
            if (static::accessible($array) && static::exists($array, $segment)) {
                $array = $array[$segment];
            } else {
                return value($default);
            }
        }
        return $array;
    }

    /**
     * Produces a new version of the array that does not contain any of the specified values
     *
     * @param array $array
     * @return array
     */
    public function without($array)

    {
        $values = func_get_args();
        unset($values[0]);

        if ($values) {

            foreach ($values as $value) {
                unset($array[array_search($value, $array)]);
            }
        }

        return $array;
    }

    /**
     * Produces a new version of the array that does not contain any of the specified keys
     *
     * @param array $array
     * @return array
     */
    public function withoutKeys($array)

    {
        $values = func_get_args();
        unset($values[0]);

        if ($values) {

            foreach ($values as $value) {
                unset($array[$value]);
            }
        }

        return $array;
    }

    /**
     * Fetch the same property for all the elements.
     *
     * @param array $array
     * @param string $property
     * @return array The property values
     */
    public function changeKey($array, $property)
    {
        $return = [];

        if (count($array) > 0) {
            foreach ($array as $item) {
                $return[$item->$property] = $item;
            }
        }

        return $return;
    }

    /**
     * Fetch the same property for all the elements.
     *
     * @param array|\Nip\Records\Collections\Collection $array
     * @param string $property
     * @param bool|string $return
     * @return array The property values
     */
    public function pluck($array, $property, &$return = false)
    {
        $return = [];

        if (count($array) > 0) {
            foreach ($array as $item) {
                if (is_array($item)) {
                    $this->pluck($array, $property, $return);
                }

                $return[] = $item->$property;
            }
        }

        return $return;
    }

    /**
     * Fetch the same property for all the elements.
     *
     * @param array $array
     * @param string $property
     */
    public function pluckFromArray($array, $property)
    {
        if (is_array($array)) {
            foreach ($array as $item) {
                $return[] = $item[$property];
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
            }
        }

        return $return;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
    }

    /**
     * Finds array item that matches $params
     *
     * @param ArrayAccess $array
     * @param array $params
     * @return mixed
     */
    public function find($array, $params)
    {
        if (count($array)) {
            foreach ($array as $item) {
                $found = true;
                foreach ($params as $key => $value) {

                    if ($item->$key != $value) {
                        $found = false;
                    }
                }
                if ($found) {
                    return $item;
                }
            }
        }

        return null;
    }

    /**
     * Finds all array items that match $params
     *
     * @param array $array
     * @param array $params
     * @param string $key
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return array
     */
    public function findAll($array, $params, $returnKey = false)
    {
        $return = [];

        if (count($array)) {
            foreach ($array as $item) {
                $found = true;
                foreach ($params as $key => $value) {
                    if ($item->$key != $value) {
                        $found = false;
                    }
                }
                if ($found) {
                    if ($returnKey) {
                        $return[$item->$returnKey] = $item;
                    } else {
                        $return[] = $item;
                    }
                }
            }
        }

        return $return;
    }

    /**
     * Transposes a bidimensional array (matrix)
     *
     * @param array $array
     * @return array
     */
    public function transpose($array)
    {
        $return = [];

        if (count($array)) {
            foreach ($array as $key => $values) {
                foreach ($values as $subkey => $value) {
                    $return[$subkey][$key] = $value;
                }
            }
        }

        return $return;
    }

    /**
     * Pass in a multi dimensional array and this recrusively loops through and builds up an XML document.
     *
     * @param array $data
     * @param string $rootNodeName - what you want the root node to be - defaults to data
     * @param SimpleXMLElement $xml - should only be used recursively
     * @return string XML
     */
    public function toXML($data, $rootNodeName = 'ResultSet', &$xml = null)
    {
        // turn off compatibility mode as simple xml throws a wobbly if you don't.
        if (ini_get('zend.ze1_compatibility_mode') == 1)
            ini_set('zend.ze1_compatibility_mode', 0);

        if (is_null($xml)) {
            $xml = simplexml_load_string("<?xml version='1.0' encoding='utf-8'?><$rootNodeName />");
        }

        // loop through the data passed in.
        foreach ($data as $key => $value) {
            // no numeric keys in our xml please!
            if (is_numeric($key)) {
                $numeric = 1;
                $key = $rootNodeName;
            }

            // delete any char not allowed in XML element names
            $key = preg_replace('/[^a-z0-9\-\_\.\:]/i', '', $key);

            // if there is another array found recrusively call this function
            if (is_array($value)) {
                $node = $this->isAssoc($value) || $numeric ? $xml->addChild($key) : $xml;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}

                // recursive call
                if ($numeric)
                    $key = 'anon';
                $this->toXML($value, $key, $node);
            } else {
                // add single node.
                $value = htmlentities($value);
//                $xml->addChild($key, $value);

                $xml->addAttribute($key, $value);
            }
        }

        // pass back as XML
        // return $xml->asXML();

        // if you want the XML to be formatted, use the below instead to return the XML
        $doc = new DOMDocument('1.0');
        $doc->preserveWhiteSpace = false;
        $doc->loadXML($xml->asXML());
        $doc->formatOutput = true;
        return $doc->saveXML();
    }

    /**
     * Determine if a variable is an associative array
     *
     * @param array $array
     * @return bool
     */
    public static function isAssoc($array)
    {
        return (is_array($array) && 0 !== count(array_diff_key($array, array_keys(array_keys($array)))));
    }

    function merge_distinct(array &$array1, array &$array2)

    {
        $merged = $array1;

        foreach ($array2 as $key => &$value) {
            if (is_array($value) && isset($merged [$key]) && is_array($merged [$key])) {
                $merged [$key] = $this->merge_distinct($merged [$key], $value);
            } else {
                $merged [$key] = $value;
            }
        }

        return $merged;
    }
}


GitHub Access Token became invalid

Nip_Helper_Arrays F
last analyzed 2017-08-07 20:36 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

16 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

1		<?php
2
3		class Nip_Helper_Arrays extends Nip\Helpers\AbstractHelper
		0 ignored issues – show Coding Style Compatibility introduced 2016-08-20 20:47 UTC by Report Bug Copy Issue Report PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
4		{
5
6		/**
7		* Determine whether the given value is array accessible.
8		*
9		* @param mixed $value
10		* @return bool
11		*/
12		public static function accessible($value)
13		{
14		return is_array($value) \|\| $value instanceof ArrayAccess;
15		}
16
17		/**
18		* Determine if the given key exists in the provided array.
19		*
20		* @param \ArrayAccess\|array $array
21		* @param string\|int $key
22		* @return bool
23		*/
24		public static function exists($array, $key)
25		{
26		if ($array instanceof ArrayAccess) {
27		return $array->offsetExists($key);
28		}
29		return array_key_exists($key, $array);
30		}
31
32		/**
33		* Return the first element in an array passing a given truth test.
34		*
35		* @param array $array
36		* @param callable\|null $callback
37		* @param mixed $default
38		* @return mixed
39		*/
40		public static function first($array, callable $callback = null, $default = null)
41		{
42		if (is_null($callback)) {
43		if (empty($array)) {
44		return value($default);
45		}
46		foreach ($array as $item) {
47		return $item;
48		}
49		}
50		foreach ($array as $key => $value) {
51		if (call_user_func($callback, $value, $key)) {
52		return $value;
53		}
54		}
55		return value($default);
56		}
57
58		public function toXLS($array, $filename, $labels = array())
59		{
60		$xls = new Spreadsheet_Excel_Writer();
61		$xls->setVersion(8);
62
63		$sheet = $xls->addWorksheet();
64		$sheet->setInputEncoding("UTF-8");
65
66		$heading = $xls->addFormat(['bold' => '1', 'align' => 'center']);
67
68		if ($array && !$labels) {
		0 ignored issues – show Bug Best Practice introduced 2016-08-20 20:47 UTC by Report Bug Copy Issue Report The expression `$labels` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
69		$labels = array_keys(reset($array));
70		}
71
72		$i = 0;
73		foreach ($labels as $label) {
74		$sheet->write(0, $i, $label, $heading);
75		$i++;
76		}
77
78		if (count($array)) {
79		$line = 1;
80		foreach ($array as $item) {
81		$column = 0;
82		foreach ($labels as $label) {
83		$sheet->write($line, $column, html_entity_decode($item[$label], ENT_QUOTES, 'UTF-8'));
84		$column++;
85		}
86		$line++;
87		}
88		}
89
90		header("Cache-Control: private, max-age=1, pre-check=1", true);
91		header("Pragma: none", true);
92
93		$xls->send($filename);
94		$xls->close();
95		exit();
		0 ignored issues – show Coding Style Compatibility introduced 2017-07-29 13:16 UTC by Report Bug Copy Issue Report The method `toXLS()` contains an exit expression. An exit expression should only be used in rare cases. For example, if you write a short command line script. In most cases however, using an `exit` expression makes the code untestable and often causes incompatibilities with other libraries. Thus, unless you are absolutely sure it is required here, we recommend to refactor your code to avoid its usage. Loading history...
96		}
97
98		/**
99		* Get an item from an array using "dot" notation.
100		*
101		* @param \ArrayAccess\|array $array
102		* @param string $key
103		* @param mixed $default
104		* @return mixed
105		*/
106		public static function get($array, $key, $default = null)
107		{
108		if (!static::accessible($array)) {
109		return value($default);
110		}
111		if (is_null($key)) {
112		return $array;
113		}
114		if (static::exists($array, $key)) {
115		return $array[$key];
116		}
117		foreach (explode('.', $key) as $segment) {
118		if (static::accessible($array) && static::exists($array, $segment)) {
119		$array = $array[$segment];
120		} else {
121		return value($default);
122		}
123		}
124		return $array;
125		}
126
127		/**
128		* Produces a new version of the array that does not contain any of the specified values
129		*
130		* @param array $array
131		* @return array
132		*/
133	View Code Duplication	public function without($array)
		0 ignored issues – show Duplication introduced 2017-08-03 19:41 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...
134		{
135		$values = func_get_args();
136		unset($values[0]);
137
138		if ($values) {
		0 ignored issues – show Bug Best Practice introduced 2016-08-20 20:47 UTC by Report Bug Copy Issue Report The expression `$values` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
139		foreach ($values as $value) {
140		unset($array[array_search($value, $array)]);
141		}
142		}
143
144		return $array;
145		}
146
147		/**
148		* Produces a new version of the array that does not contain any of the specified keys
149		*
150		* @param array $array
151		* @return array
152		*/
153	View Code Duplication	public function withoutKeys($array)
		0 ignored issues – show Duplication introduced 2017-08-03 19:41 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...
154		{
155		$values = func_get_args();
156		unset($values[0]);
157
158		if ($values) {
		0 ignored issues – show Bug Best Practice introduced 2016-08-20 20:47 UTC by Report Bug Copy Issue Report The expression `$values` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
159		foreach ($values as $value) {
160		unset($array[$value]);
161		}
162		}
163
164		return $array;
165		}
166
167		/**
168		* Fetch the same property for all the elements.
169		*
170		* @param array $array
171		* @param string $property
172		* @return array The property values
173		*/
174		public function changeKey($array, $property)
175		{
176		$return = [];
177
178		if (count($array) > 0) {
179		foreach ($array as $item) {
180		$return[$item->$property] = $item;
181		}
182		}
183
184		return $return;
185		}
186
187		/**
188		* Fetch the same property for all the elements.
189		*
190		* @param array\|\Nip\Records\Collections\Collection $array
191		* @param string $property
192		* @param bool\|string $return
193		* @return array The property values
194		*/
195		public function pluck($array, $property, &$return = false)
196		{
197		$return = [];
198
199		if (count($array) > 0) {
200		foreach ($array as $item) {
201		if (is_array($item)) {
202		$this->pluck($array, $property, $return);
203		}
204
205		$return[] = $item->$property;
206		}
207		}
208
209		return $return;
210		}
211
212		/**
213		* Fetch the same property for all the elements.
214		*
215		* @param array $array
216		* @param string $property
217		*/
218		public function pluckFromArray($array, $property)
219		{
220		if (is_array($array)) {
221		foreach ($array as $item) {
222		$return[] = $item[$property];
		0 ignored issues – show Coding Style Comprehensibility introduced 2016-08-20 20:47 UTC by Report Bug Copy Issue Report `$return` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$return = array();` before regardless. Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code. Let’s take a look at an example: foreach ($collection as $item) { $myArray['foo'] = $item->getFoo(); if ($item->hasBar()) { $myArray['bar'] = $item->getBar(); } // do something with $myArray } As you can see in this example, the array `$myArray` is initialized the first time when the foreach loop is entered. You can also see that the value of the `bar` key is only written conditionally; thus, its value might result from a previous iteration. This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization `$myArray = array()` either outside or inside the foreach loop. Loading history...
223		}
224		}
225
226		return $return;
		0 ignored issues – show Bug introduced 2016-08-20 20:47 UTC by Report Bug Copy Issue Report The variable `$return` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
227		}
228
229		/**
230		* Finds array item that matches $params
231		*
232		* @param ArrayAccess $array
233		* @param array $params
234		* @return mixed
235		*/
236		public function find($array, $params)
237		{
238		if (count($array)) {
239		foreach ($array as $item) {
240		$found = true;
241		foreach ($params as $key => $value) {
242
243		if ($item->$key != $value) {
244		$found = false;
245		}
246		}
247		if ($found) {
248		return $item;
249		}
250		}
251		}
252
253		return null;
254		}
255
256		/**
257		* Finds all array items that match $params
258		*
259		* @param array $array
260		* @param array $params
261		* @param string $key
		0 ignored issues – show Bug introduced 2016-08-20 20:47 UTC by Report Bug Copy Issue Report There is no parameter named `$key`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
262		* @return array
263		*/
264		public function findAll($array, $params, $returnKey = false)
265		{
266		$return = [];
267
268		if (count($array)) {
269		foreach ($array as $item) {
270		$found = true;
271		foreach ($params as $key => $value) {
272		if ($item->$key != $value) {
273		$found = false;
274		}
275		}
276		if ($found) {
277		if ($returnKey) {
278		$return[$item->$returnKey] = $item;
279		} else {
280		$return[] = $item;
281		}
282		}
283		}
284		}
285
286		return $return;
287		}
288
289		/**
290		* Transposes a bidimensional array (matrix)
291		*
292		* @param array $array
293		* @return array
294		*/
295		public function transpose($array)
296		{
297		$return = [];
298
299		if (count($array)) {
300		foreach ($array as $key => $values) {
301		foreach ($values as $subkey => $value) {
302		$return[$subkey][$key] = $value;
303		}
304		}
305		}
306
307		return $return;
308		}
309
310		/**
311		* Pass in a multi dimensional array and this recrusively loops through and builds up an XML document.
312		*
313		* @param array $data
314		* @param string $rootNodeName - what you want the root node to be - defaults to data
315		* @param SimpleXMLElement $xml - should only be used recursively
316		* @return string XML
317		*/
318		public function toXML($data, $rootNodeName = 'ResultSet', &$xml = null)
319		{
320		// turn off compatibility mode as simple xml throws a wobbly if you don't.
321		if (ini_get('zend.ze1_compatibility_mode') == 1)
322		ini_set('zend.ze1_compatibility_mode', 0);
323
324		if (is_null($xml)) {
325		$xml = simplexml_load_string("<?xml version='1.0' encoding='utf-8'?><$rootNodeName />");
326		}
327
328		// loop through the data passed in.
329		foreach ($data as $key => $value) {
330		// no numeric keys in our xml please!
331		if (is_numeric($key)) {
332		$numeric = 1;
333		$key = $rootNodeName;
334		}
335
336		// delete any char not allowed in XML element names
337		$key = preg_replace('/[^a-z0-9\-\_\.\:]/i', '', $key);
338
339		// if there is another array found recrusively call this function
340		if (is_array($value)) {
341		$node = $this->isAssoc($value) \|\| $numeric ? $xml->addChild($key) : $xml;
		0 ignored issues – show Bug introduced 2016-08-20 20:47 UTC by Report Bug Copy Issue Report The variable `$numeric` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
342
343		// recursive call
344		if ($numeric)
345		$key = 'anon';
346		$this->toXML($value, $key, $node);
347		} else {
348		// add single node.
349		$value = htmlentities($value);
350		// $xml->addChild($key, $value);
		0 ignored issues – show Unused Code Comprehensibility introduced 2016-08-20 20:47 UTC by Report Bug Copy Issue Report `73%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
351		$xml->addAttribute($key, $value);
352		}
353		}
354
355		// pass back as XML
356		// return $xml->asXML();
		0 ignored issues – show Unused Code Comprehensibility introduced 2016-08-20 20:47 UTC by Report Bug Copy Issue Report `67%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
357		// if you want the XML to be formatted, use the below instead to return the XML
358		$doc = new DOMDocument('1.0');
359		$doc->preserveWhiteSpace = false;
360		$doc->loadXML($xml->asXML());
361		$doc->formatOutput = true;
362		return $doc->saveXML();
363		}
364
365		/**
366		* Determine if a variable is an associative array
367		*
368		* @param array $array
369		* @return bool
370		*/
371		public static function isAssoc($array)
372		{
373		return (is_array($array) && 0 !== count(array_diff_key($array, array_keys(array_keys($array)))));
374		}
375
376		function merge_distinct(array &$array1, array &$array2)
		0 ignored issues – show Best Practice introduced 2016-08-20 20:47 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...
377		{
378		$merged = $array1;
379
380		foreach ($array2 as $key => &$value) {
381		if (is_array($value) && isset($merged [$key]) && is_array($merged [$key])) {
382		$merged [$key] = $this->merge_distinct($merged [$key], $value);
383		} else {
384		$merged [$key] = $value;
385		}
386		}
387
388		return $merged;
389		}
390		}
391

ByTIC / framework

GitHub Access Token became invalid

Nip_Helper_Arrays F last analyzed 2017-08-07 20:36 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

16 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

Nip_Helper_Arrays F
last analyzed 2017-08-07 20:36 UTC