Arrays - Code Metrics - Inspection of "remove duplicate code" - cs-eliseev/helpers-arrays - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 8ed8d6...840195 )

by Eliseev

created 2019-04-01 07:09 UTC

Arrays F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	362
Duplicated Lines	0 %

Importance

Changes

Metric	Value
eloc	116
dl	0
loc	362
rs	2.56
c	0
b	0
f	0
wmc	73

15 Methods

Rating	Name	Size	Complexity
A	index()	13	5
A	objectToArray()	3	1
A	pullKey()	6	1
A	get()	5	2
A	group()	17	6
B	toTags()	36	11
A	map()	13	5
A	removeEmpty()	13	5
A	emptyToNull()	13	5
A	mergeNotEmptyData()	15	6
A	trim()	13	5
A	replaceEmptyNotEmptyData()	15	6
A	replaceNotEmptyData()	15	5
A	appendNotEmptyData()	20	5
A	removeNull()	13	5

How to fix Complexity

<?php

declare(strict_types=1);

namespace cse\helpers;

/**
 * Class Arrays
 *
 * @package cse\helpers
 */
class Arrays
{
    /**
     * Get array value by key
     *
     * @param array $data
     * @param $key
     * @param $default
     *
     * @return mixed|null
     */
    public static function get(array $data, $key, $default = null)
    {
        if (!array_key_exists($key, $data)) return $default;

        return $data[$key];
    }

    /**
     * Pull array key
     *
     * @param array $data
     * @param $key
     * @param $default
     *
     * @return mixed|null
     */
    public static function pullKey(array &$data, $key, $default = null)
    {
        $result = self::get($data, $key, $default);
        unset($data[$key]);

        return $result;
    }

    /**
     * Object to array
     *
     * @param $data
     *
     * @return array
     */
    public static function objectToArray($data): array
    {
        return json_decode(json_encode($data), true);
    }

    /**
     * Array to html
     *
     * @param array $data
     *
     * @return string
     */
    public static function toTags(array $data): string
    {
        $result = [];

        foreach ($data as $key => $item) {
            if (is_int($key)) {
                $tag = $item;
            } else {
                $tag = $key;

                if (is_array($item)) {
                    $options = '';
                    $content = '';

                    foreach ($item as $key2 => $item2) {
                        if (is_int($key2) && is_array($item2)) {
                            foreach ($item2 as $name => $value) {
                                $options .= ' ' . $name .'="' . $value . '"';
                            }
                        } elseif (is_int($key2)) {
                            $content = $item2;
                        } else {
                            $options .= ' ' . $key2 .'="' . $item2 . '"';
                        }
                    }

                } else {
                    $content = $item;
                }
            }

            $result[] = '<' . $tag . (empty($options) ? '' : $options) . (empty($content) ? ' />' : '>' . $content . '</' . $tag . '>');
            unset($options, $content, $tag);
        }

        return implode(PHP_EOL, $result);
    }

    /**
     * Building Maps
     *
     * @param $data
     * @param $keyGroup
     * @param $keyValue
     *
     * @return array
     */
    public static function map(array $data, $keyGroup, $keyValue = null): array
    {
        $result = [];

        foreach ($data as $item) {
            if (array_key_exists($keyGroup, $item)) {
                $result[$item[$keyGroup]] = is_null($keyValue) ? $item : (array_key_exists($keyValue, $item) ? $item[$keyValue] : null);
            }
        }

        unset($item);

        return $result;
    }

    /**
     * Group array
     *
     * @param array $data
     * @param $keyGroup
     * @param $keyValue
     *
     * @return array
     */
    public static function group(array $data, $keyGroup, $keyValue = null): array
    {
        $result = [];

        foreach ($data as $item) {
            if (array_key_exists($keyGroup, $item)) {
                $key = $item[$keyGroup];

                if (empty($result[$key])) $result[$key] = [];

                $result[$key][] = is_null($keyValue) ? $item : (array_key_exists($keyValue, $item) ? $item[$keyValue] : null);
            }
        }

        unset($item, $key);

        return $result;
    }
    /**
     * Index group array
     *
     * @param array $data
     * @param $keyGroup
     * @param $keyValue
     *
     * @return array
     */
    public static function index(array $data, $keyGroup, $keyValue = null): array
    {
        $result = [];

        foreach ($data as $item) {
            if (array_key_exists($keyGroup, $item)) {
                $result[$item[$keyGroup]][] = is_null($keyValue) ? $item : (array_key_exists($keyValue, $item) ? $item[$keyValue] : null);
            }
        }

        unset($item);

        return $result;
    }

    /**
     * Append not empty array data
     *
     * @param array $first
     * @param array $second
     *
     * @return array
     */
    public static function appendNotEmptyData(array $first, array $second): array
    {
        $result = null;

        switch (true) {
            case empty($first) && empty($second):
                $result = [];
                break;
            case empty($second):
                $result = $first;
                break;
            case empty($first):
                $result = self::removeEmpty($second);
                break;
            default:
                $result = self::mergeNotEmptyData($first, $second);
                break;
        }

        return $result;
    }

    /**
     * Replace empty array data to not empty array data
     *
     * @param array $first
     * @param array $second
     *
     * @return array
     */
    public static function replaceEmptyNotEmptyData(array $first, array $second): array
    {
        if (empty($first)) {
            return [];
        } elseif (empty($second)) {
            return $first;
        }

        foreach ($first as $key => &$value) {
            if (empty($value) && array_key_exists($key, $second)) $value = $second[$key];
        }

        unset($value, $key, $second);

        return $first;
    }

    /**
     * Replace not empty array data
     *
     * @param array $first
     * @param array $second
     *
     * @return array
     */
    public static function replaceNotEmptyData(array $first, array $second): array
    {
        if (empty($first)) {
            return [];
        } elseif (empty($second)) {
            return $first;
        }

        foreach ($first as $key => &$value) {
            if (!empty($second[$key])) $value = $second[$key];
        }

        unset($value, $key, $second);

        return $first;
    }

    /**
     * Merge not empty array data
     *
     * @param array $first
     * @param array $second
     *
     * @return array
     */
    public static function mergeNotEmptyData(array $first, array $second): array
    {
        if (empty($first) && empty($second)) {
            return [];
        } elseif (empty($second)) {
            return $first;
        }

        foreach ($second as $key => $value) {
            if (!empty($value)) $first[$key] = $value;
        }

        unset($value, $key);

        return $first;
    }

    /**
     * Convert empty to null
     *
     * @param array $data
     * @param bool $recursive
     *
     * @return array
     */
    public static function emptyToNull(array $data, bool $recursive = false): array
    {
        foreach ($data as $key => &$value) {
            if (empty($value)) {
                $value = null;
            } elseif ($recursive && is_array($value)) {
                $value = self::emptyToNull($value, $recursive);
            }
        }

        unset($value, $key);

        return $data;
    }

    /**
     * Remove empty data to array
     *
     * @param array $data
     * @param bool $recursive
     *
     * @return array
     */
    public static function removeEmpty(array $data, bool $recursive = false): array
    {
        foreach ($data as $key => &$value) {
            if (empty($value)) {
                unset($data[$key]);
            } elseif ($recursive && is_array($value)) {
                $value = self::removeEmpty($value, $recursive);
            }
        }

        unset($value, $key);

        return $data;
    }

    /**
     * Remove null data to array
     *
     * @param array $data
     * @param bool $recursive
     *
     * @return array
     */
    public static function removeNull(array $data, bool $recursive = false): array
    {
        foreach ($data as $key => &$value) {
            if (is_null($value)) {
                unset($data[$key]);
            } elseif ($recursive && is_array($value)) {
                $value = self::removeNull($value, $recursive);
            }
        }

        unset($value, $key);

        return $data;
    }

    /**
     * Trim value to array
     *
     * @param array $data
     * @param bool $recursive
     *
     * @return array
     */
    public static function trim(array $data, bool $recursive = true): array
    {
        foreach ($data as $key => &$value) {
            if (is_string($value)) {
                $value = trim($value);
            } elseif ($recursive && is_array($value)) {
                $value = self::trim($value);
            }
        }

        unset($value, $key);

        return $data;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace cse\helpers;
6
7			/**
8			* Class Arrays
9			*
10			* @package cse\helpers
11			*/
12			class Arrays
13			{
14			/**
15			* Get array value by key
16			*
17			* @param array $data
18			* @param $key
19			* @param $default
20			*
21			* @return mixed\|null
22			*/
23			public static function get(array $data, $key, $default = null)
24			{
25			if (!array_key_exists($key, $data)) return $default;
26
27			return $data[$key];
28			}
29
30			/**
31			* Pull array key
32			*
33			* @param array $data
34			* @param $key
35			* @param $default
36			*
37			* @return mixed\|null
38			*/
39			public static function pullKey(array &$data, $key, $default = null)
40			{
41			$result = self::get($data, $key, $default);
42			unset($data[$key]);
43
44			return $result;
45			}
46
47			/**
48			* Object to array
49			*
50			* @param $data
51			*
52			* @return array
53			*/
54			public static function objectToArray($data): array
55			{
56			return json_decode(json_encode($data), true);
57			}
58
59			/**
60			* Array to html
61			*
62			* @param array $data
63			*
64			* @return string
65			*/
66			public static function toTags(array $data): string
67			{
68			$result = [];
69
70			foreach ($data as $key => $item) {
71			if (is_int($key)) {
72			$tag = $item;
73			} else {
74			$tag = $key;
75
76			if (is_array($item)) {
77			$options = '';
78			$content = '';
79
80			foreach ($item as $key2 => $item2) {
81			if (is_int($key2) && is_array($item2)) {
82			foreach ($item2 as $name => $value) {
83			$options .= ' ' . $name .'="' . $value . '"';
84			}
85			} elseif (is_int($key2)) {
86			$content = $item2;
87			} else {
88			$options .= ' ' . $key2 .'="' . $item2 . '"';
89			}
90			}
91
92			} else {
93			$content = $item;
94			}
95			}
96
97			$result[] = '<' . $tag . (empty($options) ? '' : $options) . (empty($content) ? ' />' : '>' . $content . '</' . $tag . '>');
98			unset($options, $content, $tag);
99			}
100
101			return implode(PHP_EOL, $result);
102			}
103
104			/**
105			* Building Maps
106			*
107			* @param $data
108			* @param $keyGroup
109			* @param $keyValue
110			*
111			* @return array
112			*/
113			public static function map(array $data, $keyGroup, $keyValue = null): array
114			{
115			$result = [];
116
117			foreach ($data as $item) {
118			if (array_key_exists($keyGroup, $item)) {
119			$result[$item[$keyGroup]] = is_null($keyValue) ? $item : (array_key_exists($keyValue, $item) ? $item[$keyValue] : null);
120			}
121			}
122
123			unset($item);
124
125			return $result;
126			}
127
128			/**
129			* Group array
130			*
131			* @param array $data
132			* @param $keyGroup
133			* @param $keyValue
134			*
135			* @return array
136			*/
137			public static function group(array $data, $keyGroup, $keyValue = null): array
138			{
139			$result = [];
140
141			foreach ($data as $item) {
142			if (array_key_exists($keyGroup, $item)) {
143			$key = $item[$keyGroup];
144
145			if (empty($result[$key])) $result[$key] = [];
146
147			$result[$key][] = is_null($keyValue) ? $item : (array_key_exists($keyValue, $item) ? $item[$keyValue] : null);
148			}
149			}
150
151			unset($item, $key);
152
153			return $result;
154			}
155			/**
156			* Index group array
157			*
158			* @param array $data
159			* @param $keyGroup
160			* @param $keyValue
161			*
162			* @return array
163			*/
164			public static function index(array $data, $keyGroup, $keyValue = null): array
165			{
166			$result = [];
167
168			foreach ($data as $item) {
169			if (array_key_exists($keyGroup, $item)) {
170			$result[$item[$keyGroup]][] = is_null($keyValue) ? $item : (array_key_exists($keyValue, $item) ? $item[$keyValue] : null);
171			}
172			}
173
174			unset($item);
175
176			return $result;
177			}
178
179			/**
180			* Append not empty array data
181			*
182			* @param array $first
183			* @param array $second
184			*
185			* @return array
186			*/
187			public static function appendNotEmptyData(array $first, array $second): array
188			{
189			$result = null;
190
191			switch (true) {
192			case empty($first) && empty($second):
193			$result = [];
194			break;
195			case empty($second):
196			$result = $first;
197			break;
198			case empty($first):
199			$result = self::removeEmpty($second);
200			break;
201			default:
202			$result = self::mergeNotEmptyData($first, $second);
203			break;
204			}
205
206			return $result;
207			}
208
209			/**
210			* Replace empty array data to not empty array data
211			*
212			* @param array $first
213			* @param array $second
214			*
215			* @return array
216			*/
217			public static function replaceEmptyNotEmptyData(array $first, array $second): array
218			{
219			if (empty($first)) {
220			return [];
221			} elseif (empty($second)) {
222			return $first;
223			}
224
225			foreach ($first as $key => &$value) {
226			if (empty($value) && array_key_exists($key, $second)) $value = $second[$key];
227			}
228
229			unset($value, $key, $second);
230
231			return $first;
232			}
233
234			/**
235			* Replace not empty array data
236			*
237			* @param array $first
238			* @param array $second
239			*
240			* @return array
241			*/
242			public static function replaceNotEmptyData(array $first, array $second): array
243			{
244			if (empty($first)) {
245			return [];
246			} elseif (empty($second)) {
247			return $first;
248			}
249
250			foreach ($first as $key => &$value) {
251			if (!empty($second[$key])) $value = $second[$key];
252			}
253
254			unset($value, $key, $second);
255
256			return $first;
257			}
258
259			/**
260			* Merge not empty array data
261			*
262			* @param array $first
263			* @param array $second
264			*
265			* @return array
266			*/
267			public static function mergeNotEmptyData(array $first, array $second): array
268			{
269			if (empty($first) && empty($second)) {
270			return [];
271			} elseif (empty($second)) {
272			return $first;
273			}
274
275			foreach ($second as $key => $value) {
276			if (!empty($value)) $first[$key] = $value;
277			}
278
279			unset($value, $key);
280
281			return $first;
282			}
283
284			/**
285			* Convert empty to null
286			*
287			* @param array $data
288			* @param bool $recursive
289			*
290			* @return array
291			*/
292			public static function emptyToNull(array $data, bool $recursive = false): array
293			{
294			foreach ($data as $key => &$value) {
295			if (empty($value)) {
296			$value = null;
297			} elseif ($recursive && is_array($value)) {
298			$value = self::emptyToNull($value, $recursive);
299			}
300			}
301
302			unset($value, $key);
303
304			return $data;
305			}
306
307			/**
308			* Remove empty data to array
309			*
310			* @param array $data
311			* @param bool $recursive
312			*
313			* @return array
314			*/
315			public static function removeEmpty(array $data, bool $recursive = false): array
316			{
317			foreach ($data as $key => &$value) {
318			if (empty($value)) {
319			unset($data[$key]);
320			} elseif ($recursive && is_array($value)) {
321			$value = self::removeEmpty($value, $recursive);
322			}
323			}
324
325			unset($value, $key);
326
327			return $data;
328			}
329
330			/**
331			* Remove null data to array
332			*
333			* @param array $data
334			* @param bool $recursive
335			*
336			* @return array
337			*/
338			public static function removeNull(array $data, bool $recursive = false): array
339			{
340			foreach ($data as $key => &$value) {
341			if (is_null($value)) {
342			unset($data[$key]);
343			} elseif ($recursive && is_array($value)) {
344			$value = self::removeNull($value, $recursive);
345			}
346			}
347
348			unset($value, $key);
349
350			return $data;
351			}
352
353			/**
354			* Trim value to array
355			*
356			* @param array $data
357			* @param bool $recursive
358			*
359			* @return array
360			*/
361			public static function trim(array $data, bool $recursive = true): array
362			{
363			foreach ($data as $key => &$value) {
364			if (is_string($value)) {
365			$value = trim($value);
366			} elseif ($recursive && is_array($value)) {
367			$value = self::trim($value);
368			}
369			}
370
371			unset($value, $key);
372
373			return $data;
374			}
375			}
376

cs-eliseev / helpers-arrays

Push — master ( 8ed8d6...840195 )

Arrays F

Complexity

Size/Duplication

Importance

15 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like