Add annotation support to ChangeSpringPropertyValue (#907)

* Add annotation support to ChangeSpringPropertyValue

Extend ChangeSpringPropertyValue to change property values in Java/Kotlin
annotations, mirroring the pattern used in ChangeSpringPropertyKey.

Supported annotations:
- @value("${key:defaultValue}") - changes the defaultValue after the colon
- @ConditionalOnProperty(name="key", havingValue="val") - changes havingValue
- @SpringBootTest(properties="key=value") - changes the value after =
- @TestPropertySource(properties="key=value") - changes the value after =

Features:
- Relaxed binding support for property key matching
- Regex replacement support with capture groups
- Proper escaping preservation for Kotlin's \$ syntax
- Idempotent transformations (won't change already-matching values)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

* Apply suggestions from code review

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

* Prune dead code paths

* No else after return

* Logically group tests

* Logically group methods

---------

Co-authored-by: Claude Opus 4.5 <[email protected]>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Author: 3 people

src/main/java/org/openrewrite/java/spring/ChangeSpringPropertyValue.java

@@ -19,10 +19,20 @@
 import lombok.Value;
 import org.jspecify.annotations.Nullable;
 import org.openrewrite.*;
+import org.openrewrite.internal.ListUtils;
+import org.openrewrite.internal.NameCaseConvention;
 import org.openrewrite.internal.StringUtils;
+import org.openrewrite.java.AnnotationMatcher;
+import org.openrewrite.java.JavaIsoVisitor;
+import org.openrewrite.java.search.UsesType;
+import org.openrewrite.java.tree.Expression;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaSourceFile;
+import org.openrewrite.kotlin.tree.K;
 import org.openrewrite.properties.tree.Properties;
 import org.openrewrite.yaml.tree.Yaml;
 
+import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 @EqualsAndHashCode(callSuper = false)
@@ -31,7 +41,8 @@ public class ChangeSpringPropertyValue extends Recipe {
 
     String displayName = "Change the value of a spring application property";
 
-    String description = "Change spring application property values existing in either Properties or Yaml files.";
+    String description = "Change Spring application property values existing in either Properties or YAML files, " +
+                         "and in `@Value`, `@ConditionalOnProperty`, `@SpringBootTest`, or `@TestPropertySource` annotations.";
 
     @Option(displayName = "Property key",
             description = "The name of the property key whose value is to be changed.",
@@ -75,13 +86,21 @@ public TreeVisitor<?, ExecutionContext> getVisitor() {
         Recipe changeProperties = new org.openrewrite.properties.ChangePropertyValue(propertyKey, newValue, oldValue, regex, relaxedBinding);
         String yamlValue = quoteValue(newValue) ? "\"" + newValue + "\"" : newValue;
         Recipe changeYaml = new org.openrewrite.yaml.ChangePropertyValue(propertyKey, yamlValue, oldValue, regex, relaxedBinding, null);
+        TreeVisitor<?, ExecutionContext> javaVisitor = Preconditions.check(Preconditions.or(
+                new UsesType<>("org.springframework.beans.factory.annotation.Value", false),
+                new UsesType<>("org.springframework.boot.autoconfigure.condition.ConditionalOnProperty", false),
+                new UsesType<>("org.springframework.boot..*Test", false),
+                new UsesType<>("org.springframework.test.context.TestPropertySource", false)
+        ), new JavaPropertyValueVisitor());
         return new TreeVisitor<Tree, ExecutionContext>() {
             @Override
             public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) {
                 if (tree instanceof Properties.File) {
                     tree = changeProperties.getVisitor().visit(tree, ctx);
                 } else if (tree instanceof Yaml.Documents) {
                     tree = changeYaml.getVisitor().visit(tree, ctx);
+                } else if (tree instanceof JavaSourceFile) {
+                    tree = javaVisitor.visit(tree, ctx);
                 }
                 return tree;
             }
@@ -92,4 +111,241 @@ public TreeVisitor<?, ExecutionContext> getVisitor() {
     private boolean quoteValue(String value) {
         return scalarNeedsAQuote.matcher(value).matches();
     }
+
+    private class JavaPropertyValueVisitor extends JavaIsoVisitor<ExecutionContext> {
+        private final AnnotationMatcher VALUE_MATCHER =
+                new AnnotationMatcher("@org.springframework.beans.factory.annotation.Value");
+        private final AnnotationMatcher CONDITIONAL_ON_PROPERTY_MATCHER =
+                new AnnotationMatcher("@org.springframework.boot.autoconfigure.condition.ConditionalOnProperty");
+        private final AnnotationMatcher SPRING_BOOT_TEST_MATCHER =
+                new AnnotationMatcher("@org.springframework.boot..*Test");
+        private final AnnotationMatcher TEST_PROPERTY_SOURCE_MATCHER =
+                new AnnotationMatcher("@org.springframework.test.context.TestPropertySource");
+
+        // Pattern to match ${key:defaultValue} in @Value annotations
+        private final Pattern valueAnnotationPattern = Pattern.compile("\\$\\{([^:}]+)(?::([^}]*))?\\}");
+        // Pattern to match key=value in test annotations
+        private final Pattern keyValuePattern = Pattern.compile("^([^=]+)=(.*)$");
+
+        @Override
+        public J.Annotation visitAnnotation(J.Annotation annotation, ExecutionContext ctx) {
+            J.Annotation a = super.visitAnnotation(annotation, ctx);
+
+            if (VALUE_MATCHER.matches(a)) {
+                a = handleValueAnnotation(a);
+            } else if (CONDITIONAL_ON_PROPERTY_MATCHER.matches(a)) {
+                a = handleConditionalOnPropertyAnnotation(a);
+            } else if (SPRING_BOOT_TEST_MATCHER.matches(a) || TEST_PROPERTY_SOURCE_MATCHER.matches(a)) {
+                a = handleTestPropertiesAnnotation(a);
+            }
+
+            return a;
+        }
+
+        private J.Annotation handleValueAnnotation(J.Annotation annotation) {
+            return annotation.withArguments(ListUtils.map(annotation.getArguments(), arg -> {
+                if (arg instanceof J.Literal) {
+                    return changeValueInValueAnnotation((J.Literal) arg);
+                }
+                return arg;
+            }));
+        }
+
+        private J.Literal changeValueInValueAnnotation(J.Literal literal) {
+            if (!(literal.getValue() instanceof String)) {
+                return literal;
+            }
+            String value = (String) literal.getValue();
+            String valueSource = literal.getValueSource();
+            Matcher matcher = valueAnnotationPattern.matcher(value);
+
+            boolean changed = false;
+            StringBuilder newValue = new StringBuilder();
+            int lastEnd = 0;
+
+            while (matcher.find()) {
+                String key = matcher.group(1);
+                String defaultValue = matcher.group(2);
+
+                if (matchesPropertyKey(key) && defaultValue != null && matchesOldValue(defaultValue)) {
+                    String computedNewValue = computeNewValue(defaultValue);
+                    if (!computedNewValue.equals(defaultValue)) {
+                        newValue.append(value, lastEnd, matcher.start());
+                        newValue.append("${").append(key).append(":").append(computedNewValue).append("}");
+                        lastEnd = matcher.end();
+
+                        // Also update valueSource by replacing the old default with new default
+                        // This preserves all other escaping (e.g., \$ in Kotlin)
+                        if (valueSource != null) {
+                            valueSource = valueSource.replace(defaultValue, computedNewValue);
+                        }
+
+                        changed = true;
+                    }
+                }
+            }
+
+            if (changed) {
+                newValue.append(value, lastEnd, value.length());
+                String newValueStr = newValue.toString();
+                if (valueSource == null) {
+                    valueSource = "\"" + newValueStr + "\"";
+                }
+                return literal.withValue(newValueStr).withValueSource(valueSource);
+            }
+            return literal;
+        }
+
+        private J.Annotation handleConditionalOnPropertyAnnotation(J.Annotation annotation) {
+            if (annotation.getArguments() == null) {
+                return annotation;
+            }
+
+            // First, find the property key from 'name' or 'value' attribute
+            String foundKey = null;
+            for (Expression arg : annotation.getArguments()) {
+                if (arg instanceof J.Assignment) {
+                    J.Assignment assignment = (J.Assignment) arg;
+                    String attrName = ((J.Identifier) assignment.getVariable()).getSimpleName();
+                    if ("name".equals(attrName) || "value".equals(attrName)) {
+                        if (assignment.getAssignment() instanceof J.Literal) {
+                            Object val = ((J.Literal) assignment.getAssignment()).getValue();
+                            if (val instanceof String) {
+                                foundKey = (String) val;
+                                break;
+                            }
+                        }
+                    }
+                } else if (arg instanceof J.Literal && ((J.Literal) arg).getValue() instanceof String) {
+                    // First unnamed argument is the property name
+                    foundKey = (String) ((J.Literal) arg).getValue();
+                    break;
+                }
+            }
+
+            if (foundKey == null || !matchesPropertyKey(foundKey)) {
+                return annotation;
+            }
+
+            // Now change the 'havingValue' attribute
+            return annotation.withArguments(ListUtils.map(annotation.getArguments(), arg -> {
+                if (arg instanceof J.Assignment) {
+                    J.Assignment assignment = (J.Assignment) arg;
+                    String attrName = ((J.Identifier) assignment.getVariable()).getSimpleName();
+                    if ("havingValue".equals(attrName)) {
+                        if (assignment.getAssignment() instanceof J.Literal) {
+                            J.Literal literal = (J.Literal) assignment.getAssignment();
+                            J.Literal newLiteral = changeValueInLiteral(literal);
+                            if (newLiteral != literal) {
+                                return assignment.withAssignment(newLiteral);
+                            }
+                        }
+                    }
+                }
+                return arg;
+            }));
+        }
+
+        private J.Literal changeValueInLiteral(J.Literal literal) {
+            String value = (String) literal.getValue();
+            if (matchesOldValue(value)) {
+                String computedNewValue = computeNewValue(value);
+                if (!computedNewValue.equals(value)) {
+                    return updateLiteral(literal, computedNewValue);
+                }
+            }
+            return literal;
+        }
+
+        private J.Annotation handleTestPropertiesAnnotation(J.Annotation annotation) {
+            return annotation.withArguments(ListUtils.map(annotation.getArguments(), arg -> {
+                if (arg instanceof J.Assignment) {
+                    J.Assignment assignment = (J.Assignment) arg;
+                    String attrName = ((J.Identifier) assignment.getVariable()).getSimpleName();
+                    if ("properties".equals(attrName)) {
+                        if (assignment.getAssignment() instanceof J.Literal) {
+                            J.Literal literal = (J.Literal) assignment.getAssignment();
+                            J.Literal newLiteral = changeValueInTestProperty(literal);
+                            return assignment.withAssignment(newLiteral);
+                        }
+                        if (assignment.getAssignment() instanceof J.NewArray) {
+                            J.NewArray array = (J.NewArray) assignment.getAssignment();
+                            return assignment.withAssignment(array.withInitializer(ListUtils.map(array.getInitializer(),
+                                    element -> element instanceof J.Literal ? changeValueInTestProperty((J.Literal) element) : element)));
+                        }
+                        if (assignment.getAssignment() instanceof K.ListLiteral) {
+                            K.ListLiteral listLiteral = (K.ListLiteral) assignment.getAssignment();
+                            return assignment.withAssignment(listLiteral.withElements(ListUtils.map(listLiteral.getElements(),
+                                    element -> element instanceof J.Literal ? changeValueInTestProperty((J.Literal) element) : element)));
+                        }
+                    }
+                }
+                return arg;
+            }));
+        }
+
+        private J.Literal changeValueInTestProperty(J.Literal literal) {
+            String value = (String) literal.getValue();
+            Matcher matcher = keyValuePattern.matcher(value);
+            if (matcher.matches()) {
+                String key = matcher.group(1);
+                String propValue = matcher.group(2);
+                if (matchesPropertyKey(key) && matchesOldValue(propValue)) {
+                    String computedNewValue = computeNewValue(propValue);
+                    if (!computedNewValue.equals(propValue)) {
+                        return updateLiteral(literal, key + "=" + computedNewValue);
+                    }
+                }
+            }
+            return literal;
+        }
+
+        private boolean matchesPropertyKey(String key) {
+            if (!Boolean.FALSE.equals(relaxedBinding)) {
+                // Normalize dots to hyphens for relaxed binding comparison
+                // (NameCaseConvention doesn't handle dots as separators)
+                String normalizedKey = key.replace('.', '-');
+                String normalizedPropertyKey = propertyKey.replace('.', '-');
+                return NameCaseConvention.equalsRelaxedBinding(normalizedKey, normalizedPropertyKey);
+            }
+            return key.equals(propertyKey);
+        }
+
+        private boolean matchesOldValue(String value) {
+            // Don't match if the value is already the target value (idempotency)
+            if (value.equals(newValue)) {
+                return false;
+            }
+            if (oldValue == null) {
+                return true;
+            }
+            if (Boolean.TRUE.equals(regex)) {
+                return Pattern.compile(oldValue).matcher(value).find();
+            }
+            return value.equals(oldValue);
+        }
+
+        private String computeNewValue(String currentValue) {
+            if (Boolean.TRUE.equals(regex) && oldValue != null) {
+                String computed = Pattern.compile(oldValue).matcher(currentValue).replaceFirst(newValue);
+                // Return original if no change to ensure idempotency
+                return computed.equals(currentValue) ? currentValue : computed;
+            }
+            return newValue;
+        }
+
+        private J.Literal updateLiteral(J.Literal literal, String newValueStr) {
+            String valueSource = literal.getValueSource();
+            if (valueSource == null) {
+                return literal.withValue(newValueStr).withValueSource("\"" + newValueStr + "\"");
+            }
+            // Handle escaping for the valueSource
+            char quote = valueSource.charAt(0);
+            String escapedValue = newValueStr.replace("\\", "\\\\");
+            if (quote == '"') {
+                escapedValue = escapedValue.replace("\"", "\\\"");
+            }
+            return literal.withValue(newValueStr).withValueSource(quote + escapedValue + quote);
+        }
+    }
 }