cfengine format: Fixed implementation to match test expectations

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Signed-off-by: Ole Herman Schumacher Elgesem <ole@northern.tech>

Author: olehermanse

src/cfengine_cli/format.py

@@ -536,6 +536,9 @@ def _can_single_line_promise(node: Node, indent: int, line_length: int) -> bool:
         return False
     if _contains_list_with_comment(children):
         return False
+    if any(c.type == "comment" for c in children):
+        # Comments between promiser and attribute force multi-line layout
+        return False
     attrs = [c for c in children if c.type == "attribute"]
     next_sib = node.next_named_sibling
     while next_sib and next_sib.type == "macro":
@@ -647,9 +650,21 @@ def _format_remaining_children(
     line_length: int,
 ) -> None:
     """Format promise children, skipping promiser/arrow/stakeholder parts."""
+    # When the promise was multi-lined because of comments between the
+    # promiser and the attribute, preserve the attribute's original spacing
+    # rather than running it through the spacing-normalizing stringifier.
+    # Only applies when the comments and attribute aren't separated by a
+    # macro — half-promise patterns still use the normal renderer.
+    verbatim_attr = any(c.type == "comment" for c in children) and not any(
+        c.type == "macro" for c in children
+    )
     for child in children:
         if child.type in PROMISER_PARTS:
             continue
+        if verbatim_attr and child.type == "attribute":
+            fmt.print(text(child), indent + 2)
+            fmt.update_previous(child)
+            continue
         _autoformat(child, fmt, line_length, indent)
 
 
@@ -712,6 +727,30 @@ def _needs_blank_line_before(child: Node, indent: int, line_length: int) -> bool
     if not prev:
         return False
 
+    # Preserve blank lines from the input source for transitions inside
+    # body/bundle/promise block bodies. Only applies when entering a new
+    # commented or class-guarded section — blank lines between bare
+    # attributes are stripped, and class guards with attached leading
+    # comments take their blank line before the comment.
+    parent = child.parent
+    if parent and parent.type in BLOCK_BODY_TYPES:
+        if child.type == "comment" and not _is_empty_comment(child):
+            next_sib = _skip_comments(child.next_named_sibling, "next")
+            # First comment of a chain leading into a class-guarded group:
+            # take the input blank line from anywhere along the transition.
+            if (
+                prev.type != "comment"
+                and next_sib is not None
+                and next_sib.type in CLASS_GUARD_TYPES
+                and next_sib.start_point[0] - prev.end_point[0] >= 2
+            ):
+                return True
+            if child.start_point[0] - prev.end_point[0] >= 2:
+                return True
+        elif child.type in CLASS_GUARD_TYPES and prev.type != "comment":
+            if child.start_point[0] - prev.end_point[0] >= 2:
+                return True
+
     if child.type == "bundle_section":
         return prev.type == "bundle_section"
 
@@ -740,9 +779,13 @@ def _needs_blank_line_before(child: Node, indent: int, line_length: int) -> bool
         return prev.type in {"promise", "half_promise", "class_guarded_promises"}
 
     if child.type == "comment":
+        if _is_empty_comment(child):
+            return False
+        # Top-level comment after a complete block — visually separates them
+        if prev.type in BLOCK_TYPES:
+            return True
         if prev.type not in {"promise", "half_promise"} | CLASS_GUARD_TYPES:
             return False
-        parent = child.parent
         if parent and parent.type in {"bundle_section", "class_guarded_promises"}:
             return True
         # Inside a body/promise block, a comment between two class guards
@@ -790,13 +833,14 @@ def _skip_comments(sibling: Node | None, direction: str = "next") -> Node | None
 def _comment_indent(node: Node, indent: int) -> int:
     """Compute indentation for a leaf comment based on its nearest non-comment neighbor."""
     nearest = _skip_comments(node.next_named_sibling, "next")
-    # A trailing comment whose previous sibling is a class-guarded group
-    # lines up with that group's contents (one extra indent level), as if
-    # it were the last comment inside the class guard.
+    # A trailing comment with no next sibling aligns with the deepest
+    # content at the end of the previous sibling subtree, so that comments
+    # appended after a class-guarded block visually belong to that block.
     if nearest is None:
-        nearest = _skip_comments(node.prev_named_sibling, "prev")
-        if nearest and nearest.type in CLASS_GUARD_TYPES:
-            return indent + 4
+        prev = _skip_comments(node.prev_named_sibling, "prev")
+        if prev and prev.type in INDENTED_TYPES:
+            return _trailing_comment_indent(prev, indent)
+        nearest = prev
     if nearest and nearest.type in INDENTED_TYPES:
         return indent + 2
     # No indented sibling found — if we're directly inside a block body,
@@ -806,6 +850,21 @@ def _comment_indent(node: Node, indent: int) -> int:
     return indent
 
 
+def _trailing_comment_indent(prev: Node, indent: int) -> int:
+    """Walk down the end of a sibling subtree to compute the deepest indent."""
+    while prev.type in INDENTED_TYPES:
+        indent += 2
+        deeper = None
+        for child in reversed(prev.children):
+            if child.type in INDENTED_TYPES:
+                deeper = child
+                break
+        if deeper is None:
+            break
+        prev = deeper
+    return indent
+
+
 # ---------------------------------------------------------------------------
 # Main recursive formatter
 # ---------------------------------------------------------------------------