The repository can be browsed and you can grab your own working copy over HTTP using

  bzr branch http://jezuk.dnsalias.net/arabica-bzr/trunk

• Tar.bz2 bundle
• Tar.gz bundle
• Zip bundle

What I'd said, in a rather long winded and rambling way, was that import precedence is now works correctly for all cases, not just mainly implemented for the common cases, a couple of nagging little bits got sorted out, and over the past few weeks I've implemented xsl:key and key(). As many times before, James Clark's concise and subtle spec text has been a pleasure to work with, and I've surprised myself with how easily I've been able to implement a feature. I've been working with this code for a long time now, but it really is holding up.

Although it's not done yet, it might well be done enough. I'm using the OASIS XSLT test suite to help drive development, and so it also provides a measure of how much has been done, what's working and what isn't. The results are published here, but all the code and test data is included in the download. The executive summary is the core stuff that you use every day works, but some of the bits round the edges (edges defined by my experience, anyway) are missing.

To my knowledge there's nothing that causes Mangle to crash, and anything that I haven't yet implemented generates a warning when the stylesheet is compiled.

Give it a go. It might do what you need.

Failures in any other tests are, however, indicative of a problem that needs investigating.

Source tar.bz2
http://downloads.sourceforge.net/arabica/arabica-2008-october.tar.bz2

Source tar.gz
http://downloads.sourceforge.net/arabica/arabica-2008-october.tar.gz

Source zip
http://downloads.sourceforge.net/arabica/arabica-2008-october.zip

Exciting New Stuff

The exciting new stuff is Taggle, a port of John Cowan's rather super TagSoup package.

TagSoup, if you're not familiar with it, is

a SAX-compliant parser written in Java that, instead of parsing well-formed or valid XML, parses HTML as it is found in the wild: poor, nasty and brutish, though quite often far from short. TagSoup is designed for people who have to process this stuff using some semblance of a rational application design. By providing a SAX interface, it allows standard XML tools to be applied to even the worst HTML.

Cowan describes what TagSoup does as

TagSoup is designed as a parser, not a whole application; it isn't intended to permanently clean up bad HTML, as HTML Tidy does, only to parse it on the fly. Therefore, it does not convert presentation HTML to CSS or anything similar. It does guarantee well-structured results: tags will wind up properly nested, default attributes will appear appropriately, and so on.

The semantics of TagSoup are as far as practical those of actual HTML browsers. In particular, never, never will it throw any sort of syntax error: the TagSoup motto is "Just Keep On Truckin'". But there's much, much more. For example, if the first tag is LI, it will supply the application with enclosing HTML, BODY, and UL tags. Why UL? Because that's what browsers assume in this situation. For the same reason, overlapping tags are correctly restarted whenever possible: text like:

This is <B>bold, <I>bold italic, </b>italic, </i>normal text
gets correctly rewritten as:

This is <b>bold, <i>bold italic, </i></b><i>italic, </i>normal text.

Arabica Taggle chews through HTML, providing the same SAX XMLReader interface as the XML parser, and can be used in exactly the same way. HTML source can be fed through SAX filter stacks, used to build DOM trees, queried with XPath, or transformed using XSLT.

Changes and Bug Fixes

There are, of course, many other fixes and changes. Most are relatively minor, and if you haven't been bitten by them you won't notice. The most significant changes are in Arabica's XSLT engine, Mangle. While still not feature complete and under development, it takes, in this release, a fairly big step forward.

SAX

• Fixed AttributesImpl.getIndex. Thanks to Isak Johnsson for that, and what on earth was I thinking to me
• Return attribute type as "CDATA" not the empty string
• After all this time, realised I had too many template parameters on XMLReaderInterface. It only needs the string_type and string_adaptor. Any addition parameters are only of interest the implementing parser class

DOM

• Output DocumentFragment properly
• Output <elem/> for empty elements
• Slipped a TextCoalescer filter into the DOM builder, so that consecutive bits of text get applied to a single Text or CDATA node, rather than as a series of nodes. (A series of nodes is perfectly legal, it's just slightly unexpected. Even to me, and I work with DOMs a lot :)

XPath

• Some time ago, it was gently suggested to me that XPathValuePtr and XPathExpressionPtr both exposed implementation details and provided an interface that was inconsistent with the DOM classes, because you accessed the member functions via -> rather than . At the time, I was just pleased to have got the XPath stuff done and wasn't really fussed, so I left it. Since then though, it's niggled and niggled away at the back of my mind and now I've done something about it. XPathValuePtr has become XPathValue and XPathExpressionPtr has become XPathExpression, with the member functions accessed through the . operator. The XPathValuePtr and XPathExpressionPtr name and -> member access are retained for the meantime, so that existing code won't be broken. Existing code using XPathValuePtr will still work, but new stuff should use XPathValue
• Correctly implemented Namespace Nodes. The XPath data model requires that namespace nodes are associated with an element, and sort ahead of attribute nodes in document order. Until now, Arabica's namespace node had no parent, or owner document and so was failing these requirements
• The default namespace is included when constructing namespace nodes
• Amazingly, the XPath prefix:* didn't compile. I had no test for it, and had overlooked it. Now I do, and it isn't
• Unbound namespace prefixes throw an exception
• Corrected text() test to match CDATA nodes as well as text nodes
• XPaths are now evaluated as if the DOM had been normalised, even if it hasn't. That is, consecutive text nodes are treated as a single node

XSLT

• Params are not passed on through an xsl:apply-imports call
• Template names are now QNames
• Template mode is now QName
• In XPath node() matches any node of any type. In an XSLT match pattern, node() matches everything except attributes and the document root node. Fixed.
• Fixed variable scoping in xsl:for-each, xsl:if, and xsl:choose
• Escape naughty text when outputting processing instructions and comments (eg ---)
• Use std::stable_sort instead of std::sort. When xsl:sort specifies a numerical sort, but you've got some string data in there we need to maintain the relative positions of that string data. This is the first time I can recall actually using std::stable_sort. I will mark it down in my big book of programming accomplishments.
• Fixed local-name for namespace nodes
• xsl:message can contain another xsl:message - now handled properly
• Empty comments output correctly
• Ensure xsl:choose has at lease one xsl:when
• Make sure any xsl:template mode attribute is not empty
• Verify xsl:sort attribute values
• xsl:call-template now throws if it can't find a matching template
• Duplicate variable and parameter names are rejected
• Disallowed current() in match patterns
• Verify xsl:for-each selects a node-set
• Disallow pcdata ahead of an xsl:param
• xsl:stylesheet now allows top-level elements when they are in a foreign namespace
• Implemented position(), last() and positional predicates in match patterns
• Throw error if transform is run with no input
• Verify QNames at transform compile time
• Detect circular variable references
• Reject variables and parameters which have both a select attribute and text content
• Top level variables and parameters handled according to import precedence
• Fixed internal QName resolution - unprefixed names are not in the default namespace
• Fixed xsl:element unprefixed names - when no namespace uri is supplied are in the default namespace
• Don't suppress output of element namespace prefixes or attributes which are in the XSL namespace
• ensure @xmlns|@xsmlns:* selects no nodes
• direct information messages to std::cerr, not std::cout

Build and installation

• Fix for problem installing headers on FreeBSD, where install doesn't understand -D
• Changes to help out-of-tree builds
• Added build files for Visual Studio 2008
• Added configure tests for std::mbstate_t and/or mbstate_t. Some platforms don't have it (VxWorks, for example)
• Visual Studio 2005 and 2003 project files are now munged from the Visual Studio 2008 files. (Don't try this at home, folks)

Other bits and bobs

• Fixed for base URIs with leading ../
• Convert \ to / for relative paths as well as absolute Windows paths.

There really is a release coming now, because I'm cutting it now. The source bundles will probably go are up on Sourceforge this evening now, and tagged in subversion. Release notes should follow later this weekend or early next week. I'll write up the niggly thing too, because it's quite a nice one.

The last release was just over a year ago. That's probably a bit too long.

If you can't wait, there's always the subversion repository. ]]> http://www.jezuk.co.uk/arabica/log?id=3824After a bit of break, I've spent time hacking on Arabica again, which has been lovely. It's really rather relaxing to just nurdle around in your own code, without any particular pressure or need. My normal way of working on Arabica's XSLT processor is to run some of the test suite, pick a failing case, and fix it. If I can get a few more tests passing in half an hour or an hour, and I generally can, then that's a little step further along.

In this latest little bit of activity, I've been focussing on variables and variable resolution. I've fixed various problem with circular references, scoping, namespace resolution, and what I thought was going to be a thorny problem with import precedence.

What constantly surprises me is how straightforward most of these problems are, requiring only a few lines of code. In fact this has been the story of Arabica's XSLT development. Once the initial development push was done, almost all the rest has been a few lines here, a few lines there. I've been working away on this now for coming up three years, on and off and with digressions, and have no idea when I'll be done, but I that doesn't bother me at all. It's like an old pair of slippers, or favourite woolly jumper. It's a comfortable, gentle thing to slip into and go for a stroll in every now and again.