/*
* Copyright 2013, The Sporting Exchange Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.betfair.cougar.codegen.resolver;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.plugin.logging.SystemStreamLog;
import org.apache.xerces.dom.DOMInputImpl;
import org.apache.xerces.util.XMLCatalogResolver;
import org.w3c.dom.ls.LSInput;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import com.betfair.cougar.codegen.except.PluginException;
import com.betfair.cougar.codegen.resource.ResourceLoader;
/**
* Our own custom resolver which knows to go looking for include files (*.inc) as resources, if
* a flag is set.
* <p>
* Note that this overrides {@link XMLCatalogResolver} and that we still (for now) rely on the
* older catalog functionality to work with the underlying schemas. We should be able to extend
* this resolver to locate those schemas (as resources), and move away from the write-to-disk-
* and-catalog functionality completely. TODO
*/
public class InterceptingResolver extends XMLCatalogResolver {
private final Log log;
/**
* The resource loader can find resources in places a plain ClassLoader couldn't
*/
private final ResourceLoader resourceLoader;
public InterceptingResolver() {
this(new SystemStreamLog(), null, new String[0]);
}
/**
* @param log mojo logger
* @param resourceLoader finds resources. If null, means should be used (ie. don't do
* resource-based loading)
* @param catalogs catalogs to be used by underlying resolver
*/
public InterceptingResolver(Log log, ResourceLoader resourceLoader, String[] catalogs) {
super(catalogs);
for (String f : catalogs) {
if (!new File(f).exists()) {
throw new PluginException("Given nonexistent catalog: " + f);
}
}
this.log = log;
this.resourceLoader = resourceLoader;
}
@Override
public InputSource resolveEntity (
String name,
String publicId,
String baseURI,
String systemId)
throws SAXException, IOException {
try {
if (shouldLoadAsResource(systemId)) {
log.debug("Loading entity '" + systemId + "' as resource");
return resourceToInputSource(publicId, systemId);
}
else {
return super.resolveEntity(publicId, systemId);
}
}
catch (Exception e) {
// not in spec but too bad
throw new PluginException("Error resolving entity: " + systemId + ": " + e, e);
}
}
@Override
public LSInput resolveResource(
String type,
String namespaceURI,
String publicId,
String systemId,
String baseURI) {
try {
if (shouldLoadAsResource(systemId)) {
log.debug("Loading resource '" + systemId + "' as resource");
return resourceToLSInput(publicId, systemId);
}
else {
return super.resolveResource(type, namespaceURI, publicId, systemId, baseURI);
}
}
catch (Exception e) {
// this is cheating, the spec says allow for an exception, but we don't care
throw new PluginException("Error resolving resource: " + systemId + ": " + e, e);
}
}
private InputStream resourceAsStream(String systemId) {
String resource = resourceFromId(systemId);
InputStream is = resourceLoader.getResourceAsStream(resource);
if (is == null) {
// worth logging since we might otherwise miss this
log.warn("Resource '" + resource + "' not found.");
}
return is;
}
private String resourceFromId(String systemId) {
int endPos = systemId.lastIndexOf('/');
return endPos > 0 ? systemId.substring(endPos) : systemId;
}
private InputSource resourceToInputSource(String publicId, String systemId) {
InputStream is = resourceAsStream(systemId);
if (is != null) {
InputSource s = new InputSource(is);
s.setPublicId(publicId);
s.setSystemId(systemId);
return s;
}
else {
return null;
}
}
private LSInput resourceToLSInput(String publicId, String systemId) {
InputStream is = resourceAsStream(systemId);
if (is != null) {
DOMInputImpl result = new DOMInputImpl(); // any old impl would do
result.setByteStream(is);
result.setCharacterStream(null);
result.setPublicId(publicId);
result.setSystemId(systemId);
return result;
}
else {
return null;
}
}
private boolean shouldLoadAsResource(String systemId) {
return (resourceLoader != null) && systemId != null && systemId.endsWith(".inc");
}
}