XML::Output is a Perl module for writing simple XML documents.

SYNOPSIS

use XML::Output;

open(FH,>file.xml);
my $xo = new XML::Output({fh => *FH});
$xo->open(tagname, {attrname => attrval});
$xo->pcdata(element content);
$xo->close();
close(FH);

ABSTRACT

XML::Output is a Perl module for writing simple XML documents

XML::Output is a Perl module for writing simple XML document. The following methods are provided.

new
$xo = new XML::Output;
Constructs a new XML::Output object.

open
$xo->open(tagname, {attrname => attrval});
Open an element with specified name (and optional attributes)

close
$xo->close;
Close an element

empty
$xo->empty(tagname, {attrname => attrval});
Insert an empty element with specified name (and optional attributes)

pcdata
$xo->pcdata(element content);
Insert text

comment
$xo->comment(comment text);
Insert a comment

xmlstr
print $xo->xmlstr;
Get a string representation of the constructed document

DBIx::SQLCrosstab::Format is a Perl module with formats results created by DBIx::SQLCrosstab.

SYNOPSIS

use DBIx::SQLCrosstab::Format;
my $dbh=DBI->connect("dbi:driver:database"
"user","password", {RaiseError=>1})
or die "error in connection $DBI::errstrn";

my $params = {
dbh => $dbh,
op => [ [ SUM, salary] ],
from => person INNER JOIN departments USING (dept_id),
rows => [
{ col => country},
],
cols => [
{
id => dept,
value =>department,
from =>departments
},
{
id => gender, from => person
}
]
};
my $xtab = DBIx::SQLCrosstab::Format->new($params)
or die "error in creation ($DBIx::SQLCrosstab::errstr)n";

my $query = $xtab->get_query("#")
or die "error in query building $DBIx::SQLCrosstab::errstrn";

if ( $xtab->get_recs) {
# do something with records, or use a built-in function
# to produce a well formatted HTML table
#
print $xtab->as_html;

print $xtab->as_xml;
print $xtab->as_yaml;
print $xtab->as_csv(header);
$xtab->as_xls("xtab.xls");
use Data::Dumper;
print Data::Dumper->Dump ([ $xtab->as_perl_struct(hoh)],
[hoh]);
print Data::Dumper->Dump ([ $xtab->as_perl_struct(losh)],
[losh]);
print Data::Dumper->Dump ([ $xtab->as_perl_struct(loh)],
[loh]);
}
else {
die "error in execution $DBIx::SQLCrosstab::errstrn";
}

DBIx::SQLCrosstab::Format is a class descending from DBIx::SQLCrosstab. Being a child class, it inherits its parent methods and can be used in the same way.

In addition, it provides methods to produce formatted output.

XML::DocStats is a Perl module to produce a simple analysis of an XML document.
SYNOPSIS
Analyze the xml document on STDIN, the STDOUT output format is html:
use XML::DocStats;
my $parse = XML::DocStats->new;
$parse->analyze;
Analyze in-memory xml document:
use XML::DocStats;
my ($xmldata) = @_;
my $parse = XML::DocStats->new(xmlsource=>{String => $xmldata},
BYTES => length($xmldata));
$parse->analyze;
Analyze xml document IO stream, the output format is plain text:
use XML::DocStats;
use IO::File;
my $xmlsource = IO::File->new("< document.xml");
my $parse = XML::DocStats->new(xmlsource=>{ByteStream => $xmlsource});
$parse->format(text);
$parse->analyze;
XML::DocStats parses an xml document using a SAX handler built using Ken MacLeods XML::Parser::PerlSAX. It produces a listing indented to show the element heirarchy, and collects counts of various xml components along the way. A summary of the counts is produced following the conclusion of the parse. This is useful to visualize the structure and content of an XML document.
The output listing is either in plain text or html.
Each xml thingy is color-coded in the html output for easy reading:
- purple denotes elements.
- blue denotes text (character data). The text itself is black.
- olive denotes attributes and attribute valuesin elements, XML-DCL, DOCTYPE, and PIs.
- fuchsia denotes entity references. The name of the entity is in black. fuchsia is also used to denote the root element, and to mark the start and finish of the parse, as well as to label the statistices at the end.
- teal denotes the XML declaration.
- navy denotes the DOCTYPE declaration.
- maroon denotes PIs (processing instructions).
- green denotes comments. The text of the comment is black.
- red denotes error messages should the xml fail to be well-formed.

DateTime::Format::Roman is a Perl module with roman day numbering for DateTime objects.

SYNOPSIS

use DateTime::Format::Roman;

my $formatter = DateTime::Format::Roman->new(
pattern => %d %f %b %y );

my $dt = DateTime->new( year => 2003, month => 5, day => 28 );

$formatter->format_datetime($dt);
# 5 Kal Jun 2003

This module formats dates in the Roman style.

The Romans expressed their dates in relation to three fixed dates per month. For example: the Ides of March was the 15th of that month; 14 March was called "2 Ides", 13 March was called "3 Ides", etcetera. The days in the second half of the month were named after the first day of the next month, the "Kalends"; e.g. 16 March was called "17 Kalends of April".

METHODS

new( pattern => $string )

Creates a new formatter object. The optional formatting pattern defines the format of the output of format_datetime(). If no formatting pattern is given, a reasonable default is used.

format_datetime($datetime)

Retruns the formatted string. This method can be called on a formatter object (created by new()), or it can be called as a class method. In the latter case, the default pattern is used.

PATTERN SPECIFIERS

The following specifiers are allowed in the format strings given to the new() method:

%b

The abbreviated month name.

%B

The full month name.

%d

The day of the month as a decimal number (including 1 for the fixed days).

%D

The day of the month, written as a number plus the corresponding fixed day.

%f

The fixed day part of the date.

%m

The month as a decimal number (range 1 to 12).

%y

The year as a decimal number.

If a specifier is preceded by O or o, numbers will be written in uppercase and lowercase Roman numerals, respectively.

The %f specifier accepts an additional argument of 1 digit, specifying the length of the output:

%0f : abbreviated name (e.g. "Kal")
%1f : full name (e.g. "Kalends")
%2f : one-letter abbreviation (e.g. "K")

[COPYRIGHT]

SYNOPSIS

use XML::DOM::Lite qw(Parser XSLT);
$parser = Parser->new( whitespace => strip );
$xsldoc = $parser->parse($xsl);
$xmldoc = $parser->parse($xml);
$output = XSLT->process($xmldoc, $xsldoc);

XML::DOM::Lite is a Lite Pure Perl XML DOM Parser Kit.

SYNOPSIS

# Parser
use XML::DOM::Lite qw(Parser :constants);

$parser = Parser->new( %options );
$doc = Parser->parse($xmlstr);
$doc = Parser->parseFile(/path/to/file.xml);

# strip whitespace (can be about 30% faster)
$doc = Parser->parse($xml, whitespace => strip);


# All Nodes
$copy = $node->cloneNode($deep);
$nodeType = $node->nodeType;
$parent = $node->parentNode;
$name = $node->nodeName;
$xmlstr = $node->xml;
$owner = $node->ownerDocument;

# Element Nodes
$first = $node->firstChild;
$last = $node->lastChild;
$tag = $node->tagName;
$prev = $node->nextSibling;
$next = $node->previousSibling;

$node->setAttribute("foo", $bar);
$foo = $node->getAttribute("foo");
foreach my $attr (@{$node->attributes}) { # attributes as nodelist
# ... do stuff
}
$node->attributes->{foo} = "bar"; # or as hashref (overload)

$liveNodeList = $node->getElementsByTagName("child"); # deep

$node->insertBefore($newchild, $refchild);
$node->replaceChild($newchild, $refchild);


# Text Nodes
$nodeValue = $node->nodeValue;
$node->nodeValue("new text value");

# Processing Instruction Nodes
# CDATA Nodes
# Comments
$data = $node->nodeValue;

# NodeList
$item = $nodeList->item(42);
$index = $nodeList->nodeIndex($node);
$nlist->insertNode($newNode, $index);
$removed = $nlist->removeNode($node);
$length = $nlist->length; # OR scalar(@$nodeList)


# NodeIterator and NodeFilter
use XML::DOM::Lite qw(NodeIterator :constants);

$niter = NodeIterator->new($rootnode, SHOW_ELEMENT, {
acceptNode => sub {
my $n = shift;
if ($n->tagName eq wantme) {
return FILTER_ACCEPT;
} elsif ($n->tagName eq skipme) {
return FILTER_SKIP;
} else {
return FILTER_REJECT;
}
}
);
while (my $n = $niter->nextNode) {
# do stuff
}

# XSLT
use XML::DOM::Lite qw(Parser XSLT);
$parser = Parser->new( whitespace => strip );
$xsldoc = $parser->parse($xsl);
$xmldoc = $parser->parse($xml);
$output = XSLT->process($xmldoc, $xsldoc);


# XPath
use XML::DOM::Lite qw(XPath);
$result = XPath->evaluate(/path/to/*[@attr="value"], $contextNode);


# Document
$rootnode = $doc->documentElement;
$nodeWithId = $doc->getElementById("my_node_id");
$textnode = $doc->createTextNode("some text string");
$element = $doc->createElement("myTagName");
$docfrag = $doc->createDocumentFragment();
$xmlstr = $doc->xml;
$nlist = $doc->selectNodes(/xpath/expression);
$node = $doc->selectSingleNode(/xpath/expression);


# Serializer
use XML::DOM::Lite qw(Serializer);

$serializer = Serializer->new;
$xmlout = $serializer->serializeToString($node);

XML::DifferenceMarkup is a XML diff and merge.

SYNOPSIS

use XML::DifferenceMarkup qw(make_diff);

$parser = XML::LibXML->new();
$parser->keep_blanks(0);
$d1 = $parser->parse_file($fname1);
$d2 = $parser->parse_file($fname2);

$dom = make_diff($d1, $d2);
print $dom->toString(1);

This module implements an XML diff producing XML output. Both input and output are DOM documents, as implemented by XML::LibXML.

The diff format used by XML::DifferenceMarkup is meant to be human-readable (i.e. simple, as opposed to short) - basically the diff is a subset of the input trees, annotated with instruction element nodes specifying how to convert the source tree to the target by inserting and deleting nodes. To prevent name colisions with input trees, all added elements are in a namespace http://www.locus.cz/diffmark (the diff will fail on input trees which already use that namespace).

TagSoup is a SAX2 parser written in Java that, instead of parsing well-formed or valid XML. Tag Soup parses HTML as it is found in the wild: nasty and brutish, though quite often far from short.

By providing a SAX interface, it allows standard XML tools to be applied to even the worst HTML. It is a parser, not a whole application; it isnt intended to permanently clean up bad HTML, as HTML Tidy does, only to parse it on the fly.

The following options are understood:

--files
Output into individual files, with html extensions changed to xhtml. Otherwise, all output is sent to the standard output.
--html
Output is in clean HTML: the XML declaration is suppressed, as are end-tags for the known empty elements.
--omit-xml-declaration
The XML declaration is suppressed.
--method=html
End-tags for the known empty HTML elements are suppressed.
--pyx
Output is in PYX format.
--pyxin
Input is in PYXoid format (need not be well-formed).
--nons
Namespaces are suppressed. Normally, all elements are in the XHTML 1.x namespace, and all attributes are in no namespace.
--nobogons
Bogons (unknown elements) are suppressed. Normally, they are treated as empty.
--nodefaults
suppress default attribute values
--nocolons
change explicit colons in element and attribute names to underscores
--norestart
dont restart any normally restartable elements
--any
Bogons are given a content model of ANY rather than EMPTY.
--lexical
Pass through HTML comments. Has no effect when output is in PYX format.
--reuse
Reuse a single instance of TagSoup parser throughout. Normally, a new one is instantiated for each input file.
--nocdata
Change the content models of the script and style elements to treat them as ordinary #PCDATA (text-only) elements, as in XHTML, rather than with the special CDATA content model.
--encoding=encoding
Specify the input encoding. The default is the Java platform default.
--help
Print help.
--version
Print the version number.