AbstractNode::propagateEncoding() - Code Metrics - Inspection of "Updated documentation" - paquettg/php-html-parser - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 12b94f...668c77 )

by Gilles

created 2020-01-20 13:00 UTC

AbstractNode::propagateEncoding() A

↳ Parent: AbstractNode

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

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

<?php declare(strict_types=1);
namespace PHPHtmlParser\Dom;

use PHPHtmlParser\Exceptions\CircularException;
use PHPHtmlParser\Exceptions\ParentNotFoundException;
use PHPHtmlParser\Exceptions\ChildNotFoundException;
use PHPHtmlParser\Selector\Selector;
use PHPHtmlParser\Selector\Parser as SelectorParser;
use stringEncode\Encode;
use PHPHtmlParser\Finder;

/**
 * Dom node object.
 * @property string    $outerhtml
 * @property string    $innerhtml
 * @property string    $text
 * @property int       $prev
 * @property int       $next
 * @property Tag       $tag
 * @property InnerNode $parent
 */
abstract class AbstractNode
{
    /**
     * @var int
     */
    private static $count = 0;

    /**
     * Contains the tag name/type
     *
     * @var ?Tag
     */
    protected $tag = null;

    /**
     * Contains a list of attributes on this tag.
     *
     * @var array
     */
    protected $attr = [];

    /**
     * Contains the parent Node.
     *
     * @var ?InnerNode
     */
    protected $parent = null;

    /**
     * The unique id of the class. Given by PHP.
     *
     * @var int
     */
    protected $id;

    /**
     * The encoding class used to encode strings.
     *
     * @var mixed
     */
    protected $encode;

    /**
     * An array of all the children.
     *
     * @var array
     */
    protected $children = [];

    /**
     * @var bool
     */
    protected $htmlSpecialCharsDecode = false;

    /**
     * Creates a unique id for this node.
     */
    public function __construct()
    {
        $this->id = self::$count;
        self::$count++;
    }

    /**
     * Magic get method for attributes and certain methods.
     *
     * @param string $key
     * @return mixed
     */
    public function __get(string $key)
    {
        // check attribute first
        if ( ! is_null($this->getAttribute($key))) {
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            return $this->getAttribute($key);
        }
        switch (strtolower($key)) {
            case 'outerhtml':
                return $this->outerHtml();
            case 'innerhtml':
                return $this->innerHtml();
            case 'text':
                return $this->text();
            case 'tag':
                return $this->getTag();
            case 'parent':
                return $this->getParent();
        }

        return null;
    }

    /**
     * Attempts to clear out any object references.
     */
    public function __destruct()
    {
        $this->tag      = null;
        $this->parent   = null;
        $this->attr     = [];
        $this->children = [];
    }

    /**
     * Simply calls the outer text method.
     *
     * @return string
     */
    public function __toString()
    {
        return $this->outerHtml();
    }

    /**
     * @param bool $htmlSpecialCharsDecode
     * @return void
     */
    public function setHtmlSpecialCharsDecode($htmlSpecialCharsDecode = false): void
    {
        $this->htmlSpecialCharsDecode = $htmlSpecialCharsDecode;
    }


    /**
     * Reset node counter
     *
     * @return void
     */
    public static function resetCount()
    {
        self::$count = 0;
    }

    /**
     * Returns the id of this object.
     *
     * @return int
     */
    public function id(): int
    {
        return $this->id;
    }

    /**
     * Returns the parent of node.
     *
     * @return AbstractNode
     */
    public function getParent()
    {
        return $this->parent;
    }

    /**
     * Sets the parent node.
     * @param InnerNode $parent
     * @return AbstractNode
     * @throws ChildNotFoundException
     * @throws CircularException
     */
    public function setParent(InnerNode $parent): AbstractNode
    {
        // remove from old parent
        if ( ! is_null($this->parent)) {
            if ($this->parent->id() == $parent->id()) {
                // already the parent
                return $this;
            }

            $this->parent->removeChild($this->id);
        }

        $this->parent = $parent;

        // assign child to parent
        $this->parent->addChild($this);

        return $this;
    }

    /**
     * Removes this node and all its children from the
     * DOM tree.
     *
     * @return void
     */
    public function delete()
    {
        if ( ! is_null($this->parent)) {
            $this->parent->removeChild($this->id);
        }
        $this->parent->clear();
        $this->clear();
    }

    /**
     * Sets the encoding class to this node.
     *
     * @param Encode $encode
     * @return void
     */
    public function propagateEncoding(Encode $encode)
    {
        $this->encode = $encode;
        $this->tag->setEncoding($encode);
    }

    /**
     * Checks if the given node id is an ancestor of
     * the current node.
     *
     * @param int $id
     * @return bool
     */
    public function isAncestor(int $id): Bool
    {
        if ( ! is_null($this->getAncestor($id))) {
            return true;
        }

        return false;
    }

    /**
     * Attempts to get an ancestor node by the given id.
     *
     * @param int $id
     * @return null|AbstractNode
     */
    public function getAncestor(int $id)
    {
        if ( ! is_null($this->parent)) {
            if ($this->parent->id() == $id) {
                return $this->parent;
            }

            return $this->parent->getAncestor($id);
        }

        return null;
    }

    /**
     * Checks if the current node has a next sibling.
     *
     * @return bool
     */
    public function hasNextSibling(): bool
    {
        try
        {
            $this->nextSibling();

            // sibling found, return true;
            return true;
        }
        catch (ParentNotFoundException $e)
        {
            // no parent, no next sibling
            unset($e);
            return false;
        }
        catch (ChildNotFoundException $e)
        {
            // no sibling found
            unset($e);
            return false;
        }
    }

    /**
     * Attempts to get the next sibling.
     * @return AbstractNode
     * @throws ChildNotFoundException
     * @throws ParentNotFoundException
     */
    public function nextSibling(): AbstractNode
    {
        if (is_null($this->parent)) {
            throw new ParentNotFoundException('Parent is not set for this node.');
        }

        return $this->parent->nextChild($this->id);
    }

    /**
     * Attempts to get the previous sibling.
     * @return AbstractNode
     * @throws ChildNotFoundException
     * @throws ParentNotFoundException
     */
    public function previousSibling(): AbstractNode
    {
        if (is_null($this->parent)) {
            throw new ParentNotFoundException('Parent is not set for this node.');
        }

        return $this->parent->previousChild($this->id);
    }

    /**
     * Gets the tag object of this node.
     *
     * @return Tag
     */
    public function getTag(): Tag
    {
        return $this->tag;
    }

    /**
     * A wrapper method that simply calls the getAttribute method
     * on the tag of this node.
     *
     * @return array
     */
    public function getAttributes(): array
    {
        $attributes = $this->tag->getAttributes();
        foreach ($attributes as $name => $info) {
            $attributes[$name] = $info['value'];
        }

        return $attributes;
    }

    /**
     * A wrapper method that simply calls the getAttribute method
     * on the tag of this node.
     *
     * @param string $key
     * @return string|null
     */
    public function getAttribute(string $key): ?string
    {
        $attribute = $this->tag->getAttribute($key);
        $attributeValue = $attribute['value'];

        return $attributeValue;
    }

    /**
     * A wrapper method that simply calls the hasAttribute method
     * on the tag of this node.
     *
     * @param string $key
     * @return bool
     */
    public function hasAttribute(string $key): bool
    {
        return $this->tag->hasAttribute($key);
    }

    /**
     * A wrapper method that simply calls the setAttribute method
     * on the tag of this node.
     *
     * @param string $key
     * @param string|array $value
     * @return AbstractNode
     * @chainable
     */
    public function setAttribute(string $key, $value): AbstractNode
    {
        $this->tag->setAttribute($key, $value);

        //clear any cache
        $this->clear();

        return $this;
    }

    /**
     * A wrapper method that simply calls the removeAttribute method
     * on the tag of this node.
     *
     * @param string $key
     * @return void
     */
    public function removeAttribute(string $key): void
    {
        $this->tag->removeAttribute($key);

        //clear any cache
        $this->clear();
    }

    /**
     * A wrapper method that simply calls the removeAllAttributes
     * method on the tag of this node.
     *
     * @return void
     */
    public function removeAllAttributes(): void
    {
        $this->tag->removeAllAttributes();

        //clear any cache
        $this->clear();
    }
    /**
     * Function to locate a specific ancestor tag in the path to the root.
     *
     * @param  string $tag
     * @return AbstractNode
     * @throws ParentNotFoundException
     */
    public function ancestorByTag(string $tag): AbstractNode
    {
        // Start by including ourselves in the comparison.
        $node = $this;

        while ( ! is_null($node)) {
            if ($node->tag->name() == $tag) {
                return $node;
            }

            $node = $node->getParent();
        }

        throw new ParentNotFoundException('Could not find an ancestor with "'.$tag.'" tag');
    }

    /**
     * Find elements by css selector
     * @param string   $selector
     * @param int|null $nth
     * @param bool     $depthFirst
     * @return mixed|Collection|null
     * @throws ChildNotFoundException
     */
    public function find(string $selector, int $nth = null, bool $depthFirst = false)
    {
        $selector = new Selector($selector, new SelectorParser());
        $selector->setDepthFirstFind($depthFirst);
        $nodes    = $selector->find($this);

        if ( ! is_null($nth)) {
            // return nth-element or array
            if (isset($nodes[$nth])) {
                return $nodes[$nth];
            }

            return null;
        }

        return $nodes;
    }

    /**
     * Find node by id
     * @param int $id
     * @return bool|AbstractNode
     * @throws ChildNotFoundException
     * @throws ParentNotFoundException
     */
    public function findById(int $id)
    {
        $finder= new Finder($id);

        return $finder->find($this);
    }


    /**
     * Gets the inner html of this node.
     *
     * @return string
     */
    abstract public function innerHtml(): string;

    /**
     * Gets the html of this node, including it's own
     * tag.
     *
     * @return string
     */
    abstract public function outerHtml(): string;

    /**
     * Gets the text of this node (if there is any text).
     *
     * @return string
     */
    abstract public function text(): string;

    /**
     * Call this when something in the node tree has changed. Like a child has been added
     * or a parent has been changed.
     *
     * @return void
     */
    abstract protected function clear(): void;

    /**
     * Check is node type textNode
     *
     * @return boolean
     */
    public function isTextNode(): bool 
    {

        return false;
    }
}


1		<?php declare(strict_types=1);
2		namespace PHPHtmlParser\Dom;
3
4		use PHPHtmlParser\Exceptions\CircularException;
5		use PHPHtmlParser\Exceptions\ParentNotFoundException;
6		use PHPHtmlParser\Exceptions\ChildNotFoundException;
7		use PHPHtmlParser\Selector\Selector;
8		use PHPHtmlParser\Selector\Parser as SelectorParser;
9		use stringEncode\Encode;
10		use PHPHtmlParser\Finder;
11
12		/**
13		* Dom node object.
14		* @property string $outerhtml
15		* @property string $innerhtml
16		* @property string $text
17		* @property int $prev
18		* @property int $next
19		* @property Tag $tag
20		* @property InnerNode $parent
21		*/
22		abstract class AbstractNode
23		{
24		/**
25		* @var int
26		*/
27		private static $count = 0;
28
29		/**
30		* Contains the tag name/type
31		*
32		* @var ?Tag
33		*/
34		protected $tag = null;
35
36		/**
37		* Contains a list of attributes on this tag.
38		*
39		* @var array
40		*/
41		protected $attr = [];
42
43		/**
44		* Contains the parent Node.
45		*
46		* @var ?InnerNode
47		*/
48		protected $parent = null;
49
50		/**
51		* The unique id of the class. Given by PHP.
52		*
53		* @var int
54		*/
55		protected $id;
56
57		/**
58		* The encoding class used to encode strings.
59		*
60		* @var mixed
61		*/
62		protected $encode;
63
64		/**
65		* An array of all the children.
66		*
67		* @var array
68		*/
69		protected $children = [];
70
71		/**
72		* @var bool
73		*/
74		protected $htmlSpecialCharsDecode = false;
75
76		/**
77		* Creates a unique id for this node.
78		*/
79	510	public function __construct()
80		{
81	510	$this->id = self::$count;
82	510	self::$count++;
83	510	}
84
85		/**
86		* Magic get method for attributes and certain methods.
87		*
88		* @param string $key
89		* @return mixed
90		*/
91	174	public function __get(string $key)
92		{
93		// check attribute first
94	174	if ( ! is_null($this->getAttribute($key))) {
		0 ignored issues – show introduced 2020-01-13 00:05 UTC by Report Bug Copy Issue Report The condition `is_null($this->getAttribute($key))` is always `true`. Loading history... Bug introduced 2020-01-13 00:05 UTC by Report Bug Copy Issue Report Are you sure the usage of `$this->getAttribute($key)` targeting `PHPHtmlParser\Dom\AbstractNode::getAttribute()` seems to always return null. This check looks for function or method calls that always return null and whose return value is used. class A { function getObject() { return null; } } $a = new A(); if ($a->getObject()) { The method `getObject()` can return nothing but null, so it makes no sense to use the return value. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
95	21	return $this->getAttribute($key);
96		}
97	156	switch (strtolower($key)) {
98	156	case 'outerhtml':
99	36	return $this->outerHtml();
100	120	case 'innerhtml':
101	66	return $this->innerHtml();
102	57	case 'text':
103	51	return $this->text();
104	6	case 'tag':
105	3	return $this->getTag();
106	3	case 'parent':
107		return $this->getParent();
108		}
109
110	3	return null;
111		}
112
113		/**
114		* Attempts to clear out any object references.
115		*/
116	126	public function __destruct()
117		{
118	126	$this->tag = null;
119	126	$this->parent = null;
120	126	$this->attr = [];
121	126	$this->children = [];
122	126	}
123
124		/**
125		* Simply calls the outer text method.
126		*
127		* @return string
128		*/
129	12	public function __toString()
130		{
131	12	return $this->outerHtml();
132		}
133
134		/**
135		* @param bool $htmlSpecialCharsDecode
136		* @return void
137		*/
138	246	public function setHtmlSpecialCharsDecode($htmlSpecialCharsDecode = false): void
139		{
140	246	$this->htmlSpecialCharsDecode = $htmlSpecialCharsDecode;
141	246	}
142
143
144		/**
145		* Reset node counter
146		*
147		* @return void
148		*/
149	183	public static function resetCount()
150		{
151	183	self::$count = 0;
152	183	}
153
154		/**
155		* Returns the id of this object.
156		*
157		* @return int
158		*/
159	444	public function id(): int
160		{
161	444	return $this->id;
162		}
163
164		/**
165		* Returns the parent of node.
166		*
167		* @return AbstractNode
168		*/
169	240	public function getParent()
170		{
171	240	return $this->parent;
172		}
173
174		/**
175		* Sets the parent node.
176		* @param InnerNode $parent
177		* @return AbstractNode
178		* @throws ChildNotFoundException
179		* @throws CircularException
180		*/
181	438	public function setParent(InnerNode $parent): AbstractNode
182		{
183		// remove from old parent
184	438	if ( ! is_null($this->parent)) {
185	30	if ($this->parent->id() == $parent->id()) {
186		// already the parent
187	27	return $this;
188		}
189
190	6	$this->parent->removeChild($this->id);
191		}
192
193	438	$this->parent = $parent;
194
195		// assign child to parent
196	438	$this->parent->addChild($this);
197
198	438	return $this;
199		}
200
201		/**
202		* Removes this node and all its children from the
203		* DOM tree.
204		*
205		* @return void
206		*/
207	3	public function delete()
208		{
209	3	if ( ! is_null($this->parent)) {
210	3	$this->parent->removeChild($this->id);
211		}
212	3	$this->parent->clear();
213	3	$this->clear();
214	3	}
215
216		/**
217		* Sets the encoding class to this node.
218		*
219		* @param Encode $encode
220		* @return void
221		*/
222	222	public function propagateEncoding(Encode $encode)
223		{
224	222	$this->encode = $encode;
225	222	$this->tag->setEncoding($encode);
226	222	}
227
228		/**
229		* Checks if the given node id is an ancestor of
230		* the current node.
231		*
232		* @param int $id
233		* @return bool
234		*/
235	441	public function isAncestor(int $id): Bool
236		{
237	441	if ( ! is_null($this->getAncestor($id))) {
238	6	return true;
239		}
240
241	441	return false;
242		}
243
244		/**
245		* Attempts to get an ancestor node by the given id.
246		*
247		* @param int $id
248		* @return null\|AbstractNode
249		*/
250	444	public function getAncestor(int $id)
251		{
252	444	if ( ! is_null($this->parent)) {
253	309	if ($this->parent->id() == $id) {
254	12	return $this->parent;
255		}
256
257	300	return $this->parent->getAncestor($id);
258		}
259
260	444	return null;
261		}
262
263		/**
264		* Checks if the current node has a next sibling.
265		*
266		* @return bool
267		*/
268	9	public function hasNextSibling(): bool
269		{
270		try
271		{
272	9	$this->nextSibling();
273
274		// sibling found, return true;
275	9	return true;
276		}
277	9	catch (ParentNotFoundException $e)
278		{
279		// no parent, no next sibling
280		unset($e);
281		return false;
282		}
283	9	catch (ChildNotFoundException $e)
284		{
285		// no sibling found
286	9	unset($e);
287	9	return false;
288		}
289		}
290
291		/**
292		* Attempts to get the next sibling.
293		* @return AbstractNode
294		* @throws ChildNotFoundException
295		* @throws ParentNotFoundException
296		*/
297	39	public function nextSibling(): AbstractNode
298		{
299	39	if (is_null($this->parent)) {
300	3	throw new ParentNotFoundException('Parent is not set for this node.');
301		}
302
303	36	return $this->parent->nextChild($this->id);
304		}
305
306		/**
307		* Attempts to get the previous sibling.
308		* @return AbstractNode
309		* @throws ChildNotFoundException
310		* @throws ParentNotFoundException
311		*/
312	9	public function previousSibling(): AbstractNode
313		{
314	9	if (is_null($this->parent)) {
315	3	throw new ParentNotFoundException('Parent is not set for this node.');
316		}
317
318	6	return $this->parent->previousChild($this->id);
319		}
320
321		/**
322		* Gets the tag object of this node.
323		*
324		* @return Tag
325		*/
326	315	public function getTag(): Tag
327		{
328	315	return $this->tag;
329		}
330
331		/**
332		* A wrapper method that simply calls the getAttribute method
333		* on the tag of this node.
334		*
335		* @return array
336		*/
337	6	public function getAttributes(): array
338		{
339	6	$attributes = $this->tag->getAttributes();
340	6	foreach ($attributes as $name => $info) {
341	3	$attributes[$name] = $info['value'];
342		}
343
344	6	return $attributes;
345		}
346
347		/**
348		* A wrapper method that simply calls the getAttribute method
349		* on the tag of this node.
350		*
351		* @param string $key
352		* @return string\|null
353		*/
354	237	public function getAttribute(string $key): ?string
355		{
356	237	$attribute = $this->tag->getAttribute($key);
357	237	$attributeValue = $attribute['value'];
358
359	237	return $attributeValue;
360		}
361
362		/**
363		* A wrapper method that simply calls the hasAttribute method
364		* on the tag of this node.
365		*
366		* @param string $key
367		* @return bool
368		*/
369	99	public function hasAttribute(string $key): bool
370		{
371	99	return $this->tag->hasAttribute($key);
372		}
373
374		/**
375		* A wrapper method that simply calls the setAttribute method
376		* on the tag of this node.
377		*
378		* @param string $key
379		* @param string\|array $value
380		* @return AbstractNode
381		* @chainable
382		*/
383	24	public function setAttribute(string $key, $value): AbstractNode
384		{
385	24	$this->tag->setAttribute($key, $value);
386
387		//clear any cache
388	24	$this->clear();
389
390	24	return $this;
391		}
392
393		/**
394		* A wrapper method that simply calls the removeAttribute method
395		* on the tag of this node.
396		*
397		* @param string $key
398		* @return void
399		*/
400	3	public function removeAttribute(string $key): void
401		{
402	3	$this->tag->removeAttribute($key);
403
404		//clear any cache
405	3	$this->clear();
406	3	}
407
408		/**
409		* A wrapper method that simply calls the removeAllAttributes
410		* method on the tag of this node.
411		*
412		* @return void
413		*/
414	3	public function removeAllAttributes(): void
415		{
416	3	$this->tag->removeAllAttributes();
417
418		//clear any cache
419	3	$this->clear();
420	3	}
421		/**
422		* Function to locate a specific ancestor tag in the path to the root.
423		*
424		* @param string $tag
425		* @return AbstractNode
426		* @throws ParentNotFoundException
427		*/
428	6	public function ancestorByTag(string $tag): AbstractNode
429		{
430		// Start by including ourselves in the comparison.
431	6	$node = $this;
432
433	6	while ( ! is_null($node)) {
434	6	if ($node->tag->name() == $tag) {
435	3	return $node;
436		}
437
438	3	$node = $node->getParent();
439		}
440
441	3	throw new ParentNotFoundException('Could not find an ancestor with "'.$tag.'" tag');
442		}
443
444		/**
445		* Find elements by css selector
446		* @param string $selector
447		* @param int\|null $nth
448		* @param bool $depthFirst
449		* @return mixed\|Collection\|null
450		* @throws ChildNotFoundException
451		*/
452	240	public function find(string $selector, int $nth = null, bool $depthFirst = false)
453		{
454	240	$selector = new Selector($selector, new SelectorParser());
455	240	$selector->setDepthFirstFind($depthFirst);
456	240	$nodes = $selector->find($this);
457
458	240	if ( ! is_null($nth)) {
459		// return nth-element or array
460	240	if (isset($nodes[$nth])) {
461	123	return $nodes[$nth];
462		}
463
464	210	return null;
465		}
466
467	84	return $nodes;
468		}
469
470		/**
471		* Find node by id
472		* @param int $id
473		* @return bool\|AbstractNode
474		* @throws ChildNotFoundException
475		* @throws ParentNotFoundException
476		*/
477	9	public function findById(int $id)
478		{
479	9	$finder= new Finder($id);
480
481	9	return $finder->find($this);
482		}
483
484
485		/**
486		* Gets the inner html of this node.
487		*
488		* @return string
489		*/
490		abstract public function innerHtml(): string;
491
492		/**
493		* Gets the html of this node, including it's own
494		* tag.
495		*
496		* @return string
497		*/
498		abstract public function outerHtml(): string;
499
500		/**
501		* Gets the text of this node (if there is any text).
502		*
503		* @return string
504		*/
505		abstract public function text(): string;
506
507		/**
508		* Call this when something in the node tree has changed. Like a child has been added
509		* or a parent has been changed.
510		*
511		* @return void
512		*/
513		abstract protected function clear(): void;
514
515		/**
516		* Check is node type textNode
517		*
518		* @return boolean
519		*/
520	9	public function isTextNode(): bool
521		{
522
523	9	return false;
524		}
525		}
526

paquettg / php-html-parser

Push — master ( 12b94f...668c77 )

AbstractNode::propagateEncoding() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like