ElementConstructorTrait::parseAttributesReal() - Code Metrics - spider-mane/html - Measure and Improve Code Quality continuously with Scrutinizer

ElementConstructorTrait::parseAttributesReal() C
last analyzed 2022-05-24 01:00 UTC

↳ Parent: ElementConstructorTrait

Complexity

Conditions	16
Paths	12

Size

Total Lines	65
Code Lines	28

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	272

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	16
eloc	28
nc	12
nop	2
dl	0
loc	65
ccs	0
cts	29
cp	0
crap	272
rs	5.5666
c	1
b	0
f	0

How to fix Long Method Complexity

<?php

namespace WebTheory\Html\Traits;

use WebTheory\Html\Contracts\HtmlAttributeInterface;
use WebTheory\Html\TagSage;

trait ElementConstructorTrait
{
    protected static function parseAttributes(array $attributes): string
    {
        return static::parseAttributesRealSwitch($attributes);
    }

    protected static function parseAttributesReal(array $attrArr, string &$attrStr = ''): string
    {
        foreach ($attrArr as $attr => $val) {

            // don't add empty strings or null values
            if ('' === $val && 'value' !== $attr || null === $val) {

                continue;
            }

            // treat numerical keys as boolean values
            if (is_int($attr)) {
                $attrStr .= static::renderAttribute($val, (string) $val);

                continue;
            }

            // simple attribute
            if (is_string($val) || is_numeric($val)) {
                $attrStr .= static::renderAttribute($attr, $val);

                continue;
            }

            // support interface for defining custom parsing schemes
            if ($val instanceof HtmlAttributeInterface) {
                $attrStr .= static::renderAttribute($attr, $val->parse());

                continue;
            }

            // boolean attribute
            if ($val === true) {
                $attrStr .= static::renderAttribute($attr, $attr);

                continue;
            }

            // support for passing an array of boolean values
            if ('@boolean' === $attr) {
                foreach ((array) $val as $bool) {
                    $attrStr .= static::renderAttribute($bool, $bool);
                }

                continue;
            }

            // support for converting indexed array to DOMTokenList
            if (is_array($val) && isset($val[0])) {
                $val = implode(' ', array_filter($val));
                $attrStr .= static::renderAttribute($attr, $val);

                continue;
            }

            // support for converting associative array to DOMStringMap
            if (is_array($val)) {
                foreach ($val as $set => $setval) {
                    static::parseAttributesReal(["{$attr}-{$set}" => $setval], $attrStr);
                }

                continue;
            }
        }

        return $attrStr;
    }

    protected static function parseAttributesRealSwitch(array $attrArr, string &$attrStr = ''): string
    {
        foreach ($attrArr as $attr => $val) {
            switch (true) {
                    // don't add empty strings or null values
                case ('' === $val && 'value' !== $attr || null === $val):
                    break;

                    // treat numerical keys as boolean values
                case (is_int($attr)):
                    $attrStr .= static::renderAttribute($val, (string) $val);

                    break;

                    // simple attribute
                case (is_string($val) || is_numeric($val)):
                    $attrStr .= static::renderAttribute($attr, $val);

                    break;

                    // support interface for defining custom parsing schemes
                case ($val instanceof HtmlAttributeInterface):
                    $attrStr .= static::renderAttribute($attr, $val->parse());

                    break;

                    // boolean attribute
                case ($val === true):
                    $attrStr .= static::renderAttribute($attr, $attr);

                    break;

                    // support for passing an array of boolean values
                case ('@bool' === $attr):
                    foreach ((array) $val as $bool) {
                        $attrStr .= static::renderAttribute($bool, $bool);
                    }

                    break;

                    // support for converting indexed array to DOMTokenList
                case (is_array($val) && isset($val[0])):
                    $val = implode(' ', array_filter($val));
                    $attrStr .= static::renderAttribute($attr, $val);

                    break;

                    // support for converting associative array to DOMStringMap
                case (is_array($val)):
                    foreach ($val as $set => $setval) {
                        static::parseAttributesRealSwitch(["{$attr}-{$set}" => $setval], $attrStr);
                    }

                    break;
            }
        }

        return $attrStr;
    }

    protected static function renderAttribute(string $attribute, string $value): string
    {
        $value = static::escapeAttribute($value);

        return " {$attribute}=\"{$value}\"";
    }

    protected static function escapeAttribute(string $attribute): string
    {
        return htmlspecialchars($attribute);
    }

    protected static function tag(string $tag, array $attributes = [], string $inner = ''): string
    {
        return static::open($tag, $attributes) . static::maybeClose($tag, $inner);
    }

    protected static function open(string $tag, array $attributes = []): string
    {
        $attributes = static::maybeParseAttributes($attributes);
        $slash = static::maybeAddSlash($tag);

        return "<{$tag}{$attributes}{$slash}>";
    }

    protected static function close(string $tag): string
    {
        return "</{$tag}>";
    }

    protected static function maybeClose(string $tag, string $inner = ''): string
    {
        return static::tagIsVoid($tag) ? '' : $inner . static::close($tag);
    }

    protected static function maybeParseAttributes(array $attributes): string
    {
        return empty($attributes) ? '' : static::parseAttributes($attributes);
    }

    protected static function maybeAddSlash(string $tag): string
    {
        return static::tagIsVoid($tag) ? ' /' : '';
    }

    protected static function tagIsVoid(string $tag): bool
    {
        return TagSage::isIt('self_closing', $tag);
    }

    protected static function indent(int $levels = 0): string
    {
        return str_repeat('&nbsp;', $levels);
    }

    protected static function newLine(bool $newLine = false): string
    {
        return $newLine ? "\n" : '';
    }
}


1			<?php
2
3			namespace WebTheory\Html\Traits;
4
5			use WebTheory\Html\Contracts\HtmlAttributeInterface;
6			use WebTheory\Html\TagSage;
7
8			trait ElementConstructorTrait
9			{
10			protected static function parseAttributes(array $attributes): string
11			{
12			return static::parseAttributesRealSwitch($attributes);
13			}
14
15			protected static function parseAttributesReal(array $attrArr, string &$attrStr = ''): string
16			{
17			foreach ($attrArr as $attr => $val) {
18
19			// don't add empty strings or null values
20			if ('' === $val && 'value' !== $attr \|\| null === $val) {
			0 ignored issues – show introduced 2022-05-23 20:03 UTC by Report Bug Copy Issue Report Consider adding parentheses for clarity. Current Interpretation: `('' === $val && 'value' ...$attr) \|\| null === $val`, Probably Intended Meaning: `'' === $val && ('value' ...$attr \|\| null === $val)` Loading history...
21			continue;
22			}
23
24			// treat numerical keys as boolean values
25			if (is_int($attr)) {
26			$attrStr .= static::renderAttribute($val, (string) $val);
27
28			continue;
29			}
30
31			// simple attribute
32			if (is_string($val) \|\| is_numeric($val)) {
33			$attrStr .= static::renderAttribute($attr, $val);
34
35			continue;
36			}
37
38			// support interface for defining custom parsing schemes
39			if ($val instanceof HtmlAttributeInterface) {
40			$attrStr .= static::renderAttribute($attr, $val->parse());
41
42			continue;
43			}
44
45			// boolean attribute
46			if ($val === true) {
47			$attrStr .= static::renderAttribute($attr, $attr);
48
49			continue;
50			}
51
52			// support for passing an array of boolean values
53			if ('@boolean' === $attr) {
54			foreach ((array) $val as $bool) {
55			$attrStr .= static::renderAttribute($bool, $bool);
56			}
57
58			continue;
59			}
60
61			// support for converting indexed array to DOMTokenList
62			if (is_array($val) && isset($val[0])) {
63			$val = implode(' ', array_filter($val));
64			$attrStr .= static::renderAttribute($attr, $val);
65
66			continue;
67			}
68
69			// support for converting associative array to DOMStringMap
70			if (is_array($val)) {
71			foreach ($val as $set => $setval) {
72			static::parseAttributesReal(["{$attr}-{$set}" => $setval], $attrStr);
73			}
74
75			continue;
76			}
77			}
78
79			return $attrStr;
80			}
81
82			protected static function parseAttributesRealSwitch(array $attrArr, string &$attrStr = ''): string
83			{
84			foreach ($attrArr as $attr => $val) {
85			switch (true) {
86			// don't add empty strings or null values
87			case ('' === $val && 'value' !== $attr \|\| null === $val):
88			break;
89
90			// treat numerical keys as boolean values
91			case (is_int($attr)):
92			$attrStr .= static::renderAttribute($val, (string) $val);
93
94			break;
95
96			// simple attribute
97			case (is_string($val) \|\| is_numeric($val)):
98			$attrStr .= static::renderAttribute($attr, $val);
99
100			break;
101
102			// support interface for defining custom parsing schemes
103			case ($val instanceof HtmlAttributeInterface):
104			$attrStr .= static::renderAttribute($attr, $val->parse());
105
106			break;
107
108			// boolean attribute
109			case ($val === true):
110			$attrStr .= static::renderAttribute($attr, $attr);
111
112			break;
113
114			// support for passing an array of boolean values
115			case ('@bool' === $attr):
116			foreach ((array) $val as $bool) {
117			$attrStr .= static::renderAttribute($bool, $bool);
118			}
119
120			break;
121
122			// support for converting indexed array to DOMTokenList
123			case (is_array($val) && isset($val[0])):
124			$val = implode(' ', array_filter($val));
125			$attrStr .= static::renderAttribute($attr, $val);
126
127			break;
128
129			// support for converting associative array to DOMStringMap
130			case (is_array($val)):
131			foreach ($val as $set => $setval) {
132			static::parseAttributesRealSwitch(["{$attr}-{$set}" => $setval], $attrStr);
133			}
134
135			break;
136			}
137			}
138
139			return $attrStr;
140			}
141
142			protected static function renderAttribute(string $attribute, string $value): string
143			{
144			$value = static::escapeAttribute($value);
145
146			return " {$attribute}=\"{$value}\"";
147			}
148
149			protected static function escapeAttribute(string $attribute): string
150			{
151			return htmlspecialchars($attribute);
152			}
153
154			protected static function tag(string $tag, array $attributes = [], string $inner = ''): string
155			{
156			return static::open($tag, $attributes) . static::maybeClose($tag, $inner);
157			}
158
159			protected static function open(string $tag, array $attributes = []): string
160			{
161			$attributes = static::maybeParseAttributes($attributes);
162			$slash = static::maybeAddSlash($tag);
163
164			return "<{$tag}{$attributes}{$slash}>";
165			}
166
167			protected static function close(string $tag): string
168			{
169			return "</{$tag}>";
170			}
171
172			protected static function maybeClose(string $tag, string $inner = ''): string
173			{
174			return static::tagIsVoid($tag) ? '' : $inner . static::close($tag);
175			}
176
177			protected static function maybeParseAttributes(array $attributes): string
178			{
179			return empty($attributes) ? '' : static::parseAttributes($attributes);
180			}
181
182			protected static function maybeAddSlash(string $tag): string
183			{
184			return static::tagIsVoid($tag) ? ' /' : '';
185			}
186
187			protected static function tagIsVoid(string $tag): bool
188			{
189			return TagSage::isIt('self_closing', $tag);
190			}
191
192			protected static function indent(int $levels = 0): string
193			{
194			return str_repeat(' ', $levels);
195			}
196
197			protected static function newLine(bool $newLine = false): string
198			{
199			return $newLine ? "\n" : '';
200			}
201			}
202

spider-mane / html

ElementConstructorTrait::parseAttributesReal() C last analyzed 2022-05-24 01:00 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

ElementConstructorTrait::parseAttributesReal() C
last analyzed 2022-05-24 01:00 UTC