use std::path::PathBuf;
use clap::{Args, Parser, Subcommand};
use rsomics_common::{OutputArgs, Result, RsomicsError, ToolMeta};
use serde::Serialize;
use rsomics_seq::{
ConvertFormat, ConvertReport, GrepMode, GrepOptions, GrepReport, KmerOptions, KmerReport,
StatsReport, ValidationReport, compute_stats, convert_sequences, count_kmers, grep_records,
validate_sequences, write_kmer_tsv, write_stats_tsv, write_validation_tsv,
};
use crate::output::{reject_output_alias, with_output, with_sequence_output};
pub const META: ToolMeta = ToolMeta {
name: env!("CARGO_PKG_NAME"),
version: env!("CARGO_PKG_VERSION"),
};
#[derive(Debug, Parser)]
#[command(
name = "rsomics-seq",
version,
about = "Coherent FASTA/FASTQ sequence utilities",
subcommand_required = true,
arg_required_else_help = true
)]
pub struct Cli {
#[command(subcommand)]
command: Command,
#[command(flatten)]
pub output: OutputArgs,
}
#[derive(Debug, Subcommand)]
enum Command {
Stats(StatsArgs),
Kmers(KmerArgs),
Grep(GrepArgs),
Convert(ConvertArgs),
Validate(ValidateArgs),
}
#[derive(Debug, Args)]
struct StatsArgs {
#[arg(default_value = "-", num_args = 1..)]
inputs: Vec<String>,
#[arg(short, long, default_value = "-")]
output: PathBuf,
}
#[derive(Debug, Args)]
struct KmerArgs {
#[arg(default_value = "-")]
input: String,
#[arg(short, long)]
k: usize,
#[arg(short, long)]
canonical: bool,
#[arg(short = 'm', long, default_value_t = 1)]
min_count: u64,
#[arg(short, long, default_value = "-")]
output: PathBuf,
}
#[derive(Debug, Args)]
struct GrepArgs {
#[arg(default_value = "-")]
input: String,
#[arg(short, long = "pattern", required = true, value_delimiter = ',')]
patterns: Vec<String>,
#[arg(short = 'n', long, conflicts_with = "by_seq")]
by_name: bool,
#[arg(short = 's', long, conflicts_with = "by_name")]
by_seq: bool,
#[arg(short = 'i', long)]
ignore_case: bool,
#[arg(long)]
invert_match: bool,
#[arg(short = 'P', long, requires = "by_seq")]
only_positive_strand: bool,
#[arg(short, long, default_value = "-")]
output: PathBuf,
}
#[derive(Debug, Args)]
struct ConvertArgs {
#[arg(default_value = "-")]
input: String,
#[arg(long, value_enum)]
to: ConvertFormat,
#[arg(short, long, default_value = "-")]
output: PathBuf,
}
#[derive(Debug, Args)]
struct ValidateArgs {
#[arg(default_value = "-")]
input: String,
#[arg(short, long, default_value = "-")]
output: PathBuf,
}
#[derive(Debug, Serialize)]
#[serde(tag = "operation", content = "data", rename_all = "lowercase")]
pub enum CommandResult {
Stats(StatsReport),
Kmers(KmerReport),
Grep(GrepReport),
Convert(ConvertReport),
Validate(ValidationReport),
}
impl Cli {
pub fn execute(self) -> Result<CommandResult> {
let json = self.output.json;
match self.command {
Command::Stats(args) => {
validate_json_output(json, &args.output)?;
reject_output_alias(&args.output, args.inputs.iter().map(std::path::Path::new))?;
let report = compute_stats(&args.inputs)?;
if !json {
with_output(&args.output, |output| write_stats_tsv(&report, output))?;
}
Ok(CommandResult::Stats(report))
}
Command::Kmers(args) => {
validate_json_output(json, &args.output)?;
reject_output_alias(&args.output, [std::path::Path::new(args.input.as_str())])?;
let report = count_kmers(
&args.input,
KmerOptions {
k: args.k,
canonical: args.canonical,
min_count: args.min_count,
},
)?;
if !json {
with_output(&args.output, |output| write_kmer_tsv(&report, output))?;
}
Ok(CommandResult::Kmers(report))
}
Command::Grep(args) => {
validate_json_output(json, &args.output)?;
reject_output_alias(&args.output, [std::path::Path::new(args.input.as_str())])?;
let mode = if args.by_seq {
GrepMode::Sequence
} else if args.by_name {
GrepMode::Name
} else {
GrepMode::Id
};
let options = GrepOptions {
patterns: args.patterns,
mode,
ignore_case: args.ignore_case,
invert_match: args.invert_match,
only_positive_strand: args.only_positive_strand,
};
let report = if json {
grep_records(&args.input, &options, &mut std::io::sink())?
} else {
with_sequence_output(&args.output, |output| {
grep_records(&args.input, &options, output)
})?
};
Ok(CommandResult::Grep(report))
}
Command::Convert(args) => {
validate_json_output(json, &args.output)?;
reject_output_alias(&args.output, [std::path::Path::new(args.input.as_str())])?;
let report = if json {
convert_sequences(&args.input, args.to, &mut std::io::sink())?
} else {
with_sequence_output(&args.output, |output| {
convert_sequences(&args.input, args.to, output)
})?
};
Ok(CommandResult::Convert(report))
}
Command::Validate(args) => {
validate_json_output(json, &args.output)?;
reject_output_alias(&args.output, [std::path::Path::new(args.input.as_str())])?;
let report = validate_sequences(&args.input)?;
if !json {
with_output(&args.output, |output| write_validation_tsv(&report, output))?;
}
Ok(CommandResult::Validate(report))
}
}
}
}
fn validate_json_output(json: bool, output: &std::path::Path) -> Result<()> {
if json && output != std::path::Path::new("-") {
return Err(RsomicsError::ConfigError(
"--json writes its envelope to stdout and cannot be combined with --output".into(),
));
}
Ok(())
}
#[cfg(test)]
mod tests {
use clap::CommandFactory;
use super::*;
#[test]
fn command_tree_is_valid() {
Cli::command().debug_assert();
}
}