Merge pull request #83 from ronaldorcampos/feature/support-pyproject

Add support for pyproject.toml

Author: jaltmayerpizzorno

README.md

@@ -91,6 +91,36 @@ which starts `pytest`, passing it any options (`-x -v` in this example)
 after the module name.
 No plug-in is required for pytest.
 
+### Configuration via `pyproject.toml`
+Instead of passing options on every command invocation, you can store them
+in your project's `pyproject.toml` under the `[tool.slipcover]` section.
+SlipCover automatically discovers the nearest `pyproject.toml` by walking up
+from the current working directory.
+
+```toml
+[tool.slipcover]
+branch = true
+source = "src"        # or ["src", "lib"]
+omit = "tests/*"       # or ["tests/*", "*.pyc"]
+fail-under = 80.0
+json = true
+xml = false
+pretty-print = true
+skip-covered = true
+immediate = false
+out = "coverage.json"
+threshold = 75
+missing-width = 120
+xml-package-depth = 3
+```
+
+Most command-line flags have a matching key (use hyphens, as shown above);
+`source` and `omit` also accept a TOML array instead of a single
+comma-separated string. `--merge`, `-m`/module, the script argument, `--version`,
+and `--help` are per-invocation choices rather than settings, so they aren't
+configurable this way. Command-line arguments always take precedence over
+values in `pyproject.toml`, so you can override any setting on a per-run basis.
+
 ## Usage example
 ```console
 $ python3 -m slipcover -m pytest

pyproject.toml

@@ -21,7 +21,8 @@ classifiers = [
 ]
 requires-python = ">=3.9,<3.15"
 dependencies = [
-    "tabulate"
+    "tabulate",
+    "tomli; python_version < '3.11'"
 ]
 
 [project.scripts]

src/slipcover/__main__.py

@@ -154,8 +154,40 @@ def merge_files(args, base_path):
     return 0
 
 
+def _detect_explicit_args(ap, argv):
+    """Returns the set of argparse dest names explicitly provided on the command line."""
+    import argparse
+
+    explicit = set()
+
+    class _Track(argparse.Action):
+        def __call__(self, parser, namespace, values, option_string=None):
+            explicit.add(self.dest)
+            setattr(namespace, self.dest, values)
+
+    shadow = argparse.ArgumentParser(add_help=False)
+    for action in ap._actions:
+        if action.option_strings:
+            kwargs = {
+                "dest": action.dest,
+                "nargs": action.nargs,
+                "default": action.default,
+            }
+            if isinstance(action, argparse._StoreTrueAction):
+                kwargs["nargs"] = 0
+                kwargs["const"] = True
+            elif isinstance(action, argparse._VersionAction):
+                continue
+            kwargs["action"] = _Track
+            shadow.add_argument(*action.option_strings, **kwargs)
+
+    shadow.parse_known_args(argv)
+    return explicit
+
+
 def main():
     import argparse
+    from slipcover.config import read_config, apply_config
 
     #
     # The intended usage is:
@@ -202,13 +234,32 @@ def main():
     g.add_argument('script', nargs='?', type=Path, help="the script to run")
     ap.add_argument('script_or_module_args', nargs=argparse.REMAINDER)
 
+    # Figure out which CLI flags were explicitly provided, so that
+    # pyproject.toml values don't override them.
+    if '-m' in sys.argv:
+        minus_m = sys.argv.index('-m')
+        cli_argv = sys.argv[1:minus_m+2]
+    else:
+        cli_argv = sys.argv[1:]
+
+    explicit_args = _detect_explicit_args(ap, cli_argv)
+
     if '-m' in sys.argv: # work around exclusive group not handled properly
         minus_m = sys.argv.index('-m')
         args = ap.parse_args(sys.argv[1:minus_m+2])
         args.script_or_module_args = sys.argv[minus_m+2:]
     else:
         args = ap.parse_args(sys.argv[1:])
 
+    # Apply [tool.slipcover] from pyproject.toml; CLI flags take precedence
+    try:
+        config = read_config()
+        if config:
+            apply_config(config, args, explicit_args)
+    except (ValueError, TypeError) as e:
+        print(f"slipcover: error in pyproject.toml configuration: {e}", file=sys.stderr)
+        return 1
+
 
     base_path = Path(args.script).resolve().parent if args.script \
                 else Path('.').resolve()

src/slipcover/config.py

@@ -0,0 +1,128 @@
+"""Read and apply [tool.slipcover] configuration from pyproject.toml."""
+
+from pathlib import Path
+
+try:
+    import tomllib  # Python 3.11+
+except ImportError:
+    import tomli as tomllib  # type: ignore[no-redef]
+
+
+# Markers that indicate a project root; stop climbing here.
+_ROOT_MARKERS = frozenset({".git", ".hg", ".svn", "setup.py", "setup.cfg"})
+
+# Maximum number of parent directories to walk up from the start.
+_MAX_WALK = 3
+
+
+def find_pyproject(start=None):
+    """Walks up from 'start' (default cwd) looking for pyproject.toml.
+
+    The search stops and returns None when any of these boundaries is
+    reached without finding the file:
+
+    - a directory containing a VCS/project root marker
+      (.git, .hg, .svn, setup.py, setup.cfg)
+    - the user's home directory
+    - more than _MAX_WALK parent directories have been visited
+    """
+    if start is None:
+        start = Path.cwd()
+    start = start.resolve()
+
+    home = Path.home()
+
+    for depth, directory in enumerate((start, *start.parents)):
+        candidate = directory / "pyproject.toml"
+        if candidate.is_file():
+            return candidate
+
+        # Don't climb above a project root, the user's home directory,
+        # or more than _MAX_WALK levels.
+        if (depth >= _MAX_WALK
+                or directory == home
+                or any((directory / m).exists() for m in _ROOT_MARKERS)):
+            break
+
+    return None
+
+
+def read_config(path=None):
+    """Returns the [tool.slipcover] table from a pyproject.toml.
+
+    If 'path' is None, find_pyproject() is used to locate the file.
+    Returns an empty dict when no file is found or the section is absent.
+    """
+    if path is None:
+        path = find_pyproject()
+
+    if path is None:
+        return {}
+
+    with open(path, "rb") as f:
+        data = tomllib.load(f)
+
+    return data.get("tool", {}).get("slipcover", {})
+
+
+# Boolean flags (store_true in CLI). Excludes --silent/--dis/--debug/
+# --dont-wrap-pytest: those are argparse.SUPPRESS'd, dev-only flags, not
+# part of the stable, user-facing config surface.
+_BOOL_KEYS = {
+    "branch",
+    "json",
+    "pretty-print",
+    "xml",
+    "immediate",
+    "skip-covered",
+}
+
+# Keys that take a value
+_VALUE_KEYS = {
+    "out": Path,
+    "source": str,
+    "omit": str,
+    "fail-under": float,
+    "threshold": int,
+    "missing-width": int,
+    "xml-package-depth": int,
+}
+
+
+def apply_config(config, parsed_args, explicit_args=None):
+    """Merges config values into parsed_args.
+
+    Keys whose dest name appears in 'explicit_args' are skipped so that
+    command-line flags always take precedence over the config file.
+
+    Raises TypeError if a boolean key has a non-boolean value.
+    Emits a UserWarning for unrecognised keys.
+    """
+    if explicit_args is None:
+        explicit_args = set()
+
+    for key, value in config.items():
+        dest = key.replace("-", "_")
+
+        # CLI flags always win
+        if dest in explicit_args:
+            continue
+
+        if key in _BOOL_KEYS:
+            if not isinstance(value, bool):
+                raise TypeError(
+                    f"[tool.slipcover] key '{key}' must be a boolean, got {type(value).__name__}"
+                )
+            setattr(parsed_args, dest, value)
+
+        elif key in _VALUE_KEYS:
+            # TOML's idiomatic way to express multiple values is an array;
+            # join it the way --source/--omit's comma-separated CLI form
+            # expects, rather than stringifying the Python list itself.
+            if key in ("source", "omit") and isinstance(value, list):
+                value = ",".join(str(v) for v in value)
+            setattr(parsed_args, dest, _VALUE_KEYS[key](value))
+
+        else:
+            import warnings
+            warnings.warn(f"Unknown [tool.slipcover] key: '{key}'")