.
=head2 Rendering XML
The simplest way to use this plugin is simply to extract each value
you want to print by hand
The title of the first page is '[%
docroot.findvalue("/website/section/page[1]/@title") %]'
or
The title of the first page is '[%
docroot.documentElement
.getElementsByLocalName("section").first
.getElementsByLocalName("page").first
.getAttribute("title") %]'
You might want to discard whitespace from text areas. XPath
can remove all leading and following whitespace, and condense
all multiple spaces in the text to single spaces.
[% htmlroot.findvalue("normalize-space(
/html/body/p[1]/text()
)" | html %]
Note that, as above, when we're inserting the values extracted into a
XML or HTML document we have to be careful to re-encode the attributes
we need to escape with something like the html filter. A slightly
more advanced technique is to extract a whole node and use the
toString method call on it to convert it to a string of XML. This is
most useful when you are extracting an existing chunk of XML en mass,
as things like EbE and EiE tags will be passed thought
correctly and entities will be encoded suitably (for example '"' will
be turned into '"')
# get the second paragraph and insert it here as XML
[% htmlroot.findnodes("/html/body/p[2]").toString %]
The most powerful technique is to use a view (as defined by the VIEW
keyword) to recursively render out the XML. By loading this plugin
C methods will be created in the B classes
and subclasses. Calling C on a node with a VIEW will cause
it to be rendered by the view block matching the local name of that
node (with any non alphanumeric charecters turned to underscores. So
a EauthorE tag will be rendered by the 'author' block. Text
nodes will call the 'text' block with the text of the node.
As the blocks can refer back to both the node it was called with and
the view they can choose to recursively render out it's children using
the view again. To better facilitate this technique the extra methods
C (recreate a string of the starting tag, including
attributes,) C (recreate a string of the ending tag) and
C (when called with a view, will render by calling all the
children of that node in turn with that view) have been added.
This is probably best shown with a well commented example:
# create the view
[% VIEW myview notfound => 'passthru' %]
# default tag that will recreate the tag 'as is' meaning
# that unknown tags will 'passed though' by the view
[% BLOCK passthru; item.starttag;
item.content(view);
item.endtag;
END %]
# convert all sections to headed paragraphs
[% BLOCK section %]
[% item.getAttribute("title") %]
[% item.content(view) %]
[% END %]
# urls link to themselves
[% BLOCK url %]
[% item.content(view) %]
[% END %]
# email link to themselves with mailtos
[% BLOCK email %]
[% item.content(view) %]
[% END %]
# make pod links bold
[% BLOCK pod %]
[% item.content(view) %]
[% END %]
# render text, re-encoding the attributes as we go
[% BLOCK text; item | html; END %]
# render arrays out
[% BLOCK list; FOREACH i = item; view.print(i); END ; END %]
[% END %]
# use it to render the paragraphs
[% USE doc = XML.LibXML("mydoc.xml") %]
[% doc.findvalue("/doc/page[1]/@title") %]
[% sections = doc.findnodes("/doc/page[1]/section");
FOREACH section = sections %]
[% section.present(myview);
END %]
=head1 BUGS
In order to detect if a scalar is an open filehandle (which is used if
the USE isn't explicit about it's data source) this plugin uses the
C routine from B. If you do not have
B installed, or the version of B is
sufficiently old that it does not support the C routine
then a much cruder C check will be employed.
Bugs may be reported either via the CPAN RT at
http://rt.cpan.org/NoAuth/Bugs.html?Dist=Template-Plugin-XML-LibXML
or via the Template Toolkit mailing list:
http://www.template-toolkit.org/mailman/listinfo/templates or direct
to the author
=head1 AUTHOR
Written by Mark Fowler
Copyright Mark Fowler 2002-3, all rights reserved.
This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.
This module wouldn't have been possible without the wonderful work
that has been put into the libxml library by the gnome team or the
equally wonderful work put in by Matt Sergeant and Christian Glahn in
creating XML::LibXML.
=head1 SEE ALSO
L, L, L, L.
On a similar note, you may want to see L.
The t/test directory in the Template-Plugin-XML-LibXML distribution
contains all the example XML files discussed in this documentation.
=cut
Template-XML-2.17/lib/Template/Plugin/XML/Simple.pm 0000644 0001750 0001750 00000004723 10563113667 021244 0 ustar abw abw 0000000 0000000 #============================================================= -*-Perl-*-
#
# Template::Plugin::XML::Simple
#
# DESCRIPTION
# Template Toolkit plugin interfacing to the XML::Simple.pm module.
#
# AUTHOR
# Andy Wardley
#
# COPYRIGHT
# Copyright (C) 2001-2006 Andy Wardley. All Rights Reserved.
#
# This module is free software; you can redistribute it and/or
# modify it under the same terms as Perl itself.
#
#============================================================================
package Template::Plugin::XML::Simple;
use strict;
use warnings;
use base 'Template::Plugin';
use XML::Simple;
our $VERSION = 2.66;
#------------------------------------------------------------------------
# new($context, $file_or_text, \%config)
#------------------------------------------------------------------------
sub new {
my $class = shift;
my $context = shift;
my $input = shift;
my $args = ref $_[-1] eq 'HASH' ? pop(@_) : { };
if (defined($input)) {
# an input parameter can been be provided and can contain
# XML text or the filename of an XML file, which we load
# using insert() to honour the INCLUDE_PATH; then we feed
# it into XMLin().
$input = $context->insert($input) unless ( $input =~ /new('XML.Simple', $error));
}
1;
__END__
=head1 NAME
Template::Plugin::XML::Simple - Plugin interface to XML::Simple
=head1 SYNOPSIS
# load plugin and specify XML file to parse
[% USE xml = XML.Simple(xml_file_or_text) %]
=head1 DESCRIPTION
This is a Template Toolkit plugin interfacing to the XML::Simple
module.
=head1 AUTHORS
This plugin wrapper module was written by Andy Wardley.
The XML::Simple module which implements all the core functionality was
written by Grant McLean.
=head1 COPYRIGHT
Copyright (C) 1996-2006 Andy Wardley. All Rights Reserved.
This module is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
=head1 SEE ALSO
L, L, L
Template-XML-2.17/lib/Template/Plugin/XML/Style.pm 0000644 0001750 0001750 00000016117 10563113667 021113 0 ustar abw abw 0000000 0000000 #============================================================= -*-Perl-*-
#
# Template::Plugin::XML::Style
#
# DESCRIPTION
# Template Toolkit plugin which performs some basic munging of XML
# to perform simple stylesheet like transformations.
#
# AUTHOR
# Andy Wardley
#
# COPYRIGHT
# Copyright (C) 2001-2006 Andy Wardley. All Rights Reserved.
#
# This module is free software; you can redistribute it and/or
# modify it under the same terms as Perl itself.
#
#============================================================================
package Template::Plugin::XML::Style;
use strict;
use warnings;
use base 'Template::Plugin::Filter';
our $VERSION = 2.36;
our $DYNAMIC = 1;
our $FILTER_NAME = 'xmlstyle';
#------------------------------------------------------------------------
# new($context, \%config)
#------------------------------------------------------------------------
sub init {
my $self = shift;
my $name = $self->{ _ARGS }->[0] || $FILTER_NAME;
$self->install_filter($name);
return $self;
}
sub filter {
my ($self, $text, $args, $config) = @_;
# munge start tags
$text =~ s/ < ([\w\.\:]+) ( \s+ [^>]+ )? >
/ $self->start_tag($1, $2, $config)
/gsex;
# munge end tags
$text =~ s/ < \/ ([\w\.\:]+) >
/ $self->end_tag($1, $config)
/gsex;
return $text;
}
sub start_tag {
my ($self, $elem, $textattr, $config) = @_;
$textattr ||= '';
my ($pre, $post);
# look for an element match in the stylesheet
my $match = $config->{ $elem }
|| $self->{ _CONFIG }->{ $elem }
|| return "<$elem$textattr>";
# merge element attributes into copy of stylesheet attributes
my $attr = { %{ $match->{ attributes } || { } } };
while ($textattr =~ / \s* ([\w\.\:]+) = " ([^"]+) " /gsx ) {
$attr->{ $1 } = $2;
}
$textattr = join(' ', map { "$_=\"$attr->{$_}\"" } keys %$attr);
$textattr = " $textattr" if $textattr;
$elem = $match->{ element } || $elem;
$pre = $match->{ pre_start } || '';
$post = $match->{ post_start } || '';
return "$pre<$elem$textattr>$post";
}
sub end_tag {
my ($self, $elem, $config) = @_;
my ($pre, $post);
# look for an element match in the stylesheet
my $match = $config->{ $elem }
|| $self->{ _CONFIG }->{ $elem }
|| return "";
$elem = $match->{ element } || $elem;
$pre = $match->{ pre_end } || '';
$post = $match->{ post_end } || '';
return "$pre$post";
}
1;
__END__
=head1 NAME
Template::Plugin::XML::Style - Simple XML stylesheet transfomations
=head1 SYNOPSIS
[% USE xmlstyle
table = {
attributes = {
border = 0
cellpadding = 4
cellspacing = 1
}
}
%]
[% FILTER xmlstyle %]
[% END %]
=head1 DESCRIPTION
This plugin defines a filter for performing simple stylesheet based
transformations of XML text.
Named parameters are used to define those XML elements which require
transformation. These may be specified with the USE directive when
the plugin is loaded and/or with the FILTER directive when the plugin
is used.
This example shows how the default attributes C and
C can be added to EtableE elements.
[% USE xmlstyle
table = {
attributes = {
border = 0
cellpadding = 4
}
}
%]
[% FILTER xmlstyle %]
[% END %]
This produces the output:
Parameters specified within the USE directive are applied
automatically each time the C FILTER is used. Additional
parameters passed to the FILTER directive apply for only that block.
[% USE xmlstyle
table = {
attributes = {
border = 0
cellpadding = 4
}
}
%]
[% FILTER xmlstyle
tr = {
attributes = {
valign="top"
}
}
%]
[% END %]
Of course, you may prefer to define your stylesheet structures once
and simply reference them by name. Passing a hash reference of named
parameters is just the same as specifying the named parameters as far
as the Template Toolkit is concerned.
[% style_one = {
table = { ... }
tr = { ... }
}
style_two = {
table = { ... }
td = { ... }
}
style_three = {
th = { ... }
tv = { ... }
}
%]
[% USE xmlstyle style_one %]
[% FILTER xmlstyle style_two %]
# style_one and style_two applied here
[% END %]
[% FILTER xmlstyle style_three %]
# style_one and style_three applied here
[% END %]
Any attributes defined within the source tags will override those
specified in the style sheet.
[% USE xmlstyle
div = { attributes = { align = 'left' } }
%]
[% FILTER xmlstyle %]
foo
bar
[% END %]
The output produced is:
foo
bar
The filter can also be used to change the element from one type to
another.
[% FILTER xmlstyle
th = {
element = 'td'
attributes = { bgcolor='red' }
}
%]
| Heading |
| Value |
[% END %]
The output here is as follows. Notice how the end tag
C/thE> is changed to C/tdE> as well as the start
tag.
| Heading |
| Value |
You can also define text to be added immediately before or after the
start or end tags. For example:
[% FILTER xmlstyle
table = {
pre_start = ''
post_end = '
'
}
th = {
element = 'td'
attributes = { bgcolor='red' }
post_start = ''
pre_end = ''
}
%]
[% END %]
The output produced is:
=head1 AUTHOR
Andy Wardley
=head1 COPYRIGHT
Copyright (C) 2001-2006 Andy Wardley. All Rights Reserved.
This module is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
=head1 SEE ALSO
L
=cut
# Local Variables:
# mode: perl
# perl-indent-level: 4
# indent-tabs-mode: nil
# End:
#
# vim: expandtab shiftwidth=4:
Template-XML-2.17/lib/Template/Plugin/XML/File.pm 0000644 0001750 0001750 00000012061 10563113667 020664 0 ustar abw abw 0000000 0000000 package Template::Plugin::XML::File;
use strict;
use warnings;
use Template::Plugin::XML;
use base 'Template::Plugin::File';
our $VERSION = 2.15;
our $DEBUG = 0 unless defined $DEBUG;
our $EXCEPTION = 'Template::Exception' unless defined $EXCEPTION;
our $XML_PLUGIN = 'Template::Plugin::XML' unless defined $XML_PLUGIN;
our $FILE_TYPES = {
name => 'name',
file => 'name',
xml_file => 'name',
fh => 'handle',
handle => 'handle',
xml_fh => 'handle',
};
sub new {
my $class = shift;
my $context = shift;
my $params = @_ && ref $_[-1] eq 'HASH' ? pop(@_) : { };
my ($source, $type);
my $self = bless {
debug => delete $params->{ debug },
libxml => delete $params->{ libxml },
}, $class;
# apply default for debug from package variable
$self->{ debug } = $DEBUG unless defined $self->{ debug };
if (@_) {
# first positional argument is file name or XML string
$source = shift;
$type = $XML_PLUGIN->detect_filehandle($source) ? 'handle' : 'name';
$self->{ type } = $type;
$self->{ $type } = $source;
}
else {
# look in named params for a known type
while (my ($param, $type) = each %$FILE_TYPES) {
if (defined ($source = delete $params->{ $param })) {
$self->{ type } = $type;
$self->{ $type } = $source;
}
}
}
return $self->throw('a file name or file handle must be specified')
unless defined $self->{ type };
return $self;
}
sub type {
return $_[0]->{ type };
}
sub name {
return $_[0]->{ name };
}
sub libxml {
my $self = shift;
return $self->{ libxml };
}
sub dom {
my $self = shift;
my $args = @_ && ref $_[-1] eq 'HASH' ? pop(@_) : { };
return $self->{ dom } ||= do {
my ($parser, $dom);
if ($parser = $self->{ libxml }) {
if (defined $self->{ name }) {
# file name
eval { $dom = $parser->parse_file($self->{ name }) }
|| $self->throw("failed to parse $self->{ name }: $@");
}
else {
# file handle
eval { $dom = $parser->parse_fh($self->{ handle }) }
|| $self->throw("failed to parse file handle: $@");
}
}
else {
eval { require XML::DOM }
|| $self->throw("XML::DOM not available: $@");
$parser = XML::DOM::Parser->new(%$args)
|| $self->throw("failed to create parser");
# TODO: must call dispose() on any XML::DOM documents we create
if (defined $self->{ name }) {
# file name
eval { $dom = $parser->parsefile($self->{ name }) }
|| $self->throw("failed to parse $self->{ name }: $@");
}
else {
# file handle
local $/ = undef;
my $fh = $self->{ handle };
my $text = <$fh>;
eval { $dom = $parser->parse($text) }
|| $self->throw("failed to parse $self->{ name }: $@");
}
}
$dom;
};
}
#------------------------------------------------------------------------
# handle()
#
# TODO: this currently returns the handle iff one was specified as a
# constructor arg, and undef otherwise. But it would be nice if it
# opened the file for you (using any mode/write/append/create params
# specified either in the constructor or as args) and returned the handle.
# Then you could write [% dir.file('foo.xml').handle %]
#------------------------------------------------------------------------
sub handle {
return $_[0]->{ handle };
}
sub debug {
return $_[0]->{ debug };
}
sub throw {
my $self = shift;
die $Template::Plugin::XML::EXCEPTION->new( 'XML.File' => join('', @_) );
}
1;
__END__
=head1 NAME
Template::Plugin::XML::File - TT plugin for XML files
=head1 SYNOPSIS
# different want to specify an XML file name
[% USE xf = XML.File( filename ) %]
[% USE xf = XML.File( file = filename ) %]
[% USE xf = XML.File( name = filename ) %]
[% USE xf = XML.File( xml_file = filename ) %]
# different want to specify an XML file handle
[% USE xf = XML.File( handle ) %]
[% USE xf = XML.File( fh = handle ) %]
[% USE xf = XML.File( handle = handle ) %]
[% USE xf = XML.File( xml_fh = handle ) %]
[% xf.type %] # 'name' or 'handle'
[% xf.name %] # filename (if defined)
[% xf.handle %] # file handle (if defined)
=head1 DESCRIPTION
TODO
=head1 METHODS
TODO
=head1 AUTHORS
Andy Wardley, Mark Fowler and others...
=head1 COPYRIGHT
TODO
=head1 SEE ALSO
L, L,
L, L,
L, L
=cut
# Local Variables:
# mode: perl
# perl-indent-level: 4
# indent-tabs-mode: nil
# End:
#
# vim: expandtab shiftwidth=4:
Template-XML-2.17/lib/Template/Plugin/XML.pm 0000644 0001750 0001750 00000024016 10563114352 020000 0 ustar abw abw 0000000 0000000 package Template::Plugin::XML;
use strict;
use warnings;
use base 'Template::Plugin';
our $VERSION = 2.17;
our $DEBUG = 0 unless defined $DEBUG;
our $EXCEPTION = 'Template::Exception' unless defined $EXCEPTION;
our $LIBXML = eval { require XML::LibXML } unless defined $LIBXML;
our $OPENHANDLE = eval "use Scalar::Util qw(openhandle)";
our @TYPES = qw( file fh text
xml xml_file xml_fh xml_text
html html_file html_fh html_text );
sub new {
my $class = shift;
my $context = shift;
my $params = @_ && ref $_[-1] eq 'HASH' ? pop(@_) : { };
my ($source, $type);
if (@_) {
# first positional argument is file name or XML string
$source = shift;
$type = $class->detect_type($source);
}
else {
# look in named params for a known type
foreach (@TYPES) {
$type = $_, last
if defined ($source = delete $params->{ $_ });
}
}
my $self = bless {
context => $context,
debug => delete $params->{ debug },
libxml => delete $params->{ libxml },
}, $class;
# apply defaults for debug and libxml from package variable
$self->{ debug } = $DEBUG unless defined $self->{ debug };
$self->{ libxml } = $LIBXML unless defined $self->{ libxml };
# if libxml is enabled then we create an XML::LibXML parser
$self->{ libxml } &&= do {
# make sure they didn't try and force libxml=>1 when $LIBXML
# says we haven't got XML::LibXML installed
return $self->throw('XML::LibXML is not available')
unless $LIBXML;
my $parser = XML::LibXML->new();
# iterate through remaining params trying to call the
# appropriate method on the XML::LibXML object, e.g.
# expand_entities => 1 becomes $parse->expand_entities(1)
my ($param, $value, $method);
while (($param, $value) = each %$params) {
# throw an error if the parser doesn't have the method
$self->throw("invalid configuration parameter: $param")
unless ($method = UNIVERSAL::can($parser, $param));
# catch any errors thrown and re-throw as our exceptions
eval { &$method($parser, $value) };
$self->throw("configuration parameter '$param' failed: $@")
if $@;
}
$parser;
};
return $self;
}
sub source {
return $_[0]->{ source };
}
sub type {
return $_[0]->{ type };
}
sub debug {
my $self = shift;
return $self->{ debug };
}
sub libxml {
my $self = shift;
return $self->{ libxml };
}
sub file {
my $self = shift;
my $params = @_ && ref $_[-1] eq 'HASH' ? pop(@_) : { };
my @args = @_;
push(@args, $params);
$params->{ libxml } = $self->{ libxml }
unless defined $params->{ libxml };
return $self->{ context }->plugin('XML.File', \@args);
}
sub dir {
die "dir() not yet implemented";
# pretty much as per file
}
sub dom {
my $self = shift;
# TODO: see if we've got a filename defined, create a DOM parser
# (and cache it), and then call its parse() method
# ...but for now, we'll just create a plugin
$self->{ context }->plugin('XML.DOM', \@_);
}
sub xpath {
my $self = shift;
# as above
$self->{ context }->plugin('XML.XPath', \@_);
}
sub rss {
my $self = shift;
# as above
$self->{ context }->plugin('XML.RSS', \@_);
}
sub simple {
my $self = shift;
# as above
$self->{ context }->plugin('XML.Simple', \@_ );
}
sub throw {
my $self = shift;
die $EXCEPTION->new( XML => join('', @_) );
}
sub detect_filehandle {
my $self = shift;
# look for a filehandle using Scalar::Utils openhandle if it's
# available or our poor-man's version if not.
return $OPENHANDLE ? openhandle($_[0]) : defined(fileno $_[0]);
}
sub detect_type {
my $self = shift;
# look for a filehandle using Scalar::Utils openhandle if it's
# available or our poor-man's version if not.
return 'fh' if $self->detect_filehandle($_[0]);
# okay, look for the xml declaration at the start
return 'xml_text' if $_[0] =~ m/^\<\?xml/;
# okay, look for the html declaration anywhere in the doc
return 'html_text' if $_[0] =~ m//i;
# okay, does this contain a "<" symbol, and declare it to be
# xml if it's got one, though they should use " module or L. For
information on using plugins, see L and
L. For further information
on XML, see L.
=head1 METHODS
The XML plugin module provides a number of methods to create various
other XML plugin objects.
=head2 file(name)
Creates a Template::Plugin::XML::File object. This is a subclass
of Template::Plugin::File.
=head2 dir(path)
Creates a Template::Plugin::XML::Directory object. This is a subclass
of Template::Plugin::Directory.
=head2 dom()
Generate a Document Object Module from an XML file. This can be
called against a directory, file or an XML plugin object, as long as
the source XML filename is defined somewhere along the line.
[% dom = XML.dom(filename) %]
[% file = XML.file(filename);
dom = file.dom
%]
[% dir = XML.dir(dirname);
dom = dir.dom(filename)
%]
=head2 xpath()
Perform XPath queries on the file. Like the dom() method, xpath() can
be called against a file, directory or an XML plugin object.
[% xpath = XML.xpath(filename) %]
[% file = XML.file(filename);
xpath = file.xpath
%]
[% dir = XML.dir(dirname);
xpath = dir.xpath(filename)
%]
=head2 simple()
TODO: As per dom() and xpath() but for XML::Simple
=head2 rss()
TODO: As per dom(), xpath() and simple() but for XML::RSS
=head1 XML PLUGINS
These are the XML plugins provided in this distribution.
=head2 Template::Plugin::XML
Front-end module to the XML plugin collection.
=head2 Template::Plugin::XML::File
This plugin module is used to represent individual XML files. It is a
subclass of the Template::Plugin::File module, providing the
additional dom(), xpath(), simple() and other methods relevant to XML
files.
=head2 Template::Plugin::XML::Directory
This plugin module is used to represent directories of XML files. It
is a subclass of the Template::Plugin::Directory module and provides
the same additional XML related methods as Template::Plugin::XML::File.
=head2 Template::Plugin::XML::DOM
Plugin interface providing access to the XML::DOM module.
[% USE XD = XML.Dom %]
[% dom = XD.parse_file('example.xml') %]
[% pages = dom.getElementsByTagName('page') %]
=head2 Template::Plugin::XML::RSS
Plugin interface providing access to the XML::RSS module.
[% USE news = XML.RSS('news.rdf') -%]
[% FOREACH item IN news.items -%]
* [% item.title %]
[% END %]
=head2 Template::Plugin::XML::Simple
Plugin interface providing access to the XML::Simple module.
[% USE xml = XML.Simple('example.xml') %]
=head2 Template::Plugin::XML::XPath
Plugin interface providing access to the XML::XPath module.
[% USE xpath = XML.XPath('example.xml');
bar = xpath.find('/foo/bar');
%]
=head1 AUTHORS
Andy Wardley wrote the Template Toolkit plugin modules, with
assistance from Simon Matthews in the case of the XML::DOM plugin.
Matt Sergeant wrote the XML::XPath module. Enno Derksen and Clark
Cooper wrote the XML::DOM module. Jonathan Eisenzopf wrote the
XML::RSS module. Grant McLean wrote the XML::Simple module. Clark
Cooper and Larry Wall wrote the XML::Parser module. James Clark wrote
the expat library.
=head1 COPYRIGHT
Copyright (C) 1996-2007 Andy Wardley. All Rights Reserved.
This module is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
=head1 SEE ALSO
L, L,
L, L,
L, L
=cut
# Local Variables:
# mode: perl
# perl-indent-level: 4
# indent-tabs-mode: nil
# End:
#
# vim: expandtab shiftwidth=4:
Template-XML-2.17/lib/Template/XML.pod 0000644 0001750 0001750 00000004303 10563113667 016715 0 ustar abw abw 0000000 0000000 =head1 NAME
Template::XML - XML plugins for the Template Toolkit
=head1 SYNOPSIS
[% USE XML;
dom = XML.dom('foo.xml');
xpath = XML.xpath('bar.xml');
simple = XML.simple('baz.xml');
rss = XML.simple('news.rdf');
%]
=head1 DESCRIPTION
The Template-XML distribution provides a number of Template Toolkit
plugin modules for working with XML.
The Template::Plugin::XML module is a front-end to the various other
XML plugin modules. Through this you can access XML files and
directories of XML files via the Template::Plugin::XML::File and
Template::Plugin::XML::Directory modules (which subclass from the
Template::Plugin::File and Template::Plugin::Directory modules
respectively). You can then create a Document Object Model (DOM) from
an XML file (Template::Plugin::XML::DOM), examine it using XPath
queries (Template::Plugin::XML::XPath), turn it into a Perl data
structure (Template::Plugin::XML::Simple) or parse it as an RSS (RDF
Site Summary) file.
The basic XML plugins were distributed as part of the Template Toolkit
until version 2.15 released in May 2006. At this time they were
extracted into this separate Template-XML distribution and an alpha
version of this Template::Plugin::XML front-end module was added.
=head1 AUTHORS
Andy Wardley wrote the Template Toolkit plugin modules, with
assistance from Simon Matthews in the case of the XML::DOM plugin.
Matt Sergeant wrote the XML::XPath module. Enno Derksen and Clark
Cooper wrote the XML::DOM module. Jonathan Eisenzopf wrote the
XML::RSS module. Grant McLean wrote the XML::Simple module. Clark
Cooper and Larry Wall wrote the XML::Parser module. James Clark wrote
the expat library.
=head1 COPYRIGHT
Copyright (C) 1996-2006 Andy Wardley. All Rights Reserved.
This module is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
=head1 SEE ALSO
L, L, L,
L, L,
L, L
=cut
# Local Variables:
# mode: perl
# perl-indent-level: 4
# indent-tabs-mode: nil
# End:
#
# vim: expandtab shiftwidth=4:
Template-XML-2.17/README 0000644 0001750 0001750 00000004173 10563113667 014115 0 ustar abw abw 0000000 0000000 NAME
Template::XML - XML plugins for the Template Toolkit
SYNOPSIS
[% USE XML;
dom = XML.dom('foo.xml');
xpath = XML.xpath('bar.xml');
simple = XML.simple('baz.xml');
rss = XML.simple('news.rdf');
%]
DESCRIPTION
The Template-XML distribution provides a number of Template Toolkit
plugin modules for working with XML.
The Template::Plugin::XML module is a front-end to the various other XML
plugin modules. Through this you can access XML files and directories of
XML files via the Template::Plugin::XML::File and
Template::Plugin::XML::Directory modules (which subclass from the
Template::Plugin::File and Template::Plugin::Directory modules
respectively). You can then create a Document Object Model (DOM) from an
XML file (Template::Plugin::XML::DOM), examine it using XPath queries
(Template::Plugin::XML::XPath), turn it into a Perl data structure
(Template::Plugin::XML::Simple) or parse it as an RSS (RDF Site Summary)
file.
The basic XML plugins were distributed as part of the Template Toolkit
until version 2.15 released in May 2006. At this time they were
extracted into this separate Template-XML distribution and an alpha
version of this Template::Plugin::XML front-end module was added.
AUTHORS
Andy Wardley wrote the Template Toolkit plugin modules, with assistance
from Simon Matthews in the case of the XML::DOM plugin. Matt Sergeant
wrote the XML::XPath module. Enno Derksen and Clark Cooper wrote the
XML::DOM module. Jonathan Eisenzopf wrote the XML::RSS module. Grant
McLean wrote the XML::Simple module. Clark Cooper and Larry Wall wrote
the XML::Parser module. James Clark wrote the expat library.
COPYRIGHT
Copyright (C) 1996-2006 Andy Wardley. All Rights Reserved.
This module is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.
SEE ALSO
Template, Template::Plugins, Template::Plugin::XML,
Template::Plugin::XML::DOM, Template::Plugin::XML::RSS,
Template::Plugin::XML::Simple, Template::Plugin::XML::XPath
Template-XML-2.17/Makefile.PL 0000644 0001750 0001750 00000001233 10563113667 015201 0 ustar abw abw 0000000 0000000 #!/usr/bin/perl -w # -*- perl -*-
use strict;
use ExtUtils::MakeMaker;
my %opts = (
'NAME' => 'Template::XML',
'VERSION_FROM' => 'lib/Template/Plugin/XML.pm',
'PMLIBDIRS' => [ 'lib' ],
'PREREQ_PM' => {
'Template' => 2.15,
'XML::Parser' => 2.19,
'XML::DOM' => 1.27,
'XML::RSS' => 0.9,
'XML::XPath' => 1.0,
'XML::Simple' => 2.0,
},
);
if ($ExtUtils::MakeMaker::VERSION >= 5.43) {
$opts{ AUTHOR } = 'Andy Wardley ';
$opts{ ABSTRACT } = 'XML plugins for the Template Toolkit',
}
WriteMakefile( %opts );
Template-XML-2.17/META.yml 0000644 0001750 0001750 00000001044 10563116312 014466 0 ustar abw abw 0000000 0000000 # http://module-build.sourceforge.net/META-spec.html
#XXXXXXX This is a prototype!!! It will change in the future!!! XXXXX#
name: Template-XML
version: 2.17
version_from: lib/Template/Plugin/XML.pm
installdirs: site
requires:
Template: 2.15
XML::DOM: 1.27
XML::Parser: 2.19
XML::RSS: 0.9
XML::Simple: 2
XML::XPath: 1
distribution_type: module
generated_by: ExtUtils::MakeMaker version 6.17
Template-XML-2.17/MANIFEST 0000644 0001750 0001750 00000001001 10563113667 014351 0 ustar abw abw 0000000 0000000 lib/Template/Plugin/XML.pm
lib/Template/Plugin/XML/DOM.pm
lib/Template/Plugin/XML/File.pm
lib/Template/Plugin/XML/LibXML.pm
lib/Template/Plugin/XML/RSS.pm
lib/Template/Plugin/XML/Simple.pm
lib/Template/Plugin/XML/Style.pm
lib/Template/Plugin/XML/View.pm
lib/Template/Plugin/XML/XPath.pm
lib/Template/XML.pod
Makefile.PL
MANIFEST This list of files
META.yml
README
t/dom.t
t/domview.t
t/file.t
t/rss.t
t/test/xml/example.rdf
t/test/xml/testfile.xml
t/xml.t
t/xml/example.xml
t/xmlsimple.t
t/xmlstyle.t
t/xpath.t