Data::Edit::Xml - Edit data held in the XML format.
Create a new XML parse tree:
my $a = Data::Edit::Xml::new("<a><b><c/></b><d><c/></d></a>");
Then:
say STDERR -p $a;
to print the parse tree:
<a> <b> <c/> </b> <d> <c/> </d> </a>
Cut out c under b but not under d in the created tree by traversing in post-order applying a sub to each node to cut out c when we are at c under b under a.
$a -> by(sub {$_ -> cut_c_b_a});
Or if you know when you are going:
$a -> go_b_c__cut;
To get:
<a> <b/> <d> <c/> </d> </a>
To transform a series of bullets into <ul><li>...</li></ul>, parse the input XML:
my $a = Data::Edit::Xml::new(<<END); <a> <p>• Minimum 1 number</p> <p>• No leading, trailing, or embedded spaces</p> <p>• Not case-sensitive</p> </a> END
Traverse the resulting parse tree, removing bullets and changing <p> to <li>, <a> to <ul>:
$a->change(q(ul))->by(sub # Change to <ul> and then traverse parse tree {$_->up->change(q(li)) if $_->text(q(p)) and $_->text =~ s/\A•\s*//s # Remove leading bullets from text and change <p> to <li> });
Print to get:
ok -p $a eq <<END; # Results <ul> <li>Minimum 1 number</li> <li>No leading, trailing, or embedded spaces</li> <li>Not case-sensitive</li> </ul> END
To transform some DocBook XML into Dita:
use Data::Edit::Xml; # Parse the DocBook XML my $a = Data::Edit::Xml::new(<<END); <sli> <li> <p>Diagnose the problem</p> <p>This can be quite difficult</p> <p>Sometimes impossible</p> </li> <li> <p><pre>ls -la</pre></p> <p><pre> drwxr-xr-x 2 phil phil 4096 Jun 15 2016 Desktop drwxr-xr-x 2 phil phil 4096 Nov 9 20:26 Downloads </pre></p> </li> </sli> END # Transform to Dita step 1 $a->by(sub {my ($o, $p) = @_; if ($o->at(qw(pre p li sli)) and $o->isOnlyChild) {$o->change($p->isFirst ? qw(cmd) : qw(stepresult)); $p->unwrap; } elsif ($o->at(qw(li sli)) and $o->over(qr(\Ap( p)+\Z))) {$_->change($_->isFirst ? qw(cmd) : qw(info)) for $o->contents; } }); # Transform to Dita step 2 $a->by(sub {my ($o) = @_; $o->change(qw(step)) if $o->at(qw(li sli)); $o->change(qw(steps)) if $o->at(qw(sli)); $o->id = 's'.($o->position+1) if $o->at(qw(step)); $o->id = 'i'.($o->index+1) if $o->at(qw(info)); $o->wrapWith(qw(screen)) if $o->at(qw(CDATA stepresult)); }); # Print the results say STDERR -p $a;
Produces:
<steps> <step id="s1"> <cmd>Diagnose the problem </cmd> <info id="i1">This can be quite difficult </info> <info id="i2">Sometimes impossible </info> </step> <step id="s2"> <cmd>ls -la </cmd> <stepresult> <screen> drwxr-xr-x 2 phil phil 4096 Jun 15 2016 Desktop drwxr-xr-x 2 phil phil 4096 Nov 9 20:26 Downloads </screen> </stepresult> </step> </steps>
Edit data held in the XML format.
The following sections describe the methods in each functional area of this module. For an alphabetic listing of all methods by name see Index.
These methods are the ones most likely to be of immediate use to anyone using this module for the first time:
at
Confirm that the node has the specified ancestry and return the starting node if it does else undef. Ancestry is specified by providing the expected tags that the parent, the parent's parent etc. must match at each level. If undef is specified then any tag is assumed to match at that level. If a regular expression is specified then the current parent node tag must match the regular expression at that level. If all supplied tags match successfully then the starting node is returned else undef
attr
Return the value of an attribute of the current node as an lvalue sub.
by
Post-order traversal of a parse tree or sub tree calling the specified sub at each node and returning the specified starting node. The sub is passed references to the current node and all of its ancestors. A reference to the current node is also made available via $_. This is equivalent to the x= operator.
change
Change the name of a node, optionally confirming that the node is in a specified context and return the node.
cut
Cut out a node so that it can be reinserted else where in the parse tree.
go
Return the node reached from the specified $node via the specified path: (index position?)* where index is the tag of the next node to be chosen and position is the optional zero based position within the index of those tags under the current node. Position defaults to zero if not specified. Position can also be negative to index back from the top of the index array. * can be used as the last position to retrieve all nodes with the final tag.
new
Create a new parse tree - call this method statically as in Data::Edit::Xml::new(file or string) to parse a file or string or with no parameters and then use "input", "inputFile", "inputString", "errorFile" to provide specific parameters for the parse, then call "parse" to perform the parse and return the parse tree.
prettyString
Return a readable string representing a node of a parse tree and all the nodes below it. Or use -p $node
putLast
Place a cut out or new node last in the content of the specified $node and return the new node. See addLast to perform this operation conditionally.
unwrap
Unwrap a node by inserting its content into its parent at the point containing the node and return the parent node.
wrapWith
Wrap the original node in a new node forcing the original node down - deepening the parse tree - return the new wrapping node. See addWrapWith to perform this operation conditionally.
Create a parse tree, either by parsing a file or string, or, node by node, or, from another parse tree
Construct a parse tree from a file or a string
Parameter Description 1 $fileNameOrString Optional file name or string from which to construct the parse tree
Example:
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END ok -p $a eq <<END; #tdown #tdownX <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END
This is a static method and so should be invoked as:
Data::Edit::Xml::new
The name of the tag to be used to represent text - this tag must not also be used as a command tag otherwise the parser will confess.
{ok Data::Edit::Xml::cdata eq q(CDATA);
Parse input XML specified via: inputFile, input or inputString.
Parameter Description 1 $parser Parser created by L</new>
{my $x = Data::Edit::Xml::new; $x->inputString = <<END; <a id="aa"><b id="bb"><c id="cc"/></b></a> END $x->parse; ok -p $x eq <<END; <a id="aa"> <b id="bb"> <c id="cc"/> </b> </a> END
Construct a parse tree node by node.
Create a new text node.
Parameter Description 1 undef Any reference to this package 2 $text Content of new text node
ok -p $x eq <<END; <a class="aa" id="1"> <b class="bb" id="2"/> </a> END $x->putLast($x->newText("t")); ok -p $x eq <<END; <a class="aa" id="1"> <b class="bb" id="2"/> t </a> END
Create a new non text node.
Parameter Description 1 undef Any reference to this package 2 $command The tag for the node 3 %attributes Attributes as a hash.
{my $x = Data::Edit::Xml::newTree("a", id=>1, class=>"aa"); $x->putLast($x->newTag("b", id=>2, class=>"bb")); ok -p $x eq <<END; <a class="aa" id="1"> <b class="bb" id="2"/> </a> END
Create a new tree.
Parameter Description 1 $command The name of the root node in the tree 2 %attributes Attributes of the root node in the tree as a hash.
{my $x = Data::Edit::Xml::newTree("a", id=>1, class=>"aa"); ok -s $x eq '<a class="aa" id="1"/>';
Replace < > " & with < > " & Larry Wall's excellent Xml parser unfortunately replaces < > " & etc. with their expansions in text by default and does not seem to provide an obvious way to stop this behavior, so we have to put them back again using this method.
Parameter Description 1 $string String to be edited.
ok Data::Edit::Xml::replaceSpecialChars(q(<">)) eq "<">";
Attributes of a node in a parse tree. For instance the attributes associated with an XML tag are held in the attributes attribute. It should not be necessary to use these attributes directly unless you are writing an extension to this module. Otherwise you should probably use the methods documented in other sections to manipulate the parse tree as they offer a safer interface at a higher level.
Content of command: the nodes immediately below this node in the order in which they appeared in the source text, see also "Contents".
Nodes by number.
A hash added to the node for use by the programmer during transformations. The data in this hash will not be printed by any of the printed methods and so can be used to add data to the parse tree that will not be seen in any output xml produced from the parse tree.
The attributes of this node, see also: "Attributes". The frequently used attributes: class, id, href, outputclass can be accessed by an lvalue method as in: $node->id = 'c1'.
Conditional strings attached to a node, see "Conditions".
Index to node by forest number as set by numberForest.
Indexes to sub commands by tag in the order in which they appeared in the source text.
The labels attached to a node to provide addressability from other nodes, see: "Labels".
Error listing file. Use this parameter to explicitly set the name of the file that will be used to write any parse errors to. By default this file is named: zzzParseErrors/out.data.
Source file of the parse if this is the parser root node. Use this parameter to explicitly set the file to be parsed.
Source of the parse if this is the parser root node. Use this parameter to specify some input either as a string or as a file name for the parser to convert into a parse tree.
Source string of the parse if this is the parser root node. Use this parameter to explicitly set the string to be parsed.
Last number used to number a node in this parse tree.
Number of this node, see findByNumber.
Parent node of this node or undef if the parser root node. See also "Traversal" and "Navigation". Consider as read only.
Parser details: the root node of a tree is the parser node for that tree. Consider as read only.
Tag name for this node, see also "Traversal" and "Navigation". Consider as read only.
Text of this node but only if it is a text node, i.e. the tag is cdata() <=> "isText" is true.
Construct a parse tree from another parse tree
Returns a renewed copy of the parse tree, optionally checking that the starting node is in a specified context: use this method if you have added nodes via the "Put as text" methods and wish to traverse their parse tree.
Returns the starting node of the new parse tree or undef if the optional context constraint was supplied but not satisfied.
Parameter Description 1 $node Node to renew from 2 @context Optional context
Use the optional @context parameter to test the context of the specified $node as understood by method at. If the context is supplied and $node is not in this context then this method returns undef immediately.
{my $a = Data::Edit::Xml::new("<a/>"); $a->putFirstAsText(qq(<b/>)); ok !$a->go(q(b)); my $A = $a->renew; ok -t $A->go(q(b)) eq q(b)
Return a clone of the parse tree optionally checking that the starting node is in a specified context: the parse tree is cloned without converting it to string and reparsing it so this method will not renew any nodes added as text.
Parameter Description 1 $node Node to clone from 2 @context Optional context
{my $a = Data::Edit::Xml::new("<a> </a>"); my $A = $a->clone; ok -s $A eq q(<a/>); ok $a->equals($A); {my $x = Data::Edit::Xml::new(<<END); <x> <a>aaa <b>bbb</b> ccc <d>ddd</d> eee </a> </x> END my $y = $x->clone; ok !$x->diff($y);
Return the first node if the two parse trees have identical representations via string, else undef.
Parameter Description 1 $node1 Parse tree 1 2 $node2 Parse tree 2.
{my $a = Data::Edit::Xml::new("<a> </a>"); my $A = $a->clone; ok -s $A eq q(<a/>); ok $a->equals($A);
Return the first node if the two parse trees have identical representations via string if the specified attributes are ignored, else undef.
Parameter Description 1 $node1 Parse tree 1 2 $node2 Parse tree 2 3 @attributes Attributes to ignore during comparison
{my $a = Data::Edit::Xml::new(<<END); <a> <b id="1" outputclass="1" name="b"> <c id="2" outputclass="2" name="c"/> </b> </a> END my $A = Data::Edit::Xml::new(<<END); <a> <b id="11" outputclass="11" name="b"> <c id="22" outputclass="22" name="c"/> </b> </a> END ok !$a->equals($A); ok !$a->equalsIgnoringAttributes($A, qw(id)); ok $a->equalsIgnoringAttributes($A, qw(id outputclass));
Return () if the dense string representations of the two nodes are equal, else up to the first N (default 16) characters of the common prefix before the point of divergence and the remainder of the string representation of each node from the point of divergence. All <!-- ... --> comments are ignored during this comparison and all spans of white space are reduced to a single blank.
Parameter Description 1 $first First node 2 $second Second node 3 $N Maximum length of difference strings to return
{my $x = Data::Edit::Xml::new(<<END); <x> <a>aaa <b>bbb</b> ccc <d>ddd</d> eee </a> </x> END ok !$x->diff($x); my $y = $x->clone; ok !$x->diff($y); $y->first->putLast($x->newTag(q(f))); ok nws(<<END) eq nws(-p $y); <x> <a>aaa <b>bbb</b> ccc <d>ddd</d> eee <f/> </a> </x> END is_deeply [$x->diff($y)], ["<d>ddd</d> eee <", "/a></x>", "f/></a></x>"]; is_deeply [diff(-p $x, $y)], ["<d>ddd</d> eee <", "/a></x>", "f/></a></x>"]; is_deeply [$x->diff(-p $y)], ["<d>ddd</d> eee <", "/a></x>", "f/></a></x>"]; my $X = writeFile(undef, -p $x); my $Y = writeFile(undef, -p $y); is_deeply [diff($X, $Y)], ["<d>ddd</d> eee <", "/a></x>", "f/></a></x>"];
Save a copy of the parse tree to a file which can be restored and return the saved node.
Parameter Description 1 $node Parse tree 2 $file File.
$y->save($f); my $Y = Data::Edit::Xml::restore($f); ok $Y->equals($y);
Return a parse tree from a copy saved in a file by "save".
Parameter Description 1 $file File
Data::Edit::Xml::restore
Expand the includes mentioned in a parse tree: any tag that ends in include is assumed to be an include directive. The file to be included is named on the href keyword. If the file to be included is a relative file name, i.e. it does not begin with / then this file is made absolute relative to the file from which this parse tree was obtained.
Parameter Description 1 $x Parse tree
{my @files = (writeFile("in1/a.xml", q(<a id="a"><include href="../in2/b.xml"/></a>)), writeFile("in2/b.xml", q(<b id="b"><include href="c.xml"/></b>)), writeFile("in2/c.xml", q(<c id="c"/>))); my $x = Data::Edit::Xml::new(fpf(currentDirectory, $files[0])); $x->expandIncludes; ok <<END eq -p $x; <a id="a"> <b id="b"> <c id="c"/> </b> </a> END
Create a string representation of the parse tree with optional selection of nodes via conditions.
Normally use the methods in Pretty to format the XML in a readable yet reparseable manner; use Dense string to format the XML densely in a reparseable manner; use the other methods to produce unreparseable strings conveniently formatted to assist various specialized operations such as debugging CDATA, using labels or creating tests. A number of the file test operators can also be conveniently used to print parse trees in these formats.
Pretty print the parse tree.
Parameter Description 1 $node Start node 2 $depth Optional depth.
{my $s = <<END; <a> <b> <A/> <B/> </b> <c> <C/> <D/> </c> </a> END my $a = Data::Edit::Xml::new($s); ok $s eq $a->prettyString; ok $s eq -p $a; {my $a = Data::Edit::Xml::new(<<END); <a> <b>bbb</b>. <c>ccc</c>. </a> END ok nn(-p $a) eq qq(<a>N <b>bbb</b>.NN N <c>ccc</c>.NNN</a>N);
Return a readable string representing the parse tree below the specified $node with appropriate headers as determined by ditaOrganization . Or use -x $node
Parameter Description 1 $node Start node
{my $a = Data::Edit::Xml::new(<<END); <concept/> END Data::Edit::Xml::ditaOrganization = q(ACT); ok $a->prettyStringDitaHeaders eq <<END; <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE concept PUBLIC "-//ACT//DTD DITA Concept//EN" "concept.dtd" []> <concept/> END ok -x $a eq <<END; <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE concept PUBLIC "-//ACT//DTD DITA Concept//EN" "concept.dtd" []> <concept/> END
Return a readable string representing a node of a parse tree and all the nodes below it with a number attached to each tag. The node numbers can then be used as described in Order to monitor changes to the parse tree.
{my $s = <<END; <a> <b> <A/> <B/> </b> <c> <C/> <D/> </c> </a> END $a->numberTree; ok $a->prettyStringNumbered eq <<END; <a id="1"> <b id="2"> <A id="3"/> <B id="4"/> </b> <c id="5"> <C id="6"/> <D id="7"/> </c> </a> END
Return a readable string representing a node of a parse tree and all the nodes below it with the text fields wrapped with <CDATA>...</CDATA>.
{my $a = Data::Edit::Xml::new("<a><b>A</b></a>"); my $b = $a->first; $b->first->replaceWithBlank; ok $a->prettyStringCDATA eq <<END; <a> <b><CDATA> </CDATA></b> </a> END
Return a readable string representing all the nodes below a node of a parse tree.
Parameter Description 1 $node Start node.
{my $s = <<END; <a> <b> <A/> <B/> </b> <c> <C/> <D/> </c> </a> END ok $a->prettyStringContent eq <<END; <b> <A/> <B/> </b> <c> <C/> <D/> </c> END
Return a readable string representing all the nodes below a node of a parse tree with numbering added.
{my $s = <<END; <a> <b> <c/> </b> </a> END my $a = Data::Edit::Xml::new($s); $a->numberTree; ok $a->prettyStringContentNumbered eq <<END; <b id="2"> <c id="3"/> </b> END ok $a->go(qw(b))->prettyStringContentNumbered eq <<END; <c id="3"/> END
Add the standard xml header to a string
Parameter Description 1 $string String to which a standard xml header should be prefixed
ok xmlHeader("<a/>") eq <<END; <?xml version="1.0" encoding="UTF-8"?> <a/> END
Data::Edit::Xml::xmlHeader
Print the parse tree.
Return a dense string representing a node of a parse tree and all the nodes below it. Or use -s $node
ok -p $a eq <<END; #tdown #tdownX <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END ok -s $a eq '<a><b><c id="42" match="mm"/></b><d><e/></d></a>';
Return a quoted string representing a parse tree a node of a parse tree and all the nodes below it. Or use -o $node
{my $s = <<END; <a> <b> <A/> <B/> </b> <c> <C/> <D/> </c> </a> END ok $a->stringQuoted eq q('<a><b><A/><B/></b><c><C/><D/></c></a>');
Return a string representing the specified parse tree with the id attribute of each node set to the Labels attached to each node.
ok $x->stringReplacingIdsWithLabels eq '<a><b><c/></b></a>'; $b->addLabels(1..4); $c->addLabels(5..8); ok $x->stringReplacingIdsWithLabels eq '<a><b id="1, 2, 3, 4"><c id="5, 6, 7, 8"/></b></a>'; my $s = $x->stringReplacingIdsWithLabels; ok $s eq '<a><b id="1, 2, 3, 4"><c id="5, 6, 7, 8"/></b></a>';
Return a string representing the specified parse tree with the id attribute of each node extended by the Labels attached to each node.
{my $a = Data::Edit::Xml::new(<<END); <a id="a"> <b id="b"> <c id="c"/> </b> <b id="B"> <c id="C"/> </b> </a> END my $N = 0; $a->by(sub{$_->addLabels((-t $_).++$N)}); ok -p (new $a->stringExtendingIdsWithLabels) eq <<END; <a id="a, a5"> <b id="b, b2"> <c id="c, c1"/> </b> <b id="B, b4"> <c id="C, c3"/> </b> </a> END
Return a string representing all the nodes below a node of a parse tree.
{my $s = <<END; <a> <b> <A/> <B/> </b> <c> <C/> <D/> </c> </a> END ok $a->stringContent eq "<b><A/><B/></b><c><C/><D/></c>";
Return a string representing a node showing the attributes, labels and node number
Parameter Description 1 $node Node.
ok $x->stringReplacingIdsWithLabels eq '<a><b><c/></b></a>'; my $b = $x->go(q(b)); $b->addLabels(1..2); $b->addLabels(3..4); ok $x->stringReplacingIdsWithLabels eq '<a><b id="1, 2, 3, 4"><c/></b></a>'; $b->numberTree; ok -S $b eq "b(2) 0:1 1:2 2:3 3:4";
Print a subset of the the parse tree determined by the conditions attached to it.
Return a string representing a node of a parse tree and all the nodes below it subject to conditions to select or reject some nodes.
Parameter Description 1 $node Start node 2 @conditions Conditions to be regarded as in effect.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> </b> </a> END my $b = $a >= 'b'; my ($c, $d) = $b->contents; $b->addConditions(qw(bb BB)); $c->addConditions(qw(cc CC)); ok $a->stringWithConditions eq '<a><b><c/><d/></b></a>'; ok $a->stringWithConditions(qw(bb)) eq '<a><b><d/></b></a>'; ok $a->stringWithConditions(qw(cc)) eq '<a/>';
Return the node if it has the specified condition and is in the optional context, else return undef
Parameter Description 1 $node Node 2 $condition Condition to check 3 @context Optional context
$b->addConditions(qw(bb BB)); $c->addConditions(qw(cc CC)); ok $c->condition(q(cc)); ok !$c->condition(q(dd)); ok $c->condition(q(cc), qw(c b a));
Return the node if it has any of the specified conditions, else return undef
Parameter Description 1 $node Node 2 @conditions Conditions to check
$b->addConditions(qw(bb BB)); $c->addConditions(qw(cc CC)); ok $b->anyCondition(qw(bb cc)); ok !$b->anyCondition(qw(cc CC));
Return the node if it has all of the specified conditions, else return undef
$b->addConditions(qw(bb BB)); $c->addConditions(qw(cc CC)); ok $b->allConditions(qw(bb BB)); ok !$b->allConditions(qw(bb cc));
Add conditions to a node and return the node.
Parameter Description 1 $node Node 2 @conditions Conditions to add.
$b->addConditions(qw(bb BB)); ok join(' ', $b->listConditions) eq 'BB bb';
Delete conditions applied to a node and return the node.
ok join(' ', $b->listConditions) eq 'BB bb'; $b->deleteConditions(qw(BB)); ok join(' ', $b->listConditions) eq 'bb';
Return a list of conditions applied to a node.
Get or set the attributes of nodes in the parse tree. Well Known Attributes can be set directly via lvalue subs. To set or get the values of other attributes use Get or Set Attributes. To delete or rename attributes see: Other Operations on Attributes.
Get or set these attributes of nodes via lvalue subs as in:
$x->href = "#ref";
Attribute audience for a node as an lvalue sub. Use audienceX() to return q() rather than undef.
Attribute class for a node as an lvalue sub. Use classX() to return q() rather than undef.
Attribute guid for a node as an lvalue sub. Use guidX() to return q() rather than undef.
Attribute href for a node as an lvalue sub. Use hrefX() to return q() rather than undef.
Attribute id for a node as an lvalue sub. Use idX() to return q() rather than undef.
Attribute lang for a node as an lvalue sub. Use langX() to return q() rather than undef.
Attribute navtitle for a node as an lvalue sub. Use navtitleX() to return q() rather than undef.
Attribute otherprops for a node as an lvalue sub. Use otherpropsX() to return q() rather than undef.
Attribute outputclass for a node as an lvalue sub. Use outputclassX() to return q() rather than undef.
Attribute props for a node as an lvalue sub. Use propsX() to return q() rather than undef.
Attribute style for a node as an lvalue sub. Use styleX() to return q() rather than undef.
Attribute type for a node as an lvalue sub. Use typeX() to return q() rather than undef.
Get or set the attributes of nodes.
Parameter Description 1 $node Node in parse tree 2 $attribute Attribute name.
{my $x = Data::Edit::Xml::new(my $s = <<END); <a number="1"/> END ok $x->attr(qq(number)) == 1; $x->attr(qq(number)) = 2; ok $x->attr(qq(number)) == 2; ok -s $x eq '<a number="2"/>';
Set the values of some attributes in a node and return the node. Identical in effect to setAttr.
Parameter Description 1 $node Node in parse tree 2 %values (attribute name=>new value)*
ok q(<a a="1" b="1" id="aa"/>) eq -s $a; $a->set(a=>11, b=>undef, c=>3, d=>4, e=>5); }
Set the values of some attributes in a node and return the node. Identical in effect to set.
ok -s $x eq '<a number="2"/>'; $x->setAttr(first=>1, second=>2, last=>undef); ok -s $x eq '<a first="1" number="2" second="2"/>';
Perform operations other than get or set on the attributes of a node
Return the values of the specified attributes of the current node as a list
Parameter Description 1 $node Node in parse tree 2 @attributes Attribute names.
ok -s $x eq '<a first="1" number="2" second="2"/>'; is_deeply [$x->attrs(qw(third second first ))], [undef, 2, 1];
Return the number of attributes in the specified $node, optionally ignoring the specified names from the count.
Parameter Description 1 $node Node in parse tree 2 @exclude Optional attribute names to exclude from the count.
ok -s $x eq '<a first="1" number="2" second="2"/>'; ok $x->attrCount == 3; ok $x->attrCount(qw(first second third)) == 1;
Return a sorted list of all the attributes on this node.
Parameter Description 1 $node Node in parse tree.
ok -s $x eq '<a first="1" number="2" second="2"/>'; is_deeply [$x->getAttrs], [qw(first number second)];
Delete the named attribute in the specified $node, optionally check its value first, return the node regardless.
Parameter Description 1 $node Node 2 $attr Attribute name 3 $value Optional attribute value to check first.
ok -s $x eq '<a delete="me" number="2"/>'; $x->deleteAttr(qq(delete)); ok -s $x eq '<a number="2"/>';
Delete the specified attributes of the specified $node without checking their values and return the node.
Parameter Description 1 $node Node 2 @attrs Names of the attributes to delete
ok -s $x eq '<a first="1" number="2" second="2"/>'; $x->deleteAttrs(qw(first second third number)); ok -s $x eq '<a/>';
Change the name of an attribute in the specified $node regardless of whether the new attribute already exists or not and return the node. To prevent inadvertent changes to an existing attribute use changeAttr.
Parameter Description 1 $node Node 2 $old Existing attribute name 3 $new New attribute name.
ok $x->printAttributes eq qq( no="1" word="first"); $x->renameAttr(qw(no number)); ok $x->printAttributes eq qq( number="1" word="first");
Change the name of an attribute in the specified $node unless it has already been set and return the node. To make changes regardless of whether the new attribute already exists use renameAttr.
ok $x->printAttributes eq qq( number="1" word="first"); $x->changeAttr(qw(number word)); ok $x->printAttributes eq qq( number="1" word="first");
Change the name and value of an attribute in the specified $node regardless of whether the new attribute already exists or not and return the node. To prevent inadvertent changes to existing attributes use changeAttrValue.
Parameter Description 1 $node Node 2 $old Existing attribute name 3 $oldValue Existing attribute value 4 $new New attribute name 5 $newValue New attribute value.
ok $x->printAttributes eq qq( number="1" word="first"); $x->renameAttrValue(qw(number 1 numeral I)); ok $x->printAttributes eq qq( numeral="I" word="first");
Change the name and value of an attribute in the specified $node unless it has already been set and return the node. To make changes regardless of whether the new attribute already exists use renameAttrValue.
ok $x->printAttributes eq qq( numeral="I" word="first"); $x->changeAttrValue(qw(word second greek mono)); ok $x->printAttributes eq qq( numeral="I" word="first"); $x->changeAttrValue(qw(word first greek mono)); ok $x->printAttributes eq qq( greek="mono" numeral="I");
Apply a sub to the value of an attribute of the specified $node. The value to be changed is supplied and returned in: $_.
Parameter Description 1 $node Node 2 $attribute Attribute name 3 $sub Change sub 4 @context Optional context;
{my $a = Data::Edit::Xml::new(<<END); <a aa="abc"/> END $a->changeAttributeValue(q(aa), sub{s(b) (B)}); ok -p $a eq <<END; <a aa="aBc"/> END
Copy all the attributes of the source node to the target node, or, just the named attributes if the optional list of attributes to copy is supplied, overwriting any existing attributes in the target node and return the source node.
Parameter Description 1 $source Source node 2 $target Target node 3 @attr Optional list of attributes to copy
{my $x = Data::Edit::Xml::new(<<END); <x> <a a="1" b="2"/> <b b="3" c="4"/> <c/> </x> END my ($a, $b, $c) = $x->contents; $a->copyAttrs($b, qw(aa bb)); ok <<END eq -p $x; <x> <a a="1" b="2"/> <b b="3" c="4"/> <c/> </x> END $a->copyAttrs($b); ok <<END eq -p $x; <x> <a a="1" b="2"/> <b a="1" b="2" c="4"/> <c/> </x> END
Copy all the attributes of the source node to the target node, or, just the named attributes if the optional list of attributes to copy is supplied, without overwriting any existing attributes in the target node and return the source node.
{my $x = Data::Edit::Xml::new(<<END); <x> <a a="1" b="2"/> <b b="3" c="4"/> <c/> </x> END my ($a, $b, $c) = $x->contents; $a->copyNewAttrs($b, qw(aa bb)); ok <<END eq -p $x; <x> <a a="1" b="2"/> <b b="3" c="4"/> <c/> </x> END $a->copyNewAttrs($b); ok <<END eq -p $x; <x> <a a="1" b="2"/> <b a="1" b="3" c="4"/> <c/> </x> END
Move all the attributes of the source node to the target node, or, just the named attributes if the optional list of attributes to move is supplied, overwriting any existing attributes in the target node and return the source node.
Parameter Description 1 $source Source node 2 $target Target node 3 @attr Attributes to move
{my $x = Data::Edit::Xml::new(<<END); <x> <a a="1" b="2"/> <b b="3" c="4"/> <c/> </x> END my ($a, $b, $c) = $x->contents; $a->moveAttrs($c, qw(aa bb)); ok <<END eq -p $x; <x> <a a="1" b="2"/> <b a="1" b="2" c="4"/> <c/> </x> END $b->moveAttrs($c); ok <<END eq -p $x; <x> <a a="1" b="2"/> <b/> <c a="1" b="2" c="4"/> </x> END
Move all the attributes of the source node to the target node, or, just the named attributes if the optional list of attributes to copy is supplied, without overwriting any existing attributes in the target node and return the source node.
Parameter Description 1 $source Source node 2 $target Target node 3 @attr Optional list of attributes to move
{my $x = Data::Edit::Xml::new(<<END); <x> <a a="1" b="2"/> <b b="3" c="4"/> <c/> </x> END my ($a, $b, $c) = $x->contents; $b->moveNewAttrs($c, qw(aa bb)); ok <<END eq -p $x; <x> <a a="1" b="2"/> <b a="1" b="3" c="4"/> <c/> </x> END $b->moveNewAttrs($c); ok <<END eq -p $x; <x> <a a="1" b="2"/> <b/> <c a="1" b="3" c="4"/> </x> END ok <<END eq -p $x; <x> <c a="1" b="3" c="4"/> <b/> <a a="1" b="2"/> </x> END
Traverse the parse tree in various orders applying a sub to each node.
This order allows you to edit children before their parents.
Parameter Description 1 $node Starting node 2 $sub Sub to call for each sub node 3 @context Accumulated context.
ok -p $a eq <<END; #tdown #tdownX <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END {my $s; $a->by(sub{$s .= $_->tag}); ok $s eq "cbeda"
Post-order traversal of a parse tree calling the specified sub at each node as long as this sub does not die. The traversal is halted if the called sub does die on any call with the reason in ?@ The sub is passed references to the current node and all of its ancestors up to the node on which this sub was called. A reference to the current node is also made available via $_.
Returns the start node regardless of the outcome of calling sub.
Parameter Description 1 $node Start node 2 $sub Sub to call
ok -p $a eq <<END; #tdown #tdownX <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END {my $s; $a->byX(sub{$s .= $_->tag}); ok $s eq "cbeda" sub byX($$) {my ($node, $sub) = @_; # Start node, sub to call eval {$node->byX2($sub)}; # Trap any errors that occur $node }
Return a list of all the nodes at and below a specified $node in pre-order or the empty list if the $node is not in the optional context.
Parameter Description 1 $node Starting node 2 @context Optional context
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END ok -c $e eq q(e d a);
Reverse post-order traversal of a parse tree or sub tree calling the specified sub at each node and returning the specified starting $node. The sub is passed references to the current node and all of its ancestors. The value of the current node is also made available via $_.
ok -p $a eq <<END; #tdown #tdownX <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END {my $s; $a->byReverse(sub{$s .= $_->tag}); ok $s eq "edcba"
Reverse post-order traversal of a parse tree or sub tree below the specified $node calling the specified sub within eval{} at each node and returning the specified starting $node. The sub is passed references to the current node and all of its ancestors. The value of the current node is also made available via $_.
Return a list of all the nodes at and below a specified $node in reverse preorder or the empty list if the specified $node is not in the optional context.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END my ($E, $D, $C, $B) = $a->byReverseList; ok -A $C eq q(c id="42" match="mm");
This order allows you to edit children after their parents
Pre-order traversal down through a parse tree or sub tree calling the specified sub at each node and returning the specified starting node. The sub is passed references to the current node and all of its ancestors. The value of the current node is also made available via $_.
{my $s; $a->down(sub{$s .= $_->tag}); ok $s eq "abcde"
Pre-order traversal of a parse tree calling the specified sub at each node as long as this sub does not die. The traversal is halted if the called sub does die on any call with the reason in ?@ The sub is passed references to the current node and all of its ancestors up to the node on which this sub was called. A reference to the current node is also made available via $_.
{my $s; $a->down(sub{$s .= $_->tag}); ok $s eq "abcde" sub downX($$) {my ($node, $sub) = @_; # Start node, sub to call eval {$node->downX2($sub)}; # Trap any errors that occur $node }
Reverse pre-order traversal down through a parse tree or sub tree calling the specified sub at each node and returning the specified starting node. The sub is passed references to the current node and all of its ancestors. The value of the current node is also made available via $_.
ok -p $a eq <<END; #tdown #tdownX <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END {my $s; $a->downReverse(sub{$s .= $_->tag}); ok $s eq "adebc"
Reverse pre-order traversal down through a parse tree or sub tree calling the specified sub within eval{} at each node and returning the specified starting node. The sub is passed references to the current node and all of its ancestors. The value of the current node is also made available via $_.
Visit the parent first, then the children, then the parent again.
Traverse parse tree visiting each node twice calling the specified sub at each node and returning the specified starting node. The subs are passed references to the current node and all of its ancestors. The value of the current node is also made available via $_.
Parameter Description 1 $node Starting node 2 $before Sub to call when we meet a node 3 $after Sub to call we leave a node 4 @context Accumulated context.
{my $s; my $n = sub{$s .= $_->tag}; $a->through($n, $n); ok $s eq "abccbdeeda"
Traverse parse tree visiting each node twice calling the specified sub within eval{} at each node and returning the specified starting node. The sub is passed references to the current node and all of its ancestors. The value of the current node is also made available via $_.
Ranges of nodes
Return a list consisting of the specified node and its following siblings optionally including only those nodes that match one of the tags in the specified list.
Parameter Description 1 $start Start node 2 @match Optional list of tags to match
ok -z $a eq <<END; <a id="1"> <b id="2"> <c id="3"> <e id="4"/> </c> <d id="5"> <e id="6"/> </d> <c id="7"> <d id="8"> <e id="9"/> </d> </c> <d id="10"> <e id="11"/> </d> <c id="12"> <d id="13"> <e id="14"/> </d> </c> </b> </a> END {my ($d, $c, $D) = $a->findByNumbers(5, 7, 10); my @f = $d->from; ok @f == 4; ok $d == $f[0]; my @F = $d->from(qw(c)); ok @F == 2; ok -M $F[1] == 12; ok $D == $t[-1];
Return a list of the sibling nodes preceding the specified node optionally including only those nodes that match one of the tags in the specified list.
Parameter Description 1 $end End node 2 @match Optional list of tags to match
ok -z $a eq <<END; <a id="1"> <b id="2"> <c id="3"> <e id="4"/> </c> <d id="5"> <e id="6"/> </d> <c id="7"> <d id="8"> <e id="9"/> </d> </c> <d id="10"> <e id="11"/> </d> <c id="12"> <d id="13"> <e id="14"/> </d> </c> </b> </a> END {my ($d, $c, $D) = $a->findByNumbers(5, 7, 10); my @t = $D->to; ok @t == 4; my @T = $D->to(qw(c)); ok @T == 2; ok -M $T[1] == 7;
Return a list of the nodes between the specified start and end nodes optionally including only those nodes that match one of the tags in the specified list.
Parameter Description 1 $start Start node 2 $end End node 3 @match Optional list of tags to match
ok -z $a eq <<END; <a id="1"> <b id="2"> <c id="3"> <e id="4"/> </c> <d id="5"> <e id="6"/> </d> <c id="7"> <d id="8"> <e id="9"/> </d> </c> <d id="10"> <e id="11"/> </d> <c id="12"> <d id="13"> <e id="14"/> </d> </c> </b> </a> END {my ($d, $c, $D) = $a->findByNumbers(5, 7, 10); my @r = $d->fromTo($D); ok @r == 3; my @R = $d->fromTo($D, qw(c)); ok @R == 1; ok -M $R[0] == 7; ok !$D->fromTo($d); ok 1 == $d->fromTo($d);
Confirm that the position navigated to is the expected position.
Parameter Description 1 $start Starting node 2 @context Ancestry.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> <c> <e/> </c> <c> <f/> </c> </b> </a> END ok $a->go(qw(b c -1 f))->at(qw(f c b a)); ok $a->go(qw(b c 1 e))->at(undef, qr(c|d), undef, qq(a)); ok $d->context eq q(d c b a); ok $d->at(qw(d c b), undef); ok !$d->at(qw(d c b), undef, undef); ok !$d->at(qw(d e b));
Return the specified $node if it does not match any of the specified tags, else undef
Parameter Description 1 $node Node 2 @tags Tags not to match
{my $a = Data::Edit::Xml::new(<<END); <a> <b/> </a> END ok $a->first->not_a_c;
Confirm that the node or one of its ancestors has the specified context as recognized by at and return the first node that matches the context or undef if none do.
ok $d->context eq q(d c b a); ok $d->atOrBelow(qw(d c b a)); ok $d->atOrBelow(qw( c b a)); ok $d->atOrBelow(qw( b a)); ok !$d->atOrBelow(qw( c a));
Return the first node if it is adjacent to the second node else undef.
Parameter Description 1 $first First node 2 $second Second node
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <b> <c/> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $C, $B, $f, $e) = $a->byList; ok !$a->adjacent($B); ok $b->adjacent($B);
Return a list containing: (the specified $node, its parent, its parent's parent etc..). Or use upn to go up the specified number of levels.
Parameter Description 1 $node Starting node.
$a->numberTree; ok $a->prettyStringNumbered eq <<END; <a id="1"> <b id="2"> <A id="3"/> <B id="4"/> </b> <c id="5"> <C id="6"/> <D id="7"/> </c> </a> END is_deeply [map {-t $_} $a->findByNumber(7)->ancestry], [qw(D c a)];
Return a string containing the tag of the starting node and the tags of all its ancestors separated by single spaces.
ok -p $a eq <<END; #tdown #tdownX <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END ok $a->go(qw(d e))->context eq 'e d a';
Return the single text element below the specified $node else return undef.
Parameter Description 1 $node Node 2 @context Optional context
{my $a = Data::Edit::Xml::new("<a><b>bb</b><c>cc<d/>ee</c></a>"); ok $a->go(q(b))->containsSingleText->text eq q(bb); ok !$a->go(q(c))->containsSingleText;
Returns the depth of the specified $node, the depth of a root node is zero.
ok -z $a eq <<END; <a id="1"> <b id="2"> <c id="3"> <e id="4"/> </c> <d id="5"> <e id="6"/> </d> <c id="7"> <d id="8"> <e id="9"/> </d> </c> <d id="10"> <e id="11"/> </d> <c id="12"> <d id="13"> <e id="14"/> </d> </c> </b> </a> END ok 0 == $a->depth; ok 4 == $a->findByNumber(14)->depth;
Return the specified $node if it is first under its parent and optionally has the specified context, else return undef
Use isFirstNonBlank to skip a (rare) initial blank text CDATA. Use isFirstNonBlankX to die rather then receive a returned undef or false result.
ok -p $a eq <<END; #tdown #tdownX <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END ok $a->go(q(b))->isFirst; {my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <b> <c/> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $C, $B, $f, $e) = $a->byList; ok $a->isFirst;
Return the specified $node if it is first to the specified depth else return undef
Parameter Description 1 $node Node 2 $depth Depth 3 @context Optional context
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $f, $e) = $a->byList; ok $d->isFirstToDepth(4); ok !$f->isFirstToDepth(2); ok $f->isFirstToDepth(1); ok !$f->isFirstToDepth(3);
Return the specified $node if it is last under its parent and optionally has the specified context, else return undef
Use isLastNonBlank to skip a (rare) initial blank text CDATA. Use isLastNonBlankX to die rather then receive a returned undef or false result.
ok -p $a eq <<END; #tdown #tdownX <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END ok $a->go(q(d))->isLast; {my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <b> <c/> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $C, $B, $f, $e) = $a->byList; ok $a->isLast;
Return the specified $node if it is last to the specified depth else return undef
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $f, $e) = $a->byList; ok $c->isLastToDepth(1); ok !$c->isLastToDepth(3); ok $d->isLastToDepth(2); ok !$d->isLastToDepth(4);
Return the specified $node if it is the only node under its parent ignoring any surrounding blank text.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $f, $e) = $a->byList; ok $d->isOnlyChild; ok !$d->isOnlyChild(qw(b)); {my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <b> <c/> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $C, $B, $f, $e) = $a->byList; ok $a->isOnlyChild;
Return the specified $node if it and its ancestors are only children to the specified depth else return undef. isOnlyChildToDepth(1) is the same as isOnlychild
Parameter Description 1 $node Node 2 $depth Depth to which each parent node must also be an only child 3 @context Optional context
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $f, $e) = $a->byList; ok $d->isOnlyChildToDepth(1, qw(d c b a)); ok $d->isOnlyChildToDepth(2, qw(d c b a)); ok !$d->isOnlyChildToDepth(3, qw(d c b a));
Return the only child of the specified $node if the child is the only node under its parent ignoring any surrounding blank text and has the optional specified context, else return undef.
{my $a = Data::Edit::Xml::new(<<END); <a> <b id="b" b="bb"> <b id="c" c="cc"/> </b> </a> END my ($c, $b) = $a->byList; is_deeply [$b->id, $c->id], [qw(b c)]; ok $c == $b->singleChild; ok $b == $a->singleChild;
Return the specified $node if it has single children to at least the specified depth else return undef. singleChildToDepth(0) is equivalent to singleChild.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> <e> <j/> </e> <f/> </b> <g> <h> <i> <k/> <l/> </i> </h> </g> </a> END my ($c, $d, $j, $e, $f, $b, $k, $l, $i, $h, $g) = $a->byList; ok $h == $g->singleChildToDepth(1); ok $i == $g->singleChildToDepth(2); ok !$g->singleChildToDepth(0); ok !$g->singleChildToDepth(3); ok $i == $i->singleChildToDepth(0);
Confirm that this node is empty, that is: this node has no content, not even a blank string of text. To test for blank nodes, see isAllBlankText.
{my $x = Data::Edit::Xml::new(<<END); <a> </a> END ok $x->isEmpty; {my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $f, $e) = $a->byList; ok $d->isEmpty;
Confirm that the string representing the tags at the level below this node match a regular expression where each pair of tags is separated by a single space. Use contentAsTags to visualize the tags at the next level.
Parameter Description 1 $node Node 2 $re Regular expression 3 @context Optional context.
{my $x = Data::Edit::Xml::new(<<END); <a> <b> <c/><d/><e/><f/><g/> </b> </a> END ok $x->go(q(b))->over(qr(d.+e));
Confirm that the string representing the tags at the level below this node match a regular expression where each pair of tags have two spaces between them and the first tag is preceded by a single space and the last tag is followed by a single space. This arrangement simplifies the regular expression used to detect combinations like p+ q? . Use contentAsTags2 to visualize the tags at the next level.
{my $x = Data::Edit::Xml::new(<<END); <a> <b> <c/><d/><e/><f/><g/> </b> </a> END ok $x->go(q(b))->over2(qr(\A c d e f g \Z)); ok $x->go(q(b))->contentAsTags eq q(c d e f g) ;
Return the specified b<$node> if all of it's child nodes match the specified <@tags> else return undef.
Parameter Description 1 $node Node 2 @tags Tags.
if (1) {my $a = Data::Edit::Xml::new(<<END); <a> <b/> <c/> <d/> </a> END ok $a->overAllTags_b_c_d; ok !$a->overAllTags_b_c; ok !$a->overAllTags_b_c_d_e; ok $a->oat_b_c_d; ok !$a->oat_B_c_d; ok $a->overFirstTags_b_c_d; ok $a->overFirstTags_b_c; ok !$a->overFirstTags_b_c_d_e; ok $a->oft_b_c; ok !$a->oft_B_c; ok $a->overLastTags_b_c_d; ok $a->overLastTags_c_d; ok !$a->overLastTags_b_c_d_e; ok $a->olt_c_d; ok !$a->olt_C_d; }
oat is a synonym for overAllTags.
Return the specified b<$node> if the first of it's child nodes match the specified <@tags> else return undef.
oft is a synonym for overFirstTags.
Return the specified b<$node> if the last of it's child nodes match the specified <@tags> else return undef.
olt is a synonym for overLastTags.
Confirm that the string representing the tags following this node matches a regular expression where each pair of tags is separated by a single space. Use contentAfterAsTags to visualize these tags.
{my $x = Data::Edit::Xml::new(<<END); <a> <b> <c/><d/><e/><f/><g/> </b> </a> END ok $x->go(qw(b e))->matchAfter (qr(\Af g\Z));
Confirm that the string representing the tags following this node matches a regular expression where each pair of tags have two spaces between them and the first tag is preceded by a single space and the last tag is followed by a single space. This arrangement simplifies the regular expression used to detect combinations like p+ q? Use contentAfterAsTags2 to visualize these tags.
{my $x = Data::Edit::Xml::new(<<END); <a> <b> <c/><d/><e/><f/><g/> </b> </a> END ok $x->go(qw(b e))->matchAfter2 (qr(\A f g \Z));
Confirm that the string representing the tags preceding this node matches a regular expression where each pair of tags is separated by a single space. Use contentBeforeAsTags to visualize these tags.
{my $x = Data::Edit::Xml::new(<<END); <a> <b> <c/><d/><e/><f/><g/> </b> </a> END ok $x->go(qw(b e))->matchBefore (qr(\Ac d\Z));
Confirm that the string representing the tags preceding this node matches a regular expression where each pair of tags have two spaces between them and the first tag is preceded by a single space and the last tag is followed by a single space. This arrangement simplifies the regular expression used to detect combinations like p+ q? Use contentBeforeAsTags2 to visualize these tags.
{my $x = Data::Edit::Xml::new(<<END); <a> <b> <c/><d/><e/><f/><g/> </b> </a> END ok $x->go(qw(b e))->matchBefore2(qr(\A c d \Z));
Return a list representing the path to a node which can then be reused by go to retrieve the node as long as the structure of the parse tree has not changed along the path.
my $x = Data::Edit::Xml::new(<<END); <a id='a1'> <b id='b1'> <c id='c1'/> <c id='c2'/> <d id='d1'> <e id='e1'/> </d> <c id='c3'/> <c id='c4'/> <d id='d2'> <e id='e2'/> </d> <c id='c5'/> <c id='c6'/> </b> </a> END is_deeply [$x->go(qw(b d 1 e))->path], [qw(b d 1 e)]; $x->by(sub {ok $x->go($_->path) == $_});
Return a string representing the path to the specified $node.
ok -z $a eq <<END; <a id="1"> <b id="2"> <c id="3"> <e id="4"/> </c> <d id="5"> <e id="6"/> </d> <c id="7"> <d id="8"> <e id="9"/> </d> </c> <d id="10"> <e id="11"/> </d> <c id="12"> <d id="13"> <e id="14"/> </d> </c> </b> </a> END ok $a->findByNumber(9)->pathString eq 'b c 1 d e';
Locate adjacent nodes that match horizontally and vertically
Return the next node if the specified $node has the specified tag and the next node is in the specified context.
Parameter Description 1 $node Node 2 $tag Tag node must match 3 @context Optional context of the next node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> <e> <j/> </e> <f/> </b> <g> <h> <i> <k/> <l/> </i> </h> </g> </a> END my ($c, $d, $j, $e, $f, $b, $k, $l, $i, $h, $g) = $a->byList; ok $e == $d->an_d_e_b_a; ok $f == $e->an_e; ok !$f->an_f;
Return the previous node if the specified $node has the specified tag and the previous node is in the specified context.
Parameter Description 1 $node Node 2 $tag Tag node must match 3 @context Optional context of the previous node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> <e> <j/> </e> <f/> </b> <g> <h> <i> <k/> <l/> </i> </h> </g> </a> END my ($c, $d, $j, $e, $f, $b, $k, $l, $i, $h, $g) = $a->byList; ok $c == $d->ap_d_c_b_a; ok $c == $d->ap_d; ok !$c->ap_c;
Return (previous node, next node) if the previous and current nodes have the specified tags and the next node is in the specified context else return ().
Parameter Description 1 $node Current node 2 $prev Tag for the previous node 3 $tag Tag for specified node 4 @context Context for the next node.
Use the @context parameter to test the context of the specified $node as understood by method at. If a context is supplied and $node is not in this context then this method returns an empty list () immediately.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> <e> <j/> </e> <f/> </b> <g> <h> <i> <k/> <l/> </i> </h> </g> </a> END my ($c, $d, $j, $e, $f, $b, $k, $l, $i, $h, $g) = $a->byList; is_deeply[$c, $e], [$d->apn_c_d_e_b_a];
Return the specified b<$node> if the siblings following the specified $node match the specified <@tags> else return undef.
if (1) {my $a = Data::Edit::Xml::new(<<END); <a><b><c/><d/><e/><f/></b></a> END ok -t $a->first__first__matchesNextTags_d_e eq q(c); ok -t $a->first__first__mnt_d_e eq q(c); ok !$a-> first__matchesNextTags_d_e; ok -t $a-> last->last__matchesPrevTags_e_d eq q(f); ok -t $a-> last->last__mpt_e_d eq q(f); ok !$a-> last__matchesPrevTags_e_d; }
mnt is a synonym for matchesNextTags.
Return the specified b<$node> if the siblings prior to the specified $node match the specified <@tags> else return undef.
mpt is a synonym for matchesPrevTags.
Move around in the parse tree.
Parameter Description 1 $node Node 2 @path Search specification.
{my $x = Data::Edit::Xml::new(my $s = <<END); <aa> <a> <b/> <c id="1"/><c id="2"/><c id="3"/><c id="4"/> <d/> </a> </aa> END ok $x->go(qw(a c)) ->id == 1; ok $x->go(qw(a c -2))->id == 3; ok $x->go(qw(a c *)) == 4; ok 1234 == join '', map {$_->id} $x->go(qw(a c *));
Return an array of all the nodes with the specified tag below the specified $node. This method is deprecated in favor of applying grep to contents.
Parameter Description 1 $node Node 2 $tag Tag.
{my $x = Data::Edit::Xml::new(<<END); <a> <b id="b1"><c id="1"/></b> <d id="d1"><c id="2"/></d> <e id="e1"><c id="3"/></e> <b id="b2"><c id="4"/></b> <d id="d2"><c id="5"/></d> <e id="e2"><c id="6"/></e> </a> END is_deeply [map{-u $_} $x->c(q(d))], [qw(d1 d2)];
Find nodes that are first amongst their siblings.
Return the first node below this node optionally checking its context. See addFirst to ensure that an expected node is in position.
Parameter Description 1 $node Node 2 @context Optional context.
Use firstNonBlank to skip a (rare) initial blank text CDATA. Use firstNonBlankX to die rather then receive a returned undef or false result.
{my $a = Data::Edit::Xml::new(<<END); <a id="11"> <b id="12"> <c id="13"/> <d id="14"/> <b id="15"> <c id="16"/> <d id="17"/> <e id="18"/> <f id="19"/> <g id="20"/> </b> <f id="21"/> <g id="22"/> </b> <b id="23"> <c id="24"/> <d id="25"/> <b id="26"> <c id="27"/> <d id="28"/> <e id="29"/> <f id="30"/> <g id="31"/> </b> <f id="32"/> <g id="33"/> </b> </a> END ok $a->go(q(b))->first->id == 13; ok $a->go(q(b))->first(qw(c b a)); ok !$a->go(q(b))->first(qw(b a));
Return the $n'th first node below this node optionally checking its context or undef if there is no such node. firstn(1) is identical in effect to first.
Parameter Description 1 $node Node 2 $N Number of times to go first 3 @context Optional context.
if (1) {my $a = Data::Edit::Xml::new(<<END); <a><b><c><d/><e/><f/></c></b></a> END ok -p $a eq <<END; <a> <b> <c> <d/> <e/> <f/> </c> </b> </a> END ok -t $a->firstn_0 eq q(a); ok -t $a->firstn_1 eq q(b); ok -t $a->firstn_2 eq q(c); ok -t $a->firstn_3 eq q(d); ok -t $a->firstn_3__nextn_0 eq q(d); ok -t $a->firstn_3__nextn_1 eq q(e); ok -t $a->firstn_3__nextn_2 eq q(f); }
Return the first node if it is a text node otherwise undef
ok -p $a eq <<END; <a>AA <b/> BB <c/> CC <d/> <e/> <f/> DD <g/> HH </a> END ok $a->firstText; ok !$a->go(qw(c))->firstText;
Return the first node under the specified $node if: it is a text mode; its text matches the specified regular expression; the specified $node is in the optional specified context. Else return undef.
Parameter Description 1 $node Node 2 $match Regular expression the text must match 3 @context Optional context of specified node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b>bb<c>cc</c>BB </b> </a> END my ($bb, $cc, $c, $BB, $b) = $a->byList; ok $bb->matchesText(qr(bb)); ok $b->at_b_a && $b->firstTextMatches(qr(bb)); ok $b->firstTextMatches(qr(bb), qw(b a)); ok $c->at_c_b && $c->firstTextMatches(qr(cc)); ok $c->at_c_b && !$c->firstTextMatches(qr(bb));
Return a list of the first instance of each specified tag encountered in a post-order traversal from the specified $node or a hash of all first instances if no tags are specified.
Parameter Description 1 $node Node 2 @tags Tags to search for.
{my $a = Data::Edit::Xml::new(<<END); <a id="11"> <b id="12"> <c id="13"/> <d id="14"/> <b id="15"> <c id="16"/> <d id="17"/> <e id="18"/> <f id="19"/> <g id="20"/> </b> <f id="21"/> <g id="22"/> </b> <b id="23"> <c id="24"/> <d id="25"/> <b id="26"> <c id="27"/> <d id="28"/> <e id="29"/> <f id="30"/> <g id="31"/> </b> <f id="32"/> <g id="33"/> </b> </a> END {my %f = $a->firstBy; ok $f{b}->id == 12;
Return a list of the first instance of each specified tag encountered in a pre-order traversal from the specified $node or a hash of all first instances if no tags are specified.
{my %f = $a->firstDown; ok $f{b}->id == 15;
Return the first child node matching one of the named tags under the specified parent node.
Parameter Description 1 $node Parent node 2 @tags Child tags to search for.
ok $a->prettyStringCDATA eq <<'END'; <a><CDATA> </CDATA> <A/> <CDATA> </CDATA> <C/> <CDATA> </CDATA> <E/> <CDATA> </CDATA> <G/> <CDATA> </CDATA> </a> END ok $a->firstIn(qw(b B c C))->tag eq qq(C);
Return the first child node that does not match any of the named @tags under the specified parent $node. Return undef if there is no such child node.
Parameter Description 1 $node Parent node 2 @tags Child tags to avoid.
{my $a = Data::Edit::Xml::new(<<END); <a> <b/> <c/> <d/> <e/> <f/> </a> END my ($b, $c, $d, $e, $f) = $a->byList; ok $c == $a->firstNot_a_b;
Return the specified $node if it is first in its index and optionally at the specified context else undef
ok -z $a eq <<END; <a id="1"> <b id="2"> <c id="3"> <e id="4"/> </c> <d id="5"> <e id="6"/> </d> <c id="7"> <d id="8"> <e id="9"/> </d> </c> <d id="10"> <e id="11"/> </d> <c id="12"> <d id="13"> <e id="14"/> </d> </c> </b> </a> END ok $a->findByNumber (5)->firstInIndex; ok !$a->findByNumber(7) ->firstInIndex;
Return an array of the nodes that are continuously first under their specified parent node and that match the specified list of tags.
{my $a = Data::Edit::Xml::new(<<END); <a><b><c/><d/><d/><e/><d/><d/><c/></b></a> END is_deeply [qw(c d d)], [map {-t $_} $a->go(q(b))->firstOf(qw(c d))];
Go first from the specified $node and continue deeper as long as each first child node matches one of the specified @tags. Return the deepest such node encountered or else return undef if no such node is encountered.
{my $a = Data::Edit::Xml::new(<<END); <a><b><c><d><e><f/> </e></d></c></b> <B><C><D><E><F/> </E></D></C></B></a> END my ($f, $e, $d, $c, $b, $F, $E, $D, $C, $B) = $a->byList; if (1)
Go first from the specified $node and continue deeper until a first child node matches the specified @context or return undef if there is no such node. Return the first child of the specified $node if no @context is specified.
Parameter Description 1 $node Node 2 @context Context to search for.
Return the first node encountered in the specified context in a depth first post-order traversal of the parse tree.
Parameter Description 1 $node Node 2 @context Array of tags specifying context.
{my $x = Data::Edit::Xml::new(<<END); <a id="a1"> <b1 id="b1"> <c id="c1"> <d id="d1">DD11</d> <e id="e1">EE11</e> </c> </b1> <b2 id="b2"> <c id="c2"> <d id="d2">DD22</d> <e id="e2">EE22</e> </c> </b2> <b3 id="b3"> <c id="c3"> <d id="d3">DD33</d> <e id="e3">EE33</e> </c> </b3> </a> END ok $x->firstContextOf(qw(d c)) ->id eq qq(d1); ok $x->firstContextOf(qw(e c b2)) ->id eq qq(e2); ok $x->firstContextOf(qw(CDATA d c b2))->string eq qq(DD22);
Return the first sibling of the specified $node in the optional context else undef
{my $a = Data::Edit::Xml::new(<<END); <a id="11"> <b id="12"> <c id="13"/> <d id="14"/> <b id="15"> <c id="16"/> <d id="17"/> <e id="18"/> <f id="19"/> <g id="20"/> </b> <f id="21"/> <g id="22"/> </b> <b id="23"> <c id="24"/> <d id="25"/> <b id="26"> <c id="27"/> <d id="28"/> <e id="29"/> <f id="30"/> <g id="31"/> </b> <f id="32"/> <g id="33"/> </b> </a> END ok $a->go(qw(b b))->firstSibling->id == 13;
Find nodes that are last amongst their siblings.
Return the last node below this node optionally checking its context. See addLast to ensure that an expected node is in position.
Use lastNonBlank to skip a (rare) initial blank text CDATA. Use lastNonBlankX to die rather then receive a returned undef or false result.
{my $a = Data::Edit::Xml::new(<<END); <a id="11"> <b id="12"> <c id="13"/> <d id="14"/> <b id="15"> <c id="16"/> <d id="17"/> <e id="18"/> <f id="19"/> <g id="20"/> </b> <f id="21"/> <g id="22"/> </b> <b id="23"> <c id="24"/> <d id="25"/> <b id="26"> <c id="27"/> <d id="28"/> <e id="29"/> <f id="30"/> <g id="31"/> </b> <f id="32"/> <g id="33"/> </b> </a> END ok $a->go(q(b))->last ->id == 22; ok $a->go(q(b))->last(qw(g b a)); ok !$a->go(q(b))->last(qw(b a)); ok !$a->go(q(b))->last(qw(b a));
Return the $n'th last node below this node optionally checking its context or undef if there is no such node. lastn(1) is identical in effect to last.
Parameter Description 1 $node Node 2 $N Number of times to go last 3 @context Optional context.
if (1) {my $a = Data::Edit::Xml::new(<<END); <a><b><c><d/><e/><f/></c></b> <B><C><D/><E/><F/></C></B></a> END ok -p $a eq <<END; <a> <b> <c> <d/> <e/> <f/> </c> </b> <B> <C> <D/> <E/> <F/> </C> </B> </a> END ok -t $a->lastn_0 eq q(a); ok -t $a->lastn_1 eq q(B); ok -t $a->lastn_2 eq q(C); ok -t $a->lastn_3 eq q(F); ok -t $a->lastn_3__prevn_0 eq q(F); ok -t $a->lastn_3__prevn_1 eq q(E); ok -t $a->lastn_3__prevn_2 eq q(D); }
Return the last node if it is a text node otherwise undef
ok -p $a eq <<END; <a>AA <b/> BB <c/> CC <d/> <e/> <f/> DD <g/> HH </a> END ok $a->lastText; ok !$a->go(qw(c))->lastText;
Return the last node under the specified $node if: it is a text mode; its text matches the specified regular expression; the specified $node is in the optional specified context. Else return undef.
{my $a = Data::Edit::Xml::new(<<END); <a> <b>bb<c>cc</c>BB </b> </a> END my ($bb, $cc, $c, $BB, $b) = $a->byList; ok $BB->matchesText(qr(BB)); ok $b->at_b_a && $b->lastTextMatches(qr(BB)); ok $b->lastTextMatches(qr(BB), qw(b a)); ok $c->at_c_b && $c->lastTextMatches(qr(cc)); ok $c->at_c_b && !$c->lastTextMatches(qr(bb));
Return a list of the last instance of each specified tag encountered in a post-order traversal from the specified $node or a hash of all last instances if no tags are specified.
{my $a = Data::Edit::Xml::new(<<END); <a id="11"> <b id="12"> <c id="13"/> <d id="14"/> <b id="15"> <c id="16"/> <d id="17"/> <e id="18"/> <f id="19"/> <g id="20"/> </b> <f id="21"/> <g id="22"/> </b> <b id="23"> <c id="24"/> <d id="25"/> <b id="26"> <c id="27"/> <d id="28"/> <e id="29"/> <f id="30"/> <g id="31"/> </b> <f id="32"/> <g id="33"/> </b> </a> END {my %l = $a->lastBy; ok $l{b}->id == 23;
Return a list of the last instance of each specified tag encountered in a pre-order traversal from the specified $node or a hash of all last instances if no tags are specified.
{my %l = $a->lastDown; ok $l{b}->id == 26;
Return the last child node matching one of the named tags under the specified parent node.
ok $a->prettyStringCDATA eq <<'END'; <a><CDATA> </CDATA> <A/> <CDATA> </CDATA> <C/> <CDATA> </CDATA> <E/> <CDATA> </CDATA> <G/> <CDATA> </CDATA> </a> END ok $a->lastIn(qw(e E f F))->tag eq qq(E);
Return the last child node that does not match any of the named @tags under the specified parent $node. Return undef if there is no such child node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b/> <c/> <d/> <e/> <f/> </a> END my ($b, $c, $d, $e, $f) = $a->byList; ok $d == $a->lastNot_e_f;
Return an array of the nodes that are continuously last under their specified parent node and that match the specified list of tags.
{my $a = Data::Edit::Xml::new(<<END); <a><b><c/><d/><d/><e/><d/><d/><c/></b></a> END is_deeply [qw(d d c)], [map {-t $_} $a->go(q(b))->lastOf (qw(c d))];
Return the specified $node if it is last in its index and optionally at the specified context else undef
ok -z $a eq <<END; <a id="1"> <b id="2"> <c id="3"> <e id="4"/> </c> <d id="5"> <e id="6"/> </d> <c id="7"> <d id="8"> <e id="9"/> </d> </c> <d id="10"> <e id="11"/> </d> <c id="12"> <d id="13"> <e id="14"/> </d> </c> </b> </a> END ok $a->findByNumber(10)->lastInIndex; ok !$a->findByNumber(7) ->lastInIndex;
Return the last node encountered in the specified context in a depth first reverse pre-order traversal of the parse tree.
{my $x = Data::Edit::Xml::new(<<END); <a id="a1"> <b1 id="b1"> <c id="c1"> <d id="d1">DD11</d> <e id="e1">EE11</e> </c> </b1> <b2 id="b2"> <c id="c2"> <d id="d2">DD22</d> <e id="e2">EE22</e> </c> </b2> <b3 id="b3"> <c id="c3"> <d id="d3">DD33</d> <e id="e3">EE33</e> </c> </b3> </a> END ok $x-> lastContextOf(qw(d c)) ->id eq qq(d3); ok $x-> lastContextOf(qw(e c b2 )) ->id eq qq(e2); ok $x-> lastContextOf(qw(CDATA e c b2))->string eq qq(EE22);
Return the last sibling of the specified $node in the optional context else undef
{my $a = Data::Edit::Xml::new(<<END); <a id="11"> <b id="12"> <c id="13"/> <d id="14"/> <b id="15"> <c id="16"/> <d id="17"/> <e id="18"/> <f id="19"/> <g id="20"/> </b> <f id="21"/> <g id="22"/> </b> <b id="23"> <c id="24"/> <d id="25"/> <b id="26"> <c id="27"/> <d id="28"/> <e id="29"/> <f id="30"/> <g id="31"/> </b> <f id="32"/> <g id="33"/> </b> </a> END ok $a->go(qw(b b))->lastSibling ->id == 22;
Go last from the specified $node and continue deeper as long as each last child node matches one of the specified @tags. Return the deepest such node encountered or else return undef if no such node is encountered.
Go last from the specified $node and continue deeper until a last child node matches the specified @context or return undef if there is no such node. Return the last child of the specified $node if no @context is specified.
Find sibling nodes after the specified $node.
Return the node next to the specified $node, optionally checking its context. See addNext to ensure that an expected node is in position.
Use nextNonBlank to skip a (rare) initial blank text CDATA. Use nextNonBlankX to die rather then receive a returned undef or false result.
{my $a = Data::Edit::Xml::new(<<END); <a id="11"> <b id="12"> <c id="13"/> <d id="14"/> <b id="15"> <c id="16"/> <d id="17"/> <e id="18"/> <f id="19"/> <g id="20"/> </b> <f id="21"/> <g id="22"/> </b> <b id="23"> <c id="24"/> <d id="25"/> <b id="26"> <c id="27"/> <d id="28"/> <e id="29"/> <f id="30"/> <g id="31"/> </b> <f id="32"/> <g id="33"/> </b> </a> END ok $a->go(qw(b b e))->next ->id == 19; ok $a->go(qw(b b e))->next(qw(f b b a)); ok !$a->go(qw(b b e))->next(qw(f b a));
Return the $n'th next node after this node optionally checking its context or undef if there is no such node. nextn(1) is identical in effect to next.
Parameter Description 1 $node Node 2 $N Number of times to go next 3 @context Optional context.
Return the next node if it is a text node otherwise undef
ok -p $a eq <<END; <a>AA <b/> BB <c/> CC <d/> <e/> <f/> DD <g/> HH </a> END ok $a->go(qw(c))->nextText->text eq q(CC); ok !$a->go(qw(e))->nextText;
Return the next node to the specified $node if: it is a text mode; its text matches the specified regular expression; the specified $node is in the optional specified context. Else return undef.
{my $a = Data::Edit::Xml::new(<<END); <a> <b>bb<c>cc</c>BB </b> </a> END ok $cc->matchesText(qr(cc)); ok $c->at_c_b && $c->nextTextMatches(qr(BB)); ok $b->at_b && !$b->nextTextMatches(qr(BB));
Return the nearest sibling after the specified $node that matches one of the named tags or undef if there is no such sibling node.
ok $a->prettyStringCDATA eq <<'END'; <a><CDATA> </CDATA> <A/> <CDATA> </CDATA> <C/> <CDATA> </CDATA> <E/> <CDATA> </CDATA> <G/> <CDATA> </CDATA> </a> END ok $a->firstIn(qw(b B c C))->nextIn(qw(A G))->tag eq qq(G);
Step forwards as far as possible while remaining on nodes with the specified tags. In scalar context return the last such node reached or the starting node if no such steps are possible. In array context return the start node and any following matching nodes.
Parameter Description 1 $node Start node 2 @tags Tags identifying nodes that can be step on to context.
ok -p $a eq <<END; <a> <b> <c id="1"/> <d id="2"/> <c id="3"/> <d id="4"/> <e id="5"/> </b> </a> END ok $c->id == 1; ok $e->id == 5; ok $c->nextOn(qw(d)) ->id == 2; ok $c->nextOn(qw(c d))->id == 4; ok $e->nextOn(qw(c d)) == $e;
Go to the next sibling of the specified $node and continue forwards while the tag of each sibling node matches one of the specified @tags. Return the first sibling node that does not match else undef if there is no such sibling.
Parameter Description 1 $node Node 2 @tags Child tags to avoid.
{my $a = Data::Edit::Xml::new(<<END); <a> <b/> <c/> <d/> <e/> <f/> </a> END my ($b, $c, $d, $e, $f) = $a->byList; ok $e == $b->nextWhile_c_d; ok $c == $b->nextWhile;
Go to the next sibling of the specified $node and continue forwards until the tag of a sibling node matches one of the specified @tags. Return the matching sibling node else undef if there is no such sibling node.
Parameter Description 1 $node Node 2 @tags Tags to look for.
{my $a = Data::Edit::Xml::new(<<END); <a> <b/> <c/> <d/> <e/> <f/> </a> END my ($b, $c, $d, $e, $f) = $a->byList; ok $e == $b->nextUntil_e_f; ok !$b->nextUntil;
Find sibling nodes before the specified $node.
Return the node before the specified $node, optionally checking its context. See addLast to ensure that an expected node is in position.
Use prevNonBlank to skip a (rare) initial blank text CDATA. Use prevNonBlankX to die rather then receive a returned undef or false result.
{my $a = Data::Edit::Xml::new(<<END); <a id="11"> <b id="12"> <c id="13"/> <d id="14"/> <b id="15"> <c id="16"/> <d id="17"/> <e id="18"/> <f id="19"/> <g id="20"/> </b> <f id="21"/> <g id="22"/> </b> <b id="23"> <c id="24"/> <d id="25"/> <b id="26"> <c id="27"/> <d id="28"/> <e id="29"/> <f id="30"/> <g id="31"/> </b> <f id="32"/> <g id="33"/> </b> </a> END ok $a->go(qw(b b e))->prev ->id == 17; ok $a->go(qw(b b e))->prev(qw(d b b a)); ok !$a->go(qw(b b e))->prev(qw(d b a));
Return the previous node if it is a text node otherwise undef
ok -p $a eq <<END; <a>AA <b/> BB <c/> CC <d/> <e/> <f/> DD <g/> HH </a> END ok $a->go(qw(c))->prevText->text eq q(BB); ok !$a->go(qw(e))->prevText;
Return the $n'th previous node after this node optionally checking its context or undef if there is no such node. prevn(1) is identical in effect to prev.
Parameter Description 1 $node Node 2 $N Number of times to go prev 3 @context Optional context.
Return the previous node to the specified $node if: it is a text mode; its text matches the specified regular expression; the specified $node is in the optional specified context. Else return undef.
{my $a = Data::Edit::Xml::new(<<END); <a> <b>bb<c>cc</c>BB </b> </a> END ok $cc->matchesText(qr(cc)); ok $c->at_c_b && $c->prevTextMatches(qr(bb)); ok $b->at_b && !$b->prevTextMatches(qr(bb));
Return the nearest sibling node before the specified $node which matches one of the named tags or undef if there is no such sibling node.
ok $a->prettyStringCDATA eq <<'END'; <a><CDATA> </CDATA> <A/> <CDATA> </CDATA> <C/> <CDATA> </CDATA> <E/> <CDATA> </CDATA> <G/> <CDATA> </CDATA> </a> END ok $a->lastIn(qw(e E f F))->prevIn(qw(A G))->tag eq qq(A);
Step backwards as far as possible while remaining on nodes with the specified tags. In scalar context return the last such node reached or the starting node if no such steps are possible. In array context return the start node and any preceding matching nodes.
ok -p $a eq <<END; <a> <b> <c id="1"/> <d id="2"/> <c id="3"/> <d id="4"/> <e id="5"/> </b> </a> END ok $c->id == 1; ok $e->id == 5; ok $e->prevOn(qw(d)) ->id == 4; ok $e->prevOn(qw(c d)) == $c;
Go to the previous sibling of the specified $node and continue backwards while the tag of each sibling node matches one of the specified @tags. Return the first sibling node that does not match else undef if there is no such sibling.
{my $a = Data::Edit::Xml::new(<<END); <a> <b/> <c/> <d/> <e/> <f/> </a> END my ($b, $c, $d, $e, $f) = $a->byList; ok $c == $f->prevWhile_e_d; ok $b == $c->prevWhile;
Go to the previous sibling of the specified $node and continue backwards until the tag of a sibling node matches one of the specified @tags. Return the matching sibling node else undef if there is no such sibling node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b/> <c/> <d/> <e/> <f/> </a> END my ($b, $c, $d, $e, $f) = $a->byList; ok $b == $f->prevUntil_a_b; ok !$c->prevUntil;
Methods for moving up the parse tree from a node.
Return the parent of the current node optionally checking the context of the specified $node first or return undef if the specified $node is the root of the parse tree. See addWrapWith to ensure that an expected node is in position.
Parameter Description 1 $node Start node 2 @tags Optional tags identifying context.
if (1) {my $a = Data::Edit::Xml::new(<<END); <a><b><c><b><b><b><b><c/></b></b></b></b></c></b></a> END $a->numberTree; ok -z $a eq <<END; <a id="1"> <b id="2"> <c id="3"> <b id="4"> <b id="5"> <b id="6"> <b id="7"> <c id="8"/> </b> </b> </b> </b> </c> </b> </a> END my $c = $a->findByNumber(8); ok -t $c eq q(c); ok $c->up__number == 7; ok $c->upn_2__number == 6; ok $c->upWhile_b__number == 4; ok $c->upWhile_a_b__number == 4; ok $c->upWhile_b_c__number == 2; ok $c->upUntil__number == 7; ok $c->upUntil_b_c__number == 4; }
Go up the specified number of levels from the specified $node and return the node reached or undef if there is no such node.upn(1) is identical in effect to up. Or use ancestry to get the path back to the root node.
Parameter Description 1 $node Start node 2 $levels Number of levels to go up 3 @context Optional context.
if (1) {my $a = Data::Edit::Xml::new(<<END); <a><b><c><b><b><b><b><c/></b></b></b></b></c></b></a> END $a->numberTree; ok -z $a eq <<END; <a id="1"> <b id="2"> <c id="3"> <b id="4"> <b id="5"> <b id="6"> <b id="7"> <c id="8"/> </b> </b> </b> </b> </c> </b> </a> END my $c = $a->findByNumber(8); ok -t $c eq q(c); ok $c->up__number == 7; ok $c->upn_2__number == 6; ok $c->upWhile_b__number == 4; ok $c->upWhile_a_b__number == 4; ok $c->upWhile_b_c__number == 2; ok $c->upUntil__number == 7; ok $c->upUntil_b_c__number == 4; } if (1) {my $a = Data::Edit::Xml::new(<<END); <a><b><c><d><e/></d></c></b></a> END my ($e, $d, $c, $b) = $a->byList; ok $e = $e->upn(0); ok $d = $e->upn(1); ok $c = $e->upn(2); ok $b = $e->upn(3); ok $a = $e->upn(4); ok !$e->upn(5); is_deeply [$e, $d, $c, $b, $a], [$e->ancestry]; } {my $a = Data::Edit::Xml::new(<<END); <a><b><c><d><e/></d></c></b></a> END my ($e, $d, $c, $b) = $a->byList; ok $e = $e->upn(0); ok $d = $e->upn(1); ok $c = $e->upn(2); ok $b = $e->upn(3); ok $a = $e->upn(4); ok !$e->upn(5);
Go up one level from the specified $node and then continue up while each node matches on of the specified <@tags>. Return the last matching node or undef if no node matched any of the specified @tags.
Parameter Description 1 $node Start node 2 @tags Tags to match
Move up from the specified $node as long as each node is a first node or return undef if the specified $node is not a first node.
Parameter Description 1 $node Start node 2 @context Optional context
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> <e> <j/> </e> <f/> </b> <g> <h> <i> <k/> <l/> </i> </h> </g> </a> END my ($c, $d, $j, $e, $f, $b, $k, $l, $i, $h, $g) = $a->byList; ok $h == $i->upWhileFirst; ok $a == $c->upWhileFirst; ok !$d->upWhileFirst;
Move up from the specified $node as long as each node is a last node or return undef if the specified $node is not a last node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> <e> <j/> </e> <f/> </b> <g> <h> <i> <k/> <l/> </i> </h> </g> </a> END my ($c, $d, $j, $e, $f, $b, $k, $l, $i, $h, $g) = $a->byList; ok $j == $j->upWhileLast; ok $a == $l->upWhileLast; ok !$d->upWhileLast; ok $i == $k->upUntilLast;
Move up from the specified $node as long as each node is an only child or return undef if the specified $node is not an only child.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> <e> <j/> </e> <f/> </b> <g> <h> <i> <k/> <l/> </i> </h> </g> </a> END my ($c, $d, $j, $e, $f, $b, $k, $l, $i, $h, $g) = $a->byList; ok $h == $i->upWhileIsOnlyChild; ok $j == $j->upWhileIsOnlyChild; ok !$d->upWhileIsOnlyChild;
Return the nearest ancestral node that matches the specified @context or undef if there is no such node. Returns the parent node of the specified $node if no @context is specified.
Parameter Description 1 $node Start node 2 @context Context.
Move up from the specified until we reach the root or a first node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> <e> <j/> </e> <f/> </b> <g> <h> <i> <k/> <l/> </i> </h> </g> </a> END my ($c, $d, $j, $e, $f, $b, $k, $l, $i, $h, $g) = $a->byList; ok $b == $d->upUntilFirst;
Move up from the specified until we reach the root or a last node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> <e> <j/> </e> <f/> </b> <g> <h> <i> <k/> <l/> </i> </h> </g> </a> END my ($c, $d, $j, $e, $f, $b, $k, $l, $i, $h, $g) = $a->byList;
Move up from the specified $node until we reach the root or another only child.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> <e> <j/> </e> <f/> </b> <g> <h> <i> <k/> <l/> </i> </h> </g> </a> END my ($c, $d, $j, $e, $f, $b, $k, $l, $i, $h, $g) = $a->byList; ok $i == $k->upUntilIsOnlyChild;
Go up the specified path returning the node at the top or undef if no such node exists.
Parameter Description 1 $node Start node 2 @tags Tags identifying path.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d> <e/> <f/> </d> </b> </a> END my ($c, $e, $f, $d, $b) = $a->byList; ok -t $f eq q(f); ok -t $f->upThru eq q(f); ok -t $f->upThru(qw(d)) eq q(d); ok -t eval{$f->upThru(qw(d))->last->prev} eq q(e); ok ! eval{$f->upThru(qw(d b))->next};
Methods for moving down through the parse tree from a node.
Move down from the specified $node as long as each lower node is a first node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> <e> <j/> </e> <f/> </b> <g> <h> <i> <k/> <l/> </i> </h> </g> </a> END my ($c, $d, $j, $e, $f, $b, $k, $l, $i, $h, $g) = $a->byList; ok $k == $g->downWhileFirst; ok $c == $a->downWhileFirst; ok $c == $c->downWhileFirst; ok !$d->downWhileFirst;
firstLeaf is a synonym for downWhileFirst.
Move down from the specified $node as long as each lower node is a last node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> <e> <j/> </e> <f/> </b> <g> <h> <i> <k/> <l/> </i> </h> </g> </a> END my ($c, $d, $j, $e, $f, $b, $k, $l, $i, $h, $g) = $a->byList; ok $l == $a->downWhileLast; ok $l == $g->downWhileLast; ok !$d->downWhileLast;
lastLeaf is a synonym for downWhileLast.
Move down from the specified $node as long as it has a single child else return undef.
my ($c, $d, $j, $e, $f, $b, $k, $l, $i, $h, $g) = $a->byList;
Edit the data in the parse tree and change the structure of the parse tree by wrapping and unwrapping nodes, by replacing nodes, by cutting and pasting nodes, by concatenating nodes, by splitting nodes, by adding new text nodes or swapping nodes.
Parameter Description 1 $node Node 2 $name New name 3 @context Optional context.
{my $a = Data::Edit::Xml::new('<a/>'); $a->change(qq(b)); ok -s $a eq '<b/>';
If the node is a text node in the specified context then the specified sub is passed the text of the node in $_, any changes to which are recorded in the text of the node.
Returns undef if the specified $node is not a text node in the specified optional context else it returns the result of executing the specified sub.
Parameter Description 1 $node Text node 2 $sub Sub 3 @context Optional context.
{my $a = Data::Edit::Xml::new(<<END); <a>Hello World</a> END $a->first->changeText(sub{s(l) (L)g}); ok -s $a eq q(<a>HeLLo WorLd</a>);
Move nodes around in the parse tree by cutting and pasting them.
Parameter Description 1 $node Node to cut out 2 @context Optional context
ok -p $a eq <<END; <a id="aa"> <b id="bb"> <c id="cc"/> </b> </a> END my $c = $a->go(qw(b c))->cut; ok -p $a eq <<END; <a id="aa"> <b id="bb"/> </a> END
Delete the content of the specified $node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b>bb<c>cc</c>BB </b> </a> END $b->deleteContent; ok -p $a eq <<END; <a> <b/> </a> END
Place a cut out or new node at the front of the content of the specified $node and return the new node. See addFirst to perform this operation conditionally.
Parameter Description 1 $old Original node 2 $new New node 3 @context Optional context.
ok -p $a eq <<END; <a id="aa"> <b id="bb"> <c id="cc"/> </b> </a> END my $c = $a->go(qw(b c))->cut; $a->putFirst($c); ok -p $a eq <<END; <a id="aa"> <c id="cc"/> <b id="bb"/> </a> END
Cut out the second node, place it first under the first node and return the second node.
Parameter Description 1 $old First node 2 $new Second node 3 @context Optional context.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> </b> </a> END my ($c, $d, $b) = $a->byList; $c->putFirstCut($d, qw(c b a)); ok -p $a eq <<END; <a> <b> <c> <d/> </c> </b> </a> END
ok -p $a eq <<END; <a id="aa"> <c id="cc"/> <b id="bb"/> </a> END $a->putLast($a->go(qw(c))->cut); ok -p $a eq <<END; <a id="aa"> <b id="bb"/> <c id="cc"/> </a> END
Cut out the second node, place it last under the first node and return the second node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> </b> </a> END my ($c, $d, $b) = $a->byList; $a->putLastCut($d, qw(a)); ok -p $a eq <<END; <a> <b> <c/> </b> <d/> </a> END
Place a cut out or new node just after the specified $node and return the new node. See addNext to perform this operation conditionally.
ok -p $a eq <<END; <a id="aa"> <b id="bb"/> <c id="cc"/> </a> END $a->go(qw(c))->putNext($a->go(q(b))->cut); ok -p $a eq <<END; <a id="aa"> <c id="cc"/> <b id="bb"/> </a> END
Cut out the second node, place it next after the first node and return the second node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> </b> </a> END my ($c, $d, $b) = $a->byList; $d->putNextCut($c, qw(d b a)); ok -p $a eq <<END; <a> <b> <d/> <c/> </b> </a> END
Place a cut out or new node just before the specified $node and return the new node. See addPrev to perform this operation conditionally.
ok -p $a eq <<END; <a id="aa"> <c id="cc"/> <b id="bb"/> </a> END $a->go(qw(c))->putPrev($a->go(q(b))->cut); ok -p $a eq <<END; <a id="aa"> <b id="bb"/> <c id="cc"/> </a> END
Cut out the second node, place it before the first node and return the second node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> </b> </a> END my ($c, $d, $b) = $a->byList; $c->putPrevCut($d, qw(c b a)); ok -p $a eq <<END; <a> <b> <d/> <c/> </b> </a> END
Add new nodes unless they already exist.
Add a new node first below the specified $node and return the new node unless a node with that tag already exists in which case return the existing node.
Parameter Description 1 $node Node 2 $tag Tag of new node 3 %attributes Attributes for the new node.
{my $a = Data::Edit::Xml::newTree(q(a)); $a->addFirst(qw(b id b)) for 1..2; ok -p $a eq <<END; <a> <b id="b"/> </a> END
Add a new node next to the specified $node and return the new node unless a node with that tag already exists in which case return the existing node.
ok -p $a eq <<END; <a> <b id="b"/> <e id="e"/> </a> END $a->addFirst(qw(b id B))->addNext(qw(c id c)); ok -p $a eq <<END; <a> <b id="b"/> <c id="c"/> <e id="e"/> </a> END
Add a new node before the specified $node and return the new node unless a node with that tag already exists in which case return the existing node.
ok -p $a eq <<END; <a> <b id="b"/> <c id="c"/> <e id="e"/> </a> END $a->addLast(qw(e id E))->addPrev(qw(d id d)); ok -p $a eq <<END; <a> <b id="b"/> <c id="c"/> <d id="d"/> <e id="e"/> </a> END
Add a new node last below the specified $node and return the new node unless a node with that tag already exists in which case return the existing node.
ok -p $a eq <<END; <a> <b id="b"/> </a> END $a->addLast(qw(e id e)) for 1..2; ok -p $a eq <<END; <a> <b id="b"/> <e id="e"/> </a> END
Wrap the specified $node with the specified tag if the node is not already wrapped with such a tag and return the new node unless a node with that tag already exists in which case return the existing node.
{my $a = Data::Edit::Xml::new(q(<a><b/></a>)); my $b = $a->first; $b->addWrapWith(qw(c id c)) for 1..2; ok -p $a eq <<END; <a> <c id="c"> <b/> </c> </a> END
Wrap the content of a specified $node in a new node with the specified $tag and optional %attribute unless the content is already wrapped in a single child with the specified $tag.
ok -p $a eq <<END; <a> <c id="c"> <b/> </c> </a> END $a->addSingleChild(q(d)) for 1..2; ok -p $a eq <<END; <a> <d> <c id="c"> <b/> </c> </d> </a> END
Add new text unless it already exists.
Add a new text node first below the specified $node and return the new node unless a text node already exists there and starts with the same text in which case return the existing node.
Parameter Description 1 $node Node 2 $text Text
{my $a = Data::Edit::Xml::newTree(q(a)); $a->addFirstAsText(q(aaaa)) for 1..2; ok -s $a eq q(<a>aaaa</a>);
Add a new text node after the specified $node and return the new node unless a text node already exists there and starts with the same text in which case return the existing node.
{my $a = Data::Edit::Xml::new(q(<a><b/></a>)); $a->go(q(b))->addNextAsText(q(bbbb)) for 1..2; ok -p $a eq <<END; <a> <b/> bbbb </a> END
Add a new text node before the specified $node and return the new node unless a text node already exists there and ends with the same text in which case return the existing node.
ok -p $a eq <<END; <a> <b/> bbbb </a> END $a->go(q(b))->addPrevAsText(q(aaaa)) for 1..2; ok -p $a eq <<END; <a>aaaa <b/> bbbb </a> END
Add a new text node last below the specified $node and return the new node unless a text node already exists there and ends with the same text in which case return the existing node.
ok -s $a eq q(<a>aaaa</a>); $a->addLastAsText(q(dddd)) for 1..2; ok -s $a eq q(<a>aaaadddd</a>);
Join consecutive nodes
Concatenate two successive nodes and return the target node.
Parameter Description 1 $target Target node to replace 2 $source Node to concatenate 3 @context Optional context of $target
{my $s = <<END; <a> <b> <A/> <B/> </b> <c> <C/> <D/> </c> </a> END my $a = Data::Edit::Xml::new($s); $a->go(q(b))->concatenate($a->go(q(c))); my $t = <<END; <a> <b> <A/> <B/> <C/> <D/> </b> </a> END ok $t eq -p $a;
Concatenate preceding and following nodes as long as they have the same tag as the specified $node and return the specified $node.
Parameter Description 1 $node Concatenate around this node 2 @context Optional context.
ok -p $a eq <<END; <a> <b> <c id="1"/> </b> <b> <c id="2"/> </b> <b> <c id="3"/> </b> <b> <c id="4"/> </b> </a> END $a->go(qw(b 3))->concatenateSiblings; ok -p $a eq <<END; <a> <b> <c id="1"/> <c id="2"/> <c id="3"/> <c id="4"/> </b> </a> END
Merge a parent node with its only child if their tags are the same and their attributes do not collide other than possibly the id in which case the parent id is used. Any labels on the child are transferred to the parent. The child node is then unwrapped and the parent node is returned.
Parameter Description 1 $parent Parent this node 2 @context Optional context.
{my $a = Data::Edit::Xml::new(<<END); <a> <b id="b" b="bb"> <b id="c" c="cc"/> </b> </a> END my ($c, $b) = $a->byList; is_deeply [$b->id, $c->id], [qw(b c)]; ok $c == $b->singleChild; $b->mergeDuplicateChildWithParent; ok -p $a eq <<END; <a> <b b="bb" c="cc" id="b"/> </a> END ok $b == $a->singleChild;
Add text to the parse tree.
Add a new text node first under a parent and return the new text node.
Parameter Description 1 $node The parent node 2 $text The string to be added which might contain unparsed Xml as well as text 3 @context Optional context.
ok -p $x eq <<END; <a id="aa"> <b id="bb"> <c id="cc"/> </b> </a> END $x->go(qw(b c))->putFirstAsText("<d id=\"dd\">DDDD</d>"); ok -p $x eq <<END; <a id="aa"> <b id="bb"> <c id="cc"><d id="dd">DDDD</d></c> </b> </a> END
Add a new text node last under a parent and return the new text node.
ok -p $x eq <<END; <a id="aa"> <b id="bb"> <c id="cc"><d id="dd">DDDD</d></c> </b> </a> END $x->go(qw(b c))->putLastAsText("<e id=\"ee\">EEEE</e>"); ok -p $x eq <<END; <a id="aa"> <b id="bb"> <c id="cc"><d id="dd">DDDD</d><e id="ee">EEEE</e></c> </b> </a> END
Add a new text node following this node and return the new text node.
ok -p $x eq <<END; <a id="aa"> <b id="bb"> <c id="cc"><d id="dd">DDDD</d><e id="ee">EEEE</e></c> </b> </a> END $x->go(qw(b c))->putNextAsText("<n id=\"nn\">NNNN</n>"); ok -p $x eq <<END; <a id="aa"> <b id="bb"> <c id="cc"><d id="dd">DDDD</d><e id="ee">EEEE</e></c> <n id="nn">NNNN</n> </b> </a> END
Add a new text node following this node and return the new text node
ok -p $x eq <<END; <a id="aa"> <b id="bb"> <c id="cc"><d id="dd">DDDD</d><e id="ee">EEEE</e></c> <n id="nn">NNNN</n> </b> </a> END $x->go(qw(b c))->putPrevAsText("<p id=\"pp\">PPPP</p>"); ok -p $x eq <<END; <a id="aa"> <b id="bb"><p id="pp">PPPP</p> <c id="cc"><d id="dd">DDDD</d><e id="ee">EEEE</e></c> <n id="nn">NNNN</n> </b> </a> END
Break nodes out of nodes or push them back
Concatenate the nodes following and preceding the start node, unwrapping nodes whose tag matches the start node and return the start node. To concatenate only the preceding nodes, use breakInBackwards, to concatenate only the following nodes, use breakInForwards.
Parameter Description 1 $start The start node 2 @context Optional context.
ok -p $a eq <<END; <a> <d/> <b> <c/> <c/> </b> <e/> <b> <c/> <c/> </b> <d/> </a> END $a->go(qw(b 1))->breakIn; ok -p $a eq <<END; <a> <b> <d/> <c/> <c/> <e/> <c/> <c/> <d/> </b> </a> END
Concatenate the nodes following the start node, unwrapping nodes whose tag matches the start node and return the start node in the manner of breakIn.
Parameter Description 1 $start The start node 2 @context Optional context..
ok -p $a eq <<END; <a> <d/> <b> <c/> <c/> </b> <e/> <b> <c/> <c/> </b> <d/> </a> END $a->go(q(b))->breakInForwards; ok -p $a eq <<END; <a> <d/> <b> <c/> <c/> <e/> <c/> <c/> <d/> </b> </a> END
Concatenate the nodes preceding the start node, unwrapping nodes whose tag matches the start node and return the start node in the manner of breakIn.
ok -p $a eq <<END; <a> <d/> <b> <c/> <c/> </b> <e/> <b> <c/> <c/> </b> <d/> </a> END $a->go(qw(b 1))->breakInBackwards; ok -p $a eq <<END; <a> <b> <d/> <c/> <c/> <e/> <c/> <c/> </b> <d/> </a> END
Lift child nodes with the specified tags under the specified parent node splitting the parent node into clones and return the cut out original node.
Parameter Description 1 $parent The parent node 2 @tags The tags of the modes to be broken out.
{my $A = Data::Edit::Xml::new("<a><b><d/><c/><c/><e/><c/><c/><d/></b></a>"); $a->go(q(b))->breakOut($a, qw(d e)); ok -p $a eq <<END; <a> <d/> <b> <c/> <c/> </b> <e/> <b> <c/> <c/> </b> <d/> </a> END
Replace nodes in the parse tree with nodes or text
Replace a node (and all its content) with a new node (and all its content) and return the new node. If the node to be replaced is the root of the parse tree then no action is taken other then returning the new node.
Parameter Description 1 $old Old node 2 $new New node 3 @context Optional context..
{my $x = Data::Edit::Xml::new(qq(<a><b><c id="cc"/></b></a>)); $x->go(qw(b c))->replaceWith($x->newTag(qw(d id dd))); ok -s $x eq '<a><b><d id="dd"/></b></a>';
Replace a node (and all its content) with a new text node and return the new node.
Parameter Description 1 $old Old node 2 $text Text of new node 3 @context Optional context.
{my $x = Data::Edit::Xml::new(qq(<a><b><c id="cc"/></b></a>)); $x->go(qw(b c))->replaceWithText(qq(BBBB)); ok -s $x eq '<a><b>BBBB</b></a>';
Replace a node (and all its content) with a new blank text node and return the new node.
Parameter Description 1 $old Old node 2 @context Optional context.
{my $x = Data::Edit::Xml::new(qq(<a><b><c id="cc"/></b></a>)); $x->go(qw(b c))->replaceWithBlank; ok -s $x eq '<a><b> </b></a>';
Replace the content of a specified target node with the contents of the specified source nodes removing the content from each source node and return the target node.
Parameter Description 1 $node Target node 2 @nodes Source nodes
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <b1/> <b2/> </b> <c> <c1/> <c2/> </c> <d> <d1/> <d2/> </d> </a> END my ($b, $c, $d) = $a->contents; $d->replaceContentWithMovedContent($c, $b); ok -p $a eq <<END; <a> <b/> <c/> <d> <c1/> <c2/> <b1/> <b2/> </d> </a> END {my $a = Data::Edit::Xml::new(<<END); <a> <d> <b> <b1/> <b2/> </b> <c> <c1/> <c2/> </c> </d> </a> END my ($d) = $a->contents; my ($b, $c) = $d->contents; $d->replaceContentWithMovedContent($c, $b); ok -p $a eq <<END; <a> <d> <c1/> <c2/> <b1/> <b2/> </d> </a> END
Replace the content of a node with the specified nodes and return the replaced content
Parameter Description 1 $node Node whose content is to be replaced 2 @content New content
{my $x = Data::Edit::Xml::new(qq(<a><b/><c/></a>)); $x->replaceContentWith(map {$x->newTag($_)} qw(B C)); ok -s $x eq '<a><B/><C/></a>';
Replace the content of a node with the specified texts and return the replaced content
Parameter Description 1 $node Node whose content is to be replaced 2 @text Texts to form new content
{my $x = Data::Edit::Xml::new(qq(<a><b/><c/></a>)); $x->replaceContentWithText(qw(b c)); ok -s $x eq '<a>bc</a>';
Swap nodes both singly and in blocks
Swap a parent and child node where the child is the only child of the parent and return the parent.
Parameter Description 1 $parent Parent 2 @context Context
{my $a = Data::Edit::Xml::new(<<END); <a> <b id="b"> <c id="c"> <d/> <e/> </c> </b> </a> END $a->first->invert; ok -p $a eq <<END; <a> <c id="c"> <b id="b"> <d/> <e/> </b> </c> </a> END $a->first->invert; ok -p $a eq <<END; <a> <b id="b"> <c id="c"> <d/> <e/> </c> </b> </a> END
Swap a parent and child node where the child is the first child of the parent by placing the parent last in the child. Return the parent.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> <e/> </c> <f/> <g/> </b> </a> END ok -p $a eq <<END; <a> <c> <d/> <e/> <b> <f/> <g/> </b> </c> </a> END
Swap a parent and child node where the child is the last child of the parent by placing the parent first in the child. Return the parent.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> <e/> </c> <f/> <g/> </b> </a> END ok -p $a eq <<END; <a> <c> <d/> <e/> <b> <f/> <g/> </b> </c> </a> END ok -p $a eq <<END; <a> <b> <c> <d/> <e/> </c> <f/> <g/> </b> </a> END
Swap two nodes optionally checking that the first node is in the specified context and return the first node.
Parameter Description 1 $first First node 2 $second Second node 3 @context Optional context
ok <<END eq -p $x; <x> <a a="1" b="2"/> <b/> <c a="1" b="3" c="4"/> </x> END $a->swap($c); ok <<END eq -p $x; <x> <c a="1" b="3" c="4"/> <b/> <a a="1" b="2"/> </x> END
Wrap and unwrap nodes to alter the depth of the parse tree
Parameter Description 1 $old Node 2 $tag Tag for the new node or tag 3 %attributes Attributes for the new node or tag.
ok -p $x eq <<END; <a> <b> <c id="11"/> </b> </a> END $x->go(qw(b c))->wrapWith(qw(C id 1)); ok -p $x eq <<END; <a> <b> <C id="1"> <c id="11"/> </C> </b> </a> END
Wrap the original node in a sequence of new nodes forcing the original node down - deepening the parse tree - return the array of wrapping nodes.
Parameter Description 1 $node Node to wrap 2 @tags Tags to wrap the node with - with the uppermost tag rightmost.
{my $c = Data::Edit::Xml::newTree("c", id=>33); my ($b, $a) = $c->wrapUp(qw(b a)); ok -p $a eq <<'END'; <a> <b> <c id="33"/> </b> </a> END
Wrap the content of the specified $node in a sequence of new nodes forcing the original node up - deepening the parse tree - return the array of wrapping nodes.
{my $a = Data::Edit::Xml::newTree("a", id=>33); my ($b, $c) = $a->wrapDown(qw(b c)); ok -p $a eq <<END; <a id="33"> <b> <c/> </b> </a> END
Wrap the content of a node in a new node: the original node then contains just the new node which, in turn, contains all the content of the original node.
Returns the new wrapped node.
Parameter Description 1 $old Node 2 $tag Tag for new node 3 %attributes Attributes for new node.
ok -p $x eq <<END; <a> <b> <c/> <c/> <c/> </b> </a> END $x->go(q(b))->wrapContentWith(qw(D id DD)); ok -p $x eq <<END; <a> <b> <D id="DD"> <c/> <c/> <c/> </D> </b> </a> END ok -p $a eq <<END; <a> <b id="1"/> <c id="2"/> <d id="3"/> <c id="4"/> <d id="5"/> <e id="6"/> <b id="7"/> <c id="8"/> <d id="9"/> <f id="10"/> </a> END
If there are any siblings before the specified $node, wrap them with the specified tag.
Returns the specified $node.
Parameter Description 1 $node Node to wrap before 2 $tag Tag for new node 3 %attributes Attributes for new node.
{my $a = Data::Edit::Xml::new(q(<a><b/><c/><d/></a>)); my ($b, $c, $d) = $a->byList; $c->wrapSiblingsBefore(q(X)); ok -p $a eq <<END; <a> <X> <b/> </X> <c/> <d/> </a> END
If there are any siblings between the specified $nodes, wrap them with the specified tag and return the wrapping node else if there are no such nodes run undef
Parameter Description 1 $first First sibling 2 $last Last sibling 3 $tag Tag for new node 4 %attributes Attributes for new node.
{my $a = Data::Edit::Xml::new(q(<a><b/><c/><d/></a>)); my ($b, $c, $d) = $a->byList; $b->wrapSiblingsBetween($d, q(Y)); ok -p $a eq <<END; <a> <b/> <Y> <c/> </Y> <d/> </a> END
If there are any siblings after the specified $node, wrap them with the specified tag.
{my $a = Data::Edit::Xml::new(q(<a><b/><c/><d/></a>)); my ($b, $c, $d) = $a->byList; $c->wrapSiblingsAfter(q(Y)); ok -p $a eq <<END; <a> <b/> <c/> <Y> <d/> </Y> </a> END
Wrap all the nodes from the start node to the end node with a new node with the specified tag and attributes and return the new node. Return undef if the start and end nodes are not siblings - they must have the same parent for this method to work.
Parameter Description 1 $start Start node 2 $end End node 3 $tag Tag for the wrapping node 4 %attributes Attributes for the wrapping node
{my $x = Data::Edit::Xml::new(my $s = <<END); <aa> <a> <b/> <c id="1"/><c id="2"/><c id="3"/><c id="4"/> <d/> </a> </aa> END $x->go(qw(a c))->wrapTo($x->go(qw(a c -1)), qq(C), id=>1234); ok -p $x eq <<END; <aa> <a> <b/> <C id="1234"> <c id="1"/> <c id="2"/> <c id="3"/> <c id="4"/> </C> <d/> </a> </aa> END my $C = $x->go(qw(a C)); $C->wrapTo($C, qq(D)); ok -p $x eq <<END; <aa> <a> <b/> <D> <C id="1234"> <c id="1"/> <c id="2"/> <c id="3"/> <c id="4"/> </C> </D> <d/> </a> </aa> END ok -p $a eq <<END; <a> <b> <D id="DD"> <c id="0"/> <c id="1"/> </D> <E id="EE"> <c id="2"/> </E> <F id="FF"> <c id="3"/> </F> </b> </a> END
Parameter Description 1 $end End node 2 $start Start node 3 $tag Tag for the wrapping node 4 %attr Attributes for the wrapping node
{my $a = Data::Edit::Xml::new(my $s = <<END); <a> <b> <c id="0"/><c id="1"/><c id="2"/><c id="3"/> </b> </a> END my $b = $a->first; my @c = $b->contents; $c[1]->wrapFrom($c[0], qw(D id DD)); ok -p $a eq <<END; <a> <b> <D id="DD"> <c id="0"/> <c id="1"/> </D> <c id="2"/> <c id="3"/> </b> </a> END
Parameter Description 1 $node Node to unwrap 2 @context Optional context.
ok -s $x eq "<a>A<b> c </b>B</a>"; $b->unwrap; ok -s $x eq "<a>A c B</a>";
Unwrap any immediate ancestors of the specified $node which have only a single child and return the specified $node regardless.
Parameter Description 1 $o Node
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <e/> </a> END $a->go(qw(b c d))->unwrapParentsWithSingleChild; ok -p $a eq <<END; <a> <d/> <e/> </a> END
Unwrap all the non text nodes below the specified $node adding a leading and a trailing space to prevent unwrapped content from being elided and return the specified $node else undef if not in the optional context.
ok -p $x eq <<END; <a> <b> <c> <d>DD</d> EE <f>FF</f> </c> </b> </a> END $x->go(qw(b))->unwrapContentsKeepingText; ok -p $x eq <<END; <a> <b> DD EE FF </b> </a> END
The children of each node.
Return a list of all the nodes contained by this node or an empty list if the node is empty or not in the optional context.
{my $x = Data::Edit::Xml::new(<<END); <a> <b id="b1"><c id="1"/></b> <d id="d1"><c id="2"/></d> <e id="e1"><c id="3"/></e> <b id="b2"><c id="4"/></b> <d id="d2"><c id="5"/></d> <e id="e2"><c id="6"/></e> </a> END is_deeply [map{-u $_} $x->contents], [qw(b1 d1 e1 b2 d2 e2)];
Return a list of all the sibling nodes following this node or an empty list if this node is last or not in the optional context.
{my $x = Data::Edit::Xml::new(<<END); <a> <b> <c/><d/><e/><f/><g/> </b> </a> END ok 'f g' eq join ' ', map {$_->tag} $x->go(qw(b e))->contentAfter;
Return a list of all the sibling nodes preceding this node or an empty list if this node is last or not in the optional context.
{my $x = Data::Edit::Xml::new(<<END); <a> <b> <c/><d/><e/><f/><g/> </b> </a> END ok 'c d' eq join ' ', map {$_->tag} $x->go(qw(b e))->contentBefore;
Return a string containing the tags of all the child nodes of this node separated by single spaces or the empty string if the node is empty or undef if the node does not match the optional context. Use over to test the sequence of tags with a regular expression.
{my $x = Data::Edit::Xml::new(<<END); <a> <b> <c/><d/><e/><f/><g/> </b> </a> END ok $x->go(q(b))->contentAsTags eq 'c d e f g';
Return a string containing the tags of all the child nodes of this node separated by two spaces with a single space preceding the first tag and a single space following the last tag or the empty string if the node is empty or undef if the node does not match the optional context. Use over2 to test the sequence of tags with a regular expression. Use over2 to test the sequence of tags with a regular expression.
ok $x->go(q(b))->contentAsTags2 eq q( c d e f g );
Return a string containing the tags of all the sibling nodes following this node separated by single spaces or the empty string if the node is empty or undef if the node does not match the optional context. Use matchAfter to test the sequence of tags with a regular expression.
{my $x = Data::Edit::Xml::new(<<END); <a> <b> <c/><d/><e/><f/><g/> </b> </a> END ok 'f g' eq join ' ', map {$_->tag} $x->go(qw(b e))->contentAfter; ok $x->go(qw(b e))->contentAfterAsTags eq 'f g';
Return a string containing the tags of all the sibling nodes following this node separated by two spaces with a single space preceding the first tag and a single space following the last tag or the empty string if the node is empty or undef if the node does not match the optional context. Use matchAfter2 to test the sequence of tags with a regular expression.
{my $x = Data::Edit::Xml::new(<<END); <a> <b> <c/><d/><e/><f/><g/> </b> </a> END ok $x->go(qw(b e))->contentAfterAsTags2 eq q( f g );
Return a string containing the tags of all the sibling nodes preceding this node separated by single spaces or the empty string if the node is empty or undef if the node does not match the optional context. Use matchBefore to test the sequence of tags with a regular expression.
{my $x = Data::Edit::Xml::new(<<END); <a> <b> <c/><d/><e/><f/><g/> </b> </a> END ok 'c d' eq join ' ', map {$_->tag} $x->go(qw(b e))->contentBefore; ok $x->go(qw(b e))->contentBeforeAsTags eq 'c d';
Return a string containing the tags of all the sibling nodes preceding this node separated by two spaces with a single space preceding the first tag and a single space following the last tag or the empty string if the node is empty or undef if the node does not match the optional context. Use matchBefore2 to test the sequence of tags with a regular expression.
{my $x = Data::Edit::Xml::new(<<END); <a> <b> <c/><d/><e/><f/><g/> </b> </a> END ok $x->go(qw(b e))->contentBeforeAsTags2 eq q( c d );
Return the index of a node in its parent's content.
{my $a = Data::Edit::Xml::new(<<END); <a id="11"> <b id="12"> <c id="13"/> <d id="14"/> <b id="15"> <c id="16"/> <d id="17"/> <e id="18"/> <f id="19"/> <g id="20"/> </b> <f id="21"/> <g id="22"/> </b> <b id="23"> <c id="24"/> <d id="25"/> <b id="26"> <c id="27"/> <d id="28"/> <e id="29"/> <f id="30"/> <g id="31"/> </b> <f id="32"/> <g id="33"/> </b> </a> END ok $a->go(qw(b 1 b))->id == 26; ok $a->go(qw(b 1 b))->position == 2;
Return the index of a node in its parent index. To find the position of a node under its parent.
{my $a = Data::Edit::Xml::new(<<END); <a id="11"> <b id="12"> <c id="13"/> <d id="14"/> <b id="15"> <c id="16"/> <d id="17"/> <e id="18"/> <f id="19"/> <g id="20"/> </b> <f id="21"/> <g id="22"/> </b> <b id="23"> <c id="24"/> <d id="25"/> <b id="26"> <c id="27"/> <d id="28"/> <e id="29"/> <f id="30"/> <g id="31"/> </b> <f id="32"/> <g id="33"/> </b> </a> END ok $a->go(qw(b 1))->id == 23; ok $a->go(qw(b 1))->index == 1;
Return the count of the number of the specified tag types present immediately under a node or a hash {tag} = count for all the tags present under the node if no names are specified.
Parameter Description 1 $node Node 2 @names Possible tags immediately under the node.
is_deeply {$a->first->present}, {c=>2, d=>2, e=>1};
Return the specified $node if this node is a text node, optionally in the specified context, else return undef.
Parameter Description 1 $node Node to test 2 @context Optional context
ok $a->prettyStringCDATA eq <<END; <a> <b><CDATA> </CDATA></b> </a> END ok $b->first->isText; ok $b->first->isText(qw(b a));
Return the specified $node if this node is a text node, the first node under its parent and that the parent is optionally in the specified context, else return undef.
Parameter Description 1 $node Node to test 2 @context Optional context for parent
{my $x = Data::Edit::Xml::new(<<END); <x> <a>aaa <b>bbb</b> ccc <d>ddd</d> eee </a> </x> END my $a = $x->first; my ($ta, $b, $tc, $d, $te) = $a->contents; ok $ta ->isFirstText(qw(a x)); ok $b->first->isFirstText(qw(b a x)); ok $b->prev ->isFirstText(qw(a x)); ok $d->last ->isFirstText(qw(d a x));
Return the specified $node if this node is a text node, the last node under its parent and that the parent is optionally in the specified context, else return undef.
{my $x = Data::Edit::Xml::new(<<END); <x> <a>aaa <b>bbb</b> ccc <d>ddd</d> eee </a> </x> END ok $d->next ->isLastText (qw(a x)); ok $d->last ->isLastText (qw(d a x)); ok $te ->isLastText (qw(a x));
Return a list of nodes that match the specified tree of match expressions, else () if one or more match expressions fail to match nodes in the tree below the specified start node. A match expression consists of [parent node tag, [match expressions to be matched by children of parent]|tags of child nodes to match starting at the first node]. Match expressions for a single item do need to be surrounded with [] and can be merged into their predecessor. The outermost match expression should not be enclosed in [].
Parameter Description 1 $node Node to start matching from 2 @match Tree of match expressions.
if (1) {my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> </b> <e> <f> <g/> </f> </e> </a> END my ($c, $d, $b, $g, $f, $e) = $a->byList; is_deeply [$b, $c, $d], [$b->matchTree(qw(b c d))]; is_deeply [$e, $f, $g], [$e->matchTree(qr(\Ae\Z), [qw(f g)])]; is_deeply [$c], [$c->matchTree(qw(c))]; is_deeply [$a, $b, $c, $d, $e, $f, $g], [$a->matchTree({a=>1}, [qw(b c d)], [qw(e), [qw(f g)]])]; }
Returns an array of regular expression matches in the text of the specified $node if it is text node and it matches the specified regular expression and optionally has the specified context otherwise returns an empty array.
Parameter Description 1 $node Node to test 2 $re Regular expression 3 @context Optional context
{my $x = Data::Edit::Xml::new(<<END); <a> <b> <c>CDECD</c> </b> </a> END my $c = $x->go(qw(b c))->first; ok !$c->matchesText(qr(\AD)); ok $c->matchesText(qr(\AC), qw(c b a)); ok !$c->matchesText(qr(\AD), qw(c b a)); is_deeply [qw(E)], [$c->matchesText(qr(CD(.)CD))];
Return the specified $node if this node is a text node, optionally in the specified context, and contains nothing other than white space else return undef. See also: isAllBlankText
ok $a->prettyStringCDATA eq <<END; <a> <b><CDATA> </CDATA></b> </a> END ok $b->first->isBlankText;
Return the specified $node if this node, optionally in the specified context, does not contain anything or if it does contain something it is all white space else return undef. See also: bitsNodeTextBlank
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <z/> </c> </b> <d/> </a> END $a->by(sub{$_->replaceWithBlank(qw(z))}); my ($b, $c, $d) = $a->firstBy(qw(b c d)); ok $c->isAllBlankText; ok $c->isAllBlankText(qw(c b a)); ok !$c->isAllBlankText(qw(c a));
Return a bit string that shows if there are any non text nodes, text nodes or blank text nodes under a node. An empty string is returned if there are no child nodes.
Parameter Description 1 $node Node to test.
ok $x->prettyStringCDATA eq <<END; <a> <b> <C/> </b> <c> <D/> <CDATA> E </CDATA> </c> <d> <F/> <CDATA> </CDATA> <H/> </d> <e/> </a> END ok '100' eq -B $x; ok '100' eq -B $x->go(q(b)); ok '110' eq -B $x->go(q(c)); ok '111' eq -B $x->go(q(d)); ok !-B $x->go(qw(e));
Number the nodes of a parse tree so that they can be easily retrieved by number - either by a person reading the source xml or programmatically.
Find the node with the specified number as made visible by prettyStringNumbered in the parse tree containing the specified $node and return the found node or undef if no such node exists.
Parameter Description 1 $node Node in the parse tree to search 2 $number Number of the node required.
if (1) {my $a = Data::Edit::Xml::new(<<END); <a><b><c/></b><d><e/></d></a> END $a->numberTree; ok -z $a eq <<END; <a id="1"> <b id="2"> <c id="3"/> </b> <d id="4"> <e id="5"/> </d> </a> END ok -t $a->findByNumber_4 eq q(d); ok $a->findByNumber_3__up__number == 2; } $a->numberTree; ok $a->prettyStringNumbered eq <<END; <a id="1"> <b id="2"> <A id="3"/> <B id="4"/> </b> <c id="5"> <C id="6"/> <D id="7"/> </c> </a> END ok q(D) eq -t $a->findByNumber(7);
Find the nodes with the specified numbers as made visible by prettyStringNumbered in the parse tree containing the specified $node and return the found nodes in a list with undef for nodes that do not exist.
Parameter Description 1 $node Node in the parse tree to search 2 @numbers Numbers of the nodes required.
$a->numberTree; ok $a->prettyStringNumbered eq <<END; <a id="1"> <b id="2"> <A id="3"/> <B id="4"/> </b> <c id="5"> <C id="6"/> <D id="7"/> </c> </a> END is_deeply [map {-t $_} $a->findByNumbers(1..3)], [qw(a b A)];
Number the nodes in a parse tree in pre-order so they are numbered in the same sequence that they appear in the source. You can see the numbers by printing the tree with prettyStringNumbered. Nodes can be found using findByNumber. This method differs from forestNumberTrees in that avoids overwriting the id= attribute of each node by using a system attribute instead; this system attribute can then be made visible on the id attribute of each node by printing the parse tree with prettyStringNumbered.
Parameter Description 1 $node Node
$a->numberTree; ok -z $a eq <<END; <a id="1"> <b id="2"> <c id="42" match="mm"/> </b> <d id="4"> <e id="5"/> </d> </a> END if (1) {my $a = Data::Edit::Xml::new(<<END); <a><b><c/></b><d><e/></d></a> END $a->numberTree; ok -z $a eq <<END; <a id="1"> <b id="2"> <c id="3"/> </b> <d id="4"> <e id="5"/> </d> </a> END ok -t $a->findByNumber_4 eq q(d); ok $a->findByNumber_3__up__number == 2; }
Return a map of the ids at and below the specified $node.
{my $a = Data::Edit::Xml::new(<<END); <a id="A"> <b id="B"> <c id="C"/> <d id="D"> <e id="E"/> <f id="F"/> </d> </b> </a> END my $i = $a->indexIds; ok $i->{C}->tag eq q(c); ok $i->{E}->tag eq q(e);
Number the ids of the nodes in a parse tree in pre-order so they are numbered in the same sequence that they appear in the source. You can see the numbers by printing the tree with prettyStringNumbered(). This method differs from numberTree in that only non text nodes without ids are numbered. The number applied to each node consists of the concatenation of the specified prefix, an underscore and a number that is unique within the specifed parse tree. Consequently the ids across several trees trees can be made unique by supplying different prefixes for each tree. Nodes can be found using findByNumber. Returns the specified $node.
Parameter Description 1 $node Node 2 $prefix Prefix for each id at and under the specified B<$node>
{my $a = Data::Edit::Xml::new(<<END); <a>A <b id="bb">B <c/> <d>D <e id="ee"/> E <f/> F </d> G </b> H </a> END $a->numberTreesJustIds(q(T)); my $A = Data::Edit::Xml::new(<<END); <a id="T_1">A <b id="bb">B <c id="T_2"/> <d id="T_3">D <e id="ee"/> E <f id="T_4"/> F </d> G </b> H </a> END ok -p $a eq -p $A;
Number the nodes of several parse trees so that they can be easily retrieved by forest number - either by a person reading the source xml or programmatically.
Number the ids of the nodes in a parse tree in pre-order so they are numbered in the same sequence that they appear in the source. You can see the numbers by printing the tree with prettyString. This method differs from numberTree in that only non text nodes are numbered and nodes with existing id= attributes have the value of their id= attribute transferred to a label. The number applied to each node consists of the concatenation of the specified tree number, an underscore and a number that is unique within the specified parse tree. Consequently the ids across several trees can be made unique by supplying a different tree number for each tree. Nodes can be found subsequently using findByForestNumber. Returns the specified $node.
Parameter Description 1 $node Node in parse tree to be numbered 2 $prefix Tree number
{my $a = Data::Edit::Xml::new(<<END); <a> <b id="b"> <c/> </b> <b id="B"> <d/> <e/> </b> </a> END my $e = $a->go(qw(b -1 e)); $e->forestNumberTrees(1); ok -p $a eq <<END; <a id="1_1"> <b id="1_2"> <c id="1_3"/> </b> <b id="1_4"> <d id="1_5"/> <e id="1_6"/> </b> </a> END
Find the node with the specified forest number as made visible on the id attribute by prettyStringNumbered in the parse tree containing the specified $node and return the found node or undef if no such node exists.
Parameter Description 1 $node Node in the parse tree to search 2 $tree Forest number 3 $id Id number of the node required.
ok -p $a eq <<END; <a id="1_1"> <b id="1_2"> <c id="1_3"/> </b> <b id="1_4"> <d id="1_5"/> <e id="1_6"/> </b> </a> END my $B = $e->findByForestNumber(1, 4); is_deeply [$B->getLabels], ["B"];
Check the order and relative position of nodes in a parse tree.
Return the first node if the first node is above the second node optionally checking that the first node is in the specified context otherwise return undef
my $x = Data::Edit::Xml::new(<<END); <a id='a1'> <b id='b1'> <c id='c1'/> <c id='c2'/> <d id='d1'> <e id='e1'/> </d> <c id='c3'/> <c id='c4'/> <d id='d2'> <e id='e2'/> </d> <c id='c5'/> <c id='c6'/> </b> </a> END ok $b->id eq 'b1'; ok $e->id eq "e1"; ok $E->id eq "e2"; ok $b->above($e); ok !$E->above($e);
Return the nodes along the path from the first node down to the second node when the first node is above the second node else return ().
my $x = Data::Edit::Xml::new(<<END); <a id='a1'> <b id='b1'> <c id='c1'/> <c id='c2'/> <d id='d1'> <e id='e1'/> </d> <c id='c3'/> <c id='c4'/> <d id='d2'> <e id='e2'/> </d> <c id='c5'/> <c id='c6'/> </b> </a> END my ($a, $b, $c, $d, $e) = $x->firstDown(@tags); is_deeply [$b, $d, $e], [$b->abovePath($e)]; is_deeply [], [$c->abovePath($d)];
Return the first node if the first node is below the second node optionally checking that the first node is in the specified context otherwise return undef
my $x = Data::Edit::Xml::new(<<END); <a id='a1'> <b id='b1'> <c id='c1'/> <c id='c2'/> <d id='d1'> <e id='e1'/> </d> <c id='c3'/> <c id='c4'/> <d id='d2'> <e id='e2'/> </d> <c id='c5'/> <c id='c6'/> </b> </a> END ok $d->id eq 'd1'; ok $e->id eq "e1"; ok !$d->below($e);
Return the nodes along the path from the first node up to the second node when the first node is below the second node else return ().
my $x = Data::Edit::Xml::new(<<END); <a id='a1'> <b id='b1'> <c id='c1'/> <c id='c2'/> <d id='d1'> <e id='e1'/> </d> <c id='c3'/> <c id='c4'/> <d id='d2'> <e id='e2'/> </d> <c id='c5'/> <c id='c6'/> </b> </a> END my ($a, $b, $c, $d, $e) = $x->firstDown(@tags); is_deeply [$e, $d, $b], [$e->belowPath($b)]; is_deeply [$c], [$c->belowPath($c)];
Return the first node if it occurs after the second node in the parse tree optionally checking that the first node is in the specified context or else undef if the node is above, below or before the target.
my $x = Data::Edit::Xml::new(<<END); <a id='a1'> <b id='b1'> <c id='c1'/> <c id='c2'/> <d id='d1'> <e id='e1'/> </d> <c id='c3'/> <c id='c4'/> <d id='d2'> <e id='e2'/> </d> <c id='c5'/> <c id='c6'/> </b> </a> END ok $c->id eq 'c1'; ok $e->id eq "e1"; ok $e->after($c);
Return the first node if it occurs before the second node in the parse tree optionally checking that the first node is in the specified context or else undef if the node is above, below or before the target.
my $x = Data::Edit::Xml::new(<<END); <a id='a1'> <b id='b1'> <c id='c1'/> <c id='c2'/> <d id='d1'> <e id='e1'/> </d> <c id='c3'/> <c id='c4'/> <d id='d2'> <e id='e2'/> </d> <c id='c5'/> <c id='c6'/> </b> </a> END ok $e->id eq "e1"; ok $E->id eq "e2"; ok $e->before($E);
Return the first node that is out of the specified order when performing a pre-ordered traversal of the parse tree.
Parameter Description 1 $node Node 2 @nodes Following nodes.
my $x = Data::Edit::Xml::new(<<END); <a id='a1'> <b id='b1'> <c id='c1'/> <c id='c2'/> <d id='d1'> <e id='e1'/> </d> <c id='c3'/> <c id='c4'/> <d id='d2'> <e id='e2'/> </d> <c id='c5'/> <c id='c6'/> </b> </a> END ok $b->id eq 'b1'; ok $c->id eq 'c1'; ok $d->id eq 'd1'; ok $e->id eq "e1"; ok $e->disordered($c )->id eq "c1"; ok $b->disordered($c, $e, $d)->id eq "d1"; ok !$c->disordered($e);
Find the most recent common ancestor of the specified nodes or undef if there is no common ancestor.
Parameter Description 1 $node Node 2 @nodes @nodes
ok -z $a eq <<END; <a id="1"> <b id="2"> <c id="3"> <e id="4"/> </c> <d id="5"> <e id="6"/> </d> <c id="7"> <d id="8"> <e id="9"/> </d> </c> <d id="10"> <e id="11"/> </d> <c id="12"> <d id="13"> <e id="14"/> </d> </c> </b> </a> END {my ($b, $e, @n) = $a->findByNumbers(2, 4, 6, 9); ok $e == $e->commonAncestor; ok $e == $e->commonAncestor($e); ok $b == $e->commonAncestor($b); ok $b == $e->commonAncestor(@n);
Given two nodes, find a pair of adjacent ancestral siblings if such a pair exists else return ().
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <b> <c/> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $C, $B, $f, $e) = $a->byList; is_deeply [$d->commonAdjacentAncestors($C)], [$b, $B];
Return the first node if the specified nodes are all in order when performing a pre-ordered traversal of the parse tree else return undef.
my $x = Data::Edit::Xml::new(<<END); <a id='a1'> <b id='b1'> <c id='c1'/> <c id='c2'/> <d id='d1'> <e id='e1'/> </d> <c id='c3'/> <c id='c4'/> <d id='d2'> <e id='e2'/> </d> <c id='c5'/> <c id='c6'/> </b> </a> END ok $e->id eq "e1"; ok $E->id eq "e2"; ok $e->ordered($E); ok !$E->ordered($e); ok $e->ordered($e); ok $e->ordered;
Analyze two similar parse trees and create a patch that transforms the first parse tree into the second as long as each tree has the same tag and id structure with each id being unique.
Create a patch that moves the source parse tree to the target parse tree node as long as they have the same tag and id structure with each id being unique.
Parameter Description 1 $a Source parse tree 2 $A Target parse tree
{my $a = Data::Edit::Xml::new(<<END); <a>Aaaaa <b b1="b1" b2="b2">Bbbbb <c c1="c1" />Ccccc <d d1="d1" >Ddddd <e e1="e1" /> Eeeee <f f1="f1" /> Fffff </d> Ggggg </b> Hhhhhh </a> END my $A = Data::Edit::Xml::new(<<END); <a>AaaAaaA <b b1="b1" b3="B3">BbbBbbB <c c1="C1" />Ccccc <d d2="D2" >DddDddD <e e3="E3" /> EeeEeeE <f f1="F1" /> FffFffF </d> GggGggG </b> Hhhhhh </a> END $a->numberTreesJustIds(q(a)); $A->numberTreesJustIds(q(a)); my $patches = $a->createPatch($A); $patches->install($a); ok !$a->diff ($A); ok $a->equals($A);
Replay a patch created by createPatch against a parse tree that has the same tag and id structure with each id being unique.
Parameter Description 1 $patches Patch 2 $a Parse tree
Propagate parent node attributes through a parse tree.
Propagate new attributes from nodes that match the specified tag to all their child nodes, then unwrap all the nodes that match the specified tag. Return the specified parse tree.
Parameter Description 1 $tree Parse tree 2 $tag Tag of nodes whose attributes are to be propagated 3 @context Optional context for parse tree
{my $a = Data::Edit::Xml::new(<<END); <a> <b b="B"> <b c="C"> <c/> <b d="D"> <d/> <b e="E"> <e/> </b> </b> </b> </b> </a> END $a->propagate(q(b)); ok -p $a eq <<END; <a> <c b="B" c="C"/> <d b="B" c="C" d="D"/> <e b="B" c="C" d="D" e="E"/> </a> END
Analyze and generate tables of contents.
Table of Contents number the nodes in a parse tree.
Parameter Description 1 $node Node 2 @match Optional list of tags to descend into else all tags will be descended into
ok $a->prettyStringNumbered eq <<END; <a id="1"> <b id="2"> <A id="3"/> <B id="4"/> </b> <c id="5"> <C id="6"/> <D id="7"/> </c> </a> END my $t = $a->tocNumbers(); is_deeply {map {$_=>$t->{$_}->tag} keys %$t}, {"1" =>"b", "1 1"=>"A", "1 2"=>"B", "2" =>"c", "2 1"=> "C", "2 2"=>"D" }
Label nodes so that they can be cross referenced and linked by Data::Edit::Xml::Lint
Add the named labels to the specified $node and return the number of labels added. Labels that are not defined will be ignored.
Parameter Description 1 $node Node in parse tree 2 @labels Names of labels to add.
ok $x->stringReplacingIdsWithLabels eq '<a><b><c/></b></a>'; my $b = $x->go(q(b)); ok $b->countLabels == 0; $b->addLabels(1..2); $b->addLabels(3..4); ok $x->stringReplacingIdsWithLabels eq '<a><b id="1, 2, 3, 4"><c/></b></a>';
Return the count of the number of labels at a node.
ok $x->stringReplacingIdsWithLabels eq '<a><b><c/></b></a>'; my $b = $x->go(q(b)); ok $b->countLabels == 0; $b->addLabels(1..2); $b->addLabels(3..4); ok $x->stringReplacingIdsWithLabels eq '<a><b id="1, 2, 3, 4"><c/></b></a>'; ok $b->countLabels == 4;
Return a hash of all the labels in a tree
Parameter Description 1 $tree Parse tree.
ok -p (new $A->stringExtendingIdsWithLabels) eq <<END; <a id="aa, a, a5"> <b id="bb, b, b2"> <c id="cc, c, c1"/> </b> <b id="B, b4"> <c id="C, c3"/> </b> </a> END is_deeply [sort keys %{$A->labelsInTree}], ["B", "C", "a", "a5", "b", "b2", "b4", "c", "c1", "c3"];
Return the names of all the labels set on a node.
ok $x->stringReplacingIdsWithLabels eq '<a><b><c/></b></a>'; my $b = $x->go(q(b)); ok $b->countLabels == 0; $b->addLabels(1..2); $b->addLabels(3..4); ok $x->stringReplacingIdsWithLabels eq '<a><b id="1, 2, 3, 4"><c/></b></a>'; is_deeply [1..4], [$b->getLabels];
Delete the specified labels in the specified $node or all labels if no labels have are specified and return that node.
Parameter Description 1 $node Node in parse tree 2 @labels Names of the labels to be deleted
ok $x->stringReplacingIdsWithLabels eq '<a><b id="1, 2, 3, 4"><c id="1, 2, 3, 4"/></b></a>'; $b->deleteLabels(1,4) for 1..2; ok $x->stringReplacingIdsWithLabels eq '<a><b id="2, 3"><c id="1, 2, 3, 4"/></b></a>';
Copy all the labels from the source node to the target node and return the source node.
Parameter Description 1 $source Source node 2 $target Target node.
ok $x->stringReplacingIdsWithLabels eq '<a><b id="1, 2, 3, 4"><c/></b></a>'; $b->copyLabels($c) for 1..2; ok $x->stringReplacingIdsWithLabels eq '<a><b id="1, 2, 3, 4"><c id="1, 2, 3, 4"/></b></a>';
Move all the labels from the source node to the target node and return the source node.
ok $x->stringReplacingIdsWithLabels eq '<a><b id="2, 3"><c id="1, 2, 3, 4"/></b></a>'; $b->moveLabels($c) for 1..2; ok $x->stringReplacingIdsWithLabels eq '<a><b><c id="1, 2, 3, 4"/></b></a>';
Copy all the labels and ids in the source parse tree to the matching nodes in the target parse tree. Nodes are matched via path. Return the number of labels and ids copied.
ok -p (new $a->stringExtendingIdsWithLabels) eq <<END; <a id="a, a5"> <b id="b, b2"> <c id="c, c1"/> </b> <b id="B, b4"> <c id="C, c3"/> </b> </a> END ok -p (new $A->stringExtendingIdsWithLabels) eq <<END; <a id="aa"> <b id="bb"> <c id="cc"/> </b> <b> <c/> </b> </a> END ok $a->copyLabelsAndIdsInTree($A) == 10; ok -p (new $A->stringExtendingIdsWithLabels) eq <<END; <a id="aa, a, a5"> <b id="bb, b, b2"> <c id="cc, c, c1"/> </b> <b id="B, b4"> <c id="C, c3"/> </b> </a> END
Operator access to methods use the assign versions to avoid 'useless use of operator in void context' messages. Use the non assign versions to return the results of the underlying method call. Thus '/' returns the wrapping node, whilst '/=' does not. Assign operators always return their left hand side even though the corresponding method usually returns the modification on the right.
-B: bitsNodeTextBlank
-b: isAllBlankText
-c: context
-e: prettyStringEnd
-f: first node
-g: pathString
-l: last node
-M: number
-o: contentAsTags
-p: prettyString
-s: string
-S : stringNode
-T : isText
-t : tag
-u: id
-W: unWrap
-w: stringQuoted
-x: prettyStringDitaHeaders
-X: cut
-z: prettyStringNumbered.
Parameter Description 1 $node Node 2 $op Monadic operator.
{my $a = Data::Edit::Xml::new(<<END); <a> <b><c>ccc</c></b> <d><e>eee</e></d> </a> END {my $a = Data::Edit::Xml::new(<<END); <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END my ($c, $b, $e, $d) = $a->byList; ok $c->printNode eq q(c id="42" match="mm"); ok -A $c eq q(c id="42" match="mm"); ok -b $e; ok -c $e eq q(e d a); ok -f $b eq $c; ok -l $a eq $d; ok -O $a, q( b d ); ok -o $a, q(b d); ok -w $a eq q('<a><b><c id="42" match="mm"/></b><d><e/></d></a>'); ok -p $a eq <<END; #tdown #tdownX <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END ok -s $a eq '<a><b><c id="42" match="mm"/></b><d><e/></d></a>'; ok -t $a eq 'a'; $a->numberTree; ok -z $a eq <<END; <a id="1"> <b id="2"> <c id="42" match="mm"/> </b> <d id="4"> <e id="5"/> </d> </a> END {my $a = Data::Edit::Xml::new(<<END); <concept/> END Data::Edit::Xml::ditaOrganization = q(ACT); ok $a->prettyStringDitaHeaders eq <<END; <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE concept PUBLIC "-//ACT//DTD DITA Concept//EN" "concept.dtd" []> <concept/> END ok -x $a eq <<END; <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE concept PUBLIC "-//ACT//DTD DITA Concept//EN" "concept.dtd" []> <concept/> END
@{} : nodes immediately below a node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b><c>ccc</c></b> <d><e>eee</e></d> </a> END my ($b, $d) = @$a; ok -c $b eq q(b a); my ($c) = @$b; ok -c $c eq q(c b a);
<= : Check that a node is in the context specified by the referenced array of words.
Parameter Description 1 $node Node 2 $context Reference to array of words specifying the parents of the desired node.
ok -p $a eq <<END; #tdown #tdownX <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END ok (($a >= [qw(d e)]) <= [qw(e d a)]);
** : create a new node from the text on the right hand side: if the text contains a non word character \W the node will be create as text, else it will be created as a tag
Parameter Description 1 $node Node 2 $text Name node of node to create or text of new text element
{my $a = Data::Edit::Xml::new("<a/>"); my $b = $a ** q(b); ok -s $b eq "<b/>";
>> : put a node or string first under a node and return the new node.
Parameter Description 1 $node Node 2 $text Node or text to place first under the node.
ok -p $a eq <<END; <a/> END my $f = $a >> qq(first); ok -p $a eq <<END; <a> <first/> </a> END
>>= : put a node or string first under a node.
ok -p $a eq <<END; <a/> END $a >>= qq(first); ok -p $a eq <<END; <a> <first/> </a> END
<< : put a node or string last under a node and return the new node.
Parameter Description 1 $node Node 2 $text Node or text to place last under the node.
ok -p $a eq <<END; <a> <first/> </a> END my $l = $a << qq(last); ok -p $a eq <<END; <a> <first/> <last/> </a> END
<<= : put a node or string last under a node.
ok -p $a eq <<END; <a> <first/> </a> END $a <<= qq(last); ok -p $a eq <<END; <a> <first/> <last/> </a> END
> + : put a node or string after the specified $node and return the new node.
Parameter Description 1 $node Node 2 $text Node or text to place after the first node.
ok -p $a eq <<END; <a> <first/> <last/> </a> END $f += qq(next); ok -p $a eq <<END; <a> <first/> <next/> <last/> </a> END
+= : put a node or string after the specified $node.
ok -p $a eq <<END; <a> <first/> <last/> </a> END my $f = -f $a; $f += qq(next); ok -p $a eq <<END; <a> <first/> <next/> <last/> </a> END
< - : put a node or string before the specified $node and return the new node.
Parameter Description 1 $node Node 2 $text Node or text to place before the first node.
ok -p $a eq <<END; <a> <first/> <next/> <last/> </a> END $l -= qq(prev); ok -p $a eq <<END; <a> <first/> <next/> <prev/> <last/> </a> END
-= : put a node or string before the specified $node,
ok -p $a eq <<END; <a> <first/> <next/> <last/> </a> END my $l = -l $a; $l -= qq(prev); ok -p $a eq <<END; <a> <first/> <next/> <prev/> <last/> </a> END
x= : Traverse a parse tree in post-order.
Parameter Description 1 $node Parse tree 2 $code Code to execute against each node.
ok -p $a eq <<END; #tdown #tdownX <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END {my $s; $a x= sub{$s .= -t $_}; ok $s eq "cbeda"
>= : Search for a node via a specification provided as a reference to an array of words each number. Each word represents a tag name, each number the index of the previous tag or zero by default.
Parameter Description 1 $node Node 2 $go Reference to an array of search parameters.
% : Get the value of an attribute of this node.
Parameter Description 1 $node Node 2 $attr Reference to an array of words and numbers specifying the node to search for.
{my $a = Data::Edit::Xml::new('<a number="1"/>'); ok $a % qq(number) == 1;
/ : Wrap node with a tag, returning the wrapping node.
{my $c = Data::Edit::Xml::new("<c/>"); my $b = $c / qq(b); ok -s $b eq "<b><c/></b>"; my $a = $b / qq(a); ok -s $a eq "<a><b><c/></b></a>";
* : Wrap content with a tag, returning the wrapping node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> </b> </a> END my ($c, $d, $b) = $a->byList; $b *= q(B); ok -p $a eq <<END; <a> <b> <B> <c/> <d/> </B> </b> </a> END
-- : Cut out a node.
{my $x = Data::Edit::Xml::new(<<END); <a> <b><c/></b> </a> END my $b = $x >= qq(b); --$b; ok -s $x eq "<a/>"; ok -s $b eq "<b><c/></b>";
++ : Unwrap a node.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> <d/> </b> </a> END my ($c, $d, $b) = $a->byList; $b++; ok -p $a eq <<END; <a> <c/> <d/> </a> END
Statistics describing the parse tree.
Return the count of the number of instances of the specified tags under the specified $node, either by tag in array context or in total in scalar context.
{my $x = Data::Edit::Xml::new(<<END); <a> </a> END ok $x->count == 0;
Count the number of tags in a parse tree.
Parameter Description 1 $node Parse tree.
ok -p $a eq <<END; <a id="aa"> <b id="bb"> <c id="cc"/> </b> </a> END ok $a->countTags == 3;
Return a reference to a hash showing the number of instances of each tag on and below the specified $node.
Parameter Description 1 $node Node 2 $count Count of tags so far.
{my $x = Data::Edit::Xml::new(<<END); <a A="A" B="B" C="C"> <b B="B" C="C"> <c C="C"> </c> <c/> </b> <b C="C"> <c/> </b> </a> END is_deeply $x->countTagNames, { a => 1, b => 2, c => 3 };
Return a reference to a hash showing the number of instances of each attribute on and below the specified $node.
Parameter Description 1 $node Node 2 $count Attribute count so far
{my $x = Data::Edit::Xml::new(<<END); <a A="A" B="B" C="C"> <b B="B" C="C"> <c C="C"> </c> <c/> </b> <b C="C"> <c/> </b> </a> END is_deeply $x->countAttrNames, { A => 1, B => 2, C => 4 };
Count the number of attributes owned by the specified $node that are not in the specified list.
Parameter Description 1 $node Node 2 @attr Attributes to ignore
{my $a = Data::Edit::Xml::new(q(<a a="1" b="2" c="3" d="4" e="5"/>));
Return a reference to a hash showing the number of instances of each attribute value on and below the specified $node.
Parameter Description 1 $node Node 2 $count Count of attributes so far.
{my $x = Data::Edit::Xml::new(<<END); <a A="A" B="B" C="C"> <b B="B" C="C"> <c C="C"> </c> <c/> </b> <b C="C"> <c/> </b> </a> END is_deeply $x->countAttrValues, { A => 1, B => 2, C => 4 };
Count instances of outputclass attributes
Parameter Description 1 $node Node 2 $count Count so far.
{my $a = Data::Edit::Xml::newTree("a", id=>1, class=>2, href=>3, outputclass=>4); is_deeply { 4 => 1 }, $a->countOutputClasses;
Provide a specification to select change reason comments to be inserted as text into a parse tree. A specification can be either:
changeReasonCommentSelectionSpecification = {ccc=>1, ddd=>1}; changeReasonCommentSelectionSpecification = undef;
Data::Edit::Xml::changeReasonCommentSelectionSpecification
Insert a comment consisting of a code and an optional reason as text into the parse tree to indicate the location of changes to the parse tree. As such comments tend to become very numerous, only comments whose codes matches the specification provided in changeReasonCommentSelectionSpecification are accepted for insertion. Subsequently these comments can be easily located using:
grep -nr "<!--code"
on the file containing a printed version of the parse tree. Please note that these comments will be removed if the output file is reparsed.
Parameter Description 1 $node Node being changed 2 $code Reason code 3 $reason Optional text description of change
{my $a = Data::Edit::Xml::new("<a><b/></a>"); my ($b) = $a->contents; changeReasonCommentSelectionSpecification = {ccc=>1, ddd=>1}; $b->putFirst(my $c = $b->newTag(q(c))); $c->crc($_) for qw(aaa ccc); ok <<END eq -p $a; <a> <b><!--ccc--> <c/> </b> </a> END changeReasonCommentSelectionSpecification = undef; $c->putFirst(my $d = $c->newTag(q(d))); $d->crc($_) for qw(aaa ccc); ok <<END eq -p $a; <a> <b><!--ccc--> <c> <d/> </c> </b> </a> END
Return the depth to which this node is first else 0.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <b> <c/> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $C, $B, $f, $e) = $a->byList; ok $d->howFirst == 4;
Return the depth to which this node is last else 0.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <b> <c/> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $C, $B, $f, $e) = $a->byList; ok $f->howLast == 3;
Return the depth to which this node is an only child else 0.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <b> <c/> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $C, $B, $f, $e) = $a->byList; ok $d->howOnlyChild == 2;
Return how far the first node is from the second node along a path through their common ancestor.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <b> <c/> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $C, $B, $f, $e) = $a->byList; is_deeply [$d->commonAdjacentAncestors($C)], [$b, $B]; ok $d->howFar($d) == 0; ok $d->howFar($a) == 3; ok $b->howFar($B) == 1; ok $d->howFar($f) == 5; ok $d->howFar($C) == 4;
Return how far the first node is above the second node is or 0 if the first node is not strictly above the second node.
Parameter Description 1 $above First node above 2 $below Second node below
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <b> <c/> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $C, $B, $f, $e) = $a->byList; ok $a->howFarAbove($d) == 3; ok !$d->howFarAbove($c);
Return how far the first node is below the second node is or 0 if the first node is not strictly below the second node.
Parameter Description 1 $below First node below 2 $above Second node above
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> </b> <b> <c/> </b> <e> <f/> </e> </a> END my ($d, $c, $b, $C, $B, $f, $e) = $a->byList; ok $d->howFarBelow($a) == 3; ok !$c->howFarBelow($d);
Insert required clean up tags.
Replace a node with a required cleanup node around the text of the replaced node with special characters replaced by symbols.
Parameter Description 1 $node Node 2 $outputclass Optional outputclass attribute of required cleanup tag
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> ccc </c> </b> </a> END my ($b) = $a->contents; $b->requiredCleanUp(q(33)); ok -p $a eq <<END; <a> <required-cleanup outputclass="33"><b> <c> ccc </c> </b> </required-cleanup> </a> END
Replace a node with a required cleanup message and return the new node
Parameter Description 1 $node Node to be replace 2 $text Clean up message
{my $a = Data::Edit::Xml::new(<<END); <a> <b/> </a> END my ($b) = $a->contents; $b->replaceWithRequiredCleanUp(q(bb)); ok -p $a eq <<END; <a> <required-cleanup>bb</required-cleanup> </a> END
Place a required cleanup tag first under a node and return the required clean up node.
Parameter Description 1 $node Node 2 $text Clean up message
{my $a = Data::Edit::Xml::new(<<END); <a> <b/> </a> END $a->putFirstRequiredCleanUp(qq(1111 )); ok -p $a eq <<END; <a> <required-cleanup>1111 </required-cleanup> <b/> </a> END
Place a required cleanup tag last under a node and return the required clean up node.
ok -p $a eq <<END; <a> <required-cleanup>1111 </required-cleanup> <b/> </a> END $a->putLastRequiredCleanUp(qq(4444 )); ok -p $a eq <<END; <a> <required-cleanup>1111 </required-cleanup> <b/> <required-cleanup>4444 </required-cleanup> </a> END
Place a required cleanup tag after a node.
ok -p $a eq <<END; <a> <required-cleanup>1111 </required-cleanup> <b/> <required-cleanup>4444 </required-cleanup> </a> END $a->go(q(b))->putNextRequiredCleanUp(qq(3333 )); ok -p $a eq <<END; <a> <required-cleanup>1111 </required-cleanup> <b/> <required-cleanup>3333 </required-cleanup> <required-cleanup>4444 </required-cleanup> </a> END
Place a required cleanup tag before a node.
ok -p $a eq <<END; <a> <required-cleanup>1111 </required-cleanup> <b/> <required-cleanup>3333 </required-cleanup> <required-cleanup>4444 </required-cleanup> </a> END $a->go(q(b))->putPrevRequiredCleanUp(qq(2222 )); ok -p $a eq <<END; <a> <required-cleanup>1111 </required-cleanup> <required-cleanup>2222 </required-cleanup> <b/> <required-cleanup>3333 </required-cleanup> <required-cleanup>4444 </required-cleanup> </a> END
Methods useful for conversions to and from word, html and Dita.
Change the specified $node to steps and its contents to cmd\step optionally only in the specified context.
Parameter Description 1 $list Node 2 @context Optional context
ok -p $a eq <<END; <dita> <ol> <li> <p>aaa</p> </li> <li> <p>bbb</p> </li> </ol> </dita> END $a->first->ditaListToSteps; ok -p $a eq <<END; <dita> <steps> <step> <cmd>aaa</cmd> </step> <step> <cmd>bbb</cmd> </step> </steps> </dita> END
Change the specified $node to steps-unordered and its contents to cmd\step optionally only in the specified context.
ok -p $a eq <<END; <dita> <ol> <li>aaa</li> <li>bbb</li> </ol> </dita> END $a->first->ditaListToStepsUnordered; ok -p $a eq <<END; <dita> <steps-unordered> <step> <cmd>aaa</cmd> </step> <step> <cmd>bbb</cmd> </step> </steps-unordered> </dita> END
Change the specified $node to substeps and its contents to cmd\step optionally only in the specified context.
{my $a = Data::Edit::Xml::new(<<END); <dita> <ol> <li>aaa</li> <li>bbb</li> </ol> </dita> END $a->first->ditaListToSubSteps; ok -p $a eq <<END; <dita> <substeps> <substep> <cmd>aaa</cmd> </substep> <substep> <cmd>bbb</cmd> </substep> </substeps> </dita> END
Change the specified $node to ol and its cmd\step content to li optionally only in the specified context.
Parameter Description 1 $steps Node 2 @context Optional context
ok -p $a eq <<END; <dita> <ol> <li> <p>aaa</p> </li> <li> <p>bbb</p> </li> </ol> </dita> END $a->first->ditaStepsToList; ok -p $a eq <<END; <dita> <ol> <li>aaa</li> <li>bbb</li> </ol> </dita> END
Merge the specified $node with the preceding or following list or steps or substeps if possible and return the specified $node regardless.
{my $a = Data::Edit::Xml::new(<<END); <a> <li id="1"/> <ol/> <ol> <li id="2"/> <li id="3"/> </ol> </a> END $a x= sub{$_->ditaMergeLists}; ok -p $a eq <<END; <a> <ol> <li id="1"/> <li id="2"/> <li id="3"/> </ol> </a> END
Return the maximum number of entries in the rows of the specified $table or undef if not a table.
Parameter Description 1 $table Table node
if (1) {my $a = Data::Edit::Xml::new(<<END); <table> <tgroup> <tbody> <row><entry/></row> <row><entry/><entry/></row> <row><entry/><entry/><entry/></row> <row><entry/><entry/></row> <row/> </tbody> </tgroup> </table> END ok 3 == $a->ditaMaximumNumberOfEntriesInARow; $a->first->ditaAddColSpecToTgroup(3); ok -p $a eq <<END <table> <tgroup cols="3"> <colspec colname="c1" colnum="1" colwidth="1*"/> <colspec colname="c2" colnum="2" colwidth="1*"/> <colspec colname="c3" colnum="3" colwidth="1*"/> <tbody> <row> <entry/> </row> <row> <entry/> <entry/> </row> <row> <entry/> <entry/> <entry/> </row> <row> <entry/> <entry/> </row> <row/> </tbody> </tgroup> </table> END }
Add the specified $number of column specification to a specified $tgroup which does not have any already.
Parameter Description 1 $tgroup Tgroup node 2 $number Number of colspecs to add
Improve the specified $table by making obvious improvements.
if (1) {my $a = Data::Edit::Xml::new(<<END); <table> <tbody> <row><entry/></row> <row><entry/><entry/></row> <row><entry/><entry/><entry/></row> <row><entry/><entry/></row> <row> <entry> <table> <tbody> <row><entry/><entry/><entry/><entry/><entry/><entry/><entry/></row> </tbody> </table> </entry> </row> </tbody> </table> END $a->ditaFixTableColSpec; ok -p $a eq <<END <table> <tgroup cols="3"> <colspec colname="c1" colnum="1" colwidth="1*"/> <colspec colname="c2" colnum="2" colwidth="1*"/> <colspec colname="c3" colnum="3" colwidth="1*"/> <tbody> <row> <entry/> </row> <row> <entry/> <entry/> </row> <row> <entry/> <entry/> <entry/> </row> <row> <entry/> <entry/> </row> <row> <entry> <table> <tbody> <row> <entry/> <entry/> <entry/> <entry/> <entry/> <entry/> <entry/> </row> </tbody> </table> </entry> </row> </tbody> </tgroup> </table> END }
Make obvious changes to a parse tree to make it look more like Dita.
{my $a = Data::Edit::Xml::new(<<END); <dita> <ol> <li><para>aaa</para></li> <li><para>bbb</para></li> </ol> </dita> END $a->ditaObviousChanges; ok -p $a eq <<END; <dita> <ol> <li> <p>aaa</p> </li> <li> <p>bbb</p> </li> </ol> </dita> END
Set the dita organization field in the xml headers, set by default to OASIS.
Add xml headers for the dita document type indicated by the specified parse tree
Parameter Description 1 $node Node in parse tree
ok Data::Edit::Xml::new(q(<concept/>))->ditaTopicHeaders eq <<END; <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE concept PUBLIC "-//OASIS//DTD DITA Concept//EN" "concept.dtd" []> END
Position sections just before html header tags so that subsequently the document can be divided into sections.
Parameter Description 1 $node Parse tree
{my $x = Data::Edit::Xml::new(<<END); <x> <h1>h1</h1> H1 <h2>h2</h2> H2 <h3>h3</h3> H3 <h3>h3</h3> H3 <h2>h2</h2> H2 <h4>h4</h4> H4 </x> END $x->htmlHeadersToSections; $x->divideDocumentIntoSections(sub {my ($topicref, $section) = @_; my $file = keys %file; $topicref->href = $file; $file{$file} = -p $section; $section->cut; }); ok -p $x eq <<END; <x> <topicref href="0"> <topicref href="1"> <topicref href="2"/> <topicref href="3"/> </topicref> <topicref href="4"> <topicref href="5"/> </topicref> </topicref> </x> END ok nn(dump({map {$_=>nn($file{$_})} keys %file})) eq nn(dump( {"0" => "<section level=\"1\">N <h1>h1</h1>NN H1NN</section>N", "1" => "<section level=\"2\">N <h2>h2</h2>NN H2NN</section>N", "2" => "<section level=\"3\">N <h3>h3</h3>NN H3NN</section>N", "3" => "<section level=\"3\">N <h3>h3</h3>NN H3NN</section>N", "4" => "<section level=\"2\">N <h2>h2</h2>NN H2NN</section>N", "5" => "<section level=\"4\">N <h4>h4</h4>NN H4NN</section>N",
Divide a parse tree into sections by moving non section tags into their corresponding section so that the section tags expand until they are contiguous. The sections are then cut out by applying the specified sub to each section tag in the parse tree. The specified sub will receive the containing topicref and the section to be cut out as parameters allowing a reference to the cut out section to be inserted into the topicref.
Parameter Description 1 $node Parse tree 2 $cutSub Cut out sub
Convert all <p> nodes to <note> if the paragraph starts with 'Note:', optionally wrapping the content of the <note> with a <p>
Parameter Description 1 $node Parse tree 2 $wrapNoteContentWithParagaph Wrap the <note> content with a <p> if true
{my $a = Data::Edit::Xml::new(<<END); <a> <p> Note: see over for details.</p> </a> END $a->ditaParagraphToNote(1); ok -p $a eq <<END; <a> <note> <p>See over for details.</p> </note> </a> END
Extract style information from a parse tree representing a word document.
{my $a = Data::Edit::Xml::new(<<END); <a> <text:list-style style:name="aa"> <text:list-level-style-bullet text:level="2"/> </text:list-style> </a> END my $styles = $a->wordStyles; is_deeply $styles, {bulletedList=>{aa=>{2=>1}}};
Convert an html table to a Dita table.
Parameter Description 1 $table Html table node
{my $a = Data::Edit::Xml::new(<<END); <table> <thead> <tr> <th>Month</th> <th>Savings</th> <th>Phone</th> <th>Comment</th> </tr> </thead> <tbody> <tr> <td>January</td> <td>100</td> <td>555-1212</td> </tr> <tr> <td>February</td> <td>80</td> </tr> </tbody> </table> END $a->htmlTableToDita; ok -p $a eq <<END; <table> <tgroup cols="4"> <colspec colname="c1" colnum="1" colwidth="1*"/> <colspec colname="c2" colnum="2" colwidth="1*"/> <colspec colname="c3" colnum="3" colwidth="1*"/> <colspec colname="c4" colnum="4" colwidth="1*"/> <thead> <row> <entry>Month</entry> <entry>Savings</entry> <entry>Phone</entry> <entry>Comment</entry> </row> </thead> <tbody> <row> <entry>January</entry> <entry>100</entry> <entry nameend="c4" namest="c3">555-1212</entry> </row> <row> <entry>February</entry> <entry nameend="c4" namest="c2">80</entry> </row> </tbody> </tgroup> </table> END
Debugging methods
Print the attributes of a node.
Parameter Description 1 $node Node whose attributes are to be printed.
{my $x = Data::Edit::Xml::new(my $s = <<END); <a no="1" word="first"/> END ok $x->printAttributes eq qq( no="1" word="first");
Print the tag and attributes of a node.
Parameter Description 1 $node Node to be printed.
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c id="42" match="mm"/> </b> <d> <e/> </d> </a> END ok $c->printNode eq q(c id="42" match="mm");
A debug version of go that returns additional information explaining any failure to reach the node identified by the path.
Returns ([reachable tag...], failing tag, [possible tag...]) where:
the path elements successfully traversed;
the failing element;
the possibilities at the point where the path failed if it failed else undef.
Parameters:
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c> <d/> </c> <c/> </b> <b/> </a> END my ($good, $fail, $possible) = $a->goFish(qw(b c D)); ok $fail eq q(D); is_deeply $good, [qw(b c)]; is_deeply $possible, [q(d)];
Read and write files of compressed xml. These methods provide a compact, efficient way to store and retrieve parse trees to/from files.
Write the parse tree starting at $node as compressed xml to the specified $file.
Parameter Description 1 $node Parse tree node 2 $file File to write to.
my $a = Data::Edit::Xml::new(q(<a>).(q(<b>𝝱</b>)x1e3).q(</a>)); my $file = $a->writeCompressedFile(q(zzz.xml.zip)); my $A = readCompressedFile($file); ok $a->equals($A);
Read the specified $file containing compressed xml.
Parameter Description 1 $file File to read.
Data::Edit::Xml::readCompressedFile
Allow methods with constant parameters to be called as method_p1_p2...(variable parameters) whenever it is easier to type underscores than (qw()).
{my $a = Data::Edit::Xml::new(<<END); <a> <b> <c/> </b> </a> END my ($c, $b) = $a->byList; ok $c->at_c_b_a; ok !$c->at_b; ok -t $c->change_d_c_b eq q(d); ok ! $c->change_d_b; if (1) {my $a = Data::Edit::Xml::new(<<END); <a><b><c/><d/><e/><f/></b></a> END ok -t $a->first_b__first_c__next__next_e__next eq q(f); ok !$a->first_b__first_c__next__next_f; }
Build a tree representation of the parsed XML which can be easily traversed to look for things.
Parameter Description 1 $parent The parent node 2 $parse The remaining parse
Remove a leaf node from the parse tree and make it into its own parse tree.
Parameter Description 1 $node Leaf node to disconnect.
Index the children of a node so that we can access them by tag and number.
Parameter Description 1 $node Node to index.
Merge multiple text segments and set parent and parser after changes to a node
Normalize white space, remove comments DOCTYPE and xml processors from a string
Parameter Description 1 $string String to normalize
Data::Edit::Xml::normalizeWhiteSpace
Return a readable string representing a node of a parse tree and all the nodes below it as a here document
Post-order traversal of a parse tree or sub tree calling the specified sub within eval{} at each node and returning the specified starting node. The sub is passed references to the current node and all of its ancestors. The value of the current node is also made available via $_.
Parameter Description 1 $node Starting node 2 $sub Sub to call 3 @context Accumulated context.
Pre-order traversal of a parse tree or sub tree calling the specified sub within eval{} at each node and returning the specified starting node. The sub is passed references to the current node and all of its ancestors. The value of the current node is also made available via $_.
Pre-order traversal down through a parse tree or sub tree calling the specified sub within eval{} at each node and returning the specified starting node. The sub is passed references to the current node and all of its ancestors. The value of the current node is also made available via $_.
Confirm that a string matches a match expression.
Parameter Description 1 $tag Starting node 2 $match Ancestry.
Ensure that this node has a number.
Create a required clean up node
Adding padding entries to a table to make sure every row has the same number of entries
Parameter Description 1 $table Table node 2 $nEntries Number of entries
Topic type and corresponding body.
Parameter Description 1 $type Type from qw(bookmap concept reference task)
Get the heading level from a section tag.
Print the attributes of a node replacing the id with the labels.
Print the attributes of a node extending the id with the labels.
Check the parent pointers are correct in a parse tree.
Parameter Description 1 $x Parse tree.
Check that every node has a parser.
Replace new lines in a string with N to make testing easier.
Parameter Description 1 $s String.
firstLeaf is a synonym for downWhileFirst - Move down from the specified $node as long as each lower node is a first node.
lastLeaf is a synonym for downWhileLast - Move down from the specified $node as long as each lower node is a last node.
mnt is a synonym for matchesNextTags - Return the specified b<$node> if the siblings following the specified $node match the specified <@tags> else return undef.
mpt is a synonym for matchesPrevTags - Return the specified b<$node> if the siblings prior to the specified $node match the specified <@tags> else return undef.
oat is a synonym for overAllTags - Return the specified b<$node> if all of it's child nodes match the specified <@tags> else return undef.
oft is a synonym for overFirstTags - Return the specified b<$node> if the first of it's child nodes match the specified <@tags> else return undef.
olt is a synonym for overLastTags - Return the specified b<$node> if the last of it's child nodes match the specified <@tags> else return undef.
1 above - Return the first node if the first node is above the second node optionally checking that the first node is in the specified context otherwise return undef
2 abovePath - Return the nodes along the path from the first node down to the second node when the first node is above the second node else return ().
3 addConditions - Add conditions to a node and return the node.
4 addFirst - Add a new node first below the specified $node and return the new node unless a node with that tag already exists in which case return the existing node.
5 addFirstAsText - Add a new text node first below the specified $node and return the new node unless a text node already exists there and starts with the same text in which case return the existing node.
6 addLabels - Add the named labels to the specified $node and return the number of labels added.
7 addLast - Add a new node last below the specified $node and return the new node unless a node with that tag already exists in which case return the existing node.
8 addLastAsText - Add a new text node last below the specified $node and return the new node unless a text node already exists there and ends with the same text in which case return the existing node.
9 addNext - Add a new node next to the specified $node and return the new node unless a node with that tag already exists in which case return the existing node.
10 addNextAsText - Add a new text node after the specified $node and return the new node unless a text node already exists there and starts with the same text in which case return the existing node.
11 addPrev - Add a new node before the specified $node and return the new node unless a node with that tag already exists in which case return the existing node.
12 addPrevAsText - Add a new text node before the specified $node and return the new node unless a text node already exists there and ends with the same text in which case return the existing node.
13 addSingleChild - Wrap the content of a specified $node in a new node with the specified $tag and optional %attribute unless the content is already wrapped in a single child with the specified $tag.
14 addWrapWith - Wrap the specified $node with the specified tag if the node is not already wrapped with such a tag and return the new node unless a node with that tag already exists in which case return the existing node.
15 adjacent - Return the first node if it is adjacent to the second node else undef.
16 after - Return the first node if it occurs after the second node in the parse tree optionally checking that the first node is in the specified context or else undef if the node is above, below or before the target.
17 allConditions - Return the node if it has all of the specified conditions, else return undef
18 an - Return the next node if the specified $node has the specified tag and the next node is in the specified context.
19 ancestry - Return a list containing: (the specified $node, its parent, its parent's parent etc.
20 anyCondition - Return the node if it has any of the specified conditions, else return undef
21 ap - Return the previous node if the specified $node has the specified tag and the previous node is in the specified context.
22 apn - Return (previous node, next node) if the previous and current nodes have the specified tags and the next node is in the specified context else return ().
23 at - Confirm that the node has the specified ancestry and return the starting node if it does else undef.
24 atOrBelow - Confirm that the node or one of its ancestors has the specified context as recognized by at and return the first node that matches the context or undef if none do.
25 atPositionMatch - Confirm that a string matches a match expression.
26 attr - Return the value of an attribute of the current node as an lvalue sub.
27 attrCount - Return the number of attributes in the specified $node, optionally ignoring the specified names from the count.
28 attributes - The attributes of this node, see also: "Attributes".
29 attrs - Return the values of the specified attributes of the current node as a list
30 audience - Attribute audience for a node as an lvalue sub.
31 AUTOLOAD - Allow methods with constant parameters to be called as method_p1_p2.
32 before - Return the first node if it occurs before the second node in the parse tree optionally checking that the first node is in the specified context or else undef if the node is above, below or before the target.
33 below - Return the first node if the first node is below the second node optionally checking that the first node is in the specified context otherwise return undef
34 belowPath - Return the nodes along the path from the first node up to the second node when the first node is below the second node else return ().
35 bitsNodeTextBlank - Return a bit string that shows if there are any non text nodes, text nodes or blank text nodes under a node.
36 breakIn - Concatenate the nodes following and preceding the start node, unwrapping nodes whose tag matches the start node and return the start node.
37 breakInBackwards - Concatenate the nodes preceding the start node, unwrapping nodes whose tag matches the start node and return the start node in the manner of breakIn.
38 breakInForwards - Concatenate the nodes following the start node, unwrapping nodes whose tag matches the start node and return the start node in the manner of breakIn.
39 breakOut - Lift child nodes with the specified tags under the specified parent node splitting the parent node into clones and return the cut out original node.
40 by - Post-order traversal of a parse tree or sub tree calling the specified sub at each node and returning the specified starting node.
41 byList - Return a list of all the nodes at and below a specified $node in pre-order or the empty list if the $node is not in the optional context.
42 byReverse - Reverse post-order traversal of a parse tree or sub tree calling the specified sub at each node and returning the specified starting $node.
43 byReverseList - Return a list of all the nodes at and below a specified $node in reverse preorder or the empty list if the specified $node is not in the optional context.
44 byReverseX - Reverse post-order traversal of a parse tree or sub tree below the specified $node calling the specified sub within eval{} at each node and returning the specified starting $node.
45 byX - Post-order traversal of a parse tree calling the specified sub at each node as long as this sub does not die.
46 byX2 - Post-order traversal of a parse tree or sub tree calling the specified sub within eval{} at each node and returning the specified starting node.
47 byX22 - Post-order traversal of a parse tree or sub tree calling the specified sub within eval{} at each node and returning the specified starting node.
48 c - Return an array of all the nodes with the specified tag below the specified $node.
49 cdata - The name of the tag to be used to represent text - this tag must not also be used as a command tag otherwise the parser will confess.
50 change - Change the name of a node, optionally confirming that the node is in a specified context and return the node.
51 changeAttr - Change the name of an attribute in the specified $node unless it has already been set and return the node.
52 changeAttributeValue - Apply a sub to the value of an attribute of the specified $node.
53 changeAttrValue - Change the name and value of an attribute in the specified $node unless it has already been set and return the node.
54 changeReasonCommentSelectionSpecification - Provide a specification to select change reason comments to be inserted as text into a parse tree.
55 changeText - If the node is a text node in the specified context then the specified sub is passed the text of the node in $_, any changes to which are recorded in the text of the node.
56 checkParentage - Check the parent pointers are correct in a parse tree.
57 checkParser - Check that every node has a parser.
58 class - Attribute class for a node as an lvalue sub.
59 clone - Return a clone of the parse tree optionally checking that the starting node is in a specified context: the parse tree is cloned without converting it to string and reparsing it so this method will not renew any nodes added as text.
60 commonAdjacentAncestors - Given two nodes, find a pair of adjacent ancestral siblings if such a pair exists else return ().
61 commonAncestor - Find the most recent common ancestor of the specified nodes or undef if there is no common ancestor.
62 concatenate - Concatenate two successive nodes and return the target node.
63 concatenateSiblings - Concatenate preceding and following nodes as long as they have the same tag as the specified $node and return the specified $node.
64 condition - Return the node if it has the specified condition and is in the optional context, else return undef
65 conditions - Conditional strings attached to a node, see "Conditions".
66 containsSingleText - Return the single text element below the specified $node else return undef.
67 content - Content of command: the nodes immediately below this node in the order in which they appeared in the source text, see also "Contents".
68 contentAfter - Return a list of all the sibling nodes following this node or an empty list if this node is last or not in the optional context.
69 contentAfterAsTags - Return a string containing the tags of all the sibling nodes following this node separated by single spaces or the empty string if the node is empty or undef if the node does not match the optional context.
70 contentAfterAsTags2 - Return a string containing the tags of all the sibling nodes following this node separated by two spaces with a single space preceding the first tag and a single space following the last tag or the empty string if the node is empty or undef if the node does not match the optional context.
71 contentAsTags - Return a string containing the tags of all the child nodes of this node separated by single spaces or the empty string if the node is empty or undef if the node does not match the optional context.
72 contentAsTags2 - Return a string containing the tags of all the child nodes of this node separated by two spaces with a single space preceding the first tag and a single space following the last tag or the empty string if the node is empty or undef if the node does not match the optional context.
73 contentBefore - Return a list of all the sibling nodes preceding this node or an empty list if this node is last or not in the optional context.
74 contentBeforeAsTags - Return a string containing the tags of all the sibling nodes preceding this node separated by single spaces or the empty string if the node is empty or undef if the node does not match the optional context.
75 contentBeforeAsTags2 - Return a string containing the tags of all the sibling nodes preceding this node separated by two spaces with a single space preceding the first tag and a single space following the last tag or the empty string if the node is empty or undef if the node does not match the optional context.
76 contents - Return a list of all the nodes contained by this node or an empty list if the node is empty or not in the optional context.
77 context - Return a string containing the tag of the starting node and the tags of all its ancestors separated by single spaces.
78 copyAttrs - Copy all the attributes of the source node to the target node, or, just the named attributes if the optional list of attributes to copy is supplied, overwriting any existing attributes in the target node and return the source node.
79 copyLabels - Copy all the labels from the source node to the target node and return the source node.
80 copyLabelsAndIdsInTree - Copy all the labels and ids in the source parse tree to the matching nodes in the target parse tree.
81 copyNewAttrs - Copy all the attributes of the source node to the target node, or, just the named attributes if the optional list of attributes to copy is supplied, without overwriting any existing attributes in the target node and return the source node.
82 count - Return the count of the number of instances of the specified tags under the specified $node, either by tag in array context or in total in scalar context.
83 countAttrNames - Return a reference to a hash showing the number of instances of each attribute on and below the specified $node.
84 countAttrNamesOnTagExcluding - Count the number of attributes owned by the specified $node that are not in the specified list.
85 countAttrValues - Return a reference to a hash showing the number of instances of each attribute value on and below the specified $node.
86 countLabels - Return the count of the number of labels at a node.
87 countOutputClasses - Count instances of outputclass attributes
88 countTagNames - Return a reference to a hash showing the number of instances of each tag on and below the specified $node.
89 countTags - Count the number of tags in a parse tree.
90 crc - Insert a comment consisting of a code and an optional reason as text into the parse tree to indicate the location of changes to the parse tree.
91 createPatch - Create a patch that moves the source parse tree to the target parse tree node as long as they have the same tag and id structure with each id being unique.
92 createRequiredCleanUp - Create a required clean up node
93 cut - Cut out a node so that it can be reinserted else where in the parse tree.
94 data - A hash added to the node for use by the programmer during transformations.
95 Data::Edit::Xml::Patch::install - Replay a patch created by createPatch against a parse tree that has the same tag and id structure with each id being unique.
96 deleteAttr - Delete the named attribute in the specified $node, optionally check its value first, return the node regardless.
97 deleteAttrs - Delete the specified attributes of the specified $node without checking their values and return the node.
98 deleteConditions - Delete conditions applied to a node and return the node.
99 deleteContent - Delete the content of the specified $node.
100 deleteLabels - Delete the specified labels in the specified $node or all labels if no labels have are specified and return that node.
101 depth - Returns the depth of the specified $node, the depth of a root node is zero.
102 diff - Return () if the dense string representations of the two nodes are equal, else up to the first N (default 16) characters of the common prefix before the point of divergence and the remainder of the string representation of each node from the point of divergence.
103 disconnectLeafNode - Remove a leaf node from the parse tree and make it into its own parse tree.
104 disordered - Return the first node that is out of the specified order when performing a pre-ordered traversal of the parse tree.
105 ditaAddColSpecToTgroup - Add the specified $number of column specification to a specified $tgroup which does not have any already.
106 ditaAddPadEntriesToRows - Adding padding entries to a table to make sure every row has the same number of entries
107 ditaFixTableColSpec - Improve the specified $table by making obvious improvements.
108 ditaListToSteps - Change the specified $node to steps and its contents to cmd\step optionally only in the specified context.
109 ditaListToStepsUnordered - Change the specified $node to steps-unordered and its contents to cmd\step optionally only in the specified context.
110 ditaListToSubSteps - Change the specified $node to substeps and its contents to cmd\step optionally only in the specified context.
111 ditaMaximumNumberOfEntriesInARow - Return the maximum number of entries in the rows of the specified $table or undef if not a table.
112 ditaMergeLists - Merge the specified $node with the preceding or following list or steps or substeps if possible and return the specified $node regardless.
113 ditaMergeListsOnce - Merge the specified $node with the preceding or following list or steps or substeps if possible and return the specified $node regardless.
114 ditaObviousChanges - Make obvious changes to a parse tree to make it look more like Dita.
115 ditaOrganization - Set the dita organization field in the xml headers, set by default to OASIS.
116 ditaParagraphToNote - Convert all <p> nodes to <note> if the paragraph starts with 'Note:', optionally wrapping the content of the <note> with a <p>
117 ditaStepsToList - Change the specified $node to ol and its cmd\step content to li optionally only in the specified context.
118 ditaTopicHeaders - Add xml headers for the dita document type indicated by the specified parse tree
119 divideDocumentIntoSections - Divide a parse tree into sections by moving non section tags into their corresponding section so that the section tags expand until they are contiguous.
120 down - Pre-order traversal down through a parse tree or sub tree calling the specified sub at each node and returning the specified starting node.
121 downReverse - Reverse pre-order traversal down through a parse tree or sub tree calling the specified sub at each node and returning the specified starting node.
122 downReverseX - Reverse pre-order traversal down through a parse tree or sub tree calling the specified sub within eval{} at each node and returning the specified starting node.
123 downWhileFirst - Move down from the specified $node as long as each lower node is a first node.
124 downWhileLast - Move down from the specified $node as long as each lower node is a last node.
125 downWhileSingleChild - Move down from the specified $node as long as it has a single child else return undef.
126 downX - Pre-order traversal of a parse tree calling the specified sub at each node as long as this sub does not die.
127 downX2 - Pre-order traversal of a parse tree or sub tree calling the specified sub within eval{} at each node and returning the specified starting node.
128 downX22 - Pre-order traversal down through a parse tree or sub tree calling the specified sub within eval{} at each node and returning the specified starting node.
129 equals - Return the first node if the two parse trees have identical representations via string, else undef.
130 equalsIgnoringAttributes - Return the first node if the two parse trees have identical representations via string if the specified attributes are ignored, else undef.
131 errorsFile - Error listing file.
132 expandIncludes - Expand the includes mentioned in a parse tree: any tag that ends in include is assumed to be an include directive.
133 findByForestNumber - Find the node with the specified forest number as made visible on the id attribute by prettyStringNumbered in the parse tree containing the specified $node and return the found node or undef if no such node exists.
134 findByNumber - Find the node with the specified number as made visible by prettyStringNumbered in the parse tree containing the specified $node and return the found node or undef if no such node exists.
135 findByNumbers - Find the nodes with the specified numbers as made visible by prettyStringNumbered in the parse tree containing the specified $node and return the found nodes in a list with undef for nodes that do not exist.
136 first - Return the first node below this node optionally checking its context.
137 firstBy - Return a list of the first instance of each specified tag encountered in a post-order traversal from the specified $node or a hash of all first instances if no tags are specified.
138 firstContextOf - Return the first node encountered in the specified context in a depth first post-order traversal of the parse tree.
139 firstDown - Return a list of the first instance of each specified tag encountered in a pre-order traversal from the specified $node or a hash of all first instances if no tags are specified.
140 firstIn - Return the first child node matching one of the named tags under the specified parent node.
141 firstInIndex - Return the specified $node if it is first in its index and optionally at the specified context else undef
142 firstn - Return the $n'th first node below this node optionally checking its context or undef if there is no such node.
143 firstNot - Return the first child node that does not match any of the named @tags under the specified parent $node.
144 firstOf - Return an array of the nodes that are continuously first under their specified parent node and that match the specified list of tags.
145 firstSibling - Return the first sibling of the specified $node in the optional context else undef
146 firstText - Return the first node if it is a text node otherwise undef
147 firstTextMatches - Return the first node under the specified $node if: it is a text mode; its text matches the specified regular expression; the specified $node is in the optional specified context.
148 firstUntil - Go first from the specified $node and continue deeper until a first child node matches the specified @context or return undef if there is no such node.
149 firstWhile - Go first from the specified $node and continue deeper as long as each first child node matches one of the specified @tags.
150 forestNumbers - Index to node by forest number as set by numberForest.
151 forestNumberTrees - Number the ids of the nodes in a parse tree in pre-order so they are numbered in the same sequence that they appear in the source.
152 from - Return a list consisting of the specified node and its following siblings optionally including only those nodes that match one of the tags in the specified list.
153 fromTo - Return a list of the nodes between the specified start and end nodes optionally including only those nodes that match one of the tags in the specified list.
154 getAttrs - Return a sorted list of all the attributes on this node.
155 getLabels - Return the names of all the labels set on a node.
156 getSectionHeadingLevel - Get the heading level from a section tag.
157 go - Return the node reached from the specified $node via the specified path: (index position?)* where index is the tag of the next node to be chosen and position is the optional zero based position within the index of those tags under the current node.
158 goFish - A debug version of go that returns additional information explaining any failure to reach the node identified by the path.
159 guid - Attribute guid for a node as an lvalue sub.
160 howFar - Return how far the first node is from the second node along a path through their common ancestor.
161 howFarAbove - Return how far the first node is above the second node is or 0 if the first node is not strictly above the second node.
162 howFarBelow - Return how far the first node is below the second node is or 0 if the first node is not strictly below the second node.
163 howFirst - Return the depth to which this node is first else 0.
164 howLast - Return the depth to which this node is last else 0.
165 howOnlyChild - Return the depth to which this node is an only child else 0.
166 href - Attribute href for a node as an lvalue sub.
167 htmlHeadersToSections - Position sections just before html header tags so that subsequently the document can be divided into sections.
168 htmlTableToDita - Convert an html table to a Dita table.
169 id - Attribute id for a node as an lvalue sub.
170 index - Return the index of a node in its parent index.
171 indexes - Indexes to sub commands by tag in the order in which they appeared in the source text.
172 indexIds - Return a map of the ids at and below the specified $node.
173 indexNode - Merge multiple text segments and set parent and parser after changes to a node
174 input - Source of the parse if this is the parser root node.
175 inputFile - Source file of the parse if this is the parser root node.
176 inputString - Source string of the parse if this is the parser root node.
177 invert - Swap a parent and child node where the child is the only child of the parent and return the parent.
178 invertFirst - Swap a parent and child node where the child is the first child of the parent by placing the parent last in the child.
179 invertLast - Swap a parent and child node where the child is the last child of the parent by placing the parent first in the child.
180 isAllBlankText - Return the specified $node if this node, optionally in the specified context, does not contain anything or if it does contain something it is all white space else return undef.
181 isBlankText - Return the specified $node if this node is a text node, optionally in the specified context, and contains nothing other than white space else return undef.
182 isEmpty - Confirm that this node is empty, that is: this node has no content, not even a blank string of text.
183 isFirst - Return the specified $node if it is first under its parent and optionally has the specified context, else return undef
184 isFirstText - Return the specified $node if this node is a text node, the first node under its parent and that the parent is optionally in the specified context, else return undef.
185 isFirstToDepth - Return the specified $node if it is first to the specified depth else return undef
186 isLast - Return the specified $node if it is last under its parent and optionally has the specified context, else return undef
187 isLastText - Return the specified $node if this node is a text node, the last node under its parent and that the parent is optionally in the specified context, else return undef.
188 isLastToDepth - Return the specified $node if it is last to the specified depth else return undef
189 isOnlyChild - Return the specified $node if it is the only node under its parent ignoring any surrounding blank text.
190 isOnlyChildToDepth - Return the specified $node if it and its ancestors are only children to the specified depth else return undef.
191 isText - Return the specified $node if this node is a text node, optionally in the specified context, else return undef.
192 labels - The labels attached to a node to provide addressability from other nodes, see: "Labels".
193 labelsInTree - Return a hash of all the labels in a tree
194 lang - Attribute lang for a node as an lvalue sub.
195 last - Return the last node below this node optionally checking its context.
196 lastBy - Return a list of the last instance of each specified tag encountered in a post-order traversal from the specified $node or a hash of all last instances if no tags are specified.
197 lastContextOf - Return the last node encountered in the specified context in a depth first reverse pre-order traversal of the parse tree.
198 lastDown - Return a list of the last instance of each specified tag encountered in a pre-order traversal from the specified $node or a hash of all last instances if no tags are specified.
199 lastIn - Return the last child node matching one of the named tags under the specified parent node.
200 lastInIndex - Return the specified $node if it is last in its index and optionally at the specified context else undef
201 lastn - Return the $n'th last node below this node optionally checking its context or undef if there is no such node.
202 lastNot - Return the last child node that does not match any of the named @tags under the specified parent $node.
203 lastOf - Return an array of the nodes that are continuously last under their specified parent node and that match the specified list of tags.
204 lastSibling - Return the last sibling of the specified $node in the optional context else undef
205 lastText - Return the last node if it is a text node otherwise undef
206 lastTextMatches - Return the last node under the specified $node if: it is a text mode; its text matches the specified regular expression; the specified $node is in the optional specified context.
207 lastUntil - Go last from the specified $node and continue deeper until a last child node matches the specified @context or return undef if there is no such node.
208 lastWhile - Go last from the specified $node and continue deeper as long as each last child node matches one of the specified @tags.
209 listConditions - Return a list of conditions applied to a node.
210 matchAfter - Confirm that the string representing the tags following this node matches a regular expression where each pair of tags is separated by a single space.
211 matchAfter2 - Confirm that the string representing the tags following this node matches a regular expression where each pair of tags have two spaces between them and the first tag is preceded by a single space and the last tag is followed by a single space.
212 matchBefore - Confirm that the string representing the tags preceding this node matches a regular expression where each pair of tags is separated by a single space.
213 matchBefore2 - Confirm that the string representing the tags preceding this node matches a regular expression where each pair of tags have two spaces between them and the first tag is preceded by a single space and the last tag is followed by a single space.
214 matchesNextTags - Return the specified b<$node> if the siblings following the specified $node match the specified <@tags> else return undef.
215 matchesPrevTags - Return the specified b<$node> if the siblings prior to the specified $node match the specified <@tags> else return undef.
216 matchesText - Returns an array of regular expression matches in the text of the specified $node if it is text node and it matches the specified regular expression and optionally has the specified context otherwise returns an empty array.
217 matchTree - Return a list of nodes that match the specified tree of match expressions, else () if one or more match expressions fail to match nodes in the tree below the specified start node.
218 mergeDuplicateChildWithParent - Merge a parent node with its only child if their tags are the same and their attributes do not collide other than possibly the id in which case the parent id is used.
219 moveAttrs - Move all the attributes of the source node to the target node, or, just the named attributes if the optional list of attributes to move is supplied, overwriting any existing attributes in the target node and return the source node.
220 moveLabels - Move all the labels from the source node to the target node and return the source node.
221 moveNewAttrs - Move all the attributes of the source node to the target node, or, just the named attributes if the optional list of attributes to copy is supplied, without overwriting any existing attributes in the target node and return the source node.
222 navtitle - Attribute navtitle for a node as an lvalue sub.
223 new - Create a new parse tree - call this method statically as in Data::Edit::Xml::new(file or string) to parse a file or string or with no parameters and then use "input", "inputFile", "inputString", "errorFile" to provide specific parameters for the parse, then call "parse" to perform the parse and return the parse tree.
224 newTag - Create a new non text node.
225 newText - Create a new text node.
226 newTree - Create a new tree.
227 next - Return the node next to the specified $node, optionally checking its context.
228 nextIn - Return the nearest sibling after the specified $node that matches one of the named tags or undef if there is no such sibling node.
229 nextn - Return the $n'th next node after this node optionally checking its context or undef if there is no such node.
230 nextOn - Step forwards as far as possible while remaining on nodes with the specified tags.
231 nextText - Return the next node if it is a text node otherwise undef
232 nextTextMatches - Return the next node to the specified $node if: it is a text mode; its text matches the specified regular expression; the specified $node is in the optional specified context.
233 nextUntil - Go to the next sibling of the specified $node and continue forwards until the tag of a sibling node matches one of the specified @tags.
234 nextWhile - Go to the next sibling of the specified $node and continue forwards while the tag of each sibling node matches one of the specified @tags.
235 nn - Replace new lines in a string with N to make testing easier.
236 normalizeWhiteSpace - Normalize white space, remove comments DOCTYPE and xml processors from a string
237 not - Return the specified $node if it does not match any of the specified tags, else undef
238 number - Number of this node, see findByNumber.
239 numbering - Last number used to number a node in this parse tree.
240 numberNode - Ensure that this node has a number.
241 numbers - Nodes by number.
242 numberTree - Number the nodes in a parse tree in pre-order so they are numbered in the same sequence that they appear in the source.
243 numberTreesJustIds - Number the ids of the nodes in a parse tree in pre-order so they are numbered in the same sequence that they appear in the source.
244 opAt - <= : Check that a node is in the context specified by the referenced array of words.
245 opAttr - % : Get the value of an attribute of this node.
246 opBy - x= : Traverse a parse tree in post-order.
247 opContents - @{} : nodes immediately below a node.
248 opCut - -- : Cut out a node.
249 opGo - >= : Search for a node via a specification provided as a reference to an array of words each number.
250 opNew - ** : create a new node from the text on the right hand side: if the text contains a non word character \W the node will be create as text, else it will be created as a tag
251 opPutFirst - >> : put a node or string first under a node and return the new node.
252 opPutFirstAssign - >>= : put a node or string first under a node.
253 opPutLast - << : put a node or string last under a node and return the new node.
254 opPutLastAssign - <<= : put a node or string last under a node.
255 opPutNext - > + : put a node or string after the specified $node and return the new node.
256 opPutNextAssign - += : put a node or string after the specified $node.
257 opPutPrev - < - : put a node or string before the specified $node and return the new node.
258 opPutPrevAssign - -= : put a node or string before the specified $node,
259 opString - -B: bitsNodeTextBlank
260 opUnwrap - ++ : Unwrap a node.
261 opWrapContentWith - * : Wrap content with a tag, returning the wrapping node.
262 opWrapWith - / : Wrap node with a tag, returning the wrapping node.
263 ordered - Return the first node if the specified nodes are all in order when performing a pre-ordered traversal of the parse tree else return undef.
264 otherprops - Attribute otherprops for a node as an lvalue sub.
265 outputclass - Attribute outputclass for a node as an lvalue sub.
266 over - Confirm that the string representing the tags at the level below this node match a regular expression where each pair of tags is separated by a single space.
267 over2 - Confirm that the string representing the tags at the level below this node match a regular expression where each pair of tags have two spaces between them and the first tag is preceded by a single space and the last tag is followed by a single space.
268 overAllTags - Return the specified b<$node> if all of it's child nodes match the specified <@tags> else return undef.
269 overFirstTags - Return the specified b<$node> if the first of it's child nodes match the specified <@tags> else return undef.
270 overLastTags - Return the specified b<$node> if the last of it's child nodes match the specified <@tags> else return undef.
271 parent - Parent node of this node or undef if the parser root node.
272 parse - Parse input XML specified via: inputFile, input or inputString.
273 parser - Parser details: the root node of a tree is the parser node for that tree.
274 path - Return a list representing the path to a node which can then be reused by go to retrieve the node as long as the structure of the parse tree has not changed along the path.
275 pathString - Return a string representing the path to the specified $node.
276 position - Return the index of a node in its parent's content.
277 present - Return the count of the number of the specified tag types present immediately under a node or a hash {tag} = count for all the tags present under the node if no names are specified.
278 prettyString - Return a readable string representing a node of a parse tree and all the nodes below it.
279 prettyStringCDATA - Return a readable string representing a node of a parse tree and all the nodes below it with the text fields wrapped with <CDATA>.
280 prettyStringContent - Return a readable string representing all the nodes below a node of a parse tree.
281 prettyStringContentNumbered - Return a readable string representing all the nodes below a node of a parse tree with numbering added.
282 prettyStringDitaHeaders - Return a readable string representing the parse tree below the specified $node with appropriate headers as determined by ditaOrganization .
283 prettyStringEnd - Return a readable string representing a node of a parse tree and all the nodes below it as a here document
284 prettyStringNumbered - Return a readable string representing a node of a parse tree and all the nodes below it with a number attached to each tag.
285 prev - Return the node before the specified $node, optionally checking its context.
286 prevIn - Return the nearest sibling node before the specified $node which matches one of the named tags or undef if there is no such sibling node.
287 prevn - Return the $n'th previous node after this node optionally checking its context or undef if there is no such node.
288 prevOn - Step backwards as far as possible while remaining on nodes with the specified tags.
289 prevText - Return the previous node if it is a text node otherwise undef
290 prevTextMatches - Return the previous node to the specified $node if: it is a text mode; its text matches the specified regular expression; the specified $node is in the optional specified context.
291 prevUntil - Go to the previous sibling of the specified $node and continue backwards until the tag of a sibling node matches one of the specified @tags.
292 prevWhile - Go to the previous sibling of the specified $node and continue backwards while the tag of each sibling node matches one of the specified @tags.
293 printAttributes - Print the attributes of a node.
294 printAttributesExtendingIdsWithLabels - Print the attributes of a node extending the id with the labels.
295 printAttributesReplacingIdsWithLabels - Print the attributes of a node replacing the id with the labels.
296 printNode - Print the tag and attributes of a node.
297 propagate - Propagate new attributes from nodes that match the specified tag to all their child nodes, then unwrap all the nodes that match the specified tag.
298 props - Attribute props for a node as an lvalue sub.
299 putFirst - Place a cut out or new node at the front of the content of the specified $node and return the new node.
300 putFirstAsText - Add a new text node first under a parent and return the new text node.
301 putFirstCut - Cut out the second node, place it first under the first node and return the second node.
302 putFirstRequiredCleanUp - Place a required cleanup tag first under a node and return the required clean up node.
303 putLast - Place a cut out or new node last in the content of the specified $node and return the new node.
304 putLastAsText - Add a new text node last under a parent and return the new text node.
305 putLastCut - Cut out the second node, place it last under the first node and return the second node.
306 putLastRequiredCleanUp - Place a required cleanup tag last under a node and return the required clean up node.
307 putNext - Place a cut out or new node just after the specified $node and return the new node.
308 putNextAsText - Add a new text node following this node and return the new text node.
309 putNextCut - Cut out the second node, place it next after the first node and return the second node.
310 putNextRequiredCleanUp - Place a required cleanup tag after a node.
311 putPrev - Place a cut out or new node just before the specified $node and return the new node.
312 putPrevAsText - Add a new text node following this node and return the new text node
313 putPrevCut - Cut out the second node, place it before the first node and return the second node.
314 putPrevRequiredCleanUp - Place a required cleanup tag before a node.
315 readCompressedFile - Read the specified $file containing compressed xml.
316 reindexNode - Index the children of a node so that we can access them by tag and number.
317 renameAttr - Change the name of an attribute in the specified $node regardless of whether the new attribute already exists or not and return the node.
318 renameAttrValue - Change the name and value of an attribute in the specified $node regardless of whether the new attribute already exists or not and return the node.
319 renew - Returns a renewed copy of the parse tree, optionally checking that the starting node is in a specified context: use this method if you have added nodes via the "Put as text" methods and wish to traverse their parse tree.
320 replaceContentWith - Replace the content of a node with the specified nodes and return the replaced content
321 replaceContentWithMovedContent - Replace the content of a specified target node with the contents of the specified source nodes removing the content from each source node and return the target node.
322 replaceContentWithText - Replace the content of a node with the specified texts and return the replaced content
323 replaceSpecialChars - Replace < > " & with < > " & Larry Wall's excellent Xml parser unfortunately replaces < > " & etc.
324 replaceWith - Replace a node (and all its content) with a new node (and all its content) and return the new node.
325 replaceWithBlank - Replace a node (and all its content) with a new blank text node and return the new node.
326 replaceWithRequiredCleanUp - Replace a node with a required cleanup message and return the new node
327 replaceWithText - Replace a node (and all its content) with a new text node and return the new node.
328 requiredCleanUp - Replace a node with a required cleanup node around the text of the replaced node with special characters replaced by symbols.
329 restore - Return a parse tree from a copy saved in a file by "save".
330 save - Save a copy of the parse tree to a file which can be restored and return the saved node.
331 set - Set the values of some attributes in a node and return the node.
332 setAttr - Set the values of some attributes in a node and return the node.
333 singleChild - Return the only child of the specified $node if the child is the only node under its parent ignoring any surrounding blank text and has the optional specified context, else return undef.
334 singleChildToDepth - Return the specified $node if it has single children to at least the specified depth else return undef.
335 string - Return a dense string representing a node of a parse tree and all the nodes below it.
336 stringContent - Return a string representing all the nodes below a node of a parse tree.
337 stringExtendingIdsWithLabels - Return a string representing the specified parse tree with the id attribute of each node extended by the Labels attached to each node.
338 stringNode - Return a string representing a node showing the attributes, labels and node number
339 stringQuoted - Return a quoted string representing a parse tree a node of a parse tree and all the nodes below it.
340 stringReplacingIdsWithLabels - Return a string representing the specified parse tree with the id attribute of each node set to the Labels attached to each node.
341 stringWithConditions - Return a string representing a node of a parse tree and all the nodes below it subject to conditions to select or reject some nodes.
342 style - Attribute style for a node as an lvalue sub.
343 swap - Swap two nodes optionally checking that the first node is in the specified context and return the first node.
344 tag - Tag name for this node, see also "Traversal" and "Navigation".
345 text - Text of this node but only if it is a text node, i.
346 through - Traverse parse tree visiting each node twice calling the specified sub at each node and returning the specified starting node.
347 throughX - Traverse parse tree visiting each node twice calling the specified sub within eval{} at each node and returning the specified starting node.
348 to - Return a list of the sibling nodes preceding the specified node optionally including only those nodes that match one of the tags in the specified list.
349 tocNumbers - Table of Contents number the nodes in a parse tree.
350 topicTypeAndBody - Topic type and corresponding body.
351 tree - Build a tree representation of the parsed XML which can be easily traversed to look for things.
352 type - Attribute type for a node as an lvalue sub.
353 unwrap - Unwrap a node by inserting its content into its parent at the point containing the node and return the parent node.
354 unwrapContentsKeepingText - Unwrap all the non text nodes below the specified $node adding a leading and a trailing space to prevent unwrapped content from being elided and return the specified $node else undef if not in the optional context.
355 unwrapParentsWithSingleChild - Unwrap any immediate ancestors of the specified $node which have only a single child and return the specified $node regardless.
356 up - Return the parent of the current node optionally checking the context of the specified $node first or return undef if the specified $node is the root of the parse tree.
357 upn - Go up the specified number of levels from the specified $node and return the node reached or undef if there is no such node.
358 upThru - Go up the specified path returning the node at the top or undef if no such node exists.
359 upUntil - Return the nearest ancestral node that matches the specified @context or undef if there is no such node.
360 upUntilFirst - Move up from the specified until we reach the root or a first node.
361 upUntilIsOnlyChild - Move up from the specified $node until we reach the root or another only child.
362 upUntilLast - Move up from the specified until we reach the root or a last node.
363 upWhile - Go up one level from the specified $node and then continue up while each node matches on of the specified <@tags>.
364 upWhileFirst - Move up from the specified $node as long as each node is a first node or return undef if the specified $node is not a first node.
365 upWhileIsOnlyChild - Move up from the specified $node as long as each node is an only child or return undef if the specified $node is not an only child.
366 upWhileLast - Move up from the specified $node as long as each node is a last node or return undef if the specified $node is not a last node.
367 wordStyles - Extract style information from a parse tree representing a word document.
368 wrapContentWith - Wrap the content of a node in a new node: the original node then contains just the new node which, in turn, contains all the content of the original node.
369 wrapDown - Wrap the content of the specified $node in a sequence of new nodes forcing the original node up - deepening the parse tree - return the array of wrapping nodes.
370 wrapFrom - Wrap all the nodes from the start node to the end node with a new node with the specified tag and attributes and return the new node.
371 wrapSiblingsAfter - If there are any siblings after the specified $node, wrap them with the specified tag.
372 wrapSiblingsBefore - If there are any siblings before the specified $node, wrap them with the specified tag.
373 wrapSiblingsBetween - If there are any siblings between the specified $nodes, wrap them with the specified tag and return the wrapping node else if there are no such nodes run undef
374 wrapTo - Wrap all the nodes from the start node to the end node with a new node with the specified tag and attributes and return the new node.
375 wrapUp - Wrap the original node in a sequence of new nodes forcing the original node down - deepening the parse tree - return the array of wrapping nodes.
376 wrapWith - Wrap the original node in a new node forcing the original node down - deepening the parse tree - return the new wrapping node.
377 writeCompressedFile - Write the parse tree starting at $node as compressed xml to the specified $file.
378 xmlHeader - Add the standard xml header to a string
This module is written in 100% Pure Perl and, thus, it is easy to read, comprehend, use, modify and install via cpan:
sudo cpan install Data::Edit::Xml
philiprbrenan@gmail.com
http://www.appaapps.com
Copyright (c) 2016-2018 Philip R Brenan.
This module is free software. It may be used, redistributed and/or modified under the same terms as Perl itself.
To install Data::Edit::Xml, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Data::Edit::Xml
CPAN shell
perl -MCPAN -e shell install Data::Edit::Xml
For more information on module installation, please visit the detailed CPAN module installation guide.