use crate::config::AdapterInfer;
use crate::{config, filter, io, trim};
pub(crate) fn operation_line(in_fmt: io::Format, out_fmt: io::Format) -> String {
if in_fmt.family() == out_fmt.family() {
format!("Trimming {}", in_fmt.family())
} else {
format!("Converting {} to {}", in_fmt.label(), out_fmt.label())
}
}
pub(crate) fn output_banner_line(
output: Option<&std::path::Path>,
out_fmt: io::Format,
level: u8,
) -> String {
let Some(path) = output else {
return "Output: <stdout>".to_string();
};
let mut line = format!("Output: {}", path.display());
match out_fmt {
io::Format::Bam | io::Format::FastqGz | io::Format::FastqBgzf => {
line.push_str(&format!(" (bgzf level {level})"));
},
io::Format::Fastq => {},
}
line
}
pub(crate) fn threads_banner_line(threads: usize, b: config::ThreadBudget) -> String {
if threads <= 1 {
return "Threads: 1 (sequential)".to_string();
}
format!(
"Threads: {threads} (trim and compress {}, decode {})",
b.render, b.decode
)
}
pub(crate) fn filters_and_trim_line(
filter: &filter::FilterConfig,
trim: &trim::TrimPlan,
) -> String {
let mut filters = Vec::new();
let length_active = filter.min_length > 1 || filter.max_length != usize::MAX;
if length_active {
let mut length = String::new();
if filter.min_length > 1 {
length.push_str(&format!(">={}", filter.min_length));
}
if filter.max_length != usize::MAX {
if !length.is_empty() {
length.push(' ');
}
length.push_str(&format!("<={}", filter.max_length));
}
filters.push(format!("length {length}"));
}
let qual_active = filter.min_qual > 0.0 || filter.max_qual < 1000.0;
if qual_active {
let mut quality = format!("{} quality", filter.qual_mode.label());
if filter.min_qual > 0.0 {
quality.push_str(&format!(" >={}", filter.min_qual));
}
if filter.max_qual < 1000.0 {
quality.push_str(&format!(" <={}", filter.max_qual));
}
filters.push(quality);
}
if let Some(max) = filter.max_expected_errors {
filters.push(format!("expected errors <={max}"));
}
if filter.min_gc.is_some() || filter.max_gc.is_some() {
filters.push(format!(
"GC {}-{}",
filter.min_gc.unwrap_or(0.0),
filter.max_gc.unwrap_or(1.0)
));
}
let filters_str = if filters.is_empty() {
"none".to_string()
} else {
filters.join("; ")
};
let mut trim_parts = Vec::new();
if trim.head > 0 || trim.tail > 0 {
trim_parts.push(format!("head {}, tail {}", trim.head, trim.tail));
}
if let Some(op) = &trim.quality {
let mut part = format!("quality {} Q{}", op.method.label(), op.cutoff);
if op.method == trim::QualityMethod::Runs {
part.push_str(&format!(" run {}", op.min_low_quality_run));
}
if op.end_cutoff > op.cutoff {
part.push_str(&format!(" ends Q{}", op.end_cutoff));
}
trim_parts.push(part);
}
let trim_str = if trim_parts.is_empty() {
"none".to_string()
} else {
trim_parts.join(", ")
};
format!("Filters: {filters_str}; trim: {trim_str}")
}
pub(crate) fn adapter_banner_line(
adapters: Option<&crate::adapter::AdapterConfig>,
adapter_sample: usize,
adapter_infer: AdapterInfer,
) -> Option<String> {
let a = adapters?;
let mode = if a.split { "trim + split" } else { "ends-only" };
let sample = if adapter_sample > 0 {
format!("sample {adapter_sample}")
} else {
"sample off".to_string()
};
let infer_suffix = match adapter_infer {
AdapterInfer::Off => String::new(),
mode => format!(" \u{b7} {}", mode.label()),
};
let (n_adapters, roles) = (a.adapters.len(), role_breakdown(&a.adapters));
Some(format!(
"Adapters: {n_adapters} sequences{roles} · {mode} · error {:.2} · end-zone {} bp · {sample}{infer_suffix}",
a.error_rate, a.end_size
))
}
fn role_breakdown(adapters: &[crate::adapter::Adapter]) -> String {
use crate::adapter::Role;
let counts: Vec<(Role, usize)> = [Role::Adapter, Role::Primer, Role::Barcode]
.into_iter()
.map(|role| (role, adapters.iter().filter(|a| a.role == role).count()))
.filter(|(_, n)| *n > 0)
.collect();
if counts.len() < 2 {
return String::new();
}
let parts: Vec<String> = counts
.iter()
.map(|(role, n)| format!("{n} {}", role.label()))
.collect();
format!(" ({})", parts.join(", "))
}
pub(crate) fn shell_quote(arg: &str) -> String {
let is_safe = |c: char| c.is_ascii_alphanumeric() || "_@%+=:,./-".contains(c);
if !arg.is_empty() && arg.chars().all(is_safe) {
arg.to_string()
} else {
format!("'{}'", arg.replace('\'', r"'\''"))
}
}
pub fn command_line<I, S>(args: I) -> String
where
I: IntoIterator<Item = S>,
S: AsRef<std::ffi::OsStr>,
{
args.into_iter()
.map(|a| shell_quote(&a.as_ref().to_string_lossy()))
.collect::<Vec<_>>()
.join(" ")
}
pub(crate) fn output_desc(output: Option<&std::path::Path>) -> String {
match output {
Some(p) => p.display().to_string(),
None => "<stdout>".to_string(),
}
}
#[cfg(test)]
mod tests {
use super::*;
fn base_filter() -> filter::FilterConfig {
filter::FilterConfig {
min_length: 1,
max_length: usize::MAX,
min_qual: 0.0,
max_qual: 1000.0,
max_expected_errors: None,
min_gc: None,
max_gc: None,
qual_mode: crate::qual::QualMode::Mean,
}
}
fn base_trim() -> trim::TrimPlan {
trim::TrimPlan {
head: 0,
tail: 0,
quality: None,
}
}
use crate::adapter::{Adapter, AdapterConfig, Role};
#[test]
fn operation_line_collapses_matching_families() {
assert_eq!(
operation_line(io::Format::Fastq, io::Format::Fastq),
"Trimming FASTQ"
);
assert_eq!(
operation_line(io::Format::Fastq, io::Format::FastqGz),
"Trimming FASTQ"
);
}
#[test]
fn operation_line_converting_wording_for_cross_family() {
assert_eq!(
operation_line(io::Format::Bam, io::Format::Fastq),
"Converting BAM to FASTQ"
);
}
#[test]
fn output_banner_line_plain_fastq_has_no_suffix() {
let p = std::path::Path::new("/tmp/out.fastq");
assert_eq!(
output_banner_line(Some(p), io::Format::Fastq, 6),
"Output: /tmp/out.fastq"
);
}
#[test]
fn output_banner_line_appends_compression_detail() {
let p = std::path::Path::new("/tmp/out.fastq.gz");
assert_eq!(
output_banner_line(Some(p), io::Format::FastqGz, 6),
"Output: /tmp/out.fastq.gz (bgzf level 6)"
);
let p = std::path::Path::new("/tmp/out.bam");
assert_eq!(
output_banner_line(Some(p), io::Format::Bam, 3),
"Output: /tmp/out.bam (bgzf level 3)"
);
}
#[test]
fn output_banner_line_stdout_has_no_compression_detail() {
assert_eq!(
output_banner_line(None, io::Format::Bam, 6),
"Output: <stdout>"
);
}
#[test]
fn threads_banner_line_names_the_pool_and_the_decoders() {
let b = config::thread_budget(8, config::Decode::Blocks);
assert_eq!(
threads_banner_line(8, b),
"Threads: 8 (trim and compress 6, decode 2)"
);
let b = config::thread_budget(1, config::Decode::Blocks);
assert_eq!(threads_banner_line(1, b), "Threads: 1 (sequential)");
}
#[test]
fn filters_and_trim_line_defaults() {
assert_eq!(
filters_and_trim_line(&base_filter(), &base_trim()),
"Filters: none; trim: none"
);
}
#[test]
fn filters_and_trim_line_only_min_length_active() {
let mut f = base_filter();
f.min_length = 500;
assert_eq!(
filters_and_trim_line(&f, &base_trim()),
"Filters: length >=500; trim: none"
);
}
#[test]
fn filters_and_trim_line_only_max_length_active() {
let mut f = base_filter();
f.max_length = 10_000;
assert_eq!(
filters_and_trim_line(&f, &base_trim()),
"Filters: length <=10000; trim: none"
);
}
#[test]
fn filters_and_trim_line_only_min_qual_active() {
let mut f = base_filter();
f.min_qual = 10.0;
assert_eq!(
filters_and_trim_line(&f, &base_trim()),
"Filters: mean quality >=10; trim: none"
);
}
#[test]
fn filters_and_trim_line_only_max_qual_active() {
let mut f = base_filter();
f.max_qual = 40.0;
assert_eq!(
filters_and_trim_line(&f, &base_trim()),
"Filters: mean quality <=40; trim: none"
);
}
#[test]
fn filters_and_trim_line_only_gc_active() {
let mut f = base_filter();
f.min_gc = Some(0.3);
assert_eq!(
filters_and_trim_line(&f, &base_trim()),
"Filters: GC 0.3-1; trim: none"
);
}
#[test]
fn filters_and_trim_line_only_trim_active() {
let mut t = base_trim();
t.head = 5;
assert_eq!(
filters_and_trim_line(&base_filter(), &t),
"Filters: none; trim: head 5, tail 0"
);
}
#[test]
fn filters_and_trim_line_quality_ops() {
let f = base_filter();
let mut t = base_trim();
t.quality = Some(trim::QualityOp::new(trim::QualityMethod::Best, 20));
assert!(filters_and_trim_line(&f, &t).ends_with("trim: quality best Q20"));
t.quality = Some(trim::QualityOp::new(trim::QualityMethod::Segments, 10));
assert!(filters_and_trim_line(&f, &t).ends_with("trim: quality segments Q10"));
t.quality = Some(trim::QualityOp::runs(15, 50));
assert!(filters_and_trim_line(&f, &t).ends_with("trim: quality runs Q15 run 50"));
t.quality = Some(trim::QualityOp {
end_cutoff: 20,
..trim::QualityOp::new(trim::QualityMethod::Segments, 10)
});
assert!(filters_and_trim_line(&f, &t).ends_with("trim: quality segments Q10 ends Q20"));
t.quality = None;
t.head = 3;
t.tail = 0;
assert!(filters_and_trim_line(&f, &t).ends_with("trim: head 3, tail 0"));
}
#[test]
fn filters_and_trim_line_all_bounds_set() {
let mut f = base_filter();
f.min_length = 200;
f.max_length = 10_000;
f.min_qual = 8.0;
f.max_qual = 30.0;
f.min_gc = Some(0.4);
f.max_gc = Some(0.6);
f.max_expected_errors = Some(2.5);
f.qual_mode = crate::qual::QualMode::Median;
let mut t = base_trim();
t.head = 10;
t.tail = 5;
t.quality = Some(trim::QualityOp::new(trim::QualityMethod::Ends, 12));
assert_eq!(
filters_and_trim_line(&f, &t),
"Filters: length >=200 <=10000; median quality >=8 <=30; expected errors <=2.5; \
GC 0.4-0.6; \
trim: head 10, tail 5, quality ends Q12"
);
}
#[test]
fn adapter_banner_line_none_when_off_and_describes_when_on() {
assert!(adapter_banner_line(None, 10000, AdapterInfer::Off).is_none());
let cfg = AdapterConfig {
adapters: vec![Adapter {
name: "a".into(),
seq: b"ACGTACGTACGT".to_vec(),
role: Role::Adapter,
}],
error_rate: 0.2,
end_size: 150,
split: true,
min_piece: 1,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
};
let line = adapter_banner_line(Some(&cfg), 10000, AdapterInfer::Off).unwrap();
assert!(line.contains("1 sequences"));
assert!(line.contains("trim + split"));
assert!(line.contains("error 0.20"));
assert!(line.contains("end-zone 150 bp"));
assert!(line.contains("sample 10000"));
assert!(!line.contains("infer"), "No infer suffix when off: {line}");
let off_line = adapter_banner_line(Some(&cfg), 0, AdapterInfer::Off).unwrap();
assert!(off_line.contains("sample off"));
}
#[test]
fn adapter_banner_line_ends_only_when_split_disabled() {
let cfg = AdapterConfig {
adapters: vec![Adapter {
name: "a".into(),
seq: b"ACGTACGTACGT".to_vec(),
role: Role::Adapter,
}],
error_rate: 0.2,
end_size: 150,
split: false,
min_piece: 1,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
};
assert!(
adapter_banner_line(Some(&cfg), 10000, AdapterInfer::Off)
.unwrap()
.contains("ends-only")
);
}
#[test]
fn adapter_banner_line_notes_infer_mode() {
let cfg = AdapterConfig {
adapters: vec![],
error_rate: 0.2,
end_size: 150,
split: true,
min_piece: 1,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
};
let trim_line = adapter_banner_line(Some(&cfg), 40000, AdapterInfer::Discover).unwrap();
assert!(trim_line.ends_with("\u{b7} discover"), "{trim_line}");
let report_line = adapter_banner_line(Some(&cfg), 40000, AdapterInfer::Report).unwrap();
assert!(report_line.ends_with("\u{b7} report"), "{report_line}");
}
#[test]
fn command_line_quotes_only_unsafe_args() {
assert_eq!(
command_line(["whittle", "-i", "in.fastq", "-o", "out.fastq"]),
"whittle -i in.fastq -o out.fastq"
);
assert_eq!(
command_line(["whittle", "-i", "my reads.fastq"]),
"whittle -i 'my reads.fastq'"
);
}
#[test]
fn shell_quote_leaves_plain_args_bare() {
assert_eq!(shell_quote("whittle"), "whittle");
assert_eq!(shell_quote("-i"), "-i");
assert_eq!(shell_quote("in.fastq"), "in.fastq");
assert_eq!(
shell_quote("path/to/file_1.0.fq.gz"),
"path/to/file_1.0.fq.gz"
);
}
#[test]
fn shell_quote_wraps_args_with_spaces() {
assert_eq!(shell_quote("my reads.fastq"), "'my reads.fastq'");
}
#[test]
fn shell_quote_escapes_embedded_single_quotes() {
assert_eq!(shell_quote("it's here.fastq"), r"'it'\''s here.fastq'");
}
#[test]
fn shell_quote_wraps_shell_metacharacters() {
assert_eq!(shell_quote("$HOME"), "'$HOME'");
assert_eq!(shell_quote("a;b"), "'a;b'");
}
#[test]
fn shell_quote_wraps_empty_string() {
assert_eq!(shell_quote(""), "''");
}
#[test]
fn output_desc_stdout_vs_path() {
assert_eq!(output_desc(None), "<stdout>");
assert_eq!(
output_desc(Some(std::path::Path::new("/tmp/out.fastq"))),
"/tmp/out.fastq"
);
}
}