src/main/java/org/apache/maven/plugin/resources/remote/ModelUtils.java

/*
 * 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.plugin.resources.remote;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import org.apache.maven.model.Dependency;
import org.apache.maven.model.Plugin;
import org.apache.maven.model.PluginContainer;
import org.apache.maven.model.PluginExecution;
import org.apache.maven.model.Repository;
import org.codehaus.plexus.util.xml.Xpp3Dom;

/** HELPER CLASS */
public final class ModelUtils {

    /**
     * This should be the resulting ordering of plugins after merging:
     * <p>
     * Given:
     * <pre>
     * parent: X -&gt; A -&gt; B -&gt; D -&gt; E
     * child: Y -&gt; A -&gt; C -&gt; D -&gt; F
     * </pre>
     * Result:
     * <pre>
     * X -&gt; Y -&gt; A -&gt; B -&gt; C -&gt; D -&gt; E -&gt; F
     * </pre>
     */
    public static void mergePluginLists(
            PluginContainer childContainer, PluginContainer parentContainer, boolean handleAsInheritance) {
        if ((childContainer == null) || (parentContainer == null)) {
            // nothing to do.
            return;
        }

        List<Plugin> parentPlugins = parentContainer.getPlugins();

        if ((parentPlugins != null) && !parentPlugins.isEmpty()) {
            parentPlugins = new ArrayList<>(parentPlugins);

            // If we're processing this merge as an inheritance, we have to build up a list of
            // plugins that were considered for inheritance.
            if (handleAsInheritance) {
                for (Iterator<Plugin> it = parentPlugins.iterator(); it.hasNext(); ) {
                    Plugin plugin = it.next();

                    String inherited = plugin.getInherited();

                    if ((inherited != null) && !Boolean.parseBoolean(inherited)) {
                        it.remove();
                    }
                }
            }

            List<Plugin> assembledPlugins = new ArrayList<>();

            Map<String, Plugin> childPlugins = childContainer.getPluginsAsMap();

            for (Plugin parentPlugin : parentPlugins) {
                String parentInherited = parentPlugin.getInherited();

                // only merge plugin definition from the parent if at least one
                // of these is true:
                // 1. we're not processing the plugins in an inheritance-based merge
                // 2. the parent's <inherited/> flag is not set
                // 3. the parent's <inherited/> flag is set to true
                if (!handleAsInheritance || (parentInherited == null) || Boolean.parseBoolean(parentInherited)) {
                    Plugin childPlugin = childPlugins.get(parentPlugin.getKey());

                    if ((childPlugin != null) && !assembledPlugins.contains(childPlugin)) {
                        Plugin assembledPlugin = childPlugin;

                        mergePluginDefinitions(childPlugin, parentPlugin, handleAsInheritance);

                        // fix for MNG-2221 (assembly cache was not being populated for later reference):
                        assembledPlugins.add(assembledPlugin);
                    }

                    // if we're processing this as an inheritance-based merge, and
                    // the parent's <inherited/> flag is not set, then we need to
                    // clear the inherited flag in the merge result.
                    if (handleAsInheritance && (parentInherited == null)) {
                        parentPlugin.unsetInheritanceApplied();
                    }
                }

                // very important to use the parentPlugins List, rather than parentContainer.getPlugins()
                // since this list is a local one, and may have been modified during processing.
                List<Plugin> results =
                        ModelUtils.orderAfterMerge(assembledPlugins, parentPlugins, childContainer.getPlugins());

                childContainer.setPlugins(results);

                childContainer.flushPluginMap();
            }
        }
    }

    public static List<Plugin> orderAfterMerge(
            List<Plugin> merged, List<Plugin> highPrioritySource, List<Plugin> lowPrioritySource) {
        List<Plugin> results = new ArrayList<>();

        if (!merged.isEmpty()) {
            results.addAll(merged);
        }

        List<Plugin> missingFromResults = new ArrayList<>();

        List<List<Plugin>> sources = new ArrayList<>();

        sources.add(highPrioritySource);
        sources.add(lowPrioritySource);

        for (List<Plugin> source : sources) {
            for (Plugin item : source) {
                if (results.contains(item)) {
                    if (!missingFromResults.isEmpty()) {
                        int idx = results.indexOf(item);

                        if (idx < 0) {
                            idx = 0;
                        }

                        results.addAll(idx, missingFromResults);

                        missingFromResults.clear();
                    }
                } else {
                    missingFromResults.add(item);
                }
            }

            if (!missingFromResults.isEmpty()) {
                results.addAll(missingFromResults);

                missingFromResults.clear();
            }
        }

        return results;
    }

    public static void mergePluginDefinitions(Plugin child, Plugin parent, boolean handleAsInheritance) {
        if ((child == null) || (parent == null)) {
            // nothing to do.
            return;
        }

        if (parent.isExtensions()) {
            child.setExtensions(true);
        }

        if ((child.getVersion() == null) && (parent.getVersion() != null)) {
            child.setVersion(parent.getVersion());
        }

        Xpp3Dom childConfiguration = (Xpp3Dom) child.getConfiguration();
        Xpp3Dom parentConfiguration = (Xpp3Dom) parent.getConfiguration();

        childConfiguration = Xpp3Dom.mergeXpp3Dom(childConfiguration, parentConfiguration);

        child.setConfiguration(childConfiguration);

        child.setDependencies(mergeDependencyList(child.getDependencies(), parent.getDependencies()));

        // from here to the end of the method is dealing with merging of the <executions/> section.
        String parentInherited = parent.getInherited();

        boolean parentIsInherited = (parentInherited == null) || Boolean.parseBoolean(parentInherited);

        List<PluginExecution> parentExecutions = parent.getExecutions();

        if ((parentExecutions != null) && !parentExecutions.isEmpty()) {
            List<PluginExecution> mergedExecutions = new ArrayList<>();

            Map<String, PluginExecution> assembledExecutions = new TreeMap<>();

            Map<String, PluginExecution> childExecutions = child.getExecutionsAsMap();

            for (PluginExecution parentExecution : parentExecutions) {
                String inherited = parentExecution.getInherited();

                boolean parentExecInherited =
                        parentIsInherited && ((inherited == null) || Boolean.parseBoolean(inherited));

                if (!handleAsInheritance || parentExecInherited) {
                    PluginExecution assembled = parentExecution;

                    PluginExecution childExecution = childExecutions.get(parentExecution.getId());

                    if (childExecution != null) {
                        mergePluginExecutionDefinitions(childExecution, parentExecution);

                        assembled = childExecution;
                    } else if (handleAsInheritance && (parentInherited == null)) {
                        parentExecution.unsetInheritanceApplied();
                    }

                    assembledExecutions.put(assembled.getId(), assembled);
                    mergedExecutions.add(assembled);
                }
            }

            for (PluginExecution childExecution : child.getExecutions()) {
                if (!assembledExecutions.containsKey(childExecution.getId())) {
                    mergedExecutions.add(childExecution);
                }
            }

            child.setExecutions(mergedExecutions);

            child.flushExecutionMap();
        }
    }

    private static void mergePluginExecutionDefinitions(PluginExecution child, PluginExecution parent) {
        if (child.getPhase() == null) {
            child.setPhase(parent.getPhase());
        }

        List<String> parentGoals = parent.getGoals();
        List<String> childGoals = child.getGoals();

        List<String> goals = new ArrayList<>();

        if ((childGoals != null) && !childGoals.isEmpty()) {
            goals.addAll(childGoals);
        }

        if (parentGoals != null) {
            for (String goal : parentGoals) {
                if (!goals.contains(goal)) {
                    goals.add(goal);
                }
            }
        }

        child.setGoals(goals);

        Xpp3Dom childConfiguration = (Xpp3Dom) child.getConfiguration();
        Xpp3Dom parentConfiguration = (Xpp3Dom) parent.getConfiguration();

        childConfiguration = Xpp3Dom.mergeXpp3Dom(childConfiguration, parentConfiguration);

        child.setConfiguration(childConfiguration);
    }

    public static List<Repository> mergeRepositoryLists(List<Repository> dominant, List<Repository> recessive) {

        List<Repository> repositories = new ArrayList<>(dominant);

        for (Repository repository : recessive) {
            if (!repositories.contains(repository)) {
                repositories.add(repository);
            }
        }

        return repositories;
    }

    public static void mergeFilterLists(List<String> childFilters, List<String> parentFilters) {
        for (String f : parentFilters) {
            if (!childFilters.contains(f)) {
                childFilters.add(f);
            }
        }
    }

    private static List<Dependency> mergeDependencyList(List<Dependency> child, List<Dependency> parent) {
        Map<String, Dependency> depsMap = new LinkedHashMap<>();

        if (parent != null) {
            for (Dependency dependency : parent) {
                depsMap.put(dependency.getManagementKey(), dependency);
            }
        }

        if (child != null) {
            for (Dependency dependency : child) {
                depsMap.put(dependency.getManagementKey(), dependency);
            }
        }

        return new ArrayList<>(depsMap.values());
    }
}