| /* |
| * 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.source; |
| |
| import java.io.File; |
| import java.nio.file.Files; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Objects; |
| |
| import org.apache.maven.api.Artifact; |
| import org.apache.maven.api.Project; |
| import org.apache.maven.api.Session; |
| import org.apache.maven.api.Type; |
| import org.apache.maven.api.di.Inject; |
| import org.apache.maven.api.model.Resource; |
| import org.apache.maven.api.plugin.Log; |
| import org.apache.maven.api.plugin.Mojo; |
| import org.apache.maven.api.plugin.MojoException; |
| import org.apache.maven.api.plugin.annotations.Parameter; |
| import org.apache.maven.api.services.ArtifactManager; |
| import org.apache.maven.api.services.ProjectManager; |
| import org.apache.maven.archiver.MavenArchiveConfiguration; |
| import org.apache.maven.archiver.MavenArchiver; |
| import org.codehaus.plexus.archiver.Archiver; |
| import org.codehaus.plexus.archiver.ArchiverException; |
| import org.codehaus.plexus.archiver.jar.JarArchiver; |
| import org.codehaus.plexus.archiver.util.DefaultFileSet; |
| import org.codehaus.plexus.util.FileUtils; |
| |
| /** |
| * Base class for bundling sources into a jar archive. |
| * |
| * @since 2.0.3 |
| */ |
| public abstract class AbstractSourceJarMojo implements Mojo { |
| private static final String[] DEFAULT_INCLUDES = new String[] {"**/**"}; |
| |
| private static final String[] DEFAULT_EXCLUDES = new String[] {}; |
| |
| /** |
| * List of files to include. Specified as fileset patterns which are relative to the input directory whose contents |
| * is being packaged into the JAR. |
| * |
| * @since 2.1 |
| */ |
| @Parameter |
| protected String[] includes; |
| |
| /** |
| * List of files to exclude. Specified as fileset patterns which are relative to the input directory whose contents |
| * is being packaged into the JAR. |
| * |
| * @since 2.1 |
| */ |
| @Parameter |
| protected String[] excludes; |
| |
| /** |
| * Exclude commonly excluded files such as SCM configuration. These are defined in the plexus |
| * FileUtils.getDefaultExcludes() |
| * |
| * @since 2.1 |
| */ |
| @Parameter(property = "maven.source.useDefaultExcludes", defaultValue = "true") |
| protected boolean useDefaultExcludes; |
| |
| /** |
| * The Maven Project Object |
| */ |
| @Inject |
| protected Project project; |
| |
| /** |
| * The Jar archiver. |
| */ |
| @Inject |
| protected JarArchiver jarArchiver; |
| |
| /** |
| * The archive configuration to use. See <a href="http://maven.apache.org/shared/maven-archiver/index.html">Maven |
| * Archiver Reference</a>. <br/> |
| * <b>Note: Since 3.0.0 the resulting archives contain a maven descriptor. If you need to suppress the generation of |
| * the maven descriptor you can simply achieve this by using the |
| * <a href="http://maven.apache.org/shared/maven-archiver/index.html#archive">archiver configuration</a>.</b>. |
| * |
| * @since 2.1 |
| */ |
| @Parameter |
| protected MavenArchiveConfiguration archive = new MavenArchiveConfiguration(); |
| |
| /** |
| * Path to the default MANIFEST file to use. It will be used if <code>useDefaultManifestFile</code> is set to |
| * <code>true</code>. |
| * |
| * @since 2.1 |
| */ |
| // CHECKSTYLE_OFF: LineLength |
| @Parameter( |
| defaultValue = "${project.build.outputDirectory}/META-INF/MANIFEST.MF", |
| readonly = false, |
| required = true) |
| // CHECKSTYLE_ON: LineLength |
| protected Path defaultManifestFile; |
| |
| /** |
| * Set this to <code>true</code> to enable the use of the <code>defaultManifestFile</code>. <br/> |
| * |
| * @since 2.1 |
| */ |
| @Parameter(property = "maven.source.useDefaultManifestFile", defaultValue = "false") |
| protected boolean useDefaultManifestFile; |
| |
| /** |
| * Specifies whether to attach the artifact to the project |
| */ |
| @Parameter(property = "maven.source.attach", defaultValue = "true") |
| protected boolean attach; |
| |
| /** |
| * Specifies whether to exclude resources from the sources-jar. This can be convenient if your project |
| * includes large resources, such as images, and you don't want to include them in the sources-jar. |
| * |
| * @since 2.0.4 |
| */ |
| @Parameter(property = "maven.source.excludeResources", defaultValue = "false") |
| protected boolean excludeResources; |
| |
| /** |
| * Specifies whether to include the POM file in the sources-jar. |
| * |
| * @since 2.1 |
| */ |
| @Parameter(property = "maven.source.includePom", defaultValue = "false") |
| protected boolean includePom; |
| |
| /** |
| * The directory where the generated archive file will be put. |
| */ |
| @Parameter(defaultValue = "${project.build.directory}") |
| protected Path outputDirectory; |
| |
| /** |
| * The filename to be used for the generated archive file. For the source:jar goal, "-sources" is appended to this |
| * filename. For the source:test-jar goal, "-test-sources" is appended. |
| */ |
| @Parameter(defaultValue = "${project.build.finalName}") |
| protected String finalName; |
| |
| /** |
| * Contains the full list of projects in the reactor. |
| */ |
| @Parameter(defaultValue = "${session.projects}", readonly = true) |
| protected List<Project> reactorProjects; |
| |
| /** |
| * Whether creating the archive should be forced. If set to true, the jar will always be created. If set to false, |
| * the jar will only be created when the sources are newer than the jar. |
| * |
| * @since 2.1 |
| */ |
| @Parameter(property = "maven.source.forceCreation", defaultValue = "false") |
| protected boolean forceCreation; |
| |
| /** |
| * A flag used to disable the source procedure. This is primarily intended for usage from the command line to |
| * occasionally adjust the build. |
| * |
| * @since 2.2 |
| */ |
| @Parameter(property = "maven.source.skip", defaultValue = "false") |
| protected boolean skipSource; |
| |
| /** |
| * The Maven session. |
| */ |
| @Inject |
| protected Session session; |
| |
| /** |
| * Timestamp for reproducible output archive entries, either formatted as ISO 8601 |
| * <code>yyyy-MM-dd'T'HH:mm:ssXXX</code> or as an int representing seconds since the epoch (like |
| * <a href="https://reproducible-builds.org/docs/source-date-epoch/">SOURCE_DATE_EPOCH</a>). |
| * |
| * @since 3.2.0 |
| */ |
| @Parameter(defaultValue = "${project.build.outputTimestamp}") |
| protected String outputTimestamp; |
| |
| @Inject |
| protected Log log; |
| |
| /** |
| * Used for attaching the source jar to the project. |
| */ |
| protected ProjectManager projectManager; |
| |
| // ---------------------------------------------------------------------- |
| // Public methods |
| // ---------------------------------------------------------------------- |
| |
| public Log getLog() { |
| return log; |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public void execute() throws MojoException { |
| if (skipSource) { |
| getLog().info("Skipping source per configuration."); |
| return; |
| } |
| |
| projectManager = session.getService(ProjectManager.class); |
| doExecute(); |
| } |
| |
| protected void doExecute() { |
| packageSources(project); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // Protected methods |
| // ---------------------------------------------------------------------- |
| |
| /** |
| * @return the wanted classifier, ie <code>sources</code> or <code>test-sources</code> |
| */ |
| protected abstract String getClassifier(); |
| |
| /** |
| * @param p {@link Project} not null |
| * @return the compile or test sources |
| * @throws MojoException in case of an error. |
| */ |
| protected abstract List<Path> getSources(Project p) throws MojoException; |
| |
| /** |
| * @param p {@link Project} not null |
| * @return the compile or test resources |
| * @throws MojoException in case of an error. |
| */ |
| protected abstract List<Resource> getResources(Project p) throws MojoException; |
| |
| /** |
| * @param p {@link Project} |
| * @throws MojoException in case of an error. |
| */ |
| protected void packageSources(Project p) throws MojoException { |
| String type = p.getPackaging().type().id(); |
| if (!Type.POM.equals(type) && !Type.BOM.equals(type)) { |
| packageSources(Collections.singletonList(p)); |
| } |
| } |
| |
| /** |
| * @param theProjects {@link Project} |
| * @throws MojoException in case of an error. |
| */ |
| protected void packageSources(List<Project> theProjects) throws MojoException { |
| Artifact currentProjectArtifact = project.getMainArtifact().get(); |
| if (!currentProjectArtifact.getClassifier().isEmpty()) { |
| getLog().warn("NOT adding sources to artifacts with classifier as Maven only supports one classifier " |
| + "per artifact. Current artifact [" + currentProjectArtifact.key() + "] has a [" |
| + currentProjectArtifact.getClassifier() + "] classifier."); |
| |
| return; |
| } |
| |
| MavenArchiver archiver = createArchiver(); |
| |
| for (Project pItem : theProjects) { |
| Project subProject = getProject(pItem); |
| |
| String type = subProject.getPackaging().type().id(); |
| if (Type.POM.equals(type) || Type.BOM.equals(type)) { |
| continue; |
| } |
| |
| archiveProjectContent(subProject, archiver.getArchiver()); |
| } |
| |
| if (archiver.getArchiver().getResources().hasNext() || forceCreation) { |
| |
| if (useDefaultManifestFile && Files.exists(defaultManifestFile) && archive.getManifestFile() == null) { |
| getLog().info("Adding existing MANIFEST to archive. Found under: " + defaultManifestFile); |
| archive.setManifestFile(defaultManifestFile); |
| } |
| |
| Path outputFile = outputDirectory.resolve(finalName + "-" + getClassifier() + getExtension()); |
| |
| try { |
| archiver.setOutputFile(outputFile.toFile()); |
| archive.setForced(forceCreation); |
| |
| getLog().debug("create archive " + outputFile); |
| archiver.createArchive(session, project, archive); |
| } catch (ArchiverException e) { |
| throw new MojoException("Error creating source archive: " + e.getMessage(), e); |
| } |
| |
| if (attach) { |
| Artifact artifact = session.createArtifact( |
| project.getGroupId(), |
| project.getArtifactId(), |
| project.getVersion(), |
| getClassifier(), |
| null, |
| getType()); |
| boolean requiresAttach = true; |
| for (Artifact attachedArtifact : projectManager.getAttachedArtifacts(project)) { |
| if (Objects.equals(artifact.key(), attachedArtifact.key())) { |
| Path attachedFile = session.getService(ArtifactManager.class) |
| .getPath(attachedArtifact) |
| .orElse(null); |
| if (attachedFile != null && !outputFile.equals(attachedFile)) { |
| getLog().error("Artifact " + attachedArtifact.key() |
| + " already attached to a file " + relative(attachedFile) + ": attach to " |
| + relative(outputFile) + " should be done with another classifier"); |
| throw new MojoException("Presumably you have configured maven-source-plugin " |
| + "to execute twice in your build to different output files. " |
| + "You have to configure a classifier for at least one of them."); |
| } |
| requiresAttach = false; |
| getLog().info("Artifact " + attachedArtifact.key() + " already attached to " |
| + relative(outputFile) + ": ignoring same re-attach (same artifact, same file)"); |
| } |
| } |
| if (requiresAttach) { |
| projectManager.attachArtifact(project, artifact, outputFile); |
| } |
| } else { |
| getLog().info("NOT adding java-sources to attached artifacts list."); |
| } |
| } else { |
| getLog().info("No sources in project. Archive not created."); |
| } |
| } |
| |
| private String relative(Path to) { |
| Path basedir = project.getBasedir().toAbsolutePath(); |
| return basedir.relativize(to.toAbsolutePath()).toString(); |
| } |
| |
| private Artifact getPreviouslyAttached(Artifact artifact, Project checkProject, String classifier) { |
| return artifact.getExtension().equals(getExtension()) |
| && artifact.getGroupId().equals(checkProject.getGroupId()) |
| && artifact.getArtifactId().equals(checkProject.getArtifactId()) |
| && artifact.getVersion().toString().equals(checkProject.getVersion()) |
| && Objects.equals(artifact.getClassifier(), classifier) |
| ? artifact |
| : null; |
| } |
| |
| /** |
| * @param project {@link Project} |
| * @param archiver {@link Archiver} |
| * @throws MojoException in case of an error. |
| */ |
| protected void archiveProjectContent(Project project, Archiver archiver) throws MojoException { |
| if (includePom) { |
| try { |
| File pom = project.getPomPath().toFile(); |
| archiver.addFile(pom, pom.getName()); |
| } catch (ArchiverException e) { |
| throw new MojoException("Error adding POM file to target jar file.", e); |
| } |
| } |
| |
| for (Path sourceDirectory : getSources(project)) { |
| if (Files.exists(sourceDirectory)) { |
| addDirectory(archiver, sourceDirectory, getCombinedIncludes(null), getCombinedExcludes(null)); |
| } |
| } |
| |
| // MAPI: this should be taken from the resources plugin |
| for (Resource resource : getResources(project)) { |
| |
| Path sourceDirectory = Paths.get(resource.getDirectory()); |
| |
| if (!Files.exists(sourceDirectory)) { |
| continue; |
| } |
| |
| List<String> resourceIncludes = resource.getIncludes(); |
| |
| String[] combinedIncludes = getCombinedIncludes(resourceIncludes); |
| |
| List<String> resourceExcludes = resource.getExcludes(); |
| |
| String[] combinedExcludes = getCombinedExcludes(resourceExcludes); |
| |
| String targetPath = resource.getTargetPath(); |
| if (targetPath != null) { |
| if (!targetPath.trim().endsWith("/")) { |
| targetPath += "/"; |
| } |
| addDirectory(archiver, sourceDirectory, targetPath, combinedIncludes, combinedExcludes); |
| } else { |
| addDirectory(archiver, sourceDirectory, combinedIncludes, combinedExcludes); |
| } |
| } |
| } |
| |
| /** |
| * @return {@link MavenArchiver} |
| * @throws MojoException in case of an error. |
| */ |
| protected MavenArchiver createArchiver() throws MojoException { |
| MavenArchiver archiver = new MavenArchiver(); |
| archiver.setArchiver(jarArchiver); |
| archiver.setCreatedBy("Maven Source Plugin", "org.apache.maven.plugins", "maven-source-plugin"); |
| archiver.setBuildJdkSpecDefaultEntry(false); |
| |
| // configure for Reproducible Builds based on outputTimestamp value |
| archiver.configureReproducibleBuild(outputTimestamp); |
| |
| if (project.getBuild() != null) { |
| List<org.apache.maven.api.model.Resource> resources = |
| project.getBuild().getResources(); |
| |
| for (org.apache.maven.api.model.Resource r : resources) { |
| if (r.getDirectory().endsWith("maven-shared-archive-resources")) { |
| addDirectory( |
| archiver.getArchiver(), |
| Paths.get(r.getDirectory()), |
| getCombinedIncludes(null), |
| getCombinedExcludes(null)); |
| } |
| } |
| } |
| |
| return archiver; |
| } |
| |
| /** |
| * @param archiver {@link Archiver} |
| * @param sourceDirectory {@link Path} |
| * @param pIncludes The list of includes. |
| * @param pExcludes The list of excludes. |
| * @throws MojoException in case of an error. |
| */ |
| protected void addDirectory(Archiver archiver, Path sourceDirectory, String[] pIncludes, String[] pExcludes) |
| throws MojoException { |
| try { |
| getLog().debug("add directory " + sourceDirectory + " to archiver"); |
| archiver.addFileSet(DefaultFileSet.fileSet(sourceDirectory.toFile()).includeExclude(pIncludes, pExcludes)); |
| } catch (ArchiverException e) { |
| throw new MojoException("Error adding directory to source archive.", e); |
| } |
| } |
| |
| /** |
| * @param archiver {@link Archiver} |
| * @param sourceDirectory {@link Path} |
| * @param prefix The prefix. |
| * @param pIncludes the includes. |
| * @param pExcludes the excludes. |
| * @throws MojoException in case of an error. |
| */ |
| protected void addDirectory( |
| Archiver archiver, Path sourceDirectory, String prefix, String[] pIncludes, String[] pExcludes) |
| throws MojoException { |
| try { |
| getLog().debug("add directory " + sourceDirectory + " to archiver with prefix " + prefix); |
| archiver.addFileSet(DefaultFileSet.fileSet(sourceDirectory.toFile()) |
| .prefixed(prefix) |
| .includeExclude(pIncludes, pExcludes)); |
| } catch (ArchiverException e) { |
| throw new MojoException("Error adding directory to source archive.", e); |
| } |
| } |
| |
| /** |
| * @return The extension {@code .jar} |
| */ |
| protected String getExtension() { |
| return ".jar"; |
| } |
| |
| /** |
| * @param p {@link Project} |
| * @return The execution projet. |
| */ |
| protected Project getProject(Project p) { |
| return projectManager.getExecutionProject(p).orElse(p); |
| } |
| |
| /** |
| * @return The type {@code java-source} |
| */ |
| protected String getType() { |
| return "java-source"; |
| } |
| |
| /** |
| * Combines the includes parameter and additional includes. Defaults to {@link #DEFAULT_INCLUDES} If the |
| * additionalIncludes parameter is null, it is not added to the combined includes. |
| * |
| * @param additionalIncludes The includes specified in the pom resources section |
| * @return The combined array of includes. |
| */ |
| private String[] getCombinedIncludes(List<String> additionalIncludes) { |
| List<String> combinedIncludes = new ArrayList<>(); |
| |
| if (includes != null && includes.length > 0) { |
| combinedIncludes.addAll(Arrays.asList(includes)); |
| } |
| |
| if (additionalIncludes != null && !additionalIncludes.isEmpty()) { |
| combinedIncludes.addAll(additionalIncludes); |
| } |
| |
| // If there are no other includes, use the default. |
| if (combinedIncludes.isEmpty()) { |
| combinedIncludes.addAll(Arrays.asList(DEFAULT_INCLUDES)); |
| } |
| |
| return combinedIncludes.toArray(new String[0]); |
| } |
| |
| /** |
| * Combines the user parameter {@link #excludes}, the default excludes from plexus FileUtils, and the contents of |
| * the parameter addionalExcludes. |
| * |
| * @param additionalExcludes Additional excludes to add to the array |
| * @return The combined list of excludes. |
| */ |
| private String[] getCombinedExcludes(List<String> additionalExcludes) { |
| List<String> combinedExcludes = new ArrayList<>(); |
| |
| if (useDefaultExcludes) { |
| combinedExcludes.addAll(FileUtils.getDefaultExcludesAsList()); |
| } |
| |
| if (excludes != null && excludes.length > 0) { |
| combinedExcludes.addAll(Arrays.asList(excludes)); |
| } |
| |
| if (additionalExcludes != null && !additionalExcludes.isEmpty()) { |
| combinedExcludes.addAll(additionalExcludes); |
| } |
| |
| if (combinedExcludes.isEmpty()) { |
| combinedExcludes.addAll(Arrays.asList(DEFAULT_EXCLUDES)); |
| } |
| |
| return combinedExcludes.toArray(new String[0]); |
| } |
| |
| /** |
| * @return The current project. |
| */ |
| protected Project getProject() { |
| return project; |
| } |
| |
| /** |
| * @param project {@link Project} |
| */ |
| protected void setProject(Project project) { |
| this.project = project; |
| } |
| } |
