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 aabb958b67 Merge combine.id and combine.keys matches in place (#14032)
aabb958b67 is described below

commit aabb958b67e0d50b6248770a5b045723e69cdf4f
Author: Sharang Gupta <[email protected]>
AuthorDate: Wed Nov 18 07:28:34 2026 +0000

    Merge combine.id and combine.keys matches in place (#14032)
    
    * Merge combine.id and combine.keys matches in place
    
    When a recessive child matched a dominant child through combine.id or
    combine.keys, XmlService merged it into the next dominant sibling with
    the same element name rather than into the matching one, so inherited
    content ended up in the wrong element. Xpp3DomUtils, which this logic
    was ported from, merges into the match. The merged node also replaced
    the wrong sibling once recessive children had been added before it,
    and a second recessive child with the same id was dropped.
    
    * Guard indexOfSame result and add test for unmatched combine.id append
    
    ---------
    
    Co-authored-by: Guillaume Nodet <[email protected]>
---
 .../maven/internal/xml/DefaultXmlService.java      | 142 +++++++++++++--------
 .../apache/maven/internal/xml/XmlNodeImplTest.java | 123 ++++++++++++++++++
 2 files changed, 213 insertions(+), 52 deletions(-)

diff --git 
a/impl/maven-xml/src/main/java/org/apache/maven/internal/xml/DefaultXmlService.java
 
b/impl/maven-xml/src/main/java/org/apache/maven/internal/xml/DefaultXmlService.java
index 90c31ed7bb..c8a9916f53 100644
--- 
a/impl/maven-xml/src/main/java/org/apache/maven/internal/xml/DefaultXmlService.java
+++ 
b/impl/maven-xml/src/main/java/org/apache/maven/internal/xml/DefaultXmlService.java
@@ -28,13 +28,14 @@
 import java.io.Reader;
 import java.io.Writer;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.IdentityHashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -287,8 +288,10 @@ private static void writeAttributes(
      *     </ol></li>
      *   <li> Iterate through the recessive children, and:
      *     <ol type="i">
-     *     <li> if mergeChildren == true and there is a corresponding dominant 
child (matched by element name),
-     *          merge the two.</li>
+     *     <li> if there is a dominant child with the same 'combine.id' 
attribute or, when the recessive node has a
+     *          'combine.keys' attribute, with the same values for the 
attributes it lists, merge the two.</li>
+     *     <li> otherwise, if mergeChildren == true and there is a 
corresponding dominant child (matched by element
+     *          name), merge the two.</li>
      *     <li> otherwise, add the recessive child as a new child on the 
dominant root node.</li>
      *     </ol></li>
      *   </ol></li>
@@ -340,6 +343,27 @@ public XmlNode doMerge(XmlNode dominant, XmlNode 
recessive, Boolean childMergeOv
                     }
                 }
 
+                String keysValue = 
recessive.attribute(KEYS_COMBINATION_MODE_ATTRIBUTE);
+                String[] keys = isEmpty(keysValue) ? null : 
keysValue.split(",");
+
+                // the dominant children matching a recessive child by 
combine.id or combine.keys
+                Map<XmlNode, XmlNode> matches = new IdentityHashMap<>();
+                for (XmlNode recessiveChild : recessive.children()) {
+                    String idValue = 
recessiveChild.attribute(ID_COMBINATION_MODE_ATTRIBUTE);
+                    XmlNode match = null;
+                    if (!isEmpty(idValue)) {
+                        match = findNodeById(dominant.children(), idValue);
+                    } else if (keys != null) {
+                        match = findNodeByKeys(dominant.children(), 
recessiveChild, keys);
+                    }
+                    if (match != null) {
+                        matches.put(recessiveChild, match);
+                    }
+                }
+                Set<XmlNode> matchedChildren = Collections.newSetFromMap(new 
IdentityHashMap<>());
+                matchedChildren.addAll(matches.values());
+
+                // the other dominant children are merged in order with the 
recessive children of the same name
                 Map<String, Iterator<XmlNode>> commonChildren = new 
HashMap<>();
                 Set<String> names =
                         
recessive.children().stream().map(XmlNode::name).collect(Collectors.toSet());
@@ -348,79 +372,84 @@ public XmlNode doMerge(XmlNode dominant, XmlNode 
recessive, Boolean childMergeOv
                             .filter(n -> n.name().equals(name))
                             .toList();
                     if (!dominantChildren.isEmpty()) {
-                        commonChildren.put(name, dominantChildren.iterator());
+                        commonChildren.put(
+                                name,
+                                dominantChildren.stream()
+                                        .filter(n -> 
!matchedChildren.contains(n))
+                                        .iterator());
                     }
                 }
 
-                String keysValue = 
recessive.attribute(KEYS_COMBINATION_MODE_ATTRIBUTE);
+                // the dominant children already merged with a recessive 
child, and the result of that merge
+                Map<XmlNode, XmlNode> mergedChildren = new IdentityHashMap<>();
 
                 int recessiveChildIndex = 0;
                 for (XmlNode recessiveChild : recessive.children()) {
                     String idValue = 
recessiveChild.attribute(ID_COMBINATION_MODE_ATTRIBUTE);
 
-                    XmlNode childDom = null;
-                    if (!isEmpty(idValue)) {
-                        for (XmlNode dominantChild : dominant.children()) {
-                            if 
(idValue.equals(dominantChild.attribute(ID_COMBINATION_MODE_ATTRIBUTE))) {
-                                childDom = dominantChild;
-                                // we have a match, so don't append but merge
-                                mergeChildren = true;
-                            }
-                        }
-                    } else if (!isEmpty(keysValue)) {
-                        String[] keys = keysValue.split(",");
-                        Map<String, Optional<String>> recessiveKeyValues = 
Stream.of(keys)
-                                .collect(Collectors.toMap(
-                                        k -> k, k -> 
Optional.ofNullable(recessiveChild.attribute(k))));
-
-                        for (XmlNode dominantChild : dominant.children()) {
-                            Map<String, Optional<String>> dominantKeyValues = 
Stream.of(keys)
-                                    .collect(Collectors.toMap(
-                                            k -> k, k -> 
Optional.ofNullable(dominantChild.attribute(k))));
-
-                            if (recessiveKeyValues.equals(dominantKeyValues)) {
-                                childDom = dominantChild;
-                                // we have a match, so don't append but merge
-                                mergeChildren = true;
-                            }
+                    XmlNode childDom;
+                    boolean matched = false;
+                    if (!isEmpty(idValue) || keys != null) {
+                        childDom = matches.get(recessiveChild);
+                        if (childDom != null) {
+                            matched = true;
+                            // we have a match, so don't append but merge
+                            mergeChildren = true;
                         }
                     } else {
                         childDom = dominant.child(recessiveChild.name());
                     }
 
                     if (mergeChildren && childDom != null) {
-                        String name = recessiveChild.name();
-                        Iterator<XmlNode> it = commonChildren.computeIfAbsent(
-                                name,
-                                n1 -> Stream.of(dominant.children().stream()
-                                                .filter(n2 -> 
n2.name().equals(n1))
-                                                .collect(Collectors.toList()))
-                                        .filter(l -> !l.isEmpty())
-                                        .findFirst()
-                                        .map(List::iterator)
-                                        .orElse(null));
-                        if (it == null) {
-                            if (children == null) {
-                                children = new 
ArrayList<>(dominant.children());
+                        XmlNode dominantChild = null;
+                        if (matched) {
+                            // merge with the matching child, wherever it is 
among its siblings
+                            dominantChild = childDom;
+                        } else {
+                            String name = recessiveChild.name();
+                            Iterator<XmlNode> it = 
commonChildren.computeIfAbsent(
+                                    name,
+                                    n1 -> 
Stream.of(dominant.children().stream()
+                                                    .filter(n2 -> 
n2.name().equals(n1))
+                                                    
.collect(Collectors.toList()))
+                                            .filter(l -> !l.isEmpty())
+                                            .findFirst()
+                                            .map(List::iterator)
+                                            .orElse(null));
+                            if (it == null) {
+                                if (children == null) {
+                                    children = new 
ArrayList<>(dominant.children());
+                                }
+                                children.add(recessiveChild);
+                            } else if (it.hasNext()) {
+                                dominantChild = it.next();
                             }
-                            children.add(recessiveChild);
-                        } else if (it.hasNext()) {
-                            XmlNode dominantChild = it.next();
+                        }
+                        if (dominantChild != null) {
+                            // several recessive children can match the same 
dominant child
+                            XmlNode current = 
mergedChildren.getOrDefault(dominantChild, dominantChild);
 
-                            String dominantChildCombinationMode = 
getSelfCombinationMode(dominantChild);
+                            String dominantChildCombinationMode = 
getSelfCombinationMode(current);
                             if 
(SELF_COMBINATION_REMOVE.equals(dominantChildCombinationMode)) {
                                 if (children == null) {
                                     children = new 
ArrayList<>(dominant.children());
                                 }
-                                children.remove(dominantChild);
+                                int idx = indexOfSame(children, current);
+                                if (idx >= 0) {
+                                    children.remove(idx);
+                                }
                             } else {
-                                int idx = 
dominant.children().indexOf(dominantChild);
-                                XmlNode merged = merge(dominantChild, 
recessiveChild, childMergeOverride);
-                                if (merged != dominantChild) {
+                                XmlNode merged = merge(current, 
recessiveChild, childMergeOverride);
+                                if (merged != current) {
                                     if (children == null) {
                                         children = new 
ArrayList<>(dominant.children());
                                     }
-                                    children.set(idx, merged);
+                                    // recessive children may have been added 
before the dominant child
+                                    int mergeIdx = indexOfSame(children, 
current);
+                                    if (mergeIdx >= 0) {
+                                        children.set(mergeIdx, merged);
+                                        mergedChildren.put(dominantChild, 
merged);
+                                    }
                                 }
                             }
                         }
@@ -465,6 +494,15 @@ private static boolean isEmpty(String str) {
         return str == null || str.isEmpty();
     }
 
+    private static int indexOfSame(List<XmlNode> nodes, XmlNode node) {
+        for (int i = 0; i < nodes.size(); i++) {
+            if (nodes.get(i) == node) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
     private static String getSelfCombinationMode(XmlNode node) {
         String value = node.attribute(SELF_COMBINATION_MODE_ATTRIBUTE);
         return !isEmpty(value) ? value : DEFAULT_SELF_COMBINATION_MODE;
diff --git 
a/impl/maven-xml/src/test/java/org/apache/maven/internal/xml/XmlNodeImplTest.java
 
b/impl/maven-xml/src/test/java/org/apache/maven/internal/xml/XmlNodeImplTest.java
index 4f55b81bbb..eff381998a 100644
--- 
a/impl/maven-xml/src/test/java/org/apache/maven/internal/xml/XmlNodeImplTest.java
+++ 
b/impl/maven-xml/src/test/java/org/apache/maven/internal/xml/XmlNodeImplTest.java
@@ -284,6 +284,129 @@ void testCombineKeys() throws Exception {
         assertEquals("right", p2.child("value").inputLocation());
     }
 
+    @Test
+    void testCombineIdMergesMatchingElement() throws Exception {
+        String lhs = "<props>" + "<property 
combine.id='A'><name>A</name></property>"
+                + "<property combine.id='B'><name>B</name></property>" + 
"</props>";
+
+        String rhs = "<props>" + "<property 
combine.id='B'><value>RHS</value></property>" + "</props>";
+
+        assertRecessiveValueIsMergedIntoSecondProperty(lhs, rhs);
+    }
+
+    @Test
+    void testCombineKeysMergesMatchingElement() throws Exception {
+        String lhs = "<props combine.keys='key'>" + "<property 
key='A'><name>A</name></property>"
+                + "<property key='B'><name>B</name></property>" + "</props>";
+
+        String rhs = "<props combine.keys='key'>" + "<property 
key='B'><value>RHS</value></property>" + "</props>";
+
+        assertRecessiveValueIsMergedIntoSecondProperty(lhs, rhs);
+    }
+
+    @Test
+    void testCombineIdMergesMatchingElementAfterAppendedSibling() throws 
Exception {
+        String lhs =
+                "<props combine.children='append'>" + "<property 
combine.id='A'><name>A</name></property>" + "</props>";
+
+        String rhs = "<props>" + "<property 
combine.id='X'><name>X</name></property>"
+                + "<property combine.id='A'><value>RHS</value></property>" + 
"</props>";
+
+        XmlNode leftDom = XmlService.read(new StringReader(lhs), new 
FixedInputLocationBuilder("left"));
+        XmlNode rightDom = XmlService.read(new StringReader(rhs), new 
FixedInputLocationBuilder("right"));
+
+        XmlNode mergeResult = XmlService.merge(leftDom, rightDom);
+        assertEquals(2, getChildren(mergeResult, "property").size());
+
+        XmlNode p0 = getNthChild(mergeResult, "property", 0);
+        assertEquals("X", p0.child("name").value());
+        assertEquals("right", p0.child("name").inputLocation());
+
+        XmlNode p1 = getNthChild(mergeResult, "property", 1);
+        assertEquals("A", p1.child("name").value());
+        assertEquals("RHS", p1.child("value").value());
+    }
+
+    @Test
+    void testCombineIdLeavesOtherElementsMergedInOrder() throws Exception {
+        String lhs = "<props>" + "<property 
combine.id='A'><name>A</name></property>"
+                + "<property><name>B</name></property>" + "</props>";
+
+        String rhs = "<props>" + "<property 
combine.id='A'><other>RHS-A</other></property>"
+                + "<property><value>RHS</value></property>" + "</props>";
+
+        XmlNode leftDom = XmlService.read(new StringReader(lhs), new 
FixedInputLocationBuilder("left"));
+        XmlNode rightDom = XmlService.read(new StringReader(rhs), new 
FixedInputLocationBuilder("right"));
+
+        XmlNode mergeResult = XmlService.merge(leftDom, rightDom, true);
+        assertEquals(2, getChildren(mergeResult, "property").size());
+
+        XmlNode p0 = getNthChild(mergeResult, "property", 0);
+        assertEquals("A", p0.child("name").value());
+        assertEquals("RHS-A", p0.child("other").value());
+        assertNull(p0.child("value"));
+
+        XmlNode p1 = getNthChild(mergeResult, "property", 1);
+        assertEquals("B", p1.child("name").value());
+        assertEquals("RHS", p1.child("value").value());
+    }
+
+    @Test
+    void testCombineIdMergesEveryElementWithTheSameId() throws Exception {
+        String lhs = "<props>" + "<property 
combine.id='A'><name>A</name></property>" + "</props>";
+
+        String rhs = "<props>" + "<property 
combine.id='A'><value>RHS</value></property>"
+                + "<property combine.id='A'><other>RHS</other></property>" + 
"</props>";
+
+        XmlNode leftDom = XmlService.read(new StringReader(lhs), new 
FixedInputLocationBuilder("left"));
+        XmlNode rightDom = XmlService.read(new StringReader(rhs), new 
FixedInputLocationBuilder("right"));
+
+        XmlNode mergeResult = XmlService.merge(leftDom, rightDom, true);
+        assertEquals(1, getChildren(mergeResult, "property").size());
+
+        XmlNode p0 = getNthChild(mergeResult, "property", 0);
+        assertEquals("A", p0.child("name").value());
+        assertEquals("RHS", p0.child("value").value());
+        assertEquals("RHS", p0.child("other").value());
+    }
+
+    @Test
+    void testCombineIdAppendsWhenNoDominantMatchExists() throws Exception {
+        String lhs = "<props>" + "<property 
combine.id='A'><name>A</name></property>" + "</props>";
+
+        String rhs = "<props>" + "<property 
combine.id='NEW'><name>NEW</name></property>" + "</props>";
+
+        XmlNode leftDom = XmlService.read(new StringReader(lhs), new 
FixedInputLocationBuilder("left"));
+        XmlNode rightDom = XmlService.read(new StringReader(rhs), new 
FixedInputLocationBuilder("right"));
+
+        XmlNode mergeResult = XmlService.merge(leftDom, rightDom, true);
+        assertEquals(2, getChildren(mergeResult, "property").size());
+
+        XmlNode p0 = getNthChild(mergeResult, "property", 0);
+        assertEquals("A", p0.child("name").value());
+
+        XmlNode p1 = getNthChild(mergeResult, "property", 1);
+        assertEquals("NEW", p1.child("name").value());
+        assertEquals("right", p1.child("name").inputLocation());
+    }
+
+    private static void assertRecessiveValueIsMergedIntoSecondProperty(String 
lhs, String rhs) throws Exception {
+        XmlNode leftDom = XmlService.read(new StringReader(lhs), new 
FixedInputLocationBuilder("left"));
+        XmlNode rightDom = XmlService.read(new StringReader(rhs), new 
FixedInputLocationBuilder("right"));
+
+        XmlNode mergeResult = XmlService.merge(leftDom, rightDom, true);
+        assertEquals(2, getChildren(mergeResult, "property").size());
+
+        XmlNode p0 = getNthChild(mergeResult, "property", 0);
+        assertEquals("A", p0.child("name").value());
+        assertNull(p0.child("value"));
+
+        XmlNode p1 = getNthChild(mergeResult, "property", 1);
+        assertEquals("B", p1.child("name").value());
+        assertEquals("RHS", p1.child("value").value());
+        assertEquals("right", p1.child("value").inputLocation());
+    }
+
     @Test
     void testPreserveDominantBlankValue() throws XMLStreamException, 
IOException {
         String lhs = "<parameter xml:space=\"preserve\"> </parameter>";

Reply via email to