tursu 0.1.2__tar.gz

tursu-0.1.2/CHANGELOG.md

@@ -0,0 +1,4 @@
+0.1.2 - Released on 2025-03-09
+------------------------------
+* Initial release
+

tursu-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Guillaume Gauvrit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tursu-0.1.2/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.1
+Name: tursu
+Version: 0.1.2
+Summary: A gherkin tests runner
+Author-Email: Guillaume Gauvrit <guillaume@gauvr.it>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Project-URL: Homepage, https://mardiros.github.io/tursu
+Project-URL: Documentation, https://mardiros.github.io/tursu
+Project-URL: Repository, https://github.com/mardiros/tursu.git
+Project-URL: Issues, https://github.com/mardiros/tursu/issues
+Project-URL: Changelog, https://mardiros.github.io/tursu/user/changelog.html
+Requires-Python: >=3.10
+Requires-Dist: gherkin-official>=32.0.0
+Requires-Dist: pydantic>=2.10.6
+Requires-Dist: pytest>=8.3.5
+Requires-Dist: venusian<4,>=3.1.1
+Description-Content-Type: text/markdown
+
+# turşu
+
+This project allows you to write **Gherkin**-based behavior-driven development (BDD) tests
+and execute them using **pytest**.
+
+It compiles Gherkin syntax into Python code using **Abstract Syntax Tree (AST)** manipulation,
+enabling seamless integration with pytest for running your tests.
+
+
+## Features
+
+- Write tests using **Gherkin syntax** (Given, When, Then).
+- Compile Gherkin scenarios to Python code using **AST**.
+- Execute tests directly with **pytest**.
+- Supports **step definitions** in Python for easy test scenario implementation.
+- Allows integration with existing pytest setups.
+
+## Installation
+
+will come soon

tursu-0.1.2/README.md

@@ -0,0 +1,20 @@
+# turşu
+
+This project allows you to write **Gherkin**-based behavior-driven development (BDD) tests
+and execute them using **pytest**.
+
+It compiles Gherkin syntax into Python code using **Abstract Syntax Tree (AST)** manipulation,
+enabling seamless integration with pytest for running your tests.
+
+
+## Features
+
+- Write tests using **Gherkin syntax** (Given, When, Then).
+- Compile Gherkin scenarios to Python code using **AST**.
+- Execute tests directly with **pytest**.
+- Supports **step definitions** in Python for easy test scenario implementation.
+- Allows integration with existing pytest setups.
+
+## Installation
+
+will come soon

tursu-0.1.2/pyproject.toml

@@ -0,0 +1,107 @@
+[project]
+authors = [
+    { name = "Guillaume Gauvrit", email = "guillaume@gauvr.it" },
+]
+description = "A gherkin tests runner"
+name = "tursu"
+readme = "README.md"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+version = "0.1.2"
+requires-python = ">=3.10"
+dependencies = [
+    "gherkin-official>=32.0.0",
+    "pydantic>=2.10.6",
+    "pytest>=8.3.5",
+    "venusian>=3.1.1,<4",
+]
+
+[project.license]
+text = "MIT"
+
+[project.urls]
+Homepage = "https://mardiros.github.io/tursu"
+Documentation = "https://mardiros.github.io/tursu"
+Repository = "https://github.com/mardiros/tursu.git"
+Issues = "https://github.com/mardiros/tursu/issues"
+Changelog = "https://mardiros.github.io/tursu/user/changelog.html"
+
+[dependency-groups]
+dev = [
+    "mypy>=1.4.0,<2",
+    "pytest>=8,<9",
+    "pytest-cov>=6.0.0,<7",
+]
+
+[tool.uv]
+default-groups = []
+
+[tool.pdm.build]
+includes = [
+    "src",
+    "CHANGELOG.md",
+]
+excludes = [
+    "tests",
+]
+
+[tool.ruff]
+target-version = "py39"
+line-length = 88
+
+[tool.ruff.lint]
+select = [
+    "B",
+    "I",
+    "F",
+    "UP",
+    "RUF",
+]
+ignore = [
+    "RUF022",
+]
+
+[tool.pyright]
+ignore = [
+    "examples",
+]
+include = [
+    "src",
+    "tests",
+]
+reportPrivateUsage = false
+reportUnknownMemberType = false
+reportUnknownParameterType = false
+reportUnknownVariableType = false
+reportShadowedImports = false
+reportUnknownLambdaType = false
+reportUnknownArgumentType = false
+useLibraryCodeForTypes = true
+reportMissingTypeStubs = false
+typeCheckingMode = "strict"
+venvPath = ".venv"
+
+[tool.mypy]
+overrides = [
+    { disallow_any_generics = true, disallow_untyped_defs = true, module = "tursu.*" },
+    { ignore_missing_imports = true, module = "venusian" },
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "if TYPE_CHECKING:",
+    "except ImportError",
+    "\\s+\\.\\.\\.$",
+    "# coverage: ignore",
+]
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"

tursu-0.1.2/src/tursu/__init__.py

@@ -0,0 +1,14 @@
+from importlib import metadata
+
+from .compile_all import generate_tests
+from .registry import StepRegistry, given, then, when
+
+__version__ = metadata.version("tursu")
+
+__all__ = [
+    "given",
+    "when",
+    "then",
+    "StepRegistry",
+    "generate_tests",
+]

tursu-0.1.2/src/tursu/compile_all.py

@@ -0,0 +1,37 @@
+import atexit
+import inspect
+from collections.abc import Iterator
+from pathlib import Path
+
+from tursu.compiler import GherkinCompiler
+from tursu.domain.model.gherkin import GherkinDocument
+from tursu.registry import StepRegistry
+
+
+def walk_features(path: Path) -> Iterator[GherkinDocument]:
+    for sub in path.glob("**/*.feature"):
+        yield GherkinDocument.from_file(sub)
+
+
+def generate_tests() -> None:
+    caller_module = inspect.getmodule(inspect.stack()[1][0])
+    assert caller_module
+    assert caller_module.__file__
+
+    reg = StepRegistry()
+    reg.scan(caller_module)
+
+    to_removes: list[Path] = []
+    for doc in walk_features(Path(caller_module.__file__).parent):
+        compiler = GherkinCompiler(doc, reg)
+
+        case = compiler.to_module()
+        casefile = doc.filepath.parent / case.filename
+        casefile.write_text(str(case))
+        to_removes.append(casefile)
+
+    def clean_up() -> None:
+        for r in to_removes:
+            r.unlink()
+
+    atexit.register(clean_up)

tursu-0.1.2/src/tursu/compiler.py

@@ -0,0 +1,218 @@
+import ast
+import re
+from collections.abc import Iterator
+from typing import Any, TypeGuard, get_args
+
+from tursu.domain.model.gherkin import (
+    GherkinBackgroundEnvelope,
+    GherkinDocument,
+    GherkinFeature,
+    GherkinKeyword,
+    GherkinRuleEnvelope,
+    GherkinScenario,
+    GherkinScenarioEnvelope,
+    GherkinStep,
+)
+from tursu.domain.model.testmod import TestModule
+from tursu.registry import StepRegistry
+from tursu.steps import StepKeyword
+
+
+class GherkinIterator:
+    def __init__(self, doc: GherkinDocument) -> None:
+        self.doc = doc
+        self.stack: list[Any] = []
+
+    def emit(self) -> Iterator[Any]:
+        self.stack.append(self.doc)
+        yield self.stack
+        for _ in self.emit_feature(self.doc.feature):
+            yield self.stack
+        self.stack.pop()
+
+    def emit_feature(self, feature: GherkinFeature) -> Iterator[Any]:
+        self.stack.append(feature)
+        yield self.stack
+        for child in self.doc.feature.children:
+            match child:
+                case GherkinBackgroundEnvelope(background=background):
+                    self.stack.append(background)
+                    yield self.stack
+                    self.stack.pop()
+                case GherkinScenarioEnvelope(scenario=scenario):
+                    self.stack.append(scenario)
+                    yield self.stack
+                    for _ in self.emit_scenario(scenario):
+                        yield self.stack
+                    self.stack.pop()
+                case GherkinRuleEnvelope(rule=rule):
+                    self.stack.append(rule)
+                    yield self.stack
+                    self.stack.pop()
+        self.stack.pop()
+
+    def emit_scenario(self, scenario: GherkinScenario) -> Iterator[Any]:
+        for step in scenario.steps:
+            self.stack.append(step)
+            yield self.stack
+            self.stack.pop()
+
+
+def is_step_keyword(value: GherkinKeyword) -> TypeGuard[StepKeyword]:
+    return value in get_args(StepKeyword)
+
+
+def sanitize(name: str) -> str:
+    return re.sub(r"\W+", "_", name)[:100]
+
+
+class GherkinCompiler:
+    feat_idx = 1
+
+    def __init__(self, doc: GherkinDocument, registry: StepRegistry) -> None:
+        self.emmiter = GherkinIterator(doc)
+        self.registry = registry
+
+    def to_module(self) -> TestModule:
+        last_keyword: StepKeyword | None = None
+
+        module_name = None
+        module_node = None
+        test_function = None
+        args: Any = None
+
+        for stack in self.emmiter.emit():
+            el = stack[-1]
+            match el:
+                case GherkinFeature(
+                    location=_,
+                    tags=_,
+                    language=_,
+                    keyword=_,
+                    name=name,
+                    description=description,
+                    children=_,
+                ):
+                    assert module_node is None
+                    docstring = f"{name}\n\n{description}".strip()
+                    import_node = ast.ImportFrom(
+                        module="tursu",  # the module name
+                        names=[ast.alias(name="StepRegistry", asname=None)],
+                        level=0,  # import at the top level
+                    )
+                    module_node = ast.Module(
+                        body=[
+                            ast.Expr(value=ast.Constant(docstring), lineno=1),
+                            import_node,
+                        ],
+                        type_ignores=[],
+                    )
+                    module_name = f"test_{GherkinCompiler.feat_idx}_{sanitize(name)}.py"
+                    GherkinCompiler.feat_idx += 1
+
+                case GherkinScenario(
+                    id=id,
+                    location=location,
+                    tags=_,
+                    keyword=_,
+                    name=name,
+                    description=description,
+                    steps=steps,
+                    examples=_,
+                ):
+                    fixtures: dict[str, type] = {}
+                    step_last_keyword = None
+                    for step in steps:
+                        if step.keyword_type == "Conjunction":
+                            assert step_last_keyword is not None, (
+                                f"Using {step.keyword} without context"
+                            )
+                        else:
+                            step_last_keyword = step.keyword
+                        assert is_step_keyword(step_last_keyword)
+
+                        fixtures.update(
+                            self.registry.extract_fixtures(step_last_keyword, step.text)
+                        )
+
+                    args = [
+                        ast.arg(
+                            arg="registry",
+                            annotation=ast.Name(id="StepRegistry", ctx=ast.Load()),
+                        )
+                    ]
+                    for key, _val in fixtures.items():
+                        args.append(
+                            ast.arg(
+                                arg=key,
+                                # annotation=ast.Name(id=val.__name__, ctx=ast.Load()),
+                            )
+                        )
+
+                    docstring = f"{name}\n\n{description}".strip()
+                    test_function = ast.FunctionDef(
+                        name=f"test_{id}_{sanitize(name)}",
+                        args=ast.arguments(
+                            args=args,
+                        ),
+                        body=[
+                            ast.Expr(
+                                value=ast.Constant(docstring), lineno=location.line + 1
+                            ),
+                        ],
+                        decorator_list=[],
+                        lineno=location.line,
+                    )
+                    assert module_node is not None
+                    module_node.body.append(test_function)
+
+                case GherkinStep(
+                    id=_,
+                    location=location,
+                    keyword=keyword,
+                    text=text,
+                    keyword_type=keyword_type,
+                    data_table=_,
+                    docstring=_,
+                ):
+                    if keyword_type == "Conjunction":
+                        assert last_keyword is not None, (
+                            f"Using {keyword} without context"
+                        )
+                        keyword = last_keyword
+                    assert is_step_keyword(keyword)
+                    last_keyword = keyword
+
+                    assert test_function is not None
+                    keywords = []
+                    step_fixtures = self.registry.extract_fixtures(last_keyword, text)
+                    for key, _val in step_fixtures.items():
+                        keywords.append(
+                            ast.keyword(arg=key, value=ast.Name(id=key, ctx=ast.Load()))
+                        )
+
+                    call_node = ast.Call(
+                        func=ast.Attribute(
+                            value=ast.Name(id="registry", ctx=ast.Load()),
+                            attr="run_step",
+                            ctx=ast.Load(),
+                        ),  # registry.run_step
+                        args=[
+                            ast.Constant(value=keyword),
+                            ast.Constant(value=text),
+                        ],
+                        keywords=keywords,
+                    )
+
+                    # Add the call node to the body of the function
+                    test_function.body.append(
+                        ast.Expr(value=call_node, lineno=location.line)
+                    )
+
+                case _:
+                    # print(el)
+                    ...
+
+        assert module_node is not None
+        assert module_name is not None
+        return TestModule(module_name, module_node)

tursu-0.1.2/src/tursu/domain/model/gherkin.py

@@ -0,0 +1,149 @@
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Annotated, Any, Literal
+
+from gherkin import Parser
+from pydantic import BaseModel, Field
+from pydantic.functional_validators import BeforeValidator
+
+
+def sanitize(value: Any) -> str:
+    return value.strip().lower() if isinstance(value, str) else value
+
+
+GherkinKeyword = Annotated[
+    Literal["feature", "scenario", "given", "when", "then", "and", "but"],
+    BeforeValidator(sanitize),
+]
+
+
+class GherkinLocation(BaseModel):
+    line: int
+    column: int | None = Field(default=None)
+
+
+class GherkinComment(BaseModel):
+    location: GherkinLocation
+    text: str
+
+
+class GherkinTag(BaseModel):
+    id: str
+    location: GherkinLocation
+    name: str
+
+
+class GherkinCell(BaseModel):
+    location: GherkinLocation
+    value: str
+
+
+class GherkinTableRow(BaseModel):
+    id: str
+    location: GherkinLocation
+    cells: Sequence[GherkinCell]
+
+
+class GherkinDataTable(BaseModel):
+    location: GherkinLocation
+    rows: Sequence[GherkinTableRow]
+
+
+class GherkinDocString(BaseModel):
+    location: GherkinLocation
+    content: str
+    delimiter: str
+    media_type: str | None = Field(alias="mediaType")
+
+
+class GherkinStep(BaseModel):
+    id: str
+    location: GherkinLocation
+    keyword: GherkinKeyword
+    text: str
+    keyword_type: str = Field(alias="keywordType")
+    data_table: GherkinDataTable | None = Field(default=None, alias="data_table")
+    docstring: GherkinDocString | None = Field(default=None, alias="docstring")
+
+
+class GherkinBackground(BaseModel):
+    id: str
+    location: GherkinLocation
+    keyword: GherkinKeyword
+    name: str
+    description: str
+    steps: Sequence[GherkinStep]
+
+
+class GherkinExamples(BaseModel):
+    id: str
+    location: GherkinLocation
+    tags: Sequence[GherkinTag]
+    keyword: GherkinKeyword
+    name: str
+    description: str
+    table_header: GherkinTableRow = Field(alias="tableHeader")
+    table_body: Sequence[GherkinTableRow] = Field(alias="tableBody")
+
+
+class GherkinScenario(BaseModel):
+    id: str
+    location: GherkinLocation
+    tags: Sequence[GherkinTag]
+    keyword: GherkinKeyword
+    name: str
+    description: str
+    steps: Sequence[GherkinStep]
+    examples: Sequence[GherkinExamples]
+
+
+class GherkinBackgroundEnvelope(BaseModel):
+    background: GherkinBackground
+
+
+class GherkinScenarioEnvelope(BaseModel):
+    scenario: GherkinScenario
+
+
+class GherkinRuleEnvelope(BaseModel):
+    rule: "GherkinRule"
+
+
+GherkinEnvelope = (
+    GherkinBackgroundEnvelope | GherkinScenarioEnvelope | GherkinRuleEnvelope
+)
+
+
+class GherkinRule(BaseModel):
+    id: str
+    location: GherkinLocation
+    tags: Sequence[GherkinTag]
+    keyword: GherkinKeyword
+    name: str
+    description: str
+    children: Sequence[GherkinEnvelope]
+
+
+class GherkinFeature(BaseModel):
+    location: GherkinLocation
+    tags: Sequence[GherkinTag]
+    language: str
+    keyword: GherkinKeyword
+    name: str
+    description: str
+    children: Sequence[GherkinEnvelope]
+
+
+class GherkinDocument(BaseModel):
+    name: str
+    filepath: Path
+    feature: GherkinFeature
+    comments: Sequence[GherkinComment]
+
+    @classmethod
+    def from_file(cls, file: Path) -> "GherkinDocument":
+        return GherkinDocument(
+            name=file.name[: -len(".feature")],
+            filepath=file,
+            **Parser().parse(file.read_text()),  # type: ignore
+        )

tursu-0.1.2/src/tursu/domain/model/testmod.py

@@ -0,0 +1,22 @@
+import ast
+from types import CodeType
+
+
+class TestModule:
+    def __init__(self, filename: str, module_node: ast.Module):
+        self.filename = filename
+        self.module_node = module_node
+
+    @property
+    def modname(self) -> str:
+        return self.filename[:-3]
+
+    def compile(self) -> CodeType:
+        return compile(
+            ast.unparse(self.module_node), filename=self.filename, mode="exec"
+        )
+
+    def __str__(self) -> str:
+        return ast.unparse(self.module_node)
+
+    __repr__ = __str__

tursu-0.1.2/src/tursu/exceptions.py

@@ -0,0 +1 @@
+class Unregistered(RuntimeError): ...

tursu-0.1.2/src/tursu/pattern_matcher.py

@@ -0,0 +1,89 @@
+import abc
+import re
+from collections.abc import Mapping
+from inspect import Signature
+from typing import Any
+
+
+class AbstractPatternMatcher(abc.ABC):
+    def __init__(self, pattern: str, signature: Signature) -> None:
+        self.pattern = pattern
+        self.signature = signature
+
+    def __eq__(self, other: Any) -> bool:
+        if self.__class__ != other.__class__:
+            return False
+        return self.pattern == self.pattern
+
+    def __str__(self) -> str:
+        return self.pattern
+
+    def __repr__(self) -> str:
+        return f'"{self.pattern}"'
+
+    @abc.abstractmethod
+    def get_matches(
+        self, text: str, kwargs: Mapping[str, Any]
+    ) -> Mapping[str, Any] | None: ...
+
+    @abc.abstractmethod
+    def extract_fixtures(self, text: str) -> Mapping[str, Any] | None: ...
+
+
+class AbstractPattern(abc.ABC):
+    def __init__(self, pattern: str) -> None:
+        self.pattern = pattern
+
+    @classmethod
+    @abc.abstractmethod
+    def get_matcher(cls) -> type[AbstractPatternMatcher]: ...
+
+
+class DefaultPatternMatcher(AbstractPatternMatcher):
+    def __init__(self, pattern: str, signature: Signature) -> None:
+        super().__init__(pattern, signature)
+        re_pattern = pattern
+        for key, val in signature.parameters.items():
+            match val.annotation:
+                case type() if val.annotation is int:
+                    re_pattern = re_pattern.replace(f"{{{key}}}", rf"(?P<{key}>\d+)")
+                case _:
+                    # if enclosed by double quote, use double quote as escaper
+                    # not a gherkin spec.
+                    re_pattern = re_pattern.replace(f'"{{{key}}}"', rf'"(?P<{key}>[^"]+)"')
+                    # otherwise, match one word
+                    re_pattern = re_pattern.replace(f"{{{key}}}", rf"(?P<{key}>[^\s]+)")
+        self.re_pattern = re.compile(f"^{re_pattern}$")
+
+    def get_matches(
+        self, text: str, kwargs: Mapping[str, Any]
+    ) -> Mapping[str, Any] | None:
+        matches = self.re_pattern.match(text)
+        if matches:
+            res = {}
+            matchdict = matches.groupdict()
+            for key, val in self.signature.parameters.items():
+                if key in matchdict:
+                    res[key] = self.signature.parameters[key].annotation(matchdict[key])
+                elif key in kwargs:
+                    res[key] = kwargs[key]
+                elif val.default and val.default != val.empty:
+                    res[key] = val.default
+            return res
+
+        return None
+
+    def extract_fixtures(self, text: str) -> Mapping[str, Any] | None:
+        matches = self.re_pattern.match(text)
+        if matches:
+            res = {}
+            matchdict = matches.groupdict()
+            for key, val in self.signature.parameters.items():
+                if key in matchdict:
+                    continue
+                if val.default != val.empty:
+                    continue
+                res[key] = val.annotation
+            return res
+
+        return None

tursu-0.1.2/src/tursu/registry.py

@@ -0,0 +1,102 @@
+import sys
+from collections.abc import Mapping
+from types import ModuleType
+from typing import Callable
+
+import venusian
+from typing_extensions import Any
+
+from .exceptions import Unregistered
+from .steps import Handler, Step, StepKeyword
+
+VENUSIAN_CATEGORY = "tursu"
+
+
+def _step(step_name: str, step_pattern: str) -> Callable[[Handler], Handler]:
+    def wrapper(wrapped: Handler) -> Handler:
+        def callback(scanner: venusian.Scanner, name: str, ob: Handler) -> None:
+            if not hasattr(scanner, "registry"):
+                return  # coverage: ignore
+            scanner.registry.register_handler(step_name, step_pattern, wrapped)  # type: ignore
+
+        venusian.attach(wrapped, callback, category=VENUSIAN_CATEGORY)  # type: ignore
+        return wrapped
+
+    return wrapper
+
+
+def given(pattern: str) -> Callable[[Handler], Handler]:
+    """
+    Decorator to listen for the given gherkin keyword.
+    """
+    return _step("given", pattern)
+
+
+def when(pattern: str) -> Callable[[Handler], Handler]:
+    """
+    Decorator to listen for the when gherkin keyword.
+    """
+    return _step("when", pattern)
+
+
+def then(pattern: str) -> Callable[[Handler], Handler]:
+    """
+    Decorator to listen for the then gherkin keyword.
+    """
+    return _step("then", pattern)
+
+
+class StepRegistry:
+    """Store all the handlers for gherkin action."""
+
+    def __init__(self) -> None:
+        self._handlers: dict[StepKeyword, list[Step]] = {
+            "given": [],
+            "when": [],
+            "then": [],
+        }
+
+    def register_handler(
+        self, type: StepKeyword, pattern: str, handler: Handler
+    ) -> None:
+        self._handlers[type].append(Step(pattern, handler))
+
+    def run_step(self, step: StepKeyword, text: str, **kwargs: Any) -> None:
+        handlers = self._handlers[step]
+        for handler in handlers:
+            matches = handler.pattern.get_matches(text, kwargs)
+            if matches is not None:
+                handler(**matches)
+                break
+        else:
+            raise Unregistered(f"{step.capitalize()} {text}")
+
+    def extract_fixtures(
+        self, step: StepKeyword, text: str, **kwargs: Any
+    ) -> Mapping[str, Any]:
+        handlers = self._handlers[step]
+        for handler in handlers:
+            fixtures = handler.pattern.extract_fixtures(text)
+            if fixtures is not None:
+                return fixtures
+                break
+        else:
+            raise Unregistered(f"{step.capitalize()} {text}")
+
+    def scan(self, mod: ModuleType | None = None) -> "StepRegistry":
+        """
+        Scan the module (or modules) containing steps.
+        """
+        if mod is None:
+            import inspect
+
+            mod = inspect.getmodule(inspect.stack()[1][0])
+            assert mod
+            module_name = mod.__name__
+            if "." in module_name:  # Check if it's a submodule
+                parent_name = module_name.rsplit(".", 1)[0]  # Remove the last part
+                mod = sys.modules.get(parent_name)
+
+        scanner = venusian.Scanner(registry=self)
+        scanner.scan(mod, categories=[VENUSIAN_CATEGORY])  # type: ignore
+        return self

tursu-0.1.2/src/tursu/steps.py

@@ -0,0 +1,35 @@
+import inspect
+from typing import Any, Callable, Literal
+
+from .pattern_matcher import (
+    AbstractPattern,
+    AbstractPatternMatcher,
+    DefaultPatternMatcher,
+)
+
+StepKeyword = Literal["given", "when", "then"]
+Handler = Callable[..., None]
+
+
+class Step:
+    def __init__(self, pattern: str | AbstractPattern, hook: Handler):
+        matcher: type[AbstractPatternMatcher]
+        if isinstance(pattern, str):
+            matcher = DefaultPatternMatcher
+        else:
+            matcher = pattern.get_matcher()
+            pattern = pattern.pattern
+
+        self.pattern = matcher(pattern, inspect.signature(hook))
+        self.hook = hook
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Step):
+            return False
+        return self.pattern == other.pattern and self.hook == other.hook
+
+    def __repr__(self) -> str:
+        return f"Step({self.pattern}, {self.hook.__qualname__})"
+
+    def __call__(self, **kwargs: Any) -> None:
+        self.hook(**kwargs)