├── README.pod
├── .editorconfig
├── lib
    └── HTML5
    │   ├── DOM
    │       ├── AsyncResult.pm
    │       ├── CSS.pm
    │       ├── Text.pm
    │       ├── Comment.pm
    │       ├── DocType.pm
    │       ├── Document.pm
    │       ├── Fragment.pm
    │       ├── CSS
    │       │   ├── Selector
    │       │   │   └── Entry.pm
    │       │   └── Selector.pm
    │       ├── Element.pm
    │       ├── Tree.pm
    │       ├── Node.pm
    │       ├── Encoding.pm
    │       ├── TokenList.pm
    │       └── Collection.pm
    │   └── DOM.pm
├── .gitmodules
├── modest_config.h
├── modest_myencoding.c
├── MANIFEST.SKIP
├── typemap
├── modest_myurl.c
├── .travis.yml
├── modest_myfont.c
├── leaks.pl
├── modest_mycore.c
├── modest_myport.c
├── t
    ├── 2-encodings.t
    ├── 1-api-use-utf8.t
    └── 0-api.t
├── modest_myhtml.c
├── LICENSE
├── examples
    ├── simple.pl
    └── html5lib_tests.pl
├── modest_modest.c
├── scripts
    ├── tags.txt
    └── gen.pl
├── Makefile.PL
├── CHANGES
├── modest_mycss.c
├── port
    └── openbsd
    │   └── mcsync.c
├── gen
    ├── tags_ua_style.c
    └── modest_errors.c
├── utils.h
└── utils.c


/README.pod:
--------------------------------------------------------------------------------
1 | lib/HTML5/DOM.pod


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
1 | root = true
2 | 
3 | [*]
4 | indent_style = tab
5 | indent_size = 4
6 | charset = utf-8
7 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM/AsyncResult.pm:
--------------------------------------------------------------------------------
1 | package HTML5::DOM::AsyncResult;
2 | use strict;
3 | use warnings;
4 | 
5 | 1;
6 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "third_party/modest"]
2 | 	path = third_party/modest
3 | 	url = https://github.com/lexborisov/Modest
4 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM/CSS.pm:
--------------------------------------------------------------------------------
1 | package HTML5::DOM::CSS;
2 | use strict;
3 | use warnings;
4 | 
5 | use HTML5::DOM::CSS::Selector;
6 | 
7 | 1;
8 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM/Text.pm:
--------------------------------------------------------------------------------
 1 | package HTML5::DOM::Text;
 2 | use strict;
 3 | use warnings;
 4 | 
 5 | use HTML5::DOM::Node;
 6 | 
 7 | our @ISA = ("HTML5::DOM::Node");
 8 | 
 9 | 1;
10 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM/Comment.pm:
--------------------------------------------------------------------------------
 1 | package HTML5::DOM::Comment;
 2 | use strict;
 3 | use warnings;
 4 | 
 5 | use HTML5::DOM::Node;
 6 | 
 7 | our @ISA = ("HTML5::DOM::Node");
 8 | 
 9 | 1;
10 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM/DocType.pm:
--------------------------------------------------------------------------------
 1 | package HTML5::DOM::DocType;
 2 | use strict;
 3 | use warnings;
 4 | 
 5 | use HTML5::DOM::Node;
 6 | 
 7 | our @ISA = ("HTML5::DOM::Node");
 8 | 
 9 | 1;
10 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM/Document.pm:
--------------------------------------------------------------------------------
 1 | package HTML5::DOM::Document;
 2 | use strict;
 3 | use warnings;
 4 | 
 5 | use HTML5::DOM::Node;
 6 | 
 7 | our @ISA = ("HTML5::DOM::Element");
 8 | 
 9 | 1;
10 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM/Fragment.pm:
--------------------------------------------------------------------------------
 1 | package HTML5::DOM::Fragment;
 2 | use strict;
 3 | use warnings;
 4 | 
 5 | use HTML5::DOM::Node;
 6 | 
 7 | our @ISA = ("HTML5::DOM::Element");
 8 | 
 9 | 1;
10 | 


--------------------------------------------------------------------------------
/modest_config.h:
--------------------------------------------------------------------------------
1 | #define _DEFAULT_SOURCE 1
2 | #define _BSD_SOURCE 1
3 | #define _POSIX_C_SOURCE 199309L
4 | 
5 | #if (defined(_WIN32) || defined(_WIN64))
6 | 	#define MyCORE_OS_WINDOWS_NT
7 | #endif
8 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM/CSS/Selector/Entry.pm:
--------------------------------------------------------------------------------
 1 | package HTML5::DOM::CSS::Selector::Entry;
 2 | use strict;
 3 | use warnings;
 4 | 
 5 | use overload
 6 | 	'""'		=> sub { shift->text }, 
 7 | 	'%{}'		=> sub { shift->specificity }, 
 8 | 	'bool'		=> sub { 1 }, 
 9 | 	fallback	=> 1;
10 | 
11 | 1;
12 | __END__
13 | 


--------------------------------------------------------------------------------
/modest_myencoding.c:
--------------------------------------------------------------------------------
 1 | #include "modest_config.h"
 2 | 
 3 | // myencoding
 4 | #include "third_party/modest/source/myencoding/encoding.c"
 5 | #include "third_party/modest/source/myencoding/detect.c"
 6 | #include "third_party/modest/source/myencoding/mystring.c"
 7 | 
 8 | // myunicode
 9 | #include "third_party/modest/source/myunicode/myosi.c"
10 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM/Element.pm:
--------------------------------------------------------------------------------
 1 | package HTML5::DOM::Element;
 2 | use strict;
 3 | use warnings;
 4 | 
 5 | use HTML5::DOM::Node;
 6 | use HTML5::DOM::TokenList;
 7 | 
 8 | our @ISA = ("HTML5::DOM::Node");
 9 | 
10 | sub classList {
11 | 	return HTML5::DOM::TokenList->new($_[0], "class");
12 | }
13 | 
14 | sub className {
15 | 	my $class = $_[0]->attr("class");
16 | 	return defined $class ? $class : "";
17 | }
18 | 
19 | 1;
20 | 


--------------------------------------------------------------------------------
/MANIFEST.SKIP:
--------------------------------------------------------------------------------
 1 | #!install_default
 2 | 
 3 | third_party/.*?\.pm$
 4 | third_party/.*?\.pl$
 5 | \.git
 6 | third_party/modest/utils/
 7 | third_party/modest/test/
 8 | third_party/modest/examples/
 9 | third_party/modest/devel/
10 | third_party/modest/third_party/font/
11 | Makefile$
12 | Makefile\.mk$
13 | Makefile\.bin\.cfg$
14 | Makefile\.cfg$
15 | MANIFEST.bak
16 | MYMETA.*?$
17 | .gz
18 | .tar
19 | .md
20 | blib/
21 | pm_to_lib
22 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM/Tree.pm:
--------------------------------------------------------------------------------
 1 | package HTML5::DOM::Tree;
 2 | use strict;
 3 | use warnings;
 4 | 
 5 | use overload
 6 | 	'""'		=> sub { $_[0]->document->html }, 
 7 | 	'@{}'		=> sub { [$_[0]->document] }, 
 8 | 	'bool'		=> sub { 1 }, 
 9 | 	'=='		=> sub { defined $_[1] && $_[0]->isSameTree($_[1]) }, 
10 | 	'!='		=> sub { !defined $_[1] || !$_[0]->isSameTree($_[1]) }, 
11 | 	fallback	=> 1;
12 | 
13 | sub text { shift->document->text(@_) }
14 | sub html { shift->document->html(@_) }
15 | 
16 | 1;
17 | 


--------------------------------------------------------------------------------
/typemap:
--------------------------------------------------------------------------------
 1 | TYPEMAP
 2 | 
 3 | HTML5::DOM				T_PTROBJ
 4 | HTML5::DOM::Collection	T_PTROBJ
 5 | HTML5::DOM::Node		T_PTROBJ
 6 | HTML5::DOM::DocType		T_PTROBJ
 7 | HTML5::DOM::Element		T_PTROBJ
 8 | HTML5::DOM::Fragment	T_PTROBJ
 9 | HTML5::DOM::Comment		T_PTROBJ
10 | HTML5::DOM::Text		T_PTROBJ
11 | HTML5::DOM::Node		T_PTROBJ
12 | HTML5::DOM::Node		T_PTROBJ
13 | HTML5::DOM::Tree		T_PTROBJ
14 | HTML5::DOM::AsyncResult	T_PTROBJ
15 | 
16 | HTML5::DOM::CSS						T_PTROBJ
17 | HTML5::DOM::CSS::Selector			T_PTROBJ
18 | HTML5::DOM::CSS::Selector::Entry	T_PTROBJ
19 | 


--------------------------------------------------------------------------------
/modest_myurl.c:
--------------------------------------------------------------------------------
 1 | #include "modest_config.h"
 2 | 
 3 | // myurl
 4 | #include "third_party/modest/source/myurl/myosi.c"
 5 | #include "third_party/modest/source/myurl/punycode.c"
 6 | #include "third_party/modest/source/myurl/path.c"
 7 | #include "third_party/modest/source/myurl/scheme.c"
 8 | #include "third_party/modest/source/myurl/url.c"
 9 | #include "third_party/modest/source/myurl/utils.c"
10 | #include "third_party/modest/source/myurl/serialization.c"
11 | #include "third_party/modest/source/myurl/parser_end.c"
12 | #include "third_party/modest/source/myurl/host.c"
13 | #include "third_party/modest/source/myurl/parser.c"
14 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM/CSS/Selector.pm:
--------------------------------------------------------------------------------
 1 | package HTML5::DOM::CSS::Selector;
 2 | use strict;
 3 | use warnings;
 4 | 
 5 | use HTML5::DOM::CSS::Selector::Entry;
 6 | 
 7 | use overload
 8 | 	'""'		=> sub { shift->text }, 
 9 | 	'@{}'		=> sub { shift->array }, 
10 | 	'bool'		=> sub { 1 }, 
11 | 	fallback	=> 1;
12 | 
13 | sub new {
14 | 	my ($class, $text) = @_;
15 | 	return HTML5::DOM::CSS->new->parseSelector($text);
16 | }
17 | 
18 | # TODO: implement in XS?
19 | sub array {
20 | 	my $self = shift;
21 | 	my @tmp;
22 | 	my $l = $self->length;
23 | 	for (my $i = 0; $i < $l; ++$i) {
24 | 		push @tmp, $self->entry($i);
25 | 	}
26 | 	return \@tmp;
27 | }
28 | 
29 | 1;
30 | __END__
31 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | jobs:
 2 |   include:
 3 |     - stage: Windows
 4 |       os: windows
 5 |       language: shell
 6 |       before_install:
 7 |         - cinst -y strawberryperl
 8 |         - export "PATH=/c/Strawberry/perl/site/bin:/c/Strawberry/perl/bin:/c/Strawberry/c/bin:$PATH"
 9 |       install:
10 |         - cpanm --notest --installdeps .
11 |       script:
12 |         - perl Makefile.PL && gmake.exe test TEST_VERBOSE=1
13 | 
14 | language: perl
15 | perl:
16 |     - "5.36"
17 |     - "5.30"
18 |     - "5.22"
19 |     - "5.20"
20 |     - "5.18"
21 |     - "5.16"
22 |     - "5.14"
23 |     - "5.8"
24 | os:
25 |     - linux
26 | 
27 | script: perl Makefile.PL && make test TEST_VERBOSE=1
28 | 


--------------------------------------------------------------------------------
/modest_myfont.c:
--------------------------------------------------------------------------------
 1 | #include "modest_config.h"
 2 | 
 3 | // myfont
 4 | #include "third_party/modest/source/myfont/glyf.c"
 5 | #include "third_party/modest/source/myfont/myosi.c"
 6 | #include "third_party/modest/source/myfont/myfont.c"
 7 | #include "third_party/modest/source/myfont/os_2.c"
 8 | #include "third_party/modest/source/myfont/head.c"
 9 | #include "third_party/modest/source/myfont/hhea.c"
10 | #include "third_party/modest/source/myfont/vmtx.c"
11 | #include "third_party/modest/source/myfont/vhea.c"
12 | #include "third_party/modest/source/myfont/name.c"
13 | #include "third_party/modest/source/myfont/maxp.c"
14 | #include "third_party/modest/source/myfont/pclt.c"
15 | #include "third_party/modest/source/myfont/cmap.c"
16 | #include "third_party/modest/source/myfont/hmtx.c"
17 | #include "third_party/modest/source/myfont/loca.c"
18 | 


--------------------------------------------------------------------------------
/leaks.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl
 2 | use warnings;
 3 | use strict;
 4 | use File::Slurp qw|read_file write_file|;
 5 | use File::Basename qw|dirname|;
 6 | use POSIX;
 7 | 
 8 | for my $file (glob("t/*.t")) {
 9 | 	my $text = read_file($file);
10 | 	
11 | 	if ($text =~ /<test-body>(.*?)<\/test-body>/sim) {
12 | 		print $file."\n";
13 | 		my $code = 
14 | 			'
15 | 				use warnings;
16 | 				use strict;
17 | 				use Test::LeakTrace;
18 | 				use HTML5::DOM;
19 | 				
20 | 				sub ok {
21 | 					print "ok - ".$_[1]."\n" if ($_[0]);
22 | 					print "not ok - ".$_[1]."\n" if (!$_[0]);
23 | 				};
24 | 				sub done_testing { };
25 | 				sub require_ok { };
26 | 				sub can_ok { };
27 | 				sub isa_ok { };
28 | 				
29 | 				no_leaks_ok {
30 | 					(sub {
31 | 						'.$1.';
32 | 						1;
33 | 					})->();
34 | 				};
35 | 			';
36 | 		eval($code);
37 | 		die "$@" if ($@);
38 | 	}
39 | }
40 | 


--------------------------------------------------------------------------------
/modest_mycore.c:
--------------------------------------------------------------------------------
 1 | #include "modest_config.h"
 2 | 
 3 | // mycore
 4 | #include "third_party/modest/source/mycore/mythread.c"
 5 | #include "third_party/modest/source/mycore/thread_queue.c"
 6 | #include "third_party/modest/source/mycore/utils/mchar_async.c"
 7 | #include "third_party/modest/source/mycore/utils/mhash.c"
 8 | #include "third_party/modest/source/mycore/utils/mctree.c"
 9 | #include "third_party/modest/source/mycore/utils/mcobject_async.c"
10 | #include "third_party/modest/source/mycore/utils/mcobject.c"
11 | #include "third_party/modest/source/mycore/utils/mcsync.c"
12 | #include "third_party/modest/source/mycore/utils/mcsimple.c"
13 | #include "third_party/modest/source/mycore/utils/avl_tree.c"
14 | #include "third_party/modest/source/mycore/myosi.c"
15 | #include "third_party/modest/source/mycore/utils.c"
16 | #include "third_party/modest/source/mycore/mystring.c"
17 | #include "third_party/modest/source/mycore/incoming.c"
18 | 


--------------------------------------------------------------------------------
/modest_myport.c:
--------------------------------------------------------------------------------
 1 | #include "modest_config.h"
 2 | 
 3 | // myport
 4 | #ifdef MyCORE_OS_WINDOWS_NT
 5 | 	#include "third_party/modest/source/myport/windows_nt/mycore/io.c"
 6 | 	#include "third_party/modest/source/myport/windows_nt/mycore/utils/mcsync.c"
 7 | 	#include "third_party/modest/source/myport/windows_nt/mycore/memory.c"
 8 | 	#include "third_party/modest/source/myport/windows_nt/mycore/thread.c"
 9 | 	#include "third_party/modest/source/myport/windows_nt/mycore/perf.c"
10 | #else
11 | 	#include "third_party/modest/source/myport/posix/mycore/io.c"
12 | 	
13 | 	#if MyCORE_USE_SEMAPHORE_INSTEAD_OF_MUTEX
14 | 		#include "port/openbsd/mcsync.c"
15 | 	#else
16 | 		#include "third_party/modest/source/myport/posix/mycore/utils/mcsync.c"
17 | 	#endif
18 | 	
19 | 	#include "third_party/modest/source/myport/posix/mycore/memory.c"
20 | 	#include "third_party/modest/source/myport/posix/mycore/thread.c"
21 | 	#include "third_party/modest/source/myport/posix/mycore/perf.c"
22 | #endif
23 | 


--------------------------------------------------------------------------------
/t/2-encodings.t:
--------------------------------------------------------------------------------
 1 | use warnings;
 2 | use strict;
 3 | use Test::More;
 4 | 
 5 | # <test-body>
 6 | 
 7 | use Encode;
 8 | 
 9 | require_ok('HTML5::DOM');
10 | 
11 | my $encodings = ["WINDOWS-1251", "KOI8-U", "KOI8-R", "UTF-16LE", "UTF-8"];
12 | my $test_str = "тест test :)";
13 | 
14 | for my $enc (@$encodings) {
15 | 	my $parser;
16 | 	
17 | 	my $from_str = $test_str;
18 | 	Encode::from_to($from_str, "UTF-8", $enc);
19 | 	
20 | 	my $to_str = $from_str;
21 | 	Encode::from_to($to_str, $enc, "UTF-8");
22 | 	
23 | 	$parser = HTML5::DOM->new({encoding => $enc});
24 | 	ok($parser->parse($from_str)->body->text eq $to_str, $enc.' - set encoding in new()');
25 | 	
26 | 	$parser = HTML5::DOM->new;
27 | 	ok($parser->parse($from_str, {encoding => $enc})->body->text eq $to_str, $enc.' - set encoding in parse()');
28 | 	
29 | 	$parser = HTML5::DOM->new;
30 | 	
31 | 	my ($enc_id) = HTML5::DOM::Encoding::detectAuto($to_str);
32 | 	if (!$enc_id) {
33 | 		ok($parser->parse($from_str, {default_encoding => $enc})->body->text eq $to_str, $enc.' - set default_encoding in parse()');
34 | 	}
35 | }
36 | 
37 | done_testing;
38 | 
39 | # </test-body>
40 | 


--------------------------------------------------------------------------------
/modest_myhtml.c:
--------------------------------------------------------------------------------
 1 | #include "modest_config.h"
 2 | 
 3 | // myhtml
 4 | #include "third_party/modest/source/myhtml/tree.c"
 5 | #include "third_party/modest/source/myhtml/data_process.c"
 6 | #include "third_party/modest/source/myhtml/mynamespace.c"
 7 | #include "third_party/modest/source/myhtml/tokenizer.c"
 8 | #include "third_party/modest/source/myhtml/tokenizer_doctype.c"
 9 | #include "third_party/modest/source/myhtml/tokenizer_end.c"
10 | #include "third_party/modest/source/myhtml/tokenizer_script.c"
11 | #include "third_party/modest/source/myhtml/tag_init.c"
12 | #include "third_party/modest/source/myhtml/rules.c"
13 | #include "third_party/modest/source/myhtml/callback.c"
14 | #include "third_party/modest/source/myhtml/serialization.c"
15 | #include "third_party/modest/source/myhtml/myhtml.c"
16 | #include "third_party/modest/source/myhtml/mystring.c"
17 | #include "third_party/modest/source/myhtml/tag.c"
18 | #include "third_party/modest/source/myhtml/token.c"
19 | #include "third_party/modest/source/myhtml/stream.c"
20 | #include "third_party/modest/source/myhtml/charef.c"
21 | #include "third_party/modest/source/myhtml/parser.c"
22 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2018 Kirill Zhumarin <kirill.zhumarin@gmail.com>
 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 | 


--------------------------------------------------------------------------------
/examples/simple.pl:
--------------------------------------------------------------------------------
 1 | use warnings;
 2 | use strict;
 3 | use HTML5::DOM;
 4 | 
 5 | # create parser object
 6 | my $parser = HTML5::DOM->new;
 7 | 
 8 | # parse some html
 9 | my $tree = $parser->parse('
10 | 	<label>Some list of OS:</label>
11 | 	<ul class="list" data-what="os" title="OS list">
12 | 	   <li>UNIX</li>
13 | 	   <li>Linux</li>
14 | 	   <!-- comment -->
15 | 	   <li>OSX</li>
16 | 	   <li>Windows</li>
17 | 	   <li>FreeBSD</li>
18 | 	</ul>
19 | ');
20 | 
21 | # find one element by CSS selector
22 | my $ul = $tree->at('ul.list');
23 | 
24 | # prints tag
25 | print $ul->tag."\n"; # ul
26 | 
27 | # check if <ul> has class list
28 | print "<ul> has class .list\n" if ($ul->classList->has('list'));
29 | 
30 | # add some class
31 | $ul->classList->add('os-list');
32 | 
33 | # prints <ul> classes
34 | print $ul->className."\n"; # list os-list
35 | 
36 | # prints <ul> attribute title
37 | print $ul->attr("title")."\n"; # OS list
38 | 
39 | # changing <ul> attribute title
40 | $ul->attr("title", "OS names list");
41 | 
42 | # find all os names
43 | $ul->find('li')->each(sub {
44 | 	my ($node, $index) = @_;
45 | 	print "OS #$index: ".$node->text."\n";
46 | });
47 | 
48 | # we can use precompiled selectors
49 | my $css_parser = HTML5::DOM::CSS->new;
50 | my $selector = $css_parser->parseSelector('li');
51 | 
52 | # remove OSX from OS
53 | $ul->find($selector)->[2]->remove();
54 | 
55 | # serialize tree
56 | print $tree->html."\n";
57 | 


--------------------------------------------------------------------------------
/modest_modest.c:
--------------------------------------------------------------------------------
 1 | #include "modest_config.h"
 2 | 
 3 | // modest
 4 | #include "third_party/modest/source/modest/glue.c"
 5 | #include "third_party/modest/source/modest/finder/pseudo_class.c"
 6 | #include "third_party/modest/source/modest/finder/match.c"
 7 | #include "third_party/modest/source/modest/finder/thread.c"
 8 | #include "third_party/modest/source/modest/finder/finder.c"
 9 | #include "third_party/modest/source/modest/finder/type.c"
10 | #include "third_party/modest/source/modest/render/tree.c"
11 | #include "third_party/modest/source/modest/render/begin.c"
12 | #include "third_party/modest/source/modest/render/binding.c"
13 | #include "third_party/modest/source/modest/render/tree_node.c"
14 | #include "third_party/modest/source/modest/layer/layer.c"
15 | #include "third_party/modest/source/modest/node/raw_property.c"
16 | #include "third_party/modest/source/modest/node/node.c"
17 | #include "third_party/modest/source/modest/node/property.c"
18 | #include "third_party/modest/source/modest/node/serialization.c"
19 | #include "third_party/modest/source/modest/declaration.c"
20 | #include "third_party/modest/source/modest/style/map.c"
21 | #include "third_party/modest/source/modest/style/default.c"
22 | #include "third_party/modest/source/modest/style/sheet.c"
23 | #include "third_party/modest/source/modest/style/type.c"
24 | #include "third_party/modest/source/modest/style/raw.c"
25 | #include "third_party/modest/source/modest/modest.c"
26 | 


--------------------------------------------------------------------------------
/scripts/tags.txt:
--------------------------------------------------------------------------------
 1 | article			block
 2 | aside			block
 3 | details			block
 4 | div				block
 5 | dt				block
 6 | figcaption		block
 7 | footer			block
 8 | form			block
 9 | header			block
10 | hgroup			block
11 | html			block
12 | main			block
13 | nav				block
14 | section			block
15 | summary			block
16 | body			block
17 | p				block
18 | dl				block
19 | dd				block
20 | blockquote		block
21 | figure			block
22 | address			block
23 | center			block
24 | h1				block
25 | h2				block
26 | h3				block
27 | h4				block
28 | h5				block
29 | h6				block
30 | xmp				block
31 | pre				block
32 | plaintext		block
33 | table			table
34 | caption			table-caption
35 | tr				table-row
36 | col				table-column
37 | colgroup		table-column-group
38 | tbody			table-row-group
39 | thead			table-header-group
40 | tfoot			table-footer-group
41 | td				table-cell
42 | th				table-cell
43 | ul				block
44 | menu			block
45 | dir				block
46 | ol				block
47 | li				list-item
48 | hr				block
49 | frameset		block
50 | link			none
51 | noframes		none
52 | base			none
53 | basefont		none
54 | datalist		none
55 | head			none
56 | meta			none
57 | script			none
58 | style			none
59 | title			none
60 | noembed			none
61 | param			none
62 | template		none
63 | area			none
64 | marquee			inline-block
65 | ruby			ruby
66 | rb				ruby-base
67 | rp				none
68 | rt				ruby-text
69 | rtc				ruby-text-container
70 | legend			block
71 | fieldset		block
72 | select			inline-block
73 | option			block
74 | optgroup		block
75 | button			inline-block
76 | progress		inline-block
77 | meter			inline-block
78 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM/Node.pm:
--------------------------------------------------------------------------------
 1 | package HTML5::DOM::Node;
 2 | use strict;
 3 | use warnings;
 4 | 
 5 | use overload
 6 | 	'""'		=> sub { $_[0]->html }, 
 7 | 	'@{}'		=> sub { $_[0]->childrenNode->array }, 
 8 | 	'%{}'		=> \&__attrHashAccess, 
 9 | 	'=='		=> sub { defined $_[1] && $_[0]->isSameNode($_[1]) }, 
10 | 	'!='		=> sub { !defined $_[1] || !$_[0]->isSameNode($_[1]) }, 
11 | 	'bool'		=> sub { 1 }, 
12 | 	fallback	=> 1;
13 | 
14 | # https://developer.mozilla.org/pl/docs/Web/API/Element/nodeType
15 | use constant	ELEMENT_NODE					=> 1; 
16 | use constant	ATTRIBUTE_NODE					=> 2;	# not supported
17 | use constant	TEXT_NODE						=> 3; 
18 | use constant	CDATA_SECTION_NODE				=> 4;	# not supported
19 | use constant	ENTITY_REFERENCE_NODE			=> 5;	# not supported
20 | use constant	ENTITY_NODE						=> 6;	# not supported
21 | use constant	PROCESSING_INSTRUCTION_NODE		=> 7;	# not supported
22 | use constant	COMMENT_NODE					=> 8; 
23 | use constant	DOCUMENT_NODE					=> 9; 
24 | use constant	DOCUMENT_TYPE_NODE				=> 10; 
25 | use constant	DOCUMENT_FRAGMENT_NODE			=> 11; 
26 | use constant	NOTATION_NODE					=> 12;	# not supported
27 | 
28 | sub __attrHashAccess {
29 | 	my $self = shift;
30 | 	my %h;
31 | 	tie %h, 'HTML5::DOM::Node::_AttrHashAccess', $self;
32 | 	return \%h;
33 | }
34 | 
35 | 1;
36 | 
37 | package HTML5::DOM::Node::_AttrHashAccess;
38 | use strict;
39 | use warnings;
40 | 
41 | sub TIEHASH {
42 | 	my $p = shift;
43 | 	bless \shift, $p
44 | }
45 | 
46 | sub EXISTS {
47 | 	defined ${shift()}->attr(shift);
48 | }
49 | 
50 | sub DELETE {
51 | 	${shift()}->removeAttr(shift);
52 | }
53 | 
54 | sub FETCH {
55 | 	${shift()}->attr(shift);
56 | }
57 | 
58 | sub STORE {
59 | 	${shift()}->attr(shift, shift);
60 | }
61 | 
62 | 1;
63 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM/Encoding.pm:
--------------------------------------------------------------------------------
 1 | package HTML5::DOM::Encoding;
 2 | use strict;
 3 | use warnings;
 4 | 
 5 | # <MyENCODING_const>
 6 | use constant	DEFAULT					=> 0x0;
 7 | use constant	AUTO					=> 0x1;
 8 | use constant	NOT_DETERMINED			=> 0x2;
 9 | use constant	UTF_8					=> 0x0;
10 | use constant	UTF_16LE				=> 0x4;
11 | use constant	UTF_16BE				=> 0x5;
12 | use constant	X_USER_DEFINED			=> 0x6;
13 | use constant	BIG5					=> 0x7;
14 | use constant	EUC_JP					=> 0x8;
15 | use constant	EUC_KR					=> 0x9;
16 | use constant	GB18030					=> 0xa;
17 | use constant	GBK						=> 0xb;
18 | use constant	IBM866					=> 0xc;
19 | use constant	ISO_2022_JP				=> 0xd;
20 | use constant	ISO_8859_10				=> 0xe;
21 | use constant	ISO_8859_13				=> 0xf;
22 | use constant	ISO_8859_14				=> 0x10;
23 | use constant	ISO_8859_15				=> 0x11;
24 | use constant	ISO_8859_16				=> 0x12;
25 | use constant	ISO_8859_2				=> 0x13;
26 | use constant	ISO_8859_3				=> 0x14;
27 | use constant	ISO_8859_4				=> 0x15;
28 | use constant	ISO_8859_5				=> 0x16;
29 | use constant	ISO_8859_6				=> 0x17;
30 | use constant	ISO_8859_7				=> 0x18;
31 | use constant	ISO_8859_8				=> 0x19;
32 | use constant	ISO_8859_8_I			=> 0x1a;
33 | use constant	KOI8_R					=> 0x1b;
34 | use constant	KOI8_U					=> 0x1c;
35 | use constant	MACINTOSH				=> 0x1d;
36 | use constant	SHIFT_JIS				=> 0x1e;
37 | use constant	WINDOWS_1250			=> 0x1f;
38 | use constant	WINDOWS_1251			=> 0x20;
39 | use constant	WINDOWS_1252			=> 0x21;
40 | use constant	WINDOWS_1253			=> 0x22;
41 | use constant	WINDOWS_1254			=> 0x23;
42 | use constant	WINDOWS_1255			=> 0x24;
43 | use constant	WINDOWS_1256			=> 0x25;
44 | use constant	WINDOWS_1257			=> 0x26;
45 | use constant	WINDOWS_1258			=> 0x27;
46 | use constant	WINDOWS_874				=> 0x28;
47 | use constant	X_MAC_CYRILLIC			=> 0x29;
48 | use constant	LAST_ENTRY				=> 0x2a;
49 | use constant	STATUS_OK				=> 0x0;
50 | use constant	STATUS_ERROR			=> 0x1;
51 | use constant	STATUS_CONTINUE			=> 0x2;
52 | use constant	STATUS_DONE				=> 0x4;
53 | # </MyENCODING_const>
54 | 
55 | 1;
56 | 


--------------------------------------------------------------------------------
/Makefile.PL:
--------------------------------------------------------------------------------
 1 | use strict;
 2 | use utf8;
 3 | use Config;
 4 | 
 5 | use FindBin;
 6 | use ExtUtils::MakeMaker;
 7 | 
 8 | my $source_dir = $FindBin::Bin ."/third_party/modest/include";
 9 | my $port = "posix";
10 | my $modest_source = "third_party/modest/source";
11 | 
12 | my $libs = [];
13 | 
14 | if ($^O =~ /MSWin/i) {
15 | 	$port = 'windows_nt';
16 | } else {
17 | 	$libs = ["-lpthread", "-lm"];
18 | }
19 | 
20 | my $defines = "";
21 | 
22 | if ($^O =~ /openbsd|netbsd|freebsd/i) {
23 | 	# Simulates mutex using semaphore
24 | 	# Because MyHTML call phtread_mutex_unlock without before call phtread_mutex_lock
25 | 	# And it crashes on OpenBSD
26 | 	warn("Detected *BSD - switch from mutex to semaphore\n");
27 | 	$defines = " -DMyCORE_USE_SEMAPHORE_INSTEAD_OF_MUTEX ";
28 | }
29 | 
30 | my $sources = [
31 | 	"DOM.o",
32 | 	"utils.o",
33 | 	"modest_modest.o",
34 | 	"modest_mycore.o",
35 | 	"modest_mycss.o",
36 | 	"modest_myencoding.o",
37 | 	"modest_myfont.o",
38 | 	"modest_myhtml.o",
39 | 	"modest_myport.o",
40 | 	"modest_myurl.o"
41 | ];
42 | 
43 | WriteMakefile(
44 | 	dist	=> {
45 | 		PREOP		=> 'pod2text lib/HTML5/DOM.pod > README',
46 | 		COMPRESS	=> 'gzip -9v',
47 | 		SUFFIX		=> '.gz',
48 | 	},
49 | 	AUTHOR			=> 'Kirill Zhumarin <kirill.zhumarin@gmail.com>',
50 | 	ABSTRACT		=> 'Super fast html5 DOM library with css selectors (based on Modest/MyHTML)',
51 | 	VERSION_FROM	=> 'lib/HTML5/DOM.pm',
52 | 	NAME			=> 'HTML5::DOM',
53 | 	LICENSE			=> 'MIT',
54 | 	LINKTYPE		=> 'dynamic',
55 | 	LIBS			=> $libs,
56 | 	DEFINE			=> $defines,
57 | 	CCFLAGS			=> " -std=c99 ".$Config{ccflags},
58 | 	INC				=> "-I$source_dir",
59 | 	OBJECT			=> join(" ",@$sources),
60 | 	test			=> {TESTS => 't/*.t t/*/*.t'},
61 | 	
62 | 	(eval { ExtUtils::MakeMaker->VERSION(6.48) } ? (MIN_PERL_VERSION => 5.006) : ()),
63 | 	
64 | 	(eval { ExtUtils::MakeMaker->VERSION(6.46) } ? (META_MERGE => {
65 | 		'meta-spec' => { version => 2 },
66 | 		resources => {
67 | 			repository => {
68 | 				type		=> 'git',
69 | 				url			=> 'https://github.com/Azq2/perl-html5-dom.git',
70 | 				web			=> 'https://github.com/Azq2/perl-html5-dom'
71 | 			},
72 | 			bugtracker => {
73 | 				'web'	=> 'https://github.com/Azq2/perl-html5-dom/issues'
74 | 			}
75 | 		}}) : ()
76 | 	),
77 | );
78 | 


--------------------------------------------------------------------------------
/t/1-api-use-utf8.t:
--------------------------------------------------------------------------------
 1 | use Test::More;
 2 | use warnings;
 3 | use strict;
 4 | 
 5 | # <test-body>
 6 | 
 7 | require_ok('HTML5::DOM');
 8 | 
 9 | ######################################################################################
10 | # utf8 support
11 | ######################################################################################
12 | 
13 | ok(length(HTML5::DOM->new->parse('<b>пыщь пыщь</b>')->at('b')->text) == 17, 'test utf8 flag auto "no utf8" [0]');
14 | ok(length(HTML5::DOM->new->parse('<b>пыщь пыщь</b>', {utf8 => "auto"})->at('b')->text) == 17, 'test utf8 flag auto "no utf8" [1]');
15 | 
16 | ok(length(HTML5::DOM->new->parse('<b>пыщь пыщь</b>', {utf8 => 1})->at('b')->text) == 9, 'test utf8 flag on');
17 | 
18 | {
19 | 	use utf8;
20 | 	ok(length(HTML5::DOM->new->parse('<b>пыщь пыщь</b>')->at('b')->text) == 9, 'test utf8 flag auto with "use utf8" [0]');
21 | 	ok(length(HTML5::DOM->new->parse('<b>пыщь пыщь</b>', {utf8 => "auto"})->at('b')->text) == 9, 'test utf8 flag auto "use utf8" [1]');
22 | 	ok(length(HTML5::DOM->new->parse('<b>пыщь пыщь</b>')->utf8(0)->at('b')->text) == 17, 'test utf8 flag off after parse');
23 | 	
24 | 	ok(length(HTML5::DOM->new({utf8 => 0})->parse('<b>пыщь пыщь</b>')->at('b')->text) == 17, 'test utf8 flag off');
25 | }
26 | 
27 | ok(length(HTML5::DOM::CSS->new->parseSelector("[name=\"тест\"]")->text) == 17, 'test utf8 flag auto "no utf8" [0]');
28 | ok(length(HTML5::DOM::CSS->new->parseSelector("[name=\"тест\"]", {utf8 => "auto"})->text) == 17, 'test utf8 flag auto "no utf8" [1]');
29 | 
30 | ok(length(HTML5::DOM::CSS->new->parseSelector("[name=\"тест\"]", {utf8 => 1})->text) == 13, 'test utf8 flag on');
31 | 
32 | {
33 | 	use utf8;
34 | 	ok(length(HTML5::DOM::CSS->new->parseSelector("[name=\"тест\"]")->text) == 13, 'test utf8 flag auto with "use utf8" [0]');
35 | 	ok(length(HTML5::DOM::CSS->new->parseSelector("[name=\"тест\"]", {utf8 => "auto"})->text) == 13, 'test utf8 flag auto "use utf8" [1]');
36 | 	ok(length(HTML5::DOM::CSS->new->parseSelector("[name=\"тест\"]")->utf8(0)->text) == 17, 'test utf8 flag off after parse');
37 | }
38 | 
39 | ok(length(HTML5::DOM::CSS->new({utf8 => 0})->parseSelector("[name=\"тест\"]")->text) == 17, 'test utf8 flag off');
40 | 
41 | done_testing;
42 | 
43 | # </test-body>
44 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM/TokenList.pm:
--------------------------------------------------------------------------------
  1 | package HTML5::DOM::TokenList;
  2 | use strict;
  3 | use warnings;
  4 | 
  5 | use HTML5::DOM::Node;
  6 | 
  7 | use overload
  8 | 	'""'		=> sub { $_[0]->text }, 
  9 | 	'@{}'		=> sub { $_[0]->_items }, 
 10 | 	'bool'		=> sub { 1 }, 
 11 | 	fallback	=> 1;
 12 | 
 13 | sub new {
 14 | 	my ($class, $node, $attr) = @_;
 15 | 	my $self = {
 16 | 		node	=> $node, 
 17 | 		attr	=> $attr
 18 | 	};
 19 | 	bless $self, $class;
 20 | 	return $self;
 21 | }
 22 | 
 23 | sub text {
 24 | 	my $attr = $_[0]->{node}->attr($_[0]->{attr});
 25 | 	return defined $attr ? $attr : "";
 26 | }
 27 | 
 28 | sub _items {
 29 | 	my ($self) = @_;
 30 | 	my $attr = $self->{node}->attr($self->{attr});
 31 | 	if (defined $attr) {
 32 | 		my @items = split(/\s+/, $attr);
 33 | 		return [] if (scalar(@items) == 1 && $items[0] eq '');
 34 | 		return \@items;
 35 | 	}
 36 | 	return [];
 37 | }
 38 | 
 39 | sub item {
 40 | 	my ($self, $index) = @_;
 41 | 	return $self->_items()->[$index];
 42 | }
 43 | 
 44 | sub length {
 45 | 	my ($self) = @_;
 46 | 	return scalar(@{$self->_items()});
 47 | }
 48 | 
 49 | sub has {
 50 | 	my ($self, $token) = @_;
 51 | 	my $attr = $self->{node}->attr($self->{attr});
 52 | 	if (defined $attr) {
 53 | 		return $attr =~ /(\s|^)\Q$token\E(\s|$)/;
 54 | 	}
 55 | 	return 0;
 56 | }
 57 | 
 58 | sub contains { shift->has(@_) }
 59 | 
 60 | sub add {
 61 | 	my $self = shift;
 62 | 	my $items = $self->_items();
 63 | 	for my $token (@_) {
 64 | 		next if ($self->has($token));
 65 | 		push @$items, $token;
 66 | 	}
 67 | 	$self->{node}->attr($self->{attr}, join(" ", @$items));
 68 | 	return $self;
 69 | }
 70 | 
 71 | sub remove {
 72 | 	my $self = shift;
 73 | 	my $attr = $self->{node}->attr($self->{attr});
 74 | 	if (defined $attr) {
 75 | 		for my $token (@_) {
 76 | 			$attr =~ s/(\s|^)\Q$token\E(\s|$)/ /g;
 77 | 		}
 78 | 		$attr =~ s/^\s+|\s+$//;
 79 | 		$self->{node}->attr($self->{attr}, $attr);
 80 | 	}
 81 | 	return $self;
 82 | }
 83 | 
 84 | sub replace {
 85 | 	my ($self, $key, $value) = @_;
 86 | 	my $attr = $self->{node}->attr($self->{attr});
 87 | 	if (defined $attr) {
 88 | 		$attr =~ s/(\s|^)\Q$key\E(\s|$)/$1$value$2/g;
 89 | 		$self->{node}->attr($self->{attr}, $attr);
 90 | 	}
 91 | 	return $self;
 92 | }
 93 | 
 94 | sub toggle {
 95 | 	my ($self, $token, $force) = @_;
 96 | 	my $state = defined $force ? $force : !$self->has($token);
 97 | 	$state ? $self->add($token) : $self->remove($token);
 98 | 	return $state;
 99 | }
100 | 
101 | sub each {
102 | 	my ($self, $callback) = @_;
103 | 	my $index = 0;
104 | 	for my $node (@{$self->_items()}) {
105 | 		$callback->($node, $index);
106 | 		++$index;
107 | 	}
108 | 	return $self;
109 | }
110 | 
111 | 1;
112 | 


--------------------------------------------------------------------------------
/CHANGES:
--------------------------------------------------------------------------------
 1 | 2018-05-22  1.00    - initial release
 2 | 2018-05-22  1.01    - fix can package (remove trash files)
 3 | 2018-05-22  1.02    - fix Kwalitee and packaging issues
 4 | 2018-05-23  1.03    - fix fragments insertion, add Selector::Entry::pseudoElement and allow delete $node->{attr} to remove attribute.
 5 | 2018-05-23  1.04    - add missing myhtml_tree_node_remove, extend Collection API
 6 | 2018-05-27  1.05    - fix specificity calculation
 7 | 2018-05-27  1.06    - fix tests passing on 32-bit machines
 8 | 2018-05-27  1.07    - fix crash on OpenBSD (use semaphore instead of mutex)
 9 | 2018-06-16  1.08    - fix char-ref parsing (myhtml bug), fix doctype serialization (myhtml bug), new api for DOCTYPE nodes, attrArray method.
10 | 2019-01-13  1.09    - API CHANGE: removed old broken async api (wait and parsed methods on Tree and Node)
11 |                     - API CHANGE: now by default parsing in a single mode (it used to be 2 threads)
12 |                     - new async parsing api (see docs)
13 |                     - event loop integration (using EV or any custom implementations top on pipes or sockets)
14 |                     - update modest/myhtml
15 |                     - update and fix docs
16 |                     - supports exists($node->{attr}) for attributes
17 | 2019-01-13  1.10    - fix docs
18 | 2019-01-14  1.11    - fix work on windows (tested with Strawberry)
19 |                     - fix infinitie loop with threads >= 2
20 | 2019-01-15  1.12    - fixes for some strange windows/*bsd environments.
21 |                     - attention about threads mode.
22 | 2019-01-17  1.13    - support for perl utf8-enabled strings.
23 |                     - added parseChunkTree function for getting temporary tree when parsing by chunks.
24 |                     - some fixes (encoding value parsing in options)
25 | 2019-01-17  1.14    - fix docs
26 | 2019-01-17  1.15    - fix setting encoding
27 | 2020-04-29  1.16    - fix random trash in innerText in some cases
28 | 2020-12-12  1.17    - fix docs
29 | 2020-12-12  1.18    - fix docs
30 | 2021-06-26  1.19    - fix infinite loop when calling replace method with a fragment
31 |                     - fix bugtracker url
32 |                     - new collection methods: uniq, grep, head, tail, slice, shuffle, reverse
33 |                     - added regexp/callback support to $collection->first
34 |                     - update modest
35 | 2021-06-26  1.20    - fix link to issues
36 | 2021-06-26  1.21    - fix link to issues
37 | 2021-06-29  1.22    - replace re::is_regexp to ref() check for older perl versions
38 | 2021-06-29  1.23    - fix "Search pattern not terminated"
39 | 2021-07-06  1.24    - more Kwalitee fixes
40 | 2021-07-06  1.25    - more Kwalitee fixes
41 | 


--------------------------------------------------------------------------------
/modest_mycss.c:
--------------------------------------------------------------------------------
 1 | #include "modest_config.h"
 2 | 
 3 | // mycss
 4 | #include "third_party/modest/source/mycss/convert.c"
 5 | #include "third_party/modest/source/mycss/tokenizer.c"
 6 | #include "third_party/modest/source/mycss/check.c"
 7 | #include "third_party/modest/source/mycss/property/parser_image.c"
 8 | #include "third_party/modest/source/mycss/property/init.c"
 9 | #include "third_party/modest/source/mycss/property/parser_url.c"
10 | #include "third_party/modest/source/mycss/property/parser_text_decoration.c"
11 | #include "third_party/modest/source/mycss/property/serialization.c"
12 | #include "third_party/modest/source/mycss/property/shared.c"
13 | #include "third_party/modest/source/mycss/property/parser_background.c"
14 | #include "third_party/modest/source/mycss/property/parser.c"
15 | #include "third_party/modest/source/mycss/mycss.c"
16 | #include "third_party/modest/source/mycss/tokenizer_global.c"
17 | #include "third_party/modest/source/mycss/stack.c"
18 | #include "third_party/modest/source/mycss/tokenizer_end.c"
19 | #include "third_party/modest/source/mycss/an_plus_b.c"
20 | #include "third_party/modest/source/mycss/namespace/init.c"
21 | #include "third_party/modest/source/mycss/namespace/state.c"
22 | #include "third_party/modest/source/mycss/namespace/serialization.c"
23 | #include "third_party/modest/source/mycss/namespace/parser.c"
24 | #include "third_party/modest/source/mycss/mystring.c"
25 | #include "third_party/modest/source/mycss/stylesheet.c"
26 | #include "third_party/modest/source/mycss/declaration/entry_destroy.c"
27 | #include "third_party/modest/source/mycss/declaration/default.c"
28 | #include "third_party/modest/source/mycss/declaration/init.c"
29 | #include "third_party/modest/source/mycss/declaration/state.c"
30 | #include "third_party/modest/source/mycss/declaration/serialization.c"
31 | #include "third_party/modest/source/mycss/declaration/entry.c"
32 | #include "third_party/modest/source/mycss/declaration/parser.c"
33 | #include "third_party/modest/source/mycss/values/color.c"
34 | #include "third_party/modest/source/mycss/values/units.c"
35 | #include "third_party/modest/source/mycss/values/consume.c"
36 | #include "third_party/modest/source/mycss/values/values.c"
37 | #include "third_party/modest/source/mycss/values/serialization.c"
38 | #include "third_party/modest/source/mycss/values/color_parser.c"
39 | #include "third_party/modest/source/mycss/values/image.c"
40 | #include "third_party/modest/source/mycss/values/destroy.c"
41 | #include "third_party/modest/source/mycss/entry.c"
42 | #include "third_party/modest/source/mycss/selectors/list.c"
43 | #include "third_party/modest/source/mycss/selectors/value.c"
44 | #include "third_party/modest/source/mycss/selectors/function_parser.c"
45 | #include "third_party/modest/source/mycss/selectors/init.c"
46 | #include "third_party/modest/source/mycss/selectors/pseudo.c"
47 | #include "third_party/modest/source/mycss/selectors/state.c"
48 | #include "third_party/modest/source/mycss/selectors/function.c"
49 | #include "third_party/modest/source/mycss/selectors/serialization.c"
50 | #include "third_party/modest/source/mycss/selectors/parser.c"
51 | #include "third_party/modest/source/mycss/media/init.c"
52 | #include "third_party/modest/source/mycss/media/state.c"
53 | #include "third_party/modest/source/mycss/parser.c"
54 | 


--------------------------------------------------------------------------------
/port/openbsd/mcsync.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Simulates mutex using semaphore
  3 | 	Because MyHTML call phtread_mutex_unlock without before call phtread_mutex_lock
  4 | 	And it crashes on OpenBSD
  5 | */
  6 | 
  7 | #include "mycore/utils/mcsync.h"
  8 | 
  9 | #ifndef MyCORE_BUILD_WITHOUT_THREADS
 10 | #include <pthread.h>
 11 | #include <semaphore.h>
 12 | 
 13 | #if ((defined(__GNUC__) && __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) || defined(__ATOMIC_SEQ_CST))
 14 | #define MyCORE_MCSYNC_SPINLOCK_PRESENT
 15 | #endif
 16 | 
 17 | #ifdef MyCORE_MCSYNC_SPINLOCK_PRESENT
 18 | static mcsync_status_t mcsync_static_atomic_lock(void *spinlock) {
 19 | 	int compare = 0;
 20 | 	while (!__atomic_compare_exchange_n((int *)spinlock, &compare, 1, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {}
 21 | 	return MCSYNC_STATUS_OK;
 22 | }
 23 | 
 24 | static mcsync_status_t mcsync_static_atomic_unlock(void *spinlock) {
 25 | 	__atomic_store_n((int*)spinlock, 0, __ATOMIC_SEQ_CST);
 26 | 	return MCSYNC_STATUS_OK;
 27 | }
 28 | #endif /* MyCORE_MCSYNC_SPINLOCK_PRESENT */
 29 | 
 30 | /* spinlock */
 31 | void * mcsync_spin_create(void) {
 32 | #ifndef MyCORE_MCSYNC_SPINLOCK_PRESENT
 33 | 	return mcsync_mutex_create();
 34 | #else
 35 | 	return mycore_calloc(1, sizeof(int));
 36 | #endif
 37 | }
 38 | 
 39 | mcsync_status_t mcsync_spin_init(void *spinlock) {
 40 | #ifndef MyCORE_MCSYNC_SPINLOCK_PRESENT
 41 | 	return mcsync_mutex_init(spinlock);
 42 | #else
 43 | 	return MCSYNC_STATUS_OK;
 44 | #endif
 45 | }
 46 | 
 47 | void mcsync_spin_clean(void *spinlock) {
 48 | #ifdef MyCORE_MCSYNC_SPINLOCK_PRESENT
 49 | 	*((int*)spinlock) = 0;
 50 | #endif
 51 | }
 52 | 
 53 | void mcsync_spin_destroy(void *spinlock) {
 54 | #ifdef MyCORE_MCSYNC_SPINLOCK_PRESENT
 55 | 	mycore_free(spinlock);
 56 | #else
 57 | 	mcsync_mutex_destroy(spinlock);
 58 | #endif
 59 | }
 60 | 
 61 | mcsync_status_t mcsync_spin_lock(void *spinlock) {
 62 | #ifdef MyCORE_MCSYNC_SPINLOCK_PRESENT
 63 | 	return mcsync_static_atomic_lock(spinlock);
 64 | #else
 65 | 	return mcsync_mutex_lock(spinlock);
 66 | #endif
 67 | }
 68 | 
 69 | mcsync_status_t mcsync_spin_unlock(void *spinlock) {
 70 | #ifdef MyCORE_MCSYNC_SPINLOCK_PRESENT
 71 | 	return mcsync_static_atomic_unlock(spinlock);
 72 | #else
 73 | 	return mcsync_mutex_unlock(spinlock);
 74 | #endif
 75 | }
 76 | 
 77 | /* fake "mutex" using semaphore */
 78 | void * mcsync_mutex_create(void) {
 79 | 	void *mutex = mycore_calloc(1, sizeof(sem_t));
 80 | 	if (mutex == NULL)
 81 | 		return NULL;
 82 | 	return (void *) mutex;
 83 | }
 84 | 								   
 85 | mcsync_status_t mcsync_mutex_init(void *mutex) {
 86 | 	if (sem_init(mutex, 0, 1))
 87 | 		return MCSYNC_STATUS_NOT_OK;
 88 | 	return MCSYNC_STATUS_OK;
 89 | }
 90 | 
 91 | void mcsync_mutex_clean(void *mutex) {
 92 | 	/* clean function */
 93 | }
 94 | 
 95 | void mcsync_mutex_destroy(void *mutex) {
 96 | 	sem_destroy(mutex);
 97 | 	mycore_free(mutex);
 98 | }
 99 | 
100 | mcsync_status_t mcsync_mutex_lock(void *mutex) {
101 | 	if (sem_wait(mutex) == 0)
102 | 		return MCSYNC_STATUS_OK;
103 | 	return MCSYNC_STATUS_NOT_OK;
104 | }
105 | 								   
106 | mcsync_status_t mcsync_mutex_try_lock(void *mutex) {
107 | 	if (sem_trywait(mutex) == 0)
108 | 		return MCSYNC_STATUS_OK;
109 | 	return MCSYNC_STATUS_NOT_OK;
110 | }
111 | 
112 | mcsync_status_t mcsync_mutex_unlock(void *mutex) {
113 | 	if (sem_post(mutex) == 0)
114 | 		return MCSYNC_STATUS_OK;
115 | 	return MCSYNC_STATUS_NOT_OK;
116 | }
117 | 
118 | #endif
119 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM/Collection.pm:
--------------------------------------------------------------------------------
  1 | package HTML5::DOM::Collection;
  2 | use strict;
  3 | use warnings;
  4 | 
  5 | use List::Util;
  6 | 
  7 | use overload
  8 | 	'""'		=> sub { shift->html }, 
  9 | 	'bool'		=> sub { 1 }, 
 10 | 	fallback	=> 1;
 11 | 
 12 | sub new {
 13 | 	my ($class, $nodes) = @_;
 14 | 	$nodes = [] if (!$nodes || ref($nodes) ne 'ARRAY');
 15 | 	return bless $nodes, $class;
 16 | }
 17 | 
 18 | sub add {
 19 | 	my $self = shift;
 20 | 	push @{$self}, shift;
 21 | 	return $self;
 22 | }
 23 | 
 24 | sub length { scalar(@{shift()}); }
 25 | 
 26 | sub first {
 27 | 	my ($self, $callback) = (shift, shift);
 28 | 	return $self->[0] if (!$callback);
 29 | 	return List::Util::first { $_ =~ $callback } @$self if (_is_regexp($callback));
 30 | 	return List::Util::first { $_->$callback(@_) } @$self;
 31 | }
 32 | 
 33 | sub last { shift->[-1] }
 34 | sub item { shift->[shift] }
 35 | sub array { [@{shift()}] }
 36 | 
 37 | sub slice {
 38 | 	my ($self, $offset, $length) = @_;
 39 | 	
 40 | 	# handle negative value as offset from end
 41 | 	$offset = scalar(@$self) + $offset if ($offset < 0);
 42 | 	
 43 | 	# validate offset
 44 | 	return HTML5::DOM::Collection->new([]) if ($offset < 0 || $offset >= scalar(@$self) - 1);
 45 | 	
 46 | 	# mean all available elements if no length specified
 47 | 	$length = scalar(@$self) if !defined $length;
 48 | 	
 49 | 	# get maximum available length from offset
 50 | 	my $max_length = scalar(@$self) - $offset;
 51 | 	
 52 | 	# handle negative length
 53 | 	$length = $max_length + $length if ($length < 0);
 54 | 	
 55 | 	# limit available length
 56 | 	$length = $max_length if ($length > $max_length);
 57 | 	
 58 | 	# validate length
 59 | 	return HTML5::DOM::Collection->new([]) if ($length <= 0);
 60 | 	
 61 | 	# return requested slice
 62 | 	return HTML5::DOM::Collection->new([@$self[$offset..$offset + $length - 1]]);
 63 | }
 64 | 
 65 | sub head {
 66 | 	my ($self, $length) = @_;
 67 | 	return $self->slice(0, $length);
 68 | }
 69 | 
 70 | sub tail {
 71 | 	my ($self, $length) = @_;
 72 | 	return $self->slice(-$length);
 73 | }
 74 | 
 75 | sub each {
 76 | 	my ($self, $callback) = (shift, shift);
 77 | 	my $index = 0;
 78 | 	for my $node (@$self) {
 79 | 		$callback->($node, $index++, @_);
 80 | 	}
 81 | 	return $self;
 82 | }
 83 | 
 84 | sub uniq {
 85 | 	my ($self, $callback) = (shift, shift);
 86 | 	my %used;
 87 | 	return HTML5::DOM::Collection->new([grep { my $id = $_->$callback(@_); !$used{defined($id) ? $id : ''}++ } @$self]) if ($callback);
 88 | 	return HTML5::DOM::Collection->new([grep { !$used{$_->hash}++ } @$self]);
 89 | }
 90 | 
 91 | sub grep {
 92 | 	my ($self, $callback) = (shift, shift);
 93 | 	return HTML5::DOM::Collection->new([grep { $_ =~ $callback } @$self]) if (_is_regexp($callback));
 94 | 	return HTML5::DOM::Collection->new([grep { $_->$callback(@_) } @$self]);
 95 | }
 96 | 
 97 | sub reverse {
 98 | 	my ($self) = @_;
 99 | 	return HTML5::DOM::Collection->new([reverse @$self]);
100 | }
101 | 
102 | sub shuffle {
103 | 	my ($self) = @_;
104 | 	return HTML5::DOM::Collection->new([List::Util::shuffle @$self]);
105 | }
106 | 
107 | sub map {
108 | 	my ($self, $callback) = (shift, shift);
109 | 	if (ref($callback) eq 'CODE') {
110 | 		my $index = 0;
111 | 		return HTML5::DOM::Collection->new([map { $_->$callback($index++, @_) } @$self]);
112 | 	} else {
113 | 		return HTML5::DOM::Collection->new([map { $_->$callback(@_) } @$self]);
114 | 	}
115 | }
116 | 
117 | sub text {
118 | 	my @nodes;
119 | 	for my $node (@{shift()}) {
120 | 		push @nodes, $node->text;
121 | 	}
122 | 	return join("", @nodes);
123 | }
124 | 
125 | sub html {
126 | 	my @nodes;
127 | 	for my $node (@{shift()}) {
128 | 		push @nodes, $node->html;
129 | 	}
130 | 	return join("", @nodes);
131 | }
132 | 
133 | sub _is_regexp {
134 | 	return ref($_[0]) eq 'Regexp' || ref(\$_[0]) eq 'Regexp';
135 | }
136 | 
137 | 1;
138 | 


--------------------------------------------------------------------------------
/scripts/gen.pl:
--------------------------------------------------------------------------------
  1 | #!/user/bin/perl
  2 | use warnings;
  3 | use strict;
  4 | 
  5 | use File::Slurp qw|read_file write_file|;
  6 | use File::Basename qw|dirname|;
  7 | use POSIX;
  8 | use Pod::Markdown::Github;
  9 | 
 10 | genReadmeMd();
 11 | genTagsDisplayProp();
 12 | genErrorCodes();
 13 | getConstants();
 14 | 
 15 | sub genReadmeMd {
 16 | 	my $pod = read_file(dirname(__FILE__)."/../lib/HTML5/DOM.pod");
 17 | 	my $markdown;
 18 | 	my $parser = Pod::Markdown::Github->new;
 19 | 	$parser->output_string(\$markdown);
 20 | 	$parser->parse_string_document($pod);
 21 | 	
 22 | 	my $fix = sub {
 23 | 		my $value = shift;
 24 | 		$value =~ s/-//g;
 25 | 		return $value;
 26 | 	};
 27 | 	
 28 | 	$markdown =~ s/(\(#html5-dom[\w\d_-]*\))/$fix->($1)/ge;
 29 | 	
 30 | 	write_file(dirname(__FILE__)."/../README.md", {binmode => ':utf8'}, $markdown);
 31 | }
 32 | 
 33 | sub genTagsDisplayProp {
 34 | 	my $text = read_file(dirname(__FILE__).'/tags.txt');
 35 | 	my $tmp = "";
 36 | 	while ($text =~ /([\w\d_-]+)\s+([\w\d_-]+)/gi) {
 37 | 		my ($tag, $display) = ($1, $2);
 38 | 		
 39 | 		$display = uc($display);
 40 | 		$display =~ s/-/_/g;
 41 | 		$display = "TAG_UA_STYLE_$display";
 42 | 		
 43 | 		$tag = uc($tag);
 44 | 		$tag =~ s/-/_/g;
 45 | 		$tag = "MyHTML_TAG_$tag";
 46 | 		
 47 | 		$tmp .= "case $tag:\n\treturn $display;\n";
 48 | 		
 49 | 		print "$tag -> $display\n";
 50 | 	}
 51 | 	write_file(dirname(__FILE__)."/../gen/tags_ua_style.c", $tmp);
 52 | }
 53 | 
 54 | sub genErrorCodes {
 55 | 	# errors codes
 56 | 	my $files = [
 57 | 		{
 58 | 			file	=> dirname(__FILE__).'/../third_party/modest/source/modest/myosi.h', 
 59 | 			prefix	=> 'MODEST_STATUS_'
 60 | 		}, 
 61 | 		{
 62 | 			file	=> dirname(__FILE__).'/../third_party/modest/source/mycss/api.h', 
 63 | 			prefix	=> 'MyCSS_STATUS_'
 64 | 		}, 
 65 | 		{
 66 | 			file	=> dirname(__FILE__).'/../third_party/modest/source/myhtml/myosi.h', 
 67 | 			prefix	=> 'MyHTML_STATUS_'
 68 | 		}
 69 | 	];
 70 | 
 71 | 	my $tmp = "";
 72 | 	for my $cfg (@$files) {
 73 | 		my $source = read_file($cfg->{file});
 74 | 		my $prefix = $cfg->{prefix};
 75 | 		while ($source =~ /($prefix[\w\d_-]+)\s*=\s*([a-fx\d]+)/gim) {
 76 | 			my ($key, $value) = ($1, eval $2);
 77 | 			next if ($key eq $prefix."OK");
 78 | 			$tmp .= "case $key:\n\treturn \"$key\";\n";
 79 | 		}
 80 | 		
 81 | 		print $cfg->{file}." - error names ok\n";
 82 | 	}
 83 | 	
 84 | 	write_file(dirname(__FILE__)."/../gen/modest_errors.c", $tmp);
 85 | }
 86 | 
 87 | sub getConstants {
 88 | 	my $files = [
 89 | 		{
 90 | 			header		=> dirname(__FILE__).'/../third_party/modest/include/myencoding/myosi.h', 
 91 | 			lib			=> dirname(__FILE__).'/../lib/HTML5/DOM/Encoding.pm', 
 92 | 			macro		=> 'MyENCODING_const', 
 93 | 			prefix		=> 'MyENCODING_', 
 94 | 			prefix_new	=> ''
 95 | 		}, 
 96 | 		{
 97 | 			header		=> dirname(__FILE__).'/../third_party/modest/include/myhtml/tag_const.h', 
 98 | 			lib			=> dirname(__FILE__).'/../lib/HTML5/DOM.pm', 
 99 | 			macro		=> 'MyHTML_tags', 
100 | 			prefix		=> 'MyHTML_TAG_', 
101 | 			prefix_new	=> 'TAG_'
102 | 		}, 
103 | 		{
104 | 			header		=> dirname(__FILE__).'/../third_party/modest/include/myhtml/myosi.h', 
105 | 			lib			=> dirname(__FILE__).'/../lib/HTML5/DOM.pm', 
106 | 			macro		=> 'MyHTML_ns', 
107 | 			prefix		=> 'MyHTML_NAMESPACE_', 
108 | 			prefix_new	=> 'NS_'
109 | 		}
110 | 	];
111 | 	
112 | 	for my $cfg (@$files) {
113 | 		my $header = read_file($cfg->{header});
114 | 		my $lib = read_file($cfg->{lib});
115 | 		my $macro = $cfg->{macro};
116 | 		my $prefix = $cfg->{prefix};
117 | 		
118 | 		my @tmp;
119 | 		while ($header =~ /($prefix([\w\d_-]+))\s*=\s*([a-fx\d]+)/gim) {
120 | 			my ($key, $value) = ($cfg->{prefix_new}.$2, eval $3);
121 | 			next if ($key =~ /_STATUS_/);
122 | 			
123 | 			my $tabs = ceil(((6 * 4) - length($key)) / 4);
124 | 			
125 | 			push @tmp, "use constant\t$key".("\t" x $tabs)."=> ".sprintf("0x%x", $value).";";
126 | 		}
127 | 		
128 | 		my $txt = join("\n", @tmp);
129 | 		$lib =~ s/(<$macro>)(.*?)(#\s*<\/$macro>)/$1\n$txt\n$3/gims;
130 | 		
131 | 		write_file($cfg->{lib}, $lib);
132 | 		
133 | 		print $cfg->{lib}." - consts `".$cfg->{prefix}."` from ".$cfg->{header}."\n";
134 | 	}
135 | }
136 | 
137 | # encodings
138 | 
139 | 


--------------------------------------------------------------------------------
/gen/tags_ua_style.c:
--------------------------------------------------------------------------------
  1 | case MyHTML_TAG_ARTICLE:
  2 | 	return TAG_UA_STYLE_BLOCK;
  3 | case MyHTML_TAG_ASIDE:
  4 | 	return TAG_UA_STYLE_BLOCK;
  5 | case MyHTML_TAG_DETAILS:
  6 | 	return TAG_UA_STYLE_BLOCK;
  7 | case MyHTML_TAG_DIV:
  8 | 	return TAG_UA_STYLE_BLOCK;
  9 | case MyHTML_TAG_DT:
 10 | 	return TAG_UA_STYLE_BLOCK;
 11 | case MyHTML_TAG_FIGCAPTION:
 12 | 	return TAG_UA_STYLE_BLOCK;
 13 | case MyHTML_TAG_FOOTER:
 14 | 	return TAG_UA_STYLE_BLOCK;
 15 | case MyHTML_TAG_FORM:
 16 | 	return TAG_UA_STYLE_BLOCK;
 17 | case MyHTML_TAG_HEADER:
 18 | 	return TAG_UA_STYLE_BLOCK;
 19 | case MyHTML_TAG_HGROUP:
 20 | 	return TAG_UA_STYLE_BLOCK;
 21 | case MyHTML_TAG_HTML:
 22 | 	return TAG_UA_STYLE_BLOCK;
 23 | case MyHTML_TAG_MAIN:
 24 | 	return TAG_UA_STYLE_BLOCK;
 25 | case MyHTML_TAG_NAV:
 26 | 	return TAG_UA_STYLE_BLOCK;
 27 | case MyHTML_TAG_SECTION:
 28 | 	return TAG_UA_STYLE_BLOCK;
 29 | case MyHTML_TAG_SUMMARY:
 30 | 	return TAG_UA_STYLE_BLOCK;
 31 | case MyHTML_TAG_BODY:
 32 | 	return TAG_UA_STYLE_BLOCK;
 33 | case MyHTML_TAG_P:
 34 | 	return TAG_UA_STYLE_BLOCK;
 35 | case MyHTML_TAG_DL:
 36 | 	return TAG_UA_STYLE_BLOCK;
 37 | case MyHTML_TAG_DD:
 38 | 	return TAG_UA_STYLE_BLOCK;
 39 | case MyHTML_TAG_BLOCKQUOTE:
 40 | 	return TAG_UA_STYLE_BLOCK;
 41 | case MyHTML_TAG_FIGURE:
 42 | 	return TAG_UA_STYLE_BLOCK;
 43 | case MyHTML_TAG_ADDRESS:
 44 | 	return TAG_UA_STYLE_BLOCK;
 45 | case MyHTML_TAG_CENTER:
 46 | 	return TAG_UA_STYLE_BLOCK;
 47 | case MyHTML_TAG_H1:
 48 | 	return TAG_UA_STYLE_BLOCK;
 49 | case MyHTML_TAG_H2:
 50 | 	return TAG_UA_STYLE_BLOCK;
 51 | case MyHTML_TAG_H3:
 52 | 	return TAG_UA_STYLE_BLOCK;
 53 | case MyHTML_TAG_H4:
 54 | 	return TAG_UA_STYLE_BLOCK;
 55 | case MyHTML_TAG_H5:
 56 | 	return TAG_UA_STYLE_BLOCK;
 57 | case MyHTML_TAG_H6:
 58 | 	return TAG_UA_STYLE_BLOCK;
 59 | case MyHTML_TAG_XMP:
 60 | 	return TAG_UA_STYLE_BLOCK;
 61 | case MyHTML_TAG_PRE:
 62 | 	return TAG_UA_STYLE_BLOCK;
 63 | case MyHTML_TAG_PLAINTEXT:
 64 | 	return TAG_UA_STYLE_BLOCK;
 65 | case MyHTML_TAG_TABLE:
 66 | 	return TAG_UA_STYLE_TABLE;
 67 | case MyHTML_TAG_CAPTION:
 68 | 	return TAG_UA_STYLE_TABLE_CAPTION;
 69 | case MyHTML_TAG_TR:
 70 | 	return TAG_UA_STYLE_TABLE_ROW;
 71 | case MyHTML_TAG_COL:
 72 | 	return TAG_UA_STYLE_TABLE_COLUMN;
 73 | case MyHTML_TAG_COLGROUP:
 74 | 	return TAG_UA_STYLE_TABLE_COLUMN_GROUP;
 75 | case MyHTML_TAG_TBODY:
 76 | 	return TAG_UA_STYLE_TABLE_ROW_GROUP;
 77 | case MyHTML_TAG_THEAD:
 78 | 	return TAG_UA_STYLE_TABLE_HEADER_GROUP;
 79 | case MyHTML_TAG_TFOOT:
 80 | 	return TAG_UA_STYLE_TABLE_FOOTER_GROUP;
 81 | case MyHTML_TAG_TD:
 82 | 	return TAG_UA_STYLE_TABLE_CELL;
 83 | case MyHTML_TAG_TH:
 84 | 	return TAG_UA_STYLE_TABLE_CELL;
 85 | case MyHTML_TAG_UL:
 86 | 	return TAG_UA_STYLE_BLOCK;
 87 | case MyHTML_TAG_MENU:
 88 | 	return TAG_UA_STYLE_BLOCK;
 89 | case MyHTML_TAG_DIR:
 90 | 	return TAG_UA_STYLE_BLOCK;
 91 | case MyHTML_TAG_OL:
 92 | 	return TAG_UA_STYLE_BLOCK;
 93 | case MyHTML_TAG_LI:
 94 | 	return TAG_UA_STYLE_LIST_ITEM;
 95 | case MyHTML_TAG_HR:
 96 | 	return TAG_UA_STYLE_BLOCK;
 97 | case MyHTML_TAG_FRAMESET:
 98 | 	return TAG_UA_STYLE_BLOCK;
 99 | case MyHTML_TAG_LINK:
100 | 	return TAG_UA_STYLE_NONE;
101 | case MyHTML_TAG_NOFRAMES:
102 | 	return TAG_UA_STYLE_NONE;
103 | case MyHTML_TAG_BASE:
104 | 	return TAG_UA_STYLE_NONE;
105 | case MyHTML_TAG_BASEFONT:
106 | 	return TAG_UA_STYLE_NONE;
107 | case MyHTML_TAG_DATALIST:
108 | 	return TAG_UA_STYLE_NONE;
109 | case MyHTML_TAG_HEAD:
110 | 	return TAG_UA_STYLE_NONE;
111 | case MyHTML_TAG_META:
112 | 	return TAG_UA_STYLE_NONE;
113 | case MyHTML_TAG_SCRIPT:
114 | 	return TAG_UA_STYLE_NONE;
115 | case MyHTML_TAG_STYLE:
116 | 	return TAG_UA_STYLE_NONE;
117 | case MyHTML_TAG_TITLE:
118 | 	return TAG_UA_STYLE_NONE;
119 | case MyHTML_TAG_NOEMBED:
120 | 	return TAG_UA_STYLE_NONE;
121 | case MyHTML_TAG_PARAM:
122 | 	return TAG_UA_STYLE_NONE;
123 | case MyHTML_TAG_TEMPLATE:
124 | 	return TAG_UA_STYLE_NONE;
125 | case MyHTML_TAG_AREA:
126 | 	return TAG_UA_STYLE_NONE;
127 | case MyHTML_TAG_MARQUEE:
128 | 	return TAG_UA_STYLE_INLINE_BLOCK;
129 | case MyHTML_TAG_RUBY:
130 | 	return TAG_UA_STYLE_RUBY;
131 | case MyHTML_TAG_RB:
132 | 	return TAG_UA_STYLE_RUBY_BASE;
133 | case MyHTML_TAG_RP:
134 | 	return TAG_UA_STYLE_NONE;
135 | case MyHTML_TAG_RT:
136 | 	return TAG_UA_STYLE_RUBY_TEXT;
137 | case MyHTML_TAG_RTC:
138 | 	return TAG_UA_STYLE_RUBY_TEXT_CONTAINER;
139 | case MyHTML_TAG_LEGEND:
140 | 	return TAG_UA_STYLE_BLOCK;
141 | case MyHTML_TAG_FIELDSET:
142 | 	return TAG_UA_STYLE_BLOCK;
143 | case MyHTML_TAG_SELECT:
144 | 	return TAG_UA_STYLE_INLINE_BLOCK;
145 | case MyHTML_TAG_OPTION:
146 | 	return TAG_UA_STYLE_BLOCK;
147 | case MyHTML_TAG_OPTGROUP:
148 | 	return TAG_UA_STYLE_BLOCK;
149 | case MyHTML_TAG_BUTTON:
150 | 	return TAG_UA_STYLE_INLINE_BLOCK;
151 | case MyHTML_TAG_PROGRESS:
152 | 	return TAG_UA_STYLE_INLINE_BLOCK;
153 | case MyHTML_TAG_METER:
154 | 	return TAG_UA_STYLE_INLINE_BLOCK;
155 | 


--------------------------------------------------------------------------------
/utils.h:
--------------------------------------------------------------------------------
  1 | #ifndef HTML5_DOM_UTILS_H
  2 | #define HTML5_DOM_UTILS_H
  3 | #pragma once
  4 | 
  5 | // Portable utils for ports to other languages
  6 | // Contains only code who independent of perl 
  7 | 
  8 | #define MyENCODING_AUTO 1
  9 | 
 10 | #define node_is_element(node) (node->tag_id != MyHTML_TAG__UNDEF && node->tag_id != MyHTML_TAG__TEXT && node->tag_id != MyHTML_TAG__COMMENT && node->tag_id != MyHTML_TAG__DOCTYPE)
 11 | #define node_is_document(node) (!node->parent && node == node->tree->document)
 12 | #define node_is_root(node) (node->tree->node_html && node->tree->node_html == node)
 13 | #define html5_dom_is_fragment(node) (((html5_dom_tree_t *) node->tree->context)->fragment_tag_id && node->tag_id == ((html5_dom_tree_t *) node->tree->context)->fragment_tag_id)
 14 | 
 15 | #if (defined(_WIN32) || defined(_WIN64))
 16 | 	#define MyCORE_OS_WINDOWS_NT
 17 | #endif
 18 | 
 19 | #include <stdio.h>
 20 | #include <ctype.h>
 21 | 
 22 | #ifdef MyCORE_OS_WINDOWS_NT
 23 | 	// for _write
 24 | 	#include <io.h>
 25 | #else
 26 | 	// for write
 27 | 	#include <unistd.h>
 28 | #endif
 29 | 
 30 | #include <modest/finder/finder.h>
 31 | #include <myhtml/myhtml.h>
 32 | #include <myhtml/serialization.h>
 33 | #include <mycss/mycss.h>
 34 | #include <mycss/selectors/init.h>
 35 | #include <mycss/selectors/serialization.h>
 36 | 
 37 | typedef struct {
 38 | 	long threads;
 39 | 	bool ignore_whitespace;
 40 | 	bool ignore_doctype;
 41 | 	bool scripts;
 42 | 	myencoding_t encoding;
 43 | 	myencoding_t default_encoding;
 44 | 	bool encoding_use_meta;
 45 | 	bool encoding_use_bom;
 46 | 	long encoding_prescan_limit;
 47 | 	int utf8; // 0 - off, 1 - on, 2 - auto (detect by input)
 48 | } html5_dom_options_t;
 49 | 
 50 | typedef struct {
 51 | 	myhtml_t *myhtml;
 52 | 	myhtml_tree_t *tree;
 53 | 	mycss_t *mycss;
 54 | 	mycss_entry_t *mycss_entry;
 55 | 	modest_finder_t *finder;
 56 | 	html5_dom_options_t opts; // base options
 57 | 	html5_dom_options_t chunk_opts; // for parseChunk
 58 | 	size_t chunks;
 59 | } html5_dom_parser_t;
 60 | 
 61 | typedef struct {
 62 | 	void *parent;
 63 | 	void *sv;
 64 | 	myhtml_tree_t *tree;
 65 | 	html5_dom_parser_t *parser;
 66 | 	myhtml_tag_id_t fragment_tag_id;
 67 | 	bool utf8;
 68 | 	bool used;
 69 | } html5_dom_tree_t;
 70 | 
 71 | typedef struct {
 72 | 	mycss_t *mycss;
 73 | 	mycss_entry_t *entry;
 74 | 	myencoding_t encoding;
 75 | 	int utf8; // 0 - off, 1 - on, 2 - auto (detect by input)
 76 | 	html5_dom_options_t opts;
 77 | } html5_css_parser_t;
 78 | 
 79 | typedef struct {
 80 | 	html5_css_parser_t *parser;
 81 | 	mycss_selectors_list_t *list;
 82 | 	void *parent;
 83 | 	bool utf8;
 84 | } html5_css_selector_t;
 85 | 
 86 | typedef struct {
 87 | 	html5_css_selector_t *selector;
 88 | 	mycss_selectors_entries_list_t *list;
 89 | 	void *parent;
 90 | } html5_css_selector_entry_t;
 91 | 
 92 | typedef struct {
 93 | 	mythread_t *thread;
 94 | 	int fd;
 95 | 	
 96 | 	// output tree
 97 | 	myhtml_tree_t *tree;
 98 | 	html5_dom_parser_t *parser;
 99 | 	void *tree_sv;
100 | 	
101 | 	// status
102 | 	mystatus_t status;
103 | 	bool done;
104 | 	
105 | 	// input html
106 | 	char *html;
107 | 	size_t length;
108 | 	
109 | 	html5_dom_options_t opts;
110 | } html5_dom_async_result;
111 | 
112 | typedef struct {
113 | 	myhtml_tree_node_t *node_html;
114 | 	myhtml_tree_node_t *node_body;
115 | 	myhtml_tree_node_t *node_head;
116 | 	myhtml_tree_node_t *document;
117 | } html5_fragment_parts_t;
118 | 
119 | typedef struct {
120 | 	bool new_line;
121 | 	bool last_br;
122 | 	mycore_string_t value;
123 | } html5_dom_inner_text_state_t;
124 | 
125 | // https://developer.mozilla.org/pl/docs/Web/API/Element/nodeType
126 | enum {
127 | 	ELEMENT_NODE					= 1, 
128 | 	ATTRIBUTE_NODE					= 2, 
129 | 	TEXT_NODE						= 3, 
130 | 	CDATA_SECTION_NODE				= 4, 
131 | 	ENTITY_REFERENCE_NODE			= 5, 
132 | 	ENTITY_NODE						= 6, 
133 | 	PROCESSING_INSTRUCTION_NODE		= 7, 
134 | 	COMMENT_NODE					= 8, 
135 | 	DOCUMENT_NODE					= 9, 
136 | 	DOCUMENT_TYPE_NODE				= 10, 
137 | 	DOCUMENT_FRAGMENT_NODE			= 11, 
138 | 	NOTATION_NODE					= 12
139 | };
140 | 
141 | enum {
142 | 	TAG_UA_STYLE_NONE					= 0, 
143 | 	TAG_UA_STYLE_INLINE					= 1, 
144 | 	TAG_UA_STYLE_BLOCK					= 2, 
145 | 	TAG_UA_STYLE_INLINE_BLOCK			= 3, 
146 | 	TAG_UA_STYLE_LIST_ITEM				= 4, 
147 | 	TAG_UA_STYLE_TABLE					= 5, 
148 | 	TAG_UA_STYLE_TABLE_CAPTION			= 6, 
149 | 	TAG_UA_STYLE_TABLE_CELL				= 7, 
150 | 	TAG_UA_STYLE_TABLE_COLUMN			= 8, 
151 | 	TAG_UA_STYLE_TABLE_COLUMN_GROUP		= 9, 
152 | 	TAG_UA_STYLE_TABLE_FOOTER_GROUP		= 10, 
153 | 	TAG_UA_STYLE_TABLE_HEADER_GROUP		= 11, 
154 | 	TAG_UA_STYLE_TABLE_ROW				= 12, 
155 | 	TAG_UA_STYLE_TABLE_ROW_GROUP		= 13, 
156 | 	TAG_UA_STYLE_RUBY					= 14, 
157 | 	TAG_UA_STYLE_RUBY_BASE				= 15, 
158 | 	TAG_UA_STYLE_RUBY_TEXT				= 16, 
159 | 	TAG_UA_STYLE_RUBY_TEXT_CONTAINER	= 17, 
160 | };
161 | 
162 | // async parsing
163 | void *html5_dom_mythread_function(void *arg);
164 | void html5_dom_async_parse_worker(mythread_id_t thread_id, void *arg);
165 | int html5_dom_async_parse(html5_dom_async_result *result);
166 | 
167 | // parser
168 | html5_dom_parser_t *html5_dom_parser_new(html5_dom_options_t *options);
169 | void *html5_dom_parser_free(html5_dom_parser_t *self);
170 | mystatus_t html5_dom_init_css(html5_dom_parser_t *parser);
171 | myhtml_tree_node_t *html5_dom_parse_fragment(html5_dom_options_t *opts, myhtml_tree_t *tree, myhtml_tag_id_t tag_id, myhtml_namespace_t ns, 
172 | 	const char *text, size_t length, html5_fragment_parts_t *parts, mystatus_t *status_out);
173 | void html5_dom_apply_tree_options(myhtml_tree_t *tree, html5_dom_options_t *opts);
174 | 
175 | // misc
176 | const char *modest_strerror(mystatus_t status);
177 | int html5_dom_get_ua_display_prop(myhtml_tree_node_t *node);
178 | void html5_dom_rtrim_mystring(mycore_string_t *str, char c);
179 | 
180 | // finders & css
181 | void _modest_finder_callback_found_with_one_node(modest_finder_t *finder, myhtml_tree_node_t *node, 
182 | 	mycss_selectors_list_t *selector_list, mycss_selectors_entry_t *selector, mycss_selectors_specificity_t *spec, void *ctx);
183 | void *html5_node_finder(html5_dom_parser_t *parser, modest_finder_selector_combinator_f func, 
184 | 		myhtml_tree_node_t *scope, mycss_selectors_entries_list_t *list, size_t list_size, mystatus_t *status_out, bool one);
185 | modest_finder_selector_combinator_f html5_find_selector_func(const char *c, int combo_len);
186 | mycss_selectors_list_t *html5_parse_selector(mycss_entry_t *entry, const char *query, size_t query_len, mystatus_t *status_out);
187 | myhtml_tag_id_t html5_dom_tag_id_by_name(myhtml_tree_t *tree, const char *tag_str, size_t tag_len, bool allow_create);
188 | myhtml_tree_node_t *html5_dom_copy_foreign_node(myhtml_tree_t *tree, myhtml_tree_node_t *node);
189 | myhtml_tree_node_t *html5_dom_recursive_clone_node(myhtml_tree_t *tree, myhtml_tree_node_t *node, html5_fragment_parts_t *parts);
190 | void html5_dom_recursive_node_inner_text(myhtml_tree_node_t *node, html5_dom_inner_text_state_t *state);
191 | void html5_tree_node_delete_recursive(myhtml_tree_node_t *node);
192 | 
193 | // attrs
194 | void html5_dom_replace_attr_value(myhtml_tree_node_t *node, const char *key, size_t key_len, const char *val, size_t val_len, myencoding_t encoding);
195 | 
196 | // encoding
197 | myencoding_t html5_dom_auto_encoding(html5_dom_options_t *opts, const char **html_str, size_t *html_length);
198 | 
199 | #endif /* HTML5_DOM_UTILS_H */
200 | 


--------------------------------------------------------------------------------
/gen/modest_errors.c:
--------------------------------------------------------------------------------
  1 | case MODEST_STATUS_ERROR:
  2 | 	return "MODEST_STATUS_ERROR";
  3 | case MODEST_STATUS_ERROR_MEMORY_ALLOCATION:
  4 | 	return "MODEST_STATUS_ERROR_MEMORY_ALLOCATION";
  5 | case MODEST_STATUS_ERROR_MNODE_CREATE:
  6 | 	return "MODEST_STATUS_ERROR_MNODE_CREATE";
  7 | case MODEST_STATUS_ERROR_MNODE_INIT:
  8 | 	return "MODEST_STATUS_ERROR_MNODE_INIT";
  9 | case MODEST_STATUS_ERROR_MNODE_NODE_ADD:
 10 | 	return "MODEST_STATUS_ERROR_MNODE_NODE_ADD";
 11 | case MODEST_STATUS_ERROR_STYLESHEET_CREATE:
 12 | 	return "MODEST_STATUS_ERROR_STYLESHEET_CREATE";
 13 | case MODEST_STATUS_ERROR_STYLESHEET_INIT:
 14 | 	return "MODEST_STATUS_ERROR_STYLESHEET_INIT";
 15 | case MODEST_STATUS_ERROR_STYLESHEET_NODE_ADD:
 16 | 	return "MODEST_STATUS_ERROR_STYLESHEET_NODE_ADD";
 17 | case MODEST_STATUS_ERROR_STYLE_TYPE_CREATE:
 18 | 	return "MODEST_STATUS_ERROR_STYLE_TYPE_CREATE";
 19 | case MODEST_STATUS_ERROR_STYLE_TYPE_NODE_ADD:
 20 | 	return "MODEST_STATUS_ERROR_STYLE_TYPE_NODE_ADD";
 21 | case MODEST_STATUS_ERROR_STYLE_DECLARATION_CREATE:
 22 | 	return "MODEST_STATUS_ERROR_STYLE_DECLARATION_CREATE";
 23 | case MODEST_STATUS_ERROR_STYLE_DECLARATION_INIT:
 24 | 	return "MODEST_STATUS_ERROR_STYLE_DECLARATION_INIT";
 25 | case MODEST_STATUS_ERROR_AVL_TREE_CREATE:
 26 | 	return "MODEST_STATUS_ERROR_AVL_TREE_CREATE";
 27 | case MODEST_STATUS_ERROR_AVL_TREE_INIT:
 28 | 	return "MODEST_STATUS_ERROR_AVL_TREE_INIT";
 29 | case MyCSS_STATUS_ERROR_MEMORY_ALLOCATION:
 30 | 	return "MyCSS_STATUS_ERROR_MEMORY_ALLOCATION";
 31 | case MyCSS_STATUS_ERROR_TOKENIZER_STATE_ALLOCATION:
 32 | 	return "MyCSS_STATUS_ERROR_TOKENIZER_STATE_ALLOCATION";
 33 | case MyCSS_STATUS_ERROR_TOKENIZER_INCOMING_BUFFER_ADD:
 34 | 	return "MyCSS_STATUS_ERROR_TOKENIZER_INCOMING_BUFFER_ADD";
 35 | case MyCSS_STATUS_ERROR_TOKENIZER_TOKEN_ALLOCATION:
 36 | 	return "MyCSS_STATUS_ERROR_TOKENIZER_TOKEN_ALLOCATION";
 37 | case MyCSS_STATUS_ERROR_INCOMING_BUFFER_INIT:
 38 | 	return "MyCSS_STATUS_ERROR_INCOMING_BUFFER_INIT";
 39 | case MyCSS_STATUS_ERROR_ENTRY_INCOMING_BUFFER_CREATE:
 40 | 	return "MyCSS_STATUS_ERROR_ENTRY_INCOMING_BUFFER_CREATE";
 41 | case MyCSS_STATUS_ERROR_ENTRY_INCOMING_BUFFER_INIT:
 42 | 	return "MyCSS_STATUS_ERROR_ENTRY_INCOMING_BUFFER_INIT";
 43 | case MyCSS_STATUS_ERROR_ENTRY_TOKEN_INCOMING_BUFFER_INIT:
 44 | 	return "MyCSS_STATUS_ERROR_ENTRY_TOKEN_INCOMING_BUFFER_INIT";
 45 | case MyCSS_STATUS_ERROR_ENTRY_TOKEN_NODE_ADD:
 46 | 	return "MyCSS_STATUS_ERROR_ENTRY_TOKEN_NODE_ADD";
 47 | case MyCSS_STATUS_ERROR_SELECTORS_CREATE:
 48 | 	return "MyCSS_STATUS_ERROR_SELECTORS_CREATE";
 49 | case MyCSS_STATUS_ERROR_SELECTORS_ENTRIES_CREATE:
 50 | 	return "MyCSS_STATUS_ERROR_SELECTORS_ENTRIES_CREATE";
 51 | case MyCSS_STATUS_ERROR_SELECTORS_ENTRIES_INIT:
 52 | 	return "MyCSS_STATUS_ERROR_SELECTORS_ENTRIES_INIT";
 53 | case MyCSS_STATUS_ERROR_SELECTORS_ENTRIES_NODE_ADD:
 54 | 	return "MyCSS_STATUS_ERROR_SELECTORS_ENTRIES_NODE_ADD";
 55 | case MyCSS_STATUS_ERROR_SELECTORS_LIST_CREATE:
 56 | 	return "MyCSS_STATUS_ERROR_SELECTORS_LIST_CREATE";
 57 | case MyCSS_STATUS_ERROR_SELECTORS_LIST_INIT:
 58 | 	return "MyCSS_STATUS_ERROR_SELECTORS_LIST_INIT";
 59 | case MyCSS_STATUS_ERROR_SELECTORS_LIST_ADD_NODE:
 60 | 	return "MyCSS_STATUS_ERROR_SELECTORS_LIST_ADD_NODE";
 61 | case MyCSS_STATUS_ERROR_NAMESPACE_CREATE:
 62 | 	return "MyCSS_STATUS_ERROR_NAMESPACE_CREATE";
 63 | case MyCSS_STATUS_ERROR_NAMESPACE_INIT:
 64 | 	return "MyCSS_STATUS_ERROR_NAMESPACE_INIT";
 65 | case MyCSS_STATUS_ERROR_NAMESPACE_ENTRIES_CREATE:
 66 | 	return "MyCSS_STATUS_ERROR_NAMESPACE_ENTRIES_CREATE";
 67 | case MyCSS_STATUS_ERROR_NAMESPACE_ENTRIES_INIT:
 68 | 	return "MyCSS_STATUS_ERROR_NAMESPACE_ENTRIES_INIT";
 69 | case MyCSS_STATUS_ERROR_NAMESPACE_NODE_ADD:
 70 | 	return "MyCSS_STATUS_ERROR_NAMESPACE_NODE_ADD";
 71 | case MyCSS_STATUS_ERROR_MEDIA_CREATE:
 72 | 	return "MyCSS_STATUS_ERROR_MEDIA_CREATE";
 73 | case MyCSS_STATUS_ERROR_STRING_CREATE:
 74 | 	return "MyCSS_STATUS_ERROR_STRING_CREATE";
 75 | case MyCSS_STATUS_ERROR_STRING_INIT:
 76 | 	return "MyCSS_STATUS_ERROR_STRING_INIT";
 77 | case MyCSS_STATUS_ERROR_STRING_NODE_INIT:
 78 | 	return "MyCSS_STATUS_ERROR_STRING_NODE_INIT";
 79 | case MyCSS_STATUS_ERROR_AN_PLUS_B_CREATE:
 80 | 	return "MyCSS_STATUS_ERROR_AN_PLUS_B_CREATE";
 81 | case MyCSS_STATUS_ERROR_AN_PLUS_B_INIT:
 82 | 	return "MyCSS_STATUS_ERROR_AN_PLUS_B_INIT";
 83 | case MyCSS_STATUS_ERROR_DECLARATION_CREATE:
 84 | 	return "MyCSS_STATUS_ERROR_DECLARATION_CREATE";
 85 | case MyCSS_STATUS_ERROR_DECLARATION_INIT:
 86 | 	return "MyCSS_STATUS_ERROR_DECLARATION_INIT";
 87 | case MyCSS_STATUS_ERROR_DECLARATION_ENTRY_CREATE:
 88 | 	return "MyCSS_STATUS_ERROR_DECLARATION_ENTRY_CREATE";
 89 | case MyCSS_STATUS_ERROR_DECLARATION_ENTRY_INIT:
 90 | 	return "MyCSS_STATUS_ERROR_DECLARATION_ENTRY_INIT";
 91 | case MyCSS_STATUS_ERROR_PARSER_LIST_CREATE:
 92 | 	return "MyCSS_STATUS_ERROR_PARSER_LIST_CREATE";
 93 | case MyHTML_STATUS_ERROR:
 94 | 	return "MyHTML_STATUS_ERROR";
 95 | case MyHTML_STATUS_ERROR_MEMORY_ALLOCATION:
 96 | 	return "MyHTML_STATUS_ERROR_MEMORY_ALLOCATION";
 97 | case MyHTML_STATUS_RULES_ERROR_MEMORY_ALLOCATION:
 98 | 	return "MyHTML_STATUS_RULES_ERROR_MEMORY_ALLOCATION";
 99 | case MyHTML_STATUS_TOKENIZER_ERROR_MEMORY_ALLOCATION:
100 | 	return "MyHTML_STATUS_TOKENIZER_ERROR_MEMORY_ALLOCATION";
101 | case MyHTML_STATUS_TOKENIZER_ERROR_FRAGMENT_INIT:
102 | 	return "MyHTML_STATUS_TOKENIZER_ERROR_FRAGMENT_INIT";
103 | case MyHTML_STATUS_TAGS_ERROR_MEMORY_ALLOCATION:
104 | 	return "MyHTML_STATUS_TAGS_ERROR_MEMORY_ALLOCATION";
105 | case MyHTML_STATUS_TAGS_ERROR_MCOBJECT_CREATE:
106 | 	return "MyHTML_STATUS_TAGS_ERROR_MCOBJECT_CREATE";
107 | case MyHTML_STATUS_TAGS_ERROR_MCOBJECT_MALLOC:
108 | 	return "MyHTML_STATUS_TAGS_ERROR_MCOBJECT_MALLOC";
109 | case MyHTML_STATUS_TAGS_ERROR_MCOBJECT_CREATE_NODE:
110 | 	return "MyHTML_STATUS_TAGS_ERROR_MCOBJECT_CREATE_NODE";
111 | case MyHTML_STATUS_TAGS_ERROR_CACHE_MEMORY_ALLOCATION:
112 | 	return "MyHTML_STATUS_TAGS_ERROR_CACHE_MEMORY_ALLOCATION";
113 | case MyHTML_STATUS_TAGS_ERROR_INDEX_MEMORY_ALLOCATION:
114 | 	return "MyHTML_STATUS_TAGS_ERROR_INDEX_MEMORY_ALLOCATION";
115 | case MyHTML_STATUS_TREE_ERROR_MEMORY_ALLOCATION:
116 | 	return "MyHTML_STATUS_TREE_ERROR_MEMORY_ALLOCATION";
117 | case MyHTML_STATUS_TREE_ERROR_MCOBJECT_CREATE:
118 | 	return "MyHTML_STATUS_TREE_ERROR_MCOBJECT_CREATE";
119 | case MyHTML_STATUS_TREE_ERROR_MCOBJECT_INIT:
120 | 	return "MyHTML_STATUS_TREE_ERROR_MCOBJECT_INIT";
121 | case MyHTML_STATUS_TREE_ERROR_MCOBJECT_CREATE_NODE:
122 | 	return "MyHTML_STATUS_TREE_ERROR_MCOBJECT_CREATE_NODE";
123 | case MyHTML_STATUS_TREE_ERROR_INCOMING_BUFFER_CREATE:
124 | 	return "MyHTML_STATUS_TREE_ERROR_INCOMING_BUFFER_CREATE";
125 | case MyHTML_STATUS_ATTR_ERROR_ALLOCATION:
126 | 	return "MyHTML_STATUS_ATTR_ERROR_ALLOCATION";
127 | case MyHTML_STATUS_ATTR_ERROR_CREATE:
128 | 	return "MyHTML_STATUS_ATTR_ERROR_CREATE";
129 | case MyHTML_STATUS_STREAM_BUFFER_ERROR_CREATE:
130 | 	return "MyHTML_STATUS_STREAM_BUFFER_ERROR_CREATE";
131 | case MyHTML_STATUS_STREAM_BUFFER_ERROR_INIT:
132 | 	return "MyHTML_STATUS_STREAM_BUFFER_ERROR_INIT";
133 | case MyHTML_STATUS_STREAM_BUFFER_ENTRY_ERROR_CREATE:
134 | 	return "MyHTML_STATUS_STREAM_BUFFER_ENTRY_ERROR_CREATE";
135 | case MyHTML_STATUS_STREAM_BUFFER_ENTRY_ERROR_INIT:
136 | 	return "MyHTML_STATUS_STREAM_BUFFER_ENTRY_ERROR_INIT";
137 | case MyHTML_STATUS_STREAM_BUFFER_ERROR_ADD_ENTRY:
138 | 	return "MyHTML_STATUS_STREAM_BUFFER_ERROR_ADD_ENTRY";
139 | 


--------------------------------------------------------------------------------
/examples/html5lib_tests.pl:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl
  2 | package main;
  3 | 
  4 | use warnings;
  5 | use strict;
  6 | 
  7 | use HTML5::DOM;
  8 | use Data::Dumper;
  9 | use Getopt::Long;
 10 | use File::Slurp qw|read_file write_file read_dir|;
 11 | use List::Util qw|min max|;
 12 | 
 13 | my $show_help			= 0;
 14 | my $enable_diff			= 0;
 15 | my $enable_colordiff	= 0;
 16 | my $html5lib_tests_dir	= "";
 17 | 
 18 | GetOptions (
 19 | 	"dir=s"		=> \$html5lib_tests_dir, 
 20 | 	"diff"		=> \$enable_diff, 
 21 | 	"colordiff"	=> \$enable_colordiff, 
 22 | 	"help"		=> \$show_help
 23 | );
 24 | 
 25 | $enable_diff = 1 if ($enable_colordiff);
 26 | 
 27 | if ($show_help || !$html5lib_tests_dir) {
 28 | 	print "--dir			path to html5lib-tests/tree-construction\n";
 29 | 	print "--diff			enable diff between expected and result (if fail)\n";
 30 | 	print "--colordiff		enable color diff between expected and result (if fail)\n";
 31 | 	exit;
 32 | }
 33 | 
 34 | main();
 35 | 
 36 | sub main {
 37 | 	# html5lib tests sections:
 38 | 	#	data					- input data
 39 | 	#	document				- expected output
 40 | 	#	document-fragment		- context tag and namespace for fragments
 41 | 	#	errors
 42 | 	#	new-errors
 43 | 	#	script-off
 44 | 	#	script-on
 45 | 	my @tests;
 46 | 	for my $file (glob("$html5lib_tests_dir/*.dat")) {
 47 | 		my $test;
 48 | 		my $key;
 49 | 		my $test_id = 0;
 50 | 		for my $line (split(/\n/, read_file($file)."\n")) {
 51 | 			if ($line eq "#data") {
 52 | 				if ($test) {
 53 | 					$test->{document} =~ s/\n\n$//s;
 54 | 					$test->{data} =~ s/\n$//s;
 55 | 					push @tests, $test;
 56 | 				}
 57 | 				
 58 | 				$file =~ s/^\Q$html5lib_tests_dir\E\/?//g;
 59 | 				$test = {
 60 | 					file	=> $file, 
 61 | 					test_id	=> $test_id++
 62 | 				};
 63 | 			}
 64 | 			
 65 | 			if (substr($line, 0, 1) eq '#') {
 66 | 				$key = substr($line, 1);
 67 | 				$test->{$key} = "";
 68 | 			} else {
 69 | 				$test->{$key} .= $line."\n";
 70 | 			}
 71 | 		}
 72 | 	}
 73 | 	
 74 | 	my $stat = {
 75 | 		success		=> 0, 
 76 | 		failed		=> 0, 
 77 | 		skipped		=> 0, 
 78 | 		total		=> 0
 79 | 	};
 80 | 	my $stat_by_file = {};
 81 | 	for my $test (@tests) {
 82 | 		if ($test->{data}) {
 83 | 			my $root;
 84 | 			my $skip;
 85 | 			if ($test->{"document-fragment"}) {
 86 | 				my @parts = split(/\s+/, $test->{"document-fragment"});
 87 | 				my $tag = scalar(@parts) > 1 ? $parts[1] : $parts[0];
 88 | 				my $ns = scalar(@parts) > 1 ? $parts[0] : "html";
 89 | 				
 90 | 				my $tree = HTML5::DOM->new({
 91 | 					scripts	=> exists $test->{'script-on'} ? 1 : 0
 92 | 				})->parse('');
 93 | 				
 94 | 				$ns = "mathml" if ($ns eq 'math'); # fixme
 95 | 				
 96 | 				if ($tree->namespace2id($ns) == HTML5::DOM->NS_UNDEF) {
 97 | 					$skip = "Unsupported namespace `$ns`";
 98 | 				} else {
 99 | 					$root = $tree->parseFragment($test->{data}, $tag, $ns);
100 | 				}
101 | 			} else {
102 | 				$root = HTML5::DOM->new({
103 | 					scripts	=> exists $test->{'script-on'} ? 1 : 0
104 | 				})->parse($test->{data})->document;
105 | 			}
106 | 			
107 | 			if (!exists $stat_by_file->{$test->{file}}) {
108 | 				$stat_by_file->{$test->{file}} = {
109 | 					success		=> 0, 
110 | 					failed		=> 0, 
111 | 					skipped		=> 0, 
112 | 					total		=> 0
113 | 				};
114 | 			}
115 | 			
116 | 			++$stat->{total};
117 | 			++$stat_by_file->{$test->{file}}->{total};
118 | 			
119 | 			if ($skip) {
120 | 				dumpTest($test, undef, "$skip");
121 | 				++$stat->{skipped};
122 | 				++$stat_by_file->{$test->{file}}->{skipped};
123 | 			} else {
124 | 				my $result = printTree($root);
125 | 				if ($result ne $test->{document}) {
126 | 					dumpTest($test, $result, "unexpected result");
127 | 					++$stat->{failed};
128 | 					++$stat_by_file->{$test->{file}}->{failed};
129 | 				} else {
130 | 					++$stat->{success};
131 | 					++$stat_by_file->{$test->{file}}->{success};
132 | 				}
133 | 			}
134 | 		}
135 | 	}
136 | 	
137 | 	my $table = [['test', 'total', 'ok', 'fail', 'skip']];
138 | 	for my $file (sort { $stat_by_file->{$b}->{failed} <=> $stat_by_file->{$a}->{failed} } keys %$stat_by_file) {
139 | 		my $stat = $stat_by_file->{$file};
140 | 		push @$table, [$file, $stat->{total}, $stat->{success}, $stat->{failed}, $stat->{skipped}];
141 | 	}
142 | 	push @$table, ['summary', $stat->{total}, $stat->{success}, $stat->{failed}, $stat->{skipped}];
143 | 	
144 | 	printTable($table);
145 | }
146 | 
147 | # Dump test if failed
148 | sub dumpTest {
149 | 	my ($test, $result, $reason) = @_;
150 | 	
151 | 	print "[failed] Test #".$test->{test_id}." in ".$test->{file}.": $reason\n";
152 | 	print "--------------------------------------------------------------------\n";
153 | 	
154 | 	if (exists $test->{'script-on'} || exists $test->{'script-off'} || exists $test->{'document-fragment'}) {
155 | 		print "scripts: on\n" if (exists $test->{'script-on'});
156 | 		print "scripts: off\n" if (exists $test->{'script-off'});
157 | 		print "fragment: ".$test->{'document-fragment'}."\n" if (exists $test->{'document-fragment'});
158 | 		print "--------------------------------------------------------------------\n";
159 | 	}
160 | 	
161 | 	print $test->{data}."\n";
162 | 	print "--------------------------------------------------------------------\n";
163 | 	
164 | 	if (defined $result) {
165 | 		if ($enable_diff) {
166 | 			my $tmp_result_file = "/tmp/html5lib-test-$$-".int(rand(time))."-result.diff";
167 | 			my $tmp_expected_file = "/tmp/html5lib-test-$$-".int(rand(time))."-expected.diff";
168 | 			
169 | 			write_file($tmp_result_file, $result);
170 | 			write_file($tmp_expected_file, $test->{document});
171 | 			
172 | 			my $diff;
173 | 			if ($enable_colordiff) {
174 | 				$diff = `diff --label="result" --label="expected" -Naur "$tmp_result_file" "$tmp_expected_file" | colordiff`;
175 | 			} else {
176 | 				$diff = `diff --label="result" --label="expected" -Naur "$tmp_result_file" "$tmp_expected_file"`;
177 | 			}
178 | 			
179 | 			unlink($tmp_result_file);
180 | 			unlink($tmp_expected_file);
181 | 			
182 | 			print $diff;
183 | 			print "--------------------------------------------------------------------\n";
184 | 		} else {
185 | 			print $test->{document}."\n";
186 | 			print "--------------------------------------------------------------------\n";
187 | 			
188 | 			print $result."\n";
189 | 			print "--------------------------------------------------------------------\n";
190 | 		}
191 | 	}
192 | 	
193 | 	print "\n";
194 | }
195 | 
196 | # Serializator to strange html5tests format
197 | sub printTree {
198 | 	my ($node, $level) = @_;
199 | 	
200 | 	$level = -1 if (!defined $level);
201 | 	
202 | 	my $out = "";
203 | 	
204 | 	# print node
205 | 	if ($node->nodeType != HTML5::DOM->DOCUMENT_NODE && $node->nodeType != HTML5::DOM->DOCUMENT_FRAGMENT_NODE) {
206 | 		$out .= "| ";
207 | 		for (my $i = 0; $i < $level; ++$i) {
208 | 			$out .= "  ";
209 | 		}
210 | 		
211 | 		if ($node->nodeType == HTML5::DOM->DOCUMENT_TYPE_NODE) {
212 | 			my $dt = "<!DOCTYPE ";
213 | 			
214 | 			if ($node->name ne "") {
215 | 				$dt .= $node->name;
216 | 				
217 | 				if ($node->systemId ne "" || $node->publicId ne "") {
218 | 					$dt .= ' "'.$node->publicId.'"';
219 | 					$dt .= ' "'.$node->systemId.'"';
220 | 				}
221 | 			}
222 | 			
223 | 			$dt .= ">";
224 | 			
225 | 			$out .= $dt;
226 | 		} elsif ($node->nodeType == HTML5::DOM->COMMENT_NODE) {
227 | 			$out .= "<!-- ".$node->text." -->";
228 | 		} elsif ($node->nodeType == HTML5::DOM->TEXT_NODE) {
229 | 			$out .= '"'.$node->text.'"';
230 | 		} elsif ($node->nodeType == HTML5::DOM->ELEMENT_NODE) {
231 | 			if ($node->namespace eq 'HTML') {
232 | 				$out .= "<".$node->tag.">";
233 | 			} elsif (lc($node->namespace) eq 'mathml') { # fixme
234 | 				$out .= "<math ".$node->tag.">";
235 | 			} else {
236 | 				$out .= "<".lc($node->namespace)." ".$node->tag.">";
237 | 			}
238 | 		}
239 | 	}
240 | 	
241 | 	$out .= "\n" if (length($out));
242 | 	
243 | 	# print attributes
244 | 	if ($node->nodeType == HTML5::DOM->ELEMENT_NODE) {
245 | 		for my $attr (sort { $a->{name} cmp $b->{name} } @{$node->attrArray}) { # todo: implement https://developer.mozilla.org/ru/docs/Web/API/Element/attributes
246 | 			$out .= "| ";
247 | 			for (my $i = 0; $i < $level + 1; ++$i) {
248 | 				$out .= "  ";
249 | 			}
250 | 			$out .= lc($attr->{namespace})." " if ($attr->{namespace} ne "HTML");
251 | 			$out .= $attr->{name}."=\"".$attr->{value}."\"";
252 | 			$out .= "\n";
253 | 		}
254 | 	}
255 | 	
256 | 	# print childrens
257 | 	if ($node->nodeType == HTML5::DOM->DOCUMENT_NODE || $node->nodeType == HTML5::DOM->DOCUMENT_FRAGMENT_NODE || $node->nodeType == HTML5::DOM->ELEMENT_NODE) {
258 | 		if ($node->namespace eq "HTML" && $node->tag eq "template") {
259 | 			$out .= "| ";
260 | 			for (my $i = 0; $i < $level + 1; ++$i) {
261 | 				$out .= "  ";
262 | 			}
263 | 			$out .= "content\n";
264 | 			++$level;
265 | 		}
266 | 		
267 | 		for my $child (@$node) {
268 | 			$out .= printTree($child, $level + 1);
269 | 		}
270 | 	}
271 | 	
272 | 	$out =~ s/\n$//g if ($level == -1);
273 | 	
274 | 	return $out;
275 | }
276 | 
277 | sub printTable {
278 | 	my $table = shift;
279 | 	
280 | 	my $maxlength = {};
281 | 	for my $row (@$table) {
282 | 		my $i = 0;
283 | 		for my $col (@$row) {
284 | 			$maxlength->{$i} = 0 if (!exists $maxlength->{$i});
285 | 			$maxlength->{$i} = max($maxlength->{$i}, length($col));
286 | 			++$i;
287 | 		}
288 | 	}
289 | 	
290 | 	my $ii = 0;
291 | 	for my $row (@$table) {
292 | 		my $i = 0;
293 | 		for my $col (@$row) {
294 | 			print $col;
295 | 			if ($i != scalar(@$row) - 1) {
296 | 				for (my $x = 0; $x < ($maxlength->{$i} + 4) - length($col); ++$x) {
297 | 					print " ";
298 | 				}
299 | 			}
300 | 			++$i;
301 | 		}
302 | 		print "\n";
303 | 		
304 | 		if (!$ii) {
305 | 			my $i = 0;
306 | 			for my $col (@$row) {
307 | 				for (my $x = 0; $x < $maxlength->{$i} + 4; ++$x) {
308 | 					print "-";
309 | 				}
310 | 				++$i;
311 | 			}
312 | 			print "\n";
313 | 		}
314 | 		
315 | 		++$ii;
316 | 	}
317 | }
318 | 


--------------------------------------------------------------------------------
/lib/HTML5/DOM.pm:
--------------------------------------------------------------------------------
  1 | package HTML5::DOM;
  2 | use strict;
  3 | use warnings;
  4 | 
  5 | # Node types
  6 | use HTML5::DOM::Node;
  7 | use HTML5::DOM::Element;
  8 | use HTML5::DOM::Fragment;
  9 | use HTML5::DOM::Comment;
 10 | use HTML5::DOM::DocType;
 11 | use HTML5::DOM::Text;
 12 | use HTML5::DOM::Document;
 13 | 
 14 | use HTML5::DOM::Encoding;
 15 | use HTML5::DOM::Tree;
 16 | use HTML5::DOM::Collection;
 17 | use HTML5::DOM::CSS;
 18 | use HTML5::DOM::TokenList;
 19 | 
 20 | our $VERSION = '1.25';
 21 | require XSLoader;
 22 | 
 23 | # https://developer.mozilla.org/pl/docs/Web/API/Element/nodeType
 24 | use constant	ELEMENT_NODE					=> 1; 
 25 | use constant	ATTRIBUTE_NODE					=> 2;	# not supported
 26 | use constant	TEXT_NODE						=> 3; 
 27 | use constant	CDATA_SECTION_NODE				=> 4;	# not supported
 28 | use constant	ENTITY_REFERENCE_NODE			=> 5;	# not supported
 29 | use constant	ENTITY_NODE						=> 6;	# not supported
 30 | use constant	PROCESSING_INSTRUCTION_NODE		=> 7;	# not supported
 31 | use constant	COMMENT_NODE					=> 8; 
 32 | use constant	DOCUMENT_NODE					=> 9; 
 33 | use constant	DOCUMENT_TYPE_NODE				=> 10; 
 34 | use constant	DOCUMENT_FRAGMENT_NODE			=> 11; 
 35 | use constant	NOTATION_NODE					=> 12;	# not supported
 36 | 
 37 | # <MyHTML_tags>
 38 | use constant	TAG__UNDEF				=> 0x0;
 39 | use constant	TAG__TEXT				=> 0x1;
 40 | use constant	TAG__COMMENT			=> 0x2;
 41 | use constant	TAG__DOCTYPE			=> 0x3;
 42 | use constant	TAG_A					=> 0x4;
 43 | use constant	TAG_ABBR				=> 0x5;
 44 | use constant	TAG_ACRONYM				=> 0x6;
 45 | use constant	TAG_ADDRESS				=> 0x7;
 46 | use constant	TAG_ANNOTATION_XML		=> 0x8;
 47 | use constant	TAG_APPLET				=> 0x9;
 48 | use constant	TAG_AREA				=> 0xa;
 49 | use constant	TAG_ARTICLE				=> 0xb;
 50 | use constant	TAG_ASIDE				=> 0xc;
 51 | use constant	TAG_AUDIO				=> 0xd;
 52 | use constant	TAG_B					=> 0xe;
 53 | use constant	TAG_BASE				=> 0xf;
 54 | use constant	TAG_BASEFONT			=> 0x10;
 55 | use constant	TAG_BDI					=> 0x11;
 56 | use constant	TAG_BDO					=> 0x12;
 57 | use constant	TAG_BGSOUND				=> 0x13;
 58 | use constant	TAG_BIG					=> 0x14;
 59 | use constant	TAG_BLINK				=> 0x15;
 60 | use constant	TAG_BLOCKQUOTE			=> 0x16;
 61 | use constant	TAG_BODY				=> 0x17;
 62 | use constant	TAG_BR					=> 0x18;
 63 | use constant	TAG_BUTTON				=> 0x19;
 64 | use constant	TAG_CANVAS				=> 0x1a;
 65 | use constant	TAG_CAPTION				=> 0x1b;
 66 | use constant	TAG_CENTER				=> 0x1c;
 67 | use constant	TAG_CITE				=> 0x1d;
 68 | use constant	TAG_CODE				=> 0x1e;
 69 | use constant	TAG_COL					=> 0x1f;
 70 | use constant	TAG_COLGROUP			=> 0x20;
 71 | use constant	TAG_COMMAND				=> 0x21;
 72 | use constant	TAG_COMMENT				=> 0x22;
 73 | use constant	TAG_DATALIST			=> 0x23;
 74 | use constant	TAG_DD					=> 0x24;
 75 | use constant	TAG_DEL					=> 0x25;
 76 | use constant	TAG_DETAILS				=> 0x26;
 77 | use constant	TAG_DFN					=> 0x27;
 78 | use constant	TAG_DIALOG				=> 0x28;
 79 | use constant	TAG_DIR					=> 0x29;
 80 | use constant	TAG_DIV					=> 0x2a;
 81 | use constant	TAG_DL					=> 0x2b;
 82 | use constant	TAG_DT					=> 0x2c;
 83 | use constant	TAG_EM					=> 0x2d;
 84 | use constant	TAG_EMBED				=> 0x2e;
 85 | use constant	TAG_FIELDSET			=> 0x2f;
 86 | use constant	TAG_FIGCAPTION			=> 0x30;
 87 | use constant	TAG_FIGURE				=> 0x31;
 88 | use constant	TAG_FONT				=> 0x32;
 89 | use constant	TAG_FOOTER				=> 0x33;
 90 | use constant	TAG_FORM				=> 0x34;
 91 | use constant	TAG_FRAME				=> 0x35;
 92 | use constant	TAG_FRAMESET			=> 0x36;
 93 | use constant	TAG_H1					=> 0x37;
 94 | use constant	TAG_H2					=> 0x38;
 95 | use constant	TAG_H3					=> 0x39;
 96 | use constant	TAG_H4					=> 0x3a;
 97 | use constant	TAG_H5					=> 0x3b;
 98 | use constant	TAG_H6					=> 0x3c;
 99 | use constant	TAG_HEAD				=> 0x3d;
100 | use constant	TAG_HEADER				=> 0x3e;
101 | use constant	TAG_HGROUP				=> 0x3f;
102 | use constant	TAG_HR					=> 0x40;
103 | use constant	TAG_HTML				=> 0x41;
104 | use constant	TAG_I					=> 0x42;
105 | use constant	TAG_IFRAME				=> 0x43;
106 | use constant	TAG_IMAGE				=> 0x44;
107 | use constant	TAG_IMG					=> 0x45;
108 | use constant	TAG_INPUT				=> 0x46;
109 | use constant	TAG_INS					=> 0x47;
110 | use constant	TAG_ISINDEX				=> 0x48;
111 | use constant	TAG_KBD					=> 0x49;
112 | use constant	TAG_KEYGEN				=> 0x4a;
113 | use constant	TAG_LABEL				=> 0x4b;
114 | use constant	TAG_LEGEND				=> 0x4c;
115 | use constant	TAG_LI					=> 0x4d;
116 | use constant	TAG_LINK				=> 0x4e;
117 | use constant	TAG_LISTING				=> 0x4f;
118 | use constant	TAG_MAIN				=> 0x50;
119 | use constant	TAG_MAP					=> 0x51;
120 | use constant	TAG_MARK				=> 0x52;
121 | use constant	TAG_MARQUEE				=> 0x53;
122 | use constant	TAG_MENU				=> 0x54;
123 | use constant	TAG_MENUITEM			=> 0x55;
124 | use constant	TAG_META				=> 0x56;
125 | use constant	TAG_METER				=> 0x57;
126 | use constant	TAG_MTEXT				=> 0x58;
127 | use constant	TAG_NAV					=> 0x59;
128 | use constant	TAG_NOBR				=> 0x5a;
129 | use constant	TAG_NOEMBED				=> 0x5b;
130 | use constant	TAG_NOFRAMES			=> 0x5c;
131 | use constant	TAG_NOSCRIPT			=> 0x5d;
132 | use constant	TAG_OBJECT				=> 0x5e;
133 | use constant	TAG_OL					=> 0x5f;
134 | use constant	TAG_OPTGROUP			=> 0x60;
135 | use constant	TAG_OPTION				=> 0x61;
136 | use constant	TAG_OUTPUT				=> 0x62;
137 | use constant	TAG_P					=> 0x63;
138 | use constant	TAG_PARAM				=> 0x64;
139 | use constant	TAG_PLAINTEXT			=> 0x65;
140 | use constant	TAG_PRE					=> 0x66;
141 | use constant	TAG_PROGRESS			=> 0x67;
142 | use constant	TAG_Q					=> 0x68;
143 | use constant	TAG_RB					=> 0x69;
144 | use constant	TAG_RP					=> 0x6a;
145 | use constant	TAG_RT					=> 0x6b;
146 | use constant	TAG_RTC					=> 0x6c;
147 | use constant	TAG_RUBY				=> 0x6d;
148 | use constant	TAG_S					=> 0x6e;
149 | use constant	TAG_SAMP				=> 0x6f;
150 | use constant	TAG_SCRIPT				=> 0x70;
151 | use constant	TAG_SECTION				=> 0x71;
152 | use constant	TAG_SELECT				=> 0x72;
153 | use constant	TAG_SMALL				=> 0x73;
154 | use constant	TAG_SOURCE				=> 0x74;
155 | use constant	TAG_SPAN				=> 0x75;
156 | use constant	TAG_STRIKE				=> 0x76;
157 | use constant	TAG_STRONG				=> 0x77;
158 | use constant	TAG_STYLE				=> 0x78;
159 | use constant	TAG_SUB					=> 0x79;
160 | use constant	TAG_SUMMARY				=> 0x7a;
161 | use constant	TAG_SUP					=> 0x7b;
162 | use constant	TAG_SVG					=> 0x7c;
163 | use constant	TAG_TABLE				=> 0x7d;
164 | use constant	TAG_TBODY				=> 0x7e;
165 | use constant	TAG_TD					=> 0x7f;
166 | use constant	TAG_TEMPLATE			=> 0x80;
167 | use constant	TAG_TEXTAREA			=> 0x81;
168 | use constant	TAG_TFOOT				=> 0x82;
169 | use constant	TAG_TH					=> 0x83;
170 | use constant	TAG_THEAD				=> 0x84;
171 | use constant	TAG_TIME				=> 0x85;
172 | use constant	TAG_TITLE				=> 0x86;
173 | use constant	TAG_TR					=> 0x87;
174 | use constant	TAG_TRACK				=> 0x88;
175 | use constant	TAG_TT					=> 0x89;
176 | use constant	TAG_U					=> 0x8a;
177 | use constant	TAG_UL					=> 0x8b;
178 | use constant	TAG_VAR					=> 0x8c;
179 | use constant	TAG_VIDEO				=> 0x8d;
180 | use constant	TAG_WBR					=> 0x8e;
181 | use constant	TAG_XMP					=> 0x8f;
182 | use constant	TAG_ALTGLYPH			=> 0x90;
183 | use constant	TAG_ALTGLYPHDEF			=> 0x91;
184 | use constant	TAG_ALTGLYPHITEM		=> 0x92;
185 | use constant	TAG_ANIMATE				=> 0x93;
186 | use constant	TAG_ANIMATECOLOR		=> 0x94;
187 | use constant	TAG_ANIMATEMOTION		=> 0x95;
188 | use constant	TAG_ANIMATETRANSFORM	=> 0x96;
189 | use constant	TAG_CIRCLE				=> 0x97;
190 | use constant	TAG_CLIPPATH			=> 0x98;
191 | use constant	TAG_COLOR_PROFILE		=> 0x99;
192 | use constant	TAG_CURSOR				=> 0x9a;
193 | use constant	TAG_DEFS				=> 0x9b;
194 | use constant	TAG_DESC				=> 0x9c;
195 | use constant	TAG_ELLIPSE				=> 0x9d;
196 | use constant	TAG_FEBLEND				=> 0x9e;
197 | use constant	TAG_FECOLORMATRIX		=> 0x9f;
198 | use constant	TAG_FECOMPONENTTRANSFER	=> 0xa0;
199 | use constant	TAG_FECOMPOSITE			=> 0xa1;
200 | use constant	TAG_FECONVOLVEMATRIX	=> 0xa2;
201 | use constant	TAG_FEDIFFUSELIGHTING	=> 0xa3;
202 | use constant	TAG_FEDISPLACEMENTMAP	=> 0xa4;
203 | use constant	TAG_FEDISTANTLIGHT		=> 0xa5;
204 | use constant	TAG_FEDROPSHADOW		=> 0xa6;
205 | use constant	TAG_FEFLOOD				=> 0xa7;
206 | use constant	TAG_FEFUNCA				=> 0xa8;
207 | use constant	TAG_FEFUNCB				=> 0xa9;
208 | use constant	TAG_FEFUNCG				=> 0xaa;
209 | use constant	TAG_FEFUNCR				=> 0xab;
210 | use constant	TAG_FEGAUSSIANBLUR		=> 0xac;
211 | use constant	TAG_FEIMAGE				=> 0xad;
212 | use constant	TAG_FEMERGE				=> 0xae;
213 | use constant	TAG_FEMERGENODE			=> 0xaf;
214 | use constant	TAG_FEMORPHOLOGY		=> 0xb0;
215 | use constant	TAG_FEOFFSET			=> 0xb1;
216 | use constant	TAG_FEPOINTLIGHT		=> 0xb2;
217 | use constant	TAG_FESPECULARLIGHTING	=> 0xb3;
218 | use constant	TAG_FESPOTLIGHT			=> 0xb4;
219 | use constant	TAG_FETILE				=> 0xb5;
220 | use constant	TAG_FETURBULENCE		=> 0xb6;
221 | use constant	TAG_FILTER				=> 0xb7;
222 | use constant	TAG_FONT_FACE			=> 0xb8;
223 | use constant	TAG_FONT_FACE_FORMAT	=> 0xb9;
224 | use constant	TAG_FONT_FACE_NAME		=> 0xba;
225 | use constant	TAG_FONT_FACE_SRC		=> 0xbb;
226 | use constant	TAG_FONT_FACE_URI		=> 0xbc;
227 | use constant	TAG_FOREIGNOBJECT		=> 0xbd;
228 | use constant	TAG_G					=> 0xbe;
229 | use constant	TAG_GLYPH				=> 0xbf;
230 | use constant	TAG_GLYPHREF			=> 0xc0;
231 | use constant	TAG_HKERN				=> 0xc1;
232 | use constant	TAG_LINE				=> 0xc2;
233 | use constant	TAG_LINEARGRADIENT		=> 0xc3;
234 | use constant	TAG_MARKER				=> 0xc4;
235 | use constant	TAG_MASK				=> 0xc5;
236 | use constant	TAG_METADATA			=> 0xc6;
237 | use constant	TAG_MISSING_GLYPH		=> 0xc7;
238 | use constant	TAG_MPATH				=> 0xc8;
239 | use constant	TAG_PATH				=> 0xc9;
240 | use constant	TAG_PATTERN				=> 0xca;
241 | use constant	TAG_POLYGON				=> 0xcb;
242 | use constant	TAG_POLYLINE			=> 0xcc;
243 | use constant	TAG_RADIALGRADIENT		=> 0xcd;
244 | use constant	TAG_RECT				=> 0xce;
245 | use constant	TAG_SET					=> 0xcf;
246 | use constant	TAG_STOP				=> 0xd0;
247 | use constant	TAG_SWITCH				=> 0xd1;
248 | use constant	TAG_SYMBOL				=> 0xd2;
249 | use constant	TAG_TEXT				=> 0xd3;
250 | use constant	TAG_TEXTPATH			=> 0xd4;
251 | use constant	TAG_TREF				=> 0xd5;
252 | use constant	TAG_TSPAN				=> 0xd6;
253 | use constant	TAG_USE					=> 0xd7;
254 | use constant	TAG_VIEW				=> 0xd8;
255 | use constant	TAG_VKERN				=> 0xd9;
256 | use constant	TAG_MATH				=> 0xda;
257 | use constant	TAG_MACTION				=> 0xdb;
258 | use constant	TAG_MALIGNGROUP			=> 0xdc;
259 | use constant	TAG_MALIGNMARK			=> 0xdd;
260 | use constant	TAG_MENCLOSE			=> 0xde;
261 | use constant	TAG_MERROR				=> 0xdf;
262 | use constant	TAG_MFENCED				=> 0xe0;
263 | use constant	TAG_MFRAC				=> 0xe1;
264 | use constant	TAG_MGLYPH				=> 0xe2;
265 | use constant	TAG_MI					=> 0xe3;
266 | use constant	TAG_MLABELEDTR			=> 0xe4;
267 | use constant	TAG_MLONGDIV			=> 0xe5;
268 | use constant	TAG_MMULTISCRIPTS		=> 0xe6;
269 | use constant	TAG_MN					=> 0xe7;
270 | use constant	TAG_MO					=> 0xe8;
271 | use constant	TAG_MOVER				=> 0xe9;
272 | use constant	TAG_MPADDED				=> 0xea;
273 | use constant	TAG_MPHANTOM			=> 0xeb;
274 | use constant	TAG_MROOT				=> 0xec;
275 | use constant	TAG_MROW				=> 0xed;
276 | use constant	TAG_MS					=> 0xee;
277 | use constant	TAG_MSCARRIES			=> 0xef;
278 | use constant	TAG_MSCARRY				=> 0xf0;
279 | use constant	TAG_MSGROUP				=> 0xf1;
280 | use constant	TAG_MSLINE				=> 0xf2;
281 | use constant	TAG_MSPACE				=> 0xf3;
282 | use constant	TAG_MSQRT				=> 0xf4;
283 | use constant	TAG_MSROW				=> 0xf5;
284 | use constant	TAG_MSTACK				=> 0xf6;
285 | use constant	TAG_MSTYLE				=> 0xf7;
286 | use constant	TAG_MSUB				=> 0xf8;
287 | use constant	TAG_MSUP				=> 0xf9;
288 | use constant	TAG_MSUBSUP				=> 0xfa;
289 | use constant	TAG__END_OF_FILE		=> 0xfb;
290 | use constant	TAG_LAST_ENTRY			=> 0xfc;
291 | # </MyHTML_tags>
292 | 
293 | # <MyHTML_ns>
294 | use constant	NS_UNDEF				=> 0x0;
295 | use constant	NS_HTML					=> 0x1;
296 | use constant	NS_MATHML				=> 0x2;
297 | use constant	NS_SVG					=> 0x3;
298 | use constant	NS_XLINK				=> 0x4;
299 | use constant	NS_XML					=> 0x5;
300 | use constant	NS_XMLNS				=> 0x6;
301 | use constant	NS_ANY					=> 0x7;
302 | use constant	NS_LAST_ENTRY			=> 0x7;
303 | # </MyHTML_ns>
304 | 
305 | sub parseAsync($$;$$) {
306 | 	my ($self, $html, $options, $callback) = @_;
307 | 	
308 | 	if (ref($options) eq 'CODE' && !defined $callback) {
309 | 		$callback = $options;
310 | 		$options = {};
311 | 	}
312 | 	
313 | 	if (ref($callback) eq 'CODE') {
314 | 		require EV;
315 | 		require AnyEvent::Util;
316 | 		
317 | 		my ($r, $w) = AnyEvent::Util::portable_pipe();
318 | 		AnyEvent::fh_unblock($r);
319 | 		
320 | 		my $async_w;
321 | 		my $async = $self->_parseAsync($html, $options, fileno($w));
322 | 		
323 | 		$async_w = EV::io($r, EV::READ(), sub {
324 | 			close $w;
325 | 			close $r;
326 | 			undef $w;
327 | 			undef $r;
328 | 			undef $async_w;
329 | 			
330 | 			$callback->($async->wait);
331 | 		});
332 | 		
333 | 		return $async;
334 | 	} else {
335 | 		_parseAsync(@_);
336 | 	}
337 | }
338 | 
339 | XSLoader::load('HTML5::DOM', $VERSION);
340 | 
341 | 1;
342 | __END__
343 | 


--------------------------------------------------------------------------------
/utils.c:
--------------------------------------------------------------------------------
  1 | #include "utils.h"
  2 | 
  3 | /*
  4 | 	async parsing
  5 | */
  6 | void *html5_dom_mythread_function(void *arg) {
  7 | 	mythread_context_t *ctx = (mythread_context_t *) arg;
  8 | 	mythread_t *mythread = ctx->mythread;
  9 | 	
 10 | 	mythread_mutex_wait(mythread, ctx->mutex);
 11 | 	ctx->func(ctx->id, ctx);
 12 | 	mythread_nanosleep_destroy(ctx->timespec);
 13 | 	ctx->opt = MyTHREAD_OPT_QUIT;
 14 | 	mythread_mutex_close(mythread, ctx->mutex);
 15 | 	
 16 |     return NULL;
 17 | }
 18 | 
 19 | static int html5_dom_fd_write(int fd, const char *data, int size) {
 20 | 	if (fd > -1) {
 21 | 		#ifdef MyCORE_OS_WINDOWS_NT
 22 | 			return _write(fd, data, size);
 23 | 		#else
 24 | 			return write(fd, data, size);
 25 | 		#endif
 26 | 	}
 27 | 	return 0;
 28 | }
 29 | 
 30 | int html5_dom_async_parse(html5_dom_async_result *result) {
 31 | 	mystatus_t status;
 32 | 	
 33 | 	// create parser
 34 | 	html5_dom_parser_t *self = html5_dom_parser_new(&result->opts);
 35 | 	
 36 | 	// init myhtml
 37 | 	self->myhtml = myhtml_create();
 38 | 	
 39 | 	if (self->opts.threads <= 1) {
 40 | 		status = myhtml_init(self->myhtml, MyHTML_OPTIONS_PARSE_MODE_SINGLE, 1, 0);
 41 | 	} else {
 42 | 		status = myhtml_init(self->myhtml, MyHTML_OPTIONS_DEFAULT, self->opts.threads, 0);
 43 | 	}
 44 | 	
 45 | 	if (status) {
 46 | 		html5_dom_parser_free(self);
 47 | 		result->status = status;
 48 | 		result->done = true;
 49 | 		return html5_dom_fd_write(result->fd, "0", 1);
 50 | 	}
 51 | 	
 52 | 	// init myhtml tree
 53 | 	myhtml_tree_t *tree = myhtml_tree_create();
 54 | 	status = myhtml_tree_init(tree, self->myhtml);
 55 | 	if (status) {
 56 | 		myhtml_tree_destroy(tree);
 57 | 		html5_dom_parser_free(self);
 58 | 		result->status = status;
 59 | 		result->done = true;
 60 | 		return html5_dom_fd_write(result->fd, "0", 1);
 61 | 	}
 62 | 	
 63 | 	// detect encoding
 64 | 	myencoding_t encoding = html5_dom_auto_encoding(&result->opts, (const char **) &result->html, &result->length);
 65 | 	
 66 | 	// apply options to tree
 67 | 	html5_dom_apply_tree_options(tree, &result->opts);
 68 | 	
 69 | 	// try parse
 70 | 	status = myhtml_parse(tree, encoding, result->html, result->length);
 71 | 	
 72 | 	if (status) {
 73 | 		myhtml_tree_destroy(tree);
 74 | 		html5_dom_parser_free(self);
 75 | 		result->status = status;
 76 | 		result->done = true;
 77 | 		return html5_dom_fd_write(result->fd, "0", 1);
 78 | 	}
 79 | 	
 80 | 	result->done = true;
 81 | 	result->tree = tree;
 82 | 	result->parser = self;
 83 | 	
 84 | 	// trigger event
 85 | 	return html5_dom_fd_write(result->fd, "1", 1);
 86 | }
 87 | 
 88 | void html5_dom_async_parse_worker(mythread_id_t thread_id, void *arg) {
 89 | 	mythread_context_t *ctx = (mythread_context_t *) arg;
 90 | 	html5_dom_async_result *result = (html5_dom_async_result *) ctx->mythread->context;
 91 | 	html5_dom_async_parse(result);
 92 | }
 93 | 
 94 | /*
 95 | 	parser
 96 | */
 97 | html5_dom_parser_t *html5_dom_parser_new(html5_dom_options_t *options) {
 98 | 	html5_dom_parser_t *self = (html5_dom_parser_t *) malloc(sizeof(html5_dom_parser_t));
 99 | 	memset(self, 0, sizeof(html5_dom_parser_t));
100 | 	memcpy(&self->opts, options, sizeof(html5_dom_options_t));
101 | 	return self;
102 | }
103 | 
104 | void *html5_dom_parser_free(html5_dom_parser_t *self) {
105 | 	if (self->myhtml) {
106 | 		myhtml_destroy(self->myhtml);
107 | 		self->myhtml = NULL;
108 | 	}
109 | 	
110 | 	if (self->mycss_entry) {
111 | 		mycss_entry_destroy(self->mycss_entry, 1);
112 | 		self->mycss_entry = NULL;
113 | 	}
114 | 	
115 | 	if (self->mycss) {
116 | 		mycss_destroy(self->mycss, 1);
117 | 		self->mycss = NULL;
118 | 	}
119 | 	
120 | 	if (self->finder) {
121 | 		modest_finder_destroy(self->finder, 1);
122 | 		self->finder = NULL;
123 | 	}
124 | 	
125 | 	free(self);
126 | }
127 | 
128 | mystatus_t html5_dom_init_css(html5_dom_parser_t *parser) {
129 | 	mystatus_t status = MyCSS_STATUS_OK;
130 | 	
131 | 	if (!parser->mycss) {
132 | 		parser->mycss = mycss_create();
133 | 		status = mycss_init(parser->mycss);
134 | 		if (status) {
135 | 			mycss_destroy(parser->mycss, 1);
136 | 			parser->mycss = NULL;
137 | 			return status;
138 | 		}
139 | 	}
140 | 	
141 | 	if (!parser->mycss_entry) {
142 | 		parser->mycss_entry = mycss_entry_create();
143 | 		status = mycss_entry_init(parser->mycss, parser->mycss_entry);
144 | 		if (status) {
145 | 			mycss_entry_destroy(parser->mycss_entry, 1);
146 | 			mycss_destroy(parser->mycss, 1);
147 | 			parser->mycss = NULL;
148 | 			parser->mycss_entry = NULL;
149 | 			return status;
150 | 		}
151 | 	}
152 | 	
153 | 	return status;
154 | }
155 | 
156 | myhtml_tree_node_t *html5_dom_parse_fragment(html5_dom_options_t *opts, myhtml_tree_t *tree, myhtml_tag_id_t tag_id, myhtml_namespace_t ns, 
157 | 	const char *text, size_t length, html5_fragment_parts_t *parts, mystatus_t *status_out)
158 | {
159 | 	mystatus_t status;
160 | 	
161 | 	myhtml_t *parser = myhtml_tree_get_myhtml(tree);
162 | 	
163 | 	// cteate temorary tree
164 | 	myhtml_tree_t *fragment_tree = myhtml_tree_create();
165 | 	status = myhtml_tree_init(fragment_tree, parser);
166 | 	if (status) {
167 | 		*status_out = status;
168 | 		myhtml_tree_destroy(tree);
169 | 		return NULL;
170 | 	}
171 | 	
172 | 	html5_dom_apply_tree_options(fragment_tree, opts);
173 | 	
174 | 	myencoding_t encoding = html5_dom_auto_encoding(opts, &text, &length);
175 | 	
176 | 	// parse fragment from text
177 | 	status = myhtml_parse_fragment(fragment_tree, encoding, text, length, tag_id, ns);
178 | 	if (status) {
179 | 		*status_out = status;
180 | 		myhtml_tree_destroy(tree);
181 | 		return NULL;
182 | 	}
183 | 	
184 | 	// clone fragment from temporary tree to persistent tree
185 | 	myhtml_tree_node_t *node = html5_dom_recursive_clone_node(tree, myhtml_tree_get_node_html(fragment_tree), parts);
186 | 	
187 | 	if (node) {
188 | 		html5_dom_tree_t *context = (html5_dom_tree_t *) node->tree->context;
189 | 		if (!context->fragment_tag_id)
190 | 			context->fragment_tag_id = html5_dom_tag_id_by_name(tree, "-fragment", 9, true);
191 | 		node->tag_id = context->fragment_tag_id;
192 | 	}
193 | 	
194 | 	myhtml_tree_destroy(fragment_tree);
195 | 	
196 | 	*status_out = status;
197 | 	
198 | 	return node;
199 | }
200 | 
201 | void html5_dom_apply_tree_options(myhtml_tree_t *tree, html5_dom_options_t *opts) {
202 | 	if (opts->scripts) {
203 | 		tree->flags |= MyHTML_TREE_FLAGS_SCRIPT;
204 | 	} else {
205 | 		tree->flags &= ~MyHTML_TREE_FLAGS_SCRIPT;
206 | 	}
207 | 	
208 | 	if (opts->ignore_doctype)
209 | 		tree->parse_flags |= MyHTML_TREE_PARSE_FLAGS_WITHOUT_DOCTYPE_IN_TREE;
210 | 	
211 | 	if (opts->ignore_whitespace)
212 | 		tree->parse_flags |= MyHTML_TREE_PARSE_FLAGS_SKIP_WHITESPACE_TOKEN;
213 | }
214 | 
215 | /*
216 | 	misc
217 | */
218 | const char *modest_strerror(mystatus_t status) {
219 | 	switch (status) {
220 | 		#include "gen/modest_errors.c"	
221 | 	}
222 | 	return status ? "UNKNOWN" : "";
223 | }
224 | 
225 | int html5_dom_get_ua_display_prop(myhtml_tree_node_t *node) {
226 | 	switch (node->tag_id) {
227 | 		#include "gen/tags_ua_style.c"	
228 | 	}
229 | 	return TAG_UA_STYLE_INLINE;
230 | }
231 | 
232 | void html5_dom_rtrim_mystring(mycore_string_t *str, char c) {
233 | 	size_t i = str->length;
234 | 	while (i > 0) {
235 | 		--i;
236 | 		
237 | 		if (str->data[i] != c)
238 | 			break;
239 | 		
240 | 		str->data[i] = '\0';
241 | 		--str->length;
242 | 	}
243 | }
244 | 
245 | /*
246 | 	finders & css
247 | */
248 | void _modest_finder_callback_found_with_one_node(modest_finder_t *finder, myhtml_tree_node_t *node, 
249 | 	mycss_selectors_list_t *selector_list, mycss_selectors_entry_t *selector, mycss_selectors_specificity_t *spec, void *ctx)
250 | {
251 | 	myhtml_tree_node_t **result_node = (myhtml_tree_node_t **) ctx;
252 | 	if (!*result_node)
253 | 		*result_node = node;
254 | }
255 | 
256 | void *html5_node_finder(html5_dom_parser_t *parser, modest_finder_selector_combinator_f func, 
257 | 		myhtml_tree_node_t *scope, mycss_selectors_entries_list_t *list, size_t list_size, mystatus_t *status_out, bool one)
258 | {
259 | 	*status_out = MODEST_STATUS_OK;
260 | 	
261 | 	if (!scope)
262 | 		return NULL;
263 | 	
264 | 	// Init finder
265 | 	mystatus_t status;
266 | 	if (parser->finder) {
267 | 		parser->finder = modest_finder_create();
268 | 		status = modest_finder_init(parser->finder);
269 | 		if (status) {
270 | 			*status_out = status;
271 | 			modest_finder_destroy(parser->finder, 1);
272 | 			return NULL;
273 | 		}
274 | 	}
275 | 	
276 | 	if (one) {
277 | 		// Process selector entries
278 | 		myhtml_tree_node_t *node = NULL;
279 | 		for (size_t i = 0; i < list_size; ++i) {
280 | 			func(parser->finder, scope, NULL, list[i].entry, &list[i].specificity, 
281 | 				_modest_finder_callback_found_with_one_node, &node);
282 | 			
283 | 			if (node)
284 | 				break;
285 | 		}
286 | 		
287 | 		return (void *) node;
288 | 	} else {
289 | 		// Init collection for results
290 | 		myhtml_collection_t *collection = myhtml_collection_create(4096, &status);
291 | 		if (status) {
292 | 			*status_out = MODEST_STATUS_ERROR_MEMORY_ALLOCATION;
293 | 			return NULL;
294 | 		}
295 | 		
296 | 		// Process selector entries
297 | 		for (size_t i = 0; i < list_size; ++i) {
298 | 			func(parser->finder, scope, NULL, list[i].entry, &list[i].specificity, 
299 | 				modest_finder_callback_found_with_collection, collection);
300 | 		}
301 | 		
302 | 		return (void *) collection;
303 | 	}
304 | }
305 | 
306 | modest_finder_selector_combinator_f html5_find_selector_func(const char *c, int combo_len) {
307 | 	if (combo_len == 2) {
308 | 		if (c[0] == '|' && c[1] == '|')
309 | 			return modest_finder_node_combinator_column;
310 | 		if ((c[0] == '>' && c[1] == '>'))
311 | 			return modest_finder_node_combinator_descendant;
312 | 	} else if (combo_len == 1) {
313 | 		if (c[0] == '>')
314 | 			return modest_finder_node_combinator_child;
315 | 		if (c[0] == '+')
316 | 			return modest_finder_node_combinator_next_sibling;
317 | 		if (c[0] == '~')
318 | 			return modest_finder_node_combinator_following_sibling;
319 | 		if (c[0] == '^')
320 | 			return modest_finder_node_combinator_begin;
321 | 	}
322 | 	return modest_finder_node_combinator_descendant;
323 | }
324 | 
325 | mycss_selectors_list_t *html5_parse_selector(mycss_entry_t *entry, const char *query, size_t query_len, mystatus_t *status_out) {
326 | 	mystatus_t status;
327 | 	
328 | 	*status_out = MyCSS_STATUS_OK;
329 | 	
330 | 	mycss_selectors_list_t *list = mycss_selectors_parse(mycss_entry_selectors(entry), MyENCODING_UTF_8, query, query_len, &status);
331 | 	if (status || list == NULL || (list->flags & MyCSS_SELECTORS_FLAGS_SELECTOR_BAD)) {
332 | 		if (list)
333 | 			mycss_selectors_list_destroy(mycss_entry_selectors(entry), list, true);
334 | 		*status_out = status;
335 | 		return NULL;
336 | 	}
337 | 	
338 | 	return list;
339 | }
340 | 
341 | /*
342 | 	nodes
343 | */
344 | myhtml_tag_id_t html5_dom_tag_id_by_name(myhtml_tree_t *tree, const char *tag_str, size_t tag_len, bool allow_create) {
345 | 	const myhtml_tag_context_t *tag_ctx = myhtml_tag_get_by_name(tree->tags, tag_str, tag_len);
346 | 	if (tag_ctx) {
347 | 		return tag_ctx->id;
348 | 	} else if (allow_create) {
349 | 		// add custom tag
350 | 		return myhtml_tag_add(tree->tags, tag_str, tag_len, MyHTML_TOKENIZER_STATE_DATA, true);
351 | 	}
352 | 	return MyHTML_TAG__UNDEF;
353 | }
354 | 
355 | // Safe copy node from native or foreign tree
356 | myhtml_tree_node_t *html5_dom_copy_foreign_node(myhtml_tree_t *tree, myhtml_tree_node_t *node) {
357 | 	// Create new node
358 | 	myhtml_tree_node_t *new_node = myhtml_tree_node_create(tree);
359 | 	new_node->tag_id		= node->tag_id;
360 | 	new_node->ns			= node->ns;
361 | 	
362 | 	// Copy custom tag
363 | 	if (tree != node->tree && node->tag_id >= MyHTML_TAG_LAST_ENTRY) {
364 | 		new_node->tag_id = MyHTML_TAG__UNDEF;
365 | 		
366 | 		// Get tag name in foreign tree
367 | 		const myhtml_tag_context_t *tag_ctx = myhtml_tag_get_by_id(node->tree->tags, node->tag_id);
368 | 		if (tag_ctx) {
369 | 			// Get same tag in native tree
370 | 			new_node->tag_id = html5_dom_tag_id_by_name(tree, tag_ctx->name, tag_ctx->name_length, true);
371 | 		}
372 | 	}
373 | 	
374 | 	if (node->token) {
375 | 		// Wait, if node not yet done
376 | 		myhtml_token_node_wait_for_done(node->tree->token, node->token);
377 | 		
378 | 		// Copy node token
379 | 		new_node->token = myhtml_token_node_create(tree->token, tree->mcasync_rules_token_id);
380 | 		if (!new_node->token) {
381 | 			myhtml_tree_node_delete(new_node);
382 | 			return NULL;
383 | 		}
384 | 		
385 | 		new_node->token->tag_id			= node->token->tag_id;
386 | 		new_node->token->type			= node->token->type;
387 | 		new_node->token->attr_first		= NULL;
388 | 		new_node->token->attr_last		= NULL;
389 | 		new_node->token->raw_begin		= tree != node->tree ? 0 : node->token->raw_begin;
390 | 		new_node->token->raw_length		= tree != node->tree ? 0 : node->token->raw_length;
391 | 		new_node->token->element_begin	= tree != node->tree ? 0 : node->token->element_begin;
392 | 		new_node->token->element_length	= tree != node->tree ? 0 : node->token->element_length;
393 | 		new_node->token->type			= new_node->token->type | MyHTML_TOKEN_TYPE_DONE;
394 | 		
395 | 		// Copy text data
396 | 		if (node->token->str.length) {
397 | 			mycore_string_init(tree->mchar, tree->mchar_node_id, &new_node->token->str, node->token->str.length + 1);
398 | 			mycore_string_append(&new_node->token->str, node->token->str.data, node->token->str.length);
399 | 		} else {
400 | 			mycore_string_clean_all(&new_node->token->str);
401 | 		}
402 | 		
403 | 		// Copy node attributes
404 | 		myhtml_token_attr_t *attr = node->token->attr_first;
405 | 		while (attr) {
406 | 			myhtml_token_attr_copy(tree->token, attr, new_node->token, tree->mcasync_rules_attr_id);
407 | 			attr = attr->next;
408 | 		}
409 | 	}
410 | 	
411 | 	return new_node;
412 | }
413 | 
414 | myhtml_tree_node_t *html5_dom_recursive_clone_node(myhtml_tree_t *tree, myhtml_tree_node_t *node, html5_fragment_parts_t *parts) {
415 | 	myhtml_tree_node_t *new_node = html5_dom_copy_foreign_node(tree, node);
416 | 	myhtml_tree_node_t *child = myhtml_node_child(node);
417 | 	
418 | 	if (parts) {
419 | 		if (node == node->tree->node_html)
420 | 			parts->node_html = new_node;
421 | 		else if (node == node->tree->node_head)
422 | 			parts->node_head = new_node;
423 | 		else if (node == node->tree->node_body)
424 | 			parts->node_body = new_node;
425 | 		else if (node == node->tree->document)
426 | 			parts->document = new_node;
427 | 	}
428 | 	
429 | 	while (child) {
430 | 		myhtml_tree_node_add_child(new_node, html5_dom_recursive_clone_node(tree, child, parts));
431 | 		child = myhtml_node_next(child);
432 | 	}
433 | 	
434 | 	return new_node;
435 | }
436 | 
437 | // Try to implements https://html.spec.whatwg.org/multipage/dom.html#the-innertext-idl-attribute
438 | // Using default user-agent box model types for tags instead of real css.
439 | void html5_dom_recursive_node_inner_text(myhtml_tree_node_t *node, html5_dom_inner_text_state_t *state) {
440 | 	if (node->tag_id == MyHTML_TAG__TEXT) {
441 | 		size_t text_len = 0;
442 | 		const char *text = myhtml_node_text(node, &text_len);
443 | 		
444 | 		bool is_empty = true;
445 | 		for (size_t i = 0; i < text_len; ++i) {
446 | 			// skip CR
447 | 			if (text[i] == '\r')
448 | 				continue;
449 | 			
450 | 			// collapse spaces
451 | 			if (isspace(text[i]) && (text[i] != '\xA0' || !i || text[i - 1] != '\xC2') && text[i] != '\xC2') {
452 | 				bool skip_spaces = (state->value.length > 0 && state->value.data[state->value.length - 1] == ' ') || state->new_line;
453 | 				if (skip_spaces)
454 | 					continue;
455 | 				mycore_string_append_one(&state->value, ' ');
456 | 			}
457 | 			// save other chars
458 | 			else {
459 | 				mycore_string_append_one(&state->value, text[i]);
460 | 				is_empty = false;
461 | 				state->new_line = false;
462 | 			}
463 | 		}
464 | 		
465 | 		if (!is_empty)
466 | 			state->last_br = false;
467 | 	} else if (node_is_element(node)) {
468 | 		// get default box model type for tag
469 | 		int display = html5_dom_get_ua_display_prop(node);
470 | 		
471 | 		// skip hidden nodes
472 | 		if (display == TAG_UA_STYLE_NONE)
473 | 			return;
474 | 		
475 | 		// skip some special nodes
476 | 		switch (node->tag_id) {
477 | 			case MyHTML_TAG_TEXTAREA:
478 | 			case MyHTML_TAG_INPUT:
479 | 			case MyHTML_TAG_AUDIO:
480 | 			case MyHTML_TAG_VIDEO:
481 | 				return;
482 | 		}
483 | 		
484 | 		// <br> always inserts \n
485 | 		if (node->tag_id == MyHTML_TAG_BR) {
486 | 			mycore_string_append_one(&state->value, '\n');
487 | 			state->new_line = true;
488 | 			state->last_br = true;
489 | 		} else {
490 | 			switch (display) {
491 | 				case TAG_UA_STYLE_BLOCK:
492 | 				case TAG_UA_STYLE_TABLE:
493 | 				case TAG_UA_STYLE_TABLE_CAPTION:
494 | 					// if last token - line break, then collapse
495 | 					// if last token - text, then insert new line break
496 | 					if (!state->last_br) {
497 | 						html5_dom_rtrim_mystring(&state->value, ' ');
498 | 						mycore_string_append_one(&state->value, '\n');
499 | 						state->new_line = true;
500 | 						state->last_br = true;
501 | 					}
502 | 				break;
503 | 			}
504 | 			
505 | 			myhtml_tree_node_t *child = myhtml_node_child(node);
506 | 			while (child) {
507 | 				html5_dom_recursive_node_inner_text(child, state);
508 | 				child = myhtml_node_next(child);
509 | 			}
510 | 			
511 | 			switch (display) {
512 | 				case TAG_UA_STYLE_BLOCK:
513 | 				case TAG_UA_STYLE_TABLE:
514 | 				case TAG_UA_STYLE_TABLE_CAPTION:
515 | 					// if last token - line break, then collapse
516 | 					// if last token - text, then insert new line break
517 | 					if (!state->last_br) {
518 | 						html5_dom_rtrim_mystring(&state->value, ' ');
519 | 						if (node->tag_id == MyHTML_TAG_P) {
520 | 							// chrome inserts two \n after <p>
521 | 							mycore_string_append_one(&state->value, '\n');
522 | 							mycore_string_append_one(&state->value, '\n');
523 | 						} else {
524 | 							mycore_string_append_one(&state->value, '\n');
525 | 						}
526 | 						state->new_line = true;
527 | 						state->last_br = true;
528 | 					}
529 | 				break;
530 | 				
531 | 				case TAG_UA_STYLE_TABLE_CELL:
532 | 				{
533 | 					bool is_last_cell = false;
534 | 					myhtml_tree_node_t *cell = myhtml_node_last_child(myhtml_node_parent(node));
535 | 					while (cell) {
536 | 						if (html5_dom_get_ua_display_prop(cell) == TAG_UA_STYLE_TABLE_CELL) {
537 | 							is_last_cell = cell == node;
538 | 							break;
539 | 						}
540 | 						cell = myhtml_node_prev(cell);
541 | 					}
542 | 					
543 | 					if (!is_last_cell) {
544 | 						html5_dom_rtrim_mystring(&state->value, ' ');
545 | 						mycore_string_append_one(&state->value, '\t');
546 | 					}
547 | 					
548 | 					state->new_line = true;
549 | 				}
550 | 				break;
551 | 				
552 | 				case TAG_UA_STYLE_TABLE_ROW:
553 | 				{
554 | 					bool is_last_row = false;
555 | 					myhtml_tree_node_t *row = myhtml_node_last_child(myhtml_node_parent(node));
556 | 					while (row) {
557 | 						if (html5_dom_get_ua_display_prop(row) == TAG_UA_STYLE_TABLE_ROW) {
558 | 							is_last_row = (row == node);
559 | 							break;
560 | 						}
561 | 						row = myhtml_node_prev(row);
562 | 					}
563 | 					
564 | 					if (!is_last_row) {
565 | 						html5_dom_rtrim_mystring(&state->value, ' ');
566 | 						mycore_string_append_one(&state->value, '\n');
567 | 						state->last_br = true;
568 | 					}
569 | 					
570 | 					state->new_line = true;
571 | 				}
572 | 				break;
573 | 			}
574 | 		}
575 | 	}
576 | }
577 | 
578 | // Safe delete nodes only if it has not perl object representation
579 | void html5_tree_node_delete_recursive(myhtml_tree_node_t *node) {
580 | 	if (!myhtml_node_get_data(node)) {
581 | 		myhtml_tree_node_t *child = myhtml_node_child(node);
582 | 		if (child) {
583 | 			while (child) {
584 | 				myhtml_tree_node_t *next = myhtml_node_next(child);
585 | 				myhtml_tree_node_remove(child);
586 | 				html5_tree_node_delete_recursive(child);
587 | 				child = next;
588 | 			}
589 | 		}
590 | 		myhtml_tree_node_delete(node);
591 | 	}
592 | }
593 | 
594 | /*
595 | 	attrs
596 | */
597 | void html5_dom_replace_attr_value(myhtml_tree_node_t *node, const char *key, size_t key_len, const char *val, size_t val_len, myencoding_t encoding) {
598 | 	myhtml_tree_attr_t *attr = myhtml_attribute_by_key(node, key, key_len);
599 | 	if (attr) { // edit
600 | 		// destroy original value
601 | 		mycore_string_destroy(&attr->value, 0);
602 | 		
603 | 		// set new value
604 | 		mycore_string_init(node->tree->mchar, node->tree->mchar_node_id, &attr->value, (val_len + 1));
605 | 		
606 | 		// apply encoding
607 | 		if (encoding == MyENCODING_UTF_8) {
608 | 			mycore_string_append(&attr->value, val, val_len);
609 | 		} else {
610 | 			myencoding_string_append(&attr->value, val, val_len, encoding);
611 | 		}
612 | 	} else { // add new
613 | 		myhtml_attribute_add(node, key, key_len, val, val_len, encoding);
614 | 	}
615 | }
616 | 
617 | /*
618 | 	encoding
619 | */
620 | myencoding_t html5_dom_auto_encoding(html5_dom_options_t *opts, const char **html_str, size_t *html_length) {
621 | 	// Try to determine encoding
622 | 	myencoding_t encoding;
623 | 	if (opts->encoding == MyENCODING_AUTO) {
624 | 		encoding = MyENCODING_NOT_DETERMINED;
625 | 		if (*html_length) {
626 | 			// Search encoding in meta-tags
627 | 			if (opts->encoding_use_meta) {
628 | 				size_t size = opts->encoding_prescan_limit < *html_length ? opts->encoding_prescan_limit : *html_length;
629 | 				encoding = myencoding_prescan_stream_to_determine_encoding(*html_str, size);
630 | 			}
631 | 			
632 | 			if (encoding == MyENCODING_NOT_DETERMINED) {
633 | 				// Check BOM
634 | 				if (!opts->encoding_use_bom || !myencoding_detect_and_cut_bom(*html_str, *html_length, &encoding, html_str, html_length)) {
635 | 					// Check heuristic
636 | 					if (!myencoding_detect(*html_str, *html_length, &encoding)) {
637 | 						// Can't determine encoding, use default
638 | 						encoding = opts->default_encoding;
639 | 					}
640 | 				}
641 | 			}
642 | 		} else {
643 | 			encoding = opts->default_encoding;
644 | 		}
645 | 	} else {
646 | 		encoding = opts->encoding;
647 | 	}
648 | 	return encoding;
649 | }
650 | 


--------------------------------------------------------------------------------
/t/0-api.t:
--------------------------------------------------------------------------------
   1 | use Test::More;
   2 | use warnings;
   3 | use strict;
   4 | 
   5 | # <test-body>
   6 | 
   7 | require_ok('HTML5::DOM');
   8 | 
   9 | # test static API
  10 | can_ok('HTML5::DOM', qw(new));
  11 | can_ok('HTML5::DOM::Collection', qw(new));
  12 | can_ok('HTML5::DOM::Encoding', qw(
  13 | 	id2name name2id detectAuto detect detectCyrillic detectUkrainian detectRussian detectUnicode
  14 | 	detectByPrescanStream detectByCharset detectBomAndCut
  15 | ));
  16 | can_ok('HTML5::DOM::CSS', qw(new));
  17 | can_ok('HTML5::DOM::CSS::Selector', qw(new));
  18 | 
  19 | #####################################
  20 | # HTML5::DOM
  21 | #####################################
  22 | 
  23 | # new without options
  24 | my $parser = HTML5::DOM->new;
  25 | isa_ok($parser, 'HTML5::DOM', 'create parser without options');
  26 | 
  27 | # new with options
  28 | $parser = HTML5::DOM->new({
  29 | 	threads	=> 2
  30 | });
  31 | isa_ok($parser, 'HTML5::DOM', 'create parser with options');
  32 | 
  33 | # test api
  34 | can_ok($parser, qw(parse parseChunkStart parseChunk parseChunkEnd parseAsync));
  35 | 
  36 | # test html parsing with threads
  37 | $parser = HTML5::DOM->new({threads	=> 2});
  38 | my $tree = $parser->parse('<div id="test">bla bla<!-- o_O --></div>');
  39 | isa_ok($tree, 'HTML5::DOM::Tree', 'parse with threads');
  40 | 
  41 | # test html parsing without threads
  42 | $parser = HTML5::DOM->new;
  43 | $tree = $parser->parse('<div id="test">bla bla<!-- o_O --></div>');
  44 | isa_ok($tree, 'HTML5::DOM::Tree', 'parse without threads');
  45 | 
  46 | # test api
  47 | can_ok($tree, qw(
  48 | 	createElement createComment createTextNode parseFragment document root head body
  49 | 	at querySelector find querySelectorAll findId getElementById findTag getElementsByTagName
  50 | 	findClass getElementsByClassName findAttr getElementByAttribute encoding encodingId
  51 | 	tag2id id2tag namespace2id id2namespace wait parsed parser
  52 | ));
  53 | 
  54 | # test chunks
  55 | isa_ok($parser->parseChunkStart(), 'HTML5::DOM');
  56 | isa_ok($parser->parseChunk('<div'), 'HTML5::DOM');
  57 | isa_ok($parser->parseChunk('>ololo'), 'HTML5::DOM');
  58 | isa_ok($parser->parseChunk('</div>'), 'HTML5::DOM');
  59 | isa_ok($parser->parseChunkTree, 'HTML5::DOM::Tree');
  60 | isa_ok($parser->parseChunk('ololo'), 'HTML5::DOM');
  61 | isa_ok($parser->parseChunkEnd, 'HTML5::DOM::Tree');
  62 | 
  63 | $parser->parseChunkStart->parseChunk('<div');
  64 | my $tree0 = $parser->parseChunkTree;
  65 | my $tree1 = $parser->parseChunkTree;
  66 | my $tree2 = $parser->parseChunkEnd;
  67 | 
  68 | ok($tree0 == $tree1, 'tree from chunks is eq [0]');
  69 | ok($tree2 == $tree1, 'tree from chunks is eq [1]');
  70 | 
  71 | #####################################
  72 | # HTML5::DOM::Tree
  73 | #####################################
  74 | 
  75 | $tree = $parser->parse('<div id="test">bla bla<!-- o_O --></div>');
  76 | 
  77 | # wait
  78 | isa_ok($tree->wait, "HTML5::DOM::Tree");
  79 | ok($tree->parsed == 1, "parsed");
  80 | 
  81 | # basic tree api
  82 | isa_ok($tree->root, 'HTML5::DOM::Element');
  83 | ok($tree->root->tag eq 'html', 'root tag name');
  84 | ok($tree->root->tagId == HTML5::DOM->TAG_HTML, 'root tag id');
  85 | 
  86 | isa_ok($tree->head, 'HTML5::DOM::Element');
  87 | ok($tree->head->tag eq 'head', 'head tag name');
  88 | ok($tree->head->tagId == HTML5::DOM->TAG_HEAD, 'head tag id');
  89 | 
  90 | isa_ok($tree->body, 'HTML5::DOM::Element');
  91 | ok($tree->body->tag eq 'body', 'body tag name');
  92 | ok($tree->body->tagId == HTML5::DOM->TAG_BODY, 'body tag id');
  93 | 
  94 | isa_ok($tree->document, 'HTML5::DOM::Document');
  95 | ok($tree->document->tag eq '-undef', 'document tag name');
  96 | ok($tree->document->tagId == HTML5::DOM->TAG__UNDEF, 'document tag id');
  97 | 
  98 | # createElement with namespace
  99 | my $new_node = $tree->createElement("mycustom", "svg");
 100 | isa_ok($new_node, 'HTML5::DOM::Element');
 101 | ok($new_node->tag eq 'mycustom', 'mycustom tag name');
 102 | ok($new_node->namespace eq 'SVG', 'mycustom namespace name');
 103 | ok($new_node->namespaceId eq HTML5::DOM->NS_SVG, 'mycustom namespace id');
 104 | ok($new_node->tagId == $tree->tag2id('mycustom'), 'mycustom tag id');
 105 | 
 106 | # createElement with default namespace
 107 | $new_node = $tree->createElement("mycustom2");
 108 | isa_ok($new_node, 'HTML5::DOM::Element');
 109 | ok($new_node->namespace eq 'HTML', 'mycustom2 namespace name');
 110 | ok($new_node->namespaceId eq HTML5::DOM->NS_HTML, 'mycustom2 namespace id');
 111 | 
 112 | # createComment
 113 | $new_node = $tree->createComment(" my comment >_< ");
 114 | isa_ok($new_node, 'HTML5::DOM::Comment');
 115 | ok($new_node->text eq ' my comment >_< ', 'Comment serialization text');
 116 | ok($new_node->html eq '<!-- my comment >_< -->', 'Comment serialization html');
 117 | 
 118 | # createTextNode
 119 | $new_node = $tree->createTextNode(" my text >_< ");
 120 | isa_ok($new_node, 'HTML5::DOM::Text');
 121 | ok($new_node->text eq ' my text >_< ', 'Text serialization text');
 122 | ok($new_node->html eq ' my text &gt;_&lt; ', 'Text serialization html');
 123 | 
 124 | # parseFragment
 125 | $new_node = $tree->parseFragment(" <div>its <b>a</b><!-- ololo --> fragment</div> ");
 126 | isa_ok($new_node, 'HTML5::DOM::Fragment');
 127 | ok($new_node->text eq ' its a fragment ', 'Fragment serialization text');
 128 | ok($new_node->html eq ' <div>its <b>a</b><!-- ololo --> fragment</div> ', 'Fragment serialization html');
 129 | 
 130 | # encoding
 131 | ok($tree->encoding() eq "UTF-8", "encoding");
 132 | ok($tree->encodingId() == HTML5::DOM::Encoding->UTF_8, "encodingId");
 133 | 
 134 | # tag2id
 135 | ok($tree->tag2id("div") == HTML5::DOM->TAG_DIV, "tag2id");
 136 | ok($tree->tag2id("DiV") == HTML5::DOM->TAG_DIV, "tag2id");
 137 | ok($tree->tag2id("blablabla") == HTML5::DOM->TAG__UNDEF, "tag2id not exists");
 138 | 
 139 | # id2tag
 140 | ok($tree->id2tag(HTML5::DOM->TAG_DIV) eq "div", "id2tag");
 141 | ok(!defined $tree->id2tag(8274242), "id2tag not exists");
 142 | 
 143 | # namespace2id
 144 | ok($tree->namespace2id("SvG") == HTML5::DOM->NS_SVG, "namespace2id");
 145 | ok($tree->namespace2id("svg") == HTML5::DOM->NS_SVG, "namespace2id");
 146 | ok($tree->namespace2id("blablabla") == HTML5::DOM->NS_UNDEF, "namespace2id not exists");
 147 | 
 148 | # id2namespace
 149 | ok($tree->id2namespace(HTML5::DOM->NS_SVG) eq "SVG", "id2namespace");
 150 | ok(!defined $tree->id2namespace(8274242), "id2namespace not exists");
 151 | 
 152 | # parser
 153 | isa_ok($tree->parser, 'HTML5::DOM');
 154 | ok($tree->parser == $parser, 'parser');
 155 | 
 156 | # finders
 157 | $tree = $parser->parse('
 158 | 	<!DOCTYPE html>
 159 | 	<div id="test0" some-attr="ololo trololo" class="red blue">
 160 | 		<div class="yellow" id="test1"></div>
 161 | 	</div>
 162 | 	<div id="test2" some-attr="ololo" class="blue">
 163 | 		<div class="yellow" id="test3"></div>
 164 | 	</div>
 165 | 	
 166 | 	<span test-attr-eq="test"></span>
 167 | 	<span test-attr-eq="testt"></span>
 168 | 	
 169 | 	<span test-attr-space="wefwef   test   wefewfew"></span>
 170 | 	<span test-attr-space="wefewwef testt wewe"></span>
 171 | 	
 172 | 	<span test-attr-dash="test-fwefwewfe"></span>
 173 | 	<span test-attr-dash="testt-"></span>
 174 | 	
 175 | 	<span test-attr-substr="wefwefweftestfweewfwe"></span>
 176 | 	
 177 | 	<span test-attr-prefix="testewfwefewwf"></span>
 178 | 	
 179 | 	<span test-attr-suffix="ewfwefwefweftest"></span>
 180 | ');
 181 | 
 182 | # querySelector + at
 183 | for my $method (qw|at querySelector|) {
 184 | 	isa_ok($tree->$method('div'), 'HTML5::DOM::Element');
 185 | 	ok($tree->$method('div')->attr("id") eq 'test0', "$method: find div");
 186 | 	ok(!defined $tree->$method('xuj'), "$method: not found");
 187 | }
 188 | 
 189 | # findId + getElementById
 190 | for my $method (qw|findId getElementById|) {
 191 | 	isa_ok($tree->$method('test2'), 'HTML5::DOM::Element');
 192 | 	ok($tree->$method('test2')->attr("id") eq 'test2', "$method: find #test2");
 193 | 	ok(!defined $tree->$method('xuj'), "$method: not found");
 194 | }
 195 | 
 196 | # find + querySelectorAll
 197 | for my $method (qw|find querySelectorAll|) {
 198 | 	isa_ok($tree->$method('.blue'), 'HTML5::DOM::Collection');
 199 | 	isa_ok($tree->$method('.ewfwefwefwefwef'), 'HTML5::DOM::Collection');
 200 | 	ok($tree->$method('.blue')->length == 2, "$method: find .blue");
 201 | 	ok($tree->$method('.bluE')->length == 0, "$method: find .bluE");
 202 | 	ok($tree->$method('.ewfwefwefwefwef')->length == 0, "$method: not found");
 203 | 	ok($tree->$method('.blue')->item(1)->attr("id") eq "test2", "$method: check result element");
 204 | }
 205 | 
 206 | # findTag + getElementsByTagName
 207 | for my $method (qw|findTag getElementsByTagName|) {
 208 | 	isa_ok($tree->$method('div'), 'HTML5::DOM::Collection');
 209 | 	isa_ok($tree->$method('ewfwefwefwefwef'), 'HTML5::DOM::Collection');
 210 | 	ok($tree->$method('div')->length == 4, "$method: find div");
 211 | 	ok($tree->$method('dIv')->length == 4, "$method: find dIv");
 212 | 	ok($tree->$method('ewfwefwefwefwef')->length == 0, "$method: not found");
 213 | 	ok($tree->$method('div')->item(0)->attr("id") eq "test0", "$method: check result element");
 214 | }
 215 | 
 216 | # findClass + getElementsByClassName
 217 | for my $method (qw|findClass getElementsByClassName|) {
 218 | 	isa_ok($tree->$method('blue'), 'HTML5::DOM::Collection');
 219 | 	isa_ok($tree->$method('ewfwefwefwefwef'), 'HTML5::DOM::Collection');
 220 | 	ok($tree->$method('blue')->length == 2, "$method: find .blue");
 221 | 	ok($tree->$method('red')->length == 1, "$method: find .red");
 222 | 	ok($tree->$method('bluE')->length == 0, "$method: find .bluE");
 223 | 	ok($tree->$method('ewfwefwefwefwef')->length == 0, "$method: not found");
 224 | 	ok($tree->$method('yellow')->item(0)->attr("id") eq "test1", "$method: check result element");
 225 | }
 226 | 
 227 | # findAttr + getElementByAttribute
 228 | for my $method (qw|findAttr getElementByAttribute|) {
 229 | 	for my $cmp (qw(= ~ | * ^ $)) {
 230 | 		for my $i ((0, 1)) {
 231 | 			my $attrs = {
 232 | 				'='	=> 'test-attr-eq', 
 233 | 				'~'	=> 'test-attr-space', 
 234 | 				'|'	=> 'test-attr-dash', 
 235 | 				'*'	=> 'test-attr-substr', 
 236 | 				'^'	=> 'test-attr-prefix', 
 237 | 				'$'	=> 'test-attr-suffix', 
 238 | 			};
 239 | 			
 240 | 			my $values = [['test', 'tesT'], ['tEsT', 'test2']];
 241 | 			
 242 | 			# test found
 243 | 			my $collection = $tree->$method($attrs->{$cmp}, $values->[$i]->[0], $i, $cmp);
 244 | 			isa_ok($collection, 'HTML5::DOM::Collection');
 245 | 			ok($collection->length == 1, "$method(".$attrs->{$cmp}.", $cmp, $i): found ".$collection->length);
 246 | 			
 247 | 			# test not found
 248 | 			$collection = $tree->$method($attrs->{$cmp}, $values->[$i]->[1], $i, $cmp);
 249 | 			isa_ok($collection, 'HTML5::DOM::Collection');
 250 | 			ok($collection->length == 0, "$method(".$attrs->{$cmp}.", $cmp, $i): not found ".$collection->length);
 251 | 		}
 252 | 	}
 253 | }
 254 | 
 255 | # compatMode
 256 | ok($parser->parse('<div></div>')->compatMode eq 'BackCompat', 'compatMode: BackCompat');
 257 | ok($parser->parse('<!DOCTYPE html><div></div>')->compatMode eq 'CSS1Compat', 'compatMode: CSS1Compat');
 258 | 
 259 | #####################################
 260 | # HTML5::DOM::AsyncResult
 261 | #####################################
 262 | 
 263 | my $async;
 264 | 
 265 | for my $threads ((0, 2)) {
 266 | 	$parser = HTML5::DOM->new({threads => $threads});
 267 | 	
 268 | 	$async = $parser->parseAsync('<div class="test">PASSED</div>');
 269 | 	
 270 | 	# check api + isa
 271 | 	can_ok($async, qw(parsed wait tree));
 272 | 	isa_ok($async, 'HTML5::DOM::AsyncResult', "AsyncResult [threads=$threads]");
 273 | 	
 274 | 	# check parsed()
 275 | 	while (!$async->parsed) { };
 276 | 	ok($async->parsed == 1, "parsed [threads=$threads]");
 277 | 	
 278 | 	# check wait()
 279 | 	isa_ok($async->wait, 'HTML5::DOM::Tree', "wait [threads=$threads]");
 280 | 	
 281 | 	# check tree()
 282 | 	isa_ok($async->tree, 'HTML5::DOM::Tree', "tree [threads=$threads]");
 283 | 	
 284 | 	# test leak
 285 | 	(sub { $parser->parseAsync('<div class="test">PASSED</div>', {threads => $threads}); })->();
 286 | 	(sub { my $new_parser = $parser->parseAsync('<div class="test">PASSED</div>', {threads => $threads})->wait->parser; })->();
 287 | 	(sub { $parser->parseAsync('<div class="test">PASSED</div>', {threads => $threads})->wait->parser->parse(""); })->();
 288 | }
 289 | 
 290 | #####################################
 291 | # HTML5::DOM::Node
 292 | #####################################
 293 | $parser = HTML5::DOM->new;
 294 | 
 295 | my @node_methods = qw(
 296 | 	tag nodeName tagId namespace namespaceId tree nodeType next nextElementSibling
 297 | 	prev previousElementSibling nextNode nextSibling prevNode previousSibling 
 298 | 	html innerHTML outerHTML text innerText outerText textContent
 299 | 	nodeHtml nodeValue data isConnected parent parentElement document ownerDocument
 300 | 	append appendChild prepend prependChild replace replaceChild before insertBefore
 301 | 	after insertAfter remove removeChild clone cloneNode void selfClosed position
 302 | 	isSameNode wait parsed
 303 | );
 304 | my @element_methods = qw(
 305 | 	first firstElementChild last lastElementChild firstNode firstChild lastNode lastChild
 306 | 	children childrenNode childNodes attr removeAttr getAttribute setAttribute
 307 | 	removeAttribute at querySelector find querySelectorAll findId getElementById
 308 | 	findTag getElementsByTagName findClass getElementsByClassName findAttr
 309 | 	getElementByAttribute getDefaultBoxType
 310 | );
 311 | 
 312 | # check elements + nodeType
 313 | my $el_node = $tree->createElement("div");
 314 | can_ok($el_node, @node_methods);
 315 | can_ok($el_node, @element_methods);
 316 | ok(ref($el_node) eq 'HTML5::DOM::Element', 'check element ref');
 317 | ok($el_node->nodeType == $el_node->ELEMENT_NODE, 'nodeType == ELEMENT_NODE');
 318 | 
 319 | # check comments + nodeType
 320 | my $comment_node = $tree->createComment("comment...");
 321 | can_ok($comment_node, @node_methods);
 322 | ok(ref($comment_node) eq 'HTML5::DOM::Comment', 'check comment ref');
 323 | ok($comment_node->nodeType == $comment_node->COMMENT_NODE, 'nodeType == COMMENT_NODE');
 324 | 
 325 | # check texts + nodeType
 326 | my $text_node = $tree->createTextNode("text?");
 327 | can_ok($text_node, @node_methods);
 328 | ok(ref($text_node) eq 'HTML5::DOM::Text', 'check text ref');
 329 | ok($text_node->nodeType == $text_node->TEXT_NODE, 'nodeType == TEXT_NODE');
 330 | 
 331 | # check doctype + nodeType
 332 | my $doctype_node = $parser->parse('<!DOCTYPE html>')->document->[0];
 333 | can_ok($doctype_node, @node_methods);
 334 | ok(ref($doctype_node) eq 'HTML5::DOM::DocType', 'check doctype ref');
 335 | ok($doctype_node->nodeType == $doctype_node->DOCUMENT_TYPE_NODE, 'nodeType == DOCUMENT_TYPE_NODE');
 336 | 
 337 | # check fragment + nodeType
 338 | my $frag_node = $tree->parseFragment('test...');
 339 | can_ok($frag_node, @node_methods);
 340 | can_ok($frag_node, @element_methods);
 341 | ok(ref($frag_node) eq 'HTML5::DOM::Fragment', 'check fragment ref');
 342 | ok($frag_node->nodeType == $frag_node->DOCUMENT_FRAGMENT_NODE, 'nodeType == DOCUMENT_FRAGMENT_NODE');
 343 | 
 344 | # check document + nodeType
 345 | my $doc_node = $tree->document;
 346 | can_ok($doc_node, @node_methods);
 347 | can_ok($doc_node, @element_methods);
 348 | ok(ref($doc_node) eq 'HTML5::DOM::Document', 'check document ref');
 349 | ok($doc_node->nodeType == $doc_node->DOCUMENT_NODE, 'nodeType == DOCUMENT_NODE');
 350 | 
 351 | # tag + nodeName
 352 | $el_node = $tree->createElement("div");
 353 | ok($el_node->tag eq "div", "node->tag");
 354 | ok($el_node->nodeName eq "DIV", "node->nodeName");
 355 | ok($el_node->tagName eq "DIV", "node->tagName");
 356 | 
 357 | for my $method (qw|tag nodeName tagName|) {
 358 | 	my $node = $tree->createElement("div");
 359 | 	
 360 | 	isa_ok($node->$method("span"), 'HTML5::DOM::Node');
 361 | 	ok($node->nodeName eq "SPAN", "$method: change tag to span");
 362 | 	
 363 | 	isa_ok($node->$method("blablaxuj"), 'HTML5::DOM::Node');
 364 | 	ok($node->nodeName eq "BLABLAXUJ", "$method: change tag to blablaxuj");
 365 | 	
 366 | 	isa_ok($node->$method("blablaxuj" x 102400), 'HTML5::DOM::Node');
 367 | 	ok($node->nodeName eq "BLABLAXUJ" x 102400, "$method: change tag to long blablaxuj");
 368 | 	
 369 | 	eval { $node->$method(""); };
 370 | 	ok($@ =~ /empty tag name not allowed/, "$method: change tag to empty string");
 371 | }
 372 | 
 373 | # tagId
 374 | $el_node = $tree->createElement("div");
 375 | ok($el_node->tagId == HTML5::DOM->TAG_DIV, "node->tagId");
 376 | isa_ok($el_node->tagId(HTML5::DOM->TAG_SPAN), 'HTML5::DOM::Node');
 377 | ok($el_node->tagId == HTML5::DOM->TAG_SPAN, "node->tagId");
 378 | eval { $el_node->tagId(999999999); };
 379 | ok($@ =~ /unknown tag id/, "tagId: change tag to unknown id");
 380 | 
 381 | # namespace
 382 | $el_node = $tree->createElement("div", "svg");
 383 | ok($el_node->namespace eq "SVG", "node->namespace");
 384 | isa_ok($el_node->namespace("hTml"), 'HTML5::DOM::Node');
 385 | ok($el_node->namespace eq "HTML", "node->namespace");
 386 | eval { $el_node->namespace("ewfwefwefwefwef"); };
 387 | ok($@ =~ /unknown namespace/, "node->namespace: set unknown namespace");
 388 | 
 389 | # namespaceId
 390 | $el_node = $tree->createElement("div");
 391 | ok($el_node->namespaceId == HTML5::DOM->NS_HTML, "node->namespaceId");
 392 | isa_ok($el_node->namespaceId(HTML5::DOM->NS_SVG), 'HTML5::DOM::Node');
 393 | ok($el_node->namespaceId == HTML5::DOM->NS_SVG, "node->namespaceId");
 394 | eval { $el_node->namespaceId(999999999); };
 395 | ok($@ =~ /unknown namespace/, "node->namespaceId: set unknown namespace");
 396 | 
 397 | # tree
 398 | isa_ok($el_node->tree, "HTML5::DOM::Tree");
 399 | ok($el_node->tree == $tree, "node->tree");
 400 | 
 401 | $tree = HTML5::DOM->new->parse('
 402 |    <ul>
 403 |        <li>Linux</li>
 404 |        <!-- comment -->
 405 |        <li>OSX</li>
 406 |        <li>Windows</li>
 407 |    </ul>
 408 | ');
 409 | 
 410 | # test all siblings navigators
 411 | my $siblings_tests = [
 412 | 	{
 413 | 		methods	=> [qw|next nextElementSibling|], 
 414 | 		index	=> 1, 
 415 | 		results	=> [
 416 | 			['HTML5::DOM::Element',	qr/^Linux$/], 
 417 | 			['HTML5::DOM::Element',	qr/^OSX$/], 
 418 | 			['HTML5::DOM::Element',	qr/^Windows$/], 
 419 | 			['',					undef]
 420 | 		]
 421 | 	}, 
 422 | 	{
 423 | 		methods	=> [qw|prev previousElementSibling|], 
 424 | 		index	=> -2, 
 425 | 		results	=> [
 426 | 			['HTML5::DOM::Element',	qr/^Windows$/], 
 427 | 			['HTML5::DOM::Element',	qr/^OSX$/], 
 428 | 			['HTML5::DOM::Element',	qr/^Linux$/], 
 429 | 			['',					undef]
 430 | 		]
 431 | 	}, 
 432 | 	{
 433 | 		methods	=> [qw|nextNode nextSibling|], 
 434 | 		index	=> 0, 
 435 | 		results	=> [
 436 | 			['HTML5::DOM::Text',	qr/^\s+$/], 
 437 | 			['HTML5::DOM::Element',	qr/^Linux$/], 
 438 | 			['HTML5::DOM::Text',	qr/^\s+$/], 
 439 | 			['HTML5::DOM::Comment',	qr/^ comment $/], 
 440 | 			['HTML5::DOM::Text',	qr/^\s+$/], 
 441 | 			['HTML5::DOM::Element',	qr/^OSX$/], 
 442 | 			['HTML5::DOM::Text',	qr/^\s+$/], 
 443 | 			['HTML5::DOM::Element',	qr/^Windows$/], 
 444 | 			['HTML5::DOM::Text',	qr/^\s+$/], 
 445 | 			['',					undef]
 446 | 		]
 447 | 	}, 
 448 | 	{
 449 | 		methods	=> [qw|prevNode previousSibling|], 
 450 | 		index	=> -1, 
 451 | 		results	=> [
 452 | 			['HTML5::DOM::Text',	qr/^\s+$/], 
 453 | 			['HTML5::DOM::Element',	qr/^Windows$/], 
 454 | 			['HTML5::DOM::Text',	qr/^\s+$/], 
 455 | 			['HTML5::DOM::Element',	qr/^OSX$/], 
 456 | 			['HTML5::DOM::Text',	qr/^\s+$/], 
 457 | 			['HTML5::DOM::Comment',	qr/^ comment $/], 
 458 | 			['HTML5::DOM::Text',	qr/^\s+$/], 
 459 | 			['HTML5::DOM::Element',	qr/^Linux$/], 
 460 | 			['HTML5::DOM::Text',	qr/^\s+$/], 
 461 | 			['',					undef]
 462 | 		]
 463 | 	}
 464 | ];
 465 | 
 466 | for my $test (@$siblings_tests) {
 467 | 	my $ul = $tree->at('ul');
 468 | 	ok($ul->tag eq 'ul', "siblings test: check test element");
 469 | 	
 470 | 	for my $method (@{$test->{methods}}) {
 471 | 		my $next = $ul->childrenNode->[$test->{index}];
 472 | 		my @chain = ($method);
 473 | 		for my $result (@{$test->{results}}) {
 474 | 			ok(ref($next) eq $result->[0], join(" > ", @chain)." check ref");
 475 | 			
 476 | 			if (defined $result->[1]) {
 477 | 				ok($next->text =~ $result->[1], join(" > ", @chain)." check value");
 478 | 			} else {
 479 | 				ok(!defined $result->[1], join(" > ", @chain)." (undef)");
 480 | 			}
 481 | 			
 482 | 			last if (!$next);
 483 | 			
 484 | 			$next = $next->$method;
 485 | 			push @chain, $method;
 486 | 		}
 487 | 	}
 488 | }
 489 | 
 490 | $tree = HTML5::DOM->new->parse('
 491 |    <ul><!--
 492 |         first comment -->
 493 |        <li>Linux</li>
 494 |        <li>OSX</li>
 495 |        <li>Windows</li>
 496 |        <!-- last comment 
 497 |    --></ul>
 498 | ');
 499 | 
 500 | # test all first/last navigators
 501 | my $first_last_tests = [
 502 | 	{
 503 | 		methods	=> [qw|first firstElementChild|], 
 504 | 		results	=> [
 505 | 			['HTML5::DOM::Element',	qr/^Linux$/], 
 506 | 			['',					undef]
 507 | 		]
 508 | 	}, 
 509 | 	{
 510 | 		methods	=> [qw|last lastElementChild|], 
 511 | 		results	=> [
 512 | 			['HTML5::DOM::Element',	qr/^Windows$/], 
 513 | 			['',					undef], 
 514 | 		]
 515 | 	}, 
 516 | 	{
 517 | 		methods	=> [qw|firstNode firstChild|], 
 518 | 		results	=> [
 519 | 			['HTML5::DOM::Comment',	qr/^\s+first comment\s+$/]
 520 | 		]
 521 | 	}, 
 522 | 	{
 523 | 		methods	=> [qw|lastNode lastChild|], 
 524 | 		results	=> [
 525 | 			['HTML5::DOM::Comment',	qr/^\s+last comment\s+$/]
 526 | 		]
 527 | 	}
 528 | ];
 529 | 
 530 | for my $test (@$first_last_tests) {
 531 | 	my $ul = $tree->at('ul');
 532 | 	ok($ul->tag eq 'ul', "first/last test: check test element");
 533 | 	
 534 | 	for my $method (@{$test->{methods}}) {
 535 | 		my $next = $ul->$method;
 536 | 		my @chain = ($method);
 537 | 		for my $result (@{$test->{results}}) {
 538 | 			ok(ref($next) eq $result->[0], join(" > ", @chain)." check ref .. ".ref($next));
 539 | 			
 540 | 			if (defined $result->[1]) {
 541 | 				ok($next->text =~ $result->[1], join(" > ", @chain)." check value");
 542 | 			} else {
 543 | 				ok(!defined $result->[1], join(" > ", @chain)." (undef)");
 544 | 			}
 545 | 			
 546 | 			last if (!$next || !$next->can($method));
 547 | 			
 548 | 			$next = $next->$method;
 549 | 			push @chain, $method;
 550 | 		}
 551 | 	}
 552 | }
 553 | 
 554 | # html and text serialzation
 555 | $tree = HTML5::DOM->new->parse('<body aaa="bb"><b>      <!-- super cool new comment --> ololo ??? <div class="red">&nbsp;&gt;&lt;&quot;</div></b></body>');
 556 | 
 557 | my $html_serialize2 = {
 558 | 	'html'			=> '<body aaa="bb"><b>      <!-- super cool new comment --> ololo ??? <div class="red">&nbsp;&gt;&lt;"</div></b></body>', 
 559 | 	'innerHTML'		=> '<b>      <!-- super cool new comment --> ololo ??? <div class="red">&nbsp;&gt;&lt;"</div></b>', 
 560 | 	'outerHTML'		=> '<body aaa="bb"><b>      <!-- super cool new comment --> ololo ??? <div class="red">&nbsp;&gt;&lt;"</div></b></body>', 
 561 | 	'nodeHtml'		=> '<body aaa="bb">', 
 562 | 	'text'			=> '       ololo ???  ><"', 
 563 | 	'innerText'		=> "ololo ???\n ><\"\n", 
 564 | 	'outerText'		=> "ololo ???\n ><\"\n", 
 565 | 	'textContent'	=> '       ololo ???  ><"', 
 566 | 	'nodeValue'		=> undef, 
 567 | 	'data'			=> undef
 568 | };
 569 | 
 570 | for my $method (keys %$html_serialize2) {
 571 | 	if (defined $html_serialize2->{$method}) {
 572 | 		ok($tree->body->$method eq $html_serialize2->{$method}, "$method serialization");
 573 | 	} else {
 574 | 		ok(!defined $tree->body->$method, "$method serialization (undef)");
 575 | 	}
 576 | }
 577 | 
 578 | # html/text fragments
 579 | my $html_serialize3 = [
 580 | 	{
 581 | 		method	=> 'html', 
 582 | 		html	=> '<b>      <!-- super cool new comment --> ololo ??? <div class="red">&nbsp;&gt;&lt;&quot;</div></b>', 
 583 | 		body	=> '<body><div id="test"><b>      <!-- super cool new comment --> ololo ??? <div class="red">&nbsp;&gt;&lt;"</div></b></div></body>'
 584 | 	}, 
 585 | 	{
 586 | 		method	=> 'innerHTML', 
 587 | 		html	=> '<b>      <!-- super cool new comment --> ololo ??? <div class="red">&nbsp;&gt;&lt;&quot;</div></b>', 
 588 | 		body	=> '<body><div id="test"><b>      <!-- super cool new comment --> ololo ??? <div class="red">&nbsp;&gt;&lt;"</div></b></div></body>'
 589 | 	}, 
 590 | 	{
 591 | 		method	=> 'outerHTML', 
 592 | 		html	=> '<b>      <!-- super cool new comment --> ololo ??? <div class="red">&nbsp;&gt;&lt;&quot;</div></b>', 
 593 | 		body	=> '<body><b>      <!-- super cool new comment --> ololo ??? <div class="red">&nbsp;&gt;&lt;"</div></b></body>'
 594 | 	}, 
 595 | 	{
 596 | 		method	=> 'text', 
 597 | 		html	=> "\nololo   >^_^<   trololo\n", 
 598 | 		body	=> "<body><div id=\"test\">\nololo   &gt;^_^&lt;   trololo\n</div></body>"
 599 | 	}, 
 600 | 	{
 601 | 		method	=> 'textContent', 
 602 | 		html	=> "\nololo   >^_^<   trololo\n", 
 603 | 		body	=> "<body><div id=\"test\">\nololo   &gt;^_^&lt;   trololo\n</div></body>"
 604 | 	}, 
 605 | 	{
 606 | 		method	=> 'innerText', 
 607 | 		html	=> "\nololo   >^_^<   trololo\n", 
 608 | 		body	=> "<body><div id=\"test\"><br>ololo   &gt;^_^&lt;   trololo<br></div></body>"
 609 | 	}, 
 610 | 	{
 611 | 		method	=> 'outerText', 
 612 | 		html	=> "\nololo   >^_^<   trololo\n", 
 613 | 		body	=> "<body><br>ololo   &gt;^_^&lt;   trololo<br></body>"
 614 | 	}
 615 | ];
 616 | 
 617 | for my $test (@$html_serialize3) {
 618 | 	$tree = HTML5::DOM->new->parse('<div id="test"><b><!-- super cool new comment --> ololo ??? <div class="red">&nbsp;&gt;&lt;&quot;</div></b></div>');
 619 | 	
 620 | 	my $method = $test->{method};
 621 | 	my $method2 = $test->{method2};
 622 | 	my $test_el = $tree->at('#test');
 623 | 	
 624 | 	my $ret = $test_el->$method($test->{html});
 625 | 	isa_ok($ret, "HTML5::DOM::Node");
 626 | 	ok($ret == $test_el, "$method return test: '".$tree->body->html."'");
 627 | 	ok($tree->body->html eq $test->{body}, "$method content test");
 628 | }
 629 | 
 630 | # isConnected
 631 | my $node_test_connected = $tree->createElement('ololo');
 632 | ok($node_test_connected->isConnected == 0, 'isConnected == 0');
 633 | $tree->body->append($node_test_connected);
 634 | ok($node_test_connected->isConnected == 1, 'isConnected == 1');
 635 | 
 636 | # parent
 637 | for my $method (qw|parent parentElement|) {
 638 | 	ok($node_test_connected->$method == $tree->body, "$method check");
 639 | }
 640 | 
 641 | # document + ownerDocument
 642 | for my $method (qw|document ownerDocument|) {
 643 | 	ok($node_test_connected->$method == $tree->document, "$method check");
 644 | }
 645 | 
 646 | # clone
 647 | $tree = HTML5::DOM->new->parse('<div id="test"><b><!-- super cool new comment --> ololo ??? <div class="red">&nbsp;&gt;&lt;&quot;</div></b></div>');
 648 | 
 649 | my $clone_tests = [
 650 | 	{
 651 | 		src		=> $tree->at('#test'), 
 652 | 		html	=> '<div id="test"></div>', 
 653 | 		deep	=> 0
 654 | 	}, 
 655 | 	{
 656 | 		src		=> $tree->at('#test'), 
 657 | 		html	=> $tree->at('#test')->html, 
 658 | 		deep	=> 1
 659 | 	}, 
 660 | 	{
 661 | 		src		=> $tree->createComment(" comment >^_^< "), 
 662 | 		html	=> $tree->createComment(" comment >^_^< ")->html, 
 663 | 		deep	=> 0
 664 | 	}, 
 665 | 	{
 666 | 		src		=> $tree->createComment(" comment >^_^< "), 
 667 | 		html	=> $tree->createComment(" comment >^_^< ")->html, 
 668 | 		deep	=> 1
 669 | 	}, 
 670 | 	{
 671 | 		src		=> $tree->createTextNode(" text >^_^< "), 
 672 | 		html	=> $tree->createTextNode(" text >^_^< ")->html, 
 673 | 		deep	=> 0
 674 | 	}, 
 675 | 	{
 676 | 		src		=> $tree->createTextNode(" text >^_^< "), 
 677 | 		html	=> $tree->createTextNode(" text >^_^< ")->html, 
 678 | 		deep	=> 1
 679 | 	}, 
 680 | ];
 681 | 
 682 | my $new_tree = HTML5::DOM->new->parse('<div id="test"></div>');
 683 | 
 684 | for my $copy_dst_tree (($tree, $new_tree)) {
 685 | 	for my $method (qw|clone cloneNode|) {
 686 | 		for my $test (@$clone_tests) {
 687 | 			my $clone = $test->{src}->$method($test->{deep}, $copy_dst_tree);
 688 | 			ok($copy_dst_tree == $clone->tree, ref($test->{src})."->$method(".$test->{deep}.") tree");
 689 | 			ok($clone != $test->{src}, ref($test->{src})."->$method(".$test->{deep}.") eq");
 690 | 			ok($clone->html eq $test->{html}, ref($test->{src})."$method(".$test->{deep}.") content");
 691 | 		}
 692 | 	}
 693 | }
 694 | 
 695 | # void
 696 | ok($tree->createElement('br')->void == 1, 'void == 1');
 697 | ok($tree->createElement('div')->void == 0, 'void == 0');
 698 | 
 699 | # selfClosed
 700 | ok($tree->parseFragment('<meta />')->first->selfClosed == 1, 'selfClosed == 1');
 701 | ok($tree->parseFragment('<meta></meta>')->first->selfClosed == 0, 'selfClosed == 0');
 702 | 
 703 | # wait
 704 | my $test_pos_buff = '<div><div id="position"></div></div>';
 705 | $tree = HTML5::DOM->new->parse($test_pos_buff);
 706 | isa_ok($tree->body->wait, "HTML5::DOM::Node");
 707 | ok($tree->body->parsed == 1, "parsed");
 708 | 
 709 | # position
 710 | my $pos = $tree->at('#position')->position;
 711 | ok(ref($pos) eq 'HASH', 'position is HASH');
 712 | ok(substr($test_pos_buff, $pos->{raw_begin}, $pos->{raw_length}) eq 'div', 'position raw begin/length');
 713 | ok(substr($test_pos_buff, $pos->{element_begin}, $pos->{element_length}) eq '<div id="position">', 'position element begin/length');
 714 | 
 715 | # isSameNode
 716 | ok($tree->body->isSameNode($tree->body) == 1, 'isSameNode == 1');
 717 | ok($tree->body->isSameNode($tree->head) == 0, 'isSameNode == 0');
 718 | 
 719 | # DOM node insertion manipulations
 720 | my $test_manipulations = [
 721 | 	{
 722 | 		method	=> 'append', 
 723 | 		method2	=> 'last', 
 724 | 		arg		=> sub { shift->createElement('div') }, 
 725 | 		return	=> 'self', 
 726 | 		type	=> 'add'
 727 | 	}, 
 728 | 	{
 729 | 		method	=> 'appendChild', 
 730 | 		method2	=> 'last', 
 731 | 		arg		=> sub { shift->createElement('div') }, 
 732 | 		return	=> 'added', 
 733 | 		type	=> 'add'
 734 | 	}, 
 735 | 	{
 736 | 		method	=> 'prepend', 
 737 | 		method2	=> 'first', 
 738 | 		arg		=> sub { shift->createElement('div') }, 
 739 | 		return	=> 'self', 
 740 | 		type	=> 'add'
 741 | 	}, 
 742 | 	{
 743 | 		method	=> 'prependChild', 
 744 | 		method2	=> 'first', 
 745 | 		arg		=> sub { shift->createElement('div') }, 
 746 | 		return	=> 'added', 
 747 | 		type	=> 'add'
 748 | 	}, 
 749 | 	{
 750 | 		method	=> 'replace', 
 751 | 		method2	=> 'first', 
 752 | 		arg		=> sub { shift->createElement('div') }, 
 753 | 		return	=> 'self', 
 754 | 		type	=> 'replace'
 755 | 	}, 
 756 | 	{
 757 | 		method	=> 'replaceChild', 
 758 | 		method2	=> 'first', 
 759 | 		arg		=> sub { shift->createElement('div') }, 
 760 | 		return	=> 'self', 
 761 | 		type	=> 'replace', 
 762 | 		parent	=> 1
 763 | 	}, 
 764 | 	{
 765 | 		method	=> 'before', 
 766 | 		method2	=> 'first', 
 767 | 		arg		=> sub { shift->createElement('div') }, 
 768 | 		return	=> 'self', 
 769 | 		type	=> 'add2', 
 770 | 		custom	=> [2, 0, 4], 
 771 | 		offset	=> -1
 772 | 	}, 
 773 | 	{
 774 | 		method	=> 'insertBefore', 
 775 | 		method2	=> 'first', 
 776 | 		arg		=> sub { shift->createElement('div') }, 
 777 | 		return	=> 'added', 
 778 | 		type	=> 'add2', 
 779 | 		custom	=> [2, 0, 4], 
 780 | 		offset	=> -1, 
 781 | 		parent	=> 1
 782 | 	}, 
 783 | 	{
 784 | 		method	=> 'after', 
 785 | 		method2	=> 'first', 
 786 | 		arg		=> sub { shift->createElement('div') }, 
 787 | 		return	=> 'self', 
 788 | 		type	=> 'add2', 
 789 | 		custom	=> [2, 0, 4], 
 790 | 		offset	=> 1
 791 | 	}, 
 792 | 	{
 793 | 		method	=> 'insertAfter', 
 794 | 		method2	=> 'first', 
 795 | 		arg		=> sub { shift->createElement('div') }, 
 796 | 		return	=> 'added', 
 797 | 		type	=> 'add2', 
 798 | 		custom	=> [2, 0, 4], 
 799 | 		offset	=> 1, 
 800 | 		parent	=> 1
 801 | 	}, 
 802 | 	{
 803 | 		method	=> 'remove', 
 804 | 		type	=> 'del'
 805 | 	}, 
 806 | 	{
 807 | 		method	=> 'removeChild', 
 808 | 		type	=> 'del', 
 809 | 		parent	=> 1
 810 | 	}
 811 | ];
 812 | 
 813 | for my $test (@$test_manipulations) {
 814 | 	$test->{custom} = [0] if (!$test->{custom});
 815 | 	
 816 | 	for my $custom_arg1 (@{$test->{custom}}) {
 817 | 		$tree = HTML5::DOM->new->parse('
 818 | 			<div id="test"><b><!-- super cool new comment --> ololo ??? <div class="red">&nbsp;&gt;&lt;&quot;</div></b></div>
 819 | 			<ul>
 820 | 			   <li>UNIX</li>
 821 | 			   <li>Linux</li>
 822 | 			   <!-- comment -->
 823 | 			   <li>OSX</li>
 824 | 			   <li>Windows</li>
 825 | 			   <li>FreeBSD</li>
 826 | 		   </ul>
 827 | 		');
 828 | 		
 829 | 		my $arg = $test->{arg};
 830 | 		
 831 | 		$arg = $arg->($tree) if (ref($test->{arg}) eq 'CODE');
 832 | 		
 833 | 		my $method = $test->{method};
 834 | 		my $method2 = $test->{method2};
 835 | 		
 836 | 		if ($test->{type} eq 'add') {
 837 | 			my $test_el = $tree->at('#test');
 838 | 			my $result = $test_el->$method($arg);
 839 | 			my $old_parent = $test_el->parent;
 840 | 			
 841 | 			if ($test->{return} eq 'self') {
 842 | 				ok($result == $test_el, "$method: check return (self)");
 843 | 			} elsif ($test->{return} eq 'added') {
 844 | 				ok($result == $arg, "$method: check return (added)");
 845 | 			}
 846 | 			
 847 | 			ok($test_el->$method2 == $arg, "$method: check position");
 848 | 			ok($test_el == $arg->parent, "$method: check parent for new");
 849 | 			ok($old_parent == $test_el->parent, "$method: check parent for old");
 850 | 		} elsif ($test->{type} eq 'replace') {
 851 | 			my $test_el = $tree->at('#test');
 852 | 			my $result;
 853 | 			my $old_parent = $test_el->parent();
 854 | 			
 855 | 			my $test_el_index = 0;
 856 | 			for my $child (@{$old_parent->children}) {
 857 | 				last if ($child == $test_el);
 858 | 				++$test_el_index;
 859 | 			}
 860 | 			
 861 | 			if ($test->{parent}) {
 862 | 				$result = $old_parent->$method($arg, $test_el);
 863 | 			} else {
 864 | 				$result = $test_el->$method($arg);
 865 | 			}
 866 | 			
 867 | 			if ($test->{return} eq 'self') {
 868 | 				ok($result == $test_el, "$method: check return (self)");
 869 | 			} elsif ($test->{return} eq 'added') {
 870 | 				ok($result == $arg, "$method: check return (added)");
 871 | 			}
 872 | 			
 873 | 			ok($old_parent->children->item($test_el_index) == $arg, "$method: check position");
 874 | 			ok($old_parent == $arg->parent, "$method: check parent for new");
 875 | 			ok($test_el->isConnected == 0, "$method: check parent for old");
 876 | 		} elsif ($test->{type} eq 'add2') {
 877 | 			my $test_el = $tree->find('ul li')->[$custom_arg1];
 878 | 			my $result;
 879 | 			my $old_parent = $test_el->parent();
 880 | 			
 881 | 			my $test_el_index = 0;
 882 | 			for my $child (@{$old_parent->children}) {
 883 | 				last if ($child == $test_el);
 884 | 				++$test_el_index;
 885 | 			}
 886 | 			
 887 | 			if ($test->{parent}) {
 888 | 				$result = $old_parent->$method($arg, $test_el);
 889 | 			} else {
 890 | 				$result = $test_el->$method($arg);
 891 | 			}
 892 | 			
 893 | 			if ($test->{return} eq 'self') {
 894 | 				ok($result == $test_el, "$method: check return (self) [ref=$custom_arg1]");
 895 | 			} elsif ($test->{return} eq 'added') {
 896 | 				ok($result == $arg, "$method: check return (added) [ref=$custom_arg1]");
 897 | 			}
 898 | 			
 899 | 			my $check_offset = $test->{offset} < 0 ? $test_el_index : $test_el_index + $test->{offset};
 900 | 			ok($old_parent->children->item($check_offset) == $arg, "$method: check position [ref=$custom_arg1]");
 901 | 			ok($old_parent == $arg->parent, "$method: check parent for new [ref=$custom_arg1]");
 902 | 			ok($old_parent == $test_el->parent, "$method: check parent for old [ref=$custom_arg1]");
 903 | 		} elsif ($test->{type} eq 'del') {
 904 | 			my $test_el = $tree->at('#test');
 905 | 			my $result;
 906 | 			my $old_parent = $test_el->parent();
 907 | 			
 908 | 			my $test_el_index = 0;
 909 | 			for my $child (@{$old_parent->children}) {
 910 | 				last if ($child == $test_el);
 911 | 				++$test_el_index;
 912 | 			}
 913 | 			
 914 | 			if ($test->{parent}) {
 915 | 				$result = $old_parent->$method($test_el);
 916 | 			} else {
 917 | 				$result = $test_el->$method($test_el);
 918 | 			}
 919 | 			
 920 | 			ok($result == $test_el, "$method: check return (self)");
 921 | 			ok($test_el->isConnected == 0, "$method: check isConnected");
 922 | 			ok($old_parent->children->[$test_el_index] != $test_el, "$method: check parent children");
 923 | 		}
 924 | 	}
 925 | }
 926 | 
 927 | # DOM node insertion manipulations with fragment
 928 | my $test_manipulations_with_fragment = [
 929 | 	{
 930 | 		method       => 'append',
 931 | 		on_parent    => 1,
 932 | 		return       => 'self',
 933 | 		check_offset => 5,
 934 | 	},
 935 | 	{
 936 | 		method       => 'appendChild',
 937 | 		on_parent    => 1,
 938 | 		return       => 'added',
 939 | 		check_offset => 5,
 940 | 	},
 941 | 	{
 942 | 		method       => 'prepend',
 943 | 		on_parent    => 1,
 944 | 		return       => 'self',
 945 | 		check_offset => 0,
 946 | 	},
 947 | 	{
 948 | 		method       => 'prependChild',
 949 | 		on_parent    => 1,
 950 | 		return       => 'added',
 951 | 		check_offset => 0,
 952 | 	},
 953 | 	{
 954 | 		method       => 'replace',
 955 | 		return       => 'self',
 956 | 		check_offset => 2,
 957 | 		replace      => 1,
 958 | 	},
 959 | 	{
 960 | 		method       => 'replaceChild',
 961 | 		on_parent    => 1,
 962 | 		with_child   => 1,
 963 | 		return       => 'removed',
 964 | 		check_offset => 2,
 965 | 		replace      => 1,
 966 | 	},
 967 | 	{
 968 | 		method       => 'before',
 969 | 		return       => 'self',
 970 | 		check_offset => 2,
 971 | 	},
 972 | 	{
 973 | 		method       => 'insertBefore',
 974 | 		on_parent    => 1,
 975 | 		with_child   => 1,
 976 | 		return       => 'added',
 977 | 		check_offset => 2,
 978 | 	},
 979 | 	{
 980 | 		method       => 'after',
 981 | 		return       => 'self',
 982 | 		check_offset => 3,
 983 | 	},
 984 | 	{
 985 | 		method       => 'insertAfter',
 986 | 		on_parent    => 1,
 987 | 		with_child   => 1,
 988 | 		return       => 'added',
 989 | 		check_offset => 3,
 990 | 	},
 991 | ];
 992 | 
 993 | for my $test (@$test_manipulations_with_fragment) {
 994 | 	my $tree = HTML5::DOM->new->parse('
 995 | 		<ul>
 996 | 			<li>UNIX</li>
 997 | 			<li>Linux</li>
 998 | 			<li id="child">OSX</li>
 999 | 			<li>Windows</li>
1000 | 			<li>FreeBSD</li>
1001 | 		</ul>
1002 | 	');
1003 | 
1004 | 	my $arg = $tree->parseFragment('
1005 | 		<li>NetBSD</li>
1006 | 		<li>OpenBSD</li>
1007 | 	', 'ul');
1008 | 	my $arg_child1 = $arg->firstElementChild;
1009 | 	my $arg_child2 = $arg->lastElementChild;
1010 | 
1011 | 	my $method = $test->{method};
1012 | 	my $child = $tree->at('#child');
1013 | 	my $parent = $child->parent;
1014 | 	my $test_el = $test->{on_parent} ? $parent : $child;
1015 | 
1016 | 	my $result;
1017 | 	if ($test->{with_child}) {
1018 | 		$result = $test_el->$method($arg, $child);
1019 | 	} else {
1020 | 		$result = $test_el->$method($arg);
1021 | 	}
1022 | 
1023 | 	if ($test->{return} eq 'self') {
1024 | 		ok($result == $test_el, "$method with fragment: check return (self)");
1025 | 	} elsif ($test->{return} eq 'added') {
1026 | 		ok($result == $arg, "$method with fragment: check return (added)");
1027 | 	} elsif ($test->{return} eq 'removed') {
1028 | 		ok($result == $child, "$method with fragment: check return (removed)");
1029 | 	}
1030 | 
1031 | 	my $check_offset1 = $test->{check_offset};
1032 | 	my $check_offset2 = $check_offset1 + 1;
1033 | 	my $child_count = $test->{replace} ? 6 : 7;
1034 | 	my $children = $parent->children;
1035 | 	ok($children->item($check_offset1) == $arg_child1, "$method with fragment: check position 1");
1036 | 	ok($children->item($check_offset2) == $arg_child2, "$method with fragment: check position 2");
1037 | 	ok($children->length == $child_count, "$method with fragment: check child count");
1038 | 
1039 | 	ok($arg->childNodes->length == 0, "$method with fragment: check child count of arg");
1040 | }
1041 | 
1042 | #####################################
1043 | # HTML5::DOM::DocType
1044 | #####################################
1045 | my $doctype_lists = [
1046 | 	{
1047 | 		'in'		=> '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
1048 | 		'out'		=> '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">', 
1049 | 		'name'		=> 'html', 
1050 | 		'systemId'	=> 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd',
1051 | 		'publicId'	=> '-//W3C//DTD XHTML 1.0 Strict//EN',
1052 | 	}, {
1053 | 		'in'		=> '<!DOCTYPE html>',
1054 | 		'out'		=> '<!DOCTYPE html>', 
1055 | 		'name'		=> 'html',
1056 | 		'systemId'	=> '',
1057 | 		'publicId'	=> '',
1058 | 	}, {
1059 | 		'in'		=> '<!DOCTYPE html PUBLIC>',
1060 | 		'out'		=> '<!DOCTYPE html>',
1061 | 		'name'		=> 'html',
1062 | 		'publicId'	=> '',
1063 | 		'systemId'	=> '',
1064 | 	}, {
1065 | 		'in'		=> '<!DOCTYPE html SYSTEM>',
1066 | 		'out'		=> '<!DOCTYPE html>', 
1067 | 		'name'		=> 'html',
1068 | 		'publicId'	=> '',
1069 | 		'systemId'	=> ''
1070 | 	}, {
1071 | 		'in'		=> '<!DOCTYPE html allala>',
1072 | 		'out'		=> '<!DOCTYPE html>',
1073 | 		'name'		=> 'html',
1074 | 		'publicId'	=> '',
1075 | 		'systemId'	=> ''
1076 | 	}, {
1077 | 		'out'		=> '<!DOCTYPE html>',
1078 | 		'in'		=> '<!DOCTYPE html "allala">',
1079 | 		'name'		=> 'html',
1080 | 		'publicId'	=> '',
1081 | 		'systemId'	=> ''
1082 | 	}, {
1083 | 		'in'		=> '<!doctype HTML system "about:legacy-compat">',
1084 | 		'out'		=> '<!DOCTYPE html SYSTEM "about:legacy-compat">',
1085 | 		'name'		=> 'html', 
1086 | 		'publicId'	=> '',
1087 | 		'systemId'	=> 'about:legacy-compat'
1088 | 	}, {
1089 | 		'in'		=> '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN">',
1090 | 		'out'		=> '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN">',
1091 | 		'name'		=> 'html',
1092 | 		'publicId'	=> '-//W3C//DTD HTML 4.0//EN',
1093 | 		'systemId'	=> ''
1094 | 	}, {
1095 | 		'in'		=> '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">',
1096 | 		'out'		=> '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">',
1097 | 		'name'		=> 'html',
1098 | 		'publicId'	=> '-//W3C//DTD HTML 4.0//EN',
1099 | 		'systemId'	=> 'http://www.w3.org/TR/REC-html40/strict.dtd'
1100 | 	}, {
1101 | 		'in'		=> '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">',
1102 | 		'out'		=> '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">',
1103 | 		'name'		=> 'html',
1104 | 		'publicId'	=> '-//W3C//DTD HTML 4.01//EN',
1105 | 		'systemId'	=> ''
1106 | 	}, {
1107 | 		'in'		=> '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">',
1108 | 		'out'		=> '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">',
1109 | 		'name'		=> 'html',
1110 | 		'publicId'	=> '-//W3C//DTD HTML 4.01//EN',
1111 | 		'systemId'	=> 'http://www.w3.org/TR/html4/strict.dtd'
1112 | 	}, {
1113 | 		'in'		=> '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
1114 | 		'out'		=> '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
1115 | 		'name'		=> 'html',
1116 | 		'publicId'	=> '-//W3C//DTD XHTML 1.0 Strict//EN',
1117 | 		'systemId'	=> 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'
1118 | 	}, {
1119 | 		'in'		=> '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">',
1120 | 		'out'		=> '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">',
1121 | 		'name'		=> 'html',
1122 | 		'publicId'	=> '-//W3C//DTD XHTML 1.1//EN',
1123 | 		'systemId'	=> 'http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd'
1124 | 	}, {
1125 | 		'in'		=> '<!DOCTYPE html SYSTEM "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">',
1126 | 		'out'		=> '<!DOCTYPE html SYSTEM "-//W3C//DTD XHTML 1.1//EN">',
1127 | 		'name'		=> 'html',
1128 | 		'publicId'	=> '',
1129 | 		'systemId'	=> '-//W3C//DTD XHTML 1.1//EN',
1130 | 	}, {
1131 | 		'in'		=> '<!DOCTYPE OlOlLo>',
1132 | 		'out'		=> '<!DOCTYPE olollo>',
1133 | 		'name'		=> 'olollo',
1134 | 		'publicId'	=> '',
1135 | 		'systemId'	=> '',
1136 | 	}, {
1137 | 		'in'		=> '<!DOCTYPE html PUBLIC "" "xxx">',
1138 | 		'out'		=> '<!DOCTYPE html SYSTEM "xxx">',
1139 | 		'name'		=> 'html',
1140 | 		'publicId'	=> '',
1141 | 		'systemId'	=> 'xxx',
1142 | 	}, {
1143 | 		'in'		=> '<!DOCTYPE svg:svg PUBLIC "-//W3C//DTD XHTML 1.1 plus MathML 2.0 plus SVG 1.1//EN" "http://www.w3.org/2002/04/xhtml-math-svg/xhtml-math-svg.dtd">',
1144 | 		'out'		=> '<!DOCTYPE svg:svg PUBLIC "-//W3C//DTD XHTML 1.1 plus MathML 2.0 plus SVG 1.1//EN" "http://www.w3.org/2002/04/xhtml-math-svg/xhtml-math-svg.dtd">',
1145 | 		'name'		=> 'svg:svg',
1146 | 		'publicId'	=> '-//W3C//DTD XHTML 1.1 plus MathML 2.0 plus SVG 1.1//EN',
1147 | 		'systemId'	=> 'http://www.w3.org/2002/04/xhtml-math-svg/xhtml-math-svg.dtd'
1148 | 	}
1149 | ];
1150 | 
1151 | # basic doctype tests
1152 | for my $dt (@$doctype_lists) {
1153 | 	my $tree = HTML5::DOM->new->parse($dt->{in});
1154 | 	
1155 | 	if ($dt == $doctype_lists->[0]) {
1156 | 		isa_ok($tree->document->firstChild, 'HTML5::DOM::DocType', 'check doctype isa');
1157 | 		can_ok($tree->document->firstChild, @node_methods);
1158 | 		can_ok($tree->document->firstChild, qw|name publicId systemId|);
1159 | 	}
1160 | 	
1161 | 	# check serialization
1162 | 	# ok($tree->document->firstChild->html eq $dt->{out}, 'check doctype serialization');
1163 | 	
1164 | 	# check name
1165 | 	ok($tree->document->firstChild->name eq $dt->{name}, 'check doctype name');
1166 | 	
1167 | 	# check systemId
1168 | 	ok($tree->document->firstChild->publicId eq $dt->{publicId}, 'check doctype publicId');
1169 | 	
1170 | 	# check publicId
1171 | 	ok($tree->document->firstChild->systemId eq $dt->{systemId}, 'check doctype systemId');
1172 | }
1173 | 
1174 | # test change value
1175 | my $doctype_test_change = [
1176 | 	{
1177 | 		method		=> 'name', 
1178 | 		value		=> 'svg'
1179 | 	}, 
1180 | 	{
1181 | 		method		=> 'publicId', 
1182 | 		value		=> '-//W3C//DTD XHTML 1.1 plus MathML 2.0 plus SVG 1.1//EN'
1183 | 	}, 
1184 | 	{
1185 | 		method		=> 'systemId', 
1186 | 		value		=> 'http://www.w3.org/2002/04/xhtml-math-svg/xhtml-math-svg.dtd'
1187 | 	}
1188 | ];
1189 | for my $test (@$doctype_test_change) {
1190 | 	my @doctypes = (
1191 | 		'<!DOCTYPE>', 
1192 | 		'<!DOCTYPE html>', 
1193 | 		'<!DOCTYPE html SYSTEM "blabla">', 
1194 | 		'<!DOCTYPE html PUBLIC "blabla">', 
1195 | 		'<!DOCTYPE html PUBLIC "blabla" "blabla222">'
1196 | 	);
1197 | 	
1198 | 	my $method = $test->{method};
1199 | 	for my $dt (@doctypes) {
1200 | 		my $tree = HTML5::DOM->new->parse($dt);
1201 | 		
1202 | 		my @check;
1203 | 		for my $method2 (qw|name publicId systemId|) {
1204 | 			if ($method2 ne $method) {
1205 | 				push @check, {
1206 | 					method	=> $method2, 
1207 | 					value	=> $tree->document->firstChild->$method2()
1208 | 				};
1209 | 			}
1210 | 		}
1211 | 		
1212 | 		isa_ok($tree->document->firstChild->$method($test->{value}), 'HTML5::DOM::DocType');
1213 | 		ok($tree->document->firstChild->$method() eq $test->{value}, "$method: test new val");
1214 | 		
1215 | 		for my $c (@check) {
1216 | 			my $method2 = $c->{method};
1217 | 			my $value = $tree->document->firstChild->$method2();
1218 | 			
1219 | 			ok($tree->document->firstChild->$method2() eq $c->{value}, "$method: test old val of $method2");
1220 | 		}
1221 | 	}
1222 | }
1223 | 
1224 | #####################################
1225 | # HTML5::DOM::Element
1226 | #####################################
1227 | # classList
1228 | 
1229 | $tree = HTML5::DOM->new->parse('
1230 | 	<div class="red blue">ololo</div>
1231 | ');
1232 | my $cl_test_node = $tree->at('.red');
1233 | isa_ok($cl_test_node->classList, 'HTML5::DOM::TokenList');
1234 | 
1235 | isa_ok($cl_test_node->classList->add('blue', 'right', 'red', 'brown'), 'HTML5::DOM::TokenList');
1236 | ok($cl_test_node->classList->text eq 'red blue right brown', 'class add '.$cl_test_node->classList->text);
1237 | 
1238 | isa_ok($cl_test_node->classList->remove('blue', 'right', 'red'), 'HTML5::DOM::TokenList');
1239 | ok($cl_test_node->classList->text eq 'brown', 'class remove');
1240 | 
1241 | isa_ok($cl_test_node->classList->add('blue', 'right', 'red', 'brown'), 'HTML5::DOM::TokenList');
1242 | isa_ok($cl_test_node->classList->replace('right', 'right2'), 'HTML5::DOM::TokenList');
1243 | 
1244 | ok($cl_test_node->classList->text eq 'brown blue right2 red', 'class replace');
1245 | 
1246 | ok($cl_test_node->classList->length == 4, 'class length');
1247 | 
1248 | isa_ok($cl_test_node->classList->each(sub {
1249 | 	my ($class, $index) = @_;
1250 | 	ok($class eq $cl_test_node->classList->[$index], 'classList each ['.$index.']');
1251 | }), 'HTML5::DOM::TokenList');
1252 | 
1253 | isa_ok($cl_test_node->classList->remove('blue', 'right2', 'red', 'brown'), 'HTML5::DOM::TokenList');
1254 | 
1255 | ok($cl_test_node->classList->length == 0, 'class length after remove');
1256 | 
1257 | $tree = HTML5::DOM->new->parse('
1258 | 	<ul>
1259 | 	   <li>UNIX</li>
1260 | 	   <li>Linux</li>
1261 | 	   <!-- comment -->
1262 | 	   <li>OSX</li>
1263 | 	   <li>Windows</li>
1264 | 	   <li>FreeBSD</li>
1265 |    </ul>
1266 | ');
1267 | 
1268 | # children
1269 | my $childrens_tests = [
1270 | 	{
1271 | 		method	=> 'children', 
1272 | 		results	=> [
1273 | 			['HTML5::DOM::Element', qr/^UNIX$/], 
1274 | 			['HTML5::DOM::Element', qr/^Linux$/], 
1275 | 			['HTML5::DOM::Element', qr/^OSX$/], 
1276 | 			['HTML5::DOM::Element', qr/^Windows$/], 
1277 | 			['HTML5::DOM::Element', qr/^FreeBSD$/], 
1278 | 		], 
1279 | 	}, 
1280 | 	{
1281 | 		method	=> 'childrenNode', 
1282 | 		results	=> [
1283 | 			['HTML5::DOM::Text', qr/^\s+$/], 
1284 | 			['HTML5::DOM::Element', qr/^UNIX$/], 
1285 | 			['HTML5::DOM::Text', qr/^\s+$/], 
1286 | 			['HTML5::DOM::Element', qr/^Linux$/], 
1287 | 			['HTML5::DOM::Text', qr/^\s+$/], 
1288 | 			['HTML5::DOM::Comment', qr/^ comment $/], 
1289 | 			['HTML5::DOM::Text', qr/^\s+$/], 
1290 | 			['HTML5::DOM::Element', qr/^OSX$/], 
1291 | 			['HTML5::DOM::Text', qr/^\s+$/], 
1292 | 			['HTML5::DOM::Element', qr/^Windows$/], 
1293 | 			['HTML5::DOM::Text', qr/^\s+$/], 
1294 | 			['HTML5::DOM::Element', qr/^FreeBSD$/], 
1295 | 			['HTML5::DOM::Text', qr/^\s+$/], 
1296 | 		], 
1297 | 	}, 
1298 | 	{
1299 | 		method	=> 'childNodes', 
1300 | 		results	=> [
1301 | 			['HTML5::DOM::Text', qr/^\s+$/], 
1302 | 			['HTML5::DOM::Element', qr/^UNIX$/], 
1303 | 			['HTML5::DOM::Text', qr/^\s+$/], 
1304 | 			['HTML5::DOM::Element', qr/^Linux$/], 
1305 | 			['HTML5::DOM::Text', qr/^\s+$/], 
1306 | 			['HTML5::DOM::Comment', qr/^ comment $/], 
1307 | 			['HTML5::DOM::Text', qr/^\s+$/], 
1308 | 			['HTML5::DOM::Element', qr/^OSX$/], 
1309 | 			['HTML5::DOM::Text', qr/^\s+$/], 
1310 | 			['HTML5::DOM::Element', qr/^Windows$/], 
1311 | 			['HTML5::DOM::Text', qr/^\s+$/], 
1312 | 			['HTML5::DOM::Element', qr/^FreeBSD$/], 
1313 | 			['HTML5::DOM::Text', qr/^\s+$/], 
1314 | 		], 
1315 | 	}
1316 | ];
1317 | 
1318 | for my $test (@$childrens_tests) {
1319 | 	my $method = $test->{method};
1320 | 	
1321 | 	my $collection = $tree->at('ul')->$method;
1322 | 	
1323 | 	ok($collection->length == scalar(@{$test->{results}}), "$method: check length");
1324 | 	
1325 | 	for (my $index = 0; $index < scalar(@{$test->{results}}); ++$index) {
1326 | 		my $child = $test->{results}->[$index];
1327 | 		my $element = $collection->[$index];
1328 | 		ok(ref($element) eq $child->[0], "$method: check result ref");
1329 | 		ok($element->text =~ $child->[1], "$method: check result content");
1330 | 	}
1331 | }
1332 | 
1333 | # finders
1334 | $tree = $parser->parse('
1335 | 	<!DOCTYPE html>
1336 | 	<div id="test0" some-attr="ololo trololo" class="red blue">
1337 | 		<div class="yellow" id="test1"></div>
1338 | 	</div>
1339 | 	<div id="test2" some-attr="ololo" class="blue">
1340 | 		<div class="yellow" id="test3"></div>
1341 | 	</div>
1342 | 	
1343 | 	<span test-attr-eq="test"></span>
1344 | 	<span test-attr-eq="testt"></span>
1345 | 	
1346 | 	<span test-attr-space="wefwef   test   wefewfew"></span>
1347 | 	<span test-attr-space="wefewwef testt wewe"></span>
1348 | 	
1349 | 	<span test-attr-dash="test-fwefwewfe"></span>
1350 | 	<span test-attr-dash="testt-"></span>
1351 | 	
1352 | 	<span test-attr-substr="wefwefweftestfweewfwe"></span>
1353 | 	
1354 | 	<span test-attr-prefix="testewfwefewwf"></span>
1355 | 	
1356 | 	<span test-attr-suffix="ewfwefwefweftest"></span>
1357 | ');
1358 | 
1359 | # querySelector + at
1360 | for my $method (qw|at querySelector|) {
1361 | 	isa_ok($tree->body->$method('div'), 'HTML5::DOM::Element');
1362 | 	ok($tree->body->$method('div')->attr("id") eq 'test0', "$method: find div");
1363 | 	ok(!defined $tree->body->$method('xuj'), "$method: not found");
1364 | }
1365 | 
1366 | # findId + getElementById
1367 | for my $method (qw|findId getElementById|) {
1368 | 	isa_ok($tree->body->$method('test2'), 'HTML5::DOM::Element');
1369 | 	ok($tree->body->$method('test2')->attr("id") eq 'test2', "$method: find #test2");
1370 | 	ok(!defined $tree->body->$method('xuj'), "$method: not found");
1371 | }
1372 | 
1373 | # find + querySelectorAll
1374 | for my $method (qw|find querySelectorAll|) {
1375 | 	isa_ok($tree->body->$method('.blue'), 'HTML5::DOM::Collection');
1376 | 	isa_ok($tree->body->$method('.ewfwefwefwefwef'), 'HTML5::DOM::Collection');
1377 | 	ok($tree->body->$method('.blue')->length == 2, "$method: find .blue");
1378 | 	ok($tree->body->$method('.bluE')->length == 0, "$method: find .bluE");
1379 | 	ok($tree->body->$method('.ewfwefwefwefwef')->length == 0, "$method: not found");
1380 | 	ok($tree->body->$method('.blue')->item(1)->attr("id") eq "test2", "$method: check result element");
1381 | }
1382 | 
1383 | # findTag + getElementsByTagName
1384 | for my $method (qw|findTag getElementsByTagName|) {
1385 | 	isa_ok($tree->body->$method('div'), 'HTML5::DOM::Collection');
1386 | 	isa_ok($tree->body->$method('ewfwefwefwefwef'), 'HTML5::DOM::Collection');
1387 | 	ok($tree->body->$method('div')->length == 4, "$method: find div");
1388 | 	ok($tree->body->$method('dIv')->length == 4, "$method: find dIv");
1389 | 	ok($tree->body->$method('ewfwefwefwefwef')->length == 0, "$method: not found");
1390 | 	ok($tree->body->$method('div')->item(0)->attr("id") eq "test0", "$method: check result element");
1391 | }
1392 | 
1393 | # findClass + getElementsByClassName
1394 | for my $method (qw|findClass getElementsByClassName|) {
1395 | 	isa_ok($tree->body->$method('blue'), 'HTML5::DOM::Collection');
1396 | 	isa_ok($tree->body->$method('ewfwefwefwefwef'), 'HTML5::DOM::Collection');
1397 | 	ok($tree->body->$method('blue')->length == 2, "$method: find .blue");
1398 | 	ok($tree->body->$method('red')->length == 1, "$method: find .red");
1399 | 	ok($tree->body->$method('bluE')->length == 0, "$method: find .bluE");
1400 | 	ok($tree->body->$method('ewfwefwefwefwef')->length == 0, "$method: not found");
1401 | 	ok($tree->body->$method('yellow')->item(0)->attr("id") eq "test1", "$method: check result element");
1402 | }
1403 | 
1404 | # findAttr + getElementByAttribute
1405 | for my $method (qw|findAttr getElementByAttribute|) {
1406 | 	for my $cmp (qw(= ~ | * ^ $)) {
1407 | 		for my $i ((0, 1)) {
1408 | 			my $attrs = {
1409 | 				'='	=> 'test-attr-eq', 
1410 | 				'~'	=> 'test-attr-space', 
1411 | 				'|'	=> 'test-attr-dash', 
1412 | 				'*'	=> 'test-attr-substr', 
1413 | 				'^'	=> 'test-attr-prefix', 
1414 | 				'$'	=> 'test-attr-suffix', 
1415 | 			};
1416 | 			
1417 | 			my $values = [['test', 'tesT'], ['tEsT', 'test2']];
1418 | 			
1419 | 			# test found
1420 | 			my $collection = $tree->body->$method($attrs->{$cmp}, $values->[$i]->[0], $i, $cmp);
1421 | 			isa_ok($collection, 'HTML5::DOM::Collection');
1422 | 			ok($collection->length == 1, "$method(".$attrs->{$cmp}.", $cmp, $i): found ".$collection->length);
1423 | 			
1424 | 			# test not found
1425 | 			$collection = $tree->body->$method($attrs->{$cmp}, $values->[$i]->[1], $i, $cmp);
1426 | 			isa_ok($collection, 'HTML5::DOM::Collection');
1427 | 			ok($collection->length == 0, "$method(".$attrs->{$cmp}.", $cmp, $i): not found ".$collection->length);
1428 | 		}
1429 | 	}
1430 | }
1431 | 
1432 | # getDefaultBoxType
1433 | my $test_box_type = [
1434 | 	{
1435 | 		element	=> $tree->createElement('script'), 
1436 | 		type	=> 'none'
1437 | 	}, 
1438 | 	{
1439 | 		element	=> $tree->createElement('span'), 
1440 | 		type	=> 'inline'
1441 | 	}, 
1442 | 	{
1443 | 		element	=> $tree->createElement('div'), 
1444 | 		type	=> 'block'
1445 | 	}, 
1446 | 	{
1447 | 		element	=> $tree->createElement('table'), 
1448 | 		type	=> 'table'
1449 | 	}, 
1450 | 	{
1451 | 		element	=> $tree->createElement('wefewfwefewwefew'), 
1452 | 		type	=> 'inline'
1453 | 	},
1454 | ];
1455 | 
1456 | for my $test (@$test_box_type) {
1457 | 	ok($test->{element}->getDefaultBoxType eq $test->{type}, "getDefaultBoxType: ".$test->{type});
1458 | }
1459 | 
1460 | # get attr
1461 | $tree = $parser->parse('
1462 | 	<div id="test" test data-test="'."\n".' 123409 >^_^< '."\n".'" test-empty="" test-one="1">
1463 | 		
1464 | 	</div>
1465 | ');
1466 | for my $method (qw|{} attr getAttribute attrArray|) {
1467 | 	my $test = $tree->at('#test');
1468 | 	
1469 | 	my $method2 = $method eq 'attrArray' ? 'attr' : $method;
1470 | 	
1471 | 	if ($method2 eq '{}') {
1472 | 		ok(!defined $test->{"iwefwefwefewfwe"}, "$method2 (undef)");
1473 | 		ok(!exists $test->{"iwefwefwefewfwe"}, "$method2 (exists)");
1474 | 	} else {
1475 | 		ok(!defined $test->$method2("iwefwefwefewfwe"), "$method2 (undef)");
1476 | 	}
1477 | 	
1478 | 	my $attrs_test = [
1479 | 		['id', 'test'], 
1480 | 		['test', ''], 
1481 | 		['data-test', "\n 123409 >^_^< \n"], 
1482 | 		['test-empty', ''], 
1483 | 		['test-one', '1'], 
1484 | 	];
1485 | 	
1486 | 	for my $attr (@$attrs_test) {
1487 | 		if ($method2 eq '{}') {
1488 | 			ok($test->{$attr->[0]} eq $attr->[1], "->{".$attr->[0]."}");
1489 | 		} else {
1490 | 			ok($test->$method2($attr->[0]) eq $attr->[1], "$method2(".$attr->[0].")");
1491 | 		}
1492 | 	}
1493 | 	
1494 | 	# bulk test attr
1495 | 	if ($method eq 'attr') {
1496 | 		my $hash = $test->attr;
1497 | 		ok(scalar(keys(%$hash)) == scalar(@$attrs_test), 'attr bulk: result length');
1498 | 		
1499 | 		for my $attr (@$attrs_test) {
1500 | 			ok($hash->{$attr->[0]} eq $attr->[1], 'attr bulk: test '.$attr->[0]);
1501 | 		}
1502 | 	}
1503 | 	
1504 | 	# bulk test attrArray
1505 | 	if ($method eq 'attrArray') {
1506 | 		my $i = 0;
1507 | 		
1508 | 		for my $attr (@{$test->$method()}) {
1509 | 			ok($attrs_test->[$i]->[0] eq $attr->{name}, 'attrArray bulk: test key '.$attr->{name}." eq ".$attrs_test->[$i]->[0]);
1510 | 			ok($attrs_test->[$i]->[1] eq $attr->{value}, 'attrArray bulk: test val '.$attr->{name});
1511 | 			++$i;
1512 | 		}
1513 | 	}
1514 | }
1515 | 
1516 | # remove attr
1517 | for my $method (qw|attr removeAttribute setAttribute removeAttr|) {
1518 | 	$tree = $parser->parse('
1519 | 		<div id="test" test data-test="'."\n".' 123409 >^_^< '."\n".'" test-empty="" test-one="1">
1520 | 			
1521 | 		</div>
1522 | 	');
1523 | 	
1524 | 	my $test = $tree->at('#test');
1525 | 	for my $attr (qw|id test-one test-empty data-test|) {
1526 | 		my $result;
1527 | 		if ($method eq 'attr' || $method eq 'setAttribute') {
1528 | 			ok($test == $test->$method($attr, undef), "$method($attr, undef): return ref");
1529 | 		} else {
1530 | 			ok($test == $test->$method($attr), "$method($attr, undef): return ref");
1531 | 		}
1532 | 		ok(!defined $test->attr($attr), "$method($attr): confirm delete");
1533 | 	}
1534 | }
1535 | 
1536 | # get attr
1537 | for my $method (qw|attr setAttribute|) {
1538 | 	$tree = $parser->parse('<div></div>');
1539 | 	my $test = $tree->at('div');
1540 | 	
1541 | 	my $attrs_test = [
1542 | 		['test', ''], 
1543 | 		['id', 'test'], 
1544 | 		['test-one', '1'], 
1545 | 		['test-empty', ''], 
1546 | 		['data-test', "\n 123409 >^_^< \n"]
1547 | 	];
1548 | 	
1549 | 	for my $attr (@$attrs_test) {
1550 | 		ok($test->$method($attr->[0], $attr->[1]) == $test, "set $method(".$attr->[0].")");
1551 | 		ok($test->attr($attr->[0]) eq $attr->[1], "get $method(".$attr->[0].")");
1552 | 	}
1553 | }
1554 | 
1555 | # bulk attr set/unset
1556 | $tree = $parser->parse('
1557 | 	<div id="test" test data-test="'."\n".' 123409 >^_^< '."\n".'" test-empty="" test-one="1">
1558 | 		
1559 | 	</div>
1560 | ');
1561 | 
1562 | my $test_bulk_attr_set = {
1563 | 	'id'			=> undef, 
1564 | 	'test'			=> undef, 
1565 | 	'data-test'		=> undef, 
1566 | 	'test-empty'	=> undef, 
1567 | 	'abcd'			=> '123', 
1568 | 	'abc323d'		=> " 123 >^_^< \n\n\n", 
1569 | 	'qqq'			=> 1
1570 | };
1571 | 
1572 | my $test_attr_el = $tree->at('#test');
1573 | ok($test_attr_el->attr($test_bulk_attr_set) == $test_attr_el, 'bulk attr set: ref');
1574 | for my $attr (keys %$test_bulk_attr_set) {
1575 | 	my $val = $test_bulk_attr_set->{$attr};
1576 | 	if (defined $val) {
1577 | 		ok($test_attr_el->attr($attr) eq $val, 'bulk attr set: check '.$attr);
1578 | 	} else {
1579 | 		ok(!defined $test_attr_el->attr($attr), 'bulk attr set: check '.$attr.' (undef)');
1580 | 	}
1581 | }
1582 | 
1583 | #####################################
1584 | # HTML5::DOM::Collection
1585 | #####################################
1586 | $tree = HTML5::DOM->new->parse('
1587 | 	<ul>
1588 | 	   <li>UNIX</li>
1589 | 	   <li>Linux</li>
1590 | 	   <!-- comment -->
1591 | 	   <li>OSX</li>
1592 | 	   <li>Windows</li>
1593 | 	   <li>FreeBSD</li>
1594 |    </ul>
1595 | ');
1596 | my $collection = $tree->find('li');
1597 | ok($collection->length == 5, 'colection: length');
1598 | ok(scalar(@{$collection}) == 5, 'colection: scalar length');
1599 | ok(scalar(@{$collection->array}) == 5, 'colection->array: length');
1600 | ok($collection->item(1) == $collection->[1], 'colection->item check');
1601 | ok($collection->html eq "<li>UNIX</li><li>Linux</li><li>OSX</li><li>Windows</li><li>FreeBSD</li>", 'colection->html check');
1602 | ok($collection->text eq "UNIXLinuxOSXWindowsFreeBSD", 'colection->text check');
1603 | ok($collection->reverse->text eq "FreeBSDWindowsOSXLinuxUNIX", 'colection reverse check');
1604 | ok(length($collection->shuffle->text) == 26, 'colection shuffle check');
1605 | 
1606 | ok(join('', @{$collection->grep(qr/X/i)->map('text')}) eq 'UNIXLinuxOSX', 'colection grep regexp');
1607 | ok(join('', @{$collection->grep(sub { $_->text =~ $_[1] }, qr/X/i)->map('text')}) eq 'UNIXLinuxOSX', 'colection grep callback');
1608 | 
1609 | ok($collection->head(2)->text eq 'UNIXLinux', 'colection head');
1610 | ok($collection->head(-2)->text eq 'UNIXLinuxOSX', 'colection head negative');
1611 | ok($collection->head(343344334)->text eq 'UNIXLinuxOSXWindowsFreeBSD', 'colection head large offset');
1612 | ok($collection->head(-343344334)->text eq '', 'colection head invalid 2');
1613 | 
1614 | ok($collection->tail(2)->text eq 'WindowsFreeBSD', 'colection tail');
1615 | ok($collection->tail(-2)->text eq 'OSXWindowsFreeBSD', 'colection tail negative');
1616 | ok($collection->tail(343344334)->text eq '', 'colection tail invalid');
1617 | ok($collection->tail(-343344334)->text eq '', 'colection tail invalid 2');
1618 | 
1619 | ok($collection->slice(1)->text eq 'LinuxOSXWindowsFreeBSD', 'colection slice(1)');
1620 | ok($collection->slice(1, 2)->text eq 'LinuxOSX', 'colection slice(1, 2)');
1621 | ok($collection->slice(-2)->text eq 'WindowsFreeBSD', 'colection slice(-2)');
1622 | ok($collection->slice(-2, 1)->text eq 'Windows', 'colection slice(-2, 1)');
1623 | ok($collection->slice(-3, -1)->text eq 'OSXWindows', 'colection slice(-3, -1)');
1624 | ok($collection->slice(-33232, -134343443)->text eq '', 'colection slice invalid');
1625 | ok($collection->slice(555534, 34433443)->text eq '', 'colection slice invalid 2');
1626 | ok($collection->slice(-33232, 134343443)->text eq '', 'colection slice invalid 3');
1627 | ok($collection->slice(555534, -34433443)->text eq '', 'colection slice invalid 4');
1628 | 
1629 | my $uniq_map = {
1630 | 	UNIX		=> 1,
1631 | 	OSX			=> 1,
1632 | 	FreeBSD		=> 1,
1633 | 	Windows		=> 2
1634 | };
1635 | 
1636 | ok($collection->uniq()->text eq 'UNIXLinuxOSXWindowsFreeBSD', 'collection uniq');
1637 | ok($collection->uniq(sub { $uniq_map->{$_->text} })->text eq 'UNIXLinuxWindows', 'collection uniq callback');
1638 | 
1639 | ok($collection->first == $collection->[0], 'colection->first check');
1640 | ok($collection->last == $collection->[-1], 'colection->last check');
1641 | ok($collection->first(qr/W/i)->text eq 'Windows', 'colection first like grep regexp');
1642 | ok($collection->first(sub { $_->text =~ $_[1] }, qr/W/i)->text eq 'Windows', 'colection first like grep callback');
1643 | 
1644 | my $check_index = 0;
1645 | $collection->each(sub {
1646 | 	my ($node, $index, $additional) = @_;
1647 | 	ok($additional == 42 && $index == $check_index && $node == $collection->[$check_index], 'collection each ['.$check_index.']');
1648 | 	$check_index++;
1649 | }, 42);
1650 | 
1651 | $check_index = 0;
1652 | my $result = $collection->map(sub {
1653 | 	my ($node, $index, $additional) = @_;
1654 | 	ok($additional == 42 && $index == $check_index && $node == $collection->[$check_index], 'collection map ['.$check_index.']');
1655 | 	$check_index++;
1656 | 	return $node->text;
1657 | }, 42);
1658 | 
1659 | ok(join('', @$result) eq "UNIXLinuxOSXWindowsFreeBSD", 'colection map result join');
1660 | ok(join('', @{$collection->map('text')}) eq "UNIXLinuxOSXWindowsFreeBSD", 'colection map result join 2');
1661 | 
1662 | $collection->map('text', 1);
1663 | ok(join('', @{$collection->map('text')}) eq "11111", 'colection map bulk call');
1664 | 
1665 | ######################################################################################
1666 | # HTML5::DOM::CSS + HTML5::DOM::CSS::Selector + HTML5::DOM::CSS::Selector::Entry
1667 | ######################################################################################
1668 | my $css = HTML5::DOM::CSS->new;
1669 | isa_ok($css, 'HTML5::DOM::CSS');
1670 | can_ok($css, qw|parseSelector new|);
1671 | 
1672 | # parseSelector
1673 | my $selector = $css->parseSelector('div:last-child > span.red[attr=value], div, img:nth-child(2n+1), table ~ tr, div + div');
1674 | isa_ok($selector, 'HTML5::DOM::CSS::Selector');
1675 | can_ok($selector, qw|text new ast length entry|);
1676 | 
1677 | my $entry = $selector->entry(0);
1678 | isa_ok($entry, 'HTML5::DOM::CSS::Selector::Entry');
1679 | can_ok($entry, qw|text ast specificity specificityArray|);
1680 | 
1681 | # length
1682 | ok($selector->length == 5, 'css selector length');
1683 | 
1684 | # entry
1685 | ok(!defined $selector->entry(-1), 'css selector entry undef');
1686 | ok(!defined $selector->entry(5), 'css selector entry undef');
1687 | 
1688 | # text
1689 | ok($selector->text eq 'div:last-child > span.red[attr = value], div, img:nth-child(2n+1), table ~ tr, div + div', 'css selector text');
1690 | ok($selector->entry(0)->text eq 'div:last-child > span.red[attr = value]', 'css selector entry 0 text');
1691 | ok($selector->entry(4)->text eq 'div + div', 'css selector entry 5 text');
1692 | 
1693 | # ast
1694 | ok(ref($selector->ast) eq 'ARRAY', 'selector ast');
1695 | ok(ref($selector->entry(0)->ast) eq 'ARRAY', 'selector entry ast');
1696 | 
1697 | # specificity + specificityArray
1698 | my $test_specificity = {
1699 | 	'*'				=> '0,0,0', 
1700 | 	'a'				=> '0,0,1', 
1701 | 	'#id'			=> '1,0,0', 
1702 | 	'.class'		=> '0,1,0', 
1703 | 	'[a=b]'			=> '0,1,0', 
1704 | 	':after'		=> '0,0,1', 
1705 | 	'::after'		=> '0,0,1', 
1706 | 	':first-child'	=> '0,1,0', 
1707 | };
1708 | 
1709 | for my $selector (keys %$test_specificity) {
1710 | 	my $ent = HTML5::DOM::CSS::Selector->new($selector)->entry(0);
1711 | 	
1712 | 	my $spec = join(",", @{$ent->specificityArray});
1713 | 	ok($spec eq $test_specificity->{$selector}, "test specificityArray($selector) $spec eq ".$test_specificity->{$selector});
1714 | 	
1715 | 	$spec = join(",", ($ent->specificity->{a}, $ent->specificity->{b}, $ent->specificity->{c}));
1716 | 	ok($spec eq $test_specificity->{$selector}, "test specificity($selector)");
1717 | }
1718 | 
1719 | # valid
1720 | ok(HTML5::DOM::CSS::Selector->new('')->valid == 0, 'css selector valid=0');
1721 | ok(HTML5::DOM::CSS::Selector->new('(*&*^&**%%*(')->valid == 0, 'css selector valid=0');
1722 | ok(HTML5::DOM::CSS::Selector->new('div[attr]')->valid == 1, 'css selector valid=1');
1723 | 
1724 | # pseudoElement
1725 | ok(HTML5::DOM::CSS::Selector->new('div:after')->entry(0)->pseudoElement eq 'after', 'css selector entry pseudoElement');
1726 | ok(!defined HTML5::DOM::CSS::Selector->new('div')->entry(0)->pseudoElement, 'css selector entry pseudoElement (undef)');
1727 | 
1728 | 
1729 | ######################################################################################
1730 | # HTML5::DOM::Encoding
1731 | ######################################################################################
1732 | 
1733 | # name2id
1734 | ok(HTML5::DOM::Encoding::name2id("UTF-8") == HTML5::DOM::Encoding->UTF_8, 'encoding name2id');
1735 | ok(!defined HTML5::DOM::Encoding::name2id("wefewf"), 'encoding name2id non exists');
1736 | 
1737 | # id2name
1738 | ok(HTML5::DOM::Encoding::id2name(HTML5::DOM::Encoding->UTF_8) eq "UTF-8", 'encoding id2name');
1739 | ok(!defined HTML5::DOM::Encoding::id2name(332322242424), 'encoding name2id non exists');
1740 | 
1741 | # detectBomAndCut
1742 | my ($encoding_id, $new_text) = HTML5::DOM::Encoding::detectBomAndCut("\xEF\xBB\xBFtest214");
1743 | ok($encoding_id == HTML5::DOM::Encoding->UTF_8, 'detectBomAndCut id');
1744 | ok($new_text eq 'test214', 'detectBomAndCut text');
1745 | 
1746 | # detectByCharset
1747 | $encoding_id = HTML5::DOM::Encoding::detectByCharset("text/html; charset=windows-1251");
1748 | ok($encoding_id == HTML5::DOM::Encoding->WINDOWS_1251, 'detectByCharset');
1749 | 
1750 | # detectByPrescanStream
1751 | $encoding_id = HTML5::DOM::Encoding::detectByPrescanStream('<meta http-equiv="content-type" content="text/html; charset=windows-1251">');
1752 | ok($encoding_id == HTML5::DOM::Encoding->WINDOWS_1251, 'detectByPrescanStream');
1753 | 
1754 | my $utf16 = "\x21\x04\x4a\x04\x35\x04\x48\x04\x4c\x04\x20\x00\x35\x04\x49\x04\x51\x04\x20\x00\x4d\x04\x42\x04\x38\x04\x45\x04\x20\x00\x3c\x04\x4f\x04\x33\x04\x3a\x04\x38\x04\x45\x04\x20\x00\x44\x04\x40\x04\x30\x04\x3d\x04\x46\x04\x43\x04\x37\x04\x41\x04\x3a\x04\x38\x04\x45\x04\x20\x00\x31\x04\x43\x04\x3b\x04\x3e\x04\x3a\x04\x2c\x00\x20\x00\x34\x04\x30\x04\x20\x00\x32\x04\x4b\x04\x3f\x04\x35\x04\x39\x04\x20\x00\x36\x04\x35\x04\x20\x00\x47\x04\x30\x04\x4e\x04\x2e\x00";
1755 | my $cp1251 = "\xe5\xed\xe8\x20\xee\xe3\xee\x20\xf1\xf2\xe2\x20\xed\xe8\xff\x20\xee\xe2\xe0\x20\xf2\xe5\xeb\x20\xf0\xe5\xe4\x20\xee\xf1\xf2" x 100;
1756 | 
1757 | # detectUnicode
1758 | $encoding_id = HTML5::DOM::Encoding::detectUnicode($utf16);
1759 | ok($encoding_id == HTML5::DOM::Encoding->UTF_16LE, 'detectUnicode');
1760 | 
1761 | # detect
1762 | $encoding_id = HTML5::DOM::Encoding::detect($utf16);
1763 | ok($encoding_id == HTML5::DOM::Encoding->UTF_16LE, 'detect (pass utf-16)');
1764 | 
1765 | # detectCyrillic
1766 | $encoding_id = HTML5::DOM::Encoding::detectCyrillic($cp1251);
1767 | ok($encoding_id == HTML5::DOM::Encoding->WINDOWS_1251, 'detectCyrillic');
1768 | 
1769 | $encoding_id = HTML5::DOM::Encoding::detectUkrainian($cp1251);
1770 | ok($encoding_id == HTML5::DOM::Encoding->WINDOWS_1251, 'detectUkrainian');
1771 | 
1772 | $encoding_id = HTML5::DOM::Encoding::detectRussian($cp1251);
1773 | ok($encoding_id == HTML5::DOM::Encoding->WINDOWS_1251, 'detectRussian');
1774 | 
1775 | # detect
1776 | $encoding_id = HTML5::DOM::Encoding::detect($cp1251);
1777 | ok($encoding_id == HTML5::DOM::Encoding->WINDOWS_1251, 'detect (pass cp1251)');
1778 | 
1779 | done_testing;
1780 | 
1781 | # </test-body>
1782 | 


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