view release on metacpan or  search on metacpan

lib/XML/DOM/Lite.pm  view on Meta::CPAN

     # do stuff
 }
  
 # XSLT
 use XML::DOM::Lite qw(Parser XSLT);
 $parser = Parser->new( whitespace => 'strip' );
 $xsldoc = $parser->parse($xsl); 
 $xmldoc = $parser->parse($xml); 
 $output = XSLT->process($xmldoc, $xsldoc);
  
  
 # XPath
 use XML::DOM::Lite qw(XPath);
 $result = XPath->evaluate('/path/to/*[@attr="value"]', $contextNode);
  
  
 # Document
 $rootnode = $doc->documentElement;
 $nodeWithId = $doc->getElementById("my_node_id");
 $textnode = $doc->createTextNode("some text string");
 $element = $doc->createElement("myTagName");
 $docfrag = $doc->createDocumentFragment();
 $xmlstr = $doc->xml;
 $nlist = $doc->selectNodes('/xpath/expression');
 $node  = $doc->selectSingleNode('/xpath/expression');
   
  
 # Serializer
 use XML::DOM::Lite qw(Serializer);
  
 $serializer = Serializer->new;
 $xmlout = $serializer->serializeToString($node);

=head1 INTRODUCTION

Why Yet Another XML Parser?

The first reason is portability. XML::DOM::Lite has only one external dependency: L<Scalar::Util>
without which your Perl installation is probably not sane anyway (if pressed, this dependency could
even be removed). I wanted a DOM standard XML parser kit complete with XSLT, XPath, NodeIterator,
Serializer etc. without needing Expat - and it had to be fast enough for serious use. An added
benefit is that you can freeze and thaw your entire DOM tree using Storable - it's all just Perl.

The second reason is that the DOM standard was not made for Perl and lacks certain
perlisms, and if you, like me, prefer a perlesque way of doing
things, then the full DOM API can get a bit clunky...

Most of the time when dealing with XML DOM trees, I find myself doing
a lot of traversal - and when doing so, I usually want my DOM tree to
be a HASH ref with ARRAY refs of HASH refs (etc.), so node lists are
blessed array refs - so you can say :

 foreach (@{$node->childNodes}) {
     if ($_->nodeType == ELEMENT_NODE) {
         # do stuff
     }
 }

... or ...

 @cdata = map {
     $_->nodeValue if $_->nodeType == TEXT_NODE
 }, @{$node->childNodes};

... or for attributes :

Node lists can also behave as hashrefs using overload, so that we can:
 foreach (keys %{$node->attributes}) {
     # do something
 }

Furthermore, maybe sometimes I want the value of an attribute to,
temporarily, be something other than a string, so...

 $node->setAttribute("sessionStash", $session->stash);

Sometimes, I may want to Storable::freeze or YAML::Dump or
DBM::Deep::put my DOM tree (or some part of it) without any XS bits
getting in the way.

Other times, I may just not have Expat handy, and I want something
that can munge a bit of XML into a usable data structure and still
perform reasonably well.

And/Or any combination of the above.

=head1 DESCRIPTION

XML::DOM::Lite is designed to be a reasonably fast, highly portable,
XML parser kit written in pure perl, implementing the DOM standard
quite closely. To keep performance up and footprint down.

The standard pattern for using the XML::DOM::Lite parser kit is to
 use XML::DOM::Lite qw(Parser :constants);

Available exports are : I<Parser>, I<Node>, I<NodeList>,
I<NodeIterator>, I<NodeFilter>, I<XPath>, I<Document>, I<XSLT> and the
constants.

This is mostly for convenience, so that you can save your key-strokes
for the fun stuff. Alternatively, to avoid polluting your namespace,
you can simply :
 use XML::DOM::Lite::Parser;
 use XML::DOM::Lite::Constants qw(:all);
 # ... etc

=head2 Parser Options

So far the only options which are supported involve white space stripping
and normalization. The whitespace option value can be 'strip' or 'normalize'.

The 'strip' option removes whitespace at the beginning and end of XML tag.
Thus, whitespace between tags is completely eliminated and whitespace at the
beginning and end of text nodes is removed. If you are using inline tags, this
will result in the removal of whitespace between text.

E.g the sequence "Sequence of <b>bold</b> and <i>italic</i> words" will be changed to
'Sequence ofboldanditalcwords'.

The 'normalize' option replaces all multiple tab, new line space characters
with a single space character.