feat: refactor for code clarity

Author: LifeLex

Makefile

@@ -0,0 +1,34 @@
+.PHONY: help install test lint format typecheck check clean build
+
+help: ## Show this help
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-12s\033[0m %s\n", $$1, $$2}'
+
+install: ## Install in editable mode with dev dependencies
+	pip install -e ".[dev]"
+
+test: ## Run tests
+	pytest tests/ -v
+
+lint: ## Run ruff linter
+	ruff check --no-fix src tests
+
+format: ## Run ruff formatter (fix in place)
+	ruff format src tests
+	ruff check --fix src tests
+
+format-check: ## Check formatting without changes
+	ruff format --check src tests
+	ruff check --no-fix src tests
+
+typecheck: ## Run mypy and pyright
+	mypy src
+	pyright src
+
+check: lint format-check typecheck test ## Run all checks (lint, format, types, tests)
+
+clean: ## Remove build artifacts
+	rm -rf dist build src/*.egg-info .pytest_cache .mypy_cache .ruff_cache htmlcov .coverage
+	find . -type d -name __pycache__ -exec rm -rf {} +
+
+build: clean ## Build source and wheel distributions
+	python -m build

README.md

@@ -68,42 +68,65 @@ def test_string_path():
 - `patch.object()` targeting the protected function
 - Other mocking is allowed
 
-## Testing
+## Development
 
 ```bash
-tox
+git clone git@github.com:LifeLex/pytest-do-not-mock.git
+cd pytest-do-not-mock
+python3 -m venv .venv
+source .venv/bin/activate
+make install
+```
+
+### Available commands
+
+```
+make help         Show all commands
+make install      Install in editable mode with dev dependencies
+make test         Run tests
+make lint         Run ruff linter
+make format       Run ruff formatter
+make typecheck    Run mypy and pyright
+make check        Run all checks (lint, format, types, tests)
+make clean        Remove build artifacts
+make build        Build source and wheel distributions
 ```
 
-Runs tests across Python 3.10–3.13, plus ruff linting and type checking (mypy + pyright).
+### Running checks
 
 ```bash
-tox -e py313          # single Python version
-tox -e linting        # ruff check + format
-tox -e typing         # mypy + pyright
-pytest tests/ -v      # run tests directly
+make check        # everything: lint + format + typecheck + tests
+make lint         # ruff linter only
+make typecheck    # mypy + pyright
+make test         # pytest only
 ```
 
-## Development
+Or via tox for multi-version testing:
 
 ```bash
-git clone git@github.com:LifeLex/pytest-do-not-mock.git
-cd pytest-do-not-mock
-python3 -m venv .venv
-source .venv/bin/activate
-pip install -e ".[dev]"
+tox               # all environments (py310–py313, linting, typing)
+tox -e py313      # single Python version
 ```
 
 ### Project structure
 
 ```
 src/pytest_do_not_mock/
 ├── __init__.py      # Public API: do_not_mock, DoNotMockError
-└── plugin.py        # Decorator + pytest hooks
+├── plugin.py        # Pytest hooks (entry point)
+├── decorator.py     # @pytest.do_not_mock decorator
+├── guards.py        # Mock interception and guard context manager
+└── protected.py     # ProtectedFunc resolution and validation
 
 tests/
 └── test_do_not_mock.py
 ```
 
+### Releasing
+
+1. Tag the commit: `git tag v0.1.0 && git push origin v0.1.0`
+2. GitHub Actions builds and publishes to PyPI automatically via trusted publishing
+
 ## License
 
 MIT

pyproject.toml

@@ -82,6 +82,7 @@ exclude_lines = [
 line-length = 120
 target-version = "py310"
 fix = true
+exclude = ["src/pytest_do_not_mock/_version.py"]
 
 [tool.ruff.lint]
 select = ["E4", "E7", "E9", "F", "B", "I"]

src/pytest_do_not_mock/__init__.py

@@ -5,7 +5,8 @@
 except ImportError:
     __version__ = "unknown"
 
-from .plugin import DoNotMockError, do_not_mock
+from .decorator import do_not_mock
+from .errors import DoNotMockError
 
 
 __all__ = ["do_not_mock", "DoNotMockError", "__version__"]

src/pytest_do_not_mock/decorator.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import functools
+import unittest.mock
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+from .errors import DoNotMockError
+from .guards import mock_guard
+from .protected import ProtectedFunc, validate_no_mocks
+
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def do_not_mock(*funcs: Any) -> Any:
+    """Test decorator that prevents mocking.
+
+    Usage::
+
+        @pytest.do_not_mock                          # blocks ALL mocking
+        @pytest.do_not_mock()                         # blocks ALL mocking
+        @pytest.do_not_mock(func1, func2)             # blocks only these functions
+        @pytest.do_not_mock("myapp.module.func")      # string paths supported
+    """
+    # @pytest.do_not_mock without parentheses — single callable whose name starts with test_
+    if len(funcs) == 1 and callable(funcs[0]) and not isinstance(funcs[0], str):
+        func = funcs[0]
+        if getattr(func, "__name__", "").startswith("test_"):
+            return _wrap_block_all(func)
+
+    def decorator(test_func: F) -> F:
+        if not funcs:
+            return _wrap_block_all(test_func)
+        return _wrap_targeted(test_func, list(funcs))
+
+    return decorator
+
+
+def _wrap_block_all(test_func: F) -> F:
+    @functools.wraps(test_func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        for arg in args:
+            if isinstance(arg, unittest.mock.NonCallableMock):
+                raise DoNotMockError(
+                    f"\nPatching is not allowed in test '{test_func.__name__}' (decorated with @pytest.do_not_mock).\n"
+                )
+        with mock_guard(test_func.__name__, block_all=True):
+            return test_func(*args, **kwargs)
+
+    wrapper._pytest_do_not_mock = True  # type: ignore[attr-defined]
+    return wrapper  # type: ignore[return-value]
+
+
+def _wrap_targeted(test_func: F, funcs: list[Any]) -> F:
+    protected = [ProtectedFunc.from_arg(f) for f in funcs]
+
+    @functools.wraps(test_func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        validate_no_mocks(protected, test_func.__name__, "before")
+        with mock_guard(test_func.__name__, protected=protected):
+            result = test_func(*args, **kwargs)
+        validate_no_mocks(protected, test_func.__name__, "after")
+        return result
+
+    wrapper._pytest_do_not_mock = True  # type: ignore[attr-defined]
+    wrapper._pytest_do_not_mock_funcs = funcs  # type: ignore[attr-defined]
+    return wrapper  # type: ignore[return-value]

src/pytest_do_not_mock/errors.py

@@ -0,0 +1,5 @@
+"""Exceptions for pytest-do-not-mock."""
+
+
+class DoNotMockError(Exception):
+    """Raised when mocking is attempted in a protected test."""

src/pytest_do_not_mock/guards.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import contextlib
+import unittest.mock
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from typing import Any
+
+from .errors import DoNotMockError
+from .protected import ProtectedFunc
+
+
+_original_mock_init = unittest.mock.NonCallableMock.__init__
+_original_patch_enter = unittest.mock._patch.__enter__  # pyright: ignore[reportPrivateUsage,reportUnknownVariableType,reportUnknownMemberType]
+_original_patch_dict_enter = unittest.mock._patch_dict.__enter__  # pyright: ignore[reportPrivateUsage]
+
+
+@dataclass
+class _ActiveGuard:
+    test_name: str
+    block_all: bool = False
+    protected: list[ProtectedFunc] = field(default_factory=lambda: [])
+
+
+_active_guard: _ActiveGuard | None = None
+
+
+def _guarded_mock_init(self: Any, *args: Any, **kwargs: Any) -> None:
+    guard = _active_guard
+    if guard is not None and guard.block_all:
+        raise DoNotMockError(
+            f"\nMocking is not allowed in test '{guard.test_name}' (decorated with @pytest.do_not_mock).\n"
+        )
+    _original_mock_init(self, *args, **kwargs)
+
+
+def _guarded_patch_enter(self: Any) -> Any:
+    guard = _active_guard
+    if guard is None:
+        return _original_patch_enter(self)  # pyright: ignore[reportUnknownVariableType]
+
+    if guard.block_all:
+        raise DoNotMockError(
+            f"\nPatching is not allowed in test '{guard.test_name}' (decorated with @pytest.do_not_mock).\n"
+        )
+
+    # Targeted mode — only block patches that hit a protected function
+    try:
+        target = self.getter()
+    except Exception:
+        return _original_patch_enter(self)  # pyright: ignore[reportUnknownVariableType]
+
+    for pf in guard.protected:
+        if pf.matches_patch_target(target, self.attribute):
+            raise DoNotMockError(
+                f"\nTest '{guard.test_name}' marked '{pf.name}' with @pytest.do_not_mock\n"
+                f"but it is being patched.\n"
+                f"\nPlease remove the patch for '{pf.module_path}'.\n"
+            )
+    return _original_patch_enter(self)  # pyright: ignore[reportUnknownVariableType]
+
+
+def _guarded_patch_dict_enter(self: Any) -> Any:
+    guard = _active_guard
+    if guard is not None and guard.block_all:
+        raise DoNotMockError(
+            f"\nPatching is not allowed in test '{guard.test_name}' (decorated with @pytest.do_not_mock).\n"
+        )
+    return _original_patch_dict_enter(self)
+
+
+@contextlib.contextmanager
+def mock_guard(
+    test_name: str,
+    *,
+    block_all: bool = False,
+    protected: list[ProtectedFunc] | None = None,
+) -> Iterator[None]:
+    """Install mock guards for the duration of a ``with`` block, then restore originals."""
+    global _active_guard  # noqa: PLW0603
+
+    _active_guard = _ActiveGuard(test_name=test_name, block_all=block_all, protected=protected or [])
+
+    unittest.mock.NonCallableMock.__init__ = _guarded_mock_init  # type: ignore[method-assign]
+    unittest.mock._patch.__enter__ = _guarded_patch_enter  # type: ignore[method-assign]
+    unittest.mock._patch_dict.__enter__ = _guarded_patch_dict_enter  # type: ignore[method-assign]
+    try:
+        yield
+    finally:
+        unittest.mock.NonCallableMock.__init__ = _original_mock_init  # type: ignore[method-assign]
+        unittest.mock._patch.__enter__ = _original_patch_enter  # type: ignore[method-assign]
+        unittest.mock._patch_dict.__enter__ = _original_patch_dict_enter  # type: ignore[method-assign]
+        _active_guard = None