Make the id and location attributes private in the gherkin parser so that they are not part of the public API if we share the objects from the parser (as we do now with the DataTable)

Author: jsa34

src/pytest_bdd/gherkin_parser.py

@@ -67,50 +67,50 @@ def from_dict(cls, data: dict[str, Any]) -> Self:
 
 @dataclass
 class Comment:
-    location: Location
+    _location: Location
     text: str
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
-        return cls(location=Location.from_dict(data["location"]), text=data["text"])
+        return cls(_location=Location.from_dict(data["location"]), text=data["text"])
 
 
 @dataclass
 class Cell:
-    location: Location
+    _location: Location
     value: str
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
-        return cls(location=Location.from_dict(data["location"]), value=_to_raw_string(data["value"]))
+        return cls(_location=Location.from_dict(data["location"]), value=_to_raw_string(data["value"]))
 
 
 @dataclass
 class Row:
-    id: str
-    location: Location
+    _id: str
+    _location: Location
     cells: list[Cell]
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
         return cls(
-            id=data["id"],
-            location=Location.from_dict(data["location"]),
+            _id=data["id"],
+            _location=Location.from_dict(data["location"]),
             cells=[Cell.from_dict(cell) for cell in data["cells"]],
         )
 
 
 @dataclass
 class ExamplesTable:
-    location: Location
+    _location: Location
     name: str | None = None
     table_header: Row | None = None
     table_body: list[Row] | None = field(default_factory=list)
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
         return cls(
-            location=Location.from_dict(data["location"]),
+            _location=Location.from_dict(data["location"]),
             name=data.get("name"),
             table_header=Row.from_dict(data["tableHeader"]) if data.get("tableHeader") else None,
             table_body=[Row.from_dict(row) for row in data.get("tableBody", [])],
@@ -119,13 +119,13 @@ def from_dict(cls, data: dict[str, Any]) -> Self:
 
 @dataclass
 class DataTable:
-    location: Location
+    _location: Location
     rows: list[Row]
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
         return cls(
-            location=Location.from_dict(data["location"]), rows=[Row.from_dict(row) for row in data.get("rows", [])]
+            _location=Location.from_dict(data["location"]), rows=[Row.from_dict(row) for row in data.get("rows", [])]
         )
 
     def transpose(self) -> DataTable:
@@ -134,11 +134,11 @@ def transpose(self) -> DataTable:
 
         # Use zip to transpose the matrix and create transposed rows
         transposed_cells = [
-            Row(id=str(i), location=self.location, cells=list(col)) for i, col in enumerate(zip(*cells_matrix))
+            Row(_id=str(i), _location=self._location, cells=list(col)) for i, col in enumerate(zip(*cells_matrix))
         ]
 
         # Return a new DataTable with transposed rows
-        return DataTable(location=self.location, rows=transposed_cells)
+        return DataTable(_location=self._location, rows=transposed_cells)
 
     def to_dict(self) -> dict[str, list[str]]:
         # Ensure there are at least two rows: one for the header and one for the values
@@ -157,34 +157,34 @@ def to_dict(self) -> dict[str, list[str]]:
 class DocString:
     content: str
     delimiter: str
-    location: Location
+    _location: Location
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
         return cls(
             content=textwrap.dedent(data["content"]),
             delimiter=data["delimiter"],
-            location=Location.from_dict(data["location"]),
+            _location=Location.from_dict(data["location"]),
         )
 
 
 @dataclass
 class Step:
-    id: str
+    _id: str
+    _location: Location
     keyword: str
     keyword_type: str
-    location: Location
     text: str
     data_table: DataTable | None = None
     doc_string: DocString | None = None
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
         return cls(
-            id=data["id"],
+            _id=data["id"],
+            _location=Location.from_dict(data["location"]),
             keyword=data["keyword"].strip(),
             keyword_type=data["keywordType"],
-            location=Location.from_dict(data["location"]),
             text=data["text"],
             data_table=DataTable.from_dict(data["dataTable"]) if data.get("dataTable") else None,
             doc_string=DocString.from_dict(data["docString"]) if data.get("docString") else None,
@@ -193,20 +193,20 @@ def from_dict(cls, data: dict[str, Any]) -> Self:
 
 @dataclass
 class Tag:
-    id: str
-    location: Location
+    _id: str
+    _location: Location
     name: str
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
-        return cls(id=data["id"], location=Location.from_dict(data["location"]), name=data["name"])
+        return cls(_id=data["id"], _location=Location.from_dict(data["location"]), name=data["name"])
 
 
 @dataclass
 class Scenario:
-    id: str
+    _id: str
+    _location: Location
     keyword: str
-    location: Location
     name: str
     description: str
     steps: list[Step]
@@ -216,9 +216,9 @@ class Scenario:
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
         return cls(
-            id=data["id"],
+            _id=data["id"],
+            _location=Location.from_dict(data["location"]),
             keyword=data["keyword"],
-            location=Location.from_dict(data["location"]),
             name=data["name"],
             description=data["description"],
             steps=[Step.from_dict(step) for step in data["steps"]],
@@ -229,9 +229,9 @@ def from_dict(cls, data: dict[str, Any]) -> Self:
 
 @dataclass
 class Rule:
-    id: str
+    _id: str
+    _location: Location
     keyword: str
-    location: Location
     name: str
     description: str
     tags: list[Tag]
@@ -240,9 +240,9 @@ class Rule:
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
         return cls(
-            id=data["id"],
+            _id=data["id"],
+            _location=Location.from_dict(data["location"]),
             keyword=data["keyword"],
-            location=Location.from_dict(data["location"]),
             name=data["name"],
             description=data["description"],
             tags=[Tag.from_dict(tag) for tag in data["tags"]],
@@ -252,19 +252,19 @@ def from_dict(cls, data: dict[str, Any]) -> Self:
 
 @dataclass
 class Background:
-    id: str
+    _id: str
+    _location: Location
     keyword: str
-    location: Location
     name: str
     description: str
     steps: list[Step]
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
         return cls(
-            id=data["id"],
+            _id=data["id"],
+            _location=Location.from_dict(data["location"]),
             keyword=data["keyword"],
-            location=Location.from_dict(data["location"]),
             name=data["name"],
             description=data["description"],
             steps=[Step.from_dict(step) for step in data["steps"]],
@@ -288,8 +288,8 @@ def from_dict(cls, data: dict[str, Any]) -> Self:
 
 @dataclass
 class Feature:
+    _location: Location
     keyword: str
-    location: Location
     tags: list[Tag]
     name: str
     description: str
@@ -298,8 +298,8 @@ class Feature:
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
         return cls(
+            _location=Location.from_dict(data["location"]),
             keyword=data["keyword"],
-            location=Location.from_dict(data["location"]),
             tags=[Tag.from_dict(tag) for tag in data["tags"]],
             name=data["name"],
             description=data["description"],

src/pytest_bdd/parser.py

@@ -359,7 +359,7 @@ def get_step_content(_gherkin_step: GherkinStep) -> str:
         if first_step.keyword.lower() not in STEP_TYPES:
             raise StepError(
                 message=f"First step in a scenario or background must start with 'Given', 'When' or 'Then', but got {first_step.keyword}.",
-                line=first_step.location.line,
+                line=first_step._location.line,
                 line_content=get_step_content(first_step),
                 filename=self.abs_filename,
             )
@@ -375,8 +375,8 @@ def get_step_content(_gherkin_step: GherkinStep) -> str:
                 Step(
                     name=name,
                     type=current_type,
-                    indent=step.location.column - 1,
-                    line_number=step.location.line,
+                    indent=step._location.column - 1,
+                    line_number=step._location.line,
                     keyword=step.keyword.title(),
                     data_table=step.data_table,
                 )
@@ -397,7 +397,7 @@ def parse_scenario(self, scenario_data: GherkinScenario, feature: Feature) -> Sc
         scenario = ScenarioTemplate(
             feature=feature,
             name=strip_comments(scenario_data.name),
-            line_number=scenario_data.location.line,
+            line_number=scenario_data._location.line,
             templated=templated,
             tags=self.get_tag_names(scenario_data.tags),
             description=textwrap.dedent(scenario_data.description),
@@ -407,7 +407,7 @@ def parse_scenario(self, scenario_data: GherkinScenario, feature: Feature) -> Sc
 
         for example_data in scenario_data.examples:
             examples = Examples(
-                line_number=example_data.location.line,
+                line_number=example_data._location.line,
                 name=example_data.name,
             )
             if example_data.table_header is not None:
@@ -424,7 +424,7 @@ def parse_scenario(self, scenario_data: GherkinScenario, feature: Feature) -> Sc
     def parse_background(self, background_data: GherkinBackground, feature: Feature) -> Background:
         background = Background(
             feature=feature,
-            line_number=background_data.location.line,
+            line_number=background_data._location.line,
         )
         background.steps = self.parse_steps(background_data.steps)
         for step in background.steps:
@@ -449,7 +449,7 @@ def parse(self) -> Feature:
             name=strip_comments(feature_data.name),
             tags=self.get_tag_names(feature_data.tags),
             background=None,
-            line_number=feature_data.location.line,
+            line_number=feature_data._location.line,
             description=textwrap.dedent(feature_data.description),
         )