AbstractSimpleHtmlDom::__get() - Code Metrics - Inspection of "add "specialScriptTags"" - voku/simple_html_dom - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#55)

by Volodymyr

created 2020-08-03 18:40 UTC

AbstractSimpleHtmlDom::__get() C

↳ Parent: AbstractSimpleHtmlDom

Complexity

Conditions	16
Paths	15

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	25
CRAP Score	16.1041

Importance

Changes

Metric	Value
dl	0
loc	38
ccs	25
cts	27
cp	0.9259
rs	5.5666
c	0
b	0
f	0
cc	16
nc	15
nop	1
crap	16.1041

How to fix Complexity

<?php

declare(strict_types=1);

namespace voku\helper;

abstract class AbstractSimpleHtmlDom
{
    /**
     * @var array
     */
    protected static $functionAliases = [
        'children'     => 'childNodes',
        'first_child'  => 'firstChild',
        'last_child'   => 'lastChild',
        'next_sibling' => 'nextSibling',
        'prev_sibling' => 'previousSibling',
        'parent'       => 'parentNode',
        'outertext'    => 'html',
        'outerhtml'    => 'html',
        'innertext'    => 'innerHtml',
        'innerhtml'    => 'innerHtml',
    ];

    /**
     * @var \DOMElement|\DOMNode|null
     */
    protected $node;

    /**
     * @var SimpleHtmlAttributes|null
     */
    private $classListCache;

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

    /**
     * @param string $name
     *
     * @return SimpleHtmlAttributes|string|string[]|null
     */
    public function __get($name)
    {
        $nameOrig = $name;
        $name = \strtolower($name);

        switch ($name) {
            case 'outerhtml':
            case 'outertext':
            case 'html':
                return $this->html();
            case 'innerhtml':
            case 'innertext':
                return $this->innerHtml();
            case 'text':
            case 'plaintext':
                return $this->text();
            case 'tag':
                return $this->node ? $this->node->nodeName : '';
            case 'attr':
                return $this->getAllAttributes();
            case 'classlist':
                if ($this->classListCache === null) {
                    $this->classListCache = new SimpleHtmlAttributes($this->node ?? null, 'class');
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                }

                return $this->classListCache;
            default:
                if ($this->node && \property_exists($this->node, $nameOrig)) {
                    if (\is_string($this->node->{$nameOrig})) {
                        return HtmlDomParser::putReplacedBackToPreserveHtmlEntities($this->node->{$nameOrig});
                    }

                    return $this->node->{$nameOrig};
                }

                return $this->getAttribute($name);
        }
    }

    /**
     * @param string $selector
     * @param int    $idx
     *
     * @return SimpleHtmlDomInterface|SimpleHtmlDomInterface[]|SimpleHtmlDomNodeInterface<SimpleHtmlDomInterface>

     */
    public function __invoke($selector, $idx = null)
    {
        return $this->find($selector, $idx);
    }

    /**
     * @param string $name
     *
     * @return bool
     */
    public function __isset($name)

    {
        $nameOrig = $name;
        $name = \strtolower($name);

        switch ($name) {
            case 'outertext':
            case 'outerhtml':
            case 'innertext':
            case 'innerhtml':
            case 'plaintext':
            case 'text':
            case 'tag':
                return true;
            default:
                if ($this->node && \property_exists($this->node, $nameOrig)) {
                    return isset($this->node->{$nameOrig});
                }

                return $this->hasAttribute($name);
        }
    }

    /**
     * @param string $name
     * @param mixed  $value
     *
     * @return SimpleHtmlDomInterface|null
     */
    public function __set($name, $value)
    {
        $nameOrig = $name;
        $name = \strtolower($name);

        switch ($name) {
            case 'outerhtml':
            case 'outertext':
                return $this->replaceNodeWithString($value);
            case 'innertext':
            case 'innerhtml':
                return $this->replaceChildWithString($value);
            case 'plaintext':
                return $this->replaceTextWithString($value);
            case 'classlist':
                $name = 'class';
                $nameOrig = 'class';
                // no break
            default:

                if ($this->node && \property_exists($this->node, $nameOrig)) {
                    return $this->node->{$nameOrig} = $value;
                }

                return $this->setAttribute($name, $value);
        }
    }

    /**
     * @return string
     */
    public function __toString()
    {
        return $this->html();
    }

    /**
     * @param string $name
     *
     * @return void
     */
    public function __unset($name)
    {
        /** @noinspection UnusedFunctionResultInspection */
        $this->removeAttribute($name);
    }

    /**
     * @param string $selector
     * @param int|null   $idx
     *
     * @return mixed
     */
    abstract public function find(string $selector, $idx = null);

    /**
     * @return string[]|null
     */
    abstract public function getAllAttributes();

    abstract public function getAttribute(string $name): string;

    abstract public function hasAttribute(string $name): bool;

    abstract public function html(bool $multiDecodeNewHtmlEntity = false): string;

    abstract public function innerHtml(bool $multiDecodeNewHtmlEntity = false): string;

    abstract public function removeAttribute(string $name): SimpleHtmlDomInterface;

    abstract protected function replaceChildWithString(string $string): SimpleHtmlDomInterface;

    abstract protected function replaceNodeWithString(string $string): SimpleHtmlDomInterface;

    /**
     * @param string $string
     *
     * @return SimpleHtmlDomInterface
     */
    abstract protected function replaceTextWithString($string): SimpleHtmlDomInterface;

    /**
     * @param string $name
     * @param string|null   $value
     * @param bool   $strict
     *
     * @return SimpleHtmlDomInterface
     */
    abstract public function setAttribute(string $name, $value = null, bool $strict = false): SimpleHtmlDomInterface;

    abstract public function text(): string;
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace voku\helper;
6
7			abstract class AbstractSimpleHtmlDom
8			{
9			/**
10			* @var array
11			*/
12			protected static $functionAliases = [
13			'children' => 'childNodes',
14			'first_child' => 'firstChild',
15			'last_child' => 'lastChild',
16			'next_sibling' => 'nextSibling',
17			'prev_sibling' => 'previousSibling',
18			'parent' => 'parentNode',
19			'outertext' => 'html',
20			'outerhtml' => 'html',
21			'innertext' => 'innerHtml',
22			'innerhtml' => 'innerHtml',
23			];
24
25			/**
26			* @var \DOMElement\|\DOMNode\|null
27			*/
28			protected $node;
29
30			/**
31			* @var SimpleHtmlAttributes\|null
32			*/
33			private $classListCache;
34
35			/**
36			* @param string $name
37			* @param array $arguments
38			*
39			* @throws \BadMethodCallException
40			*
41			* @return SimpleHtmlDomInterface\|string\|null
42			*/
43			public function __call($name, $arguments)
44			{
45			$name = \strtolower($name);
46
47			if (isset(self::$functionAliases[$name])) {
48			return \call_user_func_array([$this, self::$functionAliases[$name]], $arguments);
49			}
50
51			throw new \BadMethodCallException('Method does not exist');
52			}
53
54			/**
55			* @param string $name
56			*
57			* @return SimpleHtmlAttributes\|string\|string[]\|null
58			*/
59	81		public function __get($name)
60			{
61	81		$nameOrig = $name;
62	81		$name = \strtolower($name);
63
64	81		switch ($name) {
65	81		case 'outerhtml':
66	73		case 'outertext':
67	63		case 'html':
68	28		return $this->html();
69	63		case 'innerhtml':
70	51		case 'innertext':
71	20		return $this->innerHtml();
72	46		case 'text':
73	41		case 'plaintext':
74	21		return $this->text();
75	29		case 'tag':
76	5		return $this->node ? $this->node->nodeName : '';
77	27		case 'attr':
78			return $this->getAllAttributes();
79	27		case 'classlist':
80	12		if ($this->classListCache === null) {
81	12		$this->classListCache = new SimpleHtmlAttributes($this->node ?? null, 'class');
			0 ignored issues – show Bug introduced 2019-09-12 22:45 UTC by Report Bug Copy Issue Report It seems like `$this->node ?? null` can also be of type `object<DOMNode>`; however, `voku\helper\SimpleHtmlAttributes::__construct()` does only seem to accept `object<DOMElement>\|null`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
82			}
83
84	12		return $this->classListCache;
85			default:
86	15		if ($this->node && \property_exists($this->node, $nameOrig)) {
87	2		if (\is_string($this->node->{$nameOrig})) {
88	2		return HtmlDomParser::putReplacedBackToPreserveHtmlEntities($this->node->{$nameOrig});
89			}
90
91			return $this->node->{$nameOrig};
92			}
93
94	15		return $this->getAttribute($name);
95			}
96			}
97
98			/**
99			* @param string $selector
100			* @param int $idx
101			*
102			* @return SimpleHtmlDomInterface\|SimpleHtmlDomInterface[]\|SimpleHtmlDomNodeInterface<SimpleHtmlDomInterface>
			0 ignored issues – show Documentation introduced 2019-12-08 01:55 UTC by Report Bug Copy Issue Report The doc-type `SimpleHtmlDomInterface\|S...SimpleHtmlDomInterface>` could not be parsed: Expected "\|" or "end of type", but got "<" at position 74. (view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
103			*/
104	12		public function __invoke($selector, $idx = null)
105			{
106	12		return $this->find($selector, $idx);
107			}
108
109			/**
110			* @param string $name
111			*
112			* @return bool
113			*/
114	1	View Code Duplication	public function __isset($name)
			0 ignored issues – show Duplication introduced 2019-07-01 08:00 UTC by Report Bug Copy Issue Report This method 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...
115			{
116	1		$nameOrig = $name;
117	1		$name = \strtolower($name);
118
119	1		switch ($name) {
120	1		case 'outertext':
121	1		case 'outerhtml':
122	1		case 'innertext':
123	1		case 'innerhtml':
124	1		case 'plaintext':
125	1		case 'text':
126	1		case 'tag':
127			return true;
128			default:
129	1		if ($this->node && \property_exists($this->node, $nameOrig)) {
130			return isset($this->node->{$nameOrig});
131			}
132
133	1		return $this->hasAttribute($name);
134			}
135			}
136
137			/**
138			* @param string $name
139			* @param mixed $value
140			*
141			* @return SimpleHtmlDomInterface\|null
142			*/
143	24		public function __set($name, $value)
144			{
145	24		$nameOrig = $name;
146	24		$name = \strtolower($name);
147
148	24		switch ($name) {
149	24		case 'outerhtml':
150	20		case 'outertext':
151	6		return $this->replaceNodeWithString($value);
152	18		case 'innertext':
153	15		case 'innerhtml':
154	9		return $this->replaceChildWithString($value);
155	13		case 'plaintext':
156	1		return $this->replaceTextWithString($value);
157	12		case 'classlist':
158	1		$name = 'class';
159	1		$nameOrig = 'class';
160			// no break
161		View Code Duplication	default:
			0 ignored issues – show Duplication introduced 2018-12-30 21:12 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
162	12		if ($this->node && \property_exists($this->node, $nameOrig)) {
163			return $this->node->{$nameOrig} = $value;
164			}
165
166	12		return $this->setAttribute($name, $value);
167			}
168			}
169
170			/**
171			* @return string
172			*/
173	3		public function __toString()
174			{
175	3		return $this->html();
176			}
177
178			/**
179			* @param string $name
180			*
181			* @return void
182			*/
183			public function __unset($name)
184			{
185			/** @noinspection UnusedFunctionResultInspection */
186			$this->removeAttribute($name);
187			}
188
189			/**
190			* @param string $selector
191			* @param int\|null $idx
192			*
193			* @return mixed
194			*/
195			abstract public function find(string $selector, $idx = null);
196
197			/**
198			* @return string[]\|null
199			*/
200			abstract public function getAllAttributes();
201
202			abstract public function getAttribute(string $name): string;
203
204			abstract public function hasAttribute(string $name): bool;
205
206			abstract public function html(bool $multiDecodeNewHtmlEntity = false): string;
207
208			abstract public function innerHtml(bool $multiDecodeNewHtmlEntity = false): string;
209
210			abstract public function removeAttribute(string $name): SimpleHtmlDomInterface;
211
212			abstract protected function replaceChildWithString(string $string): SimpleHtmlDomInterface;
213
214			abstract protected function replaceNodeWithString(string $string): SimpleHtmlDomInterface;
215
216			/**
217			* @param string $string
218			*
219			* @return SimpleHtmlDomInterface
220			*/
221			abstract protected function replaceTextWithString($string): SimpleHtmlDomInterface;
222
223			/**
224			* @param string $name
225			* @param string\|null $value
226			* @param bool $strict
227			*
228			* @return SimpleHtmlDomInterface
229			*/
230			abstract public function setAttribute(string $name, $value = null, bool $strict = false): SimpleHtmlDomInterface;
231
232			abstract public function text(): string;
233			}
234

voku / simple_html_dom

Pull Request — master (#55)

AbstractSimpleHtmlDom::__get() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like