Result:
found 674 distributions and 1899 files matching your query !
( run in 0.677 )
HTML-HTML5-Writer
view release on metacpan or search on metacpan
lib/HTML/HTML5/Writer.pm view on Meta::CPAN
if ($etc->nodeName eq '#text')
{ return $self->text($etc); }
elsif ($etc->nodeName eq '#comment')
{ return $self->comment($etc); }
elsif ($etc->nodeName eq '#cdata-section')
{ return $self->cdata($etc); }
elsif ($etc->isa('XML::LibXML::PI'))
{ return $self->pi($etc); }
else
{ return $self->element($etc); }
}
lib/HTML/HTML5/Writer.pm view on Meta::CPAN
return HTML::HTML5::Entities::decode($pi->textContent);
}
return $pi->toString;
}
sub cdata
{
my ($self, $text) = @_;
if ($self->is_polyglot && $text->parentNode->nodeName =~ /^(script|style)$/i)
{
return '/* <![CDATA[ */' . $text->nodeValue . '/* ]]> */';
lib/HTML/HTML5/Writer.pm view on Meta::CPAN
=item C<< $writer->text($node) >>
Outputs an XML::LibXML::Text as HTML.
=item C<< $writer->cdata($node) >>
Outputs an XML::LibXML::CDATASection as HTML.
=item C<< $writer->comment($node) >>
HTML-Laundry
view release on metacpan or search on metacpan
lib/HTML/Laundry.pm view on Meta::CPAN
use Scalar::Util 'blessed';
my @fragments;
my $unacceptable_count;
my $local_unacceptable_count;
my $cdata_dirty;
my $in_cdata;
my $tag_leading_whitespace = qr/
(?<=<) # Left bracket followed by
\s* # any amount of whitespace
(\/?) # optionally with a forward slash
\s* # and then more whitespace
lib/HTML/Laundry.pm view on Meta::CPAN
$self->{parser} = HTML::Parser->new(
api_version => 3,
utf8_mode => 1,
start_h => [ sub { $self->_tag_start_handler(@_) }, 'tagname,attr' ],
end_h => [ sub { $self->_tag_end_handler(@_) }, 'tagname,attr' ],
text_h => [ sub { $self->_text_handler(@_) }, 'dtext,is_cdata' ],
empty_element_tags => 1,
marked_sections => 1,
);
$self->{cdata_parser} = HTML::Parser->new(
api_version => 3,
utf8_mode => 1,
start_h => [ sub { $self->_tag_start_handler(@_) }, 'tagname,attr' ],
end_h => [ sub { $self->_tag_end_handler(@_) }, 'tagname,attr' ],
text_h => [ sub { $self->_text_handler(@_) }, 'dtext' ],
lib/HTML/Laundry.pm view on Meta::CPAN
$self->_reset_state();
if ( $self->{trim_tag_whitespace} ) {
$chunk =~ s/$tag_leading_whitespace/$1/gs;
}
my $p = $self->{parser};
my $cp = $self->{cdata_parser};
$p->parse($chunk);
if ( !$in_cdata && !$unacceptable_count ) {
$p->eof();
}
if ( $in_cdata && !$local_unacceptable_count ) {
$cp->eof();
}
my $output = $self->gen_output;
$cp->eof(); # Clear buffer if we haven't already
if ($cdata_dirty) { # Overkill to get out of CDATA parser state
$self->{parser} = HTML::Parser->new(
api_version => 3,
start_h =>
[ sub { $self->_tag_start_handler(@_) }, 'tagname,attr' ],
end_h => [ sub { $self->_tag_end_handler(@_) }, 'tagname,attr' ],
text_h => [ sub { $self->_text_handler(@_) }, 'dtext,is_cdata' ],
empty_element_tags => 1,
marked_sections => 1,
);
}
else {
lib/HTML/Laundry.pm view on Meta::CPAN
sub _reset_state {
my ($self) = @_;
@fragments = ();
$unacceptable_count = 0;
$local_unacceptable_count = 0;
$in_cdata = 0;
$cdata_dirty = 0;
return;
}
sub _tag_start_handler {
my ( $self, $tagname, $attr ) = @_;
if ( !$self->_run_callbacks( q{start_tag}, \$tagname, $attr ) ) {
return;
}
if ( !$in_cdata ) {
$cdata_dirty = 0;
}
my @attributes;
foreach my $k ( keys %{$attr} ) {
if ( $self->{acceptable_a}->{$k} ) {
if ( grep {/^$k$/} @{ $self->{uri_list}->{$tagname} } ) {
lib/HTML/Laundry.pm view on Meta::CPAN
push @fragments, "<$tagname$attributes>";
}
}
else {
if ( $self->{unacceptable_e}->{$tagname} ) {
if ($in_cdata) {
$local_unacceptable_count += 1;
}
else {
$unacceptable_count += 1;
}
lib/HTML/Laundry.pm view on Meta::CPAN
sub _tag_end_handler {
my ( $self, $tagname ) = @_;
if ( !$self->_run_callbacks( q{end_tag}, \$tagname ) ) {
return;
}
if ( !$in_cdata ) {
$cdata_dirty = 0;
}
if ( $self->{acceptable_e}->{$tagname} ) {
if ( !$self->{empty_e}->{$tagname} ) {
push @fragments, "</$tagname>";
}
}
else {
if ( $self->{unacceptable_e}->{$tagname} ) {
if ($in_cdata) {
$local_unacceptable_count -= 1;
$local_unacceptable_count = 0
if ( $local_unacceptable_count < 0 );
}
else {
lib/HTML/Laundry.pm view on Meta::CPAN
}
return;
}
sub _text_handler {
my ( $self, $text, $is_cdata ) = @_;
if ( $in_cdata && $local_unacceptable_count ) {
return;
}
if ($unacceptable_count) {
return;
}
if ($is_cdata) {
my $cp = $self->{cdata_parser};
$in_cdata = 1;
$cp->parse($text);
if ( !$local_unacceptable_count ) {
$cp->eof();
}
$cdata_dirty = 1;
$in_cdata = 0;
return;
}
else {
if ( !$self->_run_callbacks( q{text}, \$text, $is_cdata ) ) {
return q{};
}
$text = encode_entities( $text, '<>&"' );
$cdata_dirty = 0;
}
push @fragments, $text;
return;
}
HTML-Make-Calendar
view release on metacpan or search on metacpan
examples/menu.pl view on Meta::CPAN
ðŸ‡ðŸˆðŸ‰ðŸŠðŸ‹ðŸŒðŸðŸ¥ðŸŽðŸðŸðŸ‘ðŸ’ðŸ“ðŸ¥ðŸ…ðŸ¥
ðŸ…🥒🥬🥦🧄🧅ðŸ„🥜🌰ðŸ˜ðŸ™ðŸšðŸ›ðŸœðŸðŸ ðŸ¢
ðŸ£ðŸ¤ðŸ¥ðŸ¥®ðŸ¡ðŸ¥ŸðŸ¥ 🥡🦪ðŸ¦ðŸ§ðŸ¨ðŸ©ðŸªðŸŽ‚ðŸ°ðŸ§
EOF
@foods = grep {!/\s/} @foods;
my $cal = calendar (cdata => \@foods, dayc => \&add_food);
print $cal->text ();
exit;
sub add_food
{
HTML-MyHTML
view release on metacpan or search on metacpan
source/myhtml/tokenizer.c view on Meta::CPAN
/////////////////////////////////////////////////////////
//// RCDATA
////
/////////////////////////////////////////////////////////
size_t myhtml_tokenizer_state_rcdata(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size)
{
if(tree->tmp_tag_id == 0) {
token_node->raw_begin = (html_offset + tree->global_offset);
mythread_queue_node_t* prev_qnode = mythread_queue_get_prev_node(tree->current_qnode);
source/myhtml/tokenizer.c view on Meta::CPAN
}
return html_offset;
}
size_t myhtml_tokenizer_state_rcdata_less_than_sign(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size)
{
if(html[html_offset] == '/')
{
html_offset++;
myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA_END_TAG_OPEN;
source/myhtml/tokenizer.c view on Meta::CPAN
}
return html_offset;
}
size_t myhtml_tokenizer_state_rcdata_end_tag_open(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size)
{
if(myhtml_tokenizer_chars_map[ (unsigned char)html[html_offset] ] == MyHTML_TOKENIZER_CHAR_A_Z_a_z)
{
myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA_END_TAG_NAME;
}
source/myhtml/tokenizer.c view on Meta::CPAN
token_node->type |= MyHTML_TOKEN_TYPE_CLOSE;
return true;
}
size_t myhtml_tokenizer_state_rcdata_end_tag_name(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size)
{
size_t tmp_begin = token_node->raw_begin;
token_node->raw_begin = html_offset + tree->global_offset;
while(html_offset < html_size)
source/myhtml/tokenizer.c view on Meta::CPAN
/////////////////////////////////////////////////////////
//// CDATA
////
/////////////////////////////////////////////////////////
size_t myhtml_tokenizer_state_cdata_section(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size)
{
if((token_node->type & MyHTML_TOKEN_TYPE_CDATA) == 0)
token_node->type |= MyHTML_TOKEN_TYPE_CDATA;
while(html_offset < html_size)
source/myhtml/tokenizer.c view on Meta::CPAN
myhtml->parse_state_func[MyHTML_TOKENIZER_STATE_COMMENT_END] = myhtml_tokenizer_state_comment_end;
myhtml->parse_state_func[MyHTML_TOKENIZER_STATE_COMMENT_END_DASH] = myhtml_tokenizer_state_comment_end_dash;
myhtml->parse_state_func[MyHTML_TOKENIZER_STATE_COMMENT_END_BANG] = myhtml_tokenizer_state_comment_end_bang;
myhtml->parse_state_func[MyHTML_TOKENIZER_STATE_BOGUS_COMMENT] = myhtml_tokenizer_state_bogus_comment;
// cdata
myhtml->parse_state_func[MyHTML_TOKENIZER_STATE_CDATA_SECTION] = myhtml_tokenizer_state_cdata_section;
// rcdata
myhtml->parse_state_func[MyHTML_TOKENIZER_STATE_RCDATA] = myhtml_tokenizer_state_rcdata;
myhtml->parse_state_func[MyHTML_TOKENIZER_STATE_RCDATA_LESS_THAN_SIGN] = myhtml_tokenizer_state_rcdata_less_than_sign;
myhtml->parse_state_func[MyHTML_TOKENIZER_STATE_RCDATA_END_TAG_OPEN] = myhtml_tokenizer_state_rcdata_end_tag_open;
myhtml->parse_state_func[MyHTML_TOKENIZER_STATE_RCDATA_END_TAG_NAME] = myhtml_tokenizer_state_rcdata_end_tag_name;
// rawtext
myhtml->parse_state_func[MyHTML_TOKENIZER_STATE_RAWTEXT] = myhtml_tokenizer_state_rawtext;
myhtml->parse_state_func[MyHTML_TOKENIZER_STATE_RAWTEXT_LESS_THAN_SIGN] = myhtml_tokenizer_state_rawtext_less_than_sign;
myhtml->parse_state_func[MyHTML_TOKENIZER_STATE_RAWTEXT_END_TAG_OPEN] = myhtml_tokenizer_state_rawtext_end_tag_open;
source/myhtml/tokenizer.c view on Meta::CPAN
myhtml->parse_state_func[(MyHTML_TOKENIZER_STATE_LAST_ENTRY
+ MyHTML_TOKENIZER_STATE_COMMENT_END_BANG)] = myhtml_tokenizer_end_state_comment_end_bang;
myhtml->parse_state_func[(MyHTML_TOKENIZER_STATE_LAST_ENTRY
+ MyHTML_TOKENIZER_STATE_BOGUS_COMMENT)] = myhtml_tokenizer_end_state_bogus_comment;
// for ends cdata
myhtml->parse_state_func[(MyHTML_TOKENIZER_STATE_LAST_ENTRY
+ MyHTML_TOKENIZER_STATE_CDATA_SECTION)] = myhtml_tokenizer_end_state_cdata_section;
// rcdata
myhtml->parse_state_func[(MyHTML_TOKENIZER_STATE_LAST_ENTRY
+ MyHTML_TOKENIZER_STATE_RCDATA)] = myhtml_tokenizer_end_state_rcdata;
myhtml->parse_state_func[(MyHTML_TOKENIZER_STATE_LAST_ENTRY
+ MyHTML_TOKENIZER_STATE_RCDATA_LESS_THAN_SIGN)] = myhtml_tokenizer_end_state_rcdata_less_than_sign;
myhtml->parse_state_func[(MyHTML_TOKENIZER_STATE_LAST_ENTRY
+ MyHTML_TOKENIZER_STATE_RCDATA_END_TAG_OPEN)] = myhtml_tokenizer_end_state_rcdata_end_tag_open;
myhtml->parse_state_func[(MyHTML_TOKENIZER_STATE_LAST_ENTRY
+ MyHTML_TOKENIZER_STATE_RCDATA_END_TAG_NAME)] = myhtml_tokenizer_end_state_rcdata_end_tag_name;
// rawtext
myhtml->parse_state_func[(MyHTML_TOKENIZER_STATE_LAST_ENTRY
+ MyHTML_TOKENIZER_STATE_RAWTEXT)] = myhtml_tokenizer_end_state_rawtext;
myhtml->parse_state_func[(MyHTML_TOKENIZER_STATE_LAST_ENTRY
HTML-Packer
view release on metacpan or search on metacpan
- Fixed tests. Thanks to Kent Fredric.
- Changed possible values for do_javascript options.
1.001_001 2011-04-12
- Added html5 option.
- Removed no_cdata option.
- Added tests.
- Minor bugfixes.
- Cleanup.
1.001001 2011-03-07
0.05_06 2011-01-05
- Changed requirements to Regexp::RegGrp 0.04.
0.05_05 2010-12-03
- Added no_cdata option.
0.05_04 2010-10-05
- Changed required perl version to 5.8.9.
0.05_03 2010-09-21
HTML-Parser
view release on metacpan or search on metacpan
lib/HTML/Parser.pm view on Meta::CPAN
"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");
lib/HTML/Parser.pm view on Meta::CPAN
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
lib/HTML/Parser.pm view on Meta::CPAN
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($_); }
HTML-PullParser-Nested
view release on metacpan or search on metacpan
lib/HTML/PullParser/Nested.pm view on Meta::CPAN
my $p = HTML::PullParser::Nested->new(
doc => \ "<html>...<ul><li>abcd<li>efgh<li>wvyz</ul>...<ul><li>1<li>2<li>9</ul></html>",
start => "'S',tagname,attr,attrseq,text",
end => "'E',tagname,text",
text => "'T',text,is_cdata",
);
while (my $token = $p->get_token()) {
if ($token->[0] eq "S" && $token->[1] eq "ul") {
$p->push_nest($token);
HTML-Quoted
view release on metacpan or search on metacpan
lib/HTML/Quoted.pm view on Meta::CPAN
handlers => {
start_document => [handle_doc_start => 'self'],
end_document => [handle_doc_end => 'self'],
start => [handle_start => 'self, tagname, attr, attrseq, text'],
end => [handle_end => 'self, tagname, text'],
text => [handle_text => 'self, text, is_cdata'],
default => [handle_default => 'self, event, text'],
},
);
$parser->empty_element_tags(1);
$parser->parse($_[0]);
HTML-StripScripts-LibXML
view release on metacpan or search on metacpan
q{<ins><p>valid p</p></ins>}
],
[ 'misplaced tr', q{misplaced <tr>}, q{misplaced <!--filtered-->} ],
[ 'misplaced td', q{misplaced <td>}, q{misplaced <!--filtered-->} ],
[ 'misplaced li', q{misplaced <li>}, q{misplaced <!--filtered-->} ],
[ 'misplaced cdata',
q{<table><tr>misplaced cdata<td>hello},
q{<table><tr/></table>misplaced cdata<!--filtered-->hello}
],
[ 'pass emtpy img', q{<img>}, q{<img/>} ],
[ 'block img src',
q{<img src="http://example.com/foo.png" />},
q{<img/>}
HTML-StripScripts-Parser
view release on metacpan or search on metacpan
q{<ins><p>valid p</p></ins>}
],
[ 'misplaced tr', q{misplaced <tr>}, q{misplaced <!--filtered-->} ],
[ 'misplaced td', q{misplaced <td>}, q{misplaced <!--filtered-->} ],
[ 'misplaced li', q{misplaced <li>}, q{misplaced <!--filtered-->} ],
[ 'misplaced cdata',
q{<table><tr>misplaced cdata<td>hello},
q{<table><tr></tr></table>misplaced cdata<!--filtered-->hello}
],
[ 'pass emtpy img', q{<img>}, q{<img />} ],
[ 'block img src',
q{<img src="http://example.com/foo.png" />},
q{<img />}
HTML-StripScripts-Regex
view release on metacpan or search on metacpan
[ 'i tag', qq{<i>hello mum\n}, "<i>hello mum\n</i>" ],
[ 'valid p', q{<ins><p>valid p</p></ins>}, q{<ins><p>valid p</p></ins>} ],
[ 'misplaced tr', q{misplaced <tr>}, q{misplaced <!--filtered-->} ],
[ 'misplaced td', q{misplaced <td>}, q{misplaced <!--filtered-->} ],
[ 'misplaced li', q{misplaced <li>}, q{misplaced <!--filtered-->} ],
[ 'misplaced cdata', q{<table><tr>misplaced cdata<td>hello}, q{<table><tr></tr></table>misplaced cdata<!--filtered-->hello} ],
[ 'pass emtpy img', q{<img>}, q{<img />} ],
[ 'block img src', q{<img src="http://example.com/foo.png" />}, q{<img />} ],
[ 'block a href', q{<a href="http://foo.foo/foo">x}, q{<a>x</a>} ],
[ 'block a mailto', q{<a href="mailto:foo@foo.foo">x}, q{<a>x</a>} ],
[ 'unknown tag', q{<foo>}, q{<!--filtered-->} ],
HTML-StripScripts
view release on metacpan or search on metacpan
lib/HTML/StripScripts.pm view on Meta::CPAN
=back
=head1 OTHER METHODS TO OVERRIDE
As well as the output, reject, init and cdata methods listed above,
it might make sense for subclasses to override the following methods:
=over
=item filter_text ( TEXT )
HTML-T5
view release on metacpan or search on metacpan
doctype => 'strict',
clean => 1,
css_prefix => 'myprefix',
drop_empty_paras => 0,
enclose_block_text => 1,
escape_cdata => 1,
hide_comments => 1,
replace_color => 1,
repeated_attributes => 'keep-first',
break_before_br => 1,
vertical_space => 1,
HTML-Template-Compiled-Plugin-VBEscape
view release on metacpan or search on metacpan
example/01_escape.pl view on Meta::CPAN
plugin => [qw(HTML::Template::Compiled::Plugin::VBEscape)],
tagstyle => [qw(-classic -comment +asp)],
scalarref => \<<'EOVB');
<script language="VBScript"><!--
string1 = "<%= attribute ESCAPE=VB%>"
string2 = "<%= cdata ESCAPE=VB%>"
'--></script>
EOVB
$htc->param(
attribute => 'foo "bar"',
cdata => 'text "with" double quotes',
);
() = print $htc->output();
# $Id$
HTML-Template-Compiled
view release on metacpan or search on metacpan
lib/HTML/Template/Compiled/Plugin/XMLEscape.pm view on Meta::CPAN
use HTML::Template::Compiled::Plugin::XMLEscape;
my $htc = HTML::Template::Compiled->new(
plugin => [qw(HTML::Template::Compiled::Plugin::XMLEscape)],
tagstyle => [qw(-classic -comment -asp +tt)],
scalarref => \'<foo attr="[%= attribute %]">[%= cdata escape=XML %]</foo>',
default_escape => 'XML_ATTR',
);
$htc->param(
attr => 'foo & bar',
cdata => 'text < with > tags',
);
print $htc->output;
Output:
HTML-Tested-ClassDBI
view release on metacpan or search on metacpan
lib/HTML/Tested/ClassDBI.pm view on Meta::CPAN
use base 'HTML::Tested';
use Carp;
use HTML::Tested::ClassDBI::Field;
use Data::Dumper;
my @_cdata = qw(_CDBI_Class _PrimaryFields _Field_Handlers _PrimaryKey);
__PACKAGE__->mk_classdata($_) for @_cdata;
our $VERSION = '0.23';
sub class_dbi_object { shift()->class_dbi_object_gr('_CDBIM_', @_); }
lib/HTML/Tested/ClassDBI.pm view on Meta::CPAN
as the default group.
=cut
sub bind_to_class_dbi_gr {
my ($class, $gr, $dbi_class, $opts) = @_;
$class->$_({}) for grep { !$class->$_ } @_cdata;
$class->_CDBI_Class->{$gr} = $dbi_class;
$class->_Field_Handlers->{$gr} = {};
$class->_PrimaryFields->{$gr} = {};
$class->cdbi_bind_from_fields($gr);
$class->_load_db_info($gr);
HTML-Tidy
view release on metacpan or search on metacpan
doctype => 'strict',
clean => 1,
css_prefix => 'myprefix',
drop_empty_paras => 0,
enclose_block_text => 1,
escape_cdata => 1,
hide_comments => 1,
replace_color => 1,
repeated_attributes => 'keep-first',
break_before_br => 1,
vertical_space => 1,
HTML-Tidy5
view release on metacpan or search on metacpan
doctype => 'strict',
clean => 1,
css_prefix => 'myprefix',
drop_empty_paras => 0,
enclose_block_text => 1,
escape_cdata => 1,
hide_comments => 1,
replace_color => 1,
repeated_attributes => 'keep-first',
break_before_br => 1,
vertical_space => 1,
HTML-Tree
view release on metacpan or search on metacpan
lib/HTML/TreeBuilder.pm view on Meta::CPAN
sub text {
return if $_[0]{'_stunted'};
# Accept a "here's a text token" signal from HTML::Parser.
my ( $self, $text, $is_cdata ) = @_;
# the >3.0 versions of Parser may pass a cdata node.
# Thanks to Gisle Aas for pointing this out.
return unless length $text; # I guess that's always right
my $ignore_text = $self->{'_ignore_text'};
lib/HTML/TreeBuilder.pm view on Meta::CPAN
my $no_expand_entities = $self->{'_no_expand_entities'};
my $pos = $self->{'_pos'} || $self;
HTML::Entities::decode($text)
unless $ignore_text
|| $is_cdata
|| $HTML::Tagset::isCDATA_Parent{ $pos->{'_tag'} }
|| $no_expand_entities;
#my($indent, $nugget);
if (DEBUG) {
HTML-TreeBuilder-XPath
view release on metacpan or search on metacpan
lib/HTML/TreeBuilder/XPath.pm view on Meta::CPAN
my $xml= $node->_start_tag;
if( $HTML::Tagset::isCDATA_Parent{$lc_name})
{ my $content= $node->{_content} || '';
if( ref $content eq 'ARRAY' || $content->isa( 'ARRAY'))
{ $xml .= _xml_escape_cdata( join( '', @$content), $opt); }
else
{ $xml .= $content; }
}
else
{ # start tag
lib/HTML/TreeBuilder/XPath.pm view on Meta::CPAN
my $content='';
if( $HTML::Tagset::isCDATA_Parent{$lc_name})
{ my $content= $node->{_content} || '';
if( ref $content && (ref $content eq 'ARRAY' || $content->isa( 'ARRAY') ))
{ $content= _xml_escape_cdata( join( '', @$content), $opt); }
}
else
{
my %child_opt= %$opt;
$child_opt{indent_level}++;
lib/HTML/TreeBuilder/XPath.pm view on Meta::CPAN
$text=~ s{([&<>])}{$CHAR2DEFAULT_ENT{$1}}g;
$text=~ s{--}{--}g; # can't have double --'s in XML comments
return $text;
}
sub _xml_escape_cdata
{ my( $text, $opt)= @_;
if( $opt->{force_escape_cdata} || $text=~ m{[<&]})
{ $text=~ s{^\s*\Q<![CDATA[}{}s;
$text=~ s{\Q]]>\E\s*$}{}s;
$text=~ s{]]>}{]]>}g; # can't have]]> in CDATA
$text= "<![CDATA[$text]]>";
}
HTML-Valid
view release on metacpan or search on metacpan
lib/HTML/Valid/Tagset.pm view on Meta::CPAN
# contradictory to the specification it claims to be based on.
our %is_Possible_Strict_P_Content = %isInline;
our %attr2type = (
'abbr' => 'pcdata',
'accept' => 'xtype',
'accept-charset' => 'charset',
'accesskey' => 'character',
'action' => 'action',
'add_date' => 'pcdata',
'align' => 'align',
'alink' => 'color',
'alt' => 'pcdata',
'archive' => 'urls',
'aria-activedescendant' => 'pcdata',
'aria-atomic' => 'pcdata',
'aria-autocomplete' => 'pcdata',
'aria-busy' => 'pcdata',
'aria-checked' => 'pcdata',
'aria-controls' => 'pcdata',
'aria-describedby' => 'pcdata',
'aria-disabled' => 'pcdata',
'aria-dropeffect' => 'pcdata',
'aria-expanded' => 'pcdata',
'aria-flowto' => 'pcdata',
'aria-grabbed' => 'pcdata',
'aria-haspopup' => 'pcdata',
'aria-hidden' => 'pcdata',
'aria-invalid' => 'pcdata',
'aria-label' => 'pcdata',
'aria-labelledby' => 'pcdata',
'aria-level' => 'pcdata',
'aria-live' => 'pcdata',
'aria-multiline' => 'pcdata',
'aria-multiselectable' => 'pcdata',
'aria-orientation' => 'pcdata',
'aria-owns' => 'pcdata',
'aria-posinset' => 'pcdata',
'aria-pressed' => 'pcdata',
'aria-readonly' => 'pcdata',
'aria-relevant' => 'pcdata',
'aria-required' => 'pcdata',
'aria-selected' => 'pcdata',
'aria-setsize' => 'pcdata',
'aria-sort' => 'pcdata',
'aria-valuemax' => 'pcdata',
'aria-valuemin' => 'pcdata',
'aria-valuenow' => 'pcdata',
'aria-valuetext' => 'pcdata',
'async' => 'bool',
'autocomplete' => 'pcdata',
'autofocus' => 'pcdata',
'autoplay' => 'pcdata',
'axis' => 'pcdata',
'background' => 'url',
'baseprofile' => 'pcdata',
'bgcolor' => 'color',
'bgproperties' => 'pcdata',
'border' => 'border',
'bordercolor' => 'color',
'bottommargin' => 'number',
'cellpadding' => 'length',
'cellspacing' => 'length',
'challenge' => 'pcdata',
'char' => 'character',
'charoff' => 'length',
'charset' => 'charset',
'checked' => 'bool',
'cite' => 'url',
'class' => 'pcdata',
'classid' => 'url',
'clear' => 'clear',
'code' => 'pcdata',
'codebase' => 'url',
'codetype' => 'xtype',
'color' => 'color',
'cols' => 'cols',
'colspan' => 'number',
'compact' => 'bool',
'content' => 'pcdata',
'contenteditable' => 'pcdata',
'contentscripttype' => 'pcdata',
'contentstyletype' => 'pcdata',
'contextmenu' => 'pcdata',
'controls' => 'pcdata',
'coords' => 'coords',
'data' => 'url',
'datafld' => 'pcdata',
'dataformatas' => 'pcdata',
'datapagesize' => 'number',
'datasrc' => 'url',
'datetime' => 'date',
'declare' => 'bool',
'default' => 'pcdata',
'defer' => 'bool',
'dir' => 'textdir',
'dirname' => 'pcdata',
'disabled' => 'bool',
'display' => 'pcdata',
'draggable' => 'pcdata',
'dropzone' => 'pcdata',
'encoding' => 'pcdata',
'enctype' => 'xtype',
'event' => 'pcdata',
'face' => 'pcdata',
'for' => 'idref',
'form' => 'pcdata',
'formaction' => 'pcdata',
'formenctype' => 'pcdata',
'formmethod' => 'pcdata',
'formnovalidate' => 'pcdata',
'formtarget' => 'pcdata',
'frame' => 'tframe',
'frameborder' => 'fborder',
'framespacing' => 'number',
'gridx' => 'number',
'gridy' => 'number',
'headers' => 'idrefs',
'height' => 'length',
'hidden' => 'pcdata',
'high' => 'pcdata',
'href' => 'url',
'hreflang' => 'lang',
'hspace' => 'number',
'http-equiv' => 'pcdata',
'icon' => 'pcdata',
'id' => 'iddef',
'ismap' => 'bool',
'itemid' => 'pcdata',
'itemprop' => 'pcdata',
'itemref' => 'pcdata',
'itemscope' => 'bool',
'itemtype' => 'url',
'keytype' => 'pcdata',
'kind' => 'pcdata',
'label' => 'pcdata',
'lang' => 'lang',
'language' => 'pcdata',
'last_modified' => 'pcdata',
'last_visit' => 'pcdata',
'leftmargin' => 'number',
'link' => 'color',
'list' => 'pcdata',
'longdesc' => 'url',
'loop' => 'pcdata',
'low' => 'pcdata',
'lowsrc' => 'url',
'manifest' => 'pcdata',
'marginheight' => 'number',
'marginwidth' => 'number',
'max' => 'pcdata',
'maxlength' => 'number',
'media' => 'media',
'mediagroup' => 'pcdata',
'method' => 'fsubmit',
'methods' => 'pcdata',
'min' => 'pcdata',
'multiple' => 'bool',
'n' => 'pcdata',
'name' => 'name',
'nohref' => 'bool',
'noresize' => 'bool',
'noshade' => 'bool',
'novalidate' => 'pcdata',
'nowrap' => 'bool',
'object' => 'pcdata',
'onabort' => 'pcdata',
'onafterprint' => 'pcdata',
'onafterupdate' => 'script',
'onbeforeprint' => 'pcdata',
'onbeforeunload' => 'script',
'onbeforeupdate' => 'script',
'onblur' => 'script',
'oncanplay' => 'pcdata',
'oncanplaythrough' => 'pcdata',
'onchange' => 'script',
'onclick' => 'script',
'oncontextmenu' => 'pcdata',
'oncuechange' => 'pcdata',
'ondataavailable' => 'script',
'ondatasetchanged' => 'script',
'ondatasetcomplete' => 'script',
'ondblclick' => 'script',
'ondrag' => 'pcdata',
'ondragend' => 'pcdata',
'ondragenter' => 'pcdata',
'ondragleave' => 'pcdata',
'ondragover' => 'pcdata',
'ondragstart' => 'pcdata',
'ondrop' => 'pcdata',
'ondurationchange' => 'pcdata',
'onemptied' => 'pcdata',
'onended' => 'pcdata',
'onerror' => 'pcdata',
'onerrorupdate' => 'script',
'onfocus' => 'script',
'onhashchange' => 'pcdata',
'oninput' => 'pcdata',
'oninvalid' => 'pcdata',
'onkeydown' => 'script',
'onkeypress' => 'script',
'onkeyup' => 'script',
'onload' => 'script',
'onloadeddata' => 'pcdata',
'onloadedmetadata' => 'pcdata',
'onloadstart' => 'pcdata',
'onmessage' => 'pcdata',
'onmousedown' => 'script',
'onmousemove' => 'script',
'onmouseout' => 'script',
'onmouseover' => 'script',
'onmouseup' => 'script',
'onmousewheel' => 'pcdata',
'onoffline' => 'pcdata',
'ononline' => 'pcdata',
'onpagehide' => 'pcdata',
'onpageshow' => 'pcdata',
'onpause' => 'pcdata',
'onplay' => 'pcdata',
'onplaying' => 'pcdata',
'onpopstate' => 'pcdata',
'onprogress' => 'pcdata',
'onratechange' => 'pcdata',
'onreadystatechange' => 'pcdata',
'onredo' => 'pcdata',
'onreset' => 'script',
'onresize' => 'pcdata',
'onrowenter' => 'script',
'onrowexit' => 'script',
'onscroll' => 'pcdata',
'onseeked' => 'pcdata',
'onseeking' => 'pcdata',
'onselect' => 'script',
'onshow' => 'pcdata',
'onstalled' => 'pcdata',
'onstorage' => 'pcdata',
'onsubmit' => 'script',
'onsuspend' => 'pcdata',
'ontimeupdate' => 'pcdata',
'onundo' => 'pcdata',
'onunload' => 'script',
'onvolumechange' => 'pcdata',
'onwaiting' => 'pcdata',
'open' => 'pcdata',
'optimum' => 'pcdata',
'pattern' => 'pcdata',
'placeholder' => 'pcdata',
'poster' => 'pcdata',
'preload' => 'pcdata',
'preserveaspectratio' => 'pcdata',
'profile' => 'url',
'prompt' => 'pcdata',
'pubdate' => 'pcdata',
'radiogroup' => 'pcdata',
'rbspan' => 'number',
'readonly' => 'bool',
'rel' => 'linktypes',
'required' => 'pcdata',
'rev' => 'linktypes',
'reversed' => 'pcdata',
'rightmargin' => 'number',
'role' => 'pcdata',
'rows' => 'number',
'rowspan' => 'number',
'rules' => 'trules',
'sandbox' => 'pcdata',
'scheme' => 'pcdata',
'scope' => 'scope',
'scoped' => 'pcdata',
'scrolling' => 'scroll',
'sdaform' => 'pcdata',
'sdapref' => 'pcdata',
'sdasuff' => 'pcdata',
'seamless' => 'pcdata',
'selected' => 'bool',
'shape' => 'shape',
'showgrid' => 'bool',
'showgridx' => 'bool',
'showgridy' => 'bool',
'size' => 'number',
'sizes' => 'pcdata',
'span' => 'number',
'spellcheck' => 'pcdata',
'src' => 'url',
'srcdoc' => 'pcdata',
'srclang' => 'pcdata',
'srcset' => 'pcdata',
'standby' => 'pcdata',
'start' => 'number',
'step' => 'pcdata',
'style' => 'pcdata',
'summary' => 'pcdata',
'tabindex' => 'number',
'target' => 'target',
'text' => 'color',
'title' => 'pcdata',
'topmargin' => 'number',
'type' => 'type',
'urn' => 'pcdata',
'usemap' => 'url',
'valign' => 'valign',
'value' => 'pcdata',
'valuetype' => 'vtype',
'version' => 'pcdata',
'viewbox' => 'pcdata',
'vlink' => 'color',
'vspace' => 'number',
'width' => 'length',
'wrap' => 'pcdata',
'x' => 'pcdata',
'xml:lang' => 'lang',
'xml:space' => 'pcdata',
'xmlns' => 'pcdata',
'y' => 'pcdata',
'zoomandpan' => 'pcdata',
);
# Private routine, for testing we got the tag info.
HTML-WebMake
view release on metacpan or search on metacpan
lib/HTML/WebMake/HTMLCleaner.pm view on Meta::CPAN
}
# --------------------------------------------------------------------------
sub text {
my($self, $origtext, $is_cdata) = @_;
if ($self->{in_pre} > 0) {
$self->{last_was_noninline_close_tag} = 0;
$self->{last_text_was_whitespace} = 0;
$self->add_text ($origtext);
HTML-Zoom
view release on metacpan or search on metacpan
t/bugs/void.t
t/doctype.t
t/dwim-autoload.t
t/flush.t
t/forms.t
t/parse_cdata.t
t/parser_weirdness.t
t/repeat_bugfixes.t
t/selectors.t
t/span.t
t/synopsis/filterbuilder.t
HTML5-DOM
view release on metacpan or search on metacpan
third_party/modest/include/myhtml/tokenizer_end.h view on Meta::CPAN
size_t myhtml_tokenizer_end_state_comment(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size);
size_t myhtml_tokenizer_end_state_comment_end(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size);
size_t myhtml_tokenizer_end_state_comment_end_dash(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size);
size_t myhtml_tokenizer_end_state_comment_end_bang(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size);
size_t myhtml_tokenizer_end_state_bogus_comment(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size);
size_t myhtml_tokenizer_end_state_cdata_section(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size);
size_t myhtml_tokenizer_end_state_rcdata(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size);
size_t myhtml_tokenizer_end_state_rcdata_less_than_sign(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size);
size_t myhtml_tokenizer_end_state_rcdata_end_tag_open(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size);
size_t myhtml_tokenizer_end_state_rcdata_end_tag_name(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size);
size_t myhtml_tokenizer_end_state_rawtext(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size);
size_t myhtml_tokenizer_end_state_rawtext_less_than_sign(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size);
size_t myhtml_tokenizer_end_state_rawtext_end_tag_open(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size);
size_t myhtml_tokenizer_end_state_rawtext_end_tag_name(myhtml_tree_t* tree, myhtml_token_node_t* token_node, const char* html, size_t html_offset, size_t html_size);
HTTP-DAV
view release on metacpan or search on metacpan
lib/HTTP/DAV/Lock.pm view on Meta::CPAN
$lock->set_type($lock_type);
}
# 3. RFC2518 allows only depth of 0,1,infinity
elsif ( $lock_prop_name eq "depth" ) {
my $lock_depth = HTTP::DAV::Utils::get_only_cdata($node_lock_param);
$lock->set_depth($lock_depth);
}
# 4. RFC2518 allows anything here.
# Patrick: I'm just going to convert the XML to a string
lib/HTTP/DAV/Lock.pm view on Meta::CPAN
$lock->set_owner( $node_lock_param->getFirstChild->toString );
}
# 5. RFC2518 (Section 9.8) e.g. Timeout: Second-234234 or Timeout: infinity
elsif ( $lock_prop_name eq "timeout" ) {
my $lock_timeout = HTTP::DAV::Utils::get_only_cdata($node_lock_param);
my $timeout = HTTP::DAV::Lock->interpret_timeout($lock_timeout);
$lock->set_timeout( $timeout );
#if ( $HTTP::DAV::DEBUG ) {
# $lock->{ "_timeout_val" } = HTTP::Date::time2str($timeout)
#}
lib/HTTP/DAV/Lock.pm view on Meta::CPAN
# 6. RFC2518 allows one or more <href>'s
# Push them all into the lock object.
elsif ( $lock_prop_name eq "locktoken" ) {
my @nodelist_hrefs = HTTP::DAV::Utils::get_elements_by_tag_name($node_lock_param,"D:href");
foreach my $node ( @nodelist_hrefs) {
my $href_cdata = HTTP::DAV::Utils::get_only_cdata( $node );
$lock->set_locktoken( $href_cdata );
}
}
} # Foreach property
} # Foreach ActiveLock
HTTP-OAI
view release on metacpan or search on metacpan
lib/HTTP/OAI/SAXHandler.pm view on Meta::CPAN
sub entity_reference {
my ($self,$hash) = @_;
HTTP::OAI::Debug::sax( $hash->{Name} );
}
sub start_cdata {
HTTP::OAI::Debug::sax();
}
sub end_cdata {
HTTP::OAI::Debug::sax();
}
sub comment {
HTTP::OAI::Debug::sax( $_[1]->{Data} );
HTTP-Promise
view release on metacpan or search on metacpan
lib/HTTP/Promise/MIME.pm view on Meta::CPAN
}
sub _data
{
my $data = <<'EOT';
{"application/vnd.is-xpr":["xpr"],"application/vnd.groove-help":["ghf"],"application/vnd.curl.pcurl":["pcurl"],"application/onenote":["onetoc","onetoc2","onetmp","onepkg"],"application/x-authorware-map":["aam"],"application/x-texinfo":["texinfo","tex...
EOT
return( \$data );
}
# NOTE: sub FREEZE is inherited
HTTP-Webdav
view release on metacpan or search on metacpan
=item Callback function: endelm_cb
int = endelm_cb (userdata,s,cdata)
Called when a complete element is parsed
=item s
const struct ne_xml_elm *
=item cdata
<string>
=back
=back
=head2 $hip -> push_mixed_handler (elements,validate_cb,startelm_cb,cdata_cb,endelm_cb)
Add a handler which uses a mixed-mode cdata callback
=over 4
=item Arguments
=back
=item Callback function: cdata_cb
cdata_cb (userdata,s,cdata,len)
=over 4
=item s
const struct ne_xml_elm *
=item cdata
<string>
=item len
=item Callback function: endelm_cb
int = endelm_cb (userdata,s,cdata)
Called when a complete element is parsed
=item s
const struct ne_xml_elm *
=item cdata
<string>
Handel
view release on metacpan or search on metacpan
demo/axkit/style/xsl/cart.xsl view on Meta::CPAN
<?xml version="1.0" encoding="UTF-8"?>
<!-- $Id$ -->
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" cdata-section-elements="CDATA" version="1.0">
<xsl:output method="xml" omit-xml-declaration="no" encoding="UTF-8"/>
<xsl:template match="@*|node()">
<xsl:copy>
<xsl:apply-templates select="@*|node()"/>
Hatena-Keyword
view release on metacpan or search on metacpan
lib/Hatena/Keyword.pm view on Meta::CPAN
my $body = shift or croak sprintf 'usage %s->extract($text)', $class;
my $args = shift || {};
$args->{mode} = 'lite';
my $res = $class->_call_rpc_with_cache($body, $args)
or $class->error($class->errstr);
my @keywords = map { $class->_instance_from_rpcdata($_) }@{$res->{wordlist}};
return wantarray ? @keywords : \@keywords;
}
sub markup_as_html {
my $class = shift;
lib/Hatena/Keyword.pm view on Meta::CPAN
RPC::XML::request->new('hatena.setkeywordlink', $params),
);
return ref $res ? $res : $class->error(qq/RPC Error: "$res"/);
}
sub _instance_from_rpcdata {
my ($class, $data) = @_;
return $class->new({
map {$_ => $data->{$_}->value } @Fields,
});
}
( run in 0.677 second using v1.01-cache-2.11-cpan-454fe037f31 )