Implement the official gherkin parser

pyproject.toml

@@ -43,7 +43,6 @@ pytest = ">=6.2.0"
 typing-extensions = "*"
 packaging = "*"
 gherkin-official = "^29.0.0"
-pydantic = "^2.9.0"
 
 [tool.poetry.group.dev.dependencies]
 tox = ">=4.11.3"

src/pytest_bdd/gherkin_parser.py

@@ -1,56 +1,94 @@
 import linecache
 import textwrap
-from pathlib import Path
-from typing import List, Optional
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
 
 from gherkin.errors import CompositeParserException
 from gherkin.parser import Parser
 from gherkin.token_scanner import TokenScanner
-from pydantic import BaseModel, field_validator, model_validator
 
 from . import exceptions
 from .types import STEP_TYPES
 
 
-class Location(BaseModel):
+@dataclass
+class Location:
     column: int
     line: int
 
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Location":
+        return cls(column=data["column"], line=data["line"])
 
-class Comment(BaseModel):
+
+@dataclass
+class Comment:
     location: Location
     text: str
 
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Comment":
+        return cls(location=Location.from_dict(data["location"]), text=data["text"])
+
 
-class Cell(BaseModel):
+@dataclass
+class Cell:
     location: Location
     value: str
 
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Cell":
+        return cls(location=Location.from_dict(data["location"]), value=_convert_to_raw_string(data["value"]))
+
 
-class Row(BaseModel):
+@dataclass
+class Row:
     id: str
     location: Location
     cells: List[Cell]
 
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Row":
+        return cls(
+            id=data["id"],
+            location=Location.from_dict(data["location"]),
+            cells=[Cell.from_dict(cell) for cell in data["cells"]],
+        )
 
-class DataTable(BaseModel):
-    name: Optional[str] = None
+
+@dataclass
+class DataTable:
     location: Location
+    name: Optional[str] = None
     tableHeader: Optional[Row] = None
-    tableBody: Optional[List[Row]] = None
+    tableBody: Optional[List[Row]] = field(default_factory=list)
 
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "DataTable":
+        return cls(
+            location=Location.from_dict(data["location"]),
+            name=data.get("name"),
+            tableHeader=Row.from_dict(data["tableHeader"]) if data.get("tableHeader") else None,
+            tableBody=[Row.from_dict(row) for row in data.get("tableBody", [])],
+        )
 
-class DocString(BaseModel):
+
+@dataclass
+class DocString:
     content: str
     delimiter: str
     location: Location
 
-    @field_validator("content", mode="before")
-    def dedent_content(cls, value: str) -> str:
-        return textwrap.dedent(value)
+    def __post_init__(self):
+        self.content = textwrap.dedent(self.content)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "DocString":
+        return cls(content=data["content"], delimiter=data["delimiter"], location=Location.from_dict(data["location"]))
 
 
-class Step(BaseModel):
+@dataclass
+class Step:
     id: str
     keyword: str
     keywordType: str
@@ -59,43 +97,71 @@ class Step(BaseModel):
     dataTable: Optional[DataTable] = None
     docString: Optional[DocString] = None
 
-    @field_validator("keyword", mode="before")
-    def normalize_keyword(cls, value: str) -> str:
-        return value.lower().strip()
+    def __post_init__(self):
+        self.keyword = self.keyword.lower().strip()
 
     @property
     def given_when_then(self) -> str:
-        return self._gwt
+        return getattr(self, "_gwt", "")
 
     @given_when_then.setter
     def given_when_then(self, gwt: str) -> None:
         self._gwt = gwt
 
-
-class Tag(BaseModel):
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Step":
+        return cls(
+            id=data["id"],
+            keyword=data["keyword"],
+            keywordType=data["keywordType"],
+            location=Location.from_dict(data["location"]),
+            text=data["text"],
+            dataTable=DataTable.from_dict(data["dataTable"]) if data.get("dataTable") else None,
+            docString=DocString.from_dict(data["docString"]) if data.get("docString") else None,
+        )
+
+
+@dataclass
+class Tag:
     id: str
     location: Location
     name: str
 
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Tag":
+        return cls(id=data["id"], location=Location.from_dict(data["location"]), name=data["name"])
 
-class Scenario(BaseModel):
+
+@dataclass
+class Scenario:
     id: str
     keyword: str
     location: Location
     name: str
     description: str
     steps: List[Step]
     tags: List[Tag]
-    examples: Optional[List[DataTable]] = None
-
-    @model_validator(mode="after")
-    def process_steps(cls, instance):
-        steps = instance.steps
-        instance.steps = _compute_given_when_then(steps)
-        return instance
-
-
-class Rule(BaseModel):
+    examples: Optional[List[DataTable]] = field(default_factory=list)
+
+    def __post_init__(self):
+        self.steps = _compute_given_when_then(self.steps)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Scenario":
+        return cls(
+            id=data["id"],
+            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"]],
+            tags=[Tag.from_dict(tag) for tag in data["tags"]],
+            examples=[DataTable.from_dict(example) for example in data.get("examples", [])],
+        )
+
+
+@dataclass
+class Rule:
     id: str
     keyword: str
     location: Location
@@ -104,41 +170,91 @@ class Rule(BaseModel):
     tags: List[Tag]
     children: List[Scenario]
 
-
-class Background(BaseModel):
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Rule":
+        return cls(
+            id=data["id"],
+            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"]],
+            children=[Scenario.from_dict(child) for child in data["children"]],
+        )
+
+
+@dataclass
+class Background:
     id: str
     keyword: str
     location: Location
     name: str
     description: str
     steps: List[Step]
 
-    @model_validator(mode="after")
-    def process_steps(cls, instance):
-        steps = instance.steps
-        instance.steps = _compute_given_when_then(steps)
-        return instance
+    def __post_init__(self):
+        self.steps = _compute_given_when_then(self.steps)
 
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Background":
+        return cls(
+            id=data["id"],
+            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"]],
+        )
 
-class Child(BaseModel):
+
+@dataclass
+class Child:
     background: Optional[Background] = None
     rule: Optional[Rule] = None
     scenario: Optional[Scenario] = None
 
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Child":
+        return cls(
+            background=Background.from_dict(data["background"]) if data.get("background") else None,
+            rule=Rule.from_dict(data["rule"]) if data.get("rule") else None,
+            scenario=Scenario.from_dict(data["scenario"]) if data.get("scenario") else None,
+        )
+
 
-class Feature(BaseModel):
+@dataclass
+class Feature:
     keyword: str
     location: Location
     tags: List[Tag]
     name: str
     description: str
     children: List[Child]
 
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Feature":
+        return cls(
+            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"],
+            children=[Child.from_dict(child) for child in data["children"]],
+        )
+
 
-class GherkinDocument(BaseModel):
+@dataclass
+class GherkinDocument:
     feature: Feature
     comments: List[Comment]
 
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "GherkinDocument":
+        return cls(
+            feature=Feature.from_dict(data["feature"]),
+            comments=[Comment.from_dict(comment) for comment in data["comments"]],
+        )
+
 
 def _compute_given_when_then(steps: List[Step]) -> List[Step]:
     last_gwt = None
@@ -149,22 +265,22 @@ def _compute_given_when_then(steps: List[Step]) -> List[Step]:
     return steps
 
 
-class GherkinParser:
-    def __init__(self, abs_filename: str = None, encoding: str = "utf-8"):
-        self.abs_filename = Path(abs_filename)
-        self.encoding = encoding
-
-        with open(self.abs_filename, encoding=self.encoding) as f:
-            self.feature_file_text = f.read()
-        try:
-            self.gherkin_data = Parser().parse(TokenScanner(self.feature_file_text))
-        except CompositeParserException as e:
-            raise exceptions.FeatureError(
-                e.args[0],
-                e.errors[0].location["line"],
-                linecache.getline(str(self.abs_filename), e.errors[0].location["line"]).rstrip("\n"),
-                self.abs_filename,
-            ) from e
-
-    def to_gherkin_document(self) -> GherkinDocument:
-        return GherkinDocument(**self.gherkin_data)
+def _convert_to_raw_string(normal_string: str) -> str:
+    return normal_string.replace("\\", "\\\\")
+
+
+def get_gherkin_document(abs_filename: str = None, encoding: str = "utf-8") -> GherkinDocument:
+    with open(abs_filename, encoding=encoding) as f:
+        feature_file_text = f.read()
+
+    try:
+        gherkin_data = Parser().parse(TokenScanner(feature_file_text))
+    except CompositeParserException as e:
+        raise exceptions.FeatureError(
+            e.args[0],
+            e.errors[0].location["line"],
+            linecache.getline(abs_filename, e.errors[0].location["line"]).rstrip("\n"),
+            abs_filename,
+        ) from e
+
+    return GherkinDocument.from_dict(gherkin_data)

src/pytest_bdd/parser.py

@@ -9,10 +9,11 @@
 
 from .gherkin_parser import Background as GherkinBackground
 from .gherkin_parser import Feature as GherkinFeature
-from .gherkin_parser import GherkinDocument, GherkinParser
+from .gherkin_parser import GherkinDocument
 from .gherkin_parser import Scenario as GherkinScenario
 from .gherkin_parser import Step as GherkinStep
 from .gherkin_parser import Tag as GherkinTag
+from .gherkin_parser import get_gherkin_document
 from .types import GIVEN, THEN, WHEN
 
 STEP_PARAM_RE = re.compile(r"<(.+?)>")
@@ -422,7 +423,7 @@ def _parse_feature_file(self) -> GherkinDocument:
         Returns:
             Dict: A Gherkin document representation of the feature file.
         """
-        return GherkinParser(self.abs_filename, self.encoding).to_gherkin_document()
+        return get_gherkin_document(self.abs_filename, self.encoding)
 
     def parse(self):
         gherkin_doc: GherkinDocument = self._parse_feature_file()

src/pytest_bdd/scenario.py

@@ -424,7 +424,7 @@ def _scenario() -> None:
 
                 for test_name in get_python_name_generator(scenario_name):
                     if test_name not in caller_locals:
-                        # found an unique test name
+                        # found a unique test name
                         caller_locals[test_name] = _scenario
                         break
             found = True

src/pytest_bdd/steps.py

@@ -149,7 +149,7 @@ def step(
     :return: Decorator function for the step.
 
     Example:
-    >>> @step("there is an wallet", target_fixture="wallet")
+    >>> @step("there is a wallet", target_fixture="wallet")
     >>> def _() -> dict[str, int]:
     >>>     return {"eur": 0, "usd": 0}
 

tests/feature/test_outline.py

@@ -217,6 +217,6 @@ def _(string):
         r"bork |",
         r"bork||bork",
         r"|",
-        "bork      \\",
-        "bork    \\|",
+        r"bork      \\",
+        r"bork    \\|",
     ]