[MNG-5102] Add support for POM mixins

Author: gnodet

api/maven-api-model/src/main/mdo/maven.mdo

@@ -113,6 +113,20 @@
           </association>
         </field>
 
+        <!-- ====================================================================== -->
+        <!-- Mixins                                                                 -->
+        <!-- ====================================================================== -->
+
+        <field xdoc.separator="blank">
+          <name>mixins</name>
+          <version>4.1.0+</version>
+          <description>Mixins...</description>
+          <association>
+            <type>Parent</type>
+            <multiplicity>*</multiplicity>
+          </association>
+        </field>
+
         <!-- ====================================================================== -->
         <!-- groupId/artifactId/Version/Packaging                                   -->
         <!-- ====================================================================== -->

maven-model-builder/src/main/java/org/apache/maven/model/building/DefaultModelBuilder.java

@@ -719,6 +719,27 @@ private void activateFileModel(
         }
     }
 
+    static class Lineage {
+        final Model model;
+        final List<Lineage> parents;
+
+        Lineage(Model model, List<Lineage> parents) {
+            this.model = model;
+            this.parents = parents;
+        }
+
+        List<Model> getAllModels() {
+            List<Model> models = new ArrayList<>();
+            doGetModels(models);
+            return models;
+        }
+
+        void doGetModels(List<Model> models) {
+            models.add(model);
+            parents.forEach(p -> p.doGetModels(models));
+        }
+    }
+
     @SuppressWarnings("checkstyle:methodlength")
     private Model readEffectiveModel(
             final ModelBuildingRequest request,
@@ -746,100 +767,119 @@ private Model readEffectiveModel(
             profileActivationContext.setUserProperties(profileProps);
         }
 
-        Collection<String> parentIds = new LinkedHashSet<>();
+        LinkedHashSet<String> parentIds = new LinkedHashSet<>();
+        Lineage lineage =
+                getLineage(request, result, problems, resultData, superData, profileActivationContext, parentIds);
 
-        List<Model> lineage = new ArrayList<>();
+        Model tmpModel = lineage.model;
+        for (Profile activeProfile : activeExternalProfiles) {
+            profileInjector.injectProfile(tmpModel, activeProfile, request, problems);
+        }
+        result.setEffectiveModel(tmpModel);
 
-        for (ModelData currentData = resultData; ; ) {
-            String modelId = currentData.getId();
-            result.addModelId(modelId);
+        problems.setSource(result.getRawModel());
+        checkPluginVersions(lineage, request, problems);
 
-            Model rawModel = currentData.getModel();
-            result.setRawModel(modelId, rawModel);
+        // inheritance assembly
+        Model resultModel = assembleInheritance(lineage, request, problems);
 
-            profileActivationContext.setProjectProperties(rawModel.getProperties());
-            problems.setSource(rawModel);
-            List<Profile> activePomProfiles =
-                    profileSelector.getActiveProfiles(rawModel.getProfiles(), profileActivationContext, problems);
-            result.setActivePomProfiles(modelId, activePomProfiles);
+        // consider caching inherited model
 
-            Model tmpModel = rawModel.clone();
+        problems.setSource(resultModel);
+        problems.setRootModel(resultModel);
 
-            problems.setSource(tmpModel);
+        // model interpolation
+        resultModel = interpolateModel(resultModel, request, problems);
 
-            // model normalization
-            tmpModel = new Model(modelNormalizer.mergeDuplicates(tmpModel.getDelegate(), request, problems));
+        // url normalization
+        modelUrlNormalizer.normalize(resultModel, request);
 
-            profileActivationContext.setProjectProperties(tmpModel.getProperties());
+        result.setEffectiveModel(resultModel);
 
-            Map<String, Activation> interpolatedActivations =
-                    getInterpolatedActivations(rawModel, profileActivationContext, problems);
-            injectProfileActivations(tmpModel, interpolatedActivations);
+        // Now the fully interpolated model is available: reconfigure the resolver
+        configureResolver(request.getModelResolver(), resultModel, problems, true);
 
-            // profile injection
-            for (Profile activeProfile : result.getActivePomProfiles(modelId)) {
-                profileInjector.injectProfile(tmpModel, activeProfile, request, problems);
-            }
+        return resultModel;
+    }
 
-            if (currentData == resultData) {
-                for (Profile activeProfile : activeExternalProfiles) {
-                    profileInjector.injectProfile(tmpModel, activeProfile, request, problems);
-                }
-                result.setEffectiveModel(tmpModel);
-            }
+    private Lineage getLineage(
+            ModelBuildingRequest request,
+            DefaultModelBuildingResult result,
+            DefaultModelProblemCollector problems,
+            ModelData resultData,
+            ModelData superData,
+            DefaultProfileActivationContext profileActivationContext,
+            LinkedHashSet<String> parentIds)
+            throws ModelBuildingException {
 
-            lineage.add(tmpModel);
+        ModelData currentData = resultData;
 
-            if (currentData == superData) {
-                break;
-            }
+        String modelId = currentData.getId();
+        result.addModelId(modelId);
 
-            configureResolver(request.getModelResolver(), tmpModel, problems);
+        Model rawModel = currentData.getModel();
+        result.setRawModel(modelId, rawModel);
 
-            ModelData parentData =
-                    readParent(currentData.getModel(), currentData.getSource(), request, result, problems);
+        profileActivationContext.setProjectProperties(rawModel.getProperties());
+        problems.setSource(rawModel);
+        List<Profile> activePomProfiles =
+                profileSelector.getActiveProfiles(rawModel.getProfiles(), profileActivationContext, problems);
+        result.setActivePomProfiles(modelId, activePomProfiles);
 
-            if (parentData == null) {
-                currentData = superData;
-            } else if (!parentIds.add(parentData.getId())) {
-                StringBuilder message = new StringBuilder("The parents form a cycle: ");
-                for (String parentId : parentIds) {
-                    message.append(parentId).append(" -> ");
-                }
-                message.append(parentData.getId());
+        Model tmpModel = rawModel.clone();
 
-                problems.add(new ModelProblemCollectorRequest(ModelProblem.Severity.FATAL, ModelProblem.Version.BASE)
-                        .setMessage(message.toString()));
+        problems.setSource(tmpModel);
 
-                throw problems.newModelBuildingException();
-            } else {
-                currentData = parentData;
-            }
-        }
+        // model normalization
+        tmpModel = new Model(modelNormalizer.mergeDuplicates(tmpModel.getDelegate(), request, problems));
 
-        problems.setSource(result.getRawModel());
-        checkPluginVersions(lineage, request, problems);
+        profileActivationContext.setProjectProperties(tmpModel.getProperties());
 
-        // inheritance assembly
-        Model resultModel = assembleInheritance(lineage, request, problems);
+        Map<String, Activation> interpolatedActivations =
+                getInterpolatedActivations(rawModel, profileActivationContext, problems);
+        injectProfileActivations(tmpModel, interpolatedActivations);
 
-        // consider caching inherited model
+        // profile injection
+        for (Profile activeProfile : result.getActivePomProfiles(modelId)) {
+            profileInjector.injectProfile(tmpModel, activeProfile, request, problems);
+        }
 
-        problems.setSource(resultModel);
-        problems.setRootModel(resultModel);
+        if (currentData == superData) {
+            return new Lineage(tmpModel, Collections.emptyList());
+        }
 
-        // model interpolation
-        resultModel = interpolateModel(resultModel, request, problems);
+        configureResolver(request.getModelResolver(), tmpModel, problems, false);
 
-        // url normalization
-        modelUrlNormalizer.normalize(resultModel, request);
+        List<Lineage> parents = new ArrayList<>();
 
-        result.setEffectiveModel(resultModel);
+        List<Parent> list = new ArrayList<>();
+        list.add(currentData.getModel().getParent());
+        list.addAll(currentData.getModel().getMixins());
+        for (Parent parent : list) {
 
-        // Now the fully interpolated model is available: reconfigure the resolver
-        configureResolver(request.getModelResolver(), resultModel, problems, true);
+            ModelData parentData =
+                    readParent(currentData.getModel(), parent, currentData.getSource(), request, result, problems);
+            if (parents.isEmpty() && parentData == null) {
+                parentData = superData;
+            }
+            LinkedHashSet<String> newParentIds = new LinkedHashSet<>(parentIds.size() + 1);
+            newParentIds.addAll(parentIds);
+            if (!newParentIds.add(parentData.getId())) {
+                StringBuilder message = new StringBuilder("The parents form a cycle: ");
+                for (String parentId : newParentIds) {
+                    message.append(parentId).append(" -> ");
+                }
+                message.append(parentData.getId());
+                problems.add(
+                        new ModelProblemCollectorRequest(Severity.FATAL, Version.BASE).setMessage(message.toString()));
 
-        return resultModel;
+                throw problems.newModelBuildingException();
+            }
+            parents.add(getLineage(
+                    request, result, problems, parentData, superData, profileActivationContext, newParentIds));
+        }
+
+        return new Lineage(tmpModel, parents);
     }
 
     private Map<String, Activation> getInterpolatedActivations(
@@ -1179,10 +1219,6 @@ private DefaultProfileActivationContext getProfileActivationContext(ModelBuildin
         return context;
     }
 
-    private void configureResolver(ModelResolver modelResolver, Model model, DefaultModelProblemCollector problems) {
-        configureResolver(modelResolver, model, problems, false);
-    }
-
     private void configureResolver(
             ModelResolver modelResolver,
             Model model,
@@ -1208,8 +1244,7 @@ private void configureResolver(
         }
     }
 
-    private void checkPluginVersions(
-            List<Model> lineage, ModelBuildingRequest request, ModelProblemCollector problems) {
+    private void checkPluginVersions(Lineage lineage, ModelBuildingRequest request, ModelProblemCollector problems) {
         if (request.getValidationLevel() < ModelBuildingRequest.VALIDATION_LEVEL_MAVEN_2_0) {
             return;
         }
@@ -1218,8 +1253,9 @@ private void checkPluginVersions(
         Map<String, String> versions = new HashMap<>();
         Map<String, String> managedVersions = new HashMap<>();
 
-        for (int i = lineage.size() - 1; i >= 0; i--) {
-            Model model = lineage.get(i);
+        List<Model> models = lineage.getAllModels();
+        Collections.reverse(models);
+        for (Model model : models) {
             Build build = model.getBuild();
             if (build != null) {
                 for (Plugin plugin : build.getPlugins()) {
@@ -1249,12 +1285,11 @@ private void checkPluginVersions(
         }
     }
 
-    private Model assembleInheritance(
-            List<Model> lineage, ModelBuildingRequest request, ModelProblemCollector problems) {
-        org.apache.maven.api.model.Model parent =
-                lineage.get(lineage.size() - 1).getDelegate();
-        for (int i = lineage.size() - 2; i >= 0; i--) {
-            Model child = lineage.get(i);
+    private Model assembleInheritance(Lineage lineage, ModelBuildingRequest request, ModelProblemCollector problems) {
+        List<Model> models = lineage.getAllModels();
+        org.apache.maven.api.model.Model parent = models.get(models.size() - 1).getDelegate();
+        for (int i = models.size() - 2; i >= 0; i--) {
+            Model child = models.get(i);
             parent = inheritanceAssembler.assembleModelInheritance(child.getDelegate(), parent, request, problems);
         }
         return new Model(parent);
@@ -1329,18 +1364,18 @@ private Model interpolateModel(Model model, ModelBuildingRequest request, ModelP
 
     private ModelData readParent(
             Model childModel,
+            Parent parent,
             Source childSource,
             ModelBuildingRequest request,
             ModelBuildingResult result,
             DefaultModelProblemCollector problems)
             throws ModelBuildingException {
         ModelData parentData = null;
 
-        Parent parent = childModel.getParent();
         if (parent != null) {
-            parentData = readParentLocally(childModel, childSource, request, result, problems);
+            parentData = readParentLocally(childModel, parent, childSource, request, result, problems);
             if (parentData == null) {
-                parentData = readParentExternally(childModel, request, result, problems);
+                parentData = readParentExternally(childModel, parent, request, result, problems);
             }
 
             Model parentModel = parentData.getModel();
@@ -1357,17 +1392,17 @@ private ModelData readParent(
 
     private ModelData readParentLocally(
             Model childModel,
+            Parent parent,
             Source childSource,
             ModelBuildingRequest request,
             ModelBuildingResult result,
             DefaultModelProblemCollector problems)
             throws ModelBuildingException {
-        final Parent parent = childModel.getParent();
         final ModelSource candidateSource;
         final Model candidateModel;
         final WorkspaceModelResolver resolver = request.getWorkspaceModelResolver();
         if (resolver == null) {
-            candidateSource = getParentPomFile(childModel, childSource);
+            candidateSource = getParentPomFile(parent, childSource);
 
             if (candidateSource == null) {
                 return null;
@@ -1480,12 +1515,12 @@ private boolean rawChildVersionReferencesParent(String rawChildModelVersion) {
                 || rawChildModelVersion.equals("${project.parent.version}");
     }
 
-    private ModelSource getParentPomFile(Model childModel, Source source) {
+    private ModelSource getParentPomFile(Parent parent, Source source) {
         if (!(source instanceof ModelSource2)) {
             return null;
         }
 
-        String parentPath = childModel.getParent().getRelativePath();
+        String parentPath = parent.getRelativePath();
 
         if (parentPath == null || parentPath.length() <= 0) {
             return null;
@@ -1496,14 +1531,13 @@ private ModelSource getParentPomFile(Model childModel, Source source) {
 
     private ModelData readParentExternally(
             Model childModel,
+            Parent parent,
             ModelBuildingRequest request,
             ModelBuildingResult result,
             DefaultModelProblemCollector problems)
             throws ModelBuildingException {
         problems.setSource(childModel);
 
-        Parent parent = childModel.getParent();
-
         String groupId = parent.getGroupId();
         String artifactId = parent.getArtifactId();
         String version = parent.getVersion();