Free xml document types software for linux

XML::Diff is a Perl module for XML DOM-Tree based Diff & Patch Module.

SYNOPSIS

my $diff = XML::Diff->new();

# to generate a diffgram of two XML files, use compare.
# $old and $new can be filepaths, XML as a string,
# XML::LibXML::Document or XML::LibXML::Element objects.
# The diffgram is a XML::LibXML::Document by default.
my $diffgram = $diff->compare(
-old => $old_xml,
-new => $new_xml,
);

# To patch an XML document, an patch. $old and $diffgram
# follow the same formatting rules as compare.
# The resulting XML is a XML::LibXML::Document by default.
my $patched = $diff->patch(
-old => $old,
-diffgram => $diffgram,
);

This module provides methods for generating and applying an XML diffgram of two related XML files. The basis of the algorithm is tree-wise comparison using the DOM model as provided by XML::LibXML.

The Diffgram is well-formed XML in the XVCS namespance and supports update, insert, delete and move operations. It is meant to be human and machine readable. It uses XPath expressions for locating the nodes to operate on.

XML::Mini is a Perl implementation of the XML::Mini XML create/parse interface.

SYNOPSIS

use XML::Mini::Document;

use Data::Dumper;


###### PARSING XML #######

# create a new object
my $xmlDoc = XML::Mini::Document->new();

# init the doc from an XML string
$xmlDoc->parse($XMLString);

# You may use the toHash() method to automatically
# convert the XML into a hash reference
my $xmlHash = $xmlDoc->toHash();

print Dumper($xmlHash);


# You can also manipulate the elements like directly, like this:

# Fetch the ROOT element for the document
# (an instance of XML::Mini::Element)
my $xmlRoot = $xmlDoc->getRoot();

# play with the element and its children
# ...
my $topLevelChildren = $xmlRoot->getAllChildren();

foreach my $childElement (@{$topLevelChildren})
{
# ...
}


###### CREATING XML #######

# Create a new document from scratch

my $newDoc = XML::Mini::Document->new();

# This can be done easily by using a hash:
my $h = {
spy => {
id => 007,
type => SuperSpy,
name => James Bond,
email => mi5@london.uk,
address => Wherever he is needed most,
},
};

$newDoc->fromHash($h);



# Or new XML can also be created by manipulating
#elements directly:

my $newDocRoot = $newDoc->getRoot();

# create the < ? xml ?> header
my $xmlHeader = $newDocRoot->header(xml);
# add the version
$xmlHeader->attribute(version, 1.0);

my $person = $newDocRoot->createChild(person);

my $name = $person->createChild(name);
$name->createChild(first)->text(John);
$name->createChild(last)->text(Doe);

my $eyes = $person->createChild(eyes);
$eyes->attribute(color, blue);
$eyes->attribute(number, 2);

# output the document
print $newDoc->toString();
This example would output :
< ?xml version="1.0"? >
< person>
< name>
< first>
John
< /first>
< last>
Doe
< /last>
< /name>
< eyes color="blue" number="2" />
< /person>

XML::Mini is a set of Perl classes that allow you to access XML data and create valid XML output with a tree-based hierarchy of elements. The MiniXML API has both Perl and PHP implementations.

It provides an easy, object-oriented interface for manipulating XML documents and their elements. It is currently being used to send requests and understand responses from remote servers in Perl or PHP applications. An XML::Mini based parser is now being tested within the RPC::XML framework.

XML::Mini does not require any external libraries or modules and is pure Perl. If available, XML::Mini will use the Text::Balanced module in order to escape limitations of the regex-only approach (eg "cross-nested" tag parsing).
The Mini.pm module includes a number of variables you may use to tweak XML::Minis behavior. These include:

$XML::Mini::AutoEscapeEntities - when greater than 0, the values set for nodes are automatically escaped, thus $element->text(4 is > 3) will set the contents of the appended node to 4 is > 3. Default setting is 1.

$XML::Mini::IgnoreWhitespaces - when greater than 0, extraneous whitespaces will be ignored (maily useful when parsing). Thus Hello There will be parsed as containing a text node with contents Hello There instead of Hello There . Default setting is 1.

$XML::Mini::CaseSensitive - when greater than 0, element names are treated as case sensitive. Thus, $element->getElement(subelement) and $element->getElement(SubElement) will be equivalent. Defaults to 0.