root/src/jomdoc/trunk/src/jomdoc/org/omdoc/jomdoc/util/resolver/AbstractJOMDocURIResolver.java

/*
 * JOMDoc - A Java library for OMDoc documents (http://omdoc.org/jomdoc).
 *
 * Original author    Dimitar Misev <d.misev@jacobs-university.de>
 * Web                http://kwarc.info/dmisev/
 * Created            Feb 5, 2010, 4:19:28 PM
 *
 * Filename           $Id$
 * Revision           $Revision$
 * Last modified on   $Date$
 *               by   $Author$
 *
 * Copyright (C) 2007,2008 the KWARC group (http://kwarc.info)
 * Licensed under the GNU Public License v3 (GPL3).
 * For other licensing contact Michael Kohlhase <m.kohlhase@jacobs-university.de>
 */
package org.omdoc.jomdoc.util.resolver;

import com.thaiopensource.validation.LSInputImpl;
import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import javax.xml.transform.Source;
import javax.xml.transform.TransformerException;
import javax.xml.transform.stream.StreamSource;
import nu.xom.Document;
import nu.xom.Element;
import org.apache.log4j.Logger;
import org.omdoc.jomdoc.lang.OMDocDocument;
import org.omdoc.jomdoc.lang.OMDocElement;
import org.omdoc.jomdoc.parser.Parser;
import org.omdoc.jomdoc.util.err.ErrorUtil;
import org.omdoc.jomdoc.util.etc.IOUtil;
import org.omdoc.jomdoc.util.etc.Log;
import org.omdoc.jomdoc.util.types.Pair;
import org.omdoc.jomdoc.util.xml.RelaxNGValidator;
import org.omdoc.jomdoc.util.xml.XMLUtil;
import org.omdoc.jomdoc.util.xml.XSLTUtil;
import org.w3c.dom.ls.LSInput;

/**
 * This is a default implementation of {@link JOMDocURIResolver}. Users that want
 * to use their own URIResolver in JOMDoc will typically extend from this class,
 * specifying supported URI schemes with {@link #AbstractJOMDocURIResolver(String[])}.
 * <p>
 * 
 * @author <a href="mailto:d.misev@jacobs-university.de">Dimitar Misev</a>
 */
public abstract class AbstractJOMDocURIResolver implements JOMDocURIResolver {

    static Logger log = Logger.getLogger(AbstractJOMDocURIResolver.class);

    protected Set<String> supportedSchemas;

    protected AbstractJOMDocURIResolver(String... supportedSchemas) {
        if (supportedSchemas == null) {
            throw new IllegalArgumentException("A resolver must support at least one scheme");
        }
        this.supportedSchemas = new HashSet<String>();
        this.supportedSchemas.addAll(Arrays.asList(supportedSchemas));
    }

    public Source resolve(String href, String base) throws TransformerException {
        if (!isSchemaSupported(href, base, true)) {
            return null;
        }
        Pair<? extends InputStream, URI> p = null;
        try {
             p = resolveInputStream(href, base);
        } catch (ResolveException ex) {
            log.warn(Log.array("Error resolving resource during transformation: " + href, ErrorUtil.errorMessage(ex)));
        }
        if (p != null && p.fst != null && p.snd != null) {
            return new StreamSource(p.fst, p.snd.toString());
        } else {
            return null;
        }
    }

    public Element resolveElement(String href, String base) throws ResolveException {
        Pair<String, String> p = URIUtil.splitURI(href);
        Document doc = resolveDocument(p.fst, base);
        if (doc == null) {
            return null;
        }
        Element root = doc.getRootElement();
        if (p.snd == null) {
            return root;
        } else {
            return XMLUtil.childWithId(root, p.snd);
        }
    }

    public final OMDocDocument resolveOMDocDocument(String href, String base) throws ResolveException {
        Document doc = resolveDocument(href, base);
        if (doc == null) {
            return null;
        }
        try {
            return Parser.parse(doc);
        } catch (URISyntaxException ex) {
            throw new ResolveException(ex);
        } catch (Exception ex) {
            throw new ResolveException("Error parsing XOM Document to OMDocDocument.", ex);
        }
    }

    public final OMDocElement resolveOMDocElement(String href, String base) throws ResolveException {
        Element e = resolveElement(href, base);
        if (e == null) {
            return null;
        }
        try {
            return (OMDocElement) Parser.parse(e);
        } catch (URISyntaxException ex) {
            throw new ResolveException(ex);
        } catch (Exception ex) {
            throw new ResolveException("Error parsing XOM Element to OMDocElement.", ex);
        }
    }

    public LSInput resolveResource(String type, String namespaceURI, String publicId, String systemId, String baseURI) {
        LSInput ret = new LSInputImpl();
        ret.setPublicId(publicId);
        try {
            // resolve with default
            InputStream is = RelaxNGValidator.class.getClassLoader().getResourceAsStream(RelaxNGValidator.SCHEMA_DIR + systemId);
            ret.setSystemId(systemId);
            if (is == null) {
                // if it fails use resolveInputStream
                Pair<? extends InputStream, URI> res = null;
                if (baseURI != null && (!baseURI.contains(":") || !isSchemaSupported(baseURI))) {
                    baseURI = "file:" + baseURI;
                }
                res = resolveInputStream(systemId, baseURI);
                if (res == null) {
                    return ret;
                }
                is = res.fst;
                if (res.snd != null) {
                    ret.setBaseURI(res.snd.toString());
                    // the scheme must be removed, doesn't work otherwise
                    ret.setSystemId(IOUtil.removeScheme(res.snd.toString()));
                }
            }
            ret.setByteStream(is);
        } catch (Exception ex) {
            log.warn(Log.array("Resolve error in RelaxNG validation", ex));
        }
        return ret;
    }

    public boolean isSchemaSupported(String uri) {
        String schema = IOUtil.getScheme(uri);
        if (schema == null) {
            return false;
        }
        return supportedSchemas.contains(schema);
    }

    public boolean isSchemaSupported(String href, String base, boolean print) {
        URI absURI = null;
        try {
            absURI = URIUtil.toAbsoluteURI(href, base);
        } catch (ResolveException e) {
            log.warn(String.format("Exception while resolving href %s against base $b", href, base));
            return false;
        }
        return isSchemaSupported(absURI.toString());

//        if (base != null)
//            if (!isSchemaSupported(base)) {
//                if (print) {
//                    log.warn(Log.array("URI schema of " + base + "\nis not supported by this URI resolver"));
//                }
//                return false;
//            } else {
//                return true;
//            }
//        if (!isSchemaSupported(href)) {
//            if (print) {
//                log.warn(Log.array("URI schema of " + href + "\nis not supported by this URI resolver"));
//            }
//            return false;
//        }
//        return true;
    }
}