Abstract superclass for Mojos generating Java source or binaries from XML schema(s) by invoking the JAXB XJC
* binding compiler. Most of the Configuration options for the AbstractJavaGeneratorMojo are set or copied to the
* XJC directly; refer to their documentation in the JAXB Reference Implementation
* site.
*
* @author PROXY_PROPERTY_KEYS = Arrays.asList("http.proxyHost", "http.proxyPort", "https.proxyHost", "https.proxyPort");
private static final int XJC_COMPLETED_OK = 0;
/**
* Corresponding XJC parameter: {@code catalog}.
* Specify catalog files to resolve external entity references.
* Supports TR9401, XCatalog, and OASIS XML Catalog format.
*/
@Parameter
protected File catalog;
/**
* Deprecated - will be removed in a future release
* From plugin version 2.4, this parameter will not be used.
* Instead, episode files are generated by default with all JAXB operations.
* Starting with plugin version 2.4, use the parameter {@link #episodeFileName} to provide a custom
* name of the generated episode File (or rely on the standard file name {@link #STANDARD_EPISODE_FILENAME}).
*
* @since 2.0
* @deprecated
*/
@Deprecated
@Parameter(defaultValue = "true")
protected boolean generateEpisode;
/**
* Corresponding XJC parameter: {@code episode}.
* Generate an episode file with the supplied name from this XJC compilation, so that other schemas that rely
* on this schema can be compiled later and rely on classes that are generated from this compilation.
* The generated episode file is simply a JAXB customization file (but with vendor extensions), normally known
* as a binding file with the suffix .xjb.
* If the episodeFileName parameter is not given, the episode file name is synthesized on the form
* "episode_" + executionID + ".xjb" - typically something like episode_my_xjc.xjb, but
* it depends on the actual ID given in the execution element:
*
*
* <executions>
* <execution>
* <id>my_xjc</id>
* <goals>
* <goal>xjc</goal>
* </goals>
* </execution>
* </executions>
*
*
*
* @see #STANDARD_EPISODE_FILENAME
* @since 2.4
*/
@Parameter
protected String episodeFileName;
/**
* Sets the HTTP/HTTPS proxy to be used by the XJC, on the format
* {@code [user[:password]@]proxyHost[:proxyPort]}.
* All information is retrieved from the active proxy within the standard maven settings file.
*/
@Parameter(defaultValue = "${settings}", readonly = true)
protected Settings settings;
/**
* Defines the content type of sources for the XJC. To simplify usage of the JAXB2 maven plugin,
* all source files are assumed to have the same type of content.
* This parameter replaces the previous multiple-choice boolean configuration options for the
* jaxb2-maven-plugin (i.e. dtd, xmlschema, relaxng, relaxng-compact, wsdl), and
* corresponds to setting one of those flags as an XJC argument.
*
* @since 2.0
*/
@Parameter(defaultValue = "XmlSchema")
protected SourceContentType sourceType;
/**
* Corresponding XJC parameter: {@code npa}.
* Suppress the generation of package level annotations into {@code package-info.java}.
* Using this switch causes the generated code to internalize those annotations into the other
* generated classes.
*
* @since 2.0
*/
@Parameter(defaultValue = "false")
protected boolean noPackageLevelAnnotations;
/**
* Corresponding XJC parameter: {@code no-header}.
* Suppress the generation of a file header comment that includes some note and timestamp.
* Using this makes the generated code more diff-friendly.
*
* @since 2.0
*/
@Parameter(defaultValue = "false")
protected boolean noGeneratedHeaderComments;
/**
* Corresponding XJC parameter: {@code mark-generated}.
* This feature causes all of the generated code to have {@code @Generated} annotation.
*
* @since 2.0
*/
@Parameter(defaultValue = "false")
protected boolean addGeneratedAnnotation;
/**
* Corresponding XJC parameter: {@code nv}.
* By default, the XJC binding compiler performs strict validation of the source schema before processing it.
* Use this option to disable strict schema validation. This does not mean that the binding compiler will not
* perform any validation, it simply means that it will perform less-strict validation.
*
* @since 2.0
*/
@Parameter(defaultValue = "false")
protected boolean laxSchemaValidation;
/**
* Corresponding XJC parameter: {@code quiet}.
* Suppress compiler output, such as progress information and warnings.
*/
@Parameter(defaultValue = "false")
protected boolean quiet;
/**
* Corresponding XJC parameter: {@code verbose}.
* Tells XJC to be extra verbose, such as printing informational messages or displaying stack traces.
*/
@Parameter(property = "xjc.verbose", defaultValue = "false")
protected boolean verbose;
/**
* Corresponding XJC parameter: {@code extension}.
* By default, the XJC binding compiler strictly enforces the rules outlined in the Compatibility chapter of
* the JAXB Specification. Appendix E.2 defines a set of W3C XML Schema features that are not completely
* supported by JAXB v1.0. In some cases, you may be allowed to use them in the "-extension" mode enabled by
* this switch. In the default (strict) mode, you are also limited to using only the binding customizations
* defined in the specification.
*/
@Parameter(defaultValue = "true")
protected boolean extension;
/**
* Fails the Mojo execution if no XSDs/schemas are found.
*
* @since 1.3
*/
@Parameter(defaultValue = "true")
protected boolean failOnNoSchemas;
/**
* Removes all files from the output directory before running XJC.
*/
@Parameter(defaultValue = "true")
protected boolean clearOutputDir;
/**
* Corresponding XJC parameter: {@code readOnly}.
* By default, the XJC binding compiler does not write-protect the Java source files it generates.
* Use this option to force the XJC binding compiler to mark the generated Java sources read-only.
*
* @since 2.0
*/
@Parameter(defaultValue = "false")
protected boolean readOnly;
/**
* List of ordered extra arguments to the XJC command. Each extra argument is interpreted as a word, intended
* to be copied verbatim to the XJC argument list with spaces in between:
*
*
* <configuration>
* ...
* <arguments>
* <argument>-Xfluent-api</argument>
* <argument>somefile</argument>
* </arguments>
* </configuration>
*
*
* The arguments configured above yields the following extra arguments to the XJC command:
* -Xfluent-api -episode somefile
*
* @since 2.0
* @deprecated This should be removed in the 2.0+ release, as all arguments should be handled by other parameters.
*/
@Parameter(property = "xjc.arguments")
protected List arguments;
/**
* Corresponding XJC parameter: {@code enableIntrospection}.
* Enable correct generation of Boolean getters/setters to enable Bean Introspection APIs.
*
* @since 1.4
*/
@Parameter(defaultValue = "false")
private boolean enableIntrospection;
/**
* Corresponding XJC parameter: {@code p}.
* The package under which the source files will be generated. Quoting the XJC documentation:
* "Specifying a target package via this command-line option overrides any binding customization for package
* name and the default package name algorithm defined in the specification".
*/
@Parameter
protected String packageName;
/**
* Corresponding XJC parameter: {@code target}.
* Permitted values: {@code "2.0"} and {@code "2.1"}. Avoid generating code that relies on JAXB newer than the
* version given. This will allow the generated code to run with JAXB 2.0 runtime (such as JavaSE 6.)
*
* @since 1.3
*/
@Parameter
protected String target;
/**
* If provided, this parameter indicates that the XSDs used by XJC to generate Java code should be
* copied into the resulting artifact of this project (the JAR, WAR or whichever artifact type is generated).
* The value of the {@code xsdPathWithinArtifact} parameter is the relative path within the artifact where
* all source XSDs are copied to (hence the name "XSD Path Within Artifact").
* The target directory is created within the artifact if it does not already exist.
* If the {@code xsdPathWithinArtifact} parameter is not given, the XSDs used to generate Java code are
* not included within the project's artifact.
* Example:Adding the sample configuration below would copy all source XSDs to the given directory
* within the resulting JAR (and/or test-JAR). If the directory {@code META-INF/jaxb/xsd} does not exist, it
* will be created.
*
*
* <configuration>
* ...
* <xsdPathWithinArtifact>META-INF/jaxb/xsd</xsdPathWithinArtifact>
* </configuration>
*
*
* Note: This parameter was previously called {@code includeSchemasOutputPath}
* in the 1.x versions of this plugin, but was renamed and re-documented for improved usability and clarity.
*
* @since 2.0
*/
@Parameter
protected String xsdPathWithinArtifact;
/**
* If set to true, the system property enableExternalEntityProcessing is set for the
* duration of the Java generation by this plugin, permitting DTD sources to use external entity URIs such as
* file://. Typically, this is used in conjunction with the sourceType similar to the
* configuration snippet below where DTDs are used as sourceType and read from the src/main/dtd
* directory. This implies a file:// URI.
*
*
* <configuration>
* ...
* <sourceType>dtd</sourceType>
* <sources>
* <source>src/main/dtd</source>
* </sources>
* <externalEntityProcessing>true</externalEntityProcessing>
* </configuration>
*
*
*
* @since 2.4
*/
@Parameter(defaultValue = "false")
protected boolean externalEntityProcessing;
/**
* Java generation is required if any of the file products is outdated/stale.
* {@inheritDoc}
*/
@Override
protected boolean isReGenerationRequired() {
//
// Use the stale flag method to identify if we should re-generate the java source code from the supplied
// Xml Schema. Basically, we should regenerate the JAXB code if:
//
// a) The staleFile does not exist
// b) The staleFile exists and is older than one of the sources (XSD or XJB files).
// "Older" is determined by comparing the modification timestamp of the staleFile and the source files.
//
final File staleFile = getStaleFile();
final String debugPrefix = "StaleFile [" + FileSystemUtilities.getCanonicalPath(staleFile) + "]";
boolean stale = !staleFile.exists();
if (stale) {
getLog().debug(debugPrefix + " not found. JAXB (re-)generation required.");
} else {
final List sourceXSDs = getSources();
final List sourceXJBs = getSourceXJBs();
if (getLog().isDebugEnabled()) {
getLog().debug(debugPrefix + " found. Checking timestamps on source XSD and XJB "
+ "files to determine if JAXB (re-)generation is required.");
}
final long staleFileLastModified = staleFile.lastModified();
for (URL current : sourceXSDs) {
final URLConnection sourceXsdConnection;
try {
sourceXsdConnection = current.openConnection();
sourceXsdConnection.connect();
} catch (Exception e) {
// Can't determine if the staleFile is younger than this sourceXSD.
// Re-generate to be on the safe side.
stale = true;
break;
}
try {
if (sourceXsdConnection.getLastModified() > staleFileLastModified) {
if (getLog().isDebugEnabled()) {
getLog().debug(current.toString() + " is newer than the stale flag file.");
}
stale = true;
}
} finally {
if (sourceXsdConnection instanceof HttpURLConnection) {
((HttpURLConnection) sourceXsdConnection).disconnect();
}
}
}
for (File current : sourceXJBs) {
if (current.lastModified() > staleFileLastModified) {
if (getLog().isDebugEnabled()) {
getLog().debug(FileSystemUtilities.getCanonicalPath(current)
+ " is newer than the stale flag file.");
}
stale = true;
break;
}
}
}
// All done.
return stale;
}
/**
* {@inheritDoc}
*/
@Override
protected boolean performExecution() throws MojoExecutionException, MojoFailureException {
boolean updateStaleFileTimestamp = false;
try {
// Setup the Tool's execution environment
ToolExecutionEnvironment environment = null;
try {
// Create a LocaleFacet if the user has configured an explicit Locale for the tool.
final LocaleFacet localeFacet = locale == null ? null : LocaleFacet.createFor(locale, getLog());
// Create the ToolExecutionEnvironment
environment = new ToolExecutionEnvironment(getLog(),
ThreadContextClassLoaderBuilder.createFor(this.getClass(), getLog(), getEncoding(false))
.addPaths(getClasspath()),
LoggingHandlerEnvironmentFacet.create(getLog(), getClass(), getEncoding(false)),
localeFacet);
// Add any extra configured EnvironmentFacets, as configured in the POM.
if (extraFacets != null) {
for (EnvironmentFacet current : extraFacets) {
environment.add(current);
}
}
// Handle extended properties?
if (externalEntityProcessing) {
final List sysPropChanges =
SystemPropertyChangeEnvironmentFacet.getBuilder(getLog())
.addOrChange("enableExternalEntityProcessing", "" + externalEntityProcessing)
.build();
for (SystemPropertyChangeEnvironmentFacet current : sysPropChanges) {
environment.add(current);
}
}
// XJC overwrites proxy properties if so inclined, so we use this facet to save them
for (String key : PROXY_PROPERTY_KEYS) {
environment.add(new SystemPropertySaveEnvironmentFacet(key, getLog()));
}
// Setup the environment.
environment.setup();
// Compile the XJC arguments
final String[] xjcArguments = getXjcArguments(environment.getClassPathAsArgument(), episodeFileName);
// Ensure that the outputDirectory exists, but only clear it if does not already
FileSystemUtilities.createDirectory(getOutputDirectory(), clearOutputDir);
// Do we need to re-create the episode file's parent directory.
final boolean reCreateEpisodeFileParentDirectory = generateEpisode && clearOutputDir;
if (reCreateEpisodeFileParentDirectory) {
getEpisodeFile(episodeFileName);
}
// Check the system properties.
logSystemPropertiesAndBasedir();
// Fire XJC
if (XJC_COMPLETED_OK != Driver.run(xjcArguments, new XjcLogAdapter(getLog()))) {
final StringBuilder errorMsgBuilder = new StringBuilder();
errorMsgBuilder.append("\n+=================== [XJC Error]\n");
errorMsgBuilder.append("|\n");
final List sourceXSDs = getSources();
for (int i = 0; i < sourceXSDs.size(); i++) {
errorMsgBuilder.append("| " + i + ": ").append(sourceXSDs.get(i).toString()).append("\n");
}
errorMsgBuilder.append("|\n");
errorMsgBuilder.append("+=================== [End XJC Error]\n");
throw new MojoExecutionException(errorMsgBuilder.toString());
}
// Indicate that the output directory was updated.
getBuildContext().refresh(getOutputDirectory());
// Update the modification timestamp of the staleFile.
updateStaleFileTimestamp = true;
} finally {
if (environment != null) {
environment.restore();
}
}
// Add the generated source root to the project, enabling tooling and other plugins to see them.
addGeneratedSourcesToProjectSourceRoot();
// Copy all source XSDs to the resulting artifact?
if (xsdPathWithinArtifact != null) {
final String buildOutputDirectory = getProject().getBuild().getOutputDirectory();
final File targetXsdDirectory = new File(buildOutputDirectory, xsdPathWithinArtifact);
FileUtils.forceMkdir(targetXsdDirectory);
for (URL current : getSources()) {
String fileName = null;
if ("file".equalsIgnoreCase(current.getProtocol())) {
fileName = new File(current.getPath()).getName();
} else if ("jar".equalsIgnoreCase(current.getProtocol())) {
// Typical JAR path
// jar:file:/path/to/aJar.jar!/some/path/xsd/aResource.xsd
final int bangIndex = current.toString().indexOf("!");
if (bangIndex == -1) {
throw new MojoExecutionException("Illegal JAR URL [" + current.toString()
+ "]: lacks a '!'");
}
final String internalPath = current.toString().substring(bangIndex + 1);
fileName = new File(internalPath).getName();
} else {
throw new MojoExecutionException("Could not extract FileName from URL [" + current + "]");
}
final File targetFile = new File(targetXsdDirectory, fileName);
if (targetFile.exists()) {
// TODO: Should we throw an exception here instead?
getLog().warn("File [" + FileSystemUtilities.getCanonicalPath(targetFile)
+ "] already exists. Not copying XSD file [" + current.getPath() + "] to it.");
}
IOUtil.copy(current.openStream(), new FileWriter(targetFile));
}
// Refresh the BuildContext
getBuildContext().refresh(targetXsdDirectory);
}
} catch (MojoExecutionException e) {
throw e;
} catch (NoSchemasException e) {
if (failOnNoSchemas) {
throw new MojoExecutionException("", e);
}
} catch (Exception e) {
throw new MojoExecutionException(e.getMessage(), e);
}
// All done.
return updateStaleFileTimestamp;
}
/**
* Override this method to acquire a List holding all URLs to the JAXB sources for which this
* AbstractJavaGeneratorMojo should generate Java files. Sources are assumed to be in the form given by
* the {@code sourceType} value.
*
* @return A non-null List holding URLs to sources for the XJC generation.
* @see #sourceType
*/
@Override
protected abstract List getSources();
/**
* Override this method to retrieve a list of Files to all XJB files for which this
* AbstractJavaGeneratorMojo should generate Java files.
*
* @return A non-null List holding binding files.
*/
protected abstract List getSourceXJBs();
/**
* Adds any directories containing the generated XJC classes to the appropriate Project compilation sources;
* either {@code TestCompileSourceRoot} or {@code CompileSourceRoot} depending on the exact Mojo implementation
* of this AbstractJavaGeneratorMojo.
*/
protected abstract void addGeneratedSourcesToProjectSourceRoot();
//
// Private helpers
//
private String[] getXjcArguments(final String classPath, final String episodeFileNameOrNull)
throws MojoExecutionException, NoSchemasException {
final ArgumentBuilder builder = new ArgumentBuilder();
// Add all flags on the form '-flagName'
builder.withFlag(true, sourceType.getXjcArgument());
builder.withFlag(noPackageLevelAnnotations, "npa");
builder.withFlag(laxSchemaValidation, "nv");
builder.withFlag(verbose, "verbose");
builder.withFlag(quiet, "quiet");
builder.withFlag(enableIntrospection, "enableIntrospection");
builder.withFlag(extension, "extension");
builder.withFlag(readOnly, "readOnly");
builder.withFlag(noGeneratedHeaderComments, "no-header");
builder.withFlag(addGeneratedAnnotation, "mark-generated");
// Add all arguments on the form '-argumentName argumentValue'
// (i.e. in 2 separate elements of the returned String[])
builder.withNamedArgument("httpproxy", getProxyString(settings.getActiveProxy()));
builder.withNamedArgument("encoding", getEncoding(true));
builder.withNamedArgument("p", packageName);
builder.withNamedArgument("target", target);
builder.withNamedArgument("d", getOutputDirectory().getAbsolutePath());
builder.withNamedArgument("classpath", classPath);
// We must add the -extension flag in order to generate the episode file.
if (!extension) {
if (getLog().isInfoEnabled()) {
getLog().info("Adding 'extension' flag to XJC arguments, to generate an episode "
+ "file named '" + (episodeFileName == null ? STANDARD_EPISODE_FILENAME : episodeFileName)
+ "'. (XJCs 'episode' argument requires that the 'extension' argument is provided).");
}
}
builder.withFlag(true, "extension");
final File episodeFile = getEpisodeFile(episodeFileNameOrNull);
builder.withNamedArgument("episode", FileSystemUtilities.getCanonicalPath(episodeFile));
if (catalog != null) {
builder.withNamedArgument("catalog", FileSystemUtilities.getCanonicalPath(catalog));
}
if (arguments != null) {
builder.withPreCompiledArguments(arguments);
}
for (File current : getSourceXJBs()) {
// Shorten the argument?
// final String strippedXjbPath = FileSystemUtilities.relativize(
// current.getAbsolutePath(), getProject().getBasedir());
// Each XJB must be given as a separate argument.
builder.withPreCompiledArguments(Arrays.asList("-b", current.getAbsolutePath()));
}
final List sourceXSDs = getSources();
if (sourceXSDs.isEmpty()) {
// If we have no XSDs, we are not going to be able to run XJC.
getLog().warn("No XSD files found. Please check your plugin configuration.");
throw new NoSchemasException();
} else {
final List unwrappedSourceXSDs = new ArrayList();
for (URL current : sourceXSDs) {
// Shorten the argument if possible.
if ("file".equalsIgnoreCase(current.getProtocol())) {
unwrappedSourceXSDs.add(FileSystemUtilities.relativize(
current.getPath(),
new File(System.getProperty("user.dir")),
true));
} else {
unwrappedSourceXSDs.add(current.toString());
}
}
builder.withPreCompiledArguments(unwrappedSourceXSDs);
}
// All done.
return logAndReturnToolArguments(builder.build(), "XJC");
}
private String getProxyString(final Proxy activeProxy) {
// Check sanity
if (activeProxy == null) {
return null;
}
// The XJC proxy argument should be on the form
// [user[:password]@]proxyHost[:proxyPort]
//
// builder.withNamedArgument("httpproxy", httpproxy);
//
final StringBuilder proxyBuilder = new StringBuilder();
if (activeProxy.getUsername() != null) {
// Start with the username.
proxyBuilder.append(activeProxy.getUsername());
// Append the password if provided.
if (activeProxy.getPassword() != null) {
proxyBuilder.append(":").append(activeProxy.getPassword());
}
proxyBuilder.append("@");
}
// Append hostname and port.
proxyBuilder.append(activeProxy.getHost()).append(":").append(activeProxy.getPort());
// All done.
return proxyBuilder.toString();
}
}
SourceContentType.java 0000664 0000000 0000000 00000011761 13511002134 0036732 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/javageneration package org.codehaus.mojo.jaxb2.javageneration;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
/**
* The type of source input used by XJC.
* The constants are duplicated in lowercase since Maven's Mojo argument matcher is case sensitive.
*
* @author Lennart Jörelid, jGuru Europe AB
* @see The JAXB Reference Implementation
* @since 2.0
*/
public enum SourceContentType {
/**
* Treat input as DTDs (i.e. Document Type
* Definitions). This option is labelled as "experimental,unsupported" in the XJC documentation.
*/
DTD("dtd"),
/**
* Treat input as DTDs (i.e. Document Type
* Definitions). This option is labelled as "experimental,unsupported" in the XJC documentation.
*
* @see #DTD
*/
dtd("dtd"),
/**
* Treat input as W3C XML Schema (i.e. Xml Schema Definitions).
* This is the standard mode of the XJC (and is recommended by the Codehaus Mojo team as well).
*/
XmlSchema("xmlschema"),
/**
* Treat input as W3C XML Schema (i.e. Xml Schema Definitions).
* This is the standard mode of the XJC (and is recommended by the Codehaus Mojo team as well).
*
* @see #XmlSchema
*/
xmlschema("xmlschema"),
/**
* Treat input as Relax NG.
* This option is labelled as "experimental,unsupported" in the XJC documentation.
*
* @see Relax NG on WikiPedia
*/
RelaxNG("relaxng"),
/**
* Treat input as Relax NG.
* This option is labelled as "experimental,unsupported" in the XJC documentation.
*
* @see Relax NG on WikiPedia
* @see #RelaxNG
*/
relaxng("relaxng"),
/**
* Treat input as Relax
* NG with Compact syntax. This option is labelled as "experimental,unsupported" in the XJC documentation.
*
* @see Relax NG on WikiPedia
*/
RelaxNGCompact("relaxng-compact"),
/**
* Treat input as Relax
* NG with Compact syntax. This option is labelled as "experimental,unsupported" in the XJC documentation.
*
* @see Relax NG on WikiPedia
* @see #RelaxNGCompact
*/
relaxng_compact("relaxng-compact"),
/**
* Treat input as Relax
* NG with Compact syntax. This option is labelled as "experimental,unsupported" in the XJC documentation.
*
* @see Relax NG on WikiPedia
* @see #RelaxNGCompact
*/
relaxngcompact("relaxng-compact"),
/**
* Treat input as WSDL, and compile schemas inside it.
* This option is labelled as "experimental,unsupported" in the XJC documentation.
*
* @see Web Services Description Language (WSDL) 1.1
*/
WSDL("wsdl"),
/**
* Treat input as WSDL, and compile schemas inside it.
* This option is labelled as "experimental,unsupported" in the XJC documentation.
*
* @see Web Services Description Language (WSDL) 1.1
* @see #WSDL
*/
wsdl("wsdl");
// Internal state
private String xjcArgument;
SourceContentType(final String xjcArgument) {
this.xjcArgument = xjcArgument;
}
/**
* @return The XJC argument flag corresponding to this InputType.
*/
public String getXjcArgument() {
return xjcArgument;
}
}
TestXjcMojo.java 0000664 0000000 0000000 00000033662 13511002134 0035512 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/javageneration package org.codehaus.mojo.jaxb2.javageneration;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.apache.maven.artifact.DependencyResolutionRequiredException;
import org.apache.maven.model.Resource;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.plugins.annotations.ResolutionScope;
import org.codehaus.mojo.jaxb2.AbstractJaxbMojo;
import org.codehaus.mojo.jaxb2.shared.FileSystemUtilities;
import org.codehaus.mojo.jaxb2.shared.filters.Filter;
import org.codehaus.mojo.jaxb2.shared.filters.Filters;
import org.codehaus.mojo.jaxb2.shared.filters.pattern.PatternFileFilter;
import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* Mojo that creates test-scope Java source or binaries from XML schema(s)
* by invoking the JAXB XJC binding compiler. This implementation is tailored
* to use the JAXB Reference Implementation from project Kenai.
* Note that the TestXjcMojo was completely re-implemented for the 2.x versions.
* Its configuration semantics and parameter set is not necessarily
* backwards compatible with the 1.x plugin versions. If you are
* upgrading from version 1.x of the plugin, read the documentation carefully.
*
* @author Lennart Jörelid
* @see The JAXB Reference Implementation
*/
@Mojo(name = "testXjc",
defaultPhase = LifecyclePhase.GENERATE_TEST_SOURCES,
requiresDependencyResolution = ResolutionScope.TEST,
threadSafe = false)
public class TestXjcMojo extends AbstractJavaGeneratorMojo {
/**
* The last part of the stale fileName for this TestXjcMojo.
*/
public static final String STALE_FILENAME = "testXjcStaleFlag";
/**
* Standard directory path (relative to basedir) searched recursively for test
* source files (typically XSDs), unless overridden by a
* testSources configuration element.
*/
public static final String STANDARD_TEST_SOURCE_DIRECTORY = "src/test/xsd";
/**
* Default exclude Filters for test sources, used unless overridden by an
* explicit configuration in the {@code testSourceExcludeFilters} parameter.
* The default values are found as follows:
*
*
* final List<Filter<File>> xjbTemp = new ArrayList<Filter<File>>();
* xjbTemp.addAll(AbstractJaxbMojo.STANDARD_EXCLUDE_FILTERS);
* xsdTemp.add(new PatternFileFilter(Arrays.asList("\\.xjb"), true));
* STANDARD_TEST_SOURCE_EXCLUDE_FILTERS = Collections.unmodifiableList(xsdTemp);
*
*
*
* @see #STANDARD_EXCLUDE_FILTERS
*/
public static final List> STANDARD_TEST_SOURCE_EXCLUDE_FILTERS;
/**
* Standard directory path (relative to basedir) searched recursively for XJB
* files, unless overridden by an testXjbSources configuration element.
* As explained in the JAXB specification, XJB files (JAXB Xml Binding files)
* are used to configure parts of the Java source generation.
*/
public static final String STANDARD_TEST_XJB_DIRECTORY = "src/test/xjb";
/**
* Default List of exclude Filters for XJB files, unless overridden by providing
* an explicit configuration in the {@code testXjbExcludeFilters} parameter.
* The default values are found as follows:
*
*
* final List<Filter<File>> xjbTemp = new ArrayList<Filter<File>>();
* xjbTemp.addAll(AbstractJaxbMojo.STANDARD_EXCLUDE_FILTERS);
* xjbTemp.add(new PatternFileFilter(Arrays.asList("\\.xsd"), true));
* STANDARD_TEST_XJB_EXCLUDE_FILTERS = Collections.unmodifiableList(xjbTemp);
*
*
*
* @see #STANDARD_EXCLUDE_FILTERS
*/
public static final List> STANDARD_TEST_XJB_EXCLUDE_FILTERS;
static {
final List> xjbTemp = new ArrayList>();
xjbTemp.addAll(AbstractJaxbMojo.STANDARD_EXCLUDE_FILTERS);
xjbTemp.add(new PatternFileFilter(Arrays.asList("\\.xsd"), true));
STANDARD_TEST_XJB_EXCLUDE_FILTERS = Collections.unmodifiableList(xjbTemp);
final List> xsdTemp = new ArrayList>();
xsdTemp.addAll(AbstractJaxbMojo.STANDARD_EXCLUDE_FILTERS);
xsdTemp.add(new PatternFileFilter(Arrays.asList("\\.xjb"), true));
STANDARD_TEST_SOURCE_EXCLUDE_FILTERS = Collections.unmodifiableList(xsdTemp);
}
/**
* Corresponding XJC parameter: {@code d}.
* The working directory where the generated Java test source files are created.
*/
@Parameter(defaultValue = "${project.build.directory}/generated-test-sources/jaxb", required = true)
private File outputDirectory;
/**
* Parameter holding List of XSD paths to files and/or directories which should be recursively searched
* for XSD files. Only files or directories that actually exist will be included (in the case of files)
* or recursively searched for XSD files to include (in the case of directories).
* Configure using standard Maven structure for Lists:
*
*
* <configuration>
* ...
* <testSources>
* <testSource>some/explicit/relative/file.xsd</testSource>
* <testSource>/another/absolute/path/to/a/specification.xsd</testSource>
* <testSource>a/directory/holding/xsds</testSource>
* </testSources>
* </configuration>
*
*
*
* @see #STANDARD_TEST_SOURCE_DIRECTORY
*/
@Parameter(required = false)
private List testSources;
/**
* Parameter holding List of XJB Files and/or directories which should be recursively searched
* for XJB files. Only files or directories that actually exist will be included (in the case of files)
* or recursively searched for XJB files to include (in the case of directories). JAXB binding files are
* used to configure parts of the Java source generation.
* Supply the configuration using the standard Maven structure for configuring plugin Lists:
*
*
* <configuration>
* ...
* <testXjbSources>
* <testXjbSource>bindings/aBindingConfiguration.xjb</testXjbSource>
* <testXjbSource>bindings/config/directory</testXjbSource>
* </testXjbSources>
* </configuration>
*
*
*
* @see #STANDARD_TEST_XJB_DIRECTORY
*/
@Parameter(required = false)
private List testXjbSources;
/**
* Parameter holding a List of Filters, used to match all files under the {@code testSources} directories
* which should not be considered XJC test source files. (The filters identify files to
* exclude, and hence this parameter is called {@code testS§ourceExcludeFilters}). If a file under any of the
* test source directories matches at least one of the Filters supplied in the {@code testSourceExcludeFilters},
* it is not considered an XJC source file, and therefore excluded from processing.
* If not explicitly provided, the Mojo uses the value within {@code STANDARD_TEST_SOURCE_EXCLUDE_FILTERS}.
* The algorithm for finding XJC test sources is as follows:
*
* - Find all files given in the testSources List. Any Directories provided are searched for files
* recursively.
* - Exclude any found files matching any of the supplied {@code testSourceExcludeFilters} List.
* - The remaining Files are submitted for processing by the XJC tool.
*
* Example: The following configuration would exclude any sources whose names end with
* {@code txt} or {@code foo}:
*
*
* <configuration>
* ...
* <testSourceExcludeFilters>
* <suffixFilter impl="org.codehaus.mojo.jaxb2.shared.filters.source.ExclusionRegularExpressionFileFilter">txt</suffixFilter>
* <suffixFilter impl="org.codehaus.mojo.jaxb2.shared.filters.source.ExclusionRegularExpressionFileFilter">foo</suffixFilter>
* </testSourceExcludeFilters>
* </configuration>
*
*
*
* @see #STANDARD_TEST_SOURCE_EXCLUDE_FILTERS
* @see org.codehaus.mojo.jaxb2.shared.filters.pattern.PatternFileFilter
* @see org.codehaus.mojo.jaxb2.shared.filters.pattern.AbstractPatternFilter
* @see org.codehaus.mojo.jaxb2.shared.filters.AbstractFilter
*/
@Parameter(required = false)
private List> testSourceExcludeFilters;
/***
* Parameter holding a List of Filters, used to match all files under the {@code testXjbSources} directories
* which should not be considered XJB files. (The filters identify files to exclude, and hence
* this parameter is called {@code testXjbExcludeFilters}). If a file matches at least one of the supplied Filters,
* it is not considered an XJB file, and therefore excluded from processing.
* If not explicitly provided, the Mojo uses the value within {@code STANDARD_TEST_XJB_EXCLUDE_FILTERS}.
* Example: The following configuration would exclude any XJB files whose names end with
* {@code xml} or {@code foo}:
*
*
* <configuration>
* ...
* <testXjbExcludeFilters>
* <suffixFilter impl="org.codehaus.mojo.jaxb2.shared.filters.source.ExclusionRegularExpressionFileFilter">xml</suffixFilter>
* <suffixFilter impl="org.codehaus.mojo.jaxb2.shared.filters.source.ExclusionRegularExpressionFileFilter">foo</suffixFilter>
* </sourceExcludeFilters>
* </testXjbExcludeFilters>
*
*
*
* @see #STANDARD_TEST_XJB_EXCLUDE_FILTERS
* @see org.codehaus.mojo.jaxb2.shared.filters.pattern.PatternFileFilter
* @see org.codehaus.mojo.jaxb2.shared.filters.pattern.AbstractPatternFilter
* @see org.codehaus.mojo.jaxb2.shared.filters.AbstractFilter
*/
@Parameter(required = false)
private List> testXjbExcludeFilters;
/**
* Indicate if the XjcMojo execution should be skipped.
*/
@Parameter(property = "xjc.test.skip", defaultValue = "false")
private boolean skipTestXjc;
/**
* {@inheritDoc}
*/
@Override
protected boolean shouldExecutionBeSkipped() {
return skipTestXjc;
}
/**
* {@inheritDoc}
*/
@Override
protected List getSources() {
final List> excludePatterns = testSourceExcludeFilters == null
? STANDARD_TEST_SOURCE_EXCLUDE_FILTERS
: testSourceExcludeFilters;
Filters.initialize(getLog(), excludePatterns);
// All done.
return FileSystemUtilities.filterFiles(
getProject().getBasedir(),
testSources,
Arrays.asList(STANDARD_TEST_SOURCE_DIRECTORY),
getLog(),
"testSources",
excludePatterns);
}
/**
* {@inheritDoc}
*/
@Override
protected List getSourceXJBs() {
final List> excludePatterns = testXjbExcludeFilters == null
? STANDARD_TEST_XJB_EXCLUDE_FILTERS
: testXjbExcludeFilters;
Filters.initialize(getLog(), excludePatterns);
return FileSystemUtilities.filterFiles(
getProject().getBasedir(),
testXjbSources,
STANDARD_TEST_XJB_DIRECTORY,
getLog(),
"testXjbSources",
excludePatterns);
}
/**
* {@inheritDoc}
*/
@Override
protected String getStaleFileName() {
return STALE_FILENAME;
}
/**
* {@inheritDoc}
*/
@Override
protected File getOutputDirectory() {
return outputDirectory;
}
/**
* {@inheritDoc}
*/
@Override
protected List getClasspath() throws MojoExecutionException {
try {
return (List) getProject().getTestClasspathElements();
} catch (DependencyResolutionRequiredException e) {
throw new MojoExecutionException("Could not retrieve Compile classpath.", e);
}
}
/**
* {@inheritDoc}
*/
@Override
protected void addGeneratedSourcesToProjectSourceRoot() {
getProject().addTestCompileSourceRoot(getOutputDirectory().getAbsolutePath());
}
/**
* {@inheritDoc}
*/
@Override
protected void addResource(final Resource resource) {
getProject().addTestResource(resource);
}
}
XjcLogAdapter.java 0000664 0000000 0000000 00000005523 13511002134 0035763 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/javageneration package org.codehaus.mojo.jaxb2.javageneration;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import com.sun.tools.xjc.XJCListener;
import org.apache.maven.plugin.logging.Log;
import org.codehaus.mojo.jaxb2.shared.Validate;
import org.xml.sax.SAXParseException;
/**
* Adapter implementation emitting XJC events to a Maven Log.
*
* @author Lennart Jörelid, jGuru Europe AB
* @since 2.0
*/
public class XjcLogAdapter extends XJCListener {
// Internal state
private Log log;
/**
* Creates an XjcLogAdapter which emits all XJC events onto the supplied Maven Log.
*
* @param log A non-null Log logging all inbound XJC events.
*/
public XjcLogAdapter(final Log log) {
// Check sanity
Validate.notNull(log, "log");
// Assign internal state
this.log = log;
}
/**
* {@inheritDoc}
*/
@Override
public void generatedFile(final String fileName, final int current, final int total) {
if (log.isDebugEnabled()) {
log.debug("Processing file [" + current + "/" + total + "]: " + fileName);
}
}
/**
* {@inheritDoc}
*/
@Override
public void error(final SAXParseException exception) {
log.error(getLocation(exception), exception);
}
/**
* {@inheritDoc}
*/
@Override
public void fatalError(final SAXParseException exception) {
log.error(getLocation(exception), exception);
}
/**
* {@inheritDoc}
*/
@Override
public void warning(final SAXParseException exception) {
log.warn(getLocation(exception), exception);
}
/**
* {@inheritDoc}
*/
@Override
public void info(final SAXParseException exception) {
log.info(getLocation(exception), exception);
}
//
// Private helpers
//
private String getLocation(final SAXParseException e) {
final String exceptionId = e.getPublicId() == null ? e.getSystemId() : e.getPublicId();
return exceptionId + " [" + e.getLineNumber() + "," + e.getColumnNumber() + "] ";
}
}
XjcMojo.java 0000664 0000000 0000000 00000034646 13511002134 0034655 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/javageneration package org.codehaus.mojo.jaxb2.javageneration;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.apache.maven.artifact.DependencyResolutionRequiredException;
import org.apache.maven.model.Resource;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.plugins.annotations.ResolutionScope;
import org.codehaus.mojo.jaxb2.AbstractJaxbMojo;
import org.codehaus.mojo.jaxb2.shared.FileSystemUtilities;
import org.codehaus.mojo.jaxb2.shared.filters.Filter;
import org.codehaus.mojo.jaxb2.shared.filters.Filters;
import org.codehaus.mojo.jaxb2.shared.filters.pattern.PatternFileFilter;
import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* Mojo that creates compile-scope Java source or binaries from XML schema(s)
* by invoking the JAXB XJC binding compiler. This implementation is tailored
* to use the JAXB Reference Implementation from project Kenai.
* Note that the XjcMojo was completely re-implemented for the 2.x versions.
* Its configuration semantics and parameter set is not necessarily
* backwards compatible with the 1.x plugin versions. If you are
* upgrading from version 1.x of the plugin, read the documentation carefully.
*
* @author Lennart Jörelid
* @see The JAXB Reference Implementation
*/
@Mojo(name = "xjc",
threadSafe = true,
defaultPhase = LifecyclePhase.GENERATE_SOURCES,
requiresDependencyResolution = ResolutionScope.COMPILE)
public class XjcMojo extends AbstractJavaGeneratorMojo {
/**
* The last part of the stale fileName for this XjcMojo.
*/
public static final String STALE_FILENAME = "xjcStaleFlag";
/**
* Standard directory path (relative to basedir) searched recursively for source
* files (typically XSDs), unless overridden by an sources configuration element.
*/
public static final String STANDARD_SOURCE_DIRECTORY = "src/main/xsd";
/**
* Default exclude Filters for sources, used unless overridden by an
* explicit configuration in the {@code xjcSourceExcludeFilters} parameter.
* The default values are found as follows:
*
*
* final List<Filter<File>> xsdTemp = new ArrayList<Filter<File>>();
* xsdTemp.addAll(AbstractJaxbMojo.STANDARD_EXCLUDE_FILTERS);
* xsdTemp.add(new PatternFileFilter(Arrays.asList("\\.xjb"), true));
* STANDARD_SOURCE_EXCLUDE_FILTERS = Collections.unmodifiableList(xsdTemp);
*
*
* @see #STANDARD_EXCLUDE_FILTERS
*/
public static final List> STANDARD_SOURCE_EXCLUDE_FILTERS;
/**
* Standard directory path (relative to basedir) searched recursively for XJB
* files, unless overridden by an xjbSources configuration element.
* As explained in the JAXB specification, XJB files (JAXB Xml Binding files)
* are used to configure parts of the Java source generation.
*/
public static final String STANDARD_XJB_DIRECTORY = "src/main/xjb";
/**
* Default List of exclude Filters for XJB files, unless overridden by providing
* an explicit configuration in the {@code xjbExcludeSuffixes} parameter.
* The default values are found as follows:
*
*
* final List<Filter<File>> xjbTemp = new ArrayList<Filter<File>>();
* xjbTemp.addAll(AbstractJaxbMojo.STANDARD_EXCLUDE_FILTERS);
* xjbTemp.add(new PatternFileFilter(Arrays.asList("\\.xsd"), true));
* STANDARD_XJB_EXCLUDE_FILTERS = Collections.unmodifiableList(xjbTemp);
*
*
* @see #STANDARD_EXCLUDE_FILTERS
*/
public static final List> STANDARD_XJB_EXCLUDE_FILTERS;
static {
final List> xjbTemp = new ArrayList>();
xjbTemp.addAll(AbstractJaxbMojo.STANDARD_EXCLUDE_FILTERS);
xjbTemp.add(new PatternFileFilter(Arrays.asList("\\.xsd"), true));
STANDARD_XJB_EXCLUDE_FILTERS = Collections.unmodifiableList(xjbTemp);
final List> xsdTemp = new ArrayList>();
xsdTemp.addAll(AbstractJaxbMojo.STANDARD_EXCLUDE_FILTERS);
xsdTemp.add(new PatternFileFilter(Arrays.asList("\\.xjb"), true));
STANDARD_SOURCE_EXCLUDE_FILTERS = Collections.unmodifiableList(xsdTemp);
}
/**
* Corresponding XJC parameter: {@code d}.
* The working directory where the generated Java source files are created.
*/
@Parameter(defaultValue = "${project.build.directory}/generated-sources/jaxb", required = true)
private File outputDirectory;
/**
* Parameter holding List of XSD paths to files and/or directories which should be recursively searched
* for XSD files. Only files or directories that actually exist will be included (in the case of files)
* or recursively searched for XSD files to include (in the case of directories).
* Configure using standard Maven structure for Lists:
*
*
* <configuration>
* ...
* <sources>
* <source>some/explicit/relative/file.xsd</source>
* <source>/another/absolute/path/to/a/specification.xsd</source>
* <source>a/directory/holding/xsds</source>
* </sources>
* </configuration>
*
*
*
* @see #STANDARD_SOURCE_DIRECTORY
*/
@Parameter(required = false)
private List sources;
/**
* Parameter holding List of XJB Files and/or directories which should be recursively searched
* for XJB files. Only files or directories that actually exist will be included (in the case of files)
* or recursively searched for XJB files to include (in the case of directories). JAXB binding files are
* used to configure parts of the Java source generation.
* Supply the configuration using the standard Maven structure for configuring plugin Lists:
*
*
* <configuration>
* ...
* <xjbSources>
* <xjbSource>bindings/aBindingConfiguration.xjb</xjbSource>
* <xjbSource>bindings/config/directory</xjbSource>
* </xjbSources>
* </configuration>
*
*
*
* @see #STANDARD_XJB_DIRECTORY
*/
@Parameter(required = false)
private List xjbSources;
/**
* Parameter holding a List of Filters, used to match all files under the {@code sources} directories
* which should not be considered XJC source files. (The filters identify files to
* exclude, and hence this parameter is called {@code xjcSourceExcludeFilters}). If a file under any of the
* source directories matches at least one of the Filters supplied in the {@code xjcSourceExcludeFilters},
* it is not considered an XJC source file, and therefore excluded from processing.
* If not explicitly provided, the Mojo uses the value within {@code STANDARD_SOURCE_EXCLUDE_FILTERS}.
* The algorithm for finding XJC sources is as follows:
*
* - Find all files given in the sources List. Any Directories provided are searched for files
* recursively.
* - Exclude any found files matching any of the supplied {@code xjcSourceExcludeFilters} List.
* - The remaining Files are submitted for processing by the XJC tool.
*
* Example: The following configuration would exclude any sources whose names end with
* {@code txt} or {@code foo}:
*
*
* <configuration>
* ...
* <xjcSourceExcludeFilters>
* <filter implementation="org.codehaus.mojo.jaxb2.shared.filters.pattern.PatternFileFilter">
* <patterns>
* <pattern>\.txt</pattern>
* <pattern>\.foo</pattern>
* </patterns>
* </filter>
* </xjcSourceExcludeFilters>
* </configuration>
*
*
* Note that inner workings of the Dependency Injection mechanism used by Maven Plugins (i.e. the DI from
* the Plexus container) requires that the full class name to the Filter implementation should be supplied for
* each filter, as is illustrated in the sample above. This is true also if you implement custom Filters.
*
* @see #STANDARD_SOURCE_EXCLUDE_FILTERS
* @see org.codehaus.mojo.jaxb2.shared.filters.pattern.PatternFileFilter
* @see org.codehaus.mojo.jaxb2.shared.filters.pattern.AbstractPatternFilter
* @see org.codehaus.mojo.jaxb2.shared.filters.AbstractFilter
*/
@Parameter(required = false)
private List> xjcSourceExcludeFilters;
/**
* Parameter holding a List of Filters, used to match all files under the {@code xjbSources} directories
* which should not be considered XJB files. (The filters identify files to exclude, and hence
* this parameter is called {@code xjbExcludeFilters}). If a file matches at least one of the supplied Filters,
* it is not considered an XJB file, and therefore excluded from processing.
* If not explicitly provided, the Mojo uses the value within {@code STANDARD_XJB_EXCLUDE_FILTERS}.
* Example: The following configuration would exclude any XJB files whose names end with
* {@code xml} or {@code foo}:
*
*
* <configuration>
* ...
* <xjbExcludeFilters>
* <filter implementation="org.codehaus.mojo.jaxb2.shared.filters.pattern.PatternFileFilter">
* <patterns>
* <pattern>\.txt</pattern>
* <pattern>\.foo</pattern>
* </patterns>
* </filter>
* </xjbExcludeFilters>
* ...
* </configuration>
*
*
* Note that inner workings of the Dependency Injection mechanism used by Maven Plugins (i.e. the DI from
* the Plexus container) requires that the full class name to the Filter implementation should be supplied for
* each filter, as is illustrated in the sample above. This is true also if you implement custom Filters.
*
* @see #STANDARD_XJB_EXCLUDE_FILTERS
* @see org.codehaus.mojo.jaxb2.shared.filters.pattern.PatternFileFilter
* @see org.codehaus.mojo.jaxb2.shared.filters.pattern.AbstractPatternFilter
* @see org.codehaus.mojo.jaxb2.shared.filters.AbstractFilter
*/
@Parameter(required = false)
private List> xjbExcludeFilters;
/**
* Indicate if the XjcMojo execution should be skipped.
*/
@Parameter(property = "xjc.skip", defaultValue = "false")
private boolean skipXjc;
/**
* {@inheritDoc}
*/
@Override
protected boolean shouldExecutionBeSkipped() {
return skipXjc;
}
/**
* {@inheritDoc}
*/
@Override
protected List getSources() {
final List> excludePatterns = xjcSourceExcludeFilters == null
? STANDARD_SOURCE_EXCLUDE_FILTERS
: xjcSourceExcludeFilters;
Filters.initialize(getLog(), excludePatterns);
return FileSystemUtilities.filterFiles(
getProject().getBasedir(),
sources,
Arrays.asList(STANDARD_SOURCE_DIRECTORY),
getLog(),
"sources",
excludePatterns);
}
/**
* {@inheritDoc}
*/
@Override
protected List getSourceXJBs() {
final List> excludePatterns = xjbExcludeFilters == null
? STANDARD_XJB_EXCLUDE_FILTERS
: xjbExcludeFilters;
Filters.initialize(getLog(), excludePatterns);
return FileSystemUtilities.filterFiles(
getProject().getBasedir(),
xjbSources,
STANDARD_XJB_DIRECTORY,
getLog(),
"xjbSources",
excludePatterns);
}
/**
* {@inheritDoc}
*/
@Override
protected String getStaleFileName() {
return STALE_FILENAME;
}
/**
* {@inheritDoc}
*/
@Override
protected File getOutputDirectory() {
return outputDirectory;
}
/**
* {@inheritDoc}
*/
@Override
protected List getClasspath() throws MojoExecutionException {
try {
return (List) getProject().getCompileClasspathElements();
} catch (DependencyResolutionRequiredException e) {
throw new MojoExecutionException("Could not retrieve Compile classpath.", e);
}
}
/**
* {@inheritDoc}
*/
@Override
protected void addGeneratedSourcesToProjectSourceRoot() {
getProject().addCompileSourceRoot(FileSystemUtilities.getCanonicalPath(getOutputDirectory()));
}
/**
* {@inheritDoc}
*/
@Override
protected void addResource(final Resource resource) {
getProject().addResource(resource);
}
}
package-info.java 0000664 0000000 0000000 00000000757 13511002134 0035624 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/javageneration /**
* The jaxb2-maven-plugin wraps and adapts the JAXB reference implementation
* to be useful within the Maven build process.
* The javageneration package (including subpackages) contains Mojos for generating Java files from
* XSDs or DTDs.
*
* @author Lennart Jörelid
* @see The JAXB Reference Implementation
*/
package org.codehaus.mojo.jaxb2.javageneration; jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/package-info.java 0000664 0000000 0000000 00000002204 13511002134 0032673 0 ustar 00root root 0000000 0000000 /**
* The jaxb2-maven-plugin wraps and adapts the JAXB reference implementation
* to be useful within the Maven build process.
* The plugin's code is divided into 3 main blocks, each placed within a separate package structure:
*
*
* - javageneration. Contains code involved in creating java code from XSD or DTDs.
* This package structure adapts the plugin to using the XJC ("Xml-to-Java-Compiler") from the
* JAXB reference implementation.
* - schemageneration. Contains code involved in creating XSDs from annotated Java classes.
* This package structure adapts the plugin to using the schemagen tool from the JDK. (Typically found in the
* bin directory of the java installation).
* - shared. Contains shared utility classes used by both the java- and xsd-generation
* structure classes.
*
*
* @author Lennart Jörelid
* @see The JAXB Reference Implementation
*/
package org.codehaus.mojo.jaxb2; jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/ 0000775 0000000 0000000 00000000000 13511002134 0033022 5 ustar 00root root 0000000 0000000 AbstractXsdGeneratorMojo.java 0000664 0000000 0000000 00000125135 13511002134 0040533 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration package org.codehaus.mojo.jaxb2.schemageneration;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import com.sun.tools.jxc.SchemaGenerator;
import com.thoughtworks.qdox.JavaProjectBuilder;
import com.thoughtworks.qdox.model.JavaClass;
import com.thoughtworks.qdox.model.JavaPackage;
import com.thoughtworks.qdox.model.JavaSource;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.Parameter;
import org.codehaus.mojo.jaxb2.AbstractJaxbMojo;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.DefaultJavaDocRenderer;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.JavaDocExtractor;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.JavaDocRenderer;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.SearchableDocumentation;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.schemaenhancement.SimpleNamespaceResolver;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.schemaenhancement.TransformSchema;
import org.codehaus.mojo.jaxb2.shared.FileSystemUtilities;
import org.codehaus.mojo.jaxb2.shared.arguments.ArgumentBuilder;
import org.codehaus.mojo.jaxb2.shared.environment.EnvironmentFacet;
import org.codehaus.mojo.jaxb2.shared.environment.ToolExecutionEnvironment;
import org.codehaus.mojo.jaxb2.shared.environment.classloading.ThreadContextClassLoaderBuilder;
import org.codehaus.mojo.jaxb2.shared.environment.locale.LocaleFacet;
import org.codehaus.mojo.jaxb2.shared.environment.logging.LoggingHandlerEnvironmentFacet;
import org.codehaus.mojo.jaxb2.shared.filters.Filter;
import org.codehaus.mojo.jaxb2.shared.filters.pattern.PatternFileFilter;
import org.codehaus.plexus.classworlds.realm.ClassRealm;
import org.codehaus.plexus.util.FileUtils;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.regex.Pattern;
/**
* Abstract superclass for Mojos that generate XSD files from annotated Java Sources.
* This Mojo delegates execution to the {@code schemagen} tool to perform the XSD file
* generation. Moreover, the AbstractXsdGeneratorMojo provides an augmented processing
* pipeline by optionally letting a set of NodeProcessors improve the 'vanilla' XSD files.
*
* @author Lennart Jörelid
* @see The JAXB Reference Implementation
*/
public abstract class AbstractXsdGeneratorMojo extends AbstractJaxbMojo {
/**
* Pattern matching the names of files emitted by the JAXB/JDK SchemaGenerator.
* According to the JAXB Schema Generator documentation:
* There is no way to control the name of the generated schema files at this time.
*/
public static final Pattern SCHEMAGEN_EMITTED_FILENAME = Pattern.compile("schema\\p{javaDigit}+.xsd");
/**
* The default JavaDocRenderer used unless another JavaDocRenderer should be used.
*
* @see #javaDocRenderer
* @since 2.0
*/
public static final JavaDocRenderer STANDARD_JAVADOC_RENDERER = new DefaultJavaDocRenderer();
/**
* Default exclude file name suffixes for testSources, used unless overridden by an
* explicit configuration in the {@code testSourceExcludeSuffixes} parameter.
*
*
*
* final List<Filter<File>> schemagenTmp = new ArrayList<Filter<File>>();
* schemagenTmp.addAll(AbstractJaxbMojo.STANDARD_EXCLUDE_FILTERS);
* schemagenTmp.add(new PatternFileFilter(Arrays.asList("\\.java", "\\.scala", "\\.mdo"), false));
* STANDARD_BYTECODE_EXCLUDE_FILTERS = Collections.unmodifiableList(schemagenTmp);
*
*
*/
public static final List> STANDARD_BYTECODE_EXCLUDE_FILTERS;
/**
* Filter list containing a PatternFileFilter including ".class" files.
*/
public static final List> CLASS_INCLUDE_FILTERS;
/**
* Specification for packages which must be loaded using the SystemToolClassLoader (and not in the plugin's
* ThreadContext ClassLoader). The SystemToolClassLoader is used by SchemaGen to process some stuff from the
* {@code tools.jar} archive, in particular its exception types used to signal JAXB annotation Exceptions.
*
* @see ToolProvider#getSystemToolClassLoader()
*/
public static final List SYSTEM_TOOLS_CLASSLOADER_PACKAGES = Arrays.asList(
"com.sun.source.util",
"com.sun.source.tree");
static {
final List> schemagenTmp = new ArrayList>();
schemagenTmp.addAll(AbstractJaxbMojo.STANDARD_EXCLUDE_FILTERS);
schemagenTmp.add(new PatternFileFilter(Arrays.asList("\\.java", "\\.scala", "\\.mdo"), false));
STANDARD_BYTECODE_EXCLUDE_FILTERS = Collections.unmodifiableList(schemagenTmp);
CLASS_INCLUDE_FILTERS = new ArrayList>();
CLASS_INCLUDE_FILTERS.add(new PatternFileFilter(Arrays.asList("\\.class"), true));
}
// Internal state
private static final int SCHEMAGEN_INCORRECT_OPTIONS = -1;
private static final int SCHEMAGEN_COMPLETED_OK = 0;
private static final int SCHEMAGEN_JAXB_ERRORS = 1;
/**
* A List holding desired schema mappings, each of which binds a schema namespace URI to its desired prefix
* [optional] and the name of the resulting schema file [optional]. All given elements (uri, prefix, file) must be
* unique within the configuration; no two elements may have the same values.
* The example schema configuration below maps two namespace uris to prefixes and generated file names. This implies
* that http://some/namespace will be represented by the prefix some within the generated XML
* Schema files; creating namespace definitions on the form xmlns:some="http://some/namespace", and
* corresponding uses on the form <xs:element minOccurs="0"
* ref="some:anOptionalElementInSomeNamespace"/>. Moreover, the file element defines that the
* http://some/namespace definitions will be written to the file some_schema.xsd, and that all
* import references will be on the form <xs:import namespace="http://some/namespace"
* schemaLocation="some_schema.xsd"/>
* The example configuration below also performs identical operations for the namespace uri
* http://another/namespace with the prefix another and the file another_schema.xsd.
*
*
*
* <transformSchemas>
* <transformSchema>
* <uri>http://some/namespace</uri>
* <toPrefix>some</toPrefix>
* <toFile>some_schema.xsd</toFile>
* <transformSchema>
* <uri>http://another/namespace</uri>
* <toPrefix>another</toPrefix>
* <toFile>another_schema.xsd</toFile>
* </transformSchema>
* </transformSchemas>
*
*
*
* @since 1.4
*/
@Parameter
private List transformSchemas;
/**
* Deprecated - will be removed in a future release
* From plugin version 2.4, this parameter will not be used.
* Instead, episode files are generated by default with all JAXB operations.
* Starting with plugin version 2.4, use the parameter {@link #episodeFileName} to provide a custom
* name of the generated episode File (or rely on the standard file name {@link #STANDARD_EPISODE_FILENAME}).
*
* @since 2.0
* @deprecated
*/
@Deprecated
@Parameter(defaultValue = "true")
protected boolean generateEpisode;
/**
* Corresponding SchemaGen parameter: {@code episode}.
* Generate an episode file with the supplied name from this XSD generation, so that other schemas that rely
* on this schema can be compiled later and rely on classes that are generated from this compilation.
* The generated episode file is simply a JAXB customization file (but with vendor extensions), normally known
* as a binding file with the suffix .xjb.
* If the episodeFileName parameter is not given, the episode file name is synthesized on the form
* "episode_" + executionID + ".xjb" - typically something like episode_schemagen.xjb, but
* it depends on the actual ID given in the execution element:
*
*
* <executions>
* <execution>
* <id>schemagen</id>
* <goals>
* <goal>schemagen</goal>
* </goals>
* </execution>
* </executions>
*
*
*
* @see #STANDARD_EPISODE_FILENAME
* @since 2.4
*/
@Parameter
protected String episodeFileName;
/**
* If {@code true}, Elements or Attributes in the generated XSD files will be annotated with any
* JavaDoc found for their respective properties. If {@code false}, no XML documentation annotations will be
* generated in post-processing any results from the JAXB SchemaGenerator.
*
* @since 2.0
*/
@Parameter(defaultValue = "true")
protected boolean createJavaDocAnnotations;
/**
* A renderer used to create XML annotation text from JavaDoc comments found within the source code.
* Unless another implementation is provided, the standard JavaDocRenderer used is
* {@linkplain org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.DefaultJavaDocRenderer}.
*
* @see org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.DefaultJavaDocRenderer
* @since 2.0
*/
@Parameter
protected JavaDocRenderer javaDocRenderer;
/**
* Removes all files from the output directory before running SchemaGenerator.
*
* @since 2.0
*/
@Parameter(defaultValue = "true")
protected boolean clearOutputDir;
/**
* XSD schema files are not generated from POM projects or if no includes have been supplied.
* {@inheritDoc}
*/
@Override
protected boolean shouldExecutionBeSkipped() {
boolean toReturn = false;
if ("pom".equalsIgnoreCase(getProject().getPackaging())) {
warnAboutIncorrectPluginConfiguration("packaging", "POM-packaged projects should not generate XSDs.");
toReturn = true;
}
if (getSources().isEmpty()) {
warnAboutIncorrectPluginConfiguration("sources", "At least one Java Source file has to be included.");
toReturn = true;
}
// All done.
return toReturn;
}
/**
* {@inheritDoc}
*/
@Override
protected boolean isReGenerationRequired() {
//
// Use the stale flag method to identify if we should re-generate the XSDs from the sources.
// Basically, we should re-generate the XSDs if:
//
// a) The staleFile does not exist
// b) The staleFile exists and is older than one of the sources (Java or XJB files).
// "Older" is determined by comparing the modification timestamp of the staleFile and the source files.
//
final File staleFile = getStaleFile();
final String debugPrefix = "StaleFile [" + FileSystemUtilities.getCanonicalPath(staleFile) + "]";
boolean stale = !staleFile.exists();
if (stale) {
getLog().debug(debugPrefix + " not found. XML Schema (re-)generation required.");
} else {
final List sources = getSources();
if (getLog().isDebugEnabled()) {
getLog().debug(debugPrefix + " found. Checking timestamps on source Java "
+ "files to determine if XML Schema (re-)generation is required.");
}
final long staleFileLastModified = staleFile.lastModified();
for (URL current : sources) {
final URLConnection sourceFileConnection;
try {
sourceFileConnection = current.openConnection();
sourceFileConnection.connect();
} catch (Exception e) {
if (getLog().isDebugEnabled()) {
getLog().debug("Could not open a sourceFileConnection to [" + current + "]", e);
}
// Can't determine if the staleFile is younger than this source.
// Re-generate to be on the safe side.
stale = true;
break;
}
try {
if (sourceFileConnection.getLastModified() > staleFileLastModified) {
if (getLog().isDebugEnabled()) {
getLog().debug(current.toString() + " is newer than the stale flag file.");
}
stale = true;
}
} finally {
if (sourceFileConnection instanceof HttpURLConnection) {
((HttpURLConnection) sourceFileConnection).disconnect();
}
}
}
}
// All done.
return stale;
}
/**
* {@inheritDoc}
*/
@Override
protected boolean performExecution() throws MojoExecutionException, MojoFailureException {
boolean updateStaleFileTimestamp = false;
ToolExecutionEnvironment environment = null;
try {
//
// Ensure that classes that SchemaGen expects to be loaded in the SystemToolClassLoader
// is delegated to that ClassLoader, to comply with SchemaGen's internal reflective loading
// of classes. Otherwise we will have ClassCastExceptions instead of proper execution.
//
final ClassRealm localRealm = (ClassRealm) getClass().getClassLoader();
for (String current : SYSTEM_TOOLS_CLASSLOADER_PACKAGES) {
localRealm.importFrom(ToolProvider.getSystemToolClassLoader(), current);
}
// Configure the ThreadContextClassLoaderBuilder, to enable synthesizing a correct ClassPath for the tool.
final ThreadContextClassLoaderBuilder classLoaderBuilder = ThreadContextClassLoaderBuilder
.createFor(this.getClass(), getLog(), getEncoding(false))
.addPaths(getClasspath())
.addPaths(getProject().getCompileSourceRoots());
final LocaleFacet localeFacet = locale == null ? null : LocaleFacet.createFor(locale, getLog());
// Create the execution environment as required by the XJC tool.
environment = new ToolExecutionEnvironment(
getLog(),
classLoaderBuilder,
LoggingHandlerEnvironmentFacet.create(getLog(), getClass(), getEncoding(false)),
localeFacet);
final String projectBasedirPath = FileSystemUtilities.getCanonicalPath(getProject().getBasedir());
// Add any extra configured EnvironmentFacets, as configured in the POM.
if (extraFacets != null) {
for (EnvironmentFacet current : extraFacets) {
environment.add(current);
}
}
// Setup the environment.
environment.setup();
// Compile the SchemaGen arguments
final File episodeFile = getEpisodeFile(episodeFileName);
final List sources = getSources();
final String[] schemaGenArguments = getSchemaGenArguments(
environment.getClassPathAsArgument(),
episodeFile,
sources);
// Ensure that the outputDirectory and workDirectory exists.
// Clear them if configured to do so.
FileSystemUtilities.createDirectory(getOutputDirectory(), clearOutputDir);
FileSystemUtilities.createDirectory(getWorkDirectory(), clearOutputDir);
// Re-generate the episode file's parent directory.
getEpisodeFile(episodeFileName);
// Do we need to re-create the episode file's parent directory?
/*final boolean reCreateEpisodeFileParentDirectory = generateEpisode && clearOutputDir;
if (reCreateEpisodeFileParentDirectory) {
}
*/
try {
// Check the system properties.
// logSystemPropertiesAndBasedir();
// Fire the SchemaGenerator
final int result = SchemaGenerator.run(
schemaGenArguments,
Thread.currentThread().getContextClassLoader());
if (SCHEMAGEN_INCORRECT_OPTIONS == result) {
printSchemaGenCommandAndThrowException(projectBasedirPath,
sources,
schemaGenArguments,
result,
null);
} else if (SCHEMAGEN_JAXB_ERRORS == result) {
// TODO: Collect the error message(s) which was emitted by SchemaGen. How can this be done?
throw new MojoExecutionException("JAXB errors arose while SchemaGen compiled sources to XML.");
}
// Copy generated XSDs and episode files from the WorkDirectory to the OutputDirectory,
// but do not copy the intermediary bytecode files generated by schemagen.
final List> exclusionFilters = PatternFileFilter.createIncludeFilterList(
getLog(), "\\.class");
final List toCopy = FileSystemUtilities.resolveRecursively(
Arrays.asList(getWorkDirectory()),
exclusionFilters, getLog());
for (File current : toCopy) {
// Get the path to the current file
final String currentPath = FileSystemUtilities.getCanonicalPath(current.getAbsoluteFile());
final File target = new File(getOutputDirectory(),
FileSystemUtilities.relativize(currentPath, getWorkDirectory(), true));
// Copy the file to the same relative structure within the output directory.
FileSystemUtilities.createDirectory(target.getParentFile(), false);
FileUtils.copyFile(current, target);
}
//
// The XSD post-processing should be applied in the following order:
//
// 1. [XsdAnnotationProcessor]: Inject JavaDoc annotations for Classes.
// 2. [XsdEnumerationAnnotationProcessor]: Inject JavaDoc annotations for Enums.
// 3. [ChangeNamespacePrefixProcessor]: Change namespace prefixes within XSDs.
// 4. [ChangeFilenameProcessor]: Change the fileNames of XSDs.
//
final boolean performPostProcessing = createJavaDocAnnotations || transformSchemas != null;
if (performPostProcessing) {
// Map the XML Namespaces to their respective XML URIs (and reverse)
// The keys are the generated 'vanilla' XSD file names.
final Map resolverMap =
XsdGeneratorHelper.getFileNameToResolverMap(getOutputDirectory());
if (createJavaDocAnnotations) {
if (getLog().isInfoEnabled()) {
getLog().info("XSD post-processing: Adding JavaDoc annotations in generated XSDs.");
}
// Resolve the sources
final List fileSources = new ArrayList();
for (URL current : sources) {
if ("file".equalsIgnoreCase(current.getProtocol())) {
final File toAdd = new File(current.getPath());
if (toAdd.exists()) {
fileSources.add(toAdd);
} else {
if (getLog().isWarnEnabled()) {
getLog().warn("Ignoring URL [" + current + "] as it is a nonexistent file.");
}
}
}
}
final List files = FileSystemUtilities.resolveRecursively(
fileSources, null, getLog());
// Acquire JavaDocs
final JavaDocExtractor extractor = new JavaDocExtractor(getLog()).addSourceFiles(files);
final SearchableDocumentation javaDocs = extractor.process();
// Modify the 'vanilla' generated XSDs by inserting the JavaDoc as annotations
final JavaDocRenderer renderer = javaDocRenderer == null
? STANDARD_JAVADOC_RENDERER
: javaDocRenderer;
final int numProcessedFiles = XsdGeneratorHelper.insertJavaDocAsAnnotations(getLog(),
getEncoding(false),
getOutputDirectory(),
javaDocs,
renderer);
if (getLog().isDebugEnabled()) {
getLog().info("XSD post-processing: " + numProcessedFiles + " files processed.");
}
}
if (transformSchemas != null) {
if (getLog().isInfoEnabled()) {
getLog().info("XSD post-processing: Renaming and converting XSDs.");
}
// Transform all namespace prefixes as requested.
XsdGeneratorHelper.replaceNamespacePrefixes(resolverMap,
transformSchemas,
getLog(),
getOutputDirectory(),
getEncoding(false));
// Rename all generated schema files as requested.
XsdGeneratorHelper.renameGeneratedSchemaFiles(resolverMap,
transformSchemas,
getLog(),
getOutputDirectory(),
getEncoding(false));
}
}
} catch (MojoExecutionException e) {
throw e;
} catch (Exception e) {
// Find the root exception, and print its stack trace to the Maven Log.
// These invocation target exceptions tend to produce really deep stack traces,
// hiding the actual root cause of the exception.
Throwable current = e;
while (current.getCause() != null) {
current = current.getCause();
}
getLog().error("Execution failed.");
//
// Print a stack trace
//
StringBuilder rootCauseBuilder = new StringBuilder();
rootCauseBuilder.append("\n");
rootCauseBuilder.append("[Exception]: " + current.getClass().getName() + "\n");
rootCauseBuilder.append("[Message]: " + current.getMessage() + "\n");
for (StackTraceElement el : current.getStackTrace()) {
rootCauseBuilder.append(" " + el.toString()).append("\n");
}
getLog().error(rootCauseBuilder.toString().replaceAll("[\r\n]+", "\n"));
printSchemaGenCommandAndThrowException(projectBasedirPath,
sources,
schemaGenArguments,
-1,
current);
}
// Indicate that the output directory was updated.
getBuildContext().refresh(getOutputDirectory());
// Update the modification timestamp of the staleFile.
updateStaleFileTimestamp = true;
} finally {
// Restore the environment
if (environment != null) {
environment.restore();
}
}
// Add generated directories to
// All done.
return updateStaleFileTimestamp;
}
/**
* @return The working directory to which the SchemaGenerator should initially copy all its generated files,
* including bytecode files, compiled from java sources.
*/
protected abstract File getWorkDirectory();
/**
* Finds a List containing URLs to compiled bytecode files within this Compilation Unit.
* Typically this equals the resolved files under the project's build directories, plus any
* JAR artifacts found on the classpath.
*
* @return A non-null List containing URLs to bytecode files within this compilation unit.
* Typically this equals the resolved files under the project's build directories, plus any JAR
* artifacts found on the classpath.
*/
protected abstract List getCompiledClassNames();
/**
* Override this method to acquire a List holding all URLs to the SchemaGen Java sources for which this
* AbstractXsdGeneratorMojo should generate Xml Schema Descriptor files.
*
* @return A non-null List holding URLs to sources for the XSD generation.
*/
@Override
protected abstract List getSources();
//
// Private helpers
//
private String[] getSchemaGenArguments(final String classPath,
final File episodeFile,
final List sources)
throws MojoExecutionException {
final ArgumentBuilder builder = new ArgumentBuilder();
// Add all flags on the form '-flagName'
// builder.withFlag();
// Add all arguments on the form '-argumentName argumentValue'
// (i.e. in 2 separate elements of the returned String[])
builder.withNamedArgument("encoding", getEncoding(true));
builder.withNamedArgument("d", getWorkDirectory().getAbsolutePath());
builder.withNamedArgument("classpath", classPath);
// From 2.4: Always generate an episode file.
//
builder.withNamedArgument("episode", FileSystemUtilities.getCanonicalPath(episodeFile));
try {
//
// The SchemaGenerator does not support directories as arguments:
// "Caused by: java.lang.IllegalArgumentException: directories not supported"
// ... implying we must resolve source files in the compilation unit.
//
// There seems to be two ways of adding sources to the SchemaGen tool:
// 1) Using java source files
// Define the relative paths to source files, calculated from the System.property "user.dir"
// (i.e. *not* the Maven "basedir" property) on the form 'src/main/java/se/west/something/SomeClass.java'.
// Sample: javac -d . ../github_jaxb2_plugin/src/it/schemagen-main/src/main/java/se/west/gnat/Foo.java
//
// 2) Using bytecode files
// Define the CLASSPATH to point to build output directories (such as target/classes), and then use
// package notation arguments on the form 'se.west.something.SomeClass'.
// Sample: schemagen -d . -classpath brat se.west.gnat.Foo
//
// The jaxb2-maven-plugin uses these two methods in the order given.
//
builder.withPreCompiledArguments(getSchemaGeneratorSourceFiles(sources));
} catch (IOException e) {
throw new MojoExecutionException("Could not compile source paths for the SchemaGenerator", e);
}
// All done.
return logAndReturnToolArguments(builder.build(), "SchemaGen");
}
/**
* The SchemaGenerator does not support directories as arguments, implying we must resolve source
* files in the compilation unit. This fact is shown when supplying a directory argument as source, when
* the tool emits:
*
Caused by: java.lang.IllegalArgumentException: directories not supported
* There seems to be two ways of adding sources to the SchemaGen tool:
*
* - 1. Java Source files
* - Define the relative paths to source files, calculated from the System.property {@code user.dir}
* (i.e. not the Maven {@code basedir} property) on the form
* {@code src/main/java/se/west/something/SomeClass.java}.
* Sample: {@code javac -d . .
* ./github_jaxb2_plugin/src/it/schemagen-main/src/main/java/se/west/gnat/Foo.java}
* - 2. Bytecode files
* - Define the {@code CLASSPATH} to point to build output directories (such as target/classes), and then
* use package notation arguments on the form {@code se.west.something.SomeClass}.
* Sample: {@code schemagen -d . -classpath brat se.west.gnat.Foo}
*
* The jaxb2-maven-plugin uses these two methods in the order given
*
* @param sources The compiled sources (as calculated from the local project's
* source paths, {@code getSources()}).
* @return A sorted List holding all sources to be used by the SchemaGenerator. According to the SchemaGenerator
* documentation, the order in which the source arguments are provided is irrelevant.
* The sources are to be rendered as the final (open-ended) argument to the schemagen execution.
* @see #getSources()
*/
private List getSchemaGeneratorSourceFiles(final List sources)
throws IOException, MojoExecutionException {
final SortedMap className2SourcePath = new TreeMap();
final File baseDir = getProject().getBasedir();
final File userDir = new File(System.getProperty("user.dir"));
final String encoding = getEncoding(true);
// 1) Find/add all sources available in the compilation unit.
for (URL current : sources) {
final File sourceCodeFile = FileSystemUtilities.getFileFor(current, encoding);
// Calculate the relative path for the current source
final String relativePath = FileSystemUtilities.relativize(
FileSystemUtilities.getCanonicalPath(sourceCodeFile),
userDir,
true);
if (getLog().isDebugEnabled()) {
getLog().debug("SourceCodeFile ["
+ FileSystemUtilities.getCanonicalPath(sourceCodeFile)
+ "] and userDir [" + FileSystemUtilities.getCanonicalPath(userDir)
+ "] ==> relativePath: "
+ relativePath
+ ". (baseDir: " + FileSystemUtilities.getCanonicalPath(baseDir) + "]");
}
// Find the Java class(es) within the source.
final JavaProjectBuilder builder = new JavaProjectBuilder();
builder.setEncoding(encoding);
//
// Ensure that we include package-info.java classes in the SchemaGen compilation.
//
if (sourceCodeFile.getName().trim().equalsIgnoreCase(PACKAGE_INFO_FILENAME)) {
// For some reason, QDox requires the package-info.java to be added as a URL instead of a File.
builder.addSource(current);
final Collection packages = builder.getPackages();
if (packages.size() != 1) {
throw new MojoExecutionException("Exactly one package should be present in file ["
+ sourceCodeFile.getPath() + "]");
}
// Make the key indicate that this is the package-info.java file.
final JavaPackage javaPackage = packages.iterator().next();
className2SourcePath.put("package-info for (" + javaPackage.getName() + ")", relativePath);
continue;
}
// This is not a package-info.java file, so QDox lets us add this as a File.
builder.addSource(sourceCodeFile);
// Map any found FQCN to the relativized path of its source file.
for (JavaSource currentJavaSource : builder.getSources()) {
for (JavaClass currentJavaClass : currentJavaSource.getClasses()) {
final String className = currentJavaClass.getFullyQualifiedName();
if (className2SourcePath.containsKey(className)) {
if (getLog().isWarnEnabled()) {
getLog().warn("Already mapped. Source class [" + className + "] within ["
+ className2SourcePath.get(className)
+ "]. Not overwriting with [" + relativePath + "]");
}
} else {
className2SourcePath.put(className, relativePath);
}
}
}
}
/*
// 2) Find any bytecode available in the compilation unit, and add its file as a SchemaGen argument.
//
// The algorithm is:
// 1) Add bytecode classpath unless its class is already added in source form.
// 2) SchemaGen cannot handle directory arguments, so any bytecode files in classpath directories
// must be resolved.
// 3) All JARs in the classpath should be added as arguments to SchemaGen.
//
// .... Gosh ...
//
for (URL current : getCompiledClassNames()) {
getLog().debug(" (compiled ClassName) --> " + current.toExternalForm());
}
Filters.initialize(getLog(), CLASS_INCLUDE_FILTERS);
final List classPathURLs = new ArrayList();
for (String current : getClasspath()) {
final File currentFile = new File(current);
if (FileSystemUtilities.EXISTING_FILE.accept(currentFile)) {
// This is a file/JAR. Simply add its path to SchemaGen's arguments.
classPathURLs.add(FileSystemUtilities.getUrlFor(currentFile));
} else if (FileSystemUtilities.EXISTING_DIRECTORY.accept(currentFile)) {
// Resolve all bytecode files within this directory.
// FileSystemUtilities.filterFiles(baseDir, )
if (getLog().isDebugEnabled()) {
getLog().debug("TODO: Resolve and add bytecode files within: ["
+ FileSystemUtilities.getCanonicalPath(currentFile) + "]");
}
// Find the byte code files within the current directory.
final List byteCodeFiles = new ArrayList();
for(File currentResolvedFile : FileSystemUtilities.resolveRecursively(
Arrays.asList(currentFile), null, getLog())) {
if(Filters.matchAtLeastOnce(currentResolvedFile, CLASS_INCLUDE_FILTERS)) {
byteCodeFiles.add(currentResolvedFile);
}
}
for(File currentByteCodeFile : byteCodeFiles) {
final String currentCanonicalPath = FileSystemUtilities.getCanonicalPath(
currentByteCodeFile.getAbsoluteFile());
final String relativized = FileSystemUtilities.relativize(currentCanonicalPath,
FileSystemUtilities.getCanonicalFile(currentFile.getAbsoluteFile()));
final String pathFromUserDir = FileSystemUtilities.relativize(currentCanonicalPath, userDir);
final String className = relativized.substring(0, relativized.indexOf(".class"))
.replace("/", ".")
.replace(File.separator, ".");
if(!className2SourcePath.containsKey(className)) {
className2SourcePath.put(className, pathFromUserDir);
if(getLog().isDebugEnabled()) {
getLog().debug("Adding ByteCode [" + className + "] at relativized path ["
+ pathFromUserDir + "]");
}
} else {
if(getLog().isDebugEnabled()) {
getLog().debug("ByteCode [" + className + "] already added. Not re-adding.");
}
}
}
} else if (getLog().isWarnEnabled()) {
final String suffix = !currentFile.exists() ? " nonexistent" : " was neither a File nor a Directory";
getLog().warn("Classpath part [" + current + "] " + suffix + ". Ignoring it.");
}
}
/*
for (URL current : getCompiledClassNames()) {
// TODO: FIX THIS!
// Get the class information data from the supplied URL
for (String currentClassPathElement : getClasspath()) {
if(getLog().isDebugEnabled()) {
getLog().debug("Checking class path element: [" + currentClassPathElement + "]");
}
}
if(getLog().isDebugEnabled()) {
getLog().debug("Processing compiledClassName: [" + current + "]");
}
// Find the Java class(es) within the source.
final JavaProjectBuilder builder = new JavaProjectBuilder();
builder.setEncoding(getEncoding(true));
builder.addSource(current);
for (JavaSource currentSource : builder.getSources()) {
for (JavaClass currentClass : currentSource.getClasses()) {
final String className = currentClass.getFullyQualifiedName();
if (className2SourcePath.containsKey(className)) {
if (getLog().isWarnEnabled()) {
getLog().warn("Already mapped. Source class [" + className + "] within ["
+ className2SourcePath.get(className)
+ "]. Not overwriting with [" + className + "]");
}
} else {
className2SourcePath.put(className, className);
}
}
}
}
*/
if (getLog().isDebugEnabled()) {
final int size = className2SourcePath.size();
getLog().debug("[ClassName-2-SourcePath Map (size: " + size + ")] ...");
int i = 0;
for (Map.Entry current : className2SourcePath.entrySet()) {
getLog().debug(" " + (++i) + "/" + size + ": [" + current.getKey() + "]: "
+ current.getValue());
}
getLog().debug("... End [ClassName-2-SourcePath Map]");
}
// Sort the source paths and place them first in the argument array
final ArrayList toReturn = new ArrayList(className2SourcePath.values());
Collections.sort(toReturn);
// All Done.
return toReturn;
}
private void printSchemaGenCommandAndThrowException(final String projectBasedirPath,
final List sources,
final String[] schemaGenArguments,
final int result,
final Throwable cause) throws MojoExecutionException {
final StringBuilder errorMsgBuilder = new StringBuilder();
errorMsgBuilder.append("\n+=================== [SchemaGenerator Error '"
+ (result == -1 ? "" : result) + "']\n");
errorMsgBuilder.append("|\n");
errorMsgBuilder.append("| SchemaGen did not complete its operation correctly.\n");
errorMsgBuilder.append("|\n");
errorMsgBuilder.append("| To re-create the error (and get a proper error message), cd to:\n");
errorMsgBuilder.append("| ").append(projectBasedirPath).append("\n");
errorMsgBuilder.append("| ... and fire the following on a command line/in a shell:\n");
errorMsgBuilder.append("|\n");
final StringBuilder builder = new StringBuilder("schemagen ");
for (String current : schemaGenArguments) {
builder.append(current).append(" ");
}
errorMsgBuilder.append("| " + builder.toString() + "\n");
errorMsgBuilder.append("|\n");
errorMsgBuilder.append("| The following source files should be processed by schemagen:\n");
for (int i = 0; i < sources.size(); i++) {
errorMsgBuilder.append("| " + i + ": ").append(sources.get(i).toString()).append("\n");
}
errorMsgBuilder.append("|\n");
errorMsgBuilder.append("+=================== [End SchemaGenerator Error]\n");
final String msg = errorMsgBuilder.toString().replaceAll("[\r\n]+", "\n");
if (cause != null) {
throw new MojoExecutionException(msg, cause);
} else {
throw new MojoExecutionException(msg);
}
}
}
SchemaGenerationMojo.java 0000664 0000000 0000000 00000027413 13511002134 0037656 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration package org.codehaus.mojo.jaxb2.schemageneration;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.apache.maven.artifact.DependencyResolutionRequiredException;
import org.apache.maven.model.Resource;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.plugins.annotations.ResolutionScope;
import org.codehaus.mojo.jaxb2.AbstractJaxbMojo;
import org.codehaus.mojo.jaxb2.shared.FileSystemUtilities;
import org.codehaus.mojo.jaxb2.shared.filters.Filter;
import org.codehaus.mojo.jaxb2.shared.filters.Filters;
import org.codehaus.mojo.jaxb2.shared.filters.pattern.PatternFileFilter;
import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* Mojo that creates XML schema(s) from compile-scope Java sources or binaries
* by invoking the JAXB SchemaGenerator. This implementation is tailored to use the
* JAXB Reference Implementation from project Kenai.
* Note that the SchemaGenerationMojo was completely re-implemented for the 2.x versions.
* Its configuration semantics and parameter set is not necessarily
* backwards compatible with the 1.x plugin versions. If you are
* upgrading from version 1.x of the plugin, read the documentation carefully.
*
* @author Lennart Jörelid
* @see The JAXB Reference Implementation
*/
@Mojo(name = "schemagen",
defaultPhase = LifecyclePhase.GENERATE_RESOURCES,
requiresDependencyResolution = ResolutionScope.COMPILE,
threadSafe = true)
public class SchemaGenerationMojo extends AbstractXsdGeneratorMojo {
/**
* The last part of the stale fileName for this SchemaGenerationMojo.
*/
public static final String STALE_FILENAME = "schemaGenerationStaleFlag";
/**
* Default exclude file name suffixes for sources, used unless overridden by an
* explicit configuration in the {@code sourceExcludeSuffixes} parameter.
* The default values are found as follows:
*
*
* final List<Filter<File>> srcTemp = new ArrayList<Filter<File>>();
* srcTemp.addAll(AbstractJaxbMojo.STANDARD_EXCLUDE_FILTERS);
* srcTemp.add(new PatternFileFilter(Arrays.asList("\\.xjb", "\\.xsd", "\\.properties"), true));
* STANDARD_SOURCE_EXCLUDE_FILTERS = Collections.unmodifiableList(srcTemp);
*
*
*
* @see #STANDARD_EXCLUDE_FILTERS
*/
public static final List> STANDARD_SOURCE_EXCLUDE_FILTERS;
static {
final List> srcTemp = new ArrayList>();
srcTemp.addAll(AbstractJaxbMojo.STANDARD_EXCLUDE_FILTERS);
srcTemp.add(new PatternFileFilter(Arrays.asList("\\.xjb", "\\.xsd", "\\.properties"), true));
STANDARD_SOURCE_EXCLUDE_FILTERS = Collections.unmodifiableList(srcTemp);
}
/**
* Parameter holding List of paths to files and/or directories which should be recursively searched
* for Java source files. Only files or directories that actually exist will be included (in the case of files)
* or recursively searched for source files to include (in the case of directories or JARs).
* Configure using standard Maven structure for Lists:
*
*
* <configuration>
* ...
* <sources>
* <source>/a/full/absolute/path/to/a/SourceFile.java</source>
* <source>target/some/sourceJar.jar</source>
* <source>src/main/java</source>
* </sources>
* </configuration>
*
*
* Note: if configured, the sources parameters replace the default
* value, which is a List containing the paths to the directories defined by
* {@code getProject().getCompileSourceRoots()}.
*
* @since 2.0
*/
@Parameter(required = false)
private List sources;
/**
* Parameter holding a List of Filters, used to match all files under the {@code sources} directories
* which should not be considered SchemaGenerator source files. (The filters identify files to
* exclude, and hence this parameter is called {@code schemaSourceExcludeFilters}). If a file under any of the
* source directories matches at least one of the Filters supplied in the {@code schemaSourceExcludeFilters},
* it is not considered an XJC source file, and therefore excluded from processing.
* If not explicitly provided, the Mojo uses the value within {@code STANDARD_SOURCE_EXCLUDE_FILTERS}.
* The algorithm for finding XJC sources is as follows:
*
* - Find all files given in the sources List. Any Directories provided are searched for files
* recursively.
* - Exclude any found files matching any of the supplied {@code schemaSourceExcludeFilters} List.
* - The remaining Files are submitted for processing by the XJC tool.
*
* Example: The following configuration would exclude any sources whose names end with
* {@code .txt} or {@code .foo}:
*
*
* <configuration>
* ...
* <schemaSourceExcludeFilters>
* <filter implementation="org.codehaus.mojo.jaxb2.shared.filters.pattern.PatternFileFilter">
* <patterns>
* <pattern>\.txt</pattern>
* <pattern>\.foo</pattern>
* </patterns>
* </filter>
* </schemaSourceExcludeFilters>
* </configuration>
*
*
* Note that inner workings of the Dependency Injection mechanism used by Maven Plugins (i.e. the DI from
* the Plexus container) requires that the full class name to the Filter implementation should be supplied for
* each filter, as is illustrated in the sample above. This is true also if you implement custom Filters.
*
* @see #STANDARD_SOURCE_EXCLUDE_FILTERS
* @see org.codehaus.mojo.jaxb2.shared.filters.pattern.PatternFileFilter
* @see org.codehaus.mojo.jaxb2.shared.filters.pattern.AbstractPatternFilter
* @see org.codehaus.mojo.jaxb2.shared.filters.AbstractFilter
* @since 2.0
*/
@Parameter(required = false)
private List> schemaSourceExcludeFilters;
/**
* The directory where the generated XML Schema file(s) will be
* placed, after all transformations are done.
*/
@Parameter(defaultValue = "${project.build.directory}/generated-resources/schemagen", required = true)
private File outputDirectory;
/**
* The directory where the {@code schemagen} tool will output XSDs, episode files - and intermediary bytecode
* files. From this directory the XSDs and the episode file (but not the bytecode files) will be copied to the
* outputDirectory for further processing.
*
* @see #outputDirectory
*/
@Parameter(defaultValue = "${project.build.directory}/schemagen-work/compile_scope", required = true)
private File workDirectory;
/**
* {@inheritDoc}
*/
@Override
protected List getCompiledClassNames() {
List> excludeFilters = schemaSourceExcludeFilters == null
? STANDARD_BYTECODE_EXCLUDE_FILTERS
: schemaSourceExcludeFilters;
Filters.initialize(getLog(), excludeFilters);
try {
return FileSystemUtilities.filterFiles(
getProject().getBasedir(),
null,
getProject().getCompileClasspathElements(),
getLog(),
"compiled bytecode",
excludeFilters);
} catch (DependencyResolutionRequiredException e) {
throw new IllegalStateException("Could not resolve dependencies.", e);
}
}
/**
* {@inheritDoc}
*/
@Override
protected List getSources() {
final List> sourceExcludes = schemaSourceExcludeFilters == null
? STANDARD_SOURCE_EXCLUDE_FILTERS
: schemaSourceExcludeFilters;
Filters.initialize(getLog(), sourceExcludes);
final List defaultSources = getProject().getCompileSourceRoots();
// All Done.
return FileSystemUtilities.filterFiles(
getProject().getBasedir(),
(sources == null) ? defaultSources : sources,
defaultSources,
getLog(),
"sources",
sourceExcludes);
}
/**
* {@inheritDoc}
*/
@Override
protected File getOutputDirectory() {
return outputDirectory;
}
/**
* {@inheritDoc}
*/
@Override
protected List getClasspath() throws MojoExecutionException {
List toReturn = null;
try {
toReturn = getProject().getCompileClasspathElements();
} catch (DependencyResolutionRequiredException e) {
throw new MojoExecutionException("Could not acquire compile classpath elements from MavenProject", e);
}
// All done.
return toReturn;
}
/**
* {@inheritDoc}
*/
@Override
protected String getStaleFileName() {
return STALE_FILENAME;
}
/**
* {@inheritDoc}
*/
@Override
protected File getWorkDirectory() {
return workDirectory;
}
/**
* {@inheritDoc}
*/
@Override
protected void addResource(final Resource resource) {
if(resource != null) {
final String newDirectory = resource.getDirectory();
// Is the supplied resource already added?
final List currentResources = getProject().getResources();
if(getLog().isDebugEnabled()) {
getLog().debug("Candidate Resource Directory [" + newDirectory + "]");
getLog().debug("Found [" + currentResources.size() + "] current Resources: "
+ currentResources);
}
for (Resource current : currentResources) {
// Is the resource already added?
if(current.getDirectory() != null && current.getDirectory().equalsIgnoreCase(newDirectory)) {
getLog().debug("Resource already added [" + newDirectory + "]. Not adding again.");
return;
}
}
// Add the new Resource
currentResources.add(resource);
if(getLog().isDebugEnabled()) {
getLog().debug("Added resource [" + newDirectory + "] to existing resources.");
}
}
}
}
TestSchemaGenerationMojo.java 0000664 0000000 0000000 00000027675 13511002134 0040530 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration package org.codehaus.mojo.jaxb2.schemageneration;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.apache.maven.artifact.DependencyResolutionRequiredException;
import org.apache.maven.model.Resource;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.plugins.annotations.ResolutionScope;
import org.codehaus.mojo.jaxb2.AbstractJaxbMojo;
import org.codehaus.mojo.jaxb2.shared.FileSystemUtilities;
import org.codehaus.mojo.jaxb2.shared.filters.Filter;
import org.codehaus.mojo.jaxb2.shared.filters.Filters;
import org.codehaus.mojo.jaxb2.shared.filters.pattern.PatternFileFilter;
import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* Mojo that creates XML schema(s) from test-scope Java testSources or binaries
* by invoking the JAXB SchemaGenerator. This implementation is tailored to use the
* JAXB Reference Implementation from project Kenai.
* Note that the TestSchemaGenerationMojo was completely re-implemented for the 2.x versions.
* Its configuration semantics and parameter set is not backwards compatible
* with the 1.x plugin versions. If you are upgrading from version 1.x of the plugin, read
* the documentation carefully.
*
* @author Lennart Jörelid
* @see The JAXB Reference Implementation
*/
@Mojo(name = "testSchemagen",
defaultPhase = LifecyclePhase.GENERATE_TEST_RESOURCES,
requiresDependencyResolution = ResolutionScope.TEST,
threadSafe = true)
public class TestSchemaGenerationMojo extends AbstractXsdGeneratorMojo {
/**
* The last part of the stale fileName for this TestSchemaGenerationMojo.
*/
public static final String STALE_FILENAME = "testSchemaGenerationStaleFlag";
/**
* Default exclude file name suffixes for testSources, used unless overridden by an
* explicit configuration in the {@code testSchemaSourceExcludeFilters} parameter.
* The default values are found as follows:
*
*
* final List<Filter<File>> testSrcTemp = new ArrayList<Filter<File>>();
* testSrcTemp.addAll(AbstractJaxbMojo.STANDARD_EXCLUDE_FILTERS);
* testSrcTemp.add(new PatternFileFilter(Arrays.asList("\\.xjb", "\\.xsd", "\\.properties"), true));
* STANDARD_TEST_SOURCE_EXCLUDE_FILTERS = Collections.unmodifiableList(testSrcTemp);
*
*
*
* @see #STANDARD_EXCLUDE_FILTERS
*/
public static final List> STANDARD_TEST_SOURCE_EXCLUDE_FILTERS;
static {
final List> testSrcTemp = new ArrayList>();
testSrcTemp.addAll(AbstractJaxbMojo.STANDARD_EXCLUDE_FILTERS);
testSrcTemp.add(new PatternFileFilter(Arrays.asList("\\.xjb", "\\.xsd", "\\.properties"), true));
STANDARD_TEST_SOURCE_EXCLUDE_FILTERS = Collections.unmodifiableList(testSrcTemp);
}
/**
* Parameter holding List of paths to files and/or directories which should be recursively searched
* for Java source files. Only files or directories that actually exist will be included (in the case of files)
* or recursively searched for source files to include (in the case of directories or JARs).
* Configure using standard Maven structure for Lists:
*
*
* <configuration>
* ...
* <testSources>
* <testSource>/a/full/absolute/path/to/a/SourceFile.java</testSource>
* <testSource>target/some/sourceJar.jar</test>
* <testSource>src/test/java</test>
* </testSources>
* </configuration>
*
*
* Note: if configured, the sources parameters replace the default
* value, which is a List containing the paths to the directories defined by
* {@code getProject().getTestCompileSourceRoots()}.
*
* @since 2.0
*/
@Parameter(required = false)
private List testSources;
/**
* Parameter holding a List of Filters, used to match all files under the {@code testSources} directories
* which should not be considered SchemaGenerator testSource files. (The filters identify files to
* exclude, and hence this parameter is called {@code testSchemaSourceExcludeFilters}). If a file under any of the
* testSource directories matches at least one of the Filters supplied in the
* {@code testSchemaSourceExcludeFilters}, it is not considered an XJC test source file, and therefore excluded
* from processing.
* If not explicitly provided, the Mojo uses the value within {@code STANDARD_TEST_SOURCE_EXCLUDE_FILTERS}.
* The algorithm for finding XJC sources is as follows:
*
* - Find all files given in the testSources List. Any Directories provided are searched for files
* recursively.
* - Exclude any found files matching any of the supplied {@code testSchemaSourceExcludeFilters} List.
* - The remaining Files are submitted for processing by the XJC tool.
*
* Example: The following configuration would exclude any testSources whose names end with
* {@code .txt} or {@code .foo}:
*
*
* <configuration>
* ...
* <testSchemaSourceExcludeFilters>
* <filter implementation="org.codehaus.mojo.jaxb2.shared.filters.pattern.PatternFileFilter">
* <patterns>
* <pattern>\.txt</pattern>
* <pattern>\.foo</pattern>
* </patterns>
* </filter>
* </testSchemaSourceExcludeFilters>
* </configuration>
*
*
* Note that inner workings of the Dependency Injection mechanism used by Maven Plugins (i.e. the DI from
* the Plexus container) requires that the full class name to the Filter implementation should be supplied for
* each filter, as is illustrated in the sample above. This is true also if you implement custom Filters.
*
* @see #STANDARD_TEST_SOURCE_EXCLUDE_FILTERS
* @see org.codehaus.mojo.jaxb2.shared.filters.pattern.PatternFileFilter
* @see org.codehaus.mojo.jaxb2.shared.filters.pattern.AbstractPatternFilter
* @see org.codehaus.mojo.jaxb2.shared.filters.AbstractFilter
*/
@Parameter(required = false)
private List> testSchemaSourceExcludeFilters;
/**
* The directory where the generated XML Schema file(s) will be placed.
*/
@Parameter(defaultValue = "${project.build.directory}/generated-test-resources/schemagen", required = true)
private File outputDirectory;
/**
* The directory where the {@code schemagen} tool will output XSDs, episode files - and intermediary bytecode
* files. From this directory the XSDs and the episode file (but not the bytecode files) will be copied to the
* outputDirectory for further processing.
*
* @see #outputDirectory
*/
@Parameter(defaultValue = "${project.build.directory}/schemagen-work/test_scope", required = true)
private File testWorkDirectory;
/**
* {@inheritDoc}
*/
@Override
protected List getCompiledClassNames() {
final List> excludeFilters = testSchemaSourceExcludeFilters == null
? STANDARD_BYTECODE_EXCLUDE_FILTERS
: testSchemaSourceExcludeFilters;
Filters.initialize(getLog(), excludeFilters);
final List defaultTestSources = getProject().getTestCompileSourceRoots();
try {
return FileSystemUtilities.filterFiles(
getProject().getBasedir(),
(testSources == null) ? defaultTestSources : testSources,
defaultTestSources,
getLog(),
"test-compiled bytecode",
excludeFilters);
} catch (Exception e) {
throw new IllegalStateException("Could not resolve test classpath elements.", e);
}
}
/**
* {@inheritDoc}
*/
@Override
protected List getClasspath() throws MojoExecutionException {
List toReturn = null;
try {
toReturn = getProject().getTestClasspathElements();
} catch (DependencyResolutionRequiredException e) {
throw new MojoExecutionException("Could not acquire compile classpath elements from MavenProject", e);
}
// All done.
return toReturn;
}
/**
* {@inheritDoc}
*/
@Override
protected List getSources() {
final List> excludeFilters = testSchemaSourceExcludeFilters == null
? STANDARD_TEST_SOURCE_EXCLUDE_FILTERS
: testSchemaSourceExcludeFilters;
Filters.initialize(getLog(), excludeFilters);
return FileSystemUtilities.filterFiles(
getProject().getBasedir(),
testSources,
getProject().getTestCompileSourceRoots(),
getLog(),
"test schema sources",
excludeFilters);
}
/**
* {@inheritDoc}
*/
@Override
protected File getOutputDirectory() {
return outputDirectory;
}
/**
* {@inheritDoc}
*/
@Override
protected String getStaleFileName() {
return STALE_FILENAME;
}
/**
* {@inheritDoc}
*/
@Override
protected File getWorkDirectory() {
return testWorkDirectory;
}
/**
* {@inheritDoc}
*/
@Override
protected void addResource(final Resource resource) {
if (resource != null) {
final String newDirectory = resource.getDirectory();
// Is the supplied resource already added?
final List currentResources = getProject().getTestResources();
if (getLog().isDebugEnabled()) {
getLog().debug("Candidate Test Resource Directory [" + newDirectory + "]");
getLog().debug("Found [" + currentResources.size() + "] current Test Resources: "
+ currentResources);
}
for (Resource current : currentResources) {
// Is the resource already added?
if (current.getDirectory() != null && current.getDirectory().equalsIgnoreCase(newDirectory)) {
getLog().debug("Test resource already added [" + newDirectory + "]. Not adding again.");
return;
}
}
// Add the new Resource
currentResources.add(resource);
if (getLog().isDebugEnabled()) {
getLog().debug("Added test resource [" + newDirectory + "] to existing test resources.");
}
}
}
}
XsdGeneratorHelper.java 0000664 0000000 0000000 00000065254 13511002134 0037367 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration package org.codehaus.mojo.jaxb2.schemageneration;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.logging.Log;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.NodeProcessor;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.JavaDocRenderer;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.SearchableDocumentation;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.XsdAnnotationProcessor;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.XsdEnumerationAnnotationProcessor;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.schemaenhancement.ChangeFilenameProcessor;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.schemaenhancement.ChangeNamespacePrefixProcessor;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.schemaenhancement.SimpleNamespaceResolver;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.schemaenhancement.TransformSchema;
import org.codehaus.mojo.jaxb2.shared.FileSystemUtilities;
import org.codehaus.mojo.jaxb2.shared.Validate;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.StringUtils;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileFilter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
/**
* Utility class holding algorithms used when generating XSD schema.
*
* @author Lennart Jörelid
* @since 1.4
*/
public final class XsdGeneratorHelper {
// Constants
private static final String MISCONFIG = "Misconfiguration detected: ";
private static TransformerFactory FACTORY;
private static final FileFilter RECURSIVE_XSD_FILTER;
/**
* Hide the constructor for utility classes.
*/
private XsdGeneratorHelper() {
// Do nothing.
}
static {
// Create the static filter used for recursive generated XSD files detection.
RECURSIVE_XSD_FILTER = new FileFilter() {
@Override
public boolean accept(final File toMatch) {
if (toMatch.exists()) {
// Accept directories for recursive operation, and
// files with names matching the SCHEMAGEN_EMITTED_FILENAME Pattern.
return toMatch.isDirectory()
|| AbstractXsdGeneratorMojo.SCHEMAGEN_EMITTED_FILENAME.matcher(toMatch.getName()).matches();
}
// Not a directory or XSD file.
return false;
}
};
}
/**
* Acquires a map relating generated schema filename to its SimpleNamespaceResolver.
*
* @param outputDirectory The output directory of the generated schema files.
* @return a map relating generated schema filename to an initialized SimpleNamespaceResolver.
* @throws MojoExecutionException if two generated schema files used the same namespace URI.
*/
public static Map getFileNameToResolverMap(final File outputDirectory)
throws MojoExecutionException {
final Map toReturn = new TreeMap();
// Each generated schema file should be written to the output directory.
// Each generated schema file should have a unique targetNamespace.
File[] generatedSchemaFiles = outputDirectory.listFiles(new FileFilter() {
public boolean accept(File pathname) {
return pathname.getName().startsWith("schema") && pathname.getName().endsWith(".xsd");
}
});
for (File current : generatedSchemaFiles) {
toReturn.put(current.getName(), new SimpleNamespaceResolver(current));
}
return toReturn;
}
/**
* Validates that the list of Schemas provided within the configuration all contain unique values. Should a
* MojoExecutionException be thrown, it contains informative text about the exact nature of the configuration
* problem - we should simplify for all plugin users.
*
* @param configuredTransformSchemas The List of configuration schemas provided to this mojo.
* @throws MojoExecutionException if any two configuredSchemas instances contain duplicate values for any of the
* properties uri, prefix or file. Also throws a MojoExecutionException if the uri of any Schema is null
* or empty, or if none of the 'file' and 'prefix' properties are given within any of the
* configuredSchema instances.
*/
public static void validateSchemasInPluginConfiguration(final List configuredTransformSchemas)
throws MojoExecutionException {
final List uris = new ArrayList();
final List prefixes = new ArrayList();
final List fileNames = new ArrayList();
for (int i = 0; i < configuredTransformSchemas.size(); i++) {
final TransformSchema current = configuredTransformSchemas.get(i);
final String currentURI = current.getUri();
final String currentPrefix = current.getToPrefix();
final String currentFile = current.getToFile();
// We cannot work with a null or empty uri
if (StringUtils.isEmpty(currentURI)) {
throw new MojoExecutionException(MISCONFIG + "Null or empty property 'uri' found in "
+ "plugin configuration for schema element at index [" + i + "]: " + current);
}
// No point in having *only* a namespace.
if (StringUtils.isEmpty(currentPrefix) && StringUtils.isEmpty(currentFile)) {
throw new MojoExecutionException(MISCONFIG + "Null or empty properties 'prefix' "
+ "and 'file' found within plugin configuration for schema element at index ["
+ i + "]: " + current);
}
// Validate that all given uris are unique.
if (uris.contains(currentURI)) {
throw new MojoExecutionException(getDuplicationErrorMessage("uri", currentURI,
uris.indexOf(currentURI), i));
}
uris.add(currentURI);
// Validate that all given prefixes are unique.
if (prefixes.contains(currentPrefix) && !(currentPrefix == null)) {
throw new MojoExecutionException(getDuplicationErrorMessage("prefix", currentPrefix,
prefixes.indexOf(currentPrefix), i));
}
prefixes.add(currentPrefix);
// Validate that all given files are unique.
if (fileNames.contains(currentFile)) {
throw new MojoExecutionException(getDuplicationErrorMessage("file", currentFile,
fileNames.indexOf(currentFile), i));
}
fileNames.add(currentFile);
}
}
/**
* Inserts XML documentation annotations into all generated XSD files found
* within the supplied outputDir.
*
* @param log A Maven Log.
* @param outputDir The outputDir, where generated XSD files are found.
* @param docs The SearchableDocumentation for the source files within the compilation unit.
* @param renderer The JavaDocRenderer used to convert JavaDoc annotations into XML documentation annotations.
* @return The number of processed XSDs.
*/
public static int insertJavaDocAsAnnotations(final Log log,
final String encoding,
final File outputDir,
final SearchableDocumentation docs,
final JavaDocRenderer renderer) {
// Check sanity
Validate.notNull(docs, "docs");
Validate.notNull(log, "log");
Validate.notNull(outputDir, "outputDir");
Validate.isTrue(outputDir.isDirectory(), "'outputDir' must be a Directory.");
Validate.notNull(renderer, "renderer");
int processedXSDs = 0;
final List foundFiles = new ArrayList();
addRecursively(foundFiles, RECURSIVE_XSD_FILTER, outputDir);
if (foundFiles.size() > 0) {
// Create the processors.
final XsdAnnotationProcessor classProcessor = new XsdAnnotationProcessor(docs, renderer);
final XsdEnumerationAnnotationProcessor enumProcessor
= new XsdEnumerationAnnotationProcessor(docs, renderer);
for (File current : foundFiles) {
// Create an XSD document from the current File.
final Document generatedSchemaFileDocument = parseXmlToDocument(current);
// Replace all namespace prefixes within the provided document.
process(generatedSchemaFileDocument.getFirstChild(), true, classProcessor);
processedXSDs++;
// Overwrite the vanilla file.
savePrettyPrintedDocument(generatedSchemaFileDocument, current, encoding);
}
} else {
if (log.isWarnEnabled()) {
log.warn("Found no generated 'vanilla' XSD files to process under ["
+ FileSystemUtilities.getCanonicalPath(outputDir) + "]. Aborting processing.");
}
}
// All done.
return processedXSDs;
}
/**
* Replaces all namespaces within generated schema files, as instructed by the configured Schema instances.
*
* @param resolverMap The map relating generated schema file name to SimpleNamespaceResolver instances.
* @param configuredTransformSchemas The Schema instances read from the configuration of this plugin.
* @param mavenLog The active Log.
* @param schemaDirectory The directory where all generated schema files reside.
* @param encoding The encoding to use when writing the file.
* @throws MojoExecutionException If the namespace replacement could not be done.
*/
public static void replaceNamespacePrefixes(
final Map resolverMap,
final List configuredTransformSchemas,
final Log mavenLog,
final File schemaDirectory,
final String encoding) throws MojoExecutionException {
if (mavenLog.isDebugEnabled()) {
mavenLog.debug("Got resolverMap.keySet() [generated filenames]: " + resolverMap.keySet());
}
for (SimpleNamespaceResolver currentResolver : resolverMap.values()) {
File generatedSchemaFile = new File(schemaDirectory, currentResolver.getSourceFilename());
Document generatedSchemaFileDocument = null;
for (TransformSchema currentTransformSchema : configuredTransformSchemas) {
// Should we alter the namespace prefix as instructed by the current schema?
final String newPrefix = currentTransformSchema.getToPrefix();
final String currentUri = currentTransformSchema.getUri();
if (StringUtils.isNotEmpty(newPrefix)) {
// Find the old/current prefix of the namespace for the current schema uri.
final String oldPrefix = currentResolver.getNamespaceURI2PrefixMap().get(currentUri);
if (StringUtils.isNotEmpty(oldPrefix)) {
// Can we perform the prefix substitution?
validatePrefixSubstitutionIsPossible(oldPrefix, newPrefix, currentResolver);
if (mavenLog.isDebugEnabled()) {
mavenLog.debug("Subtituting namespace prefix [" + oldPrefix + "] with [" + newPrefix
+ "] in file [" + currentResolver.getSourceFilename() + "].");
}
// Get the Document of the current schema file.
if (generatedSchemaFileDocument == null) {
generatedSchemaFileDocument = parseXmlToDocument(generatedSchemaFile);
}
// Replace all namespace prefixes within the provided document.
process(generatedSchemaFileDocument.getFirstChild(), true,
new ChangeNamespacePrefixProcessor(oldPrefix, newPrefix));
}
}
}
if (generatedSchemaFileDocument != null) {
// Overwrite the generatedSchemaFile with the content of the generatedSchemaFileDocument.
mavenLog.debug("Overwriting file [" + currentResolver.getSourceFilename() + "] with content ["
+ getHumanReadableXml(generatedSchemaFileDocument) + "]");
savePrettyPrintedDocument(generatedSchemaFileDocument, generatedSchemaFile, encoding);
} else {
mavenLog.debug("No namespace prefix changes to generated schema file ["
+ generatedSchemaFile.getName() + "]");
}
}
}
/**
* Updates all schemaLocation attributes within the generated schema files to match the 'file' properties within the
* Schemas read from the plugin configuration. After that, the files are physically renamed.
*
* @param resolverMap The map relating generated schema file name to SimpleNamespaceResolver instances.
* @param configuredTransformSchemas The Schema instances read from the configuration of this plugin.
* @param mavenLog The active Log.
* @param schemaDirectory The directory where all generated schema files reside.
* @param charsetName The encoding / charset name.
*/
public static void renameGeneratedSchemaFiles(final Map resolverMap,
final List configuredTransformSchemas,
final Log mavenLog,
final File schemaDirectory,
final String charsetName) {
// Create the map relating namespace URI to desired filenames.
Map namespaceUriToDesiredFilenameMap = new TreeMap();
for (TransformSchema current : configuredTransformSchemas) {
if (StringUtils.isNotEmpty(current.getToFile())) {
namespaceUriToDesiredFilenameMap.put(current.getUri(), current.getToFile());
}
}
// Replace the schemaLocation values to correspond to the new filenames
for (SimpleNamespaceResolver currentResolver : resolverMap.values()) {
File generatedSchemaFile = new File(schemaDirectory, currentResolver.getSourceFilename());
Document generatedSchemaFileDocument = parseXmlToDocument(generatedSchemaFile);
// Replace all namespace prefixes within the provided document.
process(generatedSchemaFileDocument.getFirstChild(), true,
new ChangeFilenameProcessor(namespaceUriToDesiredFilenameMap));
// Overwrite the generatedSchemaFile with the content of the generatedSchemaFileDocument.
if (mavenLog.isDebugEnabled()) {
mavenLog.debug("Changed schemaLocation entries within [" + currentResolver.getSourceFilename() + "]. "
+ "Result: [" + getHumanReadableXml(generatedSchemaFileDocument) + "]");
}
savePrettyPrintedDocument(generatedSchemaFileDocument, generatedSchemaFile, charsetName);
}
// Now, rename the actual files.
for (SimpleNamespaceResolver currentResolver : resolverMap.values()) {
final String localNamespaceURI = currentResolver.getLocalNamespaceURI();
if (StringUtils.isEmpty(localNamespaceURI)) {
mavenLog.warn("SimpleNamespaceResolver contained no localNamespaceURI; aborting rename.");
continue;
}
final String newFilename = namespaceUriToDesiredFilenameMap.get(localNamespaceURI);
final File originalFile = new File(schemaDirectory, currentResolver.getSourceFilename());
if (StringUtils.isNotEmpty(newFilename)) {
File renamedFile = FileUtils.resolveFile(schemaDirectory, newFilename);
String renameResult = (originalFile.renameTo(renamedFile) ? "Success " : "Failure ");
if (mavenLog.isDebugEnabled()) {
String suffix = "renaming [" + originalFile.getAbsolutePath() + "] to [" + renamedFile + "]";
mavenLog.debug(renameResult + suffix);
}
}
}
}
/**
* Drives the supplied visitor to process the provided Node and all its children, should the recurseToChildren flag
* be set to true. All attributes of the current node are processed before recursing to children (i.e.
* breadth first recursion).
*
* @param node The Node to process.
* @param recurseToChildren if true, processes all children of the supplied node recursively.
* @param visitor The NodeProcessor instance which should process the nodes.
*/
public static void process(final Node node, final boolean recurseToChildren, final NodeProcessor visitor) {
// Process the current Node, if the NodeProcessor accepts it.
if (visitor.accept(node)) {
visitor.process(node);
}
NamedNodeMap attributes = node.getAttributes();
for (int i = 0; i < attributes.getLength(); i++) {
Node attribute = attributes.item(i);
// Process the current attribute, if the NodeProcessor accepts it.
if (visitor.accept(attribute)) {
visitor.process(attribute);
}
}
if (recurseToChildren) {
NodeList children = node.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node child = children.item(i);
// Recurse to Element children.
if (child.getNodeType() == Node.ELEMENT_NODE) {
process(child, true, visitor);
}
}
}
}
/**
* Parses the provided InputStream to create a dom Document.
*
* @param xmlStream An InputStream connected to an XML document.
* @return A DOM Document created from the contents of the provided stream.
*/
public static Document parseXmlStream(final Reader xmlStream) {
// Build a DOM model of the provided xmlFileStream.
final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(true);
try {
return factory.newDocumentBuilder().parse(new InputSource(xmlStream));
} catch (Exception e) {
throw new IllegalArgumentException("Could not acquire DOM Document", e);
}
}
/**
* Converts the provided DOM Node to a pretty-printed XML-formatted string.
*
* @param node The Node whose children should be converted to a String.
* @return a pretty-printed XML-formatted string.
*/
protected static String getHumanReadableXml(final Node node) {
StringWriter toReturn = new StringWriter();
try {
Transformer transformer = getFactory().newTransformer();
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.STANDALONE, "yes");
transformer.transform(new DOMSource(node), new StreamResult(toReturn));
} catch (TransformerException e) {
throw new IllegalStateException("Could not transform node [" + node.getNodeName() + "] to XML", e);
}
return toReturn.toString();
}
//
// Private helpers
//
private static String getDuplicationErrorMessage(final String propertyName, final String propertyValue,
final int firstIndex, final int currentIndex) {
return MISCONFIG + "Duplicate '" + propertyName + "' property with value [" + propertyValue
+ "] found in plugin configuration. Correct schema elements index (" + firstIndex + ") and ("
+ currentIndex + "), to ensure that all '" + propertyName + "' values are unique.";
}
/**
* Validates that the transformation from oldPrefix to newPrefix is possible, in that
* newPrefix is not already used by a schema file. This would corrupt the schema by assigning elements
* from one namespace to another.
*
* @param oldPrefix The old/current namespace prefix.
* @param newPrefix The new/future namespace prefix.
* @param currentResolver The currently active SimpleNamespaceResolver.
* @throws MojoExecutionException if any schema file currently uses newPrefix.
*/
private static void validatePrefixSubstitutionIsPossible(final String oldPrefix, final String newPrefix,
final SimpleNamespaceResolver currentResolver)
throws MojoExecutionException {
// Make certain the newPrefix does not exist already.
if (currentResolver.getNamespaceURI2PrefixMap().containsValue(newPrefix)) {
throw new MojoExecutionException(MISCONFIG + "Namespace prefix [" + newPrefix + "] is already in use."
+ " Cannot replace namespace prefix [" + oldPrefix + "] with [" + newPrefix + "] in file ["
+ currentResolver.getSourceFilename() + "].");
}
}
/**
* Creates a Document from parsing the XML within the provided xmlFile.
*
* @param xmlFile The XML file to be parsed.
* @return The Document corresponding to the xmlFile.
*/
private static Document parseXmlToDocument(final File xmlFile) {
Document result = null;
Reader reader = null;
try {
reader = new FileReader(xmlFile);
result = parseXmlStream(reader);
} catch (FileNotFoundException e) {
// This should never happen...
} finally {
IOUtil.close(reader);
}
return result;
}
private static void savePrettyPrintedDocument(final Document toSave,
final File targetFile,
final String charsetName) {
Writer out = null;
try {
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(targetFile), charsetName));
out.write(getHumanReadableXml(toSave.getFirstChild()));
} catch (IOException e) {
throw new IllegalStateException("Could not write to file [" + targetFile.getAbsolutePath() + "]", e);
} finally {
IOUtil.close(out);
}
}
private static void addRecursively(final List toPopulate,
final FileFilter fileFilter,
final File aDir) {
// Check sanity
Validate.notNull(toPopulate, "toPopulate");
Validate.notNull(fileFilter, "fileFilter");
Validate.notNull(aDir, "aDir");
// Add all matching files.
for (File current : aDir.listFiles(fileFilter)) {
if (current.isFile()) {
toPopulate.add(current);
} else if (current.isDirectory()) {
addRecursively(toPopulate, fileFilter, current);
}
}
}
private static TransformerFactory getFactory() {
if (FACTORY == null) {
try {
FACTORY = TransformerFactory.newInstance();
// Harmonize XML formatting
for (String currentAttributeName : Arrays.asList("indent-number", OutputKeys.INDENT)) {
try {
FACTORY.setAttribute(currentAttributeName, 2);
} catch (IllegalArgumentException ex) {
// Ignore this.
}
}
} catch (Throwable exception) {
// This should really not happen... but it seems to happen in some test cases.
throw new IllegalStateException("Could not acquire TransformerFactory implementation.", exception);
}
}
// All done.
return FACTORY;
}
} package-info.java 0000664 0000000 0000000 00000001236 13511002134 0036134 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration /**
* The jaxb2-maven-plugin wraps and adapts the JAXB reference implementation
* to be useful within the Maven build process.
* The schemageneneration package (including subpackages) contains Mojos for generating XSD files from
* annotated Java classes. It also contains subpackages for post-processing the results of the schemagen tool,
* to create XSDs with better usability than the XSDs generated by default.
*
* @author Lennart Jörelid
* @see The JAXB Reference Implementation
*/
package org.codehaus.mojo.jaxb2.schemageneration; postprocessing/ 0000775 0000000 0000000 00000000000 13511002134 0036025 5 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration NodeProcessor.java 0000664 0000000 0000000 00000002772 13511002134 0041465 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing package org.codehaus.mojo.jaxb2.schemageneration.postprocessing;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.w3c.dom.Node;
/**
* Processor/visitor pattern specification for DOM Nodes.
*
* @author Lennart Jörelid
* @since 1.4
*/
public interface NodeProcessor {
/**
* Defines if this visitor should process the provided node.
*
* @param aNode The DOM node to process.
* @return true if the provided Node should be processed by this NodeProcessor.
*/
boolean accept(Node aNode);
/**
* Processes the provided DOM Node.
*
* @param aNode The DOM Node to process.
*/
void process(Node aNode);
} javadoc/ 0000775 0000000 0000000 00000000000 13511002134 0037434 5 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing DefaultJavaDocRenderer.java 0000664 0000000 0000000 00000007246 13511002134 0044613 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/javadoc package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import java.util.Map;
/**
* Default JavaDocRenderer implementation which provides a plain JavaDocData rendering, on the form:
*
* [JavaDoc comment]
* (tag1): [tag1 value]
* (tag2): [tag2 value]
*
*
* @author Lennart Jörelid, jGuru Europe AB
* @since 2.0
*/
public class DefaultJavaDocRenderer implements JavaDocRenderer {
/**
* {@inheritDoc}
*/
@Override
public String render(final JavaDocData nonNullData, final SortableLocation location) {
// Compile the XSD documentation string for this Node.
final StringBuilder builder = new StringBuilder();
// First, render the JavaDoc comment.
builder.append(renderJavaDocComment(nonNullData.getComment(), location)).append("\n");
// Then, render each JavaDoc tag.
for (Map.Entry current : nonNullData.getTag2ValueMap().entrySet()) {
final String tagXsdDoc = renderJavaDocTag(current.getKey(), current.getValue(), location);
if (tagXsdDoc != null && !tagXsdDoc.isEmpty()) {
builder.append(tagXsdDoc);
}
}
// All done.
return builder.toString();
}
/**
* Override this method to yield another rendering of the javadoc comment.
*
* @param comment The comment to render.
* @param location the SortableLocation where the JavaDocData was harvested. Never {@code null}.
* @return The XSD documentation for the supplied JavaDoc comment. A null or empty value will not be rendered.
*/
protected String renderJavaDocComment(final String comment, final SortableLocation location) {
return harmonizeNewlines(comment);
}
/**
* Override this method to yield another
*
* @param name The name of a JavaDoc tag.
* @param value The value of a JavaDoc tag.
* @param location the SortableLocation where the JavaDocData was harvested. Never {@code null}.
* @return The XSD documentation for the supplied JavaDoc tag.
*/
protected String renderJavaDocTag(final String name, final String value, final SortableLocation location) {
final String nameKey = name != null ? name.trim() : "";
final String valueKey = value != null ? value.trim() : "";
// All Done.
return "(" + nameKey + "): " + harmonizeNewlines(valueKey);
}
/**
* Squashes newline characters into
*
* @param original the original string, potentially containing newline characters.
* @return A string where all newline characters are removed
*/
protected String harmonizeNewlines(final String original) {
final String toReturn = original.trim().replaceAll("[\r\n]+", "\n");
return toReturn.endsWith("\n") ? toReturn : toReturn + "\n";
}
}
DomHelper.java 0000664 0000000 0000000 00000044360 13511002134 0042165 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/javadoc package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location.ClassLocation;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location.FieldLocation;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location.MethodLocation;
import org.w3c.dom.CDATASection;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import javax.xml.XMLConstants;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;
import java.util.SortedMap;
/**
* Helper class stashing commonly used algorithms to work with DOM documents.
*
* @author Lennart Jörelid, jGuru Europe AB
* @since 2.3
*/
public final class DomHelper {
private static final String NAME_ATTRIBUTE = "name";
private static final String VALUE_ATTRIBUTE = "value";
/**
* The name of the annotation element.
*/
public static final String ANNOTATION_ELEMENT_NAME = "annotation";
/**
* The name of the documentation element.
*/
public static final String DOCUMENTATION_ELEMENT_NAME = "documentation";
/**
* The namespace schema prefix for the URI {@code http://www.w3.org/2001/XMLSchema}
* (i.e. {@code XMLConstants.W3C_XML_SCHEMA_NS_URI}).
*
* @see javax.xml.XMLConstants#W3C_XML_SCHEMA_NS_URI
*/
public static final String XSD_SCHEMA_NAMESPACE_PREFIX = "xs";
/**
* The names of DOM Elements corresponding to Java class Fields or Methods.
*/
public static final List CLASS_FIELD_METHOD_ELEMENT_NAMES = Arrays.asList("element", "attribute");
/**
* The names of DOM Elements corresponding to Java enum Fields or Methods.
*/
public static final List ENUMERATION_FIELD_METHOD_ELEMENT_NAMES = Collections.singletonList("enumeration");
/*
* Hide constructor for utility classes
*/
private DomHelper() {
}
/**
* Retrieves the value of the {@code name} attribute of the supplied Node.
*
* @param aNode A DOM Node.
* @return the value of the {@code name} attribute of the supplied Node/Element.
*/
public static String getNameAttribute(final Node aNode) {
return getNamedAttribute(aNode, NAME_ATTRIBUTE);
}
/**
* Retrieves the value of the {@code value} attribute of the supplied Node.
*
* @param aNode A DOM Node.
* @return the value of the {@code value} attribute of the supplied Node/Element.
*/
public static String getValueAttribute(final Node aNode) {
return getNamedAttribute(aNode, VALUE_ATTRIBUTE);
}
/**
* Checks if the supplied DOM Node is a DOM Element having a defined "name" attribute.
*
* @param aNode A DOM Node.
* @return {@code true} if the supplied aNode is an Elemnet having a defined "name" attribute.
*/
public static boolean isNamedElement(final Node aNode) {
final boolean isElementNode = aNode != null && aNode.getNodeType() == Node.ELEMENT_NODE;
return isElementNode
&& getNamedAttribute(aNode, NAME_ATTRIBUTE) != null
&& !getNamedAttribute(aNode, NAME_ATTRIBUTE).isEmpty();
}
/**
* Retrieves the TagName for the supplied Node if it is an Element, and null otherwise.
*
* @param aNode A DOM Node.
* @return The TagName of the Node if it is an Element, and null otherwise.
*/
public static String getElementTagName(final Node aNode) {
if (aNode != null && aNode.getNodeType() == Node.ELEMENT_NODE) {
final Element theElement = (Element) aNode;
return theElement.getTagName();
}
// The Node was not an Element.
return null;
}
/**
* Adds the given formattedDocumentation within an XML documentation annotation under the supplied Node.
* Only adds the documentation annotation if the formattedDocumentation is non-null and non-empty. The
* documentation annotation is on the form:
*
*
* <xs:annotation>
* <xs:documentation>(JavaDoc here, within a CDATA section)</xs:documentation>
* </xs:annotation>
*
*
*
* @param aNode The non-null Node to which an XML documentation annotation should be added.
* @param formattedDocumentation The documentation text to add.
*/
public static void addXmlDocumentAnnotationTo(final Node aNode, final String formattedDocumentation) {
if (aNode != null && formattedDocumentation != null && !formattedDocumentation.isEmpty()) {
// Add the new Elements, as required.
final Document doc = aNode.getOwnerDocument();
final Element annotation = doc.createElementNS(
XMLConstants.W3C_XML_SCHEMA_NS_URI, ANNOTATION_ELEMENT_NAME);
final Element docElement = doc.createElementNS(
XMLConstants.W3C_XML_SCHEMA_NS_URI, DOCUMENTATION_ELEMENT_NAME);
final CDATASection xsdDocumentation = doc.createCDATASection(formattedDocumentation);
// Set the prefixes
annotation.setPrefix(XSD_SCHEMA_NAMESPACE_PREFIX);
docElement.setPrefix(XSD_SCHEMA_NAMESPACE_PREFIX);
// Inject the formattedDocumentation into the CDATA section.
annotation.appendChild(docElement);
final Node firstChildOfCurrentNode = aNode.getFirstChild();
if (firstChildOfCurrentNode == null) {
aNode.appendChild(annotation);
} else {
aNode.insertBefore(annotation, firstChildOfCurrentNode);
}
// All Done.
docElement.appendChild(xsdDocumentation);
}
}
/**
* Retrieves the XPath for the supplied Node within its document.
*
* @param aNode The DOM Node for which the XPath should be retrieved.
* @return The XPath to the supplied DOM Node.
*/
public static String getXPathFor(final Node aNode) {
List nodeNameList = new ArrayList();
for (Node current = aNode; current != null; current = current.getParentNode()) {
final String currentNodeName = current.getNodeName();
final String nameAttribute = DomHelper.getNameAttribute(current);
if (currentNodeName.toLowerCase().endsWith("enumeration")) {
// We should print the "value" attribute here.
nodeNameList.add(currentNodeName + "[@value='" + getValueAttribute(current) + "']");
} else if (nameAttribute == null) {
// Just emit the node's name.
nodeNameList.add(current.getNodeName());
} else {
// We should print the "name" attribute here.
nodeNameList.add(current.getNodeName() + "[@name='" + nameAttribute + "']");
}
}
StringBuilder builder = new StringBuilder();
for (ListIterator it = nodeNameList.listIterator(nodeNameList.size()); it.hasPrevious(); ) {
builder.append(it.previous());
if (it.hasPrevious()) {
builder.append("/");
}
}
return builder.toString();
}
/**
* Retrieves the ClassLocation for the supplied aNode.
*
* @param aNode A non-null DOM Node.
* @param classLocations The set of known ClassLocations, extracted from the JavaDocs.
* @return the ClassLocation matching the supplied Node
*/
public static ClassLocation getClassLocation(final Node aNode, final Set classLocations) {
if (aNode != null) {
// The LocalName of the supplied DOM Node should be either "complexType" or "simpleType".
final String nodeLocalName = aNode.getLocalName();
final boolean acceptableType = "complexType".equalsIgnoreCase(nodeLocalName)
|| "simpleType".equalsIgnoreCase(nodeLocalName);
if (acceptableType) {
final String nodeClassName = DomHelper.getNameAttribute(aNode);
for (ClassLocation current : classLocations) {
// TODO: Ensure that the namespace of the supplied aNode matches the expected namespace.
// Issue #25: Handle XML Type renaming.
final String effectiveClassName = current.getAnnotationRenamedTo() == null
? current.getClassName()
: current.getAnnotationRenamedTo();
if (effectiveClassName.equalsIgnoreCase(nodeClassName)) {
return current;
}
}
}
}
// Nothing found
return null;
}
/**
* Finds the MethodLocation within the given Set, which corresponds to the supplied DOM Node.
*
* @param aNode A DOM Node.
* @param methodLocations The Set of all found/known MethodLocation instances.
* @return The MethodLocation matching the supplied Node - or {@code null} if no match was found.
*/
public static MethodLocation getMethodLocation(final Node aNode, final Set methodLocations) {
MethodLocation toReturn = null;
if (aNode != null && CLASS_FIELD_METHOD_ELEMENT_NAMES.contains(aNode.getLocalName().toLowerCase())) {
final MethodLocation validLocation = getFieldOrMethodLocationIfValid(aNode,
getContainingClassOrNull(aNode),
methodLocations);
// The MethodLocation should represent a normal getter; no arguments should be present.
if (validLocation != null
&& MethodLocation.NO_PARAMETERS.equalsIgnoreCase(validLocation.getParametersAsString())) {
toReturn = validLocation;
}
}
// All done.
return toReturn;
}
/**
* Retrieves a FieldLocation from the supplied Set, provided that the FieldLocation matches the supplied Node.
*
* @param aNode The non-null Node.
* @param fieldLocations The Set of known/found FieldLocation instances.
* @return The FieldLocation corresponding to the supplied DOM Node.
*/
public static FieldLocation getFieldLocation(final Node aNode, final Set fieldLocations) {
FieldLocation toReturn = null;
if (aNode != null) {
if (CLASS_FIELD_METHOD_ELEMENT_NAMES.contains(aNode.getLocalName().toLowerCase())) {
// This is a ComplexType which correspond to a Java class.
toReturn = getFieldOrMethodLocationIfValid(aNode, getContainingClassOrNull(aNode), fieldLocations);
} else if (ENUMERATION_FIELD_METHOD_ELEMENT_NAMES.contains(aNode.getLocalName().toLowerCase())) {
// This is a SimpleType which correspond to a Java enum.
toReturn = getFieldOrMethodLocationIfValid(aNode, getContainingClassOrNull(aNode), fieldLocations);
}
}
// All done.
return toReturn;
}
/**
* Retrieves a FieldLocation or MethodLocation from the supplied Set of Field- or MethodLocations, provided that
* the supplied Node has the given containing Node corresponding to a Class or an Enum.
*
* @param aNode A non-null DOM Node.
* @param containingClassNode A Non-null DOM Node corresponding to a Class or Enum.
* @param locations A Set containing known/found Field- and MethodLocations.
* @param The FieldLocation type.
* @return The Matching Field- or MethodLocation.
*/
public static T getFieldOrMethodLocationIfValid(
final Node aNode,
final Node containingClassNode,
final Set locations) {
T toReturn = null;
if (containingClassNode != null) {
// Do we have a FieldLocation corresponding to the supplied Node?
for (FieldLocation current : locations) {
// Validate that the field and class names match the FieldLocation's corresponding values,
// minding that annotations such as XmlType, XmlElement and XmlAttribute may override the
// reflective Class, Field and Method names.
//
// Note that we cannot match package names here, as the generated XSD does not contain package
// information directly. Instead, we must get the Namespace for the generated Class, and compare
// it to the effective Namespace of the current Node.
//
// However, this is a computational-expensive operation, implying we would rather
// do it at processing time when the number of nodes are (considerably?) reduced.
// Issue #25: Handle XML Type renaming.
final String fieldName = current.getAnnotationRenamedTo() == null
? current.getMemberName()
: current.getAnnotationRenamedTo();
final String className = current.getClassName();
try {
//
// Fields in XML enums are rendered on the form
// , implying that
// we must retrieve the 'value' attribute's value.
//
// Fields in XML classes are rendered on the form
// , implying that
// we must retrieve the 'name' attribute's value.
//
final String attributeValue = DomHelper.getNameAttribute(aNode) == null
? DomHelper.getValueAttribute(aNode)
: DomHelper.getNameAttribute(aNode);
if (fieldName.equalsIgnoreCase(attributeValue)
&& className.equalsIgnoreCase(DomHelper.getNameAttribute(containingClassNode))) {
toReturn = (T) current;
}
} catch (Exception e) {
throw new IllegalStateException("Could not acquire FieldLocation for fieldName ["
+ fieldName + "] and className [" + className + "]", e);
}
}
}
// All done.
return toReturn;
}
/**
* Processes the supplied DOM Node, inserting XML Documentation annotations if applicable.
*
* @param aNode The DOM Node to process.
* @param classJavaDocs A Map relating {@link ClassLocation}s to {@link JavaDocData}.
* @param fieldJavaDocs A Map relating {@link FieldLocation}s to {@link JavaDocData}.
* @param methodJavaDocs A Map relating {@link MethodLocation}s to {@link JavaDocData}.
* @param renderer A non-null {@link JavaDocRenderer}.
*/
public static void insertXmlDocumentationAnnotationsFor(
final Node aNode,
final SortedMap classJavaDocs,
final SortedMap fieldJavaDocs,
final SortedMap methodJavaDocs,
final JavaDocRenderer renderer) {
JavaDocData javaDocData = null;
SortableLocation location = null;
// Insert the documentation annotation into the current Node.
final ClassLocation classLocation = DomHelper.getClassLocation(aNode, classJavaDocs.keySet());
if (classLocation != null) {
javaDocData = classJavaDocs.get(classLocation);
location = classLocation;
} else {
final FieldLocation fieldLocation = DomHelper.getFieldLocation(aNode, fieldJavaDocs.keySet());
if (fieldLocation != null) {
javaDocData = fieldJavaDocs.get(fieldLocation);
location = fieldLocation;
} else {
final MethodLocation methodLocation = DomHelper.getMethodLocation(aNode, methodJavaDocs.keySet());
if (methodLocation != null) {
javaDocData = methodJavaDocs.get(methodLocation);
location = methodLocation;
}
}
}
// We should have a JavaDocData here.
if (javaDocData == null) {
final String nodeName = aNode.getNodeName();
String humanReadableName = DomHelper.getNameAttribute(aNode);
if (humanReadableName == null && nodeName.toLowerCase().endsWith("enumeration")) {
humanReadableName = "enumeration#" + getValueAttribute(aNode);
}
throw new IllegalStateException("Could not find JavaDocData for XSD node ["
+ humanReadableName + "] with XPath [" + DomHelper.getXPathFor(aNode) + "]");
}
// Add the XML documentation annotation.
final String processedJavaDoc = renderer.render(javaDocData, location).trim();
DomHelper.addXmlDocumentAnnotationTo(aNode, processedJavaDoc);
}
//
// Private helpers
//
private static Node getContainingClassOrNull(final Node aNode) {
for (Node current = aNode.getParentNode(); current != null; current = current.getParentNode()) {
final String localName = current.getLocalName();
final boolean foundClassMatch = "complexType".equalsIgnoreCase(localName)
|| "simpleType".equalsIgnoreCase(localName);
if (foundClassMatch) {
return current;
}
}
// No parent Node found.
return null;
}
private static String getNamedAttribute(final Node aNode, final String attributeName) {
// Fail fast
if (aNode == null) {
return null;
}
final NamedNodeMap attributes = aNode.getAttributes();
if (attributes != null) {
final Node nameNode = attributes.getNamedItem(attributeName);
if (nameNode != null) {
return nameNode.getNodeValue().trim();
}
}
// Not found.
return null;
}
}
JavaDocData.java 0000664 0000000 0000000 00000010551 13511002134 0042402 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/javadoc package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import com.thoughtworks.qdox.model.DocletTag;
import org.codehaus.mojo.jaxb2.AbstractJaxbMojo;
import java.util.List;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
/**
* Simplified structure containing comments and tags read from a JavaDoc comment block.
*
* @author Lennart Jörelid, jGuru Europe AB
* @since 2.0
*/
public class JavaDocData {
/**
* Substitution value for when no JavaDoc comment text was found within a JavaDoc comment block.
*/
public static final String NO_COMMENT = "";
// Internal state
private String comment;
private SortedMap tag2ValueMap;
/**
* Creates a JavaDocData for a particular entry with the supplied JavaDoc comment and List of DocletTags.
*
* @param comment The actual comment in the JavaDoc. Null values are replaced with the value {@code NO_COMMENT},
* to ensure that the {@code getComment() } method does not return null values.
* @param tags The DocletTags of the JavaDoc entry. Can be null or empty.
*/
public JavaDocData(final String comment, final List tags) {
// Assign internal state
this.comment = comment == null ? NO_COMMENT : comment;
this.tag2ValueMap = new TreeMap();
// Parse, and assign internal state
for (DocletTag current : tags) {
final String tagName = current.getName();
String tagValue = current.getValue();
// Handle the case of multi-valued tags, such as
//
// @author SomeAuthor
// @author AnotherAuthor
//
// which becomes [author] --> [SomeAuthor, AnotherAuthor]
String currentValue = tag2ValueMap.get(tagName);
if (currentValue != null) {
tagValue = currentValue + ", " + current.getValue();
}
tag2ValueMap.put(tagName, tagValue);
}
}
/**
* Retrieves the comment/text in the JavaDoc structure, minus the names and values of any given JavaDoc tags.
*
* @return the comment/text in the JavaDoc structure, or {@code NO_COMMENT} if no JavaDoc was provided.
* Never returns a {@code null} value.
*/
public String getComment() {
return comment;
}
/**
* Retrieves the names and values of all JavaDoc tags found.
* If two tags were found (such as two {@code @author} tags, the
* value contains all found
*
* @return A non-null Map relating the names of all supplied JavaDoc Tags to their value(s).
*/
public SortedMap getTag2ValueMap() {
return tag2ValueMap;
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
StringBuilder toReturn = new StringBuilder();
toReturn.append("\n+=================\n");
toReturn.append("| Comment: ").append(comment).append("\n");
if (tag2ValueMap.size() == 0) {
toReturn.append("| No JavaDoc tags.\n");
} else {
toReturn.append("| ").append(tag2ValueMap.size()).append(" JavaDoc tags ...\n");
for (Map.Entry current : tag2ValueMap.entrySet()) {
toReturn.append("| ").append(current.getKey()).append(": ").append(current.getValue()).append("\n");
}
}
toReturn.append("+=================\n\n");
return toReturn.toString().replace("\n", AbstractJaxbMojo.NEWLINE);
}
}
JavaDocExtractor.java 0000664 0000000 0000000 00000052356 13511002134 0043515 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/javadoc package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import com.thoughtworks.qdox.JavaProjectBuilder;
import com.thoughtworks.qdox.model.JavaAnnotatedElement;
import com.thoughtworks.qdox.model.JavaAnnotation;
import com.thoughtworks.qdox.model.JavaClass;
import com.thoughtworks.qdox.model.JavaField;
import com.thoughtworks.qdox.model.JavaMethod;
import com.thoughtworks.qdox.model.JavaPackage;
import com.thoughtworks.qdox.model.JavaSource;
import org.apache.maven.plugin.logging.Log;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location.ClassLocation;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location.FieldLocation;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location.MethodLocation;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location.PackageLocation;
import org.codehaus.mojo.jaxb2.shared.FileSystemUtilities;
import org.codehaus.mojo.jaxb2.shared.Validate;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlEnumValue;
import javax.xml.bind.annotation.XmlType;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
/**
* The schemagen tool operates on compiled bytecode, where JavaDoc comments are not present.
* However, the javadoc documentation present in java source files is required within the generated
* XSD to increase usability and produce an XSD which does not loose out on important usage information.
* The JavaDocExtractor is used as a post processor after creating the XSDs within the compilation
* unit, and injects XSD annotations into the appropriate XSD elements or types.
*
* @author Lennart Jörelid, jGuru Europe AB
* @since 2.0
*/
public class JavaDocExtractor {
/**
* The default value given as the return value from some annotation classes whenever the attribute
* has not been supplied within the codebase.
*/
private static final String DEFAULT_VALUE = "##default";
// Internal state
private JavaProjectBuilder builder;
private Log log;
/**
* Creates a JavaDocExtractor wrapping the supplied Maven Log.
*
* @param log A non-null Log.
*/
public JavaDocExtractor(final Log log) {
// Check sanity
Validate.notNull(log, "log");
// Create internal state
this.log = log;
this.builder = new JavaProjectBuilder();
}
/**
* Assigns the encoding of the underlying {@link JavaProjectBuilder}.
*
* @param encoding The non-empty encoding to be set into the underlying {@link JavaProjectBuilder}.
*/
public void setEncoding(final String encoding) {
this.builder.setEncoding(encoding);
}
/**
* Adds the supplied sourceCodeFiles for processing by this JavaDocExtractor.
*
* @param sourceCodeFiles The non-null List of source code files to add.
* @return This JavaDocExtractor, for call chaining.
* @throws IllegalArgumentException If any of the given sourceCodeFiles could not be read properly.
*/
public JavaDocExtractor addSourceFiles(final List sourceCodeFiles) throws IllegalArgumentException {
// Check sanity
Validate.notNull(sourceCodeFiles, "addSourceFiles");
// Add the files.
for (File current : sourceCodeFiles) {
try {
builder.addSource(current);
} catch (IOException e) {
throw new IllegalArgumentException("Could not add file ["
+ FileSystemUtilities.getCanonicalPath(current) + "]", e);
}
}
// All done.
return this;
}
/**
* Adds the supplied sourceCodeFiles for processing by this JavaDocExtractor.
*
* @param sourceCodeURLs The non-null List of source code URLs to add.
* @return This JavaDocExtractor, for call chaining.
* @throws IllegalArgumentException If any of the given sourceCodeURLs could not be read properly.
*/
public JavaDocExtractor addSourceURLs(final List sourceCodeURLs) throws IllegalArgumentException {
// Check sanity
Validate.notNull(sourceCodeURLs, "sourceCodeURLs");
// Add the URLs
for (URL current : sourceCodeURLs) {
try {
builder.addSource(current);
} catch (IOException e) {
throw new IllegalArgumentException("Could not add URL [" + current.toString() + "]", e);
}
}
// All done
return this;
}
/**
* Processes all supplied Java source Files and URLs to extract JavaDocData for all ClassLocations from which
* JavaDoc has been collected.
*
* @return A SearchableDocumentation relating SortableLocations and their paths to harvested JavaDocData.
*/
public SearchableDocumentation process() {
// Start processing.
final SortedMap dataHolder = new TreeMap();
final Collection sources = builder.getSources();
if (log.isInfoEnabled()) {
log.info("Processing [" + sources.size() + "] java sources.");
}
for (JavaSource current : sources) {
// Add the package-level JavaDoc
final JavaPackage currentPackage = current.getPackage();
final String packageName = currentPackage.getName();
addEntry(dataHolder, new PackageLocation(packageName), currentPackage);
if (log.isDebugEnabled()) {
log.debug("Added package-level JavaDoc for [" + packageName + "]");
}
for (JavaClass currentClass : current.getClasses()) {
// Add the class-level JavaDoc
final String simpleClassName = currentClass.getName();
final String classXmlName = getAnnotationAttributeValueFrom(XmlType.class,
"name",
currentClass.getAnnotations());
final ClassLocation classLocation = new ClassLocation(packageName, simpleClassName, classXmlName);
addEntry(dataHolder, classLocation, currentClass);
if (log.isDebugEnabled()) {
log.debug("Added class-level JavaDoc for [" + classLocation + "]");
}
for (JavaField currentField : currentClass.getFields()) {
final List currentFieldAnnotations = currentField.getAnnotations();
String annotatedXmlName = null;
//
// Is this field a collection, annotated with @XmlElementWrapper?
// If so, the documentation should pertain to the corresponding XML Sequence,
// rather than the individual XML elements.
//
if (hasAnnotation(XmlElementWrapper.class, currentFieldAnnotations)) {
// There are 2 cases here:
//
// 1: The XmlElementWrapper is named.
// ==================================
// @XmlElementWrapper(name = "foobar")
// @XmlElement(name = "aString")
// private List strings;
//
// ==> annotatedXmlName == "foobar"
//
// 2: The XmlElementWrapper is not named.
// ======================================
// @XmlElementWrapper
// @XmlElement(name = "anInteger")
// private SortedSet integerSet;
//
// ==> annotatedXmlName == "integerSet"
//
annotatedXmlName = getAnnotationAttributeValueFrom(
XmlElementWrapper.class,
"name",
currentFieldAnnotations);
if (annotatedXmlName == null || annotatedXmlName.equals(DEFAULT_VALUE)) {
annotatedXmlName = currentField.getName();
}
}
// Find the XML name if provided within an annotation.
if (annotatedXmlName == null) {
annotatedXmlName = getAnnotationAttributeValueFrom(
XmlElement.class,
"name",
currentFieldAnnotations);
}
if (annotatedXmlName == null) {
annotatedXmlName = getAnnotationAttributeValueFrom(
XmlAttribute.class,
"name",
currentFieldAnnotations);
}
if (annotatedXmlName == null) {
annotatedXmlName = getAnnotationAttributeValueFrom(
XmlEnumValue.class,
"value",
currentFieldAnnotations);
}
// Add the field-level JavaDoc
final FieldLocation fieldLocation = new FieldLocation(
packageName,
simpleClassName,
classXmlName,
currentField.getName(),
annotatedXmlName);
addEntry(dataHolder, fieldLocation, currentField);
if (log.isDebugEnabled()) {
log.debug("Added field-level JavaDoc for [" + fieldLocation + "]");
}
}
for (JavaMethod currentMethod : currentClass.getMethods()) {
final List currentMethodAnnotations = currentMethod.getAnnotations();
String annotatedXmlName = null;
//
// Is this field a collection, annotated with @XmlElementWrapper?
// If so, the documentation should pertain to the corresponding XML Sequence,
// rather than the individual XML elements.
//
if (hasAnnotation(XmlElementWrapper.class, currentMethodAnnotations)) {
// There are 2 cases here:
//
// 1: The XmlElementWrapper is named.
// ==================================
// @XmlElementWrapper(name = "foobar")
// @XmlElement(name = "aString")
// public List getStrings() { ... };
//
// ==> annotatedXmlName == "foobar"
//
// 2: The XmlElementWrapper is not named.
// ======================================
// @XmlElementWrapper
// @XmlElement(name = "anInteger")
// public SortedSet getIntegerSet() { ... };
//
// ==> annotatedXmlName == "getIntegerSet"
//
annotatedXmlName = getAnnotationAttributeValueFrom(
XmlElementWrapper.class,
"name",
currentMethodAnnotations);
if (annotatedXmlName == null || annotatedXmlName.equals(DEFAULT_VALUE)) {
annotatedXmlName = currentMethod.getName();
}
}
// Find the XML name if provided within an annotation.
if (annotatedXmlName == null) {
annotatedXmlName = getAnnotationAttributeValueFrom(
XmlElement.class,
"name",
currentMethod.getAnnotations());
}
if (annotatedXmlName == null) {
annotatedXmlName = getAnnotationAttributeValueFrom(
XmlAttribute.class,
"name",
currentMethod.getAnnotations());
}
// Add the method-level JavaDoc
final MethodLocation location = new MethodLocation(packageName,
simpleClassName,
classXmlName,
currentMethod.getName(),
annotatedXmlName,
currentMethod.getParameters());
addEntry(dataHolder, location, currentMethod);
if (log.isDebugEnabled()) {
log.debug("Added method-level JavaDoc for [" + location + "]");
}
}
}
}
// All done.
return new ReadOnlySearchableDocumentation(dataHolder);
}
/**
* Finds the value of the attribute with the supplied name within the first matching JavaAnnotation of
* the given type encountered in the given annotations List. This is typically used for reading values of
* annotations such as {@link XmlElement}, {@link XmlAttribute} or {@link XmlEnumValue}.
*
* @param annotations The list of JavaAnnotations to filter from.
* @param annotationType The type of annotation to read attribute values from.
* @param attributeName The name of the attribute the value of which should be returned.
* @return The first matching JavaAnnotation of type annotationType within the given annotations
* List, or {@code null} if none was found.
* @since 2.2
*/
private static String getAnnotationAttributeValueFrom(
final Class annotationType,
final String attributeName,
final List annotations) {
// QDox uses the fully qualified class name of the annotation for comparison.
// Extract it.
final String fullyQualifiedClassName = annotationType.getName();
JavaAnnotation annotation = null;
String toReturn = null;
if (annotations != null) {
for (JavaAnnotation current : annotations) {
if (current.getType().isA(fullyQualifiedClassName)) {
annotation = current;
break;
}
}
if (annotation != null) {
final Object nameValue = annotation.getNamedParameter(attributeName);
if (nameValue != null && nameValue instanceof String) {
toReturn = ((String) nameValue).trim();
// Remove initial and trailing " chars, if present.
if (toReturn.startsWith("\"") && toReturn.endsWith("\"")) {
toReturn = (((String) nameValue).trim()).substring(1, toReturn.length() - 1);
}
}
}
}
// All Done.
return toReturn;
}
private static boolean hasAnnotation(final Class annotationType,
final List annotations) {
if (annotations != null && !annotations.isEmpty() && annotationType != null) {
final String fullAnnotationClassName = annotationType.getName();
for (JavaAnnotation current : annotations) {
if (current.getType().isA(fullAnnotationClassName)) {
return true;
}
}
}
return false;
}
//
// Private helpers
//
private void addEntry(final SortedMap map,
final SortableLocation key,
final JavaAnnotatedElement value) {
// Check sanity
if (map.containsKey(key)) {
// Get something to compare with
final JavaDocData existing = map.get(key);
// Is this an empty package-level documentation?
if (key instanceof PackageLocation) {
final boolean emptyExisting = existing.getComment() == null || existing.getComment().isEmpty();
final boolean emptyGiven = value.getComment() == null || value.getComment().isEmpty();
if (emptyGiven) {
if (log.isDebugEnabled()) {
log.debug("Skipping processing empty Package javadoc from [" + key + "]");
}
return;
} else if (emptyExisting && log.isWarnEnabled()) {
log.warn("Overwriting empty Package javadoc from [" + key + "]");
}
} else {
final String given = "[" + value.getClass().getName() + "]: " + value.getComment();
throw new IllegalArgumentException("Not processing duplicate SortableLocation [" + key + "]. "
+ "\n Existing: " + existing
+ ".\n Given: [" + given + "]");
}
}
// Validate.isTrue(!map.containsKey(key), "Found duplicate SortableLocation [" + key + "] in map. "
// + "Current map keySet: " + map.keySet() + ". Got comment: [" + value.getComment() + "]");
map.put(key, new JavaDocData(value.getComment(), value.getTags()));
}
/**
* Standard read-only SearchableDocumentation implementation.
*/
private class ReadOnlySearchableDocumentation implements SearchableDocumentation {
// Internal state
private TreeMap keyMap;
private SortedMap valueMap;
ReadOnlySearchableDocumentation(final SortedMap valueMap) {
// Create internal state
this.valueMap = valueMap;
keyMap = new TreeMap();
for (Map.Entry current : valueMap.entrySet()) {
final SortableLocation key = current.getKey();
keyMap.put(key.getPath(), key);
}
}
/**
* {@inheritDoc}
*/
@Override
public SortedSet getPaths() {
return Collections.unmodifiableSortedSet(keyMap.navigableKeySet());
}
/**
* {@inheritDoc}
*/
@Override
public JavaDocData getJavaDoc(final String path) {
// Check sanity
Validate.notNull(path, "path");
// All done.
final SortableLocation location = getLocation(path);
return (location == null) ? null : valueMap.get(location);
}
/**
* {@inheritDoc}
*/
@Override
@SuppressWarnings("unchecked")
public T getLocation(final String path) {
// Check sanity
Validate.notNull(path, "path");
// All done
return (T) keyMap.get(path);
}
/**
* {@inheritDoc}
*/
@Override
@SuppressWarnings("unchecked")
public SortedMap getAll() {
return (SortedMap) Collections.unmodifiableSortedMap(valueMap);
}
/**
* {@inheritDoc}
*/
@Override
@SuppressWarnings("unchecked")
public SortedMap getAll(final Class type) {
// Check sanity
Validate.notNull(type, "type");
// Filter the valueMap.
final SortedMap toReturn = new TreeMap();
for (Map.Entry current : valueMap.entrySet()) {
if (type == current.getKey().getClass()) {
toReturn.put((T) current.getKey(), current.getValue());
}
}
// All done.
return toReturn;
}
}
}
JavaDocRenderer.java 0000664 0000000 0000000 00000006057 13511002134 0043305 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/javadoc package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
/**
* Specification for how to convert/render JavaDocData into an XML annotation. As an example, let us
* assume that a class contains the following field and JavaDoc:
*
*
* {@literal /}**
* The last name of the SomewhatNamedPerson.
* *{@literal /}
* {@literal @}XmlElement(nillable = false, required = true)
* private String lastName;
*
*
* The standard SchemaGen generation creates a complex type with the following element declaration:
*
*
* <xs:element name="lastName" type="xs:string" />
*
*
* However, if we use the jaxb2-maven-plugin for post-processing, we can inject the javadoc as an XSD
* annotation into the resulting schema, yielding the following result:
*
*
* <xs:element name="lastName" type="xs:string">
* <xs:annotation>
* <xs:documentation><![CDATA[The last name of the SomewhatNamedPerson.]]></xs:documentation>
* </xs:annotation>
* </xs:element>
*
*
* The JavaDocRenderer will create the content of the CDATA element within the XSD documentation annotation,
* given the JavaDocData for each field, such as the lastName in our example.
*
* @author Lennart Jörelid, jGuru Europe AB
* @see org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.DefaultJavaDocRenderer
* @since 2.0
*/
public interface JavaDocRenderer {
/**
* Renders the supplied JavaDocData structure as text to be used within an XSD documentation annotation.
* The XSD documentation annotation will contain a CDATA section to which the rendered JavaDocData is
* emitted.
*
* @param nonNullData the JavaDocData instance to render as XSD documentation. Will never be {@code null}.
* @param location the SortableLocation where the JavaDocData was harvested. Never {@code null}.
* @return The rendered text contained within the XML annotation.
*/
String render(JavaDocData nonNullData, SortableLocation location);
}
NoAuthorJavaDocRenderer.java 0000664 0000000 0000000 00000003376 13511002134 0044766 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/javadoc package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
/**
* Default JavaDocRenderer implementation which provides a plain JavaDocData rendering, while skipping
* output from the {@code author} tag, on the form:
*
* [JavaDoc comment]
* (tag1): [tag1 value]
* (tag2): [tag2 value]
*
*
* @author Lennart Jörelid, jGuru Europe AB
* @since 2.3
*/
public class NoAuthorJavaDocRenderer extends DefaultJavaDocRenderer {
/**
* The author key.
*/
private static final String AUTHOR_KEY = "author";
/**
* {@inheritDoc}
*/
@Override
protected String renderJavaDocTag(final String name, final String value, final SortableLocation location) {
// Don't render the author
if(AUTHOR_KEY.equalsIgnoreCase(name)) {
return "";
}
// Delegate.
return super.renderJavaDocTag(name, value, location);
}
}
SearchableDocumentation.java 0000664 0000000 0000000 00000007146 13511002134 0045072 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/javadoc package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import java.util.SortedMap;
import java.util.SortedSet;
/**
* Specification for a Map of SortableLocations correlated to their respective JavaDocData.
* To simplify searching and accessing within the JavaDocData, the paths of each SortableLocation
* is exposed for searching and listing.
*
* @author Lennart Jörelid, jGuru Europe AB
* @since 2.0
*/
public interface SearchableDocumentation {
/**
* Retrieves all unique SortableLocation paths within this SearchableDocumentation.
*
* @return all unique SortableLocation paths within this SearchableDocumentation.
* The result may be empty, but will never be {@code null}.
*/
SortedSet getPaths();
/**
* Convenience method to acquire the JavaDocData for a SortableLocation with the supplied path.
*
* @param path A non-null path for which the harvested JavaDocData should be retrieved.
* @return The JavaDocData matching the SortableLocation with the supplied path, or {@code null} if no
* SortableLocation with the supplied path was found within this SearchableDocumentation.
*/
JavaDocData getJavaDoc(String path);
/**
* Convenience method to acquire the SortableLocation corresponding to the given path.
*
* @param path The path of a SortableLocation, which is retrieved by a call to its {@code toString()} method.
* @param The SortableLocation subtype.
* @return the SortableLocation corresponding to the given path, or {@code null} if this SearchableDocumentation
* does not contain a SortableLocation with the provided path.
*/
T getLocation(String path);
/**
* The full map relating each SortableLocation subclass to its corresponding JavaDocData.
*
* @return The full map relating each SortableLocation subclass to its corresponding JavaDocData. Never null.
*/
SortedMap getAll();
/**
* Convenience method which retrieves a SortedMap relating all SortableLocations of a particular type
* to their JavaDocData, respectively.
*
* @param type The exact type of SortableLocation which should be filtered from the result and returned in the
* form of a SortedMap, along with its respective JavaDocData.
* @param The SortableLocation subtype for which all JavaDocData should be retrieved.
* @return a SortedMap relating all SortableLocations of a particular (exact) type (i.e. any subclass types will
* not be returned) to their JavaDocData, respectively.
* May return empty Maps, but never {@code null}.
*/
SortedMap getAll(Class type);
}
SortableLocation.java 0000664 0000000 0000000 00000004566 13511002134 0043556 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/javadoc package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
/**
* Common specification for a JavaDoc location which can be compared and sorted.
* JavaDoc locations must be comparable and also convert-able to unique strings.
*
* @author Lennart Jörelid, jGuru Europe AB
* @since 2.0
*/
public interface SortableLocation extends Comparable {
/**
* Validates if the supplied path is equal to this SortableLocation.
*
* @param path The non-null path to compare to this SortableLocation.
* @return {@code true} if this SortableLocation is equal to the supplied path.
*/
boolean isEqualToPath(final String path);
/**
* Retrieves the path of this SortableLocation. The path must uniquely correspond to each unique SortableLocation,
* implying that SortableLocations could be sorted and compared for equality using the path property.
*
* @return the path of this SortableLocation. Never null.
*/
String getPath();
/**
* Retrieves the value of the name attribute provided by a JAXB annotation, implying that
* the XSD type should use another name than the default.
*
* @return the value of the name attribute provided by a JAXB annotation relevant to this {@link SortableLocation}.
* @see XmlElement#name()
* @see XmlAttribute#name()
* @see XmlType#name()
*/
String getAnnotationRenamedTo();
}
XsdAnnotationProcessor.java 0000664 0000000 0000000 00000017464 13511002134 0045004 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/javadoc package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.NodeProcessor;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location.ClassLocation;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location.FieldLocation;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location.MethodLocation;
import org.codehaus.mojo.jaxb2.shared.Validate;
import org.w3c.dom.Node;
import java.util.SortedMap;
/**
* Node processor that injects XSD documentation annotations consisting of JavaDoc harvested Java source code
* into ComplexTypes, Elements and Attributes. The documentation is injected as follows:
*
* - ComplexType: Class-level JavaDoc from the corresponding type is injected as an
* annotation directly inside the complexType.
* - Element: Field-level JavaDoc (or getter Method-level JavaDoc, in case the Field does
* not contain a JavaDoc annotation) from the corresponding member is injected as an
* annotation directly inside the element.
* - Attribute: Field-level JavaDoc (or getter Method-level JavaDoc, in case the Field does
* not contain a JavaDoc annotation) from the corresponding member is injected as an
* annotation directly inside the element.
*
* Thus, the following 'vanilla'-generated XSD:
*
*
* <xs:complexType name="somewhatNamedPerson">
* <xs:sequence>
* <xs:element name="firstName" type="xs:string" nillable="true" minOccurs="0"/>
* <xs:element name="lastName" type="xs:string"/>
* </xs:sequence>
* <xs:attribute name="age" type="xs:int" use="required"/>
* </xs:complexType>
*
*
* ... would be converted to the following annotated XSD, given a DefaultJavaDocRenderer:
*
*
* <xs:complexType name="somewhatNamedPerson">
* <xs:annotation>
* <xs:documentation><![CDATA[Definition of a person with lastName and age, and optionally a firstName as well...
*
* (author): <a href="mailto:lj@jguru.se">Lennart Jörelid</a>, jGuru Europe AB
* (custom): A custom JavaDoc annotation.]]></xs:documentation>
* </xs:annotation>
* <xs:sequence>
* <xs:element minOccurs="0" name="firstName" nillable="true" type="xs:string">
* <xs:annotation>
* <xs:documentation><![CDATA[The first name of the SomewhatNamedPerson.]]></xs:documentation>
* </xs:annotation>
* </xs:element>
* <xs:element name="lastName" type="xs:string">
* <xs:annotation>
* <xs:documentation><![CDATA[The last name of the SomewhatNamedPerson.]]></xs:documentation>
* </xs:annotation>
* </xs:element>
* </xs:sequence>
* <xs:attribute name="age" type="xs:int" use="required">
* <xs:annotation>
* <xs:documentation><![CDATA[The age of the SomewhatNamedPerson. Must be positive.]]></xs:documentation>
* </xs:annotation>
* </xs:attribute>
* </xs:complexType>
*
*
* ... given that the Java class SomewhatNamedPerson has JavaDoc on its class and fields
* corresponding to the injected XSD annotation/documentation elements.
*
* @author Lennart Jörelid, jGuru Europe AB
* @see org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.JavaDocRenderer
* @since 2.0
*/
public class XsdAnnotationProcessor implements NodeProcessor {
// Internal state
private SortedMap classJavaDocs;
private SortedMap fieldJavaDocs;
private SortedMap methodJavaDocs;
private JavaDocRenderer renderer;
/**
* Creates an XsdAnnotationProcessor that uses the supplied/generated SearchableDocumentation to read all
* JavaDoc structures and the supplied JavaDocRenderer to render JavaDocs into XSD documentation annotations.
*
* @param docs A non-null SearchableDocumentation, produced from the source code of the JAXB compilation unit.
* @param renderer A non-null JavaDocRenderer, used to render the JavaDocData within the SearchableDocumentation.
*/
public XsdAnnotationProcessor(final SearchableDocumentation docs, final JavaDocRenderer renderer) {
// Check sanity
Validate.notNull(docs, "docs");
Validate.notNull(renderer, "renderer");
// Assign internal state
this.classJavaDocs = docs.getAll(ClassLocation.class);
this.fieldJavaDocs = docs.getAll(FieldLocation.class);
this.methodJavaDocs = docs.getAll(MethodLocation.class);
this.renderer = renderer;
}
/**
* {@inheritDoc}
*/
@Override
public boolean accept(final Node aNode) {
// Only deal with Element nodes with "name" attributes.
if (!DomHelper.isNamedElement(aNode)) {
return false;
}
/*
*/
// Only process nodes corresponding to Types we have any JavaDoc for.
// TODO: How should we handle PackageLocations and package documentation?
boolean toReturn = false;
if (DomHelper.getMethodLocation(aNode, methodJavaDocs.keySet()) != null) {
toReturn = true;
} else if (DomHelper.getFieldLocation(aNode, fieldJavaDocs.keySet()) != null) {
toReturn = true;
} else if (DomHelper.getClassLocation(aNode, classJavaDocs.keySet()) != null) {
toReturn = true;
}
// All done.
return toReturn;
}
/**
* {@inheritDoc}
*/
@Override
public void process(final Node aNode) {
DomHelper.insertXmlDocumentationAnnotationsFor(aNode, classJavaDocs, fieldJavaDocs, methodJavaDocs, renderer);
}
}
XsdEnumerationAnnotationProcessor.java 0000664 0000000 0000000 00000016547 13511002134 0047214 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/javadoc package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.NodeProcessor;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location.ClassLocation;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location.FieldLocation;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location.MethodLocation;
import org.codehaus.mojo.jaxb2.shared.Validate;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import java.util.SortedMap;
/**
* Node processor that injects XSD documentation annotations consisting of JavaDoc harvested Java source code
* into SimpleTypes, Elements and Attributes typically produced by SchemaGen when generate XSDs for Java Enumerations.
* The documentation is injected as follows:
*
* - SimpleType: Class-level JavaDoc from the corresponding type is injected as an
* annotation directly inside the SimpleType.
* - Element: Field-level JavaDoc (or getter Method-level JavaDoc, in case the Field does
* not contain a JavaDoc annotation) from the corresponding member is injected as an
* annotation directly inside the element.
* - Attribute: Field-level JavaDoc (or getter Method-level JavaDoc, in case the Field does
* not contain a JavaDoc annotation) from the corresponding member is injected as an
* annotation directly inside the element.
*
* Thus, the following 'vanilla'-generated XSD:
*
*
* <xs:simpleType name="foodPreference">
* <xs:restriction base="xs:string">
* <xs:enumeration value="NONE"/>
* <xs:enumeration value="VEGAN"/>
* <xs:enumeration value="LACTO_VEGETARIAN"/>
* </xs:restriction>
* </xs:simpleType>
*
*
* ... will be converted in a manner similar to the one below:
*
*
* <xs:simpleType name="foodPreference">
* <xs:annotation>
* <xs:documentation><![CDATA[Simple enumeration example defining some Food preferences.]]></xs:documentation>
* </xs:annotation>
* <xs:restriction base="xs:string">
* <xs:enumeration value="LACTO_VEGETARIAN">
* <xs:annotation>
* <xs:documentation><![CDATA[Vegetarian who will not eat meats, but drinks milk.]]></xs:documentation>
* </xs:annotation>
* </xs:enumeration>
* <xs:enumeration value="NONE">
* <xs:annotation>
* <xs:documentation><![CDATA[No special food preferences; eats everything.]]></xs:documentation>
* </xs:annotation>
* </xs:enumeration>
* <xs:enumeration value="VEGAN">
* <xs:annotation>
* <xs:documentation><![CDATA[Vegan who will neither eat meats nor drink milk.]]></xs:documentation>
* </xs:annotation>
* </xs:enumeration>
* </xs:restriction>
* </xs:simpleType>
*
*
* ... given that the Java class FoodPreference has JavaDoc on its class and fields
* corresponding to the injected XSD annotation/documentation elements.
*
* @author Lennart Jörelid, jGuru Europe AB
*/
public class XsdEnumerationAnnotationProcessor implements NodeProcessor {
// Internal state
private SortedMap classJavaDocs;
private SortedMap fieldJavaDocs;
private SortedMap methodJavaDocs;
private JavaDocRenderer renderer;
/**
* Creates an XsdEnumerationAnnotationProcessor that uses the supplied/generated SearchableDocumentation to read all
* JavaDoc structures and the supplied JavaDocRenderer to render JavaDocs into XSD documentation annotations.
*
* @param docs A non-null SearchableDocumentation, produced from the source code of the JAXB compilation unit.
* @param renderer A non-null JavaDocRenderer, used to render the JavaDocData within the SearchableDocumentation.
*/
public XsdEnumerationAnnotationProcessor(final SearchableDocumentation docs, final JavaDocRenderer renderer) {
// Check sanity
Validate.notNull(docs, "docs");
Validate.notNull(renderer, "renderer");
// Assign internal state
this.classJavaDocs = docs.getAll(ClassLocation.class);
this.fieldJavaDocs = docs.getAll(FieldLocation.class);
this.methodJavaDocs = docs.getAll(MethodLocation.class);
this.renderer = renderer;
}
/**
* Only accept simpleTypes which are restrictions to either xs:string or xs:integer.
* The former is generated by JAXB when the Java Enum uses String values, and the latter is used
* for ordinal values.
*
* {@inheritDoc}
*/
@Override
public boolean accept(final Node aNode) {
// Only deal with Element nodes.
if (aNode.getNodeType() != Node.ELEMENT_NODE) {
return false;
}
// We should accept:
//
// 1) A simpleType Element
// 2) An enumeration Element
final Element theElement = (Element) aNode;
final String localName = theElement.getLocalName();
if (localName != null) {
final String trimmed = localName.trim();
return trimmed.equalsIgnoreCase("enumeration")
|| trimmed.equalsIgnoreCase("simpleType");
}
/*
*/
/*
*/
// All done.
return false;
}
/**
* {@inheritDoc}
*/
@Override
public void process(final Node aNode) {
DomHelper.insertXmlDocumentationAnnotationsFor(aNode, classJavaDocs, fieldJavaDocs, methodJavaDocs, renderer);
}
}
location/ 0000775 0000000 0000000 00000000000 13511002134 0041244 5 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/javadoc ClassLocation.java 0000664 0000000 0000000 00000007571 13511002134 0044657 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/javadoc/location package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.codehaus.mojo.jaxb2.shared.Validate;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
/**
* Comparable path structure to locate a particular class within compilation unit.
*
* @author Lennart Jörelid, jGuru Europe AB
* @since 2.0
*/
public class ClassLocation extends PackageLocation {
// Internal state
private String className;
private String classXmlName;
/**
* Creates a new ClassLocation with the supplied package and class names.
*
* @param packageName The name of the package for a class potentially holding JavaDoc. Cannot be {@code null}.
* @param classXmlName The name given as the {@link XmlType#name()} value of an annotation placed on the Class,
* or {@code null} if none is provided.
* @param className The (simple) name of a class. Cannot be null or empty.
*/
public ClassLocation(final String packageName, final String className, final String classXmlName) {
super(packageName);
// Check sanity
Validate.notEmpty(className, "className");
// Assign internal state
this.className = className;
this.classXmlName = classXmlName;
}
/**
* Retrieves the simple class name for the class potentially holding JavaDoc. Never {@code null} or empty.
*
* @return The simple class name for the class potentially holding JavaDoc. Never {@code null} or empty.
*/
public String getClassName() {
return classXmlName == null ? className : classXmlName;
}
/**
* Always appends the effective className to the path from the superclass {@link PackageLocation}.
* If the {@link #getAnnotationRenamedTo()} method returns a non-null value, that value is the effective className.
* Otherwise, the {@link #getClassName()} method is used as the effective className.
*
* This is to handle renames such as provided in a {@link javax.xml.bind.annotation.XmlType} annotation's
* {@link XmlType#name()} attribute value.
*
* @return the path of the PackageLocation superclass, appended with the effective className.
* @see XmlType
* @see XmlAttribute#name()
* @see XmlElement#name()
*/
@Override
public String getPath() {
return super.toString() + "." + getClassName();
}
/**
* {@inheritDoc}
*/
@Override
public String getAnnotationRenamedTo() {
return classXmlName;
}
/**
* {@inheritDoc}
*/
@Override
public int hashCode() {
return this.toString().hashCode();
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
final String xmlOverriddenFrom = classXmlName != null && !className.equals(classXmlName)
? " (from: " + className + ")"
: "";
return super.toString() + "." + getClassName() + xmlOverriddenFrom;
}
}
FieldLocation.java 0000664 0000000 0000000 00000007273 13511002134 0044634 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/javadoc/location package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.codehaus.mojo.jaxb2.shared.Validate;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
/**
* Comparable path structure to locate a particular field within compilation unit.
*
* @author Lennart Jörelid, jGuru Europe AB
* @since 2.0
*/
public class FieldLocation extends ClassLocation {
// Internal state
private String memberName;
private String memberXmlName;
/**
* Creates a new FieldLocation with the supplied package, class and member names.
*
* @param packageName The name of the package for a class potentially holding JavaDoc. Cannot be {@code null}.
* @param className The (simple) name of a class. Cannot be null or empty.
* @param memberName The name of a (method or) field. Cannot be null or empty.
* @param classXmlName The name given as the {@link XmlType#name()} value of an annotation placed on the Class,
* or {@code null} if none is provided.
* @param memberXmlName The name given as the {@link XmlElement#name()} or {@link XmlAttribute#name()} value of
* an annotation placed on this Field, or {@code null} if none is provided.
*/
public FieldLocation(final String packageName,
final String className,
final String classXmlName,
final String memberName,
final String memberXmlName) {
// Delegate
super(packageName, className, classXmlName);
// Check sanity
Validate.notEmpty(memberName, "memberName");
// Assign internal state
this.memberName = memberName;
this.memberXmlName = memberXmlName;
}
/**
* Retrieves the name of the member (i.e. method or field), potentially holding JavaDoc.
*
* @return The name of the member (i.e. method or field), potentially holding JavaDoc.
* Never null or empty.
*/
public String getMemberName() {
return memberXmlName == null ? memberName : memberXmlName;
}
/**
* {@inheritDoc}
*/
@Override
public String getAnnotationRenamedTo() {
return memberXmlName;
}
/**
* {@inheritDoc}
*/
@Override
public String getPath() {
return super.getPath() + "#" + getMemberName();
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
final String xmlOverriddenFrom = memberXmlName != null && !memberName.equals(memberXmlName)
? " (from: " + memberName + ")"
: "";
return super.toString() + "#" + getMemberName() + xmlOverriddenFrom;
}
/**
* {@inheritDoc}
*/
@Override
public int hashCode() {
return this.toString().hashCode();
}
}
MethodLocation.java 0000664 0000000 0000000 00000010076 13511002134 0045024 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/javadoc/location package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import com.thoughtworks.qdox.model.JavaParameter;
import org.codehaus.mojo.jaxb2.shared.Validate;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
import java.util.List;
/**
* Comparable path structure to locate a particular method within compilation unit.
*
* @author Lennart Jörelid, jGuru Europe AB
* @since 2.0
*/
public class MethodLocation extends FieldLocation {
/**
* Signature for a method without any parameters.
*/
public static final String NO_PARAMETERS = "()";
/**
* Separator for a method's parameters.
*/
public static final String PARAMETER_SEPARATOR = ",";
// Internal state
private String parameters = NO_PARAMETERS;
/**
* Creates a new MethodLocation with the supplied package, class and member names.
*
* @param packageName The name of the package for a class potentially holding JavaDoc. Cannot be {@code null}.
* @param className The (simple) name of a class. Cannot be null or empty.
* @param classXmlName The name given as the {@link XmlType#name()} value of an annotation placed on the Class,
* or {@code null} if none is provided.
* @param memberName The name of a (method or) field. Cannot be null or empty.
* @param memberXmlName The name given as the {@link XmlElement#name()} or {@link XmlAttribute#name()} value of
* an annotation placed on this Field, or {@code null} if none is provided.
* @param parameters The names of the types which are parameters to this method.
*/
public MethodLocation(final String packageName,
final String className,
final String classXmlName,
final String memberName,
final String memberXmlName,
final List parameters) {
super(packageName, className, classXmlName, memberName, memberXmlName);
// Check sanity
Validate.notNull(parameters, "parameters");
// Stringify the parameter types
if (parameters.size() > 0) {
final StringBuilder builder = new StringBuilder();
for (JavaParameter current : parameters) {
builder.append(current.getType().getFullyQualifiedName()).append(PARAMETER_SEPARATOR);
}
this.parameters = "(" + builder.substring(0, builder.lastIndexOf(PARAMETER_SEPARATOR)) + ")";
}
}
/**
* {@inheritDoc}
*/
@Override
public String getPath() {
return super.getPath() + parameters;
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
return super.toString() + parameters;
}
/**
* {@inheritDoc}
*/
@Override
public int hashCode() {
return this.toString().hashCode();
}
/**
* @return The parameters, concatenated into a String.
*/
public String getParametersAsString() {
return parameters;
}
/**
* @return True if this MethodLocation has no parameters.
*/
public boolean hasNoParameters() {
return NO_PARAMETERS.equals(parameters);
}
}
PackageLocation.java 0000664 0000000 0000000 00000006747 13511002134 0045151 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/javadoc/location package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.location;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.javadoc.SortableLocation;
import org.codehaus.mojo.jaxb2.shared.Validate;
/**
* Comparable path structure to locate a particular package within compilation unit.
*
* @author Lennart Jörelid, jGuru Europe AB
* @since 2.0
*/
public class PackageLocation implements SortableLocation {
// Internal state
private String packageName;
/**
* Creates a new PackageLocation with the supplied package name.
*
* @param packageName The name of the package potentially holding JavaDoc. Cannot be {@code null}.
*/
public PackageLocation(final String packageName) {
// Check sanity
Validate.notNull(packageName, "packageName");
// Assign internal state
this.packageName = packageName;
}
/**
* Retrieves the name of the package potentially holding JavaDoc.
*
* @return The name of the package potentially holding JavaDoc. Can be empty, but never {@code null}.
*/
public String getPackageName() {
return packageName;
}
/**
* {@inheritDoc}
*/
@Override
public boolean equals(final Object obj) {
// Check sanity
if (obj == this) {
return true;
}
// Delegate
return obj instanceof PackageLocation
&& toString().equals(obj.toString());
}
/**
* {@inheritDoc}
*/
@Override
public int hashCode() {
return toString().hashCode();
}
/**
* Note: Packages cannot be renamed from a JAXB annotation.
* {@inheritDoc}
*/
@Override
public String getAnnotationRenamedTo() {
return null;
}
/**
* {@inheritDoc}
*/
@Override
public String getPath() {
return toString();
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
return packageName;
}
/**
* {@inheritDoc}
*/
@Override
public boolean isEqualToPath(final String path) {
// Check sanity
Validate.notNull(path, "path");
// All done.
return toString().equals(path);
}
/**
* Compares the string representations of this PackageLocation and the supplied SortableLocation.
* {@inheritDoc}
*/
@Override
public int compareTo(final SortableLocation that) {
// Check sanity
Validate.notNull(that, "that");
if (this == that) {
return 0;
}
// Delegate
return this.toString().compareTo(that.toString());
}
}
schemaenhancement/ 0000775 0000000 0000000 00000000000 13511002134 0041473 5 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing ChangeFilenameProcessor.java 0000664 0000000 0000000 00000011402 13511002134 0047062 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/schemaenhancement package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.schemaenhancement;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.NodeProcessor;
import org.codehaus.mojo.jaxb2.shared.Validate;
import org.w3c.dom.Attr;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import javax.xml.XMLConstants;
import java.util.Map;
/**
* NodeProcessor which alters the filename for generated XML schema files.
* The ChangeNamespacePrefixProcessor alters the following:
*
* - Schema Import Definitions
* - <xs:import namespace="http://some/namespace" schemaLocation="schema2.xsd"/> is
* altered to
* <xs:import namespace="http://some/namespace" schemaLocation="anotherFile.xsd"/>
*
*
* @author Lennart Jörelid
* @since 1.4
*/
public class ChangeFilenameProcessor implements NodeProcessor {
// Constants
private static final String SCHEMA_LOCATION = "schemaLocation";
private static final String IMPORT = "import";
private static final String NAMESPACE = "namespace";
// Internal state
private Map namespaceUriToNewFilenameMap;
/**
* Creates a new ChangeFilenameProcessor using the provided map relating namespace URIs
* to desired new file names.
*
* @param namespaceUriToNewFilenameMap A map relating namespace URIs [key] to
* new/desired schema filenames [value].
*/
public ChangeFilenameProcessor(final Map namespaceUriToNewFilenameMap) {
// Check sanity
Validate.notNull(namespaceUriToNewFilenameMap, "namespaceUriToNewFilenameMap");
// Assign internal state
this.namespaceUriToNewFilenameMap = namespaceUriToNewFilenameMap;
}
/**
* {@inheritDoc}
*/
public boolean accept(final Node aNode) {
return aNode instanceof Attr && isSchemaLocationAttributeForKnownNamespaceUri((Attr) aNode);
}
/**
* {@inheritDoc}
*/
public void process(final Node aNode) {
// Only attributes are permitted here.
Attr attribute = (Attr) aNode;
// Change the fileName.
String newFilename = namespaceUriToNewFilenameMap.get(getNamespace(attribute));
attribute.setValue(newFilename);
}
//
// Private helpers
//
/**
* Discovers if the provided attribute is a schemaLocation definition, which should
* be changed by this ChangeFilenameProcessor. Such an attribute is on the form
* <xs:import namespace="http://a/registered/namespace" schemaLocation="schema1.xsd"/>.
*
* @param attribute the attribute to test.
* @return true if the provided attribute is a schemaLocation definition
* whose namespace is known to this ChangeFilenameProcessor.
*/
private boolean isSchemaLocationAttributeForKnownNamespaceUri(final Attr attribute) {
final Element parent = attribute.getOwnerElement();
//
return XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(parent.getNamespaceURI())
&& IMPORT.equalsIgnoreCase(parent.getLocalName())
&& namespaceUriToNewFilenameMap.containsKey(getNamespace(attribute))
&& SCHEMA_LOCATION.equals(attribute.getName());
}
/**
* Retrieves the value of the "namespace" attribute found within the parent element of the provided attribute.
*
* @param attribute An attribute defined within the parent holding the "namespace" attribute.
* @return The value of the "namespace" attribute.
*/
private String getNamespace(final Attr attribute) {
final Element parent = attribute.getOwnerElement();
return parent.getAttribute(NAMESPACE);
}
} ChangeNamespacePrefixProcessor.java 0000664 0000000 0000000 00000020521 13511002134 0050416 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/schemaenhancement package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.schemaenhancement;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.NodeProcessor;
import org.w3c.dom.Attr;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import javax.xml.XMLConstants;
/**
* NodeProcessor which alters the namespace prefix for all relevant Nodes within an XML
* document Node. It alters namespace prefixes in the following logical places:
*
* - Schema Namespace Definition
* - xmlns:oldPrefix="http://some/namespace" is altered to xmlns:newPrefix="http://some/namespace"
* - Elements Namespace Prefix
* - <oldPrefix:someElement ... > is altered to <newPrefix:someElement ... >
* - Element Reference
* <xs:element ref="oldPrefix:aRequiredElementInTheOldPrefixNamespace"/> is altered to
* <xs:element ref="newPrefix:aRequiredElementInTheOldPrefixNamespace"/>- Type Attribute
* <xs:element type="oldPrefix:something"/> is altered to
* <xs:element type="newPrefix:something"/>- Type Extension
* <xs:extension base="oldPrefix:something"/> is altered to
* <xs:extension base="newPrefix:something"/>
*
* @author Lennart Jörelid
* @since 1.4
*/
public class ChangeNamespacePrefixProcessor implements NodeProcessor {
// Constants
//
private static final String EXTENSION_ELEMENT_NAME = "extension";
private static final String EXTENSION_BASE_ATTRIBUTE_NAME = "base";
private static final String REFERENCE_ATTRIBUTE_NAME = "ref";
private static final String TYPE_ATTRIBUTE_NAME = "type";
private static final String SCHEMA = "schema";
private static final String XMLNS = "xmlns:";
//
// private static final String ELEMENT_NAME = "element";
// Internal state
private String oldPrefix;
private String newPrefix;
/**
* Creates a new ChangeNamespacePrefixProcessor providing the oldPrefix which should be replaced by the newPrefix.
*
* @param oldPrefix The old/current namespace prefix
* @param newPrefix The new/substituted namespace prefix
*/
public ChangeNamespacePrefixProcessor(final String oldPrefix, final String newPrefix) {
this.oldPrefix = oldPrefix;
this.newPrefix = newPrefix;
}
/**
* {@inheritDoc}
*/
public boolean accept(final Node aNode) {
if (oldPrefix.equals(aNode.getPrefix())) {
// Process any nodes on the form [oldPrefix]:something.
return true;
}
if (aNode instanceof Attr) {
// These cases are defined by attribute properties.
final Attr attribute = (Attr) aNode;
if (isNamespaceDefinition(attribute)
|| isElementReference(attribute)
|| isTypeAttributeWithPrefix(attribute)
|| isExtension(attribute)) {
return true;
}
}
// Nopes.
return false;
}
/**
* {@inheritDoc}
*/
public void process(final Node aNode) {
if (aNode instanceof Attr) {
final Attr attribute = (Attr) aNode;
final Element parentElement = attribute.getOwnerElement();
if (isNamespaceDefinition(attribute)) {
// Use the incredibly smooth DOM way to rename an attribute...
parentElement.setAttributeNS(attribute.getNamespaceURI(), XMLNS + newPrefix, aNode.getNodeValue());
parentElement.removeAttribute(XMLNS + oldPrefix);
} else if (isElementReference(attribute)
|| isTypeAttributeWithPrefix(attribute)
|| isExtension(attribute)) {
// Simply alter the value of the reference
final String value = attribute.getValue();
final String elementName = value.substring(value.indexOf(":") + 1);
attribute.setValue(newPrefix + ":" + elementName);
}
}
if (oldPrefix.equals(aNode.getPrefix())) {
// Simply change the prefix to the new one.
aNode.setPrefix(newPrefix);
}
}
//
// Private helpers
//
/**
* Discovers if the provided attribute is the oldPrefix namespace definition, i.e. if the given attribute is the
* xmlns:[oldPrefix] within the schema Element.
*
* @param attribute the attribute to test.
* @return true if the provided attribute is the oldPrefix namespace definition, i.e. if the given
* attribute is the xmlns:[oldPrefix] within the schema Element.
*/
private boolean isNamespaceDefinition(final Attr attribute) {
final Element parent = attribute.getOwnerElement();
return XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(parent.getNamespaceURI())
&& SCHEMA.equalsIgnoreCase(parent.getLocalName())
&& oldPrefix.equals(attribute.getLocalName());
}
/**
* Discovers if the provided attribute is a namespace reference to the oldPrefix namespace, on the form
* <xs:element ref="oldPrefix:anElementInTheOldPrefixNamespace"/>
*
* @param attribute the attribute to test.
* @return true if the provided attribute is named "ref" and starts with [oldPrefix]:, in
* which case it is a reference to the oldPrefix namespace.
*/
private boolean isElementReference(final Attr attribute) {
return REFERENCE_ATTRIBUTE_NAME.equals(attribute.getName())
&& attribute.getValue().startsWith(oldPrefix + ":");
}
/**
* Discovers if the provided attribute is a type attribute using the oldPrefix namespace, on the form
* <xs:element type="oldPrefix:anElementInTheOldPrefixNamespace"/>
*
* @param attribute the attribute to test.
* @return true if the provided attribute is named "type" and starts with [oldPrefix]:, in
* which case it is a type in the oldPrefix namespace.
*/
private boolean isTypeAttributeWithPrefix(final Attr attribute) {
return TYPE_ATTRIBUTE_NAME.equals(attribute.getName()) && attribute.getValue().startsWith(oldPrefix + ":");
}
/**
* Discovers if the provided attribute is a namespace reference to the oldPrefix namespace, on the form
*
*
* <xs:extension base="[oldPrefix]:importItem">
*
*
* @param attribute the attribute to test.
* @return true if the provided attribute is named "extension" and starts with
* [oldPrefix]:, in which case it is a reference to the oldPrefix namespace.
*/
private boolean isExtension(final Attr attribute) {
final Element parent = attribute.getOwnerElement();
return XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(parent.getNamespaceURI())
&& EXTENSION_ELEMENT_NAME.equalsIgnoreCase(parent.getLocalName())
&& EXTENSION_BASE_ATTRIBUTE_NAME.equalsIgnoreCase(attribute.getName())
&& attribute.getValue().startsWith(oldPrefix + ":");
}
} SimpleNamespaceResolver.java 0000664 0000000 0000000 00000017753 13511002134 0047143 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/schemaenhancement package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.schemaenhancement;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.codehaus.mojo.jaxb2.schemageneration.XsdGeneratorHelper;
import org.codehaus.mojo.jaxb2.schemageneration.postprocessing.NodeProcessor;
import org.codehaus.plexus.util.IOUtil;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import javax.xml.XMLConstants;
import javax.xml.namespace.NamespaceContext;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.Reader;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
/**
* Namespace resolver for XML documents, which relates XML Namespace Prefixes to XML Namespace URIs.
* Doubles as a JAXB NamespaceContext, if we decide to use JAXB instead of DOM to parse our generated
* schema files.
*
* @author Lennart Jörelid
* @since 1.4
*/
public class SimpleNamespaceResolver implements NamespaceContext {
// Constants
private static final String DEFAULT_NS = "DEFAULT";
private static final String TARGET_NAMESPACE = "targetNamespace";
private static final String SCHEMA = "schema";
// Internal state
private String sourceFilename;
private String localNamespaceURI;
private Map prefix2Uri = new HashMap();
private Map uri2Prefix = new HashMap();
/**
* Creates a new SimpleNamespaceResolver which collects namespace data
* from the provided XML file.
*
* @param xmlFile The XML file from which to collect namespace data, should not be null.
*/
public SimpleNamespaceResolver(final File xmlFile) {
this.sourceFilename = xmlFile.getName();
Reader reader = null;
try {
reader = new FileReader(xmlFile);
initialize(reader);
} catch (FileNotFoundException e) {
throw new IllegalArgumentException("File [" + xmlFile + "] could not be found.");
} finally {
IOUtil.close(reader);
}
}
/**
* {@inheritDoc}
*/
public String getNamespaceURI(final String prefix) {
if (prefix == null) {
// Be compliant with the JAXB contract for NamespaceResolver.
throw new IllegalArgumentException("Cannot handle null prefix argument.");
}
return prefix2Uri.get(XMLConstants.DEFAULT_NS_PREFIX.equals(prefix) ? DEFAULT_NS : prefix);
}
/**
* {@inheritDoc}
*/
public String getPrefix(final String namespaceURI) {
if (namespaceURI == null) {
// Be compliant with the JAXB contract for NamespaceResolver.
throw new IllegalArgumentException("Cannot acquire prefix for null namespaceURI.");
}
return uri2Prefix.get(namespaceURI);
}
/**
* {@inheritDoc}
*/
public Iterator getPrefixes(final String namespaceURI) {
if (namespaceURI == null) {
// Be compliant with the JAXB contract for NamespaceResolver.
throw new IllegalArgumentException("Cannot acquire prefixes for null namespaceURI.");
}
return Collections.singletonList(uri2Prefix.get(namespaceURI)).iterator();
}
/**
* @return A readonly map relating namespace URIs to namespace prefixes.
*/
public Map getNamespaceURI2PrefixMap() {
return Collections.unmodifiableMap(uri2Prefix);
}
/**
* @return The namespace URI of the default namespace within the sourceFile of this SimpleNamespaceResolver.
*/
public String getLocalNamespaceURI() {
return localNamespaceURI;
}
/**
* @return The name of the source file used for this SimpleNamespaceResolver.
*/
public String getSourceFilename() {
return sourceFilename;
}
//
// Private helpers
//
/**
* Initializes this SimpleNamespaceResolver to collect namespace data from the provided stream.
*
* @param xmlFileStream A Reader connected to the XML file from which we should read namespace data.
*/
private void initialize(final Reader xmlFileStream) {
// Build a DOM model.
final Document parsedDocument = XsdGeneratorHelper.parseXmlStream(xmlFileStream);
// Process the DOM model.
XsdGeneratorHelper.process(parsedDocument.getFirstChild(), true, new NamespaceAttributeNodeProcessor());
}
private class NamespaceAttributeNodeProcessor
implements NodeProcessor {
/**
* Defines if this visitor should process the provided node.
*
* @param aNode The DOM node to process.
* @return true if the provided Node should be processed by this NodeProcessor.
*/
public boolean accept(final Node aNode) {
// Correct namespace?
if (aNode.getNamespaceURI() != null
&& XMLConstants.XMLNS_ATTRIBUTE_NS_URI.equals(aNode.getNamespaceURI())) {
return true;
}
// Is this Node the targetNamespace attribute?
if (aNode instanceof Attr) {
final Attr attribute = (Attr) aNode;
final Element parent = attribute.getOwnerElement();
if (XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(parent.getNamespaceURI())
&& SCHEMA.equalsIgnoreCase(parent.getLocalName())
&& TARGET_NAMESPACE.equals(attribute.getLocalName())) {
SimpleNamespaceResolver.this.localNamespaceURI = attribute.getNodeValue();
}
}
// Ignore processing this Node.
return false;
}
/**
* Processes the provided DOM Node.
*
* @param aNode The DOM Node to process.
*/
public void process(final Node aNode) {
// If we have no namespace, use the DEFAULT_NS as the prefix
final String cacheKey = XMLConstants.XMLNS_ATTRIBUTE.equals(aNode.getNodeName())
? DEFAULT_NS
: aNode.getLocalName();
final String nodeValue = aNode.getNodeValue();
// Cache the namespace in both caches.
final String oldUriValue = prefix2Uri.put(cacheKey, nodeValue);
final String oldPrefixValue = uri2Prefix.put(nodeValue, cacheKey);
// Check sanity; we should not be overwriting values here.
if (oldUriValue != null) {
throw new IllegalStateException(
"Replaced URI [" + oldUriValue + "] with [" + aNode.getNodeValue() + "] for prefix [" + cacheKey
+ "]");
}
if (oldPrefixValue != null) {
throw new IllegalStateException(
"Replaced prefix [" + oldPrefixValue + "] with [" + cacheKey + "] for URI [" + aNode.getNodeValue()
+ "]");
}
}
}
} TransformSchema.java 0000664 0000000 0000000 00000020513 13511002134 0045433 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/schemageneration/postprocessing/schemaenhancement package org.codehaus.mojo.jaxb2.schemageneration.postprocessing.schemaenhancement;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.codehaus.mojo.jaxb2.shared.Validate;
/**
* Data holder for schema transformation operations, to permit customization of the
* schema namespace prefix and file name of generated schema. As the schemagen
* tool has no mechanics to control namespace prefix and file name of generated schema,
* the Jaxb2-Maven-plugin must supply a post-processing step to work around this situation.
* Each TransformSchema object holds data pertaining to changes for one namespace
* URI - either namespace prefix used within the generated XSD or resulting filename for
* the schema definition.
*
* - Namespace prefix. Each XML element within a namespace uses the supplied
* prefix. (As a reference, in the XML element
<foo:bar/>, the namespace prefix
* is "foo" and the element name is "bar"). The Schemagen tool by default only generates namespace
* prefixes on the form "ns1", "ns2" etc., which means that the generated schema will contain elements
* on the form <xs:extension base="ns1:nazgulEntity">.
* Use a toPrefix element to change the namespace prefix of a particular XML URI to
* simplify understanding the schema.
* - Filename. By default, the Schemagen tool creates files called "schema1.xsd",
* "schema2.xsd" etc. Since the XSD imports one another, simply changing the filename will frequently
* break the schema structure - you will need to change all import statements in all generated XSD files
* to match the new file names. The Jaxb2 Maven plugin can do all this housekeeping automatically, if you
* create a transformSchema element containing a
toFile element to change the filename for a
* particular XML URI. Changing the file names frequently improves overview and usability of the generated schema
* files.
*
* Example TransformSchemas
* The URI element is mandatory for each TransformSchema element. The first example illustrates how
* to use the TransformSchema element to change the prefix and file name of 3 XML URIs. This is the recommended
* use of a TransformSchema - change both prefix and filename to something meaningful for each URI:
*
* <transformSchemas>
* <transformSchema>
* <uri>http://some/namespace</uri>
* <toPrefix>some</toPrefix>
* <toFile>some_schema.xsd</toFile>
* </transformSchema>
* <transformSchema>
* <uri>http://another/namespace</uri>
* <toPrefix>another</toPrefix>
* <toFile>another_schema.xsd</toFile>
* </transformSchema>
* <transformSchema>
* <uri>http://yet/another/namespace</uri>
* <toPrefix>yetAnother</toPrefix>
* <toFile>yet_another_schema.xsd</toFile>
* </transformSchema>
* </transformSchemas>
*
* The URI element is mandatory for each TransformSchema element, along with at least one of the other two
* elements in the TransformSchema. This implies that partial configuration for TransformSchema can be used,
* although this is not recommended since the readability and usability of the automatically generated
* namespace prefixes and file names are poor. The second example illustrates how to use the TransformSchema element
* to change either prefix or file name for 2 XML URIs:
*
* <transformSchemas>
* <transformSchema>
* <uri>http://another/namespace</uri>
* <toPrefix>another</toPrefix>
* </transformSchema>
* <transformSchema>
* <uri>http://yet/another/namespace</uri>
* <toFile>yet_another_schema.xsd</toFile>
* </transformSchema>
* </transformSchemas>
*
*
* @author Lennart Jörelid
* @since 1.4
*/
public class TransformSchema {
/**
* The empty XML Namespace.
*/
public static final String EMPTY_NAMESPACE = "";
// Internal state
private String uri = EMPTY_NAMESPACE;
private String toPrefix;
private String toFile;
/**
* Default constructor.
*/
public TransformSchema() {
}
/**
* Compound constructor, creating a TransformSchema instruction wrapping the supplied data.
*
* @param uri The URI of this Schema, such as
* http://www.jguru.se/some/namespace. Cannot be null or empty.
* @param toPrefix The new namespace prefix for this Schema. Optional.
* @param toFile The new name of the generated schema file.
*/
public TransformSchema(final String uri, final String toPrefix, final String toFile) {
this.uri = uri;
this.toPrefix = toPrefix;
this.toFile = toFile;
}
/**
* @return The URI of this Schema, such as http://www.jguru.se/some/namespace.
* The namespace URI is mapped to its prefix in the schema element, i.e:
* xmlns:xs="http://www.w3.org/2001/XMLSchema" or
* xmlns:foo="http://www.acme.com/xml/schema/foo".
*/
public String getUri() {
return uri;
}
/**
* @return The namespace prefix of this Schema. Each schema element is related to its namespace using the prefix.
* For an XML element <foo:bar/>, the prefix is "foo" (and the element name is "bar").
*/
public String getToPrefix() {
return toPrefix;
}
/**
* @return the name of the target file if/when renamed.
*/
public String getToFile() {
return toFile;
}
/**
* Assigns the URI of this Schema, such as http://www.jguru.se/some/namespace.
* The namespace URI is mapped to its prefix in the schema element, i.e:
* xmlns:xs="http://www.w3.org/2001/XMLSchema" or
* xmlns:foo="http://www.acme.com/xml/schema/foo".
*
* @param uri The non-empty uri of this Schema.
*/
public void setUri(final String uri) {
// Check sanity
Validate.notEmpty(uri, "uri");
// Assign internal state
this.uri = uri;
}
/**
* Assigns the namespace prefix of this Schema. Each schema element is related to its namespace
* using the prefix. For an XML element <foo:bar/>, the prefix is "foo"
* (and the element name is "bar").
*
* @param toPrefix The non-empty prefix to assign.
*/
public void setToPrefix(final String toPrefix) {
// Check sanity
Validate.notEmpty(toPrefix, "toPrefix");
// Assign internal state
this.toPrefix = toPrefix;
}
/**
* Assigns the the name of the target file if/when renamed.
*
* @param toFile The non-empty filename to assign.
*/
public void setToFile(final String toFile) {
// Check sanity
Validate.notEmpty(toFile, "toFile");
// Assign internal state
this.toFile = toFile;
}
/**
* {@inheritDoc}
*/
public String toString() {
return "[ uri: " + uri + " --> prefix: " + toPrefix + ", file: " + toFile + " ]";
}
} jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/shared/ 0000775 0000000 0000000 00000000000 13511002134 0030754 5 ustar 00root root 0000000 0000000 FileSystemUtilities.java 0000664 0000000 0000000 00000074153 13511002134 0035532 0 ustar 00root root 0000000 0000000 jaxb2-maven-plugin-jaxb2-maven-plugin-2.5.0/src/main/java/org/codehaus/mojo/jaxb2/shared package org.codehaus.mojo.jaxb2.shared;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.logging.Log;
import org.codehaus.mojo.jaxb2.AbstractJaxbMojo;
import org.codehaus.mojo.jaxb2.shared.filters.Filter;
import org.codehaus.mojo.jaxb2.shared.filters.Filters;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.Os;
import org.codehaus.plexus.util.StringUtils;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
/**
* The Jaxb2 Maven Plugin needs to fiddle with the filesystem a great deal, to create and optionally prune
* directories or detect/create various files. This utility class contains all such algorithms, and serves as
* an entry point to any Plexus Utils methods.
*
* @author Lennart Jörelid
* @since 2.0
*/
public final class FileSystemUtilities {
/*
* Hide the constructor for utility classes.
*/
private FileSystemUtilities() {
// Do nothing
}
/**
* FileFilter which accepts Files that exist and for which {@code File.isFile() } is {@code true}.
*/
public static final FileFilter EXISTING_FILE = new FileFilter() {
@Override
public boolean accept(final File candidate) {
return candidate != null && candidate.exists() && candidate.isFile();
}
};
/**
* FileFilter which accepts Files that exist and for which {@code File.isDirectory() } is {@code true}.
*/
public static final FileFilter EXISTING_DIRECTORY = new FileFilter() {
@Override
public boolean accept(final File candidate) {
return candidate != null && candidate.exists() && candidate.isDirectory();
}
};
/**
* Acquires the canonical path for the supplied file.
*
* @param file A non-null File for which the canonical path should be retrieved.
* @return The canonical path of the supplied file.
*/
public static String getCanonicalPath(final File file) {
return getCanonicalFile(file).getPath();
}
/**
* Non-valid Characters for naming files, folders under Windows: ":", "*", "?", "\"", "<", ">", "|"
*
* @see
* http://support.microsoft.com/?scid=kb%3Ben-us%3B177506&x=12&y=13
* @see org.codehaus.plexus.util.FileUtils
*/
private static final String[] INVALID_CHARACTERS_FOR_WINDOWS_FILE_NAME = {":", "*", "?", "\"", "<", ">", "|"};
/**
* Acquires the canonical File for the supplied file.
*
* @param file A non-null File for which the canonical File should be retrieved.
* @return The canonical File of the supplied file.
*/
public static File getCanonicalFile(final File file) {
// Check sanity
Validate.notNull(file, "file");
// All done
try {
return file.getCanonicalFile();
} catch (IOException e) {
throw new IllegalArgumentException("Could not acquire the canonical file for ["
+ file.getAbsolutePath() + "]", e);
}
}
/**
* Retrieves the canonical File matching the supplied path in the following order or priority:
*
* - Absolute path: The path is used by itself (i.e. {@code new File(path);}). If an
* existing file or directory matches the provided path argument, its canonical path will be returned.
* - Relative path: The path is appended to the baseDir (i.e.
* {@code new File(baseDir, path);}). If an existing file or directory matches the provided path argument,
* its canonical path will be returned. Only in this case will be baseDir argument be considered.
*
* If no file or directory could be derived from the supplied path and baseDir, {@code null} is returned.
*
* @param path A non-null path which will be used to find an existing file or directory.
* @param baseDir A directory to which the path will be appended to search for the existing file or directory in
* case the file was nonexistent when interpreted as an absolute path.
* @return either a canonical File for the path, or {@code null} if no file or directory matched
* the supplied path and baseDir.
*/
public static File getExistingFile(final String path, final File baseDir) {
// Check sanity
Validate.notEmpty(path, "path");
final File theFile = new File(path);
File toReturn = null;
// Is 'path' absolute?
if (theFile.isAbsolute() && (EXISTING_FILE.accept(theFile) || EXISTING_DIRECTORY.accept(theFile))) {
toReturn = getCanonicalFile(theFile);
}
// Is 'path' relative?
if (!theFile.isAbsolute()) {
// In this case, baseDir cannot be null.
Validate.notNull(baseDir, "baseDir");
final File relativeFile = new File(baseDir, path);
if (EXISTING_FILE.accept(relativeFile) || EXISTING_DIRECTORY.accept(relativeFile)) {
toReturn = getCanonicalFile(relativeFile);
}
}
// The path provided did not point to an existing File or Directory.
return toReturn;
}
/**
* Retrieves the URL for the supplied File. Convenience method which hides exception handling
* for the operation in question.
*
* @param aFile A File for which the URL should be retrieved.
* @return The URL for the supplied aFile.
* @throws java.lang.IllegalArgumentException if getting the URL yielded a MalformedURLException.
*/
public static URL getUrlFor(final File aFile) throws IllegalArgumentException {
// Check sanity
Validate.notNull(aFile, "aFile");
try {
return aFile.toURI().normalize().toURL();
} catch (MalformedURLException e) {
throw new IllegalArgumentException("Could not retrieve the URL from file ["
+ getCanonicalPath(aFile) + "]", e);
}
}
/**
* Acquires the file for a supplied URL, provided that its protocol is is either a file or a jar.
*
* @param anURL a non-null URL.
* @param encoding The encoding to be used by the URLDecoder to decode the path found.
* @return The File pointing to the supplied URL, for file or jar protocol URLs and null otherwise.
*/
public static File getFileFor(final URL anURL, final String encoding) {
// Check sanity
Validate.notNull(anURL, "anURL");
Validate.notNull(encoding, "encoding");
final String protocol = anURL.getProtocol();
File toReturn = null;
if ("file".equalsIgnoreCase(protocol)) {
try {
final String decodedPath = URLDecoder.decode(anURL.getPath(), encoding);
toReturn = new File(decodedPath);
} catch (Exception e) {
throw new IllegalArgumentException("Could not get the File for [" + anURL + "]", e);
}
} else if ("jar".equalsIgnoreCase(protocol)) {
try {
// Decode the JAR
final String tmp = URLDecoder.decode(anURL.getFile(), encoding);
// JAR URLs generally contain layered protocols, such as:
// jar:file:/some/path/to/nazgul-tools-validation-aspect-4.0.2.jar!/the/package/ValidationAspect.class
final URL innerURL = new URL(tmp);
// We can handle File protocol URLs here.
if ("file".equalsIgnoreCase(innerURL.getProtocol())) {
// Peel off the inner protocol
final String innerUrlPath = innerURL.getPath();
final String filePath = innerUrlPath.contains("!")
? innerUrlPath.substring(0, innerUrlPath.indexOf("!"))
: innerUrlPath;
toReturn = new File(URLDecoder.decode(filePath, encoding));
}
} catch (Exception e) {
throw new IllegalArgumentException("Could not get the File for [" + anURL + "]", e);
}
}
// All done.
return toReturn;
}
/**
* Filters files found either in the sources paths (or in the standardDirectory if no explicit sources are given),
* and retrieves a List holding those files that do not match any of the supplied Java Regular Expression
* excludePatterns.
*
* @param baseDir The non-null basedir Directory.
* @param sources The sources which should be either absolute or relative (to the given baseDir)
* paths to files or to directories that should be searched recursively for files.
* @param standardDirectories If no sources are given, revert to searching all files under these standard
* directories. Each path is {@code relativize()}-d to the supplied baseDir to
* reach a directory path.
* @param log A non-null Maven Log for logging any operations performed.
* @param fileTypeDescription A human-readable short description of what kind of files are searched for, such as
* "xsdSources" or "xjbSources".
* @param excludePatterns An optional List of patterns used to construct an ExclusionRegExpFileFilter used to
* identify files which should be excluded from the result.
* @return URLs to all Files under the supplied sources (or standardDirectories, if no explicit sources
* are given) which do not match the supplied Java Regular excludePatterns.
*/
@SuppressWarnings("all")
public static List filterFiles(final File baseDir,
final List sources,
final List standardDirectories,
final Log log,
final String fileTypeDescription,
final List> excludePatterns) {
final SortedMap pathToResolvedSourceMap = new TreeMap();
for (String current : standardDirectories) {
for (File currentResolvedSource : FileSystemUtilities.filterFiles(
baseDir,
sources,
FileSystemUtilities.relativize(current, baseDir, true),
log,
fileTypeDescription,
excludePatterns)) {
// Add the source
pathToResolvedSourceMap.put(
FileSystemUtilities.getCanonicalPath(currentResolvedSource),
currentResolvedSource);
}
}
final List toReturn = new ArrayList();
// Extract the URLs for all resolved Java sources.
for (Map.Entry current : pathToResolvedSourceMap.entrySet()) {
toReturn.add(FileSystemUtilities.getUrlFor(current.getValue()));
}
if (log.isDebugEnabled()) {
final StringBuilder builder = new StringBuilder();
builder.append("\n+=================== [Filtered " + fileTypeDescription + "]\n");
builder.append("|\n");
builder.append("| " + excludePatterns.size() + " Exclude patterns:\n");
for (int i = 0; i < excludePatterns.size(); i++) {
builder.append("| [" + (i + 1) + "/" + excludePatterns.size() + "]: " + excludePatterns.get(i) + "\n");
}
builder.append("|\n");
builder.append("| " + standardDirectories.size() + " Standard Directories:\n");
for (int i = 0; i < standardDirectories.size(); i++) {
builder.append("| [" + (i + 1) + "/" + standardDirectories.size() + "]: "
+ standardDirectories.get(i) + "\n");
}
builder.append("|\n");
builder.append("| " + toReturn.size() + " Results:\n");
for (int i = 0; i < toReturn.size(); i++) {
builder.append("| [" + (i + 1) + "/" + toReturn.size() + "]: " + toReturn.get(i) + "\n");
}
builder.append("|\n");
builder.append("+=================== [End Filtered " + fileTypeDescription + "]\n\n");
// Log all.
log.debug(builder.toString().replace("\n", AbstractJaxbMojo.NEWLINE));
}
// All done.
return toReturn;
}
/**
* Filters files found either in the sources paths (or in the standardDirectory if no explicit sources are given),
* and retrieves a List holding those files that do not match any of the supplied Java Regular Expression
* excludePatterns.
*
* @param baseDir The non-null basedir Directory.
* @param sources The sources which should be either absolute or relative (to the given baseDir)
* paths to files or to directories that should be searched recursively for files.
* @param standardDirectory If no sources are given, revert to searching all files under this standard directory.
* This is the path appended to the baseDir to reach a directory.
* @param log A non-null Maven Log for logging any operations performed.
* @param fileTypeDescription A human-readable short description of what kind of files are searched for, such as
* "xsdSources" or "xjbSources".
* @param excludeFilters An optional List of Filters used to identify files which should be excluded from
* the result.
* @return All files under the supplied sources (or standardDirectory, if no explicit sources are given) which
* do not match the supplied Java Regular excludePatterns.
*/
@SuppressWarnings("CheckStyle")
public static List filterFiles(final File baseDir,
final List sources,
final String standardDirectory,
final Log log,
final String fileTypeDescription,
final List> excludeFilters) {
// Check sanity
Validate.notNull(baseDir, "baseDir");
Validate.notNull(log, "log");
Validate.notEmpty(standardDirectory, "standardDirectory");
Validate.notEmpty(fileTypeDescription, "fileTypeDescription");
// No sources provided? Fallback to the standard (which should be a relative path).
List effectiveSources = sources;
if (sources == null || sources.isEmpty()) {
effectiveSources = new ArrayList