openscad-parser 2.2.1__tar.gz → 2.3.1__tar.gz

{openscad_parser-2.2.1 → openscad_parser-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_parser
-Version: 2.2.1
+Version: 2.3.1
 Summary: A PEG parser to read OpenSCAD language source code, with optional AST tree generation.
 Keywords: openscad,openscad parser,parser
 Author: Revar Desmera
@@ -21,6 +21,7 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: arpeggio>=2.0.3
 Requires-Dist: pytest>=7.0.0 ; extra == 'dev'
+Requires-Dist: pytest-cov>=7.1.0 ; extra == 'dev'
 Requires-Dist: pyyaml>=6.0 ; extra == 'yaml'
 Maintainer: Revar Desmera
 Maintainer-email: Revar Desmera <revarbat@gmail.com>

{openscad_parser-2.2.1 → openscad_parser-2.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "openscad_parser"
-version = "2.2.1"
+version = "2.3.1"
 description = "A PEG parser to read OpenSCAD language source code, with optional AST tree generation."
 readme = "README.rst"
 authors = [
@@ -38,6 +38,7 @@ dependencies = [
 [project.optional-dependencies]
 dev = [
     "pytest>=7.0.0",
+    "pytest-cov>=7.1.0",
 ]
 yaml = [
     "PyYAML>=6.0",

{openscad_parser-2.2.1 → openscad_parser-2.3.1}/src/openscad_parser/ast/builder.py

@@ -9,18 +9,22 @@ from .nodes import *
 @dataclass
 class Position:
     """Represents a location in a source origin.
-    
+
     Attributes:
         origin: Identifier for the source origin (e.g., file path, "<editor>", etc.)
         line: Line number (1-indexed)
         column: Column number (1-indexed)
+        start_offset: 0-based character offset of the token start within the origin's content
+        end_offset: 0-based character offset one past the token end within the origin's content
     """
     origin: str
     line: int
     column: int
+    start_offset: int = 0
+    end_offset: int = 0
 
     def __repr__(self):
-        return f"{self.origin}:{self.line}:{self.column}"
+        return f"{self.origin}:{self.line}:{self.column}[{self.start_offset}:{self.end_offset}]"
 
 
 class SemanticChildren(list):
@@ -33,6 +37,11 @@ class SemanticChildren(list):
     def __getattr__(self, name):
         return self._rule_map.get(name, [])
 
+    def get_rule(self, rule_name, index=0):
+        """Return the index-th result for rule_name, or [] if absent/out of range."""
+        results = self._rule_map.get(rule_name, [])
+        return results[index] if index < len(results) else []
+
 
 class ASTBuilderVisitor(PTNodeVisitor):
     """
@@ -136,26 +145,43 @@ class ASTBuilderVisitor(PTNodeVisitor):
             # This is useful for operator nodes like TOK_BINARY_OR, TOK_EQUAL, etc.
             return node
     
+    def _get_node_end_position(self, node) -> int:
+        """Return the combined-string offset one past the last character of node."""
+        if node is None:
+            return 0
+        try:
+            # NonTerminal: recurse to find the furthest end among children
+            end = getattr(node, 'position', 0)
+            for child in node:
+                child_end = self._get_node_end_position(child)
+                if child_end > end:
+                    end = child_end
+            return end
+        except TypeError:
+            pass
+        # Terminal: start + length of matched value
+        pos = getattr(node, 'position', 0)
+        val = getattr(node, 'value', '')
+        return pos + len(str(val))
+
     def _get_node_position(self, node):
         """Extract position information from an Arpeggio parse tree node.
-        
+
         Uses SourceMap to map positions back to original origins if available.
-        
+        start_offset and end_offset are 0-based offsets within the origin's content.
+
         Args:
             node: Arpeggio parse tree node
-            
+
         Returns:
             Position object for the node
         """
-        if hasattr(node, 'position'):
-            char_pos = node.position
-        else:
-            char_pos = 0
-        
+        char_pos = getattr(node, 'position', 0)
+        end_pos = self._get_node_end_position(node)
+
         # Use SourceMap if available to map position back to original origin
         if hasattr(self, 'source_map') and self.source_map.get_segments():
-            location = self.source_map.get_location(char_pos)
-            return Position(origin=location.origin, line=location.line, column=location.column)
+            return self.source_map.get_location(char_pos, end_pos)
         else:
             # Fallback: calculate line/column from character position
             input_str = self.parser.input if hasattr(self.parser, 'input') else ""
@@ -167,8 +193,14 @@ class ASTBuilderVisitor(PTNodeVisitor):
                 line = text_before.count('\n') + 1
                 last_newline = text_before.rfind('\n')
                 column = char_pos - last_newline  # 1-indexed
-            
-            return Position(origin=self.file if self.file else "<unknown>", line=line, column=column)
+
+            return Position(
+                origin=self.file if self.file else "<unknown>",
+                line=line,
+                column=column,
+                start_offset=char_pos,
+                end_offset=end_pos,
+            )
 
 
     # -- Basic Tokens --
@@ -455,7 +487,7 @@ class ASTBuilderVisitor(PTNodeVisitor):
         # After visiting: [Identifier, parameters, statement] (KWD_MODULE returns None)
         if hasattr(children, "module_name"):
             name = children.module_name[0] if children.module_name else None
-            parameters = children.parameter_block[0] if hasattr(children, "parameter_block") and children.parameter_block else []
+            parameters = children.get_rule("parameter_block")
             statement = list(children.statement) if hasattr(children, "statement") and children.statement else []
         else:
             name = children[0] if children else None
@@ -491,7 +523,7 @@ class ASTBuilderVisitor(PTNodeVisitor):
         # After visiting: [Identifier, parameters, expr] (KWD_FUNCTION, TOK_ASSIGN, TOK_SEMICOLON return None)
         if hasattr(children, "function_name"):
             name = children.function_name[0] if children.function_name else None
-            parameters = children.parameter_block[0] if hasattr(children, "parameter_block") and children.parameter_block else []
+            parameters = children.get_rule("parameter_block")
             expr = children.expr[0] if hasattr(children, "expr") and children.expr else None
         else:
             name = children[0] if children else None
@@ -551,7 +583,7 @@ class ASTBuilderVisitor(PTNodeVisitor):
         # Grammar: (KWD_LET, TOK_PAREN, assignments_expr, TOK_ENDPAREN, expr)
         # After visiting: [assignments_list, expr] (KWD_LET, TOK_PAREN, TOK_ENDPAREN return None)
         if hasattr(children, "assignments_expr"):
-            assignments = children.assignments_expr[0] if children.assignments_expr else []
+            assignments = children.get_rule("assignments_expr")
             body = children.expr[0] if hasattr(children, "expr") and children.expr else None
         else:
             assignments = children[0] if len(children) > 0 else []
@@ -559,12 +591,12 @@ class ASTBuilderVisitor(PTNodeVisitor):
         if body is None:
             raise ValueError("let_expr should have an Expression body")
         return LetOp(assignments=assignments, body=body, position=self._get_node_position(node))
-    
+
     def visit_assert_expr(self, node, children):
         # Grammar: (KWD_ASSERT, TOK_PAREN, arguments, TOK_ENDPAREN, Optional(expr))
         # After visiting: [arguments_list, expr or None] (KWD_ASSERT, TOK_PAREN, TOK_ENDPAREN return None)
         if hasattr(children, "arguments"):
-            arguments = children.arguments[0] if children.arguments else []
+            arguments = children.get_rule("arguments")
             body = children.expr[0] if hasattr(children, "expr") and children.expr else None
         else:
             arguments = children[0] if len(children) > 0 else []
@@ -572,12 +604,12 @@ class ASTBuilderVisitor(PTNodeVisitor):
         if body is None:
             raise ValueError("assert_expr should have an Expression body")
         return AssertOp(arguments=arguments, body=body, position=self._get_node_position(node))
-    
+
     def visit_echo_expr(self, node, children):
         # Grammar: (KWD_ECHO, TOK_PAREN, arguments, TOK_ENDPAREN, Optional(expr))
         # After visiting: [arguments_list, expr or None] (KWD_ECHO, TOK_PAREN, TOK_ENDPAREN return None)
         if hasattr(children, "arguments"):
-            arguments = children.arguments[0] if children.arguments else []
+            arguments = children.get_rule("arguments")
             body = children.expr[0] if hasattr(children, "expr") and children.expr else None
         else:
             arguments = children[0] if len(children) > 0 else []
@@ -1015,9 +1047,7 @@ class ASTBuilderVisitor(PTNodeVisitor):
         return RangeLiteral(start=start, end=end, step=step, position=self._get_node_position(node))
     
     def visit_vector_expr(self, node, children):
-        elements = children[0] if children else []
-        if elements is None:  # pragma: no cover
-            elements = []
+        elements = children if children else []
         if not isinstance(elements, list):
             elements = [elements]
         return ListComprehension(elements=elements, position=self._get_node_position(node))
@@ -1080,18 +1110,12 @@ class ASTBuilderVisitor(PTNodeVisitor):
             raise ValueError("modular_call should have a module name")
         if not isinstance(name, Identifier):
             name = Identifier(name=str(name), position=self._get_node_position(node))
-        if hasattr(children, "arguments") and children.arguments:
-            arguments = children.arguments[0]
-        else:
-            arguments = children[1] if len(children) > 1 else []
+        arguments = children.get_rule("arguments") if hasattr(children, "get_rule") else (children[1] if len(children) > 1 else [])
         if arguments is None:  # pragma: no cover
             arguments = []
         if not isinstance(arguments, list):  # pragma: no cover
             arguments = [arguments]
-        if hasattr(children, "child_statement") and children.child_statement:
-            mods = children.child_statement[0]
-        else:
-            mods = children[2] if len(children) > 2 else []
+        mods = children.get_rule("child_statement") if hasattr(children, "get_rule") else (children[2] if len(children) > 2 else [])
         if mods is None:  # pragma: no cover
             mods = []
         if not isinstance(mods, list):
@@ -1106,57 +1130,86 @@ class ASTBuilderVisitor(PTNodeVisitor):
     def visit_modular_c_for(self, node, children):
         initial = children[0] if isinstance(children[0], list) else [children[0]]
         increment = children[2] if isinstance(children[2], list) else [children[2]]
+        body = children.get_rule('child_statement')
+        if not isinstance(body, list):
+            body = [body]
         return ModularCFor(
             initial=initial,
             condition=children[1],
             increment=increment,
-            body=children[3],
+            body=body,
             position=self._get_node_position(node)
         )
     
     def visit_modular_for(self, node, children):
         assignments = children[0] if isinstance(children[0], list) else [children[0]]
+        body = children.get_rule('child_statement')
+        if not isinstance(body, list):
+            body = [body]
         return ModularFor(
             assignments=assignments,
-            body=children[1],
+            body=body,
             position=self._get_node_position(node)
         )
     
     def visit_modular_intersection_c_for(self, node, children):
         initial = children[0] if isinstance(children[0], list) else [children[0]]
         increment = children[2] if isinstance(children[2], list) else [children[2]]
+        body = children.get_rule('child_statement')
+        if not isinstance(body, list):
+            body = [body]
         return ModularIntersectionCFor(
             initial=initial,
             condition=children[1],
             increment=increment,
-            body=children[3],
+            body=body,
             position=self._get_node_position(node)
         )
 
     def visit_modular_intersection_for(self, node, children):
         assignments = children[0] if isinstance(children[0], list) else [children[0]]
-        return ModularIntersectionFor(assignments=assignments, body=children[1], position=self._get_node_position(node))
+        body = children.get_rule('child_statement')
+        if not isinstance(body, list):
+            body = [body]
+        return ModularIntersectionFor(assignments=assignments, body=body, position=self._get_node_position(node))
     
     def visit_modular_let(self, node, children):
         assignments = children[0] if isinstance(children[0], list) else [children[0]]
-        mods = children[1] if isinstance(children[1], list) else [children[1]]
+        mods = children.get_rule('child_statement')
+        if not isinstance(mods, list):
+            mods = [mods]
         return ModularLet(assignments=assignments, children=mods, position=self._get_node_position(node))
     
     def visit_modular_echo(self, node, children):
         arguments = children[0] if isinstance(children[0], list) else [children[0]]
-        mods = children[1] if isinstance(children[1], list) else [children[1]]
+        mods = children.get_rule('child_statement')
+        if not isinstance(mods, list):
+            mods = [mods]
         return ModularEcho(arguments=arguments, children=mods, position=self._get_node_position(node))
     
     def visit_modular_assert(self, node, children):
         arguments = children[0] if isinstance(children[0], list) else [children[0]]
-        mods = children[1] if isinstance(children[1], list) else [children[1]]
+        mods = children.get_rule('child_statement')
+        if not isinstance(mods, list):
+            mods = [mods]
         return ModularAssert(arguments=arguments, children=mods, position=self._get_node_position(node))
     
     def visit_if_statement(self, node, children):
-        return ModularIf(condition=children[0], true_branch=children[1], position=self._get_node_position(node))
-    
+        condition = children[0]
+        true_branch = children.get_rule('child_statement')
+        if not isinstance(true_branch, list):
+            true_branch = [true_branch]
+        return ModularIf(condition=condition, true_branch=true_branch, position=self._get_node_position(node))
+
     def visit_ifelse_statement(self, node, children):
-        return ModularIfElse(condition=children[0], true_branch=children[1], false_branch=children[2], position=self._get_node_position(node))
+        condition = children[0]
+        true_branch = children.get_rule('child_statement')
+        false_branch = children.get_rule('child_statement', index=1)
+        if not isinstance(true_branch, list):
+            true_branch = [true_branch]
+        if not isinstance(false_branch, list):
+            false_branch = [false_branch]
+        return ModularIfElse(condition=condition, true_branch=true_branch, false_branch=false_branch, position=self._get_node_position(node))
     
     def visit_modifier_show_only(self, node, children):
         child = children[0]  # We know modifiers can only have one child.
@@ -1229,8 +1282,10 @@ class ASTBuilderVisitor(PTNodeVisitor):
     
     def visit_child_statement(self, node, children):
         # Grammar: [empty_statement, statement_block, module_instantiation]
-        # Return the first child if available
-        return children[0] if children else None
+        # Return all children as a list. statement_block flattens its contents
+        # into children via _visit_node's extend behavior, so we must return all
+        # of them rather than just children[0] (which would silently drop siblings).
+        return list(children)
     
     def visit_expr(self, node, children) -> Expression:
         if not children:

{openscad_parser-2.2.1 → openscad_parser-2.3.1}/src/openscad_parser/ast/serialization.py

@@ -184,6 +184,8 @@ def _serialize_position(position: Position) -> dict[str, Any]:
         "origin": position.origin,
         "line": position.line,
         "column": position.column,
+        "start_offset": position.start_offset,
+        "end_offset": position.end_offset,
     }
 
 
@@ -277,6 +279,8 @@ def _deserialize_position(data: dict[str, Any]) -> Position:
         origin=data["origin"],
         line=data["line"],
         column=data["column"],
+        start_offset=data.get("start_offset", 0),
+        end_offset=data.get("end_offset", 0),
     )
 
 

{openscad_parser-2.2.1 → openscad_parser-2.3.1}/src/openscad_parser/ast/source_map.py

@@ -264,34 +264,48 @@ class SourceMap:
         self._combined_string = ''.join(parts)
         self._combined_string_dirty = False
     
-    def get_location(self, position: int):
+    def get_location(self, position: int, end_position: Optional[int] = None):
         """Get the original source location for a position in the combined string.
-        
+
         Args:
             position: Character position in the combined string (0-indexed)
-        
+            end_position: Optional end position (exclusive) in the combined string.
+                If provided, end_offset in the returned Position will reflect the
+                end of the token within the origin's content.
+
         Returns:
-            Position with origin, line, and column in the original source
+            Position with origin, line, column, start_offset, and end_offset
         """
         from .builder import Position  # Lazy import to avoid circular dependency
-        
+
         if position < 0:
             position = 0
-        
+
         # Find the segment containing this position
         segment = self._find_segment(position)
-        
+
         if segment is None:
             # Position is beyond all segments, return location from last segment
             if self._segments:
                 last_segment = max(self._segments, key=lambda s: s.combined_start + len(s.content))
-                return self._calculate_location_in_segment(last_segment, len(last_segment.content))
+                seg_offset = len(last_segment.content)
+                end_offset = (
+                    (end_position - last_segment.combined_start)
+                    if end_position is not None
+                    else seg_offset
+                )
+                return self._calculate_location_in_segment(last_segment, seg_offset, end_offset)
             else:
                 return Position(origin="", line=1, column=1)
-        
-        # Calculate the position within the segment
+
+        # Calculate offsets within the segment
         segment_offset = position - segment.combined_start
-        return self._calculate_location_in_segment(segment, segment_offset)
+        end_offset = (
+            (end_position - segment.combined_start)
+            if end_position is not None
+            else segment_offset
+        )
+        return self._calculate_location_in_segment(segment, segment_offset, end_offset)
     
     def _find_segment(self, position: int) -> Optional[SourceSegment]:
         """Find the segment containing the given position.
@@ -324,30 +338,32 @@ class SourceMap:
         
         return None
     
-    def _calculate_location_in_segment(self, segment: SourceSegment, offset: int):
+    def _calculate_location_in_segment(self, segment: SourceSegment, offset: int,
+                                        end_offset: Optional[int] = None):
         """Calculate the source location for an offset within a segment.
-        
+
         Args:
             segment: The source segment
-            offset: Character offset within the segment (0-indexed)
-        
+            offset: Character offset within the segment (0-indexed), used for start
+            end_offset: Optional exclusive end offset within the segment (0-indexed)
+
         Returns:
-            Position with the original source location
+            Position with the original source location, start_offset, and end_offset
         """
         from .builder import Position  # Lazy import to avoid circular dependency
-        
+
         if offset < 0:
             offset = 0  # pragma: no cover
         if offset > len(segment.content):
             offset = len(segment.content)  # pragma: no cover
-        
+
         # Count lines in the content up to the offset
         content_before = segment.content[:offset]
         line_count = content_before.count('\n')
-        
+
         # Calculate line number
         line_number = segment.start_line + line_count
-        
+
         # Calculate column number
         if line_count == 0:
             # Same line as start
@@ -356,11 +372,15 @@ class SourceMap:
             # Find the last newline before offset
             last_newline = content_before.rfind('\n')
             column_number = offset - last_newline
-        
+
+        resolved_end = end_offset if end_offset is not None else offset
+
         return Position(
             origin=segment.origin,
             line=line_number,
-            column=column_number
+            column=column_number,
+            start_offset=offset,
+            end_offset=resolved_end,
         )
     
     def get_segments(self) -> list[SourceSegment]:

{openscad_parser-2.2.1 → openscad_parser-2.3.1}/src/openscad_parser/grammar.py

@@ -454,7 +454,7 @@ def modular_echo():
 
 
 def modular_call():
-    return (module_instantiation_name, TOK_PAREN, arguments, TOK_ENDPAREN, child_statement)
+    return (module_instantiation_name, TOK_PAREN, arguments, TOK_ENDPAREN, ZeroOrMore(comment), child_statement)
 
 
 # --- Parameters used to define functions and modules ---