Optimize ChangePropertyKey (#6622)

knutwannheden · web-flow · commit e94d36f8534b · 2026-01-28T11:01:46.000+01:00
* Optimize `ChangePropertyKey`

Avoid many repeated `Pattern` allocations.

* Polish

* Polish
diff --git a/rewrite-core/src/main/java/org/openrewrite/internal/NameCaseConvention.java b/rewrite-core/src/main/java/org/openrewrite/internal/NameCaseConvention.java
@@ -15,6 +15,7 @@
  */
 package org.openrewrite.internal;
 
+import org.jspecify.annotations.Nullable;
 import org.openrewrite.Incubating;
 
 import java.util.regex.Pattern;
@@ -53,7 +54,14 @@ public enum NameCaseConvention {
      * This is the standard Java and C++ constant variable naming convention.
      * This is also known as "SCREAMING_SNAKE_CASE".
      */
-    UPPER_UNDERSCORE;
+    UPPER_UNDERSCORE,
+
+    /**
+     * No transformation - returns the input string unchanged.
+     * Use this for exact matching without any case normalization.
+     */
+    @Incubating(since = "8.73.0")
+    EXACT;
 
     private static final Pattern CAMEL_CASE_SPLIT = Pattern.compile("[\\s_-]");
     private static final int uppercaseAbbreviationMinLength = 3;
@@ -191,6 +199,80 @@ public static boolean matchesRegexRelaxedBinding(String test, String pattern) {
         return LOWER_CAMEL.format(test).matches(LOWER_CAMEL.format(pattern));
     }
 
+    /**
+     * Compiles a pattern for efficient repeated matching against this convention.
+     * The pattern is formatted once during compilation, avoiding repeated conversions
+     * when matching multiple test strings.
+     *
+     * @param pattern The pattern to compile
+     * @return A compiled pattern that can be used for efficient matching
+     * @see #matchesGlobRelaxedBinding(String, String)
+     */
+    @Incubating(since = "8.73.0")
+    public Compiled compile(String pattern) {
+        return new Compiled(this, pattern);
+    }
+
+    /**
+     * A compiled pattern for efficient repeated matching.
+     * <p>
+     * This is useful when matching multiple test strings against a constant pattern.
+     * The pattern is converted to the target convention once during construction,
+     * avoiding repeated conversions when calling {@link #matchesGlob(String)} or {@link #matchesRegex(String)}.
+     *
+     * @see NameCaseConvention#compile(String)
+     */
+    @Incubating(since = "8.73.0")
+    public static class Compiled {
+        private final NameCaseConvention convention;
+        private final String formattedPattern;
+        private volatile @Nullable Pattern compiledRegex;
+
+        private Compiled(NameCaseConvention convention, String pattern) {
+            this.convention = convention;
+            this.formattedPattern = convention.format(pattern);
+        }
+
+        /**
+         * Tests whether the given string equals the compiled pattern after formatting.
+         *
+         * @param test The string to test
+         * @return {@code true} if the formatted test string equals the formatted pattern
+         */
+        public boolean matches(String test) {
+            return convention.format(test).equals(formattedPattern);
+        }
+
+        /**
+         * Tests whether the given string matches the compiled pattern using glob matching.
+         *
+         * @param test The string to test
+         * @return {@code true} if the test string matches the pattern
+         */
+        public boolean matchesGlob(String test) {
+            return StringUtils.matchesGlob(convention.format(test), formattedPattern);
+        }
+
+        /**
+         * Tests whether the given string matches the compiled pattern using regex matching.
+         *
+         * @param test The string to test
+         * @return {@code true} if the test string matches the pattern
+         */
+        public boolean matchesRegex(String test) {
+            Pattern p = compiledRegex;
+            if (p == null) {
+                synchronized (this) {
+                    p = compiledRegex;
+                    if (p == null) {
+                        compiledRegex = p = Pattern.compile(formattedPattern);
+                    }
+                }
+            }
+            return p.matcher(convention.format(test)).matches();
+        }
+    }
+
     private static String lowerHyphen(String str) {
         return nameCaseJoiner(str.replace('_', '-').replace(' ', '-'), true, '-');
     }
diff --git a/rewrite-properties/src/main/java/org/openrewrite/properties/ChangePropertyKey.java b/rewrite-properties/src/main/java/org/openrewrite/properties/ChangePropertyKey.java
@@ -58,31 +58,26 @@ public class ChangePropertyKey extends Recipe {
 
     @Override
     public TreeVisitor<?, ExecutionContext> getVisitor() {
-        return new ChangePropertyKeyVisitor<>();
-    }
-
-    public class ChangePropertyKeyVisitor<P> extends PropertiesVisitor<P> {
-        public ChangePropertyKeyVisitor() {
-        }
+        NameCaseConvention.Compiled keyMatcher = (!Boolean.FALSE.equals(relaxedBinding) ?
+                NameCaseConvention.LOWER_CAMEL :
+                NameCaseConvention.EXACT).compile(oldPropertyKey);
 
-        @Override
-        public Properties visitEntry(Properties.Entry entry, P p) {
-            if (Boolean.TRUE.equals(regex)) {
-                if (!Boolean.FALSE.equals(relaxedBinding) ?
-                        NameCaseConvention.matchesRegexRelaxedBinding(entry.getKey(), oldPropertyKey) :
-                        entry.getKey().matches(oldPropertyKey)) {
-                    entry = entry.withKey(entry.getKey().replaceFirst(oldPropertyKey, newPropertyKey))
-                            .withPrefix(entry.getPrefix());
-                }
-            } else {
-                if (!Boolean.FALSE.equals(relaxedBinding) ?
-                        NameCaseConvention.equalsRelaxedBinding(entry.getKey(), oldPropertyKey) :
-                        entry.getKey().equals(oldPropertyKey)) {
-                    entry = entry.withKey(newPropertyKey)
-                            .withPrefix(entry.getPrefix());
+        return new PropertiesVisitor<ExecutionContext>() {
+            @Override
+            public Properties visitEntry(Properties.Entry entry, ExecutionContext ctx) {
+                if (Boolean.TRUE.equals(regex)) {
+                    if (keyMatcher.matchesRegex(entry.getKey())) {
+                        entry = entry.withKey(entry.getKey().replaceFirst(oldPropertyKey, newPropertyKey))
+                                .withPrefix(entry.getPrefix());
+                    }
+                } else {
+                    if (keyMatcher.matches(entry.getKey())) {
+                        entry = entry.withKey(newPropertyKey)
+                                .withPrefix(entry.getPrefix());
+                    }
                 }
+                return super.visitEntry(entry, ctx);
             }
-            return super.visitEntry(entry, p);
-        }
+        };
     }
 }
diff --git a/rewrite-properties/src/main/java/org/openrewrite/properties/ChangePropertyValue.java b/rewrite-properties/src/main/java/org/openrewrite/properties/ChangePropertyValue.java
@@ -71,17 +71,26 @@ public Validated validate() {
 
     @Override
     public TreeVisitor<?, ExecutionContext> getVisitor() {
-        return new ChangePropertyValueVisitor<>();
+        return new ChangePropertyValueVisitor<>((!Boolean.FALSE.equals(relaxedBinding) ?
+                NameCaseConvention.LOWER_CAMEL :
+                NameCaseConvention.EXACT).compile(propertyKey));
     }
 
     public class ChangePropertyValueVisitor<P> extends PropertiesVisitor<P> {
+        private final NameCaseConvention.Compiled keyMatcher;
+
         public ChangePropertyValueVisitor() {
+            this(NameCaseConvention.EXACT.compile(propertyKey));
+        }
+
+        public ChangePropertyValueVisitor(NameCaseConvention.Compiled keyMatcher) {
+            this.keyMatcher = keyMatcher;
         }
 
         @Override
         public Properties visitEntry(Properties.Entry entry, P p) {
             Properties.Entry e = (Properties.Entry) super.visitEntry(entry, p);
-            if (matchesPropertyKey(e.getKey()) && matchesOldValue(e.getValue())) {
+            if (keyMatcher.matchesGlob(e.getKey()) && matchesOldValue(e.getValue())) {
                 Properties.Value updatedValue = updateValue(e.getValue());
                 if (updatedValue != null) {
                     e = e.withValue(updatedValue);
@@ -98,12 +107,6 @@ public Properties visitEntry(Properties.Entry entry, P p) {
             return updatedValue.getText().equals(value.getText()) ? null : updatedValue;
         }
 
-        private boolean matchesPropertyKey(String prop) {
-            return !Boolean.FALSE.equals(relaxedBinding) ?
-                    NameCaseConvention.matchesGlobRelaxedBinding(prop, propertyKey) :
-                    StringUtils.matchesGlob(prop, propertyKey);
-        }
-
         private boolean matchesOldValue(Properties.Value value) {
             return StringUtils.isNullOrEmpty(oldValue) ||
                    (Boolean.TRUE.equals(regex) ?
diff --git a/rewrite-properties/src/main/java/org/openrewrite/properties/search/FindProperties.java b/rewrite-properties/src/main/java/org/openrewrite/properties/search/FindProperties.java
@@ -61,11 +61,14 @@ public class FindProperties extends Recipe {
      * @return The set of found properties matching the propertyKey.
      */
     public static Set<Properties.Entry> find(Properties p, String propertyKey, @Nullable Boolean relaxedBinding) {
+        NameCaseConvention.Compiled keyMatcher = (!Boolean.FALSE.equals(relaxedBinding) ?
+                NameCaseConvention.LOWER_CAMEL :
+                NameCaseConvention.EXACT).compile(propertyKey);
+
         PropertiesVisitor<Set<Properties.Entry>> findVisitor = new PropertiesVisitor<Set<Properties.Entry>>() {
             @Override
             public Properties visitEntry(Properties.Entry entry, Set<Properties.Entry> ps) {
-                if (!Boolean.FALSE.equals(relaxedBinding) ? NameCaseConvention.matchesGlobRelaxedBinding(entry.getKey(), propertyKey) :
-                        StringUtils.matchesGlob(entry.getKey(), propertyKey)) {
+                if (keyMatcher.matchesGlob(entry.getKey())) {
                     ps.add(entry);
                 }
                 return super.visitEntry(entry, ps);
@@ -79,11 +82,14 @@ public Properties visitEntry(Properties.Entry entry, Set<Properties.Entry> ps) {
 
     @Override
     public TreeVisitor<?, ExecutionContext> getVisitor() {
+        NameCaseConvention.Compiled keyMatcher = (!Boolean.FALSE.equals(relaxedBinding) ?
+                NameCaseConvention.LOWER_CAMEL :
+                NameCaseConvention.EXACT).compile(propertyKey);
+
         return new PropertiesVisitor<ExecutionContext>() {
             @Override
             public Properties visitEntry(Properties.Entry entry, ExecutionContext ctx) {
-                if (!Boolean.FALSE.equals(relaxedBinding) ? NameCaseConvention.matchesGlobRelaxedBinding(entry.getKey(), propertyKey) :
-                        StringUtils.matchesGlob(entry.getKey(), propertyKey)) {
+                if (keyMatcher.matchesGlob(entry.getKey())) {
                     entry = entry.withValue(entry.getValue().withMarkers(entry.getValue().getMarkers()
                             .computeByType(new SearchResult(randomId(), null), (s1, s2) -> s1 == null ? s2 : s1)));
                 }
diff --git a/rewrite-yaml/src/main/java/org/openrewrite/yaml/ChangePropertyKey.java b/rewrite-yaml/src/main/java/org/openrewrite/yaml/ChangePropertyKey.java
@@ -21,7 +21,6 @@
 import org.openrewrite.*;
 import org.openrewrite.internal.ListUtils;
 import org.openrewrite.internal.NameCaseConvention;
-import org.openrewrite.internal.StringUtils;
 import org.openrewrite.marker.Markers;
 import org.openrewrite.yaml.search.FindProperty;
 import org.openrewrite.yaml.tree.Yaml;
@@ -92,6 +91,30 @@ public TreeVisitor<?, ExecutionContext> getVisitor() {
     }
 
     private class ChangePropertyKeyVisitor<P> extends YamlIsoVisitor<P> {
+        private final NameCaseConvention.Compiled oldKeyMatcher;
+        private final NameCaseConvention.Compiled oldKeyWildcardMatcher;
+        private final NameCaseConvention.Compiled newKeyMatcher;
+        private final NameCaseConvention.Compiled newKeyWildcardMatcher;
+        private final List<NameCaseConvention.Compiled> exceptMatchers;
+        private final List<NameCaseConvention.Compiled> exceptWildcardMatchers;
+
+        ChangePropertyKeyVisitor() {
+            NameCaseConvention convention = !Boolean.FALSE.equals(relaxedBinding) ?
+                    NameCaseConvention.LOWER_CAMEL :
+                    NameCaseConvention.EXACT;
+            this.oldKeyMatcher = convention.compile(oldPropertyKey);
+            this.oldKeyWildcardMatcher = convention.compile(oldPropertyKey + ".*");
+            this.newKeyMatcher = convention.compile(newPropertyKey);
+            this.newKeyWildcardMatcher = convention.compile(newPropertyKey + ".*");
+            List<String> excluded = excludedSubKeys();
+            this.exceptMatchers = new ArrayList<>(excluded.size());
+            this.exceptWildcardMatchers = new ArrayList<>(excluded.size());
+            for (String subkey : excluded) {
+                exceptMatchers.add(convention.compile(oldPropertyKey + "." + subkey));
+                exceptWildcardMatchers.add(convention.compile(oldPropertyKey + "." + subkey + ".*"));
+            }
+        }
+
         @Override
         public Yaml.Mapping.Entry visitMappingEntry(Yaml.Mapping.Entry entry, P p) {
             Yaml.Mapping.Entry e = super.visitMappingEntry(entry, p);
@@ -108,12 +131,14 @@ public Yaml.Mapping.Entry visitMappingEntry(Yaml.Mapping.Entry entry, P p) {
                     .collect(joining("."));
 
             if (newPropertyKey.startsWith(oldPropertyKey) &&
-                    (matches(prop, newPropertyKey) || matches(prop, newPropertyKey + ".*") || childMatchesNewPropertyKey(entry, prop))) {
+                    (newKeyMatcher.matchesGlob(prop) ||
+                     newKeyWildcardMatcher.matchesGlob(prop) ||
+                     childMatchesNewPropertyKey(entry, prop))) {
                 return e;
             }
 
             String propertyToTest = newPropertyKey;
-            if (matches(prop, oldPropertyKey)) {
+            if (oldKeyMatcher.matchesGlob(prop)) {
                 Iterator<Yaml.Mapping.Entry> propertyEntriesLeftToRight = propertyEntries.descendingIterator();
                 while (propertyEntriesLeftToRight.hasNext()) {
                     Yaml.Mapping.Entry propertyEntry = propertyEntriesLeftToRight.next();
@@ -132,9 +157,10 @@ public Yaml.Mapping.Entry visitMappingEntry(Yaml.Mapping.Entry entry, P p) {
                 }
             } else {
                 String parentProp = prop.substring(0, prop.length() - e.getKey().getValue().length()).replaceAll(".$", "");
-                if (matches(prop, oldPropertyKey + ".*") &&
-                        !(matches(parentProp, oldPropertyKey + ".*") || matches(parentProp, oldPropertyKey)) &&
-                        noneMatch(prop, oldPropertyKey, excludedSubKeys())) {
+                if (oldKeyWildcardMatcher.matchesGlob(prop) &&
+                        !(oldKeyWildcardMatcher.matchesGlob(parentProp) ||
+                          oldKeyMatcher.matchesGlob(parentProp)) &&
+                        noneMatchExcluded(prop)) {
                     Iterator<Yaml.Mapping.Entry> propertyEntriesLeftToRight = propertyEntries.descendingIterator();
                     while (propertyEntriesLeftToRight.hasNext()) {
                         Yaml.Mapping.Entry propertyEntry = propertyEntriesLeftToRight.next();
@@ -162,6 +188,15 @@ private boolean childMatchesNewPropertyKey(Yaml.Mapping.Entry entry, String curs
                     entry.getKey().getValue());
             return !FindProperty.find(entry, rescopedNewPropertyKey, relaxedBinding).isEmpty();
         }
+
+        private boolean noneMatchExcluded(String key) {
+            for (int i = 0; i < exceptMatchers.size(); i++) {
+                if (exceptMatchers.get(i).matchesGlob(key) || exceptWildcardMatchers.get(i).matchesGlob(key)) {
+                    return false;
+                }
+            }
+            return true;
+        }
     }
 
     private boolean hasNonExcludedValues(Yaml.Mapping.Entry propertyEntry) {
@@ -208,22 +243,6 @@ private static boolean noneMatch(Yaml.Mapping.Entry entry, List<String> subKeys)
         return true;
     }
 
-    private boolean noneMatch(String key, String basePattern, List<String> excludedSubKeys) {
-        for (String subkey : excludedSubKeys) {
-            String subKeyPattern = basePattern + "." + subkey;
-            if (matches(key, subKeyPattern) || matches(key, subKeyPattern + ".*")) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    private boolean matches(String string, String pattern) {
-        return !Boolean.FALSE.equals(relaxedBinding) ?
-                NameCaseConvention.matchesGlobRelaxedBinding(string, pattern) :
-                StringUtils.matchesGlob(string, pattern);
-    }
-
     private List<String> excludedSubKeys() {
         return except != null ? except : emptyList();
     }
diff --git a/rewrite-yaml/src/main/java/org/openrewrite/yaml/ChangePropertyValue.java b/rewrite-yaml/src/main/java/org/openrewrite/yaml/ChangePropertyValue.java
@@ -86,12 +86,16 @@ public Validated<Object> validate() {
 
     @Override
     public TreeVisitor<?, ExecutionContext> getVisitor() {
+        NameCaseConvention.Compiled keyMatcher = (!Boolean.FALSE.equals(relaxedBinding) ?
+                NameCaseConvention.LOWER_CAMEL :
+                NameCaseConvention.EXACT).compile(propertyKey);
+
         return Preconditions.check(new FindSourceFiles(filePattern), new YamlIsoVisitor<ExecutionContext>() {
             @Override
             public Yaml.Mapping.Entry visitMappingEntry(Yaml.Mapping.Entry entry, ExecutionContext ctx) {
                 Yaml.Mapping.Entry e = super.visitMappingEntry(entry, ctx);
                 String prop = getProperty(getCursor());
-                if (matchesPropertyKey(prop) && matchesOldValue(e.getValue())) {
+                if (keyMatcher.matchesGlob(prop) && matchesOldValue(e.getValue())) {
                     Yaml.Block updatedValue = updateValue(e.getValue());
                     if (updatedValue != null) {
                         e = e.withValue(updatedValue);
@@ -126,12 +130,6 @@ public Yaml.Mapping.Entry visitMappingEntry(Yaml.Mapping.Entry entry, ExecutionC
         return null;
     }
 
-    private boolean matchesPropertyKey(String prop) {
-        return !Boolean.FALSE.equals(relaxedBinding) ?
-                NameCaseConvention.matchesGlobRelaxedBinding(prop, propertyKey) :
-                StringUtils.matchesGlob(prop, propertyKey);
-    }
-
     private boolean matchesOldValue(Yaml.Block value) {
         if (value instanceof Yaml.Scalar) {
             Yaml.Scalar scalar = (Yaml.Scalar) value;
diff --git a/rewrite-yaml/src/main/java/org/openrewrite/yaml/search/FindProperty.java b/rewrite-yaml/src/main/java/org/openrewrite/yaml/search/FindProperty.java
