org.apache.maven.plugins.dependency.utils.UnpackUtil Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of maven-dependency-plugin Show documentation
There is a newer version: 3.8.1
Show newest version
/*
 * 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.
 */
package org.apache.maven.plugins.dependency.utils;

import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;

import java.io.File;

import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.logging.Log;
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.archiver.UnArchiver;
import org.codehaus.plexus.archiver.manager.ArchiverManager;
import org.codehaus.plexus.archiver.manager.NoSuchArchiverException;
import org.codehaus.plexus.archiver.zip.ZipUnArchiver;
import org.codehaus.plexus.components.io.filemappers.FileMapper;
import org.codehaus.plexus.components.io.fileselectors.IncludeExcludeFileSelector;
import org.sonatype.plexus.build.incremental.BuildContext;

/**
 * Provide unpack method in one place for {@link org.apache.maven.plugins.dependency.fromConfiguration.UnpackMojo}
 * and {@link org.apache.maven.plugins.dependency.fromDependencies.UnpackDependenciesMojo}
 */
@Named
@Singleton
public class UnpackUtil {

    /**
     * To look up Archiver/UnArchiver implementations
     */
    private final ArchiverManager archiverManager;

    /**
     * For IDE build support
     */
    private final BuildContext buildContext;

    /**
     * Default constructor.
     *
     * @param archiverManager an archiver {@link ArchiverManager} to use
     * @param buildContext    a build context
     */
    @Inject
    public UnpackUtil(ArchiverManager archiverManager, BuildContext buildContext) {
        this.archiverManager = archiverManager;
        this.buildContext = buildContext;
    }

    /**
     * @param file              file to unpack
     * @param type              file / artifact type
     * @param location          The location.
     * @param includes          includes list.
     * @param excludes          excludes list.
     * @param encoding          the encoding.
     * @param ignorePermissions ignore permissions
     * @param fileMappers       {@link FileMapper}s to be used for rewriting each target path, or {@code null} if no
     *                          rewriting
     *                          shall happen.
     * @param logger            a Mojo logger
     * @throws MojoExecutionException in case of an error.
     */
    public void unpack(
            File file,
            String type,
            File location,
            String includes,
            String excludes,
            String encoding,
            boolean ignorePermissions,
            FileMapper[] fileMappers,
            Log logger)
            throws MojoExecutionException {
        try {
            logUnpack(logger, file, location, includes, excludes);

            location.mkdirs();
            if (!location.exists()) {
                throw new MojoExecutionException(
                        "Location to write unpacked files to could not be created: " + location);
            }

            if (file.isDirectory()) {
                // usual case is a future jar packaging, but there are special cases: classifier and other packaging
                throw new MojoExecutionException("Artifact has not been packaged yet. When used on reactor artifact, "
                        + "unpack should be executed after packaging: see MDEP-98.");
            }

            UnArchiver unArchiver;

            try {
                unArchiver = archiverManager.getUnArchiver(type);
                logger.debug("Found unArchiver: " + unArchiver.getClass().getName() + " by type: " + type);
            } catch (NoSuchArchiverException e) {
                unArchiver = archiverManager.getUnArchiver(file);
                logger.debug("Found unArchiver: " + unArchiver.getClass().getName() + " by file extension: " + file);
            }

            if (encoding != null && unArchiver instanceof ZipUnArchiver) {
                ((ZipUnArchiver) unArchiver).setEncoding(encoding);
                logger.info("Unpacks '" + type + "' with encoding '" + encoding + "'.");
            }

            unArchiver.setIgnorePermissions(ignorePermissions);

            unArchiver.setSourceFile(file);

            unArchiver.setDestDirectory(location);

            if ((excludes != null && !excludes.isEmpty()) || (includes != null && !includes.isEmpty())) {
                // Create the selectors that will filter
                // based on include/exclude parameters
                // MDEP-47
                IncludeExcludeFileSelector[] selectors =
                        new IncludeExcludeFileSelector[] {new IncludeExcludeFileSelector()};

                if (excludes != null && !excludes.isEmpty()) {
                    selectors[0].setExcludes(excludes.split(","));
                }

                if (includes != null && !includes.isEmpty()) {
                    selectors[0].setIncludes(includes.split(","));
                }

                unArchiver.setFileSelectors(selectors);
            }

            unArchiver.setFileMappers(fileMappers);

            unArchiver.extract();
        } catch (NoSuchArchiverException e) {
            throw new MojoExecutionException("Unknown archiver type", e);
        } catch (ArchiverException e) {
            throw new MojoExecutionException("Error unpacking file: " + file + " to: " + location, e);
        }
        buildContext.refresh(location);
    }

    private void logUnpack(Log logger, File file, File location, String includes, String excludes) {
        if (logger.isInfoEnabled()) {
            return;
        }

        StringBuilder msg = new StringBuilder();
        msg.append("Unpacking ");
        msg.append(file);
        msg.append(" to ");
        msg.append(location);

        if (includes != null && excludes != null) {
            msg.append(" with includes \"");
            msg.append(includes);
            msg.append("\" and excludes \"");
            msg.append(excludes);
            msg.append("\"");
        } else if (includes != null) {
            msg.append(" with includes \"");
            msg.append(includes);
            msg.append("\"");
        } else if (excludes != null) {
            msg.append(" with excludes \"");
            msg.append(excludes);
            msg.append("\"");
        }

        logger.info(msg.toString());
    }
}