XML::Grove::Subst(3pm) User Contributed Perl Documentation XML::Grove::Subst(3pm)NAME
XML::Grove::Subst - substitute values into a template
SYNOPSIS
use XML::Grove::Subst;
# Using subst method on XML::Grove::Document or XML::Grove::Element:
$new_grove = $source_grove->subst( ARGS );
$new_grove = $source_grove->subst_hash( ARG );
# Using an XML::Grove::Subst instance:
$subster = XML::Grove::Subst->new();
$new_grove = $subster->subst( $source_grove, ARGS );
$new_grove = $subster->subst_hash( $source_grove, ARG );
DESCRIPTION
"XML::Grove::Subst" implements XML templates. "XML::Grove::Subst" traverses through a source grove replacing all elements with names
`"SUB:XXX"' or `"SUB:key"' with their corresponding values from ARGS (a list) or ARG (a hash), repsectively.
METHODS
$grove_obj->subst( ARGS ) =item $subster->subst( $grove_obj, ARGS )
Search for `"SUB:XXX"' elements, where XXX is an array index, and replace the element with the value from ARGS, a list of values. The
return value is a new grove with the substitutions applied.
$grove_obj->subst_hash( ARG ) =item $subster->subst_hash( $grove_obj, ARG )
Search for `"SUB:key"' elements and replace the element with the value from ARG, a hash of values. The hash key is taken from the
`"key"' attribute of the `"SUB:key"' element, for example, `"<SUB:key key='foo'>"'. The return value is a new grove with the
substitutions applied.
EXAMPLE
The following template, in a file `"template.xml"', could be used for a simple parts database conversion to HTML:
<html>
<head>
<title><SUB:key key='Name'></title>
</head>
<body>
<h1><SUB:key key='Name'></title>
<p>Information for part number <SUB:key key='Number'>:</p>
<SUB:key key='Description'>
</body>
</html>
To use this template you would first parse it and convert it to a grove, and then use `"subst_hash()"' every time you needed a new page:
use XML::Parser::PerlSAX;
use XML::Grove;
use XML::Grove::Builder;
use XML::Grove::Subst;
use XML::Grove::PerlSAX;
use XML::Handler::XMLWriter;
# Load the template
$b = XML::Grove::Builder->new();
$p = XML::Parser::PerlSAX->new( Handler = $b );
$source_grove = $p->parse( Source => { SystemId => 'template.xml' } );
# Apply the substitutions
$new_grove = $source_grove->subst_hash( { Name => 'Acme DCX-2000 Filter',
Number => 'N4728',
Description => 'The Best' } );
# Write the new grove to standard output
$w = XML::Handler::XMLWriter->new();
$wp = XML::Grove::PerlSAX->new( Handler => $w );
$wp->parse( Source => { Grove => $new_grove } );
AUTHOR
Ken MacLeod, ken@bitsko.slc.ut.us
SEE ALSO perl(1), XML::Grove(3)
Extensible Markup Language (XML) <http://www.w3c.org/XML>
perl v5.10.1 2010-01-29 XML::Grove::Subst(3pm)
Check Out this Related Man Page
XML::Grove::Factory(3) User Contributed Perl Documentation XML::Grove::Factory(3)NAME
XML::Grove::Factory - simplify creation of XML::Grove objects
SYNOPSIS
use XML::Grove::Factory;
### An object that creates Grove objects directly
my $gf = XML::Grove::Factory->grove_factory;
$grove = $gf->document( CONTENTS );
$element = $gf->element( $name, { ATTRIBUTES }, CONTENTS );
$pi = $gf->pi( $target, $data );
$comment = $gf->comment( $data );
### An object that creates elements by method name
my $ef = XML::Grove::Factory->element_factory();
$element = $ef->NAME( { ATTRIBUTES }, CONTENTS);
### Similar to `element_factory', but creates functions in the
### current package
XML::Grove::Factory->element_functions( PREFIX, ELEMENTS );
$element = NAME( { ATTRIBUTES }, CONTENTS );
DESCRIPTION
"XML::Grove::Factory" provides objects or defines functions that let you simply and quickly create the most commonly used XML::Grove
objects. "XML::Grove::Factory" supports three types of object creation. The first type is to create raw XML::Grove objects. The second
type creates XML elements by element name. The third type is like the second, but defines local functions for you to call instead of using
an object, which might save typing in some cases.
The three types of factories can be mixed. For example, you can use local functions for all element names that don't conflict with your
own sub names or contain special characters, and then use a `"grove_factory()"' object for those elements that do conflict.
In the examples that follow, each example is creating an XML instance similar to the following, assuming it's pretty printed:
<?xml version="1.0"?>
<HTML>
<HEAD>
<TITLE>Some Title</TITLE>
</HEAD>
<BODY bgcolor="#FFFFFF">
<P>A paragraph.</P>
</BODY>
</HTML>
GROVE FACTORY
$gf = XML::Grove::Factory->grove_factory()
Creates a new grove factory object that creates raw XML::Grove objects.
$gf->document( CONTENTS );
Creates an XML::Grove::Document object. CONTENTS may contain processing instructions, strings containing only whitespace characters,
and a single element object (but note that there is no checking). Strings are converted to XML::Grove::Characters objects.
$gf->element($name, CONTENTS);
$gf->element($name, { ATTRIBUTES }, CONTENTS);
Creates an XML::Grove::Element object with the name `$name'. If the argument following `$name' is an anonymous hash, ATTRIBUTES, then
they will be copied to the elements attributes. CONTENTS will be stored in the element's content (note that there is no validity
checking). Strings in CONTENTS are converted to XML::Grove::Characters objects.
$gf->pi( TARGET, DATA)
$gf->pi( DATA )
Create an XML::Grove::PI object with TARGET and DATA.
$gf->comment( DATA )
Create an XML::Grove::Comment object with DATA.
GROVE FACTORY EXAMPLE
use XML::Grove::Factory;
$gf = XML::Grove::Factory->grove_factory;
$element =
$gf->element('HTML',
$gf->element('HEAD',
$gf->element('TITLE', 'Some Title')),
$gf->element('BODY', { bgcolor => '#FFFFFF' },
$gf->element('P', 'A paragraph.')));
ELEMENT FACTORY
$ef = XML::Grove::Factory->element_factory()
Creates a new element factory object for creating elements. `"element_factory()"' objects work by creating an element for any name
used to call the object.
$ef->NAME( CONTENTS )
$ef->NAME( { ATTRIBUTES }, CONTENTS)
Creates an XML::Grove::Element object with the given NAME, ATTRIBUTES, and CONTENTS. The hash containing ATTRIBUTES is optional if
this element doesn't need attributes. Strings in CONTENTS are converted to XML::Grove::Characters objects.
ELEMENT FACTORY EXAMPLE
use XML::Grove::Factory;
$ef = XML::Grove::Factory->element_factory();
$element =
$ef->HTML(
$ef->HEAD(
$ef->TITLE('Some Title')),
$ef->BODY({ bgcolor => '#FFFFFF' },
$ef->P('A paragraph.')));
ELEMENT FUNCTIONS
XML::Grove::Factory->element_functions (PREFIX, ELEMENTS)
Creates functions in the current package for creating elements with the names provided in the list ELEMENTS. PREFIX will be prepended
to every function name, or PREFIX can be an empty string ('') if you're confident that there won't be any conflicts with functions in
your package.
NAME( CONTENTS )
NAME( { ATTRIBUTES }, CONTENTS )
PREFIXNAME( CONTENTS )
PREFIXNAME( { ATTRIBUTES }, CONTENTS )
Functions created for `"NAME"' or `"PREFIXNAME"' can be called to create XML::Grove::Element objects with the given NAME, ATTRIBUTES,
and CONTENT. The hash containing ATTRIBUTES is optional if this element doesn't need attributes. Strings in CONTENT are converted to
XML::Grove::Characters objects.
ELEMENT FACTORY EXAMPLE
use XML::Grove::Factory;
XML::Grove::Factory->element_functions('', qw{ HTML HEAD TITLE BODY P });
$element =
HTML(
HEAD(
TITLE('Some Title')),
BODY({ bgcolor => '#FFFFFF' },
P('A paragraph.')));
AUTHOR
Ken MacLeod, ken@bitsko.slc.ut.us
Inspired by the HTML::AsSubs module by Gisle Aas.
SEE ALSO perl(1), XML::Grove(3).
Extensible Markup Language (XML) <http://www.w3c.org/XML>
POD ERRORS
Hey! The above document had some coding errors, which are explained below:
Around line 307:
You forgot a '=back' before '=head2'
perl v5.16.3 1999-09-03 XML::Grove::Factory(3)