• Home
• org.wildfly.swarm
• wildfly-swarm-fraction-plugin
• 67
• source code
• FractionReferenceMojo.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.wildfly.swarm.plugin.doc.FractionReferenceMojo Maven / Gradle / Ivy

/*
 * Copyright 2016 Red Hat, Inc, and individual contributors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.wildfly.swarm.plugin.doc;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import java.util.jar.JarFile;
import java.util.zip.ZipEntry;

import javax.inject.Inject;

import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.eclipse.aether.artifact.DefaultArtifact;
import org.eclipse.aether.impl.ArtifactResolver;
import org.eclipse.aether.repository.LocalArtifactRequest;
import org.eclipse.aether.repository.LocalArtifactResult;
import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.resolution.ArtifactRequest;
import org.eclipse.aether.resolution.ArtifactResolutionException;
import org.eclipse.aether.resolution.ArtifactResult;
import org.wildfly.swarm.plugin.AbstractFractionsMojo;
import org.wildfly.swarm.plugin.FractionMetadata;

@Mojo(name = "fraction-reference",
        defaultPhase = LifecyclePhase.GENERATE_RESOURCES)
public class FractionReferenceMojo extends AbstractFractionsMojo {

    @Override
    @SuppressWarnings("unchecked")
    public void execute() throws MojoExecutionException, MojoFailureException {
        Set allFractions = fractions();
        allFractions.forEach(e -> {
            try {
                generateReference(e);
            } catch (ArtifactResolutionException | IOException e1) {
                e1.printStackTrace();
            }
        });

        try {
            generateIndex(allFractions);
        } catch (FileNotFoundException e) {
            throw new MojoFailureException("unable to generate index", e);
        }
    }

    private void generateIndex(Set allFractions) throws FileNotFoundException {
        Path output = this.project.getBasedir().toPath().resolve("index.adoc");

        try (PrintStream writer = new PrintStream(new FileOutputStream(output.toFile()))) {
            allFractions.stream()
                    .sorted(Comparator.comparing(FractionMetadata::getName))
                    .forEach(fraction -> {
                        writer.println("include::fractions/" + fraction.getArtifactId() + ".adoc[]");
                        writer.println();
                    });
        }
    }

    private void generateReference(FractionMetadata fraction) throws ArtifactResolutionException, IOException {
        File artifact = resolveArtifact(fraction.getGroupId(),
                                        fraction.getArtifactId(),
                                        fraction.getVersion(),
                                        null,
                                        "jar");

        Path output = this.project.getBasedir().toPath().resolve("fractions").resolve(fraction.getArtifactId() + ".adoc");

        Files.createDirectories(output.getParent());

        try (JarFile jar = new JarFile(artifact)) {
            try (PrintStream writer = new PrintStream(new FileOutputStream(output.toFile()))) {
                ZipEntry readme = jar.getEntry("META-INF/README.adoc");
                if (readme != null) {
                    try (BufferedReader readmeStream = new BufferedReader(new InputStreamReader(jar.getInputStream(readme)))) {
                        readmeStream.lines().forEach(writer::println);
                    }
                } else {
                    writer.println("# " + fraction.getName());
                }
                writer.println();

                writer.println("## Coordinates");
                writer.println();
                writer.println("[source,xml]");
                writer.println("----");
                writer.println("");
                writer.println("  " + fraction.getGroupId() + "");
                writer.println("  " + fraction.getArtifactId() + "");
                writer.println("");
                writer.println("----");
                writer.println();

                ZipEntry ref = jar.getEntry("META-INF/configuration-meta.properties");
                if (ref != null) {
                    writer.println("## Configuration");
                    writer.println();
                    Properties props = new Properties();
                    props.load(jar.getInputStream(ref));
                    List names = new ArrayList<>();
                    names.addAll(props.stringPropertyNames());
                    Collections.sort(names);

                    names.forEach(name -> {
                        if (!name.equals("fraction")) {
                            writer.println(name.replace("*", "_KEY_") + ":: ");
                            writer.println(props.getProperty(name));
                            writer.println();
                        }
                    });
                }
            }
        }
    }

    private File resolveArtifact(final String group,
                                 final String name,
                                 final String version,
                                 final String classifier,
                                 final String type) throws ArtifactResolutionException {
        final DefaultArtifact artifact = new DefaultArtifact(group, name, classifier, type, version);
        final LocalArtifactResult localResult = this.repositorySystemSession.getLocalRepositoryManager()
                .find(this.repositorySystemSession, new LocalArtifactRequest(artifact, this.remoteRepositories, null));
        File file = null;

        if (localResult.isAvailable()) {
            file = localResult.getFile();
        } else {
            final ArtifactResult result;
            result = resolver.resolveArtifact(this.repositorySystemSession,
                                              new ArtifactRequest(artifact, this.remoteRepositories, null));
            if (result.isResolved()) {
                file = result.getArtifact().getFile();
            }
        }

        return file;
    }

    @Parameter(alias = "remoteRepositories", defaultValue = "${project.remoteProjectRepositories}", readonly = true)
    private List remoteRepositories;

    @Inject
    private ArtifactResolver resolver;
}