| /** |
| * |
| * Copyright 2003-2005 The Apache Software Foundation |
| * |
| * 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 org.apache.xmlbeans.maven; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.net.URL; |
| import java.net.URLClassLoader; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.StringTokenizer; |
| |
| import org.apache.maven.project.Resource; |
| import org.apache.xml.resolver.CatalogManager; |
| import org.apache.xml.resolver.tools.CatalogResolver; |
| import org.apache.xmlbeans.impl.tool.SchemaCompiler; |
| import org.xml.sax.EntityResolver; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.SAXException; |
| |
| |
| /** |
| * |
| * |
| * @version $Rev: 46019 $ $Date: 2004-09-14 02:56:06 -0700 (Tue, 14 Sep 2004) $ |
| * |
| * */ |
| public class SchemaCompilerWrapper { |
| |
| private String sourceDir; |
| private String sourceSchemas; |
| private String xmlConfigs; |
| private String javaTargetDir; |
| private String classTargetDir; |
| private String catalogLocation; |
| private String classPath; |
| private List resources; |
| private boolean buildSchemas; |
| //this copy should not end in / |
| private String baseSchemaLocation = "schemaorg_apache_xmlbeans/src"; |
| |
| public String getSourceDir() { |
| return sourceDir; |
| } |
| |
| public void setSourceDir(String sourceDir) { |
| this.sourceDir = sourceDir; |
| } |
| |
| public String getSourceSchemas() { |
| return sourceSchemas; |
| } |
| |
| public void setSourceSchemas(String sourceSchemas) { |
| this.sourceSchemas = sourceSchemas; |
| } |
| |
| public String getXmlConfigs() { |
| return xmlConfigs; |
| } |
| |
| public void setXmlConfigs(String xmlConfigs) { |
| this.xmlConfigs = xmlConfigs; |
| } |
| |
| public String getJavaTargetDir() { |
| return javaTargetDir; |
| } |
| |
| public void setJavaTargetDir(String javaTargetDir) { |
| this.javaTargetDir = javaTargetDir; |
| } |
| |
| public String getClassTargetDir() { |
| return classTargetDir; |
| } |
| |
| public void setClassTargetDir(String classTargetDir) { |
| this.classTargetDir = classTargetDir; |
| } |
| |
| public String getCatalogLocation() { |
| return catalogLocation; |
| } |
| |
| public void setCatalogLocation(String catalogLocation) { |
| this.catalogLocation = catalogLocation; |
| } |
| |
| public String getClassPath() { |
| return classPath; |
| } |
| |
| public void setClassPath(String classPath) { |
| this.classPath = classPath; |
| } |
| |
| public List getResources() { |
| return resources; |
| } |
| |
| public void setResources(List resources) { |
| this.resources = resources; |
| } |
| |
| public boolean isBuildSchemas() { |
| return buildSchemas; |
| } |
| |
| public void setBuildSchemas(boolean buildSchemas) { |
| this.buildSchemas = buildSchemas; |
| } |
| |
| public String getBaseSchemaLocation() { |
| return baseSchemaLocation; |
| } |
| |
| public void setBaseSchemaLocation(String baseSchemaLocation) { |
| if (baseSchemaLocation != null && !(baseSchemaLocation.length() == 0)) { |
| this.baseSchemaLocation = baseSchemaLocation; |
| } |
| } |
| |
| public void compileSchemas() throws Exception { |
| List schemas = new ArrayList(); |
| File base = new File(sourceDir); |
| Resource resource = new Resource(); |
| resource.setDirectory(sourceDir); |
| resource.setTargetPath(baseSchemaLocation); |
| for (StringTokenizer st = new StringTokenizer(sourceSchemas, ","); st.hasMoreTokens();) { |
| String schemaName = st.nextToken(); |
| schemas.add(new File(base, schemaName)); |
| resource.addInclude(schemaName); |
| } |
| resources.add(resource); |
| if (buildSchemas) { |
| List configs = new ArrayList(); |
| |
| if (xmlConfigs != null) { |
| for (StringTokenizer st = new StringTokenizer(xmlConfigs, ","); st.hasMoreTokens();) { |
| String configName = st.nextToken(); |
| configs.add(new File(configName)); |
| } |
| } |
| List classPathList = new ArrayList(); |
| List urls = new ArrayList(); |
| if (classPath != null) { |
| for (StringTokenizer st = new StringTokenizer(classPath, ","); st.hasMoreTokens();) { |
| String classpathElement = st.nextToken(); |
| File file = new File(classpathElement); |
| classPathList.add(file); |
| urls.add(file.toURL()); |
| System.out.println("Adding to classpath: " + file); |
| } |
| } |
| ClassLoader cl = new URLClassLoader((URL[]) urls.toArray(new URL[] {})); |
| EntityResolver entityResolver = null; |
| if (catalogLocation != null) { |
| CatalogManager catalogManager = CatalogManager.getStaticManager(); |
| catalogManager.setCatalogFiles(catalogLocation); |
| entityResolver = new CatalogResolver(); |
| } |
| URI sourceDirURI = new File(sourceDir).toURI(); |
| entityResolver = new PassThroughResolver(cl, entityResolver, sourceDirURI, baseSchemaLocation); |
| |
| SchemaCompiler.Parameters params = new SchemaCompiler.Parameters(); |
| params.setBaseDir(null); |
| params.setXsdFiles((File[])schemas.toArray(new File[] {})); |
| params.setWsdlFiles(new File[] {}); |
| params.setJavaFiles(new File[] {}); |
| params.setConfigFiles((File[])configs.toArray(new File[] {})); |
| params.setClasspath((File[])classPathList.toArray(new File[] {})); |
| params.setOutputJar(null); |
| params.setName(null); |
| params.setSrcDir(new File(javaTargetDir)); |
| params.setClassesDir(new File(classTargetDir)); |
| params.setCompiler(null); |
| params.setMemoryInitialSize(null); |
| params.setMemoryMaximumSize(null); |
| params.setNojavac(true); |
| params.setQuiet(false); |
| params.setVerbose(true); |
| params.setDownload(false); |
| params.setNoUpa(false); |
| params.setNoPvr(false); |
| params.setDebug(true); |
| params.setErrorListener(new ArrayList()); |
| params.setRepackage(null); |
| params.setExtensions(null); |
| params.setMdefNamespaces(null); |
| params.setEntityResolver(entityResolver); |
| |
| boolean result = SchemaCompiler.compile(params); |
| if (!result) { |
| Collection errors = params.getErrorListener(); |
| for (Iterator iterator = errors.iterator(); iterator.hasNext();) { |
| Object o = (Object) iterator.next(); |
| System.out.println("xmlbeans error: " + o); |
| } |
| throw new Exception("Schema compilation failed"); |
| } |
| } |
| |
| } |
| |
| private static class PassThroughResolver implements EntityResolver { |
| private final ClassLoader cl; |
| private final EntityResolver delegate; |
| private final URI sourceDir; |
| //this copy has an / appended |
| private final String baseSchemaLocation; |
| |
| public PassThroughResolver(ClassLoader cl, EntityResolver delegate, URI sourceDir, String baseSchemaLocation) { |
| this.cl = cl; |
| this.delegate = delegate; |
| this.sourceDir = sourceDir; |
| this.baseSchemaLocation = baseSchemaLocation + "/"; |
| } |
| public InputSource resolveEntity(String publicId, |
| String systemId) |
| throws SAXException, IOException { |
| if (delegate != null) { |
| InputSource is = delegate.resolveEntity(publicId, systemId); |
| if (is != null) { |
| return is; |
| } |
| } |
| System.out.println("Could not resolve publicId: " + publicId + ", systemId: " + systemId + " from catalog"); |
| String localSystemId; |
| try { |
| localSystemId = sourceDir.relativize(new URI(systemId)).toString(); |
| } catch (URISyntaxException e) { |
| throw (IOException)new IOException("Could not relativeize systemId").initCause(e); |
| } |
| InputStream in = cl.getResourceAsStream(localSystemId); |
| if (in != null) { |
| System.out.println("found in classpath at: " + localSystemId); |
| return new InputSource(in); |
| } |
| in = cl.getResourceAsStream(baseSchemaLocation + localSystemId); |
| if (in != null) { |
| System.out.println("found in classpath at: META-INF/" + localSystemId); |
| return new InputSource(in); |
| } |
| System.out.println("Not found in classpath, looking in current directory: " + systemId); |
| return new InputSource(systemId); |
| } |
| |
| } |
| } |