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

Completed

Push — master ( d7231d...c3f5ad )

by Lars

created 2019-08-27 00:08 UTC

SimpleXmlDomBlank::replaceChildWithString() 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 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 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 nodes with a CSS selector or false, if no element is found.
180		*
181		* @param string $selector
182		*
183		* @return false
184		*/
185		public function findMultiOrFalse(string $selector)
186		{
187		return false;
188		}
189
190		/**
191		* Find one node with a CSS selector.
192		*
193		* @param string $selector
194		*
195		* @return SimpleXmlDomInterface
196		*/
197		public function findOne(string $selector): SimpleXmlDomInterface
198		{
199		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...
200		}
201
202		/**
203		* Find one node with a CSS selector or false, if no element is found.
204		*
205		* @param string $selector
206		*
207		* @return false
208		*/
209		public function findOneOrFalse(string $selector)
210		{
211		return false;
212		}
213
214		/**
215		* Returns the first child of node.
216		*
217		* @return null
218		*/
219		public function firstChild()
220		{
221		return null;
222		}
223
224		/**
225		* Return elements by .class.
226		*
227		* @param string $class
228		*
229		* @return SimpleXmlDomNodeInterface
230		*/
231		public function getElementByClass(string $class): SimpleXmlDomNodeInterface
232		{
233		return new SimpleXmlDomNodeBlank();
234		}
235
236		/**
237		* Return element by #id.
238		*
239		* @param string $id
240		*
241		* @return SimpleXmlDomInterface
242		*/
243		public function getElementById(string $id): SimpleXmlDomInterface
244		{
245		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...
246		}
247
248		/**
249		* Return element by tag name.
250		*
251		* @param string $name
252		*
253		* @return SimpleXmlDomInterface
254		*/
255		public function getElementByTagName(string $name): 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\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...
258		}
259
260		/**
261		* Returns elements by #id.
262		*
263		* @param string $id
264		* @param int\|null $idx
265		*
266		* @return SimpleXmlDomNodeInterface
267		*/
268		public function getElementsById(string $id, $idx = null)
269		{
270		return new SimpleXmlDomNodeBlank();
271		}
272
273		/**
274		* Returns elements by tag name.
275		*
276		* @param string $name
277		* @param int\|null $idx
278		*
279		* @return SimpleXmlDomNodeInterface
280		*/
281		public function getElementsByTagName(string $name, $idx = null)
282		{
283		return new SimpleXmlDomNodeBlank();
284		}
285
286		/**
287		* @return \DOMNode
288		*/
289		public function getNode(): \DOMNode
290		{
291		return new \DOMNode();
292		}
293
294		/**
295		* Create a new "XmlDomParser"-object from the current context.
296		*
297		* @return XmlDomParser
298		*/
299		public function getXmlDomParser(): XmlDomParser
300		{
301		return new XmlDomParser($this);
302		}
303
304		/**
305		* Get dom node's inner html.
306		*
307		* @param bool $multiDecodeNewHtmlEntity
308		*
309		* @return string
310		*/
311		public function innerHtml(bool $multiDecodeNewHtmlEntity = false): string
312		{
313		return '';
314		}
315
316		/**
317		* Nodes can get partially destroyed in which they're still an
318		* actual DOM node (such as \DOMElement) but almost their entire
319		* body is gone, including the `nodeType` attribute.
320		*
321		* @return bool true if node has been destroyed
322		*/
323		public function isRemoved(): bool
324		{
325		return true;
326		}
327
328		/**
329		* Returns the last child of node.
330		*
331		* @return null
332		*/
333		public function lastChild()
334		{
335		return null;
336		}
337
338		/**
339		* Returns the next sibling of node.
340		*
341		* @return null
342		*/
343		public function nextSibling()
344		{
345		return null;
346		}
347
348		/**
349		* Returns the parent of node.
350		*
351		* @return SimpleXmlDomInterface
352		*/
353		public function parentNode(): SimpleXmlDomInterface
354		{
355		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...
356		}
357
358		/**
359		* Returns the previous sibling of node.
360		*
361		* @return null
362		*/
363		public function previousSibling()
364		{
365		return null;
366		}
367
368		/**
369		* @param string\|string[]\|null $value <p>
370		* null === get the current input value
371		* text === set a new input value
372		* </p>
373		*
374		* @return string\|string[]\|null
375		*/
376		public function val($value = null)
377		{
378		return null;
379		}
380
381		/**
382		* Retrieve an external iterator.
383		*
384		* @see http://php.net/manual/en/iteratoraggregate.getiterator.php
385		*
386		* @return SimpleXmlDomNodeInterface
387		* <p>
388		* An instance of an object implementing <b>Iterator</b> or
389		* <b>Traversable</b>
390		* </p>
391		*/
392		public function getIterator(): SimpleXmlDomNodeInterface
393		{
394		return new SimpleXmlDomNodeBlank();
395		}
396
397		/**
398		* Get dom node's outer html.
399		*
400		* @param bool $multiDecodeNewHtmlEntity
401		*
402		* @return string
403		*/
404		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...
405		{
406		return '';
407		}
408		}
409

voku / simple_html_dom

Push — master ( d7231d...c3f5ad )

SimpleXmlDomBlank::replaceChildWithString() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like