habit-hooks-python 1.3.1__tar.gz → 1.4.0__tar.gz

{habit_hooks_python-1.3.1 → habit_hooks_python-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: habit-hooks-python
-Version: 1.3.1
+Version: 1.4.0
 Summary: The Python Habit Hooks plugin
 Project-URL: Homepage, https://habit-hooks.com
 Project-URL: Repository, https://github.com/habit-hooks/habit-hooks
@@ -48,6 +48,5 @@ Installing a plugin does not switch it on — it has to be named in
 
 - [`ruff`](https://docs.astral.sh/ruff/), [`deptry`](https://github.com/fpgmaas/deptry) —
   `pip install ruff deptry`
-- `jq` — from your system package manager (e.g. `brew install jq`)
 
 Part of [habit-hooks](https://github.com/habit-hooks/habit-hooks).

{habit_hooks_python-1.3.1 → habit_hooks_python-1.4.0}/README.md

@@ -24,6 +24,5 @@ Installing a plugin does not switch it on — it has to be named in
 
 - [`ruff`](https://docs.astral.sh/ruff/), [`deptry`](https://github.com/fpgmaas/deptry) —
   `pip install ruff deptry`
-- `jq` — from your system package manager (e.g. `brew install jq`)
 
 Part of [habit-hooks](https://github.com/habit-hooks/habit-hooks).

{habit_hooks_python-1.3.1 → habit_hooks_python-1.4.0}/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' '${detector:deptry}'
 ```
 
 ## 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' '${detector:ruff}' '${files}'
 ```

{habit_hooks_python-1.3.1 → habit_hooks_python-1.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "habit-hooks-python"
-version = "1.3.1"
+version = "1.4.0"
 description = "The Python Habit Hooks plugin"
 readme = "README.md"
 license = "MIT"

{habit_hooks_python-1.3.1 → habit_hooks_python-1.4.0}/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.0/src/habit_hooks_python/sensors/deptry.toml

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

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

@@ -14,23 +14,22 @@ import tempfile
 from pathlib import Path
 
 
-def run_deptry(report: Path) -> subprocess.CompletedProcess[str]:
-    """What deptry said, or what a shell says about a deptry nobody installed.
-
-    ``pip install habit-hooks-python`` brings neither detector 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 deptry, so it answers the way the shell would have, and that phrase is
-    what the run recognises to name the missing tool.
+def run_deptry(deptry: str, report: Path) -> subprocess.CompletedProcess[str]:
+    """What deptry said, spawned as the file this sensor was handed for it.
+
+    ``sensors/deptry.toml`` names ``${detector:deptry}``, so the run resolves
+    deptry to a file before this helper starts and passes it as the first
+    argument — a console script the project's own venv installed, which
+    habit-hooks' venv may not hold at all and Windows spells ``deptry.exe``. A
+    deptry nobody installed never reaches here: the run answers for it as the
+    missing command it is, in one line rather than a traceback (#114).
     """
-    command = ["deptry", ".", "--json-output", str(report)]
-    try:
-        return subprocess.run(command, capture_output=True, text=True)
-    except FileNotFoundError:
-        return subprocess.CompletedProcess(
-            command, 127, "", "deptry: command not found\n"
-        )
+    return subprocess.run(
+        [deptry, ".", "--json-output", str(report)],
+        capture_output=True,
+        encoding="utf-8",
+        errors="replace",
+    )
 
 
 def deptry_crashed(result: subprocess.CompletedProcess[str], report: Path) -> bool:
@@ -52,7 +51,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"]
 
 
@@ -81,9 +80,10 @@ def findings(entries: list[dict]) -> list[dict]:
 
 
 def main() -> int:
+    deptry = sys.argv[1]
     with tempfile.TemporaryDirectory() as tmp:
         report = Path(tmp) / "deptry-report.json"
-        result = run_deptry(report)
+        result = run_deptry(deptry, report)
         if deptry_crashed(result, report):
             if deptry_found_no_declaration(result):
                 print(json.dumps([]))

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

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

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

@@ -0,0 +1,114 @@
+"""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
+
+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(ruff: str, files: list[str]) -> subprocess.CompletedProcess[str]:
+    """What ruff said, spawned as the file this sensor was handed for it.
+
+    ``sensors/ruff.toml`` names ``${detector:ruff}``, so the run resolves ruff
+    to a file before this helper starts and passes it as the first argument —
+    the ``ruff.exe`` a bare ``["ruff", ...]`` spawn misses on Windows. A ruff
+    nobody installed never reaches here at all: the run answers for it as the
+    missing command it is, in one line rather than a traceback (#114).
+    """
+    return subprocess.run(
+        [ruff, "check", "--output-format=json", f"--select={SELECTED_CODES}", *files],
+        capture_output=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+
+
+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:
+    ruff = sys.argv[1]
+    files = sys.argv[2:]
+    result = run_ruff(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.0/tests/conftest.py

@@ -0,0 +1,56 @@
+"""What every test here needs of the run it stands in for.
+
+**A helper loads as a loose script.** The sensor specs spell
+``${python} ${dir}/<helper>.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).
+
+**A helper is handed its tool as a file.** The specs name theirs with
+``${detector:<tool>}``, which the run resolves against the project's own bins
+before the helper is spawned (``project_paths.tool_executable``). A test
+spawning a helper directly stands in for the run, so it asks that same question
+and hands over a real file rather than a name. Absent is a failure rather than a
+skip: ``uv sync`` brings both, so a machine without one is a suite that has
+quietly stopped gating.
+"""
+
+from __future__ import annotations
+
+import shutil
+import sys
+from pathlib import Path
+
+import pytest
+
+SENSORS = (
+    Path(__file__).resolve().parents[1] / "src" / "habit_hooks_python" / "sensors"
+)
+
+sys.path.insert(0, str(SENSORS))
+
+
+@pytest.fixture(scope="session")
+def ruff() -> str:
+    """The file this machine runs ruff by, as the sensor's first argument."""
+    return _installed("ruff")
+
+
+@pytest.fixture(scope="session")
+def deptry() -> str:
+    """The file this machine runs deptry by, as the sensor's first argument."""
+    return _installed("deptry")
+
+
+def _installed(tool: str) -> str:
+    """The file this machine runs ``tool`` by.
+
+    ``shutil.which`` rather than the name on disk: a console script is
+    ``<tool>.exe`` in a Windows venv, which a lookup finds and a spawn handed
+    the bare name cannot reach.
+    """
+    found = shutil.which(tool)
+    if found is None:
+        pytest.fail(f"{tool} is not on PATH — run 'uv sync'")
+    return found

habit_hooks_python-1.4.0/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, ruff: str) -> 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), ruff, "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.1 → habit_hooks_python-1.4.0}/tests/test_a_project_declaring_no_dependencies_is_clean.py

@@ -24,14 +24,17 @@ 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")
+def test_a_project_declaring_no_dependencies_is_a_clean_run(
+    tmp_path: Path, deptry: str
+) -> None:
+    (tmp_path / "app.py").write_text("import os\n", encoding="utf-8")
 
     result = subprocess.run(
-        [sys.executable, str(SENSOR)],
+        [sys.executable, str(SENSOR), deptry],
         cwd=tmp_path,
         capture_output=True,
-        text=True,
+        encoding="utf-8",
+        errors="replace",
     )
 
     assert result.returncode == 0
@@ -40,34 +43,39 @@ def test_a_project_declaring_no_dependencies_is_a_clean_run(tmp_path: Path) -> N
 
 
 def test_deptry_still_answers_a_missing_declaration_with_that_error(
-    tmp_path: Path,
+    tmp_path: Path, deptry: str
 ) -> 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", "."],
+        [deptry, "."],
         cwd=tmp_path,
         capture_output=True,
-        text=True,
+        encoding="utf-8",
+        errors="replace",
     )
 
     assert "DependencySpecificationNotFoundError" in result.stderr
 
 
-def test_deptry_failing_another_way_still_fails_the_run(tmp_path: Path) -> None:
+def test_deptry_failing_another_way_still_fails_the_run(
+    tmp_path: Path, deptry: str
+) -> 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)],
+        [sys.executable, str(SENSOR), deptry],
         cwd=tmp_path,
         capture_output=True,
-        text=True,
+        encoding="utf-8",
+        errors="replace",
     )
 
     assert result.returncode == 2

habit_hooks_python-1.4.0/tests/test_a_sensor_spawns_the_tool_it_was_handed.py

@@ -0,0 +1,78 @@
+"""A sensor spawns the tool it was handed, never a name it looks up again.
+
+``sensors/ruff.toml`` and ``sensors/deptry.toml`` each name their tool with
+``${detector:<name>}``, so the run resolves it to a file and passes that file as
+the helper's first argument. Handing over the file is the whole point: a bare
+name is looked up again by whatever spawns it, and Windows' own lookup adds
+``.exe`` and nothing else — where a project's venv holds ``deptry.exe`` and npm
+installs a Node tool as a ``.cmd`` shim.
+
+A ``PATH`` that cannot answer the tool's own name is what proves the helper
+takes it: a helper still spelling that name would find nothing to spawn, while
+one handed the file runs a tool no search path leads to.
+
+A tool nobody installed is no longer this plugin's to answer for. The run
+resolves the name before the helper is spawned and answers for an absent one
+itself, as the ordinary missing command it is
+(``tests/test_a_tool_a_part_cannot_run.py``).
+"""
+
+from __future__ import annotations
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+from tool_lookup import where_the_bare_name_reaches_nothing
+
+SENSORS = (
+    Path(__file__).resolve().parents[1] / "src" / "habit_hooks_python" / "sensors"
+)
+
+
+def _run(
+    helper: str, tool: str, project: Path, *arguments: str
+) -> subprocess.CompletedProcess[str]:
+    """The helper's own run, where nothing answers the tool's bare name."""
+    return subprocess.run(
+        [sys.executable, str(SENSORS / helper), *arguments],
+        cwd=project,
+        capture_output=True,
+        encoding="utf-8",
+        errors="replace",
+        env=where_the_bare_name_reaches_nothing(tool),
+    )
+
+
+def test_the_ruff_sensor_spawns_the_ruff_it_was_handed(
+    tmp_path: Path, ruff: str
+) -> None:
+    (tmp_path / "billing.py").write_text("import os\n", encoding="utf-8")
+
+    result = _run("ruff_sensor.py", "ruff", tmp_path, ruff, "billing.py")
+
+    assert result.returncode == 0
+    assert result.stderr == ""
+    assert [finding["smell"] for finding in json.loads(result.stdout)] == [
+        "unused-import"
+    ]
+
+
+def test_the_deptry_sensor_spawns_the_deptry_it_was_handed(
+    tmp_path: Path, deptry: str
+) -> None:
+    (tmp_path / "pyproject.toml").write_text(
+        '[project]\nname = "demo"\nversion = "0.0.0"\ndependencies = ["rich"]\n',
+        encoding="utf-8",
+    )
+    (tmp_path / "app.py").write_text(
+        "def fetch(url):\n    return url\n", encoding="utf-8"
+    )
+
+    result = _run("deptry_sensor.py", "deptry", tmp_path, deptry)
+
+    assert result.returncode == 0
+    assert result.stderr == ""
+    assert [finding["smell"] for finding in json.loads(result.stdout)] == [
+        "unused-dependency"
+    ]

habit_hooks_python-1.4.0/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.0/tests/test_the_ruff_sensor_runs_the_real_tool.py

@@ -0,0 +1,67 @@
+"""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, ruff: str, *files: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, str(SENSOR), ruff, *files],
+        cwd=project,
+        capture_output=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+
+
+def test_a_clean_file_is_a_clean_run(tmp_path: Path, ruff: str) -> None:
+    (tmp_path / "clean.py").write_text("def add(a, b):\n    return a + b\n", encoding="utf-8")
+
+    result = _run(tmp_path, ruff, "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, ruff: str
+) -> 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, ruff, "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, ruff: str) -> None:
+    (tmp_path / "broken.py").write_text("def broken(:\n    return 1\n", encoding="utf-8")
+
+    result = _run(tmp_path, ruff, "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.1/src/habit_hooks_python/sensors/deptry.toml

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

habit_hooks_python-1.3.1/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)
-        }
-      })
-    })'
-"""

habit_hooks_python-1.3.1/tests/test_a_deptry_nobody_installed_is_named.py

@@ -1,35 +0,0 @@
-"""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. The ruff
-sensor is a shell command, so the shell answers for it; deptry is spawned from
-Python, where an absent tool is a ``FileNotFoundError`` and twenty lines of
-internals would otherwise become the sensor's diagnosis (#114).
-"""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from pathlib import Path
-
-SENSOR = (
-    Path(__file__).resolve().parents[1]
-    / "src/habit_hooks_python/sensors/deptry_sensor.py"
-)
-
-
-def test_a_deptry_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,
-        text=True,
-        env={"PATH": "/nonexistent"},
-    )
-
-    assert result.returncode != 0
-    assert result.stdout.strip() == ""
-    assert result.stderr.strip() == "deptry: command not found"