Normalizer::parseAttributes() - Code Metrics - pryley/castor-framework - Measure and Improve Code Quality continuously with Scrutinizer

Normalizer::parseAttributes() A
last analyzed 2023-03-11 16:13 UTC

↳ Parent: Normalizer

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	5
nc	2
nop	2
dl	0
loc	10
rs	10
c	0
b	0
f	0

<?php

namespace GeminiLabs\Castor\Services;

class Normalizer
{
    const BOOLEAN_ATTRIBUTES = [
        'autofocus', 'capture', 'checked', 'disabled', 'draggable', 'formnovalidate', 'hidden',
        'multiple', 'novalidate', 'readonly', 'required', 'selected', 'spellcheck',
        'webkitdirectory',
    ];

    const FORM_ATTRIBUTES = [
        'accept', 'accept-charset', 'action', 'autocapitalize', 'autocomplete', 'enctype',
        'method', 'name', 'novalidate', 'target',
    ];

    const GLOBAL_ATTRIBUTES = [
        'accesskey', 'class', 'contenteditable', 'contextmenu', 'dir', 'draggable', 'dropzone',
        'hidden', 'id', 'lang', 'spellcheck', 'style', 'tabindex', 'title',
    ];

    const GLOBAL_WILDCARD_ATTRIBUTES = [
        'aria-', 'data-', 'item', 'on',
    ];

    const INPUT_ATTRIBUTES = [
        'accept', 'autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'capture',
        'checked', 'disabled', 'form', 'formaction', 'formenctype', 'formmethod',
        'formnovalidate', 'formtarget', 'height', 'incremental', 'inputmode', 'list', 'max',
        'maxlength', 'min', 'minlength', 'mozactionhint', 'multiple', 'name', 'pattern',
        'placeholder', 'readonly', 'required', 'results', 'selectionDirection', 'size', 'src',
        'step', 'type', 'value', 'webkitdirectory', 'width', 'x-moz-errormessage',
    ];

    const INPUT_TYPES = [
        'button', 'checkbox', 'color', 'date', 'datetime', 'datetime-local', 'email', 'file',
        'hidden', 'image', 'max', 'min', 'month', 'number', 'password', 'radio', 'range',
        'reset', 'search', 'step', 'submit', 'tel', 'text', 'time', 'url', 'value', 'week',
    ];

    const SELECT_ATTRIBUTES = [
        'autofocus', 'disabled', 'form', 'multiple', 'name', 'required', 'size',
    ];

    const TEXTAREA_ATTRIBUTES = [
        'autocapitalize', 'autocomplete', 'autofocus', 'cols', 'disabled', 'form', 'maxlength',
        'minlength', 'name', 'placeholder', 'readonly', 'required', 'rows',
        'selectionDirection', 'selectionEnd', 'selectionStart', 'wrap',
    ];

    /**
     * @var array
     */
    protected $args;

    public function __construct()
    {
        $this->args = [];
    }

    /**
     * Normalize form attributes.
     *
     * @return array|string
     */
    public function form(array $args = [], $implode = false)
    {
        $attributes = $this->parseAttributes(self::FORM_ATTRIBUTES, $args);

        return $this->maybeImplode($attributes, $implode);
    }

    /**
     * Normalize input attributes.
     *
     * @return array|string
     */
    public function input(array $args = [], $implode = false)
    {
        $this->filterInputType();

        $attributes = $this->parseAttributes(self::INPUT_ATTRIBUTES, $args);

        return $this->maybeImplode($attributes, $implode);
    }

    /**
     * Possibly implode attributes into a string.
     *
     * @param bool|string $implode
     *
     * @return array|string
     */
    public function maybeImplode(array $attributes, $implode = true)
    {
        if (!$implode || 'implode' !== $implode) {
            return $attributes;
        }
        $results = [];
        foreach ($attributes as $key => $value) {
            // if data attributes, use single quotes in case of json encoded values
            $quotes = false !== stripos($key, 'data-') ? "'" : '"';
            if (is_array($value)) {
                $value = json_encode($value);
                $quotes = "'";
            }
            $results[] = is_string($key)
                ? sprintf('%1$s=%3$s%2$s%3$s', $key, $value, $quotes)
                : $value;
        }
        return implode(' ', $results);
    }

    /**
     * Normalize select attributes.
     *
     * @return array|string
     */
    public function select(array $args = [], $implode = false)
    {
        $attributes = $this->parseAttributes(self::SELECT_ATTRIBUTES, $args);

        return $this->maybeImplode($attributes, $implode);
    }

    /**
     * Normalize textarea attributes.
     *
     * @return array|string
     */
    public function textarea(array $args = [], $implode = false)
    {
        $attributes = $this->parseAttributes(self::TEXTAREA_ATTRIBUTES, $args);

        return $this->maybeImplode($attributes, $implode);
    }

    /**
     * Filter attributes by the provided attrribute keys and remove any non-boolean keys
     * with empty values.
     *
     * @return array
     */
    protected function filterAttributes(array $attributeKeys)
    {
        $filtered = array_intersect_key($this->args, array_flip($attributeKeys));

        // normalize truthy boolean attributes
        foreach ($filtered as $key => $value) {
            if (!in_array($key, self::BOOLEAN_ATTRIBUTES)) {
                continue;
            }

            if (false !== $value) {
                $filtered[$key] = '';
                continue;
            }

            unset($filtered[$key]);
        }

        $filteredKeys = array_filter(array_keys($filtered), function ($key) use ($filtered) {
            return !(
                empty($filtered[$key])
                && !is_numeric($filtered[$key])
                && !in_array($key, self::BOOLEAN_ATTRIBUTES)
            );
        });

        return array_intersect_key($filtered, array_flip($filteredKeys));
    }

    /**
     * @return array
     */
    protected function filterGlobalAttributes()
    {
        $global = $this->filterAttributes(self::GLOBAL_ATTRIBUTES);

        $wildcards = [];

        foreach (self::GLOBAL_WILDCARD_ATTRIBUTES as $wildcard) {
            foreach ($this->args as $key => $value) {
                $length = strlen($wildcard);
                $result = substr($key, 0, $length) === $wildcard;

                if ($result) {
                    // only allow data attributes to have an empty value
                    if ('data-' != $wildcard && empty($value)) {
                        continue;
                    }

                    if (is_array($value)) {
                        if ('data-' != $wildcard) {
                            continue;
                        }

                        $value = json_encode($value);
                    }

                    $wildcards[$key] = $value;
                }
            }
        }

        return array_merge($global, $wildcards);
    }

    /**
     * @return void
     */
    protected function filterInputType()
    {
        if (!isset($this->args['type']) || !in_array($this->args['type'], self::INPUT_TYPES)) {
            $this->args['type'] = 'text';
        }
    }

    /**
     * @return array
     */
    protected function parseAttributes(array $attributes, array $args = [])
    {
        if (!empty($args)) {
            $this->args = array_change_key_case($args);
        }

        $global = $this->filterGlobalAttributes();
        $local = $this->filterAttributes($attributes);

        return array_merge($global, $local);
    }
}


1			<?php
2
3			namespace GeminiLabs\Castor\Services;
4
5			class Normalizer
6			{
7			const BOOLEAN_ATTRIBUTES = [
8			'autofocus', 'capture', 'checked', 'disabled', 'draggable', 'formnovalidate', 'hidden',
9			'multiple', 'novalidate', 'readonly', 'required', 'selected', 'spellcheck',
10			'webkitdirectory',
11			];
12
13			const FORM_ATTRIBUTES = [
14			'accept', 'accept-charset', 'action', 'autocapitalize', 'autocomplete', 'enctype',
15			'method', 'name', 'novalidate', 'target',
16			];
17
18			const GLOBAL_ATTRIBUTES = [
19			'accesskey', 'class', 'contenteditable', 'contextmenu', 'dir', 'draggable', 'dropzone',
20			'hidden', 'id', 'lang', 'spellcheck', 'style', 'tabindex', 'title',
21			];
22
23			const GLOBAL_WILDCARD_ATTRIBUTES = [
24			'aria-', 'data-', 'item', 'on',
25			];
26
27			const INPUT_ATTRIBUTES = [
28			'accept', 'autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'capture',
29			'checked', 'disabled', 'form', 'formaction', 'formenctype', 'formmethod',
30			'formnovalidate', 'formtarget', 'height', 'incremental', 'inputmode', 'list', 'max',
31			'maxlength', 'min', 'minlength', 'mozactionhint', 'multiple', 'name', 'pattern',
32			'placeholder', 'readonly', 'required', 'results', 'selectionDirection', 'size', 'src',
33			'step', 'type', 'value', 'webkitdirectory', 'width', 'x-moz-errormessage',
34			];
35
36			const INPUT_TYPES = [
37			'button', 'checkbox', 'color', 'date', 'datetime', 'datetime-local', 'email', 'file',
38			'hidden', 'image', 'max', 'min', 'month', 'number', 'password', 'radio', 'range',
39			'reset', 'search', 'step', 'submit', 'tel', 'text', 'time', 'url', 'value', 'week',
40			];
41
42			const SELECT_ATTRIBUTES = [
43			'autofocus', 'disabled', 'form', 'multiple', 'name', 'required', 'size',
44			];
45
46			const TEXTAREA_ATTRIBUTES = [
47			'autocapitalize', 'autocomplete', 'autofocus', 'cols', 'disabled', 'form', 'maxlength',
48			'minlength', 'name', 'placeholder', 'readonly', 'required', 'rows',
49			'selectionDirection', 'selectionEnd', 'selectionStart', 'wrap',
50			];
51
52			/**
53			* @var array
54			*/
55			protected $args;
56
57			public function __construct()
58			{
59			$this->args = [];
60			}
61
62			/**
63			* Normalize form attributes.
64			*
65			* @return array\|string
66			*/
67			public function form(array $args = [], $implode = false)
68			{
69			$attributes = $this->parseAttributes(self::FORM_ATTRIBUTES, $args);
70
71			return $this->maybeImplode($attributes, $implode);
72			}
73
74			/**
75			* Normalize input attributes.
76			*
77			* @return array\|string
78			*/
79			public function input(array $args = [], $implode = false)
80			{
81			$this->filterInputType();
82
83			$attributes = $this->parseAttributes(self::INPUT_ATTRIBUTES, $args);
84
85			return $this->maybeImplode($attributes, $implode);
86			}
87
88			/**
89			* Possibly implode attributes into a string.
90			*
91			* @param bool\|string $implode
92			*
93			* @return array\|string
94			*/
95			public function maybeImplode(array $attributes, $implode = true)
96			{
97			if (!$implode \|\| 'implode' !== $implode) {
98			return $attributes;
99			}
100			$results = [];
101			foreach ($attributes as $key => $value) {
102			// if data attributes, use single quotes in case of json encoded values
103			$quotes = false !== stripos($key, 'data-') ? "'" : '"';
104			if (is_array($value)) {
105			$value = json_encode($value);
106			$quotes = "'";
107			}
108			$results[] = is_string($key)
109			? sprintf('%1$s=%3$s%2$s%3$s', $key, $value, $quotes)
110			: $value;
111			}
112			return implode(' ', $results);
113			}
114
115			/**
116			* Normalize select attributes.
117			*
118			* @return array\|string
119			*/
120			public function select(array $args = [], $implode = false)
121			{
122			$attributes = $this->parseAttributes(self::SELECT_ATTRIBUTES, $args);
123
124			return $this->maybeImplode($attributes, $implode);
125			}
126
127			/**
128			* Normalize textarea attributes.
129			*
130			* @return array\|string
131			*/
132			public function textarea(array $args = [], $implode = false)
133			{
134			$attributes = $this->parseAttributes(self::TEXTAREA_ATTRIBUTES, $args);
135
136			return $this->maybeImplode($attributes, $implode);
137			}
138
139			/**
140			* Filter attributes by the provided attrribute keys and remove any non-boolean keys
141			* with empty values.
142			*
143			* @return array
144			*/
145			protected function filterAttributes(array $attributeKeys)
146			{
147			$filtered = array_intersect_key($this->args, array_flip($attributeKeys));
148
149			// normalize truthy boolean attributes
150			foreach ($filtered as $key => $value) {
151			if (!in_array($key, self::BOOLEAN_ATTRIBUTES)) {
152			continue;
153			}
154
155			if (false !== $value) {
156			$filtered[$key] = '';
157			continue;
158			}
159
160			unset($filtered[$key]);
161			}
162
163			$filteredKeys = array_filter(array_keys($filtered), function ($key) use ($filtered) {
164			return !(
165			empty($filtered[$key])
166			&& !is_numeric($filtered[$key])
167			&& !in_array($key, self::BOOLEAN_ATTRIBUTES)
168			);
169			});
170
171			return array_intersect_key($filtered, array_flip($filteredKeys));
172			}
173
174			/**
175			* @return array
176			*/
177			protected function filterGlobalAttributes()
178			{
179			$global = $this->filterAttributes(self::GLOBAL_ATTRIBUTES);
180
181			$wildcards = [];
182
183			foreach (self::GLOBAL_WILDCARD_ATTRIBUTES as $wildcard) {
184			foreach ($this->args as $key => $value) {
185			$length = strlen($wildcard);
186			$result = substr($key, 0, $length) === $wildcard;
187
188			if ($result) {
189			// only allow data attributes to have an empty value
190			if ('data-' != $wildcard && empty($value)) {
191			continue;
192			}
193
194			if (is_array($value)) {
195			if ('data-' != $wildcard) {
196			continue;
197			}
198
199			$value = json_encode($value);
200			}
201
202			$wildcards[$key] = $value;
203			}
204			}
205			}
206
207			return array_merge($global, $wildcards);
208			}
209
210			/**
211			* @return void
212			*/
213			protected function filterInputType()
214			{
215			if (!isset($this->args['type']) \|\| !in_array($this->args['type'], self::INPUT_TYPES)) {
216			$this->args['type'] = 'text';
217			}
218			}
219
220			/**
221			* @return array
222			*/
223			protected function parseAttributes(array $attributes, array $args = [])
224			{
225			if (!empty($args)) {
226			$this->args = array_change_key_case($args);
227			}
228
229			$global = $this->filterGlobalAttributes();
230			$local = $this->filterAttributes($attributes);
231
232			return array_merge($global, $local);
233			}
234			}
235

pryley / castor-framework

Normalizer::parseAttributes() A last analyzed 2023-03-11 16:13 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Normalizer::parseAttributes() A
last analyzed 2023-03-11 16:13 UTC