openscad-parser 2.4.3__tar.gz → 2.4.5__tar.gz

{openscad_parser-2.4.3 → openscad_parser-2.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_parser
-Version: 2.4.3
+Version: 2.4.5
 Summary: A PEG parser to read OpenSCAD language source code, with optional AST tree generation.
 Keywords: openscad,openscad parser,parser
 Author: Revar Desmera

{openscad_parser-2.4.3 → openscad_parser-2.4.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "openscad_parser"
-version = "2.4.3"
+version = "2.4.5"
 description = "A PEG parser to read OpenSCAD language source code, with optional AST tree generation."
 readme = "README.rst"
 authors = [

{openscad_parser-2.4.3 → openscad_parser-2.4.5}/src/openscad_parser/ast/nodes.py

@@ -193,7 +193,7 @@ class BooleanLiteral(Primary):
     val: bool
 
     def __str__(self):
-        return str(self.val)
+        return "true" if self.val else "false"
 
 
 @dataclass
@@ -235,7 +235,8 @@ class ParameterDeclaration(ASTNode):
     default: Expression|None
 
     def __str__(self):
-        return f"{self.name}{f' = {self.default}' if self.default else '' }"
+        has_default = self.default is not None and not isinstance(self.default, UndefinedLiteral)
+        return f"{self.name}{f'={self.default}' if has_default else ''}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -469,21 +470,21 @@ class AssertOp(Expression):
 @dataclass
 class UnaryMinusOp(Expression):
     """Represents an OpenSCAD unary minus (negation) operation.
-    
+
     Negates a numeric expression, making positive values negative and vice versa.
-    
+
     Examples:
         -5                             // Result: -5
         -x                             // Negate variable
         -(x + y)                       // Negate expression
-    
+
     Attributes:
         expr: The expression to negate.
     """
     expr: Expression
 
     def __str__(self):
-        return f"-{self.expr}"
+        return f"-{_lp(self.expr, _prec(self))}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -493,15 +494,15 @@ class UnaryMinusOp(Expression):
 @dataclass
 class AdditionOp(Expression):
     """Represents an OpenSCAD addition operation.
-    
+
     Performs arithmetic addition of two expressions. Can be used with numbers
     or vectors (element-wise addition for vectors).
-    
+
     Examples:
         1 + 2                          // Result: 3
         [1, 2, 3] + [4, 5, 6]         // Result: [5, 7, 9]
         x + y                          // Variable addition
-    
+
     Attributes:
         left: The left operand expression.
         right: The right operand expression.
@@ -510,7 +511,8 @@ class AdditionOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} + {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} + {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -538,7 +540,8 @@ class SubtractionOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} - {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} - {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -566,7 +569,8 @@ class MultiplicationOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} * {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} * {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -594,7 +598,8 @@ class DivisionOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} / {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} / {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -621,7 +626,8 @@ class ModuloOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} % {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} % {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -648,7 +654,8 @@ class ExponentOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} ^ {self.right}"
+        p = _prec(self)
+        return f"{_rp(self.left, p)} ^ {_lp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -675,7 +682,8 @@ class BitwiseAndOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} & {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} & {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -702,7 +710,8 @@ class BitwiseOrOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} | {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} | {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -726,7 +735,7 @@ class BitwiseNotOp(Expression):
     expr: Expression
 
     def __str__(self):
-        return f"~{self.expr}"
+        return f"~{_lp(self.expr, _prec(self))}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -752,7 +761,8 @@ class BitwiseShiftLeftOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} << {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} << {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -779,7 +789,8 @@ class BitwiseShiftRightOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} >> {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} >> {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -807,7 +818,8 @@ class LogicalAndOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} && {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} && {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -835,7 +847,8 @@ class LogicalOrOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} || {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} || {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -861,7 +874,7 @@ class LogicalNotOp(Expression):
     expr: Expression
 
     def __str__(self):
-        return f"!{self.expr}"
+        return f"!{_lp(self.expr, _prec(self))}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -918,7 +931,8 @@ class EqualityOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} == {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} == {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -945,7 +959,8 @@ class InequalityOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} != {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} != {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -972,7 +987,8 @@ class GreaterThanOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} > {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} > {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -999,7 +1015,8 @@ class GreaterThanOrEqualOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} >= {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} >= {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -1026,7 +1043,8 @@ class LessThanOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} < {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} < {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -1053,7 +1071,8 @@ class LessThanOrEqualOp(Expression):
     right: Expression
 
     def __str__(self):
-        return f"{self.left} <= {self.right}"
+        p = _prec(self)
+        return f"{_lp(self.left, p)} <= {_rp(self.right, p)}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -1892,6 +1911,46 @@ class IncludeStatement(ASTNode):
         return f"include <{self.filepath.val}>"
 
 
+# ---------------------------------------------------------------------------
+# Operator precedence helpers (used by __str__ methods to emit parentheses)
+# ---------------------------------------------------------------------------
+
+_PREC: dict[type, int] = {
+    # loosest
+    TernaryOp: 10,
+    LogicalOrOp: 20,
+    LogicalAndOp: 30,
+    EqualityOp: 40, InequalityOp: 40,
+    LessThanOp: 50, LessThanOrEqualOp: 50, GreaterThanOp: 50, GreaterThanOrEqualOp: 50,
+    BitwiseOrOp: 55,
+    BitwiseAndOp: 57,
+    BitwiseShiftLeftOp: 58, BitwiseShiftRightOp: 58,
+    AdditionOp: 60, SubtractionOp: 60,
+    MultiplicationOp: 70, DivisionOp: 70, ModuloOp: 70,
+    UnaryMinusOp: 80, LogicalNotOp: 80, BitwiseNotOp: 80,
+    ExponentOp: 90,
+    # tightest — primary expressions (literals, identifiers, calls, etc.) default to 99
+}
+
+
+def _prec(node) -> int:
+    return _PREC.get(type(node), 99)
+
+
+def _lp(child, parent_prec: int) -> str:
+    """Left-operand: parenthesize when child binds strictly looser than parent."""
+    return f"({child})" if _prec(child) < parent_prec else str(child)
+
+
+def _rp(child, parent_prec: int) -> str:
+    """Right-operand: parenthesize when child binds looser than OR equal to parent.
+
+    The stricter rule is needed for left-associative operators so that
+    ``a - (b - c)`` is not flattened to ``a - b - c``.
+    """
+    return f"({child})" if _prec(child) <= parent_prec else str(child)
+
+
 def _collect_hoisted_declarations(nodes, scope: "Scope") -> None:
     """Scan a list of nodes and register assignments, functions, and modules in scope.
 

openscad_parser-2.4.5/src/openscad_parser/ast/pretty_print.py

@@ -0,0 +1,286 @@
+"""Pretty-printer: convert an OpenSCAD AST back to formatted source code."""
+from __future__ import annotations
+from .nodes import (
+    ASTNode, Assignment, FunctionDeclaration, ModuleDeclaration,
+    UseStatement, IncludeStatement,
+    ModuleInstantiation,
+    ModularCall, ModularFor,
+    ModularIntersectionFor,
+    ModularLet, ModularEcho, ModularAssert,
+    ModularIf, ModularIfElse,
+    ModularModifierShowOnly, ModularModifierHighlight,
+    ModularModifierBackground, ModularModifierDisable,
+    CommentLine, CommentSpan,
+    TernaryOp,
+    EchoOp,
+    AssertOp,
+    LetOp,
+    PrimaryCall,
+    ListComprehension,
+    ListCompFor,
+    ListCompCFor,
+    ListCompLet,
+)
+
+
+def to_openscad(nodes: list[ASTNode], indent_width: int = 4) -> str:
+    """Convert a list of AST nodes to formatted OpenSCAD source code.
+
+    Args:
+        nodes: The AST nodes to format (top-level statements).
+        indent_width: Number of spaces per indentation level (default: 4).
+
+    Returns:
+        Formatted OpenSCAD source code as a string.
+    """
+    parts = []
+    prev_complex = False
+    for node in nodes:
+        is_complex = isinstance(node, (ModuleDeclaration, FunctionDeclaration))
+        if parts and (is_complex or prev_complex):
+            parts.append("")
+        parts.append(_fmt_node(node, 0, indent_width))
+        prev_complex = is_complex
+    return "\n".join(parts)
+
+
+# Line length beyond which call arguments are formatted one-per-line.
+_MULTILINE_CHAR_LIMIT = 100
+
+# --- helpers ---
+
+def _as_list(val) -> list:
+    if isinstance(val, list):
+        return val
+    if val is None:
+        return []
+    return [val]
+
+
+def _join_str(items) -> str:
+    return ", ".join(str(i) for i in items)
+
+
+def _fmt_list_elem(elem, indent: int, w: int) -> str:
+    """Format a list comprehension element, placing the body on a new line for for loops."""
+    pad = " " * indent
+    inner_pad = " " * (indent + w)
+    if isinstance(elem, ListCompFor):
+        assigns_inline = ", ".join(str(a) for a in elem.assignments)
+        body = _fmt_list_elem(elem.body, indent + w, w)
+        if len(f"for ({assigns_inline})") + indent > _MULTILINE_CHAR_LIMIT:
+            assign_lines = (",\n" + inner_pad).join(str(a) for a in elem.assignments)
+            return f"for (\n{inner_pad}{assign_lines}\n{pad})\n{inner_pad}{body}"
+        return f"for ({assigns_inline})\n{inner_pad}{body}"
+    if isinstance(elem, ListCompCFor):
+        inits = ", ".join(str(a) for a in elem.inits)
+        incrs = ", ".join(str(a) for a in elem.incrs)
+        body = _fmt_list_elem(elem.body, indent + w, w)
+        return f"for ({inits}; {elem.condition}; {incrs})\n{inner_pad}{body}"
+    if isinstance(elem, ListCompLet):
+        formatted = [_fmt_assign(a, indent + w, w) for a in elem.assignments]
+        body = _fmt_list_elem(elem.body, indent, w)
+        if len(formatted) > 1 or any("\n" in fa for fa in formatted):
+            assign_lines = (",\n" + inner_pad).join(formatted)
+            return f"let(\n{inner_pad}{assign_lines}\n{pad})\n{pad}{body}"
+        assigns = ", ".join(formatted)
+        return f"let({assigns}) {body}"
+    if isinstance(elem, LetOp):
+        formatted = [_fmt_assign(a, indent + w, w) for a in elem.assignments]
+        body = str(elem.body)
+        if len(formatted) > 1 or any("\n" in fa for fa in formatted):
+            assign_lines = (",\n" + inner_pad).join(formatted)
+            return f"let(\n{inner_pad}{assign_lines}\n{pad})\n{pad}{body}"
+        assigns = ", ".join(formatted)
+        return f"let({assigns}) {body}"
+    return str(elem)
+
+
+def _fmt_multiline_args(head: str, args: list, indent: int, w: int) -> str:
+    """Format `head(arg1, arg2, ...)` with each arg on its own line."""
+    inner_pad = " " * (indent + w)
+    pad = " " * indent
+    arg_lines = (",\n" + inner_pad).join(str(a) for a in args)
+    return f"{head}(\n{inner_pad}{arg_lines}\n{pad})"
+
+
+def _fmt_assign(assign, indent: int, w: int) -> str:
+    """Format an Assignment node, routing its expression through _fmt_expr."""
+    return f"{assign.name} = {_fmt_expr(assign.expr, indent, w)}"
+
+
+def _fmt_expr(expr, indent: int, w: int) -> str:
+    """Format an expression with indent-aware layout for ternary, assert, and echo."""
+    pad = " " * indent
+    if isinstance(expr, TernaryOp):
+        pad2 = " " * (indent + 2)
+        return (
+            f"{expr.condition}\n"
+            f"{pad2}? {_fmt_expr(expr.true_expr, indent + 2, w)}\n"
+            f"{pad2}: {_fmt_expr(expr.false_expr, indent + 2, w)}"
+        )
+    if isinstance(expr, AssertOp):
+        args = ", ".join(str(a) for a in expr.arguments)
+        return f"assert({args})\n{pad}{_fmt_expr(expr.body, indent, w)}"
+    if isinstance(expr, EchoOp):
+        args = ", ".join(str(a) for a in expr.arguments)
+        return f"echo({args})\n{pad}{_fmt_expr(expr.body, indent, w)}"
+    if isinstance(expr, LetOp):
+        inner_pad = " " * (indent + w)
+        formatted = [_fmt_assign(a, indent + w, w) for a in expr.assignments]
+        if len(formatted) > 1 or any("\n" in fa for fa in formatted):
+            assign_lines = (",\n" + inner_pad).join(formatted)
+            return (
+                f"let(\n{inner_pad}{assign_lines}\n{pad})\n"
+                f"{pad}{_fmt_expr(expr.body, indent, w)}"
+            )
+        assigns = ", ".join(formatted)
+        return f"let({assigns})\n{pad}{_fmt_expr(expr.body, indent, w)}"
+    if isinstance(expr, PrimaryCall):
+        inline = str(expr)
+        if len(inline) + indent > _MULTILINE_CHAR_LIMIT:
+            return _fmt_multiline_args(str(expr.left), expr.arguments, indent, w)
+    if isinstance(expr, ListComprehension):
+        inner_pad = " " * (indent + w)
+        let_multiline = any(
+            isinstance(e, (LetOp, ListCompLet)) and (
+                len(e.assignments) > 1 or
+                any("\n" in _fmt_assign(a, indent + w + w, w) for a in e.assignments)
+            )
+            for e in expr.elements
+        )
+        if len(str(expr)) + indent > _MULTILINE_CHAR_LIMIT or let_multiline:
+            formatted_elems = [_fmt_list_elem(e, indent + w, w) for e in expr.elements]
+            items = (",\n" + inner_pad).join(formatted_elems)
+            return f"[\n{inner_pad}{items}\n{pad}]"
+    return str(expr)
+
+
+def _fmt_node(node: ASTNode, indent: int, w: int) -> str:
+    """Format any top-level or block-body node."""
+    pad = " " * indent
+
+    if isinstance(node, CommentLine):
+        return f"{pad}//{node.text}"
+    if isinstance(node, CommentSpan):
+        return f"{pad}/*{node.text}*/"
+    if isinstance(node, UseStatement):
+        return f"{pad}use <{node.filepath.val}>"
+    if isinstance(node, IncludeStatement):
+        return f"{pad}include <{node.filepath.val}>"
+    if isinstance(node, Assignment):
+        return f"{pad}{node.name} = {_fmt_expr(node.expr, indent, w)};"
+    if isinstance(node, FunctionDeclaration):
+        head = f"{pad}function {node.name}"
+        params_inline = _join_str(node.parameters)
+        expr_pad = " " * (indent + w)
+        if len(f"{head}({params_inline}) =") > _MULTILINE_CHAR_LIMIT:
+            param_block = _fmt_multiline_args(head, node.parameters, indent, w)
+            return f"{param_block} =\n{expr_pad}{_fmt_expr(node.expr, indent + w, w)};"
+        return f"{head}({params_inline}) =\n{expr_pad}{_fmt_expr(node.expr, indent + w, w)};"
+    if isinstance(node, ModuleDeclaration):
+        head = f"{pad}module {node.name}"
+        params_inline = _join_str(node.parameters)
+        block = _fmt_block(node.children, indent, w)
+        if len(f"{head}({params_inline})") > _MULTILINE_CHAR_LIMIT:
+            param_block = _fmt_multiline_args(head, node.parameters, indent, w)
+            return f"{param_block} {block}"
+        return f"{head}({params_inline}) {block}"
+    if isinstance(node, ModuleInstantiation):
+        return _fmt_inst(node, indent, w)
+    return f"{pad}{node}"  # pragma: no cover
+
+
+def _fmt_block(nodes: list, indent: int, w: int) -> str:
+    """Format a list of nodes as a braced block."""
+    pad = " " * indent
+    if not nodes:
+        return "{}"
+    inner = "\n".join(_fmt_node(n, indent + w, w) for n in nodes)
+    return "{\n" + inner + "\n" + pad + "}"
+
+
+def _fmt_child(body, indent: int, w: int) -> str:
+    """Format the child body of a module instantiation.
+
+    Returns the tail string appended after the header:
+      - ``";"`` when there are no children
+      - ``"\\n    child;"`` for a single inline child
+      - ``" {\\n    ...\\n}"`` for a block of multiple children
+    """
+    nodes = _as_list(body)
+    pad = " " * indent
+
+    if not nodes:
+        return ";"
+    if len(nodes) == 1:
+        return "\n" + _fmt_inst(nodes[0], indent + w, w)
+    inner = "\n".join(_fmt_inst(n, indent + w, w) for n in nodes)
+    return " {\n" + inner + "\n" + pad + "}"
+
+
+def _fmt_inst(node: ModuleInstantiation, indent: int, w: int, prefix: str = "") -> str:
+    """Format a ModuleInstantiation node.
+
+    ``prefix`` accumulates modifier characters (``!``, ``#``, ``%``, ``*``)
+    so nested modifiers produce e.g. ``!#cube(10);``.
+    """
+    pad = " " * indent
+
+    # Modifiers: push prefix down to the wrapped node
+    if isinstance(node, ModularModifierShowOnly):
+        return _fmt_inst(node.child, indent, w, "!" + prefix)
+    if isinstance(node, ModularModifierHighlight):
+        return _fmt_inst(node.child, indent, w, "#" + prefix)
+    if isinstance(node, ModularModifierBackground):
+        return _fmt_inst(node.child, indent, w, "%" + prefix)
+    if isinstance(node, ModularModifierDisable):
+        return _fmt_inst(node.child, indent, w, "*" + prefix)
+
+    if isinstance(node, ModularCall):
+        head = f"{pad}{prefix}{node.name}"
+        inline = f"{head}({_join_str(node.arguments)})"
+        if len(inline) > _MULTILINE_CHAR_LIMIT:
+            call = _fmt_multiline_args(head, node.arguments, indent, w)
+        else:
+            call = inline
+        return call + _fmt_child(node.children, indent, w)
+
+    if isinstance(node, ModularFor):
+        assigns = _join_str(_as_list(node.assignments))
+        return f"{pad}{prefix}for ({assigns})" + _fmt_child(node.body, indent, w)
+
+    if isinstance(node, ModularIntersectionFor):
+        assigns = _join_str(_as_list(node.assignments))
+        return f"{pad}{prefix}intersection_for ({assigns})" + _fmt_child(node.body, indent, w)
+
+    if isinstance(node, ModularLet):
+        inner_pad = " " * (indent + w)
+        formatted = [_fmt_assign(a, indent + w, w) for a in _as_list(node.assignments)]
+        if len(formatted) > 1 or any("\n" in fa for fa in formatted):
+            assign_lines = (",\n" + inner_pad).join(formatted)
+            tail = _fmt_child(node.children, indent, w)
+            return f"{pad}{prefix}let (\n{inner_pad}{assign_lines}\n{pad}){tail}"
+        assigns = ", ".join(formatted)
+        return f"{pad}{prefix}let ({assigns})" + _fmt_child(node.children, indent, w)
+
+    if isinstance(node, ModularEcho):
+        args = _join_str(node.arguments)
+        return f"{pad}{prefix}echo({args})" + _fmt_child(node.children, indent, w)
+
+    if isinstance(node, ModularAssert):
+        args = _join_str(node.arguments)
+        return f"{pad}{prefix}assert({args})" + _fmt_child(node.children, indent, w)
+
+    if isinstance(node, ModularIf):
+        header = f"{pad}{prefix}if ({node.condition})"
+        return header + _fmt_child(node.true_branch, indent, w)
+
+    if isinstance(node, ModularIfElse):
+        header = f"{pad}{prefix}if ({node.condition})"
+        true_tail = _fmt_child(node.true_branch, indent, w)
+        false_tail = _fmt_child(node.false_branch, indent, w)
+        connector = " else" if true_tail.startswith(" {") else f"\n{pad}else"
+        return header + true_tail + connector + false_tail
+
+    return f"{pad}{prefix}{node};"  # pragma: no cover

openscad_parser-2.4.3/src/openscad_parser/ast/pretty_print.py

@@ -1,159 +0,0 @@
-"""Pretty-printer: convert an OpenSCAD AST back to formatted source code."""
-from __future__ import annotations
-from .nodes import (
-    ASTNode, Assignment, FunctionDeclaration, ModuleDeclaration,
-    UseStatement, IncludeStatement,
-    ModuleInstantiation,
-    ModularCall, ModularFor,
-    ModularIntersectionFor,
-    ModularLet, ModularEcho, ModularAssert,
-    ModularIf, ModularIfElse,
-    ModularModifierShowOnly, ModularModifierHighlight,
-    ModularModifierBackground, ModularModifierDisable,
-    CommentLine, CommentSpan,
-)
-
-
-def to_openscad(nodes: list[ASTNode], indent_width: int = 4) -> str:
-    """Convert a list of AST nodes to formatted OpenSCAD source code.
-
-    Args:
-        nodes: The AST nodes to format (top-level statements).
-        indent_width: Number of spaces per indentation level (default: 4).
-
-    Returns:
-        Formatted OpenSCAD source code as a string.
-    """
-    parts = []
-    prev_complex = False
-    for node in nodes:
-        is_complex = isinstance(node, (ModuleDeclaration, FunctionDeclaration))
-        if parts and (is_complex or prev_complex):
-            parts.append("")
-        parts.append(_fmt_node(node, 0, indent_width))
-        prev_complex = is_complex
-    return "\n".join(parts)
-
-
-# --- helpers ---
-
-def _as_list(val) -> list:
-    if isinstance(val, list):
-        return val
-    if val is None:
-        return []
-    return [val]
-
-
-def _join_str(items) -> str:
-    return ", ".join(str(i) for i in items)
-
-
-def _fmt_node(node: ASTNode, indent: int, w: int) -> str:
-    """Format any top-level or block-body node."""
-    pad = " " * indent
-
-    if isinstance(node, CommentLine):
-        return f"{pad}//{node.text}"
-    if isinstance(node, CommentSpan):
-        return f"{pad}/*{node.text}*/"
-    if isinstance(node, UseStatement):
-        return f"{pad}use <{node.filepath.val}>"
-    if isinstance(node, IncludeStatement):
-        return f"{pad}include <{node.filepath.val}>"
-    if isinstance(node, Assignment):
-        return f"{pad}{node.name} = {node.expr};"
-    if isinstance(node, FunctionDeclaration):
-        params = _join_str(node.parameters)
-        return f"{pad}function {node.name}({params}) = {node.expr};"
-    if isinstance(node, ModuleDeclaration):
-        params = _join_str(node.parameters)
-        block = _fmt_block(node.children, indent, w)
-        return f"{pad}module {node.name}({params}) {block}"
-    if isinstance(node, ModuleInstantiation):
-        return _fmt_inst(node, indent, w)
-    return f"{pad}{node}"  # pragma: no cover
-
-
-def _fmt_block(nodes: list, indent: int, w: int) -> str:
-    """Format a list of nodes as a braced block."""
-    pad = " " * indent
-    if not nodes:
-        return "{}"
-    inner = "\n".join(_fmt_node(n, indent + w, w) for n in nodes)
-    return "{\n" + inner + "\n" + pad + "}"
-
-
-def _fmt_child(body, indent: int, w: int) -> str:
-    """Format the child body of a module instantiation.
-
-    Returns the tail string appended after the header:
-      - ``";"`` when there are no children
-      - ``"\\n    child;"`` for a single inline child
-      - ``" {\\n    ...\\n}"`` for a block of multiple children
-    """
-    nodes = _as_list(body)
-    pad = " " * indent
-
-    if not nodes:
-        return ";"
-    if len(nodes) == 1:
-        return "\n" + _fmt_inst(nodes[0], indent + w, w)
-    inner = "\n".join(_fmt_inst(n, indent + w, w) for n in nodes)
-    return " {\n" + inner + "\n" + pad + "}"
-
-
-def _fmt_inst(node: ModuleInstantiation, indent: int, w: int, prefix: str = "") -> str:
-    """Format a ModuleInstantiation node.
-
-    ``prefix`` accumulates modifier characters (``!``, ``#``, ``%``, ``*``)
-    so nested modifiers produce e.g. ``!#cube(10);``.
-    """
-    pad = " " * indent
-
-    # Modifiers: push prefix down to the wrapped node
-    if isinstance(node, ModularModifierShowOnly):
-        return _fmt_inst(node.child, indent, w, "!" + prefix)
-    if isinstance(node, ModularModifierHighlight):
-        return _fmt_inst(node.child, indent, w, "#" + prefix)
-    if isinstance(node, ModularModifierBackground):
-        return _fmt_inst(node.child, indent, w, "%" + prefix)
-    if isinstance(node, ModularModifierDisable):
-        return _fmt_inst(node.child, indent, w, "*" + prefix)
-
-    if isinstance(node, ModularCall):
-        args = _join_str(node.arguments)
-        return f"{pad}{prefix}{node.name}({args})" + _fmt_child(node.children, indent, w)
-
-    if isinstance(node, ModularFor):
-        assigns = _join_str(_as_list(node.assignments))
-        return f"{pad}{prefix}for ({assigns})" + _fmt_child(node.body, indent, w)
-
-    if isinstance(node, ModularIntersectionFor):
-        assigns = _join_str(_as_list(node.assignments))
-        return f"{pad}{prefix}intersection_for ({assigns})" + _fmt_child(node.body, indent, w)
-
-    if isinstance(node, ModularLet):
-        assigns = _join_str(_as_list(node.assignments))
-        return f"{pad}{prefix}let ({assigns})" + _fmt_child(node.children, indent, w)
-
-    if isinstance(node, ModularEcho):
-        args = _join_str(node.arguments)
-        return f"{pad}{prefix}echo({args})" + _fmt_child(node.children, indent, w)
-
-    if isinstance(node, ModularAssert):
-        args = _join_str(node.arguments)
-        return f"{pad}{prefix}assert({args})" + _fmt_child(node.children, indent, w)
-
-    if isinstance(node, ModularIf):
-        header = f"{pad}{prefix}if ({node.condition})"
-        return header + _fmt_child(node.true_branch, indent, w)
-
-    if isinstance(node, ModularIfElse):
-        header = f"{pad}{prefix}if ({node.condition})"
-        true_tail = _fmt_child(node.true_branch, indent, w)
-        false_tail = _fmt_child(node.false_branch, indent, w)
-        connector = " else" if true_tail.startswith(" {") else f"\n{pad}else"
-        return header + true_tail + connector + false_tail
-
-    return f"{pad}{prefix}{node};"  # pragma: no cover