hatch-cpp 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

hatch_cpp/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.5"
+__version__ = "0.3.7"
 
 from .config import *
 from .hooks import *

hatch_cpp/config.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from os import system as system_call
+from os import environ, system as system_call
 from pathlib import Path
 from typing import List, Optional
 
@@ -63,12 +63,27 @@ class HatchCppBuildPlan(HatchCppBuildConfig):
     def generate(self):
         self.commands = []
 
+        # Check for env var overrides
+        vcpkg_override = environ.get("HATCH_CPP_VCPKG")
+        cmake_override = environ.get("HATCH_CPP_CMAKE")
+
         # Evaluate toolchains
-        if self.vcpkg and Path(self.vcpkg.vcpkg).exists():
+        if vcpkg_override == "1":
+            if self.vcpkg:
+                self._active_toolchains.append("vcpkg")
+            else:
+                log.warning("HATCH_CPP_VCPKG=1 set but no vcpkg configuration found; ignoring.")
+        elif vcpkg_override != "0" and self.vcpkg and Path(self.vcpkg.vcpkg).exists():
             self._active_toolchains.append("vcpkg")
+
         if self.libraries:
             self._active_toolchains.append("vanilla")
-        elif self.cmake:
+        elif cmake_override == "1":
+            if self.cmake:
+                self._active_toolchains.append("cmake")
+            else:
+                log.warning("HATCH_CPP_CMAKE=1 set but no cmake configuration found; ignoring.")
+        elif cmake_override != "0" and self.cmake:
             self._active_toolchains.append("cmake")
 
         # Collect toolchain commands

hatch_cpp/tests/test_platform_specific.py

@@ -345,7 +345,7 @@ class TestPlatformFlagsIntegration:
 
         flags = platform.get_link_flags(library)
         assert "-shared" in flags
-        assert "-Wl,-rpath,$ORIGIN/lib" in flags
+        assert r"-Wl,-rpath,\$ORIGIN/lib" in flags
 
     def test_darwin_platform_uses_darwin_specific_fields(self):
         """Test that darwin platform uses darwin-specific fields."""

hatch_cpp/tests/test_structs.py

@@ -1,11 +1,14 @@
+from os import environ
 from pathlib import Path
 from sys import version_info
+from unittest.mock import patch
 
 import pytest
 from pydantic import ValidationError
 from toml import loads
 
 from hatch_cpp import HatchCppBuildConfig, HatchCppBuildPlan, HatchCppLibrary, HatchCppPlatform
+from hatch_cpp.toolchains.common import _normalize_rpath
 
 
 class TestStructs:
@@ -54,3 +57,184 @@ class TestStructs:
         assert "clang" in hatch_build_config.platform.cc
         assert "clang++" in hatch_build_config.platform.cxx
         assert hatch_build_config.platform.toolchain == "gcc"
+
+    def test_cmake_args_env_variable(self):
+        """Test that CMAKE_ARGS environment variable is respected."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        with patch.dict(environ, {"CMAKE_ARGS": "-DFOO=bar -DBAZ=qux"}):
+            hatch_build_plan.generate()
+            assert "-DFOO=bar" in hatch_build_plan.commands[0]
+            assert "-DBAZ=qux" in hatch_build_plan.commands[0]
+
+    def test_cmake_args_env_variable_empty(self):
+        """Test that an empty CMAKE_ARGS does not add extra whitespace."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        with patch.dict(environ, {"CMAKE_ARGS": ""}):
+            hatch_build_plan.generate()
+            # Should not have trailing whitespace from empty CMAKE_ARGS
+            assert not hatch_build_plan.commands[0].endswith(" ")
+
+    def test_cmake_generator_env_variable(self):
+        """Test that CMAKE_GENERATOR environment variable is respected on non-Windows platforms."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        with patch.dict(environ, {"CMAKE_GENERATOR": "Ninja"}):
+            hatch_build_plan.generate()
+            assert '-G "Ninja"' in hatch_build_plan.commands[0]
+
+    def test_cmake_generator_env_variable_unset(self):
+        """Test that no -G flag is added on non-Windows when CMAKE_GENERATOR is not set."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        with patch.dict(environ, {}, clear=False):
+            # Remove CMAKE_GENERATOR if present
+            environ.pop("CMAKE_GENERATOR", None)
+            hatch_build_plan.generate()
+            if hatch_build_plan.platform.platform != "win32":
+                assert "-G " not in hatch_build_plan.commands[0]
+
+    def test_hatch_cpp_cmake_env_force_off(self):
+        """Test that HATCH_CPP_CMAKE=0 disables cmake even when cmake config is present."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        assert hatch_build_plan.cmake is not None
+        with patch.dict(environ, {"HATCH_CPP_CMAKE": "0"}):
+            hatch_build_plan.generate()
+            # cmake should not be active, so no cmake commands generated
+            assert len(hatch_build_plan.commands) == 0
+            assert "cmake" not in hatch_build_plan._active_toolchains
+
+    def test_hatch_cpp_cmake_env_force_on(self):
+        """Test that HATCH_CPP_CMAKE=1 enables cmake when cmake config is present."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        assert hatch_build_plan.cmake is not None
+        with patch.dict(environ, {"HATCH_CPP_CMAKE": "1"}):
+            hatch_build_plan.generate()
+            assert "cmake" in hatch_build_plan._active_toolchains
+
+    def test_hatch_cpp_cmake_env_force_on_no_config(self):
+        """Test that HATCH_CPP_CMAKE=1 warns and skips when no cmake config exists."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        config_data = toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"].copy()
+        config_data.pop("cmake", None)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **config_data)
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        assert hatch_build_plan.cmake is None
+        with patch.dict(environ, {"HATCH_CPP_CMAKE": "1"}):
+            hatch_build_plan.generate()
+            # cmake should NOT be activated when there's no config
+            assert "cmake" not in hatch_build_plan._active_toolchains
+
+    def test_hatch_cpp_vcpkg_env_force_off(self):
+        """Test that HATCH_CPP_VCPKG=0 disables vcpkg even when vcpkg.json exists."""
+        txt = (Path(__file__).parent / "test_project_cmake_vcpkg" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        with patch.dict(environ, {"HATCH_CPP_VCPKG": "0"}):
+            hatch_build_plan.generate()
+            assert "vcpkg" not in hatch_build_plan._active_toolchains
+
+    def test_hatch_cpp_vcpkg_env_force_on(self):
+        """Test that HATCH_CPP_VCPKG=1 enables vcpkg even when vcpkg.json doesn't exist."""
+        txt = (Path(__file__).parent / "test_project_cmake" / "pyproject.toml").read_text()
+        toml_data = loads(txt)
+        hatch_build_config = HatchCppBuildConfig(name=toml_data["project"]["name"], **toml_data["tool"]["hatch"]["build"]["hooks"]["hatch-cpp"])
+        hatch_build_plan = HatchCppBuildPlan(**hatch_build_config.model_dump())
+
+        with patch.dict(environ, {"HATCH_CPP_VCPKG": "1"}):
+            hatch_build_plan.generate()
+            assert "vcpkg" in hatch_build_plan._active_toolchains
+
+
+class TestNormalizeRpath:
+    def test_origin_to_loader_path_on_darwin(self):
+        """$ORIGIN should be translated to @loader_path on macOS."""
+        assert _normalize_rpath("-Wl,-rpath,$ORIGIN", "darwin") == "-Wl,-rpath,@loader_path"
+
+    def test_loader_path_to_origin_on_linux(self):
+        """@loader_path should be translated to (escaped) $ORIGIN on Linux."""
+        result = _normalize_rpath("-Wl,-rpath,@loader_path", "linux")
+        assert result == r"-Wl,-rpath,\$ORIGIN"
+
+    def test_origin_escaped_on_linux(self):
+        """$ORIGIN should be escaped as \\$ORIGIN on Linux for shell safety."""
+        result = _normalize_rpath("-Wl,-rpath,$ORIGIN", "linux")
+        assert result == r"-Wl,-rpath,\$ORIGIN"
+
+    def test_already_escaped_origin_on_darwin(self):
+        """Already-escaped \\$ORIGIN should still translate to @loader_path on macOS."""
+        assert _normalize_rpath(r"-Wl,-rpath,\$ORIGIN", "darwin") == "-Wl,-rpath,@loader_path"
+
+    def test_no_rpath_unchanged(self):
+        """Args without rpath values should pass through unchanged."""
+        assert _normalize_rpath("-lfoo", "linux") == "-lfoo"
+        assert _normalize_rpath("-lfoo", "darwin") == "-lfoo"
+
+    def test_win32_no_transform(self):
+        """Windows should not transform rpath values."""
+        assert _normalize_rpath("$ORIGIN", "win32") == "$ORIGIN"
+        assert _normalize_rpath("@loader_path", "win32") == "@loader_path"
+
+    def test_link_flags_rpath_translation_darwin(self):
+        """Full integration: extra_link_args with $ORIGIN produce @loader_path on macOS."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            binding="generic",
+            extra_link_args=["-Wl,-rpath,$ORIGIN"],
+        )
+        platform = HatchCppPlatform(
+            cc="clang",
+            cxx="clang++",
+            ld="ld",
+            platform="darwin",
+            toolchain="clang",
+            disable_ccache=True,
+        )
+        flags = platform.get_link_flags(library)
+        assert "@loader_path" in flags
+        assert "$ORIGIN" not in flags
+
+    def test_link_flags_rpath_escaped_linux(self):
+        """Full integration: extra_link_args with $ORIGIN are shell-escaped on Linux."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            binding="generic",
+            extra_link_args=["-Wl,-rpath,$ORIGIN"],
+        )
+        platform = HatchCppPlatform(
+            cc="gcc",
+            cxx="g++",
+            ld="ld",
+            platform="linux",
+            toolchain="gcc",
+            disable_ccache=True,
+        )
+        flags = platform.get_link_flags(library)
+        assert r"\$ORIGIN" in flags

hatch_cpp/tests/test_vcpkg_ref.py

@@ -156,14 +156,66 @@ class TestVcpkgGenerate:
     def test_generate_skips_clone_when_vcpkg_root_exists(self, tmp_path, monkeypatch):
         monkeypatch.chdir(tmp_path)
         self._make_vcpkg_env(tmp_path)
-        (tmp_path / "vcpkg").mkdir()
+        vcpkg_root = tmp_path / "vcpkg"
+        vcpkg_root.mkdir()
+        # Existing bootstrap script and executable mean no clone/bootstrap is needed.
+        (vcpkg_root / "bootstrap-vcpkg.sh").write_text("#!/bin/sh\nexit 0\n")
+        (vcpkg_root / "vcpkg").write_text("#!/bin/sh\nexit 0\n")
 
         cfg = HatchCppVcpkgConfiguration(vcpkg_ref="2024.01.12")
+        monkeypatch.setattr(cfg, "_is_vcpkg_working", lambda: True)
         commands = cfg.generate(None)
 
-        # When vcpkg_root already exists, no clone or checkout happens
+        # When vcpkg_root already exists with a working executable, no clone or bootstrap happens.
         assert not any("git clone" in cmd for cmd in commands)
         assert not any("checkout" in cmd for cmd in commands)
+        assert not any("bootstrap-vcpkg" in cmd for cmd in commands)
+        assert any("vcpkg" in cmd and "install" in cmd for cmd in commands)
+
+    def test_generate_reclones_when_vcpkg_root_exists_but_empty(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        self._make_vcpkg_env(tmp_path)
+        (tmp_path / "vcpkg").mkdir()
+
+        cfg = HatchCppVcpkgConfiguration(vcpkg_ref="2024.01.12")
+        commands = cfg.generate(None)
+
+        assert any(cmd.startswith('rm -rf "vcpkg"') for cmd in commands)
+        assert any("git clone" in cmd for cmd in commands)
+        assert any("checkout 2024.01.12" in cmd for cmd in commands)
+        assert any("bootstrap-vcpkg" in cmd for cmd in commands)
+        assert any("vcpkg" in cmd and "install" in cmd for cmd in commands)
+
+    def test_generate_bootstraps_when_vcpkg_executable_missing(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        self._make_vcpkg_env(tmp_path)
+        vcpkg_root = tmp_path / "vcpkg"
+        vcpkg_root.mkdir()
+        (vcpkg_root / "bootstrap-vcpkg.sh").write_text("#!/bin/sh\nexit 0\n")
+
+        cfg = HatchCppVcpkgConfiguration(vcpkg_ref="2024.01.12")
+        commands = cfg.generate(None)
+
+        assert not any("git clone" in cmd for cmd in commands)
+        assert any("bootstrap-vcpkg" in cmd for cmd in commands)
+        assert any("vcpkg" in cmd and "install" in cmd for cmd in commands)
+
+    def test_generate_reclones_when_vcpkg_exists_but_not_working(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        self._make_vcpkg_env(tmp_path)
+        vcpkg_root = tmp_path / "vcpkg"
+        vcpkg_root.mkdir()
+        (vcpkg_root / "bootstrap-vcpkg.sh").write_text("#!/bin/sh\nexit 0\n")
+        (vcpkg_root / "vcpkg").write_text("#!/bin/sh\nexit 1\n")
+
+        cfg = HatchCppVcpkgConfiguration(vcpkg_ref="2024.01.12")
+        monkeypatch.setattr(cfg, "_is_vcpkg_working", lambda: False)
+        commands = cfg.generate(None)
+
+        assert any(cmd.startswith('rm -rf "vcpkg"') for cmd in commands)
+        assert any("git clone" in cmd for cmd in commands)
+        assert any("checkout 2024.01.12" in cmd for cmd in commands)
+        assert any("bootstrap-vcpkg" in cmd for cmd in commands)
         assert any("vcpkg" in cmd and "install" in cmd for cmd in commands)
 
     def test_generate_no_vcpkg_json(self, tmp_path, monkeypatch):

hatch_cpp/toolchains/cmake.py

@@ -54,9 +54,14 @@ class HatchCppCmakeConfiguration(BaseModel):
             commands[-1] += f" -DCMAKE_INSTALL_PREFIX={Path(self.root).parent}"
 
         # TODO: CMAKE_CXX_COMPILER
+        # Respect CMAKE_GENERATOR environment variable
+        cmake_generator = environ.get("CMAKE_GENERATOR", "")
         if config.platform.platform == "win32":
-            # TODO: prefix?
-            commands[-1] += f' -G "{environ.get("CMAKE_GENERATOR", "Visual Studio 17 2022")}"'
+            if not cmake_generator:
+                cmake_generator = "Visual Studio 17 2022"
+            commands[-1] += f' -G "{cmake_generator}"'
+        elif cmake_generator:
+            commands[-1] += f' -G "{cmake_generator}"'
 
         # Put in CMake flags
         args = self.cmake_args.copy()
@@ -78,6 +83,11 @@ class HatchCppCmakeConfiguration(BaseModel):
         if config.platform.platform == "darwin":
             commands[-1] += f" -DCMAKE_OSX_DEPLOYMENT_TARGET={environ.get('OSX_DEPLOYMENT_TARGET', '11')}"
 
+        # Respect CMAKE_ARGS environment variable
+        cmake_args_env = environ.get("CMAKE_ARGS", "").strip()
+        if cmake_args_env:
+            commands[-1] += " " + cmake_args_env
+
         # Append build command
         commands.append(f"cmake --build {self.build} --config {config.build_type}")
 

hatch_cpp/toolchains/common.py

@@ -20,6 +20,7 @@ __all__ = (
     "PlatformDefaults",
     "HatchCppLibrary",
     "HatchCppPlatform",
+    "_normalize_rpath",
 )
 
 
@@ -207,6 +208,28 @@ class HatchCppLibrary(BaseModel, validate_assignment=True):
         return macros
 
 
+def _normalize_rpath(value: str, platform: Platform) -> str:
+    r"""Translate and escape rpath values for the target platform.
+
+    - On macOS (darwin): ``$ORIGIN`` is replaced with ``@loader_path``.
+    - On Linux: ``@loader_path`` is replaced with ``$ORIGIN``, and
+      ``$ORIGIN`` is escaped as ``\$ORIGIN`` so that ``os.system()``
+      (which invokes a shell) passes it through literally.
+    - On Windows: no transformation is applied (Windows does not use
+      rpath).
+    """
+    if platform == "darwin":
+        # Handle already-escaped \$ORIGIN first, then plain $ORIGIN
+        value = value.replace(r"\$ORIGIN", "@loader_path")
+        value = value.replace("$ORIGIN", "@loader_path")
+    elif platform == "linux":
+        # Translate macOS rpath to Linux equivalent
+        value = value.replace("@loader_path", "$ORIGIN")
+        # Escape $ORIGIN for shell safety (os.system runs through bash)
+        value = value.replace("$ORIGIN", r"\$ORIGIN")
+    return value
+
+
 class HatchCppPlatform(BaseModel):
     cc: str
     cxx: str
@@ -338,6 +361,9 @@ class HatchCppPlatform(BaseModel):
         effective_libraries = library.get_effective_libraries(self.platform)
         effective_library_dirs = library.get_effective_library_dirs(self.platform)
 
+        # Normalize rpath values ($ORIGIN <-> @loader_path) and escape for shell
+        effective_link_args = [_normalize_rpath(arg, self.platform) for arg in effective_link_args]
+
         if self.toolchain == "gcc":
             flags += " -shared"
             flags += " " + " ".join(effective_link_args)

hatch_cpp/toolchains/vcpkg.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import configparser
+import subprocess
 from pathlib import Path
 from platform import machine as platform_machine
 from sys import platform as sys_platform
@@ -78,6 +79,39 @@ class HatchCppVcpkgConfiguration(BaseModel):
             return self.vcpkg_ref
         return _read_vcpkg_ref_from_gitmodules(self.vcpkg_root)
 
+    def _bootstrap_script_path(self) -> Path:
+        return self.vcpkg_root / ("bootstrap-vcpkg.bat" if sys_platform == "win32" else "bootstrap-vcpkg.sh")
+
+    def _vcpkg_executable_path(self) -> Path:
+        if sys_platform == "win32":
+            return self.vcpkg_root / "vcpkg.exe"
+        return self.vcpkg_root / "vcpkg"
+
+    def _delete_dir_command(self, path: Path) -> str:
+        if sys_platform == "win32":
+            return f'rmdir /s /q "{path}"'
+        return f'rm -rf "{path}"'
+
+    def _is_vcpkg_working(self) -> bool:
+        vcpkg_executable = self._vcpkg_executable_path()
+        if not vcpkg_executable.exists():
+            return False
+        try:
+            result = subprocess.run([str(vcpkg_executable), "version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False)
+            return result.returncode == 0
+        except OSError:
+            return False
+
+    def _clone_checkout_bootstrap_commands(self) -> list[str]:
+        commands = [f"git clone {self.vcpkg_repo} {self.vcpkg_root}"]
+
+        ref = self._resolve_vcpkg_ref()
+        if ref is not None:
+            commands.append(f"git -C {self.vcpkg_root} checkout {ref}")
+
+        commands.append(f"./{self._bootstrap_script_path()}")
+        return commands
+
     def generate(self, config):
         commands = []
 
@@ -87,14 +121,24 @@ class HatchCppVcpkgConfiguration(BaseModel):
                 raise ValueError(f"Could not determine vcpkg triplet for platform {sys_platform} and architecture {platform_machine()}")
 
         if self.vcpkg and Path(self.vcpkg).exists():
-            if not Path(self.vcpkg_root).exists():
-                commands.append(f"git clone {self.vcpkg_repo} {self.vcpkg_root}")
-
-                ref = self._resolve_vcpkg_ref()
-                if ref is not None:
-                    commands.append(f"git -C {self.vcpkg_root} checkout {ref}")
+            vcpkg_root = Path(self.vcpkg_root)
+            bootstrap_script = self._bootstrap_script_path()
+
+            if not vcpkg_root.exists():
+                commands.extend(self._clone_checkout_bootstrap_commands())
+            else:
+                is_empty_dir = vcpkg_root.is_dir() and not any(vcpkg_root.iterdir())
+                if is_empty_dir:
+                    commands.append(self._delete_dir_command(vcpkg_root))
+                    commands.extend(self._clone_checkout_bootstrap_commands())
+                else:
+                    vcpkg_executable = self._vcpkg_executable_path()
+                    if not vcpkg_executable.exists():
+                        commands.append(f"./{bootstrap_script}")
+                    elif not self._is_vcpkg_working():
+                        commands.append(self._delete_dir_command(vcpkg_root))
+                        commands.extend(self._clone_checkout_bootstrap_commands())
 
-                commands.append(f"./{self.vcpkg_root / 'bootstrap-vcpkg.sh' if sys_platform != 'win32' else self.vcpkg_root / 'bootstrap-vcpkg.bat'}")
             commands.append(f"./{self.vcpkg_root / 'vcpkg'} install --triplet {self.vcpkg_triplet}")
 
         return commands

{hatch_cpp-0.3.5.dist-info → hatch_cpp-0.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hatch-cpp
-Version: 0.3.5
+Version: 0.3.7
 Summary: Hatch plugin for C++ builds
 Project-URL: Repository, https://github.com/python-project-templates/hatch-cpp
 Project-URL: Homepage, https://github.com/python-project-templates/hatch-cpp
@@ -33,7 +33,7 @@ Requires-Dist: hatch-build>=0.3.2; extra == 'develop'
 Requires-Dist: hatchling; extra == 'develop'
 Requires-Dist: mdformat; extra == 'develop'
 Requires-Dist: mdformat-tables>=1; extra == 'develop'
-Requires-Dist: nanobind<2.12.0; extra == 'develop'
+Requires-Dist: nanobind<2.13.0; extra == 'develop'
 Requires-Dist: pybind11; extra == 'develop'
 Requires-Dist: pytest; extra == 'develop'
 Requires-Dist: pytest-cov; extra == 'develop'

{hatch_cpp-0.3.5.dist-info → hatch_cpp-0.3.7.dist-info}/RECORD

@@ -1,13 +1,13 @@
-hatch_cpp/__init__.py,sha256=oGC85OzqpNweL1rFPBDebJVlVz3i-HmX54zLu5_A8gU,114
-hatch_cpp/config.py,sha256=6oO8J2k91r88DwZwDJpxtxt2F5xZZ-N65IqSyabwOg4,3831
+hatch_cpp/__init__.py,sha256=GipF1UFyt6YVB3duYASeWgalyTJ30FHcGUrwBQRmGKc,114
+hatch_cpp/config.py,sha256=aRmcRyrPR7LsEOBjrF9pkOM3ldiykuYRmD73CB3k9MY,4512
 hatch_cpp/hooks.py,sha256=SQkF5WJIgzw-8rvlTzuQvBqdP6K3fHgnh6CZOZFag50,203
 hatch_cpp/plugin.py,sha256=NcIDi7c9KH-_RkPeeCgWKoH5InIjw2eECswazwvGl_c,4304
 hatch_cpp/utils.py,sha256=lxd3U3aMYsTS6DYMc1y17MR16LzgRzv92f_xh87LSg8,297
 hatch_cpp/tests/test_hatch_build.py,sha256=q2IKTFi3Pq99UsOyL84V-C9VtFUs3ZcA9UlA8lpRW54,1553
-hatch_cpp/tests/test_platform_specific.py,sha256=8EFHEv86e0CD1bIruHgLb28yf2pSRF1VgvcX2tK5bRo,20124
+hatch_cpp/tests/test_platform_specific.py,sha256=SRKAojh6PkwKZnEj8SjvfFa_Dy8NSKw4R82ol8O1TZs,20126
 hatch_cpp/tests/test_projects.py,sha256=vs-kHdiHM7pCqM3oGQsSryq5blRi0HyK5QFfHxlJDi8,1773
-hatch_cpp/tests/test_structs.py,sha256=cpzbPLneEbEONzXmPS1S9PL9mbhya4udc4eqTpU9w6w,2576
-hatch_cpp/tests/test_vcpkg_ref.py,sha256=OEb4u3Ny-OYNYLanjGaG7-dL4WW48EYdbsxeDN0sqwM,7371
+hatch_cpp/tests/test_structs.py,sha256=zmNtAV1bojvJM6gatjDtvqrAeUpKzpfmLrzgFTZLo8U,12028
+hatch_cpp/tests/test_vcpkg_ref.py,sha256=wcfbFp8Tc6E2hiQPlextdno0NYrA1yljRSRUIQEj0mM,9969
 hatch_cpp/tests/test_project_basic/pyproject.toml,sha256=eqM1UVpNmJWDfsuO18ZG_VOV9I4tAWgsM5Dhf49X8Nc,694
 hatch_cpp/tests/test_project_basic/cpp/project/basic.cpp,sha256=gQ2nmdLqIdgaqxSKvkN_vbp6Iv_pAoVIHETXPRnALb0,117
 hatch_cpp/tests/test_project_basic/cpp/project/basic.hpp,sha256=SO5GhPj8k3RzWrfH37lFSDc8w1Vf3yqTUhxmr1hnoko,422
@@ -57,11 +57,11 @@ hatch_cpp/tests/test_project_pybind_vcpkg/cpp/project/basic.cpp,sha256=MT3eCSQKr
 hatch_cpp/tests/test_project_pybind_vcpkg/cpp/project/basic.hpp,sha256=LZSfCfhLY_91MBOxtnvDk7DcceO-9GhCHKpMnAjGe18,146
 hatch_cpp/tests/test_project_pybind_vcpkg/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hatch_cpp/toolchains/__init__.py,sha256=anza4tXKxauobWMOUrxX3sEO0qs7sp6VdLXhLae3vkY,64
-hatch_cpp/toolchains/cmake.py,sha256=VQYYqiOu0ZEF0IBuep35Xad7jryWy04-dHYYf7c0XgY,3331
-hatch_cpp/toolchains/common.py,sha256=o6whV_7W9GGtBsxgxmg-dHQqdFnuMLffkLHzdbqKqME,19075
-hatch_cpp/toolchains/vcpkg.py,sha256=ku5NE4ihdzbxdReNUXsGx03fPG5FYdQC48mJhdpW-oo,3456
-hatch_cpp-0.3.5.dist-info/METADATA,sha256=BNI_Ezt3hDfW5xhETfORdexE3tb4Ul4dY4M__K0hj10,9896
-hatch_cpp-0.3.5.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-hatch_cpp-0.3.5.dist-info/entry_points.txt,sha256=RgXfjpD4iwomJQK5n7FnPkXzb5fOnF5v3DI5hbkgVcw,30
-hatch_cpp-0.3.5.dist-info/licenses/LICENSE,sha256=FWyFTpd5xXEz50QpGDtsyIv6dgR2z_dHdoab_Nq_KMw,11452
-hatch_cpp-0.3.5.dist-info/RECORD,,
+hatch_cpp/toolchains/cmake.py,sha256=yUMw6LzmasjRiJfxN98b-E9fDxUbM0-mz-RL0O7IVag,3748
+hatch_cpp/toolchains/common.py,sha256=wOu1d9bOWW962NH-Bt-cXLlfAjgCbLgq-lIXxSupCvc,20265
+hatch_cpp/toolchains/vcpkg.py,sha256=fBBModZOL49yJH8971zsOuuRPgTnmR2qvU_0AdT__DY,5233
+hatch_cpp-0.3.7.dist-info/METADATA,sha256=qc9OfLqYolu8-toWPMfDhAY_9fyaq9OfbMK4XDU_eO0,9896
+hatch_cpp-0.3.7.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+hatch_cpp-0.3.7.dist-info/entry_points.txt,sha256=RgXfjpD4iwomJQK5n7FnPkXzb5fOnF5v3DI5hbkgVcw,30
+hatch_cpp-0.3.7.dist-info/licenses/LICENSE,sha256=FWyFTpd5xXEz50QpGDtsyIv6dgR2z_dHdoab_Nq_KMw,11452
+hatch_cpp-0.3.7.dist-info/RECORD,,