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

Completed

Push — master ( 2c6d44...280d74 )

by Lars

created 2019-12-02 15:49 UTC

SimpleXmlDomBlank::nextNonWhitespaceSibling() 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
cc	1
nc	1
nop	0
dl	4
loc	4
ccs	0
cts	2
cp	0
crap	2
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace voku\helper;

/**
 * @noinspection PhpHierarchyChecksInspection
 *
 * {@inheritdoc}
 */
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 bool
     */
    public function hasAttributes(): bool
    {
        return false;
    }

    /**
     * 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 nodes with a CSS selector or false, if no element is found.
     *
     * @param string $selector
     *
     * @return false
     */
    public function findMultiOrFalse(string $selector)
    {
        return false;
    }

    /**
     * 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());
}
    }

    /**
     * Find one node with a CSS selector or false, if no element is found.
     *
     * @param string $selector
     *
     * @return false
     */
    public function findOneOrFalse(string $selector)
    {
        return false;
    }

    /**
     * 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 next sibling of node.
     *
     * @return null
     */
    public function nextNonWhitespaceSibling()
    {
        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();
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace voku\helper;
6
7		/**
8		* @noinspection PhpHierarchyChecksInspection
9		*
10		* {@inheritdoc}
11		*/
12	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...
13		{
14		/**
15		* @param string $name
16		* @param array $arguments
17		*
18		* @throws \BadMethodCallException
19		*
20		* @return SimpleXmlDomInterface\|string\|null
21		*/
22		public function __call($name, $arguments)
23		{
24		$name = \strtolower($name);
25
26		if (isset(self::$functionAliases[$name])) {
27		return \call_user_func_array([$this, self::$functionAliases[$name]], $arguments);
28		}
29
30		throw new \BadMethodCallException('Method does not exist');
31		}
32
33		/**
34		* Find list of nodes with a CSS selector.
35		*
36		* @param string $selector
37		* @param int\|null $idx
38		*
39		* @return SimpleXmlDomNodeInterface
40		*/
41		public function find(string $selector, $idx = null)
42		{
43		return new SimpleXmlDomNodeBlank();
44		}
45
46		/**
47		* Returns an array of attributes.
48		*
49		* @return null
50		*/
51		public function getAllAttributes()
52		{
53		return null;
54		}
55
56		/**
57		* @return bool
58		*/
59		public function hasAttributes(): bool
60		{
61		return false;
62		}
63
64		/**
65		* Return attribute value.
66		*
67		* @param string $name
68		*
69		* @return string
70		*/
71		public function getAttribute(string $name): string
72		{
73		return '';
74		}
75
76		/**
77		* Determine if an attribute exists on the element.
78		*
79		* @param string $name
80		*
81		* @return bool
82		*/
83		public function hasAttribute(string $name): bool
84		{
85		return false;
86		}
87
88		/**
89		* Get dom node's inner xml.
90		*
91		* @param bool $multiDecodeNewHtmlEntity
92		*
93		* @return string
94		*/
95		public function innerXml(bool $multiDecodeNewHtmlEntity = false): string
96		{
97		return '';
98		}
99
100		/**
101		* Remove attribute.
102		*
103		* @param string $name <p>The name of the html-attribute.</p>
104		*
105		* @return SimpleXmlDomInterface
106		*/
107		public function removeAttribute(string $name): SimpleXmlDomInterface
108		{
109		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...
110		}
111
112		protected function replaceChildWithString(string $string): SimpleXmlDomInterface
113		{
114		return new static();
115		}
116
117		protected function replaceNodeWithString(string $string): SimpleXmlDomInterface
118		{
119		return new static();
120		}
121
122		protected function replaceTextWithString($string): SimpleXmlDomInterface
123		{
124		return new static();
125		}
126
127		/**
128		* Set attribute value.
129		*
130		* @param string $name <p>The name of the html-attribute.</p>
131		* @param string\|null $value <p>Set to NULL or empty string, to remove the attribute.</p>
132		* @param bool $strict </p>
133		* $value must be NULL, to remove the attribute,
134		* so that you can set an empty string as attribute-value e.g. autofocus=""
135		* </p>
136		*
137		* @return SimpleXmlDomInterface
138		*/
139		public function setAttribute(string $name, $value = null, bool $strict = false): SimpleXmlDomInterface
140		{
141		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...
142		}
143
144		/**
145		* Get dom node's plain text.
146		*
147		* @return string
148		*/
149		public function text(): string
150		{
151		return '';
152		}
153
154		/**
155		* Get dom node's outer html.
156		*
157		* @param bool $multiDecodeNewHtmlEntity
158		*
159		* @return string
160		*/
161		public function xml(bool $multiDecodeNewHtmlEntity = false): string
162		{
163		return '';
164		}
165
166		/**
167		* Returns children of node.
168		*
169		* @param int $idx
170		*
171		* @return null
172		*/
173		public function childNodes(int $idx = -1)
174		{
175		return null;
176		}
177
178		/**
179		* Find nodes with a CSS selector.
180		*
181		* @param string $selector
182		*
183		* @return SimpleXmlDomNodeInterface
184		*/
185		public function findMulti(string $selector): SimpleXmlDomNodeInterface
186		{
187		return new SimpleXmlDomNodeBlank();
188		}
189
190		/**
191		* Find nodes with a CSS selector or false, if no element is found.
192		*
193		* @param string $selector
194		*
195		* @return false
196		*/
197		public function findMultiOrFalse(string $selector)
198		{
199		return false;
200		}
201
202		/**
203		* Find one node with a CSS selector.
204		*
205		* @param string $selector
206		*
207		* @return SimpleXmlDomInterface
208		*/
209		public function findOne(string $selector): SimpleXmlDomInterface
210		{
211		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...
212		}
213
214		/**
215		* Find one node with a CSS selector or false, if no element is found.
216		*
217		* @param string $selector
218		*
219		* @return false
220		*/
221		public function findOneOrFalse(string $selector)
222		{
223		return false;
224		}
225
226		/**
227		* Returns the first child of node.
228		*
229		* @return null
230		*/
231		public function firstChild()
232		{
233		return null;
234		}
235
236		/**
237		* Return elements by ".class".
238		*
239		* @param string $class
240		*
241		* @return SimpleXmlDomNodeInterface
242		*/
243		public function getElementByClass(string $class): SimpleXmlDomNodeInterface
244		{
245		return new SimpleXmlDomNodeBlank();
246		}
247
248		/**
249		* Return element by #id.
250		*
251		* @param string $id
252		*
253		* @return SimpleXmlDomInterface
254		*/
255		public function getElementById(string $id): SimpleXmlDomInterface
256		{
257		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...
258		}
259
260		/**
261		* Return element by tag name.
262		*
263		* @param string $name
264		*
265		* @return SimpleXmlDomInterface
266		*/
267		public function getElementByTagName(string $name): SimpleXmlDomInterface
268		{
269		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...
270		}
271
272		/**
273		* Returns elements by "#id".
274		*
275		* @param string $id
276		* @param int\|null $idx
277		*
278		* @return SimpleXmlDomNodeInterface
279		*/
280		public function getElementsById(string $id, $idx = null)
281		{
282		return new SimpleXmlDomNodeBlank();
283		}
284
285		/**
286		* Returns elements by tag name.
287		*
288		* @param string $name
289		* @param int\|null $idx
290		*
291		* @return SimpleXmlDomNodeInterface
292		*/
293		public function getElementsByTagName(string $name, $idx = null)
294		{
295		return new SimpleXmlDomNodeBlank();
296		}
297
298		/**
299		* @return \DOMNode
300		*/
301		public function getNode(): \DOMNode
302		{
303		return new \DOMNode();
304		}
305
306		/**
307		* Create a new "XmlDomParser"-object from the current context.
308		*
309		* @return XmlDomParser
310		*/
311		public function getXmlDomParser(): XmlDomParser
312		{
313		return new XmlDomParser($this);
314		}
315
316		/**
317		* Get dom node's inner html.
318		*
319		* @param bool $multiDecodeNewHtmlEntity
320		*
321		* @return string
322		*/
323		public function innerHtml(bool $multiDecodeNewHtmlEntity = false): string
324		{
325		return '';
326		}
327
328		/**
329		* Nodes can get partially destroyed in which they're still an
330		* actual DOM node (such as \DOMElement) but almost their entire
331		* body is gone, including the `nodeType` attribute.
332		*
333		* @return bool true if node has been destroyed
334		*/
335		public function isRemoved(): bool
336		{
337		return true;
338		}
339
340		/**
341		* Returns the last child of node.
342		*
343		* @return null
344		*/
345		public function lastChild()
346		{
347		return null;
348		}
349
350		/**
351		* Returns the next sibling of node.
352		*
353		* @return null
354		*/
355		public function nextSibling()
356		{
357		return null;
358		}
359
360		/**
361		* Returns the next sibling of node.
362		*
363		* @return null
364		*/
365		public function nextNonWhitespaceSibling()
366		{
367		return null;
368		}
369
370		/**
371		* Returns the parent of node.
372		*
373		* @return SimpleXmlDomInterface
374		*/
375		public function parentNode(): SimpleXmlDomInterface
376		{
377		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...
378		}
379
380		/**
381		* Returns the previous sibling of node.
382		*
383		* @return null
384		*/
385		public function previousSibling()
386		{
387		return null;
388		}
389
390		/**
391		* @param string\|string[]\|null $value <p>
392		* null === get the current input value
393		* text === set a new input value
394		* </p>
395		*
396		* @return string\|string[]\|null
397		*/
398		public function val($value = null)
399		{
400		return null;
401		}
402
403		/**
404		* Retrieve an external iterator.
405		*
406		* @see http://php.net/manual/en/iteratoraggregate.getiterator.php
407		*
408		* @return SimpleXmlDomNodeInterface
409		* <p>
410		* An instance of an object implementing <b>Iterator</b> or
411		* <b>Traversable</b>
412		* </p>
413		*/
414		public function getIterator(): SimpleXmlDomNodeInterface
415		{
416		return new SimpleXmlDomNodeBlank();
417		}
418		}
419

voku / simple_html_dom

Push — master ( 2c6d44...280d74 )

SimpleXmlDomBlank::nextNonWhitespaceSibling() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like