@Override
    public InstallRequest remapInstallArtifacts(RepositorySystemSession session, InstallRequest request) {
        if (consumerPomPresent(request.getArtifacts())) {
            // For install, we always include build POMs as they may be needed locally
            request.setArtifacts(replacePom(request.getArtifacts(), true));
        }
        return request;
    }

    @Override

 -----
 The Maven Team
 -----

Inheritance in Maven

 In order the understand how inheritance works in Maven there are a few notions that you must be familiar with:

 * The maven super model

 * how parent poms are processed

 * the order in which elements in the POM are overridden

 * minimum element-set for a valid project pom


Maven super model

 */
@Deprecated(since = "4.0.0")
public interface ModelBuildingRequest {

    /**
     * Denotes minimal validation of POMs. This validation level is meant for processing of POMs from repositories
     * during metadata retrieval.
     */
    int VALIDATION_LEVEL_MINIMAL = 0;

    /**

 maven 1.x and 2.x is that all project parameterization occurs in the POM and not from properties
 files.

 For many of the more advanced features in Maven2 it is critical that POMs be available in the local repository.
 Features like transitive dependencies and the new parent specification mechanism. The problem we run into is

            int result = applyGoal.execute(context);

            // Verify success
            assertEquals(0, result, "Apply should succeed for multi-module project");

            // Verify both POMs exist (they may or may not be modified depending on strategies)
            assertTrue(Files.exists(parentPom), "Parent POM should exist");
            assertTrue(Files.exists(modulePom), "Module POM should exist");
        }

     */
    boolean isAllowStubModel();

    /**
     * Determines whether the project builder should recursively build parent/child projects.
     * When true, the builder will process parent POMs and child modules as needed.
     *
     * @return true if the build should be recursive, false otherwise
     */
    boolean isRecursive();

    /**

import org.apache.maven.settings.Proxy;
import org.apache.maven.settings.Server;

/**
 * A resolution request allows you to either use an existing MavenProject, or a coordinate (gid:aid:version)
 * to process a POMs dependencies.
 *
 */
@Deprecated
public class ArtifactResolutionRequest implements RepositoryRequest {
    private static final String LS = System.lineSeparator();

    private Artifact artifact;

 * they could be resolved from a local repository - I think we need a simple dependency model here
 * that is more mercury related and not Maven related i.e. no POMs - workspace resolver - we need
 * tools to pre-populate this repository
 *
 * h3. create an isolated classloader
 *
 * h3. lookup the plugin with a configuration
 *
 * h3. execute the plugin
 *

                    // Add plugin management based on effective model analysis
                    // Note: pluginsNeedingManagement only contains entries for POMs that should receive plugin
                    // management
                    // (i.e., the "last local parent" for each plugin that needs management)

             * sake of backward-compat with 2.x (MNG-5000). In general, it is wrong to
             * base URL inheritance on the module directory names as this information is unavailable for POMs in the
             * repository. In other words, modules where artifactId != moduleDirName will see different effective URLs
             * depending on how the model was constructed (from filesystem or from repository).