Java2WSDLMojo.java

package org.codehaus.mojo.axistools;

/*
 * 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.io.File;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.Set;

import org.apache.commons.lang.StringUtils;
import org.apache.maven.artifact.DependencyResolutionRequiredException;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.MavenProjectHelper;
import org.codehaus.mojo.axistools.axis.AxisPluginException;
import org.codehaus.mojo.axistools.java2wsdl.DefaultJava2WSDLPlugin;

/**
 * A Plugin for generating WSDL files using Axis Java2WSDL.
 *
 * @author jesse <jesse.mcconnell@gmail.com>
 * @version $Id$
 * @goal java2wsdl
 * @phase process-classes
 * @requiresDependencyResolution compile
 * @description Java2WSDL plugin
 */
public class Java2WSDLMojo
    extends AbstractMojo
{
    /**
     * The directory the compile objects will be located for java2wsdl to source from.
     * @parameter default-value="${project.build.outputDirectory}"
     */
    private File classesDirectory;

    /**
     * Directory for generated content.
     *
     * Corresponds to the <code>-o, --output</code> option in the Java2WSDL command line tool,
     * together with the {@linkplain #filename} parameter.
     *
     * @parameter default-value="${project.build.directory}/generated-sources/axistools/java2wsdl"
     */
    private File outputDirectory;

    /**
     * Indicates the name of the output WSDL file.
     *
     * Corresponds to the <code>-o, --output</code> option in the Java2WSDL command line tool,
     * together with the {@linkplain #outputDirectory} parameter.
     *
     * @parameter expression="${fileName}"
     * @required
     */
    private String filename;

    /**
     * The class-of-portType.
     *
     * @parameter expression="${classOfPortType}"
     */
    private String classOfPortType;

    /**
     * Optional parameter that indicates the name of the input wsdl file. 
     * The output wsdl file will contain everything from the input wsdl file plus the new constructs. 
     * If a new construct is already present in the input wsdl file, it is not added. 
     * This option is useful for constructing a wsdl file with multiple ports, bindings, or portTypes.
     *
     * Corresponds to the <code>-I, --input</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${input}"
     */
    private String input;

    /**
     * Indicates the url of the location of the service. 
     * The name after the last slash or backslash is the name of the service port 
     * (unless overridden by the servicePortName option). 
     * The service port address location attribute is assigned the specified value.
     *
     * Corresponds to the <code>-l, --location</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${location}"
     */
    private String location;

    /**
     * Indicates the name to use for the portType element. If not specified, the
     * {@linkplain #classOfPortType} name is used.
     *
     * Corresponds to the <code>-P, --portTypeName</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${portTypeName}"
     */
    private String portTypeName;

    /**
     * Indicates the name to use for the binding element. 
     * If not specified, the value of the {@linkplain #servicePortName} + "SoapBinding" is used.
     *
     * Corresponds to the <code>-b, --bindingName</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${bindingName}"
     */
    private String bindingName;

    /**
     * Service element name (defaults to servicePortName value + "Service").
     *
     * Corresponds to the <code>-S, --serviceElementName</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${serviceElementName}"
     */
    private String serviceElementName;

    /**
     * Indicates the name of the service port. 
     * If not specified, the service port name is derived from the location value. 
     *
     * Corresponds to the <code>-s, --servicePortName</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${servicePortName}"
     */
    private String servicePortName;

    /**
     * Indicates the name of the target namespace of the WSDL.
     *
     * Corresponds to the <code>-n, --namespace</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${namespace}"
     */
    private String namespace;

    /**
     * Package=namespace, name value pair.
     * The plugin currently only supports one name value pair.
     *
     * Corresponds to the <code>-p, --PkgtoNS</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${packageToNamespace}"
     */
    private String packageToNamespace;

    /**
     * Methods to export.
     *
     * Corresponds to the <code>-m, --methods</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${methods}"
     */
    private ArrayList methods;

    /**
     * Look for allowed methods in inherited class.
     *
     * Corresponds to the <code>-a, --all</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="false"
     */
    private boolean all;

    /**
     * Indicates the kind of WSDL to generate. Accepted values are:
     * <ul>
     *   <li>All --- (default) Generates wsdl containing both interface and
     *       implementation WSDL constructs.</li>
     *   <li>Interface --- Generates a WSDL containing the interface constructs
     *       (no service element).</li>
     *   <li>Implementation -- Generates a WSDL containing the implementation.
     *       The interface WSDL is imported via the {@linkplain #locationImport}
     *       option.</li>
     * </ul>
     *
     * Corresponds to the <code>-w, --outputWsdlMode</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${outputWSDLMode}"
     */
    private String outputWSDLMode;

    /**
     * Used to indicate the location of the interface WSDL when generating an implementation WSDL.
     *
     * Corresponds to the <code>-L, --locationImport</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${locationImport}"
     */
    private String locationImport;

    /**
     * Namespace of the implementation WSDL.
     *
     * Corresponds to the <code>-N, --namespaceImpl</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${namespaceImpl}"
     */
    private String namespaceImpl;

    /**
     * Use this option to indicate the name of the output implementation WSDL file. 
     * If specified, Java2WSDL will produce interface and implementation WSDL files. 
     * If this option is used, the {@linkplain #outputWSDLMode} option is ignored.
     *
     * Corresponds to the <code>-O, --outputImpl</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${outputImpl}"
     */
    private String outputImpl;

    /**
     * Sometimes extra information is available in the implementation class file. 
     * Use this option to specify the implementation class.
     *
     * Corresponds to the <code>-i, --implClass</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${implClass}"
     */
    private String implClass;

    /**
     * List of methods not to export.
     *
     * Corresponds to the <code>-x, --exclude</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${exclude}"
     */
    private ArrayList excludes;

    /**
     * List of classes which stop the Java2WSDL inheritance search.
     *
     * Corresponds to the <code>-c, --stopClasses</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${stopClasses}"
     */
    private ArrayList stopClasses;

    /**
     * Choose the default type mapping registry to use. Either 1.1 or 1.2.
     *
     * Corresponds to the <code>-T, --typeMappingVersion</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${typeMappingVersion}"
     */
    private String typeMappingVersion;

    /**
     * The value of the operations soapAction field. 
     * Values are DEFAULT, OPERATION or NONE. 
     * OPERATION forces soapAction to the name of the operation. 
     * DEFAULT causes the soapAction to be set according to the operation's meta data (usually ""). 
     * NONE forces the soapAction to "". The default is DEFAULT.
     *
     * Corresponds to the <code>-A, --soapAction</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${soapAction}"
     */
    private String soapAction;

    /**
     * The style of the WSDL document: RPC, DOCUMENT or WRAPPED. 
     * The default is RPC. If RPC is specified, an rpc wsdl is generated. 
     * If DOCUMENT is specified, a document wsdl is generated. 
     * If WRAPPED is specified, a document/literal wsdl is generated using the wrapped approach. 
     * Wrapped style forces the use attribute to be literal.
     *
     * Corresponds to the <code>-y, --style</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${style}"
     */
    private String style;

    /**
     * The use of the WSDL document: LITERAL or ENCODED. 
     * If LITERAL is specified, the XML Schema defines the representation of the XML for the request. 
     * If ENCODED is specified, SOAP encoding is specified in the generated WSDL.
     *
     * Corresponds to the <code>-u, --use</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${use}"
     */
    private String use;

    /**
     * Specify a list of class names which should be included in the types
     * section of the WSDL document.
     * This is useful in the case where your service interface references a base
     * class and you would like your WSDL to contain XML Schema type definitions
     * for these other classes. 
     *
     * Corresponds to the <code>-e, --extraClasses</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${extraClasses}"
     */
    private ArrayList extraClasses;

    /**
     * A file or URL to an XML Schema that should be physically imported into the generated WSDL.
     *
     * Corresponds to the <code>-C, --importSchema</code> option in the Java2WSDL command line tool.
     *
     * @parameter expression="${importSchema}"
     */
    private String importSchema;

    /**
     * @parameter expression="${project}"
     * @required
     * @readonly
     */
    private MavenProject project;

    /**
     * @component
     */
    private MavenProjectHelper projectHelper;

    public void execute()
        throws MojoExecutionException, MojoFailureException
    {
        DefaultJava2WSDLPlugin plugin = new DefaultJava2WSDLPlugin();
        
        String classpath = getCompileClasspath();

        plugin.setAll( all );
        plugin.setBindingName( bindingName );
        plugin.setClasspath( classpath );
        plugin.setClassOfPortType( classOfPortType );
        plugin.setExcludes( excludes );
        plugin.setExtraClasses( extraClasses );
        plugin.setFilename( filename );
        plugin.setImplClass( implClass );
        plugin.setImportSchema( importSchema );
        plugin.setInput( input );
        plugin.setLocation( location );
        plugin.setLocationImport( locationImport );
        plugin.setMethods( methods );
        plugin.setNamespace( namespace );
        plugin.setNamespaceImpl( namespaceImpl );
        plugin.setOutputDirectory( outputDirectory );
        plugin.setOutputImpl( outputImpl );
        plugin.setOutputWSDLMode( outputWSDLMode );
        plugin.setPackageToNamespace( packageToNamespace );
        plugin.setPortTypeName( portTypeName );
        plugin.setServiceElementName( serviceElementName );
        plugin.setServicePortName( servicePortName );
        plugin.setSoapAction( soapAction );
        plugin.setStopClasses( stopClasses );
        plugin.setStyle( style );
        plugin.setTypeMappingVersion( typeMappingVersion );
        plugin.setUse( use );
        plugin.setLog( getLog() );
        plugin.setProjectHelper( projectHelper );
        plugin.setProject( project );

        try
        {
            plugin.execute();
        }
        catch ( AxisPluginException e )
        {
            throw new MojoExecutionException( "Error executing creating WSDL from the Java code.", e );
        }
    }
    
    /**
     * Computes the runtime classpath.
     * 
     * @return A representation of the computed runtime classpath.
     * @throws MojoExecutionException in case of dependency resolution failure
     */
    private String getCompileClasspath()
        throws MojoExecutionException
    {
        try
        {
            // get the union of compile- and runtime classpath elements
            Set dependencySet = new LinkedHashSet();
            dependencySet.addAll( project.getCompileClasspathElements() );
            dependencySet.add( classesDirectory.getAbsolutePath() );
            String compileClasspath = StringUtils.join( dependencySet, File.pathSeparator );

            return compileClasspath;
        }
        catch ( DependencyResolutionRequiredException e )
        {
            throw new MojoExecutionException( e.getMessage(), e );
        }
    }

}