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

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

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

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

{openscad_parser-2.4.6 → openscad_parser-2.4.8}/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.6 → openscad_parser-2.4.8}/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

{openscad_parser-2.4.6 → openscad_parser-2.4.8}/src/openscad_parser/ast/pretty_print.py

@@ -15,11 +15,15 @@ from .nodes import (
     EchoOp,
     AssertOp,
     LetOp,
+    UndefinedLiteral,
     PrimaryCall,
     ListComprehension,
     ListCompFor,
     ListCompCFor,
     ListCompLet,
+    ListCompIf,
+    ListCompIfElse,
+    ListCompEach,
     PositionalArgument,
     NamedArgument,
 )
@@ -43,7 +47,27 @@ def to_openscad(nodes: list[ASTNode], indent_width: int = 4) -> str:
             parts.append("")
         parts.append(_fmt_node(node, 0, indent_width))
         prev_complex = is_complex
-    return "\n".join(parts)
+    return _coalesce_paren_bracket("\n".join(parts))
+
+
+def _coalesce_paren_bracket(text: str) -> str:
+    """Join consecutive lines where one is a bare ')' and the next starts with '['."""
+    lines = text.split("\n")
+    result = []
+    i = 0
+    while i < len(lines):
+        if (
+            i + 1 < len(lines)
+            and lines[i].strip() == ")"
+            and lines[i + 1].lstrip().startswith("[")
+        ):
+            indent = len(lines[i]) - len(lines[i].lstrip())
+            result.append(" " * indent + ") " + lines[i + 1].lstrip())
+            i += 2
+        else:
+            result.append(lines[i])
+            i += 1
+    return "\n".join(result)
 
 
 # Line length beyond which call arguments are formatted one-per-line.
@@ -105,14 +129,29 @@ def _fmt_list_elem(elem, indent: int, w: int) -> str:
         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)
 
 
@@ -138,10 +177,43 @@ def _fmt_argument(arg, indent: int, w: int) -> str:
     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
@@ -157,9 +229,13 @@ def _fmt_expr(expr, indent: int, w: int) -> str:
         )
     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)
@@ -171,7 +247,7 @@ 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:
@@ -301,12 +377,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})"