taler-rust

configure.py (3249B)

---

 # This configure.py.template file is in the public domain.
 
 import os
 import re
 import shutil
 import subprocess
 
 from talerbuildconfig import *
 
 # Oldest Rust release that can build this tree.  Keep the reason for the number
 # next to it -- the point of the check is to report an unusable toolchain here,
 # once, instead of as a wall of parse errors in the middle of the build.
 #
 #   1.85  edition 2024 / resolver "3"   (Cargo.toml)
 #   1.86  Vec::pop_if                   (common/failure-injection)
 #   1.88  let chains                    (used throughout)
 #   1.93  std::fmt::from_fn             (taler-common, taler-api, taler-wise)
 #
 # Debian trixie ships 1.85, which is too old; trixie-backports and testing both
 # ship a new enough rustc.  Keep this in step with `rust-version` in Cargo.toml.
 RUST_MIN_VERSION = "1.93"
 
 
 def _version_tuple(version):
     parts = [int(p) for p in version.split(".")[:3]]
     return tuple(parts + [0] * (3 - len(parts)))
 
 
 class RustTool(Tool):
     """A Rust toolchain program (cargo, rustc) found on $PATH.
 
     Unlike PosixTool this honours a CARGO=/RUSTC= environment override and
     records the resolved path *and* version in config.mk.  Nothing here wants
     rustup: any cargo/rustc on $PATH will do, including the distribution's.
     """
 
     def __init__(self, name, min_version=None):
         self.name = name
         self.min_version = min_version
         self.hint = (
             f"install a Rust toolchain providing '{name}' -- the distribution's"
             f" rustc/cargo packages are fine (on Debian stable they come from"
             f" trixie-backports), as is rustup -- or point {name.upper()}= at one"
         )
 
     def args(self, parser):
         pass
 
     def check(self, buildconfig):
         prog = os.environ.get(self.name.upper()) or self.name
         path = shutil.which(prog)
         if path is None:
             return False
 
         version = self._version(path)
         buildconfig._set_tool(self.name, path, version=version)
 
         if self.min_version is None or version is None:
             return True
 
         if _version_tuple(version) < _version_tuple(self.min_version):
             # A warning, not an error: configuring is still useful (the
             # non-build targets work), and `rust-version` in Cargo.toml makes
             # cargo itself refuse the build with a precise message.
             buildconfig._warn(
                 f"{self.name} {version} is older than {self.min_version};"
                 f" this tree will not compile with it."
                 f" On Debian stable: apt install -t trixie-backports rustc cargo"
             )
         return True
 
     @staticmethod
     def _version(path):
         try:
             out = subprocess.run(
                 [path, "--version"], capture_output=True, text=True, check=True
             ).stdout
         except (OSError, subprocess.SubprocessError):
             return None
         # "cargo 1.95.0 (f2d3ce0bd 2026-03-21)", "rustc 1.95.0 (59807616e ...)"
         found = re.search(r"\d+(?:\.\d+)+", out)
         return found.group(0) if found else None
 
 
 b = BuildConfig()
 b.enable_prefix()
 b.enable_configmk()
 b.add_tool(RustTool("cargo"))
 b.add_tool(RustTool("rustc", min_version=RUST_MIN_VERSION))
 b.run()