SimpleXmlDomBlank::childNodes() - Code Metrics - Inspection of "[+]: add "XmlParser" + simple tests v2" - voku/simple_html_dom - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d36330...3c9b9d )

by Lars

created 2019-07-01 07:58 UTC

SimpleXmlDomBlank::childNodes() A

↳ Parent: SimpleXmlDomBlank

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	4
Ratio	100 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

declare(strict_types=1);

namespace voku\helper;

/** @noinspection PhpHierarchyChecksInspection */
class SimpleXmlDomBlank extends AbstractSimpleXmlDom implements \IteratorAggregate, SimpleXmlDomInterface

{
    /**
     * @param string $name
     * @param array  $arguments
     *
     * @throws \BadMethodCallException
     *
     * @return SimpleXmlDomInterface|string|null
     */
    public function __call($name, $arguments)
    {
        $name = \strtolower($name);

        if (isset(self::$functionAliases[$name])) {
            return \call_user_func_array([$this, self::$functionAliases[$name]], $arguments);
        }

        throw new \BadMethodCallException('Method does not exist');
    }

    /**
     * Find list of nodes with a CSS selector.
     *
     * @param string   $selector
     * @param int|null $idx
     *
     * @return SimpleXmlDomNodeInterface
     */
    public function find(string $selector, $idx = null)
    {
        return new SimpleXmlDomNodeBlank();
    }

    /**
     * Returns an array of attributes.
     *
     * @return null
     */
    public function getAllAttributes()
    {
        return null;
    }

    /**
     * Return attribute value.
     *
     * @param string $name
     *
     * @return string
     */
    public function getAttribute(string $name): string
    {
        return '';
    }

    /**
     * Determine if an attribute exists on the element.
     *
     * @param string $name
     *
     * @return bool
     */
    public function hasAttribute(string $name): bool
    {
        return false;
    }

    /**
     * Get dom node's inner xml.
     *
     * @param bool $multiDecodeNewHtmlEntity
     *
     * @return string
     */
    public function innerXml(bool $multiDecodeNewHtmlEntity = false): string
    {
        return '';
    }

    /**
     * Remove attribute.
     *
     * @param string $name <p>The name of the html-attribute.</p>
     *
     * @return SimpleXmlDomInterface
     */
    public function removeAttribute(string $name): SimpleXmlDomInterface
    {
        return $this;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    protected function replaceChildWithString(string $string): SimpleXmlDomInterface
    {
        return new static();
    }

    protected function replaceNodeWithString(string $string): SimpleXmlDomInterface
    {
        return new static();
    }

    protected function replaceTextWithString($string): SimpleXmlDomInterface
    {
        return new static();
    }

    /**
     * Set attribute value.
     *
     * @param string      $name       <p>The name of the html-attribute.</p>
     * @param string|null $value      <p>Set to NULL or empty string, to remove the attribute.</p>
     * @param bool        $strict     </p>
     *                                $value must be NULL, to remove the attribute,
     *                                so that you can set an empty string as attribute-value e.g. autofocus=""
     *                                </p>
     *
     * @return SimpleXmlDomInterface
     */
    public function setAttribute(string $name, $value = null, bool $strict = false): SimpleXmlDomInterface
    {
        return $this;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Get dom node's plain text.
     *
     * @return string
     */
    public function text(): string
    {
        return '';
    }

    /**
     * Get dom node's outer html.
     *
     * @param bool $multiDecodeNewHtmlEntity
     *
     * @return string
     */
    public function xml(bool $multiDecodeNewHtmlEntity = false): string
    {
        return '';
    }

    /**
     * Returns children of node.
     *
     * @param int $idx
     *
     * @return null
     */
    public function childNodes(int $idx = -1)
    {
        return null;
    }

    /**
     * Find nodes with a CSS selector.
     *
     * @param string $selector
     *
     * @return SimpleXmlDomNodeInterface
     */
    public function findMulti(string $selector): SimpleXmlDomNodeInterface
    {
        return new SimpleXmlDomNodeBlank();
    }

    /**
     * Find one node with a CSS selector.
     *
     * @param string $selector
     *
     * @return SimpleXmlDomInterface
     */
    public function findOne(string $selector): SimpleXmlDomInterface
    {
        return new static();
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Returns the first child of node.
     *
     * @return null
     */
    public function firstChild()
    {
        return null;
    }

    /**
     * Return elements by .class.
     *
     * @param string $class
     *
     * @return SimpleXmlDomNodeInterface
     */
    public function getElementByClass(string $class): SimpleXmlDomNodeInterface
    {
        return new SimpleXmlDomNodeBlank();
    }

    /**
     * Return element by #id.
     *
     * @param string $id
     *
     * @return SimpleXmlDomInterface
     */
    public function getElementById(string $id): SimpleXmlDomInterface
    {
        return new static();
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Return element by tag name.
     *
     * @param string $name
     *
     * @return SimpleXmlDomInterface
     */
    public function getElementByTagName(string $name): SimpleXmlDomInterface
    {
        return new static();
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Returns elements by #id.
     *
     * @param string   $id
     * @param int|null $idx
     *
     * @return SimpleXmlDomNodeInterface
     */
    public function getElementsById(string $id, $idx = null)
    {
        return new SimpleXmlDomNodeBlank();
    }

    /**
     * Returns elements by tag name.
     *
     * @param string   $name
     * @param int|null $idx
     *
     * @return SimpleXmlDomNodeInterface
     */
    public function getElementsByTagName(string $name, $idx = null)
    {
        return new SimpleXmlDomNodeBlank();
    }

    /**
     * @return \DOMNode
     */
    public function getNode(): \DOMNode
    {
        return new \DOMNode();
    }

    /**
     * Create a new "XmlDomParser"-object from the current context.
     *
     * @return XmlDomParser
     */
    public function getXmlDomParser(): XmlDomParser
    {
        return new XmlDomParser($this);
    }

    /**
     * Get dom node's inner html.
     *
     * @param bool $multiDecodeNewHtmlEntity
     *
     * @return string
     */
    public function innerHtml(bool $multiDecodeNewHtmlEntity = false): string
    {
        return '';
    }

    /**
     * Nodes can get partially destroyed in which they're still an
     * actual DOM node (such as \DOMElement) but almost their entire
     * body is gone, including the `nodeType` attribute.
     *
     * @return bool true if node has been destroyed
     */
    public function isRemoved(): bool
    {
        return true;
    }

    /**
     * Returns the last child of node.
     *
     * @return null
     */
    public function lastChild()
    {
        return null;
    }

    /**
     * Returns the next sibling of node.
     *
     * @return null
     */
    public function nextSibling()
    {
        return null;
    }

    /**
     * Returns the parent of node.
     *
     * @return SimpleXmlDomInterface
     */
    public function parentNode(): SimpleXmlDomInterface
    {
        return new static();
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Returns the previous sibling of node.
     *
     * @return null
     */
    public function previousSibling()
    {
        return null;
    }

    /**
     * @param string|string[]|null $value <p>
     *                                    null === get the current input value
     *                                    text === set a new input value
     *                                    </p>
     *
     * @return string|string[]|null
     */
    public function val($value = null)
    {
        return null;
    }

    /**
     * Retrieve an external iterator.
     *
     * @see  http://php.net/manual/en/iteratoraggregate.getiterator.php
     *
     * @return SimpleXmlDomNodeInterface
     *                           <p>
     *                              An instance of an object implementing <b>Iterator</b> or
     *                              <b>Traversable</b>
     *                           </p>
     */
    public function getIterator(): SimpleXmlDomNodeInterface
    {
        return new SimpleXmlDomNodeBlank();
    }

    /**
     * Get dom node's outer html.
     *
     * @param bool $multiDecodeNewHtmlEntity
     *
     * @return string
     */
    public function html(bool $multiDecodeNewHtmlEntity = false): string

    {
        return '';
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace voku\helper;
6
7		/** @noinspection PhpHierarchyChecksInspection */
8	View Code Duplication	class SimpleXmlDomBlank extends AbstractSimpleXmlDom implements \IteratorAggregate, SimpleXmlDomInterface
		0 ignored issues – show Duplication introduced 2019-07-01 08:00 UTC by Report Bug Copy Issue Report This class seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
9		{
10		/**
11		* @param string $name
12		* @param array $arguments
13		*
14		* @throws \BadMethodCallException
15		*
16		* @return SimpleXmlDomInterface\|string\|null
17		*/
18		public function __call($name, $arguments)
19		{
20		$name = \strtolower($name);
21
22		if (isset(self::$functionAliases[$name])) {
23		return \call_user_func_array([$this, self::$functionAliases[$name]], $arguments);
24		}
25
26		throw new \BadMethodCallException('Method does not exist');
27		}
28
29		/**
30		* Find list of nodes with a CSS selector.
31		*
32		* @param string $selector
33		* @param int\|null $idx
34		*
35		* @return SimpleXmlDomNodeInterface
36		*/
37		public function find(string $selector, $idx = null)
38		{
39		return new SimpleXmlDomNodeBlank();
40		}
41
42		/**
43		* Returns an array of attributes.
44		*
45		* @return null
46		*/
47		public function getAllAttributes()
48		{
49		return null;
50		}
51
52		/**
53		* Return attribute value.
54		*
55		* @param string $name
56		*
57		* @return string
58		*/
59		public function getAttribute(string $name): string
60		{
61		return '';
62		}
63
64		/**
65		* Determine if an attribute exists on the element.
66		*
67		* @param string $name
68		*
69		* @return bool
70		*/
71		public function hasAttribute(string $name): bool
72		{
73		return false;
74		}
75
76		/**
77		* Get dom node's inner xml.
78		*
79		* @param bool $multiDecodeNewHtmlEntity
80		*
81		* @return string
82		*/
83		public function innerXml(bool $multiDecodeNewHtmlEntity = false): string
84		{
85		return '';
86		}
87
88		/**
89		* Remove attribute.
90		*
91		* @param string $name <p>The name of the html-attribute.</p>
92		*
93		* @return SimpleXmlDomInterface
94		*/
95		public function removeAttribute(string $name): SimpleXmlDomInterface
96		{
97		return $this;
		0 ignored issues – show Bug Best Practice introduced 2019-07-01 08:00 UTC by Report Bug Copy Issue Report The return type of `return $this;` (`voku\helper\SimpleXmlDomBlank`) is incompatible with the return type declared by the interface `voku\helper\SimpleXmlDomInterface::removeAttribute` of type `self`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
98		}
99
100		protected function replaceChildWithString(string $string): SimpleXmlDomInterface
101		{
102		return new static();
103		}
104
105		protected function replaceNodeWithString(string $string): SimpleXmlDomInterface
106		{
107		return new static();
108		}
109
110		protected function replaceTextWithString($string): SimpleXmlDomInterface
111		{
112		return new static();
113		}
114
115		/**
116		* Set attribute value.
117		*
118		* @param string $name <p>The name of the html-attribute.</p>
119		* @param string\|null $value <p>Set to NULL or empty string, to remove the attribute.</p>
120		* @param bool $strict </p>
121		* $value must be NULL, to remove the attribute,
122		* so that you can set an empty string as attribute-value e.g. autofocus=""
123		* </p>
124		*
125		* @return SimpleXmlDomInterface
126		*/
127		public function setAttribute(string $name, $value = null, bool $strict = false): SimpleXmlDomInterface
128		{
129		return $this;
		0 ignored issues – show Bug Best Practice introduced 2019-07-01 08:00 UTC by Report Bug Copy Issue Report The return type of `return $this;` (`voku\helper\SimpleXmlDomBlank`) is incompatible with the return type declared by the interface `voku\helper\SimpleXmlDomInterface::setAttribute` of type `self`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
130		}
131
132		/**
133		* Get dom node's plain text.
134		*
135		* @return string
136		*/
137		public function text(): string
138		{
139		return '';
140		}
141
142		/**
143		* Get dom node's outer html.
144		*
145		* @param bool $multiDecodeNewHtmlEntity
146		*
147		* @return string
148		*/
149		public function xml(bool $multiDecodeNewHtmlEntity = false): string
150		{
151		return '';
152		}
153
154		/**
155		* Returns children of node.
156		*
157		* @param int $idx
158		*
159		* @return null
160		*/
161		public function childNodes(int $idx = -1)
162		{
163		return null;
164		}
165
166		/**
167		* Find nodes with a CSS selector.
168		*
169		* @param string $selector
170		*
171		* @return SimpleXmlDomNodeInterface
172		*/
173		public function findMulti(string $selector): SimpleXmlDomNodeInterface
174		{
175		return new SimpleXmlDomNodeBlank();
176		}
177
178		/**
179		* Find one node with a CSS selector.
180		*
181		* @param string $selector
182		*
183		* @return SimpleXmlDomInterface
184		*/
185		public function findOne(string $selector): SimpleXmlDomInterface
186		{
187		return new static();
		0 ignored issues – show Bug Best Practice introduced 2019-07-01 08:00 UTC by Report Bug Copy Issue Report The return type of `return new static();` (`voku\helper\SimpleXmlDomBlank`) is incompatible with the return type declared by the interface `voku\helper\SimpleXmlDomInterface::findOne` of type `self`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
188		}
189
190		/**
191		* Returns the first child of node.
192		*
193		* @return null
194		*/
195		public function firstChild()
196		{
197		return null;
198		}
199
200		/**
201		* Return elements by .class.
202		*
203		* @param string $class
204		*
205		* @return SimpleXmlDomNodeInterface
206		*/
207		public function getElementByClass(string $class): SimpleXmlDomNodeInterface
208		{
209		return new SimpleXmlDomNodeBlank();
210		}
211
212		/**
213		* Return element by #id.
214		*
215		* @param string $id
216		*
217		* @return SimpleXmlDomInterface
218		*/
219		public function getElementById(string $id): SimpleXmlDomInterface
220		{
221		return new static();
		0 ignored issues – show Bug Best Practice introduced 2019-07-01 08:00 UTC by Report Bug Copy Issue Report The return type of `return new static();` (`voku\helper\SimpleXmlDomBlank`) is incompatible with the return type declared by the interface `voku\helper\SimpleXmlDomInterface::getElementById` of type `self`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
222		}
223
224		/**
225		* Return element by tag name.
226		*
227		* @param string $name
228		*
229		* @return SimpleXmlDomInterface
230		*/
231		public function getElementByTagName(string $name): SimpleXmlDomInterface
232		{
233		return new static();
		0 ignored issues – show Bug Best Practice introduced 2019-07-01 08:00 UTC by Report Bug Copy Issue Report The return type of `return new static();` (`voku\helper\SimpleXmlDomBlank`) is incompatible with the return type declared by the interface `voku\helper\SimpleXmlDom...ce::getElementByTagName` of type `self`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
234		}
235
236		/**
237		* Returns elements by #id.
238		*
239		* @param string $id
240		* @param int\|null $idx
241		*
242		* @return SimpleXmlDomNodeInterface
243		*/
244		public function getElementsById(string $id, $idx = null)
245		{
246		return new SimpleXmlDomNodeBlank();
247		}
248
249		/**
250		* Returns elements by tag name.
251		*
252		* @param string $name
253		* @param int\|null $idx
254		*
255		* @return SimpleXmlDomNodeInterface
256		*/
257		public function getElementsByTagName(string $name, $idx = null)
258		{
259		return new SimpleXmlDomNodeBlank();
260		}
261
262		/**
263		* @return \DOMNode
264		*/
265		public function getNode(): \DOMNode
266		{
267		return new \DOMNode();
268		}
269
270		/**
271		* Create a new "XmlDomParser"-object from the current context.
272		*
273		* @return XmlDomParser
274		*/
275		public function getXmlDomParser(): XmlDomParser
276		{
277		return new XmlDomParser($this);
278		}
279
280		/**
281		* Get dom node's inner html.
282		*
283		* @param bool $multiDecodeNewHtmlEntity
284		*
285		* @return string
286		*/
287		public function innerHtml(bool $multiDecodeNewHtmlEntity = false): string
288		{
289		return '';
290		}
291
292		/**
293		* Nodes can get partially destroyed in which they're still an
294		* actual DOM node (such as \DOMElement) but almost their entire
295		* body is gone, including the `nodeType` attribute.
296		*
297		* @return bool true if node has been destroyed
298		*/
299		public function isRemoved(): bool
300		{
301		return true;
302		}
303
304		/**
305		* Returns the last child of node.
306		*
307		* @return null
308		*/
309		public function lastChild()
310		{
311		return null;
312		}
313
314		/**
315		* Returns the next sibling of node.
316		*
317		* @return null
318		*/
319		public function nextSibling()
320		{
321		return null;
322		}
323
324		/**
325		* Returns the parent of node.
326		*
327		* @return SimpleXmlDomInterface
328		*/
329		public function parentNode(): SimpleXmlDomInterface
330		{
331		return new static();
		0 ignored issues – show Bug Best Practice introduced 2019-07-01 08:00 UTC by Report Bug Copy Issue Report The return type of `return new static();` (`voku\helper\SimpleXmlDomBlank`) is incompatible with the return type declared by the interface `voku\helper\SimpleXmlDomInterface::parentNode` of type `self`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
332		}
333
334		/**
335		* Returns the previous sibling of node.
336		*
337		* @return null
338		*/
339		public function previousSibling()
340		{
341		return null;
342		}
343
344		/**
345		* @param string\|string[]\|null $value <p>
346		* null === get the current input value
347		* text === set a new input value
348		* </p>
349		*
350		* @return string\|string[]\|null
351		*/
352		public function val($value = null)
353		{
354		return null;
355		}
356
357		/**
358		* Retrieve an external iterator.
359		*
360		* @see http://php.net/manual/en/iteratoraggregate.getiterator.php
361		*
362		* @return SimpleXmlDomNodeInterface
363		* <p>
364		* An instance of an object implementing <b>Iterator</b> or
365		* <b>Traversable</b>
366		* </p>
367		*/
368		public function getIterator(): SimpleXmlDomNodeInterface
369		{
370		return new SimpleXmlDomNodeBlank();
371		}
372
373		/**
374		* Get dom node's outer html.
375		*
376		* @param bool $multiDecodeNewHtmlEntity
377		*
378		* @return string
379		*/
380		public function html(bool $multiDecodeNewHtmlEntity = false): string
		0 ignored issues – show Unused Code introduced 2019-07-01 08:00 UTC by Report Bug Copy Issue Report The parameter `$multiDecodeNewHtmlEntity` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
381		{
382		return '';
383		}
384		}
385

voku / simple_html_dom

Push — master ( d36330...3c9b9d )

SimpleXmlDomBlank::childNodes() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like