SimpleHtmlDomBlank::replaceNodeWithString() - 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

SimpleHtmlDomBlank::replaceNodeWithString() A

↳ Parent: SimpleHtmlDomBlank

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 SimpleHtmlDomBlank extends AbstractSimpleHtmlDom implements \IteratorAggregate, SimpleHtmlDomInterface

{
    /**
     * @param string $name
     * @param array  $arguments
     *
     * @throws \BadMethodCallException
     *
     * @return SimpleHtmlDomInterface|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 SimpleHtmlDomNodeInterface
     */
    public function find(string $selector, $idx = null)
    {
        return new SimpleHtmlDomNodeBlank();
    }

    /**
     * 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 outer html.
     *
     * @param bool $multiDecodeNewHtmlEntity
     *
     * @return string
     */
    public function html(bool $multiDecodeNewHtmlEntity = false): string
    {
        return '';
    }

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

    /**
     * Remove attribute.
     *
     * @param string $name <p>The name of the html-attribute.</p>
     *
     * @return SimpleHtmlDomInterface
     */
    public function removeAttribute(string $name): SimpleHtmlDomInterface
    {
        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): SimpleHtmlDomInterface
    {
        return new static();
    }

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

    protected function replaceTextWithString($string): SimpleHtmlDomInterface
    {
        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 SimpleHtmlDomInterface
     */
    public function setAttribute(string $name, $value = null, bool $strict = false): SimpleHtmlDomInterface
    {
        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 '';
    }

    /**
     * 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 SimpleHtmlDomNodeInterface
     */
    public function findMulti(string $selector): SimpleHtmlDomNodeInterface
    {
        return new SimpleHtmlDomNodeBlank();
    }

    /**
     * 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 SimpleHtmlDomInterface
     */
    public function findOne(string $selector): SimpleHtmlDomInterface
    {
        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 SimpleHtmlDomNodeInterface
     */
    public function getElementByClass(string $class): SimpleHtmlDomNodeInterface
    {
        return new SimpleHtmlDomNodeBlank();
    }

    /**
     * Return element by #id.
     *
     * @param string $id
     *
     * @return SimpleHtmlDomInterface
     */
    public function getElementById(string $id): SimpleHtmlDomInterface
    {
        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 SimpleHtmlDomInterface
     */
    public function getElementByTagName(string $name): SimpleHtmlDomInterface
    {
        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 SimpleHtmlDomNodeInterface
     */
    public function getElementsById(string $id, $idx = null)
    {
        return new SimpleHtmlDomNodeBlank();
    }

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

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

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

    /**
     * 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 SimpleHtmlDomInterface
     */
    public function parentNode(): SimpleHtmlDomInterface
    {
        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 SimpleHtmlDomNodeInterface
     *                           <p>
     *                              An instance of an object implementing <b>Iterator</b> or
     *                              <b>Traversable</b>
     *                           </p>
     */
    public function getIterator(): SimpleHtmlDomNodeInterface
    {
        return new SimpleHtmlDomNodeBlank();
    }

    /**
     * Get dom node's inner xml.
     *
     * @param bool $multiDecodeNewHtmlEntity
     *
     * @return string
     */
    public function innerXml(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 SimpleHtmlDomBlank extends AbstractSimpleHtmlDom implements \IteratorAggregate, SimpleHtmlDomInterface
			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 SimpleHtmlDomInterface\|string\|null
17			*/
18	1		public function __call($name, $arguments)
19			{
20	1		$name = \strtolower($name);
21
22	1		if (isset(self::$functionAliases[$name])) {
23	1		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 SimpleHtmlDomNodeInterface
36			*/
37			public function find(string $selector, $idx = null)
38			{
39			return new SimpleHtmlDomNodeBlank();
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	2		public function getAttribute(string $name): string
60			{
61	2		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 outer html.
78			*
79			* @param bool $multiDecodeNewHtmlEntity
80			*
81			* @return string
82			*/
83	1		public function html(bool $multiDecodeNewHtmlEntity = false): string
84			{
85	1		return '';
86			}
87
88			/**
89			* Get dom node's inner html.
90			*
91			* @param bool $multiDecodeNewHtmlEntity
92			*
93			* @return string
94			*/
95	1		public function innerHtml(bool $multiDecodeNewHtmlEntity = false): string
96			{
97	1		return '';
98			}
99
100			/**
101			* Remove attribute.
102			*
103			* @param string $name <p>The name of the html-attribute.</p>
104			*
105			* @return SimpleHtmlDomInterface
106			*/
107			public function removeAttribute(string $name): SimpleHtmlDomInterface
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\SimpleHtmlDomBlank`) is incompatible with the return type declared by the interface `voku\helper\SimpleHtmlDo...erface::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	2		protected function replaceChildWithString(string $string): SimpleHtmlDomInterface
113			{
114	2		return new static();
115			}
116
117			protected function replaceNodeWithString(string $string): SimpleHtmlDomInterface
118			{
119			return new static();
120			}
121
122			protected function replaceTextWithString($string): SimpleHtmlDomInterface
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 SimpleHtmlDomInterface
138			*/
139	1		public function setAttribute(string $name, $value = null, bool $strict = false): SimpleHtmlDomInterface
140			{
141	1		return $this;
			0 ignored issues – show Bug Best Practice introduced 2019-04-25 23:06 UTC by Report Bug Copy Issue Report The return type of `return $this;` (`voku\helper\SimpleHtmlDomBlank`) is incompatible with the return type declared by the interface `voku\helper\SimpleHtmlDomInterface::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	3		public function text(): string
150			{
151	3		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 SimpleHtmlDomNodeInterface
172			*/
173			public function findMulti(string $selector): SimpleHtmlDomNodeInterface
174			{
175			return new SimpleHtmlDomNodeBlank();
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 SimpleHtmlDomInterface
196			*/
197			public function findOne(string $selector): SimpleHtmlDomInterface
198			{
199			return new static();
			0 ignored issues – show Bug Best Practice introduced 2019-04-25 23:06 UTC by Report Bug Copy Issue Report The return type of `return new static();` (`voku\helper\SimpleHtmlDomBlank`) is incompatible with the return type declared by the interface `voku\helper\SimpleHtmlDomInterface::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 SimpleHtmlDomNodeInterface
230			*/
231			public function getElementByClass(string $class): SimpleHtmlDomNodeInterface
232			{
233			return new SimpleHtmlDomNodeBlank();
234			}
235
236			/**
237			* Return element by #id.
238			*
239			* @param string $id
240			*
241			* @return SimpleHtmlDomInterface
242			*/
243			public function getElementById(string $id): SimpleHtmlDomInterface
244			{
245			return new static();
			0 ignored issues – show Bug Best Practice introduced 2019-04-25 23:06 UTC by Report Bug Copy Issue Report The return type of `return new static();` (`voku\helper\SimpleHtmlDomBlank`) is incompatible with the return type declared by the interface `voku\helper\SimpleHtmlDomInterface::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 SimpleHtmlDomInterface
254			*/
255			public function getElementByTagName(string $name): SimpleHtmlDomInterface
256			{
257			return new static();
			0 ignored issues – show Bug Best Practice introduced 2019-04-25 23:06 UTC by Report Bug Copy Issue Report The return type of `return new static();` (`voku\helper\SimpleHtmlDomBlank`) is incompatible with the return type declared by the interface `voku\helper\SimpleHtmlDo...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 SimpleHtmlDomNodeInterface
267			*/
268			public function getElementsById(string $id, $idx = null)
269			{
270			return new SimpleHtmlDomNodeBlank();
271			}
272
273			/**
274			* Returns elements by tag name.
275			*
276			* @param string $name
277			* @param int\|null $idx
278			*
279			* @return SimpleHtmlDomNodeInterface
280			*/
281			public function getElementsByTagName(string $name, $idx = null)
282			{
283			return new SimpleHtmlDomNodeBlank();
284			}
285
286			/**
287			* Create a new "HtmlDomParser"-object from the current context.
288			*
289			* @return HtmlDomParser
290			*/
291			public function getHtmlDomParser(): HtmlDomParser
292			{
293			return new HtmlDomParser($this);
294			}
295
296			/**
297			* @return \DOMNode
298			*/
299			public function getNode(): \DOMNode
300			{
301			return new \DOMNode();
302			}
303
304			/**
305			* Nodes can get partially destroyed in which they're still an
306			* actual DOM node (such as \DOMElement) but almost their entire
307			* body is gone, including the `nodeType` attribute.
308			*
309			* @return bool true if node has been destroyed
310			*/
311			public function isRemoved(): bool
312			{
313			return true;
314			}
315
316			/**
317			* Returns the last child of node.
318			*
319			* @return null
320			*/
321			public function lastChild()
322			{
323			return null;
324			}
325
326			/**
327			* Returns the next sibling of node.
328			*
329			* @return null
330			*/
331			public function nextSibling()
332			{
333			return null;
334			}
335
336			/**
337			* Returns the parent of node.
338			*
339			* @return SimpleHtmlDomInterface
340			*/
341			public function parentNode(): SimpleHtmlDomInterface
342			{
343			return new static();
			0 ignored issues – show Bug Best Practice introduced 2019-04-25 23:06 UTC by Report Bug Copy Issue Report The return type of `return new static();` (`voku\helper\SimpleHtmlDomBlank`) is incompatible with the return type declared by the interface `voku\helper\SimpleHtmlDomInterface::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...
344			}
345
346			/**
347			* Returns the previous sibling of node.
348			*
349			* @return null
350			*/
351			public function previousSibling()
352			{
353			return null;
354			}
355
356			/**
357			* @param string\|string[]\|null $value <p>
358			* null === get the current input value
359			* text === set a new input value
360			* </p>
361			*
362			* @return string\|string[]\|null
363			*/
364			public function val($value = null)
365			{
366			return null;
367			}
368
369			/**
370			* Retrieve an external iterator.
371			*
372			* @see http://php.net/manual/en/iteratoraggregate.getiterator.php
373			*
374			* @return SimpleHtmlDomNodeInterface
375			* <p>
376			* An instance of an object implementing <b>Iterator</b> or
377			* <b>Traversable</b>
378			* </p>
379			*/
380	1		public function getIterator(): SimpleHtmlDomNodeInterface
381			{
382	1		return new SimpleHtmlDomNodeBlank();
383			}
384
385			/**
386			* Get dom node's inner xml.
387			*
388			* @param bool $multiDecodeNewHtmlEntity
389			*
390			* @return string
391			*/
392			public function innerXml(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...
393			{
394			return '';
395			}
396			}
397

voku / simple_html_dom

Push — master ( d7231d...c3f5ad )

SimpleHtmlDomBlank::replaceNodeWithString() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like