ArrayHelper::formatAttribute() - Code Metrics - Inspection of "Github-Action" - abterphp/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#1)

by Peter

created 2021-02-27 14:51 UTC

ArrayHelper::formatAttribute() B

↳ Parent: ArrayHelper

Complexity

Conditions	11
Paths	14

Size

Total Lines	35
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	11
eloc	18
nc	14
nop	1
dl	0
loc	35
rs	7.3166
c	1
b	0
f	0

How to fix Complexity

<?php

declare(strict_types=1);

namespace AbterPhp\Framework\Html\Helper;

class ArrayHelper
{
    protected const ERROR_INVALID_ATTRIBUTES = 'invalid attributes (array of string[] and null items)';

    /**
     * @param array $styles
     *
     * @return string
     */
    public static function toStyles(array $styles): string
    {
        $tmp = [];
        foreach ($styles as $k => $v) {
            $tmp[] = sprintf('%s: %s', $k, $v);
        }

        return implode('; ', $tmp);
    }

    /**
     * @param array  $attributes
     * @param string $prefix string to prepend if the result is not empty
     *
     * @return string
     */
    public static function toAttributes(array $attributes, string $prefix = ' '): string
    {
        $tmp = [];
        foreach ($attributes as $k => $v) {
            if (null === $v) {
                $tmp[] = (string)$k;
                continue;
            }

            $v = is_array($v) ? implode(' ', $v) : $v;

            $tmp[] = sprintf('%s="%s"', $k, $v);
        }

        if (empty($tmp)) {
            return '';
        }

        return $prefix . implode(' ', $tmp);
    }

    /**
     * Merges two sets of attributes, but without filtering out duplicates of any sort
     * (Developed to be used in factories before Component creation)
     *
     * @return array
     */
    public static function unsafeMergeAttributes(array $existing, array $new): array
    {
        foreach ($new as $key => $value) {
            if (!isset($existing[$key])) {
                $existing[$key] = $value;
            } else {
                $existing[$key] = array_merge((array)$existing[$key], (array)$new[$key]);
            }
        }

        return $existing;
    }

    /**
     * @param array $existing
     * @param array $new
     * @param bool  $safe if true, $existing will be formatted, which is of course slower.
     *                    should only be false if $existing is already formatted
     *
     * @return array
     */
    public static function mergeAttributes(array $existing, array $new, bool $safe = true): array
    {
        if ($safe) {
            foreach ($existing as $key => $value) {
                $existing[$key] = static::formatAttribute($value);
            }
        }

        foreach ($new as $key => $value) {
            $existingValue = isset($existing[$key]) ? $existing[$key] : [];
            $newValue      = static::formatAttribute($value);

            if ($newValue !== null) {
                $existing[$key] = array_merge($existingValue, $newValue);
            }
        }

        return $existing;
    }

    /**
     * @SuppressWarnings(PHPMD.CyclomaticComplexity)
     * @SuppressWarnings(PHPMD.NPathComplexity)
     *
     * Formats an attribute so that it's either null or an array of strings where:
     *  - keys and values are the same
     *  - keys (or values) must not have spaces
     *
     * @param $value
     *
     * @return array|null
     */
    public static function formatAttribute($value): ?array
    {
        static $realEmpty = [null, '', false];

        if (in_array($value, $realEmpty, true)) {
            return null;
        }

        if (!is_scalar($value) && !is_array($value)) {
            throw new \InvalidArgumentException(static::ERROR_INVALID_ATTRIBUTES);
        }

        if (is_scalar($value)) {
            $value = [(string)$value];
        }

        if (count($value) === 1 && in_array(current($value), $realEmpty, true)) {
            return null;
        }

        $newValue = [];
        foreach ($value as $v) {
            if (!is_scalar($v)) {
                throw new \InvalidArgumentException(static::ERROR_INVALID_ATTRIBUTES);
            }

            foreach (explode(' ', (string)$v) as $w) {
                if ('' === $w) {
                    continue;
                }
                $newValue[$w] = $w;
            }
        }

        return $newValue;
    }

    /**
     * @param array $parts
     *
     * @return string
     */
    public static function toQuery(array $parts): string
    {
        if (empty($parts)) {
            return '';
        }

        $tmp = [];
        foreach ($parts as $k => $v) {
            $tmp[] = sprintf('%s=%s', $k, urlencode($v));
        }

        return '?' . implode('&', $tmp);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace AbterPhp\Framework\Html\Helper;
6
7			class ArrayHelper
8			{
9			protected const ERROR_INVALID_ATTRIBUTES = 'invalid attributes (array of string[] and null items)';
10
11			/**
12			* @param array $styles
13			*
14			* @return string
15			*/
16			public static function toStyles(array $styles): string
17			{
18			$tmp = [];
19			foreach ($styles as $k => $v) {
20			$tmp[] = sprintf('%s: %s', $k, $v);
21			}
22
23			return implode('; ', $tmp);
24			}
25
26			/**
27			* @param array $attributes
28			* @param string $prefix string to prepend if the result is not empty
29			*
30			* @return string
31			*/
32			public static function toAttributes(array $attributes, string $prefix = ' '): string
33			{
34			$tmp = [];
35			foreach ($attributes as $k => $v) {
36			if (null === $v) {
37			$tmp[] = (string)$k;
38			continue;
39			}
40
41			$v = is_array($v) ? implode(' ', $v) : $v;
42
43			$tmp[] = sprintf('%s="%s"', $k, $v);
44			}
45
46			if (empty($tmp)) {
47			return '';
48			}
49
50			return $prefix . implode(' ', $tmp);
51			}
52
53			/**
54			* Merges two sets of attributes, but without filtering out duplicates of any sort
55			* (Developed to be used in factories before Component creation)
56			*
57			* @return array
58			*/
59			public static function unsafeMergeAttributes(array $existing, array $new): array
60			{
61			foreach ($new as $key => $value) {
62			if (!isset($existing[$key])) {
63			$existing[$key] = $value;
64			} else {
65			$existing[$key] = array_merge((array)$existing[$key], (array)$new[$key]);
66			}
67			}
68
69			return $existing;
70			}
71
72			/**
73			* @param array $existing
74			* @param array $new
75			* @param bool $safe if true, $existing will be formatted, which is of course slower.
76			* should only be false if $existing is already formatted
77			*
78			* @return array
79			*/
80			public static function mergeAttributes(array $existing, array $new, bool $safe = true): array
81			{
82			if ($safe) {
83			foreach ($existing as $key => $value) {
84			$existing[$key] = static::formatAttribute($value);
85			}
86			}
87
88			foreach ($new as $key => $value) {
89			$existingValue = isset($existing[$key]) ? $existing[$key] : [];
90			$newValue = static::formatAttribute($value);
91
92			if ($newValue !== null) {
93			$existing[$key] = array_merge($existingValue, $newValue);
94			}
95			}
96
97			return $existing;
98			}
99
100			/**
101			* @SuppressWarnings(PHPMD.CyclomaticComplexity)
102			* @SuppressWarnings(PHPMD.NPathComplexity)
103			*
104			* Formats an attribute so that it's either null or an array of strings where:
105			* - keys and values are the same
106			* - keys (or values) must not have spaces
107			*
108			* @param $value
109			*
110			* @return array\|null
111			*/
112			public static function formatAttribute($value): ?array
113			{
114			static $realEmpty = [null, '', false];
115
116			if (in_array($value, $realEmpty, true)) {
117			return null;
118			}
119
120			if (!is_scalar($value) && !is_array($value)) {
121			throw new \InvalidArgumentException(static::ERROR_INVALID_ATTRIBUTES);
122			}
123
124			if (is_scalar($value)) {
125			$value = [(string)$value];
126			}
127
128			if (count($value) === 1 && in_array(current($value), $realEmpty, true)) {
129			return null;
130			}
131
132			$newValue = [];
133			foreach ($value as $v) {
134			if (!is_scalar($v)) {
135			throw new \InvalidArgumentException(static::ERROR_INVALID_ATTRIBUTES);
136			}
137
138			foreach (explode(' ', (string)$v) as $w) {
139			if ('' === $w) {
140			continue;
141			}
142			$newValue[$w] = $w;
143			}
144			}
145
146			return $newValue;
147			}
148
149			/**
150			* @param array $parts
151			*
152			* @return string
153			*/
154			public static function toQuery(array $parts): string
155			{
156			if (empty($parts)) {
157			return '';
158			}
159
160			$tmp = [];
161			foreach ($parts as $k => $v) {
162			$tmp[] = sprintf('%s=%s', $k, urlencode($v));
163			}
164
165			return '?' . implode('&', $tmp);
166			}
167			}
168

abterphp / framework

Pull Request — master (#1)

ArrayHelper::formatAttribute() B

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like