observer_core/

cmake.rs

// SPDX-FileCopyrightText: 2026 Alexander R. Croft
// SPDX-License-Identifier: GPL-3.0-or-later

use crate::error::{ObserverError, ObserverResult};
use serde::{Deserialize, Serialize, Serializer};
use serde_json::{Map, Value};
use sha2::{Digest, Sha256};
use std::collections::BTreeMap;
use std::fs;
use std::path::{Path, PathBuf};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CmakeProductModel {
	pub k: String,
	pub v: String,
	pub source_root: String,
	pub build_root: String,
	pub cmake: CmakeMetadata,
	pub configurations: Vec<CmakeConfiguration>,
	pub configure_state: CmakeConfigureState,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CmakeMetadata {
	pub version: String,
	pub generator: CmakeGenerator,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CmakeGenerator {
	pub name: String,
	pub multi_config: bool,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CmakeConfiguration {
	pub configuration_id: String,
	pub targets: Vec<CmakeTarget>,
	pub install_entries: Vec<CmakeInstallEntry>,
	pub exports: Vec<CmakeExport>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CmakeTarget {
	pub target_name: String,
	pub target_kind: String,
	pub is_abstract: bool,
	pub source_directory: String,
	pub build_directory: String,
	pub artifact_paths: Vec<String>,
	pub dependency_refs: Vec<CmakeTargetRef>,
	pub install_destinations: Vec<String>,
	pub file_sets: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CmakeTargetRef {
	pub configuration_id: String,
	pub target_name: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CmakeInstallEntry {
	pub install_kind: String,
	pub destination: String,
	pub paths: Vec<String>,
	#[serde(default, skip_serializing_if = "Option::is_none")]
	pub component_name: Option<String>,
	#[serde(default, skip_serializing_if = "Option::is_none")]
	pub subject: Option<CmakeTargetRef>,
	#[serde(default, skip_serializing_if = "Vec::is_empty")]
	pub target_refs: Vec<CmakeTargetRef>,
	#[serde(default, skip_serializing_if = "Option::is_none")]
	pub export_name: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CmakeExport {
	pub export_name: String,
	pub target_refs: Vec<CmakeTargetRef>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CmakeConfigureState {
	pub status: String,
}

impl CmakeProductModel {
	pub fn parse(source: &str) -> ObserverResult<Self> {
		let model: Self = serde_json::from_str(source)
			.map_err(|error| ObserverError::Cmake(format!("cmake model parse error: {error}")))?;
		model.validate()?;
		Ok(model)
	}

	pub fn validate(&self) -> ObserverResult<()> {
		if self.k != "observer_cmake_product_model" {
			return Err(ObserverError::Cmake(format!(
				"expected `k` = `observer_cmake_product_model`, found `{}`",
				self.k
			)));
		}
		if self.v != "0" {
			return Err(ObserverError::Cmake(format!(
				"expected `v` = `0`, found `{}`",
				self.v
			)));
		}
		if self.source_root.trim().is_empty() {
			return Err(ObserverError::Cmake("source_root must be non-empty".to_owned()));
		}
		if self.build_root.trim().is_empty() {
			return Err(ObserverError::Cmake("build_root must be non-empty".to_owned()));
		}
		if self.cmake.version.trim().is_empty() {
			return Err(ObserverError::Cmake("cmake.version must be non-empty".to_owned()));
		}
		if self.cmake.generator.name.trim().is_empty() {
			return Err(ObserverError::Cmake(
				"cmake.generator.name must be non-empty".to_owned(),
			));
		}
		match self.configure_state.status.as_str() {
			"success" | "error" => {}
			other => {
				return Err(ObserverError::Cmake(format!(
					"configure_state.status must be `success` or `error`, found `{other}`"
				)));
			}
		}

		for configuration in &self.configurations {
			if configuration.configuration_id.trim().is_empty() {
				return Err(ObserverError::Cmake(
					"configuration_id must be non-empty".to_owned(),
				));
			}
			let mut target_names = BTreeMap::new();
			for target in &configuration.targets {
				if target.target_name.trim().is_empty() {
					return Err(ObserverError::Cmake("target_name must be non-empty".to_owned()));
				}
				if target.target_kind.trim().is_empty() {
					return Err(ObserverError::Cmake("target_kind must be non-empty".to_owned()));
				}
				if target.source_directory.trim().is_empty() {
					return Err(ObserverError::Cmake(
						"source_directory must be non-empty".to_owned(),
					));
				}
				if target.build_directory.trim().is_empty() {
					return Err(ObserverError::Cmake(
						"build_directory must be non-empty".to_owned(),
					));
				}
				if target_names
					.insert(target.target_name.clone(), ())
					.is_some()
				{
					return Err(ObserverError::Cmake(format!(
						"duplicate target_name `{}` within configuration `{}`",
						target.target_name, configuration.configuration_id
					)));
				}
			}
		}

		Ok(())
	}
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ProductStageCmakeModel {
	pub cwd: String,
	pub model: String,
	pub checks: Vec<CmakeModelCheck>,
}

impl ProductStageCmakeModel {
	pub fn validate(&self) -> ObserverResult<()> {
		validate_normalized_relative_path(&self.cwd, "runner.cwd", true)?;
		validate_normalized_relative_path(&self.model, "runner.model", false)?;
		if self.checks.is_empty() {
			return Err(ObserverError::ProductParse(
				"runner.checks must declare at least one check".to_owned(),
			));
		}
		let mut seen = BTreeMap::new();
		for check in &self.checks {
			check.validate()?;
			if seen.insert(check.check_id().to_owned(), ()).is_some() {
				return Err(ObserverError::ProductParse(format!(
					"duplicate check_id `{}`",
					check.check_id()
				)));
			}
		}
		Ok(())
	}
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "k", rename_all = "snake_case")]
pub enum CmakeModelCheck {
	TargetArtifactsExist {
		check_id: String,
		targets: Vec<CmakeTargetRef>,
	},
}

impl CmakeModelCheck {
	pub fn check_id(&self) -> &str {
		match self {
			Self::TargetArtifactsExist { check_id, .. } => check_id,
		}
	}

	pub fn kind(&self) -> &'static str {
		match self {
			Self::TargetArtifactsExist { .. } => "target_artifacts_exist",
		}
	}

	fn validate(&self) -> ObserverResult<()> {
		match self {
			Self::TargetArtifactsExist { check_id, targets } => {
				if check_id.trim().is_empty() {
					return Err(ObserverError::ProductParse(
						"check_id must be non-empty".to_owned(),
					));
				}
				if targets.is_empty() {
					return Err(ObserverError::ProductParse(format!(
						"check `{check_id}` must declare at least one target"
					)));
				}
				for target in targets {
					if target.configuration_id.trim().is_empty() || target.target_name.trim().is_empty() {
						return Err(ObserverError::ProductParse(format!(
							"check `{check_id}` contains an empty target reference"
						)));
					}
				}
			}
		}
		Ok(())
	}
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CmakeCheckStatus {
	Pass,
	Fail,
	ValidationFail,
	RunnerFail,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CmakeCheckFailClass {
	CertificationFailure,
	ValidationFailure,
	RunnerFailure,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CmakeModelReportHeader {
	pub k: String,
	pub v: String,
	pub model_sha256: String,
	#[serde(default, skip_serializing_if = "Option::is_none")]
	pub product_id: Option<String>,
	#[serde(default, skip_serializing_if = "Option::is_none")]
	pub stage_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CmakeCheckRecord {
	pub check_id: String,
	pub check_kind: String,
	pub status: CmakeCheckStatus,
	#[serde(default, skip_serializing_if = "Option::is_none")]
	pub ok: Option<Value>,
	#[serde(default, skip_serializing_if = "Option::is_none")]
	pub fail: Option<CmakeCheckFail>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CmakeCheckFail {
	pub class: CmakeCheckFailClass,
	pub msg: String,
	#[serde(default, skip_serializing_if = "Vec::is_empty")]
	pub missing_artifacts: Vec<CmakeMissingArtifact>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CmakeMissingArtifact {
	pub target: CmakeTargetRef,
	pub artifact_path: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CmakeSummaryRecord {
	pub check_pass: usize,
	pub check_fail: usize,
	pub check_validation_fail: usize,
	pub check_runner_fail: usize,
	pub status: String,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CmakeModelReportRecord {
	Header(CmakeModelReportHeader),
	Check(CmakeCheckRecord),
	Summary(CmakeSummaryRecord),
}

impl Serialize for CmakeModelReportRecord {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
		S: Serializer,
	{
		match self {
			Self::Header(header) => header.serialize(serializer),
			Self::Check(record) => TaggedRecord {
				k: "cmake_check",
				inner: record,
			}
			.serialize(serializer),
			Self::Summary(record) => TaggedRecord {
				k: "cmake_summary",
				inner: record,
			}
			.serialize(serializer),
		}
	}
}

#[derive(Serialize)]
struct TaggedRecord<'a, T> {
	k: &'static str,
	#[serde(flatten)]
	inner: &'a T,
}

pub struct CmakeEvaluationOutcome {
	pub records: Vec<CmakeModelReportRecord>,
	pub exit_code: i32,
	pub check_pass: usize,
	pub check_fail: usize,
	pub check_validation_fail: usize,
	pub check_runner_fail: usize,
}

pub fn lower_cmake_product_model(build_root: &Path, base_dir: &Path) -> ObserverResult<CmakeProductModel> {
	let build_root_abs = absolutize_path(build_root, base_dir);
	let reply_dir = build_root_abs.join(".cmake").join("api").join("v1").join("reply");
	let index_path = latest_index_path(&reply_dir)?;
	let index_source = fs::read_to_string(&index_path)
		.map_err(|error| ObserverError::Cmake(format!("failed to read {}: {error}", index_path.display())))?;
	let index: FileApiIndex = serde_json::from_str(&index_source)
		.map_err(|error| ObserverError::Cmake(format!("invalid File API reply index: {error}")))?;
	let codemodel_ref = index
		.objects
		.iter()
		.filter(|item| item.kind == "codemodel" && item.version.major == 2)
		.max_by_key(|item| item.version.minor)
		.ok_or_else(|| ObserverError::Cmake("File API reply contained no supported codemodel object".to_owned()))?;
	let codemodel_path = reply_dir.join(&codemodel_ref.json_file);
	let codemodel_source = fs::read_to_string(&codemodel_path)
		.map_err(|error| ObserverError::Cmake(format!("failed to read {}: {error}", codemodel_path.display())))?;
	let codemodel: Codemodel = serde_json::from_str(&codemodel_source)
		.map_err(|error| ObserverError::Cmake(format!("invalid codemodel reply: {error}")))?;

	let mut configurations = Vec::new();
	for configuration in &codemodel.configurations {
		let configuration_id = if configuration.name.trim().is_empty() {
			"__default__".to_owned()
		} else {
			configuration.name.clone()
		};

		let mut raw_targets = Vec::new();
		for target_ref in &configuration.targets {
			let target_path = codemodel_path
				.parent()
				.unwrap_or(reply_dir.as_path())
				.join(&target_ref.json_file);
			let target_source = fs::read_to_string(&target_path).map_err(|error| {
				ObserverError::Cmake(format!("failed to read {}: {error}", target_path.display()))
			})?;
			let target: CodemodelTarget = serde_json::from_str(&target_source)
				.map_err(|error| ObserverError::Cmake(format!("invalid target reply: {error}")))?;
			raw_targets.push(target);
		}

		let mut id_to_name = BTreeMap::new();
		for target in &raw_targets {
			id_to_name.insert(target.id.clone(), target.name.clone());
		}

		let mut targets = Vec::new();
		for target in raw_targets {
			let mut artifact_paths = target
				.artifacts
				.into_iter()
				.map(|item| item.path)
				.collect::<Vec<_>>();
			artifact_paths.sort_by(|left, right| left.as_bytes().cmp(right.as_bytes()));

			let mut dependency_refs = target
				.dependencies
				.unwrap_or_default()
				.into_iter()
				.filter_map(|dependency| {
					id_to_name.get(&dependency.id).map(|target_name| CmakeTargetRef {
						configuration_id: configuration_id.clone(),
						target_name: target_name.clone(),
					})
				})
				.collect::<Vec<_>>();
			dependency_refs.sort_by(target_ref_cmp);

			targets.push(CmakeTarget {
				target_name: target.name,
				target_kind: target.target_type,
				is_abstract: target.abstract_target.unwrap_or(false),
				source_directory: target.paths.source,
				build_directory: target.paths.build,
				artifact_paths,
				dependency_refs,
				install_destinations: Vec::new(),
				file_sets: Vec::new(),
			});
		}
		targets.sort_by(|left, right| left.target_name.as_bytes().cmp(right.target_name.as_bytes()));

		configurations.push(CmakeConfiguration {
			configuration_id,
			targets,
			install_entries: Vec::new(),
			exports: Vec::new(),
		});
	}

	let mut model = CmakeProductModel {
		k: "observer_cmake_product_model".to_owned(),
		v: "0".to_owned(),
		source_root: relativize_or_slash(Path::new(&codemodel.paths.source), base_dir),
		build_root: relativize_or_slash(&build_root_abs, base_dir),
		cmake: CmakeMetadata {
			version: index.cmake.version.string,
			generator: CmakeGenerator {
				name: index.cmake.generator.name,
				multi_config: index.cmake.generator.multi_config,
			},
		},
		configurations,
		configure_state: CmakeConfigureState {
			status: "success".to_owned(),
		},
	};
	model.validate()?;
	for configuration in &mut model.configurations {
		configuration.targets.sort_by(|left, right| left.target_name.as_bytes().cmp(right.target_name.as_bytes()));
	}
	Ok(model)
}

pub fn normalized_cmake_product_model_sha256(model: &CmakeProductModel) -> ObserverResult<String> {
	model.validate()?;
	let value = serde_json::to_value(model)
		.map_err(|error| ObserverError::Normalize(error.to_string()))?;
	let canonical = canonicalize_json(value);
	let bytes = serde_json::to_vec(&canonical)
		.map_err(|error| ObserverError::Normalize(error.to_string()))?;
	Ok(hash_hex(&bytes))
}

pub fn serialize_cmake_product_model_json(model: &CmakeProductModel) -> ObserverResult<String> {
	model.validate()?;
	let value = serde_json::to_value(model)
		.map_err(|error| ObserverError::Normalize(error.to_string()))?;
	let canonical = canonicalize_json(value);
	serde_json::to_string(&canonical).map_err(|error| ObserverError::Normalize(error.to_string()))
}

pub fn evaluate_cmake_model(
	model: &CmakeProductModel,
	model_root: &Path,
	checks: &[CmakeModelCheck],
	product_id: Option<&str>,
	stage_id: Option<&str>,
) -> ObserverResult<CmakeEvaluationOutcome> {
	model.validate()?;
	let model_sha256 = normalized_cmake_product_model_sha256(model)?;
	let mut records = Vec::new();
	records.push(CmakeModelReportRecord::Header(CmakeModelReportHeader {
		k: "observer_cmake_model_report".to_owned(),
		v: "0".to_owned(),
		model_sha256,
		product_id: product_id.map(ToOwned::to_owned),
		stage_id: stage_id.map(ToOwned::to_owned),
	}));

	let mut check_pass = 0usize;
	let mut check_fail = 0usize;
	let mut check_validation_fail = 0usize;
	let mut check_runner_fail = 0usize;

	if model.configure_state.status != "success" {
		for check in checks {
			check_runner_fail += 1;
			records.push(CmakeModelReportRecord::Check(CmakeCheckRecord {
				check_id: check.check_id().to_owned(),
				check_kind: check.kind().to_owned(),
				status: CmakeCheckStatus::RunnerFail,
				ok: None,
				fail: Some(CmakeCheckFail {
					class: CmakeCheckFailClass::RunnerFailure,
					msg: "configure_state.status was not `success`".to_owned(),
					missing_artifacts: Vec::new(),
				}),
			}));
		}
	} else {
		for check in checks {
			let record = match check {
				CmakeModelCheck::TargetArtifactsExist { check_id, targets } => {
					evaluate_target_artifacts_exist(model, model_root, check_id, targets)
				}
			};
			match record.status {
				CmakeCheckStatus::Pass => check_pass += 1,
				CmakeCheckStatus::Fail => check_fail += 1,
				CmakeCheckStatus::ValidationFail => check_validation_fail += 1,
				CmakeCheckStatus::RunnerFail => check_runner_fail += 1,
			}
			records.push(CmakeModelReportRecord::Check(record));
		}
	}

	records.push(CmakeModelReportRecord::Summary(CmakeSummaryRecord {
		check_pass,
		check_fail,
		check_validation_fail,
		check_runner_fail,
		status: if check_fail == 0 && check_validation_fail == 0 && check_runner_fail == 0 {
			"pass".to_owned()
		} else {
			"fail".to_owned()
		},
	}));

	let exit_code = if check_runner_fail > 0 {
		2
	} else if check_fail > 0 || check_validation_fail > 0 {
		1
	} else {
		0
	};

	Ok(CmakeEvaluationOutcome {
		records,
		exit_code,
		check_pass,
		check_fail,
		check_validation_fail,
		check_runner_fail,
	})
}

fn evaluate_target_artifacts_exist(
	model: &CmakeProductModel,
	model_root: &Path,
	check_id: &str,
	targets: &[CmakeTargetRef],
) -> CmakeCheckRecord {
	let build_root = resolve_model_path(model_root, &model.build_root);
	let mut checked_targets = Vec::new();
	let mut missing_artifacts = Vec::new();

	for target_ref in targets {
		let Some(target) = find_target(model, target_ref) else {
			return CmakeCheckRecord {
				check_id: check_id.to_owned(),
				check_kind: "target_artifacts_exist".to_owned(),
				status: CmakeCheckStatus::ValidationFail,
				ok: None,
				fail: Some(CmakeCheckFail {
					class: CmakeCheckFailClass::ValidationFailure,
					msg: format!(
						"target reference `{}` / `{}` did not resolve",
						target_ref.configuration_id, target_ref.target_name
					),
					missing_artifacts: Vec::new(),
				}),
			};
		};
		if target.is_abstract {
			return CmakeCheckRecord {
				check_id: check_id.to_owned(),
				check_kind: "target_artifacts_exist".to_owned(),
				status: CmakeCheckStatus::ValidationFail,
				ok: None,
				fail: Some(CmakeCheckFail {
					class: CmakeCheckFailClass::ValidationFailure,
					msg: format!(
						"target `{}` / `{}` is abstract",
						target_ref.configuration_id, target_ref.target_name
					),
					missing_artifacts: Vec::new(),
				}),
			};
		}
		if target.artifact_paths.is_empty() {
			return CmakeCheckRecord {
				check_id: check_id.to_owned(),
				check_kind: "target_artifacts_exist".to_owned(),
				status: CmakeCheckStatus::ValidationFail,
				ok: None,
				fail: Some(CmakeCheckFail {
					class: CmakeCheckFailClass::ValidationFailure,
					msg: format!(
						"target `{}` / `{}` declared no artifact paths",
						target_ref.configuration_id, target_ref.target_name
					),
					missing_artifacts: Vec::new(),
				}),
			};
		}
		checked_targets.push(target_ref.clone());
		for artifact_path in &target.artifact_paths {
			let artifact_abs = if Path::new(artifact_path).is_absolute() {
				PathBuf::from(artifact_path)
			} else {
				build_root.join(artifact_path)
			};
			if !artifact_abs.exists() {
				missing_artifacts.push(CmakeMissingArtifact {
					target: target_ref.clone(),
					artifact_path: artifact_path.clone(),
				});
			}
		}
	}

	if missing_artifacts.is_empty() {
		CmakeCheckRecord {
			check_id: check_id.to_owned(),
			check_kind: "target_artifacts_exist".to_owned(),
			status: CmakeCheckStatus::Pass,
			ok: Some(serde_json::json!({ "checked_targets": checked_targets })),
			fail: None,
		}
	} else {
		CmakeCheckRecord {
			check_id: check_id.to_owned(),
			check_kind: "target_artifacts_exist".to_owned(),
			status: CmakeCheckStatus::Fail,
			ok: None,
			fail: Some(CmakeCheckFail {
				class: CmakeCheckFailClass::CertificationFailure,
				msg: "one or more declared target artifacts did not exist on disk".to_owned(),
				missing_artifacts,
			}),
		}
	}
}

fn find_target<'a>(model: &'a CmakeProductModel, target_ref: &CmakeTargetRef) -> Option<&'a CmakeTarget> {
	model
		.configurations
		.iter()
		.find(|configuration| configuration.configuration_id == target_ref.configuration_id)
		.and_then(|configuration| {
			configuration
				.targets
				.iter()
				.find(|target| target.target_name == target_ref.target_name)
		})
}

fn resolve_model_path(model_root: &Path, path: &str) -> PathBuf {
	let path = Path::new(path);
	if path.is_absolute() {
		path.to_path_buf()
	} else {
		model_root.join(path)
	}
}

fn validate_normalized_relative_path(path: &str, field: &str, allow_dot: bool) -> ObserverResult<()> {
	if path.is_empty() {
		return Err(ObserverError::ProductParse(format!("{field} must be non-empty")));
	}
	if allow_dot && path == "." {
		return Ok(());
	}
	if path.starts_with('/') || path.starts_with('~') || path.contains('\\') {
		return Err(ObserverError::ProductParse(format!(
			"{field} must be a normalized relative path"
		)));
	}
	for segment in path.split('/') {
		if segment.is_empty() || segment == "." || segment == ".." {
			return Err(ObserverError::ProductParse(format!(
				"{field} must be a normalized relative path"
			)));
		}
	}
	Ok(())
}

fn latest_index_path(reply_dir: &Path) -> ObserverResult<PathBuf> {
	let entries = fs::read_dir(reply_dir).map_err(|error| {
		ObserverError::Cmake(format!("failed to read File API reply dir {}: {error}", reply_dir.display()))
	})?;
	let mut best: Option<String> = None;
	for entry in entries {
		let entry = entry.map_err(|error| ObserverError::Cmake(format!("failed to read reply entry: {error}")))?;
		let file_name = entry.file_name();
		let file_name = file_name.to_string_lossy();
		if !file_name.starts_with("index-") || !file_name.ends_with(".json") {
			continue;
		}
		if best.as_ref().map_or(true, |current| file_name.as_ref() > current.as_str()) {
			best = Some(file_name.into_owned());
		}
	}
	let Some(file_name) = best else {
		return Err(ObserverError::Cmake(format!(
			"no File API reply index found under {}",
			reply_dir.display()
		)));
	};
	Ok(reply_dir.join(file_name))
}

fn absolutize_path(path: &Path, base_dir: &Path) -> PathBuf {
	if path.is_absolute() {
		path.to_path_buf()
	} else {
		base_dir.join(path)
	}
}

fn relativize_or_slash(path: &Path, base_dir: &Path) -> String {
	if let Ok(relative) = path.strip_prefix(base_dir) {
		if relative.as_os_str().is_empty() {
			".".to_owned()
		} else {
			path_to_slash(relative)
		}
	} else {
		path_to_slash(path)
	}
}

fn path_to_slash(path: &Path) -> String {
	path.components()
		.map(|component| component.as_os_str().to_string_lossy().into_owned())
		.collect::<Vec<_>>()
		.join("/")
}

fn target_ref_cmp(left: &CmakeTargetRef, right: &CmakeTargetRef) -> std::cmp::Ordering {
	left
		.configuration_id
		.as_bytes()
		.cmp(right.configuration_id.as_bytes())
		.then_with(|| left.target_name.as_bytes().cmp(right.target_name.as_bytes()))
}

fn hash_hex(bytes: &[u8]) -> String {
	let digest = Sha256::digest(bytes);
	format!("{digest:x}")
}

fn canonicalize_json(value: Value) -> Value {
	match value {
		Value::Object(object) => {
			let mut ordered = Map::new();
			let mut entries = object.into_iter().collect::<Vec<_>>();
			entries.sort_by(|left, right| left.0.as_bytes().cmp(right.0.as_bytes()));
			for (key, value) in entries {
				ordered.insert(key, canonicalize_json(value));
			}
			Value::Object(ordered)
		}
		Value::Array(items) => Value::Array(items.into_iter().map(canonicalize_json).collect()),
		other => other,
	}
}

#[derive(Debug, Deserialize)]
struct FileApiIndex {
	cmake: FileApiCmake,
	objects: Vec<FileApiReplyRef>,
}

#[derive(Debug, Deserialize)]
struct FileApiCmake {
	version: FileApiVersionInfo,
	generator: FileApiGeneratorInfo,
}

#[derive(Debug, Deserialize)]
struct FileApiVersionInfo {
	string: String,
}

#[derive(Debug, Deserialize)]
struct FileApiGeneratorInfo {
	name: String,
	#[serde(rename = "multiConfig")]
	multi_config: bool,
}

#[derive(Debug, Deserialize)]
struct FileApiReplyRef {
	kind: String,
	version: FileApiObjectVersion,
	#[serde(rename = "jsonFile")]
	json_file: String,
}

#[derive(Debug, Deserialize)]
struct FileApiObjectVersion {
	major: u32,
	minor: u32,
}

#[derive(Debug, Deserialize)]
struct Codemodel {
	paths: CodemodelPaths,
	configurations: Vec<CodemodelConfiguration>,
}

#[derive(Debug, Deserialize)]
struct CodemodelPaths {
	source: String,
	#[allow(dead_code)]
	build: String,
}

#[derive(Debug, Deserialize)]
struct CodemodelConfiguration {
	name: String,
	#[serde(default)]
	targets: Vec<CodemodelTargetRef>,
}

#[derive(Debug, Deserialize)]
struct CodemodelTargetRef {
	#[serde(rename = "jsonFile")]
	json_file: String,
}

#[derive(Debug, Deserialize)]
struct CodemodelTarget {
	name: String,
	id: String,
	#[serde(rename = "type")]
	target_type: String,
	#[serde(default, rename = "abstract")]
	abstract_target: Option<bool>,
	paths: CodemodelTargetPaths,
	#[serde(default)]
	artifacts: Vec<CodemodelArtifact>,
	#[serde(default)]
	dependencies: Option<Vec<CodemodelDependency>>,
}

#[derive(Debug, Deserialize)]
struct CodemodelTargetPaths {
	source: String,
	build: String,
}

#[derive(Debug, Deserialize)]
struct CodemodelArtifact {
	path: String,
}

#[derive(Debug, Deserialize)]
struct CodemodelDependency {
	id: String,
}