fr.norad.jaxrs.doc.plugin.DocGeneratorMojo Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jaxrs-doc-plugin Show documentation
The newest version!
/**
 *
 *     Copyright (C) norad.fr
 *
 *     Licensed under the Apache License, Version 2.0 (the "License");
 *     you may not use this file except in compliance with the License.
 *     You may obtain a copy of the License at
 *
 *             http://www.apache.org/licenses/LICENSE-2.0
 *
 *     Unless required by applicable law or agreed to in writing, software
 *     distributed under the License is distributed on an "AS IS" BASIS,
 *     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *     See the License for the specific language governing permissions and
 *     limitations under the License.
 */
package fr.norad.jaxrs.doc.plugin;

import java.io.File;
import java.util.Arrays;
import org.apache.maven.plugin.AbstractMojo;
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 com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.introspect.AnnotationIntrospectorPair;
import com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector;
import com.fasterxml.jackson.databind.type.TypeFactory;
import com.fasterxml.jackson.module.jaxb.JaxbAnnotationIntrospector;
import fr.norad.jaxrs.doc.JaxrsDocProcessorFactory;
import fr.norad.jaxrs.doc.ParserHolder;
import fr.norad.jaxrs.doc.api.domain.ProjectDefinition;
import fr.norad.jaxrs.doc.parserapi.ApiParser;
import fr.norad.jaxrs.doc.parserapi.ModelParser;
import fr.norad.jaxrs.doc.parserapi.OperationParser;
import fr.norad.jaxrs.doc.parserapi.ParameterParser;
import fr.norad.jaxrs.doc.parserapi.ProjectParser;
import fr.norad.jaxrs.doc.parserapi.PropertyParser;
import fr.norad.jaxrs.doc.processor.ApiProcessor;
import fr.norad.jaxrs.doc.processor.ModelProcessor;
import fr.norad.jaxrs.doc.processor.OperationProcessor;
import fr.norad.jaxrs.doc.processor.ParameterProcessor;
import fr.norad.jaxrs.doc.processor.ProjectProcessor;
import fr.norad.jaxrs.doc.processor.PropertyProcessor;

@Mojo(name = "generate-doc", defaultPhase = LifecyclePhase.PROCESS_CLASSES,
      configurator = "include-project-dependencies",
      requiresDependencyResolution = ResolutionScope.COMPILE_PLUS_RUNTIME)
public class DocGeneratorMojo extends AbstractMojo {
    @Parameter(defaultValue = "${project.build.directory}/jaxrs-doc-${version}.json", property = "outputFile",
               required = false)
    private File outputFile;
    @Parameter(defaultValue = "${project.artifactId}", property = "artifactId", required = false)
    private String name;
    @Parameter(defaultValue = "${project.version}", property = "version", required = false)
    private String version;
    @Parameter(defaultValue = "${packageIncludes}", property = "packageIncludes", required = true)
    private String[] packageIncludes;
    @Parameter(property = "projectParsers", required = false)
    private String[] projectParsers;
    @Parameter(property = "apiParsers", required = false)
    private String[] apiParsers;
    @Parameter(property = "operationParsers", required = false)
    private String[] operationParsers;
    @Parameter(property = "parameterParsers", required = false)
    private String[] parameterParsers;
    @Parameter(property = "modelParsers", required = false)
    private String[] modelParsers;
    @Parameter(property = "propertyParsers", required = false)
    private String[] propertyParsers;
    @Parameter(property = "additionalProjectParsers", required = false)
    private String[] additionalProjectParsers;
    @Parameter(property = "additionalApiParsers", required = false)
    private String[] additionalApiParsers;
    @Parameter(property = "additionalOperationParsers", required = false)
    private String[] additionalOperationParsers;
    @Parameter(property = "additionalParameterParsers", required = false)
    private String[] additionalParameterParsers;
    @Parameter(property = "additionalModelParsers", required = false)
    private String[] additionalModelParsers;
    @Parameter(property = "additionalPropertyParsers", required = false)
    private String[] additionalPropertyParsers;
    private ObjectMapper objectMapper;

    public DocGeneratorMojo() {
        objectMapper = new ObjectMapper();
        objectMapper.setSerializationInclusion(Include.NON_NULL);
        objectMapper.setAnnotationIntrospector(new AnnotationIntrospectorPair(new JacksonAnnotationIntrospector(),
                                                                              new JaxbAnnotationIntrospector(
                                                                                      TypeFactory.defaultInstance())));
    }

    @Override
    public void execute() throws MojoExecutionException {
        outputFile = new File(outputFile.getAbsolutePath().replace("${version}", version));
        try {
            JaxrsDocProcessorFactory processorFactory = prepareFactory();
            writeDefinitionToFile(processorFactory.getProjectProcessor().process());
        } catch (Exception e) {
            getLog().error(e);
            throw new MojoExecutionException("Jaxrs doc generation fail", e);
        }
    }

    private JaxrsDocProcessorFactory prepareFactory() {
        JaxrsDocProcessorFactory factory = new JaxrsDocProcessorFactory(Arrays.asList(packageIncludes),
                                                                        name, version);
        if (projectParsers.length > 0) {
            factory.setProjectProcessor(new ProjectProcessor(factory, new ParserHolder(projectParsers)));
        } else if (additionalProjectParsers.length > 0) {
            factory.getProjectProcessor().getParsers().addAll(additionalProjectParsers);
        }

        if (apiParsers.length > 0) {
            factory.setApiProcessor(new ApiProcessor(factory, new ParserHolder(apiParsers)));
        } else if (additionalApiParsers.length > 0) {
            factory.getApiProcessor().getParsers().addAll(additionalApiParsers);
        }

        if (operationParsers.length > 0) {
            factory.setOperationProcessor(new OperationProcessor(factory,
                                                                 new ParserHolder(operationParsers)));
        } else if (additionalOperationParsers.length > 0) {
            factory.getOperationProcessor().getParsers().addAll(additionalOperationParsers);
        }

        if (parameterParsers.length > 0) {
            factory.setParameterProcessor(new ParameterProcessor(factory,
                                                                 new ParserHolder(parameterParsers)));
        } else if (additionalParameterParsers.length > 0) {
            factory.getParameterProcessor().getParsers().addAll(additionalParameterParsers);
        }

        if (modelParsers.length > 0) {
            factory.setModelProcessor(new ModelProcessor(factory, new ParserHolder(modelParsers)));
        } else if (additionalModelParsers.length > 0) {
            factory.getModelProcessor().getParsers().addAll(additionalModelParsers);
        }

        if (propertyParsers.length > 0) {
            factory.setPropertyProcessor(
                    new PropertyProcessor(factory, new ParserHolder(propertyParsers)));
        } else if (additionalPropertyParsers.length > 0) {
            factory.getPropertyProcessor().getParsers().addAll(additionalPropertyParsers);
        }
        return factory;
    }

    private void writeDefinitionToFile(ProjectDefinition definition) {
        if (!outputFile.getParentFile().exists()) {
            outputFile.getParentFile().mkdirs();
        }

        try {
            getLog().info("Writing project definition to file : " + outputFile);
            objectMapper.writer().writeValue(outputFile, definition);
        } catch (Exception e) {
            throw new IllegalStateException("Cannot write project definition to file : " + outputFile, e);
        }
    }

}