You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by gn...@apache.org on 2024/08/29 05:48:59 UTC
(maven) branch master updated: [MNG-8052] New lifecycle for Maven 4 (#1448)
This is an automated email from the ASF dual-hosted git repository.
gnodet pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven.git
The following commit(s) were added to refs/heads/master by this push:
new acec540547 [MNG-8052] New lifecycle for Maven 4 (#1448)
acec540547 is described below
commit acec540547bca289b0579ab0c8f371004b8903f1
Author: Guillaume Nodet <gn...@gmail.com>
AuthorDate: Thu Aug 29 06:48:54 2024 +0100
[MNG-8052] New lifecycle for Maven 4 (#1448)
---
.../main/java/org/apache/maven/api/Lifecycle.java | 124 ++++++++-
.../apache/maven/api/plugin/annotations/After.java | 66 +++++
.../maven/api/services/LifecycleRegistry.java | 3 +
api/maven-api-plugin/pom.xml | 2 +-
api/maven-api-plugin/src/main/mdo/lifecycle.mdo | 67 ++++-
.../maven/internal/impl/standalone/ApiRunner.java | 5 +
.../project/EmptyLifecycleBindingsInjector.java | 10 +
.../internal/impl/DefaultLifecycleRegistry.java | 279 ++++++++++++++++-----
.../org/apache/maven/internal/impl/Lifecycles.java | 124 ++++++++-
.../apache/maven/lifecycle/DefaultLifecycles.java | 32 ++-
.../java/org/apache/maven/lifecycle/Lifecycle.java | 23 +-
.../DefaultLifecycleExecutionPlanCalculator.java | 9 +-
.../internal/DefaultLifecycleMappingDelegate.java | 57 ++++-
.../maven/lifecycle/internal/PhaseComparator.java | 74 ++++++
.../lifecycle/internal/PhaseExecutionPoint.java | 50 ++++
.../apache/maven/lifecycle/internal/PhaseId.java | 142 +++++++++++
.../maven/lifecycle/internal/PhaseRecorder.java | 9 +-
.../maven/lifecycle/DefaultLifecyclesTest.java | 6 +-
.../maven/lifecycle/LifecycleExecutorTest.java | 2 +
.../project/EmptyLifecycleBindingsInjector.java | 10 +
maven-plugin-api/pom.xml | 2 +-
src/mdo/reader-stax.vm | 5 +
src/mdo/writer-stax.vm | 5 +
src/mdo/writer.vm | 5 +
24 files changed, 1001 insertions(+), 110 deletions(-)
diff --git a/api/maven-api-core/src/main/java/org/apache/maven/api/Lifecycle.java b/api/maven-api-core/src/main/java/org/apache/maven/api/Lifecycle.java
index fcee471eac..40d2715e33 100644
--- a/api/maven-api-core/src/main/java/org/apache/maven/api/Lifecycle.java
+++ b/api/maven-api-core/src/main/java/org/apache/maven/api/Lifecycle.java
@@ -21,9 +21,11 @@ package org.apache.maven.api;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
+import java.util.stream.Stream;
import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.annotations.Immutable;
+import org.apache.maven.api.annotations.Nonnull;
import org.apache.maven.api.model.Plugin;
/**
@@ -41,14 +43,20 @@ import org.apache.maven.api.model.Plugin;
@Immutable
public interface Lifecycle extends ExtensibleEnum {
+ // =========================
+ // Maven defined lifecycles
+ // =========================
String CLEAN = "clean";
-
String DEFAULT = "default";
-
String SITE = "site";
-
String WRAPPER = "wrapper";
+ // ======================
+ // Phase qualifiers
+ // ======================
+ String BEFORE = "before:";
+ String AFTER = "after:";
+
/**
* Name or identifier of this lifecycle.
*
@@ -62,6 +70,18 @@ public interface Lifecycle extends ExtensibleEnum {
*/
Collection<Phase> phases();
+ /**
+ * Stream of phases containing all child phases recursively.
+ */
+ default Stream<Phase> allPhases() {
+ return phases().stream().flatMap(Phase::allPhases);
+ }
+
+ /**
+ * Collection of aliases.
+ */
+ Collection<Alias> aliases();
+
/**
* Pre-ordered list of phases.
* If not provided, a default order will be computed.
@@ -72,10 +92,108 @@ public interface Lifecycle extends ExtensibleEnum {
/**
* A phase in the lifecycle.
+ *
+ * A phase is identified by its name. It also contains a list of plugins bound to that phase,
+ * a list of {@link Link links}, and a list of sub-phases. This forms a tree of phases.
*/
interface Phase {
+
+ // ======================
+ // Maven defined phases
+ // ======================
+ String BUILD = "build";
+ String INITIALIZE = "initialize";
+ String VALIDATE = "validate";
+ String SOURCES = "sources";
+ String RESOURCES = "resources";
+ String COMPILE = "compile";
+ String READY = "ready";
+ String PACKAGE = "package";
+ String VERIFY = "verify";
+ String UNIT_TEST = "unit-test";
+ String TEST_SOURCES = "test-sources";
+ String TEST_RESOURCES = "test-resources";
+ String TEST_COMPILE = "test-compile";
+ String TEST = "test";
+ String INTEGRATION_TEST = "integration-test";
+ String INSTALL = "install";
+ String DEPLOY = "deploy";
+ String CLEAN = "clean";
+
+ @Nonnull
String name();
+ @Nonnull
List<Plugin> plugins();
+
+ @Nonnull
+ Collection<Link> links();
+
+ /**
+ * {@return the list of sub-phases}
+ */
+ @Nonnull
+ List<Phase> phases();
+
+ @Nonnull
+ Stream<Phase> allPhases();
+ }
+
+ /**
+ * A phase alias, mostly used to support the Maven 3 phases which are mapped
+ * to dynamic phases in Maven 4.
+ */
+ interface Alias {
+ String v3Phase();
+
+ String v4Phase();
+ }
+
+ /**
+ * A link from a phase to another phase, consisting of a type which can be
+ * {@link Kind#BEFORE} or {@link Kind#AFTER}, and a {@link Pointer} to
+ * another phase.
+ */
+ interface Link {
+ enum Kind {
+ BEFORE,
+ AFTER
+ }
+
+ Kind kind();
+
+ Pointer pointer();
+ }
+
+ interface Pointer {
+ enum Type {
+ PROJECT,
+ DEPENDENCIES,
+ CHILDREN
+ }
+
+ String phase();
+
+ Type type();
+ }
+
+ interface PhasePointer extends Pointer {
+ default Type type() {
+ return Type.PROJECT;
+ }
+ }
+
+ interface DependenciesPointer extends Pointer {
+ String scope(); // default: all
+
+ default Type type() {
+ return Type.DEPENDENCIES;
+ }
+ }
+
+ interface ChildrenPointer extends Pointer {
+ default Type type() {
+ return Type.CHILDREN;
+ }
}
}
diff --git a/api/maven-api-core/src/main/java/org/apache/maven/api/plugin/annotations/After.java b/api/maven-api-core/src/main/java/org/apache/maven/api/plugin/annotations/After.java
new file mode 100644
index 0000000000..697b9d4802
--- /dev/null
+++ b/api/maven-api-core/src/main/java/org/apache/maven/api/plugin/annotations/After.java
@@ -0,0 +1,66 @@
+/*
+ * 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.api.plugin.annotations;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.apache.maven.api.annotations.Experimental;
+
+/**
+ * Specifies that the mojo should be run after the specific phase.
+ *
+ * @since 4.0.0
+ */
+@Experimental
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+@Inherited
+public @interface After {
+
+ /**
+ * Type of pointer.
+ * @see org.apache.maven.api.Lifecycle.Pointer.Type
+ */
+ enum Type {
+ PROJECT,
+ DEPENDENCIES,
+ CHILDREN
+ }
+
+ /**
+ * The phase name.
+ */
+ String phase();
+
+ /**
+ * The type of this pointer.
+ */
+ Type type();
+
+ /**
+ * The scope for dependencies, only if {@code type() == Type.Dependencies}.
+ */
+ String scope() default "";
+}
diff --git a/api/maven-api-core/src/main/java/org/apache/maven/api/services/LifecycleRegistry.java b/api/maven-api-core/src/main/java/org/apache/maven/api/services/LifecycleRegistry.java
index 05970e76fc..55efc16ebc 100644
--- a/api/maven-api-core/src/main/java/org/apache/maven/api/services/LifecycleRegistry.java
+++ b/api/maven-api-core/src/main/java/org/apache/maven/api/services/LifecycleRegistry.java
@@ -18,6 +18,7 @@
*/
package org.apache.maven.api.services;
+import java.util.List;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
@@ -28,4 +29,6 @@ public interface LifecycleRegistry extends ExtensibleEnumRegistry<Lifecycle>, It
default Stream<Lifecycle> stream() {
return StreamSupport.stream(spliterator(), false);
}
+
+ List<String> computePhases(Lifecycle lifecycle);
}
diff --git a/api/maven-api-plugin/pom.xml b/api/maven-api-plugin/pom.xml
index 9a9a876c99..b5a8bdab7c 100644
--- a/api/maven-api-plugin/pom.xml
+++ b/api/maven-api-plugin/pom.xml
@@ -94,7 +94,7 @@ under the License.
<phase>generate-sources</phase>
<configuration>
<velocityBasedir>${project.basedir}/../../src/mdo</velocityBasedir>
- <version>1.0.0</version>
+ <version>2.0.0</version>
<models>
<model>src/main/mdo/lifecycle.mdo</model>
</models>
diff --git a/api/maven-api-plugin/src/main/mdo/lifecycle.mdo b/api/maven-api-plugin/src/main/mdo/lifecycle.mdo
index f469eea440..8196e3aa50 100644
--- a/api/maven-api-plugin/src/main/mdo/lifecycle.mdo
+++ b/api/maven-api-plugin/src/main/mdo/lifecycle.mdo
@@ -30,12 +30,12 @@ under the License.
<classes>
<class rootElement="true" xml.tagName="lifecycles" xsd.compositor="sequence">
<name>LifecycleConfiguration</name>
- <version>1.0.0</version>
+ <version>1.0.0+</version>
<description>Root element of the {@code lifecycle.xml} file.</description>
<fields>
<field>
<name>lifecycles</name>
- <version>1.0.0</version>
+ <version>1.0.0+</version>
<association xml.itemsStyle="flat">
<type>Lifecycle</type>
<multiplicity>*</multiplicity>
@@ -45,19 +45,19 @@ under the License.
</class>
<class>
<name>Lifecycle</name>
- <version>1.0.0</version>
+ <version>1.0.0+</version>
<description>A custom lifecycle mapping definition.</description>
<fields>
<field>
<name>id</name>
<required>true</required>
- <version>1.0.0</version>
+ <version>1.0.0+</version>
<type>String</type>
<description>The ID of this lifecycle, for identification in the mojo descriptor.</description>
</field>
<field>
<name>phases</name>
- <version>1.0.0</version>
+ <version>1.0.0+</version>
<description>The phase mappings for this lifecycle.</description>
<association>
<type>Phase</type>
@@ -68,19 +68,35 @@ under the License.
</class>
<class>
<name>Phase</name>
- <version>1.0.0</version>
+ <version>1.0.0+</version>
<description>A phase mapping definition.</description>
<fields>
<field>
<name>id</name>
<required>true</required>
- <version>1.0.0</version>
+ <version>1.0.0+</version>
<type>String</type>
- <description>The ID of this phase, e.g., <code>generate-sources</code>.</description>
+ <description>The ID of this phase, e.g., {@code generate-sources}.</description>
+ </field>
+ <field xml.attribute="true">
+ <name>executionPoint</name>
+ <required>false</required>
+ <version>2.0.0+</version>
+ <type>String</type>
+ <defaultValue><![CDATA[]]></defaultValue>
+ <description><![CDATA[If specified, identifies this phase as a dynamic phase to decorate the specified phase id, e.g. {@code after} or {@code before}.]]></description>
+ </field>
+ <field xml.attribute="true">
+ <name>priority</name>
+ <required>false</required>
+ <version>2.0.0+</version>
+ <type>int</type>
+ <defaultValue>0</defaultValue>
+ <description>If specified, identifies a within phase prioritization of executions.</description>
</field>
<field>
<name>executions</name>
- <version>1.0.0</version>
+ <version>1.0.0+</version>
<description>The goals to execute within the phase.</description>
<association>
<type>Execution</type>
@@ -89,26 +105,51 @@ under the License.
</field>
<field>
<name>configuration</name>
- <version>1.0.0</version>
+ <version>1.0.0+</version>
<type>DOM</type>
<description>Configuration to pass to all goals run in this phase.</description>
</field>
</fields>
+ <codeSegments>
+ <codeSegment>
+ <version>2.0.0+</version>
+ <code><![CDATA[
+ /**
+ * Get the effective ID of this phase, e.g.,
+ * {@code generate-sources} or {@code after:integration-test[1000]}.
+ *
+ * @return String
+ */
+ public String getEffectiveId() {
+ if (executionPoint == null) {
+ if (priority == 0) {
+ return id;
+ }
+ return id + '[' + priority + ']';
+ }
+ if (priority == 0) {
+ return executionPoint + ':' + id;
+ }
+ return executionPoint + ':' + id + '[' + priority + ']';
+ }
+]]></code>
+ </codeSegment>
+ </codeSegments>
</class>
<class>
<name>Execution</name>
- <version>1.0.0</version>
+ <version>1.0.0+</version>
<description>A set of goals to execute.</description>
<fields>
<field>
<name>configuration</name>
- <version>1.0.0</version>
+ <version>1.0.0+</version>
<type>DOM</type>
<description>Configuration to pass to the goals.</description>
</field>
<field>
<name>goals</name>
- <version>1.0.0</version>
+ <version>1.0.0+</version>
<description>The goals to execute.</description>
<association>
<type>String</type>
diff --git a/maven-api-impl/src/test/java/org/apache/maven/internal/impl/standalone/ApiRunner.java b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/standalone/ApiRunner.java
index 3c6c9433de..3806ea1e32 100644
--- a/maven-api-impl/src/test/java/org/apache/maven/internal/impl/standalone/ApiRunner.java
+++ b/maven-api-impl/src/test/java/org/apache/maven/internal/impl/standalone/ApiRunner.java
@@ -364,6 +364,11 @@ public class ApiRunner {
public Optional<Lifecycle> lookup(String id) {
return Optional.empty();
}
+
+ @Override
+ public List<String> computePhases(Lifecycle lifecycle) {
+ return List.of();
+ }
};
}
diff --git a/maven-compat/src/test/java/org/apache/maven/project/EmptyLifecycleBindingsInjector.java b/maven-compat/src/test/java/org/apache/maven/project/EmptyLifecycleBindingsInjector.java
index 513bb0236b..970b74a750 100644
--- a/maven-compat/src/test/java/org/apache/maven/project/EmptyLifecycleBindingsInjector.java
+++ b/maven-compat/src/test/java/org/apache/maven/project/EmptyLifecycleBindingsInjector.java
@@ -62,6 +62,11 @@ public class EmptyLifecycleBindingsInjector extends DefaultLifecycleBindingsInje
public Optional<Lifecycle> lookup(String id) {
return Optional.empty();
}
+
+ @Override
+ public List<String> computePhases(Lifecycle lifecycle) {
+ return List.of();
+ }
};
private static final PackagingRegistry emptyPackagingRegistry = new PackagingRegistry() {
@@ -140,6 +145,11 @@ public class EmptyLifecycleBindingsInjector extends DefaultLifecycleBindingsInje
protected LifecycleRegistry getDelegate() {
return lifecycleRegistry;
}
+
+ @Override
+ public List<String> computePhases(Lifecycle lifecycle) {
+ return List.of();
+ }
}
static class WrapperPackagingRegistry implements PackagingRegistry {
diff --git a/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultLifecycleRegistry.java b/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultLifecycleRegistry.java
index acd8fd74c2..6a401504c5 100644
--- a/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultLifecycleRegistry.java
+++ b/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultLifecycleRegistry.java
@@ -24,6 +24,7 @@ import javax.inject.Provider;
import javax.inject.Singleton;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
@@ -47,8 +48,26 @@ import org.apache.maven.lifecycle.mapping.LifecyclePhase;
import org.codehaus.plexus.PlexusContainer;
import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
-import static java.util.Arrays.asList;
-import static java.util.Collections.singleton;
+import static org.apache.maven.api.Lifecycle.Phase.BUILD;
+import static org.apache.maven.api.Lifecycle.Phase.COMPILE;
+import static org.apache.maven.api.Lifecycle.Phase.DEPLOY;
+import static org.apache.maven.api.Lifecycle.Phase.INITIALIZE;
+import static org.apache.maven.api.Lifecycle.Phase.INSTALL;
+import static org.apache.maven.api.Lifecycle.Phase.INTEGRATION_TEST;
+import static org.apache.maven.api.Lifecycle.Phase.PACKAGE;
+import static org.apache.maven.api.Lifecycle.Phase.READY;
+import static org.apache.maven.api.Lifecycle.Phase.RESOURCES;
+import static org.apache.maven.api.Lifecycle.Phase.SOURCES;
+import static org.apache.maven.api.Lifecycle.Phase.TEST;
+import static org.apache.maven.api.Lifecycle.Phase.TEST_COMPILE;
+import static org.apache.maven.api.Lifecycle.Phase.TEST_RESOURCES;
+import static org.apache.maven.api.Lifecycle.Phase.TEST_SOURCES;
+import static org.apache.maven.api.Lifecycle.Phase.UNIT_TEST;
+import static org.apache.maven.api.Lifecycle.Phase.VALIDATE;
+import static org.apache.maven.api.Lifecycle.Phase.VERIFY;
+import static org.apache.maven.internal.impl.Lifecycles.after;
+import static org.apache.maven.internal.impl.Lifecycles.alias;
+import static org.apache.maven.internal.impl.Lifecycles.dependencies;
import static org.apache.maven.internal.impl.Lifecycles.phase;
import static org.apache.maven.internal.impl.Lifecycles.plugin;
@@ -59,6 +78,8 @@ import static org.apache.maven.internal.impl.Lifecycles.plugin;
@Singleton
public class DefaultLifecycleRegistry implements LifecycleRegistry {
+ private static final String MAVEN_PLUGINS = "org.apache.maven.plugins:";
+
private final List<LifecycleProvider> providers;
public DefaultLifecycleRegistry() {
@@ -73,7 +94,7 @@ public class DefaultLifecycleRegistry implements LifecycleRegistry {
// validate lifecycle
for (Lifecycle lifecycle : this) {
Set<String> set = new HashSet<>();
- lifecycle.phases().forEach(phase -> {
+ lifecycle.allPhases().forEach(phase -> {
if (!set.add(phase.name())) {
throw new IllegalArgumentException(
"Found duplicated phase '" + phase.name() + "' in '" + lifecycle.id() + "' lifecycle");
@@ -97,6 +118,57 @@ public class DefaultLifecycleRegistry implements LifecycleRegistry {
return stream().filter(lf -> Objects.equals(id, lf.id())).findAny();
}
+ public List<String> computePhases(Lifecycle lifecycle) {
+ Graph graph = new Graph();
+ lifecycle.phases().forEach(phase -> addPhase(graph, null, null, phase));
+ List<String> allPhases = graph.visitAll();
+ Collections.reverse(allPhases);
+ List<String> computed =
+ allPhases.stream().filter(s -> !s.startsWith("$")).collect(Collectors.toList());
+ List<String> given = lifecycle.orderedPhases().orElse(null);
+ if (given != null) {
+ if (given.size() != computed.size()) {
+ Set<String> s1 =
+ given.stream().filter(s -> !computed.contains(s)).collect(Collectors.toSet());
+ Set<String> s2 =
+ computed.stream().filter(s -> !given.contains(s)).collect(Collectors.toSet());
+ throw new IllegalStateException(
+ "List of phases differ in size: expected " + computed.size() + ", but received " + given.size()
+ + (s1.isEmpty() ? "" : ", missing " + s1)
+ + (s2.isEmpty() ? "" : ", unexpected " + s2));
+ }
+ return given;
+ }
+ return computed;
+ }
+
+ private static void addPhase(
+ Graph graph, Graph.Vertex before, Graph.Vertex after, org.apache.maven.api.Lifecycle.Phase phase) {
+ Graph.Vertex ep0 = graph.addVertex("$" + phase.name());
+ Graph.Vertex ep1 = graph.addVertex("$$" + phase.name());
+ Graph.Vertex ep2 = graph.addVertex(phase.name());
+ Graph.Vertex ep3 = graph.addVertex("$$$" + phase.name());
+ graph.addEdge(ep0, ep1);
+ graph.addEdge(ep1, ep2);
+ graph.addEdge(ep2, ep3);
+ if (before != null) {
+ graph.addEdge(before, ep0);
+ }
+ if (after != null) {
+ graph.addEdge(ep3, after);
+ }
+ phase.links().forEach(link -> {
+ if (link.pointer().type() == Lifecycle.Pointer.Type.PROJECT) {
+ if (link.kind() == Lifecycle.Link.Kind.AFTER) {
+ graph.addEdge(graph.addVertex(link.pointer().phase()), ep0);
+ } else {
+ graph.addEdge(ep3, graph.addVertex("$" + link.pointer().phase()));
+ }
+ }
+ });
+ phase.phases().forEach(child -> addPhase(graph, ep1, ep2, child));
+ }
+
@Named
@Singleton
public static class LifecycleWrapperProvider implements LifecycleProvider {
@@ -140,6 +212,17 @@ public class DefaultLifecycleRegistry implements LifecycleRegistry {
return name;
}
+ @Override
+ public List<Phase> phases() {
+ return List.of();
+ }
+
+ @Override
+ public Stream<Phase> allPhases() {
+ return Stream.concat(
+ Stream.of(this), phases().stream().flatMap(Lifecycle.Phase::allPhases));
+ }
+
@Override
public List<Plugin> plugins() {
Map<String, LifecyclePhase> lfPhases = lifecycle.getDefaultLifecyclePhases();
@@ -151,16 +234,26 @@ public class DefaultLifecycleRegistry implements LifecycleRegistry {
}
return List.of();
}
+
+ @Override
+ public Collection<Link> links() {
+ return List.of();
+ }
})
.toList();
}
+
+ @Override
+ public Collection<Alias> aliases() {
+ return Collections.emptyList();
+ }
};
}
}
static class WrappedLifecycle extends org.apache.maven.lifecycle.Lifecycle {
- WrappedLifecycle(Lifecycle lifecycle) {
- super(lifecycle);
+ WrappedLifecycle(LifecycleRegistry registry, Lifecycle lifecycle) {
+ super(registry, lifecycle);
}
}
@@ -178,7 +271,7 @@ public class DefaultLifecycleRegistry implements LifecycleRegistry {
public org.apache.maven.lifecycle.Lifecycle get() {
try {
LifecycleRegistry registry = lookup.lookup(LifecycleRegistry.class);
- return new WrappedLifecycle(registry.require(name));
+ return new WrappedLifecycle(registry, registry.require(name));
} catch (ComponentLookupException e) {
throw new LookupException(e);
}
@@ -187,6 +280,7 @@ public class DefaultLifecycleRegistry implements LifecycleRegistry {
@Singleton
@Named(Lifecycle.CLEAN)
+ @SuppressWarnings("unused")
static class CleanLifecycleProvider extends BaseLifecycleProvider {
CleanLifecycleProvider() {
super(Lifecycle.CLEAN);
@@ -195,6 +289,7 @@ public class DefaultLifecycleRegistry implements LifecycleRegistry {
@Singleton
@Named(Lifecycle.DEFAULT)
+ @SuppressWarnings("unused")
static class DefaultLifecycleProvider extends BaseLifecycleProvider {
DefaultLifecycleProvider() {
super(Lifecycle.DEFAULT);
@@ -203,6 +298,7 @@ public class DefaultLifecycleRegistry implements LifecycleRegistry {
@Singleton
@Named(Lifecycle.SITE)
+ @SuppressWarnings("unused")
static class SiteLifecycleProvider extends BaseLifecycleProvider {
SiteLifecycleProvider() {
super(Lifecycle.SITE);
@@ -211,6 +307,7 @@ public class DefaultLifecycleRegistry implements LifecycleRegistry {
@Singleton
@Named(Lifecycle.WRAPPER)
+ @SuppressWarnings("unused")
static class WrapperLifecycleProvider extends BaseLifecycleProvider {
WrapperLifecycleProvider() {
super(Lifecycle.WRAPPER);
@@ -228,15 +325,16 @@ public class DefaultLifecycleRegistry implements LifecycleRegistry {
@Override
public Collection<Phase> phases() {
- return asList(
- phase("pre-clean"),
- phase(
- "clean",
- plugin(
- "org.apache.maven.plugins:maven-clean-plugin:" + MAVEN_CLEAN_PLUGIN_VERSION
- + ":clean",
- "clean")),
- phase("post-clean"));
+ return List.of(phase(
+ Phase.CLEAN,
+ plugin(
+ MAVEN_PLUGINS + "maven-clean-plugin:" + MAVEN_CLEAN_PLUGIN_VERSION + ":clean",
+ Phase.CLEAN)));
+ }
+
+ @Override
+ public Collection<Alias> aliases() {
+ return List.of(alias("pre-clean", BEFORE + Phase.CLEAN), alias("post-clean", AFTER + Phase.CLEAN));
}
}
@@ -248,36 +346,101 @@ public class DefaultLifecycleRegistry implements LifecycleRegistry {
@Override
public Collection<Phase> phases() {
- return asList(
- phase("validate"),
- phase("initialize"),
- phase("generate-sources"),
- phase("process-sources"),
- phase("generate-resources"),
- phase("process-resources"),
- phase("compile"),
- phase("process-classes"),
- phase("generate-test-sources"),
- phase("process-test-sources"),
- phase("generate-test-resources"),
- phase("process-test-resources"),
- phase("test-compile"),
- phase("process-test-classes"),
- phase("test"),
- phase("prepare-package"),
- phase("package"),
- phase("pre-integration-test"),
- phase("integration-test"),
- phase("post-integration-test"),
- phase("verify"),
- phase("install"),
- phase("deploy"));
+ return List.of(phase(
+ "all",
+ phase(INITIALIZE, phase(VALIDATE)),
+ phase(
+ BUILD,
+ after(VALIDATE),
+ phase(SOURCES),
+ phase(RESOURCES),
+ phase(COMPILE, after(SOURCES), dependencies(COMPILE, READY)),
+ phase(READY, after(COMPILE), after(RESOURCES)),
+ phase(PACKAGE, after(READY), dependencies("runtime", PACKAGE))),
+ phase(
+ VERIFY,
+ after(VALIDATE),
+ phase(
+ UNIT_TEST,
+ phase(TEST_SOURCES),
+ phase(TEST_RESOURCES),
+ phase(
+ TEST_COMPILE,
+ after(TEST_SOURCES),
+ after(READY),
+ dependencies("test-only", READY)),
+ phase(
+ TEST,
+ after(TEST_COMPILE),
+ after(TEST_RESOURCES),
+ dependencies("test", READY))),
+ phase(INTEGRATION_TEST)),
+ phase(INSTALL, after(PACKAGE)),
+ phase(DEPLOY, after(PACKAGE))));
+ }
+
+ @Override
+ public Collection<Alias> aliases() {
+ return List.of(
+ alias("generate-sources", SOURCES),
+ alias("process-sources", AFTER + SOURCES),
+ alias("generate-resources", RESOURCES),
+ alias("process-resources", AFTER + RESOURCES),
+ alias("process-classes", AFTER + COMPILE),
+ alias("generate-test-sources", TEST_SOURCES),
+ alias("process-test-sources", AFTER + TEST_SOURCES),
+ alias("generate-test-resources", TEST_RESOURCES),
+ alias("process-test-resources", AFTER + TEST_RESOURCES),
+ alias("process-test-classes", AFTER + TEST_COMPILE),
+ alias("prepare-package", BEFORE + PACKAGE),
+ alias("pre-integration-test", BEFORE + INTEGRATION_TEST),
+ alias("post-integration-test", AFTER + INTEGRATION_TEST));
+ }
+
+ @Override
+ public Optional<List<String>> orderedPhases() {
+ return Optional.of(Arrays.asList(
+ VALIDATE,
+ INITIALIZE,
+ // "generate-sources",
+ SOURCES,
+ // "process-sources",
+ // "generate-resources",
+ RESOURCES,
+ // "process-resources",
+ COMPILE,
+ // "process-classes",
+ READY,
+ // "generate-test-sources",
+ TEST_SOURCES,
+ // "process-test-sources",
+ // "generate-test-resources",
+ TEST_RESOURCES,
+ // "process-test-resources",
+ TEST_COMPILE,
+ // "process-test-classes",
+ TEST,
+ UNIT_TEST,
+ // "prepare-package",
+ PACKAGE,
+ BUILD,
+ // "pre-integration-test",
+ INTEGRATION_TEST,
+ // "post-integration-test",
+ VERIFY,
+ INSTALL,
+ DEPLOY,
+ "all"));
}
}
static class SiteLifecycle implements Lifecycle {
private static final String MAVEN_SITE_PLUGIN_VERSION = "3.12.1";
+ private static final String MAVEN_SITE_PLUGIN =
+ MAVEN_PLUGINS + "maven-site-plugin:" + MAVEN_SITE_PLUGIN_VERSION + ":";
+ private static final String PHASE_SITE = "site";
+ private static final String PHASE_SITE_DEPLOY = "site-deploy";
@Override
public String id() {
@@ -286,26 +449,24 @@ public class DefaultLifecycleRegistry implements LifecycleRegistry {
@Override
public Collection<Phase> phases() {
- return asList(
- phase("pre-site"),
- phase(
- "site",
- plugin(
- "org.apache.maven.plugins:maven-site-plugin:" + MAVEN_SITE_PLUGIN_VERSION + ":site",
- "site")),
- phase("post-site"),
+ return List.of(
+ phase(PHASE_SITE, plugin(MAVEN_SITE_PLUGIN + "site", PHASE_SITE)),
phase(
- "site-deploy",
- plugin(
- "org.apache.maven.plugins:maven-site-plugin:" + MAVEN_SITE_PLUGIN_VERSION
- + ":deploy",
- "site-deploy")));
+ PHASE_SITE_DEPLOY,
+ after(PHASE_SITE),
+ plugin(MAVEN_SITE_PLUGIN + "deploy", PHASE_SITE_DEPLOY)));
+ }
+
+ @Override
+ public Collection<Alias> aliases() {
+ return List.of(alias("pre-site", BEFORE + PHASE_SITE), alias("post-site", AFTER + PHASE_SITE));
}
}
static class WrapperLifecycle implements Lifecycle {
private static final String MAVEN_WRAPPER_PLUGIN_VERSION = "3.2.0";
+ private static final String PHASE_WRAPPER = "wrapper";
@Override
public String id() {
@@ -314,12 +475,16 @@ public class DefaultLifecycleRegistry implements LifecycleRegistry {
@Override
public Collection<Phase> phases() {
- return singleton(phase(
- "wrapper",
+ return List.of(phase(
+ PHASE_WRAPPER,
plugin(
- "org.apache.maven.plugins:maven-wrapper-plugin:" + MAVEN_WRAPPER_PLUGIN_VERSION
- + ":wrapper",
- "wrapper")));
+ MAVEN_PLUGINS + "maven-wrapper-plugin:" + MAVEN_WRAPPER_PLUGIN_VERSION + ":wrapper",
+ PHASE_WRAPPER)));
+ }
+
+ @Override
+ public Collection<Alias> aliases() {
+ return List.of();
}
}
}
diff --git a/maven-core/src/main/java/org/apache/maven/internal/impl/Lifecycles.java b/maven-core/src/main/java/org/apache/maven/internal/impl/Lifecycles.java
index b2e356f6ad..213f87d7b2 100644
--- a/maven-core/src/main/java/org/apache/maven/internal/impl/Lifecycles.java
+++ b/maven-core/src/main/java/org/apache/maven/internal/impl/Lifecycles.java
@@ -18,21 +18,52 @@
*/
package org.apache.maven.internal.impl;
+import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.stream.Stream;
import org.apache.maven.api.Lifecycle;
import org.apache.maven.api.model.Plugin;
import org.apache.maven.api.model.PluginExecution;
+import static java.util.Arrays.asList;
+
public class Lifecycles {
static Lifecycle.Phase phase(String name) {
- return new DefaultPhase(name, Collections.emptyList(), Collections.emptyList());
+ return new DefaultPhase(name, Collections.emptyList(), Collections.emptyList(), Collections.emptyList());
+ }
+
+ static Lifecycle.Phase phase(String name, Lifecycle.Phase... phases) {
+ return new DefaultPhase(name, Collections.emptyList(), Collections.emptyList(), asList(phases));
+ }
+
+ static Lifecycle.Phase phase(String name, Lifecycle.Link link, Lifecycle.Phase... phases) {
+ return new DefaultPhase(name, Collections.emptyList(), Collections.singletonList(link), asList(phases));
}
static Lifecycle.Phase phase(String name, Plugin plugin) {
- return new DefaultPhase(name, Collections.singletonList(plugin), Collections.emptyList());
+ return new DefaultPhase(
+ name, Collections.singletonList(plugin), Collections.emptyList(), Collections.emptyList());
+ }
+
+ static Lifecycle.Phase phase(String name, Lifecycle.Link link, Plugin plugin) {
+ return new DefaultPhase(
+ name, Collections.singletonList(plugin), Collections.singletonList(link), Collections.emptyList());
+ }
+
+ static Lifecycle.Phase phase(String name, Lifecycle.Link link1, Lifecycle.Link link2, Lifecycle.Phase... phases) {
+ return new DefaultPhase(name, Collections.emptyList(), asList(link1, link2), asList(phases));
+ }
+
+ static Lifecycle.Phase phase(
+ String name, Lifecycle.Link link1, Lifecycle.Link link2, Lifecycle.Link link3, Lifecycle.Phase... phases) {
+ return new DefaultPhase(name, Collections.emptyList(), asList(link1, link2, link3), asList(phases));
+ }
+
+ static Lifecycle.Phase phase(String name, Collection<Lifecycle.Link> links, Lifecycle.Phase... phases) {
+ return new DefaultPhase(name, Collections.emptyList(), links, asList(phases));
}
static Plugin plugin(String coords, String phase) {
@@ -49,14 +80,66 @@ public class Lifecycles {
.build();
}
+ /** Indicates the phase is after the phases given in arguments */
+ static Lifecycle.Link after(String b) {
+ return new Lifecycle.Link() {
+ @Override
+ public Kind kind() {
+ return Kind.AFTER;
+ }
+
+ @Override
+ public Lifecycle.Pointer pointer() {
+ return new Lifecycle.PhasePointer() {
+ @Override
+ public String phase() {
+ return b;
+ }
+ };
+ }
+ };
+ }
+
+ /** Indicates the phase is after the phases for the dependencies in the given scope */
+ static Lifecycle.Link dependencies(String scope, String phase) {
+ return new Lifecycle.Link() {
+ @Override
+ public Kind kind() {
+ return Kind.AFTER;
+ }
+
+ @Override
+ public Lifecycle.Pointer pointer() {
+ return new Lifecycle.DependenciesPointer() {
+ @Override
+ public String phase() {
+ return phase;
+ }
+
+ @Override
+ public String scope() {
+ return scope;
+ }
+ };
+ }
+ };
+ }
+
+ static Lifecycle.Alias alias(String v3Phase, String v4Phase) {
+ return new DefaultAlias(v3Phase, v4Phase);
+ }
+
static class DefaultPhase implements Lifecycle.Phase {
private final String name;
private final List<Plugin> plugins;
+ private final Collection<Lifecycle.Link> links;
private final List<Lifecycle.Phase> phases;
- DefaultPhase(String name, List<Plugin> plugins, List<Lifecycle.Phase> phases) {
+ DefaultPhase(
+ String name, List<Plugin> plugins, Collection<Lifecycle.Link> links, List<Lifecycle.Phase> phases) {
this.name = name;
this.plugins = plugins;
+ this.links = links;
this.phases = phases;
}
@@ -69,5 +152,40 @@ public class Lifecycles {
public List<Plugin> plugins() {
return plugins;
}
+
+ @Override
+ public Collection<Lifecycle.Link> links() {
+ return links;
+ }
+
+ @Override
+ public List<Lifecycle.Phase> phases() {
+ return phases;
+ }
+
+ @Override
+ public Stream<Lifecycle.Phase> allPhases() {
+ return Stream.concat(Stream.of(this), phases().stream().flatMap(Lifecycle.Phase::allPhases));
+ }
+ }
+
+ static class DefaultAlias implements Lifecycle.Alias {
+ private final String v3Phase;
+ private final String v4Phase;
+
+ DefaultAlias(String v3Phase, String v4Phase) {
+ this.v3Phase = v3Phase;
+ this.v4Phase = v4Phase;
+ }
+
+ @Override
+ public String v3Phase() {
+ return v3Phase;
+ }
+
+ @Override
+ public String v4Phase() {
+ return v4Phase;
+ }
}
}
diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/DefaultLifecycles.java b/maven-core/src/main/java/org/apache/maven/lifecycle/DefaultLifecycles.java
index 91e1adbc64..460cf5b9e4 100644
--- a/maven-core/src/main/java/org/apache/maven/lifecycle/DefaultLifecycles.java
+++ b/maven-core/src/main/java/org/apache/maven/lifecycle/DefaultLifecycles.java
@@ -56,6 +56,8 @@ public class DefaultLifecycles {
private Map<String, Lifecycle> customLifecycles;
+ private boolean lifecyclesPrinted;
+
public DefaultLifecycles() {
this.lookup = null;
this.registry = null;
@@ -94,20 +96,23 @@ public class DefaultLifecycles {
* @return A map of lifecycles, indexed on id
*/
public Map<String, Lifecycle> getPhaseToLifecycleMap() {
+ if (logger.isDebugEnabled() && !lifecyclesPrinted) {
+ for (Lifecycle lifecycle : getLifeCycles()) {
+ logger.debug("Lifecycle {}", lifecycle);
+ }
+ lifecyclesPrinted = true;
+ }
+
// If people are going to make their own lifecycles then we need to tell people how to namespace them correctly
// so that they don't interfere with internally defined lifecycles.
Map<String, Lifecycle> phaseToLifecycleMap = new HashMap<>();
for (Lifecycle lifecycle : getLifeCycles()) {
- logger.debug("Lifecycle {}", lifecycle);
-
for (String phase : lifecycle.getPhases()) {
// The first definition wins.
- if (!phaseToLifecycleMap.containsKey(phase)) {
- phaseToLifecycleMap.put(phase, lifecycle);
- } else if (logger.isWarnEnabled()) {
- Lifecycle original = phaseToLifecycleMap.get(phase);
+ Lifecycle original = phaseToLifecycleMap.put(phase, lifecycle);
+ if (original != null && logger.isWarnEnabled()) {
logger.warn(
"Duplicated lifecycle phase {}. Defined in {} but also in {}",
phase,
@@ -115,6 +120,19 @@ public class DefaultLifecycles {
lifecycle.getId());
}
}
+ if (lifecycle.getDelegate() != null) {
+ for (org.apache.maven.api.Lifecycle.Alias alias :
+ lifecycle.getDelegate().aliases()) {
+ Lifecycle original = phaseToLifecycleMap.put(alias.v3Phase(), lifecycle);
+ if (original != null && logger.isWarnEnabled()) {
+ logger.warn(
+ "Duplicated lifecycle phase {}. Defined in {} but also in {}",
+ alias.v3Phase(),
+ original.getId(),
+ lifecycle.getId());
+ }
+ }
+ }
}
return phaseToLifecycleMap;
@@ -156,7 +174,7 @@ public class DefaultLifecycles {
// Lifecycles cannot be cached as extensions might add custom lifecycles later in the execution.
try {
return registry != null
- ? registry.stream().collect(Collectors.toMap(lf -> lf.id(), lf -> new Lifecycle(lf)))
+ ? registry.stream().collect(Collectors.toMap(lf -> lf.id(), lf -> new Lifecycle(registry, lf)))
: Map.of();
} catch (LookupException e) {
throw new IllegalStateException("Unable to lookup lifecycles from the plexus container", e);
diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/Lifecycle.java b/maven-core/src/main/java/org/apache/maven/lifecycle/Lifecycle.java
index d953d9f669..cc05a32ca6 100644
--- a/maven-core/src/main/java/org/apache/maven/lifecycle/Lifecycle.java
+++ b/maven-core/src/main/java/org/apache/maven/lifecycle/Lifecycle.java
@@ -23,9 +23,13 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
+import java.util.stream.Stream;
import org.apache.maven.lifecycle.mapping.LifecyclePhase;
+import static org.apache.maven.api.Lifecycle.AFTER;
+import static org.apache.maven.api.Lifecycle.BEFORE;
+
/**
* Lifecycle definition, with eventual plugin bindings (when they are not packaging-specific).
*/
@@ -38,11 +42,12 @@ public class Lifecycle {
this.defaultPhases = defaultPhases;
}
- public Lifecycle(org.apache.maven.api.Lifecycle lifecycle) {
+ public Lifecycle(
+ org.apache.maven.api.services.LifecycleRegistry registry, org.apache.maven.api.Lifecycle lifecycle) {
this.lifecycle = lifecycle;
this.id = lifecycle.id();
- this.phases = lifecycle.phases().stream()
- .map(org.apache.maven.api.Lifecycle.Phase::name)
+ this.phases = registry.computePhases(lifecycle).stream()
+ .flatMap(p -> Stream.of(BEFORE + p, p, AFTER + p))
.toList();
this.defaultPhases = getDefaultPhases(lifecycle);
}
@@ -71,13 +76,17 @@ public class Lifecycle {
return id;
}
+ public org.apache.maven.api.Lifecycle getDelegate() {
+ return lifecycle;
+ }
+
public List<String> getPhases() {
return phases;
}
static Map<String, LifecyclePhase> getDefaultPhases(org.apache.maven.api.Lifecycle lifecycle) {
Map<String, List<String>> goals = new HashMap<>();
- lifecycle.phases().forEach(phase -> phase.plugins()
+ lifecycle.allPhases().forEach(phase -> phase.plugins()
.forEach(plugin -> plugin.getExecutions().forEach(exec -> exec.getGoals()
.forEach(goal -> goals.computeIfAbsent(phase.name(), n -> new ArrayList<>())
.add(plugin.getGroupId() + ":" + plugin.getArtifactId() + ":" + plugin.getVersion()
@@ -97,6 +106,10 @@ public class Lifecycle {
@Override
public String toString() {
- return id + " -> " + phases;
+ return id + " -> "
+ + lifecycle
+ .allPhases()
+ .map(org.apache.maven.api.Lifecycle.Phase::name)
+ .collect(Collectors.joining(", ", "[", "]"));
}
}
diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecycleExecutionPlanCalculator.java b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecycleExecutionPlanCalculator.java
index e74bbf37f0..35eadd54c3 100644
--- a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecycleExecutionPlanCalculator.java
+++ b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecycleExecutionPlanCalculator.java
@@ -475,7 +475,14 @@ public class DefaultLifecycleExecutionPlanCalculator implements LifecycleExecuti
}
for (Phase phase : lifecycleOverlay.getPhases()) {
- List<MojoExecution> forkedExecutions = lifecycleMappings.get(phase.getId());
+ String phaseId = defaultLifecycles.getLifeCycles().stream()
+ .flatMap(l -> l.getDelegate().aliases().stream())
+ .filter(a -> phase.getId().equals(a.v3Phase()))
+ .findFirst()
+ .map(a -> a.v4Phase())
+ .orElse(phase.getId());
+
+ List<MojoExecution> forkedExecutions = lifecycleMappings.get(phaseId);
if (forkedExecutions != null) {
for (Execution execution : phase.getExecutions()) {
diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecycleMappingDelegate.java b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecycleMappingDelegate.java
index 6ce06531e5..43598103f1 100644
--- a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecycleMappingDelegate.java
+++ b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecycleMappingDelegate.java
@@ -23,10 +23,12 @@ import javax.inject.Named;
import javax.inject.Singleton;
import java.util.ArrayList;
+import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
+import java.util.stream.Collectors;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.lifecycle.Lifecycle;
@@ -70,10 +72,19 @@ public class DefaultLifecycleMappingDelegate implements LifecycleMappingDelegate
* is interested in, i.e. all phases up to and including the specified phase.
*/
- Map<String, Map<Integer, List<MojoExecution>>> mappings = new LinkedHashMap<>();
+ Map<String, Map<PhaseId, List<MojoExecution>>> mappings =
+ new TreeMap<>(new PhaseComparator(lifecycle.getPhases()));
+
+ Map<String, String> aliases = lifecycle.getDelegate().aliases().stream()
+ .collect(Collectors.toMap(a -> a.v3Phase(), a -> a.v4Phase()));
+
+ if (aliases.containsKey(lifecyclePhase)) {
+ lifecyclePhase = PhaseId.of(aliases.get(lifecyclePhase)).phase();
+ }
for (String phase : lifecycle.getPhases()) {
- Map<Integer, List<MojoExecution>> phaseBindings = new TreeMap<>();
+ Map<PhaseId, List<MojoExecution>> phaseBindings =
+ new TreeMap<>(Comparator.comparing(PhaseId::toString, new PhaseComparator(lifecycle.getPhases())));
mappings.put(phase, phaseBindings);
@@ -93,13 +104,21 @@ public class DefaultLifecycleMappingDelegate implements LifecycleMappingDelegate
for (PluginExecution execution : plugin.getExecutions()) {
// if the phase is specified then I don't have to go fetch the plugin yet and pull it down
// to examine the phase it is associated to.
- if (execution.getPhase() != null) {
- Map<Integer, List<MojoExecution>> phaseBindings = mappings.get(execution.getPhase());
+ String phase = execution.getPhase();
+ if (aliases.containsKey(phase)) {
+ phase = aliases.get(phase);
+ }
+ if (phase != null) {
+ Map<PhaseId, List<MojoExecution>> phaseBindings = getPhaseBindings(mappings, phase);
if (phaseBindings != null) {
for (String goal : execution.getGoals()) {
MojoExecution mojoExecution = new MojoExecution(plugin, goal, execution.getId());
- mojoExecution.setLifecyclePhase(execution.getPhase());
- addMojoExecution(phaseBindings, mojoExecution, execution.getPriority());
+ mojoExecution.setLifecyclePhase(phase);
+ PhaseId phaseId = PhaseId.of(phase);
+ if (phaseId.priority() == 0) {
+ phaseId = PhaseId.of(phase + "[" + execution.getPriority() + "]");
+ }
+ addMojoExecution(phaseBindings, mojoExecution, phaseId);
}
}
}
@@ -109,11 +128,16 @@ public class DefaultLifecycleMappingDelegate implements LifecycleMappingDelegate
MojoDescriptor mojoDescriptor = pluginManager.getMojoDescriptor(
plugin, goal, project.getRemotePluginRepositories(), session.getRepositorySession());
- Map<Integer, List<MojoExecution>> phaseBindings = mappings.get(mojoDescriptor.getPhase());
+ phase = mojoDescriptor.getPhase();
+ if (aliases.containsKey(phase)) {
+ phase = aliases.get(phase);
+ }
+ Map<PhaseId, List<MojoExecution>> phaseBindings = getPhaseBindings(mappings, phase);
if (phaseBindings != null) {
MojoExecution mojoExecution = new MojoExecution(mojoDescriptor, execution.getId());
- mojoExecution.setLifecyclePhase(mojoDescriptor.getPhase());
- addMojoExecution(phaseBindings, mojoExecution, execution.getPriority());
+ mojoExecution.setLifecyclePhase(phase);
+ PhaseId phaseId = PhaseId.of(phase + "[" + execution.getPriority() + "]");
+ addMojoExecution(phaseBindings, mojoExecution, phaseId);
}
}
}
@@ -122,7 +146,7 @@ public class DefaultLifecycleMappingDelegate implements LifecycleMappingDelegate
Map<String, List<MojoExecution>> lifecycleMappings = new LinkedHashMap<>();
- for (Map.Entry<String, Map<Integer, List<MojoExecution>>> entry : mappings.entrySet()) {
+ for (Map.Entry<String, Map<PhaseId, List<MojoExecution>>> entry : mappings.entrySet()) {
List<MojoExecution> mojoExecutions = new ArrayList<>();
for (List<MojoExecution> executions : entry.getValue().values()) {
@@ -135,9 +159,18 @@ public class DefaultLifecycleMappingDelegate implements LifecycleMappingDelegate
return lifecycleMappings;
}
+ private Map<PhaseId, List<MojoExecution>> getPhaseBindings(
+ Map<String, Map<PhaseId, List<MojoExecution>>> mappings, String phase) {
+ if (phase != null) {
+ PhaseId id = PhaseId.of(phase);
+ return mappings.get(id.phase());
+ }
+ return null;
+ }
+
private void addMojoExecution(
- Map<Integer, List<MojoExecution>> phaseBindings, MojoExecution mojoExecution, int priority) {
- List<MojoExecution> mojoExecutions = phaseBindings.computeIfAbsent(priority, k -> new ArrayList<>());
+ Map<PhaseId, List<MojoExecution>> phaseBindings, MojoExecution mojoExecution, PhaseId phaseId) {
+ List<MojoExecution> mojoExecutions = phaseBindings.computeIfAbsent(phaseId, k -> new ArrayList<>());
mojoExecutions.add(mojoExecution);
}
diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/PhaseComparator.java b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/PhaseComparator.java
new file mode 100644
index 0000000000..7c8004b8c3
--- /dev/null
+++ b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/PhaseComparator.java
@@ -0,0 +1,74 @@
+/*
+ * 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.lifecycle.internal;
+
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * Compares phases within the context of a specific lifecycle with secondary sorting based on the {@link PhaseId}.
+ */
+public class PhaseComparator implements Comparator<String> {
+ /**
+ * The lifecycle phase ordering.
+ */
+ private final List<String> lifecyclePhases;
+
+ /**
+ * Constructor.
+ *
+ * @param lifecyclePhases the lifecycle phase ordering.
+ */
+ public PhaseComparator(List<String> lifecyclePhases) {
+ this.lifecyclePhases = lifecyclePhases;
+ }
+
+ @Override
+ public int compare(String o1, String o2) {
+ PhaseId p1 = PhaseId.of(o1);
+ PhaseId p2 = PhaseId.of(o2);
+ int i1 = lifecyclePhases.indexOf(p1.phase());
+ int i2 = lifecyclePhases.indexOf(p2.phase());
+ if (i1 == -1 && i2 == -1) {
+ // unknown phases, leave in existing order
+ return 0;
+ }
+ if (i1 == -1) {
+ // second one is known, so it comes first
+ return 1;
+ }
+ if (i2 == -1) {
+ // first one is known, so it comes first
+ return -1;
+ }
+ int rv = Integer.compare(i1, i2);
+ if (rv != 0) {
+ return rv;
+ }
+ // same phase, now compare execution points
+ i1 = p1.executionPoint().ordinal();
+ i2 = p2.executionPoint().ordinal();
+ rv = Integer.compare(i1, i2);
+ if (rv != 0) {
+ return rv;
+ }
+ // same execution point, now compare priorities
+ return Integer.compare(p1.priority(), p2.priority());
+ }
+}
diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/PhaseExecutionPoint.java b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/PhaseExecutionPoint.java
new file mode 100644
index 0000000000..78e8981c91
--- /dev/null
+++ b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/PhaseExecutionPoint.java
@@ -0,0 +1,50 @@
+/*
+ * 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.lifecycle.internal;
+
+/**
+ * Represents where a dynamic phase should be executed within a static phase.
+ */
+public enum PhaseExecutionPoint {
+ /**
+ * Execution must occur before any executions of the phase proper. Failure of any {@code #BEFORE} dynamic phase
+ * execution will prevent the {@link #AT} phase but will not prevent any {@link #AFTER} dynamic phases.
+ */
+ BEFORE("before:"),
+ /**
+ * Execution is the execution of the phase proper. Failure of any {@code #AT} dynamic phase execution will fail
+ * the phase. Any {@link #AFTER} phases will still be executed.
+ */
+ AT(""),
+ /**
+ * Guaranteed execution dynamic phases on completion of the static phase. All {@code #AFTER} dynamic phases will
+ * be executed provided at least one {@link #BEFORE} or {@link #AT} dynamic phase has started execution.
+ */
+ AFTER("after:");
+
+ private final String prefix;
+
+ PhaseExecutionPoint(String prefix) {
+ this.prefix = prefix;
+ }
+
+ public String prefix() {
+ return prefix;
+ }
+}
diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/PhaseId.java b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/PhaseId.java
new file mode 100644
index 0000000000..b52a989b7c
--- /dev/null
+++ b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/PhaseId.java
@@ -0,0 +1,142 @@
+/*
+ * 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.lifecycle.internal;
+
+import java.util.Map;
+import java.util.Objects;
+import java.util.WeakHashMap;
+
+/**
+ * Represents a parsed phase identifier.
+ */
+public class PhaseId {
+ /**
+ * Interned {@link PhaseId} instances.
+ */
+ private static final Map<String, PhaseId> INSTANCES = new WeakHashMap<>();
+
+ /**
+ * The execution point of this {@link PhaseId}.
+ */
+ private final PhaseExecutionPoint executionPoint;
+
+ /**
+ * The static phase that this dynamic phase belongs to.
+ */
+ private final String phase;
+
+ /**
+ * The priority of this dynamic phase within the static phase.
+ */
+ private final int priority;
+
+ /**
+ * Parses the phase identifier.
+ *
+ * @param phase the phase identifier.
+ * @return the {@link PhaseId}.
+ */
+ public static synchronized PhaseId of(String phase) {
+ return INSTANCES.computeIfAbsent(phase, PhaseId::new);
+ }
+
+ /**
+ * Constructor.
+ *
+ * @param phase the phase identifier string.
+ */
+ private PhaseId(String phase) {
+ int phaseStart;
+ if (phase.startsWith(PhaseExecutionPoint.BEFORE.prefix())) {
+ executionPoint = PhaseExecutionPoint.BEFORE;
+ phaseStart = PhaseExecutionPoint.BEFORE.prefix().length();
+ } else if (phase.startsWith(PhaseExecutionPoint.AFTER.prefix())) {
+ executionPoint = PhaseExecutionPoint.AFTER;
+ phaseStart = PhaseExecutionPoint.AFTER.prefix().length();
+ } else {
+ executionPoint = PhaseExecutionPoint.AT;
+ phaseStart = 0;
+ }
+ int phaseEnd = phase.indexOf('[');
+ if (phaseEnd == -1) {
+ priority = 0;
+ this.phase = phase.substring(phaseStart);
+ } else {
+ int priorityEnd = phase.lastIndexOf(']');
+ boolean hasPriority;
+ int priority;
+ if (priorityEnd < phaseEnd + 1) {
+ priority = 0;
+ hasPriority = false;
+ } else {
+ try {
+ priority = Integer.parseInt(phase.substring(phaseEnd + 1, priorityEnd));
+ hasPriority = true;
+ } catch (NumberFormatException e) {
+ // priority must be an integer
+ priority = 0;
+ hasPriority = false;
+ }
+ }
+ if (hasPriority) {
+ this.phase = phase.substring(phaseStart, phaseEnd);
+ this.priority = priority;
+ } else {
+ this.phase = phase.substring(phaseStart);
+ this.priority = 0;
+ }
+ }
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ } else if (o == null || getClass() != o.getClass()) {
+ return false;
+ } else {
+ PhaseId phaseId = (PhaseId) o;
+ return Objects.equals(executionPoint(), phaseId.executionPoint())
+ && Objects.equals(phase(), phaseId.phase())
+ && Objects.equals(priority(), phaseId.priority());
+ }
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(executionPoint(), phase(), priority());
+ }
+
+ @Override
+ public String toString() {
+ return executionPoint().prefix() + phase() + (priority() != 0 ? "[" + priority() + ']' : "");
+ }
+
+ public PhaseExecutionPoint executionPoint() {
+ return executionPoint;
+ }
+
+ public String phase() {
+ return phase;
+ }
+
+ public int priority() {
+ return priority;
+ }
+}
diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/PhaseRecorder.java b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/PhaseRecorder.java
index c037af5c4d..a5f8f46825 100644
--- a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/PhaseRecorder.java
+++ b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/PhaseRecorder.java
@@ -38,11 +38,12 @@ public class PhaseRecorder {
String lifecyclePhase = mojoExecution.getLifecyclePhase();
if (lifecyclePhase != null) {
+ PhaseId phaseId = PhaseId.of(lifecyclePhase);
if (lastLifecyclePhase == null) {
- lastLifecyclePhase = lifecyclePhase;
- } else if (!lifecyclePhase.equals(lastLifecyclePhase)) {
+ lastLifecyclePhase = phaseId.phase();
+ } else if (!phaseId.phase().equals(lastLifecyclePhase)) {
project.addLifecyclePhase(lastLifecyclePhase);
- lastLifecyclePhase = lifecyclePhase;
+ lastLifecyclePhase = phaseId.phase();
}
}
@@ -56,6 +57,6 @@ public class PhaseRecorder {
if (lifecyclePhase == null) {
return lastLifecyclePhase != null;
}
- return !lifecyclePhase.equals(lastLifecyclePhase);
+ return !PhaseId.of(lifecyclePhase).phase().equals(lastLifecyclePhase);
}
}
diff --git a/maven-core/src/test/java/org/apache/maven/lifecycle/DefaultLifecyclesTest.java b/maven-core/src/test/java/org/apache/maven/lifecycle/DefaultLifecyclesTest.java
index ba12bcade0..38be02adae 100644
--- a/maven-core/src/test/java/org/apache/maven/lifecycle/DefaultLifecyclesTest.java
+++ b/maven-core/src/test/java/org/apache/maven/lifecycle/DefaultLifecyclesTest.java
@@ -59,7 +59,7 @@ class DefaultLifecyclesTest {
void testDefaultLifecycle() {
final Lifecycle lifecycle = getLifeCycleById("default");
assertThat(lifecycle.getId(), is("default"));
- assertThat(lifecycle.getPhases(), hasSize(23));
+ assertThat(lifecycle.getPhases(), hasSize(54));
}
@Test
@@ -73,14 +73,14 @@ class DefaultLifecyclesTest {
void testSiteLifecycle() {
final Lifecycle lifecycle = getLifeCycleById("site");
assertThat(lifecycle.getId(), is("site"));
- assertThat(lifecycle.getPhases(), hasSize(4));
+ assertThat(lifecycle.getPhases(), hasSize(6));
}
@Test
void testWrapperLifecycle() {
final Lifecycle lifecycle = getLifeCycleById("wrapper");
assertThat(lifecycle.getId(), is("wrapper"));
- assertThat(lifecycle.getPhases(), hasSize(1));
+ assertThat(lifecycle.getPhases(), hasSize(3));
}
@Test
diff --git a/maven-core/src/test/java/org/apache/maven/lifecycle/LifecycleExecutorTest.java b/maven-core/src/test/java/org/apache/maven/lifecycle/LifecycleExecutorTest.java
index 883530e702..6673e0567b 100644
--- a/maven-core/src/test/java/org/apache/maven/lifecycle/LifecycleExecutorTest.java
+++ b/maven-core/src/test/java/org/apache/maven/lifecycle/LifecycleExecutorTest.java
@@ -152,6 +152,7 @@ class LifecycleExecutorTest extends AbstractCoreMavenComponentTestCase {
}
// We need to take in multiple lifecycles
+ @Test
public void testCalculationOfBuildPlanTasksOfTheCleanLifecycleAndTheInstallLifecycle() throws Exception {
File pom = getProject("project-with-additional-lifecycle-elements");
MavenSession session = createMavenSession(pom);
@@ -195,6 +196,7 @@ class LifecycleExecutorTest extends AbstractCoreMavenComponentTestCase {
}
// We need to take in multiple lifecycles
+ @Test
public void testCalculationOfBuildPlanWithMultipleExecutionsOfModello() throws Exception {
File pom = getProject("project-with-multiple-executions");
MavenSession session = createMavenSession(pom);
diff --git a/maven-core/src/test/java/org/apache/maven/project/EmptyLifecycleBindingsInjector.java b/maven-core/src/test/java/org/apache/maven/project/EmptyLifecycleBindingsInjector.java
index 747f2b8c3f..3a7bc1a2bf 100644
--- a/maven-core/src/test/java/org/apache/maven/project/EmptyLifecycleBindingsInjector.java
+++ b/maven-core/src/test/java/org/apache/maven/project/EmptyLifecycleBindingsInjector.java
@@ -61,6 +61,11 @@ public class EmptyLifecycleBindingsInjector extends DefaultLifecycleBindingsInje
public Optional<Lifecycle> lookup(String id) {
return Optional.empty();
}
+
+ @Override
+ public List<String> computePhases(Lifecycle lifecycle) {
+ return List.of();
+ }
};
private static final PackagingRegistry emptyPackagingRegistry = new PackagingRegistry() {
@@ -139,6 +144,11 @@ public class EmptyLifecycleBindingsInjector extends DefaultLifecycleBindingsInje
protected LifecycleRegistry getDelegate() {
return lifecycleRegistry;
}
+
+ @Override
+ public List<String> computePhases(Lifecycle lifecycle) {
+ return List.of();
+ }
}
static class WrapperPackagingRegistry implements PackagingRegistry {
diff --git a/maven-plugin-api/pom.xml b/maven-plugin-api/pom.xml
index 148f3dc375..f3b63da0cb 100644
--- a/maven-plugin-api/pom.xml
+++ b/maven-plugin-api/pom.xml
@@ -117,7 +117,7 @@ under the License.
<models>
<model>../api/maven-api-plugin/src/main/mdo/lifecycle.mdo</model>
</models>
- <version>1.0.0</version>
+ <version>2.0.0</version>
</configuration>
</execution>
<execution>
diff --git a/src/mdo/reader-stax.vm b/src/mdo/reader-stax.vm
index 0d3136d9f9..4b30a6a9b7 100644
--- a/src/mdo/reader-stax.vm
+++ b/src/mdo/reader-stax.vm
@@ -551,6 +551,9 @@ public class ${className} {
#foreach ( $field in $allFields )
#if ( $Helper.xmlFieldMetadata( $field ).attribute )
#set ( $fieldTagName = $Helper.xmlFieldMetadata( $field ).tagName )
+ #if ( ! $fieldTagName )
+ #set ( $fieldTagName = $field.name )
+ #end
#set ( $fieldCapName = $Helper.capitalise( $field.name ) )
} else if ("$fieldTagName".equals(name)) {
#if ( $locationTracking )
@@ -562,6 +565,8 @@ public class ${className} {
${classLcapName}.${field.name}(interpolatedTrimmed(value, "$fieldTagName"));
#elseif ( $field.type == "boolean" || $field.type == "Boolean" )
${classLcapName}.${field.name}(getBooleanValue(interpolatedTrimmed(value, "$fieldTagName"), "$fieldTagName", parser, ${field.defaultValue}));
+ #elseif ( $field.type == "int" || $field.type == "Integer" )
+ ${classLcapName}.${field.name}(getIntegerValue(interpolatedTrimmed(value, "$fieldTagName"), "$fieldTagName", parser, strict, ${field.defaultValue}));
#else
// TODO: type=${field.type} to=${field.to} multiplicity=${field.multiplicity}
#end
diff --git a/src/mdo/writer-stax.vm b/src/mdo/writer-stax.vm
index 82e7c51f26..c479e91cc6 100644
--- a/src/mdo/writer-stax.vm
+++ b/src/mdo/writer-stax.vm
@@ -227,6 +227,9 @@ public class ${className} {
#foreach ( $field in $allFields )
#if ( $Helper.xmlFieldMetadata( $field ).attribute && ! $Helper.xmlFieldMetadata( $field ).format )
#set ( $fieldTagName = $Helper.xmlFieldMetadata( $field ).tagName )
+ #if ( ! $fieldTagName )
+ #set ( $fieldTagName = $field.name )
+ #end
#set ( $fieldCapName = $Helper.capitalise( $field.name ) )
#if ( $field.type == "String" )
writeAttr("$fieldTagName", ${classLcapName}.get${fieldCapName}(), serializer);
@@ -237,6 +240,8 @@ public class ${className} {
#else
writeAttr("$fieldTagName", ${classLcapName}.is${fieldCapName}() ? "true" : null, serializer);
#end
+ #elseif ( $field.type == "int" || $field.type == "Integer" )
+ writeAttr("$fieldTagName", Integer.toString(${classLcapName}.get${fieldCapName}()), serializer);
#else
// TODO: type=${field.type} to=${field.to} multiplicity=${field.multiplicity}
#end
diff --git a/src/mdo/writer.vm b/src/mdo/writer.vm
index 33a3689993..6c3d28b5a0 100644
--- a/src/mdo/writer.vm
+++ b/src/mdo/writer.vm
@@ -152,6 +152,9 @@ public class ${className} {
#foreach ( $field in $allFields )
#if ( $Helper.xmlFieldMetadata( $field ).attribute )
#set ( $fieldTagName = $Helper.xmlFieldMetadata( $field ).tagName )
+ #if ( ! $fieldTagName )
+ #set ( $fieldTagName = $field.name )
+ #end
#set ( $fieldCapName = $Helper.capitalise( $field.name ) )
#if ( $field.type == "String" )
writeAttr("$fieldTagName", ${classLcapName}.get${fieldCapName}(), serializer);
@@ -162,6 +165,8 @@ public class ${className} {
#else
writeAttr("$fieldTagName", ${classLcapName}.is${fieldCapName}() ? "true" : null, serializer);
#end
+ #elseif ( $field.type == "int" || $field.type == "Integer" )
+ writeAttr("$fieldTagName", Integer.toString(${classLcapName}.get${fieldCapName}()), serializer);
#else
// TODO: type=${field.type} to=${field.to} multiplicity=${field.multiplicity}
#end