use std::path::PathBuf;
use clap::Parser;
use crate::config::{
AdapterInfer, Advisory, Config, FastqTags, IoConfig, ProgressMode, TagRemoval,
};
use crate::filter::FilterConfig;
use crate::io::Format;
use crate::qual::QualMode;
use crate::trim::{QualityMethod, QualityOp, TrimPlan};
#[derive(Parser, Debug)]
#[command(
author,
version,
disable_version_flag = true,
about = "Coordinate-consistent trimming of long-read uBAM and tagged FASTQ",
long_about = None,
max_term_width = 100,
after_help = EXAMPLES
)]
struct Cli {
#[arg(long, action = clap::ArgAction::Version, help_heading = "Setup")]
version: Option<bool>,
#[arg(short = 'i', long, value_name = "PATH", help_heading = "Setup")]
input: Option<PathBuf>,
#[arg(short = 'o', long, value_name = "PATH", help_heading = "Setup")]
output: Option<PathBuf>,
#[arg(
long = "input-format",
value_enum,
value_name = "FORMAT",
help_heading = "Setup"
)]
in_format: Option<Format>,
#[arg(
long = "output-format",
value_enum,
value_name = "FORMAT",
help_heading = "Setup"
)]
out_format: Option<Format>,
#[arg(
short = 't',
long,
value_name = "N",
value_parser = parse_threads,
help_heading = "Setup"
)]
threads: Option<u64>,
#[arg(long = "preserve-order", help_heading = "Setup")]
ordered: bool,
#[arg(
long,
default_value = "all",
value_name = "all|none|TAGS",
help_heading = "Tags"
)]
fastq_tags: String,
#[arg(
short = 'c',
long,
value_name = "0-9",
value_parser = clap::value_parser!(u8).range(0..=9),
help_heading = "Setup"
)]
compression_level: Option<u8>,
#[arg(long, value_name = "PATH", help_heading = "Setup")]
summary_json: Option<PathBuf>,
#[arg(long = "rejected-output", value_name = "PATH", help_heading = "Setup")]
rejected_output: Option<PathBuf>,
#[arg(short = 'v', long, action = clap::ArgAction::Count, help_heading = "Logging")]
verbose: u8,
#[arg(long, conflicts_with = "verbose", help_heading = "Logging")]
quiet: bool,
#[arg(
long,
value_enum,
value_name = "MODE",
default_value_t = ProgressMode::Auto,
conflicts_with = "quiet",
help_heading = "Logging"
)]
progress: ProgressMode,
#[arg(
short = 'l',
long,
value_name = "BASES",
default_value_t = 1,
help_heading = "Filtering"
)]
min_length: usize,
#[arg(short = 'L', long, value_name = "BASES", help_heading = "Filtering")]
max_length: Option<usize>,
#[arg(
short = 'q',
long = "min-quality",
value_name = "PHRED",
default_value_t = 0.0,
help_heading = "Filtering"
)]
min_qual: f64,
#[arg(
short = 'Q',
long = "max-quality",
value_name = "PHRED",
default_value_t = 1000.0,
help_heading = "Filtering"
)]
max_qual: f64,
#[arg(
long = "max-expected-errors",
value_name = "E",
help_heading = "Filtering"
)]
max_expected_errors: Option<f64>,
#[arg(short = 'g', long, value_name = "FRACTION", help_heading = "Filtering")]
min_gc: Option<f64>,
#[arg(long = "tag-filter", value_name = "EXPR", help_heading = "Filtering")]
tag_filter: Vec<String>,
#[arg(short = 'G', long, value_name = "FRACTION", help_heading = "Filtering")]
max_gc: Option<f64>,
#[arg(
short = 'm',
long = "quality-mode",
value_enum,
value_name = "MODE",
default_value_t = QualMode::Mean,
help_heading = "Filtering"
)]
qual_mode: QualMode,
#[arg(
short = 'H',
long = "trim-front",
visible_alias = "head-crop",
value_name = "BASES",
default_value_t = 0,
help_heading = "Trimming"
)]
head_crop: usize,
#[arg(
short = 'T',
long = "trim-tail",
visible_alias = "tail-crop",
value_name = "BASES",
default_value_t = 0,
help_heading = "Trimming"
)]
tail_crop: usize,
#[arg(
long = "quality-trim",
value_enum,
value_name = "METHOD",
help_heading = "Trimming"
)]
quality_trim: Option<QualityMethod>,
#[arg(
long = "quality-cutoff",
value_name = "PHRED",
help_heading = "Trimming"
)]
quality_cutoff: Option<u8>,
#[arg(
long = "min-low-quality-run",
value_name = "BASES",
help_heading = "Trimming"
)]
min_low_quality_run: Option<usize>,
#[arg(
long = "quality-end-cutoff",
value_name = "PHRED",
help_heading = "Trimming"
)]
quality_end_cutoff: Option<u8>,
#[arg(long = "update-moves", help_heading = "Tags")]
update_moves: bool,
#[arg(long, value_name = "TAGS", help_heading = "Tags")]
remove_tag: Vec<String>,
#[arg(
short = 'a',
long,
value_name = "FILE",
help_heading = "Adapter trimming"
)]
adapter_fasta: Option<PathBuf>,
#[arg(long, value_name = "KITS", help_heading = "Adapter trimming")]
adapter_preset: Option<String>,
#[arg(long, value_name = "FRACTION", help_heading = "Adapter trimming")]
adapter_error_rate: Option<f64>,
#[arg(
long = "adapter-end-search",
value_name = "BASES",
help_heading = "Adapter trimming"
)]
adapter_end_size: Option<usize>,
#[arg(long, help_heading = "Adapter trimming")]
adapter_ends_only: bool,
#[arg(
long = "adapter-sample-reads",
value_name = "COUNT",
help_heading = "Adapter trimming"
)]
adapter_sample: Option<usize>,
#[arg(
long = "adapter-discover",
help_heading = "Adapter trimming",
conflicts_with = "adapter_report"
)]
adapter_discover: bool,
#[arg(long = "adapter-report", help_heading = "Adapter trimming")]
adapter_report: bool,
}
const EXAMPLES: &str = "\
Examples:
whittle -i reads.fastq.gz -o trimmed.fastq.gz -H 20 --quality-trim ends --quality-cutoff 8 -l 500
whittle -i reads.bam -o trimmed.bam --quality-trim segments --quality-cutoff 9 -l 1000
whittle -i reads.bam -o trimmed.bam --adapter-preset lsk114 -l 500
whittle -i reads.bam -o trimmed.bam --adapter-discover -l 500
whittle -i 16s.fastq.gz -o trimmed.fastq.gz --adapter-preset mab114
samtools fastq -T MM,ML,MN reads.bam | whittle -o trimmed.fastq.gz -H 10 -T 10
whittle -i reads.bam -o reads.fastq.gz --quiet --summary-json qc.json";
const DEFAULT_ADAPTER_ERROR_RATE: f64 = 0.2;
const DEFAULT_ADAPTER_END_SIZE: usize = 150;
const DEFAULT_INFER_SAMPLE: usize = 40_000;
const DEFAULT_PRESET_SAMPLE: usize = 2_000;
pub fn command() -> clap::Command {
<Cli as clap::CommandFactory>::command()
}
pub fn parse() -> anyhow::Result<Config> {
let mut c = Cli::parse();
c.input = c.input.filter(|p| p.as_os_str() != "-");
c.output = c.output.filter(|p| p.as_os_str() != "-");
if c.verbose > 2 {
anyhow::bail!("verbosity accepts at most -vv (debug with -v, trace with -vv)");
}
validate_filters(&c)?;
let compression_level = compression_level_for(&c);
let fastq_tags = FastqTags::parse(&c.fastq_tags)?;
let remove_tags = TagRemoval::parse(&c.remove_tag)?;
let tag_filters = crate::tagfilter::TagFilters::parse(&c.tag_filter)?;
let quality = resolve_quality(&c)?;
let mut advisories: Vec<Advisory> = Vec::new();
let adapter_infer = resolve_infer(&c, &mut advisories)?;
let adapters = resolve_adapters(&c, adapter_infer, &mut advisories)?;
let adapter_sample = resolve_sample(&c, adapter_infer, &mut advisories)?;
let ncpu = std::thread::available_parallelism()
.map(|n| n.get())
.unwrap_or(1);
let threads_requested = c.threads.map(|n| usize::try_from(n).unwrap_or(usize::MAX));
let threads = crate::config::resolve_threads(threads_requested, ncpu);
let threads_clamped = match threads_requested {
Some(n) if n > ncpu => Some((n, ncpu)),
_ => None,
};
let cfg = Config {
io: IoConfig {
input: c.input,
output: c.output,
in_format: c.in_format,
out_format: c.out_format,
},
filter: FilterConfig {
min_length: c.min_length,
max_length: c.max_length.unwrap_or(usize::MAX),
min_qual: c.min_qual,
max_qual: c.max_qual,
max_expected_errors: c.max_expected_errors,
min_gc: c.min_gc,
max_gc: c.max_gc,
qual_mode: c.qual_mode,
},
trim: TrimPlan {
head: c.head_crop,
tail: c.tail_crop,
quality,
},
adapters,
adapter_infer,
threads,
fastq_tags,
render_workers: 0,
adapter_sample,
compression_level,
update_moves: c.update_moves,
ordered: c.ordered,
verbosity: c.verbose,
quiet: c.quiet,
threads_clamped,
summary_json: c.summary_json,
rejected_output: c.rejected_output,
advisories,
progress: c.progress,
adapter_fasta: c.adapter_fasta,
adapters_configured: None,
trim_classes: [false; 3],
remove_tags,
tag_filters,
};
let in_fmt = cfg
.io
.in_format
.or_else(|| cfg.io.input.as_deref().and_then(crate::io::from_extension));
if let Some(fmt) = in_fmt {
crate::guards::guard_bam_only_flags(&cfg, fmt)?;
}
let out_fmt = cfg
.io
.out_format
.or_else(|| cfg.io.output.as_deref().and_then(crate::io::from_extension));
if let (Some(in_fmt), Some(out_fmt)) = (in_fmt, out_fmt) {
crate::guards::guard_fastq_to_bam(in_fmt, out_fmt)?;
}
Ok(cfg)
}
fn parse_threads(value: &str) -> Result<u64, String> {
match value.parse::<u64>() {
Ok(0) => Err("must be at least 1".to_string()),
Ok(n) => Ok(n),
Err(_) => Err("must be an integer of at least 1".to_string()),
}
}
fn validate_filters(c: &Cli) -> anyhow::Result<()> {
let max_length = c.max_length.unwrap_or(usize::MAX);
if c.min_length > max_length {
anyhow::bail!(
"--min-length ({}) must not exceed --max-length ({max_length})",
c.min_length
);
}
for (flag, value) in [("--min-quality", c.min_qual), ("--max-quality", c.max_qual)] {
if !value.is_finite() || value < 0.0 {
anyhow::bail!("{flag} ({value}) must be a finite quality of at least 0");
}
}
if let Some(e) = c.max_expected_errors
&& (!e.is_finite() || e < 0.0)
{
anyhow::bail!("--max-expected-errors ({e}) must be a finite number of at least 0");
}
if c.min_qual > c.max_qual {
anyhow::bail!(
"--min-quality ({}) must not exceed --max-quality ({})",
c.min_qual,
c.max_qual
);
}
for (flag, value) in [("--min-gc", c.min_gc), ("--max-gc", c.max_gc)] {
if let Some(g) = value
&& !(0.0..=1.0).contains(&g)
{
anyhow::bail!("{flag} ({g}) must be a fraction between 0 and 1");
}
}
if let (Some(a), Some(b)) = (c.min_gc, c.max_gc)
&& a > b
{
anyhow::bail!("--min-gc ({a}) must not exceed --max-gc ({b})");
}
Ok(())
}
fn compression_level_for(c: &Cli) -> u8 {
let out_is_gz = match c.out_format {
Some(Format::FastqGz) => true,
Some(_) => false,
None => c.output.as_deref().and_then(crate::io::from_extension) == Some(Format::FastqGz),
};
c.compression_level.unwrap_or(if out_is_gz { 4 } else { 6 })
}
fn resolve_quality(c: &Cli) -> anyhow::Result<Option<QualityOp>> {
if let Some(n) = c.min_low_quality_run {
if c.quality_trim != Some(QualityMethod::Runs) {
anyhow::bail!("--min-low-quality-run requires --quality-trim runs");
}
if n == 0 {
anyhow::bail!("--min-low-quality-run must be at least 1");
}
}
if c.quality_end_cutoff.is_some()
&& !matches!(
c.quality_trim,
Some(QualityMethod::Segments | QualityMethod::Runs)
)
{
anyhow::bail!("--quality-end-cutoff requires --quality-trim segments or runs");
}
let Some(method) = c.quality_trim else {
if c.quality_cutoff.is_some() {
anyhow::bail!("--quality-cutoff requires --quality-trim");
}
return Ok(None);
};
let Some(cutoff) = c.quality_cutoff else {
anyhow::bail!("--quality-trim requires --quality-cutoff");
};
Ok(Some(QualityOp {
min_low_quality_run: c.min_low_quality_run.unwrap_or(1),
end_cutoff: c.quality_end_cutoff.unwrap_or(cutoff),
..QualityOp::new(method, cutoff)
}))
}
fn resolve_infer(c: &Cli, advisories: &mut Vec<Advisory>) -> anyhow::Result<AdapterInfer> {
let adapter_infer = if c.adapter_report {
AdapterInfer::Report
} else if c.adapter_discover {
AdapterInfer::Discover
} else {
AdapterInfer::Off
};
if adapter_infer.is_report() && c.adapter_fasta.is_some() {
advisories.push(Advisory::info(
"--adapter-report with --adapter-fasta: discovered adapters are named \
against the built-in adapter catalog and the supplied FASTA",
));
}
Ok(adapter_infer)
}
fn resolve_adapters(
c: &Cli,
adapter_infer: AdapterInfer,
advisories: &mut Vec<Advisory>,
) -> anyhow::Result<Option<crate::adapter::AdapterConfig>> {
let mut adapter_seqs: Vec<crate::adapter::Adapter> = Vec::new();
if let Some(kits) = preset_kits(c)? {
adapter_seqs.extend(crate::adapter::preset::preset(&kits));
}
if let Some(path) = &c.adapter_fasta {
let from_fasta = read_adapter_fasta(path, advisories)?;
if from_fasta.is_empty() {
anyhow::bail!(
"--adapter-fasta {}: no usable adapters (all entries were empty, \
shorter than the {}-bp minimum, or non-nucleotide)",
path.display(),
crate::adapter::MIN_PATTERN_LEN
);
}
adapter_seqs.extend(from_fasta);
}
if adapter_seqs.is_empty() && adapter_infer == AdapterInfer::Off {
require_adapter_source(c)?;
if c.adapter_ends_only {
advisories.push(Advisory::warn(
"--adapter-ends-only has no effect without --adapter-fasta, --adapter-preset or \
--adapter-discover",
));
}
return Ok(None);
}
let error_rate = c.adapter_error_rate.unwrap_or(DEFAULT_ADAPTER_ERROR_RATE);
if !(0.0..=1.0).contains(&error_rate) {
anyhow::bail!("--adapter-error-rate ({error_rate}) must be between 0 and 1");
}
let end_size = c.adapter_end_size.unwrap_or(DEFAULT_ADAPTER_END_SIZE);
if end_size == 0 {
anyhow::bail!("--adapter-end-search must be >= 1");
}
Ok(Some(crate::adapter::AdapterConfig {
adapters: adapter_seqs,
error_rate,
end_size,
split: !c.adapter_ends_only,
min_piece: c.min_length,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
}))
}
fn preset_kits(c: &Cli) -> anyhow::Result<Option<Vec<crate::adapter::preset::Kit>>> {
let Some(spec) = &c.adapter_preset else {
return Ok(None);
};
let kits = crate::adapter::preset::parse_presets(spec)
.map_err(|e| anyhow::anyhow!("--adapter-preset: {e}"))?;
Ok((!kits.is_empty()).then_some(kits))
}
fn require_adapter_source(c: &Cli) -> anyhow::Result<()> {
let explicit = [
("--adapter-error-rate", c.adapter_error_rate.is_some()),
("--adapter-end-search", c.adapter_end_size.is_some()),
("--adapter-sample-reads", c.adapter_sample.is_some()),
];
if let Some((flag, _)) = explicit.iter().find(|(_, given)| *given) {
anyhow::bail!(
"{flag} requires an adapter source (--adapter-fasta, --adapter-preset, or \
--adapter-discover)"
);
}
Ok(())
}
fn resolve_sample(
c: &Cli,
adapter_infer: AdapterInfer,
advisories: &mut Vec<Advisory>,
) -> anyhow::Result<usize> {
let min = crate::adapter::detect::MIN_SAMPLE_FOR_DETECTION;
let requested = match c.adapter_sample {
None if adapter_infer != AdapterInfer::Off => DEFAULT_INFER_SAMPLE,
None => DEFAULT_PRESET_SAMPLE,
Some(n) => {
if n != 0 && n < min {
anyhow::bail!(
"--adapter-sample-reads ({n}) must be 0 (disable detection) or at least {min} \
(smaller samples are too few for reliable detection)"
);
}
if n == 0 && adapter_infer != AdapterInfer::Off {
anyhow::bail!(
"--adapter-sample-reads 0 disables sampling, which adapter discovery requires; \
omit it or pass >= {min}"
);
}
n
},
};
if adapter_infer != AdapterInfer::Off || c.adapter_fasta.is_none() {
return Ok(requested);
}
if c.adapter_sample.is_some_and(|n| n > 0) {
advisories.push(Advisory::warn(
"--adapter-sample-reads is ignored with --adapter-fasta (presence detection is \
preset-only)",
));
}
Ok(0)
}
fn fasta_role(head: &str) -> crate::adapter::Role {
let description = head
.split_once(char::is_whitespace)
.map_or("", |(_, rest)| rest);
let mut words = description
.split(|c: char| c.is_whitespace() || matches!(c, '=' | ':' | ',' | ';'))
.filter(|w| !w.is_empty());
match words.find(|w| w.eq_ignore_ascii_case("primer") || w.eq_ignore_ascii_case("barcode")) {
Some(w) if w.eq_ignore_ascii_case("primer") => crate::adapter::Role::Primer,
Some(_) => crate::adapter::Role::Barcode,
None => crate::adapter::Role::Adapter,
}
}
fn read_adapter_fasta(
path: &std::path::Path,
advisories: &mut Vec<crate::config::Advisory>,
) -> anyhow::Result<Vec<crate::adapter::Adapter>> {
use seq_io::fasta::{Reader, Record};
let mut reader = Reader::from_path(path)
.map_err(|e| anyhow::anyhow!("--adapter-fasta {}: {e}", path.display()))?;
let mut out = Vec::new();
while let Some(rec) = reader.next() {
let rec = rec.map_err(|e| anyhow::anyhow!("--adapter-fasta {}: {e}", path.display()))?;
let seq: Vec<u8> = rec
.seq()
.iter()
.filter(|b| !b.is_ascii_whitespace())
.map(u8::to_ascii_uppercase)
.collect();
let seq: Vec<u8> = seq
.into_iter()
.map(|b| if b == b'U' { b'T' } else { b })
.collect();
let head = String::from_utf8_lossy(rec.head()).into_owned();
let role = fasta_role(&head);
let name = head
.split_once(char::is_whitespace)
.map_or(head.as_str(), |(name, _)| name)
.to_string();
let Some(degeneracy) = seq
.iter()
.map(|&b| crate::adapter::search::iupac_degeneracy(b).map(u32::from))
.sum::<Option<u32>>()
else {
let bad: String = seq
.iter()
.filter(|&&b| crate::adapter::search::iupac_degeneracy(b).is_none())
.map(|&b| b as char)
.collect();
advisories.push(crate::config::Advisory::warn(format!(
"Adapter entry skipped, contains non-nucleotide characters: \
name={name:?}, chars={bad}"
)));
continue;
};
if seq.len() < crate::adapter::MIN_PATTERN_LEN {
advisories.push(crate::config::Advisory::warn(format!(
"Adapter entry skipped, shorter than the minimum match length: \
name={name:?}, len={}, min={}",
seq.len(),
crate::adapter::MIN_PATTERN_LEN
)));
continue;
}
if degeneracy as usize >= seq.len() * 2 {
advisories.push(crate::config::Advisory::warn(format!(
"Adapter entry is highly degenerate and matches almost anywhere, which may \
trim real sequence: name={name:?}, bases_per_position={:.1}",
f64::from(degeneracy) / seq.len() as f64
)));
}
out.push(crate::adapter::Adapter { name, seq, role });
}
Ok(out)
}
#[doc(hidden)]
pub fn config_for_test(
input: &std::path::Path,
output: &std::path::Path,
head_crop: usize,
tail_crop: usize,
) -> Config {
config_for_test_threads(input, output, head_crop, tail_crop, 1)
}
#[doc(hidden)]
pub fn config_for_test_threads(
input: &std::path::Path,
output: &std::path::Path,
head_crop: usize,
tail_crop: usize,
threads: usize,
) -> Config {
Config {
io: IoConfig {
input: Some(input.to_path_buf()),
output: Some(output.to_path_buf()),
in_format: Some(Format::Bam),
out_format: Some(Format::Bam),
},
trim: TrimPlan {
head: head_crop,
tail: tail_crop,
quality: None,
},
threads: threads.max(1),
quiet: true,
..Config::default()
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Write;
#[test]
fn unsupported_parameter_names_are_rejected() {
for flag in [
"--in-format",
"--out-format",
"--ordered",
"--min-qual",
"--max-qual",
"--qual-mode",
"--qual-trim",
"--qual-best-segment",
"--qual-split",
"--qual-split-window",
"--trim-quality",
"--best-quality-segment",
"--split-quality",
"--split-min-low-quality-bases",
"--split-quality-segments",
"--update-signal-tags",
"--remove-kinetics",
"--discover-adapters",
"--strip-kinetics",
"--adapter-end-size",
"--adapter-sample",
"--adapter-infer",
"--adapter-infer-policy",
] {
let error = Cli::try_parse_from(["whittle", flag]).unwrap_err();
assert_eq!(
error.kind(),
clap::error::ErrorKind::UnknownArgument,
"{flag}"
);
}
}
#[test]
fn adapter_discover_and_report_conflict() {
let error =
Cli::try_parse_from(["whittle", "--adapter-discover", "--adapter-report"]).unwrap_err();
assert_eq!(error.kind(), clap::error::ErrorKind::ArgumentConflict);
}
#[test]
fn help_text_matches_the_adapter_constants() {
let cmd = command();
let help_for = |id: &str| {
cmd.get_arguments()
.find(|a| a.get_id().as_str() == id)
.unwrap_or_else(|| panic!("Argument {id} exists"))
.get_help()
.expect("Argument has help text")
.to_string()
};
assert!(
help_for("adapter_fasta").contains(&format!("{} bp", crate::adapter::MIN_PATTERN_LEN)),
"--adapter-fasta help quotes MIN_PATTERN_LEN"
);
assert!(
help_for("adapter_sample").contains(&format!(
"at least {}",
crate::adapter::detect::MIN_SAMPLE_FOR_DETECTION
)),
"--adapter-sample-reads help quotes MIN_SAMPLE_FOR_DETECTION"
);
}
#[test]
fn read_adapter_fasta_skips_entries_below_min_pattern_len() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("adapters.fasta");
let mut f = std::fs::File::create(&path).unwrap();
writeln!(f, ">kept_20bp").unwrap();
writeln!(f, "ACGTACGTACGTACGTACGT").unwrap(); writeln!(f, ">skipped_8bp").unwrap();
writeln!(f, "ACGTACGT").unwrap(); drop(f);
let mut advisories = Vec::new();
let adapters = read_adapter_fasta(&path, &mut advisories).unwrap();
assert_eq!(adapters.len(), 1);
assert_eq!(adapters[0].seq, b"ACGTACGTACGTACGTACGT".to_vec());
}
#[test]
fn read_adapter_fasta_keeps_iupac_and_rejects_non_nucleotides() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("adapters.fasta");
let mut f = std::fs::File::create(&path).unwrap();
writeln!(f, ">plain_20bp").unwrap();
writeln!(f, "ACGTACGTACGTACGTACGT").unwrap();
writeln!(f, ">degenerate_20bp").unwrap();
writeln!(f, "ACGTACGTYCGTACGTACGN").unwrap();
writeln!(f, ">rna_20bp").unwrap();
writeln!(f, "ACGUACGUACGUACGUACGU").unwrap();
writeln!(f, ">protein_20bp").unwrap();
writeln!(f, "ACGTACGTZCGTACGTACGT").unwrap();
drop(f);
let mut advisories = Vec::new();
let adapters = read_adapter_fasta(&path, &mut advisories).unwrap();
let names: Vec<&str> = adapters.iter().map(|a| a.name.as_str()).collect();
assert_eq!(names, ["plain_20bp", "degenerate_20bp", "rna_20bp"]);
assert_eq!(adapters[1].seq, b"ACGTACGTYCGTACGTACGN".to_vec());
assert_eq!(adapters[2].seq, b"ACGTACGTACGTACGTACGT".to_vec());
assert!(
advisories
.iter()
.any(|a| a.message.contains("non-nucleotide")),
"The protein-alphabet entry is reported"
);
}
#[test]
fn read_adapter_fasta_warns_about_a_very_degenerate_pattern() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("adapters.fasta");
let mut f = std::fs::File::create(&path).unwrap();
writeln!(f, ">mostly_n").unwrap();
writeln!(f, "NNNNNNNNNNNNNNNACGTA").unwrap();
drop(f);
let mut advisories = Vec::new();
let adapters = read_adapter_fasta(&path, &mut advisories).unwrap();
assert_eq!(adapters.len(), 1, "Still searched");
assert!(
advisories.iter().any(|a| a.message.contains("degenerate")),
"A near-wildcard pattern warns"
);
}
}