Arrays - Code Metrics - Inspection of "refactor method to tag" - cs-eliseev/helpers-arrays - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 928216...38559e )

by Eliseev

created 2019-04-01 08:18 UTC

Arrays F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	407
Duplicated Lines	0 %

Importance

Changes

Metric	Value
eloc	123
dl	0
loc	407
rs	2.08
c	0
b	0
f	0
wmc	79

18 Methods

Rating	Name	Size	Complexity
A	objectToArray()	3	1
A	pullKey()	6	1
A	get()	5	2
A	index()	13	5
A	removeEmpty()	13	5
A	emptyToNull()	13	5
A	mergeNotEmptyData()	15	6
A	trim()	13	5
A	group()	17	6
A	toTags()	20	6
A	replaceEmptyNotEmptyData()	15	6
A	replaceNotEmptyData()	15	5
A	appendNotEmpty()	7	4
A	map()	13	5
A	toString()	9	2
A	appendNotEmptyData()	20	5
A	replaceTagInfo()	15	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);
    }

    /**
     * To string key and value
     *
     * @param array $data
     * @param string $preFix
     * @param string $postFix
     *
     * @return string
     */
    public static function toString(array $data, string $preFix = ':', $postFix = ';'): string
    {
        $string = '';

        foreach ($data as $key => $option) {
            $string .= $key . $preFix . $option . $postFix;
        }

        return $string;
    }

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

        foreach ($data as $key => $item) {
            $info = [];
            if (is_int($key)) {
                $info['tag'] = $item;
            } elseif (is_array($item)) {
                $info = self::replaceTagInfo($item);
                $info['tag'] = $key;
            } else {
                $info['content'] = $item;
                $info['tag'] = $key;
            }

            $string .= '<' . $info['tag'] . (empty($info['attr']) ? '' : $info['attr']) . (empty($info['content']) ? ' />' : '>' . $info['content'] . '</' . $info['tag'] . '>');
        }

        return $string;
    }

    /**
     * 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::appendNotEmpty($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;
    }

    /**
     * Append not empty
     *
     * @param array $first
     * @param array $second
     *
     * @return array
     */
    protected static function appendNotEmpty(array $first, array $second): array
    {
        foreach ($second as $key => $value) {
            if (!empty($value) && !array_key_exists($key, $first)) $first[$key] = $value;
        }

        return $first;
    }

    /**
     * Replace tag info
     *
     * @param array $info
     *
     * @return array
     */
    protected static function replaceTagInfo(array $info): array
    {
        $result = [];

        foreach ($info as $key => $item) {
            if (is_int($key) && is_array($item)) {
                $result['attr'] .= ' ' . trim(self::toString($item, '="', '" '));
            } elseif (is_int($key)) {
                $result['content'] = $item;
            } else {
                $result['attr'] .= ' ' . $key .'="' . $item . '"';
            }
        }

        return $result;
    }
}


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			* To string key and value
61			*
62			* @param array $data
63			* @param string $preFix
64			* @param string $postFix
65			*
66			* @return string
67			*/
68			public static function toString(array $data, string $preFix = ':', $postFix = ';'): string
69			{
70			$string = '';
71
72			foreach ($data as $key => $option) {
73			$string .= $key . $preFix . $option . $postFix;
74			}
75
76			return $string;
77			}
78
79			/**
80			* Array to html
81			*
82			* @param array $data
83			*
84			* @return string
85			*/
86			public static function toTags(array $data): string
87			{
88			$string = '';
89
90			foreach ($data as $key => $item) {
91			$info = [];
92			if (is_int($key)) {
93			$info['tag'] = $item;
94			} elseif (is_array($item)) {
95			$info = self::replaceTagInfo($item);
96			$info['tag'] = $key;
97			} else {
98			$info['content'] = $item;
99			$info['tag'] = $key;
100			}
101
102			$string .= '<' . $info['tag'] . (empty($info['attr']) ? '' : $info['attr']) . (empty($info['content']) ? ' />' : '>' . $info['content'] . '</' . $info['tag'] . '>');
103			}
104
105			return $string;
106			}
107
108			/**
109			* Building Maps
110			*
111			* @param $data
112			* @param $keyGroup
113			* @param $keyValue
114			*
115			* @return array
116			*/
117			public static function map(array $data, $keyGroup, $keyValue = null): array
118			{
119			$result = [];
120
121			foreach ($data as $item) {
122			if (array_key_exists($keyGroup, $item)) {
123			$result[$item[$keyGroup]] = is_null($keyValue) ? $item : (array_key_exists($keyValue, $item) ? $item[$keyValue] : null);
124			}
125			}
126
127			unset($item);
128
129			return $result;
130			}
131
132			/**
133			* Group array
134			*
135			* @param array $data
136			* @param $keyGroup
137			* @param $keyValue
138			*
139			* @return array
140			*/
141			public static function group(array $data, $keyGroup, $keyValue = null): array
142			{
143			$result = [];
144
145			foreach ($data as $item) {
146			if (array_key_exists($keyGroup, $item)) {
147			$key = $item[$keyGroup];
148
149			if (empty($result[$key])) $result[$key] = [];
150
151			$result[$key][] = is_null($keyValue) ? $item : (array_key_exists($keyValue, $item) ? $item[$keyValue] : null);
152			}
153			}
154
155			unset($item, $key);
156
157			return $result;
158			}
159			/**
160			* Index group array
161			*
162			* @param array $data
163			* @param $keyGroup
164			* @param $keyValue
165			*
166			* @return array
167			*/
168			public static function index(array $data, $keyGroup, $keyValue = null): array
169			{
170			$result = [];
171
172			foreach ($data as $item) {
173			if (array_key_exists($keyGroup, $item)) {
174			$result[$item[$keyGroup]][] = is_null($keyValue) ? $item : (array_key_exists($keyValue, $item) ? $item[$keyValue] : null);
175			}
176			}
177
178			unset($item);
179
180			return $result;
181			}
182
183			/**
184			* Append not empty array data
185			*
186			* @param array $first
187			* @param array $second
188			*
189			* @return array
190			*/
191			public static function appendNotEmptyData(array $first, array $second): array
192			{
193			$result = null;
194
195			switch (true) {
196			case empty($first) && empty($second):
197			$result = [];
198			break;
199			case empty($second):
200			$result = $first;
201			break;
202			case empty($first):
203			$result = self::removeEmpty($second);
204			break;
205			default:
206			$result = self::appendNotEmpty($first, $second);
207			break;
208			}
209
210			return $result;
211			}
212
213			/**
214			* Replace empty array data to not empty array data
215			*
216			* @param array $first
217			* @param array $second
218			*
219			* @return array
220			*/
221			public static function replaceEmptyNotEmptyData(array $first, array $second): array
222			{
223			if (empty($first)) {
224			return [];
225			} elseif (empty($second)) {
226			return $first;
227			}
228
229			foreach ($first as $key => &$value) {
230			if (empty($value) && array_key_exists($key, $second)) $value = $second[$key];
231			}
232
233			unset($value, $key, $second);
234
235			return $first;
236			}
237
238			/**
239			* Replace not empty array data
240			*
241			* @param array $first
242			* @param array $second
243			*
244			* @return array
245			*/
246			public static function replaceNotEmptyData(array $first, array $second): array
247			{
248			if (empty($first)) {
249			return [];
250			} elseif (empty($second)) {
251			return $first;
252			}
253
254			foreach ($first as $key => &$value) {
255			if (!empty($second[$key])) $value = $second[$key];
256			}
257
258			unset($value, $key, $second);
259
260			return $first;
261			}
262
263			/**
264			* Merge not empty array data
265			*
266			* @param array $first
267			* @param array $second
268			*
269			* @return array
270			*/
271			public static function mergeNotEmptyData(array $first, array $second): array
272			{
273			if (empty($first) && empty($second)) {
274			return [];
275			} elseif (empty($second)) {
276			return $first;
277			}
278
279			foreach ($second as $key => $value) {
280			if (!empty($value)) $first[$key] = $value;
281			}
282
283			unset($value, $key);
284
285			return $first;
286			}
287
288			/**
289			* Convert empty to null
290			*
291			* @param array $data
292			* @param bool $recursive
293			*
294			* @return array
295			*/
296			public static function emptyToNull(array $data, bool $recursive = false): array
297			{
298			foreach ($data as $key => &$value) {
299			if (empty($value)) {
300			$value = null;
301			} elseif ($recursive && is_array($value)) {
302			$value = self::emptyToNull($value, $recursive);
303			}
304			}
305
306			unset($value, $key);
307
308			return $data;
309			}
310
311			/**
312			* Remove empty data to array
313			*
314			* @param array $data
315			* @param bool $recursive
316			*
317			* @return array
318			*/
319			public static function removeEmpty(array $data, bool $recursive = false): array
320			{
321			foreach ($data as $key => &$value) {
322			if (empty($value)) {
323			unset($data[$key]);
324			} elseif ($recursive && is_array($value)) {
325			$value = self::removeEmpty($value, $recursive);
326			}
327			}
328
329			unset($value, $key);
330
331			return $data;
332			}
333
334			/**
335			* Remove null data to array
336			*
337			* @param array $data
338			* @param bool $recursive
339			*
340			* @return array
341			*/
342			public static function removeNull(array $data, bool $recursive = false): array
343			{
344			foreach ($data as $key => &$value) {
345			if (is_null($value)) {
346			unset($data[$key]);
347			} elseif ($recursive && is_array($value)) {
348			$value = self::removeNull($value, $recursive);
349			}
350			}
351
352			unset($value, $key);
353
354			return $data;
355			}
356
357			/**
358			* Trim value to array
359			*
360			* @param array $data
361			* @param bool $recursive
362			*
363			* @return array
364			*/
365			public static function trim(array $data, bool $recursive = true): array
366			{
367			foreach ($data as $key => &$value) {
368			if (is_string($value)) {
369			$value = trim($value);
370			} elseif ($recursive && is_array($value)) {
371			$value = self::trim($value);
372			}
373			}
374
375			unset($value, $key);
376
377			return $data;
378			}
379
380			/**
381			* Append not empty
382			*
383			* @param array $first
384			* @param array $second
385			*
386			* @return array
387			*/
388			protected static function appendNotEmpty(array $first, array $second): array
389			{
390			foreach ($second as $key => $value) {
391			if (!empty($value) && !array_key_exists($key, $first)) $first[$key] = $value;
392			}
393
394			return $first;
395			}
396
397			/**
398			* Replace tag info
399			*
400			* @param array $info
401			*
402			* @return array
403			*/
404			protected static function replaceTagInfo(array $info): array
405			{
406			$result = [];
407
408			foreach ($info as $key => $item) {
409			if (is_int($key) && is_array($item)) {
410			$result['attr'] .= ' ' . trim(self::toString($item, '="', '" '));
411			} elseif (is_int($key)) {
412			$result['content'] = $item;
413			} else {
414			$result['attr'] .= ' ' . $key .'="' . $item . '"';
415			}
416			}
417
418			return $result;
419			}
420			}
421

cs-eliseev / helpers-arrays

Push — master ( 928216...38559e )

Arrays F

Complexity

Size/Duplication

Importance

18 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like