pub mod inspect;pub mod preview;pub mod render; use anyhow::Result;use clap::{Args, Parser, Subcommand}; use crate::cli::inspect::InspectCommand; #[derive(Args, Debug, Clone, Default)]#[group(multiple = false)]pub struct TargetArg {    #[arg(global = true, long, help_heading = "Cargo Target Options")]    pub lib: bool,    #[arg(global = true, long, help_heading = "Cargo Target Options")]    pub example: Option<String>,} #[derive(Parser, Debug, Clone, Default)]pub struct CliArgs {    #[arg(global = true, short, long, help_heading = "Cargo Options")]    pub package: Option<String>,     #[arg(global = true, long, help_heading = "Cargo Options")]    pub features: Vec<String>,     #[command(flatten)]    pub target: TargetArg,     #[arg(trailing_var_arg = true, allow_hyphen_values = true)]    pub args: Vec<String>,} #[derive(Parser, Debug)]#[command(name = "ranim")]#[command(about = "A CLI tool for Ranim animation library")]#[command(version)]pub struct Cli {    #[command(subcommand)]    command: Commands,     #[command(flatten)]    pub args: CliArgs,} impl Cli {    pub fn run(self) -> Result<()> {        let args = self.args;         match self.command {            Commands::Preview { scene } => {                preview::preview_command(&args, &scene)?;            }            Commands::Output {                scenes,                buffer_count,            } => {                render::output_command(&args, &scenes, buffer_count)?;            }            Commands::Render {                scene,                buffer_count,            } => {                render::render_command(&args, &scene, buffer_count)?;            }            Commands::Inspect { command } => {                inspect::inspect_command(&args, command)?;            }        }         Ok(())    }} #[derive(Subcommand, Debug)]pub enum Commands {    /// Launch a preview app, watch the lib crate and rebuild it to dylib when it is changed    Preview { scene: Option<String> },    /// Render every `#[output(...)]` declared by the selected scenes    Output {        /// Optional scene names to render (if not provided, render all scenes)        #[arg(num_args = 0..)]        scenes: Vec<String>,         /// Number of GPU readback buffers (higher = more parallelism, more VRAM)        #[arg(long, default_value_t = 2)]        buffer_count: usize,    },    /// Render a single scene once with default output settings (`1920x1080`, 60 fps, mp4)    Render {        /// Scene name to render        scene: String,         /// Number of GPU readback buffers (higher = more parallelism, more VRAM)        #[arg(long, default_value_t = 2)]        buffer_count: usize,    },    /// Inspect scenes, animation trees, or evaluated frames without rendering    Inspect {        #[command(subcommand)]        command: InspectCommand,    },} #[cfg(test)]mod test {    use crate::{        Target,        cli::inspect::{FormatArg, InspectCommand},    };     use super::*;     #[test]    fn test_cli() {        let parse_args = |args: &[&str]| Cli::try_parse_from(args);        let cli = parse_args(&["ranim", "output", "-p", "package"]).unwrap();        let Commands::Output { scenes, .. } = &cli.command else {            unreachable!()        };        assert!(scenes.is_empty());        assert_eq!(cli.args.package, Some("package".to_string()));        assert!(!cli.args.target.lib);        assert!(cli.args.target.example.is_none());         let cli = parse_args(&["ranim", "render", "scene_name"]).unwrap();        let Commands::Render { scene, .. } = &cli.command else {            unreachable!()        };        assert_eq!(scene, "scene_name");         let cli = parse_args(&["ranim", "preview", "--lib"]).unwrap();        assert!(matches!(cli.command, Commands::Preview { scene: None }));        assert!(cli.args.package.is_none());        let TargetArg { lib, example } = cli.args.target.clone();        assert!(lib);        assert!(example.is_none());        assert_eq!(Target::from(cli.args.target.clone()), Target::Lib);         let cli = parse_args(&["ranim", "preview", "--example", "example"]).unwrap();        assert!(matches!(cli.command, Commands::Preview { scene: None }));        assert!(cli.args.package.is_none());        let TargetArg { lib, example } = cli.args.target.clone();        assert!(!lib);        assert_eq!(example, Some("example".to_string()));        assert_eq!(            Target::from(cli.args.target.clone()),            Target::Example("example".to_string())        );         let cli = parse_args(&["ranim", "inspect", "scenes", "--format", "json"]).unwrap();        assert!(matches!(            &cli.command,            Commands::Inspect {                command: InspectCommand::Scenes {                    format: FormatArg::Json                }            }        ));         let cli = parse_args(&[            "ranim",            "inspect",            "frame",            "basic",            "--at",            "2.0",            "--verbose",            "--example",            "example",        ])        .unwrap();        assert!(matches!(            &cli.command,            Commands::Inspect {                command: InspectCommand::Frame {                    scene,                    at: 2.0,                    format: FormatArg::Text,                    verbose: true,                }            } if scene == "basic"        ));        assert_eq!(            Target::from(cli.args.target.clone()),            Target::Example("example".to_string())        );    }}