Result:
found more than 681 distributions - search limited to the first 2000 files matching your query
( run in 0.902 )
Pcore
view release on metacpan or search on metacpan
share/data/mime.yaml view on Meta::CPAN
mbk:
- application/vnd.mobius.mbk
mbox:
- application/mbox
mc1:
- application/vnd.medcalcdata
mcd:
- application/vnd.mcd
mcurl:
- text/vnd.curl.mcurl
mdb:
Perinci-CmdLine-Classic
view release on metacpan or search on metacpan
lib/Perinci/CmdLine/Classic/Role/Help.pm view on Meta::CPAN
} else {
$ct .= ($ct ? "\n" : "") . $pn .
" " . __("<subcommand> [options]");
}
} else {
my $usage = $r->{_help_clidocdata}{usage_line};
$usage =~ s/\[\[prog\]\]/$pn/;
$usage =~ s/\[options\]/__("[options]")/e;
$ct .= ($ct ? "\n" : "") . $usage;
}
$self->_help_add_heading($r, __("Usage"));
lib/Perinci/CmdLine/Classic/Role/Help.pm view on Meta::CPAN
}
sub help_section_options {
my ($self, $r) = @_;
my $opts = $r->{_help_clidocdata}{opts};
return unless keys %$opts;
my $verbose = $r->{_help_verbose};
my $info = $r->{_help_info};
my $meta = $r->{_help_meta};
lib/Perinci/CmdLine/Classic/Role/Help.pm view on Meta::CPAN
sub help_section_examples {
my ($self, $r) = @_;
my $verbose = $r->{_help_verbose};
my $meta = $r->{_help_meta};
my $egs = $r->{_help_clidocdata}{examples};
return unless $egs && @$egs;
$self->_help_add_heading($r, __("Examples"));
my $pn = $self->_color(
'program_name', $self->get_program_and_subcommand_name($r));
lib/Perinci/CmdLine/Classic/Role/Help.pm view on Meta::CPAN
unless $res->[0] == 200;
$r->{_help_meta} = $res->[2]; # cache here
}
# get cli opt spec
unless ($r->{_help_clidocdata}) {
require Perinci::Sub::To::CLIDocData;
my $res = Perinci::Sub::To::CLIDocData::gen_cli_doc_data_from_meta(
meta => $r->{_help_meta}, meta_is_normalized => 1,
common_opts => $self->common_opts,
per_arg_json => $self->per_arg_json,
per_arg_yaml => $self->per_arg_yaml,
);
die [500, "Can't gen_cli_doc_data_from_meta: $res->[0] - $res->[1]"]
unless $res->[0] == 200;
$r->{_help_clidocdata} = $res->[2]; # cache here
}
# ux: since --verbose will potentially show lots of paragraph text, let's
# default to 80 and not wider width, unless user specifically requests
# column width via COLUMNS.
Perinci-CmdLine-Help
view release on metacpan or search on metacpan
lib/Perinci/CmdLine/Help.pm view on Meta::CPAN
my $sum = $args{program_summary} // $meta->{summary};
last unless $sum;
push @help, $progname, " - ", $sum, "\n\n";
}
my $clidocdata;
# usage
push @help, "Usage:\n";
{
for (sort {
lib/Perinci/CmdLine/Help.pm view on Meta::CPAN
(lang => $args{lang}) x defined($args{lang}),
(mark_different_lang => $args{mark_different_lang}) x defined($args{mark_different_lang}),
);
die [500, "gen_cli_doc_data_from_meta failed: ".
"$res->[0] - $res->[1]"] unless $res->[0] == 200;
$clidocdata = $res->[2];
my $usage = $clidocdata->{usage_line};
$usage =~ s/\[\[prog\]\]/$progname/;
local $Text::Wrap::break = '(?=\s)\X|(?<=\\|)';
push @help, Text::Wrap::wrap(" ", " ", "$usage\n");
}
lib/Perinci/CmdLine/Help.pm view on Meta::CPAN
}
# example
{
# XXX categorize too, like options
last unless @{ $clidocdata->{examples} };
push @help, "\nExamples:\n";
my $i = 0;
my $egs = $clidocdata->{examples};
for my $eg (@$egs) {
$i++;
my $cmdline = $eg->{cmdline};
$cmdline =~ s/\[\[prog\]\]/$progname/;
push @help, "\n" if $eg->{summary} && $i > 1;
lib/Perinci/CmdLine/Help.pm view on Meta::CPAN
# options
{
require Data::Dmp;
my $opts = $clidocdata->{opts};
last unless keys %$opts;
# find all the categories
my %options_by_cat; # val=[options...]
for my $optkey (keys %$opts) {
for my $cat (@{ $opts->{$optkey}{categories} }) {
push @{ $options_by_cat{$cat} }, $optkey;
}
}
my $cats_spec = $clidocdata->{option_categories};
for my $cat (sort {
($cats_spec->{$a}{order} // 50) <=> ($cats_spec->{$b}{order} // 50)
|| $a cmp $b }
keys %options_by_cat) {
# find the longest option
Perinci-CmdLine-POD
view release on metacpan or search on metacpan
lib/Perinci/CmdLine/POD.pm view on Meta::CPAN
join "", @res;
}
sub _list_config_params {
my ($clidocdata, $filter) = @_;
my $opts = $clidocdata->{opts};
my %param2opts;
for (keys %$opts) {
my $ospec = $opts->{$_};
next unless $ospec->{common_opt} && $ospec->{common_opt_spec}{is_settable_via_config};
next if $filter && !$filter->($ospec);
lib/Perinci/CmdLine/POD.pm view on Meta::CPAN
# script has its metadata in its main:: instead of from a module, so let's
# put it there
local %main::SPEC = %{ $dump_res->[3]{'func.meta'} }
if $dump_res->[3]{'func.meta'};
# generate clidocdata(for all subcommands; if there is no subcommand then it
# is stored in key '')
my %clidocdata; # key = subcommand name
my %urls; # key = subcommand name
{
require Perinci::Sub::To::CLIDocData;
lib/Perinci/CmdLine/POD.pm view on Meta::CPAN
per_arg_json => $cli->{per_arg_json},
per_arg_yaml => $cli->{per_arg_yaml},
);
die "Can't gen_cli_doc_data_from_meta: $res->[0] - $res->[1]"
unless $res->[0] == 200;
$clidocdata{''} = $res->[2];
if ($cli->{subcommands}) {
if (ref($cli->{subcommands}) eq 'CODE') {
die "Script '$args{script}': sorry, coderef 'subcommands' not ".
"supported yet";
lib/Perinci/CmdLine/POD.pm view on Meta::CPAN
per_arg_json => $cli->{per_arg_json},
per_arg_yaml => $cli->{per_arg_yaml},
);
die "Can't gen_cli_doc_data_from_meta (subcommand $sc_name): $res->[0] - $res->[1]"
unless $res->[0] == 200;
$clidocdata{$sc_name} = $res->[2];
}
}
}
my $gen_sc = $args{gen_subcommand};
lib/Perinci/CmdLine/POD.pm view on Meta::CPAN
my $has_examples;
{
my @sectpod;
my @examples;
for my $sc_name (sort keys %clidocdata) {
if ($cli->{subcommands}) {
next unless length $sc_name;
if (defined $gen_sc) { next unless $sc_name eq $gen_sc }
}
my $i = 1;
for my $eg (@{ $clidocdata{$sc_name}{examples} }) {
# add pointer to subcommand, we need it later to show result
$eg->{_sc_name} = $sc_name;
$eg->{_i} = $i;
push @examples, $eg;
$i++;
lib/Perinci/CmdLine/POD.pm view on Meta::CPAN
}
if ($cli->{subcommands}) {
# 2a. show per-subcommand usage lines, if there are subcommands
if ($gen_scs) {
for my $sc_name (sort keys %clidocdata) {
next unless length $sc_name;
if (defined $gen_sc) { next unless $sc_name eq $gen_sc }
my $subcmd_usage = $clidocdata{$sc_name}->{'usage_line.alt.fmt.pod'};
$subcmd_usage =~ s/\[\[prog\]\]/$program_name $sc_name/g;
push @usage, "$subcmd_usage\n\n";
}
} else {
push @usage, "B<$program_name> [I<options>] [I<subcommand>] [I<arg>]...\n\n";
}
push @usage, "\n\n";
} else {
# 2b. show main usage line
my $main_usage = $clidocdata{''}->{'usage_line.alt.fmt.pod'};
$main_usage =~ s/\[\[prog\]\]/$program_name/g;
push @usage, "$main_usage\n\n";
}
$resmeta->{'func.usage'} = join('', @usage);
lib/Perinci/CmdLine/POD.pm view on Meta::CPAN
my @sectpod;
my %sc_spec_refs; # key=ref address, val=first subcommand name
my $i = -1;
for my $sc_name (sort keys %clidocdata) {
next unless length $sc_name;
$i++;
my $sc_spec = $cli->{subcommands}{$sc_name};
my $spec_same_as;
lib/Perinci/CmdLine/POD.pm view on Meta::CPAN
push @{ $resmeta->{'func.sections'} }, {name=>'SUBCOMMANDS', content=>join("", @sectpod), ignore=>1};
push @pod, "=head1 SUBCOMMANDS\n\n", @sectpod;
}
my @sc_names = grep { length } sort keys %clidocdata;
# section: OPTIONS
{
my @sectpod;
push @sectpod, "C<*> marks required options.\n\n";
lib/Perinci/CmdLine/POD.pm view on Meta::CPAN
# first display options tagged with 'common' as well as common
# option (non-function argument option, like --format or
# --log-level). these are supposed to be the same across
# subcommands.
{
my $opts = $clidocdata{ $sc_names[0] }{opts};
my @opts = sort {
(my $a_without_dash = $a) =~ s/^-+//;
(my $b_without_dash = $b) =~ s/^-+//;
lc($a) cmp lc($b);
} grep {$check_common_arg->($opts, $_)} keys %$opts;
lib/Perinci/CmdLine/POD.pm view on Meta::CPAN
$sc_spec_refs{"$sc_spec"} = $sc_name;
}
next if defined $spec_same_as;
next if $sc_spec->{is_alias};
my $opts = $clidocdata{$sc_name}{opts};
my @opts = sort {
(my $a_without_dash = $a) =~ s/^-+//;
(my $b_without_dash = $b) =~ s/^-+//;
lc($a) cmp lc($b);
} grep {!$check_common_arg->($opts, $_)} keys %$opts;
lib/Perinci/CmdLine/POD.pm view on Meta::CPAN
push @sectpod, "=back\n\n";
}
}
} else {
my $k = defined $gen_sc ? $gen_sc : '';
my $opts = $clidocdata{$k}{opts};
# find all the categories
my %options_by_cat; # val=[options...]
for my $optkey (keys %$opts) {
for my $cat (@{ $opts->{$optkey}{categories} }) {
push @{ $options_by_cat{$cat} }, $optkey;
}
}
my $cats_spec = $clidocdata{$k}{option_categories};
for my $cat (sort {
($cats_spec->{$a}{order} // 50) <=> ($cats_spec->{$b}{order} // 50)
|| $a cmp $b }
keys %options_by_cat) {
push @sectpod, "=head2 $cat\n\n"
lib/Perinci/CmdLine/POD.pm view on Meta::CPAN
# first list the options tagged with 'common' and common options
# (non-function argument options, like --format or --log-level)
# which are supposed to be the same across subcommands.
push @sectpod, "=head2 Common for all subcommands\n\n" if $gen_scs;
my $param2opts = _list_config_params(
$clidocdata{$sc_names[0]},
sub { grep { $_ eq 'common' } @{ $_[0]->{tags} // []} || !$_[0]->{arg} });
for (sort keys %$param2opts) {
push @sectpod, " $_ (see $param2opts->{$_})\n";
}
push @sectpod, "\n";
lib/Perinci/CmdLine/POD.pm view on Meta::CPAN
my $sc_spec = $cli->{subcommands}{$sc_name};
next if $sc_spec->{is_alias};
my $sc_name_e = $sc_name =~ /\A\S+\z/ ? $sc_name : "'$sc_name'";
push @sectpod, "=head2 Configuration for subcommand $sc_name_e\n\n";
$param2opts = _list_config_params(
$clidocdata{$sc_name},
sub { !(grep { $_ eq 'common' } @{ $_[0]->{tags} // []}) && $_[0]->{arg} });
for (sort keys %$param2opts) {
push @sectpod, " $_ (see $param2opts->{$_})\n";
}
push @sectpod, "\n";
}
}
} else {
my $param2opts = _list_config_params($clidocdata{''});
for (sort keys %$param2opts) {
push @sectpod, " $_ (see $param2opts->{$_})\n";
}
push @sectpod, "\n";
}
lib/Perinci/CmdLine/POD.pm view on Meta::CPAN
# section: SEE ALSO
{
my @sectpod;
my %seen_urls;
for my $sc_name (sort keys %clidocdata) {
my $meta = $metas{$sc_name};
next unless $meta->{links};
for my $link0 (@{ $meta->{links} }) {
my $link = ref($link0) ? $link0 : {url=>$link0};
my $url = $link->{url};
Perinci-Sub-To-CLIDocData
view release on metacpan or search on metacpan
lib/Perinci/Sub/To/CLIDocData.pm view on Meta::CPAN
};
$ggls_res->[0] == 200 or return $ggls_res;
my $langprop_args = {lang=>$lang, mark_different_lang=>$mark_different_lang};
my $args_prop = $meta->{args} // {};
my $clidocdata = {
option_categories => {},
example_categories => {},
};
# a mapping from arg spec keys to %opts keys, so we can create a POD link
lib/Perinci/Sub/To/CLIDocData.pm view on Meta::CPAN
# --help or -v, they are put at the end. so if an argument
# option does not have category, we'll put it in the "main"
# category.
local $arg_spec->{tags} = ['category0:main']
if !$arg_spec->{tags} || !@{$arg_spec->{tags}};
_add_category_from_spec($clidocdata->{option_categories},
$opt, $arg_spec, "options", 1);
}
_add_default_from_arg_spec($opt, $arg_spec);
} else {
lib/Perinci/Sub/To/CLIDocData.pm view on Meta::CPAN
description =>
$rimeta->langprop($langprop_args, 'description'),
(default => $spec->{default}) x !!(exists($spec->{default}) && !$show_neg),
};
_add_category_from_spec($clidocdata->{option_categories},
$opt, $spec, "options", 1);
}
$opts{$optkey} = $opt;
lib/Perinci/Sub/To/CLIDocData.pm view on Meta::CPAN
next OPT1;
}
}
} # GEN_LIST_OF_OPTIONS
$clidocdata->{opts} = \%opts;
#use DDC; dd \%arg_spec_to_opts;
#use DDC; dd \%ospec_to_opts;
GEN_USAGE_LINE: {
lib/Perinci/Sub/To/CLIDocData.pm view on Meta::CPAN
push @{ $plain_opts[ $opt_locations{$key} ] }, $plain_opt;
push @{ $pod_opts [ $opt_locations{$key} ] }, $pod_opt;
#use Data::Dmp; print "key: $key, ospec: $ospec, ospecmeta: ", dmp($ospecmeta), ", argprop: ", dmp($argprop), ", copt: ", dmp($copt), "\n";
}
$clidocdata->{compact_usage_line} = "[[prog]]".
(keys(%args_prop) || keys(%$common_opts) ? " [options]" : ""). # XXX translatable?
(@plain_args ? " ".join(" ", @plain_args) : "");
$clidocdata->{usage_line} = "[[prog]]".
(@plain_opts+@plain_args ? " ".
join(" ",
(map { "[". join("|", @$_) . "]" } @plain_opts),
(@plain_opts && @plain_args ? ("--") : ()),
@plain_args,
) : "");
$clidocdata->{'usage_line.alt.fmt.pod'} = "B<[[prog]]>".
(@pod_opts+@pod_args ? " ".
join(" ",
(map { "[". join("|", @$_) . "]" } @pod_opts),
(@pod_opts && @pod_args ? ("--") : ()),
@pod_args,
lib/Perinci/Sub/To/CLIDocData.pm view on Meta::CPAN
summary => $rimeta->langprop($langprop_args, 'summary'),
description => $rimeta->langprop($langprop_args, 'description'),
example_spec => $eg,
};
# XXX show result from $eg
_add_category_from_spec($clidocdata->{example_categories},
$egdata, $eg, "examples", $has_cats);
push @examples, $egdata;
}
}
$clidocdata->{examples} = \@examples;
[200, "OK", $clidocdata];
}
1;
# ABSTRACT: From Rinci function metadata, generate structure convenient for producing CLI documentation (help/usage/POD)
lib/Perinci/Sub/To/CLIDocData.pm view on Meta::CPAN
This document describes version 0.305 of Perinci::Sub::To::CLIDocData (from Perl distribution Perinci-Sub-To-CLIDocData), released on 2022-11-14.
=head1 SYNOPSIS
use Perinci::Sub::To::CLIDocData qw(gen_cli_doc_data_from_meta);
my $clidocdata = gen_cli_doc_data_from_meta(meta => $meta);
Sample function metadata (C<$meta>):
{
args => {
Perinci-Sub-To-FishComplete
view release on metacpan or search on metacpan
lib/Perinci/Sub/To/FishComplete.pm view on Meta::CPAN
per_arg_json => $args{per_arg_json},
per_arg_yaml => $args{per_arg_yaml},
);
};
$gcd_res->[0] == 200 or return $gcd_res;
my $clidocdata = $gcd_res->[2];
my $cmdname = $args{cmdname};
if (!$cmdname) {
($cmdname = $0) =~ s!.+/!!;
}
my @cmds;
my $prefix = "complete -c ".shell_quote($cmdname);
push @cmds, "$prefix -e"; # currently does not work (fish bug)
for my $opt0 (sort keys %{ $clidocdata->{opts} }) {
my $ospec = $clidocdata->{opts}{$opt0};
my $req_arg;
for my $opt (split /, /, $opt0) {
$opt =~ s/^--?//;
$opt =~ s/=(.+)// and $req_arg = $1;
Perl6-Pugs
view release on metacpan or search on metacpan
ext/Rosetta/lib/Rosetta/TODO.pod view on Meta::CPAN
=item *
Implement starter Rosetta::Model module, which in its first post-rewrite
incarnation will resemble a limited XML DOM, having typed nodes with
attributes, but never having 'cdata' sections. Input checking will be kept
to a minimum initially, with Rosetta::Model assuming its input is correct;
eventually the input checking code will make up most of the mass of this
module, and most of that will be done on demand rather than automatically.
=item *
PerlPoint-Generator-XML
view release on metacpan or search on metacpan
lib/PerlPoint/Generator/XML.pm view on Meta::CPAN
# declare XML tags (TODO: should it become part of the object so that derived classes
# can access and adapt it?)
my %xmltags=(
# document root and other structures
__root => 'presentation',
__docdata => 'docdata',
__slides => 'slides',
__slide => 'slide',
# document data (meta data)
_title => 'title',
lib/PerlPoint/Generator/XML.pm view on Meta::CPAN
# the DATA section contains the DTD
__DATA__
<?xml version="1.0" encoding="UTF-8"?>
<!ELEMENT =__root= (=__docdata=, =__slides=)>
<!ELEMENT =__docdata= (=_author=, =_title=)>
<!ELEMENT =_author= (#PCDATA)>
<!ELEMENT =_title= (#PCDATA)>
<!ELEMENT =__slides= (=__slide=+)>
<!ELEMENT =__slide= (=headline= | =text= | =example= | =TABLE= | =ulist= | =olist= | =dlist= | %standalonetag;)+>
<!ENTITY % standalonetag "=IMAGE= | =INDEX=">
PerlPoint-Package
view release on metacpan or search on metacpan
examples/xmldefault2html.cfg view on Meta::CPAN
-xmldoctypeid "SYSTEM //W3C//DTD XHTML 1.0 Transitional//EN"
-tagtrans __root:html
-tagtrans __docdata:head
-tagtrans __slides:body
-tagtrans __slide:span
-tagtrans _title:title
PerlPoint-Template-TT2
view release on metacpan or search on metacpan
lib/PerlPoint/Template/TT2.pm view on Meta::CPAN
# derive ...
use base qw(PerlPoint::Template);
# declare object data fields
use fields qw(
docdata
tt2
);
# = LIBRARY SECTION ======================================================================
lib/PerlPoint/Template/TT2.pm view on Meta::CPAN
# build template directory path
my $tdir="$me->{generator}{cfg}{setup}{stylepath}/$options->{style}/templates";
# generate document data structure unless done before
unless ($me->{docdata})
{push(@{$me->{docdata}}, $me->preprocessData($_)) for 1..$me->numberOfChapters;}
# act action dependent: generate document pages
$params{action}==TEMPLATE_ACTION_DOC and do
{
# first look if there is a template defined
lib/PerlPoint/Template/TT2.pm view on Meta::CPAN
# the page data structure
{
options => $me->options, # options
page => $page, # page number
docdata => $me->{docdata}, # document data (structure, no contents except headlines)
slides => $slides, # prepared content
},
# target file name
$targetfile
Plack-App-MCCS
view release on metacpan or search on metacpan
local/lib/perl5/x86_64-linux-thread-multi/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");
local/lib/perl5/x86_64-linux-thread-multi/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
local/lib/perl5/x86_64-linux-thread-multi/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($_); }
Plack-Debugger
view release on metacpan or search on metacpan
share/js/jquery.js view on Meta::CPAN
},
// Contents
"empty": function( elem ) {
// http://www.w3.org/TR/selectors/#empty-pseudo
// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
// but not by others (comment: 8; processing instruction: 7; etc.)
// nodeType < 6 works because attributes (2) do not appear as children
for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
if ( elem.nodeType < 6 ) {
return false;
Pod-Confluence
view release on metacpan or search on metacpan
lib/Pod/Confluence.pm view on Meta::CPAN
}
sub end_L {
my ( $self, $attribute_hash ) = @_;
if ( $self->{link_type} eq 'pod' ) {
$self->{in_cdata} = 0;
$self->_print( ']]></ac:plain-text-link-body>' . '</ac:link>' );
}
elsif ( $self->{link_type} eq 'url' ) {
$self->_print('</a>');
}
lib/Pod/Confluence.pm view on Meta::CPAN
$self->{in_non_breaking} = 0;
}
sub end_Verbatim {
my ( $self, $attribute_hash ) = @_;
$self->{in_cdata} = 0;
$self->_print( $self->_confluence_macro_end( has_text => 1 ) );
pop( @{ $self->{element_stack} } );
}
sub _handle_element_end {
lib/Pod/Confluence.pm view on Meta::CPAN
}
sub handle_text {
my ( $self, $text ) = @_;
$text = encode_entities($text) unless ( $self->{in_cdata} );
$text =~ s/[ \t]/ /g if ( $self->{in_non_breaking} );
$logger->tracef( 'handle_text(%s)', $text );
$self->_print($text);
}
lib/Pod/Confluence.pm view on Meta::CPAN
. ( $to ? "<ri:page ri:content-title='$to' ri:space-key='$self->{space_key}'/>"
: ''
)
. '<ac:plain-text-link-body><![CDATA['
);
$self->{in_cdata} = 1;
}
else {
my $url = $to ? "https://metacpan.org/pod/$to" : '';
my $section = $attribute_hash->{section};
if ($section) {
lib/Pod/Confluence.pm view on Meta::CPAN
'code',
has_text => 1,
parameters => { language => 'perl' }
)
);
$self->{in_cdata} = 1;
}
1;
__END__
Pod-PXML
view release on metacpan or search on metacpan
lib/Pod/PXML.pm view on Meta::CPAN
$post = "</pod>\n"; # harmless newline, I figure.
} elsif($type eq 'for') {
$out .= "<for target=\"" . xml_attr_escape($it->get_arg) . "\">";
$out .= xml_escape_maybe_cdata($it->get_text);
$out .= "</for>\n\n";
return;
} elsif($type eq 'sequence') {
$type = lc($it->get_letter);
lib/Pod/PXML.pm view on Meta::CPAN
} elsif($type eq 'verbatim') {
( $FUSE_ADJACENT_PRES and $out =~ s/<\/pre>\n\n$//s )
or $out .= "<pre>";
# possibly combine adjacent verbatims into a single 'pre'
$out .= xml_escape_maybe_cdata("\n" . $it->get_text . "\n");
$out =~ s/]]><!\[CDATA\[// if $out =~ m/]]>$/s;
# combining adjacent CDATA sections is nice, and always harmless
$out .= "</pre>\n\n";
return;
lib/Pod/PXML.pm view on Meta::CPAN
return $out;
}
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
sub xml_escape_maybe_cdata { # not destructive
my $x;
$x = '' unless defined($x = $_[0]);
if($x =~ m/[&<>]/ and not $x =~ m/[^\x00-\x80]/) {
# CDATA only if uses those [&<>], and does not use anything highbit.
$x =~ s/]]>/]]>]]><!\[CDATA\[/g; # "escape" any ]]'s
lib/Pod/PXML.pm view on Meta::CPAN
use vars qw(%Acceptable_children);
{
# This just recapitulates what's in the DTD:
my $style = {map{;$_,1} qw(b i c x f s link)};
my $pstyle = {'#PCDATA',1, %$style};
my $pcdata = {'#PCDATA',1};
%Acceptable_children = (
'pod' => {map{;$_,1} qw(head1 head2 head3 head4 p pre list for)},
map(($_=>$pstyle), qw(head1 head2 head3 head4 p)),
'pre' => $pcdata,
'list' => {map{;$_,1} qw(item p pre list for)},
'item' => $pstyle,
'for' => $pcdata,
map(($_=>$pstyle), qw(link b i c f x s)),
);
}
sub xml2pod ($) {
Pod-ToDocBook
view release on metacpan or search on metacpan
lib/Pod/ToDocBook/DoSequences.pm view on Meta::CPAN
}
$el;
}
#process conten of code
sub on_cdata {
my ( $self, $el, $text ) = @_;
return $text unless $el->local_name eq 'code';
#clean
$text =~ s/^\w<(.*)>$/$1/;
lib/Pod/ToDocBook/DoSequences.pm view on Meta::CPAN
return $self->mk_characters( $el->{TITLE} );
}
elsif ( $code eq 'C' ) {
( my $literal = $el->mk_element('literal') )->attrs_by_name->{role} =
'code';
$literal->add_content( $self->mk_cdata( $el->{TITLE} ) );
return $literal;
}
elsif ( $code eq 'S' ) {
my $str = $el->{TITLE};
$str =~ s/\s(?![^<]*>)/ /gx;
Protocol-XMPP
view release on metacpan or search on metacpan
lib/Protocol/XMPP/Handler.pod view on Meta::CPAN
=over 4
=item L<XML::SAX::Base>
L<attlist_decl|XML::SAX::Base/attlist_decl>, L<attribute_decl|XML::SAX::Base/attribute_decl>, L<comment|XML::SAX::Base/comment>, L<doctype_decl|XML::SAX::Base/doctype_decl>, L<element_decl|XML::SAX::Base/element_decl>, L<end_cdata|XML::SAX::Base/end_...
=back
=head1 AUTHOR
Prty
view release on metacpan or search on metacpan
lib/Prty/Html/Tag.pm view on Meta::CPAN
# Liste aller Attribute und ihrer Domänen.
# FIXME: anhand DTD überprüfen
my %Attribute = (
'accept-charset'=>'charsets', # form
'http-equiv'=>'cdata', # meta
'xml:lang'=>'languageCode', # I18N (XHTML)
'xml:space'=>'space', # ENUM pre,script,style(XHTML)
abbr=>'text', # Cell
accept=>'contentTypes', # form,input
accesskey=>'character', # Focus,legend
action=>'uri', # form
align=>'cellAlign', # ENUM CellAlign
alt=>'cdata', # input(cdata);area,img(text)
archive=>'uriList', # object
axis=>'cdata', # Cell
border=>'pixels', # table
cellpadding=>'length', # table
cellspacing=>'length', # table
char=>'character', # CellAlign
charoff=>'length', # CellAlign
lib/Prty/Html/Tag.pm view on Meta::CPAN
classid=>'uri', # object
codebase=>'uri', # object
codetype=>'contentType', # object
cols=>'multiLengths', # frameset(multiLengths),textarea(number)
colspan=>'number', # Cell
content=>'cdata', # meta
coords=>'coords', # a, area
data=>'uri', # object
datetime=>'datetime', # del, ins
declare=>'bool', # object
defer=>'bool', # script
lib/Prty/Html/Tag.pm view on Meta::CPAN
rel=>'linkTypes', # ENUM a,link
rev=>'linkTypes', # ENUM a,link
rows=>'multiLengths', # frameset(multiLengths);textarea(number)
rowspan=>'number', # Cell
rules=>'trules', # ENUM table
scheme=>'cdata', # meta
scope=>'scope', # ENUM Cell
scoped=>'bool', # style
scrolling=>'scrolling', # ENUM frame,iframe
selected=>'bool', # option
shape=>'shape', # ENUM a,area
lib/Prty/Html/Tag.pm view on Meta::CPAN
title=>'text', # Core,style
type=>'ContentType', # button(ENUM);a,link,object,param,script,
# style;input(ENUM)
usemap=>'uri', # img,input,object
valign=>'cellValign', # ENUM CellAlign
value=>'cdata', # button,input,option,param
valuetype=>'valueType', # ENUM param
width=>'length', # iframe,img,object,table(length);
# col,colgroup(multiLength)
xmlns=>'uri', # html (XHTML)
);
lib/Prty/Html/Tag.pm view on Meta::CPAN
# Attribut-Domänen (werden aktuell nicht geprüft)
my %Domain = (
bool=>1,
buttonType=>[qw/button reset submit/],
cdata=>1,
cellAlign=>[qw/center char justify left right/],
cellValign=>[qw/baseline bottom middle top/],
character=>1,
charset=>1,
charsets=>1,
lib/Prty/Html/Tag.pm view on Meta::CPAN
<TAG ...>
CONTENT
</TAG>\n
=item 'c' (cdata)
Wie 'm', nur dass der Content in CDATA eingefasst wird:
<TAG ...>
// <![CDATA[
Qgoda
view release on metacpan or search on metacpan
lib/Qgoda/Processor/HTMLFilter.pm view on Meta::CPAN
my ($self, $content, $asset) = @_;
my $output = '';
my $handler = sub {
my ($event, $text, $tagname, $attr, $attrseq, $is_cdata) = @_;
my $chunk;
if ('start_document' eq $event || 'end_document' eq $event) {
$chunk = $output;
$output = '';
lib/Qgoda/Processor/HTMLFilter.pm view on Meta::CPAN
output => \$output,
text => $text,
tagname => $tagname,
attr => $attr,
attrseq => $attrseq,
is_cdata => $is_cdata,
asset => $asset,
);
}
$output .= $chunk;
};
my $parser = HTML::Parser->new(
comment_h => [$handler, 'event, text'],
declaration_h => [$handler, 'event, text'],
start_h => [$handler, 'event, text, tagname, attr, attrseq, is_cdata'],
end_h => [$handler, 'event, text, tagname'],
process_h => [$handler, 'event, text'],
text_h => [$handler, 'event, text'],
start_document_h => [$handler, 'event'],
);
Quiq
view release on metacpan or search on metacpan
lib/Quiq/Html/Tag.pm view on Meta::CPAN
# Liste aller Attribute und ihrer Domänen.
# FIXME: anhand DTD überprüfen
my %Attribute = (
'accept-charset' => 'charsets', # form
'http-equiv' => 'cdata', # meta
'xml:lang' => 'languageCode', # I18N (XHTML)
'xml:space' => 'space', # ENUM pre,script,style(XHTML)
abbr => 'text', # Cell
accept => 'contentTypes', # form,input
accesskey => 'character', # Focus,legend
action => 'uri', # form
align => 'cellAlign', # ENUM CellAlign
alt => 'cdata', # input(cdata);area,img(text)
archive => 'uriList', # object
axis => 'cdata', # Cell
border => 'pixels', # table
cellpadding => 'length', # table
cellspacing => 'length', # table
char => 'character', # CellAlign
charoff => 'length', # CellAlign
lib/Quiq/Html/Tag.pm view on Meta::CPAN
classid => 'uri', # object
codebase => 'uri', # object
codetype => 'contentType', # object
cols => 'multiLengths', # frameset(multiLengths),textarea(number)
colspan => 'number', # Cell
content => 'cdata', # meta
coords => 'coords', # a, area
data => 'uri', # object
datetime => 'datetime', # del, ins
declare => 'bool', # object
defer => 'bool', # script
lib/Quiq/Html/Tag.pm view on Meta::CPAN
rel => 'linkTypes', # ENUM a,link
rev => 'linkTypes', # ENUM a,link
rows => 'multiLengths', # frameset(multiLengths);textarea(number)
rowspan => 'number', # Cell
rules => 'trules', # ENUM table
scheme => 'cdata', # meta
scope => 'scope', # ENUM Cell
scoped => 'bool', # style
scrolling => 'scrolling', # ENUM frame,iframe
selected => 'bool', # option
shape => 'shape', # ENUM a,area
lib/Quiq/Html/Tag.pm view on Meta::CPAN
title => 'text', # Core,style
type => 'ContentType', # button(ENUM);a,link,object,param,script,
# style;input(ENUM)
usemap => 'uri', # img,input,object
valign => 'cellValign', # ENUM CellAlign
value => 'cdata', # button,input,option,param
valuetype => 'valueType', # ENUM param
width => 'length', # iframe,img,object,table(length);
# col,colgroup(multiLength)
xmlns => 'uri', # html (XHTML)
);
lib/Quiq/Html/Tag.pm view on Meta::CPAN
# Attribut-Domänen (werden aktuell nicht geprüft)
my %Domain = (
bool => 1,
buttonType => [qw/button reset submit/],
cdata => 1,
cellAlign => [qw/center char justify left right/],
cellValign => [qw/baseline bottom middle top/],
character => 1,
charset => 1,
charsets => 1,
lib/Quiq/Html/Tag.pm view on Meta::CPAN
<TAG ...>
CONTENT
</TAG>\n
=item 'c' (cdata)
Wie 'm', nur dass der Content in CDATA eingefasst wird:
<TAG ...>
// <![CDATA[
RDF-Endpoint
view release on metacpan or search on metacpan
share/www/js/parsexml.js view on Meta::CPAN
var XMLParser = Editor.Parser = (function() {
var Kludges = {
autoSelfClosers: {"br": true, "img": true, "hr": true, "link": true, "input": true,
"meta": true, "col": true, "frame": true, "base": true, "area": true},
doNotIndent: {"pre": true, "!cdata": true}
};
var NoKludges = {autoSelfClosers: {}, doNotIndent: {"!cdata": true}};
var UseKludges = Kludges;
var alignCDATA = false;
// Simple stateful tokenizer for XML documents. Returns a
// MochiKit-style iterator, with a state property that contains a
share/www/js/parsexml.js view on Meta::CPAN
if (ch == "<") {
if (source.equals("!")) {
source.next();
if (source.equals("[")) {
if (source.lookAhead("[CDATA[", true)) {
setState(inBlock("xml-cdata", "]]>"));
return null;
}
else {
return "xml-text";
}
share/www/js/parsexml.js view on Meta::CPAN
}
var harmlessTokens = {"xml-text": true, "xml-entity": true, "xml-comment": true, "xml-processing": true, "xml-doctype": true};
function element(style, content) {
if (content == "<") cont(tagname, attributes, endtag(tokenNr == 1));
else if (content == "</") cont(closetagname, expect(">"));
else if (style == "xml-cdata") {
if (!context || context.name != "!cdata") pushContext("!cdata");
if (/\]\]>$/.test(content)) popContext();
cont();
}
else if (harmlessTokens.hasOwnProperty(style)) cont();
else {markErr(); cont();}
RDF-NS
view release on metacpan or search on metacpan
share/prefix.cc view on Meta::CPAN
enc http://www.w3.org/2001/04/xmlenc# 20111028
environ http://eulersharp.sourceforge.net/2003/03swap/environment# 20111028
es http://eulersharp.sourceforge.net/2003/03swap/log-rules# 20111028
esd http://def.esd.org.uk/ 20111028
eu http://eulersharp.sourceforge.net/2003/03swap/log-rules# 20111028
eui http://institutions.publicdata.eu/# 20111028
event http://purl.org/NET/c4dm/event.owl# 20111028
events http://eulersharp.sourceforge.net/2003/03swap/event# 20111028
evopat http://ns.aksw.org/Evolution/ 20111028
evset http://dsnotify.org/vocab/eventset/0.1/ 20111028
ex http://example.com/ 20111028
share/prefix.cc view on Meta::CPAN
erce http://xxefe.de/ 20140901
esadm http://vocab.linkeddata.es/datosabiertos/def/sector-publico/territorio# 20140901
escjr http://vocab.linkeddata.es/datosabiertos/def/urbanismo-infraestructuras/callejero# 20140901
estatwrap http://ontologycentral.com/2009/01/eurostat/ns# 20140901
estrn http://vocab.linkeddata.es/datosabiertos/def/urbanismo-infraestructuras/transporte# 20140901
eurlex http://eur-lex.publicdata.eu/ontology/ 20140901
evident http://purl.org/net/evident# 20140901
ext http://def.seegrid.csiro.au/isotc211/iso19115/2003/extent# 20140901
fabio http://purl.org/spar/fabio/ 20140901
fam http://vocab.fusepool.info/fam# 20140901
fao http://fao.270a.info/dataset/ 20140901
RDF-RDFa-Parser
view release on metacpan or search on metacpan
share/catalogue/www.w3.org/MarkUp/DTD/xhtml-basic10-f.dtd view on Meta::CPAN
<!-- W3C XML 1.0 Recommendation -->
<!NOTATION w3c-xml
PUBLIC "ISO 8879//NOTATION Extensible Markup Language (XML) 1.0//EN" >
<!-- XML 1.0 CDATA -->
<!NOTATION cdata
PUBLIC "-//W3C//NOTATION XML 1.0: CDATA//EN" >
<!-- SGML Formal Public Identifiers -->
<!NOTATION fpi
PUBLIC "ISO 8879:1986//NOTATION Formal Public Identifier//EN" >
RDF-Trine-Node-Literal-XML
view release on metacpan or search on metacpan
t/xmlliteral.t view on Meta::CPAN
my $l = RDF::Trine::Node::Literal::XML->new( $doc , 'tlh' );
} 'lives on documentfragment node with lang';
lives_ok {
my $node = XML::LibXML::CDATASection->new( '<cdata>' );
my $l = RDF::Trine::Node::Literal::XML->new( $node );
} 'lives on cdatasection';
lives_ok {
my $parser = XML::LibXML->new();
my $doc = $parser->parse_string( '<root><bar>baz</bar><foo>dahut</foo></root>');
RPC-XML-Deparser-XS
view release on metacpan or search on metacpan
libxwrite.c view on Meta::CPAN
this->element_has_children = TRUE;
this->last_node_was_text = TRUE;
}
void xwrite_add_CDATA(XWrite* this, const gchar* cdata) {
#if HAVE_STRSTR
g_assert(strstr(cdata, "]]>") == NULL);
#endif
xwrite_finish_element(this);
xwrite_copy(this, "<![CDATA[");
xwrite_copy(this, cdata);
xwrite_copy(this, "]]>");
this->element_has_children = TRUE;
this->last_node_was_text = TRUE;
}
RPC-XML
view release on metacpan or search on metacpan
lib/RPC/XML/Parser/XMLParser.pm view on Meta::CPAN
my ($op, $newobj, $class, $list, $name);
# This should always be one of the stack machine ops defined above
$op = pop @{$robj->[M_STACK]};
my $cdata = q{};
if ($robj->[M_SPOOLING_BASE64_DATA])
{
$cdata = $robj->[M_CDATA];
seek $cdata, 0, 0;
}
elsif ($robj->[M_CDATA])
{
$cdata = join q{} => @{$robj->[M_CDATA]};
}
# Decide what to do from here
if (VALIDTYPES->{$elem}) ## no critic (ProhibitCascadingIfElse)
{
lib/RPC/XML/Parser/XMLParser.pm view on Meta::CPAN
$class = 'datetime_iso8601';
}
# Some minimal data-integrity checking
if ($class eq 'int' or $class eq 'i4' or $class eq 'i8')
{
if ($cdata !~ /^[-+]?\d+$/)
{
return error($robj, $self, 'Bad integer data read');
}
}
elsif ($class eq 'double')
{
if ($cdata !~
# Taken from perldata(1)
/^[+-]?(?=\d|[.]\d)\d*(?:[.]\d*)?(?:[Ee](?:[+-]?\d+))?$/x)
{
return error($robj, $self, 'Bad floating-point data read');
}
}
elsif ($class eq 'nil')
{
# We now allow parsing of <nil/> at all times.
# By definition though, it must be, well... nil.
if ($cdata !~ /^\s*$/)
{
return error($robj, $self, '<nil /> element must be empty');
}
}
$class = "RPC::XML::$class";
# The string at the end is only seen by the RPC::XML::base64 class
$newobj = $class->new($cdata, 'base64 is encoded, nil is allowed');
push @{$robj->[M_STACK]}, $newobj, DATAOBJECT;
if ($robj->[M_SPOOLING_BASE64_DATA])
{
$robj->[M_SPOOLING_BASE64_DATA] = 0;
$robj->[M_CDATA] = undef; # Won't close FH, $newobj still holds it
lib/RPC/XML/Parser/XMLParser.pm view on Meta::CPAN
return stack_error($robj, $self, $elem);
}
}
else
{
$newobj = RPC::XML::string->new($cdata);
}
push @{$robj->[M_STACK]}, $newobj, DATAOBJECT;
}
elsif ($elem eq 'param')
lib/RPC/XML/Parser/XMLParser.pm view on Meta::CPAN
push @{$robj->[M_STACK]}, $name, $newobj, STRUCTMEM;
}
elsif ($elem eq 'name')
{
# Fairly simple: just push the current content of CDATA on w/ a marker
push @{$robj->[M_STACK]}, $cdata, STRUCTNAME;
}
elsif ($elem eq 'struct')
{
# Create the hash table in-place, then pass the ref to the constructor
$list = {};
lib/RPC/XML/Parser/XMLParser.pm view on Meta::CPAN
return error(
$robj, $self,
"$elem tag must immediately follow a methodCall tag"
);
}
push @{$robj->[M_STACK]}, $cdata, NAMEVAL;
}
elsif ($elem eq 'methodCall')
{
# A methodCall closing should have on the stack an optional PARAMLIST
# marker, a NAMEVAL marker, then the METHOD token from the
RTF-HTMLConverter
view release on metacpan or search on metacpan
HTMLConverter.pm view on Meta::CPAN
my $buf = $self->set_new_group_buffer();
$self->parse();
return $buf->get_text();
}
sub get_parsed_group_pcdata { $_[0]->set_pcdata_mode(); $_[0]->get_parsed_group_text() }
sub set_group_cwhandler {
my ($self, $prefix) = @_;
my @oldvalues;
$oldvalues[0] = $self->set_token_handler(CWORD, 'pth_cword');
HTMLConverter.pm view on Meta::CPAN
sub store_notes {
my ($self, $arr) = splice(@_, 0, 2);
$self->add_on_leave_handler(sub { push @{$_[1]}, map { $_[0]->notes($_) } @{$_[2]} }, [$arr, [@_]]);
}
sub set_pcdata_mode { $_[0]->group_notes(pcdata => 1) }
sub _add_on_leave { unshift @{$_[0]->{$_[1]}[0]}, [$_[2], $_[3] || []] }
sub add_on_leave_handler { shift()->_add_on_leave('on_leave1', @_) }
HTMLConverter.pm view on Meta::CPAN
###### Font Table
sub cw_fonttbl {
my $self = shift;
$self->set_pcdata_mode();
$self->set_new_group_buffer();
$self->set_group_cwhandler('fcw_');
$self->parse();
my $deff = $self->notes('deff');
if(length $deff){
HTMLConverter.pm view on Meta::CPAN
sub fcw_f {
my ($self, $num) = @_;
my $font = {};
$self->notes(f => $font);
$self->notes('f'.$num => $font);
my $txt = $self->get_parsed_group_pcdata();
$txt =~ s/;$//;
$font->{face} = $txt;
}
sub fcw_fnil { delete (($_[0]->notes('f') || {})->{family}) }
HTMLConverter.pm view on Meta::CPAN
}
sub fcw_falt {
my $self = shift;
my $font = $self->notes('f');
my $txt = $self->get_parsed_group_pcdata();
($font || {})->{falt} = $txt;
}
sub _get_text_encoding {
($_[0]->notes('pcdata') ? {} : $_[0]->notes('f') || {})->{codepage}
|| $_[0]->notes('ansicpg') || $_[0]->{doc_codepage}
}
sub _get_font_family { $_[1]->{family} }
###### Color Table
sub cw_colortbl {
my $self = shift;
$self->set_pcdata_mode();
$self->notes(colortbl => []);
$self->group_notes(colortbl_current => [(undef)x3]);
$self->set_group_token_handler(PTEXT, 'th_ptext_colortbl');
}
HTMLConverter.pm view on Meta::CPAN
###### Style Sheet
sub cw_stylesheet {
my $self = shift;
$self->set_pcdata_mode();
$self->set_new_group_buffer();
$self->set_group_cwhandler('scw_');
my $oldh = $self->set_group_token_handler(ENTER, 'th_enter_style');
$self->group_notes(stylesheet_enter => $oldh);
}
HTMLConverter.pm view on Meta::CPAN
sub ltcw_listsimple { ($_[0]->notes('list') || {})->{simple} = $_[1] }
sub ltcw_listhybrid { ($_[0]->notes('list') || {})->{hybrid} = 1 }
sub ltcw_listname {
my $self = shift;
my $txt = $self->get_parsed_group_pcdata();
$txt =~ s/;$//;
($self->notes('list') || {})->{name} = $txt;
}
######## List Levels
HTMLConverter.pm view on Meta::CPAN
sub cw_info { }
sub cw_title {
my $self = shift;
my $text = $self->get_parsed_group_pcdata();
my $head = $self->get_head_element();
return unless $head;
my $title = $self->create_element('title', $head);
$self->append_text_node($title, $text);
}
HTMLConverter.pm view on Meta::CPAN
return $self->{ancors}{$txt} = 'a'.$self->{ancor_count}++;
}
sub cw_bkmkstart {
my $self = shift;
$self->set_pcdata_mode();
my $txt = $self->get_parsed_group_text();
my $name = $self->_get_ancor_name($txt);
my $el= $self->create_element('a');
$el->setAttribute(name => $name);
$self->append_text_node($el, ' ');
RTx-Foundry
view release on metacpan or search on metacpan
sbin/foundry-lib/VCP/Utils/svn.pm
sbin/foundry-lib/VCP/Utils/vss.pm
sbin/foundry-setup
sbin/foundry-svn-pre-revprop-change
sbin/foundry-svn-start-commit
sbin/foundry-syncdata
sbin/foundry-vcp
SIGNATURE
t/0-signature.t
var/kwiki/.default/config.yaml
var/kwiki/.default/css/Display.css
Rapi-Fs
view release on metacpan or search on metacpan
share/assets/misc/prism.css view on Meta::CPAN
.token.comment,
.token.block-comment,
.token.prolog,
.token.doctype,
.token.cdata {
color: #7D8B99;
}
.token.punctuation {
color: #5F6364;
RayApp
view release on metacpan or search on metacpan
lib/RayApp/DSD.pm view on Meta::CPAN
'num' => 'num',
'string' => 'string',
'natural' => 'natural',
'' => 'natural',
},
'cdata' => {
'yes' => 'yes',
'no' => 'no',
'' => 'no',
},
);
lib/RayApp/DSD.pm view on Meta::CPAN
and not $data =~ /^[+-]?\d*\.?\d+$/) {
$self->{errstr} .= "Value '$data' of $showname is not numeric for data element defined at line $spec->{'ln'}\n";
removeChildNodeNicely($node->parentNode, $node);
return 0;
}
if ($spec->{'cdata'} eq 'yes') {
while ($data =~ s/^(.*\])(?=\]>)//sg) {
$node->appendChild($dom->createCDATASection($1));
}
$node->appendChild($dom->createCDATASection($data));
} else {
lib/RayApp/DSD.pm view on Meta::CPAN
Order of elements for values binded using multiple values B<hash> or
B<hashelement>. Possible values are B<num>, B<string>, and
(the default) B<natural>.
=item cdata
When set to yes, the scalar content of this element will be
output as a CDATA section.
=back
Redland
view release on metacpan or search on metacpan
redland/ChangeLog.3 view on Meta::CPAN
* raptor/tests/bad-04.rdf: Check rdf:ID and rdf:bagID with same
value fails
* raptor/tests/bad-02.rdf: Duplicate rdf:ID names
* raptor/raptor_parse.c: Make debug less chatty about cdata,
unless RAPTOR_DEBUG_CDATA defined.
* raptor/raptor_parse.c (raptor_record_ID): Added, notes rdf:ID
and rdf:bagID values, checks for duplicates (per in-scope
base-URI).
redland/ChangeLog.3 view on Meta::CPAN
* raptor/Makefile.am:
Restore rule to make librdf.la for when embedded in Redland
* raptor/raptor_libxml.c (raptor_libxml_init):
Enable handling of cdata blocks -
<![CDATA[...]> by registering callback to raptor_xml_cdata_handler
* raptor/tests/ex-40.out: Fix node
* raptor/tests/Makefile.am: Added ex-40
redland/ChangeLog.3 view on Meta::CPAN
revert default number hashes to 3 for now
* librdf/Makefile.am:
Always have compiled java class files in distribution.
* raptor/raptor_parse.c (raptor_xml_cdata_handler):
Allow to be ignored when there is no
element (XML very damaged)
* raptor/rdfdump.c: Tidy output formatting
( run in 0.902 second using v1.01-cache-2.11-cpan-0c5ce583b80 )