hatch-cpp 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

hatch_cpp/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.4"
+__version__ = "0.3.6"
 
 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

@@ -0,0 +1,174 @@
+"""Tests for vcpkg ref/branch checkout support."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from hatch_cpp.toolchains.vcpkg import (
+    HatchCppVcpkgConfiguration,
+    _read_vcpkg_ref_from_gitmodules,
+)
+
+
+class TestReadVcpkgRefFromGitmodules:
+    """Tests for the _read_vcpkg_ref_from_gitmodules helper."""
+
+    def test_no_gitmodules_file(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        assert _read_vcpkg_ref_from_gitmodules(Path("vcpkg")) is None
+
+    def test_gitmodules_without_vcpkg_submodule(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        (tmp_path / ".gitmodules").write_text('[submodule "other"]\n\tpath = other\n\turl = https://github.com/example/other.git\n')
+        assert _read_vcpkg_ref_from_gitmodules(Path("vcpkg")) is None
+
+    def test_gitmodules_vcpkg_without_branch(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        (tmp_path / ".gitmodules").write_text('[submodule "vcpkg"]\n\tpath = vcpkg\n\turl = https://github.com/microsoft/vcpkg.git\n')
+        assert _read_vcpkg_ref_from_gitmodules(Path("vcpkg")) is None
+
+    def test_gitmodules_vcpkg_with_branch(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        (tmp_path / ".gitmodules").write_text(
+            '[submodule "vcpkg"]\n\tpath = vcpkg\n\turl = https://github.com/microsoft/vcpkg.git\n\tbranch = 2024.01.12\n'
+        )
+        assert _read_vcpkg_ref_from_gitmodules(Path("vcpkg")) == "2024.01.12"
+
+    def test_gitmodules_vcpkg_with_commit_sha_branch(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        sha = "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2"
+        (tmp_path / ".gitmodules").write_text(
+            f'[submodule "vcpkg"]\n\tpath = vcpkg\n\turl = https://github.com/microsoft/vcpkg.git\n\tbranch = {sha}\n'
+        )
+        assert _read_vcpkg_ref_from_gitmodules(Path("vcpkg")) == sha
+
+    def test_gitmodules_custom_vcpkg_root(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        (tmp_path / ".gitmodules").write_text(
+            '[submodule "deps/vcpkg"]\n\tpath = deps/vcpkg\n\turl = https://github.com/microsoft/vcpkg.git\n\tbranch = 2024.06.15\n'
+        )
+        # Default vcpkg root won't match
+        assert _read_vcpkg_ref_from_gitmodules(Path("vcpkg")) is None
+        # Custom root matches
+        assert _read_vcpkg_ref_from_gitmodules(Path("deps/vcpkg")) == "2024.06.15"
+
+    def test_gitmodules_multiple_submodules(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        (tmp_path / ".gitmodules").write_text(
+            '[submodule "other"]\n'
+            "\tpath = other\n"
+            "\turl = https://github.com/example/other.git\n"
+            "\tbranch = main\n"
+            '[submodule "vcpkg"]\n'
+            "\tpath = vcpkg\n"
+            "\turl = https://github.com/microsoft/vcpkg.git\n"
+            "\tbranch = 2024.01.12\n"
+        )
+        assert _read_vcpkg_ref_from_gitmodules(Path("vcpkg")) == "2024.01.12"
+
+
+class TestVcpkgRefConfig:
+    """Tests for vcpkg_ref configuration field."""
+
+    def test_default_vcpkg_ref_is_none(self):
+        cfg = HatchCppVcpkgConfiguration()
+        assert cfg.vcpkg_ref is None
+
+    def test_explicit_vcpkg_ref(self):
+        cfg = HatchCppVcpkgConfiguration(vcpkg_ref="2024.01.12")
+        assert cfg.vcpkg_ref == "2024.01.12"
+
+    def test_explicit_vcpkg_ref_commit_sha(self):
+        sha = "a1b2c3d4e5f6"
+        cfg = HatchCppVcpkgConfiguration(vcpkg_ref=sha)
+        assert cfg.vcpkg_ref == sha
+
+
+class TestResolveVcpkgRef:
+    """Tests for _resolve_vcpkg_ref priority logic."""
+
+    def test_explicit_ref_takes_priority_over_gitmodules(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        (tmp_path / ".gitmodules").write_text(
+            '[submodule "vcpkg"]\n\tpath = vcpkg\n\turl = https://github.com/microsoft/vcpkg.git\n\tbranch = 2024.01.12\n'
+        )
+        cfg = HatchCppVcpkgConfiguration(vcpkg_ref="my-custom-tag")
+        assert cfg._resolve_vcpkg_ref() == "my-custom-tag"
+
+    def test_falls_back_to_gitmodules(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        (tmp_path / ".gitmodules").write_text(
+            '[submodule "vcpkg"]\n\tpath = vcpkg\n\turl = https://github.com/microsoft/vcpkg.git\n\tbranch = 2024.01.12\n'
+        )
+        cfg = HatchCppVcpkgConfiguration()
+        assert cfg._resolve_vcpkg_ref() == "2024.01.12"
+
+    def test_returns_none_when_no_ref(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        cfg = HatchCppVcpkgConfiguration()
+        assert cfg._resolve_vcpkg_ref() is None
+
+
+class TestVcpkgGenerate:
+    """Tests that generate() includes the checkout command when a ref is set."""
+
+    def _make_vcpkg_env(self, tmp_path):
+        """Create a minimal vcpkg.json so generate() produces commands."""
+        (tmp_path / "vcpkg.json").write_text("{}")
+
+    def test_generate_with_explicit_ref(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        self._make_vcpkg_env(tmp_path)
+
+        cfg = HatchCppVcpkgConfiguration(vcpkg_ref="2024.01.12")
+        commands = cfg.generate(None)
+
+        assert any("git clone" in cmd for cmd in commands)
+        assert any("git -C vcpkg checkout 2024.01.12" in cmd for cmd in commands)
+        # checkout must come after clone but before bootstrap
+        clone_idx = next(i for i, c in enumerate(commands) if "git clone" in c)
+        checkout_idx = next(i for i, c in enumerate(commands) if "checkout" in c)
+        bootstrap_idx = next(i for i, c in enumerate(commands) if "bootstrap" in c)
+        assert clone_idx < checkout_idx < bootstrap_idx
+
+    def test_generate_with_gitmodules_ref(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        self._make_vcpkg_env(tmp_path)
+        (tmp_path / ".gitmodules").write_text(
+            '[submodule "vcpkg"]\n\tpath = vcpkg\n\turl = https://github.com/microsoft/vcpkg.git\n\tbranch = 2024.06.15\n'
+        )
+
+        cfg = HatchCppVcpkgConfiguration()
+        commands = cfg.generate(None)
+
+        assert any("git -C vcpkg checkout 2024.06.15" in cmd for cmd in commands)
+
+    def test_generate_without_ref(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        self._make_vcpkg_env(tmp_path)
+
+        cfg = HatchCppVcpkgConfiguration()
+        commands = cfg.generate(None)
+
+        assert not any("checkout" in cmd for cmd in commands)
+        assert any("git clone" in cmd for cmd in commands)
+
+    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()
+
+        cfg = HatchCppVcpkgConfiguration(vcpkg_ref="2024.01.12")
+        commands = cfg.generate(None)
+
+        # When vcpkg_root already exists, no clone or checkout happens
+        assert not any("git clone" in cmd for cmd in commands)
+        assert not any("checkout" 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):
+        monkeypatch.chdir(tmp_path)
+        # No vcpkg.json => no commands at all
+        cfg = HatchCppVcpkgConfiguration(vcpkg_ref="2024.01.12")
+        commands = cfg.generate(None)
+        assert commands == []

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,5 +1,6 @@
 from __future__ import annotations
 
+import configparser
 from pathlib import Path
 from platform import machine as platform_machine
 from sys import platform as sys_platform
@@ -38,14 +39,45 @@ VcpkgPlatformDefaults = {
 }
 
 
+def _read_vcpkg_ref_from_gitmodules(vcpkg_root: Path) -> Optional[str]:
+    """Read the branch/ref for vcpkg from .gitmodules if it exists.
+
+    Looks for a submodule whose path matches ``vcpkg_root`` and returns
+    its ``branch`` value when present.
+    """
+    gitmodules_path = Path(".gitmodules")
+    if not gitmodules_path.exists():
+        return None
+
+    parser = configparser.ConfigParser()
+    parser.read(str(gitmodules_path))
+
+    for section in parser.sections():
+        if parser.get(section, "path", fallback=None) == str(vcpkg_root):
+            return parser.get(section, "branch", fallback=None)
+
+    return None
+
+
 class HatchCppVcpkgConfiguration(BaseModel):
     vcpkg: Optional[str] = Field(default="vcpkg.json")
     vcpkg_root: Optional[Path] = Field(default=Path("vcpkg"))
     vcpkg_repo: Optional[str] = Field(default="https://github.com/microsoft/vcpkg.git")
     vcpkg_triplet: Optional[VcpkgTriplet] = Field(default=None)
+    vcpkg_ref: Optional[str] = Field(
+        default=None,
+        description="Branch, tag, or commit SHA to checkout after cloning vcpkg. "
+        "If not set, falls back to the branch specified in .gitmodules for the vcpkg submodule.",
+    )
 
     # TODO: overlay
 
+    def _resolve_vcpkg_ref(self) -> Optional[str]:
+        """Return the ref to checkout: explicit config takes priority, then .gitmodules."""
+        if self.vcpkg_ref is not None:
+            return self.vcpkg_ref
+        return _read_vcpkg_ref_from_gitmodules(self.vcpkg_root)
+
     def generate(self, config):
         commands = []
 
@@ -57,9 +89,12 @@ class HatchCppVcpkgConfiguration(BaseModel):
         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}")
-                commands.append(
-                    f"./{self.vcpkg_root / 'bootstrap-vcpkg.sh' if sys_platform != 'win32' else self.vcpkg_root / 'sbootstrap-vcpkg.bat'}"
-                )
+
+                ref = self._resolve_vcpkg_ref()
+                if ref is not None:
+                    commands.append(f"git -C {self.vcpkg_root} checkout {ref}")
+
+                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.4.dist-info → hatch_cpp-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hatch-cpp
-Version: 0.3.4
+Version: 0.3.6
 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.4.dist-info → hatch_cpp-0.3.6.dist-info}/RECORD

@@ -1,12 +1,13 @@
-hatch_cpp/__init__.py,sha256=LIxZbLjKVLTqopdLZRTcOW9cNddI-RjehTkwUck5_Wg,114
-hatch_cpp/config.py,sha256=6oO8J2k91r88DwZwDJpxtxt2F5xZZ-N65IqSyabwOg4,3831
+hatch_cpp/__init__.py,sha256=xGDCEwGyCK-WHRtDPw6Bgp1xGbgIgA5VB0RayrIeETs,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_structs.py,sha256=zmNtAV1bojvJM6gatjDtvqrAeUpKzpfmLrzgFTZLo8U,12028
+hatch_cpp/tests/test_vcpkg_ref.py,sha256=OEb4u3Ny-OYNYLanjGaG7-dL4WW48EYdbsxeDN0sqwM,7371
 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
@@ -56,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=Gwv3YNXBngpdebvRuYuUcWCzPyDbmDvy8c0K7uV4k38,2146
-hatch_cpp-0.3.4.dist-info/METADATA,sha256=7ywI-SN7YMSTYlv6awfKUyz4DkASffONK4AQ8Kydt00,9896
-hatch_cpp-0.3.4.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-hatch_cpp-0.3.4.dist-info/entry_points.txt,sha256=RgXfjpD4iwomJQK5n7FnPkXzb5fOnF5v3DI5hbkgVcw,30
-hatch_cpp-0.3.4.dist-info/licenses/LICENSE,sha256=FWyFTpd5xXEz50QpGDtsyIv6dgR2z_dHdoab_Nq_KMw,11452
-hatch_cpp-0.3.4.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=ku5NE4ihdzbxdReNUXsGx03fPG5FYdQC48mJhdpW-oo,3456
+hatch_cpp-0.3.6.dist-info/METADATA,sha256=lyNg7Xk0tL_pqvKFnNujLuxdC8_8tV1WiLvazo63ywQ,9896
+hatch_cpp-0.3.6.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+hatch_cpp-0.3.6.dist-info/entry_points.txt,sha256=RgXfjpD4iwomJQK5n7FnPkXzb5fOnF5v3DI5hbkgVcw,30
+hatch_cpp-0.3.6.dist-info/licenses/LICENSE,sha256=FWyFTpd5xXEz50QpGDtsyIv6dgR2z_dHdoab_Nq_KMw,11452
+hatch_cpp-0.3.6.dist-info/RECORD,,