use super::COVERAGE_SCALE;
use std::path::Path;
use std::process::Command;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Toolchain {
Cargo,
SwiftPm,
}
#[must_use]
pub fn toolchain_of(root: &Path) -> Toolchain {
if root.join("Package.swift").is_file() && !root.join("Cargo.toml").exists()
{
return Toolchain::SwiftPm;
}
Toolchain::Cargo
}
#[must_use]
pub fn swift_bin() -> String {
std::env::var("SHERD_SWIFT").unwrap_or_else(|_| "swift".into())
}
#[must_use]
pub fn swift_coverage(root: &Path, swift: &str) -> Option<usize> {
super::swift_measure(root, swift).ok().map(|m| m.lines)
}
pub(super) fn swift_run(root: &Path, swift: &str) -> Option<String> {
let run = |args: &[&str]| {
let o = Command::new(swift)
.args(args)
.current_dir(root)
.output()
.ok()?;
o.status.success().then_some(o.stdout)
};
run(&["test", "--enable-code-coverage"])?;
let shown = run(&["test", "--show-codecov-path"])?;
let shown = String::from_utf8_lossy(&shown);
let path = shown.lines().map(str::trim).rfind(|l| !l.is_empty())?;
std::fs::read_to_string(root.join(path)).ok()
}
#[must_use]
pub fn excluded_files(root: &Path) -> Vec<String> {
super::exclusions(root)
.into_iter()
.filter(|e| e.function.is_none())
.map(|e| e.path)
.collect()
}
#[must_use]
pub fn llvm_cov_lines(json: &str, root: &Path) -> Option<usize> {
llvm_cov_lines_except(json, root, &[])
}
#[must_use]
pub fn llvm_cov_lines_except(
json: &str,
root: &Path,
excluded: &[String],
) -> Option<usize> {
let rows: Vec<super::Exclusion> = excluded
.iter()
.map(|p| super::Exclusion {
path: p.clone(),
function: None,
})
.collect();
let never = |_: &[String]| None;
super::measure_export(json, root, &rows, &never)
.ok()
.map(|m| m.lines)
}
pub(super) fn hundredths(covered: usize, count: usize) -> Option<usize> {
let scale = COVERAGE_SCALE.checked_mul(COVERAGE_SCALE)?;
let twice = covered.checked_mul(scale)?.checked_mul(2)?;
twice.checked_add(count)?.checked_div(count.checked_mul(2)?)
}
pub(super) fn is_source(
file: &Path,
roots: &[Option<std::path::PathBuf>],
) -> bool {
let sources = Path::new("Sources");
if file.is_relative() {
return file.starts_with(sources);
}
roots.iter().flatten().any(|r| {
file.strip_prefix(r)
.is_ok_and(|rel| rel.starts_with(sources))
})
}
pub(super) fn string_of(v: &str) -> Option<(String, &str)> {
let body = v.trim_start().strip_prefix('"')?;
let mut out = String::new();
let mut chars = body.char_indices();
while let Some((i, c)) = chars.next() {
match c {
'"' => return Some((out, body.get(i.checked_add(1)?..)?)),
'\\' => out.push(chars.next()?.1),
_ => out.push(c),
}
}
None
}
pub(super) fn after_key<'a>(json: &'a str, key: &str) -> Option<&'a str> {
let quoted = format!("\"{key}\"");
let at = json.find("ed)?.checked_add(quoted.len())?;
json.get(at..)?.trim_start().strip_prefix(':')
}
pub(super) fn number_of(object: &str, key: &str) -> Option<usize> {
let v = after_key(object, key)?.trim_start();
let end = v.find(|c: char| !c.is_ascii_digit()).unwrap_or(v.len());
v.get(..end)?.parse().ok()
}
#[cfg(test)]
#[path = "tests/swift.rs"]
pub(crate) mod swift_tests;