GitCorner

Code

ossartcraftfilmcraft🌐
f67d38b35cc5
//! Argument parsing: options may appear anywhere; everything else is positional.

use serde_json::{Map, Value};

// Keep nested CLI params safely within the depth also accepted by JSON serialization.
const MAX_PARAM_NESTING: usize = 64;

/// Options that take a value (`--project p`); every other `--x` is a flag.
const VALUED: &[&str] = &[
    "--project",
    "--save-as",
    "--bridge",
    "--format",
    "--scale",
    "--quality",
    "--seconds",
    "--out",
    "--frames",
    "--preset",
    "--range",
    "--start",
    "--end",
    "--data-dir",
    "--settings",
    "--gpu-rendering",
];

#[derive(Debug, Default)]
pub struct Args {
    pub positionals: Vec<String>,
    opts: Vec<(String, Option<String>)>,
}

impl Args {
    pub fn parse(it: impl IntoIterator<Item = String>) -> Self {
        let mut a = Args::default();
        let mut it = it.into_iter();
        while let Some(s) = it.next() {
            if s == "--" {
                a.positionals.extend(it.by_ref());
            } else if let Some((k, v)) = s.split_once('=').filter(|(k, _)| k.starts_with("--")) {
                a.opts.push((k.to_string(), Some(v.to_string())));
            } else if VALUED.contains(&s.as_str()) {
                let v = it.next();
                a.opts.push((s, v));
            } else if s.starts_with("--") && s.len() > 2 {
                a.opts.push((s, None));
            } else {
                a.positionals.push(s);
            }
        }
        a
    }

    pub fn pos(&self, i: usize) -> Option<&str> {
        self.positionals.get(i).map(String::as_str)
    }

    pub fn opt(&self, k: &str) -> Option<&str> {
        self.opts.iter().rev().find(|(n, _)| n == k).and_then(|(_, v)| v.as_deref())
    }

    pub fn flag(&self, k: &str) -> bool {
        self.opts.iter().any(|(n, _)| n == k)
    }

    /// A version query: `--version` anywhere, or `-V` in the subcommand position, so global
    /// options may come first (`--demo --version`, `--compact -V`).
    pub fn wants_version(&self) -> bool {
        self.flag("--version") || self.pos(0) == Some("-V")
    }

    /// The first option that is not in `allowed`, if any.
    pub fn unknown_opt(&self, allowed: &[&str]) -> Option<&str> {
        self.opts.iter().map(|(n, _)| n.as_str()).find(|n| !allowed.contains(n))
    }

    /// Command params from positionals `from..`: one JSON object, or `key=value` pairs
    /// (dotted keys nest: `color.r=1`).
    pub fn params_from(&self, from: usize) -> Result<Value, String> {
        let rest = self.positionals.get(from..).unwrap_or_default();
        if let [one] = rest
            && one.trim_start().starts_with('{')
        {
            return serde_json::from_str(one).map_err(|e| format!("params JSON: {e}"));
        }
        let mut m = Map::new();
        for kv in rest {
            let (k, v) = kv.split_once('=').ok_or_else(|| format!("expected key=value, got `{kv}`"))?;
            if k.bytes().filter(|&b| b == b'.').count() >= MAX_PARAM_NESTING {
                return Err(format!("parameter key exceeds {MAX_PARAM_NESTING} nesting levels"));
            }
            insert_dotted(&mut m, k, parse_value(v));
        }
        Ok(Value::Object(m))
    }
}

fn insert_dotted(m: &mut Map<String, Value>, key: &str, v: Value) {
    match key.split_once('.') {
        None => {
            m.insert(key.to_string(), v);
        }
        Some((head, tail)) => {
            let e = m.entry(head.to_string()).or_insert_with(|| Value::Object(Map::new()));
            if !e.is_object() {
                *e = Value::Object(Map::new());
            }
            if let Value::Object(child) = e {
                insert_dotted(child, tail, v);
            }
        }
    }
}

/// JSON when it parses (numbers, bools, null, arrays, objects, quoted strings), else a string.
pub fn parse_value(s: &str) -> Value {
    serde_json::from_str(s).unwrap_or_else(|_| Value::String(s.to_string()))
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    fn args(s: &str) -> Args {
        Args::parse(s.split_whitespace().map(str::to_string))
    }

    #[test]
    fn options_anywhere_and_positionals() {
        let a = args("exec --demo timeline.razor seconds=3.5 --project p.fcproj --save --compact");
        assert_eq!(a.positionals, ["exec", "timeline.razor", "seconds=3.5"]);
        assert_eq!(a.opt("--project"), Some("p.fcproj"));
        assert!(a.flag("--save") && a.flag("--demo") && a.flag("--compact"));
        assert!(!a.flag("--bridge"));
        let b = args("--bridge=127.0.0.1:9876 inspect sequence");
        assert_eq!(b.opt("--bridge"), Some("127.0.0.1:9876"));
        assert_eq!(b.pos(1), Some("sequence"));
    }

    #[test]
    fn key_value_params() {
        let a = args("exec x seconds=3.5 name=Selects on=true ids=[1,2] color.r=1 color.g=0.5 s=\"7\"");
        assert_eq!(a.params_from(2).unwrap(), json!({"seconds": 3.5, "name": "Selects", "on": true, "ids": [1, 2], "color": {"r": 1, "g": 0.5}, "s": "7"}));
        assert!(args("exec x novalue").params_from(2).is_err());
        assert_eq!(args("exec x").params_from(2).unwrap(), json!({}));
    }

    #[test]
    fn dotted_key_depth_is_bounded() {
        let allowed = format!("{}leaf=1", "a.".repeat(MAX_PARAM_NESTING - 1));
        let a = Args::parse(["exec".into(), "x".into(), allowed]);
        assert!(a.params_from(2).is_ok());

        let too_deep = format!("{}leaf=1", "a.".repeat(MAX_PARAM_NESTING));
        let b = Args::parse(["exec".into(), "x".into(), too_deep]);
        assert!(b.params_from(2).unwrap_err().contains("nesting levels"));
    }

    #[test]
    fn json_params() {
        let a = Args::parse(["exec".into(), "x".into(), r#"{"a": {"b": [1]}}"#.into()]);
        assert_eq!(a.params_from(2).unwrap(), json!({"a": {"b": [1]}}));
    }

    #[test]
    fn version_after_global_options() {
        for s in ["--version", "-V", "--demo --version", "--compact -V", "--data-dir d --version", "export --version"] {
            assert!(args(s).wants_version(), "{s}");
        }
        for s in ["version", "--data-dir -V", "exec x -V", "-- --version"] {
            assert!(!args(s).wants_version(), "{s}");
        }
    }

    #[test]
    fn unknown_opt_reports_first_unlisted_option() {
        let allowed = ["--bridge", "--project"];
        assert_eq!(args("mcp --automation-read-root X").unknown_opt(&allowed), Some("--automation-read-root"));
        assert_eq!(args("mcp --bridge=a --typo=1").unknown_opt(&allowed), Some("--typo"));
        assert_eq!(args("mcp --project p --bridge a").unknown_opt(&allowed), None);
    }

    #[test]
    fn double_dash_ends_options() {
        let a = args("import -- --weird-name.mov a.mov");
        assert_eq!(a.positionals, ["import", "--weird-name.mov", "a.mov"]);
    }

    #[test]
    fn gpu_rendering_takes_a_space_separated_value() {
        let a = args("export --gpu-rendering off out.wav --start 0 --end 0.1");
        assert_eq!(a.positionals, ["export", "out.wav"]);
        assert_eq!(a.opt("--gpu-rendering"), Some("off"));
        let b = args("export out.wav --gpu-rendering auto");
        assert_eq!(b.positionals, ["export", "out.wav"]);
        assert_eq!(b.opt("--gpu-rendering"), Some("auto"));
    }
}