#[derive(Debug, Default)]
pub struct Cli {
pub eval: Vec<String>,
pub requires: Vec<String>,
pub includes: Vec<String>,
pub file: Option<String>,
pub argv: Vec<String>,
pub check_syntax: bool,
pub warn_level: u8,
pub frozen_string_literal: bool,
pub frozen_string_literal_switched: bool,
pub loop_n: bool,
pub loop_p: bool,
pub autosplit: bool,
pub chomp: bool,
pub field_sep: Option<String>,
pub search_path: bool,
pub debug: bool,
pub verbose_version: bool,
pub show_version: bool,
pub show_help: bool,
pub warnings: Vec<String>,
pub repl: bool,
pub lsp: bool,
pub dap: bool,
pub build: bool,
pub native: bool,
pub dump_bytecode: bool,
pub dump_tokens: bool,
pub dump_ast: bool,
pub disasm: bool,
pub tiers: bool,
}
const VERBOSE_LEVEL: u8 = 2;
const FEATURES: &[&str] = &[
"gems",
"error_highlight",
"did_you_mean",
"syntax_suggest",
"rubyopt",
"frozen_string_literal",
"yjit",
"zjit",
];
fn apply_feature(cli: &mut Cli, arg: &str, on: bool, switch: &str) {
for raw in arg.split(',') {
let feature = raw.trim().replace('-', "_");
if feature == "all" {
cli.frozen_string_literal = on;
cli.frozen_string_literal_switched = true;
continue;
}
if !FEATURES.contains(&feature.as_str()) {
cli.warnings
.push(format!("warning: unknown argument for --{switch}: '{raw}'"));
cli.warnings
.push(format!("warning: features are [{}].", FEATURES.join(", ")));
continue;
}
if feature == "frozen_string_literal" {
cli.frozen_string_literal = on;
cli.frozen_string_literal_switched = true;
}
}
}
fn rubyopt_disabled(args: &[String]) -> bool {
args.iter().any(|a| {
let Some(long) = a.strip_prefix("--disable") else {
return false;
};
let arg = match long.strip_prefix(['-', '=']) {
Some(rest) => rest,
None => return false,
};
arg.split(',')
.any(|f| matches!(f.trim().replace('-', "_").as_str(), "rubyopt" | "all"))
})
}
use crate::host::WARNING_CATEGORIES;
const ENV_SHORT: &str = "IdvwWrKUE";
const ENV_SHORT_TAKES_REST: &str = "IrEW";
const ENV_LONG: &[&str] = &["verbose", "debug"];
pub fn split_env_options(rubyopt: &str) -> Result<Vec<String>, String> {
let bad = |tok: &str| format!("invalid switch in RUBYOPT: {tok}");
let mut out = Vec::new();
for tok in rubyopt.split_whitespace() {
if let Some(long) = tok.strip_prefix("--") {
let name = long.split_once('=').map_or(long, |(n, _)| n);
let ok = ENV_LONG.contains(&name)
|| name.starts_with("enable-")
|| name.starts_with("disable-");
if !ok {
return Err(bad(tok));
}
} else if let Some(short) = tok.strip_prefix('-') {
if short.is_empty() {
return Err(bad(tok));
}
for c in short.chars() {
if !ENV_SHORT.contains(c) {
return Err(bad(&format!("-{c}")));
}
if ENV_SHORT_TAKES_REST.contains(c) {
break;
}
}
} else {
return Err(bad(tok));
}
out.push(tok.to_string());
}
Ok(out)
}
pub fn parse() -> Result<Cli, String> {
let argv: Vec<String> = std::env::args().skip(1).collect();
let use_env = !rubyopt_disabled(&argv);
let mut args = match std::env::var("RUBYOPT") {
Ok(opt) if use_env => split_env_options(&opt)?,
_ => Vec::new(),
};
args.extend(argv);
parse_args(args)
}
pub fn parse_args(args: Vec<String>) -> Result<Cli, String> {
let mut cli = Cli {
warn_level: crate::DEFAULT_WARN_LEVEL,
..Cli::default()
};
let mut it = args.into_iter().peekable();
while let Some(tok) = it.peek() {
if tok == "--" {
it.next();
break;
}
if tok == "-" {
it.next();
cli.file = Some("-".to_string());
break;
}
if let Some(long) = tok.strip_prefix("--") {
let long = long.to_string();
it.next();
apply_long(&mut cli, &long)?;
continue;
}
if let Some(short) = tok.strip_prefix('-') {
if short.is_empty() {
break;
}
let short = short.to_string();
it.next();
apply_short_cluster(&mut cli, &short, &mut it)?;
continue;
}
if cli.eval.is_empty() {
cli.file = Some(it.next().unwrap());
}
break;
}
if !cli.eval.is_empty() {
cli.argv = it.collect();
return Ok(cli);
}
if cli.file.is_none() {
if let Some(next) = it.next() {
cli.file = Some(next);
}
}
cli.argv = it.collect();
Ok(cli)
}
fn apply_long(cli: &mut Cli, long: &str) -> Result<(), String> {
let (name, val) = long.split_once('=').unwrap_or((long, ""));
for (prefix, on) in [("enable", true), ("disable", false)] {
if name == prefix {
apply_feature(cli, val, on, prefix);
return Ok(());
}
if let Some(feature) = name.strip_prefix(prefix).and_then(|r| r.strip_prefix('-')) {
apply_feature(cli, feature, on, prefix);
return Ok(());
}
}
match name {
"version" => cli.show_version = true,
"help" => cli.show_help = true,
"repl" => cli.repl = true,
"lsp" => cli.lsp = true,
"dap" => cli.dap = true,
"build" => cli.build = true,
"native" => cli.native = true,
"dump-bytecode" => cli.dump_bytecode = true,
"dump-tokens" => cli.dump_tokens = true,
"dump-ast" => cli.dump_ast = true,
"disasm" => cli.disasm = true,
"tiers" => cli.tiers = true,
"dump" => {}
"debug" => cli.debug = true,
"verbose" => cli.warn_level = VERBOSE_LEVEL,
"copyright" => cli.show_version = true,
other => return Err(format!("invalid option --{other}")),
}
Ok(())
}
fn apply_short_cluster(
cli: &mut Cli,
cluster: &str,
it: &mut std::iter::Peekable<std::vec::IntoIter<String>>,
) -> Result<(), String> {
let bytes: Vec<char> = cluster.chars().collect();
let mut i = 0;
while i < bytes.len() {
let c = bytes[i];
let rest: String = bytes[i + 1..].iter().collect();
let take_arg = |rest: &str, it: &mut std::iter::Peekable<std::vec::IntoIter<String>>| {
if !rest.is_empty() {
Some(rest.to_string())
} else {
it.next()
}
};
match c {
'e' => {
let arg =
take_arg(&rest, it).ok_or_else(|| "no code specified for -e".to_string())?;
cli.eval.push(arg);
return Ok(());
}
'I' => {
let arg =
take_arg(&rest, it).ok_or_else(|| "missing argument for -I".to_string())?;
cli.includes.push(arg);
return Ok(());
}
'r' => {
let arg =
take_arg(&rest, it).ok_or_else(|| "missing argument for -r".to_string())?;
cli.requires.push(arg);
return Ok(());
}
'F' => {
let arg =
take_arg(&rest, it).ok_or_else(|| "missing argument for -F".to_string())?;
cli.field_sep = Some(arg);
cli.autosplit = true;
return Ok(());
}
'c' => cli.check_syntax = true,
'w' => cli.warn_level = VERBOSE_LEVEL,
'W' => {
if bytes.get(i + 1) == Some(&':') {
let cat: String = bytes[i + 2..].iter().collect();
if !WARNING_CATEGORIES.contains(&cat.trim_start_matches("no-")) {
cli.warnings
.push(format!("warning: unknown warning category: '{cat}'"));
}
return Ok(());
}
match bytes.get(i + 1).and_then(|d| d.to_digit(8)) {
Some(n) => {
cli.warn_level = n as u8;
i += 1;
}
None => cli.warn_level = VERBOSE_LEVEL,
}
}
'n' => cli.loop_n = true,
'p' => cli.loop_p = true,
'a' => cli.autosplit = true,
'l' => cli.chomp = true,
'S' => cli.search_path = true,
'd' => cli.debug = true,
'v' => {
cli.verbose_version = true;
cli.warn_level = VERBOSE_LEVEL;
}
'h' => cli.show_help = true,
'0' | 'K' | 'U' | 'T' | 'x' => {}
'C' | 'E' => {
let _ = take_arg(&rest, it);
return Ok(());
}
other => return Err(format!("invalid option -{other}")),
}
i += 1;
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::DEFAULT_WARN_LEVEL;
fn p(args: &[&str]) -> Cli {
parse_args(args.iter().map(|s| s.to_string()).collect()).unwrap()
}
#[test]
fn eval_takes_argv_not_file() {
let c = p(&["-e", "p ARGV", "one", "two"]);
assert_eq!(c.eval, ["p ARGV"]);
assert_eq!(c.file, None);
assert_eq!(c.argv, ["one", "two"]);
}
#[test]
fn multiple_e_snippets_kept_in_order() {
let c = p(&["-e", "x=1", "-e", "p x"]);
assert_eq!(c.eval, ["x=1", "p x"]);
assert!(c.argv.is_empty());
}
#[test]
fn double_dash_ends_options() {
let c = p(&["-e", "p ARGV", "--", "-x", "-y"]);
assert_eq!(c.argv, ["-x", "-y"]);
}
#[test]
fn glued_and_detached_value_switches() {
let c = p(&["-Ilib", "-I", "vendor", "-rfoo", "-r", "bar", "-e", "0"]);
assert_eq!(c.includes, ["lib", "vendor"]);
assert_eq!(c.requires, ["foo", "bar"]);
}
#[test]
fn bundled_boolean_switches() {
let c = p(&["-wc", "-e", "0"]);
assert_eq!(c.warn_level, VERBOSE_LEVEL);
assert!(c.check_syntax);
}
#[test]
fn bundled_flag_then_e_takes_next_token() {
let c = p(&["-ne", "p 1"]);
assert!(c.loop_n);
assert_eq!(c.eval, ["p 1"]);
}
#[test]
fn warning_level_digit() {
assert_eq!(p(&["-W0", "-e", "0"]).warn_level, 0);
assert_eq!(p(&["-W2", "-e", "0"]).warn_level, 2);
assert_eq!(p(&["-W", "-e", "0"]).warn_level, 2);
}
#[test]
fn no_switch_is_level_one_not_zero() {
assert_eq!(p(&["-e", "0"]).warn_level, DEFAULT_WARN_LEVEL);
assert_eq!(DEFAULT_WARN_LEVEL, 1);
assert_ne!(
p(&["-e", "0"]).warn_level,
p(&["-W0", "-e", "0"]).warn_level
);
}
#[test]
fn verbose_switches_all_reach_the_same_level() {
for args in [
vec!["-w", "-e", "0"],
vec!["-v", "-e", "0"],
vec!["--verbose", "-e", "0"],
vec!["-W", "-e", "0"],
vec!["-W2", "-e", "0"],
] {
assert_eq!(p(&args).warn_level, VERBOSE_LEVEL, "{args:?}");
}
assert!(p(&["-v", "-e", "0"]).verbose_version);
}
#[test]
fn warning_level_is_last_wins_not_highest() {
assert_eq!(p(&["-w", "-W0", "-e", "0"]).warn_level, 0);
assert_eq!(p(&["-W0", "-w", "-e", "0"]).warn_level, VERBOSE_LEVEL);
assert_eq!(p(&["-w", "-W1", "-e", "0"]).warn_level, 1);
assert_eq!(p(&["-W2", "-W0", "-e", "0"]).warn_level, 0);
}
#[test]
fn warning_level_digit_is_octal() {
for n in 0..=7u8 {
assert_eq!(p(&[&format!("-W{n}"), "-e", "0"]).warn_level, n);
}
for bad in ["-W8", "-W9"] {
assert!(
parse_args(vec![bad.to_string(), "-e".into(), "0".into()]).is_err(),
"{bad} should be rejected"
);
}
}
#[test]
fn warning_category_switch_does_not_change_the_level() {
let c = p(&["-W:no-deprecated", "-e", "0"]);
assert_eq!(c.warn_level, DEFAULT_WARN_LEVEL);
assert!(c.warnings.is_empty());
let c = p(&["-W:bogus", "-e", "0"]);
assert_eq!(c.warn_level, DEFAULT_WARN_LEVEL);
assert_eq!(c.warnings, ["warning: unknown warning category: 'bogus'"]);
}
#[test]
fn rubyopt_accepts_only_the_switches_mri_allows() {
for ok in [
"-w", "-W0", "-v", "-d", "-I/tmp", "-rjson", "-K", "-U", "-E:UTF-8",
] {
assert!(split_env_options(ok).is_ok(), "{ok} should be allowed");
}
for bad in ["-a", "-n", "-p", "-l", "-c", "-S", "-x", "-0", "-e"] {
let err = split_env_options(bad).unwrap_err();
assert_eq!(err, format!("invalid switch in RUBYOPT: {bad}"));
}
for ok in [
"--verbose",
"--debug",
"--disable-gems",
"--enable-frozen-string-literal",
] {
assert!(split_env_options(ok).is_ok(), "{ok} should be allowed");
}
for bad in ["--version", "--help"] {
assert!(split_env_options(bad).is_err(), "{bad} should be rejected");
}
assert!(split_env_options("script.rb").is_err());
}
#[test]
fn rubyopt_switches_lose_to_the_command_line() {
let mut args = split_env_options("-w").unwrap();
args.extend(["-W0", "-e", "0"].iter().map(|s| s.to_string()));
assert_eq!(parse_args(args).unwrap().warn_level, 0);
let mut args = split_env_options("-w -I/tmp").unwrap();
args.extend(["-e", "0"].iter().map(|s| s.to_string()));
let c = parse_args(args).unwrap();
assert_eq!(c.warn_level, VERBOSE_LEVEL);
assert_eq!(c.includes, ["/tmp"]);
}
#[test]
fn file_mode_takes_first_positional_then_argv() {
let c = p(&["script.rb", "a", "b"]);
assert_eq!(c.file.as_deref(), Some("script.rb"));
assert_eq!(c.argv, ["a", "b"]);
}
#[test]
fn switches_before_file() {
let c = p(&["-w", "-Ilib", "script.rb", "arg"]);
assert_eq!(c.warn_level, VERBOSE_LEVEL);
assert_eq!(c.includes, ["lib"]);
assert_eq!(c.file.as_deref(), Some("script.rb"));
assert_eq!(c.argv, ["arg"]);
}
#[test]
fn bare_dash_is_stdin_program() {
let c = p(&["-", "arg"]);
assert_eq!(c.file.as_deref(), Some("-"));
assert_eq!(c.argv, ["arg"]);
}
#[test]
fn unknown_switch_is_error() {
assert!(parse_args(vec!["-Z".to_string()]).is_err());
assert!(parse_args(vec!["--bogus".to_string()]).is_err());
}
#[test]
fn frozen_string_literal_has_four_spellings() {
for on in [
"--enable-frozen-string-literal",
"--enable=frozen-string-literal",
"--enable-frozen_string_literal",
"--enable=frozen_string_literal",
] {
assert!(p(&[on, "-e", "0"]).frozen_string_literal, "{on}");
}
for off in [
"--disable-frozen-string-literal",
"--disable=frozen-string-literal",
] {
assert!(!p(&[off, "-e", "0"]).frozen_string_literal, "{off}");
}
assert!(p(&["--enable=all", "-e", "0"]).frozen_string_literal);
assert!(p(&["--enable-all", "-e", "0"]).frozen_string_literal);
assert!(!p(&["--disable=all", "-e", "0"]).frozen_string_literal);
assert!(p(&["--enable=frozen-string-literal,gems", "-e", "0"]).frozen_string_literal);
}
#[test]
fn the_last_feature_switch_wins() {
let on = "--enable-frozen-string-literal";
let off = "--disable-frozen-string-literal";
assert!(!p(&[on, off, "-e", "0"]).frozen_string_literal);
assert!(p(&[off, on, "-e", "0"]).frozen_string_literal);
assert!(!p(&["--enable=all", off, "-e", "0"]).frozen_string_literal);
}
#[test]
fn an_unknown_feature_warns_and_lists_the_known_ones() {
let c = p(&["--enable=fsl", "-e", "0"]);
assert_eq!(
c.warnings,
[
"warning: unknown argument for --enable: 'fsl'".to_string(),
format!("warning: features are [{}].", FEATURES.join(", ")),
]
);
let c = p(&["--disable=nope", "-e", "0"]);
assert!(c.warnings[0].contains("for --disable: 'nope'"));
assert!(p(&["--disable-gems", "-e", "0"]).warnings.is_empty());
assert!(p(&["--enable=yjit", "-e", "0"]).warnings.is_empty());
}
#[test]
fn disable_rubyopt_is_read_from_the_raw_argument_vector() {
let v = |a: &[&str]| a.iter().map(|s| s.to_string()).collect::<Vec<_>>();
assert!(rubyopt_disabled(&v(&["--disable-rubyopt", "-e", "0"])));
assert!(rubyopt_disabled(&v(&["--disable=rubyopt", "-e", "0"])));
assert!(rubyopt_disabled(&v(&["--disable=all", "-e", "0"])));
assert!(rubyopt_disabled(&v(&["--disable=gems,rubyopt", "-e", "0"])));
assert!(!rubyopt_disabled(&v(&["--enable-rubyopt", "-e", "0"])));
assert!(!rubyopt_disabled(&v(&["--disable-gems", "-e", "0"])));
assert!(!rubyopt_disabled(&v(&["-e", "0"])));
}
#[test]
fn long_extensions_still_parse() {
assert!(p(&["--repl"]).repl);
assert!(p(&["--version"]).show_version);
assert!(p(&["--dump-ast", "x.rb"]).dump_ast);
}
}