use std::fs::File;
use std::io::{self, Read, Write};
use std::path::{Path, PathBuf};
use clap::{Args, Parser, Subcommand, ValueEnum};
use rsomics_common::{OutputArgs, Result, RsomicsError, ThreadArgs, ToolMeta};
use rsomics_composition::{
AncomOptions, Basis, DEFAULT_MAX_DENSE_CELLS, DelimitedFormat, GramMatrix, Grouping,
LabeledMatrix, PAdjustMethod, StructuralZeroGrid, VlrMatrix, alr, alr_inverse, ancom,
centralize, closure, clr, clr_inverse, ilr, ilr_default, ilr_default_inverse, ilr_inverse,
inner_with_limit, multi_replace, pairwise_vlr_with_limit, perturb, power, rclr,
structural_zeros, vlr,
};
use serde::Serialize;
pub const META: ToolMeta = ToolMeta {
name: env!("CARGO_PKG_NAME"),
version: env!("CARGO_PKG_VERSION"),
};
#[derive(Debug, Parser)]
#[command(
name = "rsomics-composition",
version,
about = "Analyze labeled compositional data with one coherent workflow",
arg_required_else_help = true
)]
pub struct Cli {
#[command(subcommand)]
command: Command,
#[command(flatten)]
threads: ThreadArgs,
#[command(flatten)]
pub output: OutputArgs,
}
#[derive(Debug, Subcommand)]
enum Command {
Closure(MatrixIo),
Perturb(PerturbArgs),
Power(PowerArgs),
Centralize(MatrixIo),
Inner(BinaryArgs),
Alr(AlrArgs),
Clr(InvertibleArgs),
Rclr(MatrixIo),
Ilr(IlrArgs),
Basis(BasisArgs),
MultiReplace(ReplacementArgs),
Vlr(VlrArgs),
StrucZero(StructuralArgs),
Ancom(AncomArgs),
}
impl Command {
fn writes_data_to_stdout(&self) -> bool {
let output = match self {
Self::Closure(args) | Self::Centralize(args) | Self::Rclr(args) => {
args.output.as_deref()
}
Self::Perturb(args) => args.io.output.as_deref(),
Self::Power(args) => args.io.output.as_deref(),
Self::Inner(args) => args.output.as_deref(),
Self::Alr(args) => args.transform.io.output.as_deref(),
Self::Clr(args) => args.io.output.as_deref(),
Self::Ilr(args) => args.transform.io.output.as_deref(),
Self::Basis(args) => args.output.as_deref(),
Self::MultiReplace(args) => args.io.output.as_deref(),
Self::Vlr(args) => args.io.output.as_deref(),
Self::StrucZero(args) => args.io.output.as_deref(),
Self::Ancom(_) => return false,
};
output.is_none() || output == Some(Path::new("-"))
}
}
#[derive(Clone, Copy, Debug, ValueEnum)]
enum FormatArg {
Tsv,
Csv,
}
impl From<FormatArg> for DelimitedFormat {
fn from(value: FormatArg) -> Self {
match value {
FormatArg::Tsv => Self::Tsv,
FormatArg::Csv => Self::Csv,
}
}
}
#[derive(Debug, Args)]
struct MatrixIo {
#[arg(short, long, value_name = "TABLE")]
input: PathBuf,
#[arg(short, long, value_name = "TABLE")]
output: Option<PathBuf>,
#[arg(long, value_enum, default_value_t = FormatArg::Tsv)]
format: FormatArg,
}
#[derive(Debug, Args)]
struct PerturbArgs {
#[command(flatten)]
io: MatrixIo,
#[arg(long, value_name = "TABLE")]
by: PathBuf,
#[arg(long)]
inverse: bool,
}
#[derive(Debug, Args)]
struct PowerArgs {
#[command(flatten)]
io: MatrixIo,
exponent: f64,
}
#[derive(Debug, Args)]
struct BinaryArgs {
#[arg(long)]
left: PathBuf,
#[arg(long)]
right: PathBuf,
#[arg(short, long)]
output: Option<PathBuf>,
#[arg(long, value_enum, default_value_t = FormatArg::Tsv)]
format: FormatArg,
#[arg(long, default_value_t = DEFAULT_MAX_DENSE_CELLS)]
max_dense_cells: usize,
}
#[derive(Debug, Args)]
struct InvertibleArgs {
#[command(flatten)]
io: MatrixIo,
#[arg(long)]
inverse: bool,
}
#[derive(Debug, Args)]
struct AlrArgs {
#[command(flatten)]
transform: InvertibleArgs,
#[arg(long)]
reference: Option<String>,
#[arg(long, default_value_t = 0)]
reference_index: usize,
}
#[derive(Debug, Args)]
struct IlrArgs {
#[command(flatten)]
transform: InvertibleArgs,
#[arg(long, conflicts_with_all = ["basis", "tree"])]
sbp: Option<PathBuf>,
#[arg(long, conflicts_with_all = ["sbp", "tree"])]
basis: Option<PathBuf>,
#[arg(long, conflicts_with_all = ["basis", "sbp"])]
tree: Option<PathBuf>,
#[arg(long, value_delimiter = ',')]
components: Vec<String>,
}
#[derive(Debug, Args)]
struct BasisArgs {
#[arg(long, conflicts_with = "tree")]
sbp: Option<PathBuf>,
#[arg(long, conflicts_with = "sbp")]
tree: Option<PathBuf>,
#[arg(long, value_delimiter = ',')]
components: Vec<String>,
#[arg(short, long)]
output: Option<PathBuf>,
#[arg(long, value_enum, default_value_t = FormatArg::Tsv)]
format: FormatArg,
}
#[derive(Debug, Args)]
struct ReplacementArgs {
#[command(flatten)]
io: MatrixIo,
#[arg(long)]
delta: Option<f64>,
}
#[derive(Debug, Args)]
struct VlrArgs {
#[command(flatten)]
io: MatrixIo,
#[arg(long, requires = "right")]
left: Option<String>,
#[arg(long, requires = "left")]
right: Option<String>,
#[arg(long, default_value_t = 1)]
ddof: usize,
#[arg(long, requires = "left")]
robust: bool,
#[arg(long, default_value_t = DEFAULT_MAX_DENSE_CELLS)]
max_dense_cells: usize,
}
#[derive(Debug, Args)]
struct StructuralArgs {
#[command(flatten)]
io: MatrixIo,
#[arg(long)]
metadata: PathBuf,
#[arg(long)]
group: String,
#[arg(long)]
negative_lower_bound: bool,
}
#[derive(Clone, Copy, Debug, ValueEnum)]
enum AdjustmentArg {
None,
Holm,
Bh,
}
impl From<AdjustmentArg> for PAdjustMethod {
fn from(value: AdjustmentArg) -> Self {
match value {
AdjustmentArg::None => Self::None,
AdjustmentArg::Holm => Self::Holm,
AdjustmentArg::Bh => Self::BenjaminiHochberg,
}
}
}
#[derive(Debug, Args)]
struct AncomArgs {
#[arg(short, long)]
input: PathBuf,
#[arg(long)]
metadata: PathBuf,
#[arg(long)]
group: String,
#[arg(short, long)]
output: PathBuf,
#[arg(long)]
percentiles_output: PathBuf,
#[arg(long, value_enum, default_value_t = FormatArg::Tsv)]
format: FormatArg,
#[arg(long, default_value_t = 0.05)]
alpha: f64,
#[arg(long, default_value_t = 0.02)]
tau: f64,
#[arg(long, default_value_t = 0.1)]
theta: f64,
#[arg(long, value_enum, default_value_t = AdjustmentArg::Holm)]
adjustment: AdjustmentArg,
#[arg(long, value_delimiter = ',', default_value = "0,25,50,75,100")]
percentiles: Vec<f64>,
#[arg(long, default_value_t = DEFAULT_MAX_DENSE_CELLS)]
max_dense_cells: usize,
}
#[derive(Debug, Serialize)]
pub struct ExecutionReport {
operation: &'static str,
samples: usize,
components: usize,
output: String,
#[serde(skip_serializing_if = "Option::is_none")]
degenerate_pairs: Option<usize>,
}
impl Cli {
pub fn execute(self) -> Result<ExecutionReport> {
if self.output.json && self.command.writes_data_to_stdout() {
return Err(RsomicsError::ConfigError(
"--json requires a named data output".into(),
));
}
if let Some(threads) = self.threads.requested() {
rayon::ThreadPoolBuilder::new()
.num_threads(threads.get())
.build_global()
.map_err(|error| RsomicsError::ConfigError(error.to_string()))?;
}
match self.command {
Command::Closure(io) => unary(io, "closure", closure),
Command::Perturb(args) => execute_perturb(args),
Command::Power(args) => {
let exponent = args.exponent;
unary(args.io, "power", |matrix| power(matrix, exponent))
}
Command::Centralize(io) => unary(io, "centralize", centralize),
Command::Inner(args) => execute_inner(args),
Command::Alr(args) => execute_alr(args),
Command::Clr(args) => {
let inverse = args.inverse;
unary(args.io, "clr", move |matrix| {
if inverse {
clr_inverse(matrix)
} else {
clr(matrix)
}
})
}
Command::Rclr(io) => unary(io, "rclr", rclr),
Command::Ilr(args) => execute_ilr(args),
Command::Basis(args) => execute_basis(args),
Command::MultiReplace(args) => {
let delta = args.delta;
unary(args.io, "multi-replace", |matrix| {
multi_replace(matrix, delta)
})
}
Command::Vlr(args) => execute_vlr(args),
Command::StrucZero(args) => execute_structural(args),
Command::Ancom(args) => execute_ancom(args),
}
}
}
fn unary(
io: MatrixIo,
operation: &'static str,
compute: impl FnOnce(&LabeledMatrix) -> rsomics_composition::Result<LabeledMatrix>,
) -> Result<ExecutionReport> {
reject_aliases(io.output.as_deref(), [&io.input])?;
let format = io.format.into();
let matrix = read_matrix(&io.input, format)?;
let result = compute(&matrix).map_err(composition_error)?;
let report = report(operation, &result, io.output.as_deref(), None);
write_matrix(&result, io.output.as_deref(), format)?;
Ok(report)
}
fn execute_perturb(args: PerturbArgs) -> Result<ExecutionReport> {
reject_two_stdin(&args.io.input, &args.by)?;
reject_aliases(args.io.output.as_deref(), [&args.io.input, &args.by])?;
let format = args.io.format.into();
let matrix = read_matrix(&args.io.input, format)?;
let operand = read_matrix(&args.by, format)?;
let result = perturb(&matrix, &operand, args.inverse).map_err(composition_error)?;
let report = report("perturb", &result, args.io.output.as_deref(), None);
write_matrix(&result, args.io.output.as_deref(), format)?;
Ok(report)
}
fn execute_inner(args: BinaryArgs) -> Result<ExecutionReport> {
reject_two_stdin(&args.left, &args.right)?;
reject_aliases(args.output.as_deref(), [&args.left, &args.right])?;
let format = args.format.into();
let left = read_matrix(&args.left, format)?;
let right = read_matrix(&args.right, format)?;
let result =
inner_with_limit(&left, &right, args.max_dense_cells).map_err(composition_error)?;
let report = ExecutionReport {
operation: "inner",
samples: result.rows().len(),
components: result.columns().len(),
output: output_label(args.output.as_deref()),
degenerate_pairs: None,
};
write_gram(&result, args.output.as_deref(), format)?;
Ok(report)
}
fn execute_alr(args: AlrArgs) -> Result<ExecutionReport> {
let inverse = args.transform.inverse;
let reference = args.reference;
let reference_index = args.reference_index;
let io = args.transform.io;
reject_aliases(io.output.as_deref(), [&io.input])?;
let format = io.format.into();
let matrix = read_matrix(&io.input, format)?;
let result = if inverse {
let reference = reference.ok_or_else(|| {
RsomicsError::ConfigError("--reference is required with --inverse".into())
})?;
alr_inverse(&matrix, &reference, reference_index)
} else {
let reference = reference.unwrap_or_else(|| matrix.components()[0].clone());
alr(&matrix, &reference)
}
.map_err(composition_error)?;
let report = report("alr", &result, io.output.as_deref(), None);
write_matrix(&result, io.output.as_deref(), format)?;
Ok(report)
}
fn execute_ilr(args: IlrArgs) -> Result<ExecutionReport> {
let io = args.transform.io;
reject_two_stdin_optional(&io.input, args.sbp.as_deref())?;
reject_two_stdin_optional(&io.input, args.basis.as_deref())?;
reject_two_stdin_optional(&io.input, args.tree.as_deref())?;
let mut protected = vec![&io.input];
protected.extend(args.sbp.as_ref());
protected.extend(args.basis.as_ref());
protected.extend(args.tree.as_ref());
reject_aliases(io.output.as_deref(), protected)?;
let format = io.format.into();
let matrix = read_matrix(&io.input, format)?;
let default_basis = args.sbp.is_none() && args.basis.is_none() && args.tree.is_none();
let result = if default_basis && args.transform.inverse {
require_components(&args.components)?;
ilr_default_inverse(&matrix, args.components)
} else if default_basis {
if !args.components.is_empty() && args.components != matrix.components() {
return Err(RsomicsError::ConfigError(
"--components must match the forward input table order".into(),
));
}
ilr_default(&matrix)
} else {
let basis = basis_for_transform(
args.sbp.as_deref(),
args.basis.as_deref(),
args.tree.as_deref(),
&args.components,
&matrix,
args.transform.inverse,
format,
)?;
if args.transform.inverse {
ilr_inverse(&matrix, &basis)
} else {
ilr(&matrix, &basis)
}
}
.map_err(composition_error)?;
let report = report("ilr", &result, io.output.as_deref(), None);
write_matrix(&result, io.output.as_deref(), format)?;
Ok(report)
}
fn execute_basis(args: BasisArgs) -> Result<ExecutionReport> {
let mut protected = Vec::new();
protected.extend(args.sbp.as_ref());
protected.extend(args.tree.as_ref());
reject_aliases(args.output.as_deref(), protected)?;
let format = args.format.into();
let basis = if let Some(path) = args.sbp.as_deref() {
read_sbp(path, format)?
} else if let Some(path) = args.tree.as_deref() {
require_components(&args.components)?;
let tree = read_tree(path)?;
Basis::from_tree(&tree, args.components).map_err(composition_error)?
} else {
require_components(&args.components)?;
Basis::default_for(args.components).map_err(composition_error)?
};
let matrix = LabeledMatrix::new(
basis.balances().to_vec(),
basis.components().to_vec(),
basis.values().to_vec(),
)
.map_err(composition_error)?;
let report = report("basis", &matrix, args.output.as_deref(), None);
write_matrix(&matrix, args.output.as_deref(), format)?;
Ok(report)
}
fn execute_vlr(args: VlrArgs) -> Result<ExecutionReport> {
reject_aliases(args.io.output.as_deref(), [&args.io.input])?;
let format = args.io.format.into();
let matrix = read_matrix(&args.io.input, format)?;
match (args.left, args.right) {
(Some(left), Some(right)) => {
let value =
vlr(&matrix, &left, &right, args.ddof, args.robust).map_err(composition_error)?;
write_scalar(value, args.io.output.as_deref())?;
Ok(ExecutionReport {
operation: "vlr",
samples: matrix.sample_count(),
components: 2,
output: output_label(args.io.output.as_deref()),
degenerate_pairs: None,
})
}
(None, None) => {
let result = pairwise_vlr_with_limit(&matrix, args.ddof, args.max_dense_cells)
.map_err(composition_error)?;
write_vlr(&result, args.io.output.as_deref(), format)?;
Ok(ExecutionReport {
operation: "vlr",
samples: matrix.sample_count(),
components: matrix.component_count(),
output: output_label(args.io.output.as_deref()),
degenerate_pairs: None,
})
}
_ => unreachable!(),
}
}
fn execute_structural(args: StructuralArgs) -> Result<ExecutionReport> {
reject_two_stdin(&args.io.input, &args.metadata)?;
reject_aliases(args.io.output.as_deref(), [&args.io.input, &args.metadata])?;
let format = args.io.format.into();
let matrix = read_matrix(&args.io.input, format)?;
let grouping = read_grouping(&args.metadata, format, &args.group)?;
let result = structural_zeros(&matrix, &grouping, args.negative_lower_bound)
.map_err(composition_error)?;
write_structural(&result, args.io.output.as_deref(), format)?;
Ok(ExecutionReport {
operation: "struc-zero",
samples: matrix.sample_count(),
components: matrix.component_count(),
output: output_label(args.io.output.as_deref()),
degenerate_pairs: None,
})
}
fn execute_ancom(args: AncomArgs) -> Result<ExecutionReport> {
reject_two_stdin(&args.input, &args.metadata)?;
rsomics_common::reject_output_alias(
&args.output,
[
args.input.as_path(),
args.metadata.as_path(),
args.percentiles_output.as_path(),
],
)?;
rsomics_common::reject_output_alias(
&args.percentiles_output,
[
args.input.as_path(),
args.metadata.as_path(),
args.output.as_path(),
],
)?;
let format = args.format.into();
let matrix = read_matrix(&args.input, format)?;
let grouping = read_grouping(&args.metadata, format, &args.group)?;
let options = AncomOptions {
alpha: args.alpha,
tau: args.tau,
theta: args.theta,
adjustment: args.adjustment.into(),
percentiles: args.percentiles,
max_dense_cells: args.max_dense_cells,
};
let result = ancom(&matrix, &grouping, &options).map_err(composition_error)?;
rsomics_common::write_atomic_pair(
&args.output,
&args.percentiles_output,
|main, percentiles| {
write_ancom(main, &result, format)?;
write_percentiles(percentiles, &result, format)
},
)?;
Ok(ExecutionReport {
operation: "ancom",
samples: matrix.sample_count(),
components: matrix.component_count(),
output: args.output.display().to_string(),
degenerate_pairs: Some(result.degenerate_pairs()),
})
}
fn basis_for_transform(
sbp: Option<&Path>,
basis: Option<&Path>,
tree: Option<&Path>,
components: &[String],
matrix: &LabeledMatrix,
inverse: bool,
format: DelimitedFormat,
) -> Result<Basis> {
if let Some(path) = sbp {
return read_sbp(path, format);
}
if let Some(path) = basis {
return read_basis(path, format);
}
let target_components = if inverse {
require_components(components)?;
components.to_vec()
} else {
if !components.is_empty() && components != matrix.components() {
return Err(RsomicsError::ConfigError(
"--components must match the forward input table order".into(),
));
}
matrix.components().to_vec()
};
if let Some(path) = tree {
Basis::from_tree(&read_tree(path)?, target_components).map_err(composition_error)
} else {
Basis::default_for(target_components).map_err(composition_error)
}
}
fn read_basis(path: &Path, format: DelimitedFormat) -> Result<Basis> {
let matrix = read_matrix(path, format)?;
Basis::new(
matrix.components().to_vec(),
matrix.samples().to_vec(),
matrix.values().to_vec(),
)
.map_err(composition_error)
}
fn read_sbp(path: &Path, format: DelimitedFormat) -> Result<Basis> {
let matrix = read_matrix(path, format)?;
let mut partitions = Vec::with_capacity(matrix.sample_count());
for row in matrix.rows() {
let mut partition = Vec::with_capacity(row.len());
for &value in row {
let integer = value as i8;
if f64::from(integer) != value || !matches!(integer, -1..=1) {
return Err(RsomicsError::InvalidInput(format!(
"SBP values must be exactly -1, 0, or 1; got {value}"
)));
}
partition.push(integer);
}
partitions.push(partition);
}
Basis::from_sbp(
matrix.components().to_vec(),
matrix.samples().to_vec(),
&partitions,
)
.map_err(composition_error)
}
fn read_matrix(path: &Path, format: DelimitedFormat) -> Result<LabeledMatrix> {
if path == Path::new("-") {
LabeledMatrix::read(io::stdin().lock(), format).map_err(composition_error)
} else {
let input = File::open(path)?;
LabeledMatrix::read(input, format).map_err(composition_error)
}
}
fn read_grouping(path: &Path, format: DelimitedFormat, column: &str) -> Result<Grouping> {
if path == Path::new("-") {
Grouping::read(io::stdin().lock(), format, column).map_err(composition_error)
} else {
Grouping::read(File::open(path)?, format, column).map_err(composition_error)
}
}
fn read_tree(path: &Path) -> Result<rsomics_phylo_tree::Tree> {
let mut source = String::new();
if path == Path::new("-") {
io::stdin().lock().read_to_string(&mut source)?;
} else {
File::open(path)?.read_to_string(&mut source)?;
}
rsomics_phylo_tree::Tree::from_newick(&source)
.map_err(|error| RsomicsError::InvalidInput(error.to_string()))
}
fn write_matrix(
matrix: &LabeledMatrix,
output: Option<&Path>,
format: DelimitedFormat,
) -> Result<()> {
rsomics_common::write_output(output, |writer| {
matrix.write(writer, format).map_err(composition_error)
})
}
fn write_gram(matrix: &GramMatrix, output: Option<&Path>, format: DelimitedFormat) -> Result<()> {
write_rectangular(
"sample",
matrix.rows(),
matrix.columns(),
matrix.values(),
output,
format,
)
}
fn write_vlr(matrix: &VlrMatrix, output: Option<&Path>, format: DelimitedFormat) -> Result<()> {
write_rectangular(
"component",
matrix.components(),
matrix.components(),
matrix.values(),
output,
format,
)
}
fn write_rectangular(
corner: &str,
rows: &[String],
columns: &[String],
values: &[f64],
output: Option<&Path>,
format: DelimitedFormat,
) -> Result<()> {
rsomics_common::write_output(output, |writer| {
let mut csv = csv::WriterBuilder::new()
.delimiter(delimiter(format))
.from_writer(writer);
csv.write_record(std::iter::once(corner).chain(columns.iter().map(String::as_str)))
.map_err(io_error)?;
for (row, values) in rows.iter().zip(values.chunks_exact(columns.len())) {
let mut record = Vec::with_capacity(columns.len() + 1);
record.push(row.clone());
record.extend(values.iter().map(ToString::to_string));
csv.write_record(record).map_err(io_error)?;
}
csv.flush().map_err(RsomicsError::Io)
})
}
fn write_scalar(value: f64, output: Option<&Path>) -> Result<()> {
rsomics_common::write_output(output, |writer| {
writeln!(writer, "{value}").map_err(RsomicsError::Io)
})
}
fn write_structural(
result: &StructuralZeroGrid,
output: Option<&Path>,
format: DelimitedFormat,
) -> Result<()> {
rsomics_common::write_output(output, |writer| {
let mut csv = csv::WriterBuilder::new()
.delimiter(delimiter(format))
.from_writer(writer);
csv.write_record(
std::iter::once("component").chain(result.groups().iter().map(String::as_str)),
)
.map_err(io_error)?;
for (component, name) in result.components().iter().enumerate() {
let mut record = Vec::with_capacity(result.groups().len() + 1);
record.push(name.clone());
record.extend((0..result.groups().len()).map(|group| {
if result.get(component, group).unwrap() {
"True".to_owned()
} else {
"False".to_owned()
}
}));
csv.write_record(record).map_err(io_error)?;
}
csv.flush().map_err(RsomicsError::Io)
})
}
fn write_ancom(
writer: &mut dyn Write,
result: &rsomics_composition::AncomResult,
format: DelimitedFormat,
) -> Result<()> {
let mut csv = csv::WriterBuilder::new()
.delimiter(delimiter(format))
.from_writer(writer);
csv.write_record(["component", "W", "Signif"])
.map_err(io_error)?;
for entry in result.entries() {
csv.write_record([
entry.component.clone(),
entry.w.to_string(),
if entry.significant { "True" } else { "False" }.to_owned(),
])
.map_err(io_error)?;
}
csv.flush().map_err(RsomicsError::Io)
}
fn write_percentiles(
writer: &mut dyn Write,
result: &rsomics_composition::AncomResult,
format: DelimitedFormat,
) -> Result<()> {
let mut csv = csv::WriterBuilder::new()
.delimiter(delimiter(format))
.from_writer(writer);
csv.write_record(["component", "percentile", "group", "value"])
.map_err(io_error)?;
for entry in result.percentiles() {
csv.write_record([
entry.component.clone(),
entry.percentile.to_string(),
entry.group.clone(),
entry.value.to_string(),
])
.map_err(io_error)?;
}
csv.flush().map_err(RsomicsError::Io)
}
fn report(
operation: &'static str,
matrix: &LabeledMatrix,
output: Option<&Path>,
degenerate_pairs: Option<usize>,
) -> ExecutionReport {
ExecutionReport {
operation,
samples: matrix.sample_count(),
components: matrix.component_count(),
output: output_label(output),
degenerate_pairs,
}
}
fn reject_aliases<P>(output: Option<&Path>, protected: impl IntoIterator<Item = P>) -> Result<()>
where
P: AsRef<Path>,
{
if let Some(output) = output
&& output != Path::new("-")
{
for input in protected {
rsomics_common::reject_output_alias(output, [input.as_ref()])?;
}
}
Ok(())
}
fn reject_two_stdin(left: &Path, right: &Path) -> Result<()> {
if left == Path::new("-") && right == Path::new("-") {
Err(RsomicsError::ConfigError(
"only one input may read standard input".into(),
))
} else {
Ok(())
}
}
fn reject_two_stdin_optional(left: &Path, right: Option<&Path>) -> Result<()> {
right.map_or(Ok(()), |right| reject_two_stdin(left, right))
}
fn require_components(components: &[String]) -> Result<()> {
if components.is_empty() {
Err(RsomicsError::ConfigError(
"--components is required for this basis mode".into(),
))
} else {
Ok(())
}
}
fn composition_error(error: rsomics_composition::CompositionError) -> RsomicsError {
RsomicsError::InvalidInput(error.to_string())
}
fn io_error(error: csv::Error) -> RsomicsError {
RsomicsError::Io(io::Error::other(error))
}
const fn delimiter(format: DelimitedFormat) -> u8 {
match format {
DelimitedFormat::Tsv => b'\t',
DelimitedFormat::Csv => b',',
}
}
fn output_label(output: Option<&Path>) -> String {
output
.filter(|path| *path != Path::new("-"))
.map_or_else(|| "stdout".to_owned(), |path| path.display().to_string())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn command_tree_uses_one_authoritative_parser() {
for command in [
"closure",
"perturb",
"power",
"centralize",
"inner",
"alr",
"clr",
"rclr",
"ilr",
"basis",
"multi-replace",
"vlr",
"struc-zero",
"ancom",
] {
assert!(
rsomics_help::try_parse_from::<Cli, _, _>([
"rsomics-composition",
command,
"--help"
])
.is_err()
);
}
}
#[test]
fn robust_vlr_requires_pair_mode() {
assert!(
rsomics_help::try_parse_from::<Cli, _, _>([
"rsomics-composition",
"vlr",
"-i",
"table.tsv",
"--robust",
])
.is_err()
);
}
}