SimpleHtmlDom - Code Metrics - Inspection of "[+]: use "LIBXML*" for PHP >= 5.4" - voku/simple_html_dom - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 32d697...519359 )

by Lars

created 2016-10-22 12:55 UTC

SimpleHtmlDom D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	626
Duplicated Lines	5.43 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

92.38%

Importance

Changes

Metric	Value
wmc	85
c	0
b	0
f	0
lcom	2
cbo	3
dl	34
loc	626
ccs	194
cts	210
cp	0.9238
rs	4.7671

35 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	__call()	10	10	2
C	__get()	0	22	9
A	__invoke()	0	4	1
B	__isset()	0	15	8
B	__set()	0	15	5
A	__toString()	0	4	1
A	__unset()	0	4	1
A	childNodes()	0	14	3
A	find()	0	4	1
A	firstChild()	0	10	2
A	getAllAttributes()	0	13	3
A	getAttribute()	0	6	1
A	getElementById()	0	4	1
A	getElementByTagName()	0	10	2
A	getElementsById()	0	4	1
B	getElementsByTagName()	24	24	5
A	getHtmlDomParser()	0	4	1
A	getIterator()	0	11	3
A	getNode()	0	4	1
A	hasAttribute()	0	4	1
A	html()	0	4	1
A	innerHtml()	0	4	1
A	lastChild()	0	10	2
A	nextSibling()	0	10	2
A	parentNode()	0	4	1
A	previousSibling()	0	10	2
B	replaceChild()	0	25	5
B	replaceNode()	0	27	3
A	normalizeStringForComparision()	0	4	1
B	cleanHtmlWrapper()	0	30	4
A	changeElementName()	0	14	3
B	setAttribute()	0	14	5
A	removeAttribute()	0	6	1
A	text()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like SimpleHtmlDom often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use SimpleHtmlDom, and based on these observations, apply Extract Interface, too.

<?php

namespace voku\helper;

use BadMethodCallException;
use DOMElement;
use DOMNode;
use RuntimeException;

/**
 * Class SimpleHtmlDom
 *
 * @package voku\helper
 *
 * @property string      outerText Get dom node's outer html (alias for "outerHtml")
 * @property string      outerHtml Get dom node's outer html
 * @property string      innerText Get dom node's inner html (alias for "innerHtml")
 * @property string      innerHtml Get dom node's inner html
 * @property-read string plaintext Get dom node's plain text
 * @property-read string tag       Get dom node name
 * @property-read string attr      Get dom node attributes
 *
 * @method SimpleHtmlDomNode|SimpleHtmlDom|null children() children($idx = -1) Returns children of node
 * @method SimpleHtmlDom|null first_child() Returns the first child of node
 * @method SimpleHtmlDom|null last_child() Returns the last child of node
 * @method SimpleHtmlDom|null next_sibling() Returns the next sibling of node
 * @method SimpleHtmlDom|null prev_sibling() Returns the previous sibling of node
 * @method SimpleHtmlDom|null parent() Returns the parent of node
 * @method string outerText() Get dom node's outer html (alias for "outerHtml()")
 * @method string outerHtml() Get dom node's outer html
 * @method string innerText() Get dom node's inner html (alias for "innerHtml()")
 *
 */
class SimpleHtmlDom implements \IteratorAggregate
{
  /**
   * @var array
   */
  protected static $functionAliases = array(
      '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
   */
  protected $node;

  /**
   * SimpleHtmlDom constructor.
   *
   * @param DOMNode $node
   */
  public function __construct(DOMNode $node)
  {
    $this->node = $node;
class Alien {}

class Dalek extends Alien {}

class Plot
{
    /** @var  Dalek */
    public $villain;
}

$alien = new Alien();
$plot = new Plot();
if ($alien instanceof Dalek) {
    $plot->villain = $alien;
}
  }

  /**
   * @param $name
   * @param $arguments
   *
   * @return null|string|SimpleHtmlDom
   *
   */
  public function __call($name, $arguments)

  {
    $name = strtolower($name);

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

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

  /**
   * @param $name
   *
   * @return array|null|string
   */
  public function __get($name)
  {
    $name = strtolower($name);

    switch ($name) {
      case 'outerhtml':
      case 'outertext':
        return $this->html();
      case 'innerhtml':
      case 'innertext':
        return $this->innerHtml();
      case 'text':
      case 'plaintext':
        return $this->text();
      case 'tag':
        return $this->node->nodeName;
      case 'attr':
        return $this->getAllAttributes();
      default:
        return $this->getAttribute($name);
    }
  }

  /**
   * @param string $selector
   * @param int    $idx
   *
   * @return SimpleHtmlDom|SimpleHtmlDomNode|null
   */
  public function __invoke($selector, $idx = null)
  {
    return $this->find($selector, $idx);
  }

  /**
   * @param $name
   *
   * @return bool
   */
  public function __isset($name)
  {
    switch ($name) {
      case 'outertext':
      case 'outerhtml':
      case 'innertext':
      case 'innerhtml':
      case 'plaintext':
      case 'text':
      case 'tag':
        return true;
      default:
        return $this->hasAttribute($name);
    }
  }

  /**
   * @param $name
   * @param $value
   *
   * @return SimpleHtmlDom
   */
  public function __set($name, $value)
  {
    $name = strtolower($name);

    switch ($name) {
      case 'outerhtml':
      case 'outertext':
        return $this->replaceNode($value);
      case 'innertext':
      case 'innerhtml':
        return $this->replaceChild($value);
      default:
        return $this->setAttribute($name, $value);
    }
  }

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

  /**
   * @param $name
   *
   * @return SimpleHtmlDom
   */
  public function __unset($name)
  {
    return $this->removeAttribute($name);
  }

  /**
   * Returns children of node
   *
   * @param int $idx
   *
   * @return SimpleHtmlDomNode|SimpleHtmlDom|null
   */
  public function childNodes($idx = -1)
  {
    $nodeList = $this->getIterator();

    if ($idx === -1) {
      return $nodeList;
    }

    if (isset($nodeList[$idx])) {
      return $nodeList[$idx];
    }

    return null;
  }

  /**
   * Find list of nodes with a CSS selector
   *
   * @param string $selector
   * @param int    $idx
   *
   * @return SimpleHtmlDomNode|SimpleHtmlDomNode[]|SimpleHtmlDomNodeBlank
   */
  public function find($selector, $idx = null)
  {
    return $this->getHtmlDomParser()->find($selector, $idx);
  }

  /**
   * Returns the first child of node
   *
   * @return SimpleHtmlDom|null
   */
  public function firstChild()
  {
    $node = $this->node->firstChild;

    if ($node === null) {
      return null;
    }

    return new self($node);
  }

  /**
   * Returns array of attributes
   *
   * @return array|null
   */
  public function getAllAttributes()
  {
    if ($this->node->hasAttributes()) {
      $attributes = array();
      foreach ($this->node->attributes as $attr) {
        $attributes[$attr->name] = HtmlDomParser::putReplacedBackToPreserveHtmlEntities($attr->value);
      }

      return $attributes;
    }

    return null;
  }

  /**
   * Return attribute value
   *
   * @param string $name
   *
   * @return string
   */
  public function getAttribute($name)
  {
    $html = $this->node->getAttribute($name);

    return HtmlDomParser::putReplacedBackToPreserveHtmlEntities($html);
  }

  /**
   * Return SimpleHtmlDom by id.
   *
   * @param string $id
   *
   * @return SimpleHtmlDomNode|SimpleHtmlDomNode[]|SimpleHtmlDomNodeBlank
   */
  public function getElementById($id)
  {
    return $this->find("#$id", 0);
  }

  /**
   * Return SimpleHtmlDom by tag name.
   *
   * @param string $name
   *
   * @return SimpleHtmlDom|SimpleHtmlDomNodeBlank
   */
  public function getElementByTagName($name)
  {
    $node = $this->node->getElementsByTagName($name)->item(0);

    if ($node !== null) {
      return new self($node);
    } else {
      return new SimpleHtmlDomNodeBlank();
    }
  }

  /**
   * Returns Elements by id
   *
   * @param string   $id
   * @param null|int $idx
   *
   * @return SimpleHtmlDomNode|SimpleHtmlDomNode[]|SimpleHtmlDomNodeBlank
   */
  public function getElementsById($id, $idx = null)
  {
    return $this->find("#$id", $idx);
  }

  /**
   * Returns Elements by tag name
   *
   * @param string   $name
   * @param null|int $idx
   *
   * @return SimpleHtmlDomNode|SimpleHtmlDomNode[]|SimpleHtmlDomNodeBlank
   */
  public function getElementsByTagName($name, $idx = null)

  {
    $nodesList = $this->node->getElementsByTagName($name);

    $elements = new SimpleHtmlDomNode();

    foreach ($nodesList as $node) {
      $elements[] = new self($node);
    }

    if (null === $idx) {
      return $elements;
    } else {
      if ($idx < 0) {
        $idx = count($elements) + $idx;
      }
    }

    if (isset($elements[$idx])) {
      return $elements[$idx];
    } else {
      return new SimpleHtmlDomNodeBlank();
    }
  }

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

  /**
   * Retrieve an external iterator
   *
   * @link  http://php.net/manual/en/iteratoraggregate.getiterator.php
   * @return SimpleHtmlDomNode An instance of an object implementing <b>Iterator</b> or
   * <b>Traversable</b>
   */
  public function getIterator()
  {
    $elements = new SimpleHtmlDomNode();
    if ($this->node->hasChildNodes()) {
      foreach ($this->node->childNodes as $node) {
        $elements[] = new self($node);
      }
    }

    return $elements;
  }

  /**
   * @return DOMNode
   */
  public function getNode()
  {
    return $this->node;
  }

  /**
   * Determine if an attribute exists on the element.
   *
   * @param $name
   *
   * @return bool
   */
  public function hasAttribute($name)
  {
    return $this->node->hasAttribute($name);
  }

  /**
   * Get dom node's outer html
   *
   * @return string
   */
  public function html()
  {
    return $this->getHtmlDomParser()->html();
  }

  /**
   * Get dom node's inner html
   *
   * @return string
   */
  public function innerHtml()
  {
    return $this->getHtmlDomParser()->innerHtml();
  }

  /**
   * Returns the last child of node
   *
   * @return SimpleHtmlDom|null
   */
  public function lastChild()
  {
    $node = $this->node->lastChild;

    if ($node === null) {
      return null;
    }

    return new self($node);
  }

  /**
   * Returns the next sibling of node
   *
   * @return SimpleHtmlDom|null
   */
  public function nextSibling()
  {
    $node = $this->node->nextSibling;

    if ($node === null) {
      return null;
    }

    return new self($node);
  }

  /**
   * Returns the parent of node
   *
   * @return SimpleHtmlDom
   */
  public function parentNode()
  {
    return new self($this->node->parentNode);
  }

  /**
   * Returns the previous sibling of node
   *
   * @return SimpleHtmlDom|null
   */
  public function previousSibling()
  {
    $node = $this->node->previousSibling;

    if ($node === null) {
      return null;
    }

    return new self($node);
  }

  /**
   * Replace child node
   *
   * @param $string
   *
   * @return $this
   */
  protected function replaceChild($string)
  {
    if (!empty($string)) {
      $newDocument = new HtmlDomParser($string);

      if ($this->normalizeStringForComparision($newDocument->outertext) != $this->normalizeStringForComparision($string)) {

        throw new RuntimeException('Not valid HTML fragment');
      }
    }

    foreach ($this->node->childNodes as $node) {
      $this->node->removeChild($node);
    }

    if (!empty($newDocument)) {

      $newDocument = $this->cleanHtmlWrapper($newDocument);

      $newNode = $this->node->ownerDocument->importNode($newDocument->getDocument()->documentElement, true);

      $this->node->appendChild($newNode);
    }

    return $this;
  }

  /**
   * Replace this node
   *
   * @param $string
   *
   * @return $this
   */
  protected function replaceNode($string)
  {
    if (empty($string)) {
      $this->node->parentNode->removeChild($this->node);

      return null;
    }

    $newDocument = new HtmlDomParser($string);

    // DEBUG
    //echo $this->normalizeStringForComparision($newDocument->outertext) . "\n";

    //echo $this->normalizeStringForComparision($string) . "\n\n";


    if ($this->normalizeStringForComparision($newDocument->outertext) != $this->normalizeStringForComparision($string)) {

      throw new RuntimeException('Not valid HTML fragment');
    }

    $newDocument = $this->cleanHtmlWrapper($newDocument);

    $newNode = $this->node->ownerDocument->importNode($newDocument->getDocument()->documentElement, true);

    $this->node->parentNode->replaceChild($newNode, $this->node);
    $this->node = $newNode;

    return $this;
  }

  /**
   * Normalize the given string for comparision.
   *
   * @param $string
   *
   * @return string
   */
  private function normalizeStringForComparision($string)
  {
    return urlencode(urldecode(trim(str_replace(array(' ', "\n", "\r\n", "\r"), '', strtolower($string)))));
  }

  /**
   * @param HtmlDomParser $newDocument
   *
   * @return HtmlDomParser
   */
  protected function cleanHtmlWrapper(HtmlDomParser $newDocument)
  {
    if ($newDocument->getIsDOMDocumentCreatedWithoutHtml() === true) {

      // Remove doc-type node.
      $newDocument->getDocument()->doctype->parentNode->removeChild($newDocument->getDocument()->doctype);

      // Remove html element, preserving child nodes.
      $html = $newDocument->getDocument()->getElementsByTagName('html')->item(0);
      $fragment = $newDocument->getDocument()->createDocumentFragment();
      while ($html->childNodes->length > 0) {
        $fragment->appendChild($html->childNodes->item(0));
      }
      $html->parentNode->replaceChild($fragment, $html);

      // Remove body element, preserving child nodes.
      $body = $newDocument->getDocument()->getElementsByTagName('body')->item(0);
      $fragment = $newDocument->getDocument()->createDocumentFragment();
      while ($body->childNodes->length > 0) {
        $fragment->appendChild($body->childNodes->item(0));
      }
      $body->parentNode->replaceChild($fragment, $body);

      // At this point DOMDocument still added a "<p>"-wrapper around our string,
      // so we replace it with "<simpleHtmlDomP>" and delete this at the ending ...
      $this->changeElementName($newDocument->getDocument()->getElementsByTagName('p')->item(0), 'simpleHtmlDomP');
    }

    return $newDocument;
  }

  /**
   * change the name of a tag in a "DOMNode"
   *
   * @param DOMNode $node
   * @param string  $name
   *
   * @return DOMElement
   */
  protected function changeElementName(\DOMNode $node, $name)
  {
    $newnode = $node->ownerDocument->createElement($name);
    foreach ($node->childNodes as $child) {
      $child = $node->ownerDocument->importNode($child, true);
      $newnode->appendChild($child);
    }
    foreach ($node->attributes as $attrName => $attrNode) {
      $newnode->setAttribute($attrName, $attrNode);
    }
    $newnode->ownerDocument->replaceChild($newnode, $node);

    return $newnode;
  }

  /**
   * Set attribute value
   *
   * @param string      $name
   * @param string|null $value      Set to NULL or empty string, to remove the attribute.
   * @param bool        $strict     $value must be NULL, to remove the attribute,
   *                                so that you can set an empty string as attribute-value e.g. autofocus=""
   *
   * @return $this
   */
  public function setAttribute($name, $value = null, $strict = false)
  {
    if (
        ($strict === true && null === $value)
        ||
        ($strict === false && empty($value))
    ) {
      $this->node->removeAttribute($name);
    } else {
      $this->node->setAttribute($name, $value);
    }

    return $this;
  }

  /**
   * Remove attribute
   *
   * @param $name
   *
   * @return mixed
   */
  public function removeAttribute($name)
  {
    $this->node->removeAttribute($name);

    return $this;
  }

  /**
   * Get dom node's plain text
   *
   * @return string
   */
  public function text()
  {
    return $this->node->textContent;
  }
}


1			<?php
2
3			namespace voku\helper;
4
5			use BadMethodCallException;
6			use DOMElement;
7			use DOMNode;
8			use RuntimeException;
9
10			/**
11			* Class SimpleHtmlDom
12			*
13			* @package voku\helper
14			*
15			* @property string outerText Get dom node's outer html (alias for "outerHtml")
16			* @property string outerHtml Get dom node's outer html
17			* @property string innerText Get dom node's inner html (alias for "innerHtml")
18			* @property string innerHtml Get dom node's inner html
19			* @property-read string plaintext Get dom node's plain text
20			* @property-read string tag Get dom node name
21			* @property-read string attr Get dom node attributes
22			*
23			* @method SimpleHtmlDomNode\|SimpleHtmlDom\|null children() children($idx = -1) Returns children of node
24			* @method SimpleHtmlDom\|null first_child() Returns the first child of node
25			* @method SimpleHtmlDom\|null last_child() Returns the last child of node
26			* @method SimpleHtmlDom\|null next_sibling() Returns the next sibling of node
27			* @method SimpleHtmlDom\|null prev_sibling() Returns the previous sibling of node
28			* @method SimpleHtmlDom\|null parent() Returns the parent of node
29			* @method string outerText() Get dom node's outer html (alias for "outerHtml()")
30			* @method string outerHtml() Get dom node's outer html
31			* @method string innerText() Get dom node's inner html (alias for "innerHtml()")
32			*
33			*/
34			class SimpleHtmlDom implements \IteratorAggregate
35			{
36			/**
37			* @var array
38			*/
39			protected static $functionAliases = array(
40			'children' => 'childNodes',
41			'first_child' => 'firstChild',
42			'last_child' => 'lastChild',
43			'next_sibling' => 'nextSibling',
44			'prev_sibling' => 'previousSibling',
45			'parent' => 'parentNode',
46			'outertext' => 'html',
47			'outerhtml' => 'html',
48			'innertext' => 'innerHtml',
49			'innerhtml' => 'innerHtml',
50			);
51
52			/**
53			* @var DOMElement
54			*/
55			protected $node;
56
57			/**
58			* SimpleHtmlDom constructor.
59			*
60			* @param DOMNode $node
61			*/
62	94		public function __construct(DOMNode $node)
63			{
64	94		$this->node = $node;
			0 ignored issues – show Documentation Bug introduced 2016-04-01 00:28 UTC by Report Bug Copy Issue Report `$node` is of type `object<DOMNode>`, but the property `$node` was declared to be of type `object<DOMElement>`. Are you sure that you always receive this specific sub-class here, or does it make sense to add an `instanceof` check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a given class or a super-class is assigned to a property that is type hinted more strictly. Either this assignment is in error or an instanceof check should be added for that assignment. class Alien {} class Dalek extends Alien {} class Plot { /** @var Dalek */ public $villain; } $alien = new Alien(); $plot = new Plot(); if ($alien instanceof Dalek) { $plot->villain = $alien; } Loading history...
65	94		}
66
67			/**
68			* @param $name
69			* @param $arguments
70			*
71			* @return null\|string\|SimpleHtmlDom
72			*
73			*/
74	8	View Code Duplication	public function __call($name, $arguments)
			0 ignored issues – show Duplication introduced 2016-04-01 00:28 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...
75			{
76	8		$name = strtolower($name);
77
78	8		if (isset(self::$functionAliases[$name])) {
79	8		return call_user_func_array(array($this, self::$functionAliases[$name]), $arguments);
80			}
81
82			throw new BadMethodCallException('Method does not exist');
83			}
84
85			/**
86			* @param $name
87			*
88			* @return array\|null\|string
89			*/
90	41		public function __get($name)
91			{
92	41		$name = strtolower($name);
93
94			switch ($name) {
95	41		case 'outerhtml':
96	41		case 'outertext':
97	17		return $this->html();
98	31		case 'innerhtml':
99	31		case 'innertext':
100	9		return $this->innerHtml();
101	24		case 'text':
102	24		case 'plaintext':
103	15		return $this->text();
104	10		case 'tag':
105	4		return $this->node->nodeName;
106	9		case 'attr':
107			return $this->getAllAttributes();
108	9		default:
109	9		return $this->getAttribute($name);
110	9		}
111			}
112
113			/**
114			* @param string $selector
115			* @param int $idx
116			*
117			* @return SimpleHtmlDom\|SimpleHtmlDomNode\|null
118			*/
119	12		public function __invoke($selector, $idx = null)
120			{
121	12		return $this->find($selector, $idx);
122			}
123
124			/**
125			* @param $name
126			*
127			* @return bool
128			*/
129	1		public function __isset($name)
130			{
131			switch ($name) {
132	1		case 'outertext':
133	1		case 'outerhtml':
134	1		case 'innertext':
135	1		case 'innerhtml':
136	1		case 'plaintext':
137	1		case 'text':
138	1		case 'tag':
139			return true;
140	1		default:
141	1		return $this->hasAttribute($name);
142	1		}
143			}
144
145			/**
146			* @param $name
147			* @param $value
148			*
149			* @return SimpleHtmlDom
150			*/
151	12		public function __set($name, $value)
152			{
153	12		$name = strtolower($name);
154
155			switch ($name) {
156	12		case 'outerhtml':
157	12		case 'outertext':
158	3		return $this->replaceNode($value);
159	9		case 'innertext':
160	9		case 'innerhtml':
161	5		return $this->replaceChild($value);
162	7		default:
163	7		return $this->setAttribute($name, $value);
164	7		}
165			}
166
167			/**
168			* @return string
169			*/
170	2		public function __toString()
171			{
172	2		return $this->html();
173			}
174
175			/**
176			* @param $name
177			*
178			* @return SimpleHtmlDom
179			*/
180	1		public function __unset($name)
181			{
182	1		return $this->removeAttribute($name);
183			}
184
185			/**
186			* Returns children of node
187			*
188			* @param int $idx
189			*
190			* @return SimpleHtmlDomNode\|SimpleHtmlDom\|null
191			*/
192	2		public function childNodes($idx = -1)
193			{
194	2		$nodeList = $this->getIterator();
195
196	2		if ($idx === -1) {
197	2		return $nodeList;
198			}
199
200	2		if (isset($nodeList[$idx])) {
201	2		return $nodeList[$idx];
202			}
203
204	1		return null;
205			}
206
207			/**
208			* Find list of nodes with a CSS selector
209			*
210			* @param string $selector
211			* @param int $idx
212			*
213			* @return SimpleHtmlDomNode\|SimpleHtmlDomNode[]\|SimpleHtmlDomNodeBlank
214			*/
215	25		public function find($selector, $idx = null)
216			{
217	25		return $this->getHtmlDomParser()->find($selector, $idx);
218			}
219
220			/**
221			* Returns the first child of node
222			*
223			* @return SimpleHtmlDom\|null
224			*/
225	4		public function firstChild()
226			{
227	4		$node = $this->node->firstChild;
228
229	4		if ($node === null) {
230	1		return null;
231			}
232
233	4		return new self($node);
234			}
235
236			/**
237			* Returns array of attributes
238			*
239			* @return array\|null
240			*/
241	2		public function getAllAttributes()
242			{
243	2		if ($this->node->hasAttributes()) {
244	2		$attributes = array();
245	2		foreach ($this->node->attributes as $attr) {
246	2		$attributes[$attr->name] = HtmlDomParser::putReplacedBackToPreserveHtmlEntities($attr->value);
247	2		}
248
249	2		return $attributes;
250			}
251
252	1		return null;
253			}
254
255			/**
256			* Return attribute value
257			*
258			* @param string $name
259			*
260			* @return string
261			*/
262	12		public function getAttribute($name)
263			{
264	12		$html = $this->node->getAttribute($name);
265
266	12		return HtmlDomParser::putReplacedBackToPreserveHtmlEntities($html);
267			}
268
269			/**
270			* Return SimpleHtmlDom by id.
271			*
272			* @param string $id
273			*
274			* @return SimpleHtmlDomNode\|SimpleHtmlDomNode[]\|SimpleHtmlDomNodeBlank
275			*/
276	1		public function getElementById($id)
277			{
278	1		return $this->find("#$id", 0);
279			}
280
281			/**
282			* Return SimpleHtmlDom by tag name.
283			*
284			* @param string $name
285			*
286			* @return SimpleHtmlDom\|SimpleHtmlDomNodeBlank
287			*/
288	1		public function getElementByTagName($name)
289			{
290	1		$node = $this->node->getElementsByTagName($name)->item(0);
291
292	1		if ($node !== null) {
293	1		return new self($node);
294			} else {
295			return new SimpleHtmlDomNodeBlank();
296			}
297			}
298
299			/**
300			* Returns Elements by id
301			*
302			* @param string $id
303			* @param null\|int $idx
304			*
305			* @return SimpleHtmlDomNode\|SimpleHtmlDomNode[]\|SimpleHtmlDomNodeBlank
306			*/
307			public function getElementsById($id, $idx = null)
308			{
309			return $this->find("#$id", $idx);
310			}
311
312			/**
313			* Returns Elements by tag name
314			*
315			* @param string $name
316			* @param null\|int $idx
317			*
318			* @return SimpleHtmlDomNode\|SimpleHtmlDomNode[]\|SimpleHtmlDomNodeBlank
319			*/
320	1	View Code Duplication	public function getElementsByTagName($name, $idx = null)
			0 ignored issues – show Duplication introduced 2016-06-07 08:47 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...
321			{
322	1		$nodesList = $this->node->getElementsByTagName($name);
323
324	1		$elements = new SimpleHtmlDomNode();
325
326	1		foreach ($nodesList as $node) {
327	1		$elements[] = new self($node);
328	1		}
329
330	1		if (null === $idx) {
331	1		return $elements;
332			} else {
333			if ($idx < 0) {
334			$idx = count($elements) + $idx;
335			}
336			}
337
338			if (isset($elements[$idx])) {
339			return $elements[$idx];
340			} else {
341			return new SimpleHtmlDomNodeBlank();
342			}
343			}
344
345			/**
346			* Create a new "HtmlDomParser"-object from the current context.
347			*
348			* @return HtmlDomParser
349			*/
350	51		public function getHtmlDomParser()
351			{
352	51		return new HtmlDomParser($this);
353			}
354
355			/**
356			* Retrieve an external iterator
357			*
358			* @link http://php.net/manual/en/iteratoraggregate.getiterator.php
359			* @return SimpleHtmlDomNode An instance of an object implementing <b>Iterator</b> or
360			* <b>Traversable</b>
361			*/
362	2		public function getIterator()
363			{
364	2		$elements = new SimpleHtmlDomNode();
365	2		if ($this->node->hasChildNodes()) {
366	2		foreach ($this->node->childNodes as $node) {
367	2		$elements[] = new self($node);
368	2		}
369	2		}
370
371	2		return $elements;
372			}
373
374			/**
375			* @return DOMNode
376			*/
377	52		public function getNode()
378			{
379	52		return $this->node;
380			}
381
382			/**
383			* Determine if an attribute exists on the element.
384			*
385			* @param $name
386			*
387			* @return bool
388			*/
389	1		public function hasAttribute($name)
390			{
391	1		return $this->node->hasAttribute($name);
392			}
393
394			/**
395			* Get dom node's outer html
396			*
397			* @return string
398			*/
399	18		public function html()
400			{
401	18		return $this->getHtmlDomParser()->html();
402			}
403
404			/**
405			* Get dom node's inner html
406			*
407			* @return string
408			*/
409	9		public function innerHtml()
410			{
411	9		return $this->getHtmlDomParser()->innerHtml();
412			}
413
414			/**
415			* Returns the last child of node
416			*
417			* @return SimpleHtmlDom\|null
418			*/
419	4		public function lastChild()
420			{
421	4		$node = $this->node->lastChild;
422
423	4		if ($node === null) {
424	1		return null;
425			}
426
427	4		return new self($node);
428			}
429
430			/**
431			* Returns the next sibling of node
432			*
433			* @return SimpleHtmlDom\|null
434			*/
435	1		public function nextSibling()
436			{
437	1		$node = $this->node->nextSibling;
438
439	1		if ($node === null) {
440	1		return null;
441			}
442
443	1		return new self($node);
444			}
445
446			/**
447			* Returns the parent of node
448			*
449			* @return SimpleHtmlDom
450			*/
451	1		public function parentNode()
452			{
453	1		return new self($this->node->parentNode);
454			}
455
456			/**
457			* Returns the previous sibling of node
458			*
459			* @return SimpleHtmlDom\|null
460			*/
461	1		public function previousSibling()
462			{
463	1		$node = $this->node->previousSibling;
464
465	1		if ($node === null) {
466	1		return null;
467			}
468
469	1		return new self($node);
470			}
471
472			/**
473			* Replace child node
474			*
475			* @param $string
476			*
477			* @return $this
478			*/
479	5		protected function replaceChild($string)
480			{
481	5		if (!empty($string)) {
482	4		$newDocument = new HtmlDomParser($string);
483
484	4		if ($this->normalizeStringForComparision($newDocument->outertext) != $this->normalizeStringForComparision($string)) {
			0 ignored issues – show Bug introduced 2016-07-17 18:03 UTC by Report Bug Copy Issue Report The property `outertext` does not seem to exist. Did you mean `outerText`? An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
485			throw new RuntimeException('Not valid HTML fragment');
486			}
487	4		}
488
489	5		foreach ($this->node->childNodes as $node) {
490	5		$this->node->removeChild($node);
491	5		}
492
493	5		if (!empty($newDocument)) {
494
495	4		$newDocument = $this->cleanHtmlWrapper($newDocument);
496
497	4		$newNode = $this->node->ownerDocument->importNode($newDocument->getDocument()->documentElement, true);
498
499	4		$this->node->appendChild($newNode);
500	4		}
501
502	5		return $this;
503			}
504
505			/**
506			* Replace this node
507			*
508			* @param $string
509			*
510			* @return $this
511			*/
512	3		protected function replaceNode($string)
513			{
514	3		if (empty($string)) {
515	2		$this->node->parentNode->removeChild($this->node);
516
517	2		return null;
518			}
519
520	2		$newDocument = new HtmlDomParser($string);
521
522			// DEBUG
523			//echo $this->normalizeStringForComparision($newDocument->outertext) . "\n";
			0 ignored issues – show Unused Code Comprehensibility introduced 2016-06-28 07:52 UTC by Report Bug Copy Issue Report `60%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
524			//echo $this->normalizeStringForComparision($string) . "\n\n";
			0 ignored issues – show Unused Code Comprehensibility introduced 2016-06-28 07:52 UTC by Report Bug Copy Issue Report `62%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
525
526	2		if ($this->normalizeStringForComparision($newDocument->outertext) != $this->normalizeStringForComparision($string)) {
			0 ignored issues – show Bug introduced 2016-07-17 18:03 UTC by Report Bug Copy Issue Report The property `outertext` does not seem to exist. Did you mean `outerText`? An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
527			throw new RuntimeException('Not valid HTML fragment');
528			}
529
530	2		$newDocument = $this->cleanHtmlWrapper($newDocument);
531
532	2		$newNode = $this->node->ownerDocument->importNode($newDocument->getDocument()->documentElement, true);
533
534	2		$this->node->parentNode->replaceChild($newNode, $this->node);
535	2		$this->node = $newNode;
536
537	2		return $this;
538			}
539
540			/**
541			* Normalize the given string for comparision.
542			*
543			* @param $string
544			*
545			* @return string
546			*/
547	6		private function normalizeStringForComparision($string)
548			{
549	6		return urlencode(urldecode(trim(str_replace(array(' ', "\n", "\r\n", "\r"), '', strtolower($string)))));
550			}
551
552			/**
553			* @param HtmlDomParser $newDocument
554			*
555			* @return HtmlDomParser
556			*/
557	6		protected function cleanHtmlWrapper(HtmlDomParser $newDocument)
558			{
559	6		if ($newDocument->getIsDOMDocumentCreatedWithoutHtml() === true) {
560
561			// Remove doc-type node.
562	4		$newDocument->getDocument()->doctype->parentNode->removeChild($newDocument->getDocument()->doctype);
563
564			// Remove html element, preserving child nodes.
565	4		$html = $newDocument->getDocument()->getElementsByTagName('html')->item(0);
566	4		$fragment = $newDocument->getDocument()->createDocumentFragment();
567	4		while ($html->childNodes->length > 0) {
568	4		$fragment->appendChild($html->childNodes->item(0));
569	4		}
570	4		$html->parentNode->replaceChild($fragment, $html);
571
572			// Remove body element, preserving child nodes.
573	4		$body = $newDocument->getDocument()->getElementsByTagName('body')->item(0);
574	4		$fragment = $newDocument->getDocument()->createDocumentFragment();
575	4		while ($body->childNodes->length > 0) {
576	4		$fragment->appendChild($body->childNodes->item(0));
577	4		}
578	4		$body->parentNode->replaceChild($fragment, $body);
579
580			// At this point DOMDocument still added a "<p>"-wrapper around our string,
581			// so we replace it with "<simpleHtmlDomP>" and delete this at the ending ...
582	4		$this->changeElementName($newDocument->getDocument()->getElementsByTagName('p')->item(0), 'simpleHtmlDomP');
583	4		}
584
585	6		return $newDocument;
586			}
587
588			/**
589			* change the name of a tag in a "DOMNode"
590			*
591			* @param DOMNode $node
592			* @param string $name
593			*
594			* @return DOMElement
595			*/
596	4		protected function changeElementName(\DOMNode $node, $name)
597			{
598	4		$newnode = $node->ownerDocument->createElement($name);
599	4		foreach ($node->childNodes as $child) {
600	4		$child = $node->ownerDocument->importNode($child, true);
601	4		$newnode->appendChild($child);
602	4		}
603	4		foreach ($node->attributes as $attrName => $attrNode) {
604			$newnode->setAttribute($attrName, $attrNode);
605	4		}
606	4		$newnode->ownerDocument->replaceChild($newnode, $node);
607
608	4		return $newnode;
609			}
610
611			/**
612			* Set attribute value
613			*
614			* @param string $name
615			* @param string\|null $value Set to NULL or empty string, to remove the attribute.
616			* @param bool $strict $value must be NULL, to remove the attribute,
617			* so that you can set an empty string as attribute-value e.g. autofocus=""
618			*
619			* @return $this
620			*/
621	8		public function setAttribute($name, $value = null, $strict = false)
622			{
623			if (
624	8		($strict === true && null === $value)
625			\|\|
626	8		($strict === false && empty($value))
627	8		) {
628	1		$this->node->removeAttribute($name);
629	1		} else {
630	8		$this->node->setAttribute($name, $value);
631			}
632
633	8		return $this;
634			}
635
636			/**
637			* Remove attribute
638			*
639			* @param $name
640			*
641			* @return mixed
642			*/
643	1		public function removeAttribute($name)
644			{
645	1		$this->node->removeAttribute($name);
646
647	1		return $this;
648			}
649
650			/**
651			* Get dom node's plain text
652			*
653			* @return string
654			*/
655	15		public function text()
656			{
657	15		return $this->node->textContent;
658			}
659			}
660

voku / simple_html_dom