fix utils.py tests and others

Author: shenxianpeng

MIGRATION.md

@@ -50,7 +50,7 @@ No action required! Your existing configuration will continue to work.
    from cpp_linter_hooks.util import ensure_installed
    path = ensure_installed("clang-format", "18")
    command = [str(path), "--version"]
-   
+
    # After
    from cpp_linter_hooks.util import ensure_installed
    tool_name = ensure_installed("clang-format", "18")

cpp_linter_hooks/clang_format.py

@@ -3,11 +3,11 @@
 from argparse import ArgumentParser
 from typing import Tuple
 
-from .util import ensure_installed, DEFAULT_CLANG_VERSION
+from .util import ensure_installed, DEFAULT_CLANG_FORMAT_VERSION
 
 
 parser = ArgumentParser()
-parser.add_argument("--version", default=DEFAULT_CLANG_VERSION)
+parser.add_argument("--version", default=DEFAULT_CLANG_FORMAT_VERSION)
 parser.add_argument(
     "-v", "--verbose", action="store_true", help="Enable verbose output"
 )

cpp_linter_hooks/clang_tidy.py

@@ -2,11 +2,11 @@
 from argparse import ArgumentParser
 from typing import Tuple
 
-from .util import ensure_installed, DEFAULT_CLANG_VERSION
+from .util import ensure_installed, DEFAULT_CLANG_TIDY_VERSION
 
 
 parser = ArgumentParser()
-parser.add_argument("--version", default=DEFAULT_CLANG_VERSION)
+parser.add_argument("--version", default=DEFAULT_CLANG_TIDY_VERSION)
 
 
 def run_clang_tidy(args=None) -> Tuple[int, str]:

cpp_linter_hooks/util.py

@@ -1,64 +1,200 @@
 import sys
 import shutil
+import toml
+import subprocess
 from pathlib import Path
 import logging
-from typing import Optional
+from typing import Optional, List
+from packaging.version import Version, InvalidVersion
 
 LOG = logging.getLogger(__name__)
 
-DEFAULT_CLANG_VERSION = "20"  # Default version for clang tools, can be overridden
-
-
-def is_installed(tool_name: str, version: str = "") -> Optional[Path]:
-    """Check if tool is installed.
-
-    With wheel packages, the tools are installed as regular Python packages
-    and available via shutil.which().
-    """
-    # Check if tool is available in PATH
-    tool_path = shutil.which(tool_name)
-    if tool_path is not None:
-        return Path(tool_path)
-
-    # Check if tool is available in current Python environment
-    if sys.executable:
-        python_dir = Path(sys.executable).parent
-        tool_path = python_dir / tool_name
-        if tool_path.is_file():
-            return tool_path
-
-        # Also check Scripts directory on Windows
-        scripts_dir = python_dir / "Scripts"
-        if scripts_dir.exists():
-            tool_path = scripts_dir / tool_name
-            if tool_path.is_file():
-                return tool_path
-            # Try with .exe extension on Windows
-            tool_path = scripts_dir / f"{tool_name}.exe"
-            if tool_path.is_file():
-                return tool_path
 
+def get_version_from_dependency(tool: str) -> Optional[str]:
+    pyproject_path = Path(__file__).parent.parent / "pyproject.toml"
+    if not pyproject_path.exists():
+        return None
+    data = toml.load(pyproject_path)
+    dependencies = data.get("project", {}).get("dependencies", [])
+    for dep in dependencies:
+        if dep.startswith(f"{tool}=="):
+            return dep.split("==")[1]
     return None
 
 
-def ensure_installed(tool_name: str, version: str = "") -> str:
-    """
-    Ensure tool is available. With wheel packages, we assume the tools are
-    installed as dependencies and available in PATH.
-
-    Returns the tool name (not path) since the wheel packages install the tools
-    as executables that can be called directly.
-    """
-    LOG.info("Checking for %s", tool_name)
-    path = is_installed(tool_name, version)
-    if path is not None:
-        LOG.info("%s is available at %s", tool_name, path)
-        return tool_name  # Return tool name for direct execution
-
-    # If not found, we'll still return the tool name and let subprocess handle the error
-    LOG.warning(
-        "%s not found in PATH. Make sure the %s wheel package is installed.",
-        tool_name,
-        tool_name,
+DEFAULT_CLANG_FORMAT_VERSION = get_version_from_dependency("clang-format") or "20.1.7"
+DEFAULT_CLANG_TIDY_VERSION = get_version_from_dependency("clang-tidy") or "20.1.0"
+
+
+CLANG_FORMAT_VERSIONS = [
+    "6.0.1",
+    "7.1.0",
+    "8.0.1",
+    "9.0.0",
+    "10.0.1",
+    "10.0.1.1",
+    "11.0.1",
+    "11.0.1.1",
+    "11.0.1.2",
+    "11.1.0",
+    "11.1.0.1",
+    "11.1.0.2",
+    "12.0.1",
+    "12.0.1.1",
+    "12.0.1.2",
+    "13.0.0",
+    "13.0.1",
+    "13.0.1.1",
+    "14.0.0",
+    "14.0.1",
+    "14.0.3",
+    "14.0.4",
+    "14.0.5",
+    "14.0.6",
+    "15.0.4",
+    "15.0.6",
+    "15.0.7",
+    "16.0.0",
+    "16.0.1",
+    "16.0.2",
+    "16.0.3",
+    "16.0.4",
+    "16.0.5",
+    "16.0.6",
+    "17.0.1",
+    "17.0.2",
+    "17.0.3",
+    "17.0.4",
+    "17.0.5",
+    "17.0.6",
+    "18.1.0",
+    "18.1.1",
+    "18.1.2",
+    "18.1.3",
+    "18.1.4",
+    "18.1.5",
+    "18.1.6",
+    "18.1.7",
+    "18.1.8",
+    "19.1.0",
+    "19.1.1",
+    "19.1.2",
+    "19.1.3",
+    "19.1.4",
+    "19.1.5",
+    "19.1.6",
+    "19.1.7",
+    "20.1.0",
+    "20.1.3",
+    "20.1.4",
+    "20.1.5",
+    "20.1.6",
+    "20.1.7",
+]
+
+CLANG_TIDY_VERSIONS = [
+    "13.0.1.1",
+    "14.0.6",
+    "15.0.2",
+    "15.0.2.1",
+    "16.0.4",
+    "17.0.1",
+    "18.1.1",
+    "18.1.8",
+    "19.1.0",
+    "19.1.0.1",
+    "20.1.0",
+]
+
+
+def _resolve_version(versions: List[str], user_input: Optional[str]) -> Optional[str]:
+    if user_input is None:
+        return None
+    try:
+        user_ver = Version(user_input)
+    except InvalidVersion:
+        return None
+
+    candidates = [Version(v) for v in versions]
+    if user_input.count(".") == 0:
+        matches = [v for v in candidates if v.major == user_ver.major]
+    elif user_input.count(".") == 1:
+        matches = [
+            v
+            for v in candidates
+            if f"{v.major}.{v.minor}" == f"{user_ver.major}.{user_ver.minor}"
+        ]
+    else:
+        return str(user_ver) if user_ver in candidates else None
+
+    return str(max(matches)) if matches else None
+
+
+def _get_runtime_version(tool: str) -> Optional[str]:
+    try:
+        output = subprocess.check_output([tool, "--version"], text=True)
+        if tool == "clang-tidy":
+            lines = output.strip().splitlines()
+            if len(lines) > 1:
+                return lines[1].split()[-1]
+        elif tool == "clang-format":
+            return output.strip().split()[-1]
+    except Exception:
+        return None
+
+
+def _install_tool(tool: str, version: str) -> Optional[Path]:
+    try:
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", f"{tool}=={version}"]
+        )
+        return shutil.which(tool)
+    except subprocess.CalledProcessError:
+        LOG.error("Failed to install %s==%s", tool, version)
+        return None
+
+
+def _resolve_install(tool: str, version: Optional[str]) -> Optional[Path]:
+    user_version = _resolve_version(
+        CLANG_FORMAT_VERSIONS if tool == "clang-format" else CLANG_TIDY_VERSIONS,
+        version,
     )
-    return tool_name
+    if user_version is None:
+        user_version = (
+            DEFAULT_CLANG_FORMAT_VERSION
+            if tool == "clang-format"
+            else DEFAULT_CLANG_TIDY_VERSION
+        )
+
+    path = shutil.which(tool)
+    if path:
+        runtime_version = _get_runtime_version(tool)
+        if runtime_version and user_version not in runtime_version:
+            LOG.info(
+                "%s version mismatch (%s != %s), reinstalling...",
+                tool,
+                runtime_version,
+                user_version,
+            )
+            return _install_tool(tool, user_version)
+        return Path(path)
+
+    return _install_tool(tool, user_version)
+
+
+def is_installed(tool: str) -> Optional[Path]:
+    """Check if a tool is installed and return its path."""
+    path = shutil.which(tool)
+    if path:
+        return Path(path)
+    return None
+
+
+def ensure_installed(tool: str, version: Optional[str] = None) -> str:
+    LOG.info("Ensuring %s is installed", tool)
+    tool_path = _resolve_install(tool, version)
+    if tool_path:
+        LOG.info("%s available at %s", tool, tool_path)
+        return tool
+    LOG.warning("%s not found and could not be installed", tool)
+    return tool

pyproject.toml

@@ -34,6 +34,7 @@ classifiers = [
 dependencies = [
     "clang-format==20.1.7",
     "clang-tidy==20.1.0",
+    "toml>=0.10.2",
 ]
 dynamic = ["version"]
 

tests/test_util.py

@@ -1,5 +1,4 @@
 import logging
-import sys
 import pytest
 from itertools import product
 from unittest.mock import patch
@@ -15,24 +14,27 @@
 @pytest.mark.parametrize(("tool", "version"), list(product(TOOLS, VERSIONS)))
 def test_ensure_installed(tool, version, tmp_path, monkeypatch, caplog):
     """Test that ensure_installed returns the tool name for wheel packages."""
-    with monkeypatch.context() as m:
-        m.setattr(sys, "executable", str(tmp_path / "bin" / "python"))
-
+    with monkeypatch.context():
         # Mock shutil.which to simulate the tool being available
         with patch("shutil.which", return_value=str(tmp_path / tool)):
-            caplog.clear()
-            caplog.set_level(logging.INFO, logger="cpp_linter_hooks.util")
+            # Mock _get_runtime_version to return a matching version
+            mock_version = "20.1.7" if tool == "clang-format" else "20.1.0"
+            with patch(
+                "cpp_linter_hooks.util._get_runtime_version", return_value=mock_version
+            ):
+                caplog.clear()
+                caplog.set_level(logging.INFO, logger="cpp_linter_hooks.util")
 
-            if version is None:
-                result = ensure_installed(tool)
-            else:
-                result = ensure_installed(tool, version=version)
+                if version is None:
+                    result = ensure_installed(tool)
+                else:
+                    result = ensure_installed(tool, version=version)
 
-            # Should return the tool name for direct execution
-            assert result == tool
+                # Should return the tool name for direct execution
+                assert result == tool
 
-            # Check that we logged checking for the tool
-            assert any("Checking for" in record.message for record in caplog.records)
+                # Check that we logged ensuring the tool is installed
+                assert any("Ensuring" in record.message for record in caplog.records)
 
 
 def test_is_installed_with_shutil_which(tmp_path):
@@ -59,7 +61,7 @@ def test_ensure_installed_tool_not_found(caplog):
     """Test ensure_installed when tool is not found."""
     with (
         patch("shutil.which", return_value=None),
-        patch("sys.executable", "/nonexistent/python"),
+        patch("cpp_linter_hooks.util._install_tool", return_value=None),
     ):
         caplog.clear()
         caplog.set_level(logging.WARNING, logger="cpp_linter_hooks.util")
@@ -70,4 +72,7 @@ def test_ensure_installed_tool_not_found(caplog):
         assert result == "clang-format"
 
         # Should log a warning
-        assert any("not found in PATH" in record.message for record in caplog.records)
+        assert any(
+            "not found and could not be installed" in record.message
+            for record in caplog.records
+        )