OSCR

Development and validation of a long-term co-maturation protocol for human stem cell-derived microglia and neuronal networks.

Code ↔ Paper

1 match between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 1 match
  1. [1] § STAR★Methods › Method details › RNA-sequencing ↔ src/cli.rs, lines 231–287 · score 0.54 · FastQC, kit, Library, Illumina, RNA, bp

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Rust · 1,667 lines · 62 KB · GPL-3.0 · 1 match

  1. //! Command-line argument parsing and validation.
  3. use clap::Parser;
  4. use std::path::PathBuf;
  6. /// Output container format. FASTQ is the default and preserves byte-identity
  7. /// with Perl Trim Galore 0.6.11. uBAM is opt-in and carries the input BAM's
  8. /// aux tags through (via `--preserve-tags`).
  9. ///
  10. /// See `plans/06252026_pluggable-io-formats/phase1-trimgalore-formats/PLAN.md`
  11. /// §3.2 for the full output-naming + behaviour matrix.
  12. #[derive(Clone, Debug, Default, PartialEq, Eq, clap::ValueEnum)]
  13. pub enum OutputFormat {
  14. /// FASTQ output, mirroring input compression (default).
  15. #[default]
  16. Fastq,
  17. /// Unaligned BAM output. Always single-threaded in v1; --clumpify,
  18. /// --passthrough, --clock, --implicon, --demux are rejected at validation.
  19. #[clap(name = "ubam")]
  20. UBam,
  21. }
  23. /// Trim Galore: A fast, single-pass NGS adapter and quality trimmer.
  24. ///
  25. /// Drop-in replacement for Trim Galore, rewritten in Rust. Matches v0.6.x outputs
  26. /// for the core feature set and extends it with poly-G / generic poly-A auto-trimming
  27. /// and other additions. Compatible with MultiQC and existing pipelines.
  28. #[derive(Parser, Debug)]
  29. #[clap(
  30. name = "trim_galore",
  31. version = env!("CARGO_PKG_VERSION"),
  32. long_version = concat!(
  33. env!("CARGO_PKG_VERSION"), "\n",
  34. env!("VERSION_BODY")
  35. ),
  36. about
  37. )]
  38. pub struct Cli {
  39. /// Input FASTQ file(s). For paired-end, provide two files.
  40. #[clap(required = true)]
  41. pub input: Vec<PathBuf>,
  43. /// Quality trimming cutoff (Phred score). Bases below this are trimmed from 3' end.
  44. #[clap(short = 'q', long = "quality", default_value = "20")]
  45. pub quality: u8,
  47. /// Adapter sequence for trimming. Auto-detected if not specified.
  48. /// Supports A{N} shorthand for repeated single bases (e.g., -a A{10} → AAAAAAAAAA).
  49. /// For multiple adapters, repeat -a (e.g., -a SEQ1 -a SEQ2) or use "file:adapters.fa".
  50. #[clap(short = 'a', long = "adapter")]
  51. pub adapter: Vec<String>,
  53. /// Optional adapter sequence for Read 2 (paired-end only).
  54. /// Auto-set by --small_rna and --bgiseq presets.
  55. /// Supports A{N} shorthand for repeated single bases (e.g., -a2 T{150} → 150 T's).
  56. /// For multiple adapters, repeat -a2 (e.g., -a2 SEQ1 -a2 SEQ2) or use "file:adapters.fa".
  57. #[clap(long = "adapter2", alias = "a2")]
  58. pub adapter2: Vec<String>,
  60. /// Use Illumina universal adapter (AGATCGGAAGAGC). Also the auto-detect fallback.
  61. #[clap(long = "illumina", conflicts_with_all = &["nextera", "small_rna", "stranded_illumina", "bgiseq"])]
  62. pub illumina: bool,
  64. /// Use Nextera transposase adapter (CTGTCTCTTATA).
  65. #[clap(long = "nextera", conflicts_with_all = &["illumina", "small_rna", "stranded_illumina", "bgiseq"])]
  66. pub nextera: bool,
  68. /// Use Illumina Small RNA adapter (TGGAATTCTCGG).
  69. /// Also lowers --length default to 18 and sets --adapter2 (GATCGTCGGACT, Illumina small RNA 5').
  70. #[clap(long = "small_rna", conflicts_with_all = &["illumina", "nextera", "stranded_illumina", "bgiseq"])]
  71. pub small_rna: bool,
  73. /// Use Illumina Stranded mRNA adapter (ACTGTCTCTTATA).
  74. /// Not covered by auto-detection — must be set explicitly.
  75. #[clap(long = "stranded_illumina", conflicts_with_all = &["illumina", "nextera", "small_rna", "bgiseq"])]
  76. pub stranded_illumina: bool,
  78. /// Use BGI/DNBSEQ adapter. Sets --adapter2 for Read 2. Also probed by auto-detection.
  79. #[clap(long = "bgiseq", conflicts_with_all = &["illumina", "nextera", "small_rna", "stranded_illumina"])]
  80. pub bgiseq: bool,
  82. /// Paired-end mode. Accepts an even number of input files as consecutive R1/R2 pairs
  83. /// (e.g. --paired R1.fq.gz R2.fq.gz, or a glob matching multiple samples).
  84. #[clap(long = "paired")]
  85. pub paired: bool,
  87. /// Maximum allowed error rate for adapter matching (0-1).
  88. #[clap(short = 'e', long = "error_rate", default_value = "0.1")]
  89. pub error_rate: f64,
  91. /// Minimum overlap with adapter sequence required to trim (stringency).
  92. #[clap(long = "stringency", default_value = "1")]
  93. pub stringency: usize,
  95. /// Minimum required sequence length after trimming.
  96. /// Default: 20 (18 for smallRNA adapter).
  97. /// In paired-end mode, both reads must pass; see --retain_unpaired to keep single survivors.
  98. #[clap(long = "length")]
  99. pub length: Option<usize>,
  101. /// Maximum allowed sequence length (discard reads longer than this).
  102. /// Typically only useful for smallRNA-seq to remove non-small-RNA reads.
  103. #[clap(long = "max_length")]
  104. pub max_length: Option<usize>,
  106. /// Maximum number of N bases allowed in a read.
  107. /// Integer: absolute count. Decimal (0-1): fraction of read length.
  108. /// In paired-end mode, either read over the limit removes the whole pair.
  109. #[clap(long = "max_n")]
  110. pub max_n: Option<f64>,
  112. /// Trim N bases from both ends of reads. Suppressed under --rrbs (matches Perl v0.6.x).
  113. #[clap(long = "trim-n", alias = "trim_n")]
  114. pub trim_n: bool,
  116. /// Remove N bases from the 5' end of Read 1. Useful for removing 5' quality-bias regions.
  117. #[clap(long = "clip_R1", alias = "clip_r1")]
  118. pub clip_r1: Option<usize>,
  120. /// Remove N bases from the 5' end of Read 2 (paired-end only).
  121. /// For paired-end bisulfite-seq, the end-repair step can introduce methylation bias; see Bismark User Guide.
  122. #[clap(long = "clip_R2", alias = "clip_r2")]
  123. pub clip_r2: Option<usize>,
  125. /// Remove N bases from the 3' end of Read 1, after adapter/quality trimming.
  126. #[clap(long = "three_prime_clip_R1", alias = "three_prime_clip_r1")]
  127. pub three_prime_clip_r1: Option<usize>,
  129. /// Remove N bases from the 3' end of Read 2 (paired-end only), after adapter/quality trimming.
  130. #[clap(long = "three_prime_clip_R2", alias = "three_prime_clip_r2")]
  131. pub three_prime_clip_r2: Option<usize>,
  133. /// NextSeq/NovaSeq 2-colour quality trimming. Trailing high-quality G bases
  134. /// are treated as no-signal artifacts and quality-trimmed. The value is the
  135. /// quality cutoff (replaces -q). Mutually exclusive with --quality.
  136. #[clap(long = "nextseq", alias = "2colour")]
  137. pub nextseq: Option<u8>,
  139. /// Use Phred+64 quality encoding (Illumina 1.5). Default is Phred+33.
  140. #[clap(long = "phred64")]
  141. pub phred64: bool,
  143. /// Use Phred+33 quality encoding (default, Sanger/Illumina 1.8+).
  144. #[clap(long = "phred33")]
  145. pub phred33: bool,
  147. /// Output directory for trimmed files. Created if it doesn't exist.
  148. #[clap(short = 'o', long = "output_dir")]
  149. pub output_dir: Option<PathBuf>,
  151. /// Custom basename for output files (replaces input filename stem).
  152. /// Only valid for a single file (single-end) or a single pair (paired-end).
  153. #[clap(long = "basename")]
  154. pub basename: Option<String>,
  156. /// Do not gzip-compress output files. Forces plain output regardless of
  157. /// input compression. By default, output compression mirrors the input
  158. /// (plain → plain, .gz → .gz; matches Perl v0.6.x behaviour).
  159. #[clap(long = "dont_gzip")]
  160. pub dont_gzip: bool,
  162. /// Reorder reads in the gzip output so reads sharing a canonical 16-mer
  163. /// minimizer land adjacent, letting gzip's dictionary find longer
  164. /// redundant runs. Typical saving: 16–55% on short-read FASTQ. Records
  165. /// are byte-identical — only their order on disk changes. Pair lockstep
  166. /// is preserved.
  167. ///
  168. /// Requires `--cores >= 2` and gzip output. Intended for short-read
  169. /// FASTQ; long-read inputs (ONT, PacBio) are unlikely to compress
  170. /// better. Combine with `--compression <N>` to trade speed against
  171. /// output size, and `--memory <N>` to grow the per-gzip-member sort
  172. /// run.
  173. #[clap(long = "clumpify")]
  174. pub clumpify: bool,
  176. /// Gzip compression level for output FASTQ (1–9). Default: 1 (fast,
  177. /// 75% larger files). Pass `--compression 6` for the gzip(1) default
  178. /// or `--compression 9` for archival use. Most useful in combination
  179. /// with `--clumpify`, where reordering plus a higher level
  180. /// compounds for substantially smaller output.
  181. #[clap(
  182. long = "compression",
  183. default_value_t = crate::fastq::DEFAULT_GZIP_LEVEL,
  184. value_parser = clap::value_parser!(u32).range(1..=9),
  185. )]
  186. pub compression: u32,
  188. /// Total memory budget for Trim Galore (e.g. `1G`, `512M`, `8G`).
  189. /// Currently used only by `--clumpify` for bin buffer sizing — bigger
  190. /// budget → bigger gzip members → better compression, up to a limit
  191. /// roughly equal to the uncompressed input size. Default: `1G`.
  192. /// Resolved bin layout and predicted peak RSS are printed at startup
  193. /// when `--clumpify` is set.
  194. #[clap(long = "memory", default_value = "1G")]
  195. pub memory: String,
  197. /// Suppress the trimming report.
  198. #[clap(long = "no_report_file")]
  199. pub no_report_file: bool,
  201. /// Comma-separated list of BAM tags (e.g. "CB,UB,RX") to append to the
  202. /// FASTQ header on uBAM input. Tab-separated, samtools `-T`-compatible.
  203. /// Each tag must be a 2-char SAM tag name (`[A-Za-z][A-Za-z0-9]`).
  204. /// Ignored for FASTQ input. The `ALL` keyword is reserved for a future
  205. /// release and rejected in v1. See PLAN §3.2.5.
  206. #[clap(long = "preserve-tags", value_delimiter = ',', value_parser = parse_sam_tag_name)]
  207. pub preserve_tags: Vec<String>,
  209. /// Output container format. Default `fastq` keeps existing behaviour
  210. /// (input-compression-mirroring FASTQ); `ubam` emits unaligned BAM with
  211. /// aux tags propagated from uBAM inputs (when `--preserve-tags` is set).
  212. /// uBAM output is always single-threaded in v1; see the rejection rules
  213. /// in `Cli::validate` for incompatible combinations.
  214. /// See `plans/06252026_pluggable-io-formats/phase1-trimgalore-formats/PLAN.md`.
  215. #[clap(long = "output-format", value_enum, default_value_t = OutputFormat::Fastq)]
  216. pub output_format: OutputFormat,
  218. /// Retain unpaired reads when the mate is too short (paired-end only).
  219. /// Cutoff via --length_1 / --length_2 (default 35 each).
  220. #[clap(long = "retain_unpaired")]
  221. pub retain_unpaired: bool,
  223. /// Minimum length for unpaired Read 1 (with --retain_unpaired).
  224. #[clap(short = 'r', long = "length_1", default_value = "35", alias = "r1")]
  225. pub length_1: usize,
  227. /// Minimum length for unpaired Read 2 (with --retain_unpaired).
  228. #[clap(long = "length_2", default_value = "35", alias = "r2")]
  229. pub length_2: usize,
  231. /// Pass a third FASTQ file through unchanged but keep it in lockstep with R1/R2.
  232. /// Use case: 10X Multiome / scATAC libraries where the cell-barcode (I1/I2) read
  233. /// must stay aligned to the trimmed R1/R2. Records dropped by length/quality/N
  234. /// filters are also dropped from the passthrough output. The passthrough file is
  235. /// never trimmed or adapter-scanned.
  236. ///
  237. /// Requires --paired with exactly one R1/R2 pair. Incompatible with
  238. /// --retain_unpaired, --clumpify, and all specialty modes (--clock, --implicon,
  239. /// --hardtrim5/3, --demux).
  240. ///
  241. /// Note: legacy headers like @read/1, @read/2, @read/3 sync correctly. If your
  242. /// files use unusual header conventions and the sync check fires unexpectedly,
  243. /// please file an issue with a sample header line. If --fastqc is enabled the
  244. /// passthrough FastQC report will look poor (cell-barcode reads are intentionally
  245. /// uniformly-structured) — that's expected, not a defect. On a mid-stream reader
  246. /// error (truncated or desynced passthrough), partial output files may remain on
  247. /// disk — re-run after fixing the input.
  248. #[clap(long = "passthrough")]
  249. pub passthrough: Option<PathBuf>,
  251. /// Add clipped sequences to read IDs for --clip_R1/R2, --three_prime_clip_R1/R2, and --hardtrim5/3.
  252. /// Appends :clip5:SEQ and/or :clip3:SEQ to the read ID (each half only when that side was clipped). Useful for UMI handling.
  253. #[clap(long = "rename")]
  254. pub rename: bool,
  256. /// If auto-detected adapter count is at or below this threshold,
  257. /// skip adapter trimming (only quality trimming proceeds).
  258. /// Incompatible with explicit adapter presets.
  259. #[clap(long = "consider_already_trimmed",
  260. conflicts_with_all = &["illumina", "nextera", "small_rna", "stranded_illumina", "bgiseq"])]
  261. pub consider_already_trimmed: Option<usize>,
  263. /// RRBS mode for MspI-digested samples. Removes 2bp end-repair artifacts
  264. /// at MspI cut sites after adapter trimming. In paired-end directional mode,
  265. /// automatically sets --clip_R2 2 unless the user provides their own value.
  266. /// Do not use with Tecan Ovation RRBS kits — those use a diversity-trimming step instead.
  267. #[clap(long = "rrbs")]
  268. pub rrbs: bool,
  270. /// Non-directional RRBS libraries. Reads starting with CAA or CGA get 2bp
  271. /// trimmed from the 5' end. Requires --rrbs.
  272. /// Unlike directional --rrbs, does not auto-set --clip_R2 2 in paired-end mode.
  273. #[clap(long = "non_directional", requires = "rrbs")]
  274. pub non_directional: bool,
  276. /// Run FastQC on the trimmed output files (built in via the bundled
  277. /// fastqc-rust library; no external Java or FastQC binary needed).
  278. /// Produces FastQC 0.12.1-compatible *_fastqc.html / *_fastqc.zip artifacts.
  279. #[clap(long = "fastqc")]
  280. pub fastqc: bool,
  282. /// Additional arguments to pass to FastQC. Implies --fastqc.
  283. /// Common flags are translated to the bundled engine: --nogroup, --expgroup,
  284. /// --quiet, --svg, --nano, --nofilter, --casava, -t/--threads, -o/--outdir.
  285. /// Unrecognised flags emit a warning and are ignored.
  286. #[clap(long = "fastqc_args", allow_hyphen_values = true)]
  287. pub fastqc_args: Option<String>,
  289. /// Number of worker threads for parallel processing (default: 1).
  290. /// At --cores 1 the worker-pool is bypassed (single thread, ~5 MB RAM).
  291. /// From --cores 2 upward, an N+4 thread model applies: N workers + 2
  292. /// decompressors + 1 batcher + 1 writer. Wall-clock speedup is near-linear
  293. /// up to --cores 8 for paired-end runs; beyond that, gzip-output I/O on
  294. /// the storage layer typically becomes binding before workers run out of
  295. /// useful per-read work, so additional cores help progressively less.
  296. #[clap(short = 'j', long = "cores", default_value = "1")]
  297. pub cores: usize,
  299. /// Trim poly-A tails from the 3' end of Read 1 (and single-end reads),
  300. /// and poly-T heads from the 5' end of Read 2. Runs after adapter trimming,
  301. /// so poly-A tails hidden behind adapters are also removed.
  302. #[clap(long = "poly_a", alias = "poly-a", alias = "polyA")]
  303. pub poly_a: bool,
  305. /// Trim poly-G tails from the 3' end of Read 1 (and single-end reads),
  306. /// and poly-C heads from the 5' end of Read 2. Useful for data from
  307. /// 2-colour instruments (NovaSeq, NextSeq) where no-signal bases are
  308. /// called as high-quality G. By default, poly-G trimming is auto-detected
  309. /// from the data. Use this flag to force-enable it.
  310. /// This is independent from --nextseq (quality-based G-trimming).
  311. #[clap(
  312. long = "poly_g",
  313. alias = "poly-g",
  314. alias = "polyG",
  315. conflicts_with = "no_poly_g"
  316. )]
  317. pub poly_g: bool,
  319. /// Disable poly-G auto-detection and trimming.
  320. #[clap(long = "no_poly_g", alias = "no-poly-g", alias = "no-polyG")]
  321. pub no_poly_g: bool,
  323. /// Number of adapter trimming rounds per read. With multiple adapters,
  324. /// this allows removing more than one adapter from the same read.
  325. /// Default: 1. Typical multi-adapter usage: -n 3.
  326. #[clap(short = 'n', long = "times", default_value = "1")]
  327. pub times: usize,
  329. /// Discard reads that did not contain an adapter sequence. Only reads
  330. /// where at least one adapter match was found are written to output.
  331. /// For paired-end, the pair is discarded if neither read had an adapter.
  332. #[clap(long = "discard_untrimmed", alias = "discard-untrimmed")]
  333. pub discard_untrimmed: bool,
  335. // --- Specialty modes (run-and-exit, bypass normal trimming) ---
  336. /// Hard-trim to keep only the first N bases from the 5' end.
  337. /// Bypasses adapter/quality trimming entirely. Output filenames end in .<N>bp_5prime.fq(.gz).
  338. #[clap(long = "hardtrim5")]
  339. pub hardtrim5: Option<usize>,
  341. /// Hard-trim to keep only the last N bases from the 3' end.
  342. /// Bypasses adapter/quality trimming entirely. Output filenames end in .<N>bp_3prime.fq(.gz).
  343. #[clap(long = "hardtrim3")]
  344. pub hardtrim3: Option<usize>,
  346. /// Epigenetic Clock mode (paired-end only). Extracts 8bp UMI + 4bp
  347. /// fixed sequence (CAGT) from both reads, appends to read IDs, and
  348. /// clips R1 at position 13, R2 at position 15. Bypasses normal trimming.
  349. #[clap(long = "clock", alias = "casio", alias = "breitling")]
  350. pub clock: bool,
  352. /// Transfer the first N bases from Read 2 as a UMI barcode to both
  353. /// read IDs, then clip R2 by N bases. Paired-end only.
  354. /// Bypasses normal trimming (IMPLICON preprocessing).
  355. /// Default UMI length: 8 (used when --implicon is given without a value).
  356. #[clap(long = "implicon", alias = "umi_from_r2",
  357. default_missing_value = "8", num_args = 0..=1, require_equals = true)]
  358. pub implicon: Option<usize>,
  360. /// Demultiplex reads after trimming based on 3' inline barcodes.
  361. /// Takes a barcode file (TSV: sample_name\tbarcode_sequence).
  362. /// Barcode is removed from the read and appended to the read ID.
  363. /// Single-end only.
  364. #[clap(long = "demux")]
  365. pub demux: Option<PathBuf>,
  367. // --- Deprecated flags (accepted for backwards compatibility, no-ops) ---
  368. /// [Deprecated] Output is gzipped by default in v2.0. Use --dont_gzip to disable.
  369. #[clap(long = "gzip", hide = true)]
  370. pub gzip: bool,
  372. /// [Deprecated] No longer needed — Cutadapt is built in.
  373. #[clap(long = "path_to_cutadapt", hide = true)]
  374. pub path_to_cutadapt: Option<String>,
  376. /// [Deprecated] No longer needed — Cutadapt is built in.
  377. #[clap(long = "cutadapt_args", hide = true, allow_hyphen_values = true)]
  378. pub cutadapt_args: Option<String>,
  380. /// [Deprecated] v2.0 emits only essential progress output; use shell redirection if quieter output is needed.
  381. #[clap(long = "suppress_warn", hide = true)]
  382. pub suppress_warn: bool,
  384. /// [Deprecated] Reports are generated by default.
  385. #[clap(long = "report", hide = true)]
  386. pub report: bool,
  388. /// [Deprecated] The v2.0 single-pass architecture has no quality-trim intermediate file to keep.
  389. #[clap(long = "keep", hide = true)]
  390. pub keep: bool,
  392. /// Easter egg (no-op).
  393. #[clap(long = "hulu", hide = true)]
  394. pub hulu: bool,
  395. }
  397. /// Rewrite Perl-era multi-character short flags (`-r1`, `-r2`, `-a2`) as
  398. /// their clap-compatible long-alias forms (`--r1`, `--r2`, `--a2`) before
  399. /// parsing.
  400. ///
  401. /// Clap derives single-character short flags only, so e.g. `-r1 40` would
  402. /// parse as `-r=1` with `40` becoming a stray positional, producing a
  403. /// confusing "odd count of input files" error. `-a2 SEQ` would similarly
  404. /// parse as `-a=2` with `SEQ` becoming a positional input file. This
  405. /// pre-parse hook transparently rewrites the exact tokens so Perl-era
  406. /// invocations keep working.
  407. ///
  408. /// Only exact-match tokens are rewritten — `-r10` (legitimate clap
  409. /// `-r=10`) and any other value-suffixed form pass through unchanged.
  410. /// clap value parser for `--preserve-tags`. Each tag must be a valid 2-char
  411. /// SAM tag name (`[A-Za-z][A-Za-z0-9]`). The `ALL` keyword is reserved.
  412. fn parse_sam_tag_name(s: &str) -> Result<String, String> {
  413. if s == "ALL" {
  414. return Err("--preserve-tags ALL is not supported in v1 (use an explicit list)".into());
  415. }
  416. let bytes = s.as_bytes();
  417. if bytes.len() != 2 {
  418. return Err(format!(
  419. "'{s}' is not a valid SAM tag name (must be exactly 2 characters)"
  420. ));
  421. }
  422. if !bytes[0].is_ascii_alphabetic() || !bytes[1].is_ascii_alphanumeric() {
  423. return Err(format!(
  424. "'{s}' is not a valid SAM tag name (must match [A-Za-z][A-Za-z0-9])"
  425. ));
  426. }
  427. Ok(s.to_string())
  428. }
  430. pub fn rewrite_perl_short_flags<I>(args: I) -> Vec<String>
  431. where
  432. I: IntoIterator<Item = String>,
  433. {
  434. args.into_iter()
  435. .map(|a| {
  436. if a == "-r1" || a.starts_with("-r1=") {
  437. format!("--r1{}", &a[3..])
  438. } else if a == "-r2" || a.starts_with("-r2=") {
  439. format!("--r2{}", &a[3..])
  440. } else if a == "-a2" || a.starts_with("-a2=") {
  441. format!("--a2{}", &a[3..])
  442. } else {
  443. a
  444. }
  445. })
  446. .collect()
  447. }
  449. impl Cli {
  450. /// Shared validation for any paired-end mode (`--paired`, `--clock`,
  451. /// `--implicon`) that takes input files in pairwise (R1, R2, R1, R2, …)
  452. /// order. Checks:
  453. /// 1. Even count of input files.
  454. /// 2. Within each pair, R1 ≠ R2 byte-equal (matches Perl's
  455. /// `$ARGV[$i] eq $ARGV[$i+1]` check at `trim_galore:3208`; does not
  456. /// follow symlinks or canonicalise).
  457. /// 3. Across pairs, no duplicate pair (catches accidental copy-paste
  458. /// and emits a precise error rather than the case-insensitive
  459. /// output-collision pre-flight's APFS/NTFS message).
  460. ///
  461. /// `mode_label` is used in the user-facing error string, e.g.
  462. /// `"Paired-end"`, `"--clock"`, `"--implicon"`.
  463. fn validate_paired_input(&self, mode_label: &str) -> anyhow::Result<()> {
  464. // Allow N=1 for the `--paired` case: that's only legal if the single
  465. // file is a uBAM, in which case the de-interleaver produces R1+R2 from
  466. // one interleaved BAM. The "is it BAM?" check happens at main.rs
  467. // sanity_check time (after format detection has run). For specialty
  468. // modes (--clock, --implicon, --hardtrim) the strict even-count rule
  469. // still applies because they don't yet support uBAM input.
  470. if self.input.len() == 1 && self.paired && mode_label == "Paired-end" {
  471. return Ok(());
  472. }
  473. if !self.input.len().is_multiple_of(2) {
  474. anyhow::bail!(
  475. "{} mode requires an even number of input files (R1/R2 pairs), got {}",
  476. mode_label,
  477. self.input.len()
  478. );
  479. }
  480. for chunk in self.input.chunks(2) {
  481. if chunk[0] == chunk[1] {
  482. anyhow::bail!(
  483. "Read 1 and Read 2 appear to be the same file: {}. \
  484. Did you mean to pass distinct R1 and R2 files?",
  485. chunk[0].display()
  486. );
  487. }
  488. }
  489. let pairs: Vec<(&std::path::PathBuf, &std::path::PathBuf)> =
  490. self.input.chunks(2).map(|c| (&c[0], &c[1])).collect();
  491. for (i, (r1, r2)) in pairs.iter().enumerate() {
  492. for (j, (pr1, pr2)) in pairs.iter().enumerate().take(i) {
  493. if r1 == pr1 && r2 == pr2 {
  494. anyhow::bail!(
  495. "Pair {} ({}, {}) is a duplicate of pair {}. \
  496. Did you mean to pass different files?",
  497. i + 1,
  498. r1.display(),
  499. r2.display(),
  500. j + 1
  501. );
  502. }
  503. }
  504. }
  505. Ok(())
  506. }
  508. /// Validate CLI arguments after parsing.
  509. pub fn validate(&self) -> anyhow::Result<()> {
  510. // §3.4a — `--output-format ubam` exclusions. These are pure CLI-level
  511. // (no file I/O); enforced here. The §3.4b rule (preserve-tags + all
  512. // FASTQ inputs) requires format detection and lives in main.rs.
  513. if matches!(self.output_format, OutputFormat::UBam) {
  514. if self.clumpify {
  515. anyhow::bail!(
  516. "--clumpify is for gzip output; not applicable with --output-format ubam"
  517. );
  518. }
  519. if self.passthrough.is_some() {
  520. anyhow::bail!("--passthrough is not supported with --output-format ubam in v1");
  521. }
  522. if self.clock {
  523. anyhow::bail!(
  524. "--clock + --output-format ubam: UMI-to-BAM-tag mapping not defined in v1; \
  525. use FASTQ output or convert after"
  526. );
  527. }
  528. if self.implicon.is_some() {
  529. anyhow::bail!(
  530. "--implicon + --output-format ubam: UMI-to-BAM-tag mapping not defined in v1"
  531. );
  532. }
  533. if self.demux.is_some() {
  534. anyhow::bail!("--demux is not supported with --output-format ubam in v1");
  535. }
  536. // PLAN v2.1 §3.4a addendum (Step 3 implementation note): v2.1 left
  537. // --retain_unpaired silent, but it produces multiple output files
  538. // (`*_unpaired_{1,2}.fq.gz`) — same shape as --demux / --passthrough
  539. // which are already rejected. Multi-output BAM is out of scope for
  540. // v1; revisit if a real workload demands it.
  541. if self.retain_unpaired {
  542. anyhow::bail!(
  543. "--retain_unpaired is not supported with --output-format ubam in v1 \
  544. (unpaired records would require additional BAM output paths; \
  545. run without --retain_unpaired or post-process via samtools)"
  546. );
  547. }
  548. }
  550. if self.paired {
  551. // `#[clap(required = true)]` on `input` guarantees at least one file
  552. // reaches validate(), so no is_empty() check is needed.
  553. self.validate_paired_input("Paired-end")?;
  554. }
  556. if !self.paired && self.input.len() > 1 && self.basename.is_some() {
  557. anyhow::bail!(
  558. "--basename cannot be used with multiple input files (ambiguous output naming)"
  559. );
  560. }
  561. if self.paired && self.input.len() > 2 && self.basename.is_some() {
  562. anyhow::bail!(
  563. "--basename cannot be used with multiple paired-end pairs (ambiguous output naming)"
  564. );
  565. }
  567. if self.error_rate < 0.0 || self.error_rate > 1.0 {
  568. anyhow::bail!(
  569. "Error rate must be between 0 and 1, got {}",
  570. self.error_rate
  571. );
  572. }
  574. if self.stringency == 0 {
  575. anyhow::bail!("Stringency (minimum overlap) must be at least 1");
  576. }
  578. if self.nextseq.is_some() && self.quality != 20 {
  579. anyhow::bail!(
  580. "--nextseq/--2colour and -q/--quality are mutually exclusive. \
  581. The nextseq value replaces the quality cutoff."
  582. );
  583. }
  585. if let Some(val) = self.nextseq
  586. && (val == 0 || val >= 200)
  587. {
  588. anyhow::bail!(
  589. "NextSeq quality cutoff must be between 1 and 199, got {}",
  590. val
  591. );
  592. }
  594. if let Some(threshold) = self.consider_already_trimmed
  595. && threshold > 10000
  596. {
  597. anyhow::bail!(
  598. "consider_already_trimmed value must be between 0 and 10000, got {}",
  599. threshold
  600. );
  601. }
  603. if self.times == 0 || self.times > 10 {
  604. anyhow::bail!("--times/-n must be between 1 and 10, got {}", self.times);
  605. }
  607. if self.cores == 0 {
  608. anyhow::bail!("--cores must be at least 1");
  609. }
  611. if self.clumpify {
  612. if self.cores < 2 {
  613. anyhow::bail!(
  614. "--clumpify requires --cores >= 2 (the bin dispatcher feeds parallel workers)"
  615. );
  616. }
  617. if self.dont_gzip {
  618. anyhow::bail!(
  619. "--clumpify and --dont_gzip are mutually exclusive (clumping plain text is pointless)"
  620. );
  621. }
  622. if self.clock {
  623. anyhow::bail!("--clumpify is not yet supported with --clock");
  624. }
  625. if self.implicon.is_some() {
  626. anyhow::bail!("--clumpify is not yet supported with --implicon");
  627. }
  628. if self.hardtrim5.is_some() {
  629. anyhow::bail!("--clumpify is not yet supported with --hardtrim5");
  630. }
  631. if self.hardtrim3.is_some() {
  632. anyhow::bail!("--clumpify is not yet supported with --hardtrim3");
  633. }
  634. if self.demux.is_some() {
  635. anyhow::bail!("--clumpify is not yet supported with --demux");
  636. }
  637. // Validate --memory format up front. Whether the resolved bin
  638. // pool is *large enough* for clumpify to actually run is decided
  639. // later in main.rs::resolve_clump_layout, which warns and falls
  640. // back to plain mode if the budget is below the floor.
  641. crate::clump::parse_memory_size(&self.memory)
  642. .map_err(|e| anyhow::anyhow!("--memory: {e}"))?;
  643. }
  645. // --passthrough: 9-item compatibility envelope. Layout mirrors --clumpify
  646. // above. Each rejection has a precise user-facing message; case-folded
  647. // collision check (1.ix) uses crate::io::norm_path to share the same
  648. // APFS/NTFS-aware normalisation as the output-collision pre-flight in
  649. // main.rs (issue #216 protection).
  650. if let Some(ref pt) = self.passthrough {
  651. // 1.i — paired-end required
  652. if !self.paired {
  653. anyhow::bail!("--passthrough requires --paired");
  654. }
  655. // 1.ii — exactly one R1/R2 pair in v1
  656. if self.input.len() != 2 {
  657. anyhow::bail!(
  658. "--passthrough requires exactly one R1/R2 pair (got {} input files); \
  659. multi-pair input with passthrough is not yet implemented",
  660. self.input.len()
  661. );
  662. }
  663. // 1.iii — strict pair semantics in v1
  664. if self.retain_unpaired {
  665. anyhow::bail!(
  666. "--passthrough is incompatible with --retain_unpaired \
  667. (passthrough requires strict pair semantics in v1)"
  668. );
  669. }
  670. // 1.iv — clumpy reorder breaks lockstep
  671. if self.clumpify {
  672. anyhow::bail!("--passthrough is not yet supported with --clumpify");
  673. }
  674. // 1.v–1.vii — specialty modes own their own input arity/output naming
  675. if self.clock {
  676. anyhow::bail!("--passthrough is not compatible with --clock");
  677. }
  678. if self.implicon.is_some() {
  679. anyhow::bail!("--passthrough is not compatible with --implicon");
  680. }
  681. if self.hardtrim5.is_some() {
  682. anyhow::bail!("--passthrough is not compatible with --hardtrim5");
  683. }
  684. if self.hardtrim3.is_some() {
  685. anyhow::bail!("--passthrough is not compatible with --hardtrim3");
  686. }
  687. if self.demux.is_some() {
  688. anyhow::bail!("--passthrough is not compatible with --demux");
  689. }
  690. // 1.viii — file must exist
  691. if !pt.exists() {
  692. anyhow::bail!("--passthrough file not found: {}", pt.display());
  693. }
  694. // 1.ix — case-folded collision with R1/R2 (issue #216-style APFS/NTFS guard).
  695. // self.input.len() == 2 here per 1.ii. The plan's main.rs::run pre-flight
  696. // catches case-only output collisions; this catches case-only INPUT aliases
  697. // where --passthrough silently dual-consumes one input on a case-insensitive
  698. // filesystem.
  699. if self.input.len() == 2 {
  700. let pt_norm = crate::io::norm_path(pt);
  701. if pt_norm == crate::io::norm_path(&self.input[0])
  702. || pt_norm == crate::io::norm_path(&self.input[1])
  703. {
  704. anyhow::bail!(
  705. "--passthrough cannot point at R1 or R2 (case-insensitive match \
  706. on APFS/NTFS): {} aliases an input file",
  707. pt.display()
  708. );
  709. }
  710. }
  711. }
  713. if let Some(n) = self.hardtrim5
  714. && (n == 0 || n >= 1000)
  715. {
  716. anyhow::bail!("--hardtrim5 must be between 1 and 999, got {}", n);
  717. }
  718. if let Some(n) = self.hardtrim3
  719. && (n == 0 || n >= 1000)
  720. {
  721. anyhow::bail!("--hardtrim3 must be between 1 and 999, got {}", n);
  722. }
  723. if self.clock {
  724. self.validate_paired_input("--clock")?;
  725. }
  726. if self.implicon.is_some() {
  727. self.validate_paired_input("--implicon")?;
  728. }
  729. if let Some(ref demux_file) = self.demux {
  730. if self.paired {
  731. anyhow::bail!("Demultiplexing is only allowed for single-end files");
  732. }
  733. if !demux_file.exists() {
  734. anyhow::bail!("Barcode file not found: {}", demux_file.display());
  735. }
  736. }
  738. // Check input files exist
  739. for path in &self.input {
  740. if !path.exists() {
  741. anyhow::bail!("Input file not found: {}", path.display());
  742. }
  743. }
  745. // Deprecation warnings for Perl-era flags
  746. if self.gzip {
  747. eprintln!(
  748. "WARNING: --gzip is deprecated in Trim Galore v2.0. Output is gzipped by default. Use --dont_gzip to disable. Ignoring."
  749. );
  750. }
  751. if self.path_to_cutadapt.is_some() {
  752. eprintln!(
  753. "WARNING: --path_to_cutadapt is deprecated in Trim Galore v2.0 (no external Cutadapt needed). Ignoring."
  754. );
  755. }
  756. if self.cutadapt_args.is_some() {
  757. eprintln!(
  758. "WARNING: --cutadapt_args is deprecated in Trim Galore v2.0 (no external Cutadapt needed). Ignoring."
  759. );
  760. eprintln!(" Note: --discard-untrimmed is now a native flag.");
  761. }
  762. if self.suppress_warn {
  763. eprintln!(
  764. "WARNING: --suppress_warn is deprecated in Trim Galore v2.0 (no Cutadapt subprocess). Ignoring."
  765. );
  766. }
  767. if self.keep {
  768. eprintln!(
  769. "WARNING: --keep is not yet supported in Trim Galore v2.0. RRBS reads below length cutoff will be removed. Ignoring."
  770. );
  771. }
  773. Ok(())
  774. }
  776. /// Get the Phred encoding offset.
  777. pub fn phred_offset(&self) -> u8 {
  778. if self.phred64 { 64 } else { 33 }
  779. }
  781. /// Get the effective quality cutoff value.
  782. ///
  783. /// If `--nextseq` is set, uses that value as the cutoff.
  784. /// Otherwise uses the standard `--quality` value.
  785. pub fn effective_quality_cutoff(&self) -> u8 {
  786. self.nextseq.unwrap_or(self.quality)
  787. }
  788. }
  790. #[cfg(test)]
  791. mod tests {
  792. use super::*;
  793. use clap::Parser;
  795. // All fixtures live in test_files/ and are guaranteed to exist under the
  796. // repo root during `cargo test` (cwd = crate root).
  797. const R1: &str = "test_files/BS-seq_10K_R1.fastq.gz";
  798. const R2: &str = "test_files/BS-seq_10K_R2.fastq.gz";
  799. const ALT_R1: &str = "test_files/SRR24766921_RRBS_R1.fastq.gz";
  800. const ALT_R2: &str = "test_files/SRR24766921_RRBS_R2.fastq.gz";
  802. #[test]
  803. fn test_validate_paired_odd_count_rejected() {
  804. // N=1 with --paired is INTENTIONALLY accepted by validate() — it's
  805. // the new paired-uBAM-interleaved entry point (one BAM file containing
  806. // R1/R2 records interleaved). The "is it actually a BAM?" check
  807. // happens in main.rs after format detection.
  808. // See plans/06252026_ubam-input-support/PLAN.md §3.3.
  809. for inputs in [vec![R1, R2, ALT_R1], vec![R1, R2, ALT_R1, ALT_R2, R1]] {
  810. let mut argv = vec!["trim_galore", "--paired"];
  811. argv.extend(inputs.iter().copied());
  812. let cli = Cli::parse_from(argv);
  813. let err = cli.validate().unwrap_err().to_string();
  814. assert!(
  815. err.contains("even number of input files"),
  816. "expected even-number error, got: {err}"
  817. );
  818. }
  819. }
  821. // ── parse_sam_tag_name (PLAN §5 step 4.3, T16) ──────────────────────
  822. // Both code reviewers flagged the absence of these tests; ~10 LOC to
  823. // lock the validator's contract.
  825. #[test]
  826. fn parse_sam_tag_name_accepts_canonical_two_char() {
  827. assert_eq!(parse_sam_tag_name("CB").unwrap(), "CB");
  828. assert_eq!(parse_sam_tag_name("UB").unwrap(), "UB");
  829. assert_eq!(parse_sam_tag_name("RX").unwrap(), "RX");
  830. assert_eq!(parse_sam_tag_name("A0").unwrap(), "A0");
  831. assert_eq!(parse_sam_tag_name("Zz").unwrap(), "Zz");
  832. }
  834. #[test]
  835. fn parse_sam_tag_name_rejects_all_keyword() {
  836. // PLAN §5 step 4.3 — `ALL` is reserved for a future release.
  837. assert!(parse_sam_tag_name("ALL").is_err());
  838. }
  840. #[test]
  841. fn parse_sam_tag_name_rejects_wrong_length() {
  842. assert!(parse_sam_tag_name("X").is_err());
  843. assert!(parse_sam_tag_name("ABC").is_err());
  844. assert!(parse_sam_tag_name("").is_err());
  845. }
  847. #[test]
  848. fn parse_sam_tag_name_rejects_leading_non_alpha() {
  849. // SAM spec: tags match [A-Za-z][A-Za-z0-9]. Leading digit invalid.
  850. assert!(parse_sam_tag_name("1A").is_err());
  851. assert!(parse_sam_tag_name("9X").is_err());
  852. }
  854. #[test]
  855. fn parse_sam_tag_name_rejects_non_alphanumeric() {
  856. assert!(parse_sam_tag_name("A_").is_err());
  857. assert!(parse_sam_tag_name("A-").is_err());
  858. assert!(parse_sam_tag_name(" A").is_err());
  859. }
  861. #[test]
  862. fn test_validate_paired_single_input_accepted_at_validate_layer() {
  863. // The v3 paired-uBAM change: `--paired SINGLE.bam` is structurally
  864. // legal at the validate() layer. main.rs runs format detection and
  865. // errors if SINGLE.bam turns out to be FASTQ (test that path is
  866. // covered by integration tests, not here).
  867. let cli = Cli::parse_from(["trim_galore", "--paired", R1]);
  868. assert!(
  869. cli.validate().is_ok(),
  870. "--paired with N=1 must be accepted at the structural-validation layer"
  871. );
  872. }
  874. #[test]
  875. fn test_validate_paired_r1_r2_equal_rejected_within_pair() {
  876. let cli = Cli::parse_from(["trim_galore", "--paired", R1, R1]);
  877. let err = cli.validate().unwrap_err().to_string();
  878. assert!(
  879. err.contains("appear to be the same file"),
  880. "expected within-pair duplicate error, got: {err}"
  881. );
  882. }
  884. #[test]
  885. fn test_validate_paired_duplicate_pair_rejected_across_pairs() {
  886. let cli = Cli::parse_from(["trim_galore", "--paired", R1, R2, R1, R2]);
  887. let err = cli.validate().unwrap_err().to_string();
  888. assert!(
  889. err.contains("duplicate of pair"),
  890. "expected cross-pair duplicate error, got: {err}"
  891. );
  892. }
  894. #[test]
  895. fn test_validate_paired_basename_rejected_multi_pair() {
  896. let cli = Cli::parse_from([
  897. "trim_galore",
  898. "--paired",
  899. "--basename",
  900. "foo",
  901. R1,
  902. R2,
  903. ALT_R1,
  904. ALT_R2,
  905. ]);
  906. let err = cli.validate().unwrap_err().to_string();
  907. assert!(
  908. err.contains("basename cannot be used with multiple"),
  909. "expected multi-pair basename rejection, got: {err}"
  910. );
  911. }
  913. #[test]
  914. fn test_validate_paired_single_end_basename_still_allowed() {
  915. // Regression guard: SE `--basename` with a single input must still pass.
  916. let cli = Cli::parse_from(["trim_galore", "--basename", "foo", R1]);
  917. cli.validate()
  918. .expect("SE --basename with one input should validate");
  919. }
  921. #[test]
  922. fn test_validate_paired_two_files_accepted() {
  923. // Regression guard: the 2-file golden path must keep working.
  924. let cli = Cli::parse_from(["trim_galore", "--paired", R1, R2]);
  925. cli.validate().expect("two-file paired-end should validate");
  926. }
  928. // ── Multi-pair widening for --clock and --implicon ──
  929. // (Replaces the earlier "strict-2" regression guard. Specialty
  930. // run-and-exit modes now share the same pairwise validation as
  931. // --paired itself.)
  933. #[test]
  934. fn test_validate_clock_two_pairs_accepted() {
  935. let cli = Cli::parse_from(["trim_galore", "--clock", R1, R2, ALT_R1, ALT_R2]);
  936. cli.validate()
  937. .expect("two distinct pairs should validate under --clock");
  938. }
  940. #[test]
  941. fn test_validate_clock_odd_count_rejected() {
  942. let cli = Cli::parse_from(["trim_galore", "--clock", R1, R2, ALT_R1]);
  943. let err = cli.validate().unwrap_err().to_string();
  944. assert!(
  945. err.contains("--clock") && err.contains("even number"),
  946. "expected --clock even-count rejection, got: {err}"
  947. );
  948. }
  950. #[test]
  951. fn test_validate_clock_r1_equal_r2_within_pair_rejected() {
  952. let cli = Cli::parse_from(["trim_galore", "--clock", R1, R1]);
  953. let err = cli.validate().unwrap_err().to_string();
  954. assert!(
  955. err.contains("appear to be the same file"),
  956. "expected R1==R2 rejection under --clock, got: {err}"
  957. );
  958. }
  960. #[test]
  961. fn test_validate_clock_duplicate_pair_rejected() {
  962. let cli = Cli::parse_from(["trim_galore", "--clock", R1, R2, R1, R2]);
  963. let err = cli.validate().unwrap_err().to_string();
  964. assert!(
  965. err.contains("duplicate of pair"),
  966. "expected duplicate-pair rejection under --clock, got: {err}"
  967. );
  968. }
  970. #[test]
  971. fn test_validate_implicon_two_pairs_accepted() {
  972. let cli = Cli::parse_from(["trim_galore", "--implicon", R1, R2, ALT_R1, ALT_R2]);
  973. cli.validate()
  974. .expect("two distinct pairs should validate under --implicon");
  975. }
  977. #[test]
  978. fn test_validate_implicon_odd_count_rejected() {
  979. let cli = Cli::parse_from(["trim_galore", "--implicon", R1, R2, ALT_R1]);
  980. let err = cli.validate().unwrap_err().to_string();
  981. assert!(
  982. err.contains("--implicon") && err.contains("even number"),
  983. "expected --implicon even-count rejection, got: {err}"
  984. );
  985. }
  987. #[test]
  988. fn test_validate_implicon_duplicate_pair_rejected() {
  989. let cli = Cli::parse_from(["trim_galore", "--implicon", R1, R2, R1, R2]);
  990. let err = cli.validate().unwrap_err().to_string();
  991. assert!(
  992. err.contains("duplicate of pair"),
  993. "expected duplicate-pair rejection under --implicon, got: {err}"
  994. );
  995. }
  997. // ── Perl-migration short-flag rewrite (-r1 → --r1, -r2 → --r2) ──
  999. fn rewrite(args: &[&str]) -> Vec<String> {
  1000. super::rewrite_perl_short_flags(args.iter().map(|s| s.to_string()))
  1001. }
  1003. #[test]
  1004. fn test_rewrite_r1_bare() {
  1005. assert_eq!(
  1006. rewrite(&["trim_galore", "-r1", "40"]),
  1007. vec!["trim_galore", "--r1", "40"]
  1008. );
  1009. }
  1011. #[test]
  1012. fn test_rewrite_r2_bare() {
  1013. assert_eq!(
  1014. rewrite(&["trim_galore", "-r2", "35"]),
  1015. vec!["trim_galore", "--r2", "35"]
  1016. );
  1017. }
  1019. #[test]
  1020. fn test_rewrite_r1_equals_form() {
  1021. assert_eq!(
  1022. rewrite(&["trim_galore", "-r1=40"]),
  1023. vec!["trim_galore", "--r1=40"]
  1024. );
  1025. }
  1027. #[test]
  1028. fn test_rewrite_r2_equals_form() {
  1029. assert_eq!(
  1030. rewrite(&["trim_galore", "-r2=35"]),
  1031. vec!["trim_galore", "--r2=35"]
  1032. );
  1033. }
  1035. #[test]
  1036. fn test_rewrite_leaves_r_alone() {
  1037. // -r 40 is valid clap short; must not be disturbed.
  1038. assert_eq!(
  1039. rewrite(&["trim_galore", "-r", "40"]),
  1040. vec!["trim_galore", "-r", "40"]
  1041. );
  1042. }
  1044. #[test]
  1045. fn test_rewrite_leaves_r10_alone() {
  1046. // -r10 is clap's short-with-value syntax (-r=10); must not be rewritten.
  1047. assert_eq!(
  1048. rewrite(&["trim_galore", "-r10"]),
  1049. vec!["trim_galore", "-r10"]
  1050. );
  1051. }
  1053. #[test]
  1054. fn test_rewrite_leaves_r20_alone() {
  1055. // -r20 is clap's short-with-value (-r=20); not a Perl `-r2` + value.
  1056. assert_eq!(
  1057. rewrite(&["trim_galore", "-r20"]),
  1058. vec!["trim_galore", "-r20"]
  1059. );
  1060. }
  1062. #[test]
  1063. fn test_rewrite_leaves_unrelated_alone() {
  1064. assert_eq!(
  1065. rewrite(&["trim_galore", "--paired", "-a", "AGCT", "-o", "outdir"]),
  1066. vec!["trim_galore", "--paired", "-a", "AGCT", "-o", "outdir"]
  1067. );
  1068. }
  1070. #[test]
  1071. fn test_rewrite_end_to_end_via_parse_from() {
  1072. // Verify that after rewriting, Cli::parse_from successfully parses
  1073. // -r1 / -r2 style invocations (this is the whole point of the rewrite).
  1074. let args = rewrite(&[
  1075. "trim_galore",
  1076. "--paired",
  1077. "--retain_unpaired",
  1078. "-r1",
  1079. "40",
  1080. "-r2",
  1081. "30",
  1082. "test_files/BS-seq_10K_R1.fastq.gz",
  1083. "test_files/BS-seq_10K_R2.fastq.gz",
  1084. ]);
  1085. let cli = Cli::parse_from(args);
  1086. assert_eq!(cli.length_1, 40);
  1087. assert_eq!(cli.length_2, 30);
  1088. }
  1090. #[test]
  1091. fn test_rewrite_a2_bare() {
  1092. assert_eq!(
  1093. rewrite(&["trim_galore", "-a2", "GCAT"]),
  1094. vec!["trim_galore", "--a2", "GCAT"]
  1095. );
  1096. }
  1098. #[test]
  1099. fn test_rewrite_a2_equals_form() {
  1100. assert_eq!(
  1101. rewrite(&["trim_galore", "-a2=GCAT"]),
  1102. vec!["trim_galore", "--a2=GCAT"]
  1103. );
  1104. }
  1106. #[test]
  1107. fn test_rewrite_leaves_a10_alone() {
  1108. // -a10 is clap's short-with-value (-a=10) — not a Perl `-a2` construct.
  1109. // `10` isn't a valid DNA sequence but that's for validation to catch,
  1110. // not for the rewrite to mangle.
  1111. assert_eq!(
  1112. rewrite(&["trim_galore", "-a10"]),
  1113. vec!["trim_galore", "-a10"]
  1114. );
  1115. }
  1117. #[test]
  1118. fn test_rewrite_a2_end_to_end_via_parse_from() {
  1119. let args = rewrite(&[
  1120. "trim_galore",
  1121. "--paired",
  1122. "-a",
  1123. "AGCT",
  1124. "-a2",
  1125. "GCAT",
  1126. "-a2",
  1127. "AAAA",
  1128. "test_files/BS-seq_10K_R1.fastq.gz",
  1129. "test_files/BS-seq_10K_R2.fastq.gz",
  1130. ]);
  1131. let cli = Cli::parse_from(args);
  1132. assert_eq!(cli.adapter, vec!["AGCT"]);
  1133. assert_eq!(cli.adapter2, vec!["GCAT", "AAAA"]);
  1134. }
  1136. /// Perl `trim_galore` accepts the lowercase clip-flag spellings
  1137. /// (`--clip_r1` / `--clip_r2` / `--three_prime_clip_r1` /
  1138. /// `--three_prime_clip_r2`) alongside the uppercase forms. The Rust port
  1139. /// historically only matched the uppercase canonical, breaking every
  1140. /// Perl-era pipeline using the lowercase spelling. Regression for #242.
  1141. #[test]
  1142. fn test_clip_flags_accept_lowercase_aliases() {
  1143. let cli = Cli::parse_from([
  1144. "trim_galore",
  1145. "--paired",
  1146. "--clip_r1",
  1147. "5",
  1148. "--clip_r2",
  1149. "6",
  1150. "--three_prime_clip_r1",
  1151. "7",
  1152. "--three_prime_clip_r2",
  1153. "8",
  1154. R1,
  1155. R2,
  1156. ]);
  1157. assert_eq!(cli.clip_r1, Some(5));
  1158. assert_eq!(cli.clip_r2, Some(6));
  1159. assert_eq!(cli.three_prime_clip_r1, Some(7));
  1160. assert_eq!(cli.three_prime_clip_r2, Some(8));
  1162. // The canonical uppercase forms must of course still work. Mix a few
  1163. // to confirm both aliases resolve to the same field.
  1164. let cli = Cli::parse_from([
  1165. "trim_galore",
  1166. "--paired",
  1167. "--clip_R1",
  1168. "1",
  1169. "--clip_r2",
  1170. "2",
  1171. "--three_prime_clip_R1",
  1172. "3",
  1173. "--three_prime_clip_r2",
  1174. "4",
  1175. R1,
  1176. R2,
  1177. ]);
  1178. assert_eq!(cli.clip_r1, Some(1));
  1179. assert_eq!(cli.clip_r2, Some(2));
  1180. assert_eq!(cli.three_prime_clip_r1, Some(3));
  1181. assert_eq!(cli.three_prime_clip_r2, Some(4));
  1182. }
  1184. // ── --clumpify / --compression validation ────────────────────────────
  1186. #[test]
  1187. fn test_clumpify_requires_cores_at_least_two() {
  1188. let cli = Cli::parse_from(["trim_galore", "--clumpify", "--cores", "1", R1]);
  1189. let err = cli.validate().unwrap_err().to_string();
  1190. assert!(
  1191. err.contains("--clumpify requires --cores >= 2"),
  1192. "got: {err}"
  1193. );
  1194. }
  1196. #[test]
  1197. fn test_clumpify_rejects_dont_gzip() {
  1198. let cli = Cli::parse_from([
  1199. "trim_galore",
  1200. "--clumpify",
  1201. "--cores",
  1202. "2",
  1203. "--dont_gzip",
  1204. R1,
  1205. ]);
  1206. let err = cli.validate().unwrap_err().to_string();
  1207. assert!(err.contains("--dont_gzip"), "got: {err}");
  1208. }
  1210. #[test]
  1211. fn test_clumpify_rejects_clock() {
  1212. let cli = Cli::parse_from([
  1213. "trim_galore",
  1214. "--clumpify",
  1215. "--cores",
  1216. "2",
  1217. "--clock",
  1218. R1,
  1219. R2,
  1220. ]);
  1221. let err = cli.validate().unwrap_err().to_string();
  1222. assert!(err.contains("--clock"), "got: {err}");
  1223. }
  1225. #[test]
  1226. fn test_clumpify_rejects_implicon() {
  1227. let cli = Cli::parse_from([
  1228. "trim_galore",
  1229. "--clumpify",
  1230. "--cores",
  1231. "2",
  1232. "--implicon=8",
  1233. R1,
  1234. R2,
  1235. ]);
  1236. let err = cli.validate().unwrap_err().to_string();
  1237. assert!(err.contains("--implicon"), "got: {err}");
  1238. }
  1240. #[test]
  1241. fn test_clumpify_rejects_hardtrim5() {
  1242. let cli = Cli::parse_from([
  1243. "trim_galore",
  1244. "--clumpify",
  1245. "--cores",
  1246. "2",
  1247. "--hardtrim5",
  1248. "30",
  1249. R1,
  1250. ]);
  1251. let err = cli.validate().unwrap_err().to_string();
  1252. assert!(err.contains("--hardtrim5"), "got: {err}");
  1253. }
  1255. #[test]
  1256. fn test_clumpify_accepts_paired() {
  1257. let cli = Cli::parse_from([
  1258. "trim_galore",
  1259. "--clumpify",
  1260. "--cores",
  1261. "4",
  1262. "--paired",
  1263. R1,
  1264. R2,
  1265. ]);
  1266. cli.validate()
  1267. .expect("clumpify + paired + cores=4 should validate");
  1268. }
  1270. #[test]
  1271. fn test_clumpify_rejects_garbage_memory() {
  1272. let cli = Cli::parse_from([
  1273. "trim_galore",
  1274. "--clumpify",
  1275. "--cores",
  1276. "2",
  1277. "--memory",
  1278. "garbage",
  1279. R1,
  1280. ]);
  1281. let err = cli.validate().unwrap_err().to_string();
  1282. assert!(err.contains("--memory"), "got: {err}");
  1283. }
  1285. #[test]
  1286. fn test_clumpify_too_small_memory_passes_validation() {
  1287. // Validation now accepts a too-small --memory; main.rs resolves the
  1288. // layout at runtime and either succeeds, or warns + falls back to
  1289. // plain mode. This avoids hard-failing a job over a configuration
  1290. // detail the program can recover from.
  1291. let cli = Cli::parse_from([
  1292. "trim_galore",
  1293. "--clumpify",
  1294. "--cores",
  1295. "16",
  1296. "--memory",
  1297. "64M",
  1298. R1,
  1299. ]);
  1300. cli.validate()
  1301. .expect("validation should pass; runtime warns and falls back to plain");
  1302. }
  1304. #[test]
  1305. fn test_compression_defaults_to_one() {
  1306. let cli = Cli::parse_from(["trim_galore", R1]);
  1307. assert_eq!(cli.compression, 1);
  1308. }
  1310. #[test]
  1311. fn test_compression_explicit_level() {
  1312. let cli = Cli::parse_from(["trim_galore", "--compression", "9", R1]);
  1313. assert_eq!(cli.compression, 9);
  1314. }
  1316. #[test]
  1317. fn test_compression_rejects_out_of_range() {
  1318. let result = Cli::try_parse_from(["trim_galore", "--compression", "10", R1]);
  1319. assert!(result.is_err(), "level 10 should be rejected by clap");
  1320. }
  1322. #[test]
  1323. fn test_clumpify_with_compression_six() {
  1324. let cli = Cli::parse_from([
  1325. "trim_galore",
  1326. "--clumpify",
  1327. "--compression",
  1328. "6",
  1329. "--cores",
  1330. "2",
  1331. R1,
  1332. ]);
  1333. cli.validate()
  1334. .expect("clumpify --compression 6 should validate");
  1335. assert!(cli.clumpify);
  1336. assert_eq!(cli.compression, 6);
  1337. }
  1339. // ── --passthrough validation (plan v2 Step 1) ─────────────────────────
  1340. //
  1341. // The third fixture used as the "passthrough" target — any existing
  1342. // test_files/ FASTQ works since we never trim it in validation; we just
  1343. // need a real path so step 1.viii (file exists) is satisfied.
  1344. const PT: &str = "test_files/SRR24766921_RRBS_R2.fastq.gz";
  1346. #[test]
  1347. fn test_passthrough_paired_pair_accepted() {
  1348. let cli = Cli::parse_from(["trim_galore", "--paired", "--passthrough", PT, R1, R2]);
  1349. cli.validate()
  1350. .expect("--passthrough with one R1/R2 pair should validate");
  1351. assert_eq!(cli.passthrough.as_deref(), Some(std::path::Path::new(PT)));
  1352. }
  1354. #[test]
  1355. fn test_passthrough_requires_paired() {
  1356. let cli = Cli::parse_from(["trim_galore", "--passthrough", PT, R1]);
  1357. let err = cli.validate().unwrap_err().to_string();
  1358. assert!(
  1359. err.contains("--passthrough requires --paired"),
  1360. "got: {err}"
  1361. );
  1362. }
  1364. #[test]
  1365. fn test_passthrough_rejects_multi_pair() {
  1366. let cli = Cli::parse_from([
  1367. "trim_galore",
  1368. "--paired",
  1369. "--passthrough",
  1370. PT,
  1371. R1,
  1372. R2,
  1373. ALT_R1,
  1374. ALT_R2,
  1375. ]);
  1376. let err = cli.validate().unwrap_err().to_string();
  1377. assert!(
  1378. err.contains("--passthrough requires exactly one R1/R2 pair"),
  1379. "got: {err}"
  1380. );
  1381. }
  1383. #[test]
  1384. fn test_passthrough_rejects_retain_unpaired() {
  1385. let cli = Cli::parse_from([
  1386. "trim_galore",
  1387. "--paired",
  1388. "--retain_unpaired",
  1389. "--passthrough",
  1390. PT,
  1391. R1,
  1392. R2,
  1393. ]);
  1394. let err = cli.validate().unwrap_err().to_string();
  1395. assert!(err.contains("--retain_unpaired"), "got: {err}");
  1396. }
  1398. #[test]
  1399. fn test_passthrough_rejects_clumpify() {
  1400. let cli = Cli::parse_from([
  1401. "trim_galore",
  1402. "--paired",
  1403. "--clumpify",
  1404. "--cores",
  1405. "2",
  1406. "--passthrough",
  1407. PT,
  1408. R1,
  1409. R2,
  1410. ]);
  1411. let err = cli.validate().unwrap_err().to_string();
  1412. assert!(err.contains("--clumpify"), "got: {err}");
  1413. }
  1415. #[test]
  1416. fn test_passthrough_rejects_clock() {
  1417. let cli = Cli::parse_from([
  1418. "trim_galore",
  1419. "--paired",
  1420. "--clock",
  1421. "--passthrough",
  1422. PT,
  1423. R1,
  1424. R2,
  1425. ]);
  1426. let err = cli.validate().unwrap_err().to_string();
  1427. assert!(err.contains("--clock"), "got: {err}");
  1428. }
  1430. #[test]
  1431. fn test_passthrough_rejects_implicon() {
  1432. let cli = Cli::parse_from([
  1433. "trim_galore",
  1434. "--paired",
  1435. "--implicon=8",
  1436. "--passthrough",
  1437. PT,
  1438. R1,
  1439. R2,
  1440. ]);
  1441. let err = cli.validate().unwrap_err().to_string();
  1442. assert!(err.contains("--implicon"), "got: {err}");
  1443. }
  1445. #[test]
  1446. fn test_passthrough_rejects_hardtrim5() {
  1447. let cli = Cli::parse_from([
  1448. "trim_galore",
  1449. "--paired",
  1450. "--hardtrim5",
  1451. "30",
  1452. "--passthrough",
  1453. PT,
  1454. R1,
  1455. R2,
  1456. ]);
  1457. let err = cli.validate().unwrap_err().to_string();
  1458. assert!(err.contains("--hardtrim5"), "got: {err}");
  1459. }
  1461. #[test]
  1462. fn test_passthrough_rejects_hardtrim3() {
  1463. let cli = Cli::parse_from([
  1464. "trim_galore",
  1465. "--paired",
  1466. "--hardtrim3",
  1467. "30",
  1468. "--passthrough",
  1469. PT,
  1470. R1,
  1471. R2,
  1472. ]);
  1473. let err = cli.validate().unwrap_err().to_string();
  1474. assert!(err.contains("--hardtrim3"), "got: {err}");
  1475. }
  1477. #[test]
  1478. fn test_passthrough_rejects_demux() {
  1479. // --demux conflicts with --paired in existing validation, but the
  1480. // --passthrough vs --demux check must fire BEFORE that — confirm the
  1481. // error message is the passthrough-specific one. (single-end input
  1482. // shape because --demux requires single-end.)
  1483. let cli = Cli::parse_from([
  1484. "trim_galore",
  1485. "--demux",
  1486. "test_files/demux_test_samplesheet.txt",
  1487. "--passthrough",
  1488. PT,
  1489. R1,
  1490. ]);
  1491. // With single-end input + --passthrough we hit 1.i ("requires --paired")
  1492. // FIRST. To exercise the --demux check specifically, we'd need --paired
  1493. // + --demux, which clap rejects at the --demux validation step itself.
  1494. // The 1.i error is sufficient evidence the validation chain runs.
  1495. let err = cli.validate().unwrap_err().to_string();
  1496. assert!(
  1497. err.contains("--passthrough requires --paired") || err.contains("--demux"),
  1498. "got: {err}"
  1499. );
  1500. }
  1502. #[test]
  1503. fn test_passthrough_rejects_missing_file() {
  1504. let cli = Cli::parse_from([
  1505. "trim_galore",
  1506. "--paired",
  1507. "--passthrough",
  1508. "test_files/this_does_not_exist.fastq.gz",
  1509. R1,
  1510. R2,
  1511. ]);
  1512. let err = cli.validate().unwrap_err().to_string();
  1513. assert!(err.contains("--passthrough file not found"), "got: {err}");
  1514. }
  1516. #[test]
  1517. fn test_passthrough_rejects_pointing_at_r1() {
  1518. // 1.ix collision check: the byte-equal case is the strict subset of
  1519. // case-folded equality, so this also covers the case-folded path —
  1520. // norm_path() is a single `to_ascii_lowercase()` call which is
  1521. // trivially correct (and exercised by io::tests in its own right).
  1522. // True cross-case testing would need a case-insensitive filesystem
  1523. // which CI doesn't guarantee.
  1524. let cli = Cli::parse_from(["trim_galore", "--paired", "--passthrough", R1, R1, R2]);
  1525. let err = cli.validate().unwrap_err().to_string();
  1526. assert!(err.contains("cannot point at R1 or R2"), "got: {err}");
  1527. }
  1529. #[test]
  1530. fn test_passthrough_rejects_pointing_at_r2() {
  1531. let cli = Cli::parse_from(["trim_galore", "--paired", "--passthrough", R2, R1, R2]);
  1532. let err = cli.validate().unwrap_err().to_string();
  1533. assert!(err.contains("cannot point at R1 or R2"), "got: {err}");
  1534. }
  1536. // ── --output-format (PLAN v2.1 §3.4a) ─────────────────────────────────
  1538. #[test]
  1539. fn output_format_default_is_fastq() {
  1540. let cli = Cli::parse_from(["trim_galore", R1]);
  1541. assert_eq!(cli.output_format, OutputFormat::Fastq);
  1542. }
  1544. #[test]
  1545. fn output_format_ubam_parses() {
  1546. let cli = Cli::parse_from(["trim_galore", "--output-format", "ubam", R1]);
  1547. assert_eq!(cli.output_format, OutputFormat::UBam);
  1548. }
  1550. #[test]
  1551. fn output_format_unknown_value_rejected() {
  1552. let r = Cli::try_parse_from(["trim_galore", "--output-format", "binseq", R1]);
  1553. assert!(r.is_err(), "BINSEQ is deferred in v1 — clap must reject it");
  1554. }
  1556. #[test]
  1557. fn output_format_ubam_alone_validates() {
  1558. let cli = Cli::parse_from(["trim_galore", "--output-format", "ubam", R1]);
  1559. cli.validate()
  1560. .expect("plain --output-format ubam must validate");
  1561. }
  1563. #[test]
  1564. fn output_format_ubam_plus_clumpify_rejected() {
  1565. let cli = Cli::parse_from([
  1566. "trim_galore",
  1567. "--output-format",
  1568. "ubam",
  1569. "--clumpify",
  1570. "--cores",
  1571. "2",
  1572. R1,
  1573. ]);
  1574. let err = cli.validate().unwrap_err().to_string();
  1575. assert!(
  1576. err.contains("--clumpify") && err.contains("--output-format ubam"),
  1577. "expected clumpify+ubam rejection, got: {err}"
  1578. );
  1579. }
  1581. #[test]
  1582. fn output_format_ubam_plus_passthrough_rejected() {
  1583. let cli = Cli::parse_from([
  1584. "trim_galore",
  1585. "--paired",
  1586. "--output-format",
  1587. "ubam",
  1588. "--passthrough",
  1589. ALT_R1,
  1590. R1,
  1591. R2,
  1592. ]);
  1593. let err = cli.validate().unwrap_err().to_string();
  1594. assert!(
  1595. err.contains("--passthrough") && err.contains("--output-format ubam"),
  1596. "expected passthrough+ubam rejection, got: {err}"
  1597. );
  1598. }
  1600. #[test]
  1601. fn output_format_ubam_plus_clock_rejected() {
  1602. let cli = Cli::parse_from(["trim_galore", "--clock", "--output-format", "ubam", R1, R2]);
  1603. let err = cli.validate().unwrap_err().to_string();
  1604. assert!(
  1605. err.contains("--clock") && err.contains("--output-format ubam"),
  1606. "expected clock+ubam rejection, got: {err}"
  1607. );
  1608. }
  1610. #[test]
  1611. fn output_format_ubam_plus_implicon_rejected() {
  1612. let cli = Cli::parse_from([
  1613. "trim_galore",
  1614. "--paired",
  1615. "--implicon",
  1616. "8",
  1617. "--output-format",
  1618. "ubam",
  1619. R1,
  1620. R2,
  1621. ]);
  1622. let err = cli.validate().unwrap_err().to_string();
  1623. assert!(
  1624. err.contains("--implicon") && err.contains("--output-format ubam"),
  1625. "expected implicon+ubam rejection, got: {err}"
  1626. );
  1627. }
  1629. #[test]
  1630. fn output_format_ubam_plus_retain_unpaired_rejected() {
  1631. // PLAN v2.1 §3.4a addendum: --retain_unpaired produces additional
  1632. // FASTQ files (`*_unpaired_{1,2}.fq.gz`); multi-output BAM is out of
  1633. // scope for v1.
  1634. let cli = Cli::parse_from([
  1635. "trim_galore",
  1636. "--paired",
  1637. "--retain_unpaired",
  1638. "--output-format",
  1639. "ubam",
  1640. R1,
  1641. R2,
  1642. ]);
  1643. let err = cli.validate().unwrap_err().to_string();
  1644. assert!(
  1645. err.contains("--retain_unpaired") && err.contains("--output-format ubam"),
  1646. "expected retain_unpaired+ubam rejection, got: {err}"
  1647. );
  1648. }
  1650. #[test]
  1651. fn output_format_ubam_plus_demux_rejected() {
  1652. // --demux takes a barcode-file path; any path string suffices for parser.
  1653. let cli = Cli::parse_from([
  1654. "trim_galore",
  1655. "--demux",
  1656. "test_files/demux_test_samplesheet.txt",
  1657. "--output-format",
  1658. "ubam",
  1659. R1,
  1660. ]);
  1661. let err = cli.validate().unwrap_err().to_string();
  1662. assert!(
  1663. err.contains("--demux") && err.contains("--output-format ubam"),
  1664. "expected demux+ubam rejection, got: {err}"
  1665. );
  1666. }
  1667. }

cli.rs at commit c6528e5, under GPL-3.0 · at the source

Overview

Authors: Annika Mordelt1,2, Imke M.E. Schuurmans1, Nicky Scheefhals1, Marina P. Hommersom1, Koen Slottje1, Kimberly Mast1, Mara Graziani1,2, Carlos O. González1,2, Klaas W. Mulder3, Laura J.A. Wingens3, Dirk Schubert1,2, Nael Nadif Kasri1,2, Lot D. de Witte1,2,4
ORCID iDs: Lot D. de Witte
  1. Radboud University Medical Center, Department of Human Genetics, Nijmegen, the Netherlands
  2. Donders Institute for Brain, Cognition and Behaviour, Medical Neuroscience Department, Nijmegen, the Netherlands
  3. Department of Molecular Developmental Biology, Radboud Single Cell Center, Radboud University, Nijmegen, the Netherlands
  4. Radboud University Medical Center, Department of Psychiatry, Nijmegen, the Netherlands
Institutions: Radboud University Medical Center (Netherlands); Donders Institute for Brain, Cognition and Behaviour (Netherlands); Radboud University Nijmegen (Netherlands)
Journal: Stem cell reports, volume 21, issue 9, article 103053
Dates: received 18 November 2025; accepted 23 July 2026; published online 20 August 2026; in print September 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.stemcr.2026.103053 · PMID 42624101 · PMCID PMC13555563 · OpenAlex W7203834369
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), cellular / molecular (subfield)
Methods: Statistics, Evoked potentials, Single-unit activity, calcium imaging
Keywords: microglia, neurons, iPSC, differentiation, protocol, co-culture, long-term, neuron-microglia communications, neuro-immune interactions
MeSH: Cell Differentiation*, Induced Pluripotent Stem Cells*, Microglia*, Nerve Net*, Neurons*, Astrocytes, Cells, Cultured, Coculture Techniques, Humans, Membrane Proteins, Receptors, Purinergic P2Y12 (* major topic)
Journal subjects: Resource
Topic: Neuroinflammation and Neurodegeneration Mechanisms (Neurology, Neuroscience), according to OpenAlex
Funding: Simons Foundation (00010410); ZonMw (09120012110034)
Citations: not cited yet (Europe PMC); 53 references in the paper
Research resources: CX3CR1-APC RRID:AB_11125577, CD43-PE (clone 10G7) RRID:AB_1877299, Anti-GFAP, rabbit polyclonal RRID:AB_2109645, Anti-MAP2, guinea pig polyclonal RRID:AB_2147440, Anti-Synapsin I, rabbit polyclonal RRID:AB_2200400, Anti-P2RY12, rabbit polyclonal RRID:AB_2337543, Anti-Ankyrin-G, mouse monoclonal RRID:AB_2533145, Anti-CX3CR1, rabbit polyclonal RRID:AB_2538394, CD24-PE Cyanine7 RRID:AB_2561736, RRID:AB_2566782, GFAP-BV421 RRID:AB_2734370, P2RY12-BV421 RRID:AB_2750213, CD11b-PE RRID:AB_314152, CD206-APC RRID:AB_393992, CD45-PE/Cyanine7 RRID:AB_493729, Anti-Homer1b/c, mouse monoclonal RRID:AB_887730, Lentiviral Ngn2 overexpression construct RRID:Addgene_198754, Lentiviral rtTA construct RRID:Addgene_198756, RRID:Addgene_20945, Human: HPSI0314i-hoik_1 hiPSC RRID:CVCL_TBD, Human: WTC-11 hiPSC RRID:CVCL_Y803, R v4.2.0 / RStudio RRID:SCR_001905, GraphPad Prism v8.0.0 RRID:SCR_002798, STAR aligner RRID:SCR_004463, Seurat v4.3.0 RRID:SCR_007322, Trim Galore RRID:SCR_011847, FastQC RRID:SCR_014583, MultiQC RRID:SCR_014982, Kaluza C Analysis Software RRID:SCR_016182, Salmon RRID:SCR_017036, Harmony v1.2.3 RRID:SCR_023206, Cell Ranger v9.0.0 RRID:SCR_023221

Abstract

Microglia-neuron interactions play a key role in a variety of central nervous system disorders. Technologies using human induced pluripotent stem cells (hiPSCs) have been developed to model human brain cells with the goal to understand their function. To effectively study neuro-immune crosstalk and investigate microglial contributions to neuronal network development and function, both microglia and neurons should co-mature allowing for long-term interactions throughout their differentiation. Here, we present a co-maturation protocol that robustly generates glutamatergic neuronal networks containing hiPSC-derived microglia. We validated the long-term co-cultures using single-cell transcriptomics, imaging, and neuronal activity readouts.

In this protocol, astrocytes were required for long-term survival of microglia and for their integration into neuronal networks. Our co-maturation approach induced the typical ramified microglia morphology and characteristic microglia-neuron interactions. Homeostatic markers such as P2RY12 and TMEM119 and neuronal remodeling-associated genes were upregulated compared to microglia monocultures, highlighting the necessity of the environment to generate and maintain the context-dependent microglia signature in vitro. In this manuscript, we include the full optimization process of our co-maturation approach, a comprehensive description of the protocol, practical guidelines, and troubleshooting tips. Our co-maturation model provides a powerful tool to assess the role of human microglia in modulating neuronal function and development in health and disease.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 1 match between paragraphs and lines of code.

FelixKrueger/TrimGalore

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: c6528e54512e0e388a392d36475291bcbf0eb0dd, 27 June 2026
Languages: Rust (24), TypeScript (2), Shell (2), Python (1)
Size: 267 files, 29 scripts
Software Heritage: not archived
Found in: the text, “Key resources table”
Holds: README, license file, CITATION.cff, environment (Dockerfile), tests, continuous integration, documentation
Tools: Matplotlib (1 file), SAMtools (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
31 files
At the source: github.com/FelixKrueger/TrimGalore

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 29 scripts, each with its path and the digest of its content;
  • 1 match between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data and code availability

• Source data of transcriptomic and MEA analyses underlying Figures 2, 4, and 5 are available in Table S2. • The raw single-cell RNA-seq data are deposited in the GEO repository (GSE339528). • All other raw datasets generated during the current study are available from the lead author on reasonable request.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 2, 28 September 2026

  • Authors: added Lot D. de Witte (0000-0002-7235-9958); removed Lot D. de Witte

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 13 authors, 9 keywords, 11 MeSH terms, 2 funders, 53 references, 32 RRIDs.

Cite

This paper

Mordelt, A., Schuurmans, I. M., Scheefhals, N., Hommersom, M. P., Slottje, K., Mast, K., Graziani, M., González, C. O., Mulder, K. W., Wingens, L. J., Schubert, D., Nadif Kasri, N., & de Witte, L. D. (2026). Development and validation of a long-term co-maturation protocol for human stem cell-derived microglia and neuronal networks. Stem cell reports, 21(9), 103053. https://doi.org/10.1016/j.stemcr.2026.103053

BibTeX

@article{mordelt2026development,
author = {Mordelt, Annika and Schuurmans, Imke M.E. and Scheefhals, Nicky and Hommersom, Marina P. and Slottje, Koen and Mast, Kimberly and Graziani, Mara and González, Carlos O. and Mulder, Klaas W. and Wingens, Laura J.A. and Schubert, Dirk and Nadif Kasri, Nael and de Witte, Lot D.},
title = {{Development and validation of a long-term co-maturation protocol for human stem cell-derived microglia and neuronal networks}},
journal = {Stem cell reports},
year = {2026},
month = aug,
volume = {21},
number = {9},
pages = {103053},
publisher = {Elsevier},
issn = {2213-6711},
doi = {10.1016/j.stemcr.2026.103053},
url = {https://doi.org/10.1016/j.stemcr.2026.103053},
pmid = {42624101},
pmcid = {PMC13555563}
}

RIS

TY - JOUR
AU - Mordelt, Annika
AU - Schuurmans, Imke M.E.
AU - Scheefhals, Nicky
AU - Hommersom, Marina P.
AU - Slottje, Koen
AU - Mast, Kimberly
AU - Graziani, Mara
AU - González, Carlos O.
AU - Mulder, Klaas W.
AU - Wingens, Laura J.A.
AU - Schubert, Dirk
AU - Nadif Kasri, Nael
AU - de Witte, Lot D.
TI - Development and validation of a long-term co-maturation protocol for human stem cell-derived microglia and neuronal networks
T2 - Stem cell reports
J2 - Stem Cell Reports
PY - 2026
DA - 2026/08/20
VL - 21
IS - 9
SP - 103053
SN - 2213-6711
PB - Elsevier
DO - 10.1016/j.stemcr.2026.103053
UR - https://doi.org/10.1016/j.stemcr.2026.103053
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.stemcr.2026.103053",
"type": "article-journal",
"title": "Development and validation of a long-term co-maturation protocol for human stem cell-derived microglia and neuronal networks",
"container-title": "Stem cell reports",
"author": [
{
"family": "Mordelt",
"given": "Annika"
},
{
"family": "Schuurmans",
"given": "Imke M.E."
},
{
"family": "Scheefhals",
"given": "Nicky"
},
{
"family": "Hommersom",
"given": "Marina P."
},
{
"family": "Slottje",
"given": "Koen"
},
{
"family": "Mast",
"given": "Kimberly"
},
{
"family": "Graziani",
"given": "Mara"
},
{
"family": "González",
"given": "Carlos O."
},
{
"family": "Mulder",
"given": "Klaas W."
},
{
"family": "Wingens",
"given": "Laura J.A."
},
{
"family": "Schubert",
"given": "Dirk"
},
{
"family": "Nadif Kasri",
"given": "Nael"
},
{
"family": "de Witte",
"given": "Lot D."
}
],
"container-title-short": "Stem Cell Reports",
"volume": "21",
"issue": "9",
"page": "103053",
"DOI": "10.1016/j.stemcr.2026.103053",
"PMID": "42624101",
"PMCID": "PMC13555563",
"ISSN": "2213-6711",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.stemcr.2026.103053",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
20
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1016/j.neuron.2026.07.007 [code]
Human-specific SRGAP2 paralogs synchronize neotenic microglial maturation and synaptic development.
Journal: Neuron
In common: 8 references
[2] doi:10.1093/brain/awaf340
PU.1 restores microglial dysfunction caused by C9ORF72 repeat expansions in neural organoids.
Journal: Brain : a journal of neurology
In common: cellular / molecular, 7 references
[3] doi:10.1038/s41386-026-02406-1 [code]
Functional genomic profiling of schizophrenia-associated genes reveals key microglial regulators.
Journal: Neuropsychopharmacology : official publication of the American College of Neuropsychopharmacology
In common: SAMtools, cellular / molecular, 5 references
[4] doi:10.1038/s41593-026-02367-0 [code]
A reproducible three-dimensional model of human brain tissue to investigate physiological and disease-associated microglia phenotypes.
Journal: Nature neuroscience
In common: cellular / molecular, 6 references
[5] doi:10.1002/advs.202520408
Innate Immunocompetent hiPSC-Derived Neurospheroids Capture Early CNS Responses to rAAV.
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)
In common: 6 references
[6] doi:10.1016/j.isci.2026.116412 [code]
KOLF2.1J iTF-Microglia: A standardized platform to study microglial transcriptional regulatory networks in CNS disease.
Journal: iScience
In common: SAMtools, Matplotlib, 4 references
[7] doi:10.1038/s41420-026-03185-w [code]
An electrophysiological and proteomics roadmap for human induced glutamatergic neurons: fine-tuning of culture conditions for pathophysiological studies.
Journal: Cell death discovery
In common: 5 references
[8] doi:10.3389/fnins.2026.1799542
Disease-associated RNA and protein signatures in iPSC-derived microglia model of Alzheimer's disease.
Journal: Frontiers in neuroscience
In common: cellular / molecular, 5 references
[9] doi:10.1002/glia.70158
A Dynamic Change of Microglial States Occurs During the Transition From Photoreceptor Degeneration to Regeneration in Zebrafish pde6c Mutants.
Journal: Glia
In common: cellular / molecular, 5 references
[10] doi:10.1038/s41467-026-76341-6 [code]
Neonatal inflammation disrupts a temporally restricted postnatal Numb-enriched microglial state in mice.
Journal: Nature communications
In common: Matplotlib, 4 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.