DeleteProperty: preserve inline comments when deleting entries (#6797)

* DeleteProperty: preserve inline comments when deleting entries

When an entry was deleted from a mapping, the newline fix-up logic
checked `startsWithNewline(prefix)` to decide whether to prepend a
newline. Inline comments are stored in the prefix of the next element
(e.g. ` # comment\n    `), which starts with a space, not `\n`.
This caused the comment to be moved onto its own line.

Changed the check to `containsNewline(prefix)` so that prefixes
which already contain a line break (even if preceded by an inline
comment) are left intact.

* Show limitation of the current approach

* DeleteProperty: preserve inline comments when deleting last entry

When the deleted entry is the last in a mapping, its prefix contains
the inline comment from the previous entry's line. Transfer that
comment to the previous kept entry's scalar value so it is not lost.

* Use `ListUtils.mapLast`

---------

Co-authored-by: Tim te Beek <tim@moderne.io>

Author: Jenson3210

rewrite-yaml/src/main/java/org/openrewrite/yaml/DeleteProperty.java

@@ -129,7 +129,7 @@ public Yaml.Sequence visitSequence(Yaml.Sequence sequence, ExecutionContext ctx)
                     for (int i = 1; i < entries.size(); i++) {
                         Yaml.Sequence.Entry entry = entries.get(i);
                         Yaml.Sequence.Entry prevEntry = entries.get(i - 1);
-                        if (!startsWithNewline(entry.getPrefix()) && !endsWithBlockScalar(prevEntry.getBlock())) {
+                        if (!containsNewline(entry.getPrefix()) && !endsWithBlockScalar(prevEntry.getBlock())) {
                             if (fixedEntries == null) {
                                 fixedEntries = new ArrayList<>(entries);
                             }
@@ -165,6 +165,7 @@ public Yaml.Mapping visitMapping(Yaml.Mapping mapping, ExecutionContext ctx) {
                 List<Yaml.Mapping.Entry> entries = new ArrayList<>();
                 String firstDeletedPrefix = null;
                 boolean previousWasDeleted = false;
+                String trailingInlineComment = null;
                 for (Yaml.Mapping.Entry entry : m.getEntries()) {
                     if (ToBeRemoved.hasMarker(entry.getValue()) ||
                         ToBeRemoved.hasMarker(entry) ||
@@ -173,19 +174,38 @@ public Yaml.Mapping visitMapping(Yaml.Mapping mapping, ExecutionContext ctx) {
                         if (entries.isEmpty() && firstDeletedPrefix == null) {
                             firstDeletedPrefix = entry.getPrefix();
                         }
+                        // Capture inline comment from the first deleted entry after kept entries
+                        if (trailingInlineComment == null && !entries.isEmpty()) {
+                            trailingInlineComment = extractInlineComment(entry.getPrefix());
+                        }
                         changed = true;
                         previousWasDeleted = true;
                     } else {
                         if (entries.isEmpty() && firstDeletedPrefix != null && containsOnlyWhitespace(entry.getPrefix())) {
                             entry = entry.withPrefix(firstDeletedPrefix);
-                        } else if (previousWasDeleted && !entries.isEmpty() && !startsWithNewline(entry.getPrefix())) {
+                        } else if (previousWasDeleted && !entries.isEmpty() && !containsNewline(entry.getPrefix())) {
                             entry = entry.withPrefix("\n" + entry.getPrefix());
                         }
                         entries.add(entry);
                         previousWasDeleted = false;
+                        trailingInlineComment = null;
                     }
                 }
 
+                // Preserve inline comment from deleted trailing entries on the last kept entry
+                if (trailingInlineComment != null) {
+                    String comment = trailingInlineComment;
+                    entries = ListUtils.mapLast(entries, lastKept -> {
+                        if (lastKept.getValue() instanceof Yaml.Scalar &&
+                            ((Yaml.Scalar) lastKept.getValue()).getStyle() == Yaml.Scalar.Style.PLAIN) {
+                            Yaml.Scalar scalar = (Yaml.Scalar) lastKept.getValue();
+                            return lastKept.withValue(
+                                    scalar.withValue(scalar.getValue() + comment));
+                        }
+                        return lastKept;
+                    });
+                }
+
                 if (changed) {
                     m = m.withEntries(entries);
                     if (entries.isEmpty()) {
@@ -206,7 +226,7 @@ public Yaml.Mapping visitMapping(Yaml.Mapping mapping, ExecutionContext ctx) {
                     for (int i = 1; i < currentEntries.size(); i++) {
                         Yaml.Mapping.Entry entry = currentEntries.get(i);
                         Yaml.Mapping.Entry prevEntry = currentEntries.get(i - 1);
-                        if (!startsWithNewline(entry.getPrefix()) && !endsWithBlockScalar(prevEntry)) {
+                        if (!containsNewline(entry.getPrefix()) && !endsWithBlockScalar(prevEntry)) {
                             if (fixedEntries == null) {
                                 fixedEntries = new ArrayList<>(currentEntries);
                             }
@@ -238,8 +258,18 @@ private static boolean containsOnlyWhitespace(@Nullable String str) {
         return true;
     }
 
-    private static boolean startsWithNewline(@Nullable String str) {
-        return str != null && !str.isEmpty() && str.charAt(0) == '\n';
+    private static boolean containsNewline(@Nullable String str) {
+        return str != null && str.indexOf('\n') >= 0;
+    }
+
+    /**
+     * Extract an inline comment from a prefix string. Inline comments appear before the
+     * first newline in the prefix (e.g. {@code " # comment\n  "} → {@code " # comment"}).
+     */
+    private static @Nullable String extractInlineComment(String prefix) {
+        int newlineIndex = prefix.indexOf('\n');
+        String beforeNewline = newlineIndex >= 0 ? prefix.substring(0, newlineIndex) : prefix;
+        return beforeNewline.contains("#") ? beforeNewline : null;
     }
 
     private static boolean endsWithBlockScalar(Yaml.Mapping.Entry entry) {

rewrite-yaml/src/test/java/org/openrewrite/yaml/DeletePropertyKeyTest.java

@@ -544,4 +544,22 @@ void globPatternWithFoldedBlockScalarHigherParent() {
           )
         );
     }
+
+    @Test
+    void deleteLastEntryPreservesInlineCommentOnPreviousEntry() {
+        rewriteRun(
+          spec -> spec.recipe(new DeleteProperty("root.delete-me", null, null, null)),
+          yaml(
+            """
+              root:
+                keep: yes # inline comment
+                delete-me: val
+              """,
+            """
+              root:
+                keep: yes # inline comment
+              """
+          )
+        );
+    }
 }