You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by gn...@apache.org on 2026/05/19 15:20:16 UTC
(maven) branch backport/maven-4.0.x/pr-11823 created (now eab5050c8d)
This is an automated email from the ASF dual-hosted git repository.
gnodet pushed a change to branch backport/maven-4.0.x/pr-11823
in repository https://gitbox.apache.org/repos/asf/maven.git
at eab5050c8d Fix consumer POM serialization of prefixed XML attributes (fixes #11760)
This branch includes the following new commits:
new eab5050c8d Fix consumer POM serialization of prefixed XML attributes (fixes #11760)
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
(maven) 01/01: Fix consumer POM serialization of prefixed XML attributes (fixes #11760)
Posted by gn...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
gnodet pushed a commit to branch backport/maven-4.0.x/pr-11823
in repository https://gitbox.apache.org/repos/asf/maven.git
commit eab5050c8dfd17ccdd9fcd934ad65e7601451eae
Author: Guillaume Nodet <gn...@gmail.com>
AuthorDate: Tue May 19 17:15:59 2026 +0200
Fix consumer POM serialization of prefixed XML attributes (fixes #11760)
During consumer POM transformation, namespace declarations like xmlns:mvn on
<project> are lost (not part of the Maven model), but prefixed attributes like
mvn:combine.children on XmlNode configuration trees survive, producing invalid
XML with undeclared namespace prefixes.
Fix by adding namespace context tracking to XmlNode: the parser now accumulates
namespace declarations and propagates them to child nodes. The StAX and XPP3
writers resolve prefixed attributes against local declarations first, then the
inherited namespace context, auto-declaring namespaces as needed. Orphaned
prefixes (no declaration, no context) are stripped as a last resort to ensure
valid XML output.
Changes:
- Add XmlNode.namespaces() returning inherited prefix-to-URI bindings
- Accumulate and propagate namespace context during parsing in DefaultXmlService
- Fix writer-stax.vm and writer.vm to resolve and declare namespaces properly
- Preserve dominant node's namespace context during merge
- Add 28 tests covering parsing, writing, merging, and consumer POM simulation
---
.../java/org/apache/maven/api/xml/XmlNode.java | 38 +-
.../maven/internal/xml/DefaultXmlService.java | 141 +++-
.../apache/maven/internal/xml/XmlNodeImplTest.java | 799 +++++++++++++++++++++
src/mdo/writer-stax.vm | 59 +-
src/mdo/writer.vm | 54 +-
5 files changed, 1050 insertions(+), 41 deletions(-)
diff --git a/api/maven-api-xml/src/main/java/org/apache/maven/api/xml/XmlNode.java b/api/maven-api-xml/src/main/java/org/apache/maven/api/xml/XmlNode.java
index 7cf78c9cc1..7e9004395a 100644
--- a/api/maven-api-xml/src/main/java/org/apache/maven/api/xml/XmlNode.java
+++ b/api/maven-api-xml/src/main/java/org/apache/maven/api/xml/XmlNode.java
@@ -155,6 +155,24 @@ public interface XmlNode {
@Nullable
String attribute(@Nonnull String name);
+ /**
+ * Returns the namespace context for this node — a map of namespace prefix to URI
+ * for all namespace bindings in scope, including those declared on this element
+ * and those inherited from ancestor elements.
+ * <p>
+ * This is used by the write side to properly resolve prefixed attributes.
+ * For example, if an attribute {@code mvn:combine.children} exists on a child element
+ * but {@code xmlns:mvn} was declared on the root element, this map will contain
+ * the {@code mvn → http://maven.apache.org/POM/4.0.0} binding.
+ *
+ * @return map of namespace prefix to URI, never {@code null}
+ * @since 4.1.0
+ */
+ @Nonnull
+ default Map<String, String> namespaces() {
+ return Map.of();
+ }
+
/**
* Returns an immutable list of all child nodes.
*
@@ -354,6 +372,7 @@ class Builder {
private String namespaceUri;
private String prefix;
private Map<String, String> attributes;
+ private Map<String, String> namespaces;
private List<XmlNode> children;
private Object inputLocation;
@@ -417,6 +436,21 @@ public Builder attributes(Map<String, String> attributes) {
return this;
}
+ /**
+ * Sets the namespace context for this node.
+ * <p>
+ * This map contains all namespace prefix to URI bindings in scope,
+ * including inherited ones from ancestor elements.
+ *
+ * @param namespaces the map of namespace prefix to URI
+ * @return this builder instance
+ * @since 4.1.0
+ */
+ public Builder namespaces(Map<String, String> namespaces) {
+ this.namespaces = namespaces;
+ return this;
+ }
+
/**
* Sets the child nodes of the XML node.
* <p>
@@ -450,7 +484,7 @@ public Builder inputLocation(Object inputLocation) {
* @throws NullPointerException if name has not been set
*/
public XmlNode build() {
- return new Impl(prefix, namespaceUri, name, value, attributes, children, inputLocation);
+ return new Impl(prefix, namespaceUri, name, value, attributes, namespaces, children, inputLocation);
}
private record Impl(
@@ -459,6 +493,7 @@ private record Impl(
@Nonnull String name,
String value,
@Nonnull Map<String, String> attributes,
+ @Nonnull Map<String, String> namespaces,
@Nonnull List<XmlNode> children,
Object inputLocation)
implements XmlNode, Serializable {
@@ -469,6 +504,7 @@ private record Impl(
namespaceUri = namespaceUri == null ? "" : namespaceUri;
name = Objects.requireNonNull(name);
attributes = ImmutableCollections.copy(attributes);
+ namespaces = ImmutableCollections.copy(namespaces);
children = ImmutableCollections.copy(children);
}
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 bb99243ccf..0904ebadb4 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
@@ -30,6 +30,7 @@
import java.io.Writer;
import java.util.ArrayList;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
@@ -68,18 +69,23 @@ public XmlNode doRead(Reader reader, @Nullable XmlService.InputLocationBuilder l
@Override
public XmlNode doRead(XMLStreamReader parser, @Nullable XmlService.InputLocationBuilder locationBuilder)
throws XMLStreamException {
- return doBuild(parser, DEFAULT_TRIM, locationBuilder);
+ return doBuild(parser, DEFAULT_TRIM, locationBuilder, new HashMap<>());
}
- private XmlNode doBuild(XMLStreamReader parser, boolean trim, InputLocationBuilder locationBuilder)
+ private XmlNode doBuild(
+ XMLStreamReader parser,
+ boolean trim,
+ InputLocationBuilder locationBuilder,
+ Map<String, String> parentNamespaces)
throws XMLStreamException {
boolean spacePreserve = false;
- String lPrefix = null;
- String lNamespaceUri = null;
- String lName = null;
- String lValue = null;
+ String elementPrefix = null;
+ String elementNamespaceUri = null;
+ String elementName = null;
+ String elementValue = null;
Object location = null;
Map<String, String> attrs = null;
+ Map<String, String> nsContext = null;
List<XmlNode> children = null;
int eventType = parser.getEventType();
int lastStartTag = -1;
@@ -87,54 +93,67 @@ private XmlNode doBuild(XMLStreamReader parser, boolean trim, InputLocationBuild
if (eventType == XMLStreamReader.START_ELEMENT) {
lastStartTag = parser.getLocation().getLineNumber() * 1000
+ parser.getLocation().getColumnNumber();
- if (lName == null) {
+ // The first START_ELEMENT we encounter is "this" element;
+ // subsequent START_ELEMENTs are children, handled in the else branch.
+ if (elementName == null) {
int namespacesSize = parser.getNamespaceCount();
- lPrefix = parser.getPrefix();
- lNamespaceUri = parser.getNamespaceURI();
- lName = parser.getLocalName();
+ elementPrefix = parser.getPrefix();
+ elementNamespaceUri = parser.getNamespaceURI();
+ elementName = parser.getLocalName();
location = locationBuilder != null ? locationBuilder.toInputLocation(parser) : null;
+ // Build the namespace context: start with inherited, add local declarations.
+ // The default namespace (empty prefix) is excluded because per the XML namespace
+ // spec (Section 6.2), default namespace declarations do NOT apply to attributes.
+ nsContext = new HashMap<>(parentNamespaces);
int attributesSize = parser.getAttributeCount();
if (attributesSize > 0 || namespacesSize > 0) {
attrs = new HashMap<>();
for (int i = 0; i < namespacesSize; i++) {
String nsPrefix = parser.getNamespacePrefix(i);
String nsUri = parser.getNamespaceURI(i);
- attrs.put(nsPrefix != null && !nsPrefix.isEmpty() ? "xmlns:" + nsPrefix : "xmlns", nsUri);
+ if (nsPrefix != null && !nsPrefix.isEmpty()) {
+ nsContext.put(nsPrefix, nsUri);
+ attrs.put("xmlns:" + nsPrefix, nsUri);
+ } else {
+ attrs.put("xmlns", nsUri);
+ }
}
for (int i = 0; i < attributesSize; i++) {
- String aName = parser.getAttributeLocalName(i);
- String aValue = parser.getAttributeValue(i);
- String aPrefix = parser.getAttributePrefix(i);
- if (aPrefix != null && !aPrefix.isEmpty()) {
- aName = aPrefix + ":" + aName;
+ String attrName = parser.getAttributeLocalName(i);
+ String attrValue = parser.getAttributeValue(i);
+ String attrPrefix = parser.getAttributePrefix(i);
+ if (attrPrefix != null && !attrPrefix.isEmpty()) {
+ attrName = attrPrefix + ":" + attrName;
}
- attrs.put(aName, aValue);
- spacePreserve = spacePreserve || ("xml:space".equals(aName) && "preserve".equals(aValue));
+ attrs.put(attrName, attrValue);
+ spacePreserve =
+ spacePreserve || ("xml:space".equals(attrName) && "preserve".equals(attrValue));
}
}
} else {
if (children == null) {
children = new ArrayList<>();
}
- XmlNode child = doBuild(parser, trim, locationBuilder);
+ XmlNode child = doBuild(parser, trim, locationBuilder, nsContext);
children.add(child);
}
} else if (eventType == XMLStreamReader.CHARACTERS || eventType == XMLStreamReader.CDATA) {
String text = parser.getText();
- lValue = lValue != null ? lValue + text : text;
+ elementValue = elementValue != null ? elementValue + text : text;
} else if (eventType == XMLStreamReader.END_ELEMENT) {
boolean emptyTag = lastStartTag
== parser.getLocation().getLineNumber() * 1000
+ parser.getLocation().getColumnNumber();
- if (lValue != null && trim && !spacePreserve) {
- lValue = lValue.trim();
+ if (elementValue != null && trim && !spacePreserve) {
+ elementValue = elementValue.trim();
}
return XmlNode.newBuilder()
- .prefix(lPrefix)
- .namespaceUri(lNamespaceUri)
- .name(lName)
- .value(children == null ? (lValue != null ? lValue : emptyTag ? null : "") : null)
+ .prefix(elementPrefix)
+ .namespaceUri(elementNamespaceUri)
+ .name(elementName)
+ .value(children == null ? (elementValue != null ? elementValue : emptyTag ? null : "") : null)
.attributes(attrs)
+ .namespaces(nsContext)
.children(children)
.inputLocation(location)
.build();
@@ -162,9 +181,7 @@ public void doWrite(XmlNode node, Writer writer) throws IOException {
private void writeNode(XMLStreamWriter xmlWriter, XmlNode node) throws XMLStreamException {
xmlWriter.writeStartElement(node.prefix(), node.name(), node.namespaceUri());
- for (Map.Entry<String, String> attr : node.attributes().entrySet()) {
- xmlWriter.writeAttribute(attr.getKey(), attr.getValue());
- }
+ writeAttributes(xmlWriter, node.attributes(), node.namespaces());
for (XmlNode child : node.children()) {
writeNode(xmlWriter, child);
@@ -178,6 +195,71 @@ private void writeNode(XMLStreamWriter xmlWriter, XmlNode node) throws XMLStream
xmlWriter.writeEndElement();
}
+ /**
+ * Writes XmlNode attributes, properly handling namespace declarations
+ * ({@code xmlns:prefix}) and prefixed attributes ({@code prefix:localName}).
+ * The namespace context is used to resolve prefixes when the {@code xmlns:}
+ * declaration is not present in the attribute map (e.g., it was declared on
+ * an ancestor element).
+ *
+ * @param xmlWriter the StAX writer
+ * @param attributes the attribute map (may contain xmlns: entries)
+ * @param namespaces the namespace context (prefix → URI) for resolving prefixed attributes
+ */
+ private static void writeAttributes(
+ XMLStreamWriter xmlWriter, Map<String, String> attributes, Map<String, String> namespaces)
+ throws XMLStreamException {
+ // Collect which namespace prefixes need to be declared on this element:
+ // start with those explicitly in attributes (xmlns:prefix), then add
+ // any prefixes used by attributes that are resolved from the namespace context
+ Set<String> declaredPrefixes = new HashSet<>();
+ for (Map.Entry<String, String> attribute : attributes.entrySet()) {
+ String key = attribute.getKey();
+ if ("xmlns".equals(key)) {
+ xmlWriter.writeDefaultNamespace(attribute.getValue());
+ } else if (key.startsWith("xmlns:")) {
+ String prefix = key.substring(6);
+ xmlWriter.writeNamespace(prefix, attribute.getValue());
+ declaredPrefixes.add(prefix);
+ }
+ }
+ // Write prefixed attributes, declaring their namespace if needed
+ for (Map.Entry<String, String> attribute : attributes.entrySet()) {
+ String key = attribute.getKey();
+ String value = attribute.getValue();
+ if ("xmlns".equals(key) || key.startsWith("xmlns:")) {
+ continue; // already written above
+ } else if (key.startsWith("xml:")) {
+ // The xml: prefix is predefined and bound to the XML namespace.
+ // It must not be declared, but attributes like xml:space still need
+ // to be written using the proper namespace URI.
+ xmlWriter.writeAttribute("http://www.w3.org/XML/1998/namespace", key.substring(4), value);
+ } else if (key.contains(":")) {
+ int colon = key.indexOf(':');
+ String prefix = key.substring(0, colon);
+ String localName = key.substring(colon + 1);
+ // Look up namespace URI: first from local xmlns: declarations, then from context
+ String nsUri = attributes.get("xmlns:" + prefix);
+ if (nsUri == null) {
+ nsUri = namespaces.get(prefix);
+ }
+ if (nsUri != null) {
+ // Declare the namespace if not already declared on this element
+ if (declaredPrefixes.add(prefix)) {
+ xmlWriter.writeNamespace(prefix, nsUri);
+ }
+ xmlWriter.writeAttribute(prefix, nsUri, localName, value);
+ } else {
+ // No namespace declaration found for this prefix; write as unprefixed
+ // to produce valid XML
+ xmlWriter.writeAttribute(localName, value);
+ }
+ } else {
+ xmlWriter.writeAttribute(key, value);
+ }
+ }
+ }
+
/**
* Merges one DOM into another, given a specific algorithm and possible override points for that algorithm.<p>
* The algorithm is as follows:
@@ -367,6 +449,7 @@ public XmlNode doMerge(XmlNode dominant, XmlNode recessive, Boolean childMergeOv
.name(dominant.name())
.value(value != null ? value : dominant.value())
.attributes(attrs)
+ .namespaces(dominant.namespaces())
.children(children)
.inputLocation(location)
.build();
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 633d6d3018..548e991bb8 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
@@ -24,6 +24,7 @@
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
+import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
@@ -36,10 +37,13 @@
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
class XmlNodeImplTest {
@@ -715,6 +719,801 @@ public Object toInputLocation(XMLStreamReader parser) {
}
}
+ // ========================================================================================
+ // Namespace context - Parsing tests
+ // ========================================================================================
+
+ @Test
+ void testParseNamespaceContextSinglePrefixOnRoot() throws Exception {
+ String xml = """
+ <root xmlns:mvn="http://maven.apache.org/POM/4.0.0">
+ <child/>
+ </root>
+ """;
+ XmlNode node = toXmlNode(xml);
+ assertEquals("http://maven.apache.org/POM/4.0.0", node.namespaces().get("mvn"));
+ }
+
+ @Test
+ void testParseNamespaceContextMultiplePrefixes() throws Exception {
+ String xml = """
+ <root xmlns:mvn="http://maven.apache.org/POM/4.0.0"
+ xmlns:custom="http://example.com/custom"
+ xmlns:other="http://example.com/other">
+ <child/>
+ </root>
+ """;
+ XmlNode node = toXmlNode(xml);
+ assertEquals(3, node.namespaces().size());
+ assertEquals("http://maven.apache.org/POM/4.0.0", node.namespaces().get("mvn"));
+ assertEquals("http://example.com/custom", node.namespaces().get("custom"));
+ assertEquals("http://example.com/other", node.namespaces().get("other"));
+ }
+
+ @Test
+ void testParseNamespaceContextInheritedByChild() throws Exception {
+ String xml = """
+ <root xmlns:mvn="http://maven.apache.org/POM/4.0.0">
+ <child mvn:combine.children="append"/>
+ </root>
+ """;
+ XmlNode node = toXmlNode(xml);
+ XmlNode child = node.child("child");
+ assertNotNull(child);
+ // Child inherits parent's namespace context
+ assertEquals("http://maven.apache.org/POM/4.0.0", child.namespaces().get("mvn"));
+ // Child does NOT have xmlns:mvn in its own attributes
+ assertNull(child.attribute("xmlns:mvn"));
+ }
+
+ @Test
+ void testParseNamespaceContextInheritedAcrossThreeLevels() throws Exception {
+ String xml = """
+ <root xmlns:a="http://example.com/a">
+ <level1 xmlns:b="http://example.com/b">
+ <level2 a:x="1" b:y="2">
+ <leaf/>
+ </level2>
+ </level1>
+ </root>
+ """;
+ XmlNode root = toXmlNode(xml);
+ XmlNode level1 = root.child("level1");
+ XmlNode level2 = level1.child("level2");
+ XmlNode leaf = level2.child("leaf");
+
+ // root has only "a"
+ assertEquals("http://example.com/a", root.namespaces().get("a"));
+ assertNull(root.namespaces().get("b"));
+
+ // level1 has both "a" (inherited) and "b" (own)
+ assertEquals("http://example.com/a", level1.namespaces().get("a"));
+ assertEquals("http://example.com/b", level1.namespaces().get("b"));
+
+ // level2 inherits both
+ assertEquals("http://example.com/a", level2.namespaces().get("a"));
+ assertEquals("http://example.com/b", level2.namespaces().get("b"));
+
+ // leaf also inherits both
+ assertEquals("http://example.com/a", leaf.namespaces().get("a"));
+ assertEquals("http://example.com/b", leaf.namespaces().get("b"));
+ }
+
+ @Test
+ void testParseDefaultNamespaceNotInNamespacesMap() throws Exception {
+ String xml = """
+ <root xmlns="http://maven.apache.org/POM/4.0.0">
+ <child/>
+ </root>
+ """;
+ XmlNode node = toXmlNode(xml);
+ // Default namespace (no prefix) should NOT be in the namespaces map
+ // since namespaces() tracks prefix→URI bindings for resolving prefixed attributes
+ assertNull(node.namespaces().get(""));
+ assertNull(node.namespaces().get("xmlns"));
+ // The default namespace is stored as an attribute instead
+ assertEquals("http://maven.apache.org/POM/4.0.0", node.attribute("xmlns"));
+ }
+
+ @Test
+ void testParseNamespaceContextChildOverridesPrefix() throws Exception {
+ String xml = """
+ <root xmlns:ns="http://example.com/original">
+ <child xmlns:ns="http://example.com/overridden" ns:attr="val">
+ <grandchild ns:attr2="val2"/>
+ </child>
+ </root>
+ """;
+ XmlNode root = toXmlNode(xml);
+ XmlNode child = root.child("child");
+ XmlNode grandchild = child.child("grandchild");
+
+ // Root has original binding
+ assertEquals("http://example.com/original", root.namespaces().get("ns"));
+ // Child overrides
+ assertEquals("http://example.com/overridden", child.namespaces().get("ns"));
+ // Grandchild inherits the overridden version
+ assertEquals("http://example.com/overridden", grandchild.namespaces().get("ns"));
+ }
+
+ @Test
+ void testParseNoNamespaceDeclarationsProducesEmptyMap() throws Exception {
+ String xml = "<root><child attr=\"value\"/></root>";
+ XmlNode root = toXmlNode(xml);
+ assertTrue(root.namespaces().isEmpty());
+ XmlNode child = root.child("child");
+ assertNotNull(child);
+ assertTrue(child.namespaces().isEmpty());
+ }
+
+ @Test
+ void testParseNamespacesMapIsImmutable() throws Exception {
+ String xml = """
+ <root xmlns:mvn="http://maven.apache.org/POM/4.0.0">
+ <child/>
+ </root>
+ """;
+ XmlNode node = toXmlNode(xml);
+ assertThrows(
+ UnsupportedOperationException.class, () -> node.namespaces().put("foo", "bar"));
+ }
+
+ // ========================================================================================
+ // Namespace context - Writing tests
+ // ========================================================================================
+
+ @Test
+ void testWriteWithNamespaceDeclarationsAndPrefixedAttributes() throws Exception {
+ String xml = """
+ <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:mvn="http://maven.apache.org/POM/4.0.0">
+ <compilerArgs mvn:combine.children="append">
+ <arg>-Xlint:deprecation</arg>
+ </compilerArgs>
+ </project>
+ """;
+
+ XmlNode node = toXmlNode(xml);
+ assertEquals("http://maven.apache.org/POM/4.0.0", node.attribute("xmlns:mvn"));
+
+ StringWriter writer = new StringWriter();
+ XmlService.write(node, writer);
+ String output = writer.toString();
+
+ XmlNode reRead = toXmlNode(output);
+ assertNotNull(reRead);
+ }
+
+ @Test
+ void testWriteStripsOrphanedPrefixOnAttributes() throws Exception {
+ XmlNode node = XmlNode.newBuilder()
+ .name("compilerArgs")
+ .attributes(Map.of("mvn:combine.children", "append"))
+ .children(List.of(XmlNode.newBuilder()
+ .name("arg")
+ .value("-Xlint:deprecation")
+ .build()))
+ .build();
+
+ StringWriter writer = new StringWriter();
+ XmlService.write(node, writer);
+ String output = writer.toString();
+
+ assertFalse(output.contains("mvn:combine"), "Output should not contain orphaned mvn: prefix");
+ assertTrue(output.contains("combine.children=\"append\""), "Attribute should be written unprefixed");
+
+ XmlNode reRead = toXmlNode(output);
+ assertNotNull(reRead);
+ assertEquals("append", reRead.attribute("combine.children"));
+ }
+
+ @Test
+ void testWriteForeignNamespaceAttributeRoundTrip() throws Exception {
+ XmlNode node = XmlNode.newBuilder()
+ .name("compilerArgs")
+ .attributes(Map.of(
+ "xmlns:custom", "http://example.com/custom",
+ "custom:myattr", "value"))
+ .children(List.of(XmlNode.newBuilder()
+ .name("arg")
+ .value("-Xlint:deprecation")
+ .build()))
+ .build();
+
+ StringWriter writer = new StringWriter();
+ XmlService.write(node, writer);
+ String output = writer.toString();
+
+ XmlNode reRead = toXmlNode(output);
+ assertNotNull(reRead);
+ assertEquals("value", reRead.attribute("custom:myattr"));
+ assertEquals("http://example.com/custom", reRead.attribute("xmlns:custom"));
+ }
+
+ @Test
+ void testWritePreservesPrefixFromInheritedNamespaceContext() throws Exception {
+ String xml = """
+ <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:custom="http://example.com/custom">
+ <compilerArgs custom:myattr="value">
+ <arg>-Xlint:deprecation</arg>
+ </compilerArgs>
+ </project>
+ """;
+
+ XmlNode node = toXmlNode(xml);
+ XmlNode compilerArgs = node.child("compilerArgs");
+ assertNotNull(compilerArgs);
+ assertEquals("value", compilerArgs.attribute("custom:myattr"));
+ assertNull(compilerArgs.attribute("xmlns:custom"), "xmlns:custom should be on parent, not child");
+ assertEquals("http://example.com/custom", compilerArgs.namespaces().get("custom"));
+
+ StringWriter writer = new StringWriter();
+ XmlService.write(compilerArgs, writer);
+ String output = writer.toString();
+
+ XmlNode reRead = toXmlNode(output);
+ assertNotNull(reRead);
+ assertEquals("value", reRead.attribute("custom:myattr"));
+ }
+
+ @Test
+ void testWriteStripsOrphanedPrefixWithoutNamespaceContext() throws Exception {
+ XmlNode node = XmlNode.newBuilder()
+ .name("compilerArgs")
+ .attributes(Map.of("mvn:combine.children", "append"))
+ .children(List.of(XmlNode.newBuilder()
+ .name("arg")
+ .value("-Xlint:deprecation")
+ .build()))
+ .build();
+
+ assertTrue(node.namespaces().isEmpty(), "No namespace context");
+
+ StringWriter writer = new StringWriter();
+ XmlService.write(node, writer);
+ String output = writer.toString();
+
+ assertFalse(output.contains("mvn:combine"), "Output should not contain orphaned mvn: prefix");
+ assertTrue(output.contains("combine.children=\"append\""), "Attribute should be written unprefixed");
+
+ XmlNode reRead = toXmlNode(output);
+ assertNotNull(reRead);
+ assertEquals("append", reRead.attribute("combine.children"));
+ }
+
+ @Test
+ void testWriteMultiplePrefixedAttributesFromDifferentNamespaces() throws Exception {
+ String xml = """
+ <root xmlns:a="http://example.com/a" xmlns:b="http://example.com/b">
+ <child a:x="1" b:y="2"/>
+ </root>
+ """;
+ XmlNode root = toXmlNode(xml);
+ XmlNode child = root.child("child");
+ assertNotNull(child);
+
+ // Write only the child (which has prefixed attrs but no local xmlns:)
+ StringWriter writer = new StringWriter();
+ XmlService.write(child, writer);
+ String output = writer.toString();
+
+ // Both namespace declarations should be auto-declared
+ assertTrue(output.contains("xmlns:a="), "Should auto-declare xmlns:a");
+ assertTrue(output.contains("xmlns:b="), "Should auto-declare xmlns:b");
+
+ // Round-trip should preserve attributes
+ XmlNode reRead = toXmlNode(output);
+ assertEquals("1", reRead.attribute("a:x"));
+ assertEquals("2", reRead.attribute("b:y"));
+ }
+
+ @Test
+ void testWriteLocalXmlnsOverridesNamespaceContext() throws Exception {
+ // Build a node where the local attribute has xmlns:ns with one URI
+ // but the namespace context has a different URI for the same prefix.
+ // The local declaration should win.
+ XmlNode node = XmlNode.newBuilder()
+ .name("elem")
+ .attributes(Map.of(
+ "xmlns:ns", "http://example.com/local",
+ "ns:attr", "value"))
+ .namespaces(Map.of("ns", "http://example.com/context"))
+ .build();
+
+ StringWriter writer = new StringWriter();
+ XmlService.write(node, writer);
+ String output = writer.toString();
+
+ // The local xmlns:ns should be used, not the one from context
+ assertTrue(output.contains("http://example.com/local"), "Local xmlns: should take precedence");
+
+ XmlNode reRead = toXmlNode(output);
+ assertEquals("value", reRead.attribute("ns:attr"));
+ assertEquals("http://example.com/local", reRead.attribute("xmlns:ns"));
+ }
+
+ @Test
+ void testWriteXmlSpaceAttributeRoundTrip() throws Exception {
+ String xml = """
+ <root xml:space="preserve"> content with spaces </root>
+ """;
+ XmlNode node = toXmlNode(xml);
+ assertEquals("preserve", node.attribute("xml:space"));
+
+ StringWriter writer = new StringWriter();
+ XmlService.write(node, writer);
+ String output = writer.toString();
+
+ // xml: prefix should be handled without explicit declaration
+ assertFalse(output.contains("xmlns:xml"), "xml: prefix must not be declared");
+ XmlNode reRead = toXmlNode(output);
+ assertEquals("preserve", reRead.attribute("xml:space"));
+ assertEquals(" content with spaces ", reRead.value());
+ }
+
+ @Test
+ void testWriteUnprefixedAttributeUnchanged() throws Exception {
+ XmlNode node = XmlNode.newBuilder()
+ .name("elem")
+ .attributes(Map.of("simple", "value", "another", "val2"))
+ .build();
+
+ StringWriter writer = new StringWriter();
+ XmlService.write(node, writer);
+ String output = writer.toString();
+
+ XmlNode reRead = toXmlNode(output);
+ assertEquals("value", reRead.attribute("simple"));
+ assertEquals("val2", reRead.attribute("another"));
+ }
+
+ @Test
+ void testWriteNamespaceNotDeclaredTwice() throws Exception {
+ // When xmlns:mvn is both in attributes AND namespace context,
+ // it should only be declared once
+ XmlNode node = XmlNode.newBuilder()
+ .name("elem")
+ .attributes(Map.of(
+ "xmlns:mvn", "http://maven.apache.org/POM/4.0.0",
+ "mvn:combine.children", "append"))
+ .namespaces(Map.of("mvn", "http://maven.apache.org/POM/4.0.0"))
+ .build();
+
+ StringWriter writer = new StringWriter();
+ XmlService.write(node, writer);
+ String output = writer.toString();
+
+ // Count occurrences of xmlns:mvn - should be exactly 1
+ int count = 0;
+ int idx = 0;
+ while ((idx = output.indexOf("xmlns:mvn", idx)) != -1) {
+ count++;
+ idx += "xmlns:mvn".length();
+ }
+ assertEquals(1, count, "xmlns:mvn should be declared exactly once");
+
+ XmlNode reRead = toXmlNode(output);
+ assertEquals("append", reRead.attribute("mvn:combine.children"));
+ }
+
+ @Test
+ void testWriteChildInheritsContextAndWritesStandalone() throws Exception {
+ // Parse a 3-level structure, then write the grandchild standalone
+ String xml = """
+ <root xmlns:a="http://example.com/a">
+ <mid xmlns:b="http://example.com/b">
+ <leaf a:x="1" b:y="2" plain="3"/>
+ </mid>
+ </root>
+ """;
+ XmlNode root = toXmlNode(xml);
+ XmlNode leaf = root.child("mid").child("leaf");
+
+ StringWriter writer = new StringWriter();
+ XmlService.write(leaf, writer);
+ String output = writer.toString();
+
+ XmlNode reRead = toXmlNode(output);
+ assertEquals("1", reRead.attribute("a:x"));
+ assertEquals("2", reRead.attribute("b:y"));
+ assertEquals("3", reRead.attribute("plain"));
+ }
+
+ // ========================================================================================
+ // Namespace context - Merge tests
+ // ========================================================================================
+
+ @Test
+ void testMergePreservesDominantNamespaces() throws Exception {
+ String dominant = """
+ <root xmlns:mvn="http://maven.apache.org/POM/4.0.0">
+ <child mvn:combine.children="append">
+ <item>dom</item>
+ </child>
+ </root>
+ """;
+ String recessive = """
+ <root>
+ <child>
+ <item>rec</item>
+ </child>
+ </root>
+ """;
+ XmlNode merged = XmlService.merge(toXmlNode(dominant), toXmlNode(recessive));
+
+ // The merged root should keep dominant's namespace context
+ assertEquals("http://maven.apache.org/POM/4.0.0", merged.namespaces().get("mvn"));
+
+ // The merged child should also have the namespace context
+ XmlNode child = merged.child("child");
+ assertNotNull(child);
+ assertEquals("http://maven.apache.org/POM/4.0.0", child.namespaces().get("mvn"));
+ }
+
+ @Test
+ void testMergeCombineChildrenAppendPreservesNamespaces() throws Exception {
+ String dominant = """
+ <root xmlns="http://maven.apache.org/POM/4.0.0" xmlns:mvn="http://maven.apache.org/POM/4.0.0">
+ <items combine.children="append">
+ <item>a</item>
+ </items>
+ </root>
+ """;
+ String recessive = """
+ <root xmlns="http://maven.apache.org/POM/4.0.0">
+ <items>
+ <item>b</item>
+ </items>
+ </root>
+ """;
+ XmlNode merged = XmlService.merge(toXmlNode(dominant), toXmlNode(recessive));
+ XmlNode items = merged.child("items");
+
+ assertEquals(2, items.children().size(), "append should merge children");
+ // Namespace context should be preserved on the merged element
+ assertEquals("http://maven.apache.org/POM/4.0.0", items.namespaces().get("mvn"));
+ }
+
+ @Test
+ void testMergeCombineSelfOverridePreservesNamespaces() throws Exception {
+ String dominant = """
+ <root xmlns:ns="http://example.com/ns">
+ <child combine.self="override" ns:attr="dominant">
+ <item>dom</item>
+ </child>
+ </root>
+ """;
+ String recessive = """
+ <root>
+ <child>
+ <item>rec1</item>
+ <item>rec2</item>
+ </child>
+ </root>
+ """;
+ XmlNode merged = XmlService.merge(toXmlNode(dominant), toXmlNode(recessive));
+ XmlNode child = merged.child("child");
+
+ // override means dominant completely replaces recessive
+ assertEquals(1, child.children().size());
+ assertEquals("dom", child.children().get(0).value());
+ // Namespace context preserved
+ assertEquals("http://example.com/ns", child.namespaces().get("ns"));
+ }
+
+ @Test
+ void testMergedNodeWriteProducesValidXml() throws Exception {
+ String dominant = """
+ <root xmlns:mvn="http://maven.apache.org/POM/4.0.0">
+ <child mvn:combine.children="append">
+ <item>a</item>
+ </child>
+ </root>
+ """;
+ String recessive = """
+ <root>
+ <child>
+ <item>b</item>
+ </child>
+ </root>
+ """;
+ XmlNode merged = XmlService.merge(toXmlNode(dominant), toXmlNode(recessive));
+
+ // Write the merged child alone - it should produce valid XML
+ // because it has the namespace context from the dominant
+ XmlNode child = merged.child("child");
+ StringWriter writer = new StringWriter();
+ XmlService.write(child, writer);
+ String output = writer.toString();
+
+ // mvn:combine.children should be preserved with namespace declaration
+ assertTrue(output.contains("mvn:combine.children"), "Prefix should be preserved from context");
+ assertTrue(output.contains("xmlns:mvn="), "Namespace should be auto-declared");
+
+ XmlNode reRead = toXmlNode(output);
+ assertEquals("append", reRead.attribute("mvn:combine.children"));
+ }
+
+ // ========================================================================================
+ // Namespace context - Builder tests
+ // ========================================================================================
+
+ @Test
+ void testBuilderWithExplicitNamespaces() throws Exception {
+ XmlNode node = XmlNode.newBuilder()
+ .name("elem")
+ .attributes(Map.of("ns:attr", "value"))
+ .namespaces(Map.of("ns", "http://example.com/ns"))
+ .build();
+
+ assertEquals("http://example.com/ns", node.namespaces().get("ns"));
+
+ StringWriter writer = new StringWriter();
+ XmlService.write(node, writer);
+ String output = writer.toString();
+
+ assertTrue(output.contains("xmlns:ns="), "Namespace should be auto-declared from builder context");
+ XmlNode reRead = toXmlNode(output);
+ assertEquals("value", reRead.attribute("ns:attr"));
+ }
+
+ @Test
+ void testBuilderWithNullNamespacesDefaultsToEmpty() {
+ XmlNode node = XmlNode.newBuilder().name("elem").build();
+ assertNotNull(node.namespaces());
+ assertTrue(node.namespaces().isEmpty());
+ }
+
+ @Test
+ void testBuilderNamespacesAreImmutable() {
+ Map<String, String> mutableNs = new HashMap<>(Map.of("ns", "http://example.com"));
+ XmlNode node = XmlNode.newBuilder().name("elem").namespaces(mutableNs).build();
+
+ // Mutating the original map should not affect the node
+ mutableNs.put("other", "http://other.com");
+ assertNull(node.namespaces().get("other"));
+
+ // The namespaces map itself should be immutable
+ assertThrows(
+ UnsupportedOperationException.class, () -> node.namespaces().put("foo", "bar"));
+ }
+
+ @Test
+ void testDefaultNamespacesMethodReturnsEmptyMap() {
+ // XmlNode built with newInstance (which doesn't set namespaces)
+ // should return empty map from the default namespaces() method
+ XmlNode node = XmlNode.newInstance("test");
+ assertNotNull(node.namespaces());
+ assertTrue(node.namespaces().isEmpty());
+ }
+
+ // ========================================================================================
+ // Namespace context - Round-trip fidelity tests
+ // ========================================================================================
+
+ @Test
+ void testRoundTripPreservesNamespaceContext() throws Exception {
+ String xml = """
+ <root xmlns:a="http://example.com/a" xmlns:b="http://example.com/b">
+ <child a:x="1" b:y="2"/>
+ </root>
+ """;
+ XmlNode original = toXmlNode(xml);
+
+ StringWriter writer = new StringWriter();
+ XmlService.write(original, writer);
+ XmlNode reRead = toXmlNode(writer.toString());
+
+ // Root namespace context should be preserved
+ assertEquals(original.namespaces().get("a"), reRead.namespaces().get("a"));
+ assertEquals(original.namespaces().get("b"), reRead.namespaces().get("b"));
+
+ // Child namespace context should be preserved
+ XmlNode origChild = original.child("child");
+ XmlNode reReadChild = reRead.child("child");
+ assertEquals(origChild.namespaces().get("a"), reReadChild.namespaces().get("a"));
+ assertEquals(origChild.namespaces().get("b"), reReadChild.namespaces().get("b"));
+ }
+
+ @Test
+ void testRoundTripDeepNestedStructure() throws Exception {
+ String xml = """
+ <root xmlns:ns="http://example.com/ns">
+ <level1>
+ <level2>
+ <level3 ns:deep="value">text</level3>
+ </level2>
+ </level1>
+ </root>
+ """;
+ XmlNode original = toXmlNode(xml);
+
+ StringWriter writer = new StringWriter();
+ XmlService.write(original, writer);
+ XmlNode reRead = toXmlNode(writer.toString());
+
+ XmlNode level3 = reRead.child("level1").child("level2").child("level3");
+ assertEquals("value", level3.attribute("ns:deep"));
+ assertEquals("text", level3.value());
+ assertEquals("http://example.com/ns", level3.namespaces().get("ns"));
+ }
+
+ @Test
+ void testRoundTripWithOverriddenNamespace() throws Exception {
+ String xml = """
+ <root xmlns:ns="http://example.com/v1">
+ <child xmlns:ns="http://example.com/v2" ns:attr="val"/>
+ </root>
+ """;
+ XmlNode original = toXmlNode(xml);
+ XmlNode child = original.child("child");
+ assertEquals("http://example.com/v2", child.namespaces().get("ns"));
+
+ // Write and re-read just the child
+ StringWriter writer = new StringWriter();
+ XmlService.write(child, writer);
+ XmlNode reRead = toXmlNode(writer.toString());
+
+ assertEquals("val", reRead.attribute("ns:attr"));
+ assertEquals("http://example.com/v2", reRead.namespaces().get("ns"));
+ }
+
+ // ========================================================================================
+ // Namespace context - Consumer POM simulation tests
+ // ========================================================================================
+
+ @Test
+ void testConsumerPomScenarioPrefixFromContext() throws Exception {
+ // Simulate: parse a full POM with xmlns:mvn on project, mvn:combine.children on child
+ String xml = """
+ <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:mvn="http://maven.apache.org/POM/4.0.0">
+ <build>
+ <plugins>
+ <plugin>
+ <configuration>
+ <compilerArgs mvn:combine.children="append">
+ <arg>-Xlint</arg>
+ </compilerArgs>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+ </project>
+ """;
+ XmlNode project = toXmlNode(xml);
+ XmlNode compilerArgs = project.child("build")
+ .child("plugins")
+ .child("plugin")
+ .child("configuration")
+ .child("compilerArgs");
+ assertNotNull(compilerArgs);
+ assertEquals("append", compilerArgs.attribute("mvn:combine.children"));
+ assertEquals(
+ "http://maven.apache.org/POM/4.0.0", compilerArgs.namespaces().get("mvn"));
+
+ // Simulate consumer POM: write only the configuration subtree
+ XmlNode config = project.child("build").child("plugins").child("plugin").child("configuration");
+ StringWriter writer = new StringWriter();
+ XmlService.write(config, writer);
+ String output = writer.toString();
+
+ // Should produce valid XML with auto-declared xmlns:mvn
+ XmlNode reRead = toXmlNode(output);
+ XmlNode reReadArgs = reRead.child("compilerArgs");
+ assertEquals("append", reReadArgs.attribute("mvn:combine.children"));
+ }
+
+ @Test
+ void testConsumerPomScenarioNoContextFallback() throws Exception {
+ // Simulate: programmatically-built XmlNode without namespace context
+ // (as might happen if someone builds configuration in code)
+ XmlNode config = XmlNode.newBuilder()
+ .name("configuration")
+ .children(List.of(XmlNode.newBuilder()
+ .name("compilerArgs")
+ .attributes(Map.of("mvn:combine.children", "append"))
+ .children(List.of(
+ XmlNode.newBuilder().name("arg").value("-Xlint").build()))
+ .build()))
+ .build();
+
+ StringWriter writer = new StringWriter();
+ XmlService.write(config, writer);
+ String output = writer.toString();
+
+ // Without namespace context, prefix should be stripped
+ assertFalse(output.contains("mvn:"), "No mvn: prefix without context");
+ XmlNode reRead = toXmlNode(output);
+ assertEquals("append", reRead.child("compilerArgs").attribute("combine.children"));
+ }
+
+ // ========================================================================================
+ // Namespace context - Merge directive interaction tests
+ // ========================================================================================
+
+ @Test
+ void testPrefixedCombineChildrenDoesNotMerge() throws Exception {
+ String dominant = """
+ <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:mvn="http://maven.apache.org/POM/4.0.0">
+ <compilerArgs mvn:combine.children="append">
+ <arg>-Xlint:deprecation</arg>
+ </compilerArgs>
+ </project>
+ """;
+
+ String recessive = """
+ <project xmlns="http://maven.apache.org/POM/4.0.0">
+ <compilerArgs>
+ <arg>-Xlint:unchecked</arg>
+ </compilerArgs>
+ </project>
+ """;
+
+ XmlNode dominantNode = toXmlNode(dominant);
+ XmlNode recessiveNode = toXmlNode(recessive);
+ XmlNode merged = XmlService.merge(dominantNode, recessiveNode);
+
+ XmlNode compilerArgs = merged.child("compilerArgs");
+ assertNotNull(compilerArgs);
+ assertEquals(
+ 1,
+ compilerArgs.children().size(),
+ "mvn:combine.children should not trigger append; only unprefixed combine.children works");
+ }
+
+ @Test
+ void testUnprefixedCombineChildrenStillWorks() throws Exception {
+ String dominant = """
+ <project xmlns="http://maven.apache.org/POM/4.0.0">
+ <compilerArgs combine.children="append">
+ <arg>-Xlint:deprecation</arg>
+ </compilerArgs>
+ </project>
+ """;
+
+ String recessive = """
+ <project xmlns="http://maven.apache.org/POM/4.0.0">
+ <compilerArgs>
+ <arg>-Xlint:unchecked</arg>
+ </compilerArgs>
+ </project>
+ """;
+
+ XmlNode dominantNode = toXmlNode(dominant);
+ XmlNode recessiveNode = toXmlNode(recessive);
+ XmlNode merged = XmlService.merge(dominantNode, recessiveNode);
+
+ XmlNode compilerArgs = merged.child("compilerArgs");
+ assertNotNull(compilerArgs);
+ assertEquals(2, compilerArgs.children().size(), "Unprefixed combine.children=append should work");
+ }
+
+ @Test
+ void testPrefixedCombineSelfDoesNotOverride() throws Exception {
+ String dominant = """
+ <root xmlns:mvn="http://maven.apache.org/POM/4.0.0">
+ <child mvn:combine.self="override">
+ <item>dom</item>
+ </child>
+ </root>
+ """;
+ String recessive = """
+ <root>
+ <child>
+ <item>rec</item>
+ <extra>bonus</extra>
+ </child>
+ </root>
+ """;
+ XmlNode merged = XmlService.merge(toXmlNode(dominant), toXmlNode(recessive));
+ XmlNode child = merged.child("child");
+
+ // mvn:combine.self should NOT trigger override (only unprefixed combine.self works)
+ // Default merge behavior merges children by name
+ assertEquals("dom", child.child("item").value());
+ // The "extra" child from recessive should survive since combine.self wasn't triggered
+ assertNotNull(child.child("extra"), "Recessive children should survive since mvn:combine.self is ignored");
+ }
+
public static Xpp3Dom build(Reader reader) throws XmlPullParserException, IOException {
try (Reader closeMe = reader) {
return new Xpp3Dom(XmlNodeBuilder.build(reader, true, null));
diff --git a/src/mdo/writer-stax.vm b/src/mdo/writer-stax.vm
index 9f12f7fc4e..fb2aaf7bd3 100644
--- a/src/mdo/writer-stax.vm
+++ b/src/mdo/writer-stax.vm
@@ -366,14 +366,7 @@ public class ${className} {
private void writeDom(XmlNode dom, XMLStreamWriter serializer) throws IOException, XMLStreamException {
if (dom != null) {
serializer.writeStartElement(namespace, dom.name());
- for (Map.Entry<String, String> attr : dom.attributes().entrySet()) {
- if (attr.getKey().startsWith("xml:")) {
- serializer.writeAttribute("http://www.w3.org/XML/1998/namespace",
- attr.getKey().substring(4), attr.getValue());
- } else {
- serializer.writeAttribute(attr.getKey(), attr.getValue());
- }
- }
+ writeXmlNodeAttributes(serializer, dom.attributes(), dom.namespaces());
for (XmlNode child : dom.children()) {
writeDom(child, serializer);
}
@@ -410,6 +403,56 @@ public class ${className} {
serializer.writeAttribute(attrName, value);
}
}
+
+ /**
+ * Writes XmlNode attributes, properly handling namespace declarations
+ * ({@code xmlns:prefix}) and prefixed attributes ({@code prefix:localName}).
+ * The namespace context is used to resolve prefixes when the {@code xmlns:}
+ * declaration is not present in the attribute map.
+ */
+ private static void writeXmlNodeAttributes(XMLStreamWriter serializer, Map<String, String> attributes, Map<String, String> namespaces) throws XMLStreamException {
+ // Collect which namespace prefixes need to be declared on this element
+ Set<String> declaredPrefixes = new HashSet<>();
+ for (Map.Entry<String, String> attribute : attributes.entrySet()) {
+ String key = attribute.getKey();
+ if ("xmlns".equals(key)) {
+ serializer.writeDefaultNamespace(attribute.getValue());
+ } else if (key.startsWith("xmlns:")) {
+ String prefix = key.substring(6);
+ serializer.writeNamespace(prefix, attribute.getValue());
+ declaredPrefixes.add(prefix);
+ }
+ }
+ // Write prefixed attributes, declaring their namespace if needed
+ for (Map.Entry<String, String> attribute : attributes.entrySet()) {
+ String key = attribute.getKey();
+ String value = attribute.getValue();
+ if ("xmlns".equals(key) || key.startsWith("xmlns:")) {
+ continue; // already written above
+ } else if (key.startsWith("xml:")) {
+ serializer.writeAttribute(
+ "http://www.w3.org/XML/1998/namespace", key.substring(4), value);
+ } else if (key.contains(":")) {
+ int colon = key.indexOf(':');
+ String prefix = key.substring(0, colon);
+ String localName = key.substring(colon + 1);
+ String nsUri = attributes.get("xmlns:" + prefix);
+ if (nsUri == null) {
+ nsUri = namespaces.get(prefix);
+ }
+ if (nsUri != null) {
+ if (declaredPrefixes.add(prefix)) {
+ serializer.writeNamespace(prefix, nsUri);
+ }
+ serializer.writeAttribute(prefix, nsUri, localName, value);
+ } else {
+ serializer.writeAttribute(localName, value);
+ }
+ } else {
+ serializer.writeAttribute(key, value);
+ }
+ }
+ }
#if ( $locationTracking )
/**
diff --git a/src/mdo/writer.vm b/src/mdo/writer.vm
index 3795700a2d..6a63c6e3d4 100644
--- a/src/mdo/writer.vm
+++ b/src/mdo/writer.vm
@@ -252,9 +252,7 @@ public class ${className} {
private void writeDom(XmlNode dom, XmlSerializer serializer) throws IOException {
if (dom != null) {
serializer.startTag(NAMESPACE, dom.getName());
- for (Map.Entry<String, String> attr : dom.getAttributes().entrySet()) {
- serializer.attribute(NAMESPACE, attr.getKey(), attr.getValue());
- }
+ writeXmlNodeAttributes(serializer, dom.getAttributes(), dom.namespaces());
for (XmlNode child : dom.getChildren()) {
writeDom(child, serializer);
}
@@ -266,6 +264,56 @@ public class ${className} {
}
}
+ /**
+ * Writes XmlNode attributes, properly handling namespace declarations
+ * ({@code xmlns:prefix}) and prefixed attributes ({@code prefix:localName}).
+ * The namespace context is used to resolve prefixes when the {@code xmlns:}
+ * declaration is not present in the attribute map.
+ */
+ private static void writeXmlNodeAttributes(XmlSerializer serializer, Map<String, String> attributes, Map<String, String> namespaces) throws IOException {
+ // Collect which namespace prefixes need to be declared on this element
+ Set<String> declaredPrefixes = new HashSet<>();
+ for (Map.Entry<String, String> attribute : attributes.entrySet()) {
+ String key = attribute.getKey();
+ if ("xmlns".equals(key)) {
+ serializer.setPrefix("", attribute.getValue());
+ } else if (key.startsWith("xmlns:")) {
+ String prefix = key.substring(6);
+ serializer.setPrefix(prefix, attribute.getValue());
+ declaredPrefixes.add(prefix);
+ }
+ }
+ // Write prefixed attributes, declaring their namespace if needed
+ for (Map.Entry<String, String> attribute : attributes.entrySet()) {
+ String key = attribute.getKey();
+ String value = attribute.getValue();
+ if ("xmlns".equals(key) || key.startsWith("xmlns:")) {
+ continue; // already handled above
+ } else if (key.startsWith("xml:")) {
+ serializer.attribute("http://www.w3.org/XML/1998/namespace", key.substring(4), value);
+ } else if (key.contains(":")) {
+ int colon = key.indexOf(':');
+ String prefix = key.substring(0, colon);
+ String localName = key.substring(colon + 1);
+ String nsUri = attributes.get("xmlns:" + prefix);
+ if (nsUri == null) {
+ nsUri = namespaces.get(prefix);
+ }
+ if (nsUri != null) {
+ if (declaredPrefixes.add(prefix)) {
+ serializer.setPrefix(prefix, nsUri);
+ }
+ serializer.attribute(nsUri, localName, value);
+ } else {
+ // No namespace declaration for this prefix; write as unprefixed
+ serializer.attribute(NAMESPACE, localName, value);
+ }
+ } else {
+ serializer.attribute(NAMESPACE, key, value);
+ }
+ }
+ }
+
private void writeTag(String tagName, String defaultValue, String value, XmlSerializer serializer) throws IOException {
if (value != null && !Objects.equals(defaultValue, value)) {
serializer.startTag(NAMESPACE, tagName).text(value).endTag(NAMESPACE, tagName);