mirror of
https://github.com/elicpeter/nyx.git
synced 2026-06-09 19:45:13 +02:00
1000 lines
36 KiB
Rust
1000 lines
36 KiB
Rust
//! Toolchain resolver (§22.2).
|
|
//!
|
|
//! Reads project metadata files to determine the pinned Python version, then
|
|
//! maps it to the closest Nyx reference image. Records `pin_origin` (where the
|
|
//! version was found) and a `toolchain_drift` flag when the resolved image is
|
|
//! not an exact match for the requested version.
|
|
|
|
use std::path::Path;
|
|
|
|
// Phase 19 (Track E.3): generated lookup tables for pinned Docker image
|
|
// digests. Populated by `build.rs` from `tools/image-builder/images.toml`.
|
|
//
|
|
// - `IMAGE_DIGESTS`: `toolchain_id → "<base>@sha256:…"`. Used by the docker
|
|
// backend (`src/dynamic/sandbox/docker.rs`) to pull a pinned digest so the
|
|
// sandboxed runtime is byte-identical between hosts.
|
|
// - `IMAGE_BASES`: `toolchain_id → "<base-tag>"`. Fallback for the docker
|
|
// backend when no digest is pinned yet (e.g. fresh `images.toml` entry).
|
|
include!(concat!(env!("OUT_DIR"), "/image_digests.rs"));
|
|
|
|
/// Pinned image reference (`<base>@sha256:…`) for `toolchain_id`, or `None`
|
|
/// when the catalogue entry has not been built yet.
|
|
///
|
|
/// Phase 19 keeps the pin pure-static: `nyx-image-builder build` writes the
|
|
/// digest back into `images.toml`, the daily CI workflow opens a PR with the
|
|
/// new bytes, and a regular Rust rebuild picks up the new digest via
|
|
/// `build.rs`. There is no runtime digest fetch on the hot path.
|
|
pub fn pinned_image_ref(toolchain_id: &str) -> Option<&'static str> {
|
|
IMAGE_DIGESTS.get(toolchain_id).copied()
|
|
}
|
|
|
|
/// Base image tag (no digest) for `toolchain_id`, or `None` when the
|
|
/// toolchain is not present in the catalogue.
|
|
///
|
|
/// Used by the docker backend when [`pinned_image_ref`] returns `None`: the
|
|
/// backend issues a tag pull and records the resolved digest in telemetry so
|
|
/// drift is visible to operators even when the catalogue is unpinned.
|
|
pub fn base_image_ref(toolchain_id: &str) -> Option<&'static str> {
|
|
IMAGE_BASES.get(toolchain_id).copied()
|
|
}
|
|
|
|
/// Resolved toolchain information for a target directory.
|
|
#[derive(Debug, Clone)]
|
|
pub struct ToolchainResolution {
|
|
/// Nyx reference toolchain identifier (e.g. `"python-3.11"`).
|
|
pub toolchain_id: String,
|
|
/// Where the version pin was read from.
|
|
pub pin_origin: PinOrigin,
|
|
/// Whether the resolved toolchain differs from the exact pinned version.
|
|
pub toolchain_drift: bool,
|
|
/// Resolved semver string (e.g. `"3.11.5"`).
|
|
pub version_string: String,
|
|
}
|
|
|
|
/// Where the toolchain version pin was discovered.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum PinOrigin {
|
|
/// `.python-version` file (pyenv).
|
|
PythonVersion,
|
|
/// `pyproject.toml` `[tool.python]` or `[project] requires-python`.
|
|
PyprojectToml,
|
|
/// `Pipfile` `[requires] python_version`.
|
|
Pipfile,
|
|
/// `runtime.txt` (Heroku-style).
|
|
RuntimeTxt,
|
|
/// `rust-toolchain.toml` `[toolchain] channel`.
|
|
RustToolchainToml,
|
|
/// `rust-toolchain` (plain text channel file).
|
|
RustToolchainFile,
|
|
/// `Cargo.toml` `rust-version` field.
|
|
CargoToml,
|
|
/// `package.json` `engines.node` field.
|
|
PackageJson,
|
|
/// `go.mod` `go` directive.
|
|
GoMod,
|
|
/// `pom.xml` `<java.version>` / `<maven.compiler.source>`.
|
|
PomXml,
|
|
/// `build.gradle` `sourceCompatibility` / `java.toolchain.languageVersion`.
|
|
BuildGradle,
|
|
/// `composer.json` `require.php`.
|
|
ComposerJson,
|
|
/// No pin found; used the system default.
|
|
SystemDefault,
|
|
}
|
|
|
|
// ── Rust toolchain resolver ───────────────────────────────────────────────────
|
|
|
|
/// Resolve the Rust toolchain for `project_root` (§22.2).
|
|
///
|
|
/// Reads project pin files in priority order:
|
|
/// `rust-toolchain.toml` > `rust-toolchain` > `Cargo.toml` `rust-version` > default.
|
|
pub fn resolve_rust(project_root: &Path) -> ToolchainResolution {
|
|
if let Some(r) = try_rust_toolchain_toml(project_root) {
|
|
return r;
|
|
}
|
|
if let Some(r) = try_rust_toolchain_file(project_root) {
|
|
return r;
|
|
}
|
|
if let Some(r) = try_cargo_toml_rust_version(project_root) {
|
|
return r;
|
|
}
|
|
default_rust()
|
|
}
|
|
|
|
fn try_rust_toolchain_toml(root: &Path) -> Option<ToolchainResolution> {
|
|
let content = std::fs::read_to_string(root.join("rust-toolchain.toml")).ok()?;
|
|
// Look for `channel = "stable"` or `channel = "1.75"` in [toolchain] section.
|
|
let mut in_toolchain = false;
|
|
for line in content.lines() {
|
|
let line = line.trim();
|
|
if line == "[toolchain]" {
|
|
in_toolchain = true;
|
|
continue;
|
|
}
|
|
if line.starts_with('[') {
|
|
in_toolchain = false;
|
|
}
|
|
if in_toolchain && line.starts_with("channel") {
|
|
if let Some(ver) = extract_version_from_toml_value(line) {
|
|
return Some(map_rust_version(&ver, RustPinOrigin::RustToolchainToml));
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn try_rust_toolchain_file(root: &Path) -> Option<ToolchainResolution> {
|
|
let content = std::fs::read_to_string(root.join("rust-toolchain")).ok()?;
|
|
let version = content.trim().to_owned();
|
|
if version.is_empty() {
|
|
return None;
|
|
}
|
|
// Simple format: just the channel name (e.g. "stable", "1.75.0", "nightly-2024-01-01")
|
|
Some(map_rust_version(&version, RustPinOrigin::RustToolchainFile))
|
|
}
|
|
|
|
fn try_cargo_toml_rust_version(root: &Path) -> Option<ToolchainResolution> {
|
|
let content = std::fs::read_to_string(root.join("Cargo.toml")).ok()?;
|
|
for line in content.lines() {
|
|
let line = line.trim();
|
|
if line.starts_with("rust-version") {
|
|
if let Some(ver) = extract_version_from_toml_value(line) {
|
|
return Some(map_rust_version(&ver, RustPinOrigin::CargoToml));
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn default_rust() -> ToolchainResolution {
|
|
ToolchainResolution {
|
|
toolchain_id: "rust-stable".to_owned(),
|
|
pin_origin: PinOrigin::SystemDefault,
|
|
toolchain_drift: false,
|
|
version_string: "stable".to_owned(),
|
|
}
|
|
}
|
|
|
|
/// Internal origin enum for Rust (mapped to PinOrigin for the public API).
|
|
enum RustPinOrigin {
|
|
RustToolchainToml,
|
|
RustToolchainFile,
|
|
CargoToml,
|
|
}
|
|
|
|
fn map_rust_version(version: &str, origin: RustPinOrigin) -> ToolchainResolution {
|
|
let pin_origin = match origin {
|
|
RustPinOrigin::RustToolchainToml => PinOrigin::RustToolchainToml,
|
|
RustPinOrigin::RustToolchainFile => PinOrigin::RustToolchainFile,
|
|
RustPinOrigin::CargoToml => PinOrigin::CargoToml,
|
|
};
|
|
|
|
// Named channels.
|
|
if version == "stable" || version.is_empty() {
|
|
return ToolchainResolution {
|
|
toolchain_id: "rust-stable".to_owned(),
|
|
pin_origin,
|
|
toolchain_drift: false,
|
|
version_string: "stable".to_owned(),
|
|
};
|
|
}
|
|
if version.starts_with("nightly") {
|
|
return ToolchainResolution {
|
|
toolchain_id: "rust-nightly".to_owned(),
|
|
pin_origin,
|
|
toolchain_drift: true, // nightly != stable reference image
|
|
version_string: version.to_owned(),
|
|
};
|
|
}
|
|
if version.starts_with("beta") {
|
|
return ToolchainResolution {
|
|
toolchain_id: "rust-beta".to_owned(),
|
|
pin_origin,
|
|
toolchain_drift: true,
|
|
version_string: version.to_owned(),
|
|
};
|
|
}
|
|
|
|
// Semver pinned version like "1.75.0" or "1.75".
|
|
let parts: Vec<&str> = version.splitn(3, '.').collect();
|
|
let major = parts.first().copied().unwrap_or("1");
|
|
let minor = parts.get(1).copied();
|
|
|
|
// Map to stable; drift = true when exact version differs from "stable".
|
|
let drift = minor.is_some(); // pin to specific version = drift from "stable" label
|
|
ToolchainResolution {
|
|
toolchain_id: format!("rust-{major}.{}", minor.unwrap_or("x")),
|
|
pin_origin,
|
|
toolchain_drift: drift,
|
|
version_string: version.to_owned(),
|
|
}
|
|
}
|
|
|
|
// ── Python toolchain resolver ─────────────────────────────────────────────────
|
|
|
|
/// Resolve the Python toolchain for `project_root`.
|
|
///
|
|
/// Reads project pin files in priority order:
|
|
/// `.python-version` > `pyproject.toml` > `Pipfile` > `runtime.txt` > default.
|
|
pub fn resolve_python(project_root: &Path) -> ToolchainResolution {
|
|
if let Some(r) = try_python_version_file(project_root) {
|
|
return r;
|
|
}
|
|
if let Some(r) = try_pyproject_toml(project_root) {
|
|
return r;
|
|
}
|
|
if let Some(r) = try_pipfile(project_root) {
|
|
return r;
|
|
}
|
|
if let Some(r) = try_runtime_txt(project_root) {
|
|
return r;
|
|
}
|
|
default_python()
|
|
}
|
|
|
|
fn try_python_version_file(root: &Path) -> Option<ToolchainResolution> {
|
|
let path = root.join(".python-version");
|
|
let content = std::fs::read_to_string(&path).ok()?;
|
|
let version = content.trim().to_owned();
|
|
if version.is_empty() {
|
|
return None;
|
|
}
|
|
Some(map_version(&version, PinOrigin::PythonVersion))
|
|
}
|
|
|
|
fn try_pyproject_toml(root: &Path) -> Option<ToolchainResolution> {
|
|
let content = std::fs::read_to_string(root.join("pyproject.toml")).ok()?;
|
|
// Look for `requires-python = ">=3.11"` or `python = "3.11"`.
|
|
for line in content.lines() {
|
|
let line = line.trim();
|
|
if line.starts_with("requires-python") || (line.starts_with("python") && line.contains('=') && !line.starts_with("python_requires")) {
|
|
if let Some(ver) = extract_version_from_toml_value(line) {
|
|
return Some(map_version(&ver, PinOrigin::PyprojectToml));
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn try_pipfile(root: &Path) -> Option<ToolchainResolution> {
|
|
let content = std::fs::read_to_string(root.join("Pipfile")).ok()?;
|
|
let mut in_requires = false;
|
|
for line in content.lines() {
|
|
let line = line.trim();
|
|
if line == "[requires]" {
|
|
in_requires = true;
|
|
continue;
|
|
}
|
|
if line.starts_with('[') {
|
|
in_requires = false;
|
|
}
|
|
if in_requires && line.starts_with("python_version") {
|
|
if let Some(ver) = extract_version_from_toml_value(line) {
|
|
return Some(map_version(&ver, PinOrigin::Pipfile));
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn try_runtime_txt(root: &Path) -> Option<ToolchainResolution> {
|
|
let content = std::fs::read_to_string(root.join("runtime.txt")).ok()?;
|
|
let line = content.lines().next()?.trim();
|
|
// e.g. "python-3.11.5"
|
|
let version = line.strip_prefix("python-").unwrap_or(line);
|
|
if version.is_empty() {
|
|
return None;
|
|
}
|
|
Some(map_version(version, PinOrigin::RuntimeTxt))
|
|
}
|
|
|
|
fn default_python() -> ToolchainResolution {
|
|
ToolchainResolution {
|
|
toolchain_id: "python-3".to_owned(),
|
|
pin_origin: PinOrigin::SystemDefault,
|
|
toolchain_drift: false,
|
|
version_string: "3".to_owned(),
|
|
}
|
|
}
|
|
|
|
/// Extract the bare version string from a TOML assignment like:
|
|
/// `requires-python = ">=3.11"` → `"3.11"`
|
|
/// `python_version = "3.11"` → `"3.11"`
|
|
fn extract_version_from_toml_value(line: &str) -> Option<String> {
|
|
let after_eq = line.splitn(2, '=').nth(1)?;
|
|
let raw = after_eq.trim().trim_matches('"').trim_matches('\'');
|
|
if raw.is_empty() {
|
|
return None;
|
|
}
|
|
// If the value begins with a digit (after stripping comparators), it is a
|
|
// semver pin like ">=1.75". Otherwise it is a channel name like "stable" /
|
|
// "nightly" / "beta" — return verbatim so `map_rust_version` can dispatch.
|
|
let trimmed = raw.trim_start_matches(|c: char| !c.is_ascii_digit() && !c.is_ascii_alphabetic());
|
|
if trimmed.starts_with(|c: char| c.is_ascii_digit()) {
|
|
return Some(trimmed.to_owned());
|
|
}
|
|
Some(trimmed.to_owned())
|
|
}
|
|
|
|
/// Map a raw version string to a Nyx reference toolchain ID.
|
|
///
|
|
/// Reference images: `python-3.8`, `python-3.9`, `python-3.10`,
|
|
/// `python-3.11`, `python-3.12`, `python-3.13`.
|
|
fn map_version(version: &str, origin: PinOrigin) -> ToolchainResolution {
|
|
// Normalise: take major.minor from "3.11.5" → "3.11"
|
|
let parts: Vec<&str> = version.splitn(3, '.').collect();
|
|
let major = parts.first().copied().unwrap_or("3");
|
|
let minor = parts.get(1).copied();
|
|
|
|
let (toolchain_id, drift) = match (major, minor) {
|
|
("3", Some("8")) => ("python-3.8".to_owned(), false),
|
|
("3", Some("9")) => ("python-3.9".to_owned(), false),
|
|
("3", Some("10")) => ("python-3.10".to_owned(), false),
|
|
("3", Some("11")) => ("python-3.11".to_owned(), false),
|
|
("3", Some("12")) => ("python-3.12".to_owned(), false),
|
|
("3", Some("13")) => ("python-3.13".to_owned(), false),
|
|
// Older 3.x → nearest supported is 3.8
|
|
("3", Some(m)) if m.parse::<u32>().map_or(false, |v| v < 8) => {
|
|
("python-3.8".to_owned(), true)
|
|
}
|
|
// Newer 3.x beyond catalog → use 3.13 as closest
|
|
("3", Some(_)) => ("python-3.13".to_owned(), true),
|
|
("3", None) => ("python-3".to_owned(), false),
|
|
// Python 2 → unsupported, use system default as closest
|
|
("2", _) => ("python-3".to_owned(), true),
|
|
_ => ("python-3".to_owned(), true),
|
|
};
|
|
|
|
ToolchainResolution {
|
|
version_string: version.to_owned(),
|
|
toolchain_id,
|
|
pin_origin: origin,
|
|
toolchain_drift: drift,
|
|
}
|
|
}
|
|
|
|
// ── Node.js toolchain resolver ────────────────────────────────────────────────
|
|
|
|
/// Resolve the Node.js toolchain for `project_root`.
|
|
///
|
|
/// Reads pin files in priority order:
|
|
/// `.nvmrc` > `package.json` `engines.node` > `.node-version` > default.
|
|
pub fn resolve_node(project_root: &Path) -> ToolchainResolution {
|
|
if let Some(r) = try_nvmrc(project_root) {
|
|
return r;
|
|
}
|
|
if let Some(r) = try_package_json_engines(project_root) {
|
|
return r;
|
|
}
|
|
if let Some(r) = try_node_version_file(project_root) {
|
|
return r;
|
|
}
|
|
default_node()
|
|
}
|
|
|
|
fn try_nvmrc(root: &Path) -> Option<ToolchainResolution> {
|
|
let content = std::fs::read_to_string(root.join(".nvmrc")).ok()?;
|
|
let version = content.trim().trim_start_matches('v').to_owned();
|
|
if version.is_empty() {
|
|
return None;
|
|
}
|
|
Some(map_node_version(&version, PinOrigin::PackageJson))
|
|
}
|
|
|
|
fn try_package_json_engines(root: &Path) -> Option<ToolchainResolution> {
|
|
let content = std::fs::read_to_string(root.join("package.json")).ok()?;
|
|
// Look for "node": ">=18" or "node": "20.x" under "engines".
|
|
let mut in_engines = false;
|
|
for line in content.lines() {
|
|
let trimmed = line.trim();
|
|
if json_line_has_key(trimmed, "engines") {
|
|
in_engines = true;
|
|
}
|
|
if in_engines && trimmed.contains("\"node\"") {
|
|
// Extract version from: "node": ">=18" or "node": "20"
|
|
if let Some(ver) = extract_version_from_json_value(trimmed) {
|
|
return Some(map_node_version(&ver, PinOrigin::PackageJson));
|
|
}
|
|
}
|
|
if in_engines && trimmed.starts_with('}') {
|
|
in_engines = false;
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn try_node_version_file(root: &Path) -> Option<ToolchainResolution> {
|
|
let content = std::fs::read_to_string(root.join(".node-version")).ok()?;
|
|
let version = content.trim().trim_start_matches('v').to_owned();
|
|
if version.is_empty() {
|
|
return None;
|
|
}
|
|
Some(map_node_version(&version, PinOrigin::PackageJson))
|
|
}
|
|
|
|
fn default_node() -> ToolchainResolution {
|
|
ToolchainResolution {
|
|
toolchain_id: "node-20".to_owned(),
|
|
pin_origin: PinOrigin::SystemDefault,
|
|
toolchain_drift: false,
|
|
version_string: "20".to_owned(),
|
|
}
|
|
}
|
|
|
|
fn map_node_version(version: &str, origin: PinOrigin) -> ToolchainResolution {
|
|
// Strip leading >= <= ~ ^ comparators.
|
|
let ver = version.trim_start_matches(|c: char| !c.is_ascii_digit());
|
|
let parts: Vec<&str> = ver.splitn(3, '.').collect();
|
|
let major = parts.first().copied().unwrap_or("20");
|
|
|
|
// Node.js LTS catalog: 18, 20, 22.
|
|
let (toolchain_id, drift) = match major.parse::<u32>() {
|
|
Ok(n) if n < 18 => (format!("node-{n}"), true),
|
|
Ok(18) => ("node-18".to_owned(), false),
|
|
Ok(20) => ("node-20".to_owned(), false),
|
|
Ok(22) => ("node-22".to_owned(), false),
|
|
Ok(n) => (format!("node-{n}"), true),
|
|
_ => ("node-20".to_owned(), true),
|
|
};
|
|
|
|
ToolchainResolution {
|
|
toolchain_id,
|
|
pin_origin: origin,
|
|
toolchain_drift: drift,
|
|
version_string: version.to_owned(),
|
|
}
|
|
}
|
|
|
|
/// Return true if `line` contains `"key":` as a JSON object key assignment.
|
|
///
|
|
/// Prevents false-positives from values like `"type": "require"` that would
|
|
/// otherwise match a plain `contains("\"key\"")` check.
|
|
fn json_line_has_key(line: &str, key: &str) -> bool {
|
|
let needle = format!("\"{key}\"");
|
|
let mut search = line;
|
|
while let Some(pos) = search.find(needle.as_str()) {
|
|
let rest = &search[pos + needle.len()..];
|
|
if rest.trim_start().starts_with(':') {
|
|
return true;
|
|
}
|
|
search = &search[pos + 1..];
|
|
}
|
|
false
|
|
}
|
|
|
|
/// Extract a version string from a JSON value like `">=18"` or `"20.x"`.
|
|
fn extract_version_from_json_value(line: &str) -> Option<String> {
|
|
// Find the second quoted value after the colon.
|
|
let after_colon = line.splitn(2, ':').nth(1)?;
|
|
let raw = after_colon.trim().trim_matches('"').trim_matches('\'');
|
|
let ver = raw.trim_start_matches(|c: char| !c.is_ascii_digit());
|
|
// Strip trailing junk: stop at the first char that isn't a version char.
|
|
// Handles single-line JSON like `{"php": ">=8.1"}}` where the previous
|
|
// trim still leaves `8.1"}}`.
|
|
let end = ver
|
|
.find(|c: char| !(c.is_ascii_digit() || c == '.' || c == '-'))
|
|
.unwrap_or(ver.len());
|
|
let ver = &ver[..end];
|
|
// Strip trailing .x or .* wildcards.
|
|
let ver = if let Some(pos) = ver.find(".x") {
|
|
&ver[..pos]
|
|
} else if let Some(pos) = ver.find(".*") {
|
|
&ver[..pos]
|
|
} else {
|
|
ver
|
|
};
|
|
if ver.is_empty() {
|
|
return None;
|
|
}
|
|
Some(ver.to_owned())
|
|
}
|
|
|
|
// ── Go toolchain resolver ─────────────────────────────────────────────────────
|
|
|
|
/// Resolve the Go toolchain for `project_root`.
|
|
///
|
|
/// Reads pin files in priority order: `go.mod` `go` directive > default.
|
|
pub fn resolve_go(project_root: &Path) -> ToolchainResolution {
|
|
if let Some(r) = try_go_mod(project_root) {
|
|
return r;
|
|
}
|
|
default_go()
|
|
}
|
|
|
|
fn try_go_mod(root: &Path) -> Option<ToolchainResolution> {
|
|
let content = std::fs::read_to_string(root.join("go.mod")).ok()?;
|
|
for line in content.lines() {
|
|
let trimmed = line.trim();
|
|
if let Some(rest) = trimmed.strip_prefix("go ") {
|
|
let version = rest.trim().to_owned();
|
|
if !version.is_empty() {
|
|
return Some(map_go_version(&version, PinOrigin::GoMod));
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn default_go() -> ToolchainResolution {
|
|
ToolchainResolution {
|
|
toolchain_id: "go-stable".to_owned(),
|
|
pin_origin: PinOrigin::SystemDefault,
|
|
toolchain_drift: false,
|
|
version_string: "stable".to_owned(),
|
|
}
|
|
}
|
|
|
|
fn map_go_version(version: &str, origin: PinOrigin) -> ToolchainResolution {
|
|
let parts: Vec<&str> = version.splitn(3, '.').collect();
|
|
let major = parts.first().copied().unwrap_or("1");
|
|
let minor = parts.get(1).copied();
|
|
|
|
// Go 1.21+ is the modern catalog.
|
|
let (toolchain_id, drift) = match (major, minor) {
|
|
("1", Some("21")) => ("go-1.21".to_owned(), false),
|
|
("1", Some("22")) => ("go-1.22".to_owned(), false),
|
|
("1", Some("23")) => ("go-1.23".to_owned(), false),
|
|
("1", Some(m)) if m.parse::<u32>().map_or(false, |v| v >= 24) => {
|
|
(format!("go-1.{m}"), true)
|
|
}
|
|
("1", Some(m)) if m.parse::<u32>().map_or(false, |v| v < 21) => {
|
|
(format!("go-1.{m}"), true)
|
|
}
|
|
_ => ("go-stable".to_owned(), false),
|
|
};
|
|
|
|
ToolchainResolution {
|
|
toolchain_id,
|
|
pin_origin: origin,
|
|
toolchain_drift: drift,
|
|
version_string: version.to_owned(),
|
|
}
|
|
}
|
|
|
|
// ── Java toolchain resolver ───────────────────────────────────────────────────
|
|
|
|
/// Resolve the Java toolchain for `project_root`.
|
|
///
|
|
/// Reads pin files in priority order:
|
|
/// `pom.xml` `<java.version>` / `<maven.compiler.source>` >
|
|
/// `build.gradle` `sourceCompatibility` > default.
|
|
pub fn resolve_java(project_root: &Path) -> ToolchainResolution {
|
|
if let Some(r) = try_pom_xml(project_root) {
|
|
return r;
|
|
}
|
|
if let Some(r) = try_build_gradle(project_root) {
|
|
return r;
|
|
}
|
|
default_java()
|
|
}
|
|
|
|
fn try_pom_xml(root: &Path) -> Option<ToolchainResolution> {
|
|
let content = std::fs::read_to_string(root.join("pom.xml")).ok()?;
|
|
// Look for <java.version>21</java.version> or <maven.compiler.source>21</...>
|
|
for line in content.lines() {
|
|
let trimmed = line.trim();
|
|
for tag in &["<java.version>", "<maven.compiler.source>", "<maven.compiler.release>"] {
|
|
if trimmed.starts_with(tag) {
|
|
if let Some(inner) = trimmed.strip_prefix(tag) {
|
|
let version = inner.split('<').next().unwrap_or("").trim();
|
|
if !version.is_empty() {
|
|
return Some(map_java_version(version, PinOrigin::PomXml));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn try_build_gradle(root: &Path) -> Option<ToolchainResolution> {
|
|
for fname in &["build.gradle", "build.gradle.kts"] {
|
|
let Ok(content) = std::fs::read_to_string(root.join(fname)) else {
|
|
continue;
|
|
};
|
|
for line in content.lines() {
|
|
let trimmed = line.trim();
|
|
// Groovy: sourceCompatibility = '21' or JavaVersion.VERSION_21
|
|
// Kotlin: sourceCompatibility = JavaVersion.VERSION_21
|
|
if trimmed.starts_with("sourceCompatibility") || trimmed.starts_with("languageVersion") {
|
|
if let Some(ver) = extract_java_version_from_gradle_line(trimmed) {
|
|
return Some(map_java_version(&ver, PinOrigin::BuildGradle));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn extract_java_version_from_gradle_line(line: &str) -> Option<String> {
|
|
// Handle: sourceCompatibility = '21' or sourceCompatibility = 21
|
|
// and: languageVersion.set(JavaLanguageVersion.of(21))
|
|
let after_eq = line.splitn(2, '=').nth(1).unwrap_or(line);
|
|
// Try to find a number in the value.
|
|
let digits: String = after_eq.chars()
|
|
.skip_while(|c| !c.is_ascii_digit())
|
|
.take_while(|c| c.is_ascii_digit())
|
|
.collect();
|
|
if digits.is_empty() {
|
|
// Try "VERSION_21" pattern.
|
|
if let Some(pos) = after_eq.find("VERSION_") {
|
|
let rest = &after_eq[pos + 8..];
|
|
let digits: String = rest.chars()
|
|
.take_while(|c| c.is_ascii_digit())
|
|
.collect();
|
|
if !digits.is_empty() {
|
|
return Some(digits);
|
|
}
|
|
}
|
|
return None;
|
|
}
|
|
Some(digits)
|
|
}
|
|
|
|
fn default_java() -> ToolchainResolution {
|
|
ToolchainResolution {
|
|
toolchain_id: "java-21".to_owned(),
|
|
pin_origin: PinOrigin::SystemDefault,
|
|
toolchain_drift: false,
|
|
version_string: "21".to_owned(),
|
|
}
|
|
}
|
|
|
|
fn map_java_version(version: &str, origin: PinOrigin) -> ToolchainResolution {
|
|
// Java version: 8, 11, 17, 21, 22 are common LTS/current.
|
|
let major = version.split('.').next().unwrap_or(version);
|
|
|
|
let (toolchain_id, drift) = match major.parse::<u32>() {
|
|
Ok(8) => ("java-8".to_owned(), false),
|
|
Ok(11) => ("java-11".to_owned(), false),
|
|
Ok(17) => ("java-17".to_owned(), false),
|
|
Ok(21) => ("java-21".to_owned(), false),
|
|
Ok(n) => (format!("java-{n}"), true),
|
|
_ => ("java-21".to_owned(), true),
|
|
};
|
|
|
|
ToolchainResolution {
|
|
toolchain_id,
|
|
pin_origin: origin,
|
|
toolchain_drift: drift,
|
|
version_string: version.to_owned(),
|
|
}
|
|
}
|
|
|
|
// ── PHP toolchain resolver ────────────────────────────────────────────────────
|
|
|
|
/// Resolve the PHP toolchain for `project_root`.
|
|
///
|
|
/// Reads pin files in priority order:
|
|
/// `composer.json` `require.php` > `.php-version` > default.
|
|
pub fn resolve_php(project_root: &Path) -> ToolchainResolution {
|
|
if let Some(r) = try_composer_json(project_root) {
|
|
return r;
|
|
}
|
|
if let Some(r) = try_php_version_file(project_root) {
|
|
return r;
|
|
}
|
|
default_php()
|
|
}
|
|
|
|
fn try_composer_json(root: &Path) -> Option<ToolchainResolution> {
|
|
let content = std::fs::read_to_string(root.join("composer.json")).ok()?;
|
|
// Look for "php": ">=8.1" under "require".
|
|
let mut in_require = false;
|
|
for line in content.lines() {
|
|
let trimmed = line.trim();
|
|
if json_line_has_key(trimmed, "require") {
|
|
in_require = true;
|
|
}
|
|
if in_require && trimmed.contains("\"php\"") {
|
|
if let Some(ver) = extract_version_from_json_value(trimmed) {
|
|
return Some(map_php_version(&ver, PinOrigin::ComposerJson));
|
|
}
|
|
}
|
|
// Stop at closing brace of require block.
|
|
if in_require && trimmed == "}," || (in_require && trimmed == "}") {
|
|
in_require = false;
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn try_php_version_file(root: &Path) -> Option<ToolchainResolution> {
|
|
let content = std::fs::read_to_string(root.join(".php-version")).ok()?;
|
|
let version = content.trim().to_owned();
|
|
if version.is_empty() {
|
|
return None;
|
|
}
|
|
Some(map_php_version(&version, PinOrigin::ComposerJson))
|
|
}
|
|
|
|
fn default_php() -> ToolchainResolution {
|
|
ToolchainResolution {
|
|
toolchain_id: "php-8".to_owned(),
|
|
pin_origin: PinOrigin::SystemDefault,
|
|
toolchain_drift: false,
|
|
version_string: "8".to_owned(),
|
|
}
|
|
}
|
|
|
|
fn map_php_version(version: &str, origin: PinOrigin) -> ToolchainResolution {
|
|
let ver = version.trim_start_matches(|c: char| !c.is_ascii_digit());
|
|
let parts: Vec<&str> = ver.splitn(3, '.').collect();
|
|
let major = parts.first().copied().unwrap_or("8");
|
|
let minor = parts.get(1).copied();
|
|
|
|
let (toolchain_id, drift) = match (major.parse::<u32>(), minor) {
|
|
(Ok(8), Some("0")) => ("php-8.0".to_owned(), false),
|
|
(Ok(8), Some("1")) => ("php-8.1".to_owned(), false),
|
|
(Ok(8), Some("2")) => ("php-8.2".to_owned(), false),
|
|
(Ok(8), Some("3")) => ("php-8.3".to_owned(), false),
|
|
(Ok(8), None) => ("php-8".to_owned(), false),
|
|
(Ok(7), _) => ("php-7".to_owned(), true),
|
|
(Ok(n), _) => (format!("php-{n}"), true),
|
|
_ => ("php-8".to_owned(), true),
|
|
};
|
|
|
|
ToolchainResolution {
|
|
toolchain_id,
|
|
pin_origin: origin,
|
|
toolchain_drift: drift,
|
|
version_string: version.to_owned(),
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use std::fs;
|
|
use tempfile::TempDir;
|
|
|
|
#[test]
|
|
fn python_version_file_exact() {
|
|
let dir = TempDir::new().unwrap();
|
|
fs::write(dir.path().join(".python-version"), "3.11.5\n").unwrap();
|
|
let r = resolve_python(dir.path());
|
|
assert_eq!(r.toolchain_id, "python-3.11");
|
|
assert!(!r.toolchain_drift);
|
|
assert_eq!(r.pin_origin, PinOrigin::PythonVersion);
|
|
}
|
|
|
|
#[test]
|
|
fn python_version_file_drift() {
|
|
let dir = TempDir::new().unwrap();
|
|
fs::write(dir.path().join(".python-version"), "3.7\n").unwrap();
|
|
let r = resolve_python(dir.path());
|
|
assert!(r.toolchain_drift);
|
|
}
|
|
|
|
#[test]
|
|
fn pyproject_requires_python() {
|
|
let dir = TempDir::new().unwrap();
|
|
fs::write(dir.path().join("pyproject.toml"), "[project]\nrequires-python = \">=3.11\"\n").unwrap();
|
|
let r = resolve_python(dir.path());
|
|
assert_eq!(r.toolchain_id, "python-3.11");
|
|
assert_eq!(r.pin_origin, PinOrigin::PyprojectToml);
|
|
}
|
|
|
|
#[test]
|
|
fn pipfile_python_version() {
|
|
let dir = TempDir::new().unwrap();
|
|
fs::write(dir.path().join("Pipfile"), "[requires]\npython_version = \"3.10\"\n").unwrap();
|
|
let r = resolve_python(dir.path());
|
|
assert_eq!(r.toolchain_id, "python-3.10");
|
|
assert_eq!(r.pin_origin, PinOrigin::Pipfile);
|
|
}
|
|
|
|
#[test]
|
|
fn fallback_to_system_default() {
|
|
let dir = TempDir::new().unwrap();
|
|
let r = resolve_python(dir.path());
|
|
assert_eq!(r.pin_origin, PinOrigin::SystemDefault);
|
|
}
|
|
|
|
// ── Rust toolchain tests ─────────────────────────────────────────────────
|
|
|
|
#[test]
|
|
fn rust_toolchain_toml_stable() {
|
|
let dir = TempDir::new().unwrap();
|
|
fs::write(
|
|
dir.path().join("rust-toolchain.toml"),
|
|
"[toolchain]\nchannel = \"stable\"\n",
|
|
).unwrap();
|
|
let r = resolve_rust(dir.path());
|
|
assert_eq!(r.toolchain_id, "rust-stable");
|
|
assert!(!r.toolchain_drift);
|
|
assert_eq!(r.pin_origin, PinOrigin::RustToolchainToml);
|
|
}
|
|
|
|
#[test]
|
|
fn rust_toolchain_file_nightly() {
|
|
let dir = TempDir::new().unwrap();
|
|
fs::write(dir.path().join("rust-toolchain"), "nightly\n").unwrap();
|
|
let r = resolve_rust(dir.path());
|
|
assert_eq!(r.toolchain_id, "rust-nightly");
|
|
assert!(r.toolchain_drift);
|
|
assert_eq!(r.pin_origin, PinOrigin::RustToolchainFile);
|
|
}
|
|
|
|
#[test]
|
|
fn cargo_toml_rust_version() {
|
|
let dir = TempDir::new().unwrap();
|
|
fs::write(
|
|
dir.path().join("Cargo.toml"),
|
|
"[package]\nname = \"foo\"\nrust-version = \"1.75\"\n",
|
|
).unwrap();
|
|
let r = resolve_rust(dir.path());
|
|
assert_eq!(r.pin_origin, PinOrigin::CargoToml);
|
|
assert!(r.toolchain_id.starts_with("rust-1"));
|
|
}
|
|
|
|
#[test]
|
|
fn rust_default_is_stable() {
|
|
let dir = TempDir::new().unwrap();
|
|
let r = resolve_rust(dir.path());
|
|
assert_eq!(r.toolchain_id, "rust-stable");
|
|
assert_eq!(r.pin_origin, PinOrigin::SystemDefault);
|
|
}
|
|
|
|
// ── Node.js resolver tests ────────────────────────────────────────────────
|
|
|
|
#[test]
|
|
fn node_nvmrc_exact() {
|
|
let dir = TempDir::new().unwrap();
|
|
fs::write(dir.path().join(".nvmrc"), "v20.5.0\n").unwrap();
|
|
let r = resolve_node(dir.path());
|
|
assert_eq!(r.toolchain_id, "node-20");
|
|
assert!(!r.toolchain_drift);
|
|
assert_eq!(r.pin_origin, PinOrigin::PackageJson);
|
|
}
|
|
|
|
#[test]
|
|
fn node_package_json_engines() {
|
|
let dir = TempDir::new().unwrap();
|
|
fs::write(
|
|
dir.path().join("package.json"),
|
|
r#"{"engines": {"node": ">=18.0.0"}}"#,
|
|
).unwrap();
|
|
let r = resolve_node(dir.path());
|
|
assert_eq!(r.toolchain_id, "node-18");
|
|
}
|
|
|
|
#[test]
|
|
fn node_default_is_20() {
|
|
let dir = TempDir::new().unwrap();
|
|
let r = resolve_node(dir.path());
|
|
assert_eq!(r.toolchain_id, "node-20");
|
|
assert_eq!(r.pin_origin, PinOrigin::SystemDefault);
|
|
}
|
|
|
|
// ── Go resolver tests ─────────────────────────────────────────────────────
|
|
|
|
#[test]
|
|
fn go_mod_version() {
|
|
let dir = TempDir::new().unwrap();
|
|
fs::write(dir.path().join("go.mod"), "module example.com/app\n\ngo 1.22\n").unwrap();
|
|
let r = resolve_go(dir.path());
|
|
assert_eq!(r.toolchain_id, "go-1.22");
|
|
assert!(!r.toolchain_drift);
|
|
assert_eq!(r.pin_origin, PinOrigin::GoMod);
|
|
}
|
|
|
|
#[test]
|
|
fn go_default_is_stable() {
|
|
let dir = TempDir::new().unwrap();
|
|
let r = resolve_go(dir.path());
|
|
assert_eq!(r.toolchain_id, "go-stable");
|
|
assert_eq!(r.pin_origin, PinOrigin::SystemDefault);
|
|
}
|
|
|
|
// ── Java resolver tests ───────────────────────────────────────────────────
|
|
|
|
#[test]
|
|
fn java_pom_xml_version() {
|
|
let dir = TempDir::new().unwrap();
|
|
fs::write(
|
|
dir.path().join("pom.xml"),
|
|
"<project>\n <properties>\n <java.version>21</java.version>\n </properties>\n</project>",
|
|
).unwrap();
|
|
let r = resolve_java(dir.path());
|
|
assert_eq!(r.toolchain_id, "java-21");
|
|
assert!(!r.toolchain_drift);
|
|
assert_eq!(r.pin_origin, PinOrigin::PomXml);
|
|
}
|
|
|
|
#[test]
|
|
fn java_build_gradle_source_compat() {
|
|
let dir = TempDir::new().unwrap();
|
|
fs::write(
|
|
dir.path().join("build.gradle"),
|
|
"sourceCompatibility = '17'\ntargetCompatibility = '17'\n",
|
|
).unwrap();
|
|
let r = resolve_java(dir.path());
|
|
assert_eq!(r.toolchain_id, "java-17");
|
|
assert_eq!(r.pin_origin, PinOrigin::BuildGradle);
|
|
}
|
|
|
|
#[test]
|
|
fn java_default_is_21() {
|
|
let dir = TempDir::new().unwrap();
|
|
let r = resolve_java(dir.path());
|
|
assert_eq!(r.toolchain_id, "java-21");
|
|
assert_eq!(r.pin_origin, PinOrigin::SystemDefault);
|
|
}
|
|
|
|
// ── PHP resolver tests ────────────────────────────────────────────────────
|
|
|
|
#[test]
|
|
fn php_composer_json_version() {
|
|
let dir = TempDir::new().unwrap();
|
|
fs::write(
|
|
dir.path().join("composer.json"),
|
|
r#"{"require": {"php": ">=8.1"}}"#,
|
|
).unwrap();
|
|
let r = resolve_php(dir.path());
|
|
assert_eq!(r.toolchain_id, "php-8.1");
|
|
assert_eq!(r.pin_origin, PinOrigin::ComposerJson);
|
|
}
|
|
|
|
#[test]
|
|
fn php_default_is_8() {
|
|
let dir = TempDir::new().unwrap();
|
|
let r = resolve_php(dir.path());
|
|
assert_eq!(r.toolchain_id, "php-8");
|
|
assert_eq!(r.pin_origin, PinOrigin::SystemDefault);
|
|
}
|
|
|
|
#[test]
|
|
fn php_composer_json_require_dev_before_require() {
|
|
// "require-dev" must not shadow the real "require" block even when it
|
|
// appears first. The tightened json_line_has_key check prevents false
|
|
// activation on the "require-dev" key.
|
|
let dir = TempDir::new().unwrap();
|
|
fs::write(
|
|
dir.path().join("composer.json"),
|
|
"{\n \"require-dev\": {\n \"php\": \"^7.0\"\n },\n \"require\": {\n \"php\": \">=8.1\"\n }\n}",
|
|
).unwrap();
|
|
let r = resolve_php(dir.path());
|
|
assert_eq!(r.toolchain_id, "php-8.1");
|
|
assert_eq!(r.pin_origin, PinOrigin::ComposerJson);
|
|
}
|
|
|
|
#[test]
|
|
fn php_composer_json_require_as_value_not_matched() {
|
|
// "require" appearing as a string value (not a key) must not activate
|
|
// in_require and cause a php constraint from an unrelated block to be
|
|
// returned. Without the json_line_has_key fix, a line like
|
|
// `"type": "require"` would set in_require=true, letting the "php"
|
|
// key inside require-dev be matched instead of falling through.
|
|
let dir = TempDir::new().unwrap();
|
|
fs::write(
|
|
dir.path().join("composer.json"),
|
|
"{\n \"extra\": {\"type\": \"require\"},\n \"require-dev\": {\n \"php\": \"^7.0\"\n }\n}",
|
|
).unwrap();
|
|
let r = resolve_php(dir.path());
|
|
// No real "require": key present — must fall back to system default.
|
|
assert_eq!(r.pin_origin, PinOrigin::SystemDefault);
|
|
}
|
|
|
|
// ── json_line_has_key unit tests ─────────────────────────────────────────
|
|
|
|
#[test]
|
|
fn json_line_has_key_matches_exact_key() {
|
|
assert!(json_line_has_key(r#" "require": {"#, "require"));
|
|
assert!(json_line_has_key(r#"{"require": {}}"#, "require"));
|
|
assert!(json_line_has_key(r#" "engines" : {"#, "engines"));
|
|
}
|
|
|
|
#[test]
|
|
fn json_line_has_key_rejects_key_in_value() {
|
|
assert!(!json_line_has_key(r#" "type": "require","#, "require"));
|
|
assert!(!json_line_has_key(r#" "desc": "engines config","#, "engines"));
|
|
}
|
|
|
|
#[test]
|
|
fn json_line_has_key_rejects_superstring_key() {
|
|
// "require-dev" does not contain "require" as a quoted key.
|
|
assert!(!json_line_has_key(r#" "require-dev": {"#, "require"));
|
|
}
|
|
}
|