habit-hooks-python 1.3.0__tar.gz → 1.4.0rc1__tar.gz

habit_hooks_python-1.4.0rc1/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.5
+Name: habit-hooks-python
+Version: 1.4.0rc1
+Summary: The Python Habit Hooks plugin
+Project-URL: Homepage, https://habit-hooks.com
+Project-URL: Repository, https://github.com/habit-hooks/habit-hooks
+Project-URL: Issues, https://github.com/habit-hooks/habit-hooks/issues
+Project-URL: Changelog, https://github.com/habit-hooks/habit-hooks/blob/main/CHANGELOG.md
+License-Expression: MIT
+Keywords: ai-coding-agents,ci,code-quality,code-review,code-smells,coding-agents,developer-tools,linter,python,refactoring,static-analysis,technical-debt
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# habit-hooks-python
+
+The Python Habit Hooks plugin: wraps [`ruff`](https://docs.astral.sh/ruff/) for
+structural smells (complexity, too many parameters, swallowed exceptions, …)
+and [`deptry`](https://github.com/fpgmaas/deptry) for dependency issues.
+
+## Install
+
+```sh
+pip install "habit-hooks[python]"
+```
+
+## Enable
+
+```toml
+# .habit-hooks/config.toml
+plugins = ["python", "generic"]
+```
+
+Installing a plugin does not switch it on — it has to be named in
+`plugins` before habit-hooks runs it.
+
+## Detectors
+
+- [`ruff`](https://docs.astral.sh/ruff/), [`deptry`](https://github.com/fpgmaas/deptry) —
+  `pip install ruff deptry`
+
+Part of [habit-hooks](https://github.com/habit-hooks/habit-hooks).

habit_hooks_python-1.4.0rc1/README.md

@@ -0,0 +1,28 @@
+# habit-hooks-python
+
+The Python Habit Hooks plugin: wraps [`ruff`](https://docs.astral.sh/ruff/) for
+structural smells (complexity, too many parameters, swallowed exceptions, …)
+and [`deptry`](https://github.com/fpgmaas/deptry) for dependency issues.
+
+## Install
+
+```sh
+pip install "habit-hooks[python]"
+```
+
+## Enable
+
+```toml
+# .habit-hooks/config.toml
+plugins = ["python", "generic"]
+```
+
+Installing a plugin does not switch it on — it has to be named in
+`plugins` before habit-hooks runs it.
+
+## Detectors
+
+- [`ruff`](https://docs.astral.sh/ruff/), [`deptry`](https://github.com/fpgmaas/deptry) —
+  `pip install ruff deptry`
+
+Part of [habit-hooks](https://github.com/habit-hooks/habit-hooks).

{habit_hooks_python-1.3.0 → habit_hooks_python-1.4.0rc1}/docs/python-plugin.spec.md

@@ -12,10 +12,11 @@ plugins = ["python"]
 
 ## ruff adapter maps rule IDs to canonical smells
 
-The `ruff` adapter selects `C901,PLR0913,PLR0915,F841,F401,BLE001` and a jq
-transform in its command groups the flat output into one finding per smell,
-stamping `source: "ruff:<code>"` on each issue. The shipped `ruff.toml` carries
-`max-args = 3`, so a four-argument function trips `PLR0913`.
+The `ruff` adapter selects `C901,PLR0913,PLR0915,F841,F401,BLE001` and a
+Python helper beside the sensor spec (`ruff_sensor.py`) groups the flat
+output into one finding per smell, stamping `source: "ruff:<code>"` on each
+issue. The shipped `ruff.toml` carries `max-args = 3`, so a four-argument
+function trips `PLR0913`.
 
 📄ruff.toml @plugins/python/src/habit_hooks_python/ruff.toml
 
@@ -336,17 +337,18 @@ habit-sensors --all 2>&1 >/dev/null | sed -n 1p
 
 🖥️ ❌ 1
 ```text
-habit-sensors: sensor 'deptry' failed: ${python} ${dir}/deptry_sensor.py
+habit-sensors: sensor 'deptry' failed: '${python}' '${dir}/deptry_sensor.py'
 ```
 
 ## A crashing ruff fails the run, never reports clean
 
-The `ruff` sensor pipes the tool into `jq`. A crashing `ruff` (here, a malformed
-`ruff.toml` that makes the tool exit non-zero) prints nothing on stdout, so a
-naive pipe would let `jq` succeed on empty input and mask the crash as a false-
-clean run. The command sets `pipefail` so the tool's failing exit propagates
-through the pipe; `habit-sensors` then raises, names the sensor on stderr, and
-exits 1, carrying only the reserved `incomplete-run` marker on stdout
+The `ruff` sensor runs a Python helper (`ruff_sensor.py`) rather than piping
+the tool into `jq`. A crashing `ruff` (here, a malformed `ruff.toml` that makes
+the tool exit non-zero) is a genuine crash, not a violation: ruff's own
+contract is 0 clean, 1 violations found, and the helper treats any other exit
+as broken, exiting 2 itself with nothing on stdout. `habit-sensors` then
+raises, names the sensor on stderr, and exits 1, carrying only the reserved
+`incomplete-run` marker on stdout
 ([habit-sensors.spec.md](../../../docs/habit-sensors.spec.md)).
 
 📄.habit-hooks/config.toml
@@ -376,8 +378,7 @@ habit-sensors --all | jq -c '[.[].smell]'
 ["incomplete-run"]
 ```
 
-The notice quotes the sensor's whole command — multi-line here, so its first
-line shows only where that command starts — and then ruff's own diagnosis, which
+The notice quotes the sensor's whole command, then ruff's own diagnosis, which
 names the absolute path of the config it could not parse. Only the line naming
 the sensor is stable enough to assert.
 
@@ -387,5 +388,5 @@ habit-sensors --all 2>&1 >/dev/null | sed -n 1p
 
 🖥️ ❌ 1
 ```text
-habit-sensors: sensor 'ruff' failed: set -o pipefail
+habit-sensors: sensor 'ruff' failed: '${python}' '${dir}/ruff_sensor.py' '${files}'
 ```

habit_hooks_python-1.4.0rc1/pyproject.toml

@@ -0,0 +1,51 @@
+[project]
+name = "habit-hooks-python"
+version = "1.4.0rc1"
+description = "The Python Habit Hooks plugin"
+readme = "README.md"
+license = "MIT"
+keywords = [
+    "code-quality",
+    "code-smells",
+    "static-analysis",
+    "linter",
+    "ci",
+    "code-review",
+    "technical-debt",
+    "refactoring",
+    "ai-coding-agents",
+    "coding-agents",
+    "developer-tools",
+    "python",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Testing",
+    "Topic :: Utilities",
+]
+requires-python = ">=3.11"
+dependencies = []
+
+[project.entry-points."habit_hooks.plugins"]
+python = "habit_hooks_python"
+
+[project.urls]
+Homepage = "https://habit-hooks.com"
+Repository = "https://github.com/habit-hooks/habit-hooks"
+Issues = "https://github.com/habit-hooks/habit-hooks/issues"
+Changelog = "https://github.com/habit-hooks/habit-hooks/blob/main/CHANGELOG.md"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/habit_hooks_python"]

{habit_hooks_python-1.3.0 → habit_hooks_python-1.4.0rc1}/src/habit_hooks_python/config.toml

@@ -8,9 +8,7 @@ files = ["**/*.py", "!**/site-packages/**", "!**/.venv/**", "!**/venv/**"]
 sensors = ["ruff", "deptry"]
 transformers = []
 
-# The ruff sensor pipes its JSON through jq, so a python-only project needs it.
 detectors = [
   { name = "ruff", kind = "command", install = "pip install ruff" },
   { name = "deptry", kind = "command", install = "pip install deptry" },
-  { name = "jq", kind = "command", install = "brew install jq" },
 ]

habit_hooks_python-1.4.0rc1/src/habit_hooks_python/sensors/deptry.toml

@@ -0,0 +1 @@
+argv = ["${python}", "${dir}/deptry_sensor.py"]

{habit_hooks_python-1.3.0 → habit_hooks_python-1.4.0rc1}/src/habit_hooks_python/sensors/deptry_sensor.py

@@ -13,6 +13,8 @@ import sys
 import tempfile
 from pathlib import Path
 
+from tool_spawn import run_tool
+
 
 def run_deptry(report: Path) -> subprocess.CompletedProcess[str]:
     """What deptry said, or what a shell says about a deptry nobody installed.
@@ -22,11 +24,13 @@ def run_deptry(report: Path) -> subprocess.CompletedProcess[str]:
     absent tool raised a ``FileNotFoundError`` out of here, making twenty lines
     of Python internals the sensor's diagnosis (#114). This wrapper is what looks
     for deptry, so it answers the way the shell would have, and that phrase is
-    what the run recognises to name the missing tool.
+    what the run recognises to name the missing tool. Looking is ``tool_spawn``'s,
+    which names the file — a console script a project's own venv installed, which
+    Windows spells ``deptry.exe`` there and habit-hooks' venv may not hold at all.
     """
     command = ["deptry", ".", "--json-output", str(report)]
     try:
-        return subprocess.run(command, capture_output=True, text=True)
+        return run_tool(command)
     except FileNotFoundError:
         return subprocess.CompletedProcess(
             command, 127, "", "deptry: command not found\n"
@@ -52,7 +56,7 @@ def deptry_found_no_declaration(result: subprocess.CompletedProcess[str]) -> boo
 
 
 def unused_dependencies(report: Path) -> list[dict]:
-    entries = json.loads(report.read_text())
+    entries = json.loads(report.read_text(encoding="utf-8"))
     return [entry for entry in entries if entry["error"]["code"] == "DEP002"]
 
 

habit_hooks_python-1.4.0rc1/src/habit_hooks_python/sensors/ruff.toml

@@ -0,0 +1 @@
+argv = ["${python}", "${dir}/ruff_sensor.py", "${files}"]

habit_hooks_python-1.4.0rc1/src/habit_hooks_python/sensors/ruff_sensor.py

@@ -0,0 +1,126 @@
+"""Run ruff and print canonical findings, mapped from rule code to smell.
+
+ruff's own JSON is one entry per violation; this groups them by mapped smell
+and shapes each into the canonical finding — the job the old
+``ruff | jq`` pipeline did, without needing ``jq`` installed (dropping the
+plugin's only other declared detector, and the shell it took to pipe through
+it).
+
+An entry's ``code`` not in :data:`CODE_SMELLS` has no smell to report it
+under (a code outside ``--select`` besides ``invalid-syntax``, which ruff
+reports regardless of ``--select``). It is dropped rather than crashed on or
+forwarded under ruff's own name — the same choice the knip sensor makes for a
+key with no smell mapped (see "A sensor emits vocabulary smells only" in
+CLAUDE.md): a key nobody catalogued has no guide and no severity, so
+forwarding it can only fail a run and decline to explain why. Dropping is
+also safe *by construction* rather than by ``--select`` pinning the set, which
+is what the old jq filter depended on (indexing a jq object with a key that
+maps to nothing is a jq crash, not a miss — issue #83).
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+
+from tool_spawn import run_tool
+
+SELECTED_CODES = "C901,PLR0913,PLR0915,F841,F401,BLE001"
+
+CODE_SMELLS = {
+    "C901": "high-complexity",
+    "PLR0913": "too-many-parameters",
+    "PLR0915": "oversized-function",
+    "F841": "unused-variable",
+    "F401": "unused-import",
+    "BLE001": "swallowed-exception",
+    "invalid-syntax": "parse-error",
+}
+
+# ruff's own contract: 0 is clean, 1 is "violations found" — both trustworthy.
+# Anything else is ruff never having produced a real report (bad config, a
+# missing file, an internal error), the same distinction part_output.py's
+# TOOL_EXIT_CODES draws for a part run directly.
+TOOL_EXIT_CODES = (0, 1)
+
+
+def run_ruff(files: list[str]) -> subprocess.CompletedProcess[str]:
+    """What ruff said, or what a shell says about a ruff nobody installed.
+
+    ``pip install habit-hooks-python`` brings neither wrapped tool with it, so
+    this is the ordinary state of a machine that has just enabled the plugin —
+    and an absent tool raised a ``FileNotFoundError`` out of here, making
+    twenty lines of Python internals the sensor's diagnosis (#114). This
+    wrapper is what looks for ruff, so it answers the way the shell would
+    have, and that phrase is what the run recognises to name the missing
+    tool. Looking is ``tool_spawn``'s, which names the file — ``ruff.exe`` or
+    a ``.cmd`` shim on Windows, neither of which a bare ``["ruff", ...]``
+    spawn reliably reaches there.
+    """
+    command = [
+        "ruff",
+        "check",
+        "--output-format=json",
+        f"--select={SELECTED_CODES}",
+        *files,
+    ]
+    try:
+        return run_tool(command)
+    except FileNotFoundError:
+        return subprocess.CompletedProcess(
+            command, 127, "", "ruff: command not found\n"
+        )
+
+
+def ruff_crashed(result: subprocess.CompletedProcess[str]) -> bool:
+    return result.returncode not in TOOL_EXIT_CODES
+
+
+def violations(result: subprocess.CompletedProcess[str]) -> list[dict]:
+    text = result.stdout.strip()
+    return json.loads(text) if text else []
+
+
+def issue(entry: dict) -> dict:
+    return {
+        "key": entry["filename"],
+        "details": {
+            "file": entry["filename"],
+            "line": entry["location"]["row"],
+            "column": entry["location"]["column"],
+            "message": entry["message"],
+            "source": "ruff:" + entry["code"],
+        },
+    }
+
+
+def findings(entries: list[dict]) -> list[dict]:
+    by_smell: dict[str, list[dict]] = {}
+    for entry in entries:
+        smell = CODE_SMELLS.get(entry["code"])
+        if smell is None:
+            continue
+        by_smell.setdefault(smell, []).append(entry)
+    return [
+        {
+            "smell": smell,
+            "details": {},
+            "issues": [issue(entry) for entry in by_smell[smell]],
+        }
+        for smell in sorted(by_smell)
+    ]
+
+
+def main() -> int:
+    files = sys.argv[1:]
+    result = run_ruff(files)
+    if ruff_crashed(result):
+        sys.stderr.write(result.stderr)
+        return 2
+    print(json.dumps(findings(violations(result))))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

habit_hooks_python-1.4.0rc1/src/habit_hooks_python/sensors/tool_spawn.py

@@ -0,0 +1,77 @@
+"""Spawn the third-party tool a sensor wraps, by the file rather than the name.
+
+A local copy of what ``habit_hooks/sensors/spawn.py`` and its ``batch_shell`` do
+for a part's own argv, and it is a copy on purpose: this plugin declares no
+dependency on ``habit-hooks``, so a helper cannot import the core, and four
+small copies beat a dependency that does not exist. The core's modules carry the
+full reasoning; the two rules are Windows' own.
+
+**A bare name is looked up first.** Windows' spawn appends ``.exe`` to a name and
+nothing else, so the ``jscpd.CMD`` npm installs and the ``pmd.bat`` PMD ships are
+found by a lookup and then unreachable by a spawn handed the name — the tool the
+setup cleared, reported missing by the run. This is not a second answer to that
+question: habit-hooks hands a helper a ``PATH`` of the project's own bins
+(``sensors/spawn._path_env``), so ``shutil.which`` here asks exactly what cleared
+the tool, along exactly the same path.
+
+**A batch file's arguments are then ``cmd.exe``'s syntax.** ``CreateProcess``
+runs a ``.bat`` or ``.cmd`` through that shell, which reads ``&``, ``|``, ``<``,
+``>``, ``^``, ``"``, ``%VAR%`` and a newline as its own (CVE-2024-24576; CPython
+closed its half in 3.11.9, and ``>=3.11`` is supported). A sensor's arguments are
+paths out of the work tree, so one is refused rather than escaped: no tool anyone
+wraps needs those characters, and refusing needs no interpreter version to be
+right.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+
+BATCH_SUFFIXES = (".bat", ".cmd")
+
+# Everything ``cmd.exe`` reads as other than text: the separators and pipe, both
+# redirections, its own escape character, the quote that ends a quoted run, the
+# ``%`` that opens a variable, and the newline that ends the line it is reading.
+CMD_SYNTAX = frozenset('&|<>^"%\n\r')
+
+# Found, and refused rather than run — the code a shell keeps for a command it
+# located and would not execute, and outside every wrapped tool's success set.
+REFUSED_EXIT = 126
+
+
+def run_tool(command: list[str]) -> subprocess.CompletedProcess[str]:
+    """What ``command`` said, spawned as the file this project runs for its name.
+
+    A name reaching no file is spawned as it stands, so the caller's own
+    ``FileNotFoundError`` remains the single answer for a tool nobody installed.
+    """
+    program = shutil.which(command[0]) or command[0]
+    unreadable = cmd_syntax(program, command[1:])
+    if unreadable is not None:
+        return subprocess.CompletedProcess(
+            command,
+            REFUSED_EXIT,
+            "",
+            f"{program}: cannot pass {unreadable!r} to a batch file — cmd.exe "
+            "would read it as its own syntax rather than as text\n",
+        )
+    return subprocess.run(
+        [program, *command[1:]],
+        capture_output=True,
+        encoding="utf-8",
+        errors="replace",  # sensors.spawn's policy
+    )
+
+
+def cmd_syntax(program: str, arguments: list[str]) -> str | None:
+    """The first of ``arguments`` ``cmd.exe`` would read as syntax, if it reads any.
+
+    ``None`` where ``program`` is not a batch file: nothing then stands between
+    the spawn and the program, and an ``&`` in a filename is a filename.
+    """
+    if not program.lower().endswith(BATCH_SUFFIXES):
+        return None
+    return next(
+        (argument for argument in arguments if CMD_SYNTAX & set(argument)), None
+    )

habit_hooks_python-1.4.0rc1/tests/conftest.py

@@ -0,0 +1,20 @@
+"""Load the ruff sensor the way it is actually run — as a loose script.
+
+The sensor spec spells ``${python} ${dir}/ruff_sensor.py``, so the
+interpreter puts the helper's own directory first on ``sys.path`` and a unit
+test does the same rather than reaching the code as
+``habit_hooks_python.sensors.ruff_sensor`` — a load path no run ever takes
+(see "A plugin helper imports its neighbours as top-level modules" in
+CLAUDE.md).
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+SENSORS = (
+    Path(__file__).resolve().parents[1] / "src" / "habit_hooks_python" / "sensors"
+)
+
+sys.path.insert(0, str(SENSORS))

habit_hooks_python-1.4.0rc1/tests/test_a_crashing_ruff_fails_the_run.py

@@ -0,0 +1,55 @@
+"""A broken ``ruff`` must not read as clean — it must fail the sensor.
+
+``ruff_crashed`` trusts exactly ruff's own contract (0 clean, 1 violations
+found); the boundary is exercised directly here, and
+``test_a_broken_ruff_toml_fails_the_run`` proves the whole helper honours it
+against the real tool, mirroring
+``test_deptry_failing_another_way_still_fails_the_run``.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+from ruff_sensor import ruff_crashed
+
+SENSOR = (
+    Path(__file__).resolve().parents[1]
+    / "src/habit_hooks_python/sensors/ruff_sensor.py"
+)
+
+
+def _result(returncode: int) -> subprocess.CompletedProcess[str]:
+    return subprocess.CompletedProcess(args=[], returncode=returncode, stdout="", stderr="")
+
+
+@pytest.mark.parametrize("returncode", [0, 1])
+def test_ruff_s_own_exit_codes_are_trusted(returncode: int) -> None:
+    assert ruff_crashed(_result(returncode)) is False
+
+
+@pytest.mark.parametrize("returncode", [2, 127, -9])
+def test_any_other_exit_code_is_a_crash(returncode: int) -> None:
+    assert ruff_crashed(_result(returncode)) is True
+
+
+def test_a_broken_ruff_toml_fails_the_run(tmp_path: Path) -> None:
+    (tmp_path / "ruff.toml").write_text(
+        "this is not = valid ruff config\n", encoding="utf-8"
+    )
+    (tmp_path / "app.py").write_text("import os\n", encoding="utf-8")
+
+    result = subprocess.run(
+        [sys.executable, str(SENSOR), "app.py"],
+        cwd=tmp_path,
+        capture_output=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+
+    assert result.returncode == 2
+    assert result.stdout.strip() == ""
+    assert "ruff.toml" in result.stderr

{habit_hooks_python-1.3.0 → habit_hooks_python-1.4.0rc1}/tests/test_a_deptry_nobody_installed_is_named.py

@@ -26,7 +26,8 @@ def test_a_deptry_nobody_installed_answers_the_way_a_shell_does(
         [sys.executable, str(SENSOR)],
         cwd=tmp_path,
         capture_output=True,
-        text=True,
+        encoding="utf-8",
+        errors="replace",
         env={"PATH": "/nonexistent"},
     )
 

{habit_hooks_python-1.3.0 → habit_hooks_python-1.4.0rc1}/tests/test_a_project_declaring_no_dependencies_is_clean.py

@@ -25,13 +25,14 @@ SENSOR = (
 
 
 def test_a_project_declaring_no_dependencies_is_a_clean_run(tmp_path: Path) -> None:
-    (tmp_path / "app.py").write_text("import os\n")
+    (tmp_path / "app.py").write_text("import os\n", encoding="utf-8")
 
     result = subprocess.run(
         [sys.executable, str(SENSOR)],
         cwd=tmp_path,
         capture_output=True,
-        text=True,
+        encoding="utf-8",
+        errors="replace",
     )
 
     assert result.returncode == 0
@@ -44,13 +45,14 @@ def test_deptry_still_answers_a_missing_declaration_with_that_error(
 ) -> None:
     """The sensor recognises deptry's exception by name, so a deptry that stops
     raising it must fail here rather than silently retire that branch."""
-    (tmp_path / "app.py").write_text("import os\n")
+    (tmp_path / "app.py").write_text("import os\n", encoding="utf-8")
 
     result = subprocess.run(
         ["deptry", "."],
         cwd=tmp_path,
         capture_output=True,
-        text=True,
+        encoding="utf-8",
+        errors="replace",
     )
 
     assert "DependencySpecificationNotFoundError" in result.stderr
@@ -59,15 +61,17 @@ def test_deptry_still_answers_a_missing_declaration_with_that_error(
 def test_deptry_failing_another_way_still_fails_the_run(tmp_path: Path) -> None:
     (tmp_path / "pyproject.toml").write_text(
         '[project]\nname = "demo"\nversion = "0.0.0"\ndependencies = []\n\n'
-        "[tool.deptry]\nnot_a_real_option = true\n"
+        "[tool.deptry]\nnot_a_real_option = true\n",
+        encoding="utf-8",
     )
-    (tmp_path / "app.py").write_text("import os\n")
+    (tmp_path / "app.py").write_text("import os\n", encoding="utf-8")
 
     result = subprocess.run(
         [sys.executable, str(SENSOR)],
         cwd=tmp_path,
         capture_output=True,
-        text=True,
+        encoding="utf-8",
+        errors="replace",
     )
 
     assert result.returncode == 2

habit_hooks_python-1.4.0rc1/tests/test_a_ruff_nobody_installed_is_named.py

@@ -0,0 +1,35 @@
+"""A detector this plugin does not bring with it must still answer in one line.
+
+``pip install habit-hooks-python`` installs neither ruff nor deptry, so a machine
+that has just enabled the plugin is the ordinary case, not the edge one. ruff is
+spawned from Python now (it used to be a shell recipe, so the shell answered for
+it), and an absent tool is a ``FileNotFoundError`` — twenty lines of internals
+would otherwise become the sensor's diagnosis (#114). Mirrors
+``test_a_deptry_nobody_installed_is_named.py``.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+SENSOR = (
+    Path(__file__).resolve().parents[1]
+    / "src/habit_hooks_python/sensors/ruff_sensor.py"
+)
+
+
+def test_a_ruff_nobody_installed_answers_the_way_a_shell_does(tmp_path: Path) -> None:
+    result = subprocess.run(
+        [sys.executable, str(SENSOR)],
+        cwd=tmp_path,
+        capture_output=True,
+        encoding="utf-8",
+        errors="replace",
+        env={"PATH": "/nonexistent"},
+    )
+
+    assert result.returncode == 2
+    assert result.stdout.strip() == ""
+    assert result.stderr.strip() == "ruff: command not found"

habit_hooks_python-1.4.0rc1/tests/test_the_ruff_pipeline_maps_codes_to_smells.py

@@ -0,0 +1,109 @@
+"""``findings()`` reproduces the old ``ruff | jq`` pipeline exactly: map each
+violation's ``code`` to a smell, group by smell (alphabetically, as jq's
+``group_by`` sorts), and shape each group into the canonical finding.
+
+These exercise the pure mapping logic with synthetic ruff-JSON-shaped entries
+— the same style ``plugins/java/tests/test_class_level_metric_violations_are_dropped.py``
+uses for ``pmd_sensor.findings`` — rather than spawning the real tool, which
+``test_the_ruff_sensor_runs_the_real_tool.py`` does instead.
+"""
+
+from __future__ import annotations
+
+import subprocess
+
+import pytest
+from ruff_sensor import CODE_SMELLS, findings, violations
+
+
+def _entry(code: str, filename: str = "a.py", row: int = 1) -> dict:
+    return {
+        "code": code,
+        "filename": filename,
+        "location": {"row": row, "column": 1},
+        "message": "m",
+    }
+
+
+def test_zero_entries_is_no_findings() -> None:
+    assert findings([]) == []
+
+
+def test_one_entry_becomes_one_finding_with_one_issue() -> None:
+    entry = {
+        "code": "F401",
+        "filename": "a.py",
+        "location": {"row": 3, "column": 8},
+        "message": "`os` unused",
+    }
+
+    assert findings([entry]) == [
+        {
+            "smell": "unused-import",
+            "details": {},
+            "issues": [
+                {
+                    "key": "a.py",
+                    "details": {
+                        "file": "a.py",
+                        "line": 3,
+                        "column": 8,
+                        "message": "`os` unused",
+                        "source": "ruff:F401",
+                    },
+                }
+            ],
+        }
+    ]
+
+
+def test_many_entries_group_by_smell_sorted_alphabetically() -> None:
+    """Insertion order is deliberately the reverse of the alphabetical group
+    order jq's ``group_by`` produces, so a test that merely preserved input
+    order would still pass unless the sort is checked."""
+    unused_variable = _entry("F841", filename="b.py")
+    high_complexity = _entry("C901", filename="a.py")
+
+    result = findings([unused_variable, high_complexity])
+
+    assert [finding["smell"] for finding in result] == [
+        "high-complexity",
+        "unused-variable",
+    ]
+
+
+def test_two_issues_for_the_same_smell_share_one_finding() -> None:
+    first = _entry("F401", filename="a.py", row=1)
+    second = _entry("F401", filename="a.py", row=2)
+
+    result = findings([first, second])
+
+    assert len(result) == 1
+    assert [issue["details"]["line"] for issue in result[0]["issues"]] == [1, 2]
+
+
+@pytest.mark.parametrize("code", sorted(CODE_SMELLS))
+def test_every_mapped_code_reaches_its_own_smell(code: str) -> None:
+    result = findings([_entry(code)])
+
+    assert [finding["smell"] for finding in result] == [CODE_SMELLS[code]]
+    assert result[0]["issues"][0]["details"]["source"] == f"ruff:{code}"
+
+
+def test_a_code_with_no_smell_mapped_is_dropped_not_crashed() -> None:
+    """A code outside the plugin's vocabulary has no guide and no catalogue
+    severity, so it is dropped rather than forwarded under ruff's own name —
+    see "A sensor emits vocabulary smells only" in CLAUDE.md. Indexing a dict
+    with ``.get`` rather than jq's ``{...}[.code]`` is what makes this safe by
+    construction instead of a crash (issue #83)."""
+    mapped = _entry("F401", filename="a.py")
+    unmapped = _entry("PLR9999", filename="b.py")
+
+    assert findings([unmapped]) == []
+    assert [f["smell"] for f in findings([mapped, unmapped])] == ["unused-import"]
+
+
+def test_empty_stdout_is_no_findings() -> None:
+    result = subprocess.CompletedProcess(args=[], returncode=0, stdout="", stderr="")
+
+    assert violations(result) == []

habit_hooks_python-1.4.0rc1/tests/test_the_ruff_sensor_runs_the_real_tool.py

@@ -0,0 +1,65 @@
+"""The helper wired to the real ``ruff``, mirroring
+``test_a_project_declaring_no_dependencies_is_clean.py``'s real-tool style for
+deptry. The pure mapping is covered by
+``test_the_ruff_pipeline_maps_codes_to_smells.py``; this proves ruff's own
+output still has the shape that mapping expects.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+SENSOR = (
+    Path(__file__).resolve().parents[1]
+    / "src/habit_hooks_python/sensors/ruff_sensor.py"
+)
+
+
+def _run(project: Path, *files: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, str(SENSOR), *files],
+        cwd=project,
+        capture_output=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+
+
+def test_a_clean_file_is_a_clean_run(tmp_path: Path) -> None:
+    (tmp_path / "clean.py").write_text("def add(a, b):\n    return a + b\n", encoding="utf-8")
+
+    result = _run(tmp_path, "clean.py")
+
+    assert result.returncode == 0
+    assert result.stderr == ""
+    assert json.loads(result.stdout) == []
+
+
+def test_a_real_violation_comes_out_as_the_mapped_smell(tmp_path: Path) -> None:
+    (tmp_path / "billing.py").write_text(
+        "import os\n\n\ndef charge():\n    unused = 1\n    return 0\n",
+        encoding="utf-8",
+    )
+
+    result = _run(tmp_path, "billing.py")
+
+    assert result.returncode == 0
+    findings = json.loads(result.stdout)
+    assert {finding["smell"] for finding in findings} == {
+        "unused-import",
+        "unused-variable",
+    }
+
+
+def test_ruff_maps_a_syntax_error_to_parse_error(tmp_path: Path) -> None:
+    (tmp_path / "broken.py").write_text("def broken(:\n    return 1\n", encoding="utf-8")
+
+    result = _run(tmp_path, "broken.py")
+
+    assert result.returncode == 0
+    findings = json.loads(result.stdout)
+    assert [finding["smell"] for finding in findings] == ["parse-error"]
+    assert findings[0]["issues"][0]["details"]["source"] == "ruff:invalid-syntax"

habit_hooks_python-1.3.0/PKG-INFO

@@ -1,5 +0,0 @@
-Metadata-Version: 2.5
-Name: habit-hooks-python
-Version: 1.3.0
-Summary: The Python Habit Hooks plugin
-Requires-Python: >=3.11

habit_hooks_python-1.3.0/pyproject.toml

@@ -1,16 +0,0 @@
-[project]
-name = "habit-hooks-python"
-version = "1.3.0"
-description = "The Python Habit Hooks plugin"
-requires-python = ">=3.11"
-dependencies = []
-
-[project.entry-points."habit_hooks.plugins"]
-python = "habit_hooks_python"
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/habit_hooks_python"]

habit_hooks_python-1.3.0/src/habit_hooks_python/sensors/deptry.toml

@@ -1 +0,0 @@
-command = "${python} ${dir}/deptry_sensor.py"

habit_hooks_python-1.3.0/src/habit_hooks_python/sensors/ruff.toml

@@ -1,28 +0,0 @@
-command = """
-set -o pipefail
-ruff check --output-format=json --select=C901,PLR0913,PLR0915,F841,F401,BLE001 ${files} | jq '
-  map(. + {smell: ({
-    "C901": "high-complexity",
-    "PLR0913": "too-many-parameters",
-    "PLR0915": "oversized-function",
-    "F841": "unused-variable",
-    "F401": "unused-import",
-    "BLE001": "swallowed-exception",
-    "invalid-syntax": "parse-error"
-  }[.code])})
-  | group_by(.smell)
-  | map({
-      smell: .[0].smell,
-      details: {},
-      issues: map({
-        key: .filename,
-        details: {
-          file: .filename,
-          line: .location.row,
-          column: .location.column,
-          message: .message,
-          source: ("ruff:" + .code)
-        }
-      })
-    })'
-"""