Bar
| 1 | 2 | 3 |
- >|\n|<
- >|</id=33>>|",
'|<
- >|< å/id=34>>', "|>>ul<<|", "|>>body<<|\n\n|", ) { if ($res !~ /\Q$_\E/) { diag "Can't find '$_' in parsed document"; $bad++; } } diag $res if $bad || $ENV{PRINT_RESULTS}; # And we check that we get the same result all the time $res =~ s/\|//g; # remove all break marks if ($last_res && $res ne $last_res) { diag "The result is not the same as last time"; $bad++; } $last_res = $res; unless ($res =~ /Various entities/) { diag "Some text must be missing"; $bad++; } ok(!$bad); } script.t 100644 001750 001751 2605 15253600633 14521 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict; use warnings; use HTML::Parser (); use Test::More tests => 1; my $TEXT = ""; sub h { my ($event, $tagname, $text) = @_; for ($event, $tagname, $text) { if (defined) { s/([\n\r\t])/sprintf "\\%03o", ord($1)/ge; } else { $_ = "
"; } } $TEXT .= "[$event,$tagname,$text]\n"; } my $p = HTML::Parser->new( default_h => [\&h, "event,tagname,text"], empty_element_tags => 1 ); $p->parse( q( ,] [start,tr, ] [start,td, ] [end_document,] [start,script,] [end,script,] [start,script,] [end,td, ] [end,tr,,] EOT tokenpos.h 100644 001750 001751 2166 15253600633 14602 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86 struct token_pos { char *beg; char *end; }; typedef struct token_pos token_pos_t; #define dTOKENS(init_lim) \ token_pos_t token_buf[init_lim]; \ int token_lim = init_lim; \ token_pos_t *tokens = token_buf; \ int num_tokens = 0 #define PUSH_TOKEN(p_beg, p_end) \ STMT_START { \ ++num_tokens; \ if (num_tokens == token_lim) \ tokens_grow(&tokens, &token_lim, (bool)(tokens != token_buf)); \ tokens[num_tokens-1].beg = p_beg; \ tokens[num_tokens-1].end = p_end; \ } STMT_END #define FREE_TOKENS \ STMT_START { \ if (tokens != token_buf) \ Safefree(tokens); \ } STMT_END static void tokens_grow(token_pos_t **token_ptr, int *token_lim_ptr, bool tokens_on_heap) { int new_lim = *token_lim_ptr; if (new_lim < 4) new_lim = 4; new_lim *= 2; if (tokens_on_heap) { Renew(*token_ptr, new_lim, token_pos_t); } else { token_pos_t *new_tokens; int i; New(57, new_tokens, new_lim, token_pos_t); for (i = 0; i < *token_lim_ptr; i++) new_tokens[i] = (*token_ptr)[i]; *token_ptr = new_tokens; } *token_lim_ptr = new_lim; } hanchors 100755 001750 001751 2254 15253600633 14713 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/eg #!/usr/bin/perl use strict; use warnings; # This program will print out all links in a # document together with the text that goes with it. # # See also HTML::LinkExtor use Encode; use HTML::Parser; my $p = HTML::Parser->new( api_version => 3, start_h => [\&a_start_handler, "self,tagname,attr"], report_tags => [qw(a img)], ); $p->parse_file(shift || die) || die $!; sub a_start_handler { my ($self, $tag, $attr) = @_; return unless $tag eq "a"; return unless exists $attr->{href}; print "A $attr->{href}\n"; $self->handler(text => [], '@{dtext}'); $self->handler(start => \&img_handler); $self->handler(end => \&a_end_handler, "self,tagname"); } sub img_handler { my ($self, $tag, $attr) = @_; return unless $tag eq "img"; push(@{$self->handler("text")}, $attr->{alt} || "[IMG]"); } sub a_end_handler { my ($self, $tag) = @_; my $text = encode('utf8', join("", @{$self->handler("text")})); $text =~ s/^\s+//; $text =~ s/\s+$//; $text =~ s/\s+/ /g; print "T $text\n"; $self->handler("text", undef); $self->handler("start", \&a_start_handler); $self->handler("end", undef); } hdisable 100755 001750 001751 1344 15253600633 14660 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/eg #!/usr/bin/perl use strict; use warnings; use HTML::Parser (); use HTML::Entities qw(encode_entities); sub disable_tags_but { my ($text, $allowed_tags) = @_; my @text; my %allowed_tag = map { $_ => 1 } @{$allowed_tags || []}; my $tag_h = sub { my ($tag, $text) = @_; $text = encode_entities($text, "<") unless $allowed_tag{$tag}; push(@text, $text); }; HTML::Parser->new( start_h => [$tag_h, 'tagname, text'], end_h => [$tag_h, 'tagname, text'], default_h => [\@text, '@{text}'], )->parse($text)->eof; return join("", @text); } # # Test it # print disable_tags_but(< - >|< å/id=34>>', "|>>ul<<|", "|>>body<<|\n\n|", ) { if ($res !~ /\Q$_\E/) { diag "Can't find '$_' in parsed document"; $bad++; } } diag $res if $bad || $ENV{PRINT_RESULTS}; # And we check that we get the same result all the time $res =~ s/\|//g; # remove all break marks if ($last_res && $res ne $last_res) { diag "The result is not the same as last time"; $bad++; } $last_res = $res; unless ($res =~ /Various entities/) { diag "Some text must be missing"; $bad++; } ok(!$bad); } script.t 100644 001750 001751 2605 15253600633 14521 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict; use warnings; use HTML::Parser (); use Test::More tests => 1; my $TEXT = ""; sub h { my ($event, $tagname, $text) = @_; for ($event, $tagname, $text) { if (defined) { s/([\n\r\t])/sprintf "\\%03o", ord($1)/ge; } else { $_ = "
, but possibly between
and
# Example (Reverse 'Debian' in all text) : # lynx -dump -source -raw http://www/debian.org > /tmp/a.txt # ./htextsub '$_ =~ s/Debian/Naibed/gi' /tmp/a.txt use strict; use warnings; use HTML::Parser (); my $code = shift || usage(); $code = 'sub edit_print { local $_ = shift; ' . $code . '; print }'; #print $code; eval $code; die $@ if $@; my $p = HTML::Parser->new( unbroken_text => 1, default_h => [sub { print @_; }, "text"], text_h => [\&edit_print, "text"], ); my $file = shift || usage(); $p->parse_file($file) || die "Can't open file $file: $!\n"; sub usage { my $progname = $0; $progname =~ s,^.*/,,; die "Usage: $prognameSmile ☺
\x{0420}"; is(length($doc), 46); $p->parse($doc)->eof; #use Data::Dump; Data::Dump::dump(@parsed); is(@parsed, 9); is($parsed[0][0], "start_document"); is($parsed[1][0], "start"); is($parsed[1][1], "");
is(join("|", @{$parsed[4][7]}), "1|2|4|2|7|1|9|1|0|0");
is($parsed[4][8]{id}, "\x{2600}");
is($parsed[5][0], "text");
is($parsed[5][1], "Smile ☺");
is($parsed[5][2], "Smile \x{263A}");
is($parsed[7][0], "text");
is($parsed[7][1], "\x{0420}");
is($parsed[7][2], "\x{0420}");
is($parsed[8][0], "end_document");
is($parsed[8][3], length($doc));
is($parsed[8][5], length($doc));
is($parsed[8][6], length($doc));
is(@warn, 0);
# Try to parse it as an UTF8 encoded string
utf8::encode($doc);
is(length($doc), 51);
@parsed = ();
$p->parse($doc)->eof;
#use Data::Dump; Data::Dump::dump(@parsed);
is(@parsed, 9);
is($parsed[0][0], "start_document");
is($parsed[1][0], "start");
is($parsed[1][1], "");
SKIP: {
skip "no utf8::is_utf8", 1 if !defined(&utf8::is_utf8);
ok(!utf8::is_utf8($parsed[1][1]), "!is_utf8");
}
is($parsed[1][3], 0);
is($parsed[1][4], 7);
is($parsed[2][0], "text");
is(ord($parsed[2][1]), 226);
is($parsed[2][1], "\xE2\x98\xBA");
is($parsed[2][2], "\xE2\x98\xBA");
is($parsed[2][3], 7);
is($parsed[2][4], 3);
is($parsed[2][5], 10);
is($parsed[2][6], 7);
is($parsed[3][0], "end");
is($parsed[3][1], " ");
is($parsed[3][3], 10);
is($parsed[3][6], 10);
is($parsed[4][0], "start");
is($parsed[4][1], "");
is(join("|", @{$parsed[4][7]}), "1|2|4|2|7|3|11|1|0|0");
is($parsed[4][8]{id}, "\xE2\x98\x80");
is($parsed[5][0], "text");
is($parsed[5][1], "Smile ☺");
is($parsed[5][2], "Smile \x{263A}");
is($parsed[8][0], "end_document");
is($parsed[8][3], length($doc));
is($parsed[8][5], length($doc));
is($parsed[8][6], length($doc));
is(@warn, 1);
like($warn[0],
qr/^Parsing of undecoded UTF-8 will give garbage when decoding entities/);
my $file = "test-$$.html";
open(my $fh, ">:utf8", $file) || die;
print $fh <\x{263A} Love!
♥ Love \x{2665}
EOT
close($fh) || die;
@warn = ();
@parsed = ();
$p->parse_file($file);
is(@parsed, "11");
is($parsed[6][0], "start");
is($parsed[6][8]{id}, "\x{2665}\xE2\x99\xA5");
is($parsed[7][0], "text");
is($parsed[7][1], "♥ Love \xE2\x99\xA5");
is($parsed[7][2], "\x{2665} Love \xE2\x99\xA5"); # expected garbage
is($parsed[10][3], -s $file);
is(@warn, 1);
like($warn[0],
qr/^Parsing of undecoded UTF-8 will give garbage when decoding entities/);
@warn = ();
@parsed = ();
open($fh, "<:raw:utf8", $file) || die;
$p->parse_file($fh);
is(@parsed, "11");
is($parsed[6][0], "start");
is($parsed[6][8]{id}, "\x{2665}\x{2665}");
is($parsed[7][0], "text");
is($parsed[7][1], "♥ Love \x{2665}");
is($parsed[7][2], "\x{2665} Love \x{2665}");
is($parsed[10][3], (-s $file) - 2 * 4);
is(@warn, 0);
@warn = ();
@parsed = ();
open($fh, "<:raw", $file) || die;
$p->utf8_mode(1);
$p->parse_file($fh);
is(@parsed, "11");
is($parsed[6][0], "start");
is($parsed[6][8]{id}, "\xE2\x99\xA5\xE2\x99\xA5");
is($parsed[7][0], "text");
is($parsed[7][1], "♥ Love \xE2\x99\xA5");
is($parsed[7][2], "\xE2\x99\xA5 Love \xE2\x99\xA5");
is($parsed[10][3], -s $file);
is(@warn, 0);
unlink($file);
@parsed = ();
$p->parse(q(foo))->eof;
is(@parsed, "5");
is($parsed[1][0], "start");
is($parsed[1][8]{href}, "a=1&lang=2\xC3\x97=3");
ok(!HTML::Entities::_probably_utf8_chunk(""));
ok(!HTML::Entities::_probably_utf8_chunk("f"));
ok(HTML::Entities::_probably_utf8_chunk("f\xE2\x99\xA5"));
ok(HTML::Entities::_probably_utf8_chunk("f\xE2\x99\xA5o"));
ok(HTML::Entities::_probably_utf8_chunk("f\xE2\x99\xA5o\xE2"));
ok(HTML::Entities::_probably_utf8_chunk("f\xE2\x99\xA5o\xE2\x99"));
ok(!HTML::Entities::_probably_utf8_chunk("f\xE2"));
ok(!HTML::Entities::_probably_utf8_chunk("f\xE2\x99"));
$p = HTML::Parser->new(
api_version => 3,
default_h => [\@parsed, 'event, text, tag, attr'],
attr_encoded => 1,
);
@warn = ();
@parsed = ();
$p->parse($doc)->eof;
ok(!@warn);
is(@parsed, 9);
@parsed = ();
$p = HTML::Parser->new(
api_version => 3,
utf8_mode => 1,
unbroken_text => 1,
default_h => [\@parsed, 'event,dtext'],
);
$p->parse(
"
R\xC3\xA9ductions jusqu'à -70%.
Réductions jusqu'à -70%."
);
$p->eof;
is($parsed[2][1], "R\xC3\xA9ductions jusqu'\xC3\xA0 -70%.");
is($parsed[4][1], "R\xC3\xA9ductions jusqu'\xC3\xA0 -70%.");
Makefile.PL 100644 001750 001751 3351 15253600633 14536 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86 # This Makefile.PL for HTML-Parser was generated by
# Dist::Zilla::Plugin::MakeMaker::Awesome 0.49.
# Don't edit it but the dist.ini and plugins used to construct it.
use strict;
use warnings;
use ExtUtils::MakeMaker;
my %WriteMakefileArgs = (
"ABSTRACT" => "HTML parser class",
"AUTHOR" => "Gisle Aas ",
"CONFIGURE_REQUIRES" => {
"ExtUtils::MakeMaker" => "6.52"
},
"DISTNAME" => "HTML-Parser",
"LICENSE" => "perl",
"NAME" => "HTML::Parser",
"PREREQ_PM" => {
"Carp" => 0,
"Exporter" => 0,
"HTML::Tagset" => 0,
"HTTP::Headers" => 0,
"IO::File" => 0,
"URI" => 0,
"URI::URL" => 0,
"XSLoader" => 0,
"strict" => 0
},
"TEST_REQUIRES" => {
"Config" => 0,
"ExtUtils::MakeMaker" => 0,
"File::Spec" => 0,
"IO::File" => 0,
"SelectSaver" => 0,
"Test::More" => 0,
"URI" => 0,
"strict" => 0
},
"VERSION" => "3.86",
"test" => {
"TESTS" => "t/*.t"
}
);
%WriteMakefileArgs = (
%WriteMakefileArgs,
DEFINE => "-DMARKED_SECTION",
H => [ qw(hparser.h hctype.h tokenpos.h pfunc.h hparser.c util.c) ],
);
my %FallbackPrereqs = (
"Carp" => 0,
"Config" => 0,
"Exporter" => 0,
"ExtUtils::MakeMaker" => 0,
"File::Spec" => 0,
"HTML::Tagset" => 0,
"HTTP::Headers" => 0,
"IO::File" => 0,
"SelectSaver" => 0,
"Test::More" => 0,
"URI" => 0,
"URI::URL" => 0,
"XSLoader" => 0,
"strict" => 0
);
unless ( eval { ExtUtils::MakeMaker->VERSION('6.63_03') } ) {
delete $WriteMakefileArgs{TEST_REQUIRES};
delete $WriteMakefileArgs{BUILD_REQUIRES};
$WriteMakefileArgs{PREREQ_PM} = \%FallbackPrereqs;
}
delete $WriteMakefileArgs{CONFIGURE_REQUIRES}
unless eval { ExtUtils::MakeMaker->VERSION(6.52) };
WriteMakefile(%WriteMakefileArgs);
argspec2.t 100644 001750 001751 561 15253600633 14702 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 2;
my @start;
my @text;
my $p = HTML::Parser->new(api_version => 3);
$p->handler(start => \@start, '@{tagname, @attr}');
$p->handler(text => \@text, '@{dtext}');
$p->parse(<eof;
Hi
Foo:-)
EOT
is("@start", "a href abc b");
is(join("", @text), "Hi\nFoo:-)\n");
callback.t 100644 001750 001751 2066 15253600633 14752 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 47;
my @expected;
my $p = HTML::Parser->new(
api_version => 3,
unbroken_text => 1,
default_h => [\@expected, '@{event, text}'],
);
my $doc = <<'EOT';
Hi
Ho ho
<--comment->
EOT
$p->parse($doc)->eof;
#use Data::Dump; Data::Dump::dump(@expected);
for my $i (1 .. length($doc)) {
my @t;
$p->handler(default => \@t);
$p->parse(chunk($doc, $i));
# check that we got the same stuff
#diag "X:", join(":", @t);
#diag "Y:", join(":", @expected);
is(join(":", @t), join(":", @expected));
}
sub chunk {
my $str = shift;
my $size = shift || 1;
sub {
my $res = substr($str, 0, $size);
#diag "...$res";
substr($str, 0, $size) = "";
$res;
}
}
# Test croking behaviour
$p->handler(default => []);
my $error;
{
local $@;
#<<< do not let perltidy touch this
$error = $@ || 'Error' unless eval {
$p->parse(sub { die "Hi" });
1
};
#>>>
}
like($error, qr/^Hi/);
document.t 100644 001750 001751 1376 15253600633 15037 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use File::Spec ();
use HTML::Parser ();
use Test::More tests => 6;
my $events;
my $p
= HTML::Parser->new(default_h => [sub { $events .= "$_[0]\n"; }, "event"]);
$events = "";
$p->eof;
is($events, "start_document\nend_document\n");
$events = "";
$p->parse_file(File::Spec->devnull);
is($events, "start_document\nend_document\n");
$events = "";
$p->parse("");
$p->eof;
is($events, "start_document\nend_document\n");
$events = "";
$p->parse("");
$p->parse("");
$p->eof;
is($events, "start_document\nend_document\n");
$events = "";
$p->parse("");
$p->parse("");
$p->eof;
is($events, "start_document\nstart\nend_document\n");
$events = "";
$p->parse(" ");
$p->eof;
is($events, "start_document\nstart\ntext\nend_document\n");
entities.t 100644 001750 001751 35264 15253600633 15070 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use utf8;
use HTML::Entities
qw(_decode_entities decode_entities encode_entities encode_entities_numeric);
use Test::More tests => 43;
my $x = "Våre norske tegn bør æres";
decode_entities($x);
is($x, "Våre norske tegn bør æres");
encode_entities($x);
is($x, "Våre norske tegn bør æres");
decode_entities($x);
encode_entities_numeric($x);
is($x, "Våre norske tegn bør æres");
$x = "<&>\"'";
is(encode_entities($x), "<&>"'");
is(encode_entities_numeric($x), "<&>"'");
$x = "abcdef";
is(encode_entities($x, 'a-c'), "abcdef");
$x = "[24/7]\\";
is(encode_entities($x, '/'), "[24/7]\\");
is(encode_entities($x, '\\/'), "[24/7]\\");
is(encode_entities($x, '\\'), "[24/7]\");
is(encode_entities($x, ']\\'), "[24/7]\");
# https://github.com/libwww-perl/HTML-Parser/issues/44
$x = '<]$a/b\c/d$';
is(encode_entities($x, '$'), '<]$a/b\\c/d$');
is(encode_entities($x, '\\\\/'), '<]$a/b\c/d$');
is(encode_entities($x, '\\\\/$'), '<]$a/b\c/d$');
is(encode_entities($x, '<\\\\]'), '<]$a/b\c/d$');
# POSIX character classes
$x = "'), "<Våre123[=]");
is(encode_entities($x, '[:Vlower:]'), "<Våre123[=]");
# escaped character classes
is(encode_entities($x, '\d'), ") {
next unless /^\s*
"Våre norske tegn bør æres",);
local $@;
my $got;
my $error;
#<<< do not let perltidy touch this
$error = $@ || 'Error' unless eval {
$got = decode_entities((keys %hash)[0]);
1;
};
#>>>
ok(!$error, "decode_entities() when processing a key as input");
is($got, (values %hash)[0], "decode_entities() decodes a key properly");
}
# CVE-2026-8829
# _decode_entities heap-use-after-free when the input SV is the same SV as
# a self-referential entity value. The payload must be large enough to
# force grow_gap() to realloc the SV's PV.
{
my $prefix_a = "A" x 32;
my $suffix_b = "B" x 8192;
my %h;
$h{foo} = $prefix_a . "&foo;" . $suffix_b;
_decode_entities($h{foo}, \%h);
is($h{foo}, ("A" x 64) . "&foo;" . ("B" x 16384),
"_decode_entities() with self-aliased entity hash value");
}
# An entity name that runs to the end of the input must not match a
# "name;" key on a byte beyond the end. Growing the string moves the
# tail without its NUL, so that byte holds whatever the buffer held
# before. Trim the string in place so a ";" is left just past its end.
{
my %t = ("ab;" => "X" x 40, "a;" => "Y");
my $s = "&ab;&a" . (";" x 200);
substr($s, 6) = "";
_decode_entities($s, \%t);
is(
$s,
("X" x 40) . "&a",
"_decode_entities() does not read past the end of the input"
);
}
# GH#68
# An entity whose value is the string being decoded expands to the value
# that string had when the call began, which is what an entity table
# holding a separate copy of that string has always given. The first two
# cases are the examples from the ticket.
{
my %g;
$g{foo} = "";
$g{bar} = "&foo;X&bar;";
_decode_entities($g{bar}, \%g);
is($g{bar}, "X&foo;X&bar;",
"_decode_entities() expands a self-reference after another entity");
my %i;
$i{foo} = "[.....]";
$i{bar} = "&foo;X&bar;Y";
_decode_entities($i{bar}, \%i);
is($i{bar}, "[.....]X&foo;X&bar;YY",
"_decode_entities() leaves no stale bytes at a self-reference");
my %j;
$j{amp} = "&";
$j{bar} = "&bar;&";
_decode_entities($j{bar}, \%j);
is($j{bar}, "&bar;&&",
"_decode_entities() keeps decoding after a self-reference");
my %p;
$p{nb} = " X";
_decode_entities($p{nb}, \%p, 1);
is($p{nb}, " XspX",
"_decode_entities() expands a self-reference matched as a prefix");
my %u;
$u{smile} = "\x{263a}";
$u{bar} = "\xe9⌣&bar;";
_decode_entities($u{bar}, \%u);
is(
$u{bar},
"\x{e9}\x{263a}\x{e9}⌣&bar;",
"_decode_entities() expands a self-reference after an upgrade"
);
}
# Looking up an entity value can run Perl code, through a tied hash or
# an overloaded object. That code must not be able to pull the string
# out from under the decoder.
{
package UndefOnFetch;
require Tie::Hash;
our @ISA = ("Tie::StdHash");
our $target;
sub FETCH { undef $$target; "x" }
}
{
my %tied;
tie %tied, "UndefOnFetch";
my $s = "&foo;" . ("a" x 100);
$UndefOnFetch::target = \$s;
eval { _decode_entities($s, \%tied) };
like(
$@,
qr/modified while fetching an entity value/,
"_decode_entities() dies when a tied table undefines the string"
);
}
{
package ReallocateOnFetch;
require Tie::Hash;
our @ISA = ("Tie::StdHash");
our $target;
sub FETCH { undef $$target; $$target = "Z" x 1000; undef }
}
{
my %tied;
tie %tied, "ReallocateOnFetch";
my $s = "&foo;" . ("a" x 100);
$ReallocateOnFetch::target = \$s;
eval { _decode_entities($s, \%tied) };
like(
$@,
qr/modified while fetching an entity value/,
"_decode_entities() dies when a tied table reallocates the string"
);
}
{
my $s = "&foo;" . ("a" x 100);
my %t = (foo => bless {}, "ShrinkOnStringify");
{
package ShrinkOnStringify;
use overload
'""' => sub { undef $s; $s = "Z" x 10; "x" },
fallback => 1;
}
eval { _decode_entities($s, \%t) };
like(
$@,
qr/modified while fetching an entity value/,
"_decode_entities() dies when a value shrinks the string"
);
}
{
my %h;
{
package DeleteOnStringify;
use overload '""' => sub { delete $h{str}; "x" }, fallback => 1;
}
$h{obj} = bless {}, "DeleteOnStringify";
$h{str} = "&obj;" . ("a" x 100);
eval { _decode_entities($h{str}, \%h) };
is($@, "", "_decode_entities() survives a value deleting the string");
ok(!exists $h{str}, "the deleted string stays deleted");
}
# From: Bill Simpson-Young
# Subject: HTML entities problem with 5.11
# To: libwww-perl@ics.uci.edu
# Date: Fri, 05 Sep 1997 16:56:55 +1000
# Message-Id: <199709050657.QAA10089@snowy.nsw.cmis.CSIRO.AU>
#
# Hi. I've got a problem that has surfaced with the changes to
# HTML::Entities.pm for 5.11 (it doesn't happen with 5.08). It's happening
# in the process of encoding then decoding special entities. Eg, what goes
# in as "abc&def&ghi" comes out as "abc&def;&ghi;".
is(decode_entities("abc&def&ghi&abc;&def;"), "abc&def&ghi&abc;&def;");
# Decoding of '
is(decode_entities("'"), "'");
is(encode_entities("'", "'"), "'");
is(
decode_entities(
"Attention Homeοωnөrs...1ѕt Tімe Eνөг"
),
"Attention Home\x{3BF}\x{3C9}n\x{4E9}rs...1\x{455}t T\x{456}\x{43C}e E\x{3BD}\x{4E9}\x{433}"
);
is(decode_entities("{&&& also Яœ}"),
"{&&& also \x{42F}\x{153}}");
__END__
# Quoted from rfc1866.txt
14. Proposed Entities
The HTML DTD references the "Added Latin 1" entity set, which only
supplies named entities for a subset of the non-ASCII characters in
[ISO-8859-1], namely the accented characters. The following entities
should be supported so that all ISO 8859-1 characters may only be
referenced symbolically. The names for these entities are taken from
the appendixes of [SGML].
Berners-Lee & Connolly Standards Track [Page 75]
RFC 1866 Hypertext Markup Language - 2.0 November 1995
Berners-Lee & Connolly Standards Track [Page 76]
RFC 1866 Hypertext Markup Language - 2.0 November 1995
textarea.t 100644 001750 001751 2617 15253600633 15035 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 1;
my $html = <<'EOT';
This is a <nice> title
EOT
my $dump = "";
sub tdump {
my @data = @_;
for (@data) {
$_ = "" unless defined;
s/\n/\\n/g;
}
$dump .= join("|", @data) . "\n";
}
my $p = HTML::Parser->new(default_h => [\&tdump, "event,text,dtext,is_cdata"]);
$p->parse($html)->eof;
#diag $dump;
is($dump, <<'EOT');
start_document|||
start|||
text|\n|\n|
start||<undef>|<undef>
text|This is a <nice> title|This is a <nice> title|
end| ||
text|\n|\n|
comment|||
text|\n|\n|
start|||
text|\n\n|\n\n|
start|||
text|\n\n|\n\n|
end|||
text|\n|\n|
end_document|||
EOT
xml-mode.t 100644 001750 001751 5176 15253600633 14745 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 8;
my $p = HTML::Parser->new(xml_mode => 1,);
my $text = "";
$p->handler(
start => sub {
my ($tag, $attr) = @_;
$text .= "S[$tag";
for my $k (sort keys %$attr) {
my $v = $attr->{$k};
$text .= " $k=$v";
}
$text .= "]";
},
"tagname,attr"
);
$p->handler(
end => sub {
$text .= "E[" . shift() . "]";
},
"tagname"
);
$p->handler(
process => sub {
$text .= "PI[" . shift() . "]";
},
"token0"
);
$p->handler(
text => sub {
$text .= shift;
},
"text"
);
my $xml = <<'EOT';
My first architectural document
Geir Ove Gronmo, grove@infotek.no
This is the first paragraph in this document
This is the second paragraph
<foo></foo>
EOT
$p->parse($xml)->eof;
is($text, <<'EOT');
PI[xml version="1.0"]
PI[IS10744:arch name="html"]
S[DOC]
S[title html=h1]My first architectural documentE[title]
S[author html=address]Geir Ove Gronmo, grove@infotek.noE[author]
S[para]This is the first paragraph in this documentE[para]
S[para html=p]This is the second paragraphE[para]
S[para]E[para]
S[xmp]S[foo]E[foo]E[xmp]
E[DOC]
EOT
$text = "";
$p->xml_mode(0);
$p->parse($xml)->eof;
is($text, <<'EOT');
PI[xml version="1.0"?]
PI[IS10744:arch name="html"?]
S[doc]
S[title html=h1]My first architectural documentE[title]
S[author html=address]Geir Ove Gronmo, grove@infotek.noE[author]
S[para]This is the first paragraph in this documentE[para]
S[para html=p]This is the second paragraphE[para]
S[para/]
S[xmp]and some more")->eof;
# Test that we get an empty tag back
$p = HTML::Parser->new(api_version => 3, empty_element_tags => 1);
$p->handler(
"end" => sub {
my ($tagname, $text) = @_;
is($tagname, "xyzzy");
ok(!length($text));
},
"tagname,text"
);
$p->parse("and some more")->eof;
$p = HTML::Parser->new(api_version => 3, xml_pic => 1,);
$p->handler(
"process" => sub {
my ($text, $t0) = @_;
is($text, " bar?>");
is($t0, "foo > bar");
},
"text, token0"
);
$p->parse(" bar?> and then")->eof;
entities.html 100644 001750 001751 7076 15253600633 15306 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86
Entities expansion test page
The purpose of this table is to test how various browsers expands
HTML entities in various edge cases in order to improve compatibility
for HTML-Parser.
ent with without dec hex hexx ref & & && && && &x ref ' ' &apos&aposapos '' '' 'x ref × × ××times ×× ×× ×x ref € € &euro&euroeuro €€ €€ €x ref ♥ ♥ &hearts&heartshearts ♥♥ ♥♥ ♥x ref
overflow:
3= 33=! 333=ō 3333=അ 33333=舵 333333= 3333333=� 33333333=� 333333333=� 3333333333=� 33333333333=�
ref: x ÿx ࿿x x x
Results
This table records observations of how various browsers behave with
regards to expanding entities. The term "Latin-1 entities" means named
entities that map to characters in the 0 .. 255 range. The term
"Unicode entities" means named entities that are not "Latin-1
entities".
feature
do
don't
expand '
HTML-Parser >= 3.22, FireFox 1.5, Konqueror 3.4.3, Safari 2.0
HTML-Parser <= 3.21, MSIE 7.0 beta 2
expand Latin-1 entities that are not terminated by semicolon
HTML-Parser, FireFox 1.5, Konqueror 3.4.3, MSIE 7.0 beta 2, Safari 2.0
expand prefix of Latin-1 entities in text content
HTML-Parser >= 3.40, Konqueror 3.4.3, MSIE 7.0 beta 2
HTML-Parser <= 3.38, FireFox 1.5, Safari 2.0
expand Unicode entities that are not terminated by semicolon in text content
HTML-Parser <= 3.50, FireFox 1.5, Safari 2.0
HTML-Parser >= 3.51, Konqueror 3.4.3, MSIE 7.0 beta 2
expand Unicode entities that are not terminated by semicolon in attributes
HTML-Parser <= 3.50
HTML-Parser >= 3.51, FireFox 1.5, Konqueror 3.4.3, MSIE 7.0 beta 2, Safari 2.0
expand hex entities that are not terminated by semicolon in text content
HTML-Parser, FireFox 1.5, Konqueror 3.4.3, Safari 2.0
MSIE 7.0 beta 2
expand hex entities that are not terminated by semicolon in attributes
HTML-Parser, FireFox 1.5, Konqueror 3.4.3, MSIE 7.0 beta 2, Safari 2.0
entities2.t 100644 001750 001751 3102 15253600633 15114 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use utf8;
use HTML::Entities qw(_decode_entities);
use Test::More tests => 9;
{
local $@;
my $error;
#<<< do not let perltidy touch this
$error = $@ || 'Error' unless eval {
_decode_entities("<", undef);
1;
};
#>>>
like($error,
qr/^(?:Can't inline decode readonly string|Modification of a read-only value attempted)/
);
}
{
local $@;
my $error;
#<<< do not let perltidy touch this
$error = $@ || 'Error' unless eval {
my $x = "";
_decode_entities($x, $x);
1;
};
#>>>
like($error, qr/^2nd argument must be hash reference/);
}
{
local $@;
my $error;
#<<< do not let perltidy touch this
$error = $@ || 'Error' unless eval {
my $x = "";
_decode_entities($x, []);
1;
};
#>>>
like($error, qr/^2nd argument must be hash reference/);
}
my $x = "<";
_decode_entities($x, undef);
is($x, "<");
_decode_entities($x, {"lt" => "<"});
is($x, "<");
$x = "x" x 20;
my $err;
for (":", ":a", "a:", "a:a", "a:a:a", "a:::a") {
my $x = $_;
$x =~ s/:/&a;/g;
my $y = $_;
$y =~ s/:/$x/g;
_decode_entities($x, {"a" => $x});
if ($x ne $y) {
diag "Something went wrong with '$_'";
$err++;
}
}
ok(!$err);
$x = "foo bar";
_decode_entities($x, \%HTML::Entities::entity2char);
is($x, "foo\xA0bar");
$x = "foo bar";
_decode_entities($x, \%HTML::Entities::entity2char);
is($x, "foo bar");
_decode_entities($x, \%HTML::Entities::entity2char, 1);
is($x, "foo\xA0bar");
largetags.t 100644 001750 001751 1315 15253600633 15163 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 2;
# Exercise the tokenpos buffer allocation routines by feeding it
# very large tags.
my $p = HTML::Parser->new(api_version => 3);
$p->handler(
"start" => sub {
my $tp = shift;
#diag int(@$tp), " - ", join(", ", @$tp);
is(@$tp, 2 + 26 * 6 * 4);
},
"tokenpos"
);
$p->handler(
"declaration" => sub {
my $t = shift;
#diag int(@$t), " - @$t";
is(@$t, 26 * 6 * 2 + 1);
},
"tokens"
);
$p->parse("parse("$_=1 ");
}
$p->parse(">");
$p->parse("parse("$_ -- $_ -- ");
}
$p->parse(">");
$p->eof;
parsefile.t 100644 001750 001751 2163 15253600633 15166 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use IO::File ();
use Test::More tests => 6;
my $filename = "file$$.htm";
die "$filename is already there" if -e $filename;
{
open(my $fh, '>', $filename) || die "Can't create $filename: $!";
print {$fh} "Heisan \n";
close($fh);
}
{
package MyParser;
use strict;
use warnings;
require HTML::Parser;
our @ISA = qw(HTML::Parser);
sub start {
my ($self, $tag, $attr) = @_;
Test::More::is($tag, "title");
}
1;
}
MyParser->new->parse_file($filename);
open(my $fh, $filename) || die;
MyParser->new->parse_file($fh);
seek($fh, 0, 0) || die;
MyParser->new->parse_file($fh);
close($fh);
my $io = IO::File->new($filename) || die;
MyParser->new->parse_file($io);
$io->seek(0, 0) || die;
MyParser->new->parse_file(*$io);
my $text = '';
$io->seek(0, 0) || die;
MyParser->new(
start_h => [sub { shift->eof; }, "self"],
text_h => [sub { $text = shift; }, "text"]
)->parse_file(*$io);
ok(!$text);
close($io); # needed because of bug in perl
undef($io);
unlink($filename) or warn "Can't unlink $filename: $!";
plaintext.t 100644 001750 001751 2147 15253600633 15226 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 3;
my @data;
my $p = HTML::Parser->new(api_version => 3);
$p->handler(default => \@data, '@{event, text, is_cdata}');
$p->parse(<eof;
<foo> x<foo>
</plaintext>
foo
EOT
for (@data) {
$_ = "" unless defined;
}
my $doc = join(":", @data);
#diag $doc;
is(
$doc,
"start_document:::start:<xmp>::text:<foo>:1:end:</xmp>::text:x::start:<plaintext>::text:<foo>
</plaintext>
foo
:1:end_document::"
);
@data = ();
$p->closing_plaintext('yep, emulate gecko');
$p->parse(<<EOT)->eof;
<plaintext><foo>
</plaintext>foo<b></b>
EOT
for (@data) {
$_ = "" unless defined;
}
$doc = join(":", @data);
#diag $doc;
is(
$doc, "start_document:::start:<plaintext>::text:<foo>
:1:end:</plaintext>::text:foo::start:<b>::end:</b>::text:
::end_document::"
);
@data = ();
$p->closing_plaintext('yep, emulate gecko (2)');
$p->parse(<<EOT)->eof;
<plaintext><foo>
foo<b></b>
EOT
$doc = join(":", map { defined $_ ? $_ : "" } @data);
is(
$doc, "start_document:::start:<plaintext>::text:<foo>
foo<b></b>
:1:end_document::"
);
uentities.t 100644 001750 001751 4057 15253600633 15231 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use utf8;
use HTML::Entities qw(decode_entities encode_entities);
use Test::More tests => 26;
# Test Unicode entities
SKIP: {
skip "Unicode entities not selected", 26
if !&HTML::Entities::UNICODE_SUPPORT;
is(decode_entities("&euro"), "&euro");
is(decode_entities("€"), "\x{20AC}");
is(decode_entities("å"), "å");
is(decode_entities("å"), "å");
is(decode_entities("񺄠"), chr(500000));
is(decode_entities("􏿽"), "\x{10FFFD}");
is(decode_entities(""), "\x{FFFC}");
is(decode_entities(""), "\x{FFFD}");
is(decode_entities(""), "\x{FFFD}");
is(decode_entities(""), "\x{FFFD}");
is(decode_entities(""), "\x{FFFD}");
is(decode_entities(""), "");
is(decode_entities(""), "\x{FFFD}");
is(decode_entities("�"), "�");
is(decode_entities("�"), "�");
is(decode_entities("�"), "�");
is(decode_entities("�"), "�");
is(decode_entities("�"), "�");
is(decode_entities("�"), "�");
is(decode_entities("&#ååå࿿"), "&#ååå\x{FFF}");
# This might fail when we get more than 64 bit UVs
is(decode_entities("�"),
"�");
is(decode_entities("�"), "�");
my $err;
for ([32, 48], [120, 169], [240, 250], [250, 260], [965, 975], [3000, 3005])
{
my $x = join("", map chr, $_->[0] .. $_->[1]);
my $e = encode_entities($x);
my $d = decode_entities($e);
unless ($d eq $x) {
diag "Wrong decoding in range $_->[0] .. $_->[1]";
# use Devel::Peek; Dump($x); Dump($d);
$err++;
}
}
ok(!$err);
is(decode_entities("��"), chr(0x100085));
is(decode_entities("�"), chr(0xFFFD));
is(decode_entities("\260’\260"), "\x{b0}\x{2019}\x{b0}");
}
headparser.t 100644 001750 001751 12524 15253600633 15354 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use utf8;
use HTML::HeadParser ();
use Test::More tests => 17;
{
package H;
use strict;
use warnings;
sub new { bless {}, shift; }
sub header {
my $self = shift;
my $key = uc(shift);
die if $key =~ /:/;
my $old = $self->{$key};
if (@_) { $self->{$key} = shift; }
$old;
}
sub push_header {
my ($self, $k, $v) = @_;
$k = uc($k);
die if $k =~ /:/;
if (exists $self->{$k}) {
$self->{$k} = [$self->{$k}] unless ref $self->{$k};
push(@{$self->{$k}}, $v);
}
else {
$self->{$k} = $v;
}
}
sub as_string {
my $self = shift;
my $str = "";
for (sort keys %$self) {
if (ref($self->{$_})) {
my $v;
for $v (@{$self->{$_}}) {
$str .= "$_: $v\n";
}
}
else {
$str .= "$_: $self->{$_}\n";
}
}
$str;
}
}
my $HTML = <<'EOT';
<title>Å være eller å ikke være</title>
<meta http-equiv="Expires" content="Soon">
<meta http-equiv="Foo" content="Bar">
<meta name='twitter:card' content='photo' />
<link href="mailto:gisle@aas.no" rev=made title="Gisle Aas">
<script>
ignore this
</script>
<noscript> ... and this </noscript>
<object classid="foo">
<base href="http://www.sn.no">
<meta name="Keywords" content="test, test, test,...">
<meta name="Keywords" content="more">
<meta charset="ISO-8859-1"><!-- HTML 5 -->
Dette er vanlig tekst. Denne teksten definerer også slutten på
<head> delen av dokumentet.
<style>
ignore this too
</style>
<isindex>
Dette er også vanlig tekst som ikke skal blir parset i det hele tatt.
EOT
$| = 1;
#$HTML::HeadParser::DEBUG = 1;
my $p = HTML::HeadParser->new(H->new);
if ($p->parse($HTML)) {
fail("Need more data which should not happen");
}
else {
#diag $p->as_string;
pass();
}
like($p->header('Title'), qr/Å være eller å ikke være/);
is($p->header('Expires'), 'Soon');
is($p->header('Content-Base'), 'http://www.sn.no');
is_deeply($p->header('X-Meta-Keywords'), ['test, test, test,...', 'more']);
is($p->header('X-Meta-Charset'), 'ISO-8859-1');
is($p->header('X-Meta-Twitter-Card'), 'photo');
like($p->header('Link'), qr/<mailto:gisle\@aas.no>/);
# This header should not be present because the head ended
ok(!$p->header('Isindex'));
# Try feeding one char at a time
my $expected = $p->as_string;
my $nl = 1;
$p = HTML::HeadParser->new(H->new);
while ($HTML =~ /(.)/sg) {
#print STDERR '#' if $nl;
#print STDERR $1;
$nl = $1 eq "\n";
$p->parse($1) or last;
}
is($p->as_string, $expected);
# Try reading it from a file
my $file = "hptest$$.html";
die "$file already exists" if -e $file;
{
open(my $fh, '>', $file) or die "Can't create $file: $!";
binmode($fh);
print {$fh} $HTML;
print {$fh} "<p>This is more content...</p>\n" x 2000;
print {$fh} "<title>Buuuh!</title>\n" x 200;
close $fh or die "Can't close $file: $!";
}
$p = HTML::HeadParser->new(H->new);
$p->parse_file($file);
unlink($file) or warn "Can't unlink $file: $!";
is($p->header("Title"), "Å være eller å ikke være");
# We got into an infinite loop on data without tags and no EOL.
# This was actually a HTML::Parser bug.
{
open(my $fh, '>', $file) or die "Can't create $file: $!";
print {$fh} "Foo";
close($fh);
}
$p = HTML::HeadParser->new(H->new);
$p->parse_file($file);
unlink($file) or warn "Can't unlink $file: $!";
ok(!$p->as_string);
SKIP: {
# Test that the Unicode BOM does not confuse us?
$p = HTML::HeadParser->new(H->new);
ok($p->parse("\x{FEFF}\n<title>Hi <foo></title>"));
$p->eof;
is($p->header("title"), "Hi <foo>");
$p = HTML::HeadParser->new(H->new);
$p->utf8_mode(1);
$p->parse(
<<"EOT"); # example from http://rt.cpan.org/Ticket/Display.html?id=27522
\xEF\xBB\xBF<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
<title>
Parkinson's disease</title>
<meta name="Keywords" content="brain,disease,dopamine,drug,levodopa,parkinson,patients,symptoms,,Medications, Medications">
</meta>
\t
\t<link href="../../css/ummAdam.css" rel="stylesheet" type="text/css" />
\t<link rel="stylesheet" rev="stylesheet" href="../../css/ummprint.css" media="print" />
\t
\t </head>
<body>
EOT
$p->eof;
is($p->header("title"), "Parkinson's disease");
is($p->header("link")->[0],
'<../../css/ummAdam.css>; rel="stylesheet"; type="text/css"');
$p = HTML::HeadParser->new(H->new);
$p->utf8_mode(1);
$p->parse(<<"EOT"); # example from http://www.mjw.com.pl/
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\r
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="pl" lang="pl"> \r
\r
<head profile="http://gmpg.org/xfn/11">\r
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />\r
\r
<title> ko\xC5\x84c\xC3\xB3wki kolekcji, outlet, hurtownia odzie\xC5\xBCy Warszawa – MJW</title>\r
<link rel="shortcut icon" href="favicon.ico" type="image/x-icon" />\r
EOT
$p->eof;
is($p->header("title"),
"ko\xC5\x84c\xC3\xB3wki kolekcji, outlet, hurtownia odzie\xC5\xBCy Warszawa \xE2\x80\x93 MJW"
);
}
pullparser.t 100644 001750 001751 1752 15253600633 15410 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::PullParser ();
use Test::More tests => 3;
my $doc = <<'EOT';
<title>Title</title>
<style> h1 { background: white }
<foo>
</style>
<H1 ID="3">Heading</H1>
<!-- ignore this -->
This is a text with a <A HREF="http://www.sol.no" name="l1">link</a>.
EOT
my $p = HTML::PullParser->new(
doc => $doc,
start => 'event,tagname,@attr',
end => 'event,tagname',
text => 'event,dtext',
ignore_elements => [qw(script style)],
unbroken_text => 1,
boolean_attribute_value => 1,
);
my $t = $p->get_token;
is($t->[0], "start");
is($t->[1], "title");
$p->unget_token($t);
my @data;
while (my $t = $p->get_token) {
for (@$t) {
s/\s/./g;
}
push(@data, join("|", @$t));
}
my $res = join("\n", @data, "");
#diag $res;
is($res, <<'EOT');
start|title
text|Title
end|title
text|..
start|h1|id|3
text|Heading
end|h1
text|...This.is.a.text.with.a.
start|a|href|http://www.sol.no|name|l1
text|link
end|a
text|..
EOT
tokeparser.t 100644 001750 001751 6433 15253600633 15377 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::TokeParser ();
use Test::More tests => 17;
# First we create an HTML document to test
my $file = "ttest$$.htm";
die "$file already exists" if -e $file;
{
open(my $fh, '>', $file) or die "Can't create $file: $!";
print {$fh} <<'EOT';
<!--This is a test-->
<html><head><title>
This is the <title>
</title>
<base href="http://www.perl.com">
</head>
<body background="bg.gif">
<h1>This is the <b>title</b> again
</h1>
And this is a link to the <a href="http://www.perl.com"><img src="camel.gif" alt="Perl"> <!--nice isn't it-->Institute</a>
<br/><? process instruction >
</body>
</html>
EOT
close($fh);
}
END { unlink($file) || warn "Can't unlink $file: $!"; }
my $p;
$p = HTML::TokeParser->new($file) || die "Can't open $file: $!";
ok($p->unbroken_text);
if ($p->get_tag("foo", "title")) {
my $title = $p->get_trimmed_text;
#diag "Title: $title";
is($title, "This is the <title>");
}
undef($p);
my $scount = 0;
my $ecount = 0;
my $tcount = 0;
my $pcount = 0;
# Test with reference to glob
{
open(my $fh, '<', $file) || die "Can't open $file: $!";
$p = HTML::TokeParser->new($fh);
while (my $token = $p->get_token) {
$scount++ if $token->[0] eq "S";
$ecount++ if $token->[0] eq "E";
$pcount++ if $token->[0] eq "PI";
}
undef($p);
close $fh;
}
# Test with glob
{
open(my $fh, $file) || die "Can't open $file: $!";
$p = HTML::TokeParser->new($fh);
$tcount++ while $p->get_tag;
undef($p);
close $fh;
}
# Test with plain file name
$p = HTML::TokeParser->new($file) || die;
$tcount++ while $p->get_tag;
undef($p);
#diag "Number of tokens found: $tcount/2 = $scount + $ecount";
is($tcount, 34);
is($scount, 10);
is($ecount, 7);
is($pcount, 1);
is($tcount / 2, $scount + $ecount);
ok(!HTML::TokeParser->new("/noT/thEre/$$"));
$p = HTML::TokeParser->new($file) || die;
$p->get_tag("a");
my $atext = $p->get_text;
undef($p);
is($atext, "Perl\240Institute");
# test parsing of embedded document
$p = HTML::TokeParser->new(\<<HTML);
<title>Title</title>
<H1>
Heading
</h1>
HTML
ok($p->get_tag("h1"));
is($p->get_trimmed_text, "Heading");
undef($p);
# test parsing of large embedded documents
my $doc = "<a href='foo'>foo is bar</a>\n\n\n" x 2022;
#use Time::HiRes qw(time);
my $start = time;
$p = HTML::TokeParser->new(\$doc);
#diag "Construction time: ", time - $start;
my $count;
while (my $t = $p->get_token) {
$count++ if $t->[0] eq "S";
}
#diag "Parse time: ", time - $start;
is($count, 2022);
$p = HTML::TokeParser->new(\<<'EOT');
<H1>This is a heading</H1>
This is s<b>o</b>me<hr>text.
<br />
This is some more text.
<p>
This is even some more.
EOT
$p->get_tag("/h1");
my $t = $p->get_trimmed_text("br", "p");
is($t, "This is some text.");
$p->get_tag;
$t = $p->get_trimmed_text("br", "p");
is($t, "This is some more text.");
undef($p);
$p = HTML::TokeParser->new(\<<'EOT');
<H1>This is a <b>bold</b> heading</H1>
This is some <i>italic</i> text.<br />This is some <span id=x>more text</span>.
<p>
This is even some more.
EOT
$p->get_tag("h1");
$t = $p->get_phrase;
is($t, "This is a bold heading");
$t = $p->get_phrase;
is($t, "");
$p->get_tag;
$t = $p->get_phrase;
is($t, "This is some italic text. This is some more text.");
undef($p);
api_version.t 100644 001750 001751 1102 15253600633 15522 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 4;
my $p = HTML::Parser->new(api_version => 3);
ok(!$p->handler("start"), "API version 3");
my $error;
my $success = 0;
{
local $@;
#<<< do not let perltidy touch this
$error = $@ || 'Error' unless eval {
my $p = HTML::Parser->new(api_version => 4);
$success = 1;
};
#>>>
}
like($error, qr/^API version 4 not supported/, 'API v4 error');
ok(!$success, "!API version 4");
$p = HTML::Parser->new(api_version => 2);
is($p->handler("start"), "start", "API version 2");
argspec-bad.t 100644 001750 001751 1556 15253600633 15371 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 6;
my $p = HTML::Parser->new(api_version => 3);
sub test_error {
my ($arg, $check_exp) = @_;
my $error;
{
local $@;
#<<< do not let perltidy touch this
$error = $@ || 'Error' unless eval {
$p->handler(end => "end", $arg);
1
};
#>>>
}
like($error, $check_exp);
}
test_error(q(xyzzy), qr/^Unrecognized identifier xyzzy/);
test_error(q(tagname text), qr/^Missing comma separator/);
test_error(q(tagname, "text), qr/^Unterminated literal string/);
test_error(q(tagname, "t\\t"), qr/^Backslash reserved for literal string/);
test_error('"' . ("x" x 256) . '"',
qr/^Literal string is longer than 255 chars/);
$p->handler(end => sub { is(length(shift), 255) }, '"' . ("x" x 255) . '"');
$p->parse("</x>");
declaration.t 100644 001750 001751 2032 15253600633 15474 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 2;
my $res = "";
sub decl {
my $t = shift;
$res .= "[" . join("\n", map "<$_>", @$t) . "]";
}
sub text {
$res .= shift;
}
my $p = HTML::Parser->new(
declaration_h => [\&decl, "tokens"],
default_h => [\&text, "text"],
);
$p->parse(<<EOT)->eof;
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" --<comment>--
"http://www.w3.org/TR/html40/strict.dtd">
<!ENTITY foo "<!-- foo -->">
<!Entity foo "<!-- foo -->">
<!row --> foo
EOT
is($res, <<EOT);
[<DOCTYPE>
<HTML>
<PUBLIC>
<"-//W3C//DTD HTML 4.01//EN">
<--<comment>-->
<"http://www.w3.org/TR/html40/strict.dtd">]
[<ENTITY>
<foo>
<"<!-- foo -->">]
[<Entity>
<foo>
<"<!-- foo -->">]
<!row --> foo
EOT
$res = "";
$p->parse(<<EOT)->eof;
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"[]>
EOT
is($res, <<EOT);
[<DOCTYPE>
<html>
<PUBLIC>
<"-//W3C//DTD XHTML 1.0 Strict//EN">
<"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<[]>]
EOT
handler-eof.t 100644 001750 001751 2750 15253600633 15402 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 6;
my $p = HTML::Parser->new(api_version => 3);
$p->handler(start => sub { my $attr = shift; is($attr->{testno}, 1) }, "attr");
$p->handler(end => sub { shift->eof }, "self");
my $text;
$p->handler(text => sub { $text = shift }, "text");
is($p->parse("<foo testno=1>"), $p);
$text = '';
ok(!$p->parse("</foo><foo testno=999>"));
ok(!$text);
$p->handler(end => sub { $p->parse("foo"); }, "");
{
local $@;
my $error;
#<<< do not let perltidy touch this
$error = $@ || 'Error' unless eval {
$p->parse("</foo>");
1;
};
#>>>
like($error, qr/^Parse loop not allowed/);
}
# We used to get into an infinite loop if the eof triggered
# handler called ->eof
$p = HTML::Parser->new(api_version => 3);
my $i;
$p->handler(
"default" => sub {
my $p = shift;
#++$i; diag "$i @_";
$p->eof;
},
"self, event"
);
$p->parse("Foo");
$p->eof;
# We used to sometimes trigger events after a handler signaled eof
my $title = '';
$p = HTML::Parser->new(api_version => 3,);
$p->handler(start => \&title_handler, 'tagname, self');
$p->parse("<head><title>foo</title>\n</head>");
is($title, "foo");
sub title_handler {
return if shift ne 'title';
my $self = shift;
$self->handler(text => sub { $title .= shift }, 'dtext');
$self->handler(
end => sub { shift->eof if shift eq 'title' },
'tagname, self'
);
}
marked-sect.t 100644 001750 001751 5500 15253600633 15411 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use utf8;
use HTML::Parser ();
use Test::More tests => 14;
my $tag;
my $text;
my $p = HTML::Parser->new(
start_h => [sub { $tag = shift }, "tagname"],
text_h => [sub { $text .= shift }, "dtext"],
);
my $error;
{
local $@;
#<<< do not let perltidy touch this
$error = $@ || 'Error' unless eval {
$p->marked_sections(1);
1;
};
#>>>
}
SKIP: {
skip $error, 14 if $error;
$p->parse("<![[foo]]>");
is($text, "foo");
$p->parse("<![TEMP INCLUDE[bar]]>");
is($text, "foobar");
$p->parse("<![ INCLUDE -- IGNORE -- [foo<![IGNORE[bar]]>]]>\n<br>");
is($text, "foobarfoo\n");
$text = "";
$p->parse("<![ CDATA [<foo");
$p->parse("<![IGNORE[bar]]>,bar>]]><br>");
is($text, "<foo<![IGNORE[bar,bar>]]>");
$text = "";
$p->parse("<![ RCDATA [å<a>]]><![CDATA[å<a>]]>å<a><br>");
is($text, "å<a>å<a>å");
is($tag, "br");
$text = "";
$p->parse("<![INCLUDE RCDATA CDATA IGNORE [fooå<a>]]><br>");
is($text, "");
$text = "";
$p->parse("<![INCLUDE RCDATA CDATA [fooå<a>]]><br>");
is($text, "fooå<a>");
$text = "";
$p->parse("<![INCLUDE RCDATA [fooå<a>]]><br>");
is($text, "fooå<a>");
$text = "";
$p->parse("<![INCLUDE [fooå<a>]]><br>");
is($text, "fooå");
$text = "";
$p->parse("<![[fooå<a>]]><br>");
is($text, "fooå");
# offsets/line/column numbers
$p = HTML::Parser->new(
default_h => [\&x, "line,column,offset,event,text"],
marked_sections => 1,
);
$p->parse(<<'EOT')->eof;
<title>Test</title>
<![CDATA
[fooå<a>
]]>
<![[
INCLUDE
STUFF
]]>
<h1>Test</h1>
EOT
my @x;
sub x {
my ($line, $col, $offset, $event, $text) = @_;
$text =~ s/\n/\\n/g;
$text =~ s/ /./g;
push(@x, "$line.$col:$offset $event \"$text\"\n");
}
#diag @x;
is(join("", @x), <<'EOT');
1.0:0 start_document ""
1.0:0 start "<title>"
1.7:7 text "Test"
1.11:11 end "</title>"
1.19:19 text "\n"
3.3:32 text "fooå<a>\n"
4.3:49 text "\n"
5.4:54 text "\nINCLUDE\nSTUFF\n"
8.3:72 text "\n.."
9.2:75 start "<h1>"
9.6:79 text "Test"
9.10:83 end "</h1>"
9.15:88 text "\n"
10.0:89 end_document ""
EOT
my $doc = "<Tag><![CDATA[This is cdata]]></Tag>";
my $result = "";
$p = HTML::Parser->new(
marked_sections => 1,
handlers => {
default => [sub { $result .= join("", @_); }, "skipped_text,text"]
}
)->parse($doc)->eof;
is($doc, $result);
$text = "";
$p = HTML::Parser->new(
text_h => [sub { $text .= shift }, "dtext"],
marked_sections => 1,
);
$p->parse("<![CDATA[foo [1]]]>");
is($text, "foo [1]", "CDATA text ending in square bracket");
} # SKIP
msie-compat.t 100644 001750 001751 3053 15253600633 15431 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 4;
my $TEXT = "";
sub h {
my ($event, $tagname, $text, @attr) = @_;
for ($event, $tagname, $text, @attr) {
if (defined) {
s/([\n\r\t])/sprintf "\\%03o", ord($1)/ge;
}
else {
$_ = "<undef>";
}
}
$TEXT .= "[$event,$tagname,$text," . join(":", @attr) . "]\n";
}
my $p = HTML::Parser->new(default_h => [\&h, "event,tagname,text,\@attr"]);
$p->parse("<a>");
$p->parse("</a f>");
$p->parse("</a 'foo<>' 'bar>' x>");
$p->parse("</a \"foo<>\"");
$p->parse(" \"bar>\" x>");
$p->parse("</ foo bar>");
$p->parse("</ \"<>\" >");
$p->parse("<!--comment>text<!--comment><p");
$p->eof;
is($TEXT, <<'EOT');
[start_document,<undef>,,]
[start,a,<a>,]
[end,a,</a f>,]
[end,a,</a 'foo<>' 'bar>' x>,]
[end,a,</a "foo<>" "bar>" x>,]
[comment, foo bar,</ foo bar>,]
[comment, "<>" ,</ "<>" >,]
[comment,comment,<!--comment>,]
[text,<undef>,text,]
[comment,comment,<!--comment>,]
[comment,p,<p,]
[end_document,<undef>,,]
EOT
$TEXT = "";
$p->parse("<!comment>");
$p->eof;
is($TEXT, <<'EOT');
[start_document,<undef>,,]
[comment,comment,<!comment>,]
[end_document,<undef>,,]
EOT
$TEXT = "";
$p->parse(q(<a name=`foo bar`>));
$p->eof;
is($TEXT, <<'EOT');
[start_document,<undef>,,]
[start,a,<a name=`foo bar`>,name:`foo:bar`:bar`]
[end_document,<undef>,,]
EOT
$p->backquote(1);
$TEXT = "";
$p->parse(q(<a name=`foo bar`>));
$p->eof;
is($TEXT, <<'EOT');
[start_document,<undef>,,]
[start,a,<a name=`foo bar`>,name:foo bar]
[end_document,<undef>,,]
EOT
unicode-bom.t 100644 001750 001751 2254 15253600633 15416 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t #!perl -w
use strict;
use warnings;
use utf8;
use HTML::Parser ();
use Test::More tests => 2;
my @parsed;
my $p
= HTML::Parser->new(api_version => 3, start_h => [\@parsed, 'tag, attr'],);
my @warn;
$SIG{__WARN__} = sub {
push(@warn, $_[0]);
};
$p->parse("\xEF\xBB\xBF<head>Hi there</head>");
$p->eof;
#use Encode;
$p->parse("\xEF\xBB\xBF<head>Hi there</head>" . chr(0x263A));
$p->eof;
$p->parse("\xFF\xFE<head>Hi there</head>");
$p->eof;
$p->parse("\xFE\xFF<head>Hi there</head>");
$p->eof;
$p->parse("\0\0\xFF\xFE<head>Hi there</head>");
$p->eof;
$p->parse("\xFE\xFF\0\0<head>Hi there</head>");
$p->eof;
for (@warn) {
s/line (\d+)/line ##/g;
}
is(join("", @warn), <<EOT);
Parsing of undecoded UTF-8 will give garbage when decoding entities at $0 line ##.
Parsing of undecoded UTF-8 will give garbage when decoding entities at $0 line ##.
Parsing of undecoded UTF-16 at $0 line ##.
Parsing of undecoded UTF-16 at $0 line ##.
Parsing of undecoded UTF-32 at $0 line ##.
Parsing of undecoded UTF-32 at $0 line ##.
EOT
@warn = ();
$p = HTML::Parser->new(api_version => 3, start_h => [\@parsed, 'tag'],);
$p->parse("\xEF\xBB\xBF<head>Hi there</head>");
$p->eof;
ok(!@warn);
hints 000755 001750 001751 0 15253600633 13547 5 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86 solaris.pl 100644 001750 001751 165 15253600633 15702 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/hints if ($Config{gccversion}) {
print "Turning off optimizations to avoid compiler bug\n";
$self->{OPTIMIZE} = " ";
}
attr-encoded.t 100644 001750 001751 1124 15253600633 15561 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 2;
my $p = HTML::Parser->new();
$p->attr_encoded(1);
my $text = "";
$p->handler(
start => sub {
my ($tag, $attr) = @_;
$text .= "S[$tag";
for my $k (sort keys %$attr) {
my $v = $attr->{$k};
$text .= " $k=$v";
}
$text .= "]";
},
"tagname,attr"
);
my $html = <<'EOT';
<tag arg="&<>">
EOT
$p->parse($html)->eof;
is($text, 'S[tag arg=&<>]');
$text = "";
$p->attr_encoded(0);
$p->parse($html)->eof;
is($text, 'S[tag arg=&<>]');
skipped-text.t 100644 001750 001751 3324 15253600633 15635 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use Test::More tests => 4;
use strict;
use HTML::Parser;
my $p = HTML::Parser->new(api_version => 3);
$p->report_tags("a");
my @doc;
$p->handler(start => \&a_handler, "skipped_text, text");
$p->handler(end_document => \@doc, '@{skipped_text}');
$p->parse(<<EOT)->eof;
<title>hi</title>
<h1><a href="foo">link</a></h1>
and <a foo="">some</a> text.
EOT
sub a_handler {
push(@doc, shift);
my $text = shift;
push(@doc, uc($text));
}
is(join("", @doc), <<'EOT');
<title>hi</title>
<h1><A HREF="FOO">link</a></h1>
and <A FOO="">some</a> text.
EOT
#
# Comment stripper. Interaction with "" handlers.
#
my $doc = <<EOT;
<html>text</html>
<!-- comment -->
and some more <b>text</b>.
EOT
(my $expected = $doc) =~ s/<!--.*?-->//;
$p = HTML::Parser->new(api_version => 3);
$p->handler(comment => "");
$p->handler(
end_document => sub {
my $stripped = shift;
#diag $stripped;
is($stripped, $expected);
},
"skipped_text"
);
for (split(//, $doc)) {
$p->parse($_);
}
$p->eof;
#
# Interaction with unbroken text
#
my @x;
$p = HTML::Parser->new(api_version => 3, unbroken_text => 1);
$p->handler(text => \@x, '@{"X", skipped_text, text}');
$p->handler(end => "");
$p->handler(end_document => \@x, '@{"Y", skipped_text}');
$doc = "a a<a>b b</a>c c<x>d d</x>e";
for (split(//, $doc)) {
$p->parse($_);
}
$p->eof;
#diag join(":", @x);
is(join(":", @x), "X::a a:X:<a>:b bc c:X:<x>:d de:Y:");
#
# The crash that Chip found
#
my $skipped;
$p = HTML::Parser->new(
ignore_tags => ["foo"],
start_h => [sub { $skipped = shift }, "skipped_text"],
);
$p->parse("\x{100}<foo>");
$p->parse("plain");
$p->parse("<bar>");
$p->eof;
is($skipped, "\x{100}<foo>plain");
linkextor-rel.t 100644 001750 001751 1415 15253600633 16012 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::LinkExtor ();
use Test::More tests => 3;
my $HTML = <<HTML;
<head>
<base href="http://www.sn.no/">
</head>
<body>
This is <A HREF="link.html">link</a> and an <img SRC="img.jpg"
alt="Image">.
HTML
# Try the callback interface
my $links = "";
my $p = HTML::LinkExtor->new(sub {
my($tag, %links) = @_;
#diag "$tag @{[%links]}";
$links .= "$tag @{[%links]}\n";
});
$p->parse($HTML); $p->eof;
ok($links =~ m|^base href http://www\.sn\.no/$|m);
ok($links =~ m|^a href link\.html$|m);
# Used to be problems when using the links method on a document with
# no links it it. This is a test to prove that it works.
$p = new HTML::LinkExtor;
$p->parse("this is a document with no links"); $p->eof;
my @links = $p->links;
is(@links, 0);
stack-realloc.t 100644 001750 001751 625 15253600633 15721 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 1;
# HTML-Parser 3.33 and older used to core dump on this program because
# of missing SPAGAIN calls in parse() XS code. It was not prepared for
# the stack to get realloced.
$| = 1;
my $x = HTML::Parser->new(api_version => 3);
my @row;
$x->handler(end => sub { push(@row, (1) x 505); 1 }, "tagname");
$x->parse("</TD>");
pass;
unbroken-text.t 100644 001750 001751 2224 15253600633 16017 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 3;
my $text = "";
sub text {
my $cdata = shift() ? "CDATA" : "TEXT";
my ($offset, $line, $col, $t) = @_;
$text .= "[$cdata:$offset:$line.$col:$t]";
}
sub tag {
$text .= shift;
}
my $p = HTML::Parser->new(
unbroken_text => 1,
text_h => [\&text, "is_cdata,offset,line,column,text"],
start_h => [\&tag, "text"],
end_h => [\&tag, "text"],
);
$p->parse("foo ");
$p->parse("bar ");
$p->parse("<foo>");
$p->parse("bar\n");
$p->parse("</foo>");
$p->parse("<xmp>xmp</xmp>");
$p->parse("atend");
#diag $text;
is($text,
"[TEXT:0:1.0:foo bar ]<foo>[TEXT:13:1.13:bar\n]</foo><xmp>[CDATA:28:2.11:xmp]</xmp>"
);
$text = "";
$p->eof;
#diag $text;
is($text, "[TEXT:37:2.20:atend]");
$p = HTML::Parser->new(
unbroken_text => 1,
text_h => [\&text, "is_cdata,offset,line,column,text"],
);
$text = "";
$p->parse("foo");
$p->parse("<foo");
$p->parse(">bar\n");
$p->parse("foo<xm");
$p->parse("p>xmp");
$p->parse("</xmp");
$p->parse(">bar");
$p->eof;
#diag $text;
is($text, "[TEXT:0:1.0:foobar\nfoo][CDATA:20:2.8:xmp][TEXT:29:2.17:bar]");
HTML 000755 001750 001751 0 15253600633 13734 5 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/lib Filter.pm 100644 001750 001751 5146 15253600633 15665 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/lib/HTML package HTML::Filter;
use strict;
require HTML::Parser;
our @ISA = qw(HTML::Parser);
our $VERSION = '3.86';
sub declaration { $_[0]->output("<!$_[1]>") }
sub process { $_[0]->output($_[2]) }
sub comment { $_[0]->output("<!--$_[1]-->") }
sub start { $_[0]->output($_[4]) }
sub end { $_[0]->output($_[2]) }
sub text { $_[0]->output($_[1]) }
sub output { print $_[1] }
1;
__END__
=head1 NAME
HTML::Filter - Filter HTML text through the parser
=head1 NOTE
B<This module is deprecated.> The C<HTML::Parser> now provides the
functionally of C<HTML::Filter> much more efficiently with the
C<default> handler.
=head1 SYNOPSIS
require HTML::Filter;
$p = HTML::Filter->new->parse_file("index.html");
=head1 DESCRIPTION
C<HTML::Filter> is an HTML parser that by default prints the
original text of each HTML element (a slow version of cat(1) basically).
The callback methods may be overridden to modify the filtering for some
HTML elements and you can override output() method which is called to
print the HTML text.
C<HTML::Filter> is a subclass of C<HTML::Parser>. This means that
the document should be given to the parser by calling the $p->parse()
or $p->parse_file() methods.
=head1 EXAMPLES
The first example is a filter that will remove all comments from an
HTML file. This is achieved by simply overriding the comment method
to do nothing.
package CommentStripper;
require HTML::Filter;
@ISA=qw(HTML::Filter);
sub comment { } # ignore comments
The second example shows a filter that will remove any E<lt>TABLE>s
found in the HTML file. We specialize the start() and end() methods
to count table tags and then make output not happen when inside a
table.
package TableStripper;
require HTML::Filter;
@ISA=qw(HTML::Filter);
sub start
{
my $self = shift;
$self->{table_seen}++ if $_[0] eq "table";
$self->SUPER::start(@_);
}
sub end
{
my $self = shift;
$self->SUPER::end(@_);
$self->{table_seen}-- if $_[0] eq "table";
}
sub output
{
my $self = shift;
unless ($self->{table_seen}) {
$self->SUPER::output(@_);
}
}
If you want to collect the parsed text internally you might want to do
something like this:
package FilterIntoString;
require HTML::Filter;
@ISA=qw(HTML::Filter);
sub output { push(@{$_[0]->{fhtml}}, $_[1]) }
sub filtered_html { join("", @{$_[0]->{fhtml}}) }
=head1 SEE ALSO
L<HTML::Parser>
=head1 COPYRIGHT
Copyright 1997-1999 Gisle Aas.
This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
=cut
Parser.pm 100644 001750 001751 114770 15253600633 15740 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/lib/HTML package HTML::Parser;
use strict;
our $VERSION = '3.86';
require HTML::Entities;
require XSLoader;
XSLoader::load('HTML::Parser', $VERSION);
sub new
{
my $class = shift;
my $self = bless {}, $class;
return $self->init(@_);
}
sub init
{
my $self = shift;
$self->_alloc_pstate;
my %arg = @_;
my $api_version = delete $arg{api_version} || (@_ ? 3 : 2);
if ($api_version >= 4) {
require Carp;
Carp::croak("API version $api_version not supported " .
"by HTML::Parser $VERSION");
}
if ($api_version < 3) {
# Set up method callbacks compatible with HTML-Parser-2.xx
$self->handler(text => "text", "self,text,is_cdata");
$self->handler(end => "end", "self,tagname,text");
$self->handler(process => "process", "self,token0,text");
$self->handler(start => "start",
"self,tagname,attr,attrseq,text");
$self->handler(comment =>
sub {
my($self, $tokens) = @_;
for (@$tokens) {
$self->comment($_);
}
}, "self,tokens");
$self->handler(declaration =>
sub {
my $self = shift;
$self->declaration(substr($_[0], 2, -1));
}, "self,text");
}
if (my $h = delete $arg{handlers}) {
$h = {@$h} if ref($h) eq "ARRAY";
while (my($event, $cb) = each %$h) {
$self->handler($event => @$cb);
}
}
# In the end we try to assume plain attribute or handler
while (my($option, $val) = each %arg) {
if ($option =~ /^(\w+)_h$/) {
$self->handler($1 => @$val);
}
elsif ($option =~ /^(text|start|end|process|declaration|comment)$/) {
require Carp;
Carp::croak("Bad constructor option '$option'");
}
else {
$self->$option($val);
}
}
return $self;
}
sub parse_file
{
my($self, $file) = @_;
my $opened;
if (!ref($file) && ref(\$file) ne "GLOB") {
# Assume $file is a filename
local(*F);
open(F, "<", $file) || return undef;
binmode(F); # should we? good for byte counts
$opened++;
$file = *F;
}
my $chunk = '';
while (read($file, $chunk, 512)) {
$self->parse($chunk) || last;
}
close($file) if $opened;
$self->eof;
}
sub netscape_buggy_comment # legacy
{
my $self = shift;
require Carp;
Carp::carp("netscape_buggy_comment() is deprecated. " .
"Please use the strict_comment() method instead");
my $old = !$self->strict_comment;
$self->strict_comment(!shift) if @_;
return $old;
}
# set up method stubs
sub text { }
*start = \&text;
*end = \&text;
*comment = \&text;
*declaration = \&text;
*process = \&text;
1;
__END__
=head1 NAME
HTML::Parser - HTML parser class
=head1 SYNOPSIS
use strict;
use warnings;
use HTML::Parser ();
# Create parser object
my $p = HTML::Parser->new(
api_version => 3,
start_h => [\&start, "tagname, attr"],
end_h => [\&end, "tagname"],
marked_sections => 1,
);
# Parse document text chunk by chunk
$p->parse($chunk1);
$p->parse($chunk2);
# ...
# signal end of document
$p->eof;
# Parse directly from file
$p->parse_file("foo.html");
# or
open(my $fh, "<:utf8", "foo.html") || die;
$p->parse_file($fh);
=head1 DESCRIPTION
Objects of the C<HTML::Parser> class will recognize markup and
separate it from plain text (alias data content) in HTML
documents. As different kinds of markup and text are recognized, the
corresponding event handlers are invoked.
C<HTML::Parser> is not a generic SGML parser. We have tried to
make it able to deal with the HTML that is actually "out there", and
it normally parses as closely as possible to the way the popular web
browsers do it instead of strictly following one of the many HTML
specifications from W3C. Where there is disagreement, there is often
an option that you can enable to get the official behaviour.
The document to be parsed may be supplied in arbitrary chunks. This
makes on-the-fly parsing as documents are received from the network
possible.
If event driven parsing does not feel right for your application, you
might want to use C<HTML::PullParser>. This is an C<HTML::Parser>
subclass that allows a more conventional program structure.
=head1 METHODS
The following method is used to construct a new C<HTML::Parser> object:
=over
=item $p = HTML::Parser->new( %options_and_handlers )
This class method creates a new C<HTML::Parser> object and
returns it. Key/value argument pairs may be provided to assign event
handlers or initialize parser options. The handlers and parser
options can also be set or modified later by the method calls described below.
If a top level key is in the form "<event>_h" (e.g., "text_h") then it
assigns a handler to that event, otherwise it initializes a parser
option. The event handler specification value must be an array
reference. Multiple handlers may also be assigned with the 'handlers
=> [%handlers]' option. See examples below.
If new() is called without any arguments, it will create a parser that
uses callback methods compatible with version 2 of C<HTML::Parser>.
See the section on "version 2 compatibility" below for details.
The special constructor option 'api_version => 2' can be used to
initialize version 2 callbacks while still setting other options and
handlers. The 'api_version => 3' option can be used if you don't want
to set any options and don't want to fall back to v2 compatible
mode.
Examples:
$p = HTML::Parser->new(
api_version => 3,
text_h => [ sub {...}, "dtext" ]
);
This creates a new parser object with a text event handler subroutine
that receives the original text with general entities decoded.
$p = HTML::Parser->new(
api_version => 3,
start_h => [ 'my_start', "self,tokens" ]
);
This creates a new parser object with a start event handler method
that receives the $p and the tokens array.
$p = HTML::Parser->new(
api_version => 3,
handlers => {
text => [\@array, "event,text"],
comment => [\@array, "event,text"],
}
);
This creates a new parser object that stores the event type and the
original text in @array for text and comment events.
=back
The following methods feed the HTML document
to the C<HTML::Parser> object:
=over
=item $p->parse( $string )
Parse $string as the next chunk of the HTML document. Handlers invoked should
not attempt to modify the $string in-place until $p->parse returns.
If an invoked event handler aborts parsing by calling $p->eof, then $p->parse()
will return a FALSE value. Otherwise the return value is a reference to the
parser object ($p).
=item $p->parse( $code_ref )
If a code reference is passed as the argument to be parsed, then the
chunks to be parsed are obtained by invoking this function repeatedly.
Parsing continues until the function returns an empty (or undefined)
result. When this happens $p->eof is automatically signaled.
Parsing will also abort if one of the event handlers calls $p->eof.
The effect of this is the same as:
while (1) {
my $chunk = &$code_ref();
if (!defined($chunk) || !length($chunk)) {
$p->eof;
return $p;
}
$p->parse($chunk) || return undef;
}
But it is more efficient as this loop runs internally in XS code.
=item $p->parse_file( $file )
Parse text directly from a file. The $file argument can be a
filename, an open file handle, or a reference to an open file
handle.
If $file contains a filename and the file can't be opened, then the
method returns an undefined value and $! tells why it failed.
Otherwise the return value is a reference to the parser object.
If a file handle is passed as the $file argument, then the file will
normally be read until EOF, but not closed.
If an invoked event handler aborts parsing by calling $p->eof,
then $p->parse_file() may not have read the entire file.
On systems with multi-byte line terminators, the values passed for the
offset and length argspecs may be too low if parse_file() is called on
a file handle that is not in binary mode.
If a filename is passed in, then parse_file() will open the file in
binary mode.
=item $p->eof
Signals the end of the HTML document. Calling the $p->eof method
outside a handler callback will flush any remaining buffered text
(which triggers the C<text> event if there is any remaining text).
Calling $p->eof inside a handler will terminate parsing at that point
and cause $p->parse to return a FALSE value. This also terminates
parsing by $p->parse_file().
After $p->eof has been called, the parse() and parse_file() methods
can be invoked to feed new documents with the parser object.
The return value from eof() is a reference to the parser object.
=back
Most parser options are controlled by boolean attributes.
Each boolean attribute is enabled by calling the corresponding method
with a TRUE argument and disabled with a FALSE argument. The
attribute value is left unchanged if no argument is given. The return
value from each method is the old attribute value.
Methods that can be used to get and/or set parser options are:
=over
=item $p->attr_encoded
=item $p->attr_encoded( $bool )
By default, the C<attr> and C<@attr> argspecs will have general
entities for attribute values decoded. Enabling this attribute leaves
entities alone.
=item $p->backquote
=item $p->backquote( $bool )
By default, only ' and " are recognized as quote characters around
attribute values. MSIE also recognizes backquotes for some reason.
Enabling this attribute provides compatibility with this behaviour.
=item $p->boolean_attribute_value( $val )
This method sets the value reported for boolean attributes inside HTML
start tags. By default, the name of the attribute is also used as its
value. This affects the values reported for C<tokens> and C<attr>
argspecs.
=item $p->case_sensitive
=item $p->case_sensitive( $bool )
By default, tag names and attribute names are down-cased. Enabling this
attribute leaves them as found in the HTML source document.
=item $p->closing_plaintext
=item $p->closing_plaintext( $bool )
By default, C<plaintext> element can never be closed. Everything up to
the end of the document is parsed in CDATA mode. This historical
behaviour is what at least MSIE does. Enabling this attribute makes
closing C< </plaintext> > tag effective and the parsing process will resume
after seeing this tag. This emulates early gecko-based browsers.
=item $p->empty_element_tags
=item $p->empty_element_tags( $bool )
By default, empty element tags are not recognized as such and the "/"
before ">" is just treated like a normal name character (unless
C<strict_names> is enabled). Enabling this attribute make
C<HTML::Parser> recognize these tags.
Empty element tags look like start tags, but end with the character
sequence "/>" instead of ">". When recognized by C<HTML::Parser> they
cause an artificial end event in addition to the start event. The
C<text> for the artificial end event will be empty and the C<tokenpos>
array will be undefined even though the token array will have one
element containing the tag name.
=item $p->marked_sections
=item $p->marked_sections( $bool )
By default, section markings like <![CDATA[...]]> are treated like
ordinary text. When this attribute is enabled section markings are
honoured.
There are currently no events associated with the marked section
markup, but the text can be returned as C<skipped_text>.
=item $p->strict_comment
=item $p->strict_comment( $bool )
By default, comments are terminated by the first occurrence of "-->".
This is the behaviour of most popular browsers (like Mozilla, Opera and
MSIE), but it is not correct according to the official HTML
standard. Officially, you need an even number of "--" tokens before
the closing ">" is recognized and there may not be anything but
whitespace between an even and an odd "--".
The official behaviour is enabled by enabling this attribute.
Enabling of 'strict_comment' also disables recognizing these forms as
comments:
</ comment>
<! comment>
=item $p->strict_end
=item $p->strict_end( $bool )
By default, attributes and other junk are allowed to be present on end tags in a
manner that emulates MSIE's behaviour.
The official behaviour is enabled with this attribute. If enabled,
only whitespace is allowed between the tagname and the final ">".
=item $p->strict_names
=item $p->strict_names( $bool )
By default, almost anything is allowed in tag and attribute names.
This is the behaviour of most popular browsers and allows us to parse
some broken tags with invalid attribute values like:
<IMG SRC=newprevlstGr.gif ALT=[PREV LIST] BORDER=0>
By default, "LIST]" is parsed as a boolean attribute, not as
part of the ALT value as was clearly intended. This is also what
Mozilla sees.
The official behaviour is enabled by enabling this attribute. If
enabled, it will cause the tag above to be reported as text
since "LIST]" is not a legal attribute name.
=item $p->unbroken_text
=item $p->unbroken_text( $bool )
By default, blocks of text are given to the text handler as soon as
possible (but the parser takes care always to break text at a
boundary between whitespace and non-whitespace so single words and
entities can always be decoded safely). This might create breaks that
make it hard to do transformations on the text. When this attribute is
enabled, blocks of text are always reported in one piece. This will
delay the text event until the following (non-text) event has been
recognized by the parser.
Note that the C<offset> argspec will give you the offset of the first
segment of text and C<length> is the combined length of the segments.
Since there might be ignored tags in between, these numbers can't be
used to directly index in the original document file.
=item $p->utf8_mode
=item $p->utf8_mode( $bool )
Enable this option when parsing raw undecoded UTF-8. This tells the
parser that the entities expanded for strings reported by C<attr>,
C<@attr> and C<dtext> should be expanded as decoded UTF-8 so they end
up compatible with the surrounding text.
If C<utf8_mode> is enabled then it is an error to pass strings
containing characters with code above 255 to the parse() method, and
the parse() method will croak if you try.
Example: The Unicode character "\x{2665}" is "\xE2\x99\xA5" when UTF-8
encoded. The character can also be represented by the entity
"♥" or "♥". If we feed the parser:
$p->parse("\xE2\x99\xA5♥");
then C<dtext> will be reported as "\xE2\x99\xA5\x{2665}" without
C<utf8_mode> enabled, but as "\xE2\x99\xA5\xE2\x99\xA5" when enabled.
The later string is what you want.
=item $p->xml_mode
=item $p->xml_mode( $bool )
Enabling this attribute changes the parser to allow some XML
constructs. This enables the behaviour controlled by individually by
the C<case_sensitive>, C<empty_element_tags>, C<strict_names> and
C<xml_pic> attributes and also suppresses special treatment of
elements that are parsed as CDATA for HTML.
=item $p->xml_pic
=item $p->xml_pic( $bool )
By default, I<processing instructions> are terminated by ">". When
this attribute is enabled, processing instructions are terminated by
"?>" instead.
=back
As markup and text is recognized, handlers are invoked. The following
method is used to set up handlers for different events:
=over
=item $p->handler( event => \&subroutine, $argspec )
=item $p->handler( event => $method_name, $argspec )
=item $p->handler( event => \@accum, $argspec )
=item $p->handler( event => "" );
=item $p->handler( event => undef );
=item $p->handler( event );
This method assigns a subroutine, method, or array to handle an event.
Event is one of C<text>, C<start>, C<end>, C<declaration>, C<comment>,
C<process>, C<start_document>, C<end_document> or C<default>.
The C<\&subroutine> is a reference to a subroutine which is called to handle
the event.
The C<$method_name> is the name of a method of $p which is called to handle
the event.
The C<@accum> is an array that will hold the event information as
sub-arrays.
If the second argument is "", the event is ignored.
If it is undef, the default handler is invoked for the event.
The C<$argspec> is a string that describes the information to be reported
for the event. Any requested information that does not apply to a
specific event is passed as C<undef>. If argspec is omitted, then it
is left unchanged.
The return value from $p->handler is the old callback routine or a
reference to the accumulator array.
Any return values from handler callback routines/methods are always
ignored. A handler callback can request parsing to be aborted by
invoking the $p->eof method. A handler callback is not allowed to
invoke the $p->parse() or $p->parse_file() method. An exception will
be raised if it tries.
Examples:
$p->handler(start => "start", 'self, attr, attrseq, text' );
This causes the "start" method of object C<$p> to be called for 'start' events.
The callback signature is C<< $p->start(\%attr, \@attr_seq, $text) >>.
$p->handler(start => \&start, 'attr, attrseq, text' );
This causes subroutine start() to be called for 'start' events.
The callback signature is start(\%attr, \@attr_seq, $text).
$p->handler(start => \@accum, '"S", attr, attrseq, text' );
This causes 'start' event information to be saved in @accum.
The array elements will be ['S', \%attr, \@attr_seq, $text].
$p->handler(start => "");
This causes 'start' events to be ignored. It also suppresses
invocations of any default handler for start events. It is in most
cases equivalent to $p->handler(start => sub {}), but is more
efficient. It is different from the empty-sub-handler in that
C<skipped_text> is not reset by it.
$p->handler(start => undef);
This causes no handler to be associated with start events.
If there is a default handler it will be invoked.
=back
Filters based on tags can be set up to limit the number of events
reported. The main bottleneck during parsing is often the huge number
of callbacks made from the parser. Applying filters can improve
performance significantly.
The following methods control filters:
=over
=item $p->ignore_elements( @tags )
Both the C<start> event and the C<end> event as well as any events that
would be reported in between are suppressed. The ignored elements can
contain nested occurrences of itself. Example:
$p->ignore_elements(qw(script style));
The C<script> and C<style> tags will always nest properly since their
content is parsed in CDATA mode. For most other tags
C<ignore_elements> must be used with caution since HTML is often not
I<well formed>.
=item $p->ignore_tags( @tags )
Any C<start> and C<end> events involving any of the tags given are
suppressed. To reset the filter (i.e. don't suppress any C<start> and
C<end> events), call C<ignore_tags> without an argument.
=item $p->report_tags( @tags )
Any C<start> and C<end> events involving any of the tags I<not> given
are suppressed. To reset the filter (i.e. report all C<start> and
C<end> events), call C<report_tags> without an argument.
=back
Internally, the system has two filter lists, one for C<report_tags>
and one for C<ignore_tags>, and both filters are applied. This
effectively gives C<ignore_tags> precedence over C<report_tags>.
Examples:
$p->ignore_tags(qw(style));
$p->report_tags(qw(script style));
results in only C<script> events being reported.
=head2 Argspec
Argspec is a string containing a comma-separated list that describes
the information reported by the event. The following argspec
identifier names can be used:
=over
=item C<attr>
Attr causes a reference to a hash of attribute name/value pairs to be
passed.
Boolean attributes' values are either the value set by
$p->boolean_attribute_value, or the attribute name if no value has been
set by $p->boolean_attribute_value.
This passes undef except for C<start> events.
Unless C<xml_mode> or C<case_sensitive> is enabled, the attribute
names are forced to lower case.
General entities are decoded in the attribute values and
one layer of matching quotes enclosing the attribute values is removed.
The Unicode character set is assumed for entity decoding.
=item C<@attr>
Basically the same as C<attr>, but keys and values are passed as
individual arguments and the original sequence of the attributes is
kept. The parameters passed will be the same as the @attr calculated
here:
@attr = map { $_ => $attr->{$_} } @$attrseq;
assuming $attr and $attrseq here are the hash and array passed as the
result of C<attr> and C<attrseq> argspecs.
This passes no values for events besides C<start>.
=item C<attrseq>
Attrseq causes a reference to an array of attribute names to be
passed. This can be useful if you want to walk the C<attr> hash in
the original sequence.
This passes undef except for C<start> events.
Unless C<xml_mode> or C<case_sensitive> is enabled, the attribute
names are forced to lower case.
=item C<column>
Column causes the column number of the start of the event to be passed.
The first column on a line is 0.
=item C<dtext>
Dtext causes the decoded text to be passed. General entities are
automatically decoded unless the event was inside a CDATA section or
was between literal start and end tags (C<script>, C<style>,
C<xmp>, C<iframe>, C<title>, C<textarea> and C<plaintext>).
The Unicode character set is assumed for entity decoding.
This passes undef except for C<text> events.
=item C<event>
Event causes the event name to be passed.
The event name is one of C<text>, C<start>, C<end>, C<declaration>,
C<comment>, C<process>, C<start_document> or C<end_document>.
=item C<is_cdata>
Is_cdata causes a TRUE value to be passed if the event is inside a CDATA
section or between literal start and end tags (C<script>,
C<style>, C<xmp>, C<iframe>, C<title>, C<textarea> and C<plaintext>).
if the flag is FALSE for a text event, then you should normally
either use C<dtext> or decode the entities yourself before the text is
processed further.
=item C<length>
Length causes the number of bytes of the source text of the event to
be passed.
=item C<line>
Line causes the line number of the start of the event to be passed.
The first line in the document is 1. Line counting doesn't start
until at least one handler requests this value to be reported.
=item C<offset>
Offset causes the byte position in the HTML document of the start of
the event to be passed. The first byte in the document has offset 0.
=item C<offset_end>
Offset_end causes the byte position in the HTML document of the end of
the event to be passed. This is the same as C<offset> + C<length>.
=item C<self>
Self causes the current object to be passed to the handler. If the
handler is a method, this must be the first element in the argspec.
An alternative to passing self as an argspec is to register closures
that capture $self by themselves as handlers. Unfortunately this
creates circular references which prevent the HTML::Parser object
from being garbage collected. Using the C<self> argspec avoids this
problem.
=item C<skipped_text>
Skipped_text returns the concatenated text of all the events that have
been skipped since the last time an event was reported. Events might
be skipped because no handler is registered for them or because some
filter applies. Skipped text also includes marked section markup,
since there are no events that can catch it.
If an C<"">-handler is registered for an event, then the text for this
event is not included in C<skipped_text>. Skipped text both before
and after the C<"">-event is included in the next reported
C<skipped_text>.
=item C<tag>
Same as C<tagname>, but prefixed with "/" if it belongs to an C<end>
event and "!" for a declaration. The C<tag> does not have any prefix
for C<start> events, and is in this case identical to C<tagname>.
=item C<tagname>
This is the element name (or I<generic identifier> in SGML jargon) for
start and end tags. Since HTML is case insensitive, this name is
forced to lower case to ease string matching.
Since XML is case sensitive, the tagname case is not changed when
C<xml_mode> is enabled. The same happens if the C<case_sensitive> attribute
is set.
The declaration type of declaration elements is also passed as a tagname,
even if that is a bit strange.
In fact, in the current implementation tagname is
identical to C<token0> except that the name may be forced to lower case.
=item C<token0>
Token0 causes the original text of the first token string to be
passed. This should always be the same as $tokens->[0].
For C<declaration> events, this is the declaration type.
For C<start> and C<end> events, this is the tag name.
For C<process> and non-strict C<comment> events, this is everything
inside the tag.
This passes undef if there are no tokens in the event.
=item C<tokenpos>
Tokenpos causes a reference to an array of token positions to be
passed. For each string that appears in C<tokens>, this array
contains two numbers. The first number is the offset of the start of
the token in the original C<text> and the second number is the length
of the token.
Boolean attributes in a C<start> event will have (0,0) for the
attribute value offset and length.
This passes undef if there are no tokens in the event (e.g., C<text>)
and for artificial C<end> events triggered by empty element tags.
If you are using these offsets and lengths to modify C<text>, you
should either work from right to left, or be very careful to calculate
the changes to the offsets.
=item C<tokens>
Tokens causes a reference to an array of token strings to be passed.
The strings are exactly as they were found in the original text,
no decoding or case changes are applied.
For C<declaration> events, the array contains each word, comment, and
delimited string starting with the declaration type.
For C<comment> events, this contains each sub-comment. If
$p->strict_comments is disabled, there will be only one sub-comment.
For C<start> events, this contains the original tag name followed by
the attribute name/value pairs. The values of boolean attributes will
be either the value set by $p->boolean_attribute_value, or the
attribute name if no value has been set by
$p->boolean_attribute_value.
For C<end> events, this contains the original tag name (always one token).
For C<process> events, this contains the process instructions (always one
token).
This passes C<undef> for C<text> events.
=item C<text>
Text causes the source text (including markup element delimiters) to be
passed.
=item C<undef>
Pass an undefined value. Useful as padding where the same handler
routine is registered for multiple events.
=item C<'...'>
A literal string of 0 to 255 characters enclosed
in single (') or double (") quotes is passed as entered.
=back
The whole argspec string can be wrapped up in C<'@{...}'> to signal
that the resulting event array should be flattened. This only makes a
difference if an array reference is used as the handler target.
Consider this example:
$p->handler(text => [], 'text');
$p->handler(text => [], '@{text}']);
With two text events; C<"foo">, C<"bar">; then the first example will end
up with [["foo"], ["bar"]] and the second with ["foo", "bar"] in
the handler target array.
=head2 Events
Handlers for the following events can be registered:
=over
=item C<comment>
This event is triggered when a markup comment is recognized.
Example:
<!-- This is a comment -- -- So is this -->
=item C<declaration>
This event is triggered when a I<markup declaration> is recognized.
For typical HTML documents, the only declaration you are
likely to find is <!DOCTYPE ...>.
Example:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
DTDs inside <!DOCTYPE ...> will confuse HTML::Parser.
=item C<default>
This event is triggered for events that do not have a specific
handler. You can set up a handler for this event to catch stuff you
did not want to catch explicitly.
=item C<end>
This event is triggered when an end tag is recognized.
Example:
</A>
=item C<end_document>
This event is triggered when $p->eof is called and after any remaining
text is flushed. There is no document text associated with this event.
=item C<process>
This event is triggered when a processing instructions markup is
recognized.
The format and content of processing instructions are system and
application dependent.
Examples:
<? HTML processing instructions >
<? XML processing instructions ?>
=item C<start>
This event is triggered when a start tag is recognized.
Example:
<A HREF="http://www.perl.com/">
=item C<start_document>
This event is triggered before any other events for a new document. A
handler for it can be used to initialize stuff. There is no document
text associated with this event.
=item C<text>
This event is triggered when plain text (characters) is recognized.
The text may contain multiple lines. A sequence of text may be broken
between several text events unless $p->unbroken_text is enabled.
The parser will make sure that it does not break a word or a sequence
of whitespace between two text events.
=back
=head2 Unicode
If Unicode is passed to $p->parse() then chunks
of Unicode will be reported to the handlers. The offset and length
argspecs will also report their position in terms of characters.
It is safe to parse raw undecoded UTF-8 if you either avoid decoding
entities and make sure to not use I<argspecs> that do, or enable the
C<utf8_mode> for the parser. Parsing of undecoded UTF-8 might be
useful when parsing from a file where you need the reported offsets
and lengths to match the byte offsets in the file.
If a filename is passed to $p->parse_file() then the file will be read
in binary mode. This will be fine if the file contains only ASCII or
Latin-1 characters. If the file contains UTF-8 encoded text then care
must be taken when decoding entities as described in the previous
paragraph, but better is to open the file with the UTF-8 layer so that
it is decoded properly:
open(my $fh, "<:utf8", "index.html") || die "...: $!";
$p->parse_file($fh);
If the file contains text encoded in a charset besides ASCII, Latin-1
or UTF-8 then decoding will always be needed.
=head1 VERSION 2 COMPATIBILITY
When an C<HTML::Parser> object is constructed with no arguments, a set
of handlers is automatically provided that is compatible with the old
HTML::Parser version 2 callback methods.
This is equivalent to the following method calls:
$p->handler(start => "start", "self, tagname, attr, attrseq, text");
$p->handler(end => "end", "self, tagname, text");
$p->handler(text => "text", "self, text, is_cdata");
$p->handler(process => "process", "self, token0, text");
$p->handler(
comment => sub {
my ($self, $tokens) = @_;
for (@$tokens) { $self->comment($_); }
},
"self, tokens"
);
$p->handler(
declaration => sub {
my $self = shift;
$self->declaration(substr($_[0], 2, -1));
},
"self, text"
);
Setting up these handlers can also be requested with the "api_version =>
2" constructor option.
=head1 SUBCLASSING
The C<HTML::Parser> class is able to be subclassed. Parser objects are plain
hashes and C<HTML::Parser> reserves only hash keys that start with
"_hparser". The parser state can be set up by invoking the init()
method, which takes the same arguments as new().
=head1 EXAMPLES
The first simple example shows how you might strip out comments from
an HTML document. We achieve this by setting up a comment handler that
does nothing and a default handler that will print out anything else:
use HTML::Parser ();
HTML::Parser->new(
default_h => [sub { print shift }, 'text'],
comment_h => [""],
)->parse_file(shift || die)
|| die $!;
An alternative implementation is:
use HTML::Parser ();
HTML::Parser->new(
end_document_h => [sub { print shift }, 'skipped_text'],
comment_h => [""],
)->parse_file(shift || die)
|| die $!;
This will in most cases be much more efficient since only a single
callback will be made.
The next example prints out the text that is inside the <title>
element of an HTML document. Here we start by setting up a start
handler. When it sees the title start tag it enables a text handler
that prints any text found and an end handler that will terminate
parsing as soon as the title end tag is seen:
use HTML::Parser ();
sub start_handler {
return if shift ne "title";
my $self = shift;
$self->handler(text => sub { print shift }, "dtext");
$self->handler(
end => sub {
shift->eof if shift eq "title";
},
"tagname,self"
);
}
my $p = HTML::Parser->new(api_version => 3);
$p->handler(start => \&start_handler, "tagname,self");
$p->parse_file(shift || die) || die $!;
print "\n";
More examples are found in the F<eg/> directory of the C<HTML-Parser>
distribution: the program C<hrefsub> shows how you can edit all links
found in a document; the program C<htextsub> shows how to edit the text only; the
program C<hstrip> shows how you can strip out certain tags/elements
and/or attributes; and the program C<htext> show how to obtain the
plain text, but not any script/style content.
You can browse the F<eg/> directory online from the I<[Browse]> link on
the http://search.cpan.org/~gaas/HTML-Parser/ page.
=head1 BUGS
The <style> and <script> sections do not end with the first "</", but
need the complete corresponding end tag. The standard behaviour is
not really practical.
When the I<strict_comment> option is enabled, we still recognize
comments where there is something other than whitespace between even
and odd "--" markers.
Once $p->boolean_attribute_value has been set, there is no way to
restore the default behaviour.
There is currently no way to get both quote characters
into the same literal argspec.
Empty tags, e.g. "<>" and "</>", are not recognized. SGML allows them
to repeat the previous start tag or close the previous start tag
respectively.
NET tags, e.g. "code/.../" are not recognized. This is SGML
shorthand for "<code>...</code>".
Incomplete start or end tags, e.g. "<tt<b>...</b</tt>" are not
recognized.
=head1 DIAGNOSTICS
The following messages may be produced by HTML::Parser. The notation
in this listing is the same as used in L<perldiag>:
=over
=item Not a reference to a hash
(F) The object blessed into or subclassed from HTML::Parser is not a
hash as required by the HTML::Parser methods.
=item Bad signature in parser state object at %p
(F) The _hparser_xs_state element does not refer to a valid state structure.
Something must have changed the internal value
stored in this hash element, or the memory has been overwritten.
=item _hparser_xs_state element is not a reference
(F) The _hparser_xs_state element has been destroyed.
=item Can't find '_hparser_xs_state' element in HTML::Parser hash
(F) The _hparser_xs_state element is missing from the parser hash.
It was either deleted, or not created when the object was created.
=item API version %s not supported by HTML::Parser %s
(F) The constructor option 'api_version' with an argument greater than
or equal to 4 is reserved for future extensions.
=item Bad constructor option '%s'
(F) An unknown constructor option key was passed to the new() or
init() methods.
=item Parse loop not allowed
(F) A handler invoked the parse() or parse_file() method.
This is not permitted.
=item marked sections not supported
(F) The $p->marked_sections() method was invoked in a HTML::Parser
module that was compiled without support for marked sections.
=item Unknown boolean attribute (%d)
(F) Something is wrong with the internal logic that set up aliases for
boolean attributes.
=item Only code or array references allowed as handler
(F) The second argument for $p->handler must be either a subroutine
reference, then name of a subroutine or method, or a reference to an
array.
=item No handler for %s events
(F) The first argument to $p->handler must be a valid event name; i.e. one
of "start", "end", "text", "process", "declaration" or "comment".
=item Unrecognized identifier %s in argspec
(F) The identifier is not a known argspec name.
Use one of the names mentioned in the argspec section above.
=item Literal string is longer than 255 chars in argspec
(F) The current implementation limits the length of literals in
an argspec to 255 characters. Make the literal shorter.
=item Backslash reserved for literal string in argspec
(F) The backslash character "\" is not allowed in argspec literals.
It is reserved to permit quoting inside a literal in a later version.
=item Unterminated literal string in argspec
(F) The terminating quote character for a literal was not found.
=item Bad argspec (%s)
(F) Only identifier names, literals, spaces and commas
are allowed in argspecs.
=item Missing comma separator in argspec
(F) Identifiers in an argspec must be separated with ",".
=item Parsing of undecoded UTF-8 will give garbage when decoding entities
(W) The first chunk parsed appears to contain undecoded UTF-8 and one
or more argspecs that decode entities are used for the callback
handlers.
The result of decoding will be a mix of encoded and decoded characters
for any entities that expand to characters with code above 127. This
is not a good thing.
The recommended solution is to apply Encode::decode_utf8() on the data before
feeding it to the $p->parse(). For $p->parse_file() pass a file that has been
opened in ":utf8" mode.
The alternative solution is to enable the C<utf8_mode> and not decode before
passing strings to $p->parse(). The parser can process raw undecoded UTF-8
sanely if the C<utf8_mode> is enabled, or if the C<attr>, C<@attr> or C<dtext>
argspecs are avoided.
=item Parsing string decoded with wrong endian selection
(W) The first character in the document is U+FFFE. This is not a
legal Unicode character but a byte swapped C<BOM>. The result of parsing
will likely be garbage.
=item Parsing of undecoded UTF-32
(W) The parser found the Unicode UTF-32 C<BOM> signature at the start
of the document. The result of parsing will likely be garbage.
=item Parsing of undecoded UTF-16
(W) The parser found the Unicode UTF-16 C<BOM> signature at the start of
the document. The result of parsing will likely be garbage.
=back
=head1 SEE ALSO
L<HTML::Entities>, L<HTML::PullParser>, L<HTML::TokeParser>, L<HTML::HeadParser>,
L<HTML::LinkExtor>, L<HTML::Form>
L<HTML::TreeBuilder> (part of the I<HTML-Tree> distribution)
L<http://www.w3.org/TR/html4/>
More information about marked sections and processing instructions may
be found at L<http://www.is-thought.co.uk/book/sgml-8.htm>.
=head1 COPYRIGHT
Copyright 1996-2016 Gisle Aas. All rights reserved.
Copyright 1999-2000 Michael A. Chase. All rights reserved.
This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
=cut
case-sensitive.t 100644 001750 001751 3245 15253600633 16140 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 8;
my $p = HTML::Parser->new();
$p->case_sensitive(1);
my $text = "";
$p->handler(
start => sub {
my ($tag, $attr, $attrseq) = @_;
$text .= "S[$tag";
for my $k (sort keys %$attr) {
my $v = $attr->{$k};
$text .= " $k=$v";
}
if (@$attrseq) { $text .= " Order:"; }
for my $k (@$attrseq) {
$text .= " $k";
}
$text .= "]";
},
"tagname,attr,attrseq"
);
$p->handler(
end => sub {
my ($tag) = @_;
$text .= "E[$tag]";
},
"tagname"
);
my $html = <<'EOT';
<tAg aRg="Value" arg="other value"></tAg>
EOT
my $cs = 'S[tAg aRg=Value arg=other value Order: aRg arg]E[tAg]';
my $ci = 'S[tag arg=Value Order: arg arg]E[tag]';
$p->parse($html)->eof;
is($text, $cs);
$text = "";
$p->case_sensitive(0);
$p->parse($html)->eof;
is($text, $ci);
$text = "";
$p->case_sensitive(1);
$p->xml_mode(1);
$p->parse($html)->eof;
is($text, $cs);
$text = "";
$p->case_sensitive(0);
$p->parse($html)->eof;
is($text, $cs);
$html = <<'EOT';
<tAg aRg="Value" arg="other value"></tAg>
<iGnOrE></ignore>
EOT
$p->ignore_tags('ignore');
$cs = 'S[tAg aRg=Value arg=other value Order: aRg arg]E[tAg]S[iGnOrE]';
$ci = 'S[tag arg=Value Order: arg arg]E[tag]';
$text = "";
$p->case_sensitive(0);
$p->xml_mode(0);
$p->parse($html)->eof;
is($text, $ci);
$text = "";
$p->case_sensitive(1);
$p->xml_mode(0);
$p->parse($html)->eof;
is($text, $cs);
$text = "";
$p->case_sensitive(0);
$p->xml_mode(1);
$p->parse($html)->eof;
is($text, $cs);
$text = "";
$p->case_sensitive(1);
$p->xml_mode(1);
$p->parse($html)->eof;
is($text, $cs);
filter-methods.t 100644 001750 001751 11101 15253600633 16152 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use utf8;
use HTML::Parser ();
use Test::More tests => 12;
my $p = HTML::Parser->new(api_version => 3, ignore_tags => [qw(b i em tt)],);
$p->ignore_elements("script");
$p->unbroken_text(1);
$p->handler(default => [], "event, text");
$p->parse(<<"EOT")->eof;
<html><head><title>foo</title><Script language="Perl">
while (<B>) {
# ...
}
</Script><body>
This is an <i>italic</i> and <b>bold</b> text.
</body>
</html>
EOT
my $t = join("||", map join("|", @$_), @{$p->handler("default")});
#diag $t;
is(
$t,
"start_document|||start|<html>||start|<head>||start|<title>||text|foo||end|</title>||start|<body>||text|
This is an italic and bold text.
||end|</body>||text|
||end|</html>||text|
||end_document|", 'ignore_elements'
);
#------------------------------------------------------
$p = HTML::Parser->new(api_version => 3);
$p->report_tags("a");
$p->handler(
start => sub {
my ($tagname, %attr) = @_;
ok($tagname eq "a" && $attr{href} eq "#a", 'report_tags start');
},
'tagname, @attr'
);
$p->handler(
end => sub {
my $tagname = shift;
is($tagname, "a", 'report_tags end');
},
'tagname'
);
$p->parse(<<EOT)->eof;
<h1>Next example</h1>
This is <a href="#a">very nice</a> example.
EOT
#------------------------------------------------------
my @tags;
$p = HTML::Parser->new(api_version => 3);
$p->report_tags(qw(a em));
$p->ignore_tags(qw(em));
$p->handler(end => sub { push @tags, @_; }, 'tagname');
$p->parse(<<EOT)->eof;
<h1>Next example</h1>
This is <em>yet another</em> <a href="#a">very nice</a> example.
EOT
is(join('|', @tags), 'a', 'report_tags followed by ignore_tags');
#------------------------------------------------------
@tags = ();
$p = HTML::Parser->new(api_version => 3);
$p->report_tags(qw(h1));
$p->report_tags();
$p->handler(end => sub { push @tags, @_; }, 'tagname');
$p->parse(<<EOT)->eof;
<h1>Next example</h1>
<h2>Next example</h2>
EOT
is(join('|', @tags), 'h1|h2', 'reset report_tags filter');
#------------------------------------------------------
@tags = ();
$p = HTML::Parser->new(api_version => 3);
$p->report_tags(qw(h1 h2));
$p->ignore_tags(qw(h2));
$p->report_tags(qw(h1 h2));
$p->handler(end => sub { push @tags, @_; }, 'tagname');
$p->parse(<<EOT)->eof;
<h1>Next example</h1>
<h2>Next example</h2>
EOT
is(join('|', @tags), 'h1', 'report_tags does not reset ignore_tags');
#------------------------------------------------------
@tags = ();
$p = HTML::Parser->new(api_version => 3);
$p->report_tags(qw(h1 h2));
$p->ignore_tags(qw(h2));
$p->report_tags();
$p->handler(end => sub { push @tags, @_; }, 'tagname');
$p->parse(<<EOT)->eof;
<h1>Next example</h1>
<h2>Next example</h2>
EOT
is(join('|', @tags), 'h1', 'reset report_tags does no reset ignore_tags');
#------------------------------------------------------
@tags = ();
$p = HTML::Parser->new(api_version => 3);
$p->report_tags(qw(h1 h2));
$p->report_tags(qw(h3));
$p->handler(end => sub { push @tags, @_; }, 'tagname');
$p->parse(<<EOT)->eof;
<h1>Next example</h1>
<h2>Next example</h2>
<h3>Next example</h3>
EOT
is(join('|', @tags), 'h3', 'report_tags replaces filter');
#------------------------------------------------------
@tags = ();
$p = HTML::Parser->new(api_version => 3);
$p->ignore_tags(qw(h1 h2));
$p->ignore_tags(qw(h3));
$p->handler(end => sub { push @tags, @_; }, 'tagname');
$p->parse(<<EOT)->eof;
<h1>Next example</h1>
<h2>Next example</h2>
<h3>Next example</h3>
EOT
is(join('|', @tags), 'h1|h2', 'ignore_tags replaces filter');
#------------------------------------------------------
@tags = ();
$p = HTML::Parser->new(api_version => 3);
$p->ignore_tags(qw(h2));
$p->ignore_tags();
$p->handler(end => sub { push @tags, @_; }, 'tagname');
$p->parse(<<EOT)->eof;
<h1>Next example</h1>
<h2>Next example</h2>
EOT
is(join('|', @tags), 'h1|h2', 'reset ignore_tags filter');
#------------------------------------------------------
@tags = ();
$p = HTML::Parser->new(api_version => 3);
$p->ignore_tags(qw(h2));
$p->report_tags(qw(h1 h2));
$p->handler(end => sub { push @tags, @_; }, 'tagname');
$p->parse(<<EOT)->eof;
<h1>Next example</h1>
<h2>Next example</h2>
EOT
is(join('|', @tags), 'h1', 'ignore_tags before report_tags');
#------------------------------------------------------
$p = HTML::Parser->new(api_version => 3);
$p->ignore_elements("script");
my $res = "";
$p->handler(default => sub { $res .= $_[0]; }, 'text');
$p->parse(<<'EOT')->eof;
A <script> B </script> C </script> D <script> E </script> F
EOT
is($res, "A C D F\n", "ignore </script> without <script> correctly");
linkextor-base.t 100644 001750 001751 1474 15253600633 16147 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::LinkExtor ();
use URI ();
use Test::More tests => 4;
# This test that HTML::LinkExtor really absolutize links correctly
# when a base URL is given to the constructor.
# Try with base URL and the $p->links interface.
my $p = HTML::LinkExtor->new(undef, "http://www.sn.no/foo/foo.html");
$p->parse(<<HTML)->eof;
<head>
<base href="http://www.sn.no/">
</head>
<body>
<form action="/post_here">
</form>
This is <A HREF="link.html">link</a> and an <img SRC="img.jpg"
alt="Image">.
HTML
my @links = $p->links;
# There should be 4 links in the document
is(@links, 4);
my $t;
my %attr;
for (@links) {
($t, %attr) = @$_ if $_->[0] eq 'img';
}
is($t, 'img');
is(delete $attr{src}, "http://www.sn.no/foo/img.jpg");
# there should be no more attributes
ok(!scalar(keys %attr));
headparser-http.t 100644 001750 001751 460 15253600633 16265 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::HeadParser ();
use Test::More tests => 1;
my $h;
my $p = HTML::HeadParser->new($h);
$p->parse(<<EOT);
<title>Stupid example</title>
<base href="http://www.sn.no/libwww-perl/">
Normal text starts here.
EOT
$h = $p->header;
undef $p;
is($h->title, "Stupid example");
Entities.pm 100644 001750 001751 36561 15253600633 16251 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/lib/HTML package HTML::Entities;
=encoding utf8
=head1 NAME
HTML::Entities - Encode or decode strings with HTML entities
=head1 SYNOPSIS
use HTML::Entities;
$a = "Våre norske tegn bør æres";
decode_entities($a);
encode_entities($a, "\200-\377");
For example, this:
$input = "vis-à-vis Beyoncé's naïve\npapier-mâché résumé";
print encode_entities($input), "\n"
Prints this out:
vis-à-vis Beyoncé's naïve
papier-mâché résumé
=head1 DESCRIPTION
This module deals with encoding and decoding of strings with HTML
character entities. The module provides the following functions:
=over 4
=item decode_entities( $string, ... )
This routine replaces HTML entities found in the $string with the
corresponding Unicode character. Unrecognized entities are left alone.
If multiple strings are provided as argument they are each decoded
separately and the same number of strings are returned.
If called in void context the arguments are decoded in-place.
This routine is exported by default.
=item _decode_entities( $string, \%entity2char )
=item _decode_entities( $string, \%entity2char, $expand_prefix )
This will in-place replace HTML entities in $string. The %entity2char
hash must be provided. Named entities not found in the %entity2char
hash are left alone. Numeric entities are expanded unless their value
overflow.
The keys in %entity2char are the entity names to be expanded and their
values are what they should expand into. The values do not have to be
single character strings. If a key has ";" as suffix,
then occurrences in $string are only expanded if properly terminated
with ";". Entities without ";" will be expanded regardless of how
they are terminated for compatibility with how common browsers treat
entities in the Latin-1 range.
If $expand_prefix is TRUE then entities without trailing ";" in
%entity2char will even be expanded as a prefix of a longer
unrecognized name. The longest matching name in %entity2char will be
used. This is mainly present for compatibility with an MSIE
misfeature.
$string = "foo bar";
_decode_entities($string, { nb => "@", nbsp => "\xA0" }, 1);
print $string; # will print "foo bar"
An entity whose value is the string being decoded expands to the value
that string had when the call began. This routine does not scan
replacement text again, so any entities inside it are left alone.
Looking up a value can run Perl code, through a tied hash or an
overloaded object. If that code modifies the string being decoded,
this routine dies.
This routine is exported by default.
=item encode_entities( $string )
=item encode_entities( $string, $unsafe_chars )
This routine replaces unsafe characters in $string with their entity
representation. A second argument can be given to specify which characters to
consider unsafe. The unsafe characters is specified using the regular
expression character class syntax (what you find within brackets in regular
expressions).
The default set of characters to encode are control chars, high-bit chars, and
the C<< < >>, C<< & >>, C<< > >>, C<< ' >> and C<< " >> characters. But this,
for example, would encode I<just> the C<< < >>, C<< & >>, C<< > >>, and C<< "
>> characters:
$encoded = encode_entities($input, '<>&"');
and this would only encode non-plain ASCII:
$encoded = encode_entities($input, '^\n\x20-\x25\x27-\x7e');
This routine is exported by default.
=item encode_entities_numeric( $string )
=item encode_entities_numeric( $string, $unsafe_chars )
This routine works just like encode_entities, except that the replacement
entities are always C<&#xI<hexnum>;> and never C<&I<entname>;>. For
example, C<encode_entities("r\xF4le")> returns "rôle", but
C<encode_entities_numeric("r\xF4le")> returns "rôle".
This routine is I<not> exported by default. But you can always
export it with C<use HTML::Entities qw(encode_entities_numeric);>
or even C<use HTML::Entities qw(:DEFAULT encode_entities_numeric);>
=back
All these routines modify the string passed as the first argument, if
called in a void context. In scalar and array contexts, the encoded or
decoded string is returned (without changing the input string).
If you prefer not to import these routines into your namespace, you can
call them as:
use HTML::Entities ();
$decoded = HTML::Entities::decode($a);
$encoded = HTML::Entities::encode($a);
$encoded = HTML::Entities::encode_numeric($a);
The module can also export the %char2entity and the %entity2char
hashes, which contain the mapping from all characters to the
corresponding entities (and vice versa, respectively).
=head1 COPYRIGHT
Copyright 1995-2006 Gisle Aas. All rights reserved.
This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
=cut
use strict;
our $VERSION = '3.86';
our (%entity2char, %char2entity);
require 5.008;
require Exporter;
our @ISA = qw(Exporter);
our @EXPORT = qw(encode_entities decode_entities _decode_entities);
our @EXPORT_OK = qw(%entity2char %char2entity encode_entities_numeric);
sub Version { $VERSION; }
require HTML::Parser; # for fast XS implemented decode_entities
%entity2char = (
# Some normal chars that have special meaning in SGML context
amp => '&', # ampersand
'gt' => '>', # greater than
'lt' => '<', # less than
quot => '"', # double quote
apos => "'", # single quote
# PUBLIC ISO 8879-1986//ENTITIES Added Latin 1//EN//HTML
AElig => chr(198), # capital AE diphthong (ligature)
Aacute => chr(193), # capital A, acute accent
Acirc => chr(194), # capital A, circumflex accent
Agrave => chr(192), # capital A, grave accent
Aring => chr(197), # capital A, ring
Atilde => chr(195), # capital A, tilde
Auml => chr(196), # capital A, dieresis or umlaut mark
Ccedil => chr(199), # capital C, cedilla
ETH => chr(208), # capital Eth, Icelandic
Eacute => chr(201), # capital E, acute accent
Ecirc => chr(202), # capital E, circumflex accent
Egrave => chr(200), # capital E, grave accent
Euml => chr(203), # capital E, dieresis or umlaut mark
Iacute => chr(205), # capital I, acute accent
Icirc => chr(206), # capital I, circumflex accent
Igrave => chr(204), # capital I, grave accent
Iuml => chr(207), # capital I, dieresis or umlaut mark
Ntilde => chr(209), # capital N, tilde
Oacute => chr(211), # capital O, acute accent
Ocirc => chr(212), # capital O, circumflex accent
Ograve => chr(210), # capital O, grave accent
Oslash => chr(216), # capital O, slash
Otilde => chr(213), # capital O, tilde
Ouml => chr(214), # capital O, dieresis or umlaut mark
THORN => chr(222), # capital THORN, Icelandic
Uacute => chr(218), # capital U, acute accent
Ucirc => chr(219), # capital U, circumflex accent
Ugrave => chr(217), # capital U, grave accent
Uuml => chr(220), # capital U, dieresis or umlaut mark
Yacute => chr(221), # capital Y, acute accent
aacute => chr(225), # small a, acute accent
acirc => chr(226), # small a, circumflex accent
aelig => chr(230), # small ae diphthong (ligature)
agrave => chr(224), # small a, grave accent
aring => chr(229), # small a, ring
atilde => chr(227), # small a, tilde
auml => chr(228), # small a, dieresis or umlaut mark
ccedil => chr(231), # small c, cedilla
eacute => chr(233), # small e, acute accent
ecirc => chr(234), # small e, circumflex accent
egrave => chr(232), # small e, grave accent
eth => chr(240), # small eth, Icelandic
euml => chr(235), # small e, dieresis or umlaut mark
iacute => chr(237), # small i, acute accent
icirc => chr(238), # small i, circumflex accent
igrave => chr(236), # small i, grave accent
iuml => chr(239), # small i, dieresis or umlaut mark
ntilde => chr(241), # small n, tilde
oacute => chr(243), # small o, acute accent
ocirc => chr(244), # small o, circumflex accent
ograve => chr(242), # small o, grave accent
oslash => chr(248), # small o, slash
otilde => chr(245), # small o, tilde
ouml => chr(246), # small o, dieresis or umlaut mark
szlig => chr(223), # small sharp s, German (sz ligature)
thorn => chr(254), # small thorn, Icelandic
uacute => chr(250), # small u, acute accent
ucirc => chr(251), # small u, circumflex accent
ugrave => chr(249), # small u, grave accent
uuml => chr(252), # small u, dieresis or umlaut mark
yacute => chr(253), # small y, acute accent
yuml => chr(255), # small y, dieresis or umlaut mark
# Some extra Latin 1 chars that are listed in the HTML3.2 draft (21-May-96)
copy => chr(169), # copyright sign
reg => chr(174), # registered sign
nbsp => chr(160), # non breaking space
# Additional ISO-8859/1 entities listed in rfc1866 (section 14)
iexcl => chr(161),
cent => chr(162),
pound => chr(163),
curren => chr(164),
yen => chr(165),
brvbar => chr(166),
sect => chr(167),
uml => chr(168),
ordf => chr(170),
laquo => chr(171),
'not' => chr(172), # not is a keyword in perl
shy => chr(173),
macr => chr(175),
deg => chr(176),
plusmn => chr(177),
sup1 => chr(185),
sup2 => chr(178),
sup3 => chr(179),
acute => chr(180),
micro => chr(181),
para => chr(182),
middot => chr(183),
cedil => chr(184),
ordm => chr(186),
raquo => chr(187),
frac14 => chr(188),
frac12 => chr(189),
frac34 => chr(190),
iquest => chr(191),
'times' => chr(215), # times is a keyword in perl
divide => chr(247),
'OElig;' => chr(338),
'oelig;' => chr(339),
'Scaron;' => chr(352),
'scaron;' => chr(353),
'Yuml;' => chr(376),
'fnof;' => chr(402),
'circ;' => chr(710),
'tilde;' => chr(732),
'Alpha;' => chr(913),
'Beta;' => chr(914),
'Gamma;' => chr(915),
'Delta;' => chr(916),
'Epsilon;' => chr(917),
'Zeta;' => chr(918),
'Eta;' => chr(919),
'Theta;' => chr(920),
'Iota;' => chr(921),
'Kappa;' => chr(922),
'Lambda;' => chr(923),
'Mu;' => chr(924),
'Nu;' => chr(925),
'Xi;' => chr(926),
'Omicron;' => chr(927),
'Pi;' => chr(928),
'Rho;' => chr(929),
'Sigma;' => chr(931),
'Tau;' => chr(932),
'Upsilon;' => chr(933),
'Phi;' => chr(934),
'Chi;' => chr(935),
'Psi;' => chr(936),
'Omega;' => chr(937),
'alpha;' => chr(945),
'beta;' => chr(946),
'gamma;' => chr(947),
'delta;' => chr(948),
'epsilon;' => chr(949),
'zeta;' => chr(950),
'eta;' => chr(951),
'theta;' => chr(952),
'iota;' => chr(953),
'kappa;' => chr(954),
'lambda;' => chr(955),
'mu;' => chr(956),
'nu;' => chr(957),
'xi;' => chr(958),
'omicron;' => chr(959),
'pi;' => chr(960),
'rho;' => chr(961),
'sigmaf;' => chr(962),
'sigma;' => chr(963),
'tau;' => chr(964),
'upsilon;' => chr(965),
'phi;' => chr(966),
'chi;' => chr(967),
'psi;' => chr(968),
'omega;' => chr(969),
'thetasym;' => chr(977),
'upsih;' => chr(978),
'piv;' => chr(982),
'ensp;' => chr(8194),
'emsp;' => chr(8195),
'thinsp;' => chr(8201),
'zwnj;' => chr(8204),
'zwj;' => chr(8205),
'lrm;' => chr(8206),
'rlm;' => chr(8207),
'ndash;' => chr(8211),
'mdash;' => chr(8212),
'lsquo;' => chr(8216),
'rsquo;' => chr(8217),
'sbquo;' => chr(8218),
'ldquo;' => chr(8220),
'rdquo;' => chr(8221),
'bdquo;' => chr(8222),
'dagger;' => chr(8224),
'Dagger;' => chr(8225),
'bull;' => chr(8226),
'hellip;' => chr(8230),
'permil;' => chr(8240),
'prime;' => chr(8242),
'Prime;' => chr(8243),
'lsaquo;' => chr(8249),
'rsaquo;' => chr(8250),
'oline;' => chr(8254),
'frasl;' => chr(8260),
'euro;' => chr(8364),
'image;' => chr(8465),
'weierp;' => chr(8472),
'real;' => chr(8476),
'trade;' => chr(8482),
'alefsym;' => chr(8501),
'larr;' => chr(8592),
'uarr;' => chr(8593),
'rarr;' => chr(8594),
'darr;' => chr(8595),
'harr;' => chr(8596),
'crarr;' => chr(8629),
'lArr;' => chr(8656),
'uArr;' => chr(8657),
'rArr;' => chr(8658),
'dArr;' => chr(8659),
'hArr;' => chr(8660),
'forall;' => chr(8704),
'part;' => chr(8706),
'exist;' => chr(8707),
'empty;' => chr(8709),
'nabla;' => chr(8711),
'isin;' => chr(8712),
'notin;' => chr(8713),
'ni;' => chr(8715),
'prod;' => chr(8719),
'sum;' => chr(8721),
'minus;' => chr(8722),
'lowast;' => chr(8727),
'radic;' => chr(8730),
'prop;' => chr(8733),
'infin;' => chr(8734),
'ang;' => chr(8736),
'and;' => chr(8743),
'or;' => chr(8744),
'cap;' => chr(8745),
'cup;' => chr(8746),
'int;' => chr(8747),
'there4;' => chr(8756),
'sim;' => chr(8764),
'cong;' => chr(8773),
'asymp;' => chr(8776),
'ne;' => chr(8800),
'equiv;' => chr(8801),
'le;' => chr(8804),
'ge;' => chr(8805),
'sub;' => chr(8834),
'sup;' => chr(8835),
'nsub;' => chr(8836),
'sube;' => chr(8838),
'supe;' => chr(8839),
'oplus;' => chr(8853),
'otimes;' => chr(8855),
'perp;' => chr(8869),
'sdot;' => chr(8901),
'lceil;' => chr(8968),
'rceil;' => chr(8969),
'lfloor;' => chr(8970),
'rfloor;' => chr(8971),
'lang;' => chr(9001),
'rang;' => chr(9002),
'loz;' => chr(9674),
'spades;' => chr(9824),
'clubs;' => chr(9827),
'hearts;' => chr(9829),
'diams;' => chr(9830),
);
# Make the opposite mapping
while (my($entity, $char) = each(%entity2char)) {
$entity =~ s/;\z//;
$char2entity{$char} = "&$entity;";
}
delete $char2entity{"'"}; # only one-way decoding
# Fill in missing entities
for (0 .. 255) {
next if exists $char2entity{chr($_)};
$char2entity{chr($_)} = "&#$_;";
}
my %subst; # compiled encoding regexps
sub encode_entities
{
return undef unless defined $_[0];
my $ref;
if (defined wantarray) {
my $x = $_[0];
$ref = \$x; # copy
} else {
$ref = \$_[0]; # modify in-place
}
my $regex;
if (defined $_[1] and length $_[1]) {
$regex = $subst{$_[1]};
unless (defined $regex) {
my $chars = $_[1];
# keep existing escapes, but also escape any unescaped special character:
# [ (technically unnecessary but included for symmetry with ])
# ] (end of character class)
# \ (escape character)
$chars =~ s{
# capture group 1: things to skip and keep
(
# any escaped character
\\.
|
# either an actual POSIX character class or anything
# similar enough to trigger a regex syntax error
\[: \^? [[:lower:][:digit:]]{3,} :\]
)
|
# capture group 2: things to be escaped
(
[\[\]\\]
)
}{
defined $1 ? $1 : '\\' . $2
}xseg;
$regex = eval { qr/([$chars])/ };
die( $@ . " while trying to turn range: \"$_[1]\"\n "
. "into code: /([$chars])/\n "
) if $@;
$subst{$_[1]} = $regex;
}
} else {
# Encode control chars, high bit chars and '<', '&', '>', ''' and '"'
$regex = qr/([^\n\r\t !\#\$%\(-;=?-~])/;
}
$$ref =~ s/$regex/$char2entity{$1} || num_entity($1)/eg;
$$ref;
}
sub encode_entities_numeric {
local %char2entity;
return &encode_entities; # a goto &encode_entities wouldn't work
}
sub num_entity {
sprintf "&#x%X;", ord($_[0]);
}
# Set up aliases
*encode = \&encode_entities;
*encode_numeric = \&encode_entities_numeric;
*encode_numerically = \&encode_entities_numeric;
*decode = \&decode_entities;
1;
LinkExtor.pm 100644 001750 001751 10630 15253600633 16371 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/lib/HTML package HTML::LinkExtor;
require HTML::Parser;
our @ISA = qw(HTML::Parser);
our $VERSION = '3.86';
=head1 NAME
HTML::LinkExtor - Extract links from an HTML document
=head1 SYNOPSIS
require HTML::LinkExtor;
$p = HTML::LinkExtor->new(\&cb, "http://www.perl.org/");
sub cb {
my($tag, %links) = @_;
print "$tag @{[%links]}\n";
}
$p->parse_file("index.html");
=head1 DESCRIPTION
I<HTML::LinkExtor> is an HTML parser that extracts links from an
HTML document. The I<HTML::LinkExtor> is a subclass of
I<HTML::Parser>. This means that the document should be given to the
parser by calling the $p->parse() or $p->parse_file() methods.
=cut
use strict;
use HTML::Tagset ();
# legacy (some applications grabs this hash directly)
our %LINK_ELEMENT;
*LINK_ELEMENT = \%HTML::Tagset::linkElements;
=over 4
=item $p = HTML::LinkExtor->new
=item $p = HTML::LinkExtor->new( $callback )
=item $p = HTML::LinkExtor->new( $callback, $base )
The constructor takes two optional arguments. The first is a reference
to a callback routine. It will be called as links are found. If a
callback is not provided, then links are just accumulated internally
and can be retrieved by calling the $p->links() method.
The $base argument is an optional base URL used to absolutize all URLs found.
You need to have the I<URI> module installed if you provide $base.
The callback is called with the lowercase tag name as first argument,
and then all link attributes as separate key/value pairs. All
non-link attributes are removed.
=cut
sub new
{
my($class, $cb, $base) = @_;
my $self = $class->SUPER::new(
start_h => ["_start_tag", "self,tagname,attr"],
report_tags => [keys %HTML::Tagset::linkElements],
);
$self->{extractlink_cb} = $cb;
if ($base) {
require URI;
$self->{extractlink_base} = URI->new($base);
}
$self;
}
sub _start_tag
{
my($self, $tag, $attr) = @_;
my $base = $self->{extractlink_base};
my $links = $HTML::Tagset::linkElements{$tag};
$links = [$links] unless ref $links;
my @links;
my $a;
for $a (@$links) {
next unless exists $attr->{$a};
(my $link = $attr->{$a}) =~ s/^\s+//; $link =~ s/\s+$//; # HTML5
push(@links, $a, $base ? URI->new($link, $base)->abs($base) : $link);
}
return unless @links;
$self->_found_link($tag, @links);
}
sub _found_link
{
my $self = shift;
my $cb = $self->{extractlink_cb};
if ($cb) {
&$cb(@_);
} else {
push(@{$self->{'links'}}, [@_]);
}
}
=item $p->links
Returns a list of all links found in the document. The returned
values will be anonymous arrays with the following elements:
[$tag, $attr => $url1, $attr2 => $url2,...]
The $p->links method will also truncate the internal link list. This
means that if the method is called twice without any parsing
between them the second call will return an empty list.
Also note that $p->links will always be empty if a callback routine
was provided when the I<HTML::LinkExtor> was created.
=cut
sub links
{
my $self = shift;
exists($self->{'links'}) ? @{delete $self->{'links'}} : ();
}
# We override the parse_file() method so that we can clear the links
# before we start a new file.
sub parse_file
{
my $self = shift;
delete $self->{'links'};
$self->SUPER::parse_file(@_);
}
=back
=head1 EXAMPLE
This is an example showing how you can extract links from a document
received using LWP:
use LWP::UserAgent;
use HTML::LinkExtor;
use URI::URL;
$url = "http://www.perl.org/"; # for instance
$ua = LWP::UserAgent->new;
# Set up a callback that collect image links
my @imgs = ();
sub callback {
my($tag, %attr) = @_;
return if $tag ne 'img'; # we only look closer at <img ...>
push(@imgs, values %attr);
}
# Make the parser. Unfortunately, we don't know the base yet
# (it might be different from $url)
$p = HTML::LinkExtor->new(\&callback);
# Request document and parse it as it arrives
$res = $ua->request(HTTP::Request->new(GET => $url),
sub {$p->parse($_[0])});
# Expand all image URLs to absolute ones
my $base = $res->base;
@imgs = map { $_ = url($_, $base)->abs; } @imgs;
# Print them out
print join("\n", @imgs), "\n";
=head1 SEE ALSO
L<HTML::Parser>, L<HTML::Tagset>, L<LWP>, L<URI::URL>
=head1 COPYRIGHT
Copyright 1996-2001 Gisle Aas.
This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
=cut
1;
stack-realloc-eof.t 100644 001750 001751 33602 15253600633 16531 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 2;
# HTML-Parser core dumps on this because
# of missing SPAGAIN calls in parse() XS code. It was not prepared for
# the stack to get realloced.
my $em = <<'EOF';
<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /></head><body style='font-size: 10pt; font-family: Verdana,Geneva,sans-serif'>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
<p><span style="font-size: 10.0pt; font-family: 'Verdana','sans-serif';">cat</span></p>
</body></html>
EOF
sub handle_doc_end {
my ($self) = @_;
# We need to construct a large list and then splice it in array context, this will
# cause splice to regrow the stack and mess up the stack pointer in Parser.xs's eof
my @list;
for (1..150) {
push @list, 1; # { $_ => 1 };
}
# ok(1, 'splicing');
foreach my $i (splice(@list)) { }
# ok(1, 'done splicing');
}
sub extract {
my $markup = shift;
my $parser = HTML::Parser->new(
api_version => 3,
handlers => {
end_document => [\&handle_doc_end => 'self']
},
);
$parser->empty_element_tags(1);
$parser->parse($markup);
$parser->eof();
return 1;
}
ok(extract($em), 'first call okay');
ok(extract($em), 'second call okay');
00-report-prereqs.t 100644 001750 001751 13601 15253600633 16442 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t #!perl
use strict;
use warnings;
# This test was generated by Dist::Zilla::Plugin::Test::ReportPrereqs 0.029
use Test::More tests => 1;
use ExtUtils::MakeMaker;
use File::Spec;
# from $version::LAX
my $lax_version_re =
qr/(?: undef | (?: (?:[0-9]+) (?: \. | (?:\.[0-9]+) (?:_[0-9]+)? )?
|
(?:\.[0-9]+) (?:_[0-9]+)?
) | (?:
v (?:[0-9]+) (?: (?:\.[0-9]+)+ (?:_[0-9]+)? )?
|
(?:[0-9]+)? (?:\.[0-9]+){2,} (?:_[0-9]+)?
)
)/x;
# hide optional CPAN::Meta modules from prereq scanner
# and check if they are available
my $cpan_meta = "CPAN::Meta";
my $cpan_meta_pre = "CPAN::Meta::Prereqs";
my $HAS_CPAN_META = eval "require $cpan_meta; $cpan_meta->VERSION('2.120900')" && eval "require $cpan_meta_pre"; ## no critic
# Verify requirements?
my $DO_VERIFY_PREREQS = 1;
sub _max {
my $max = shift;
$max = ( $_ > $max ) ? $_ : $max for @_;
return $max;
}
sub _merge_prereqs {
my ($collector, $prereqs) = @_;
# CPAN::Meta::Prereqs object
if (ref $collector eq $cpan_meta_pre) {
return $collector->with_merged_prereqs(
CPAN::Meta::Prereqs->new( $prereqs )
);
}
# Raw hashrefs
for my $phase ( keys %$prereqs ) {
for my $type ( keys %{ $prereqs->{$phase} } ) {
for my $module ( keys %{ $prereqs->{$phase}{$type} } ) {
$collector->{$phase}{$type}{$module} = $prereqs->{$phase}{$type}{$module};
}
}
}
return $collector;
}
my @include = qw(
);
my @exclude = qw(
);
# Add static prereqs to the included modules list
my $static_prereqs = do './t/00-report-prereqs.dd';
# Merge all prereqs (either with ::Prereqs or a hashref)
my $full_prereqs = _merge_prereqs(
( $HAS_CPAN_META ? $cpan_meta_pre->new : {} ),
$static_prereqs
);
# Add dynamic prereqs to the included modules list (if we can)
my ($source) = grep { -f } 'MYMETA.json', 'MYMETA.yml';
my $cpan_meta_error;
if ( $source && $HAS_CPAN_META
&& (my $meta = eval { CPAN::Meta->load_file($source) } )
) {
$full_prereqs = _merge_prereqs($full_prereqs, $meta->prereqs);
}
else {
$cpan_meta_error = $@; # capture error from CPAN::Meta->load_file($source)
$source = 'static metadata';
}
my @full_reports;
my @dep_errors;
my $req_hash = $HAS_CPAN_META ? $full_prereqs->as_string_hash : $full_prereqs;
# Add static includes into a fake section
for my $mod (@include) {
$req_hash->{other}{modules}{$mod} = 0;
}
for my $phase ( qw(configure build test runtime develop other) ) {
next unless $req_hash->{$phase};
next if ($phase eq 'develop' and not $ENV{AUTHOR_TESTING});
for my $type ( qw(requires recommends suggests conflicts modules) ) {
next unless $req_hash->{$phase}{$type};
my $title = ucfirst($phase).' '.ucfirst($type);
my @reports = [qw/Module Want Have/];
for my $mod ( sort keys %{ $req_hash->{$phase}{$type} } ) {
next if grep { $_ eq $mod } @exclude;
my $want = $req_hash->{$phase}{$type}{$mod};
$want = "undef" unless defined $want;
$want = "any" if !$want && $want == 0;
if ($mod eq 'perl') {
push @reports, ['perl', $want, $]];
next;
}
my $req_string = $want eq 'any' ? 'any version required' : "version '$want' required";
my $file = $mod;
$file =~ s{::}{/}g;
$file .= ".pm";
my ($prefix) = grep { -e File::Spec->catfile($_, $file) } @INC;
if ($prefix) {
my $have = MM->parse_version( File::Spec->catfile($prefix, $file) );
$have = "undef" unless defined $have;
push @reports, [$mod, $want, $have];
if ( $DO_VERIFY_PREREQS && $HAS_CPAN_META && $type eq 'requires' ) {
if ( $have !~ /\A$lax_version_re\z/ ) {
push @dep_errors, "$mod version '$have' cannot be parsed ($req_string)";
}
elsif ( ! $full_prereqs->requirements_for( $phase, $type )->accepts_module( $mod => $have ) ) {
push @dep_errors, "$mod version '$have' is not in required range '$want'";
}
}
}
else {
push @reports, [$mod, $want, "missing"];
if ( $DO_VERIFY_PREREQS && $type eq 'requires' ) {
push @dep_errors, "$mod is not installed ($req_string)";
}
}
}
if ( @reports ) {
push @full_reports, "=== $title ===\n\n";
my $ml = _max( map { length $_->[0] } @reports );
my $wl = _max( map { length $_->[1] } @reports );
my $hl = _max( map { length $_->[2] } @reports );
if ($type eq 'modules') {
splice @reports, 1, 0, ["-" x $ml, "", "-" x $hl];
push @full_reports, map { sprintf(" %*s %*s\n", -$ml, $_->[0], $hl, $_->[2]) } @reports;
}
else {
splice @reports, 1, 0, ["-" x $ml, "-" x $wl, "-" x $hl];
push @full_reports, map { sprintf(" %*s %*s %*s\n", -$ml, $_->[0], $wl, $_->[1], $hl, $_->[2]) } @reports;
}
push @full_reports, "\n";
}
}
}
if ( @full_reports ) {
diag "\nVersions for all modules listed in $source (including optional ones):\n\n", @full_reports;
}
if ( $cpan_meta_error || @dep_errors ) {
diag "\n*** WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING ***\n";
}
if ( $cpan_meta_error ) {
my ($orig_source) = grep { -f } 'MYMETA.json', 'MYMETA.yml';
diag "\nCPAN::Meta->load_file('$orig_source') failed with: $cpan_meta_error\n";
}
if ( @dep_errors ) {
diag join("\n",
"\nThe following REQUIRED prerequisites were not satisfied:\n",
@dep_errors,
"\n"
);
}
pass('Reported prereqs');
# vim: ts=4 sts=4 sw=4 et:
release 000755 001750 001751 0 15253600633 14475 5 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/xt kwalitee.t 100644 001750 001751 321 15253600633 16603 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/xt/release # this test was generated with Dist::Zilla::Plugin::Test::Kwalitee 2.13
use strict;
use warnings;
use Test::More 0.88;
use Test::Kwalitee 1.21 'kwalitee_ok';
kwalitee_ok( qw( -no_symlinks ) );
done_testing;
author 000755 001750 001751 0 15253600633 14357 5 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/xt pod-spell.t 100644 001750 001751 2062 15253600633 16603 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/xt/author use strict;
use warnings;
use Test::More;
# generated by Dist::Zilla::Plugin::Test::PodSpelling 2.007006
use Test::Spelling 0.17;
use Pod::Wordlist;
set_spell_cmd('aspell list');
add_stopwords(<DATA>);
all_pod_files_spelling_ok( qw( bin lib ) );
__DATA__
49699333
883514
Aas
Alders
Andy
Antonio
Attr
Attrseq
Barbie
Bonaccorso
CDATA
CPAN
Chase
Chip
Clark
Damyan
David
Dtext
Entities
Filter
François
Germishuys
Gisle
Graham
HTML
HeadParser
IMG
Isindex
Ivanov
Jacques
James
Jensen
Jess
Johnson
Jon
Josef
Knop
Lester
LinkExtor
Lukas
MSIE
Mai
Michael
Michal
Mike
Nicholas
Nicolas
Olaf
Orton
Parser
Paul
Perrad
PullParser
Radici
Raspass
Rinaldo
Robinson
Salvatore
Salzenberg
Skyttä
South
Steinbrunner
Textification
Todd
TokeParser
Tokenpos
Unterminated
Ville
Whitener
Yves
Zefram
and
andy
antonio
argspec
argspecs
barbie
bulk88
capoeirab
castaway
chip
demerphq
dependabot
dmn
dsteinbrunner
francois
gaas
gisle
haarg
jacquesg
jon
jraspass
lib
lukasmai
mchase
msouth
mspacek
nick
nicolas
olaf
paul
salvatore
tagname
textified
toddr
undecoded
ville
yoshikazusawa
zefram
Špaček
HeadParser.pm 100644 001750 001751 20503 15253600633 16470 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/lib/HTML package HTML::HeadParser;
=head1 NAME
HTML::HeadParser - Parse <HEAD> section of a HTML document
=head1 SYNOPSIS
require HTML::HeadParser;
$p = HTML::HeadParser->new;
$p->parse($text) and print "not finished";
$p->header('Title') # to access <title>....</title>
$p->header('Content-Base') # to access <base href="http://...">
$p->header('Foo') # to access <meta http-equiv="Foo" content="...">
$p->header('X-Meta-Author') # to access <meta name="author" content="...">
$p->header('X-Meta-Charset') # to access <meta charset="...">
=head1 DESCRIPTION
The C<HTML::HeadParser> is a specialized (and lightweight)
C<HTML::Parser> that will only parse the E<lt>HEAD>...E<lt>/HEAD>
section of an HTML document. The parse() method
will return a FALSE value as soon as some E<lt>BODY> element or body
text are found, and should not be called again after this.
Note that the C<HTML::HeadParser> might get confused if raw undecoded
UTF-8 is passed to the parse() method. Make sure the strings are
properly decoded before passing them on.
The C<HTML::HeadParser> keeps a reference to a header object, and the
parser will update this header object as the various elements of the
E<lt>HEAD> section of the HTML document are recognized. The following
header fields are affected:
=over 4
=item Content-Base:
The I<Content-Base> header is initialized from the E<lt>base
href="..."> element.
=item Title:
The I<Title> header is initialized from the E<lt>title>...E<lt>/title>
element.
=item Isindex:
The I<Isindex> header will be added if there is a E<lt>isindex>
element in the E<lt>head>. The header value is initialized from the
I<prompt> attribute if it is present. If no I<prompt> attribute is
given it will have '?' as the value.
=item X-Meta-Foo:
All E<lt>meta> elements containing a C<name> attribute will result in
headers using the prefix C<X-Meta-> appended with the value of the
C<name> attribute as the name of the header, and the value of the
C<content> attribute as the pushed header value.
E<lt>meta> elements containing a C<http-equiv> attribute will result
in headers as in above, but without the C<X-Meta-> prefix in the
header name.
E<lt>meta> elements containing a C<charset> attribute will result in
an C<X-Meta-Charset> header, using the value of the C<charset>
attribute as the pushed header value.
The ':' character can't be represented in header field names, so
if the meta element contains this char it's substituted with '-'
before forming the field name.
=back
=head1 METHODS
The following methods (in addition to those provided by the
superclass) are available:
=over 4
=cut
require HTML::Parser;
our @ISA = qw(HTML::Parser);
use HTML::Entities ();
use strict;
our $DEBUG;
#$DEBUG = 1;
our $VERSION = '3.86';
=item $hp = HTML::HeadParser->new
=item $hp = HTML::HeadParser->new( $header )
The object constructor. The optional $header argument should be a
reference to an object that implement the header() and push_header()
methods as defined by the C<HTTP::Headers> class. Normally it will be
of some class that is a or delegates to the C<HTTP::Headers> class.
If no $header is given C<HTML::HeadParser> will create an
C<HTTP::Headers> object by itself (initially empty).
=cut
sub new
{
my($class, $header) = @_;
unless ($header) {
require HTTP::Headers;
$header = HTTP::Headers->new;
}
my $self = $class->SUPER::new(api_version => 3,
start_h => ["start", "self,tagname,attr"],
end_h => ["end", "self,tagname"],
text_h => ["text", "self,text"],
ignore_elements => [qw(script style)],
);
$self->{'header'} = $header;
$self->{'tag'} = ''; # name of active element that takes textual content
$self->{'text'} = ''; # the accumulated text associated with the element
$self;
}
=item $hp->header;
Returns a reference to the header object.
=item $hp->header( $key )
Returns a header value. It is just a shorter way to write
C<$hp-E<gt>header-E<gt>header($key)>.
=cut
sub header
{
my $self = shift;
return $self->{'header'} unless @_;
$self->{'header'}->header(@_);
}
sub as_string # legacy
{
my $self = shift;
$self->{'header'}->as_string;
}
sub flush_text # internal
{
my $self = shift;
my $tag = $self->{'tag'};
my $text = $self->{'text'};
$text =~ s/^\s+//;
$text =~ s/\s+$//;
$text =~ s/\s+/ /g;
print "FLUSH $tag => '$text'\n" if $DEBUG;
if ($tag eq 'title') {
my $decoded;
$decoded = utf8::decode($text) if $self->utf8_mode && defined &utf8::decode;
HTML::Entities::decode($text);
utf8::encode($text) if $decoded;
$self->{'header'}->push_header(Title => $text);
}
$self->{'tag'} = $self->{'text'} = '';
}
# This is an quote from the HTML3.2 DTD which shows which elements
# that might be present in a <HEAD>...</HEAD>. Also note that the
# <HEAD> tags themselves might be missing:
#
# <!ENTITY % head.content "TITLE & ISINDEX? & BASE? & STYLE? &
# SCRIPT* & META* & LINK*">
#
# <!ELEMENT HEAD O O (%head.content)>
#
# From HTML 4.01:
#
# <!ENTITY % head.misc "SCRIPT|STYLE|META|LINK|OBJECT">
# <!ENTITY % head.content "TITLE & BASE?">
# <!ELEMENT HEAD O O (%head.content;) +(%head.misc;)>
#
# From HTML 5 as of WD-html5-20090825:
#
# One or more elements of metadata content, [...]
# => base, command, link, meta, noscript, script, style, title
sub start
{
my($self, $tag, $attr) = @_; # $attr is reference to a HASH
print "START[$tag]\n" if $DEBUG;
$self->flush_text if $self->{'tag'};
if ($tag eq 'meta') {
my $key = $attr->{'http-equiv'};
if (!defined($key) || !length($key)) {
if ($attr->{name}) {
$key = "X-Meta-\u$attr->{name}";
} elsif ($attr->{charset}) { # HTML 5 <meta charset="...">
$key = "X-Meta-Charset";
$self->{header}->push_header($key => $attr->{charset});
return;
} else {
return;
}
}
$key =~ s/:/-/g;
$self->{'header'}->push_header($key => $attr->{content});
} elsif ($tag eq 'base') {
return unless exists $attr->{href};
(my $base = $attr->{href}) =~ s/^\s+//; $base =~ s/\s+$//; # HTML5
$self->{'header'}->push_header('Content-Base' => $base);
} elsif ($tag eq 'isindex') {
# This is a non-standard header. Perhaps we should just ignore
# this element
$self->{'header'}->push_header(Isindex => $attr->{prompt} || '?');
} elsif ($tag =~ /^(?:title|noscript|object|command)$/) {
# Just remember tag. Initialize header when we see the end tag.
$self->{'tag'} = $tag;
} elsif ($tag eq 'link') {
return unless exists $attr->{href};
# <link href="http:..." rel="xxx" rev="xxx" title="xxx">
my $href = delete($attr->{href});
$href =~ s/^\s+//; $href =~ s/\s+$//; # HTML5
my $h_val = "<$href>";
for (sort keys %{$attr}) {
next if $_ eq "/"; # XHTML junk
$h_val .= qq(; $_="$attr->{$_}");
}
$self->{'header'}->push_header(Link => $h_val);
} elsif ($tag eq 'head' || $tag eq 'html') {
# ignore
} else {
# stop parsing
$self->eof;
}
}
sub end
{
my($self, $tag) = @_;
print "END[$tag]\n" if $DEBUG;
$self->flush_text if $self->{'tag'};
$self->eof if $tag eq 'head';
}
sub text
{
my($self, $text) = @_;
print "TEXT[$text]\n" if $DEBUG;
unless ($self->{first_chunk}) {
# drop Unicode BOM if found
if ($self->utf8_mode) {
$text =~ s/^\xEF\xBB\xBF//;
}
else {
$text =~ s/^\x{FEFF}//;
}
$self->{first_chunk}++;
}
my $tag = $self->{tag};
if (!$tag && $text =~ /\S/) {
# Normal text means start of body
$self->eof;
return;
}
return if $tag ne 'title';
$self->{'text'} .= $text;
}
BEGIN {
*utf8_mode = sub { 1 } unless HTML::Entities::UNICODE_SUPPORT;
}
1;
__END__
=back
=head1 EXAMPLE
$h = HTTP::Headers->new;
$p = HTML::HeadParser->new($h);
$p->parse(<<EOT);
<title>Stupid example</title>
<base href="http://www.linpro.no/lwp/">
Normal text starts here.
EOT
undef $p;
print $h->title; # should print "Stupid example"
=head1 SEE ALSO
L<HTML::Parser>, L<HTTP::Headers>
The C<HTTP::Headers> class is distributed as part of the
I<libwww-perl> package. If you don't have that distribution installed
you need to provide the $header argument to the C<HTML::HeadParser>
constructor with your own object that implements the documented
protocol.
=head1 COPYRIGHT
Copyright 1996-2001 Gisle Aas. All rights reserved.
This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
=cut
PullParser.pm 100644 001750 001751 13074 15253600633 16550 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/lib/HTML package HTML::PullParser;
use strict;
require HTML::Parser;
our @ISA = qw(HTML::Parser);
our $VERSION = '3.86';
use Carp ();
sub new
{
my($class, %cnf) = @_;
# Construct argspecs for the various events
my %argspec;
for (qw(start end text declaration comment process default)) {
my $tmp = delete $cnf{$_};
next unless defined $tmp;
$argspec{$_} = $tmp;
}
Carp::croak("Info not collected for any events")
unless %argspec;
my $file = delete $cnf{file};
my $doc = delete $cnf{doc};
Carp::croak("Can't parse from both 'doc' and 'file' at the same time")
if defined($file) && defined($doc);
Carp::croak("No 'doc' or 'file' given to parse from")
unless defined($file) || defined($doc);
# Create object
$cnf{api_version} = 3;
my $self = $class->SUPER::new(%cnf);
my $accum = $self->{pullparser_accum} = [];
while (my($event, $argspec) = each %argspec) {
$self->SUPER::handler($event => $accum, $argspec);
}
if (defined $doc) {
$self->{pullparser_str_ref} = ref($doc) ? $doc : \$doc;
$self->{pullparser_str_pos} = 0;
}
else {
if (!ref($file) && ref(\$file) ne "GLOB") {
require IO::File;
$file = IO::File->new($file, "r") || return;
}
$self->{pullparser_file} = $file;
}
$self;
}
sub handler
{
Carp::croak("Can't set handlers for HTML::PullParser");
}
sub get_token
{
my $self = shift;
while (!@{$self->{pullparser_accum}} && !$self->{pullparser_eof}) {
if (my $f = $self->{pullparser_file}) {
# must try to parse more from the file
my $buf;
if (read($f, $buf, 512)) {
$self->parse($buf);
} else {
$self->eof;
$self->{pullparser_eof}++;
delete $self->{pullparser_file};
}
}
elsif (my $sref = $self->{pullparser_str_ref}) {
# must try to parse more from the scalar
my $pos = $self->{pullparser_str_pos};
my $chunk = substr($$sref, $pos, 512);
$self->parse($chunk);
$pos += length($chunk);
if ($pos < length($$sref)) {
$self->{pullparser_str_pos} = $pos;
}
else {
$self->eof;
$self->{pullparser_eof}++;
delete $self->{pullparser_str_ref};
delete $self->{pullparser_str_pos};
}
}
else {
die;
}
}
shift @{$self->{pullparser_accum}};
}
sub unget_token
{
my $self = shift;
unshift @{$self->{pullparser_accum}}, @_;
$self;
}
1;
__END__
=head1 NAME
HTML::PullParser - Alternative HTML::Parser interface
=head1 SYNOPSIS
use HTML::PullParser;
$p = HTML::PullParser->new(file => "index.html",
start => 'event, tagname, @attr',
end => 'event, tagname',
ignore_elements => [qw(script style)],
) || die "Can't open: $!";
while (my $token = $p->get_token) {
#...do something with $token
}
=head1 DESCRIPTION
The HTML::PullParser is an alternative interface to the HTML::Parser class.
It basically turns the HTML::Parser inside out. You associate a file
(or any IO::Handle object or string) with the parser at construction time and
then repeatedly call $parser->get_token to obtain the tags and text
found in the parsed document.
The following methods are provided:
=over 4
=item $p = HTML::PullParser->new( file => $file, %options )
=item $p = HTML::PullParser->new( doc => \$doc, %options )
A C<HTML::PullParser> can be made to parse from either a file or a
literal document based on whether the C<file> or C<doc> option is
passed to the parser's constructor.
The C<file> passed in can either be a file name or a file handle
object. If a file name is passed, and it can't be opened for reading,
then the constructor will return an undefined value and $! will tell
you why it failed. Otherwise the argument is taken to be some object
that the C<HTML::PullParser> can read() from when it needs more data.
The stream will be read() until EOF, but not closed.
A C<doc> can be passed plain or as a reference
to a scalar. If a reference is passed then the value of this scalar
should not be changed before all tokens have been extracted.
Next the information to be returned for the different token types must
be set up. This is done by simply associating an argspec (as defined
in L<HTML::Parser>) with the events you have an interest in. For
instance, if you want C<start> tokens to be reported as the string
C<'S'> followed by the tagname and the attributes you might pass an
C<start>-option like this:
$p = HTML::PullParser->new(
doc => $document_to_parse,
start => '"S", tagname, @attr',
end => '"E", tagname',
);
At last other C<HTML::Parser> options, like C<ignore_tags>, and
C<unbroken_text>, can be passed in. Note that you should not use the
I<event>_h options to set up parser handlers. That would confuse the
inner logic of C<HTML::PullParser>.
=item $token = $p->get_token
This method will return the next I<token> found in the HTML document,
or C<undef> at the end of the document. The token is returned as an
array reference. The content of this array match the argspec set up
during C<HTML::PullParser> construction.
=item $p->unget_token( @tokens )
If you find out you have read too many tokens you can push them back,
so that they are returned again the next time $p->get_token is called.
=back
=head1 EXAMPLES
The 'eg/hform' script shows how we might parse the form section of
HTML::Documents using HTML::PullParser.
=head1 SEE ALSO
L<HTML::Parser>, L<HTML::TokeParser>
=head1 COPYRIGHT
Copyright 1998-2001 Gisle Aas.
This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
=cut
TokeParser.pm 100644 001750 001751 23604 15253600633 16536 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/lib/HTML package HTML::TokeParser;
use strict;
require HTML::PullParser;
our @ISA = qw(HTML::PullParser);
our $VERSION = '3.86';
use Carp ();
use HTML::Entities qw(decode_entities);
use HTML::Tagset ();
my %ARGS =
(
start => "'S',tagname,attr,attrseq,text",
end => "'E',tagname,text",
text => "'T',text,is_cdata",
process => "'PI',token0,text",
comment => "'C',text",
declaration => "'D',text",
# options that default on
unbroken_text => 1,
);
sub new
{
my $class = shift;
my %cnf;
if (@_ == 1) {
my $type = (ref($_[0]) eq "SCALAR") ? "doc" : "file";
%cnf = ($type => $_[0]);
}
else {
unshift @_, (ref($_[0]) eq "SCALAR") ? "doc" : "file" if(scalar(@_) % 2 == 1);
%cnf = @_;
}
my $textify = delete $cnf{textify} || {img => "alt", applet => "alt"};
my $self = $class->SUPER::new(%ARGS, %cnf) || return undef;
$self->{textify} = $textify;
$self;
}
sub get_tag
{
my $self = shift;
my $token;
while (1) {
$token = $self->get_token || return undef;
my $type = shift @$token;
next unless $type eq "S" || $type eq "E";
substr($token->[0], 0, 0) = "/" if $type eq "E";
return $token unless @_;
for (@_) {
return $token if $token->[0] eq $_;
}
}
}
sub _textify {
my($self, $token) = @_;
my $tag = $token->[1];
return undef unless exists $self->{textify}{$tag};
my $alt = $self->{textify}{$tag};
my $text;
if (ref($alt)) {
$text = &$alt(@$token);
} else {
$text = $token->[2]{$alt || "alt"};
$text = "[\U$tag]" unless defined $text;
}
return $text;
}
sub get_text
{
my $self = shift;
my @text;
while (my $token = $self->get_token) {
my $type = $token->[0];
if ($type eq "T") {
my $text = $token->[1];
decode_entities($text) unless $token->[2];
push(@text, $text);
} elsif ($type =~ /^[SE]$/) {
my $tag = $token->[1];
if ($type eq "S") {
if (defined(my $text = _textify($self, $token))) {
push(@text, $text);
next;
}
} else {
$tag = "/$tag";
}
if (!@_ || grep $_ eq $tag, @_) {
$self->unget_token($token);
last;
}
push(@text, " ")
if $tag eq "br" || !$HTML::Tagset::isPhraseMarkup{$token->[1]};
}
}
join("", @text);
}
sub get_trimmed_text
{
my $self = shift;
my $text = $self->get_text(@_);
$text =~ s/^\s+//; $text =~ s/\s+$//; $text =~ s/\s+/ /g;
$text;
}
sub get_phrase {
my $self = shift;
my @text;
while (my $token = $self->get_token) {
my $type = $token->[0];
if ($type eq "T") {
my $text = $token->[1];
decode_entities($text) unless $token->[2];
push(@text, $text);
} elsif ($type =~ /^[SE]$/) {
my $tag = $token->[1];
if ($type eq "S") {
if (defined(my $text = _textify($self, $token))) {
push(@text, $text);
next;
}
}
if (!$HTML::Tagset::isPhraseMarkup{$tag}) {
$self->unget_token($token);
last;
}
push(@text, " ") if $tag eq "br";
}
}
my $text = join("", @text);
$text =~ s/^\s+//; $text =~ s/\s+$//; $text =~ s/\s+/ /g;
$text;
}
1;
__END__
=head1 NAME
HTML::TokeParser - Alternative HTML::Parser interface
=head1 SYNOPSIS
require HTML::TokeParser;
$p = HTML::TokeParser->new("index.html") ||
die "Can't open: $!";
$p->empty_element_tags(1); # configure its behaviour
while (my $token = $p->get_token) {
#...
}
=head1 DESCRIPTION
The C<HTML::TokeParser> is an alternative interface to the
C<HTML::Parser> class. It is an C<HTML::PullParser> subclass with a
predeclared set of token types. If you wish the tokens to be reported
differently you probably want to use the C<HTML::PullParser> directly.
The following methods are available:
=over 4
=item $p = HTML::TokeParser->new( $filename, %opt );
=item $p = HTML::TokeParser->new( $filehandle, %opt );
=item $p = HTML::TokeParser->new( \$document, %opt );
The object constructor argument is either a file name, a file handle
object, or the complete document to be parsed. Extra options can be
provided as key/value pairs and are processed as documented by the base
classes.
If the argument is a plain scalar, then it is taken as the name of a
file to be opened and parsed. If the file can't be opened for
reading, then the constructor will return C<undef> and $! will tell
you why it failed.
If the argument is a reference to a plain scalar, then this scalar is
taken to be the literal document to parse. The value of this
scalar should not be changed before all tokens have been extracted.
Otherwise the argument is taken to be some object that the
C<HTML::TokeParser> can read() from when it needs more data. Typically
it will be a filehandle of some kind. The stream will be read() until
EOF, but not closed.
A newly constructed C<HTML::TokeParser> differ from its base classes
by having the C<unbroken_text> attribute enabled by default. See
L<HTML::Parser> for a description of this and other attributes that
influence how the document is parsed. It is often a good idea to enable
C<empty_element_tags> behaviour.
Note that the parsing result will likely not be valid if raw undecoded
UTF-8 is used as a source. When parsing UTF-8 encoded files turn
on UTF-8 decoding:
open(my $fh, "<:utf8", "index.html") || die "Can't open 'index.html': $!";
my $p = HTML::TokeParser->new( $fh );
# ...
If a $filename is passed to the constructor the file will be opened in
raw mode and the parsing result will only be valid if its content is
Latin-1 or pure ASCII.
If parsing from an UTF-8 encoded string buffer decode it first:
utf8::decode($document);
my $p = HTML::TokeParser->new( \$document );
# ...
=item $p->get_token
This method will return the next I<token> found in the HTML document,
or C<undef> at the end of the document. The token is returned as an
array reference. The first element of the array will be a string
denoting the type of this token: "S" for start tag, "E" for end tag,
"T" for text, "C" for comment, "D" for declaration, and "PI" for
process instructions. The rest of the token array depend on the type
like this:
["S", $tag, $attr, $attrseq, $text]
["E", $tag, $text]
["T", $text, $is_data]
["C", $text]
["D", $text]
["PI", $token0, $text]
where $attr is a hash reference, $attrseq is an array reference and
the rest are plain scalars. The L<HTML::Parser/Argspec> explains the
details.
=item $p->unget_token( @tokens )
If you find you have read too many tokens you can push them back,
so that they are returned the next time $p->get_token is called.
=item $p->get_tag
=item $p->get_tag( @tags )
This method returns the next start or end tag (skipping any other
tokens), or C<undef> if there are no more tags in the document. If
one or more arguments are given, then we skip tokens until one of the
specified tag types is found. For example:
$p->get_tag("font", "/font");
will find the next start or end tag for a font-element.
The tag information is returned as an array reference in the same form
as for $p->get_token above, but the type code (first element) is
missing. A start tag will be returned like this:
[$tag, $attr, $attrseq, $text]
The tagname of end tags are prefixed with "/", i.e. end tag is
returned like this:
["/$tag", $text]
=item $p->get_text
=item $p->get_text( @endtags )
This method returns all text found at the current position. It will
return a zero length string if the next token is not text. Any
entities will be converted to their corresponding character.
If one or more arguments are given, then we return all text occurring
before the first of the specified tags found. For example:
$p->get_text("p", "br");
will return the text up to either a paragraph of line break element.
The text might span tags that should be I<textified>. This is
controlled by the $p->{textify} attribute, which is a hash that
defines how certain tags can be treated as text. If the name of a
start tag matches a key in this hash then this tag is converted to
text. The hash value is used to specify which tag attribute to obtain
the text from. If this tag attribute is missing, then the upper case
name of the tag enclosed in brackets is returned, e.g. "[IMG]". The
hash value can also be a subroutine reference. In this case the
routine is called with the start tag token content as its argument and
the return value is treated as the text.
The default $p->{textify} value is:
{img => "alt", applet => "alt"}
This means that <IMG> and <APPLET> tags are treated as text, and that
the text to substitute can be found in the ALT attribute.
=item $p->get_trimmed_text
=item $p->get_trimmed_text( @endtags )
Same as $p->get_text above, but will collapse any sequences of white
space to a single space character. Leading and trailing white space is
removed.
=item $p->get_phrase
This will return all text found at the current position ignoring any
phrasal-level tags. Text is extracted until the first non
phrasal-level tag. Textification of tags is the same as for
get_text(). This method will collapse white space in the same way as
get_trimmed_text() does.
The definition of <i>phrasal-level tags</i> is obtained from the
HTML::Tagset module.
=back
=head1 EXAMPLES
This example extracts all links from a document. It will print one
line for each link, containing the URL and the textual description
between the <A>...</A> tags:
use HTML::TokeParser;
$p = HTML::TokeParser->new(shift||"index.html");
while (my $token = $p->get_tag("a")) {
my $url = $token->[1]{href} || "-";
my $text = $p->get_trimmed_text("/a");
print "$url\t$text\n";
}
This example extract the <TITLE> from the document:
use HTML::TokeParser;
$p = HTML::TokeParser->new(shift||"index.html");
if ($p->get_tag("title")) {
my $title = $p->get_trimmed_text;
print "Title: $title\n";
}
=head1 SEE ALSO
L<HTML::PullParser>, L<HTML::Parser>
=head1 COPYRIGHT
Copyright 1998-2005 Gisle Aas.
This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
=cut
pod-syntax.t 100644 001750 001751 251 15253600633 16770 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/xt/author #!perl
# This file was automatically generated by Dist::Zilla::Plugin::PodSyntaxTests
use strict; use warnings;
use Test::More;
use Test::Pod 1.41;
all_pod_files_ok();
00-report-prereqs.dd 100644 001750 001751 6114 15253600633 16547 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t do { my $x = {
'configure' => {
'requires' => {
'ExtUtils::MakeMaker' => '6.52',
'perl' => '5.008'
},
'suggests' => {
'JSON::PP' => '2.27300'
}
},
'develop' => {
'requires' => {
'Dist::Zilla' => '0',
'Dist::Zilla::Plugin::MinimumPerl' => '0',
'Dist::Zilla::PluginBundle::Starter' => 'v4.0.0',
'File::Spec' => '0',
'IO::Handle' => '0',
'IPC::Open3' => '0',
'Pod::Coverage::TrustPod' => '0',
'Test::CPAN::Changes' => '0.4',
'Test::CPAN::Meta' => '0',
'Test::CheckManifest' => '1.29',
'Test::Kwalitee' => '1.22',
'Test::More' => '0.88',
'Test::Pod' => '1.41',
'Test::Pod::Coverage' => '1.08',
'Test::Pod::Spelling::CommonMistakes' => '1.000',
'Test::Spelling' => '0.17',
'Test::Version' => '2.00'
}
},
'runtime' => {
'requires' => {
'Carp' => '0',
'Exporter' => '0',
'HTML::Tagset' => '0',
'HTTP::Headers' => '0',
'IO::File' => '0',
'URI' => '0',
'URI::URL' => '0',
'XSLoader' => '0',
'perl' => '5.008',
'strict' => '0'
}
},
'test' => {
'recommends' => {
'CPAN::Meta' => '2.120900'
},
'requires' => {
'Config' => '0',
'ExtUtils::MakeMaker' => '0',
'File::Spec' => '0',
'IO::File' => '0',
'SelectSaver' => '0',
'Test::More' => '0',
'URI' => '0',
'perl' => '5.008',
'strict' => '0'
}
}
};
$x;
} 00-compile.t 100644 001750 001751 2745 15253600633 16561 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/xt/author use strict;
use warnings;
# this test was generated with Dist::Zilla::Plugin::Test::Compile 2.059
use Test::More;
plan tests => 8;
my @module_files = (
'HTML/Entities.pm',
'HTML/Filter.pm',
'HTML/HeadParser.pm',
'HTML/LinkExtor.pm',
'HTML/Parser.pm',
'HTML/PullParser.pm',
'HTML/TokeParser.pm'
);
# no fake home requested
my @switches = (
-d 'blib' ? '-Mblib' : '-Ilib',
);
use File::Spec;
use IPC::Open3;
use IO::Handle;
open my $stdin, '<', File::Spec->devnull or die "can't open devnull: $!";
my @warnings;
for my $lib (@module_files)
{
# see L<perlfaq8/How can I capture STDERR from an external command?>
my $stderr = IO::Handle->new;
diag('Running: ', join(', ', map { my $str = $_; $str =~ s/'/\\'/g; q{'}.$str.q{'} }
$^X, @switches, '-e', "require q[$lib]"))
if $ENV{PERL_COMPILE_TEST_DEBUG};
my $pid = open3($stdin, '>&STDERR', $stderr, $^X, @switches, '-e', "require q[$lib]");
binmode $stderr, ':crlf' if $^O eq 'MSWin32';
my @_warnings = <$stderr>;
waitpid($pid, 0);
is($?, 0, "$lib loaded ok");
shift @_warnings if @_warnings and $_warnings[0] =~ /^Using .*\bblib/
and not eval { +require blib; blib->VERSION('1.01') };
if (@_warnings)
{
warn @_warnings;
push @warnings, @_warnings;
}
}
is(scalar(@warnings), 0, 'no warnings found') or diag 'got warnings: ', ( Test::More->can('explain') ? Test::More::explain(\@warnings) : join("\n", '', @warnings) );
test-version.t 100644 001750 001751 711 15253600633 17325 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/xt/author use strict;
use warnings;
use Test::More;
# generated by Dist::Zilla::Plugin::Test::Version 1.09
use Test::Version;
my @imports = qw( version_all_ok );
my $params = {
is_strict => 0,
has_version => 1,
multiple => 0,
filename_match => [ qr/Parser\.pm$/ ],
};
push @imports, $params
if version->parse( $Test::Version::VERSION ) >= version->parse('1.002');
Test::Version->import(@imports);
version_all_ok;
done_testing;
pod-coverage.t 100644 001750 001751 3050 15253600633 17255 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/xt/author #!perl
# This file was automatically generated by Dist::Zilla::Plugin::Test::Pod::Coverage::Configurable 0.07.
use Test::Pod::Coverage 1.08;
use Test::More 0.88;
BEGIN {
if ( $] <= 5.008008 ) {
plan skip_all => 'These tests require Pod::Coverage::TrustPod, which only works with Perl 5.8.9+';
}
}
use Pod::Coverage::TrustPod;
my %skip = map { $_ => 1 } qw( );
my @modules;
for my $module ( all_modules() ) {
next if $skip{$module};
push @modules, $module;
}
plan skip_all => 'All the modules we found were excluded from POD coverage test.'
unless @modules;
plan tests => scalar @modules;
my %trustme = (
'HTML::Entities' => [
qr/^(?:UNICODE_SUPPORT|decode|encode|encode_numeric|encode_numerically|num_entity)$/
],
'HTML::Filter' => [
qr/^(?:output)$/
],
'HTML::HeadParser' => [
qr/^(?:as_string|flush_text)$/
],
'HTML::Parser' => [
qr/^(?:init|netscape_buggy_comment)$/
]
);
my @also_private;
for my $module ( sort @modules ) {
pod_coverage_ok(
$module,
{
coverage_class => 'Pod::Coverage::TrustPod',
also_private => \@also_private,
trustme => $trustme{$module} || [],
},
"pod coverage for $module"
);
}
done_testing();
changes_has_content.t 100644 001750 001751 2100 15253600633 21010 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/xt/release use Test::More tests => 2;
note 'Checking Changes';
my $changes_file = 'Changes';
my $newver = '3.86';
my $trial_token = '-TRIAL';
my $encoding = 'UTF-8';
SKIP: {
ok(-e $changes_file, "$changes_file file exists")
or skip 'Changes is missing', 1;
ok(_get_changes($newver), "$changes_file has content for $newver");
}
done_testing;
sub _get_changes
{
my $newver = shift;
# parse changelog to find commit message
open(my $fh, '<', $changes_file) or die "cannot open $changes_file: $!";
my $changelog = join('', <$fh>);
if ($encoding) {
require Encode;
$changelog = Encode::decode($encoding, $changelog, Encode::FB_CROAK());
}
close $fh;
my @content =
grep { /^$newver(?:$trial_token)?(?:\s+|$)/ ... /^\S/ } # from newver to un-indented
split /\n/, $changelog;
shift @content; # drop the version line
# drop unindented last line and trailing blank lines
pop @content while ( @content && $content[-1] =~ /^(?:\S|\s*$)/ );
# return number of non-blank lines
return scalar @content;
}
♥ Love \x{2665}
EOT
close($fh) || die;
@warn = ();
@parsed = ();
$p->parse_file($file);
is(@parsed, "11");
is($parsed[6][0], "start");
is($parsed[6][8]{id}, "\x{2665}\xE2\x99\xA5");
is($parsed[7][0], "text");
is($parsed[7][1], "♥ Love \xE2\x99\xA5");
is($parsed[7][2], "\x{2665} Love \xE2\x99\xA5"); # expected garbage
is($parsed[10][3], -s $file);
is(@warn, 1);
like($warn[0],
qr/^Parsing of undecoded UTF-8 will give garbage when decoding entities/);
@warn = ();
@parsed = ();
open($fh, "<:raw:utf8", $file) || die;
$p->parse_file($fh);
is(@parsed, "11");
is($parsed[6][0], "start");
is($parsed[6][8]{id}, "\x{2665}\x{2665}");
is($parsed[7][0], "text");
is($parsed[7][1], "♥ Love \x{2665}");
is($parsed[7][2], "\x{2665} Love \x{2665}");
is($parsed[10][3], (-s $file) - 2 * 4);
is(@warn, 0);
@warn = ();
@parsed = ();
open($fh, "<:raw", $file) || die;
$p->utf8_mode(1);
$p->parse_file($fh);
is(@parsed, "11");
is($parsed[6][0], "start");
is($parsed[6][8]{id}, "\xE2\x99\xA5\xE2\x99\xA5");
is($parsed[7][0], "text");
is($parsed[7][1], "♥ Love \xE2\x99\xA5");
is($parsed[7][2], "\xE2\x99\xA5 Love \xE2\x99\xA5");
is($parsed[10][3], -s $file);
is(@warn, 0);
unlink($file);
@parsed = ();
$p->parse(q(foo))->eof;
is(@parsed, "5");
is($parsed[1][0], "start");
is($parsed[1][8]{href}, "a=1&lang=2\xC3\x97=3");
ok(!HTML::Entities::_probably_utf8_chunk(""));
ok(!HTML::Entities::_probably_utf8_chunk("f"));
ok(HTML::Entities::_probably_utf8_chunk("f\xE2\x99\xA5"));
ok(HTML::Entities::_probably_utf8_chunk("f\xE2\x99\xA5o"));
ok(HTML::Entities::_probably_utf8_chunk("f\xE2\x99\xA5o\xE2"));
ok(HTML::Entities::_probably_utf8_chunk("f\xE2\x99\xA5o\xE2\x99"));
ok(!HTML::Entities::_probably_utf8_chunk("f\xE2"));
ok(!HTML::Entities::_probably_utf8_chunk("f\xE2\x99"));
$p = HTML::Parser->new(
api_version => 3,
default_h => [\@parsed, 'event, text, tag, attr'],
attr_encoded => 1,
);
@warn = ();
@parsed = ();
$p->parse($doc)->eof;
ok(!@warn);
is(@parsed, 9);
@parsed = ();
$p = HTML::Parser->new(
api_version => 3,
utf8_mode => 1,
unbroken_text => 1,
default_h => [\@parsed, 'event,dtext'],
);
$p->parse(
"
R\xC3\xA9ductions jusqu'à -70%.
Réductions jusqu'à -70%."
);
$p->eof;
is($parsed[2][1], "R\xC3\xA9ductions jusqu'\xC3\xA0 -70%.");
is($parsed[4][1], "R\xC3\xA9ductions jusqu'\xC3\xA0 -70%.");
Makefile.PL 100644 001750 001751 3351 15253600633 14536 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86 # This Makefile.PL for HTML-Parser was generated by
# Dist::Zilla::Plugin::MakeMaker::Awesome 0.49.
# Don't edit it but the dist.ini and plugins used to construct it.
use strict;
use warnings;
use ExtUtils::MakeMaker;
my %WriteMakefileArgs = (
"ABSTRACT" => "HTML parser class",
"AUTHOR" => "Gisle Aas The purpose of this table is to test how various browsers expands
HTML entities in various edge cases in order to improve compatibility
for HTML-Parser.
overflow:
3= 33=! 333=ō 3333=അ 33333=舵 333333= 3333333=� 33333333=� 333333333=� 3333333333=� 33333333333=�
ref: x ÿx ࿿x x x
This table records observations of how various browsers behave with
regards to expanding entities. The term "Latin-1 entities" means named
entities that map to characters in the 0 .. 255 range. The term
"Unicode entities" means named entities that are not "Latin-1
entities".
Ho ho
<--comment->
EOT
$p->parse($doc)->eof;
#use Data::Dump; Data::Dump::dump(@expected);
for my $i (1 .. length($doc)) {
my @t;
$p->handler(default => \@t);
$p->parse(chunk($doc, $i));
# check that we got the same stuff
#diag "X:", join(":", @t);
#diag "Y:", join(":", @expected);
is(join(":", @t), join(":", @expected));
}
sub chunk {
my $str = shift;
my $size = shift || 1;
sub {
my $res = substr($str, 0, $size);
#diag "...$res";
substr($str, 0, $size) = "";
$res;
}
}
# Test croking behaviour
$p->handler(default => []);
my $error;
{
local $@;
#<<< do not let perltidy touch this
$error = $@ || 'Error' unless eval {
$p->parse(sub { die "Hi" });
1
};
#>>>
}
like($error, qr/^Hi/);
document.t 100644 001750 001751 1376 15253600633 15037 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use File::Spec ();
use HTML::Parser ();
use Test::More tests => 6;
my $events;
my $p
= HTML::Parser->new(default_h => [sub { $events .= "$_[0]\n"; }, "event"]);
$events = "";
$p->eof;
is($events, "start_document\nend_document\n");
$events = "";
$p->parse_file(File::Spec->devnull);
is($events, "start_document\nend_document\n");
$events = "";
$p->parse("");
$p->eof;
is($events, "start_document\nend_document\n");
$events = "";
$p->parse("");
$p->parse("");
$p->eof;
is($events, "start_document\nend_document\n");
$events = "";
$p->parse("");
$p->parse("");
$p->eof;
is($events, "start_document\nstart\nend_document\n");
$events = "";
$p->parse(" ");
$p->eof;
is($events, "start_document\nstart\ntext\nend_document\n");
entities.t 100644 001750 001751 35264 15253600633 15070 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use utf8;
use HTML::Entities
qw(_decode_entities decode_entities encode_entities encode_entities_numeric);
use Test::More tests => 43;
my $x = "Våre norske tegn bør æres";
decode_entities($x);
is($x, "Våre norske tegn bør æres");
encode_entities($x);
is($x, "Våre norske tegn bør æres");
decode_entities($x);
encode_entities_numeric($x);
is($x, "Våre norske tegn bør æres");
$x = "<&>\"'";
is(encode_entities($x), "<&>"'");
is(encode_entities_numeric($x), "<&>"'");
$x = "abcdef";
is(encode_entities($x, 'a-c'), "abcdef");
$x = "[24/7]\\";
is(encode_entities($x, '/'), "[24/7]\\");
is(encode_entities($x, '\\/'), "[24/7]\\");
is(encode_entities($x, '\\'), "[24/7]\");
is(encode_entities($x, ']\\'), "[24/7]\");
# https://github.com/libwww-perl/HTML-Parser/issues/44
$x = '<]$a/b\c/d$';
is(encode_entities($x, '$'), '<]$a/b\\c/d$');
is(encode_entities($x, '\\\\/'), '<]$a/b\c/d$');
is(encode_entities($x, '\\\\/$'), '<]$a/b\c/d$');
is(encode_entities($x, '<\\\\]'), '<]$a/b\c/d$');
# POSIX character classes
$x = "Entities expansion test page
ent with without dec hex hexx ref & & && && && &x ref ' ' &apos&aposapos '' '' 'x ref × × ××times ×× ×× ×x ref € € &euro&euroeuro €€ €€ €x ref ♥ ♥ &hearts&heartshearts ♥♥ ♥♥ ♥x ref Results
entities2.t 100644 001750 001751 3102 15253600633 15114 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use utf8;
use HTML::Entities qw(_decode_entities);
use Test::More tests => 9;
{
local $@;
my $error;
#<<< do not let perltidy touch this
$error = $@ || 'Error' unless eval {
_decode_entities("<", undef);
1;
};
#>>>
like($error,
qr/^(?:Can't inline decode readonly string|Modification of a read-only value attempted)/
);
}
{
local $@;
my $error;
#<<< do not let perltidy touch this
$error = $@ || 'Error' unless eval {
my $x = "";
_decode_entities($x, $x);
1;
};
#>>>
like($error, qr/^2nd argument must be hash reference/);
}
{
local $@;
my $error;
#<<< do not let perltidy touch this
$error = $@ || 'Error' unless eval {
my $x = "";
_decode_entities($x, []);
1;
};
#>>>
like($error, qr/^2nd argument must be hash reference/);
}
my $x = "<";
_decode_entities($x, undef);
is($x, "<");
_decode_entities($x, {"lt" => "<"});
is($x, "<");
$x = "x" x 20;
my $err;
for (":", ":a", "a:", "a:a", "a:a:a", "a:::a") {
my $x = $_;
$x =~ s/:/&a;/g;
my $y = $_;
$y =~ s/:/$x/g;
_decode_entities($x, {"a" => $x});
if ($x ne $y) {
diag "Something went wrong with '$_'";
$err++;
}
}
ok(!$err);
$x = "foo bar";
_decode_entities($x, \%HTML::Entities::entity2char);
is($x, "foo\xA0bar");
$x = "foo bar";
_decode_entities($x, \%HTML::Entities::entity2char);
is($x, "foo bar");
_decode_entities($x, \%HTML::Entities::entity2char, 1);
is($x, "foo\xA0bar");
largetags.t 100644 001750 001751 1315 15253600633 15163 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use Test::More tests => 2;
# Exercise the tokenpos buffer allocation routines by feeding it
# very large tags.
my $p = HTML::Parser->new(api_version => 3);
$p->handler(
"start" => sub {
my $tp = shift;
#diag int(@$tp), " - ", join(", ", @$tp);
is(@$tp, 2 + 26 * 6 * 4);
},
"tokenpos"
);
$p->handler(
"declaration" => sub {
my $t = shift;
#diag int(@$t), " - @$t";
is(@$t, 26 * 6 * 2 + 1);
},
"tokens"
);
$p->parse("parse("$_=1 ");
}
$p->parse(">");
$p->parse("parse("$_ -- $_ -- ");
}
$p->parse(">");
$p->eof;
parsefile.t 100644 001750 001751 2163 15253600633 15166 0 ustar 00olaf olaf 000000 000000 HTML-Parser-3.86/t use strict;
use warnings;
use HTML::Parser ();
use IO::File ();
use Test::More tests => 6;
my $filename = "file$$.htm";
die "$filename is already there" if -e $filename;
{
open(my $fh, '>', $filename) || die "Can't create $filename: $!";
print {$fh} "
feature
do
don't
expand '
HTML-Parser >= 3.22, FireFox 1.5, Konqueror 3.4.3, Safari 2.0
HTML-Parser <= 3.21, MSIE 7.0 beta 2
expand Latin-1 entities that are not terminated by semicolon
HTML-Parser, FireFox 1.5, Konqueror 3.4.3, MSIE 7.0 beta 2, Safari 2.0
expand prefix of Latin-1 entities in text content
HTML-Parser >= 3.40, Konqueror 3.4.3, MSIE 7.0 beta 2
HTML-Parser <= 3.38, FireFox 1.5, Safari 2.0
expand Unicode entities that are not terminated by semicolon in text content
HTML-Parser <= 3.50, FireFox 1.5, Safari 2.0
HTML-Parser >= 3.51, Konqueror 3.4.3, MSIE 7.0 beta 2
expand Unicode entities that are not terminated by semicolon in attributes
HTML-Parser <= 3.50
HTML-Parser >= 3.51, FireFox 1.5, Konqueror 3.4.3, MSIE 7.0 beta 2, Safari 2.0
expand hex entities that are not terminated by semicolon in text content
HTML-Parser, FireFox 1.5, Konqueror 3.4.3, Safari 2.0
MSIE 7.0 beta 2
expand hex entities that are not terminated by semicolon in attributes
HTML-Parser, FireFox 1.5, Konqueror 3.4.3, MSIE 7.0 beta 2, Safari 2.0