Method parse_from_with_config

rust/crates/ccusage-cli/src/parser.rs:34–85

(
        args: I,
        config: &dyn CliConfig,
        default_session_duration_hours: f64,
        version: &'static str,
    )

    }

    pub fn parse_from_with_config<I>(
        args: I,
        config: &dyn CliConfig,
        default_session_duration_hours: f64,
        version: &'static str,
    ) -> Result<Self, String>
    where
        I: IntoIterator<Item = OsString>,
    {
        let mut parser = ArgParser::new(args.into_iter().skip(1).collect())?;
        normalize_legacy_agent_command_args(&mut parser.args);
        match control_arg(&parser.args) {
            Some(ControlArg::Version) => print_version_and_exit(version),
            Some(ControlArg::Help) => print_help_and_exit(&parser.args),
            None => {}
        }
        if let Some(message) = report_flag_alias_error(&parser.args) {
            return Err(message);
        }
        if let Some(message) = agent_filter_option_error(&parser.args) {
            return Err(message);
        }
        if let Some(message) = unsupported_agent_report_error(&parser.args) {
            return Err(message);
        }
        let mut shared = SharedArgs::with_defaults();
        config.apply_shared(&mut shared);
        while let Some(arg) = parser.peek() {
            if is_command(arg) {
                break;
            }
            if !arg.starts_with('-') {
                return Err(format!("Unknown command '{arg}'"));
            }
            parse_shared_arg(&mut parser, &mut shared)?;
        }

        let command = match parser.next() {
            None => None,
            Some(command) => Some(parse_command(
                &command,
                &mut parser,
                shared.clone(),
                config,
                default_session_duration_hours,
            )?),
        };
        if let Some(extra) = parser.next() {
            return Err(format!("Unexpected argument '{extra}'"));
        }
        Ok(Self { command, shared })
    }
}

fn control_arg(args: &[String]) -> Option<ControlArg> {