LOGGER.warn(
                            "File '{}' is more recent than the packaged artifact for '{}', "
                                    + "please run a full `mvn package` build",
                            relativizeOutputFile(outputFile),
                            project.getArtifactId());
                    return true;
                }
            }

        <field xdoc.separator="blank">
          <name>name</name>
          <version>3.0.0+</version>
          <required>true</required>
          <description>The full name of the project.</description>
          <type>String</type>
        </field>
        <field>
          <name>description</name>
          <version>3.0.0+</version>

                        .replaceAll("[\n\r]", "")
                        .length());
    }

    @Test
    void testFullInterpolationOfNestedExpressions() throws Exception {
        PomTestWrapper pom = buildPom("full-interpolation");
        for (int i = 0; i < 24; i++) {
            String index = ((i < 10) ? "0" : "") + i;
            assertEquals("PASSED", pom.getValue("properties/property" + index));
        }
    }

            want to analyze the set of transitive dependencies, in particular during early lifecycle phases where
            full dependency resolution might fail due to projects which haven't been built yet.
          </description>
        </field>
        <field>
          <name>dependencyCollection</name>
          <version>2.0.0+</version>

     * being passed into the session. This is also the potentially constrained set of projects by using --projects
     * on the command line.
     */
    private List<MavenProject> projects;

    /**
     * The full set of projects before any potential constraining by --projects. Useful in the case where you want to
     * build a smaller set of projects but perform other operations in the context of your reactor.
     */

import org.apache.maven.lifecycle.internal.builder.BuilderCommon;
import org.apache.maven.plugin.MojoExecution;
import org.apache.maven.project.MavenProject;

/**
 * <p>
 * Builds one or more lifecycles for a full module
 * </p>
 * <strong>NOTE:</strong> This class is not part of any public api and can be changed or deleted without prior notice.
 *
 * @since 3.0
 */
@Named
@Singleton
public class LifecycleModuleBuilder {

     * for finalName directly in the plugin configuration section. It is also useful to ensure that - for example - a
     * List-typed parameter which expects items of type Artifact doesn't get a List full of Strings.
     *
     * @return <code>true</code> if the user should not be allowed to configure the parameter directly
     */
    boolean readonly() default false;

    private Map<String, MavenProject> artifactIdProjectMap;

    public static Stream<Arguments> parameters() {
        return Stream.of(
                scenario("Full reactor in order")
                        .expectResult(
                                PARENT_MODULE,
                                MODULE_C,
                                MODULE_C_1,

      | to be made available to plugin authors. If we find people are getting fancy and want to take advantage of
      | Guice specifics we can expose that later. Really some testing needs to be done to see full hiding
      | of Guice has any impact on what we may categorize as a standard JSR-330 based Tesla/Maven plugin.

        <exportedPackage>com.google.inject.*</exportedPackage>

     * </ul>
     * Example filter expression: {@code "h(5);s;e(org.foo:bar:1)} will cause: ranges are filtered for "top 5" (instead
     * full range), snapshots are banned if root project is not a snapshot, and if range for {@code org.foo:bar} is
     * being processed, version 1 is omitted.
     *
     * @since 4.0.0
     */