Implementation as DOM
/*--
Copyright 2000 Elliotte Rusty Harold.
All rights reserved.
I haven't yet decided on a license.
It will be some form of open source.
THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL ELLIOTTE RUSTY HAROLD OR ANY
OTHER CONTRIBUTORS TO THIS PACKAGE
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
*/
package com.macfaq.xml;
import java.net.URL;
import java.net.MalformedURLException;
import java.util.Stack;
import org.xml.sax.SAXException;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedInputStream;
import java.io.InputStream;
import org.w3c.dom.Element;
import org.w3c.dom.Document;
import org.w3c.dom.Attr;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.DocumentType;
import org.w3c.dom.DOMImplementation;
import org.apache.xerces.parsers.DOMParser;
import org.apache.xml.serialize.OutputFormat;
import org.apache.xml.serialize.XMLSerializer;
/**
* <p><code>DOMXIncluder</code> provides methods to
* resolve DOM elements and documents to produce
* a new <code>Document</code> or <code>Element</code> with all
* XInclude references resolved.
* </p>
*
*
* @author Elliotte Rusty Harold
* @version 1.0d1
*/
public class DOMXIncluder {
public final static String XINCLUDE_NAMESPACE
= "http://www.w3.org/1999/XML/xinclude";
// No instances allowed
private DOMXIncluder() {}
private static DOMParser parser = new DOMParser();
/**
* <p>
* This method resolves a DOM <code>Document</code>
* and merges in all XInclude references.
* If a referenced document cannot be found it is replaced with
* an error message. The <code>Document</code>
* object returned is a new document.
* The original <code>Document</code> object is not changed.
* </p>
*
* @param original <code>Document</code> that will be processed
* @param base <code>String</code> form of the base URI against which
* relative URLs will be resolved. This can be null if the
* document includes an <code>xml:base</code> attribute.
* @return Document new <code>Document</code> object in which all
* XInclude elements have been replaced.
* @throws CircularIncludeException if this document possesses a cycle of
* XIncludes.
* @throws NullPointerException if the original argument is null.
*/
public static Document resolve(Document original, String base)
throws CircularIncludeException, NullPointerException {
if (original == null) {
throw new NullPointerException("Document must not be null");
}
Element root = original.getDocumentElement();
// catch a ClassCastException if a Text is returned????
// Is the root element allowed to be replaced by
// an parse="text"
DOMImplementation impl = original.getImplementation();
DocumentType oldDoctype = original.getDoctype();
DocumentType newDoctype = impl.createDocumentType(
oldDoctype.getName(),
oldDoctype.getPublicId(),
oldDoctype.getSystemId());
Document resultDocument
= impl.createDocument(root.getNamespaceURI(),
root.getTagName(),
newDoctype);
// check that tag name is qualified name
NodeList children = original.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node n = children.item(i);
if (n instanceof Element) { // root element
resultDocument.replaceChild(
resolve(root, base, resultDocument),
resultDocument.getDocumentElement()
);
}
else if (n instanceof DocumentType) {
// skip it, already cloned
}
else {
resultDocument.appendChild(n.cloneNode(true));
}
}
return resultDocument;
}
/**
* <p>
* This method resolves a DOM <code>Element</code>
* and merges in all XInclude references. This process is recursive.
* The element returned contains no XInclude elements.
* If a referenced document cannot be found it is replaced with
* an error message. The <code>Element</code> object returned is a new element.
* The original <code>Element</code> is not changed.
* </p>
*
* @param original <code>Element</code> that will be processed
* @param base <code>String</code> form of the base URI against which
* relative URLs will be resolved. This can be null if the
* element includes an <code>xml:base</code> attribute.
* @param resolved <code>Document</code> into which the resolved element will be placed.
* @return Node Either an <code>Element</code>
* (<code>parse="text"</code>) or a <code>Text</code>
* (<code>parse="xml"</code>)
* @throws CircularIncludeException if this <code>Element</code> contains an XInclude element
* that attempts to include a document in which
* this element is directly or indirectly included.
* @throws NullPointerException if the original argument is null.
*/
public static Node resolve(Element original, String base, Document resolved)
throws CircularIncludeException, NullPointerException {
if (original == null) {
throw new NullPointerException(
"You can't XInclude a null element."
);
}
Stack bases = new Stack();
if (base != null) bases.push(base);
Node result = resolve(original, bases, resolved);
bases.pop();
return result;
}
private static boolean isIncludeElement(Element element) {
if (element.getLocalName().equals("include") &&
element.getNamespaceURI().equals(XINCLUDE_NAMESPACE)) {
return true;
}
return false;
}
/**
* <p>
* This method resolves a DOM <code>Element</code>
* and merges in all XInclude references. This process is recursive.
* The element returned contains no XInclude elements.
* If a referenced document cannot be found it is replaced with
* an error message. The <code>Element</code> object returned is a new element.
* The original <code>Element</code> is not changed.
* </p>
*
* @param original <code>Element</code> that will be processed
* @param bases <code>Stack</code> containing the string forms of
* all the URIs of doucments which contain this element
* through XIncludes. This used to detect if a circular
* reference is being used.
* @param resolved <code>Document</code> into which the resolved element will be placed.
* @return Node Either an <code>Element</code>
* (<code>parse="text"</code>) or a <code>String</code>
* (<code>parse="xml"</code>)
* @throws CircularIncludeException if this <code>Element</code> contains an XInclude element
* that attempts to include a document in which
* this element is directly or indirectly included.
* @throws IllegalArgumentException if the href attribute is missing from an include element.
*/
private static Node resolve(Element original, Stack bases, Document resolved)
throws CircularIncludeException, IllegalArgumentException {
Element result;
String base = "";
if (bases.size() != 0) base = (String) bases.peek();
if (isIncludeElement(original)) {
String href = original.getAttribute("href");
if (href == null || href.equals("")) { // illegal, what kind of exception????
throw new IllegalArgumentException("Missing href attribute");
}
String baseAttribute
= original.getAttributeNS("http://www.w3.org/XML/1998/namespace", "base");
if (base != null && !base.equals("")) {
base = baseAttribute;
}
boolean parse = true;
String parseAttribute = original.getAttribute("parse");
if (parseAttribute != null && parseAttribute.equals("text")) {
parse = false;
}
String remote;
if (base != null) {
try {
URL context = new URL(base);
URL u = new URL(context, href);
remote = u.toExternalForm();
}
catch (MalformedURLException ex) {
return resolved.createTextNode("Unresolvable URL "
+ base + "/" + href);
}
}
else {
remote = href;
}
if (parse) {
// checks for equality (OK) or identity (not OK)????
if (bases.contains(remote)) {
// need to figure out how to get file and number where
// bad include occurs
throw new CircularIncludeException(
"Circular XInclude Reference to "
+ remote + " in " );
}
try {
parser.parse(remote);
Document doc = parser.getDocument();
bases.push(remote);
result = (Element) resolve(doc.getDocumentElement(), bases, resolved);
bases.pop();
}
// Make this configurable
catch (SAXException e) {
return resolved.createTextNode("Document "
+ remote + " is not well-formed.\r\n" + e.getMessage());
}
catch (IOException e) {
return resolved.createTextNode("Document not found: "
+ remote + "\r\n" + e.getMessage());
}
}
else { // insert text
String s = downloadTextDocument(remote);
return resolved.createTextNode(s);
}
}
// not an include element
else { // recursively process children
// still need to adjust bases here????
result = (Element) resolved.importNode(original, false);
NodeList children = original.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node n = children.item(i);
if (n instanceof Element) {
Element e = (Element) n;
result.appendChild(resolve(e, bases, resolved));
}
else {
result.appendChild(resolved.importNode(n,true));
}
}
}
return result;
}
/**
* <p>
* This utility method reads a document at a specified URL
* and returns the contents of that document as a <code>Text</code>.
* It's used to include files with <code>parse="text"</code>
* </p>
*
* <p>
* If the document cannot be located due to an IOException,
* then an error message string is returned. I'm not yet convinced this
* is the right behavior. Perhaps I should pass on the exception?
* </p>
*
* @param url URL of the doucment that will be stored in
* <code>String</code>.
* @return Text The document retrieved from the source <code>URL</code>
* or an error message if the document can't be retrieved.
* Note: throwing an exception might be better here. I should
* at least allow the setting of the eror message.
*/
public static String downloadTextDocument(String url) {
URL source;
try {
source = new URL(url);
}
catch (MalformedURLException ex) {
return "Unresolvable URL " + url;
}
StringBuffer s = new StringBuffer();
try {
InputStream in = new BufferedInputStream(source.openStream());
// does XInclude give you anything to specify the character set????
InputStreamReader reader = new InputStreamReader(in, "8859_1");
int c;
while ((c = in.read()) != -1) {
if (c == '<') s.append("<");
else if (c == '&') s.append("&");
else s.append((char) c);
}
return s.toString();
}
catch (IOException e) {
return "Document not found: " + source.toExternalForm();
}
}
/**
* <p>
* The driver method for the XIncluder program.
* I'll probably move this to a separate class soon.
* </p>
*
* @param args <code>args[0]</code> contains the URL or file name
* of the document to be procesed.
*/
public static void main(String[] args) {
DOMParser parser = new DOMParser();
XMLSerializer outputter = new XMLSerializer();
for (int i = 0; i < args.length; i++) {
try {
parser.parse(args[i]);
Document input = parser.getDocument();
// absolutize URL
String base = args[i];
if (base.indexOf(':') < 0) {
File f = new File(base);
base = f.toURL().toExternalForm();
}
Document output = resolve(input, base);
// need to set encoding on this to Latin-1 and check what
// happens to UTF-8 curly quotes
OutputFormat format = new OutputFormat("XML", "ISO-8859-1", false);
format.setPreserveSpace(true);
XMLSerializer serializer
= new XMLSerializer(System.out, format);
serializer.serialize(output);
}
catch (Exception e) {
System.err.println(e);
e.printStackTrace();
}
}
}
}