Partial support for parsing XML namespaces

rewrite-xml/src/main/java/org/openrewrite/xml/ChangeNamespaceValue.java

@@ -19,14 +19,27 @@
 import lombok.Value;
 import org.openrewrite.*;
 import org.openrewrite.internal.ListUtils;
+import org.openrewrite.internal.StringUtils;
 import org.openrewrite.internal.lang.Nullable;
+import org.openrewrite.marker.Markers;
+import org.openrewrite.xml.internal.Namespaces;
+import org.openrewrite.xml.internal.XmlNamespaceUtils;
 import org.openrewrite.xml.tree.Xml;
 
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static org.openrewrite.Tree.randomId;
+
 @Value
 @EqualsAndHashCode(callSuper = false)
 public class ChangeNamespaceValue extends Recipe {
     private static final String XMLNS_PREFIX = "xmlns";
     private static final String VERSION_PREFIX = "version";
+    private static final String SCHEMA_LOCATION_MATCH_PATTERN = "(?m)(.*)(%s)(\\s+)(.*)";
+    private static final String SCHEMA_LOCATION_REPLACEMENT_PATTERN = "$1%s$3%s";
+    private static final String MSG_TAG_UPDATED = "msg-tag-updated";
 
     @Override
     public String getDisplayName() {
@@ -71,16 +84,40 @@ public String getDescription() {
             required = false)
     Boolean searchAllNamespaces;
 
+    @Nullable
+    @Option(displayName = "New Resource version",
+            description = "The new version of the resource",
+            example = "2.0")
+    String newVersion;
+
+    @Option(displayName = "Schema Location",
+            description = "The new value to be used for the namespace schema location.",
+            example = "newfoo.bar.attribute.value.string",
+            required = false)
+    @Nullable
+    String newSchemaLocation;
+
     @Override
     public TreeVisitor<?, ExecutionContext> getVisitor() {
         XPathMatcher elementNameMatcher = elementName != null ? new XPathMatcher(elementName) : null;
         return new XmlIsoVisitor<ExecutionContext>() {
+            @Override
+            public Xml.Document visitDocument(Xml.Document document, ExecutionContext ctx) {
+                document = super.visitDocument(document, ctx);
+                if (ctx.pollMessage(MSG_TAG_UPDATED, false)) {
+                    document = document.withRoot(addOrUpdateSchemaLocation(document.getRoot(), getCursor()));
+                }
+                return document;
+            }
+
             @Override
             public Xml.Tag visitTag(Xml.Tag tag, ExecutionContext ctx) {
                 Xml.Tag t = super.visitTag(tag, ctx);
 
                 if (matchesElementName(getCursor()) && matchesVersion(t)) {
                     t = t.withAttributes(ListUtils.map(t.getAttributes(), this::maybeReplaceNamespaceAttribute));
+                    t = t.withAttributes(ListUtils.map(t.getAttributes(), this::maybeReplaceVersionAttribute));
+                    ctx.putMessage(MSG_TAG_UPDATED, true);
                 }
 
                 return t;
@@ -114,6 +151,18 @@ private Xml.Attribute maybeReplaceNamespaceAttribute(Xml.Attribute attribute) {
                 return attribute;
             }
 
+            private Xml.Attribute maybeReplaceVersionAttribute(Xml.Attribute attribute) {
+                if (isVersionAttribute(attribute) && newVersion != null) {
+                    return attribute.withValue(
+                            new Xml.Attribute.Value(attribute.getId(),
+                                    "",
+                                    attribute.getMarkers(),
+                                    attribute.getValue().getQuote(),
+                                    newVersion));
+                }
+                return attribute;
+            }
+
             private boolean isXmlnsAttribute(Xml.Attribute attribute) {
                 boolean searchAll = searchAllNamespaces == null || Boolean.TRUE.equals(searchAllNamespaces);
                 return searchAll && attribute.getKeyAsString().startsWith(XMLNS_PREFIX) ||
@@ -149,6 +198,80 @@ private boolean isVersionMatch(Xml.Attribute attribute) {
                 }
                 return false;
             }
+
+            private Xml.Tag addOrUpdateSchemaLocation(Xml.Tag root, Cursor cursor) {
+                if (StringUtils.isBlank(newSchemaLocation)) {
+                    return root;
+                }
+                Xml.Tag newRoot = maybeAddNamespace(root);
+                Optional<Xml.Attribute> maybeSchemaLocation = maybeGetSchemaLocation(cursor, newRoot);
+                if (maybeSchemaLocation.isPresent() && oldValue != null) {
+                    newRoot = updateSchemaLocation(newRoot, maybeSchemaLocation.get());
+                } else if (!maybeSchemaLocation.isPresent()) {
+                    newRoot = addSchemaLocation(newRoot);
+                }
+                return newRoot;
+            }
+
+            private Optional<Xml.Attribute> maybeGetSchemaLocation(Cursor cursor, Xml.Tag tag) {
+                Xml.Tag schemaLocationTag = XmlNamespaceUtils.findTagContainingXmlSchemaInstanceNamespace(cursor, tag);
+                Namespaces namespaces = tag.getNamespaces();
+                return schemaLocationTag.getAttributes().stream().filter(attribute -> {
+                    String attributeNamespace = namespaces.get(XmlNamespaceUtils.extractNamespacePrefix(attribute.getKeyAsString()));
+                    return XmlNamespaceUtils.XML_SCHEMA_INSTANCE_URI.equals(attributeNamespace)
+                           && attribute.getKeyAsString().endsWith("schemaLocation");
+                }).findFirst();
+            }
+
+            private Xml.Tag maybeAddNamespace(Xml.Tag root) {
+                Namespaces namespaces = root.getNamespaces();
+                if (namespaces.containsUri(newValue) && !namespaces.containsUri(XmlNamespaceUtils.XML_SCHEMA_INSTANCE_URI)) {
+                    namespaces.add(XmlNamespaceUtils.XML_SCHEMA_INSTANCE_PREFIX, XmlNamespaceUtils.XML_SCHEMA_INSTANCE_URI);
+                    root = root.withNamespaces(namespaces);
+                }
+                return root;
+            }
+
+            private Xml.Tag updateSchemaLocation(Xml.Tag newRoot, Xml.Attribute attribute) {
+                String oldSchemaLocation = attribute.getValueAsString();
+                Matcher pattern = Pattern.compile(String.format(SCHEMA_LOCATION_MATCH_PATTERN, Pattern.quote(oldValue)))
+                        .matcher(oldSchemaLocation);
+                if (pattern.find()) {
+                    String newSchemaLocationValue = pattern.replaceFirst(
+                            String.format(SCHEMA_LOCATION_REPLACEMENT_PATTERN, newValue, newSchemaLocation)
+                    );
+                    Xml.Attribute newAttribute = attribute.withValue(attribute.getValue().withValue(newSchemaLocationValue));
+                    newRoot = newRoot.withAttributes(ListUtils.map(newRoot.getAttributes(), a -> a == attribute ? newAttribute : a));
+                }
+                return newRoot;
+            }
+
+            private Xml.Tag addSchemaLocation(Xml.Tag newRoot) {
+                return newRoot.withAttributes(
+                        ListUtils.concat(
+                                newRoot.getAttributes(),
+                                new Xml.Attribute(
+                                        randomId(),
+                                        " ",
+                                        Markers.EMPTY,
+                                        new Xml.Ident(
+                                                randomId(),
+                                                "",
+                                                Markers.EMPTY,
+                                                String.format("%s:schemaLocation", XmlNamespaceUtils.XML_SCHEMA_INSTANCE_PREFIX)
+                                        ),
+                                        "",
+                                        new Xml.Attribute.Value(
+                                                randomId(),
+                                                "",
+                                                Markers.EMPTY,
+                                                Xml.Attribute.Value.Quote.Double,
+                                                String.format("%s %s", newValue, newSchemaLocation)
+                                        )
+                                )
+                        )
+                );
+            }
         };
     }
 }

rewrite-xml/src/main/java/org/openrewrite/xml/XPathMatcher.java

@@ -18,6 +18,7 @@
 import org.openrewrite.Cursor;
 import org.openrewrite.internal.StringUtils;
 import org.openrewrite.internal.lang.Nullable;
+import org.openrewrite.xml.internal.Namespaces;
 import org.openrewrite.xml.search.FindTags;
 import org.openrewrite.xml.tree.Xml;
 
@@ -40,12 +41,18 @@ public class XPathMatcher {
     private static final Pattern PATTERN = Pattern.compile("([-\\w]+)\\[(@)?([-\\w]+)='([-\\w.]+)']");
 
     private final String expression;
+    private final Namespaces namespaces;
     private final boolean startsWithSlash;
     private final boolean startsWithDoubleSlash;
     private final String[] parts;
 
     public XPathMatcher(String expression) {
+        this(expression, new Namespaces());
+    }
+
+    public XPathMatcher(String expression, Namespaces namespaces) {
         this.expression = expression;
+        this.namespaces = namespaces;
         startsWithSlash = expression.startsWith("/");
         startsWithDoubleSlash = expression.startsWith("//");
         parts = expression.substring(startsWithDoubleSlash ? 2 : startsWithSlash ? 1 : 0).split("/");

rewrite-xml/src/main/java/org/openrewrite/xml/internal/Namespaces.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2024 the original author or authors.
+ * <p>
+ * Licensed 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
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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.openrewrite.xml.internal;
+
+import lombok.Value;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+@Value
+public class Namespaces {
+
+    Map<String, String> namespaces = new HashMap<>();
+
+    public Namespaces() {
+    }
+
+    public Namespaces(String prefix, String uri) {
+        add(prefix, uri);
+    }
+
+    public Namespaces add(String prefix, String uri) {
+        namespaces.put(prefix, uri);
+        return this;
+    }
+
+    public Namespaces combine(Namespaces namespaces) {
+        this.namespaces.putAll(namespaces.getNamespaces());
+        return this;
+    }
+
+    public String get(String prefix) {
+        return namespaces.get(prefix);
+    }
+
+    public boolean containsPrefix(String prefix) {
+        return namespaces.containsKey(prefix);
+    }
+
+    public boolean containsUri(String uri) {
+        return namespaces.containsValue(uri);
+    }
+
+    public Set<Map.Entry<String, String>> entrySet() {
+        return namespaces.entrySet();
+    }
+}