├── _config.yml
├── tests
    ├── bootstrap.php
    ├── TestCase.php
    ├── FastSimpleHTMLDom
    │   ├── NodeListTest.php
    │   ├── SelectorConverterTest.php
    │   ├── DocumentTest.php
    │   └── ElementTest.php
    └── fixtures
    │   └── testpage.html
├── .travis.yml
├── phpunit.xml.dist
├── composer.json
├── LICENSE
├── lib
    ├── SelectorConverter.php
    ├── NodeList.php
    ├── Document.php
    └── Element.php
└── README.md


/_config.yml:
--------------------------------------------------------------------------------
1 | theme: jekyll-theme-hacker


--------------------------------------------------------------------------------
/tests/bootstrap.php:
--------------------------------------------------------------------------------
1 | <?php
2 | require __DIR__.'/../vendor/autoload.php';
3 | 


--------------------------------------------------------------------------------
/tests/TestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests;
 4 | 
 5 | 
 6 | class TestCase extends \PHPUnit\Framework\TestCase
 7 | {
 8 |     protected function loadFixture($filename)
 9 |     {
10 |         $path = __DIR__ . '/fixtures/' . $filename;
11 |         if (file_exists($path)) {
12 |             return file_get_contents($path);
13 |         }
14 | 
15 |         return null;
16 |     }
17 | }


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | php:
 4 |   - 5.6
 5 |   - 7.0
 6 |   - 7.1
 7 |   - 7.2
 8 |   - 7.3
 9 |   - 7.4
10 | 
11 | matrix:
12 |   fast_finish: true
13 | 
14 | install:
15 |   - composer self-update
16 |   - composer install --dev --no-interaction
17 |   
18 | script:
19 |   - mkdir -p build/logs
20 |   - vendor/bin/phpunit --coverage-clover build/logs/clover.xml
21 | 
22 | after_script:
23 |   - travis_retry php vendor/bin/php-coveralls
24 | 


--------------------------------------------------------------------------------
/phpunit.xml.dist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | 
 3 | <phpunit backupGlobals="false"
 4 |          backupStaticAttributes="false"
 5 |          colors="true"
 6 |          convertErrorsToExceptions="true"
 7 |          convertNoticesToExceptions="true"
 8 |          convertWarningsToExceptions="true"
 9 |          processIsolation="false"
10 |          stopOnFailure="false"
11 |          bootstrap="./tests/bootstrap.php"
12 |         >
13 |     <testsuites>
14 |         <testsuite name="Test Suite">
15 |             <directory>./tests/FastSimpleHTMLDom</directory>
16 |         </testsuite>
17 |     </testsuites>
18 | 
19 |     <filter>
20 |         <whitelist>
21 |             <directory suffix=".php">./lib</directory>
22 |         </whitelist>
23 |     </filter>
24 | </phpunit>


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "dimabdc/php-fast-simple-html-dom-parser",
 3 |     "description": "PHP Fast Simple HTML DOM parser.",
 4 |     "type": "library",
 5 |     "keywords": ["html","parse","parser"],
 6 |     "license": "MIT",
 7 |     "authors": [
 8 |         {
 9 |             "name": "dimabdc",
10 |             "email": "support@titor.ru",
11 |             "homepage": "http://github.com/dimabdc"
12 |         }
13 |     ],
14 | 	"require":{
15 |         "php":">=5.6",
16 |         "ext-dom": "*",
17 |         "ext-libxml": "*",
18 |         "ext-simplexml": "*",
19 |         "symfony/css-selector": "*"
20 |     },
21 |     "require-dev": {
22 |         "phpunit/phpunit": "^5.7",
23 |         "php-coveralls/php-coveralls": "^2.2"
24 |     },
25 |     "autoload": {
26 |         "psr-4": {
27 |             "FastSimpleHTMLDom\\": "lib/"
28 |         }
29 |     },
30 |     "autoload-dev": {
31 |         "psr-4": {
32 |             "Tests\\": "tests/"
33 |         }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/lib/SelectorConverter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace FastSimpleHTMLDom;
 4 | 
 5 | use Symfony\Component\CssSelector\CssSelectorConverter;
 6 | 
 7 | class SelectorConverter
 8 | {
 9 |     protected static $compiled = [];
10 | 
11 |     /**
12 |      * @param $selector
13 |      *
14 |      * @return mixed|string
15 |      * @throws \RuntimeException
16 |      */
17 |     public static function toXPath($selector)
18 |     {
19 |         if (isset(self::$compiled[$selector])){
20 |             return self::$compiled[$selector];
21 |         }
22 | 
23 |         if (!class_exists('Symfony\\Component\\CssSelector\\CssSelectorConverter')) {
24 |             throw new \RuntimeException('Unable to filter with a CSS selector as the Symfony CssSelector 2.8+ is not installed (you can use filterXPath instead).');
25 |         }
26 | 
27 |         $converter = new CssSelectorConverter(true);
28 | 
29 |         $xPathQuery = $converter->toXPath($selector);
30 | 
31 |         $xPathQuery = preg_replace_callback('/(:(\*\/)?|\/)(text|comment)(?=[\s]*[^.\w\[\]#]|$)/', static function (array $match) {
32 |             return $match[0] . '()';
33 |         }, $xPathQuery);
34 | 
35 |         self::$compiled[$selector] = $xPathQuery;
36 | 
37 |         return $xPathQuery;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/tests/FastSimpleHTMLDom/NodeListTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests\FastSimpleHTMLDom;
 4 | 
 5 | 
 6 | use FastSimpleHTMLDom\Document;
 7 | use Tests\TestCase;
 8 | use FastSimpleHTMLDom\NodeList;
 9 | use FastSimpleHTMLDom\Element;
10 | 
11 | class NodeListTest extends TestCase
12 | {
13 |     /**
14 |      * @dataProvider findTests
15 |      */
16 |     public function testFind($html, $selector, $count)
17 |     {
18 |         $document = new Document($html);
19 |         $nodeList =$document->find('section');
20 | 
21 |         $elements = $nodeList->find($selector);
22 | 
23 |         $this->assertInstanceOf(NodeList::class, $elements);
24 |         $this->assertCount($count, $elements);
25 | 
26 |         foreach ($elements as $node) {
27 |             $this->assertInstanceOf(Element::class, $node);
28 |         }
29 |     }
30 | 
31 |     public function findTests()
32 |     {
33 |         $html = $this->loadFixture('testpage.html');
34 |         return array(
35 |             array($html, '.fake h2', 0),
36 |             array($html, 'article', 16),
37 |             array($html, '.radio', 3),
38 |             array($html, 'input.radio', 3),
39 |             array($html, 'ul li', 9),
40 |             array($html, 'fieldset#forms__checkbox li, fieldset#forms__radio li', 6),
41 |             array($html, 'input[id]', 23),
42 |             array($html, 'input[id=in]', 1),
43 |             array($html, '#in', 1),
44 |             array($html, '*[id]', 51),
45 |             array($html, 'text', 200),
46 |         );
47 |     }
48 | 
49 |     public function testInnerHtml()
50 |     {
51 |         $html = '<div><p>foo</p><p>bar</p></div>';
52 |         $document = new Document($html);
53 |         $element = $document->find('p');
54 | 
55 |         $this->assertEquals('<p>foo</p><p>bar</p>', $element->innerHtml());
56 |         $this->assertEquals('<p>foo</p><p>bar</p>', $element->innertext);
57 |     }
58 | 
59 |     public function testText()
60 |     {
61 |         $html = '<div><p>foo</p><p>bar</p></div>';
62 |         $document = new Document($html);
63 |         $element = $document->find('p');
64 | 
65 |         $this->assertEquals('foobar', $element->text());
66 |         $this->assertEquals('foobar', $element->plaintext);
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/lib/NodeList.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace FastSimpleHTMLDom;
  4 | 
  5 | 
  6 | /**
  7 |  * Class NodeList
  8 |  * @package FastSimpleHTMLDom
  9 |  * @property-read string outertext Get dom node's outer html
 10 |  * @property-read string plaintext Get dom node's plain text
 11 |  */
 12 | class NodeList extends \ArrayObject
 13 | {
 14 |     /**
 15 |      * Find list of nodes with a CSS selector
 16 |      *
 17 |      * @param string $selector
 18 |      * @param int    $idx
 19 |      *
 20 |      * @return NodeList|Element|null
 21 |      */
 22 |     public function find($selector, $idx = null)
 23 |     {
 24 |         $elements = new self();
 25 |         foreach ($this as $node) {
 26 |             foreach ($node->find($selector) as $res) {
 27 |                 $elements->append($res);
 28 |             }
 29 |         }
 30 |         if (null === $idx) {
 31 |             return $elements;
 32 |         }
 33 | 
 34 |         if ($idx < 0) {
 35 |             $idx = count($elements) + $idx;
 36 |         }
 37 | 
 38 |         return isset($elements[$idx]) ? $elements[$idx] : null;
 39 |     }
 40 | 
 41 |     /**
 42 |      * Get plain text
 43 |      *
 44 |      * @return string
 45 |      */
 46 |     public function text()
 47 |     {
 48 |         $text = '';
 49 |         foreach ($this as $node) {
 50 |             $text .= $node->plaintext;
 51 |         }
 52 | 
 53 |         return $text;
 54 |     }
 55 | 
 56 |     /**
 57 |      * Get html of Elements
 58 |      *
 59 |      * @return string
 60 |      */
 61 |     public function innerHtml()
 62 |     {
 63 |         $text = '';
 64 |         foreach ($this as $node) {
 65 |             $text .= $node->outertext;
 66 |         }
 67 | 
 68 |         return $text;
 69 |     }
 70 | 
 71 |     /**
 72 |      * @param string $string
 73 |      *
 74 |      * @return NodeList|Element[]
 75 |      */
 76 |     public static function fromString($string)
 77 |     {
 78 |         if (null === $string || trim($string) === '') {
 79 |             return new self();
 80 |         }
 81 | 
 82 |         $string = "<body>$string</body>";
 83 | 
 84 |         $newDocument = new Document($string);
 85 | 
 86 |         $nodeList = new self();
 87 |         foreach ($newDocument->getDocument()->documentElement->childNodes as $childNode) {
 88 |             $nodeList->append(new Element($childNode));
 89 |         }
 90 | 
 91 |         return $nodeList;
 92 |     }
 93 | 
 94 |     /**
 95 |      * @param $name
 96 |      *
 97 |      * @return string
 98 |      */
 99 |     public function __get($name)
100 |     {
101 |         switch ($name) {
102 |             case 'innertext':
103 |                 return $this->innerHtml();
104 |             case 'plaintext':
105 |                 return $this->text();
106 |         }
107 | 
108 |         return null;
109 |     }
110 | 
111 |     /**
112 |      * @return mixed
113 |      */
114 |     public function __toString()
115 |     {
116 |         return $this->innerHtml();
117 |     }
118 | 
119 |     /**
120 |      * @param string $selector
121 |      * @param int    $idx
122 |      *
123 |      * @return Element|NodeList|null
124 |      */
125 |     public function __invoke($selector, $idx = null)
126 |     {
127 |         return $this->find($selector, $idx);
128 |     }
129 | }
130 | 


--------------------------------------------------------------------------------
/tests/FastSimpleHTMLDom/SelectorConverterTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Tests\FastSimpleHTMLDom;
  4 | 
  5 | use FastSimpleHTMLDom\SelectorConverter;
  6 | use Tests\TestCase;
  7 | 
  8 | class SelectorConverterTest extends TestCase
  9 | {
 10 |     /**
 11 |      * @dataProvider selectorsContainsDataProvider
 12 |      */
 13 |     public function testToXPath($cssSelector, $needle)
 14 |     {
 15 |         $this->assertContains($needle, SelectorConverter::toXPath($cssSelector));
 16 |     }
 17 | 
 18 |     public function selectorsContainsDataProvider()
 19 |     {
 20 |         return [
 21 |             [
 22 |                 'text',
 23 |                 'text()',
 24 |             ],
 25 |             [
 26 |                 'div text',
 27 |                 'text()',
 28 |             ],
 29 |             [
 30 |                 'div span, text',
 31 |                 'text()',
 32 |             ],
 33 |             [
 34 |                 'div|text',
 35 |                 'text()',
 36 |             ],
 37 |             [
 38 |                 'div>text',
 39 |                 'text()',
 40 |             ],
 41 |             [
 42 |                 'div > text',
 43 |                 'text()',
 44 |             ],
 45 |             [
 46 |                 'div,text',
 47 |                 'text()',
 48 |             ],
 49 |             [
 50 |                 'div, text',
 51 |                 'text()',
 52 |             ],
 53 |             [
 54 |                 'comment',
 55 |                 'comment()',
 56 |             ],
 57 |             [
 58 |                 'div comment',
 59 |                 'comment()',
 60 |             ],
 61 |             [
 62 |                 'div span, comment',
 63 |                 'comment()',
 64 |             ],
 65 |             [
 66 |                 'div|comment',
 67 |                 'comment()',
 68 |             ],
 69 |             [
 70 |                 'div>comment',
 71 |                 'comment()',
 72 |             ],
 73 |             [
 74 |                 'div > comment',
 75 |                 'comment()',
 76 |             ],
 77 |             [
 78 |                 'div,comment',
 79 |                 'comment()',
 80 |             ],
 81 |             [
 82 |                 'div, comment',
 83 |                 'comment()',
 84 |             ],
 85 |         ];
 86 |     }
 87 | 
 88 |     /**
 89 |      * @dataProvider selectorsNotContainsDataProvider
 90 |      */
 91 |     public function testToXPathNotElements($cssSelector, $needle)
 92 |     {
 93 |         $this->assertNotContains($needle, SelectorConverter::toXPath($cssSelector));
 94 |     }
 95 | 
 96 |     public function selectorsNotContainsDataProvider()
 97 |     {
 98 |         return [
 99 |             [
100 |                 '.text',
101 |                 'text()',
102 |             ],
103 |             [
104 |                 '#text',
105 |                 'text()',
106 |             ],
107 |             [
108 |                 'foo[text]',
109 |                 'text()',
110 |             ],
111 |             [
112 |                 'div[foo|text]',
113 |                 'text()',
114 |             ],
115 |             [
116 |                 'div[text|foo]',
117 |                 'text()',
118 |             ],
119 |             [
120 |                 'div[class*=text]',
121 |                 'text()',
122 |             ],
123 |             [
124 |                 'div[class*="text"]',
125 |                 'text()',
126 |             ],
127 |             [
128 |                 '.comment',
129 |                 'comment()',
130 |             ],
131 |             [
132 |                 '#comment',
133 |                 'comment()',
134 |             ],
135 |             [
136 |                 'foo[comment]',
137 |                 'comment()',
138 |             ],
139 |             [
140 |                 'div[foo|comment]',
141 |                 'comment()',
142 |             ],
143 |             [
144 |                 'div[comment|foo]',
145 |                 'comment()',
146 |             ],
147 |             [
148 |                 'div[class*=comment]',
149 |                 'comment()',
150 |             ],
151 |             [
152 |                 'div[class*="comment"]',
153 |                 'comment()',
154 |             ],
155 |         ];
156 |     }
157 | }
158 | 


--------------------------------------------------------------------------------
/tests/FastSimpleHTMLDom/DocumentTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Tests\FastSimpleHTMLDom;
  4 | 
  5 | use BadMethodCallException;
  6 | use FastSimpleHTMLDom\Document;
  7 | use FastSimpleHTMLDom\Element;
  8 | use InvalidArgumentException;
  9 | use RuntimeException;
 10 | use Tests\TestCase;
 11 | use FastSimpleHTMLDom\NodeList;
 12 | 
 13 | class DocumentTest extends TestCase
 14 | {
 15 |     /**
 16 |      * @expectedException InvalidArgumentException
 17 |      */
 18 |     public function testConstructWithInvalidArgument()
 19 |     {
 20 |         new Document(['foo']);
 21 |     }
 22 | 
 23 |     /**
 24 |      * @expectedException InvalidArgumentException
 25 |      */
 26 |     public function testLoadHtmlWithInvalidArgument()
 27 |     {
 28 |         $document = new Document();
 29 |         $document->loadHtml(['foo']);
 30 |     }
 31 | 
 32 |     /**
 33 |      * @expectedException InvalidArgumentException
 34 |      */
 35 |     public function testLoadWithInvalidArgument()
 36 |     {
 37 |         $document = new Document();
 38 |         $document->load(['foo']);
 39 |     }
 40 | 
 41 |     /**
 42 |      * @expectedException InvalidArgumentException
 43 |      */
 44 |     public function testLoadHtmlFileWithInvalidArgument()
 45 |     {
 46 |         $document = new Document();
 47 |         $document->loadHtmlFile(['foo']);
 48 |     }
 49 | 
 50 |     /**
 51 |      * @expectedException InvalidArgumentException
 52 |      */
 53 |     public function testLoad_fileWithInvalidArgument()
 54 |     {
 55 |         $document = new Document();
 56 |         $document->load_file(['foo']);
 57 |     }
 58 | 
 59 |     /**
 60 |      * @expectedException RuntimeException
 61 |      */
 62 |     public function testLoadHtmlFileWithNotExistingFile()
 63 |     {
 64 |         $document = new Document();
 65 |         $document->loadHtmlFile('/path/to/file');
 66 |     }
 67 | 
 68 |     /**
 69 |      * @expectedException RuntimeException
 70 |      */
 71 |     public function testLoadHtmlFileWithNotLoadFile()
 72 |     {
 73 |         $document = new Document();
 74 |         $document->loadHtmlFile('http://fobar');
 75 |     }
 76 | 
 77 |     /**
 78 |      * @expectedException BadMethodCallException
 79 |      */
 80 |     public function testMethodNotExist()
 81 |     {
 82 |         $document = new Document();
 83 |         $document->bar();
 84 |     }
 85 | 
 86 |     /**
 87 |      * @expectedException BadMethodCallException
 88 |      */
 89 |     public function testStaticMethodNotExist()
 90 |     {
 91 |         Document::bar();
 92 |     }
 93 | 
 94 |     public function testNotExistProperty()
 95 |     {
 96 |         $document = new Document();
 97 | 
 98 |         $this->assertNull($document->foo);
 99 |     }
100 | 
101 |     public function testConstruct()
102 |     {
103 |         $html = '<div>foo</div>';
104 |         $document = new Document($html);
105 | 
106 |         $this->assertEquals($html, $document->outertext);
107 |     }
108 | 
109 |     public function testLoadHtmlFile()
110 |     {
111 |         $file = __DIR__ . '/../fixtures/testpage.html';
112 |         $document = new Document();
113 | 
114 |         $document->loadHtmlFile($file);
115 |         $this->assertNotNull(count($document('div')));
116 | 
117 |         $document->load_file($file);
118 |         $this->assertNotNull(count($document('div')));
119 | 
120 |         $document = Document::file_get_html($file);
121 |         $this->assertNotNull(count($document('div')));
122 |     }
123 | 
124 |     public function testLoadHtml()
125 |     {
126 |         $html = $this->loadFixture('testpage.html');
127 |         $document = new Document();
128 | 
129 |         $document->loadHtml($html);
130 |         $this->assertNotNull(count($document('div')));
131 | 
132 |         $document->load($html);
133 |         $this->assertNotNull(count($document('div')));
134 | 
135 |         $document = Document::str_get_html($html);
136 |         $this->assertNotNull(count($document('div')));
137 |     }
138 | 
139 |     public function testGetDocument()
140 |     {
141 |         $document = new Document();
142 |         $this->assertInstanceOf('DOMDocument', $document->getDocument());
143 |     }
144 | 
145 |     /**
146 |      * @dataProvider findTests
147 |      */
148 |     public function testFind($html, $selector, $count)
149 |     {
150 |         $document = new Document($html);
151 |         $elements = $document->find($selector);
152 | 
153 |         $this->assertInstanceOf(NodeList::class, $elements);
154 |         $this->assertCount($count, $elements);
155 | 
156 |         foreach ($elements as $element) {
157 |             $this->assertInstanceOf(Element::class, $element);
158 |         }
159 | 
160 |         if ($count !== 0) {
161 |             $element = $document->find($selector, -1);
162 |             $this->assertInstanceOf(Element::class, $element);
163 |         }
164 |     }
165 | 
166 |     public function findTests()
167 |     {
168 |         $html = $this->loadFixture('testpage.html');
169 | 
170 |         return [
171 |             [$html, '.fake h2', 0],
172 |             [$html, 'article', 16],
173 |             [$html, '.radio', 3],
174 |             [$html, 'input.radio', 3],
175 |             [$html, 'ul li', 35],
176 |             [$html, 'fieldset#forms__checkbox li, fieldset#forms__radio li', 6],
177 |             [$html, 'input[id]', 23],
178 |             [$html, 'input[id=in]', 1],
179 |             [$html, '#in', 1],
180 |             [$html, '*[id]', 52],
181 |             [$html, 'text', 234],
182 |             [$html, 'comment', 3],
183 |         ];
184 |     }
185 | 
186 |     public function testHtml()
187 |     {
188 |         $html = $this->loadFixture('testpage.html');
189 |         $document = new Document($html);
190 | 
191 |         $this->assertTrue(is_string($document->html()));
192 |         $this->assertTrue(is_string($document->outertext));
193 |         $this->assertTrue(strlen($document) > 0);
194 | 
195 | 
196 |         $html = '<div>foo</div>';
197 |         $document = new Document($html);
198 | 
199 |         $this->assertEquals($html, $document->html());
200 |         $this->assertEquals($html, $document->outertext);
201 |         $this->assertEquals($html, $document);
202 |     }
203 | 
204 |     public function testInnerHtml()
205 |     {
206 |         $html = '<div><div>foo</div></div>';
207 |         $document = new Document($html);
208 | 
209 |         $this->assertEquals('<div>foo</div>', $document->innerHtml());
210 |         $this->assertEquals('<div>foo</div>', $document->innertext());
211 |         $this->assertEquals('<div>foo</div>', $document->innertext);
212 |     }
213 | 
214 |     public function testText()
215 |     {
216 |         $html = '<div>foo</div>';
217 |         $document = new Document($html);
218 | 
219 |         $this->assertEquals('foo', $document->text());
220 |         $this->assertEquals('foo', $document->plaintext);
221 |     }
222 | 
223 |     public function testSave()
224 |     {
225 |         $html = $this->loadFixture('testpage.html');
226 |         $document = new Document($html);
227 | 
228 |         $this->assertTrue(is_string($document->save()));
229 |     }
230 | 
231 |     public function testClear()
232 |     {
233 |         $document = new Document();
234 | 
235 |         $this->assertNull($document->clear());
236 |     }
237 | }
238 | 


--------------------------------------------------------------------------------
/lib/Document.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace FastSimpleHTMLDom;
  4 | 
  5 | use BadMethodCallException;
  6 | use DOMDocument;
  7 | use DOMXPath;
  8 | use InvalidArgumentException;
  9 | use RuntimeException;
 10 | 
 11 | /**
 12 |  * Class Document
 13 |  * @package FastSimpleHTMLDom
 14 |  *
 15 |  * @property string      outertext Get dom node's outer html
 16 |  * @property string      innertext Get dom node's inner html
 17 |  * @property-read string plaintext Get dom node's plain text
 18 |  *
 19 |  * @method string outertext() Get dom node's outer html
 20 |  * @method string innertext() Get dom node's inner html
 21 |  * @method Document load() load($html) Load HTML from string
 22 |  * @method Document load_file() load_file($html) Load HTML from file
 23 |  *
 24 |  * @method static Document file_get_html() file_get_html($html) Load HTML from file
 25 |  * @method static Document str_get_html() str_get_html($html) Load HTML from string
 26 |  */
 27 | class Document
 28 | {
 29 |     /**
 30 |      * @var DOMDocument
 31 |      */
 32 |     protected $document;
 33 | 
 34 |     /**
 35 |      * @var array
 36 |      */
 37 |     protected $functionAliases = [
 38 |         'outertext' => 'html',
 39 |         'innertext' => 'innerHtml',
 40 |         'load'      => 'loadHtml',
 41 |         'load_file' => 'loadHtmlFile',
 42 |     ];
 43 | 
 44 |     /**
 45 |      * @var Callable
 46 |      */
 47 |     static protected $callback;
 48 | 
 49 | 
 50 |     /**
 51 |      * Constructor
 52 |      *
 53 |      * @param string|Element $element HTML code or Element
 54 |      */
 55 |     public function __construct($element = null)
 56 |     {
 57 |         $this->document = new DOMDocument('1.0', 'UTF-8');
 58 | 
 59 |         if ($element instanceof Element) {
 60 |             $node = $element->getNode();
 61 | 
 62 |             $domNode = $this->document->importNode($node, true);
 63 |             $this->document->appendChild($domNode);
 64 | 
 65 |             return;
 66 |         }
 67 | 
 68 |         if ($element !== null) {
 69 |             $this->loadHtml($element);
 70 |         }
 71 |     }
 72 | 
 73 |     /**
 74 |      * Load HTML from string
 75 |      *
 76 |      * @param string $html
 77 |      *
 78 |      * @return Document
 79 |      * @throws InvalidArgumentException if argument is not string
 80 |      */
 81 |     public function loadHtml($html)
 82 |     {
 83 |         if (!is_string($html)) {
 84 |             throw new InvalidArgumentException(__METHOD__ . ' expects parameter 1 to be string.');
 85 |         }
 86 | 
 87 |         $html = preg_replace('/>(?:[\t\s\n\r])+</', '><', $html);
 88 | 
 89 |         libxml_use_internal_errors(true);
 90 | 
 91 |         if (!$this->document->loadHTML($html, LIBXML_COMPACT|LIBXML_HTML_NOIMPLIED|LIBXML_HTML_NODEFDTD|LIBXML_NOENT|LIBXML_NOWARNING)) {
 92 |             $this->document->loadHTML('<?xml encoding="UTF-8">' . $html, LIBXML_COMPACT|LIBXML_HTML_NOIMPLIED|LIBXML_HTML_NODEFDTD|LIBXML_NOENT|LIBXML_NOWARNING);
 93 |         }
 94 | 
 95 |         libxml_clear_errors();
 96 |         libxml_use_internal_errors(false);
 97 | 
 98 |         return $this;
 99 |     }
100 | 
101 |     /**
102 |      * Load HTML from file
103 |      *
104 |      * @param string $filePath
105 |      *
106 |      * @return Document
107 |      *
108 |      * @throws InvalidArgumentException
109 |      * @throws RuntimeException
110 |      */
111 |     public function loadHtmlFile($filePath)
112 |     {
113 |         if (!is_string($filePath)) {
114 |             throw new InvalidArgumentException(__METHOD__ . ' expects parameter 1 to be string.');
115 |         }
116 | 
117 |         if (!preg_match("/^https?:\/\//i", $filePath) && !file_exists($filePath)) {
118 |             throw new RuntimeException("File $filePath not found");
119 |         }
120 | 
121 |         try {
122 |             $html = file_get_contents($filePath);
123 |         } catch (\Exception $e) {
124 |             throw new RuntimeException("Could not load file $filePath");
125 |         }
126 | 
127 |         if ($html === false) {
128 |             throw new RuntimeException("Could not load file $filePath");
129 |         }
130 | 
131 |         $this->loadHtml($html);
132 | 
133 |         return $this;
134 |     }
135 | 
136 |     /**
137 |      * @return DOMDocument
138 |      */
139 |     public function getDocument()
140 |     {
141 |         return $this->document;
142 |     }
143 | 
144 |     /**
145 |      * Find list of nodes with a CSS selector
146 |      *
147 |      * @param string $selector
148 |      * @param int    $idx
149 |      *
150 |      * @return NodeList|Element|null
151 |      */
152 |     public function find($selector, $idx = null)
153 |     {
154 |         $xPathQuery = SelectorConverter::toXPath($selector);
155 | 
156 |         $xPath = new DOMXPath($this->document);
157 |         $nodesList = $xPath->query($xPathQuery);
158 |         $elements = new NodeList();
159 | 
160 |         foreach ($nodesList as $node) {
161 |             $elements[] = new Element($node);
162 |         }
163 | 
164 |         if (null === $idx) {
165 |             return $elements;
166 |         }
167 | 
168 |         if ($idx < 0) {
169 |             $idx = count($elements) + $idx;
170 |         }
171 | 
172 |         return isset($elements[$idx]) ? $elements[$idx] : null;
173 |     }
174 | 
175 |     /**
176 |      * Get dom node's outer html
177 |      *
178 |      * @return string
179 |      */
180 |     public function html()
181 |     {
182 |         if ($this::$callback !== null) {
183 |             call_user_func($this::$callback, $this);
184 |         }
185 | 
186 |         return trim($this->document->saveHTML());
187 |     }
188 | 
189 |     /**
190 |      * Get dom node's inner html
191 |      *
192 |      * @return string
193 |      */
194 |     public function innerHtml()
195 |     {
196 |         $text = '';
197 |         foreach ($this->document->documentElement->childNodes as $node) {
198 |             $text .= trim($this->document->saveXML($node));
199 |         }
200 | 
201 |         return $text;
202 |     }
203 | 
204 |     /**
205 |      * Get dom node's plain text
206 |      *
207 |      * @return string
208 |      */
209 |     public function text()
210 |     {
211 |         return $this->document->textContent;
212 |     }
213 | 
214 |     /**
215 |      * Save dom as string
216 |      *
217 |      * @param string $filepath
218 |      *
219 |      * @return string
220 |      */
221 |     public function save($filepath = '')
222 |     {
223 |         $string = $this->innerHtml();
224 |         if ($filepath !== '') {
225 |             file_put_contents($filepath, $string, LOCK_EX);
226 |         }
227 | 
228 |         return $string;
229 |     }
230 | 
231 |     /**
232 |      * @param $functionName
233 |      */
234 |     public function set_callback($functionName)
235 |     {
236 |         $this::$callback = $functionName;
237 |     }
238 | 
239 |     public function clear()
240 |     {
241 |     }
242 | 
243 |     /**
244 |      * @param $name
245 |      *
246 |      * @return string
247 |      */
248 |     public function __get($name)
249 |     {
250 |         switch ($name) {
251 |             case 'outertext':
252 |                 return $this->html();
253 |             case 'innertext':
254 |                 return $this->innerHtml();
255 |             case 'plaintext':
256 |                 return $this->text();
257 |         }
258 | 
259 |         return null;
260 |     }
261 | 
262 |     /**
263 |      * @return mixed
264 |      */
265 |     public function __toString()
266 |     {
267 |         return $this->html();
268 |     }
269 | 
270 |     /**
271 |      * @param string $selector
272 |      * @param int    $idx
273 |      *
274 |      * @return Element|NodeList|null
275 |      */
276 |     public function __invoke($selector, $idx = null)
277 |     {
278 |         return $this->find($selector, $idx);
279 |     }
280 | 
281 |     /**
282 |      * @param $name
283 |      * @param $arguments
284 |      *
285 |      * @return bool|mixed
286 |      *
287 |      * @throws BadMethodCallException
288 |      */
289 |     public function __call($name, $arguments)
290 |     {
291 |         if (isset($this->functionAliases[$name])) {
292 |             return call_user_func_array([$this, $this->functionAliases[$name]], $arguments);
293 |         }
294 |         throw new BadMethodCallException('Method does not exist');
295 |     }
296 | 
297 |     /**
298 |      * @param $name
299 |      * @param $arguments
300 |      *
301 |      * @return bool|Document
302 |      *
303 |      * @throws BadMethodCallException
304 |      */
305 |     public static function __callStatic($name, $arguments)
306 |     {
307 |         if ($name === 'str_get_html') {
308 |             $document = new Document();
309 | 
310 |             return $document->loadHtml($arguments[0]);
311 |         }
312 | 
313 |         if ($name === 'file_get_html') {
314 |             $document = new Document();
315 | 
316 |             return $document->loadHtmlFile($arguments[0]);
317 |         }
318 |         throw new BadMethodCallException('Method does not exist');
319 |     }
320 | }
321 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # PHP Fast Simple HTML DOM Parser
  2 | 
  3 | [![Build Status](https://travis-ci.org/dimabdc/PHP-Fast-Simple-HTML-DOM-Parser.svg?branch=master)](https://travis-ci.org/dimabdc/PHP-Fast-Simple-HTML-DOM-Parser)
  4 | [![Total Downloads](https://poser.pugx.org/dimabdc/php-fast-simple-html-dom-parser/downloads)](https://packagist.org/packages/dimabdc/php-fast-simple-html-dom-parser)
  5 | [![Latest Stable Version](https://poser.pugx.org/dimabdc/php-fast-simple-html-dom-parser/v/stable)](https://packagist.org/packages/dimabdc/php-fast-simple-html-dom-parser)
  6 | [![License](https://poser.pugx.org/dimabdc/php-fast-simple-html-dom-parser/license)](https://packagist.org/packages/dimabdc/php-fast-simple-html-dom-parser)
  7 | 
  8 | PHP Fast Simple HTML DOM Parser - fast and low mamory usage HTML DOM Parser with syntax like PHP Simple HTML DOM Parser
  9 | 
 10 | ## Установка
 11 | 
 12 | Для установки выполните команду:
 13 | 
 14 |     composer require dimabdc/php-fast-simple-html-dom-parser
 15 | 
 16 | ## Быстрый старт
 17 | 
 18 | ```php    
 19 | require_once "vendor/autoload.php";
 20 | use FastSimpleHTMLDom\Document;
 21 | 
 22 | // Create DOM from URL
 23 | $html = Document::file_get_html('https://habrahabr.ru/interesting/');
 24 | 
 25 | // Find all post blocks
 26 | $post = [];
 27 | foreach($html->find('div.post') as $post) {
 28 |     $item['title']   = $post->find('h1.title', 0)->plaintext;
 29 |     $item['hubs']    = $post->find('div.hubs', 0)->plaintext;
 30 |     $item['content'] = $post->find('div.content', 0)->plaintext;
 31 |     $post[] = $item;
 32 | }
 33 | 
 34 | print_r($post);
 35 | ```
 36 | 
 37 | ## Как создать HTML DOM объект
 38 | 
 39 | ```php    
 40 | 
 41 | // Create a DOM object from a string
 42 | $html = new Document('<html><body>Hello!</body></html>');
 43 | 
 44 | // Create a DOM object from a string
 45 | $html = new Document();
 46 | $html->loadHtml('<html><body>Hello!</body></html>');
 47 | 
 48 | // Create a DOM object from a HTML file
 49 | $html = new Document();
 50 | $html->loadHtmlFile('test.htm');
 51 | 
 52 | // Create a DOM object from a URL
 53 | $html = new Document(file_get_contents('https://habrahabr.ru/interesting/'));
 54 | ```
 55 | 
 56 | ## Как искать HTML DOM элементы?
 57 | 
 58 | ### Основа
 59 | 
 60 | ```php    
 61 | 
 62 | // Find all anchors, returns a array of element objects
 63 | $ret = $html->find('a');
 64 | 
 65 | // Find (N)th anchor, returns element object or null if not found (zero based)
 66 | $ret = $html->find('a', 0);
 67 | 
 68 | // Find lastest anchor, returns element object or null if not found (zero based)
 69 | $ret = $html->find('a', -1); 
 70 | 
 71 | // Find all <div> with the id attribute
 72 | $ret = $html->find('div[id]');
 73 | 
 74 | // Find all <div> which attribute id=foo
 75 | $ret = $html->find('div[id=foo]'); 
 76 | ```
 77 | 
 78 | ### Часто используемое
 79 | 
 80 | ```php    
 81 | 
 82 | // Find all element which id=foo
 83 | $ret = $html->find('#foo');
 84 | 
 85 | // Find all element which class=foo
 86 | $ret = $html->find('.foo');
 87 | 
 88 | // Find all element has attribute id
 89 | $ret = $html->find('*[id]'); 
 90 | 
 91 | // Find all anchors and images 
 92 | $ret = $html->find('a, img'); 
 93 | 
 94 | // Find all anchors and images with the "title" attribute
 95 | $ret = $html->find('a[title], img[title]');
 96 | ```
 97 | 
 98 | ### Слекторы потомков
 99 | 
100 | ```php    
101 | 
102 | // Find all <li> in <ul> 
103 | $es = $html->find('ul li');
104 | 
105 | // Find Nested <div> tags
106 | $es = $html->find('div div div'); 
107 | 
108 | // Find all <td> in <table> which class=hello 
109 | $es = $html->find('table.hello td');
110 | 
111 | // Find all td tags with attribite align=center in table tags 
112 | $es = $html->find('table td[align=center]');
113 | ```
114 | 
115 | ### Вложенные селекторы
116 | 
117 | ```php    
118 | 
119 | // Find all <li> in <ul> 
120 | foreach($html->find('ul') as $ul) 
121 | {
122 |        foreach($ul->find('li') as $li) 
123 |        {
124 |              // do something...
125 |        }
126 | }
127 | 
128 | // Find first <li> in first <ul> 
129 | $e = $html->find('ul', 0)->find('li', 0);
130 | ```
131 | 
132 | ### Фильтр атрибутов
133 | 
134 | Filter	|Description
135 | ---|---
136 | [attribute]	|Matches elements that have the specified attribute.
137 | [!attribute]	|Matches elements that don't have the specified attribute.
138 | [attribute=value]	|Matches elements that have the specified attribute with a certain value.
139 | [attribute!=value]	|Matches elements that don't have the specified attribute with a certain value.
140 | [attribute^=value]	|Matches elements that have the specified attribute and it starts with a certain value.
141 | [attribute$=value]	|Matches elements that have the specified attribute and it ends with a certain value.
142 | [attribute*=value]	|Matches elements that have the specified attribute and it contains a certain value.
143 | 
144 | ### Текст, комментарии
145 | 
146 | ```php    
147 | 
148 | // Find all text blocks 
149 | $es = $html->find('text');
150 | 
151 | // Find all comment (<!--...-->) blocks 
152 | $es = $html->find('comment');
153 | ```
154 | 
155 | ## Доступ к атрибутам
156 | 
157 | ### Получение, установка и удаление атрибутов
158 | 
159 | ```php    
160 | 
161 | // Get a attribute ( If the attribute is non-value attribute (eg. checked, selected...), it will returns true or false)
162 | $value = $e->href;
163 | 
164 | // Set a attribute(If the attribute is non-value attribute (eg. checked, selected...), set it's value as true or false)
165 | $e->href = 'my link';
166 | 
167 | // Remove a attribute, set it's value as null! 
168 | $e->href = null;
169 | 
170 | // Determine whether a attribute exist? 
171 | if(isset($e->href)) 
172 |         echo 'href exist!';
173 | ```
174 | 
175 | ### "Магические" атрибуты
176 | 
177 | ```php    
178 | 
179 | // Example
180 | $html = str_get_html('<div>foo <b>bar</b></div>'); 
181 | $e = $html->find('div', 0);
182 | 
183 | echo $e->tag; // Returns: "div"
184 | echo $e->outertext; // Returns: "<div>foo <b>bar</b></div>"
185 | echo $e->innertext; // Returns: "foo <b>bar</b>"
186 | echo $e->plaintext; // Returns: "foo bar"
187 | ```
188 | 
189 | Attribute Name	|Usage
190 | ---|---
191 | $e->tag	|Read or write the tag name of element.
192 | $e->outertext	|Read or write the outer HTML text of element.
193 | $e->innertext	|Read or write the inner HTML text of element.
194 | $e->plaintext	|Read or write the plain text of element.
195 | 
196 | ### Трюки
197 | 
198 | ```php    
199 | 
200 | // Extract contents from HTML 
201 | echo $html->plaintext;
202 | 
203 | // Wrap a element
204 | $e->outertext = '<div class="wrap">' . $e->outertext . '<div>';
205 | 
206 | // Remove a element, set it's outertext as an empty string 
207 | $e->outertext = '';
208 | 
209 | // Append a element
210 | $e->outertext = $e->outertext . '<div>foo<div>';
211 | 
212 | // Insert a element
213 | $e->outertext = '<div>foo<div>' . $e->outertext;
214 | ```
215 | 
216 | ## Прогон по DOM-дереву
217 | 
218 | ```php    
219 | 
220 | // If you are not so familiar with HTML DOM, check this link to learn more... 
221 | 
222 | // Example
223 | echo $html->find('#div1', 0)->children(1)->children(1)->children(2)->id;
224 | // or 
225 | echo $html->getElementById('div1')->childNodes(1)->childNodes(1)->childNodes(2)->getAttribute('id');
226 | ```
227 | 
228 | Method	|Description
229 | ---|---
230 | `mixed` $e->children([int $index])	|Returns the Nth child object if index is set, otherwise return an array of children.
231 | `Element` $e->parent()	|Returns the parent of element.
232 | `Element` $e->first_child()	|Returns the first child of element, or null if not found.
233 | `Element` $e->last_child()	|Returns the last child of element, or null if not found.
234 | `Element` $e->next_sibling()	|Returns the next sibling of element, or null if not found.
235 | `Element` $e->prev_sibling()	|Returns the previous sibling of element, or null if not found.
236 | 
237 | ## API-справочник
238 | 
239 | ### Методы и свойства DOM
240 | 
241 | Name	|Description
242 | ---|---
243 | `void` __construct([string|Element $html])	|Constructor $html is text or Element.
244 | `string` plaintext	|Returns the contents extracted from HTML.
245 | `mixed` find (string $selector [, int $index])	|Find elements by the CSS selector. Returns the Nth element object if index is set, otherwise return an array of object.
246 | 
247 | ### Методы и свойства элементов
248 | 
249 | Name	|Description
250 | ---|---
251 | `string` [attribute]	|Read or write element's attribure value.
252 | `string` tag	|Read or write the tag name of element.
253 | `string` outertext	|Read or write the outer HTML text of element.
254 | `string` innertext	|Read or write the inner HTML text of element.
255 | `string` plaintext	|Read or write the plain text of element.
256 | `mixed` find (string $selector [, int $index])	|Find children by the CSS selector. Returns the Nth element object if index is set, otherwise, return an array of object.
257 | 
258 | ### Прогон по дереву DOM
259 | 
260 | Name	|Description
261 | ---|---
262 | `mixed` $e->children([int $index])	|Returns the Nth child object if index is set, otherwise return an array of children.
263 | `element` $e->parent()	|Returns the parent of element.
264 | `element` $e->first_child()	|Returns the first child of element, or null if not found.
265 | `element` $e->last_child()	|Returns the last child of element, or null if not found.
266 | `element` $e->next_sibling()	|Returns the next sibling of element, or null if not found.
267 | `element` $e->prev_sibling()	|Returns the previous sibling of element, or null if not found.
268 | 
269 | ### camelCase эквиваленты
270 | 
271 | ```php    
272 | 
273 | string $e->getAttribute($name)
274 | string $e->attribute
275 | 
276 | void $e->setAttribute($name, $value)
277 | void $value = $e->attribute
278 | 
279 | bool $e->hasAttribute($name)
280 | bool isset($e->attribute)
281 | 
282 | void $e->removeAttribute($name)
283 | void $e->attribute = null
284 | 
285 | element $e->getElementById($id)
286 | mixed $e->find("#$id", 0)
287 | 
288 | mixed $e->getElementsById($id [,$index])
289 | mixed $e->find("#$id" [, int $index])
290 | 
291 | element $e->getElementByTagName($name)
292 | mixed $e->find($name, 0)
293 | 
294 | mixed $e->getElementsByTagName($name [, $index])
295 | mixed $e->find($name [, int $index])
296 | 
297 | element $e->parentNode()
298 | element $e->parent()
299 | 
300 | mixed $e->childNodes([$index])
301 | mixed $e->children([int $index])
302 | 
303 | element $e->firstChild()
304 | element $e->first_child()
305 | 
306 | element $e->lastChild()
307 | element $e->last_child()
308 | 
309 | element $e->nextSibling()
310 | element $e->next_sibling()
311 | 
312 | element $e->previousSibling()
313 | element $e->prev_sibling()
314 | ```
315 | 


--------------------------------------------------------------------------------
/lib/Element.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace FastSimpleHTMLDom;
  4 | 
  5 | use BadMethodCallException;
  6 | use DOMElement;
  7 | use DOMNode;
  8 | use DOMText;
  9 | use RuntimeException;
 10 | 
 11 | /**
 12 |  * Class Element
 13 |  *
 14 |  * @package FastSimpleHTMLDom
 15 |  * @property string      outertext Get dom node's outer html
 16 |  * @property string      innertext Get dom node's inner html
 17 |  * @property string      plaintext Get dom node's plain text
 18 |  * @property-read string tag       Get dom node name
 19 |  * @property-read string attr      Get dom node attributes
 20 |  *
 21 |  * @method NodeList|Element|null children() children($idx = -1) Returns children of node
 22 |  * @method Element|null first_child() Returns the first child of node
 23 |  * @method Element|null last_child() Returns the last child of node
 24 |  * @method Element|null next_sibling() Returns the next sibling of node
 25 |  * @method Element|null prev_sibling() Returns the previous sibling of node
 26 |  * @method Element|null parent() Returns the parent of node
 27 |  * @method string outertext() Get dom node's outer html
 28 |  * @method string innertext() Get dom node's inner html
 29 |  */
 30 | class Element implements \IteratorAggregate
 31 | {
 32 |     /**
 33 |      * @var DOMElement
 34 |      */
 35 |     protected $node;
 36 | 
 37 |     /**
 38 |      * @var array
 39 |      */
 40 |     protected $functionAliases = [
 41 |         'children'     => 'childNodes',
 42 |         'first_child'  => 'firstChild',
 43 |         'last_child'   => 'lastChild',
 44 |         'next_sibling' => 'nextSibling',
 45 |         'prev_sibling' => 'previousSibling',
 46 |         'parent'       => 'parentNode',
 47 |         'outertext'    => 'html',
 48 |         'innertext'    => 'innerHtml',
 49 |     ];
 50 | 
 51 | 
 52 |     public function __construct(DOMNode $node)
 53 |     {
 54 |         $this->node = $node;
 55 |     }
 56 | 
 57 |     /**
 58 |      * @return DOMNode
 59 |      */
 60 |     public function getNode()
 61 |     {
 62 |         return $this->node;
 63 |     }
 64 | 
 65 |     /**
 66 |      * Replace this node
 67 |      *
 68 |      * @param $string
 69 |      *
 70 |      * @return $this
 71 |      *
 72 |      * @throws RuntimeException
 73 |      */
 74 |     protected function replaceNode($string)
 75 |     {
 76 |         $importNodeList = NodeList::fromString($string);
 77 | 
 78 |         if ($importNodeList->count() > 1) {
 79 |             throw new RuntimeException('Not valid HTML fragment. String contains more one root node');
 80 |         }
 81 | 
 82 |         if ($importNodeList->count() === 0) {
 83 |             $this->node->parentNode->removeChild($this->node);
 84 |             $this->node = new DOMText();
 85 |             return null;
 86 |         }
 87 | 
 88 |         $newNode = $this->node->ownerDocument->importNode($importNodeList[0]->getNode(), true);
 89 | 
 90 |         $this->node->parentNode->replaceChild($newNode, $this->node);
 91 |         $this->node = $newNode;
 92 | 
 93 |         return $this;
 94 |     }
 95 | 
 96 |     /**
 97 |      * Replace child node
 98 |      *
 99 |      * @param $string
100 |      *
101 |      * @return $this
102 |      */
103 |     protected function replaceChild($string)
104 |     {
105 |         $importNodeList = NodeList::fromString($string);
106 | 
107 |         foreach ($this->node->childNodes as $node) {
108 |             $this->node->removeChild($node);
109 |         }
110 | 
111 |         foreach ($importNodeList as $importNode) {
112 |             $newNode = $this->node->ownerDocument->importNode($importNode->getNode(), true);
113 |             $this->node->appendChild($newNode);
114 |         }
115 | 
116 |         $this->node->normalize();
117 | 
118 |         return $this;
119 |     }
120 | 
121 |     /**
122 |      * Replace this node with text
123 |      *
124 |      * @param $string
125 |      *
126 |      * @return $this
127 |      */
128 |     protected function replaceText($string)
129 |     {
130 |         if (empty($string)) {
131 |             $this->node->parentNode->removeChild($this->node);
132 | 
133 |             return null;
134 |         }
135 | 
136 |         $newElement = $this->node->ownerDocument->createTextNode($string);
137 | 
138 |         $newNode = $this->node->ownerDocument->importNode($newElement, true);
139 | 
140 |         $this->node->parentNode->replaceChild($newNode, $this->node);
141 |         $this->node = $newNode;
142 | 
143 |         return $this;
144 |     }
145 | 
146 |     /**
147 |      * @return Document
148 |      */
149 |     public function getDom()
150 |     {
151 |         return new Document($this);
152 |     }
153 | 
154 |     /**
155 |      * Find list of nodes with a CSS selector
156 |      *
157 |      * @param string $selector
158 |      * @param int $idx
159 |      *
160 |      * @return NodeList|Element|null
161 |      */
162 |     public function find($selector, $idx = null)
163 |     {
164 |         return $this->getDom()->find($selector, $idx);
165 |     }
166 | 
167 |     /**
168 |      * Return Element by id
169 |      *
170 |      * @param $id
171 |      *
172 |      * @return Element|null
173 |      */
174 |     public function getElementById($id)
175 |     {
176 |         return $this->find("#$id", 0);
177 |     }
178 | 
179 |     /**
180 |      * Returns Elements by id
181 |      *
182 |      * @param      $id
183 |      * @param null $idx
184 |      *
185 |      * @return Element|NodeList|null
186 |      */
187 |     public function getElementsById($id, $idx = null)
188 |     {
189 |         return $this->find("#$id", $idx);
190 |     }
191 | 
192 |     /**
193 |      * Return Element by tag name
194 |      *
195 |      * @param $name
196 |      *
197 |      * @return Element|null
198 |      */
199 |     public function getElementByTagName($name)
200 |     {
201 |         return $this->find($name, 0);
202 |     }
203 | 
204 |     /**
205 |      * Returns Elements by tag name
206 |      *
207 |      * @param      $name
208 |      * @param null $idx
209 |      *
210 |      * @return Element|NodeList|null
211 |      */
212 |     public function getElementsByTagName($name, $idx = null)
213 |     {
214 |         return $this->find($name, $idx);
215 |     }
216 | 
217 |     /**
218 |      * Returns children of node
219 |      *
220 |      * @param int $idx
221 |      *
222 |      * @return NodeList|Element|null
223 |      */
224 |     public function childNodes($idx = -1)
225 |     {
226 |         $nodeList = $this->getIterator();
227 | 
228 |         if ($idx === -1) {
229 |             return $nodeList;
230 |         }
231 | 
232 |         if (isset($nodeList[$idx])) {
233 |             return $nodeList[$idx];
234 |         }
235 | 
236 |         return null;
237 |     }
238 | 
239 |     /**
240 |      * Returns the first child of node
241 |      *
242 |      * @return Element|null
243 |      */
244 |     public function firstChild()
245 |     {
246 |         $node = $this->node->firstChild;
247 | 
248 |         if ($node === null) {
249 |             return null;
250 |         }
251 | 
252 |         return new Element($node);
253 |     }
254 | 
255 |     /**
256 |      * Returns the last child of node
257 |      *
258 |      * @return Element|null
259 |      */
260 |     public function lastChild()
261 |     {
262 |         $node = $this->node->lastChild;
263 | 
264 |         if ($node === null) {
265 |             return null;
266 |         }
267 | 
268 |         return new Element($node);
269 |     }
270 | 
271 |     /**
272 |      * Returns the next sibling of node
273 |      *
274 |      * @return Element|null
275 |      */
276 |     public function nextSibling()
277 |     {
278 |         $node = $this->node->nextSibling;
279 | 
280 |         if ($node === null) {
281 |             return null;
282 |         }
283 | 
284 |         return new Element($node);
285 |     }
286 | 
287 |     /**
288 |      * Returns the previous sibling of node
289 |      *
290 |      * @return Element|null
291 |      */
292 |     public function previousSibling()
293 |     {
294 |         $node = $this->node->previousSibling;
295 | 
296 |         if ($node === null) {
297 |             return null;
298 |         }
299 | 
300 |         return new Element($node);
301 |     }
302 | 
303 |     /**
304 |      * Returns the parent of node
305 |      *
306 |      * @return Element
307 |      */
308 |     public function parentNode()
309 |     {
310 |         return new Element($this->node->parentNode);
311 |     }
312 | 
313 |     /**
314 |      * Get dom node's outer html
315 |      *
316 |      * @return string
317 |      */
318 |     public function html()
319 |     {
320 |         return $this->getDom()->html();
321 |     }
322 | 
323 |     /**
324 |      * Get dom node's inner html
325 |      *
326 |      * @return string
327 |      */
328 |     public function innerHtml()
329 |     {
330 |         return $this->getDom()->innerHtml();
331 |     }
332 | 
333 |     /**
334 |      * Get dom node's plain text
335 |      *
336 |      * @return string
337 |      */
338 |     public function text()
339 |     {
340 |         return $this->node->textContent;
341 |     }
342 | 
343 |     /**
344 |      * Returns array of attributes
345 |      *
346 |      * @return array|null
347 |      */
348 |     public function getAllAttributes()
349 |     {
350 |         if ($this->node->hasAttributes()) {
351 |             $attributes = [];
352 |             foreach ($this->node->attributes as $attr) {
353 |                 $attributes[$attr->name] = $attr->value;
354 |             }
355 | 
356 |             return $attributes;
357 |         }
358 | 
359 |         return null;
360 |     }
361 | 
362 |     /**
363 |      * Return attribute value
364 |      *
365 |      * @param string $name
366 |      *
367 |      * @return string|null
368 |      */
369 |     public function getAttribute($name)
370 |     {
371 |         return $this->node->getAttribute($name);
372 |     }
373 | 
374 |     /**
375 |      * Set attribute value
376 |      *
377 |      * @param $name
378 |      * @param $value
379 |      *
380 |      * @return $this
381 |      */
382 |     public function setAttribute($name, $value)
383 |     {
384 |         if (empty($value)) {
385 |             $this->node->removeAttribute($name);
386 |         } else {
387 |             $this->node->setAttribute($name, $value);
388 |         }
389 | 
390 |         return $this;
391 |     }
392 | 
393 |     /**
394 |      * Determine if an attribute exists on the element.
395 |      *
396 |      * @param $name
397 |      *
398 |      * @return bool
399 |      */
400 |     public function hasAttribute($name)
401 |     {
402 |         return $this->node->hasAttribute($name);
403 |     }
404 | 
405 |     /**
406 |      * @param $name
407 |      *
408 |      * @return array|null|string
409 |      */
410 |     public function __get($name)
411 |     {
412 |         switch ($name) {
413 |             case 'outertext':
414 |                 return $this->html();
415 |             case 'innertext':
416 |                 return $this->innerHtml();
417 |             case 'plaintext':
418 |                 return $this->text();
419 |             case 'tag'      :
420 |                 return $this->node->nodeName;
421 |             case 'attr'     :
422 |                 return $this->getAllAttributes();
423 |             default         :
424 |                 return $this->getAttribute($name);
425 |         }
426 |     }
427 | 
428 |     public function __set($name, $value)
429 |     {
430 |         switch ($name) {
431 |             case 'outertext':
432 |                 return $this->replaceNode($value);
433 |             case 'innertext':
434 |                 return $this->replaceChild($value);
435 |             case 'plaintext':
436 |                 return $this->replaceText($value);
437 |             default         :
438 |                 return $this->setAttribute($name, $value);
439 |         }
440 |     }
441 | 
442 |     /**
443 |      * @param $name
444 |      *
445 |      * @return bool
446 |      */
447 |     public function __isset($name)
448 |     {
449 |         switch ($name) {
450 |             case 'outertext':
451 |             case 'innertext':
452 |             case 'plaintext':
453 |             case 'tag'      :
454 |                 return true;
455 |             default         :
456 |                 return $this->hasAttribute($name);
457 |         }
458 |     }
459 | 
460 |     public function __unset($name)
461 |     {
462 |         return $this->setAttribute($name, null);
463 |     }
464 | 
465 |     /**
466 |      * @return mixed
467 |      */
468 |     public function __toString()
469 |     {
470 |         return $this->html();
471 |     }
472 | 
473 |     /**
474 |      * @param string $selector
475 |      * @param int $idx
476 |      *
477 |      * @return Element|NodeList|null
478 |      */
479 |     public function __invoke($selector, $idx = null)
480 |     {
481 |         return $this->find($selector, $idx);
482 |     }
483 | 
484 |     /**
485 |      * @param $name
486 |      * @param $arguments
487 |      *
488 |      * @return null|string|Element
489 |      *
490 |      * @throws BadMethodCallException
491 |      */
492 |     public function __call($name, $arguments)
493 |     {
494 |         if (isset($this->functionAliases[$name])) {
495 |             return call_user_func_array([$this, $this->functionAliases[$name]], $arguments);
496 |         }
497 |         throw new BadMethodCallException('Method does not exist');
498 |     }
499 | 
500 |     /**
501 |      * Retrieve an external iterator
502 |      *
503 |      * @link  http://php.net/manual/en/iteratoraggregate.getiterator.php
504 |      * @return NodeList An instance of an object implementing <b>Iterator</b> or
505 |      * <b>Traversable</b>
506 |      * @since 5.0.0
507 |      */
508 |     public function getIterator()
509 |     {
510 |         $elements = new NodeList();
511 |         if ($this->node->hasChildNodes()) {
512 |             foreach ($this->node->childNodes as $node) {
513 |                 $elements[] = new Element($node);
514 |             }
515 |         }
516 | 
517 |         return $elements;
518 |     }
519 | }
520 | 


--------------------------------------------------------------------------------
/tests/FastSimpleHTMLDom/ElementTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Tests\FastSimpleHTMLDom;
  4 | 
  5 | use FastSimpleHTMLDom\Document;
  6 | use FastSimpleHTMLDom\Element;
  7 | use RuntimeException;
  8 | use Tests\TestCase;
  9 | use FastSimpleHTMLDom\NodeList;
 10 | 
 11 | class ElementTest extends TestCase
 12 | {
 13 |     public function testConstructor()
 14 |     {
 15 |         $html = '<input name="username" value="John">User name</input>';
 16 | 
 17 |         $document = new Document($html);
 18 |         $node = $document->getDocument()->documentElement;
 19 | 
 20 |         $element = new Element($node);
 21 | 
 22 |         $this->assertEquals('input', $element->tag);
 23 |         $this->assertEquals('User name', $element->plaintext);
 24 |         $this->assertEquals('username', $element->name);
 25 |         $this->assertEquals('John', $element->value);
 26 |     }
 27 | 
 28 |     public function testGetNode()
 29 |     {
 30 |         $html = '<div>foo</div>';
 31 | 
 32 |         $document = new Document($html);
 33 |         $node = $document->getDocument()->documentElement;
 34 |         $element = new Element($node);
 35 | 
 36 |         $this->assertInstanceOf('DOMNode', $element->getNode());
 37 |     }
 38 | 
 39 |     /**
 40 |      * @dataProvider replaceNodeDataProvider
 41 |      *
 42 |      * @param string $replace
 43 |      */
 44 |     public function testReplaceNode($replace)
 45 |     {
 46 |         $html = '<div>foo</div>';
 47 | 
 48 |         $document = new Document($html);
 49 |         $node = $document->getDocument()->documentElement;
 50 |         $element = new Element($node);
 51 |         $element->outertext = $replace;
 52 | 
 53 |         $this->assertEquals($replace, $document->outertext);
 54 |         $this->assertEquals($replace, $element->outertext);
 55 |     }
 56 | 
 57 |     public function replaceNodeDataProvider()
 58 |     {
 59 |         return [
 60 |             [
 61 |                 '<h1>bar</h1>',
 62 |             ],
 63 |             [
 64 |                 '',
 65 |             ],
 66 |             [
 67 |                 'foo',
 68 |             ],
 69 |         ];
 70 |     }
 71 | 
 72 |     public function testReplaceNodeManyRootNodesException()
 73 |     {
 74 |         $this->expectException(RuntimeException::class);
 75 |         $this->expectExceptionMessage('Not valid HTML fragment. String contains more one root node');
 76 | 
 77 |         $html = '<div>foo</div>';
 78 |         $replace = 'foo<h1>bar</h1>';
 79 | 
 80 |         $document = new Document($html);
 81 |         $node = $document->getDocument()->documentElement;
 82 |         $element = new Element($node);
 83 |         $element->outertext = $replace;
 84 |     }
 85 | 
 86 |     public function testReplaceChild()
 87 |     {
 88 |         $html = '<div><p>foo</p></div>';
 89 |         $replace = '<h1>bar</h1>';
 90 | 
 91 |         $document = new Document($html);
 92 |         $node = $document->getDocument()->documentElement;
 93 |         $element = new Element($node);
 94 |         $element->innertext = $replace;
 95 | 
 96 |         $this->assertEquals('<div><h1>bar</h1></div>', $document->outertext);
 97 |         $this->assertEquals('<div><h1>bar</h1></div>', $element->outertext);
 98 |     }
 99 | 
100 |     public function testReplaceText()
101 |     {
102 |         $html = '<div>foo</div>';
103 |         $replace = '<h1>bar</h1>';
104 | 
105 |         $document = new Document($html);
106 |         $node = $document->getDocument()->documentElement;
107 |         $element = new Element($node);
108 |         $element->plaintext = $replace;
109 | 
110 |         $this->assertEquals('&lt;h1&gt;bar&lt;/h1&gt;', $document->outertext);
111 |         $this->assertEquals($replace, $document->plaintext);
112 |         $this->assertEquals('&lt;h1&gt;bar&lt;/h1&gt;', $element->outertext);
113 |         $this->assertEquals($replace, $element->plaintext);
114 | 
115 |         $element->plaintext = '';
116 | 
117 |         $this->assertEquals('', $document->outertext);
118 |         $this->assertEquals('', $document->plaintext);
119 |     }
120 | 
121 |     public function testGetDom()
122 |     {
123 |         $html = '<div><p>foo</p></div>';
124 | 
125 |         $document = new Document($html);
126 |         $node = $document->getDocument()->documentElement;
127 |         $element = new Element($node);
128 | 
129 |         $this->assertInstanceOf(Document::class, $element->getDom());
130 |     }
131 | 
132 |     /**
133 |      * @dataProvider findTestsDataProvider
134 |      */
135 |     public function testFind($html, $selector, $count)
136 |     {
137 |         $document = new Document($html);
138 |         $element = new Element($document->getDocument()->documentElement);
139 | 
140 |         $elements = $element->find($selector);
141 | 
142 |         $this->assertInstanceOf(NodeList::class, $elements);
143 |         $this->assertCount($count, $elements);
144 | 
145 |         foreach ($elements as $id => $node) {
146 |             $this->assertInstanceOf(Element::class, $node);
147 |         }
148 | 
149 |         $elements = $element($selector);
150 | 
151 |         $this->assertInstanceOf(NodeList::class, $elements);
152 |     }
153 | 
154 |     public function findTestsDataProvider()
155 |     {
156 |         $html = $this->loadFixture('testpage.html');
157 |         return array(
158 |             array($html, '.fake h2', 0),
159 |             array($html, 'article', 16),
160 |             array($html, '.radio', 3),
161 |             array($html, 'input.radio', 3),
162 |             array($html, 'ul li', 35),
163 |             array($html, 'fieldset#forms__checkbox li, fieldset#forms__radio li', 6),
164 |             array($html, 'input[id]', 23),
165 |             array($html, 'input[id=in]', 1),
166 |             array($html, '#in', 1),
167 |             array($html, '*[id]', 52),
168 |             array($html, 'text', 234),
169 |             array($html, 'comment', 3),
170 |         );
171 |     }
172 | 
173 |     public function testGetElementById()
174 |     {
175 |         $html = $this->loadFixture('testpage.html');
176 | 
177 |         $document = new Document($html);
178 |         $element = new Element($document->getDocument()->documentElement);
179 | 
180 |         $node = $element->getElementById('in');
181 | 
182 |         $this->assertInstanceOf(Element::class, $node);
183 |         $this->assertEquals('input', $node->tag);
184 |         $this->assertEquals('number', $node->type);
185 |         $this->assertEquals('5', $node->value);
186 |     }
187 | 
188 |     public function testGetElementByTagName()
189 |     {
190 |         $html = $this->loadFixture('testpage.html');
191 | 
192 |         $document = new Document($html);
193 |         $element = new Element($document->getDocument()->documentElement);
194 | 
195 |         $node = $element->getElementByTagName('div');
196 | 
197 |         $this->assertInstanceOf(Element::class, $node);
198 |         $this->assertEquals('div', $node->tag);
199 |         $this->assertEquals('top', $node->id);
200 |         $this->assertEquals('page', $node->class);
201 |     }
202 | 
203 |     public function testGetElementsByTagName()
204 |     {
205 |         $html = $this->loadFixture('testpage.html');
206 | 
207 |         $document = new Document($html);
208 |         $element = new Element($document->getDocument()->documentElement);
209 | 
210 |         $elements = $element->getElementsByTagName('div');
211 | 
212 |         $this->assertInstanceOf(NodeList::class, $elements);
213 |         $this->assertCount(16, $elements);
214 | 
215 |         foreach ($elements as $node) {
216 |             $this->assertInstanceOf(Element::class, $node);
217 |         }
218 |     }
219 | 
220 |     public function testChildNodes()
221 |     {
222 |         $html = '<div><p>foo</p><p>bar</p></div>';
223 | 
224 |         $document = new Document($html);
225 |         $element = new Element($document->getDocument()->documentElement);
226 | 
227 |         $nodes = $element->childNodes();
228 | 
229 |         $this->assertInstanceOf(NodeList::class, $nodes);
230 |         $this->assertCount(2, $nodes);
231 | 
232 |         foreach ($nodes as $node) {
233 |             $this->assertInstanceOf(Element::class, $node);
234 |         }
235 | 
236 |         $node = $element->childNodes(1);
237 | 
238 |         $this->assertInstanceOf(Element::class, $node);
239 | 
240 |         $this->assertEquals('<p>bar</p>', $node->outertext);
241 |         $this->assertEquals('bar', $node->plaintext);
242 | 
243 |         $node = $element->childNodes(2);
244 |         $this->assertNull($node);
245 |     }
246 | 
247 |     public function testChildren()
248 |     {
249 |         $html = '<div><p>foo</p><p>bar</p></div>';
250 | 
251 |         $document = new Document($html);
252 |         $element = new Element($document->getDocument()->documentElement);
253 | 
254 |         $nodes = $element->children();
255 | 
256 |         $this->assertInstanceOf(NodeList::class, $nodes);
257 |         $this->assertCount(2, $nodes);
258 | 
259 |         foreach ($nodes as $node) {
260 |             $this->assertInstanceOf(Element::class, $node);
261 |         }
262 | 
263 |         $node = $element->children(1);
264 | 
265 |         $this->assertInstanceOf(Element::class, $node);
266 | 
267 |         $this->assertEquals('<p>bar</p>', $node->outertext);
268 |         $this->assertEquals('bar', $node->plaintext);
269 |     }
270 | 
271 |     public function testFirstChild()
272 |     {
273 |         $html = '<div><p>foo</p><p></p></div>';
274 | 
275 |         $document = new Document($html);
276 |         $element = new Element($document->getDocument()->documentElement);
277 | 
278 |         $node = $element->firstChild();
279 | 
280 |         $this->assertInstanceOf(Element::class, $node);
281 |         $this->assertEquals('<p>foo</p>', $node->outertext);
282 |         $this->assertEquals('foo', $node->plaintext);
283 | 
284 |         $node = $element->lastChild();
285 | 
286 |         $this->assertNull($node->firstChild());
287 |         $this->assertNull($node->first_child());
288 |     }
289 | 
290 |     public function testLastChild()
291 |     {
292 |         $html = '<div><p></p><p>bar</p></div>';
293 | 
294 |         $document = new Document($html);
295 |         $element = new Element($document->getDocument()->documentElement);
296 | 
297 |         $node = $element->lastChild();
298 | 
299 |         $this->assertInstanceOf(Element::class, $node);
300 |         $this->assertEquals('<p>bar</p>', $node->outertext);
301 |         $this->assertEquals('bar', $node->plaintext);
302 | 
303 |         $node = $element->firstChild();
304 | 
305 |         $this->assertNull($node->lastChild());
306 |         $this->assertNull($node->last_child());
307 |     }
308 | 
309 |     public function testNextSibling()
310 |     {
311 |         $html = '<div><p>foo</p><p>bar</p></div>';
312 | 
313 |         $document = new Document($html);
314 |         $element = new Element($document->getDocument()->documentElement);
315 | 
316 |         $node = $element->firstChild();
317 |         $sibling = $node->nextSibling();
318 | 
319 |         $this->assertInstanceOf(Element::class, $sibling);
320 |         $this->assertEquals('<p>bar</p>', $sibling->outertext);
321 |         $this->assertEquals('bar', $sibling->plaintext);
322 | 
323 |         $node = $element->lastChild();
324 | 
325 |         $this->assertNull($node->nextSibling());
326 |         $this->assertNull($node->next_sibling());
327 |     }
328 | 
329 |     public function testPreviousSibling()
330 |     {
331 |         $html = '<div><p>foo</p><p>bar</p></div>';
332 | 
333 |         $document = new Document($html);
334 |         $element = new Element($document->getDocument()->documentElement);
335 | 
336 |         $node = $element->lastChild();
337 |         $sibling = $node->previousSibling();
338 | 
339 |         $this->assertInstanceOf(Element::class, $sibling);
340 |         $this->assertEquals('<p>foo</p>', $sibling->outertext);
341 |         $this->assertEquals('foo', $sibling->plaintext);
342 | 
343 |         $node = $element->firstChild();
344 | 
345 |         $this->assertNull($node->previousSibling());
346 |         $this->assertNull($node->prev_sibling());
347 |     }
348 | 
349 |     public function testParentNode()
350 |     {
351 |         $html = '<div><p>foo</p><p>bar</p></div>';
352 | 
353 |         $document = new Document($html);
354 |         $element = $document->find('p', 0);
355 | 
356 |         $node = $element->parentNode();
357 | 
358 |         $this->assertInstanceOf(Element::class, $node);
359 |         $this->assertEquals('div', $node->tag);
360 |         $this->assertEquals('div', $element->parent()->tag);
361 |     }
362 | 
363 |     public function testHtml()
364 |     {
365 |         $html = '<div>foo</div>';
366 |         $document = new Document($html);
367 |         $element = new Element($document->getDocument()->documentElement);
368 | 
369 |         $this->assertEquals($html, $element->html());
370 |         $this->assertEquals($html, $element->outertext());
371 |         $this->assertEquals($html, $element->outertext);
372 |         $this->assertEquals($html, (string)$element);
373 |     }
374 | 
375 |     public function testInnerHtml()
376 |     {
377 |         $html = '<div><div>foo</div></div>';
378 |         $document = new Document($html);
379 |         $element = new Element($document->getDocument()->documentElement);
380 | 
381 |         $this->assertEquals('<div>foo</div>', $element->innerHtml());
382 |         $this->assertEquals('<div>foo</div>', $element->innertext());
383 |         $this->assertEquals('<div>foo</div>', $element->innertext);
384 |     }
385 | 
386 |     public function testText()
387 |     {
388 |         $html = '<div>foo</div>';
389 |         $document = new Document($html);
390 |         $element = new Element($document->getDocument()->documentElement);
391 | 
392 |         $this->assertEquals('foo', $element->text());
393 |         $this->assertEquals('foo', $element->plaintext);
394 |     }
395 | 
396 |     public function testGetAllAttributes()
397 |     {
398 |         $attr = ['class' => 'post', 'id' => 'p1'];
399 |         $html = '<html><div class="post" id="p1">foo</div><div>bar</div></html>';
400 | 
401 |         $document = new Document($html);
402 | 
403 |         $element = $document->find('div', 0);
404 |         $this->assertEquals($attr, $element->getAllAttributes());
405 | 
406 |         $element = $document->find('div', 1);
407 |         $this->assertNull($element->getAllAttributes());
408 |     }
409 | 
410 |     public function testGetAttribute()
411 |     {
412 |         $html = '<div class="post" id="p1">foo</div>';
413 | 
414 |         $document = new Document($html);
415 |         $element = $document->find('div', 0);
416 | 
417 |         $this->assertEquals('post', $element->getAttribute('class'));
418 |         $this->assertEquals('post', $element->class);
419 |         $this->assertEquals('p1', $element->getAttribute('id'));
420 |         $this->assertEquals('p1', $element->id);
421 |     }
422 | 
423 |     public function testSetAttribute()
424 |     {
425 |         $html = '<div class="post" id="p1">foo</div>';
426 | 
427 |         $document = new Document($html);
428 |         $element = $document->find('div', 0);
429 | 
430 |         $element->setAttribute('id', 'bar');
431 |         $element->data = 'value';
432 |         unset($element->class);
433 | 
434 |         $this->assertEquals('bar', $element->getAttribute('id'));
435 |         $this->assertEquals('value', $element->getAttribute('data'));
436 |         $this->assertEmpty($element->getAttribute('class'));
437 |     }
438 | 
439 |     public function testHasAttribute()
440 |     {
441 |         $html = '<div class="post" id="p1">foo</div>';
442 | 
443 |         $document = new Document($html);
444 |         $element = $document->find('div', 0);
445 | 
446 |         $this->assertTrue($element->hasAttribute('class'));
447 |         $this->assertInstanceOf(Element::class, $element);
448 |         /** @noinspection MissingIssetImplementationInspection */
449 |         $this->assertTrue(isset($element->id));
450 |     }
451 | }
452 | 


--------------------------------------------------------------------------------
/tests/fixtures/testpage.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html lang="en">
  3 | <head>
  4 |     <meta charset="utf-8">
  5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6 |     <title>HTML5 Test Page</title>
  7 | </head>
  8 | <body>
  9 | <div id="top" class="page" role="document">
 10 |     <header role="banner">
 11 |         <h1>HTML5 Test Page</h1>
 12 |         <p>This is a test page filled with common HTML elements to be used to provide visual feedback whilst building CSS systems and frameworks.</p>
 13 |     </header>
 14 |     <!-- Navigation -->
 15 |     <nav role="navigation">
 16 |         <ul>
 17 |             <li>
 18 |                 <a href="#text">Text</a>
 19 |                 <ul>
 20 |                     <li><a href="#text__headings">Headings</a></li>
 21 |                     <li><a href="#text__paragraphs">Paragraphs</a></li>
 22 |                     <li><a href="#text__blockquotes">Blockquotes</a></li>
 23 |                     <li><a href="#text__lists">Lists</a></li>
 24 |                     <li><a href="#text__hr">Horizontal rules</a></li>
 25 |                     <li><a href="#text__tables">Tabular data</a></li>
 26 |                     <li><a href="#text__code">Code</a></li>
 27 |                     <li><a href="#text__inline">Inline elements</a></li>
 28 |                 </ul>
 29 |             </li>
 30 |             <li>
 31 |                 <a href="#embedded">Embedded content</a>
 32 |                 <ul>
 33 |                     <li><a href="#embedded__images">Images</a></li>
 34 |                     <li><a href="#embedded__audio">Audio</a></li>
 35 |                     <li><a href="#embedded__video">Video</a></li>
 36 |                     <li><a href="#embedded__canvas">Canvas</a></li>
 37 |                     <li><a href="#embedded__meter">Meter</a></li>
 38 |                     <li><a href="#embedded__progress">Progress</a></li>
 39 |                     <li><a href="#embedded__svg">Inline SVG</a></li>
 40 |                     <li><a href="#embedded__iframe">IFrames</a></li>
 41 |                 </ul>
 42 |             </li>
 43 |             <li>
 44 |                 <a href="#forms">Form elements</a>
 45 |                 <ul>
 46 |                     <li><a href="#forms__input">Input fields</a></li>
 47 |                     <li><a href="#forms__select">Select menus</a></li>
 48 |                     <li><a href="#forms__checkbox">Checkboxes</a></li>
 49 |                     <li><a href="#forms__radio">Radio buttons</a></li>
 50 |                     <li><a href="#forms__textareas">Textareas</a></li>
 51 |                     <li><a href="#forms__html5">HTML5 inputs</a></li>
 52 |                     <li><a href="#forms__action">Action buttons</a></li>
 53 |                 </ul>
 54 |             </li>
 55 |         </ul>
 56 |     </nav>
 57 |     <!-- Main -->
 58 |     <main role="main">
 59 |         <section id="text">
 60 |             <header><h1>Text</h1></header>
 61 |             <article id="text__headings">
 62 |                 <header>
 63 |                     <h1>Headings</h1>
 64 |                 </header>
 65 |                 <div>
 66 |                     <h1>Heading 1</h1>
 67 |                     <h2>Heading 2</h2>
 68 |                     <h3>Heading 3</h3>
 69 |                     <h4>Heading 4</h4>
 70 |                     <h5>Heading 5</h5>
 71 |                     <h6>Heading 6</h6>
 72 |                 </div>
 73 |                 <footer><p><a href="#top">[Top]</a></p></footer>
 74 |             </article>
 75 |             <article id="text__paragraphs">
 76 |                 <header><h1>Paragraphs</h1></header>
 77 |                 <div>
 78 |                     <p>A paragraph (from the Greek paragraphos, “to write beside” or “written beside”) is a self-contained unit of a discourse in writing dealing with a particular point or idea. A paragraph consists of one or more sentences. Though not required by the syntax of any language, paragraphs are usually an expected part of formal writing, used to organize longer prose.</p>
 79 |                 </div>
 80 |                 <footer><p><a href="#top">[Top]</a></p></footer>
 81 |             </article>
 82 |             <article id="text__blockquotes">
 83 |                 <header><h1>Blockquotes</h1></header>
 84 |                 <div>
 85 |                     <blockquote>
 86 |                         <p>A block quotation (also known as a long quotation or extract) is a quotation in a written document, that is set off from the main text as a paragraph, or block of text.</p>
 87 |                         <p>It is typically distinguished visually using indentation and a different typeface or smaller size quotation. It may or may not include a citation, usually placed at the bottom.</p>
 88 |                         <cite><a href="#!">Said no one, ever.</a></cite>
 89 |                     </blockquote>
 90 |                 </div>
 91 |                 <footer><p><a href="#top">[Top]</a></p></footer>
 92 |             </article>
 93 |             <article id="text__lists">
 94 |                 <header><h1>Lists</h1></header>
 95 |                 <div>
 96 |                     <h3>Definition list</h3>
 97 |                     <dl>
 98 |                         <dt>Definition List Title</dt>
 99 |                         <dd>This is a definition list division.</dd>
100 |                     </dl>
101 |                     <h3>Ordered List</h3>
102 |                     <ol>
103 |                         <li>List Item 1</li>
104 |                         <li>List Item 2</li>
105 |                         <li>List Item 3</li>
106 |                     </ol>
107 |                     <h3>Unordered List</h3>
108 |                     <ul>
109 |                         <li>List Item 1</li>
110 |                         <li>List Item 2</li>
111 |                         <li>List Item 3</li>
112 |                     </ul>
113 |                 </div>
114 |                 <footer><p><a href="#top">[Top]</a></p></footer>
115 |             </article>
116 |             <article id="text__hr">
117 |                 <header><h1>Horizontal rules</h1></header>
118 |                 <div>
119 |                     <hr>
120 |                 </div>
121 |                 <footer><p><a href="#top">[Top]</a></p></footer>
122 |             </article>
123 |             <article id="text__tables">
124 |                 <header><h1>Tabular data</h1></header>
125 |                 <table>
126 |                     <caption>Table Caption</caption>
127 |                     <thead>
128 |                     <tr>
129 |                         <th>Table Heading 1</th>
130 |                         <th>Table Heading 2</th>
131 |                         <th>Table Heading 3</th>
132 |                         <th>Table Heading 4</th>
133 |                         <th>Table Heading 5</th>
134 |                     </tr>
135 |                     </thead>
136 |                     <tfoot>
137 |                     <tr>
138 |                         <th>Table Footer 1</th>
139 |                         <th>Table Footer 2</th>
140 |                         <th>Table Footer 3</th>
141 |                         <th>Table Footer 4</th>
142 |                         <th>Table Footer 5</th>
143 |                     </tr>
144 |                     </tfoot>
145 |                     <tbody>
146 |                     <tr>
147 |                         <td>Table Cell 1</td>
148 |                         <td>Table Cell 2</td>
149 |                         <td>Table Cell 3</td>
150 |                         <td>Table Cell 4</td>
151 |                         <td>Table Cell 5</td>
152 |                     </tr>
153 |                     <tr>
154 |                         <td>Table Cell 1</td>
155 |                         <td>Table Cell 2</td>
156 |                         <td>Table Cell 3</td>
157 |                         <td>Table Cell 4</td>
158 |                         <td>Table Cell 5</td>
159 |                     </tr>
160 |                     <tr>
161 |                         <td>Table Cell 1</td>
162 |                         <td>Table Cell 2</td>
163 |                         <td>Table Cell 3</td>
164 |                         <td>Table Cell 4</td>
165 |                         <td>Table Cell 5</td>
166 |                     </tr>
167 |                     <tr>
168 |                         <td>Table Cell 1</td>
169 |                         <td>Table Cell 2</td>
170 |                         <td>Table Cell 3</td>
171 |                         <td>Table Cell 4</td>
172 |                         <td>Table Cell 5</td>
173 |                     </tr>
174 |                     </tbody>
175 |                 </table>
176 |                 <footer><p><a href="#top">[Top]</a></p></footer>
177 |             </article>
178 |             <article id="text__code">
179 |                 <header><h1>Code</h1></header>
180 |                 <div>
181 |                     <p><strong>Keyboard input:</strong> <kbd>Cmd</kbd></p>
182 |                     <p><strong>Inline code:</strong> <code>&lt;div&gt;code&lt;/div&gt;</code></p>
183 |                     <p><strong>Sample output:</strong> <samp>This is sample output from a computer program.</samp></p>
184 |                     <h2>Pre-formatted text</h2>
185 |               <pre>P R E F O R M A T T E D T E X T
186 |   ! " # $ % &amp; ' ( ) * + , - . /
187 |   0 1 2 3 4 5 6 7 8 9 : ; &lt; = &gt; ?
188 |   @ A B C D E F G H I J K L M N O
189 |   P Q R S T U V W X Y Z [ \ ] ^ _
190 |   ` a b c d e f g h i j k l m n o
191 |   p q r s t u v w x y z { | } ~ </pre>
192 |                 </div>
193 |                 <footer><p><a href="#top">[Top]</a></p></footer>
194 |             </article>
195 |             <article id="text__inline">
196 |                 <header><h1>Inline elements</h1></header>
197 |                 <div>
198 |                     <p><a href="#!">This is a text link</a>.</p>
199 |                     <p><strong>Strong is used to indicate strong importance.</strong></p>
200 |                     <p><em>This text has added emphasis.</em></p>
201 |                     <p>The <b>b element</b> is stylistically different text from normal text, without any special importance.</p>
202 |                     <p>The <i>i element</i> is text that is offset from the normal text.</p>
203 |                     <p>The <u>u element</u> is text with an unarticulated, though explicitly rendered, non-textual annotation.</p>
204 |                     <p><del>This text is deleted</del> and <ins>This text is inserted</ins>.</p>
205 |                     <p><s>This text has a strikethrough</s>.</p>
206 |                     <p>Superscript<sup>®</sup>.</p>
207 |                     <p>Subscript for things like H<sub>2</sub>O.</p>
208 |                     <p><small>This small text is small for for fine print, etc.</small></p>
209 |                     <p>Abbreviation: <abbr title="HyperText Markup Language">HTML</abbr></p>
210 |                     <p><q cite="https://developer.mozilla.org/en-US/docs/HTML/Element/q">This text is a short inline quotation.</q></p>
211 |                     <p><cite>This is a citation.</cite>
212 |                     </p><p>The <dfn>dfn element</dfn> indicates a definition.</p>
213 |                     <p>The <mark>mark element</mark> indicates a highlight.</p>
214 |                     <p>The <var>variable element</var>, such as <var>x</var> = <var>y</var>.</p>
215 |                     <p>The time element: <time datetime="2013-04-06T12:32+00:00">2 weeks ago</time></p>
216 |                 </div>
217 |                 <footer><p><a href="#top">[Top]</a></p></footer>
218 |             </article>
219 |         </section>
220 | 
221 |         <section id="embedded">
222 |             <header><h1>Embedded content</h1></header>
223 |             <article id="embedded__images">
224 |                 <header><h2>Images</h2></header>
225 |                 <div>
226 |                     <h3>No <code>&lt;figure&gt;</code> element</h3>
227 |                     <p><img src="http://placekitten.com/480/480" alt="Image alt text"></p>
228 |                     <h3>Wrapped in a <code>&lt;figure&gt;</code> element, no <code>&lt;figcaption&gt;</code></h3>
229 |                     <figure><img src="http://placekitten.com/420/420" alt="Image alt text"></figure>
230 |                     <h3>Wrapped in a <code>&lt;figure&gt;</code> element, with a <code>&lt;figcaption&gt;</code></h3>
231 |                     <figure>
232 |                         <img src="http://placekitten.com/420/420" alt="Image alt text">
233 |                         <figcaption>Here is a caption for this image.</figcaption>
234 |                     </figure>
235 |                 </div>
236 |                 <footer><p><a href="#top">[Top]</a></p></footer>
237 |             </article>
238 |             <article id="embedded__audio">
239 |                 <header><h2>Audio</h2></header>
240 |                 <div><audio controls="">audio</audio></div>
241 |                 <footer><p><a href="#top">[Top]</a></p></footer>
242 |             </article>
243 |             <article id="embedded__video">
244 |                 <header><h2>Video</h2></header>
245 |                 <div><video controls="">video</video></div>
246 |                 <footer><p><a href="#top">[Top]</a></p></footer>
247 |             </article>
248 |             <article id="embedded__canvas">
249 |                 <header><h2>Canvas</h2></header>
250 |                 <div><canvas>canvas</canvas></div>
251 |                 <footer><p><a href="#top">[Top]</a></p></footer>
252 |             </article>
253 |             <article id="embedded__meter">
254 |                 <header><h2>Meter</h2></header>
255 |                 <div><meter value="2" min="0" max="10">2 out of 10</meter></div>
256 |                 <footer><p><a href="#top">[Top]</a></p></footer>
257 |             </article>
258 |             <article id="embedded__progress">
259 |                 <header><h2>Progress</h2></header>
260 |                 <div><progress>progress</progress></div>
261 |                 <footer><p><a href="#top">[Top]</a></p></footer>
262 |             </article>
263 |             <article id="embedded__svg">
264 |                 <header><h2>Inline SVG</h2></header>
265 |                 <div><svg width="100px" height="100px"><circle cx="100" cy="100" r="100" fill="#1fa3ec"></circle></svg></div>
266 |                 <footer><p><a href="#top">[Top]</a></p></footer>
267 |             </article>
268 |             <article id="embedded__iframe">
269 |                 <header><h2>IFrame</h2></header>
270 |                 <div><iframe src="index.html" height="300"></iframe></div>
271 |                 <footer><p><a href="#top">[Top]</a></p></footer>
272 |             </article>
273 |         </section>
274 |         <section id="forms">
275 |             <header><h1>Form elements</h1></header>
276 |             <form>
277 |                 <fieldset id="forms__input">
278 |                     <legend>Input fields</legend>
279 |                     <p>
280 |                         <label for="input__text">Text Input</label>
281 |                         <input id="input__text" type="text" placeholder="Text Input">
282 |                     </p>
283 |                     <p>
284 |                         <label for="input__password">Password</label>
285 |                         <input id="input__password" type="password" placeholder="Type your Password">
286 |                     </p>
287 |                     <p>
288 |                         <label for="input__webaddress">Web Address</label>
289 |                         <input id="input__webaddress" type="url" placeholder="http://yoursite.com">
290 |                     </p>
291 |                     <p>
292 |                         <label for="input__emailaddress">Email Address</label>
293 |                         <input id="input__emailaddress" type="email" placeholder="name@email.com">
294 |                     </p>
295 |                     <p>
296 |                         <label for="input__phone">Phone Number</label>
297 |                         <input id="input__phone" type="tel" placeholder="(999) 999-9999">
298 |                     </p>
299 |                     <p>
300 |                         <label for="input__search">Search</label>
301 |                         <input id="input__search" type="search" placeholder="Enter Search Term">
302 |                     </p>
303 |                     <p>
304 |                         <label for="input__text2">Number Input</label>
305 |                         <input id="input__text2" type="number" placeholder="Enter a Number">
306 |                     </p>
307 |                     <p>
308 |                         <label for="input__text3" class="error">Error</label>
309 |                         <input id="input__text3" class="is-error" type="text" placeholder="Text Input">
310 |                     </p>
311 |                     <p>
312 |                         <label for="input__text4" class="valid">Valid</label>
313 |                         <input id="input__text4" class="is-valid" type="text" placeholder="Text Input">
314 |                     </p>
315 |                 </fieldset>
316 |                 <p><a href="#top">[Top]</a></p>
317 |                 <fieldset id="forms__select">
318 |                     <legend>Select menus</legend>
319 |                     <p>
320 |                         <label for="select">Select</label>
321 |                         <select id="select">
322 |                             <optgroup label="Option Group">
323 |                                 <option>Option One</option>
324 |                                 <option>Option Two</option>
325 |                                 <option>Option Three</option>
326 |                             </optgroup>
327 |                         </select>
328 |                     </p>
329 |                 </fieldset>
330 |                 <p><a href="#top">[Top]</a></p>
331 |                 <fieldset id="forms__checkbox">
332 |                     <legend>Checkboxes</legend>
333 |                     <ul class="list list--bare">
334 |                         <li><label for="checkbox1"><input id="checkbox1" name="checkbox" type="checkbox" checked="checked"> Choice A</label></li>
335 |                         <li><label for="checkbox2"><input id="checkbox2" name="checkbox" type="checkbox"> Choice B</label></li>
336 |                         <li><label for="checkbox3"><input id="checkbox3" name="checkbox" type="checkbox"> Choice C</label></li>
337 |                     </ul>
338 |                 </fieldset>
339 |                 <p><a href="#top">[Top]</a></p>
340 |                 <fieldset id="forms__radio">
341 |                     <legend>Radio buttons</legend>
342 |                     <ul class="list list--bare">
343 |                         <li><label for="radio1"><input id="radio1" name="radio" type="radio" class="radio" checked="checked"> Option 1</label></li>
344 |                         <li><label for="radio2"><input id="radio2" name="radio" type="radio" class="radio"> Option 2</label></li>
345 |                         <li><label for="radio3"><input id="radio3" name="radio" type="radio" class="radio"> Option 3</label></li>
346 |                     </ul>
347 |                 </fieldset>
348 |                 <p><a href="#top">[Top]</a></p>
349 |                 <fieldset id="forms__textareas">
350 |                     <legend>Textareas</legend>
351 |                     <p>
352 |                         <label for="textarea">Textarea</label>
353 |                         <textarea id="textarea" rows="8" cols="48" placeholder="Enter your message here"></textarea>
354 |                     </p>
355 |                 </fieldset>
356 |                 <p><a href="#top">[Top]</a></p>
357 |                 <fieldset id="forms__html5">
358 |                     <legend>HTML5 inputs</legend>
359 |                     <p>
360 |                         <label for="ic">Color input</label>
361 |                         <input type="color" id="ic" value="#000000">
362 |                     </p>
363 |                     <p>
364 |                         <label for="in">Number input</label>
365 |                         <input type="number" id="in" min="0" max="10" value="5">
366 |                     </p>
367 |                     <p>
368 |                         <label for="ir">Range input</label>
369 |                         <input type="range" id="ir" value="10">
370 |                     </p>
371 |                     <p>
372 |                         <label for="idd">Date input</label>
373 |                         <input type="date" id="idd" value="1970-01-01">
374 |                     </p>
375 |                     <p>
376 |                         <label for="idm">Month input</label>
377 |                         <input type="month" id="idm" value="1970-01">
378 |                     </p>
379 |                     <p>
380 |                         <label for="idw">Week input</label>
381 |                         <input type="week" id="idw" value="1970-W01">
382 |                     </p>
383 |                     <p>
384 |                         <label for="idt">Datetime input</label>
385 |                         <input type="datetime" id="idt" value="1970-01-01T00:00:00Z">
386 |                     </p>
387 |                     <p>
388 |                         <label for="idtl">Datetime-local input</label>
389 |                         <input type="datetime-local" id="idtl" value="1970-01-01T00:00">
390 |                     </p>
391 |                 </fieldset>
392 |                 <p><a href="#top">[Top]</a></p>
393 |                 <fieldset id="forms__action">
394 |                     <legend>Action buttons</legend>
395 |                     <p>
396 |                         <input type="submit" value="Input">
397 |                         <button type="submit">Button</button>
398 |                         <input type="reset" value="Reset">
399 |                         <input type="submit" value="Disabled" disabled>
400 |                     </p>
401 |                 </fieldset>
402 |                 <p><a href="#top">[Top]</a></p>
403 |             </form>
404 |         </section>
405 |     </main>
406 |     <!-- Footer -->
407 |     <footer role="contentinfo">
408 |         <p>Made by <a href="http://twitter.com/cbracco">@cbracco</a>. Code on <a href="http://github.com/cbracco/html5-test-page">GitHub</a>.</p>
409 |     </footer>
410 | </div>
411 | </body>
412 | </html>


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