openscad-parser 2.4.4__tar.gz → 2.4.6__tar.gz

{openscad_parser-2.4.4 → openscad_parser-2.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_parser
-Version: 2.4.4
+Version: 2.4.6
 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.4 → openscad_parser-2.4.6}/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.4 → openscad_parser-2.4.6}/pyproject.toml

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

{openscad_parser-2.4.4 → openscad_parser-2.4.6}/src/openscad_parser/ast/nodes.py

@@ -1350,7 +1350,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 +1379,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.4 → openscad_parser-2.4.6}/src/openscad_parser/ast/pretty_print.py

@@ -19,6 +19,9 @@ from .nodes import (
     ListComprehension,
     ListCompFor,
     ListCompCFor,
+    ListCompLet,
+    PositionalArgument,
+    NamedArgument,
 )
 
 
@@ -65,37 +68,92 @@ 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)
+        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})\n{pad}{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}"
+    if isinstance(elem, ListComprehension):
+        return _fmt_expr(elem, indent, w)
     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})"
 
 
+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_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_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)
+        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)
@@ -105,25 +163,28 @@ def _fmt_expr(expr, indent: int, w: int) -> str:
         return f"echo({args})\n{pad}{_fmt_expr(expr.body, indent, w)}"
     if isinstance(expr, LetOp):
         inner_pad = " " * (indent + w)
-        if len(expr.assignments) <= 1:
-            assigns = ", ".join(str(a) for a in expr.assignments)
-            return f"let({assigns})\n{pad}{_fmt_expr(expr.body, indent, w)}"
-        else:
-            assign_lines = (",\n" + inner_pad).join(str(a) for a in expr.assignments)
+        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)
+            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):
-        inline = str(expr)
-        if len(inline) + indent > _MULTILINE_CHAR_LIMIT:
-            inner_pad = " " * (indent + w)
-            pad = " " * indent
-            items = (",\n" + inner_pad).join(_fmt_list_elem(e, indent + w, w) for e in expr.elements)
+        inner_pad = " " * (indent + w)
+        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)
 
@@ -213,7 +274,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)
@@ -227,7 +291,13 @@ def _fmt_inst(node: ModuleInstantiation, indent: int, w: int, prefix: str = "")
         return f"{pad}{prefix}intersection_for ({assigns})" + _fmt_child(node.body, indent, w)
 
     if isinstance(node, ModularLet):
-        assigns = _join_str(_as_list(node.assignments))
+        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):