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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_parser
-Version: 2.4.5
+Version: 2.4.7
 Summary: A PEG parser to read OpenSCAD language source code, with optional AST tree generation.
 Keywords: openscad,openscad parser,parser
 Author: Revar Desmera
@@ -65,7 +65,7 @@ Features
 - AST tree can contain comment nodes (single-line and multi-line)
 - AST tree uses dataclasses and can be pickled/unpickled for caching/serialization
 - JSON and YAML serialization/deserialization of AST trees
-- Pretty-printer that converts an AST back to formatted OpenSCAD source (``to_openscad()``)
+- Pretty-printer that converts an AST back to formatted OpenSCAD source (``to_openscad()``) with correct operator-precedence parenthesization
 - Command-line interface (``openscad-parser``) for JSON/YAML/formatted output
 
 Installation
@@ -441,8 +441,8 @@ List Comprehensions
 - ``ListComprehension(elements: list[VectorElement])``: Vector/list literals ``[elements]``
 - ``ListCompFor(assignments: list[Assignment], body: VectorElement)``: for loops in list comprehensions ``for(assignments) body``
 - ``ListCompCFor(inits: list[Assignment], condition: Expression, incrs: list[Assignment], body: VectorElement)``: C-style for loops in list comprehensions ``for(inits; condition; incrs) body``
-- ``ListCompIf(condition: Expression, true_expr: VectorElement)``: Conditional inclusion without else ``if(condition) true_expr``
-- ``ListCompIfElse(condition: Expression, true_expr: VectorElement, false_expr: VectorElement)``: Conditional inclusion with else ``if(condition) true_expr else false_expr``
+- ``ListCompIf(condition: Expression, true_expr: VectorElement)``: Conditional inclusion without else ``if (condition) true_expr``
+- ``ListCompIfElse(condition: Expression, true_expr: VectorElement, false_expr: VectorElement)``: Conditional inclusion with else ``if (condition) true_expr else false_expr``
 - ``ListCompLet(assignments: list[Assignment], body: VectorElement)``: let expressions in list comprehensions ``let(assignments) body``
 - ``ListCompEach(body: VectorElement)``: each expressions (flattens nested lists) ``each body``
 
@@ -805,7 +805,7 @@ The ``to_openscad()`` function converts an AST back to formatted OpenSCAD source
 
     formatted = to_openscad(ast)
     # module box(w, h) {
-    #     cube([w, h, 1.0]);
+    #     cube([w, h, 1]);
     # }
     print(formatted)
 
@@ -822,6 +822,12 @@ control structures, modifiers, list comprehensions, and comments.
 
     - Blank lines are inserted before and after module/function declarations.
     - Single-child module instantiations are formatted inline; multiple children use a block.
+    - Operator precedence is preserved — parentheses are re-inserted exactly where needed.
+    - Boolean literals are always written as ``true`` / ``false``.
+    - Ternary expressions are formatted across three lines (``condition``, ``? true``, ``: false``); block-formatted branches (``let``, ``assert``, ``echo``, list comprehensions, long calls) align their closing delimiter with their visual keyword column.
+    - ``let()``, ``assert()``, and ``echo()`` expressions place their body on the next line.
+    - List comprehensions containing ``for`` loops always expand to block form; ``if (condition)`` elements include parentheses around the condition.
+    - Long argument/parameter lists (> 100 characters) are formatted one argument per line, with each argument expression individually reformatted (ternaries, let, list comprehensions, nested long calls).
     - Comments are preserved when the AST was parsed with ``include_comments=True``.
 
 Controlling indentation::

{openscad_parser-2.4.5 → openscad_parser-2.4.7}/README.rst

@@ -22,7 +22,7 @@ Features
 - AST tree can contain comment nodes (single-line and multi-line)
 - AST tree uses dataclasses and can be pickled/unpickled for caching/serialization
 - JSON and YAML serialization/deserialization of AST trees
-- Pretty-printer that converts an AST back to formatted OpenSCAD source (``to_openscad()``)
+- Pretty-printer that converts an AST back to formatted OpenSCAD source (``to_openscad()``) with correct operator-precedence parenthesization
 - Command-line interface (``openscad-parser``) for JSON/YAML/formatted output
 
 Installation
@@ -398,8 +398,8 @@ List Comprehensions
 - ``ListComprehension(elements: list[VectorElement])``: Vector/list literals ``[elements]``
 - ``ListCompFor(assignments: list[Assignment], body: VectorElement)``: for loops in list comprehensions ``for(assignments) body``
 - ``ListCompCFor(inits: list[Assignment], condition: Expression, incrs: list[Assignment], body: VectorElement)``: C-style for loops in list comprehensions ``for(inits; condition; incrs) body``
-- ``ListCompIf(condition: Expression, true_expr: VectorElement)``: Conditional inclusion without else ``if(condition) true_expr``
-- ``ListCompIfElse(condition: Expression, true_expr: VectorElement, false_expr: VectorElement)``: Conditional inclusion with else ``if(condition) true_expr else false_expr``
+- ``ListCompIf(condition: Expression, true_expr: VectorElement)``: Conditional inclusion without else ``if (condition) true_expr``
+- ``ListCompIfElse(condition: Expression, true_expr: VectorElement, false_expr: VectorElement)``: Conditional inclusion with else ``if (condition) true_expr else false_expr``
 - ``ListCompLet(assignments: list[Assignment], body: VectorElement)``: let expressions in list comprehensions ``let(assignments) body``
 - ``ListCompEach(body: VectorElement)``: each expressions (flattens nested lists) ``each body``
 
@@ -762,7 +762,7 @@ The ``to_openscad()`` function converts an AST back to formatted OpenSCAD source
 
     formatted = to_openscad(ast)
     # module box(w, h) {
-    #     cube([w, h, 1.0]);
+    #     cube([w, h, 1]);
     # }
     print(formatted)
 
@@ -779,6 +779,12 @@ control structures, modifiers, list comprehensions, and comments.
 
     - Blank lines are inserted before and after module/function declarations.
     - Single-child module instantiations are formatted inline; multiple children use a block.
+    - Operator precedence is preserved — parentheses are re-inserted exactly where needed.
+    - Boolean literals are always written as ``true`` / ``false``.
+    - Ternary expressions are formatted across three lines (``condition``, ``? true``, ``: false``); block-formatted branches (``let``, ``assert``, ``echo``, list comprehensions, long calls) align their closing delimiter with their visual keyword column.
+    - ``let()``, ``assert()``, and ``echo()`` expressions place their body on the next line.
+    - List comprehensions containing ``for`` loops always expand to block form; ``if (condition)`` elements include parentheses around the condition.
+    - Long argument/parameter lists (> 100 characters) are formatted one argument per line, with each argument expression individually reformatted (ternaries, let, list comprehensions, nested long calls).
     - Comments are preserved when the AST was parsed with ``include_comments=True``.
 
 Controlling indentation::

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

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

{openscad_parser-2.4.5 → openscad_parser-2.4.7}/src/openscad_parser/ast/builder.py

@@ -624,7 +624,7 @@ class ASTBuilderVisitor(PTNodeVisitor):
             arguments = children[0] if len(children) > 0 else []
             body = children[1] if len(children) > 1 else None
         if body is None:
-            raise ValueError("assert_expr should have an Expression body")
+            body = UndefinedLiteral(position=self._get_node_position(node))
         return AssertOp(arguments=arguments, body=body, position=self._get_node_position(node))
 
     def visit_echo_expr(self, node, children):
@@ -637,7 +637,7 @@ class ASTBuilderVisitor(PTNodeVisitor):
             arguments = children[0] if len(children) > 0 else []
             body = children[1] if len(children) > 1 else None
         if body is None:
-            raise ValueError("echo_expr should have an Expression body")
+            body = UndefinedLiteral(position=self._get_node_position(node))
         return EchoOp(arguments=arguments, body=body, position=self._get_node_position(node))
     
     def visit_ternary_expr(self, node, children):

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

@@ -430,7 +430,10 @@ class EchoOp(Expression):
     body: Expression
 
     def __str__(self):
-        return f"echo({', '.join(str(arg) for arg in self.arguments)}) {self.body}"
+        args = ', '.join(str(arg) for arg in self.arguments)
+        if isinstance(self.body, UndefinedLiteral):
+            return f"echo({args})"
+        return f"echo({args}) {self.body}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -458,7 +461,10 @@ class AssertOp(Expression):
     body: Expression
 
     def __str__(self):
-        return f"assert({', '.join(str(arg) for arg in self.arguments)}) {self.body}"
+        args = ', '.join(str(arg) for arg in self.arguments)
+        if isinstance(self.body, UndefinedLiteral):
+            return f"assert({args})"
+        return f"assert({args}) {self.body}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -1350,7 +1356,7 @@ class ListCompIf(VectorElement):
     true_expr: VectorElement
 
     def __str__(self):
-        return f"if {self.condition} {self.true_expr}"
+        return f"if ({self.condition}) {self.true_expr}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
@@ -1379,7 +1385,7 @@ class ListCompIfElse(VectorElement):
     false_expr: VectorElement
 
     def __str__(self):
-        return f"if {self.condition} {self.true_expr} else {self.false_expr}"
+        return f"if ({self.condition}) {self.true_expr} else {self.false_expr}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope

{openscad_parser-2.4.5 → openscad_parser-2.4.7}/src/openscad_parser/ast/pretty_print.py

@@ -15,11 +15,17 @@ from .nodes import (
     EchoOp,
     AssertOp,
     LetOp,
+    UndefinedLiteral,
     PrimaryCall,
     ListComprehension,
     ListCompFor,
     ListCompCFor,
     ListCompLet,
+    ListCompIf,
+    ListCompIfElse,
+    ListCompEach,
+    PositionalArgument,
+    NamedArgument,
 )
 
 
@@ -66,17 +72,33 @@ def _fmt_list_elem(elem, indent: int, w: int) -> str:
     pad = " " * indent
     inner_pad = " " * (indent + w)
     if isinstance(elem, ListCompFor):
-        assigns_inline = ", ".join(str(a) for a in elem.assignments)
+        formatted = [_fmt_assign(a, indent + w, w) 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)
+        assigns_inline = ", ".join(formatted)
+        if any("\n" in fa for fa in formatted) or len(f"for ({assigns_inline})") + indent > _MULTILINE_CHAR_LIMIT:
+            assign_lines = (",\n" + inner_pad).join(formatted)
             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)
+        fmt_inits = [_fmt_assign(a, indent + w, w) for a in elem.inits]
+        fmt_incrs = [_fmt_assign(a, indent + w, w) for a in elem.incrs]
+        inits_str = ", ".join(fmt_inits)
+        incrs_str = ", ".join(fmt_incrs)
+        cond_str = str(elem.condition)
         body = _fmt_list_elem(elem.body, indent + w, w)
-        return f"for ({inits}; {elem.condition}; {incrs})\n{inner_pad}{body}"
+        header = f"for ({inits_str}; {cond_str}; {incrs_str})"
+        any_multiline = (
+            any("\n" in fa for fa in fmt_inits) or
+            any("\n" in fa for fa in fmt_incrs) or
+            "\n" in cond_str
+        )
+        if any_multiline or len(header) + indent > _MULTILINE_CHAR_LIMIT:
+            return (
+                f"for (\n{inner_pad}{inits_str};\n"
+                f"{inner_pad}{cond_str};\n"
+                f"{inner_pad}{incrs_str}\n{pad})\n{inner_pad}{body}"
+            )
+        return f"{header}\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)
@@ -84,23 +106,40 @@ def _fmt_list_elem(elem, indent: int, w: int) -> str:
             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 f"let({assigns})\n{pad}{body}"
     if isinstance(elem, LetOp):
         formatted = [_fmt_assign(a, indent + w, w) for a in elem.assignments]
-        body = str(elem.body)
+        body = _fmt_expr(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}"
+        inline = f"let({assigns}) {body}"
+        if "\n" in body or len(inline) + indent > _MULTILINE_CHAR_LIMIT:
+            return f"let({assigns})\n{pad}{body}"
+        return inline
+    if isinstance(elem, ListComprehension):
+        return _fmt_expr(elem, indent, w)
+    if isinstance(elem, ListCompIf):
+        cond = str(elem.condition)
+        body = _fmt_list_elem(elem.true_expr, indent + w, w)
+        return f"if ({cond})\n{inner_pad}{body}"
+    if isinstance(elem, ListCompIfElse):
+        cond = str(elem.condition)
+        true_body = _fmt_list_elem(elem.true_expr, indent + w, w)
+        false_body = _fmt_list_elem(elem.false_expr, indent + w, w)
+        return f"if ({cond})\n{inner_pad}{true_body}\n{pad}else\n{inner_pad}{false_body}"
+    if isinstance(elem, ListCompEach):
+        body = _fmt_list_elem(elem.body, indent, w)
+        return f"each {body}"
     return str(elem)
 
 
-def _fmt_multiline_args(head: str, args: list, indent: int, w: int) -> str:
+def _fmt_multiline_args(head: str, args: list, indent: int, w: int, fmt_fn=str) -> 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)
+    arg_lines = (",\n" + inner_pad).join(fmt_fn(a) for a in args)
     return f"{head}(\n{inner_pad}{arg_lines}\n{pad})"
 
 
@@ -109,21 +148,74 @@ def _fmt_assign(assign, indent: int, w: int) -> str:
     return f"{assign.name} = {_fmt_expr(assign.expr, indent, w)}"
 
 
+def _fmt_argument(arg, indent: int, w: int) -> str:
+    """Format a call argument, routing its expression through _fmt_expr."""
+    if isinstance(arg, PositionalArgument):
+        return _fmt_expr(arg.expr, indent, w)
+    if isinstance(arg, NamedArgument):
+        return f"{arg.name}={_fmt_expr(arg.expr, indent, w)}"
+    return str(arg)
+
+
+def _fmt_ternary_chain(expr: TernaryOp, indent: int, w: int) -> str:
+    """Format a right-chain of ternaries with flat ? / : alignment.
+
+    All ': ' connectors stay at the same indent column as the conditions;
+    each true branch is on its own line at indent+w.  The '?' moves to
+    the end of the condition line rather than the beginning of the true-branch.
+
+        cond1?
+            true1
+        : cond2?
+            true2
+        : final_else
+    """
+    pad = " " * indent
+    inner_pad = " " * (indent + w)
+    parts = []
+    node: TernaryOp = expr
+    while isinstance(node, TernaryOp):
+        parts.append((node.condition, node.true_expr))
+        node = node.false_expr
+    final = node
+    lines = []
+    for i, (cond, true_expr) in enumerate(parts):
+        true_str = _fmt_expr(true_expr, indent + w, w)
+        prefix = "" if i == 0 else f"{pad}: "
+        lines.append(f"{prefix}{cond} ?\n{inner_pad}{true_str}")
+    lines.append(f"{pad}: {_fmt_expr(final, indent + w, w)}")
+    return "\n".join(lines)
+
+
 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):
+        # Right-chain of ternaries → flat cascade format
+        if isinstance(expr.false_expr, TernaryOp):
+            return _fmt_ternary_chain(expr, indent, w)
         pad2 = " " * (indent + 2)
+        def _fmt_branch(branch):
+            # Nested ternary: 2 spaces per nesting level
+            if isinstance(branch, TernaryOp):
+                return _fmt_expr(branch, indent + 2, w)
+            # All other expressions: their visual start is 2 chars into "? "/":", "
+            # so block content and closing delimiters align to indent + 4
+            return _fmt_expr(branch, indent + 4, w)
         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)}"
+            f"{pad2}? {_fmt_branch(expr.true_expr)}\n"
+            f"{pad2}: {_fmt_branch(expr.false_expr)}"
         )
     if isinstance(expr, AssertOp):
         args = ", ".join(str(a) for a in expr.arguments)
+        if isinstance(expr.body, UndefinedLiteral):
+            return f"assert({args})"
         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)
+        if isinstance(expr.body, UndefinedLiteral):
+            return f"echo({args})"
         return f"echo({args})\n{pad}{_fmt_expr(expr.body, indent, w)}"
     if isinstance(expr, LetOp):
         inner_pad = " " * (indent + w)
@@ -135,22 +227,19 @@ def _fmt_expr(expr, indent: int, w: int) -> str:
                 f"{pad}{_fmt_expr(expr.body, indent, w)}"
             )
         assigns = ", ".join(formatted)
-        return f"let({assigns})\n{pad}{_fmt_expr(expr.body, indent, w)}"
+        return f"let({assigns})\n{inner_pad}{_fmt_expr(expr.body, indent + w, 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)
+            return _fmt_multiline_args(
+                str(expr.left), expr.arguments, indent, w,
+                fmt_fn=lambda a: _fmt_argument(a, indent + w, 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]
+        formatted_elems = [_fmt_list_elem(e, indent + w, w) for e in expr.elements]
+        any_multiline = any("\n" in fe for fe in formatted_elems)
+        if len(str(expr)) + indent > _MULTILINE_CHAR_LIMIT or any_multiline:
             items = (",\n" + inner_pad).join(formatted_elems)
             return f"[\n{inner_pad}{items}\n{pad}]"
     return str(expr)
@@ -241,7 +330,10 @@ def _fmt_inst(node: ModuleInstantiation, indent: int, w: int, prefix: str = "")
         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)
+            call = _fmt_multiline_args(
+                head, node.arguments, indent, w,
+                fmt_fn=lambda a: _fmt_argument(a, indent + w, w),
+            )
         else:
             call = inline
         return call + _fmt_child(node.children, indent, w)
@@ -265,12 +357,24 @@ def _fmt_inst(node: ModuleInstantiation, indent: int, w: int, prefix: str = "")
         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)
+        head = f"{pad}{prefix}echo"
+        inline = f"{head}({_join_str(node.arguments)})"
+        if len(inline) > _MULTILINE_CHAR_LIMIT:
+            call = _fmt_multiline_args(head, node.arguments, indent, w,
+                                       fmt_fn=lambda a: _fmt_argument(a, indent + w, w))
+        else:
+            call = inline
+        return call + _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)
+        head = f"{pad}{prefix}assert"
+        inline = f"{head}({_join_str(node.arguments)})"
+        if len(inline) > _MULTILINE_CHAR_LIMIT:
+            call = _fmt_multiline_args(head, node.arguments, indent, w,
+                                       fmt_fn=lambda a: _fmt_argument(a, indent + w, w))
+        else:
+            call = inline
+        return call + _fmt_child(node.children, indent, w)
 
     if isinstance(node, ModularIf):
         header = f"{pad}{prefix}if ({node.condition})"