Free xslt software for linux

mod-xslt is an Apache module that converts XML files into HTML files using XSLT stylesheets. It was written to overcome most of the limits of similar modules and uses a standard API, which could easily be used for other applications or to support more servers.
It is able to parse dynamically generated documents, both in POST and GET requests, includes a fully featured language to choose the stylesheet to load from both configuration files and from .xml files, and allows stylesheets to access server variables. It supports redirects, dynamically generated stylesheets, and both Apache 1 and 2.
Enhancements:
- configure, configure.ac - updated automatically by release scripts, in order to prepare a snapshot.

[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);

Sablotron is a fast, compact and portable XML toolkit implementing XSLT 1.0, DOM Level2 and XPath 1.0. Sablotron is an open project; other users and developers are encouraged to use it or to help us testing or improving it.

Sablotron is written in C++ and we try to keep it as portable as possible. Click here here to see Sablotron cross-reference sources. We compile Sablotron on Linux (using g++) and Windows 2000 (using MS Visual C++).

GA does not directly support other platforms but as far as we know, it runs on Solaris, FreeBSD, OpenBSD, HP-UX, Irix and all Win32 systems. It should be possible to port Sablotron on other systems as well. In the event you run any other port of Sablotron, please let us know.

svn2cl is an xsl stylesheet for generating a clasic GNU-style ChangeLog from a subversion repository log. svn2cl is made from several changelog-like scripts using common xslt constructs found in different places. This is just my implementation.
I made it because it was the only thing that I missed from cvs after I converted a repository to subversion. I used cvs2cl before.
Installation:
Just unpack the tarball in some directory (e.g. /opt/svn2cl-0.3) and symlink the svn2cl.sh script in your path somewhere (e.g. ln -s /opt/svn2cl-0.3/svn2cl.sh /usr/local/bin/svn2cl).
Note: Be sure to keep the svn2cl.xsl file in the same directory as the svn2cl.sh script as the script looks for it there (symlinking is ok).
Enhancements:
- The implementation of a new option to ignore log messages that start with a specific text and change to ignore paths from outside of the directory where svn2cl is run.

XmlAutoIndex (xai) is a module for Apache written in perl that browses your directories and outputs it into Xml.

The aim of this project is to replace mod_autoindex in Apache:
I would like to separate data from design, that is why I have made a xml output.

After that, using Xslt you can translate it into Html, Svg or Xul for example (you can make your own theme by updating xsl style sheet and with never touching the core engine).

Each plugins are indepentant and are here to generate thumbnails, previews, etc... Each previews, meta-data are cached in a cache directory to accelerate http queries. bonus: I have included in engine a handler that allows you to add comments per file, this behaviour does not require SQL server because comments are saved in files caches meta-data.

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);

mod_xml is an XML applications development environment for Apache 2.0. mod_xmls primary purpose is to provide a powerful, full-featured opensource platform for Webservices and XML applications.
Written in C (and possibly C++, depending on the XML library used) and fully integrated into Apache, it should present a leaner, meaner system and a far lower overhead than the heavyweight alternatives that have traditionally dominated this market.
It comprises three main components:
- Main Handler: SAX and DOM APIs for applications development
- Input filter: convert request data to XML, with additional options to encapsulate HTTP headers (XMTP) and CGI vars.
- XSLT output filter for dynamic publishing.
XML Platform
mod_xml requires an XML implementation, to support the required XML and XSLT technologies. The XML implementations currently provided are:
- apache, using Xerces-C and Xalan-C
- gnome, using libxml2 and libxslt
So you will need to have either Xalan/Xerces or libxml2/libxslt installed before you can build mod_xml. Applications using the SAX or DOM should use the same XML libraries that were used to build the module. Applications using only XSLT can use any XML implementation.
Other XML implementations, such as expat+sablot, may be supported as and when resources permit.