polaranges 0.3.2

Rust-first genomic range operations on top of Polars DataFrames
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use clap::{Parser, Subcommand};

use crate::commands::execute::{run_command, ExecOptions};
use crate::commands::spec::IntervalCommandSpec;
use crate::commands::Result;

pub mod compat;
pub mod regular;

/// The top-level CLI currently exposes the regular mode directly at the root.
/// A future `compat` subtree can translate bedtools-like syntax into the same
/// shared command specs without changing the execution engine.
#[derive(Parser, Clone, Debug)]
#[command(
    name = "polaranges",
    version,
    about = "Modern interval operations for polaranges. The regular mode is the current default command surface."
)]
pub struct RootCli {
    #[command(subcommand)]
    pub command: RootCommand,
}

#[derive(Subcommand, Clone, Debug)]
pub enum RootCommand {
    /// Modern overlap command from the default regular frontend.
    Overlap(regular::OverlapArgs),
    /// Modern nearest command from the default regular frontend.
    Nearest(regular::NearestArgs),
    /// Planned bedtools-style compatibility layer.
    Compat(compat::CompatCli),
}

impl RootCli {
    pub fn exec_options(&self) -> ExecOptions {
        let execution = match &self.command {
            RootCommand::Overlap(args) => args.execution,
            RootCommand::Nearest(args) => args.execution,
            RootCommand::Compat(_) => regular::ExecutionArgs::default(),
        };

        ExecOptions {
            benchmark: execution.benchmark,
            reps: execution.reps.max(1),
            no_output: execution.no_output,
            ..ExecOptions::default()
        }
    }

    pub fn into_command_spec(self) -> Result<IntervalCommandSpec> {
        match self.command {
            RootCommand::Overlap(args) => {
                regular::translate_regular_command(regular::RegularCommand::Overlap(args))
            }
            RootCommand::Nearest(args) => {
                regular::translate_regular_command(regular::RegularCommand::Nearest(args))
            }
            RootCommand::Compat(args) => compat::translate_compat_cli(args),
        }
    }
}

pub fn run() -> Result<()> {
    let cli = RootCli::parse();
    let options = cli.exec_options();
    let spec = cli.into_command_spec()?;
    run_command(&spec, &options)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::commands::spec;
    use crate::commands::{execute::run_command, ExecOptions};

    #[test]
    fn root_cli_routes_direct_commands_into_shared_specs() {
        let cli = RootCli::try_parse_from([
            "polaranges",
            "overlap",
            "--a",
            "left.bed",
            "--b",
            "right.bed",
        ])
        .unwrap();

        let spec = cli.into_command_spec().unwrap();
        match spec {
            spec::IntervalCommandSpec::Overlap(spec) => {
                assert_eq!(spec.inputs.left_path, std::path::PathBuf::from("left.bed"));
                assert_eq!(
                    spec.inputs.right_path,
                    std::path::PathBuf::from("right.bed")
                );
            }
            other => panic!("expected overlap spec, got {other:?}"),
        }

        let dispatcher: fn(
            &spec::IntervalCommandSpec,
            &ExecOptions,
        ) -> crate::commands::Result<()> = run_command;
        let _ = dispatcher;
    }

    #[test]
    fn root_cli_builds_exec_options_from_regular_flags() {
        let cli = RootCli::try_parse_from([
            "polaranges",
            "nearest",
            "--a",
            "left.bed",
            "--b",
            "right.bed",
            "--benchmark",
            "--reps",
            "4",
            "--no-output",
        ])
        .unwrap();

        let options = cli.exec_options();
        assert!(options.benchmark);
        assert_eq!(options.reps, 4);
        assert!(options.no_output);
    }
}