├── .gitattributes
├── .gitignore
├── .scrutinizer.yml
├── composer.json
├── phpunit.xml.dist
└── src
    └── PHPHtmlParser
        ├── Content.php
        ├── Curl.php
        ├── CurlInterface.php
        ├── Dom.php
        ├── Dom
            ├── AbstractNode.php
            ├── ArrayNode.php
            ├── Collection.php
            ├── HtmlNode.php
            ├── InnerNode.php
            ├── LeafNode.php
            ├── MockNode.php
            ├── Tag.php
            └── TextNode.php
        ├── Exceptions
            ├── ChildNotFoundException.php
            ├── CircularException.php
            ├── CurlException.php
            ├── EmptyCollectionException.php
            ├── NotLoadedException.php
            ├── ParentNotFoundException.php
            ├── StrictException.php
            └── UnknownChildTypeException.php
        ├── Options.php
        ├── Selector.php
        └── StaticDom.php


/.gitattributes:
--------------------------------------------------------------------------------
 1 | /tests              export-ignore
 2 | /.scrutinizar.yml   export-ignore
 3 | /.travis.yml        export-ignore
 4 | /CHANGELOG.md       export-ignore
 5 | /CONTRIBUTING.md    export-ignore
 6 | /LICENSE.md         export-ignore
 7 | /README.md          export-ignore
 8 | /phpunit.php        export-ignore
 9 | /phpunit.xml        export-ignore
10 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | composer.lock
2 | vendor/
3 | phpunit.xml
4 | 


--------------------------------------------------------------------------------
/.scrutinizer.yml:
--------------------------------------------------------------------------------
 1 | filter:
 2 |     paths: [src/*]
 3 |     excluded_paths: [tests/*]
 4 | checks:
 5 |     php:
 6 |         code_rating: true
 7 |         remove_extra_empty_lines: true
 8 |         remove_php_closing_tag: true
 9 |         remove_trailing_whitespace: true
10 |         fix_use_statements:
11 |             remove_unused: true
12 |             preserve_multiple: false
13 |             preserve_blanklines: true
14 |             order_alphabetically: true
15 |         fix_php_opening_tag: true
16 |         fix_linefeed: true
17 |         fix_line_ending: true
18 |         fix_identation_4spaces: true
19 |         fix_doc_comments: true
20 | tools:
21 |     external_code_coverage:
22 |         timeout: 600
23 |         runs: 3
24 |     php_code_coverage: false
25 |     php_code_sniffer:
26 |         config:
27 |             standard: PSR2
28 |         filter:
29 |             paths: ['src']
30 |     php_loc:
31 |         enabled: true
32 |         excluded_dirs: [vendor, test]
33 |     php_cpd:
34 |         enabled: true
35 |         excluded_dirs: [vendor, test]
36 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "thesoftwarefanatics/php-html-parser",
 3 |     "type": "library",
 4 |     "description": "An HTML DOM parser. It allows you to manipulate HTML. Find tags on an HTML page with selectors just like jQuery.",
 5 |     "keywords": ["html", "dom", "parser"],
 6 |     "homepage": "https://github.com/thesoftwarefanatics/php-html-parser",
 7 |     "license": "MIT",
 8 |     "authors": [
 9 |         {
10 |             "name": "Gilles Paquette",
11 |             "email": "paquettg@gmail.com",
12 |             "homepage": "http://gillespaquette.ca"
13 |         },
14 |         {
15 |             "name": "The Software Fanatics GmbH",
16 |             "email": "dev@thesoftwarefanatics.com",
17 |             "homepage": "https://thesoftwarefanatics.com"
18 |         }
19 |     ],
20 |     "require": {
21 |         "php": "^7.1",
22 |         "paquettg/string-encode": "^0.1.1"
23 |     },
24 |     "require-dev": {
25 |         "phpunit/phpunit": "^6.5",
26 |         "php-coveralls/php-coveralls": "^2.0",
27 |         "mockery/mockery": "^1.0"
28 |     },
29 |     "replace": {
30 |         "paquettg/php-html-parser": "self.version"
31 |     },
32 |     "autoload": {
33 |         "psr-0": {
34 |             "PHPHtmlParser": "src/"
35 |         }
36 |     },
37 |     "extra": {
38 |         "branch-alias": {
39 |             "dev-master": "1.8.x-dev"
40 |         }
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/phpunit.xml.dist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit backupGlobals="false"
 3 |     backupStaticAttributes="false"
 4 |     bootstrap="vendor/autoload.php"
 5 |     colors="true"
 6 |     convertErrorsToExceptions="true"
 7 |     convertNoticesToExceptions="true"
 8 |     convertWarningsToExceptions="true"
 9 |     processIsolation="false"
10 |     stopOnFailure="false"
11 |     syntaxCheck="false"
12 | >
13 |     <testsuites>
14 |         <testsuite name="Repository Test Suite">
15 |             <directory>./tests/</directory>
16 |         </testsuite>
17 |     </testsuites>
18 | </phpunit>
19 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Content.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace PHPHtmlParser;
  3 | 
  4 | /**
  5 |  * Class Content
  6 |  *
  7 |  * @package PHPHtmlParser
  8 |  */
  9 | class Content
 10 | {
 11 | 
 12 |     /**
 13 |      * The content string.
 14 |      *
 15 |      * @var string
 16 |      */
 17 |     protected $content;
 18 | 
 19 |     /**
 20 |      * The size of the content.
 21 |      *
 22 |      * @var integer
 23 |      */
 24 |     protected $size;
 25 | 
 26 |     /**
 27 |      * The current position we are in the content.
 28 |      *
 29 |      * @var integer
 30 |      */
 31 |     protected $pos;
 32 | 
 33 |     /**
 34 |      * The following 4 strings are tags that are important to us.
 35 |      *
 36 |      * @var string
 37 |      */
 38 |     protected $blank = " \t\r\n";
 39 |     protected $equal = ' =/>';
 40 |     protected $slash = " />\r\n\t";
 41 |     protected $attr = ' >';
 42 | 
 43 |     /**
 44 |      * Content constructor.
 45 |      *
 46 |      * @param $content
 47 |      */
 48 |     public function __construct($content)
 49 |     {
 50 |         $this->content = $content;
 51 |         $this->size    = strlen($content);
 52 |         $this->pos     = 0;
 53 |     }
 54 | 
 55 |     /**
 56 |      * Returns the current position of the content.
 57 |      *
 58 |      * @return int
 59 |      */
 60 |     public function getPosition()
 61 |     {
 62 |         return $this->pos;
 63 |     }
 64 | 
 65 |     /**
 66 |      * Gets the current character we are at.
 67 |      *
 68 |      * @param int $char
 69 |      * @return string
 70 |      */
 71 |     public function char($char = null)
 72 |     {
 73 |         $pos = $this->pos;
 74 |         if ( ! is_null($char)) {
 75 |             $pos = $char;
 76 |         }
 77 | 
 78 |         if ( ! isset($this->content[$pos])) {
 79 |             return '';
 80 |         }
 81 | 
 82 |         return $this->content[$pos];
 83 |     }
 84 | 
 85 |     /**
 86 |      * Moves the current position forward.
 87 |      *
 88 |      * @param int $count
 89 |      * @return $this
 90 |      */
 91 |     public function fastForward($count)
 92 |     {
 93 |         $this->pos += $count;
 94 | 
 95 |         return $this;
 96 |     }
 97 | 
 98 |     /**
 99 |      * Moves the current position backward.
100 |      *
101 |      * @param int $count
102 |      * @return $this
103 |      */
104 |     public function rewind($count)
105 |     {
106 |         $this->pos -= $count;
107 |         if ($this->pos < 0) {
108 |             $this->pos = 0;
109 |         }
110 | 
111 |         return $this;
112 |     }
113 | 
114 |     /**
115 |      * Copy the content until we find the given string.
116 |      *
117 |      * @param string $string
118 |      * @param bool $char
119 |      * @param bool $escape
120 |      * @return string
121 |      */
122 |     public function copyUntil($string, $char = false, $escape = false)
123 |     {
124 |         if ($this->pos >= $this->size) {
125 |             // nothing left
126 |             return '';
127 |         }
128 | 
129 |         if ($escape) {
130 |             $position = $this->pos;
131 |             $found    = false;
132 |             while ( ! $found) {
133 |                 $position = strpos($this->content, $string, $position);
134 |                 if ($position === false) {
135 |                     // reached the end
136 |                     $found = true;
137 |                     continue;
138 |                 }
139 | 
140 |                 if ($this->char($position - 1) == '\\') {
141 |                     // this character is escaped
142 |                     ++$position;
143 |                     continue;
144 |                 }
145 | 
146 |                 $found = true;
147 |             }
148 |         } elseif ($char) {
149 |             $position = strcspn($this->content, $string, $this->pos);
150 |             $position += $this->pos;
151 |         } else {
152 |             $position = strpos($this->content, $string, $this->pos);
153 |         }
154 | 
155 |         if ($position === false) {
156 |             // could not find character, just return the remaining of the content
157 |             $return    = substr($this->content, $this->pos, $this->size - $this->pos);
158 |             $this->pos = $this->size;
159 | 
160 |             return $return;
161 |         }
162 | 
163 |         if ($position == $this->pos) {
164 |             // we are at the right place
165 |             return '';
166 |         }
167 | 
168 |         $return = substr($this->content, $this->pos, $position - $this->pos);
169 |         // set the new position
170 |         $this->pos = $position;
171 | 
172 |         return $return;
173 |     }
174 | 
175 |     /**
176 |      * Copies the content until the string is found and return it
177 |      * unless the 'unless' is found in the substring.
178 |      *
179 |      * @param string $string
180 |      * @param string $unless
181 |      * @return string
182 |      */
183 |     public function copyUntilUnless($string, $unless)
184 |     {
185 |         $lastPos = $this->pos;
186 |         $this->fastForward(1);
187 |         $foundString = $this->copyUntil($string, true, true);
188 | 
189 |         $position = strcspn($foundString, $unless);
190 |         if ($position == strlen($foundString)) {
191 |             return $string.$foundString;
192 |         }
193 |         // rewind changes and return nothing
194 |         $this->pos = $lastPos;
195 | 
196 |         return '';
197 |     }
198 | 
199 |     /**
200 |      * Copies the content until it reaches the token string.,
201 |      *
202 |      * @param string $token
203 |      * @param bool $char
204 |      * @param bool $escape
205 |      * @return string
206 |      * @uses $this->copyUntil()
207 |      */
208 |     public function copyByToken($token, $char = false, $escape = false)
209 |     {
210 |         $string = $this->$token;
211 | 
212 |         return $this->copyUntil($string, $char, $escape);
213 |     }
214 | 
215 |     /**
216 |      * Skip a given set of characters.
217 |      *
218 |      * @param string $string
219 |      * @param bool $copy
220 |      * @return $this|string
221 |      */
222 |     public function skip($string, $copy = false)
223 |     {
224 |         $len = strspn($this->content, $string, $this->pos);
225 | 
226 |         // make it chainable if they don't want a copy
227 |         $return = $this;
228 |         if ($copy) {
229 |             $return = substr($this->content, $this->pos, $len);
230 |         }
231 | 
232 |         // update the position
233 |         $this->pos += $len;
234 | 
235 |         return $return;
236 |     }
237 | 
238 |     /**
239 |      * Skip a given token of pre-defined characters.
240 |      *
241 |      * @param string $token
242 |      * @param bool $copy
243 |      * @return null|string
244 |      * @uses $this->skip()
245 |      */
246 |     public function skipByToken($token, $copy = false)
247 |     {
248 |         $string = $this->$token;
249 | 
250 |         return $this->skip($string, $copy);
251 |     }
252 | }
253 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Curl.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace PHPHtmlParser;
 3 | 
 4 | use PHPHtmlParser\Exceptions\CurlException;
 5 | 
 6 | /**
 7 |  * Class Curl
 8 |  *
 9 |  * @package PHPHtmlParser
10 |  */
11 | class Curl implements CurlInterface
12 | {
13 | 
14 |     /**
15 |      * A simple curl implementation to get the content of the url.
16 |      *
17 |      * @param string $url
18 |      * @return string
19 |      * @throws CurlException
20 |      */
21 |     public function get($url)
22 |     {
23 |         $ch = curl_init($url);
24 | 
25 |         if ( ! ini_get('open_basedir')) {
26 |             curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
27 |         }
28 | 
29 |         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
30 |         curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 5);
31 | 
32 |         $content = curl_exec($ch);
33 |         if ($content === false) {
34 |             // there was a problem
35 |             $error = curl_error($ch);
36 |             throw new CurlException('Error retrieving "'.$url.'" ('.$error.')');
37 |         }
38 | 
39 |         return $content;
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/CurlInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace PHPHtmlParser;
 3 | 
 4 | /**
 5 |  * Interface CurlInterface
 6 |  *
 7 |  * @package PHPHtmlParser
 8 |  */
 9 | interface CurlInterface
10 | {
11 | 
12 |     /**
13 |      * This method should return the content of the url in a string
14 |      *
15 |      * @param string $url
16 |      * @return string
17 |      */
18 |     public function get($url);
19 | }
20 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Dom.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace PHPHtmlParser;
  3 | 
  4 | use PHPHtmlParser\Dom\AbstractNode;
  5 | use PHPHtmlParser\Dom\HtmlNode;
  6 | use PHPHtmlParser\Dom\TextNode;
  7 | use PHPHtmlParser\Exceptions\NotLoadedException;
  8 | use PHPHtmlParser\Exceptions\StrictException;
  9 | use stringEncode\Encode;
 10 | 
 11 | /**
 12 |  * Class Dom
 13 |  *
 14 |  * @package PHPHtmlParser
 15 |  */
 16 | class Dom
 17 | {
 18 | 
 19 |     /**
 20 |      * The charset we would like the output to be in.
 21 |      *
 22 |      * @var string
 23 |      */
 24 |     protected $defaultCharset = 'UTF-8';
 25 | 
 26 |     /**
 27 |      * Contains the root node of this dom tree.
 28 |      *
 29 |      * @var HtmlNode
 30 |      */
 31 |     public $root;
 32 | 
 33 |     /**
 34 |      * The raw version of the document string.
 35 |      *
 36 |      * @var string
 37 |      */
 38 |     protected $raw;
 39 | 
 40 |     /**
 41 |      * The document string.
 42 |      *
 43 |      * @var Content
 44 |      */
 45 |     protected $content = null;
 46 | 
 47 |     /**
 48 |      * The original file size of the document.
 49 |      *
 50 |      * @var int
 51 |      */
 52 |     protected $rawSize;
 53 | 
 54 |     /**
 55 |      * The size of the document after it is cleaned.
 56 |      *
 57 |      * @var int
 58 |      */
 59 |     protected $size;
 60 | 
 61 |     /**
 62 |      * A global options array to be used by all load calls.
 63 |      *
 64 |      * @var array
 65 |      */
 66 |     protected $globalOptions = [];
 67 | 
 68 |     /**
 69 |      * A persistent option object to be used for all options in the
 70 |      * parsing of the file.
 71 |      *
 72 |      * @var Options
 73 |      */
 74 |     protected $options;
 75 | 
 76 |     /**
 77 |      * A list of tags which will always be self closing
 78 |      *
 79 |      * @var array
 80 |      */
 81 |     protected $selfClosing = [
 82 |         'img',
 83 |         'br',
 84 |         'input',
 85 |         'meta',
 86 |         'link',
 87 |         'hr',
 88 |         'base',
 89 |         'embed',
 90 |         'spacer',
 91 |     ];
 92 | 
 93 |     /**
 94 |      * Returns the inner html of the root node.
 95 |      *
 96 |      * @return string
 97 |      */
 98 |     public function __toString()
 99 |     {
100 |         return $this->root->innerHtml();
101 |     }
102 | 
103 |     /**
104 |      * A simple wrapper around the root node.
105 |      *
106 |      * @param string $name
107 |      * @return mixed
108 |      */
109 |     public function __get($name)
110 |     {
111 |         return $this->root->$name;
112 |     }
113 | 
114 |     /**
115 |      * Attempts to load the dom from any resource, string, file, or URL.
116 |      *
117 |      * @param string $str
118 |      * @param array $options
119 |      * @return $this
120 |      */
121 |     public function load($str, $options = [])
122 |     {
123 |         // check if it's a file
124 |         if (strpos($str, "\n") === false && is_file($str)) {
125 |             return $this->loadFromFile($str, $options);
126 |         }
127 |         // check if it's a url
128 |         if (preg_match("/^https?:\/\//i", $str)) {
129 |             return $this->loadFromUrl($str, $options);
130 |         }
131 | 
132 |         return $this->loadStr($str, $options);
133 |     }
134 | 
135 |     /**
136 |      * Loads the dom from a document file/url
137 |      *
138 |      * @param string $file
139 |      * @param array $options
140 |      * @return $this
141 |      */
142 |     public function loadFromFile($file, $options = [])
143 |     {
144 |         return $this->loadStr(file_get_contents($file), $options);
145 |     }
146 | 
147 |     /**
148 |      * Use a curl interface implementation to attempt to load
149 |      * the content from a url.
150 |      *
151 |      * @param string $url
152 |      * @param array $options
153 |      * @param CurlInterface $curl
154 |      * @return $this
155 |      */
156 |     public function loadFromUrl($url, $options = [], CurlInterface $curl = null)
157 |     {
158 |         if (is_null($curl)) {
159 |             // use the default curl interface
160 |             $curl = new Curl;
161 |         }
162 |         $content = $curl->get($url);
163 | 
164 |         return $this->loadStr($content, $options);
165 |     }
166 | 
167 |     /**
168 |      * Parsers the html of the given string. Used for load(), loadFromFile(),
169 |      * and loadFromUrl().
170 |      *
171 |      * @param string $str
172 |      * @param array $option
173 |      * @return $this
174 |      */
175 |     public function loadStr($str, $option)
176 |     {
177 |         $this->options = new Options;
178 |         $this->options->setOptions($this->globalOptions)
179 |                       ->setOptions($option);
180 | 
181 |         $this->rawSize = strlen($str);
182 |         $this->raw     = $str;
183 | 
184 |         $html = $this->clean($str);
185 | 
186 |         $this->size    = strlen($str);
187 |         $this->content = new Content($html);
188 | 
189 |         $this->parse();
190 |         $this->detectCharset();
191 | 
192 |         return $this;
193 |     }
194 | 
195 |     /**
196 |      * Sets a global options array to be used by all load calls.
197 |      *
198 |      * @param array $options
199 |      * @return $this
200 |      */
201 |     public function setOptions(array $options)
202 |     {
203 |         $this->globalOptions = $options;
204 | 
205 |         return $this;
206 |     }
207 | 
208 |     /**
209 |      * Find elements by css selector on the root node.
210 |      *
211 |      * @param string $selector
212 |      * @param int $nth
213 |      * @return array
214 |      */
215 |     public function find($selector, $nth = null)
216 |     {
217 |         $this->isLoaded();
218 | 
219 |         return $this->root->find($selector, $nth);
220 |     }
221 | 
222 |     /**
223 |      * Adds the tag (or tags in an array) to the list of tags that will always
224 |      * be self closing.
225 |      *
226 |      * @param string|array $tag
227 |      * @return $this
228 |      */
229 |     public function addSelfClosingTag($tag)
230 |     {
231 |         if ( ! is_array($tag)) {
232 |             $tag = [$tag];
233 |         }
234 |         foreach ($tag as $value) {
235 |             $this->selfClosing[] = $value;
236 |         }
237 | 
238 |         return $this;
239 |     }
240 | 
241 |     /**
242 |      * Removes the tag (or tags in an array) from the list of tags that will
243 |      * always be self closing.
244 |      *
245 |      * @param string|array $tag
246 |      * @return $this
247 |      */
248 |     public function removeSelfClosingTag($tag)
249 |     {
250 |         if ( ! is_array($tag)) {
251 |             $tag = [$tag];
252 |         }
253 |         $this->selfClosing = array_diff($this->selfClosing, $tag);
254 | 
255 |         return $this;
256 |     }
257 | 
258 |     /**
259 |      * Sets the list of self closing tags to empty.
260 |      *
261 |      * @return $this
262 |      */
263 |     public function clearSelfClosingTags()
264 |     {
265 |         $this->selfClosing = [];
266 | 
267 |         return $this;
268 |     }
269 | 
270 |     /**
271 |      * Simple wrapper function that returns the first child.
272 |      *
273 |      * @return \PHPHtmlParser\Dom\AbstractNode
274 |      */
275 |     public function firstChild()
276 |     {
277 |         $this->isLoaded();
278 | 
279 |         return $this->root->firstChild();
280 |     }
281 | 
282 |     /**
283 |      * Simple wrapper function that returns the last child.
284 |      *
285 |      * @return \PHPHtmlParser\Dom\AbstractNode
286 |      */
287 |     public function lastChild()
288 |     {
289 |         $this->isLoaded();
290 | 
291 |         return $this->root->lastChild();
292 |     }
293 | 
294 |     /**
295 |      * Simple wrapper function that returns an element by the
296 |      * id.
297 |      *
298 |      * @param string $id
299 |      * @return \PHPHtmlParser\Dom\AbstractNode
300 |      */
301 |     public function getElementById($id)
302 |     {
303 |         $this->isLoaded();
304 | 
305 |         return $this->find('#'.$id, 0);
306 |     }
307 | 
308 |     /**
309 |      * Simple wrapper function that returns all elements by
310 |      * tag name.
311 |      *
312 |      * @param string $name
313 |      * @return array
314 |      */
315 |     public function getElementsByTag($name)
316 |     {
317 |         $this->isLoaded();
318 | 
319 |         return $this->find($name);
320 |     }
321 | 
322 |     /**
323 |      * Simple wrapper function that returns all elements by
324 |      * class name.
325 |      *
326 |      * @param string $class
327 |      * @return array
328 |      */
329 |     public function getElementsByClass($class)
330 |     {
331 |         $this->isLoaded();
332 | 
333 |         return $this->find('.'.$class);
334 |     }
335 | 
336 |     /**
337 |      * Checks if the load methods have been called.
338 |      *
339 |      * @throws NotLoadedException
340 |      */
341 |     protected function isLoaded()
342 |     {
343 |         if (is_null($this->content)) {
344 |             throw new NotLoadedException('Content is not loaded!');
345 |         }
346 |     }
347 | 
348 |     /**
349 |      * Cleans the html of any none-html information.
350 |      *
351 |      * @param string $str
352 |      * @return string
353 |      */
354 |     protected function clean($str)
355 |     {
356 |         if ($this->options->get('cleanupInput') != true) {
357 |             // skip entire cleanup step
358 |             return $str;
359 |         }
360 | 
361 |         // remove white space before closing tags
362 |         $str = preg_replace("#'\s+>#i", "'>", $str);
363 |         $str = preg_replace('#"\s+>#i', '">', $str);
364 | 
365 |         // clean out the \n\r
366 |         $replace = ' ';
367 |         if ($this->options->get('preserveLineBreaks')) {
368 |             $replace = '&#10;';
369 |         }
370 |         $str = str_replace(["\r\n", "\r", "\n"], $replace, $str);
371 | 
372 |         // strip the doctype
373 |         $str = preg_replace("#<!doctype(.*?)>#i", '', $str);
374 | 
375 |         // strip out comments
376 |         $str = preg_replace("#<!--(.*?)-->#i", '', $str);
377 | 
378 |         // strip out cdata
379 |         $str = preg_replace("#<!\[CDATA\[(.*?)\]\]>#i", '', $str);
380 | 
381 |         // strip out <script> tags
382 |         if ($this->options->get('removeScripts') == true) {
383 |             $str = preg_replace("#<\s*script[^>]*[^/]>(.*?)<\s*/\s*script\s*>#i", '', $str);
384 |             $str = preg_replace("#<\s*script\s*>(.*?)<\s*/\s*script\s*>#i", '', $str);
385 |         }
386 | 
387 |         // strip out <style> tags
388 |         if ($this->options->get('removeStyles') == true) {
389 |             $str = preg_replace("#<\s*style[^>]*[^/]>(.*?)<\s*/\s*style\s*>#", '', $str);
390 |             $str = preg_replace("#<\s*style\s*>(.*?)<\s*/\s*style\s*>#", '', $str);
391 |         }
392 | 
393 |         // strip out server side scripts
394 |         $str = preg_replace("#(<\?)(.*?)(\?>)#i", '', $str);
395 | 
396 |         // strip smarty scripts
397 |         $str = preg_replace("#(\{\w)(.*?)(\})#i", '', $str);
398 | 
399 |         return $str;
400 |     }
401 | 
402 |     /**
403 |      * Attempts to parse the html in content.
404 |      */
405 |     protected function parse()
406 |     {
407 |         // add the root node
408 |         $this->root = new HtmlNode('root');
409 |         $activeNode = $this->root;
410 |         while ( ! is_null($activeNode)) {
411 |             $str = $this->content->copyUntil('<');
412 |             if ($str == '') {
413 |                 $info = $this->parseTag();
414 |                 if ( ! $info['status']) {
415 |                     // we are done here
416 |                     $activeNode = null;
417 |                     continue;
418 |                 }
419 | 
420 |                 // check if it was a closing tag
421 |                 if ($info['closing']) {
422 |                     $originalNode = $activeNode;
423 |                     while ($activeNode->getTag()->name() != $info['tag']) {
424 |                         $activeNode = $activeNode->getParent();
425 |                         if (is_null($activeNode)) {
426 |                             // we could not find opening tag
427 |                             $activeNode = $originalNode;
428 |                             break;
429 |                         }
430 |                     }
431 |                     if ( ! is_null($activeNode)) {
432 |                         $activeNode = $activeNode->getParent();
433 |                     }
434 |                     continue;
435 |                 }
436 | 
437 |                 if ( ! isset($info['node'])) {
438 |                     continue;
439 |                 }
440 | 
441 |                 /** @var AbstractNode $node */
442 |                 $node = $info['node'];
443 |                 $activeNode->addChild($node);
444 | 
445 |                 // check if node is self closing
446 |                 if ( ! $node->getTag()->isSelfClosing()) {
447 |                     $activeNode = $node;
448 |                 }
449 |             } else if ($this->options->whitespaceTextNode ||
450 |                 trim($str) != ''
451 |             ) {
452 |                 // we found text we care about
453 |                 $textNode = new TextNode($str);
454 |                 $activeNode->addChild($textNode);
455 |             }
456 |         }
457 |     }
458 | 
459 |     /**
460 |      * Attempt to parse a tag out of the content.
461 |      *
462 |      * @return array
463 |      * @throws StrictException
464 |      */
465 |     protected function parseTag()
466 |     {
467 |         $return = [
468 |             'status'  => false,
469 |             'closing' => false,
470 |             'node'    => null,
471 |         ];
472 |         if ($this->content->char() != '<') {
473 |             // we are not at the beginning of a tag
474 |             return $return;
475 |         }
476 | 
477 |         // check if this is a closing tag
478 |         if ($this->content->fastForward(1)->char() == '/') {
479 |             // end tag
480 |             $tag = $this->content->fastForward(1)
481 |                                  ->copyByToken('slash', true);
482 |             // move to end of tag
483 |             $this->content->copyUntil('>');
484 |             $this->content->fastForward(1);
485 | 
486 |             // check if this closing tag counts
487 |             $tag = strtolower($tag);
488 |             if (in_array($tag, $this->selfClosing)) {
489 |                 $return['status'] = true;
490 | 
491 |                 return $return;
492 |             } else {
493 |                 $return['status']  = true;
494 |                 $return['closing'] = true;
495 |                 $return['tag']     = strtolower($tag);
496 |             }
497 | 
498 |             return $return;
499 |         }
500 | 
501 |         $tag  = strtolower($this->content->copyByToken('slash', true));
502 |         $node = new HtmlNode($tag);
503 | 
504 |         // attributes
505 |         while ($this->content->char() != '>' &&
506 |             $this->content->char() != '/') {
507 |             $space = $this->content->skipByToken('blank', true);
508 |             if (empty($space)) {
509 |                 $this->content->fastForward(1);
510 |                 continue;
511 |             }
512 | 
513 |             $name = $this->content->copyByToken('equal', true);
514 |             if ($name == '/') {
515 |                 break;
516 |             }
517 | 
518 |             if (empty($name)) {
519 |                 $this->content->fastForward(1);
520 |                 continue;
521 |             }
522 | 
523 |             $this->content->skipByToken('blank');
524 |             if ($this->content->char() == '=') {
525 |                 $attr = [];
526 |                 $this->content->fastForward(1)
527 |                               ->skipByToken('blank');
528 |                 switch ($this->content->char()) {
529 |                     case '"':
530 |                         $attr['doubleQuote'] = true;
531 |                         $this->content->fastForward(1);
532 |                         $string = $this->content->copyUntil('"', true, true);
533 |                         do {
534 |                             $moreString = $this->content->copyUntilUnless('"', '=>');
535 |                             $string .= $moreString;
536 |                         } while ( ! empty($moreString));
537 |                         $attr['value'] = $string;
538 |                         $this->content->fastForward(1);
539 |                         $node->getTag()->$name = $attr;
540 |                         break;
541 |                     case "'":
542 |                         $attr['doubleQuote'] = false;
543 |                         $this->content->fastForward(1);
544 |                         $string = $this->content->copyUntil("'", true, true);
545 |                         do {
546 |                             $moreString = $this->content->copyUntilUnless("'", '=>');
547 |                             $string .= $moreString;
548 |                         } while ( ! empty($moreString));
549 |                         $attr['value'] = $string;
550 |                         $this->content->fastForward(1);
551 |                         $node->getTag()->$name = $attr;
552 |                         break;
553 |                     default:
554 |                         $attr['doubleQuote']   = true;
555 |                         $attr['value']         = $this->content->copyByToken('attr', true);
556 |                         $node->getTag()->$name = $attr;
557 |                         break;
558 |                 }
559 |             } else {
560 |                 // no value attribute
561 |                 if ($this->options->strict) {
562 |                     // can't have this in strict html
563 |                     $character = $this->content->getPosition();
564 |                     throw new StrictException("Tag '$tag' has an attribute '$name' with out a value! (character #$character)");
565 |                 }
566 |                 $node->getTag()->$name = [
567 |                     'value'       => null,
568 |                     'doubleQuote' => true,
569 |                 ];
570 |                 if ($this->content->char() != '>') {
571 |                     $this->content->rewind(1);
572 |                 }
573 |             }
574 |         }
575 | 
576 |         $this->content->skipByToken('blank');
577 |         if ($this->content->char() == '/') {
578 |             // self closing tag
579 |             $node->getTag()->selfClosing();
580 |             $this->content->fastForward(1);
581 |         } elseif (in_array($tag, $this->selfClosing)) {
582 | 
583 |             // Should be a self closing tag, check if we are strict
584 |             if ($this->options->strict) {
585 |                 $character = $this->content->getPosition();
586 |                 throw new StrictException("Tag '$tag' is not self closing! (character #$character)");
587 |             }
588 | 
589 |             // We force self closing on this tag.
590 |             $node->getTag()->selfClosing();
591 |         }
592 | 
593 |         $this->content->fastForward(1);
594 | 
595 |         $return['status'] = true;
596 |         $return['node']   = $node;
597 | 
598 |         return $return;
599 |     }
600 | 
601 |     /**
602 |      * Attempts to detect the charset that the html was sent in.
603 |      *
604 |      * @return bool
605 |      */
606 |     protected function detectCharset()
607 |     {
608 |         // set the default
609 |         $encode = new Encode;
610 |         $encode->from($this->defaultCharset);
611 |         $encode->to($this->defaultCharset);
612 | 
613 |         if ( ! is_null($this->options->enforceEncoding)) {
614 |             //  they want to enforce the given encoding
615 |             $encode->from($this->options->enforceEncoding);
616 |             $encode->to($this->options->enforceEncoding);
617 | 
618 |             return false;
619 |         }
620 | 
621 |         $meta = $this->root->find('meta[http-equiv=Content-Type]', 0);
622 |         if (is_null($meta)) {
623 |             // could not find meta tag
624 |             $this->root->propagateEncoding($encode);
625 | 
626 |             return false;
627 |         }
628 |         $content = $meta->content;
629 |         if (empty($content)) {
630 |             // could not find content
631 |             $this->root->propagateEncoding($encode);
632 | 
633 |             return false;
634 |         }
635 |         $matches = [];
636 |         if (preg_match('/charset=([^; ]+)/', $content, $matches)) {
637 |             $encode->from(trim($matches[1]));
638 |             $this->root->propagateEncoding($encode);
639 | 
640 |             return true;
641 |         }
642 | 
643 |         // no charset found
644 |         $this->root->propagateEncoding($encode);
645 | 
646 |         return false;
647 |     }
648 | }
649 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Dom/AbstractNode.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace PHPHtmlParser\Dom;
  3 | 
  4 | use PHPHtmlParser\Exceptions\CircularException;
  5 | use PHPHtmlParser\Exceptions\ParentNotFoundException;
  6 | use PHPHtmlParser\Selector;
  7 | use stringEncode\Encode;
  8 | 
  9 | /**
 10 |  * Dom node object.
 11 |  *
 12 |  * @property string outerhtml
 13 |  * @property string innerhtml
 14 |  * @property string text
 15 |  * @property \PHPHtmlParser\Dom\Tag tag
 16 |  * @property InnerNode parent
 17 |  */
 18 | abstract class AbstractNode
 19 | {
 20 | 
 21 |     /**
 22 |      * Contains the tag name/type
 23 |      *
 24 |      * @var \PHPHtmlParser\Dom\Tag
 25 |      */
 26 |     protected $tag;
 27 | 
 28 |     /**
 29 |      * Contains a list of attributes on this tag.
 30 |      *
 31 |      * @var array
 32 |      */
 33 |     protected $attr = [];
 34 | 
 35 |     /**
 36 |      * Contains the parent Node.
 37 |      *
 38 |      * @var InnerNode
 39 |      */
 40 |     protected $parent = null;
 41 | 
 42 |     /**
 43 |      * The unique id of the class. Given by PHP.
 44 |      *
 45 |      * @var string
 46 |      */
 47 |     protected $id;
 48 | 
 49 |     /**
 50 |      * The encoding class used to encode strings.
 51 |      *
 52 |      * @var mixed
 53 |      */
 54 |     protected $encode;
 55 | 
 56 |     /**
 57 |      * Creates a unique spl hash for this node.
 58 |      */
 59 |     public function __construct()
 60 |     {
 61 |         $this->id = spl_object_hash($this);
 62 |     }
 63 | 
 64 |     /**
 65 |      * Magic get method for attributes and certain methods.
 66 |      *
 67 |      * @param string $key
 68 |      * @return mixed
 69 |      */
 70 |     public function __get($key)
 71 |     {
 72 |         // check attribute first
 73 |         if ( ! is_null($value = $this->getAttribute($key))) {
 74 |             return $value;
 75 |         }
 76 |         switch (strtolower($key)) {
 77 |             case 'outerhtml':
 78 |                 return $this->outerHtml();
 79 |             case 'innerhtml':
 80 |                 return $this->innerHtml();
 81 |             case 'text':
 82 |                 return $this->text();
 83 |             case 'tag':
 84 |                 return $this->getTag();
 85 |             case 'parent':
 86 |                 $this->getParent();
 87 |         }
 88 | 
 89 |         return null;
 90 |     }
 91 | 
 92 |     /**
 93 |      * Attempts to clear out any object references.
 94 |      */
 95 |     public function __destruct()
 96 |     {
 97 |         $this->tag      = null;
 98 |         $this->attr     = [];
 99 |         $this->parent   = null;
100 |         $this->children = [];
101 |     }
102 | 
103 |     /**
104 |      * Simply calls the outer text method.
105 |      *
106 |      * @return string
107 |      */
108 |     public function __toString()
109 |     {
110 |         return $this->outerHtml();
111 |     }
112 | 
113 |     /**
114 |      * Returns the id of this object.
115 |      */
116 |     public function id()
117 |     {
118 |         return $this->id;
119 |     }
120 | 
121 |     /**
122 |      * Returns the parent of node.
123 |      *
124 |      * @return AbstractNode
125 |      */
126 |     public function getParent()
127 |     {
128 |         return $this->parent;
129 |     }
130 | 
131 |     /**
132 |      * Sets the parent node.
133 |      *
134 |      * @param InnerNode $parent
135 |      * @return $this
136 |      * @throws CircularException
137 |      */
138 |     public function setParent(InnerNode $parent)
139 |     {
140 |         // remove from old parent
141 |         if ( ! is_null($this->parent)) {
142 |             if ($this->parent->id() == $parent->id()) {
143 |                 // already the parent
144 |                 return $this;
145 |             }
146 | 
147 |             $this->parent->removeChild($this->id);
148 |         }
149 | 
150 |         $this->parent = $parent;
151 | 
152 |         // assign child to parent
153 |         $this->parent->addChild($this);
154 | 
155 |         //clear any cache
156 |         $this->clear();
157 | 
158 |         return $this;
159 |     }
160 | 
161 |     /**
162 |      * Removes this node and all its children from the
163 |      * DOM tree.
164 |      *
165 |      * @return void
166 |      */
167 |     public function delete()
168 |     {
169 |         if ( ! is_null($this->parent)) {
170 |             $this->parent->removeChild($this->id);
171 |         }
172 | 
173 |         $this->parent = null;
174 |     }
175 | 
176 |     /**
177 |      * Sets the encoding class to this node.
178 |      *
179 |      * @param Encode $encode
180 |      * @return void
181 |      */
182 |     public function propagateEncoding(Encode $encode)
183 |     {
184 |         $this->encode = $encode;
185 |         $this->tag->setEncoding($encode);
186 |     }
187 | 
188 |     /**
189 |      * Checks if the given node id is an ancestor of
190 |      * the current node.
191 |      *
192 |      * @param int $id
193 |      * @return bool
194 |      */
195 |     public function isAncestor($id)
196 |     {
197 |         if ( ! is_null($this->getAncestor($id))) {
198 |             return true;
199 |         }
200 | 
201 |         return false;
202 |     }
203 | 
204 |     /**
205 |      * Attempts to get an ancestor node by the given id.
206 |      *
207 |      * @param int $id
208 |      * @return null|AbstractNode
209 |      */
210 |     public function getAncestor($id)
211 |     {
212 |         if ( ! is_null($this->parent)) {
213 |             if ($this->parent->id() == $id) {
214 |                 return $this->parent;
215 |             }
216 | 
217 |             return $this->parent->getAncestor($id);
218 |         }
219 | 
220 |         return null;
221 |     }
222 | 
223 |     /**
224 |      * Attempts to get the next sibling.
225 |      *
226 |      * @return AbstractNode
227 |      * @throws ParentNotFoundException
228 |      */
229 |     public function nextSibling()
230 |     {
231 |         if (is_null($this->parent)) {
232 |             throw new ParentNotFoundException('Parent is not set for this node.');
233 |         }
234 | 
235 |         return $this->parent->nextChild($this->id);
236 |     }
237 | 
238 |     /**
239 |      * Attempts to get the previous sibling
240 |      *
241 |      * @return AbstractNode
242 |      * @throws ParentNotFoundException
243 |      */
244 |     public function previousSibling()
245 |     {
246 |         if (is_null($this->parent)) {
247 |             throw new ParentNotFoundException('Parent is not set for this node.');
248 |         }
249 | 
250 |         return $this->parent->previousChild($this->id);
251 |     }
252 | 
253 |     /**
254 |      * Gets the tag object of this node.
255 |      *
256 |      * @return Tag
257 |      */
258 |     public function getTag()
259 |     {
260 |         return $this->tag;
261 |     }
262 | 
263 |     /**
264 |      * A wrapper method that simply calls the getAttribute method
265 |      * on the tag of this node.
266 |      *
267 |      * @return array
268 |      */
269 |     public function getAttributes()
270 |     {
271 |         $attributes = $this->tag->getAttributes();
272 |         foreach ($attributes as $name => $info) {
273 |             $attributes[$name] = $info['value'];
274 |         }
275 | 
276 |         return $attributes;
277 |     }
278 | 
279 |     /**
280 |      * A wrapper method that simply calls the getAttribute method
281 |      * on the tag of this node.
282 |      *
283 |      * @param string $key
284 |      * @return mixed
285 |      */
286 |     public function getAttribute($key)
287 |     {
288 |         $attribute = $this->tag->getAttribute($key);
289 |         if ( ! is_null($attribute)) {
290 |             $attribute = $attribute['value'];
291 |         }
292 | 
293 |         return $attribute;
294 |     }
295 | 
296 |     /**
297 |      * A wrapper method that simply calls the setAttribute method
298 |      * on the tag of this node.
299 |      *
300 |      * @param string $key
301 |      * @param string $value
302 |      * @return $this
303 |      */
304 |     public function setAttribute($key, $value)
305 |     {
306 |         $this->tag->setAttribute($key, $value);
307 | 
308 |         return $this;
309 |     }
310 | 
311 |     /**
312 |      * A wrapper method that simply calls the removeAttribute method
313 |      * on the tag of this node.
314 |      *
315 |      * @param string $key
316 |      * @return void
317 |      */
318 |     public function removeAttribute($key)
319 |     {
320 |         $this->tag->removeAttribute($key);
321 |     }
322 | 
323 |     /**
324 |      * A wrapper method that simply calls the removeAllAttributes
325 |      * method on the tag of this node.
326 |      *
327 |      * @return void
328 |      */
329 |     public function removeAllAttributes()
330 |     {
331 |         $this->tag->removeAllAttributes();
332 |     }
333 | 
334 |     /**
335 |      * Function to locate a specific ancestor tag in the path to the root.
336 |      *
337 |      * @param  string $tag
338 |      * @return AbstractNode
339 |      * @throws ParentNotFoundException
340 |      */
341 |     public function ancestorByTag($tag)
342 |     {
343 |         // Start by including ourselves in the comparison.
344 |         $node = $this;
345 | 
346 |         while ( ! is_null($node)) {
347 |             if ($node->tag->name() == $tag) {
348 |                 return $node;
349 |             }
350 | 
351 |             $node = $node->getParent();
352 |         }
353 | 
354 |         throw new ParentNotFoundException('Could not find an ancestor with "'.$tag.'" tag');
355 |     }
356 | 
357 |     /**
358 |      * Find elements by css selector
359 |      *
360 |      * @param string $selector
361 |      * @param int $nth
362 |      * @return array|AbstractNode
363 |      */
364 |     public function find($selector, $nth = null)
365 |     {
366 |         $selector = new Selector($selector);
367 |         $nodes    = $selector->find($this);
368 | 
369 |         if ( ! is_null($nth)) {
370 |             // return nth-element or array
371 |             if (isset($nodes[$nth])) {
372 |                 return $nodes[$nth];
373 |             }
374 | 
375 |             return null;
376 |         }
377 | 
378 |         return $nodes;
379 |     }
380 | 
381 |     /**
382 |      * Gets the inner html of this node.
383 |      *
384 |      * @return string
385 |      */
386 |     abstract public function innerHtml();
387 | 
388 |     /**
389 |      * Gets the html of this node, including it's own
390 |      * tag.
391 |      *
392 |      * @return string
393 |      */
394 |     abstract public function outerHtml();
395 | 
396 |     /**
397 |      * Gets the text of this node (if there is any text).
398 |      *
399 |      * @return string
400 |      */
401 |     abstract public function text();
402 | 
403 |     /**
404 |      * Call this when something in the node tree has changed. Like a child has been added
405 |      * or a parent has been changed.
406 |      *
407 |      * @return void
408 |      */
409 |     abstract protected function clear();
410 | }
411 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Dom/ArrayNode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace PHPHtmlParser\Dom;
 3 | 
 4 | use Countable;
 5 | use ArrayIterator;
 6 | use IteratorAggregate;
 7 | 
 8 | /**
 9 |  * Dom node object which will allow users to use it as
10 |  * an array.
11 |  */
12 | abstract class ArrayNode extends AbstractNode implements IteratorAggregate, Countable
13 | {
14 | 
15 |     /**
16 |      * Gets the iterator
17 |      *
18 |      * @return ArrayIterator
19 |      */
20 |     public function getIterator()
21 |     {
22 |         return new ArrayIterator($this->getIteratorArray());
23 |     }
24 | 
25 |     /**
26 |      * Returns the count of the iterator array.
27 |      *
28 |      * @return int
29 |      */
30 |     public function count()
31 |     {
32 |         return count($this->getIteratorArray());
33 |     }
34 | 
35 |     /**
36 |      * Returns the array to be used the the iterator.
37 |      *
38 |      * @return array
39 |      */
40 |     abstract protected function getIteratorArray();
41 | }
42 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Dom/Collection.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace PHPHtmlParser\Dom;
  3 | 
  4 | use ArrayAccess;
  5 | use ArrayIterator;
  6 | use Countable;
  7 | use IteratorAggregate;
  8 | use PHPHtmlParser\Exceptions\EmptyCollectionException;
  9 | 
 10 | /**
 11 |  * Class Collection
 12 |  *
 13 |  * @package PHPHtmlParser\Dom
 14 |  */
 15 | class Collection implements IteratorAggregate, ArrayAccess, Countable
 16 | {
 17 | 
 18 |     /**
 19 |      * The collection of Nodes.
 20 |      *
 21 |      * @param array
 22 |      */
 23 |     protected $collection = [];
 24 | 
 25 |     /**
 26 |      * Attempts to call the method on the first node in
 27 |      * the collection.
 28 |      *
 29 |      * @param string $method
 30 |      * @param array $arguments
 31 |      * @return mixed;
 32 |      * @throws EmptyCollectionException
 33 |      */
 34 |     public function __call($method, $arguments)
 35 |     {
 36 |         $node = reset($this->collection);
 37 |         if ($node instanceof AbstractNode) {
 38 |             return call_user_func_array([$node, $method], $arguments);
 39 |         } else {
 40 |             throw new EmptyCollectionException('The collection does not contain any Nodes.');
 41 |         }
 42 |     }
 43 | 
 44 |     /**
 45 |      * Attempts to apply the magic get to the first node
 46 |      * in the collection.
 47 |      *
 48 |      * @param mixed $key
 49 |      * @return mixed
 50 |      * @throws EmptyCollectionException
 51 |      */
 52 |     public function __get($key)
 53 |     {
 54 |         $node = reset($this->collection);
 55 |         if ($node instanceof AbstractNode) {
 56 |             return $node->$key;
 57 |         } else {
 58 |             throw new EmptyCollectionException('The collection does not contain any Nodes.');
 59 |         }
 60 |     }
 61 | 
 62 |     /**
 63 |      * Applies the magic string method to the first node in
 64 |      * the collection.
 65 |      *
 66 |      * @return string
 67 |      * @throws EmptyCollectionException
 68 |      */
 69 |     public function __toString()
 70 |     {
 71 |         $node = reset($this->collection);
 72 |         if ($node instanceof AbstractNode) {
 73 |             return (string)$node;
 74 |         } else {
 75 |             throw new EmptyCollectionException('The collection does not contain any Nodes.');
 76 |         }
 77 |     }
 78 | 
 79 |     /**
 80 |      * Returns the count of the collection.
 81 |      *
 82 |      * @return int
 83 |      */
 84 |     public function count()
 85 |     {
 86 |         return count($this->collection);
 87 |     }
 88 | 
 89 |     /**
 90 |      * Returns an iterator for the collection.
 91 |      *
 92 |      * @return ArrayIterator
 93 |      */
 94 |     public function getIterator()
 95 |     {
 96 |         return new ArrayIterator($this->collection);
 97 |     }
 98 | 
 99 |     /**
100 |      * Set an attribute by the given offset
101 |      *
102 |      * @param mixed $offset
103 |      * @param mixed $value
104 |      */
105 |     public function offsetSet($offset, $value)
106 |     {
107 |         if (is_null($offset)) {
108 |             $this->collection[] = $value;
109 |         } else {
110 |             $this->collection[$offset] = $value;
111 |         }
112 |     }
113 | 
114 |     /**
115 |      * Checks if an offset exists.
116 |      *
117 |      * @param mixed $offset
118 |      * @return bool
119 |      */
120 |     public function offsetExists($offset)
121 |     {
122 |         return isset($this->collection[$offset]);
123 |     }
124 | 
125 |     /**
126 |      * Unset a collection Node.
127 |      *
128 |      * @param mixed $offset
129 |      */
130 |     public function offsetUnset($offset)
131 |     {
132 |         unset($this->collection[$offset]);
133 |     }
134 | 
135 |     /**
136 |      * Gets a node at the given offset, or null
137 |      *
138 |      * @param mixed $offset
139 |      * @return mixed
140 |      */
141 |     public function offsetGet($offset)
142 |     {
143 |         return isset($this->collection[$offset]) ? $this->collection[$offset] : null;
144 |     }
145 | 
146 |     /**
147 |      * Returns this collection as an array.
148 |      *
149 |      * @return array
150 |      */
151 |     public function toArray()
152 |     {
153 |         return $this->collection;
154 |     }
155 | 
156 |     /**
157 |      * Similar to jQuery "each" method. Calls the callback with each
158 |      * Node in this collection.
159 |      *
160 |      * @param callback $callback
161 |      */
162 |     public function each($callback)
163 |     {
164 |         foreach ($this->collection as $key => $value) {
165 |             $callback($value, $key);
166 |         }
167 |     }
168 | }
169 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Dom/HtmlNode.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace PHPHtmlParser\Dom;
  3 | 
  4 | use PHPHtmlParser\Exceptions\UnknownChildTypeException;
  5 | use PHPHtmlParser\Exceptions\ChildNotFoundException;
  6 | 
  7 | /**
  8 |  * Class HtmlNode
  9 |  *
 10 |  * @package PHPHtmlParser\Dom
 11 |  */
 12 | class HtmlNode extends InnerNode
 13 | {
 14 | 
 15 |     /**
 16 |      * Remembers what the innerHtml was if it was scanned previously.
 17 |      */
 18 |     protected $innerHtml = null;
 19 | 
 20 |     /**
 21 |      * Remembers what the outerHtml was if it was scanned previously.
 22 |      *
 23 |      * @var string
 24 |      */
 25 |     protected $outerHtml = null;
 26 | 
 27 |     /**
 28 |      * Remembers what the text was if it was scanned previously.
 29 |      *
 30 |      * @var string
 31 |      */
 32 |     protected $text = null;
 33 | 
 34 |     /**
 35 |      * Remembers what the text was when we looked into all our
 36 |      * children nodes.
 37 |      *
 38 |      * @var string
 39 |      */
 40 |     protected $textWithChildren = null;
 41 | 
 42 |     /**
 43 |      * Sets up the tag of this node.
 44 |      *
 45 |      * @param $tag
 46 |      */
 47 |     public function __construct($tag)
 48 |     {
 49 |         if ( ! $tag instanceof Tag) {
 50 |             $tag = new Tag($tag);
 51 |         }
 52 |         $this->tag = $tag;
 53 |         parent::__construct();
 54 |     }
 55 | 
 56 |     /**
 57 |      * Gets the inner html of this node.
 58 |      *
 59 |      * @return string
 60 |      * @throws UnknownChildTypeException
 61 |      */
 62 |     public function innerHtml()
 63 |     {
 64 |         if ( ! $this->hasChildren()) {
 65 |             // no children
 66 |             return '';
 67 |         }
 68 | 
 69 |         if ( ! is_null($this->innerHtml)) {
 70 |             // we already know the result.
 71 |             return $this->innerHtml;
 72 |         }
 73 | 
 74 |         $child  = $this->firstChild();
 75 |         $string = '';
 76 | 
 77 |         // continue to loop until we are out of children
 78 |         while ( ! is_null($child)) {
 79 |             if ($child instanceof TextNode) {
 80 |                 $string .= $child->text();
 81 |             } elseif ($child instanceof HtmlNode) {
 82 |                 $string .= $child->outerHtml();
 83 |             } else {
 84 |                 throw new UnknownChildTypeException('Unknown child type "'.get_class($child).'" found in node');
 85 |             }
 86 | 
 87 |             try {
 88 |                 $child = $this->nextChild($child->id());
 89 |             } catch (ChildNotFoundException $e) {
 90 |                 // no more children
 91 |                 $child = null;
 92 |             }
 93 |         }
 94 | 
 95 |         // remember the results
 96 |         $this->innerHtml = $string;
 97 | 
 98 |         return $string;
 99 |     }
100 | 
101 |     /**
102 |      * Gets the html of this node, including it's own
103 |      * tag.
104 |      *
105 |      * @return string
106 |      */
107 |     public function outerHtml()
108 |     {
109 |         // special handling for root
110 |         if ($this->tag->name() == 'root') {
111 |             return $this->innerHtml();
112 |         }
113 | 
114 |         if ( ! is_null($this->outerHtml)) {
115 |             // we already know the results.
116 |             return $this->outerHtml;
117 |         }
118 | 
119 |         $return = $this->tag->makeOpeningTag();
120 |         if ($this->tag->isSelfClosing()) {
121 |             // ignore any children... there should not be any though
122 |             return $return;
123 |         }
124 | 
125 |         // get the inner html
126 |         $return .= $this->innerHtml();
127 | 
128 |         // add closing tag
129 |         $return .= $this->tag->makeClosingTag();
130 | 
131 |         // remember the results
132 |         $this->outerHtml = $return;
133 | 
134 |         return $return;
135 |     }
136 | 
137 |     /**
138 |      * Gets the text of this node (if there is any text). Or get all the text
139 |      * in this node, including children.
140 |      *
141 |      * @param bool $lookInChildren
142 |      * @return string
143 |      */
144 |     public function text($lookInChildren = false)
145 |     {
146 |         if ($lookInChildren) {
147 |             if ( ! is_null($this->textWithChildren)) {
148 |                 // we already know the results.
149 |                 return $this->textWithChildren;
150 |             }
151 |         } elseif ( ! is_null($this->text)) {
152 |             // we already know the results.
153 |             return $this->text;
154 |         }
155 | 
156 |         // find out if this node has any text children
157 |         $text = '';
158 |         foreach ($this->children as $child) {
159 |             /** @var AbstractNode $node */
160 |             $node = $child['node'];
161 |             if ($node instanceof TextNode) {
162 |                 $text .= $child['node']->text;
163 |             } elseif ($lookInChildren &&
164 |                 $node instanceof HtmlNode
165 |             ) {
166 |                 $text .= $node->text($lookInChildren);
167 |             }
168 |         }
169 | 
170 |         // remember our result
171 |         if ($lookInChildren) {
172 |             $this->textWithChildren = $text;
173 |         } else {
174 |             $this->text = $text;
175 |         }
176 | 
177 |         return $text;
178 |     }
179 | 
180 |     /**
181 |      * Call this when something in the node tree has changed. Like a child has been added
182 |      * or a parent has been changed.
183 |      */
184 |     protected function clear()
185 |     {
186 |         $this->innerHtml = null;
187 |         $this->outerHtml = null;
188 |         $this->text      = null;
189 |     }
190 | 
191 |     /**
192 |      * Returns all children of this html node.
193 |      *
194 |      * @return array
195 |      */
196 |     protected function getIteratorArray()
197 |     {
198 |         return $this->getChildren();
199 |     }
200 | }
201 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Dom/InnerNode.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace PHPHtmlParser\Dom;
  3 | 
  4 | use PHPHtmlParser\Exceptions\ChildNotFoundException;
  5 | use PHPHtmlParser\Exceptions\CircularException;
  6 | use stringEncode\Encode;
  7 | 
  8 | /**
  9 |  * Inner node of the html tree, might have children.
 10 |  *
 11 |  * @package PHPHtmlParser\Dom
 12 |  */
 13 | abstract class InnerNode extends ArrayNode
 14 | {
 15 | 
 16 |     /**
 17 |      * An array of all the children.
 18 |      *
 19 |      * @var array
 20 |      */
 21 |     protected $children = [];
 22 | 
 23 |     /**
 24 |      * Sets the encoding class to this node and propagates it
 25 |      * to all its children.
 26 |      *
 27 |      * @param Encode $encode
 28 |      * @return void
 29 |      */
 30 |     public function propagateEncoding(Encode $encode)
 31 |     {
 32 |         $this->encode = $encode;
 33 |         $this->tag->setEncoding($encode);
 34 |         // check children
 35 |         foreach ($this->children as $id => $child) {
 36 |             /** @var AbstractNode $node */
 37 |             $node = $child['node'];
 38 |             $node->propagateEncoding($encode);
 39 |         }
 40 |     }
 41 | 
 42 |     /**
 43 |      * Checks if this node has children.
 44 |      *
 45 |      * @return bool
 46 |      */
 47 |     public function hasChildren()
 48 |     {
 49 |         return ! empty($this->children);
 50 |     }
 51 | 
 52 |     /**
 53 |      * Returns the child by id.
 54 |      *
 55 |      * @param int $id
 56 |      * @return AbstractNode
 57 |      * @throws ChildNotFoundException
 58 |      */
 59 |     public function getChild($id)
 60 |     {
 61 |         if ( ! isset($this->children[$id])) {
 62 |             throw new ChildNotFoundException("Child '$id' not found in this node.");
 63 |         }
 64 | 
 65 |         return $this->children[$id]['node'];
 66 |     }
 67 | 
 68 |     /**
 69 |      * Returns a new array of child nodes
 70 |      *
 71 |      * @return array
 72 |      */
 73 |     public function getChildren()
 74 |     {
 75 |         $nodes = [];
 76 |         try {
 77 |             $child = $this->firstChild();
 78 |             do {
 79 |                 $nodes[] = $child;
 80 |                 $child   = $this->nextChild($child->id());
 81 |             } while ( ! is_null($child));
 82 |         } catch (ChildNotFoundException $e) {
 83 |             // we are done looking for children
 84 |         }
 85 | 
 86 |         return $nodes;
 87 |     }
 88 | 
 89 |     /**
 90 |      * Counts children
 91 |      *
 92 |      * @return int
 93 |      */
 94 |     public function countChildren()
 95 |     {
 96 |         return count($this->children);
 97 |     }
 98 | 
 99 |     /**
100 |      * Adds a child node to this node and returns the id of the child for this
101 |      * parent.
102 |      *
103 |      * @param AbstractNode $child
104 |      * @return bool
105 |      * @throws CircularException
106 |      */
107 |     public function addChild(AbstractNode $child)
108 |     {
109 |         $key = null;
110 | 
111 |         // check integrity
112 |         if ($this->isAncestor($child->id())) {
113 |             throw new CircularException('Can not add child. It is my ancestor.');
114 |         }
115 | 
116 |         // check if child is itself
117 |         if ($child->id() == $this->id) {
118 |             throw new CircularException('Can not set itself as a child.');
119 |         }
120 | 
121 |         if ($this->hasChildren()) {
122 |             if (isset($this->children[$child->id()])) {
123 |                 // we already have this child
124 |                 return false;
125 |             }
126 |             $sibling                      = $this->lastChild();
127 |             $key                          = $sibling->id();
128 |             $this->children[$key]['next'] = $child->id();
129 |         }
130 | 
131 |         // add the child
132 |         $this->children[$child->id()] = [
133 |             'node' => $child,
134 |             'next' => null,
135 |             'prev' => $key,
136 |         ];
137 | 
138 |         // tell child I am the new parent
139 |         $child->setParent($this);
140 | 
141 |         //clear any cache
142 |         $this->clear();
143 | 
144 |         return true;
145 |     }
146 | 
147 |     /**
148 |      * Removes the child by id.
149 |      *
150 |      * @param int $id
151 |      * @return $this
152 |      */
153 |     public function removeChild($id)
154 |     {
155 |         if ( ! isset($this->children[$id])) {
156 |             return $this;
157 |         }
158 | 
159 |         // handle moving next and previous assignments.
160 |         $next = $this->children[$id]['next'];
161 |         $prev = $this->children[$id]['prev'];
162 |         if ( ! is_null($next)) {
163 |             $this->children[$next]['prev'] = $prev;
164 |         }
165 |         if ( ! is_null($prev)) {
166 |             $this->children[$prev]['next'] = $next;
167 |         }
168 | 
169 |         // remove the child
170 |         unset($this->children[$id]);
171 | 
172 |         //clear any cache
173 |         $this->clear();
174 | 
175 |         return $this;
176 |     }
177 | 
178 |     /**
179 |      * Attempts to get the next child.
180 |      *
181 |      * @param int $id
182 |      * @return AbstractNode
183 |      * @uses $this->getChild()
184 |      * @throws ChildNotFoundException
185 |      */
186 |     public function nextChild($id)
187 |     {
188 |         $child = $this->getChild($id);
189 |         $next  = $this->children[$child->id()]['next'];
190 | 
191 |         return $this->getChild($next);
192 |     }
193 | 
194 |     /**
195 |      * Attempts to get the previous child.
196 |      *
197 |      * @param int $id
198 |      * @return AbstractNode
199 |      * @uses $this->getChild()
200 |      * @throws ChildNotFoundException
201 |      */
202 |     public function previousChild($id)
203 |     {
204 |         $child = $this->getChild($id);
205 |         $next  = $this->children[$child->id()]['prev'];
206 | 
207 |         return $this->getChild($next);
208 |     }
209 | 
210 |     /**
211 |      * Checks if the given node id is a child of the
212 |      * current node.
213 |      *
214 |      * @param int $id
215 |      * @return bool
216 |      */
217 |     public function isChild($id)
218 |     {
219 |         foreach ($this->children as $childId => $child) {
220 |             if ($id == $childId) {
221 |                 return true;
222 |             }
223 |         }
224 | 
225 |         return false;
226 |     }
227 | 
228 |     /**
229 |      * Removes the child with id $childId and replace it with the new child
230 |      * $newChild.
231 |      *
232 |      * @param int $childId
233 |      * @param AbstractNode $newChild
234 |      * @throws ChildNotFoundException
235 |      */
236 |     public function replaceChild($childId, AbstractNode $newChild)
237 |     {
238 |         // Replace key of old child
239 |         $keys           = array_keys($this->children);
240 |         $index          = array_search($childId, $keys, true);
241 |         $keys[$index]   = $newChild->id();
242 |         $this->children = array_combine($keys, $this->children);
243 | 
244 |         // Replace old child node with new one
245 |         $this->children[$newChild->id()]['node'] = $newChild;
246 | 
247 |         $child = $this->children[$newChild->id()];
248 | 
249 |         // Update previous and next nodes
250 |         if ($child['prev'] !== null) {
251 |             $this->children[$child['prev']]['next'] = $newChild->id();
252 |         }
253 | 
254 |         if ($child['next'] !== null) {
255 |             $this->children[$child['next']]['prev'] = $newChild->id();
256 |         }
257 |     }
258 | 
259 |     /**
260 |      * Shortcut to return the first child.
261 |      *
262 |      * @return AbstractNode
263 |      * @uses $this->getChild()
264 |      */
265 |     public function firstChild()
266 |     {
267 |         reset($this->children);
268 |         $key = key($this->children);
269 | 
270 |         return $this->getChild($key);
271 |     }
272 | 
273 |     /**
274 |      * Attempts to get the last child.
275 |      *
276 |      * @return AbstractNode
277 |      */
278 |     public function lastChild()
279 |     {
280 |         end($this->children);
281 |         $key = key($this->children);
282 | 
283 |         return $this->getChild($key);
284 |     }
285 | 
286 |     /**
287 |      * Checks if the given node id is a descendant of the
288 |      * current node.
289 |      *
290 |      * @param int $id
291 |      * @return bool
292 |      */
293 |     public function isDescendant($id)
294 |     {
295 |         if ($this->isChild($id)) {
296 |             return true;
297 |         }
298 | 
299 |         foreach ($this->children as $childId => $child) {
300 |             /** @var InnerNode $node */
301 |             $node = $child['node'];
302 |             if ($node instanceof InnerNode &&
303 |                 $node->hasChildren() &&
304 |                 $node->isDescendant($id)
305 |             ) {
306 |                 return true;
307 |             }
308 |         }
309 | 
310 |         return false;
311 |     }
312 | 
313 |     /**
314 |      * Sets the parent node.
315 |      *
316 |      * @param InnerNode $parent
317 |      * @return $this
318 |      * @throws CircularException
319 |      */
320 |     public function setParent(InnerNode $parent)
321 |     {
322 |         // check integrity
323 |         if ($this->isDescendant($parent->id())) {
324 |             throw new CircularException('Can not add descendant "'.$parent->id().'" as my parent.');
325 |         }
326 | 
327 |         return parent::setParent($parent);
328 |     }
329 | }
330 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Dom/LeafNode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace PHPHtmlParser\Dom;
 3 | 
 4 | 
 5 | /**
 6 |  * Class LeafNode
 7 |  *
 8 |  * @package PHPHtmlParser
 9 |  */
10 | abstract class LeafNode extends AbstractNode
11 | {
12 | 
13 | }


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Dom/MockNode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace PHPHtmlParser\Dom;
 3 | 
 4 | /**
 5 |  * This mock object is used solely for testing the abstract
 6 |  * class Node with out any potential side effects caused
 7 |  * by testing a supper class of Node.
 8 |  *
 9 |  * This object is not to be used for any other reason.
10 |  */
11 | class MockNode extends InnerNode
12 | {
13 | 
14 |     /**
15 |      * Mock of innner html.
16 |      */
17 |     public function innerHtml()
18 |     {
19 |     }
20 | 
21 |     /**
22 |      * Mock of outer html.
23 |      */
24 |     public function outerHtml()
25 |     {
26 |     }
27 | 
28 |     /**
29 |      * Mock of text.
30 |      */
31 |     public function text()
32 |     {
33 |     }
34 | 
35 |     /**
36 |      * Clear content of this node
37 |      */
38 |     protected function clear()
39 |     {
40 |         $this->innerHtml = null;
41 |         $this->outerHtml = null;
42 |         $this->text      = null;
43 |     }
44 | 
45 |     /**
46 |      * Returns all children of this html node.
47 |      *
48 |      * @return array
49 |      */
50 |     protected function getIteratorArray()
51 |     {
52 |         return $this->getChildren();
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Dom/Tag.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace PHPHtmlParser\Dom;
  3 | 
  4 | use PHPHtmlParser\Dom;
  5 | use stringEncode\Encode;
  6 | 
  7 | /**
  8 |  * Class Tag
  9 |  *
 10 |  * @package PHPHtmlParser\Dom
 11 |  */
 12 | class Tag
 13 | {
 14 | 
 15 |     /**
 16 |      * The name of the tag.
 17 |      *
 18 |      * @var string
 19 |      */
 20 |     protected $name;
 21 | 
 22 |     /**
 23 |      * The attributes of the tag.
 24 |      *
 25 |      * @var array
 26 |      */
 27 |     protected $attr = [];
 28 | 
 29 |     /**
 30 |      * Is this tag self closing.
 31 |      *
 32 |      * @var bool
 33 |      */
 34 |     protected $selfClosing = false;
 35 | 
 36 |     /**
 37 |      * Tag noise
 38 |      */
 39 |     protected $noise = '';
 40 | 
 41 |     /**
 42 |      * The encoding class to... encode the tags
 43 |      *
 44 |      * @var mixed
 45 |      */
 46 |     protected $encode = null;
 47 | 
 48 |     /**
 49 |      * Sets up the tag with a name.
 50 |      *
 51 |      * @param $name
 52 |      */
 53 |     public function __construct($name)
 54 |     {
 55 |         $this->name = $name;
 56 |     }
 57 | 
 58 |     /**
 59 |      * Magic method to get any of the attributes.
 60 |      *
 61 |      * @param string $key
 62 |      * @return mixed
 63 |      */
 64 |     public function __get($key)
 65 |     {
 66 |         return $this->getAttribute($key);
 67 |     }
 68 | 
 69 |     /**
 70 |      * Magic method to set any attribute.
 71 |      *
 72 |      * @param string $key
 73 |      * @param mixed $value
 74 |      */
 75 |     public function __set($key, $value)
 76 |     {
 77 |         $this->setAttribute($key, $value);
 78 |     }
 79 | 
 80 |     /**
 81 |      * Returns the name of this tag.
 82 |      *
 83 |      * @return string
 84 |      */
 85 |     public function name()
 86 |     {
 87 |         return $this->name;
 88 |     }
 89 | 
 90 |     /**
 91 |      * Sets the tag to be self closing.
 92 |      *
 93 |      * @return $this
 94 |      */
 95 |     public function selfClosing()
 96 |     {
 97 |         $this->selfClosing = true;
 98 | 
 99 |         return $this;
100 |     }
101 | 
102 |     /**
103 |      * Checks if the tag is self closing.
104 |      *
105 |      * @return bool
106 |      */
107 |     public function isSelfClosing()
108 |     {
109 |         return $this->selfClosing;
110 |     }
111 | 
112 |     /**
113 |      * Sets the encoding type to be used.
114 |      *
115 |      * @param Encode $encode
116 |      */
117 |     public function setEncoding(Encode $encode)
118 |     {
119 |         $this->encode = $encode;
120 |     }
121 | 
122 |     /**
123 |      * Sets the noise for this tag (if any)
124 |      *
125 |      * @param $noise
126 |      * @return $this
127 |      */
128 |     public function noise($noise)
129 |     {
130 |         $this->noise = $noise;
131 | 
132 |         return $this;
133 |     }
134 | 
135 |     /**
136 |      * Set an attribute for this tag.
137 |      *
138 |      * @param string $key
139 |      * @param string|array $value
140 |      * @return $this
141 |      */
142 |     public function setAttribute($key, $value)
143 |     {
144 |         $key = strtolower($key);
145 |         if ( ! is_array($value)) {
146 |             $value = [
147 |                 'value'       => $value,
148 |                 'doubleQuote' => true,
149 |                 'didConvertCharset' => true, 
150 |             ];
151 |         }
152 |         $this->attr[$key] = $value;
153 | 
154 |         return $this;
155 |     }
156 | 
157 |     /**
158 |      * Removes an attribute from this tag.
159 |      *
160 |      * @param $key
161 |      * @return void
162 |      */
163 |     public function removeAttribute($key)
164 |     {
165 |         $key = strtolower($key);
166 |         unset($this->attr[$key]);
167 |     }
168 | 
169 |     /**
170 |      * Removes all attributes on this tag.
171 |      *
172 |      * @return void
173 |      */
174 |     public function removeAllAttributes()
175 |     {
176 |         $this->attr = [];
177 |     }
178 | 
179 |     /**
180 |      * Sets the attributes for this tag
181 |      *
182 |      * @param array $attr
183 |      * @return $this
184 |      */
185 |     public function setAttributes(array $attr)
186 |     {
187 |         foreach ($attr as $key => $value) {
188 |             $this->setAttribute($key, $value);
189 |         }
190 | 
191 |         return $this;
192 |     }
193 | 
194 |     /**
195 |      * Returns all attributes of this tag.
196 |      *
197 |      * @return array
198 |      */
199 |     public function getAttributes()
200 |     {
201 |         $return = [];
202 |         foreach ($this->attr as $attr => $info) {
203 |             $return[$attr] = $this->getAttribute($attr);
204 |         }
205 | 
206 |         return $return;
207 |     }
208 | 
209 |     /**
210 |      * Returns an attribute by the key
211 |      *
212 |      * @param string $key
213 |      * @return mixed
214 |      */
215 |     public function getAttribute($key)
216 |     {
217 |         if ( ! isset($this->attr[$key])) {
218 |             return null;
219 |         }
220 |         $value = $this->attr[$key]['value'];
221 |         if (is_string($value) && ! is_null($this->encode) && ! ($this->attr[$key]['didConvertCharset'] ?? false)) {
222 |             // convert charset
223 |             $this->attr[$key]['value'] = $this->encode->convert($value);
224 |             $this->attr[$key]['didConvertCharset'] = true;
225 |         }
226 | 
227 |         return $this->attr[$key];
228 |     }
229 | 
230 |     /**
231 |      * Generates the opening tag for this object.
232 |      *
233 |      * @return string
234 |      */
235 |     public function makeOpeningTag()
236 |     {
237 |         $return = '<'.$this->name;
238 | 
239 |         // add the attributes
240 |         foreach ($this->attr as $key => $info) {
241 |             $info = $this->getAttribute($key);
242 |             $val  = $info['value'];
243 |             if (is_null($val)) {
244 |                 $return .= ' '.$key;
245 |             } elseif ($info['doubleQuote']) {
246 |                 $return .= ' '.$key.'="'.$val.'"';
247 |             } else {
248 |                 $return .= ' '.$key.'=\''.$val.'\'';
249 |             }
250 |         }
251 | 
252 |         if ($this->selfClosing) {
253 |             return $return.' />';
254 |         } else {
255 |             return $return.'>';
256 |         }
257 |     }
258 | 
259 |     /**
260 |      * Generates the closing tag for this object.
261 |      *
262 |      * @return string
263 |      */
264 |     public function makeClosingTag()
265 |     {
266 |         if ($this->selfClosing) {
267 |             return '';
268 |         }
269 | 
270 |         return '</'.$this->name.'>';
271 |     }
272 | }
273 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Dom/TextNode.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace PHPHtmlParser\Dom;
  3 | 
  4 | /**
  5 |  * Class TextNode
  6 |  *
  7 |  * @package PHPHtmlParser\Dom
  8 |  */
  9 | class TextNode extends LeafNode
 10 | {
 11 | 
 12 |     /**
 13 |      * This is a text node.
 14 |      *
 15 |      * @var Tag
 16 |      */
 17 |     protected $tag;
 18 | 
 19 |     /**
 20 |      * This is the text in this node.
 21 |      *
 22 |      * @var string
 23 |      */
 24 |     protected $text;
 25 | 
 26 |     /**
 27 |      * This is the converted version of the text.
 28 |      *
 29 |      * @var string
 30 |      */
 31 |     protected $convertedText = null;
 32 | 
 33 |     /**
 34 |      * Sets the text for this node.
 35 |      *
 36 |      * @param string $text
 37 |      */
 38 |     public function __construct($text)
 39 |     {
 40 |         // remove double spaces
 41 |         $text = preg_replace('#\s+#', ' ', $text);
 42 | 
 43 |         // restore line breaks
 44 |         $text = str_replace('&#10;', "\n", $text);
 45 | 
 46 |         $this->text = $text;
 47 |         $this->tag  = new Tag('text');
 48 |         parent::__construct();
 49 |     }
 50 | 
 51 |     /**
 52 |      * Returns the text of this node.
 53 |      *
 54 |      * @return string
 55 |      */
 56 |     public function text()
 57 |     {
 58 |         // convert charset
 59 |         if ( ! is_null($this->encode)) {
 60 |             if ( ! is_null($this->convertedText)) {
 61 |                 // we already know the converted value
 62 |                 return $this->convertedText;
 63 |             }
 64 |             $text = $this->encode->convert($this->text);
 65 | 
 66 |             // remember the conversion
 67 |             $this->convertedText = $text;
 68 | 
 69 |             return $text;
 70 |         } else {
 71 |             return $this->text;
 72 |         }
 73 |     }
 74 | 
 75 |     /**
 76 |      * This node has no html, just return the text.
 77 |      *
 78 |      * @return string
 79 |      * @uses $this->text()
 80 |      */
 81 |     public function innerHtml()
 82 |     {
 83 |         return $this->text();
 84 |     }
 85 | 
 86 |     /**
 87 |      * This node has no html, just return the text.
 88 |      *
 89 |      * @return string
 90 |      * @uses $this->text()
 91 |      */
 92 |     public function outerHtml()
 93 |     {
 94 |         return $this->text();
 95 |     }
 96 | 
 97 |     /**
 98 |      * Call this when something in the node tree has changed. Like a child has been added
 99 |      * or a parent has been changed.
100 |      */
101 |     protected function clear()
102 |     {
103 |         $this->convertedText = null;
104 |     }
105 | }
106 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Exceptions/ChildNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace PHPHtmlParser\Exceptions;
 3 | 
 4 | /**
 5 |  * Class ChildNotFoundException
 6 |  *
 7 |  * @package PHPHtmlParser\Exceptions
 8 |  */
 9 | final class ChildNotFoundException extends \Exception
10 | {
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Exceptions/CircularException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace PHPHtmlParser\Exceptions;
 3 | 
 4 | /**
 5 |  * Class CircularException
 6 |  *
 7 |  * @package PHPHtmlParser\Exceptions
 8 |  */
 9 | final class CircularException extends \Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Exceptions/CurlException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace PHPHtmlParser\Exceptions;
 3 | 
 4 | /**
 5 |  * Class CurlException
 6 |  *
 7 |  * @package PHPHtmlParser\Exceptions
 8 |  */
 9 | class CurlException extends \Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Exceptions/EmptyCollectionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace PHPHtmlParser\Exceptions;
 3 | 
 4 | /**
 5 |  * Class EmptyCollectionException
 6 |  *
 7 |  * @package PHPHtmlParser\Exceptions
 8 |  */
 9 | final class EmptyCollectionException extends \Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Exceptions/NotLoadedException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace PHPHtmlParser\Exceptions;
 3 | 
 4 | /**
 5 |  * Class NotLoadedException
 6 |  *
 7 |  * @package PHPHtmlParser\Exceptions
 8 |  */
 9 | final class NotLoadedException extends \Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Exceptions/ParentNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace PHPHtmlParser\Exceptions;
 3 | 
 4 | /**
 5 |  * Class ParentNotFoundException
 6 |  *
 7 |  * @package PHPHtmlParser\Exceptions
 8 |  */
 9 | final class ParentNotFoundException extends \Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Exceptions/StrictException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace PHPHtmlParser\Exceptions;
 3 | 
 4 | /**
 5 |  * Class StrictException
 6 |  *
 7 |  * @package PHPHtmlParser\Exceptions
 8 |  */
 9 | final class StrictException extends \Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Exceptions/UnknownChildTypeException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace PHPHtmlParser\Exceptions;
 3 | 
 4 | /**
 5 |  * Class UnknownChildTypeException
 6 |  *
 7 |  * @package PHPHtmlParser\Exceptions
 8 |  */
 9 | final class UnknownChildTypeException extends \Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Options.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace PHPHtmlParser;
 3 | 
 4 | /**
 5 |  * Class Options
 6 |  *
 7 |  * @package PHPHtmlParser
 8 |  * @property bool whitespaceTextNode
 9 |  * @property bool strict
10 |  * @property bool enforceEncoding
11 |  */
12 | class Options
13 | {
14 | 
15 |     /**
16 |      * The default options array
17 |      *
18 |      * @param array
19 |      */
20 |     protected $defaults = [
21 |         'whitespaceTextNode' => true,
22 |         'strict'             => false,
23 |         'enforceEncoding'    => null,
24 |         'cleanupInput'       => true,
25 |         'removeScripts'      => true,
26 |         'removeStyles'       => true,
27 |         'preserveLineBreaks' => false,
28 |     ];
29 | 
30 |     /**
31 |      * The list of all current options set.
32 |      *
33 |      * @param array
34 |      */
35 |     protected $options = [];
36 | 
37 |     /**
38 |      * Sets the default options in the options array
39 |      */
40 |     public function __construct()
41 |     {
42 |         $this->options = $this->defaults;
43 |     }
44 | 
45 |     /**
46 |      * A magic get to call the get() method.
47 |      *
48 |      * @param string $key
49 |      * @return mixed
50 |      * @uses $this->get()
51 |      */
52 |     public function __get($key)
53 |     {
54 |         return $this->get($key);
55 |     }
56 | 
57 |     /**
58 |      * Sets a new options param to override the current option array.
59 |      *
60 |      * @param array $options
61 |      * @return $this
62 |      */
63 |     public function setOptions(array $options)
64 |     {
65 |         foreach ($options as $key => $option) {
66 |             $this->options[$key] = $option;
67 |         }
68 | 
69 |         return $this;
70 |     }
71 | 
72 |     /**
73 |      * Gets the value associated to the key, or null if the key is not
74 |      * found.
75 |      *
76 |      * @param string
77 |      * @return mixed
78 |      */
79 |     public function get($key)
80 |     {
81 |         if (isset($this->options[$key])) {
82 |             return $this->options[$key];
83 |         }
84 | 
85 |         return null;
86 |     }
87 | }
88 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/Selector.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace PHPHtmlParser;
  3 | 
  4 | use PHPHtmlParser\Dom\AbstractNode;
  5 | use PHPHtmlParser\Dom\Collection;
  6 | use PHPHtmlParser\Dom\InnerNode;
  7 | use PHPHtmlParser\Dom\LeafNode;
  8 | use PHPHtmlParser\Exceptions\ChildNotFoundException;
  9 | 
 10 | /**
 11 |  * Class Selector
 12 |  *
 13 |  * @package PHPHtmlParser
 14 |  */
 15 | class Selector
 16 | {
 17 | 
 18 |     /**
 19 |      * Pattern of CSS selectors, modified from 'mootools'
 20 |      *
 21 |      * @var string
 22 |      */
 23 |     protected $pattern = "/([\w\-:\*>]*)(?:\#([\w\-]+)|\.([\w\-]+))?(?:\[@?(!?[\w\-:]+)(?:([!*^$]?=)[\"']?(.*?)[\"']?)?\])?([\/, ]+)/is";
 24 | 
 25 |     protected $selectors = [];
 26 | 
 27 |     /**
 28 |      * Constructs with the selector string
 29 |      *
 30 |      * @param string $selector
 31 |      */
 32 |     public function __construct($selector)
 33 |     {
 34 |         $this->parseSelectorString($selector);
 35 |     }
 36 | 
 37 |     /**
 38 |      * Returns the selectors that where found in __construct
 39 |      *
 40 |      * @return array
 41 |      */
 42 |     public function getSelectors()
 43 |     {
 44 |         return $this->selectors;
 45 |     }
 46 | 
 47 |     /**
 48 |      * Attempts to find the selectors starting from the given
 49 |      * node object.
 50 |      *
 51 |      * @param AbstractNode $node
 52 |      * @return Collection
 53 |      */
 54 |     public function find(AbstractNode $node)
 55 |     {
 56 |         $results = new Collection;
 57 |         foreach ($this->selectors as $selector) {
 58 |             $nodes = [$node];
 59 |             if (count($selector) == 0) {
 60 |                 continue;
 61 |             }
 62 | 
 63 |             $options = [];
 64 |             foreach ($selector as $rule) {
 65 |                 if ($rule['alterNext']) {
 66 |                     $options[] = $this->alterNext($rule);
 67 |                     continue;
 68 |                 }
 69 |                 $nodes = $this->seek($nodes, $rule, $options);
 70 |                 // clear the options
 71 |                 $options = [];
 72 |             }
 73 | 
 74 |             // this is the final set of nodes
 75 |             foreach ($nodes as $result) {
 76 |                 $results[] = $result;
 77 |             }
 78 |         }
 79 | 
 80 |         return $results;
 81 |     }
 82 | 
 83 |     /**
 84 |      * Parses the selector string
 85 |      *
 86 |      * @param string $selector
 87 |      */
 88 |     protected function parseSelectorString($selector)
 89 |     {
 90 |         $matches = [];
 91 |         preg_match_all($this->pattern, trim($selector).' ', $matches, PREG_SET_ORDER);
 92 | 
 93 |         // skip tbody
 94 |         $result = [];
 95 |         foreach ($matches as $match) {
 96 |             // default values
 97 |             $tag       = strtolower(trim($match[1]));
 98 |             $operator  = '=';
 99 |             $key       = null;
100 |             $value     = null;
101 |             $noKey     = false;
102 |             $alterNext = false;
103 | 
104 |             // check for elements that alter the behavior of the next element
105 |             if ($tag == '>') {
106 |                 $alterNext = true;
107 |             }
108 | 
109 |             // check for id selector
110 |             if ( ! empty($match[2])) {
111 |                 $key   = 'id';
112 |                 $value = $match[2];
113 |             }
114 | 
115 |             // check for class selector
116 |             if ( ! empty($match[3])) {
117 |                 $key   = 'class';
118 |                 $value = $match[3];
119 |             }
120 | 
121 |             // and final attribute selector
122 |             if ( ! empty($match[4])) {
123 |                 $key = strtolower($match[4]);
124 |             }
125 |             if ( ! empty($match[5])) {
126 |                 $operator = $match[5];
127 |             }
128 |             if ( ! empty($match[6])) {
129 |                 $value = $match[6];
130 |             }
131 | 
132 |             // check for elements that do not have a specified attribute
133 |             if (isset($key[0]) && $key[0] == '!') {
134 |                 $key   = substr($key, 1);
135 |                 $noKey = true;
136 |             }
137 | 
138 |             $result[] = [
139 |                 'tag'       => $tag,
140 |                 'key'       => $key,
141 |                 'value'     => $value,
142 |                 'operator'  => $operator,
143 |                 'noKey'     => $noKey,
144 |                 'alterNext' => $alterNext,
145 |             ];
146 |             if (trim($match[7]) == ',') {
147 |                 $this->selectors[] = $result;
148 |                 $result            = [];
149 |             }
150 |         }
151 | 
152 |         // save last results
153 |         if (count($result) > 0) {
154 |             $this->selectors[] = $result;
155 |         }
156 |     }
157 | 
158 |     /**
159 |      * Attempts to find all children that match the rule
160 |      * given.
161 |      *
162 |      * @param array $nodes
163 |      * @param array $rule
164 |      * @param array $options
165 |      * @return array
166 |      * @recursive
167 |      */
168 |     protected function seek(array $nodes, array $rule, array $options)
169 |     {
170 |         // XPath index
171 |         if (!empty($rule['tag']) &&
172 |             is_numeric($rule['key'])
173 |         ) {
174 |             $count = 0;
175 |             /** @var AbstractNode $node */
176 |             foreach ($nodes as $node) {
177 |                 if ($rule['tag'] == '*' ||
178 |                     $rule['tag'] == $node->getTag()->name()
179 |                 ) {
180 |                     ++$count;
181 |                     if ($count == $rule['key']) {
182 |                         // found the node we wanted
183 |                         return [$node];
184 |                     }
185 |                 }
186 |             }
187 | 
188 |             return [];
189 |         }
190 | 
191 |         $options = $this->flattenOptions($options);
192 | 
193 |         $return = [];
194 |         /** @var InnerNode $node */
195 |         foreach ($nodes as $node) {
196 |             // check if we are a leaf
197 |             if ($node instanceof LeafNode ||
198 |                 ! $node->hasChildren()
199 |             ) {
200 |                 continue;
201 |             }
202 | 
203 |             $children = [];
204 |             $child    = $node->firstChild();
205 |             while ( ! is_null($child)) {
206 |                 // wild card, grab all
207 |                 if ($rule['tag'] == '*' && is_null($rule['key'])) {
208 |                     $return[] = $child;
209 |                     try {
210 |                         $child = $node->nextChild($child->id());
211 |                     } catch (ChildNotFoundException $e) {
212 |                         // no more children
213 |                         $child = null;
214 |                     }
215 |                     continue;
216 |                 }
217 | 
218 |                 $pass = true;
219 |                 // check tag
220 |                 if ( ! empty($rule['tag']) && $rule['tag'] != $child->getTag()->name() &&
221 |                     $rule['tag'] != '*'
222 |                 ) {
223 |                     // child failed tag check
224 |                     $pass = false;
225 |                 }
226 | 
227 |                 // check key
228 |                 if ($pass && ! is_null($rule['key'])) {
229 |                     if ($rule['noKey']) {
230 |                         if ( ! is_null($child->getAttribute($rule['key']))) {
231 |                             $pass = false;
232 |                         }
233 |                     } else {
234 |                         if ($rule['key'] != 'plaintext' &&
235 |                             is_null($child->getAttribute($rule['key']))
236 |                         ) {
237 |                             $pass = false;
238 |                         }
239 |                     }
240 |                 }
241 | 
242 |                 // compare values
243 |                 if ($pass && ! is_null($rule['key']) &&
244 |                     ! is_null($rule['value']) && $rule['value'] != '*'
245 |                 ) {
246 |                     if ($rule['key'] == 'plaintext') {
247 |                         // plaintext search
248 |                         $nodeValue = $child->text();
249 |                     } else {
250 |                         // normal search
251 |                         $nodeValue = $child->getAttribute($rule['key']);
252 |                     }
253 | 
254 |                     $check = $this->match($rule['operator'], $rule['value'], $nodeValue);
255 | 
256 |                     // handle multiple classes
257 |                     if ( ! $check && $rule['key'] == 'class') {
258 |                         $childClasses = explode(' ', $child->getAttribute('class'));
259 |                         foreach ($childClasses as $class) {
260 |                             if ( ! empty($class)) {
261 |                                 $check = $this->match($rule['operator'], $rule['value'], $class);
262 |                             }
263 |                             if ($check) {
264 |                                 break;
265 |                             }
266 |                         }
267 |                     }
268 | 
269 |                     if ( ! $check) {
270 |                         $pass = false;
271 |                     }
272 |                 }
273 | 
274 |                 if ($pass) {
275 |                     // it passed all checks
276 |                     $return[] = $child;
277 |                 } else {
278 |                     // this child failed to be matched
279 |                     if ($child instanceof InnerNode &&
280 |                         $child->hasChildren()
281 |                     ) {
282 |                         // we still want to check its children
283 |                         $children[] = $child;
284 |                     }
285 |                 }
286 | 
287 |                 try {
288 |                     // get next child
289 |                     $child = $node->nextChild($child->id());
290 |                 } catch (ChildNotFoundException $e) {
291 |                     // no more children
292 |                     $child = null;
293 |                 }
294 |             }
295 | 
296 |             if (( ! isset($options['checkGrandChildren']) ||
297 |                     $options['checkGrandChildren'])
298 |                 && count($children) > 0
299 |             ) {
300 |                 // we have children that failed but are not leaves.
301 |                 $matches = $this->seek($children, $rule, $options);
302 |                 foreach ($matches as $match) {
303 |                     $return[] = $match;
304 |                 }
305 |             }
306 |         }
307 | 
308 |         return $return;
309 |     }
310 | 
311 |     /**
312 |      * Attempts to match the given arguments with the given operator.
313 |      *
314 |      * @param string $operator
315 |      * @param string $pattern
316 |      * @param string $value
317 |      * @return bool
318 |      */
319 |     protected function match($operator, $pattern, $value)
320 |     {
321 |         $value   = strtolower($value);
322 |         $pattern = strtolower($pattern);
323 |         switch ($operator) {
324 |             case '=':
325 |                 return $value === $pattern;
326 |             case '!=':
327 |                 return $value !== $pattern;
328 |             case '^=':
329 |                 return preg_match('/^'.preg_quote($pattern, '/').'/', $value);
330 |             case '$=':
331 |                 return preg_match('/'.preg_quote($pattern, '/').'$/', $value);
332 |             case '*=':
333 |                 if ($pattern[0] == '/') {
334 |                     return preg_match($pattern, $value);
335 |                 }
336 | 
337 |                 return preg_match("/".$pattern."/i", $value);
338 |         }
339 | 
340 |         return false;
341 |     }
342 | 
343 |     /**
344 |      * Attempts to figure out what the alteration will be for
345 |      * the next element.
346 |      *
347 |      * @param array $rule
348 |      * @return array
349 |      */
350 |     protected function alterNext($rule)
351 |     {
352 |         $options = [];
353 |         if ($rule['tag'] == '>') {
354 |             $options['checkGrandChildren'] = false;
355 |         }
356 | 
357 |         return $options;
358 |     }
359 | 
360 |     /**
361 |      * Flattens the option array.
362 |      *
363 |      * @param array $optionsArray
364 |      * @return array
365 |      */
366 |     protected function flattenOptions(array $optionsArray)
367 |     {
368 |         $options = [];
369 |         foreach ($optionsArray as $optionArray) {
370 |             foreach ($optionArray as $key => $option) {
371 |                 $options[$key] = $option;
372 |             }
373 |         }
374 | 
375 |         return $options;
376 |     }
377 | }
378 | 


--------------------------------------------------------------------------------
/src/PHPHtmlParser/StaticDom.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace PHPHtmlParser;
  3 | 
  4 | use PHPHtmlParser\Exceptions\NotLoadedException;
  5 | 
  6 | /**
  7 |  * Class StaticDom
  8 |  *
  9 |  * @package PHPHtmlParser
 10 |  */
 11 | final class StaticDom
 12 | {
 13 | 
 14 |     private static $dom = null;
 15 | 
 16 |     /**
 17 |      * Attempts to call the given method on the most recent created dom
 18 |      * from bellow.
 19 |      *
 20 |      * @param string $method
 21 |      * @param array $arguments
 22 |      * @throws NotLoadedException
 23 |      * @return mixed
 24 |      */
 25 |     public static function __callStatic($method, $arguments)
 26 |     {
 27 |         if (self::$dom instanceof Dom) {
 28 |             return call_user_func_array([self::$dom, $method], $arguments);
 29 |         } else {
 30 |             throw new NotLoadedException('The dom is not loaded. Can not call a dom method.');
 31 |         }
 32 |     }
 33 | 
 34 |     /**
 35 |      * Call this to mount the static facade. The facade allows you to use
 36 |      * this object as a $className.
 37 |      *
 38 |      * @param string $className
 39 |      * @param Dom $dom
 40 |      * @return bool
 41 |      */
 42 |     public static function mount($className = 'Dom', Dom $dom = null)
 43 |     {
 44 |         if (class_exists($className)) {
 45 |             return false;
 46 |         }
 47 |         class_alias(__CLASS__, $className);
 48 |         if ($dom instanceof Dom) {
 49 |             self::$dom = $dom;
 50 |         }
 51 | 
 52 |         return true;
 53 |     }
 54 | 
 55 |     /**
 56 |      * Creates a new dom object and calls load() on the
 57 |      * new object.
 58 |      *
 59 |      * @param string $str
 60 |      * @return $this
 61 |      */
 62 |     public static function load($str)
 63 |     {
 64 |         $dom       = new Dom;
 65 |         self::$dom = $dom;
 66 | 
 67 |         return $dom->load($str);
 68 |     }
 69 | 
 70 |     /**
 71 |      * Creates a new dom object and calls loadFromFile() on the
 72 |      * new object.
 73 |      *
 74 |      * @param string $file
 75 |      * @return $this
 76 |      */
 77 |     public static function loadFromFile($file)
 78 |     {
 79 |         $dom       = new Dom;
 80 |         self::$dom = $dom;
 81 | 
 82 |         return $dom->loadFromFile($file);
 83 |     }
 84 | 
 85 |     /**
 86 |      * Creates a new dom object and calls loadFromUrl() on the
 87 |      * new object.
 88 |      *
 89 |      * @param string $url
 90 |      * @param array $options
 91 |      * @param CurlInterface $curl
 92 |      * @return $this
 93 |      */
 94 |     public static function loadFromUrl($url, $options = [], CurlInterface $curl = null)
 95 |     {
 96 |         $dom       = new Dom;
 97 |         self::$dom = $dom;
 98 |         if (is_null($curl)) {
 99 |             // use the default curl interface
100 |             $curl = new Curl;
101 |         }
102 | 
103 |         return $dom->loadFromUrl($url, $options, $curl);
104 |     }
105 | 
106 |     /**
107 |      * Sets the $dom variable to null.
108 |      */
109 |     public static function unload()
110 |     {
111 |         self::$dom = null;
112 |     }
113 | }
114 | 


--------------------------------------------------------------------------------