org.codehaus.mojo.versions.UseLatestVersionsMojo Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of versions-maven-plugin Show documentation
Show all versions of versions-maven-plugin Show documentation
Versions Plugin for Maven. The Versions Plugin updates the versions of components in the POM.
The newest version!
package org.codehaus.mojo.versions;
/*
* Copyright MojoHaus and 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.
*/
import javax.inject.Inject;
import javax.xml.stream.XMLStreamException;
import java.io.IOException;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import org.apache.maven.artifact.handler.manager.ArtifactHandlerManager;
import org.apache.maven.model.Dependency;
import org.apache.maven.model.DependencyManagement;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.wagon.Wagon;
import org.codehaus.mojo.versions.api.PomHelper;
import org.codehaus.mojo.versions.api.Segment;
import org.codehaus.mojo.versions.api.VersionRetrievalException;
import org.codehaus.mojo.versions.api.recording.ChangeRecorder;
import org.codehaus.mojo.versions.api.recording.DependencyChangeRecord;
import org.codehaus.mojo.versions.ordering.InvalidSegmentException;
import org.codehaus.mojo.versions.rewriting.MutableXMLStreamReader;
import org.eclipse.aether.RepositorySystem;
import static java.util.Collections.singletonList;
import static java.util.Optional.empty;
import static java.util.Optional.of;
import static org.codehaus.mojo.versions.api.Segment.INCREMENTAL;
import static org.codehaus.mojo.versions.api.Segment.MAJOR;
import static org.codehaus.mojo.versions.api.Segment.MINOR;
/**
* Replaces any version with the latest version found in the artifactory.
*
* @author Stephen Connolly
* @since 1.0-alpha-3
*/
@Mojo(name = "use-latest-versions", threadSafe = true)
public class UseLatestVersionsMojo extends UseLatestVersionsMojoBase {
/**
* Whether to allow the major version number to be changed.
*
* @since 1.2
*/
@Parameter(property = "allowMajorUpdates", defaultValue = "true")
private boolean allowMajorUpdates = true;
/**
* Whether to allow the minor version number to be changed.
*
* Note: {@code false} also implies {@linkplain #allowMajorUpdates} {@code false}
* @since 1.2
*/
@Parameter(property = "allowMinorUpdates", defaultValue = "true")
private boolean allowMinorUpdates = true;
/**
* Whether to allow the incremental version number to be changed.
*
* Note: {@code false} also implies {@linkplain #allowMajorUpdates}
* and {@linkplain #allowMinorUpdates} {@code false}
* @since 1.2
*/
@Parameter(property = "allowIncrementalUpdates", defaultValue = "true")
private boolean allowIncrementalUpdates = true;
/**
* Whether to downgrade a snapshot dependency if allowSnapshots is false
* and there exists a non-snapshot version within the range fulfilling the criteria.
* Only valid if allowSnapshots is false.
*
* @since 2.12.0
*/
@Parameter(property = "allowDowngrade", defaultValue = "false")
private boolean allowDowngrade;
// ------------------------------ METHODS --------------------------
@Inject
public UseLatestVersionsMojo(
ArtifactHandlerManager artifactHandlerManager,
RepositorySystem repositorySystem,
Map wagonMap,
Map changeRecorders) {
super(artifactHandlerManager, repositorySystem, wagonMap, changeRecorders);
}
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
if (allowDowngrade && allowSnapshots) {
throw new MojoExecutionException("allowDowngrade is only valid with allowSnapshots equal to false");
}
super.execute();
}
/**
* @param pom the pom to update.
* @throws org.apache.maven.plugin.MojoExecutionException when things go wrong
* @throws org.apache.maven.plugin.MojoFailureException when things go wrong in a very bad way
* @throws javax.xml.stream.XMLStreamException when things go wrong with XML streaming
* @see AbstractVersionsUpdaterMojo#update(MutableXMLStreamReader)
*/
protected void update(MutableXMLStreamReader pom)
throws MojoExecutionException, MojoFailureException, XMLStreamException, VersionRetrievalException {
try {
if (isProcessingDependencyManagement()) {
DependencyManagement dependencyManagement =
PomHelper.getRawModel(getProject()).getDependencyManagement();
if (dependencyManagement != null) {
useLatestVersions(
pom,
dependencyManagement.getDependencies(),
DependencyChangeRecord.ChangeKind.DEPENDENCY_MANAGEMENT);
}
}
if (getProject().getDependencies() != null && isProcessingDependencies()) {
useLatestVersions(pom, getProject().getDependencies(), DependencyChangeRecord.ChangeKind.DEPENDENCY);
}
if (getProject().getParent() != null && isProcessingParent()) {
useLatestVersions(pom, singletonList(getParentDependency()), DependencyChangeRecord.ChangeKind.PARENT);
}
} catch (IOException e) {
throw new MojoExecutionException(e.getMessage(), e);
}
}
private void useLatestVersions(
MutableXMLStreamReader pom,
Collection dependencies,
DependencyChangeRecord.ChangeKind changeKind)
throws XMLStreamException, MojoExecutionException, VersionRetrievalException {
Log log = getLog();
if (log != null && !allowIncrementalUpdates) {
log.info("Assuming allowMinorUpdates false because allowIncrementalUpdates is false.");
}
if (log != null && !allowMinorUpdates) {
log.info("Assuming allowMajorUpdates false because allowMinorUpdates is false.");
}
Optional unchangedSegment = allowMajorUpdates && allowMinorUpdates && allowIncrementalUpdates
? empty()
: allowMinorUpdates && allowIncrementalUpdates
? of(MAJOR)
: allowIncrementalUpdates ? of(MINOR) : of(INCREMENTAL);
if (log != null && log.isDebugEnabled()) {
log.debug(unchangedSegment
.map(Segment::minorTo)
.map(Segment::toString)
.orElse("ALL") + " version changes allowed");
}
useLatestVersions(
pom,
dependencies,
(dep, versions) -> {
try {
return versions.getNewestVersion(
dep.getVersion(), unchangedSegment, allowSnapshots, allowDowngrade);
} catch (InvalidSegmentException e) {
getLog().warn(String.format(
"Skipping the processing of %s:%s:%s due to: %s",
dep.getGroupId(), dep.getArtifactId(), dep.getVersion(), e.getMessage()));
}
return empty();
},
changeKind);
}
}