yash_cli/startup/

args.rs

// This file is part of yash, an extended POSIX shell.
// Copyright (C) 2023 WATANABE Yuki
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

//! Command line argument parser for the shell

use std::iter::Peekable;
use thiserror::Error;
#[cfg(doc)]
use yash_env::Env;
use yash_env::option::FromStrError::{Ambiguous, NoSuchOption};
use yash_env::option::Option as ShellOption;
use yash_env::option::State;
use yash_env::option::canonicalize;
use yash_env::option::parse_long;
use yash_env::option::parse_short;
use yash_quote::quoted;

/// Input to the main read-eval loop
#[derive(Clone, Debug, Default, Eq, Hash, PartialEq)]
pub enum Source {
    /// Read from standard input (the `-s` option)
    #[default]
    Stdin,
    /// Read from a file (no option)
    File { path: String },
    /// Read from a string (the `-c` option)
    String(String),
}

/// Option specifying an initialization file
#[derive(Clone, Debug, Default, Eq, Hash, PartialEq)]
pub enum InitFile {
    /// No initialization file
    None,
    /// Use the default initialization file
    #[default]
    Default,
    /// Use the specified initialization file
    File { path: String },
}

/// Specification of what the shell should do after the environment is set up
#[derive(Clone, Debug, Default, Eq, Hash, PartialEq)]
pub struct Work {
    /// Input source
    pub source: Source,
    /// Initialization file for a login shell
    pub profile: InitFile,
    /// Initialization file for an interactive shell
    pub rcfile: InitFile,
}

#[derive(Clone, Debug, Default, Eq, Hash, PartialEq)]
/// Configuration for initializing and running the shell
pub struct Run {
    /// What the shell should do after the environment is set up
    pub work: Work,
    /// Shell options
    pub options: Vec<(ShellOption, State)>,
    /// Value of [`Env::arg0`]
    pub arg0: String,
    /// Positional parameters
    pub positional_params: Vec<String>,
}

/// Parse result
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub enum Parse {
    /// Runs the shell
    Run(Run),
    /// Prints help message and exit
    Help,
    /// Prints version information and exit
    Version,
}

impl From<Run> for Parse {
    fn from(run: Run) -> Self {
        Parse::Run(run)
    }
}

/// Error in command line parsing
#[derive(Clone, Debug, Eq, Error, PartialEq)]
pub enum Error {
    /// Short option that is not defined in the option specs
    #[error("unknown option `{0}`")]
    UnknownShortOption(char),

    /// Long option that is not defined in the option specs
    #[error("unknown option `{0}`")]
    UnknownLongOption(String),

    /// Long option that matches the prefix of more than one option name.
    #[error("ambiguous option name `{0}`")]
    AmbiguousLongOption(String),

    /// Option missing an argument
    #[error("option `{0}` missing an argument")]
    MissingOptionArgument(String),

    /// Argument specified to an option that does not take an argument
    #[error("option `{0}` does not take an argument")]
    UnexpectedOptionArgument(String),

    /// The `-c` and `-s` options used together
    #[error("cannot specify both `-c` and `-s`")]
    ConflictingSources,

    /// Negated short option that is not a shell option
    #[error("cannot negate option `{0}`")]
    UnnegatableShortOption(char),

    /// Negated long option that is not a shell option
    #[error("cannot negate option `{0}`")]
    UnnegatableLongOption(String),

    /// The `-c` option without a command string
    #[error("missing command string for `-c`")]
    MissingCommandString,

    /// Short option that POSIX does not specify
    ///
    /// This error occurs only while the `portable` shell option is on.
    #[error("non-portable option `{0}`")]
    NonPortableShortOption(char),

    /// Negated `-c` or `-s` option
    ///
    /// POSIX specifies `-c` and `-s` but not their negations, so this error
    /// occurs only while the `portable` shell option is on.
    #[error("non-portable option `+{0}`")]
    NonPortableShortOptionNegation(char),

    /// Option name that POSIX does not specify, or that POSIX spells
    /// differently
    ///
    /// This error occurs only while the `portable` shell option is on. It
    /// covers the `--name` and `++name` forms, which POSIX does not define at
    /// all, as well as an `-o` or `+o` argument that is not an exact POSIX
    /// option name. The second item is a portable spelling with the same
    /// effect, if there is one.
    #[error("non-portable option name `{}`{}", .0, suggestion(.1))]
    NonPortableLongOption(String, Option<String>),

    /// `-o` or `+o` whose argument is not a separate argument
    ///
    /// POSIX requires conforming applications to specify an option argument as
    /// a separate argument, so this error occurs only while the `portable`
    /// shell option is on.
    #[error(
        "option argument not separated from the option name in `{argument}`; use `{separated_spelling}` instead"
    )]
    UnseparatedOptionArgument {
        /// The offending command line argument
        argument: String,
        /// The same argument with the option argument separated
        separated_spelling: String,
    },
}

/// Formats the trailing clause of [`Error::NonPortableLongOption`].
fn suggestion(spelling: &Option<String>) -> String {
    match spelling {
        Some(spelling) => format!("; use `{spelling}` instead"),
        None => String::new(),
    }
}

/// Returns whether the given `-o` option name is one POSIX specifies.
///
/// `name` is the name as written by the user, before [canonicalization](canonicalize),
/// and `state` is the state the name renders, before any negation by `+o`.
fn is_portable_long_name(name: &str, option: ShellOption, state: State) -> bool {
    if option == ShellOption::Portable {
        // POSIX does not specify the `portable` option, but it must remain
        // possible to turn it off again once it is on. Accept its canonical
        // spelling only.
        name == "portable"
    } else {
        option.portable_long_name() == Some((name, state))
    }
}

/// Returns a portable spelling that would set the option to the given state.
///
/// The result is `None` if POSIX specifies no name for the option.
fn portable_spelling(option: ShellOption, state: State) -> Option<String> {
    fn flag(state: State, name_state: State) -> char {
        if state == name_state { '-' } else { '+' }
    }

    if option == ShellOption::Portable {
        // See `is_portable_long_name` for why this spelling is accepted.
        return Some(format!("{}o portable", flag(state, State::On)));
    }
    if let Some((name, name_state)) = option.portable_long_name() {
        return Some(format!("{}o {name}", flag(state, name_state)));
    }
    let (name, name_state) = option.portable_short_name()?;
    Some(format!("{}{name}", flag(state, name_state)))
}

/// Result of parsing short options
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum ShortOption {
    /// One or more shell options
    Shell,
    /// The `-V` option
    Version,
}

/// Result of parsing a long option
#[derive(Clone, Debug, PartialEq, Eq)]
enum LongOption {
    Shell(ShellOption, State),
    Profile { path: String },
    NoProfile,
    Rcfile { path: String },
    NoRcfile,
    Help,
    Version,
}

/// Intermediate object for parsing a long option
#[derive(Clone, Debug)]
enum NonShellOptionConstructor {
    WithoutArgument(LongOption),
    WithArgument(fn(String) -> LongOption),
}

impl NonShellOptionConstructor {
    fn from_name(name: &str) -> Option<Self> {
        if "profile".starts_with(name) {
            Some(Self::WithArgument(|path| LongOption::Profile { path }))
        } else if "rcfile".starts_with(name) {
            Some(Self::WithArgument(|path| LongOption::Rcfile { path }))
        } else if "noprofile".starts_with(name) {
            Some(Self::WithoutArgument(LongOption::NoProfile))
        } else if "norcfile".starts_with(name) {
            Some(Self::WithoutArgument(LongOption::NoRcfile))
        } else if "help".starts_with(name) {
            Some(Self::WithoutArgument(LongOption::Help))
        } else if "version".starts_with(name) {
            Some(Self::WithoutArgument(LongOption::Version))
        } else {
            None
        }
    }
}

/// Parses command line arguments.
pub fn parse<I, S>(args: I) -> Result<Parse, Error>
where
    I: IntoIterator<Item = S>,
    S: Into<String>,
{
    let mut args = args.into_iter().map(Into::into).peekable();
    let mut result = Run::default();
    // State of the `Portable` option in effect for the argument being parsed.
    // The arguments are examined in order, so an argument that turns the
    // option on or off affects only the arguments that follow it.
    let mut portable = State::Off;

    // Below, we use `args.next_if(|_| true)` instead of `args.next()` to avoid
    // consuming the `None` value that needs to be seen again.

    // Parse the command name
    if let Some(arg0) = args.next_if(|_| true) {
        parse_arg0(&arg0, &mut result.options);
        result.arg0 = arg0;
    }

    // Parse options
    loop {
        if let Some(option) = try_parse_short(&mut args, &mut result.options, &mut portable)? {
            match option {
                ShortOption::Shell => continue,
                ShortOption::Version => return Ok(Parse::Version),
            }
        }

        let Some(option) = try_parse_long(&mut args, &mut portable)? else {
            break;
        };
        match option {
            LongOption::Shell(option, state) => result.options.push((option, state)),
            LongOption::Profile { path } => {
                if result.work.profile != InitFile::None {
                    result.work.profile = InitFile::File { path }
                }
            }
            LongOption::NoProfile => result.work.profile = InitFile::None,
            LongOption::Rcfile { path } => {
                if result.work.rcfile != InitFile::None {
                    result.work.rcfile = InitFile::File { path }
                }
            }
            LongOption::NoRcfile => result.work.rcfile = InitFile::None,
            LongOption::Help => return Ok(Parse::Help),
            LongOption::Version => return Ok(Parse::Version),
        }
    }

    args.next_if(|arg| arg == "-" || arg == "--");

    // Parse operands
    if result.options.contains(&(ShellOption::CmdLine, State::On)) {
        if result.options.contains(&(ShellOption::Stdin, State::On)) {
            return Err(Error::ConflictingSources);
        }

        let command = args.next_if(|_| true).ok_or(Error::MissingCommandString)?;
        result.work.source = Source::String(command);
        if let Some(name) = args.next_if(|_| true) {
            result.arg0 = name;
        }
    } else if result.options.contains(&(ShellOption::Stdin, State::On)) {
        result.work.source = Source::Stdin;
    } else {
        // No -c or -s
        if let Some(operand) = args.next_if(|_| true) {
            result.arg0.clone_from(&operand);
            result.work.source = Source::File { path: operand };
        }
    }
    result.positional_params = args.collect();

    Ok(Parse::Run(result))
}

fn parse_arg0(arg0: &str, options: &mut Vec<(ShellOption, State)>) {
    if arg0.starts_with('-') {
        options.push((ShellOption::Login, State::On));
    }
    if arg0.rsplit('/').next().unwrap_or("") == "sh" {
        options.push((ShellOption::PosixlyCorrect, State::On));
    }
}

/// Parses the next argument as short options.
///
/// If the next argument is not a short option, returns `Ok(None)`.
/// If the next argument is a short option, consumes it and returns `Ok(Some(_))`.
/// The parsed options are added to `option_occurrences`.
/// If the `-V` option is included, returns `Ok(Some(ShortOption::Version))`.
///
/// `portable` is the state of the [`Portable`](ShellOption::Portable) option in
/// effect for this argument. It is updated when the argument modifies the
/// option, so that the options that follow are parsed under the new state.
fn try_parse_short<I: Iterator<Item = String>>(
    args: &mut Peekable<I>,
    option_occurrences: &mut Vec<(ShellOption, State)>,
    portable: &mut State,
) -> Result<Option<ShortOption>, Error> {
    let Some(mut arg) = args.next_if(|arg| is_short_option(arg)) else {
        return Ok(None);
    };

    let mut chars = arg.chars();
    let negate = match chars.next() {
        Some('-') => false,
        Some('+') => true,
        _ => unreachable!(),
    };

    while let Some(c) = chars.next() {
        if c == 'V' {
            return if negate {
                Err(Error::UnnegatableShortOption('V'))
            } else if *portable == State::On {
                Err(Error::NonPortableShortOption('V'))
            } else {
                Ok(Some(ShortOption::Version))
            };
        }
        if c == 'o' {
            let attached = chars.as_str();
            // Byte index where the attached option argument starts,
            // or `None` if the option argument is a separate argument
            let attached_index = if attached.is_empty() {
                let prev = arg;
                arg = args.next().ok_or(Error::MissingOptionArgument(prev))?;
                None
            } else {
                Some(arg.len() - attached.len())
            };
            let raw_name = &arg[attached_index.unwrap_or(0)..];
            let name = canonicalize(raw_name);
            match parse_long(&name) {
                Ok((option, name_state)) => {
                    let new_state = if negate { !name_state } else { name_state };
                    if *portable == State::On
                        && !is_portable_long_name(raw_name, option, name_state)
                    {
                        return Err(Error::NonPortableLongOption(
                            raw_name.to_owned(),
                            portable_spelling(option, new_state),
                        ));
                    }
                    if *portable == State::On
                        && let Some(index) = attached_index
                    {
                        // How this argument would read with the option argument separated
                        let separated_spelling =
                            format!("{} {}", quoted(&arg[..index]), quoted(&arg[index..]));
                        return Err(Error::UnseparatedOptionArgument {
                            argument: arg,
                            separated_spelling,
                        });
                    }
                    if option == ShellOption::Portable {
                        *portable = new_state;
                    }
                    option_occurrences.push((option, new_state));
                    break;
                }
                Err(NoSuchOption) => return Err(Error::UnknownLongOption(name.into_owned())),
                Err(Ambiguous) => return Err(Error::AmbiguousLongOption(name.into_owned())),
            }
        }

        let (option, state) = parse_short(c).ok_or(Error::UnknownShortOption(c))?;
        if *portable == State::On {
            if option.portable_short_name() != Some((c, state)) {
                return Err(Error::NonPortableShortOption(c));
            }
            // POSIX's shell invocation synopsis lists `-c` and `-s` apart from
            // the option letters that may also be written with `+`, so their
            // negations are not portable.
            if negate && matches!(option, ShellOption::CmdLine | ShellOption::Stdin) {
                return Err(Error::NonPortableShortOptionNegation(c));
            }
        }
        option_occurrences.push((option, if negate { !state } else { state }));
    }

    Ok(Some(ShortOption::Shell))
}

/// Tests if the given string is a short option.
fn is_short_option(arg: &str) -> bool {
    let mut chars = arg.chars();
    let negate = match chars.next() {
        Some('-') => false,
        Some('+') => true,
        _ => return false,
    };
    match chars.next() {
        Some('-') if !negate => false,
        Some('+') if negate => false,
        Some(_) => true,
        None => false,
    }
}

/// Tries to parse and consume the next argument in `args` as a long option.
///
/// `portable` is the state of the [`Portable`](ShellOption::Portable) option in
/// effect for this argument. It is updated when the argument modifies the
/// option, so that the options that follow are parsed under the new state.
/// POSIX defines neither the `--name` and `++name` forms nor any of the
/// initialization-file options, so all of them are rejected while `portable`
/// is on.
fn try_parse_long<I: Iterator<Item = String>>(
    args: &mut Peekable<I>,
    portable: &mut State,
) -> Result<Option<LongOption>, Error> {
    let Some(arg) = args.next_if(|arg| is_long_option(arg)) else {
        return Ok(None);
    };

    let mut chars = arg.chars();
    let negate = match chars.next() {
        Some('-') => false,
        Some('+') => true,
        _ => unreachable!(),
    };

    // Skip the second `-` or `+`
    chars.next();

    let chars = chars.as_str();

    // Parse non-shell options
    let (name, value) = match chars.split_once('=') {
        Some((name, value)) => (name, Some(value)),
        None => (chars, None),
    };
    let non_shell_option = NonShellOptionConstructor::from_name(name);

    // Parse shell options
    let shell_option = parse_long(&canonicalize(chars));

    // Check if the result is unique and return the final result
    match (non_shell_option, shell_option) {
        (_, Err(Ambiguous)) | (Some(_), Ok(_)) => Err(Error::AmbiguousLongOption(arg)),

        (None, Err(NoSuchOption)) => Err(Error::UnknownLongOption(arg)),

        (Some(_), Err(NoSuchOption)) if negate => Err(Error::UnnegatableLongOption(arg)),

        (Some(NonShellOptionConstructor::WithoutArgument(option)), Err(NoSuchOption)) => {
            if *portable == State::On {
                Err(Error::NonPortableLongOption(arg, None))
            } else if value.is_none() {
                Ok(Some(option))
            } else {
                Err(Error::UnexpectedOptionArgument(arg))
            }
        }

        (Some(NonShellOptionConstructor::WithArgument(ctor)), Err(NoSuchOption)) => {
            if *portable == State::On {
                return Err(Error::NonPortableLongOption(arg, None));
            }
            let value = match value {
                Some(value) => value.to_owned(),
                None => match args.next() {
                    Some(next_arg) => next_arg,
                    None => return Err(Error::MissingOptionArgument(arg)),
                },
            };
            Ok(Some(ctor(value)))
        }

        (None, Ok((option, name_state))) => {
            let new_state = if negate { !name_state } else { name_state };
            if *portable == State::On {
                return Err(Error::NonPortableLongOption(
                    arg,
                    portable_spelling(option, new_state),
                ));
            }
            if option == ShellOption::Portable {
                *portable = new_state;
            }
            Ok(Some(LongOption::Shell(option, new_state)))
        }
    }
}

/// Tests if the given string is a long option.
fn is_long_option(arg: &str) -> bool {
    if let Some(name) = arg.strip_prefix("--") {
        !name.is_empty()
    } else {
        arg.starts_with("++")
    }
}

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

    fn parse<I, S>(args: I) -> Result<Parse, Error>
    where
        I: IntoIterator<Item = S>,
        S: Into<String>,
    {
        use fuzed_iterator::IteratorExt as _;
        super::parse(args.into_iter().fuze())
    }

    #[test]
    fn no_arguments() {
        assert_eq!(parse([] as [&str; 0]), Ok(Parse::Run(Run::default())));
    }

    #[test]
    fn arg0_only() {
        assert_eq!(
            parse(["yash"]),
            Ok(Parse::Run(Run {
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
    }

    #[test]
    fn run_file() {
        // Without positional parameters
        assert_eq!(
            parse(["yash", "my-script"]),
            Ok(Parse::Run(Run {
                work: Work {
                    source: Source::File {
                        path: "my-script".to_string()
                    },
                    ..Work::default()
                },
                arg0: "my-script".to_string(),
                ..Run::default()
            })),
        );

        // With positional parameters
        assert_eq!(
            parse(["yash", "path/to/script", "-option", "foo", "bar"]),
            Ok(Parse::Run(Run {
                work: Work {
                    source: Source::File {
                        path: "path/to/script".to_string()
                    },
                    ..Work::default()
                },
                arg0: "path/to/script".to_string(),
                positional_params: vec![
                    "-option".to_string(),
                    "foo".to_string(),
                    "bar".to_string()
                ],
                ..Run::default()
            })),
        );
    }

    #[test]
    fn run_string() {
        // Without command name or positional parameters
        assert_eq!(
            parse(["yash", "-c", "echo"]),
            Ok(Parse::Run(Run {
                work: Work {
                    source: Source::String("echo".to_string()),
                    ..Work::default()
                },
                options: vec![(ShellOption::CmdLine, State::On)],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        // With command name but no positional parameters
        assert_eq!(
            parse(["yash", "-c", "echo", "name"]),
            Ok(Parse::Run(Run {
                work: Work {
                    source: Source::String("echo".to_string()),
                    ..Work::default()
                },
                options: vec![(ShellOption::CmdLine, State::On)],
                arg0: "name".to_string(),
                ..Run::default()
            })),
        );

        // With command name and positional parameters
        assert_eq!(
            parse(["yash", "-c", "echo", "name", "foo", "bar"]),
            Ok(Parse::Run(Run {
                work: Work {
                    source: Source::String("echo".to_string()),
                    ..Work::default()
                },
                options: vec![(ShellOption::CmdLine, State::On)],
                arg0: "name".to_string(),
                positional_params: vec!["foo".to_string(), "bar".to_string()],
            }))
        );

        // long option
        assert_eq!(
            parse(["yash", "--cmd-line", "echo"]),
            Ok(Parse::Run(Run {
                work: Work {
                    source: Source::String("echo".to_string()),
                    ..Work::default()
                },
                options: vec![(ShellOption::CmdLine, State::On)],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
    }

    #[test]
    fn missing_command_string() {
        assert_eq!(parse(["yash", "-c"]), Err(Error::MissingCommandString));
    }

    #[test]
    fn run_stdin() {
        // Without positional parameters
        assert_eq!(
            parse(["yash", "-s"]),
            Ok(Parse::Run(Run {
                work: Work {
                    source: Source::Stdin,
                    ..Work::default()
                },
                options: vec![(ShellOption::Stdin, State::On)],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        // With positional parameters
        assert_eq!(
            parse(["yash", "-s", "foo", "bar", "-baz"]),
            Ok(Parse::Run(Run {
                work: Work {
                    source: Source::Stdin,
                    ..Work::default()
                },
                options: vec![(ShellOption::Stdin, State::On)],
                arg0: "yash".to_string(),
                positional_params: vec!["foo".to_string(), "bar".to_string(), "-baz".to_string()],
            })),
        );

        // long option
        assert_eq!(
            parse(["yash", "--stdin"]),
            Ok(Parse::Run(Run {
                work: Work {
                    source: Source::Stdin,
                    ..Work::default()
                },
                options: vec![(ShellOption::Stdin, State::On)],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
    }

    #[test]
    fn conflicting_sources() {
        assert_eq!(parse(["yash", "-cs"]), Err(Error::ConflictingSources));
    }

    #[test]
    fn short_options() {
        // Single short option
        assert_eq!(
            parse(["yash", "-a"]),
            Ok(Parse::Run(Run {
                options: vec![(ShellOption::AllExport, State::On)],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
        assert_eq!(
            parse(["yash", "-n"]),
            Ok(Parse::Run(Run {
                options: vec![(ShellOption::Exec, State::Off)],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        // Combined short options
        assert_eq!(
            parse(["yash", "-an"]),
            Ok(Parse::Run(Run {
                options: vec![
                    (ShellOption::AllExport, State::On),
                    (ShellOption::Exec, State::Off)
                ],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        // Many short options
        assert_eq!(
            parse(["yash", "-a", "-nu", "-x"]),
            Ok(Parse::Run(Run {
                options: vec![
                    (ShellOption::AllExport, State::On),
                    (ShellOption::Exec, State::Off),
                    (ShellOption::Unset, State::Off),
                    (ShellOption::XTrace, State::On),
                ],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
    }

    #[test]
    fn negated_short_options() {
        // Single short option
        assert_eq!(
            parse(["yash", "+a"]),
            Ok(Parse::Run(Run {
                options: vec![(ShellOption::AllExport, State::Off)],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
        assert_eq!(
            parse(["yash", "+n"]),
            Ok(Parse::Run(Run {
                options: vec![(ShellOption::Exec, State::On)],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        // Combined short options
        assert_eq!(
            parse(["yash", "+an"]),
            Ok(Parse::Run(Run {
                options: vec![
                    (ShellOption::AllExport, State::Off),
                    (ShellOption::Exec, State::On)
                ],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        // Many short options
        assert_eq!(
            parse(["yash", "+a", "+ns", "+x"]),
            Ok(Parse::Run(Run {
                options: vec![
                    (ShellOption::AllExport, State::Off),
                    (ShellOption::Exec, State::On),
                    (ShellOption::Stdin, State::Off),
                    (ShellOption::XTrace, State::Off),
                ],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
    }

    #[test]
    fn o_options() {
        // Adjoined o options
        assert_eq!(
            parse(["yash", "-oallexport"]),
            Ok(Parse::Run(Run {
                options: vec![(ShellOption::AllExport, State::On)],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        // Separate o options
        assert_eq!(
            parse(["yash", "-o", "allexport"]),
            Ok(Parse::Run(Run {
                options: vec![(ShellOption::AllExport, State::On)],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        // Non-canonical o options
        assert_eq!(
            parse(["yash", "-o", "all-Export", "-o StD+in_"]),
            Ok(Parse::Run(Run {
                options: vec![
                    (ShellOption::AllExport, State::On),
                    (ShellOption::Stdin, State::On),
                ],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
    }

    #[test]
    fn negated_o_options() {
        // Adjoined o options
        assert_eq!(
            parse(["yash", "+oallexport"]),
            Ok(Parse::Run(Run {
                options: vec![(ShellOption::AllExport, State::Off)],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        // Separate o options
        assert_eq!(
            parse(["yash", "+o", "allexport"]),
            Ok(Parse::Run(Run {
                options: vec![(ShellOption::AllExport, State::Off)],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        // Non-canonical o options
        assert_eq!(
            parse(["yash", "+o", "all-Export", "+o no_exec"]),
            Ok(Parse::Run(Run {
                options: vec![
                    (ShellOption::AllExport, State::Off),
                    (ShellOption::Exec, State::On),
                ],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
    }

    #[test]
    fn long_options() {
        assert_eq!(
            parse(["yash", "--all-export"]),
            Ok(Parse::Run(Run {
                options: vec![(ShellOption::AllExport, State::On)],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
        assert_eq!(
            parse(["yash", "--all-export", "--no*un=set"]),
            Ok(Parse::Run(Run {
                options: vec![
                    (ShellOption::AllExport, State::On),
                    (ShellOption::Unset, State::Off),
                ],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
    }

    #[test]
    fn negated_long_options() {
        assert_eq!(
            parse(["yash", "++all-export"]),
            Ok(Parse::Run(Run {
                options: vec![(ShellOption::AllExport, State::Off)],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
        assert_eq!(
            parse(["yash", "++all+export", "++no*un-set"]),
            Ok(Parse::Run(Run {
                options: vec![
                    (ShellOption::AllExport, State::Off),
                    (ShellOption::Unset, State::On),
                ],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
    }

    #[test]
    fn profile_option() {
        // Separate argument
        assert_eq!(
            parse(["yash", "--profile", "my/file"]),
            Ok(Parse::Run(Run {
                work: Work {
                    profile: InitFile::File {
                        path: "my/file".to_string(),
                    },
                    ..Work::default()
                },
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        // Adjoined argument
        assert_eq!(
            parse(["yash", "--profile=my/file"]),
            Ok(Parse::Run(Run {
                work: Work {
                    profile: InitFile::File {
                        path: "my/file".to_string(),
                    },
                    ..Work::default()
                },
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        // Abbreviated option name
        assert_eq!(
            parse(["yash", "--pr=ofile"]),
            Ok(Parse::Run(Run {
                work: Work {
                    profile: InitFile::File {
                        path: "ofile".to_string(),
                    },
                    ..Work::default()
                },
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
    }

    #[test]
    fn missing_profile_option_argument() {
        assert_eq!(
            parse(["yash", "--profile"]),
            Err(Error::MissingOptionArgument("--profile".to_string())),
        );
    }

    #[test]
    fn noprofile_option() {
        let expected = Ok(Parse::Run(Run {
            work: Work {
                profile: InitFile::None,
                ..Work::default()
            },
            arg0: "yash".to_string(),
            ..Run::default()
        }));
        assert_eq!(parse(["yash", "--noprofile"]), expected);

        // noprofile option wins over profile option
        assert_eq!(parse(["yash", "--profile=file", "--noprofile"]), expected);
        assert_eq!(parse(["yash", "--noprofile", "--profile=file"]), expected);
    }

    #[test]
    fn unexpected_noprofile_option_argument() {
        assert_eq!(
            parse(["yash", "--noprofile=x"]),
            Err(Error::UnexpectedOptionArgument("--noprofile=x".to_string())),
        );
    }

    #[test]
    fn rcfile_option() {
        // Separate argument
        assert_eq!(
            parse(["yash", "--rcfile", "my/file"]),
            Ok(Parse::Run(Run {
                work: Work {
                    rcfile: InitFile::File {
                        path: "my/file".to_string(),
                    },
                    ..Work::default()
                },
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        // Adjoined argument
        assert_eq!(
            parse(["yash", "--rcfile=my/file"]),
            Ok(Parse::Run(Run {
                work: Work {
                    rcfile: InitFile::File {
                        path: "my/file".to_string(),
                    },
                    ..Work::default()
                },
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        // Abbreviated option name
        assert_eq!(
            parse(["yash", "--rc=file"]),
            Ok(Parse::Run(Run {
                work: Work {
                    rcfile: InitFile::File {
                        path: "file".to_string(),
                    },
                    ..Work::default()
                },
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
    }

    #[test]
    fn missing_rcfile_option_argument() {
        assert_eq!(
            parse(["yash", "--rcfile"]),
            Err(Error::MissingOptionArgument("--rcfile".to_string())),
        );
    }

    #[test]
    fn norcfile_option() {
        let expected = Ok(Parse::Run(Run {
            work: Work {
                rcfile: InitFile::None,
                ..Work::default()
            },
            arg0: "yash".to_string(),
            ..Run::default()
        }));
        assert_eq!(parse(["yash", "--norcfile"]), expected);

        // norcfile option wins over rcfile option
        assert_eq!(parse(["yash", "--rcfile=file", "--norcfile"]), expected);
        assert_eq!(parse(["yash", "--norcfile", "--rcfile=file"]), expected);
    }

    #[test]
    fn option_combinations() {
        assert_eq!(
            parse(["yash", "-a", "--err-exit", "-u"]),
            Ok(Parse::Run(Run {
                options: vec![
                    (ShellOption::AllExport, State::On),
                    (ShellOption::ErrExit, State::On),
                    (ShellOption::Unset, State::Off),
                ],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        assert_eq!(
            parse(["yash", "-xo", "noclobber", "-il"]),
            Ok(Parse::Run(Run {
                options: vec![
                    (ShellOption::XTrace, State::On),
                    (ShellOption::Clobber, State::Off),
                    (ShellOption::Interactive, State::On),
                    (ShellOption::Login, State::On),
                ],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );

        assert_eq!(
            parse(["yash", "--all", "-f", "--posix"]),
            Ok(Parse::Run(Run {
                options: vec![
                    (ShellOption::AllExport, State::On),
                    (ShellOption::Glob, State::Off),
                    (ShellOption::PosixlyCorrect, State::On),
                ],
                arg0: "yash".to_string(),
                ..Run::default()
            })),
        );
    }

    #[test]
    fn double_hyphen_separator_and_operands() {
        assert_eq!(
            parse(["yash", "--"]),
            Ok(Parse::Run(Run {
                arg0: "yash".to_string(),
                ..Default::default()
            })),
        );

        assert_eq!(
            parse(["yash", "-a", "--", "file", "arg"]),
            Ok(Parse::Run(Run {
                work: Work {
                    source: Source::File {
                        path: "file".to_string()
                    },
                    ..Work::default()
                },
                options: vec![(ShellOption::AllExport, State::On)],
                arg0: "file".to_string(),
                positional_params: vec!["arg".to_string()],
            })),
        );

        assert_eq!(
            parse(["yash", "-a", "--", "--", "arg"]),
            Ok(Parse::Run(Run {
                work: Work {
                    source: Source::File {
                        path: "--".to_string()
                    },
                    ..Work::default()
                },
                options: vec![(ShellOption::AllExport, State::On)],
                arg0: "--".to_string(),
                positional_params: vec!["arg".to_string()],
            })),
        );
    }

    #[test]
    fn single_hyphen_separator_and_operands() {
        assert_eq!(
            parse(["yash", "-"]),
            Ok(Parse::Run(Run {
                arg0: "yash".to_string(),
                ..Default::default()
            })),
        );

        assert_eq!(
            parse(["yash", "-a", "-", "file", "arg"]),
            Ok(Parse::Run(Run {
                work: Work {
                    source: Source::File {
                        path: "file".to_string()
                    },
                    ..Work::default()
                },
                options: vec![(ShellOption::AllExport, State::On)],
                arg0: "file".to_string(),
                positional_params: vec!["arg".to_string()],
            })),
        );

        assert_eq!(
            parse(["yash", "-a", "-", "-", "arg"]),
            Ok(Parse::Run(Run {
                work: Work {
                    source: Source::File {
                        path: "-".to_string()
                    },
                    ..Work::default()
                },
                options: vec![(ShellOption::AllExport, State::On)],
                arg0: "-".to_string(),
                positional_params: vec!["arg".to_string()],
            })),
        );
    }

    #[test]
    fn option_after_operand() {
        assert_eq!(
            parse(["yash", "-a", "file", "-e"]),
            Ok(Parse::Run(Run {
                work: Work {
                    source: Source::File {
                        path: "file".to_string()
                    },
                    ..Work::default()
                },
                options: vec![(ShellOption::AllExport, State::On)],
                arg0: "file".to_string(),
                positional_params: vec!["-e".to_string()],
            })),
        );
    }

    #[test]
    fn leading_hyphen_in_arg0_makes_login_shell() {
        assert_eq!(
            parse(["-yash"]),
            Ok(Parse::Run(Run {
                options: vec![(ShellOption::Login, State::On)],
                arg0: "-yash".to_string(),
                ..Run::default()
            })),
        );

        assert_matches!(
            parse(["-/bin/sh"]),
            Ok(Parse::Run(run)) => {
                assert!(run.options.contains(&(ShellOption::Login, State::On)));
            }
        );
    }

    #[test]
    fn command_name_sh_enables_posix_mode() {
        assert_eq!(
            parse(["sh"]),
            Ok(Parse::Run(Run {
                options: vec![(ShellOption::PosixlyCorrect, State::On)],
                arg0: "sh".to_string(),
                ..Run::default()
            })),
        );
        assert_eq!(
            parse(["/usr/bin/sh"]),
            Ok(Parse::Run(Run {
                options: vec![(ShellOption::PosixlyCorrect, State::On)],
                arg0: "/usr/bin/sh".to_string(),
                ..Run::default()
            })),
        );

        assert_matches!(
            parse(["-/bin/sh"]),
            Ok(Parse::Run(run)) => {
                assert!(run.options.contains(&(ShellOption::PosixlyCorrect, State::On)));
            }
        );
    }

    #[test]
    fn help_option() {
        assert_eq!(parse(["yash", "--help"]), Ok(Parse::Help));
        assert_eq!(parse(["yash", "-a", "--help", "file"]), Ok(Parse::Help));
    }

    #[test]
    fn version_option() {
        assert_eq!(parse(["yash", "-V"]), Ok(Parse::Version));
        assert_eq!(parse(["yash", "-aV", "x"]), Ok(Parse::Version));

        assert_eq!(parse(["yash", "--version"]), Ok(Parse::Version));
        assert_eq!(parse(["yash", "-a", "--version", "x"]), Ok(Parse::Version));
    }

    #[test]
    fn ambiguous_long_option() {
        assert_eq!(
            parse(["yash", "--no"]),
            Err(Error::AmbiguousLongOption("--no".to_string())),
        );
        assert_eq!(
            parse(["yash", "--p"]),
            Err(Error::AmbiguousLongOption("--p".to_string())),
        );
        assert_eq!(
            parse(["yash", "--ver=bose"]),
            Err(Error::AmbiguousLongOption("--ver=bose".to_string())),
        );
    }

    #[test]
    fn non_existing_option() {
        assert_eq!(
            parse(["yash", "-x", "-y"]),
            Err(Error::UnknownShortOption('y')),
        );
        assert_eq!(parse(["yash", "-CDf"]), Err(Error::UnknownShortOption('D')),);

        assert_eq!(
            parse(["yash", "--unexisting"]),
            Err(Error::UnknownLongOption("--unexisting".to_string())),
        );
        assert_eq!(
            parse(["yash", "--no+un=existing"]),
            Err(Error::UnknownLongOption("--no+un=existing".to_string())),
        );
    }

    #[test]
    fn unnegatable_short_option() {
        assert_eq!(
            parse(["yash", "+V"]),
            Err(Error::UnnegatableShortOption('V')),
        );
    }

    #[test]
    fn unnegatable_long_option() {
        assert_eq!(
            parse(["yash", "++profile"]),
            Err(Error::UnnegatableLongOption("++profile".to_string())),
        );
        assert_eq!(
            parse(["yash", "++vers=ion"]),
            Err(Error::UnnegatableLongOption("++vers=ion".to_string())),
        );
    }

    /// Asserts that the arguments, prefixed with `-o portable`, are accepted
    /// and yield the given shell options in addition to `Portable`.
    fn assert_portable_options(args: &[&str], expected: &[(ShellOption, State)]) {
        let mut all_args = vec!["yash", "-o", "portable"];
        all_args.extend_from_slice(args);
        let mut all_expected = vec![(ShellOption::Portable, State::On)];
        all_expected.extend_from_slice(expected);
        assert_matches!(parse(all_args.clone()), Ok(Parse::Run(run)) => {
            assert_eq!(run.options, all_expected, "{all_args:?}");
        }, "{all_args:?}");
    }

    #[test]
    fn portable_accepts_posix_short_options() {
        assert_portable_options(&["-a"], &[(ShellOption::AllExport, State::On)]);
        assert_portable_options(&["-C"], &[(ShellOption::Clobber, State::Off)]);
        assert_portable_options(&["-i"], &[(ShellOption::Interactive, State::On)]);
        assert_portable_options(&["-s"], &[(ShellOption::Stdin, State::On)]);
        assert_portable_options(&["+e"], &[(ShellOption::ErrExit, State::Off)]);
        assert_portable_options(
            &["-ex"],
            &[
                (ShellOption::ErrExit, State::On),
                (ShellOption::XTrace, State::On),
            ],
        );
    }

    #[test]
    fn portable_accepts_posix_o_names() {
        assert_portable_options(&["-o", "errexit"], &[(ShellOption::ErrExit, State::On)]);
        assert_portable_options(&["-o", "noclobber"], &[(ShellOption::Clobber, State::Off)]);
        assert_portable_options(&["+o", "noclobber"], &[(ShellOption::Clobber, State::On)]);
        assert_portable_options(&["-o", "nolog"], &[(ShellOption::Log, State::Off)]);
        assert_portable_options(&["-o", "vi"], &[(ShellOption::Vi, State::On)]);
    }

    #[test]
    fn portable_rejects_short_option_posix_does_not_specify() {
        assert_eq!(
            parse(["yash", "-o", "portable", "-l"]),
            Err(Error::NonPortableShortOption('l')),
        );
        assert_eq!(
            parse(["yash", "-o", "portable", "-V"]),
            Err(Error::NonPortableShortOption('V')),
        );
    }

    #[test]
    fn portable_rejects_negated_c_and_s_options() {
        assert_eq!(
            parse(["yash", "-o", "portable", "+c"]),
            Err(Error::NonPortableShortOptionNegation('c')),
        );
        assert_eq!(
            parse(["yash", "-o", "portable", "+s"]),
            Err(Error::NonPortableShortOptionNegation('s')),
        );
        assert_eq!(
            parse(["yash", "-o", "portable", "+es"]),
            Err(Error::NonPortableShortOptionNegation('s')),
        );
    }

    #[test]
    fn portable_accepts_negated_i_option() {
        assert_portable_options(&["+i"], &[(ShellOption::Interactive, State::Off)]);
    }

    #[test]
    fn negated_c_and_s_options_are_accepted_without_the_portable_option() {
        assert_matches!(parse(["yash", "+c", "+s"]), Ok(Parse::Run(run)) => {
            assert_eq!(run.options, [
                (ShellOption::CmdLine, State::Off),
                (ShellOption::Stdin, State::Off),
            ]);
        });
    }

    #[test]
    fn portable_rejects_o_name_that_is_not_a_posix_spelling() {
        for name in ["clobber", "ERREXIT", "errex", "noerrexit", "login"] {
            assert_matches!(
                parse(["yash", "-o", "portable", "-o", name]),
                Err(Error::NonPortableLongOption(reported, _)) => {
                    assert_eq!(reported, name);
                },
                "{name}"
            );
        }
    }

    #[test]
    fn portable_rejects_long_options() {
        for arg in ["--errexit", "++errexit", "--noclobber"] {
            assert_matches!(
                parse(["yash", "-o", "portable", arg]),
                Err(Error::NonPortableLongOption(reported, _)) => {
                    assert_eq!(reported, arg);
                },
                "{arg}"
            );
        }
    }

    #[test]
    fn portable_rejects_options_posix_does_not_define() {
        for arg in ["--help", "--version", "--noprofile", "--norcfile"] {
            assert_eq!(
                parse(["yash", "-o", "portable", arg]),
                Err(Error::NonPortableLongOption(arg.to_string(), None)),
                "{arg}"
            );
        }
        assert_eq!(
            parse(["yash", "-o", "portable", "--profile", "f"]),
            Err(Error::NonPortableLongOption("--profile".to_string(), None)),
        );
        assert_eq!(
            parse(["yash", "-o", "portable", "--rcfile=f"]),
            Err(Error::NonPortableLongOption("--rcfile=f".to_string(), None)),
        );
    }

    #[test]
    fn portable_accepts_canonical_spelling_of_portable_option() {
        assert_portable_options(&["+o", "portable"], &[(ShellOption::Portable, State::Off)]);
        assert_portable_options(&["-o", "portable"], &[(ShellOption::Portable, State::On)]);
    }

    #[test]
    fn portable_rejects_other_spellings_of_portable_option() {
        for arg in ["--portable", "++portable"] {
            assert_matches!(
                parse(["yash", "-o", "portable", arg]),
                Err(Error::NonPortableLongOption(reported, _)) => {
                    assert_eq!(reported, arg);
                },
                "{arg}"
            );
        }
        assert_matches!(
            parse(["yash", "-o", "portable", "-o", "PORTABLE"]),
            Err(Error::NonPortableLongOption(..))
        );
    }

    #[test]
    fn enabling_portable_affects_only_following_options() {
        assert_matches!(parse(["yash", "--errexit", "-o", "portable"]), Ok(Parse::Run(run)) => {
            assert_eq!(run.options, [
                (ShellOption::ErrExit, State::On),
                (ShellOption::Portable, State::On),
            ]);
        });

        assert_matches!(parse(["yash", "--rcfile", "f", "--portable"]), Ok(Parse::Run(run)) => {
            assert_eq!(run.options, [(ShellOption::Portable, State::On)]);
            assert_eq!(run.work.rcfile, InitFile::File { path: "f".to_string() });
        });

        assert_eq!(
            parse(["yash", "--version", "-o", "portable"]),
            Ok(Parse::Version)
        );
    }

    #[test]
    fn disabling_portable_affects_only_following_options() {
        assert_matches!(
            parse(["yash", "-o", "portable", "+o", "portable", "--errexit"]),
            Ok(Parse::Run(run)) => {
                assert_eq!(run.options, [
                    (ShellOption::Portable, State::On),
                    (ShellOption::Portable, State::Off),
                    (ShellOption::ErrExit, State::On),
                ]);
            }
        );
    }

    #[test]
    fn unrecognized_option_name_is_reported_rather_than_non_portable() {
        assert_eq!(
            parse(["yash", "-o", "portable", "-o", "foo"]),
            Err(Error::UnknownLongOption("foo".to_string())),
        );
        assert_eq!(
            parse(["yash", "-o", "portable", "--foo"]),
            Err(Error::UnknownLongOption("--foo".to_string())),
        );
        assert_eq!(
            parse(["yash", "-o", "portable", "-Z"]),
            Err(Error::UnknownShortOption('Z')),
        );
    }

    #[test]
    fn portable_rejects_option_argument_attached_to_the_option_name() {
        for (arg, separated) in [
            ("-oerrexit", "-o errexit"),
            ("-aoerrexit", "-ao errexit"),
            ("+onoclobber", "+o noclobber"),
            ("-oportable", "-o portable"),
        ] {
            assert_eq!(
                parse(["yash", "-o", "portable", arg]),
                Err(Error::UnseparatedOptionArgument {
                    argument: arg.to_string(),
                    separated_spelling: separated.to_string()
                }),
                "{arg}"
            );
        }
    }

    #[test]
    fn non_portable_option_name_is_reported_before_the_attached_argument() {
        assert_matches!(
            parse(["yash", "-o", "portable", "-oclobber"]),
            Err(Error::NonPortableLongOption(..))
        );
    }

    #[test]
    fn non_portable_error_suggests_portable_spelling() {
        fn message(args: &[&str]) -> String {
            let mut all_args = vec!["yash", "-o", "portable"];
            all_args.extend_from_slice(args);
            parse(all_args).unwrap_err().to_string()
        }

        assert_eq!(
            message(&["--errexit"]),
            "non-portable option name `--errexit`; use `-o errexit` instead",
        );
        assert_eq!(
            message(&["-o", "clobber"]),
            "non-portable option name `clobber`; use `+o noclobber` instead",
        );
        assert_eq!(
            message(&["++portable"]),
            "non-portable option name `++portable`; use `+o portable` instead",
        );
        assert_eq!(message(&["--help"]), "non-portable option name `--help`",);
        assert_eq!(
            message(&["-o", "login"]),
            "non-portable option name `login`",
        );
    }
}