Node::overrideXmlAttrs() - Code Metrics - Inspection of "Reduce cyclomatic complexity." - simplepie/simplepie-ng - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 179aff...ec953f )

by Ryan

created 2018-02-17 17:29 UTC

Node::overrideXmlAttrs() A

↳ Parent: Node

Complexity

Conditions	3
Paths	3

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes

Metric	Value
cc	3
eloc	4
nc	3
nop	1
dl	0
loc	6
ccs	0
cts	3
cp	0
crap	12
rs	9.4285
c	0
b	0
f	0

<?php
/**
 * Copyright (c) 2017–2018 Ryan Parman <http://ryanparman.com>.
 * Copyright (c) 2017–2018 Contributors.
 *
 * http://opensource.org/licenses/Apache2.0
 */
declare(strict_types=1);

namespace SimplePie\Type;

use DOMAttr;
use DOMNode;
use DOMText;
use SimplePie\Enum\CharacterSet;
use SimplePie\Enum\Serialization;
use SimplePie\Exception\SimplePieException;

/**
 * A type model for a deep-level Node element.
 */
class Node extends AbstractType implements NodeInterface, TypeInterface
{
    /**
     * The raw `DOMNode` element.
     *
     * @var DOMNode|null
     */
    protected $node;

    /**
     * The content of the node, serialized appropriately.
     *
     * @var string|null
     */
    protected $value;

    /**
     * The language of the content.
     *
     * @var string|null
     */
    protected $lang;

    /**
     * The xml:base value of the content.
     *
     * @var string|null
     */
    protected $base;

    /**
     * The serialization of the content.
     *
     * @var string
     */
    protected $serialization = Serialization::TEXT;

    /**
     * Get the text node in multiple formats.
     *
     * @param DOMNode|null $node     A `DOMNode` element to read properties from.
     * @param array        $fallback An array of attributes for default XML attributes. The default value is an
     *                               empty array.
     */
    public function __construct(?DOMNode $node = null, array $fallback = [])
    {
        if ($node) {
            $this->node  = $node;
            $this->value = $node->nodeValue;

            // Set some default values
            $this->handleFallback($fallback);

            if (XML_ELEMENT_NODE === $node->nodeType && $node->attributes->length > 0) {
                foreach ($node->attributes as $attribute) {
                    $this->overrideXmlAttrs($attribute);
                    $this->handleTypes($attribute);
                }
            }
        }
    }

    /**
     * Casting this Node element to a string with return the _value_ of the Node.
     *
     * @return string
     */
    public function __toString(): string
    {
        return $this->getValue() ?? '';
    }

    /**
     * Creates a new `Node` object from a string of text (such as from an XML attribute).
     *
     * @param string $value The string of text to convert to a `Node` object.
     *
     * @return Node
     */
    public static function factory(string $value): self
    {
        return new self(
            new DOMText($value)
        );
    }

    /**
     * Gets the raw `DOMNode` element.
     *
     * @return DOMNode|null
     */
    public function getNode(): ?DOMNode
    {
        return $this->node;
    }

    /**
     * Gets the content of the node, serialized appropriately.
     *
     * @return string|null
     */
    public function getValue(): ?string
    {
        return $this->value;
    }

    /**
     * Gets the serialization of the content.
     *
     * Will always be one of the enums from `SimplePie\Enum\Serialization`.
     *
     * @return string
     */
    public function getSerialization(): string
    {
        return $this->serialization;
    }

    /**
     * Gets the language of the content.
     *
     * @return string|null
     */
    public function getLang(): self
    {
        return self::factory($this->lang ?? '');
    }

    /**
     * Gets the xml:base of the content.
     *
     * @return string|null
     */
    public function getBase(): self
    {
        return self::factory($this->base ?? '');
    }

    /**
     * {@inheritdoc}
     */
    public function getAlias(string $nodeName): string
    {
        switch ($nodeName) {
            case 'language':
                return 'lang';

            default:
                return $nodeName;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getHandler(string $nodeName, array $args = []): self
    {
        throw new SimplePieException(
            $this->getUnresolvableMessage($nodeName)
        );
    }

    /**
     * Override the `xml:`-prefixed values inherited from the parent with local values.
     *
     * @param DOMAttr $attribute A `DOMAttr` element to read properties from.
     */
    private function overrideXmlAttrs(DOMAttr $attribute): void
    {
        if ('xml:base' === $attribute->nodeName) {
            $this->base = $attribute->nodeValue;
        } elseif ('xml:lang' === $attribute->nodeName) {
            $this->lang = $attribute->nodeValue;
        }
    }

    /**
     * Determine how a serialized node should be handled.
     *
     * @param DOMAttr $attribute A `DOMAttr` element to read properties from.
     */
    private function handleTypes(DOMAttr $attribute): void
    {
        if ('src' === $attribute->name) {
            $this->handleAsSource($attribute);
        } elseif ('type' === $attribute->name && Serialization::TEXT === $attribute->value) {
            $this->handleAsText($node, $attribute);

        } elseif ('type' === $attribute->name && Serialization::HTML === $attribute->value) {
            $this->handleAsHtml($node, $attribute);
        } elseif ('type' === $attribute->name && Serialization::XHTML === $attribute->value) {
            $this->handleAsXhtml($node, $attribute);
        } elseif ('type' === $attribute->name && 'application/octet-stream' === $attribute->value) {
            $this->handleAsBase64($node);
        } else {
            $this->serialization = Serialization::TEXT;
            $this->value         = $node->nodeValue;
        }
    }

    /**
     * Handle the default "fallback" state of certain properties.
     *
     * @param array $fallback An array of attributes for default XML attributes. The default value is an empty array.
     */
    private function handleFallback(array $fallback = []): void
    {
        if (isset($fallback['base'])) {
            $this->base = $fallback['base']->nodeValue;
        }

        if (isset($fallback['lang'])) {
            $this->lang = $fallback['lang']->nodeValue;
        }
    }

    /**
     * Handle the content as source.
     *
     * @param DOMAttr $attribute The DOMAttr element.
     */
    private function handleAsSource(DOMAttr $attribute): void
    {
        $this->serialization = Serialization::TEXT;
        $this->value         = $attribute->nodeValue;
    }

    /**
     * Handle the content as plain text.
     *
     * @param DOMNode $node      The DOMNode element.
     * @param DOMAttr $attribute The DOMAttr element.
     */
    private function handleAsText(DOMNode $node, DOMAttr $attribute): void
    {
        $this->serialization = $attribute->nodeValue;
        $this->value         = \html_entity_decode(
            $node->nodeValue,
            ENT_COMPAT,
            CharacterSet::UTF_8
        );
    }

    /**
     * Handle the content as HTML.
     *
     * @param DOMNode $node      The DOMNode element.
     * @param DOMAttr $attribute The DOMAttr element.
     */
    private function handleAsHtml(DOMNode $node, DOMAttr $attribute): void
    {
        $this->serialization = $attribute->nodeValue;
        $this->value         = \html_entity_decode(
            $node->nodeValue,
            ENT_COMPAT | ENT_HTML5,
            CharacterSet::UTF_8
        );
    }

    /**
     * Handle the content as XHTML.
     *
     * @param DOMNode $node      The DOMNode element.
     * @param DOMAttr $attribute The DOMAttr element.
     */
    private function handleAsXhtml(DOMNode $node, DOMAttr $attribute): void
    {
        $this->serialization = $attribute->nodeValue;

        // We can't just grab the content. We need to stringify it, then remove the wrapper element.
        $content = \preg_replace(
            '/^<div xmlns=\"http:\/\/www.w3.org\/1999\/xhtml\">(.*)<\/div>$/ims',
            '$1',
            $node->ownerDocument->saveXML(
                $node->getElementsByTagNameNS('http://www.w3.org/1999/xhtml', 'div')[0]
            )
        );

        $this->value = \trim($content);
    }

    /**
     * Handle the content as Base64-encoded text.
     *
     * @param DOMNode $node The DOMNode element.
     */
    private function handleAsBase64(DOMNode $node): void
    {
        $this->serialization = Serialization::TEXT;
        $this->value         = \base64_decode(\trim($node->nodeValue), true);
    }
}


1		<?php
2		/**
3		* Copyright (c) 2017–2018 Ryan Parman <http://ryanparman.com>.
4		* Copyright (c) 2017–2018 Contributors.
5		*
6		* http://opensource.org/licenses/Apache2.0
7		*/
8		declare(strict_types=1);
9
10		namespace SimplePie\Type;
11
12		use DOMAttr;
13		use DOMNode;
14		use DOMText;
15		use SimplePie\Enum\CharacterSet;
16		use SimplePie\Enum\Serialization;
17		use SimplePie\Exception\SimplePieException;
18
19		/**
20		* A type model for a deep-level Node element.
21		*/
22		class Node extends AbstractType implements NodeInterface, TypeInterface
23		{
24		/**
25		* The raw `DOMNode` element.
26		*
27		* @var DOMNode\|null
28		*/
29		protected $node;
30
31		/**
32		* The content of the node, serialized appropriately.
33		*
34		* @var string\|null
35		*/
36		protected $value;
37
38		/**
39		* The language of the content.
40		*
41		* @var string\|null
42		*/
43		protected $lang;
44
45		/**
46		* The xml:base value of the content.
47		*
48		* @var string\|null
49		*/
50		protected $base;
51
52		/**
53		* The serialization of the content.
54		*
55		* @var string
56		*/
57		protected $serialization = Serialization::TEXT;
58
59		/**
60		* Get the text node in multiple formats.
61		*
62		* @param DOMNode\|null $node A `DOMNode` element to read properties from.
63		* @param array $fallback An array of attributes for default XML attributes. The default value is an
64		* empty array.
65		*/
66		public function __construct(?DOMNode $node = null, array $fallback = [])
67		{
68	484	if ($node) {
69		$this->node = $node;
70	484	$this->value = $node->nodeValue;
71	484
72	484	// Set some default values
73		$this->handleFallback($fallback);
74	484
75	2	if (XML_ELEMENT_NODE === $node->nodeType && $node->attributes->length > 0) {
76		foreach ($node->attributes as $attribute) {
77		$this->overrideXmlAttrs($attribute);
78	484	$this->handleTypes($attribute);
79	64	}
80		}
81		}
82	484	}
83	136
84	136	/**
85	41	* Casting this Node element to a string with return the _value_ of the Node.
86	136	*
87	65	* @return string
88	128	*/
89	1	public function __toString(): string
90	127	{
91	11	return $this->getValue() ?? '';
92	116	}
93	50
94	105	/**
95	25	* Creates a new `Node` object from a string of text (such as from an XML attribute).
96	80	*
97	12	* @param string $value The string of text to convert to a `Node` object.
98		*
99	68	* @return Node
100	136	*/
101		public static function factory(string $value): self
102		{
103		return new self(
104		new DOMText($value)
105	484	);
106		}
107
108		/**
109		* Gets the raw `DOMNode` element.
110		*
111		* @return DOMNode\|null
112		*/
113		public function getNode(): ?DOMNode
114	470	{
115		return $this->node;
116	470	}
117
118		/**
119		* Gets the content of the node, serialized appropriately.
120		*
121		* @return string\|null
122		*/
123		public function getValue(): ?string
124		{
125		return $this->value;
126	38	}
127
128	38	/**
129	38	* Gets the serialization of the content.
130		*
131		* Will always be one of the enums from `SimplePie\Enum\Serialization`.
132		*
133		* @return string
134		*/
135		public function getSerialization(): string
136		{
137		return $this->serialization;
138	484	}
139
140	484	/**
141		* Gets the language of the content.
142		*
143		* @return string\|null
144		*/
145		public function getLang(): self
146		{
147		return self::factory($this->lang ?? '');
148	476	}
149
150	476	/**
151		* Gets the xml:base of the content.
152		*
153		* @return string\|null
154		*/
155		public function getBase(): self
156		{
157		return self::factory($this->base ?? '');
158		}
159
160	374	/**
161		* {@inheritdoc}
162	374	*/
163		public function getAlias(string $nodeName): string
164		{
165		switch ($nodeName) {
166		case 'language':
167		return 'lang';
168
169		default:
170	30	return $nodeName;
171		}
172	30	}
173
174		/**
175		* {@inheritdoc}
176		*/
177		public function getHandler(string $nodeName, array $args = []): self
178		{
179		throw new SimplePieException(
180	3	$this->getUnresolvableMessage($nodeName)
181		);
182	3	}
183
184		/**
185		* Override the `xml:`-prefixed values inherited from the parent with local values.
186		*
187		* @param DOMAttr $attribute A `DOMAttr` element to read properties from.
188		*/
189		private function overrideXmlAttrs(DOMAttr $attribute): void
190		{
191		if ('xml:base' === $attribute->nodeName) {
192		$this->base = $attribute->nodeValue;
193		} elseif ('xml:lang' === $attribute->nodeName) {
194		$this->lang = $attribute->nodeValue;
195		}
196		}
197
198		/**
199		* Determine how a serialized node should be handled.
200		*
201		* @param DOMAttr $attribute A `DOMAttr` element to read properties from.
202		*/
203		private function handleTypes(DOMAttr $attribute): void
204		{
205		if ('src' === $attribute->name) {
206		$this->handleAsSource($attribute);
207		} elseif ('type' === $attribute->name && Serialization::TEXT === $attribute->value) {
208		$this->handleAsText($node, $attribute);
		0 ignored issues – show Comprehensibility Best Practice introduced 2018-02-17 17:41 UTC by Report Bug Copy Issue Report The variable `$node` seems to be never defined. Loading history...
209		} elseif ('type' === $attribute->name && Serialization::HTML === $attribute->value) {
210		$this->handleAsHtml($node, $attribute);
211		} elseif ('type' === $attribute->name && Serialization::XHTML === $attribute->value) {
212		$this->handleAsXhtml($node, $attribute);
213		} elseif ('type' === $attribute->name && 'application/octet-stream' === $attribute->value) {
214	1	$this->handleAsBase64($node);
215		} else {
216	1	$this->serialization = Serialization::TEXT;
217	1	$this->value = $node->nodeValue;
218	1	}
219		}
220
221		/**
222		* Handle the default "fallback" state of certain properties.
223		*
224		* @param array $fallback An array of attributes for default XML attributes. The default value is an empty array.
225		*/
226	11	private function handleFallback(array $fallback = []): void
227		{
228	11	if (isset($fallback['base'])) {
229	11	$this->base = $fallback['base']->nodeValue;
230	11	}
231	11
232	11	if (isset($fallback['lang'])) {
233		$this->lang = $fallback['lang']->nodeValue;
234	11	}
235		}
236
237		/**
238		* Handle the content as source.
239		*
240		* @param DOMAttr $attribute The DOMAttr element.
241		*/
242	50	private function handleAsSource(DOMAttr $attribute): void
243		{
244	50	$this->serialization = Serialization::TEXT;
245	50	$this->value = $attribute->nodeValue;
246	50	}
247	50
248	50	/**
249		* Handle the content as plain text.
250	50	*
251		* @param DOMNode $node The DOMNode element.
252		* @param DOMAttr $attribute The DOMAttr element.
253		*/
254		private function handleAsText(DOMNode $node, DOMAttr $attribute): void
255		{
256		$this->serialization = $attribute->nodeValue;
257		$this->value = \html_entity_decode(
258	25	$node->nodeValue,
259		ENT_COMPAT,
260	25	CharacterSet::UTF_8
261		);
262		}
263	25
264	25	/**
265	25	* Handle the content as HTML.
266	25	*
267	25	* @param DOMNode $node The DOMNode element.
268		* @param DOMAttr $attribute The DOMAttr element.
269		*/
270		private function handleAsHtml(DOMNode $node, DOMAttr $attribute): void
271	25	{
272	25	$this->serialization = $attribute->nodeValue;
273		$this->value = \html_entity_decode(
274		$node->nodeValue,
275		ENT_COMPAT \| ENT_HTML5,
276		CharacterSet::UTF_8
277		);
278		}
279	12
280		/**
281	12	* Handle the content as XHTML.
282	12	*
283	12	* @param DOMNode $node The DOMNode element.
284		* @param DOMAttr $attribute The DOMAttr element.
285		*/
286		private function handleAsXhtml(DOMNode $node, DOMAttr $attribute): void
287		{
288		$this->serialization = $attribute->nodeValue;
289
290		// We can't just grab the content. We need to stringify it, then remove the wrapper element.
291		$content = \preg_replace(
292		'/^<div xmlns=\"http:\/\/www.w3.org\/1999\/xhtml\">(.*)<\/div>$/ims',
293		'$1',
294		$node->ownerDocument->saveXML(
295		$node->getElementsByTagNameNS('http://www.w3.org/1999/xhtml', 'div')[0]
296		)
297		);
298
299		$this->value = \trim($content);
300		}
301
302		/**
303		* Handle the content as Base64-encoded text.
304		*
305		* @param DOMNode $node The DOMNode element.
306		*/
307		private function handleAsBase64(DOMNode $node): void
308		{
309		$this->serialization = Serialization::TEXT;
310		$this->value = \base64_decode(\trim($node->nodeValue), true);
311		}
312		}
313

simplepie / simplepie-ng

Push — master ( 179aff...ec953f )

Node::overrideXmlAttrs() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like