use crate::Config;
use clap::{App, Arg, ArgMatches, SubCommand};
use std::{io::Write, path::Path};
const DEBUG_OPTION_VALUES: &'static [(&'static str, fn(&mut Config))] = &[
("variable-resolution", |config: &mut Config| {
config.dump_variable_resolution = true;
}),
];
const SHOW_OPTION_VALUES: &'static [(&'static str, fn(&Config, &mut dyn Write) -> std::io::Result<()>)] = &[
("test-file-paths", |config, writer| {
let test_file_paths = crate::run::find_files::with_config(config).unwrap();
for test_file_path in test_file_paths {
writeln!(writer, "{}", test_file_path.absolute.display())?;
}
Ok(())
}),
("lit-config", |config, writer| {
writeln!(writer, "{:#?}", config)
}),
];
const MULTIPLY_TRUNCATION_LINES_BY_THIS_AT_EACH_VERBOSITY_LEVEL: usize = 4;
lazy_static! {
static ref DEBUG_OPTION_HELP: String = {
let debug_option_vals = DEBUG_OPTION_VALUES.iter().map(|d| d.0).collect::<Vec<_>>();
let debug_option_vals = debug_option_vals.join(", ");
format!("Enable debug output. Possible debugging flags are: {}.", debug_option_vals)
};
static ref SHOW_SUBCOMMAND_WHAT_OPTION_HELP: String = {
let show_option_vals = SHOW_OPTION_VALUES.iter().map(|d| format!(" - {}", d.0)).collect::<Vec<_>>();
let show_option_vals = show_option_vals.join("\n");
format!("Show only a specific value. Possible values are:\n{}\nIf this value is not specified, all values are shown", show_option_vals)
};
}
pub fn mount_inside_app<'a, 'b>(
app: App<'a, 'b>,
test_paths_as_positional_arguments: bool,
) -> App<'a, 'b> {
let app = app
.arg(Arg::with_name("supported-file-extension")
.long("add-file-extension")
.takes_value(true)
.value_name("EXT")
.multiple(true)
.help("Adds a file extension to the test search list. Extensions can be specified either with or without a leading period"))
.arg(Arg::with_name("constant")
.long("define-constant")
.short("c")
.takes_value(true)
.value_name("NAME>=<VALUE") .multiple(true)
.help("Sets a constant, accessible in the test via '@<NAME>"))
.arg(Arg::with_name("show-context-lines")
.long("show-context-lines")
.short("C")
.takes_value(true)
.value_name("NUMBER OF CONTEXT LINES")
.help("Sets the number of output lines to be displayed when showing failure context. Set to '-1' to disable truncation."))
.arg(Arg::with_name("always-show-stderr")
.long("always-show-stderr")
.help("Always echo the stderr streams emitted by programs under test. By default this is only done if the program exits with an error code. Stderr is also always printed when verbose mode is on."))
.arg(Arg::with_name("keep-tempfiles")
.long("keep-tempfiles")
.help("Disables automatic deletion of tempfiles generated during the test run"))
.arg(Arg::with_name("save-artifacts-to")
.long("save-artifacts-to")
.short("O")
.takes_value(true)
.value_name("DIRECTORY")
.help("Exports all program outputs, temporary files, and logs, to a directory at the specified path. Will create the directory if it does not yet exist."))
.arg(Arg::with_name("verbose")
.long("verbose")
.short("v")
.multiple(true)
.help("Increase the level of verbosity in the output. Pass '-vv' for maximum verbosity"))
.arg(Arg::with_name("debug-all")
.long("debug-all")
.short("g")
.help("Turn on all debugging flags"))
.arg(Arg::with_name("debug")
.long("debug")
.takes_value(true)
.value_name("FLAG")
.multiple(true)
.help(&DEBUG_OPTION_HELP[..]))
.subcommand(SubCommand::with_name("show")
.about("Shows information about the test suite, without running tests")
.arg(Arg::with_name("what")
.takes_value(true)
.value_name("WHAT")
.help(&SHOW_SUBCOMMAND_WHAT_OPTION_HELP)));
let test_paths_arg = {
let mut arg = Arg::with_name("add-tests")
.takes_value(true)
.value_name("PATH TO TEST OR TESTS")
.multiple(true)
.help("Adds a path to the test search pathset. If the path refers to a directory, it will be recursed, if it refers to a file, it will be treated as a test file");
if !test_paths_as_positional_arguments {
arg = arg.long("add-tests");
}
arg
};
let app = app
.arg(test_paths_arg);
app
}
pub fn parse_arguments(matches: &ArgMatches,
destination_config: &mut Config) {
if let Some(extensions) = matches.values_of("supported-file-extension") {
for extension in extensions {
destination_config.add_extension(extension);
}
}
if let Some(test_paths) = matches.values_of("add-tests") {
for test_path in test_paths {
destination_config.add_search_path(test_path);
}
}
if let Some(constant_define_strs) = matches.values_of("constant") {
for constant_define_str in constant_define_strs {
let constant_definition: ConstantDefinition = match constant_define_str.parse() {
Ok(c) => c,
Err(e) => panic!(e),
};
destination_config.constants.insert(constant_definition.name, constant_definition.value);
}
}
if matches.is_present("keep-tempfiles") {
destination_config.cleanup_temporary_files = false;
}
if let Some(artifacts_path) = matches.value_of("save-artifacts-to") {
destination_config.save_artifacts_to_directory = Some(Path::new(artifacts_path).to_owned());
}
{
let verbosity_level = matches.occurrences_of("verbose");
if verbosity_level > 2 {
warning(format!("the current verbosity level of '{}' specified is redundant, the maximum verbosity is '-vv' (corresponding to verbosity level 2)", verbosity_level));
}
if verbosity_level > 0 {
if let Some(truncation) = destination_config.truncate_output_context_to_number_of_lines {
destination_config.truncate_output_context_to_number_of_lines = Some(truncation * MULTIPLY_TRUNCATION_LINES_BY_THIS_AT_EACH_VERBOSITY_LEVEL * (verbosity_level as usize));
}
if verbosity_level >= 1 {
destination_config.always_show_stderr = true;
}
if verbosity_level >= 2 {
destination_config.dump_variable_resolution = true;
}
}
}
if matches.is_present("always-show-stderr") {
destination_config.always_show_stderr = true;
}
if let Some(debug_flags) = matches.values_of("debug") {
for debug_flag in debug_flags {
let apply_fn = DEBUG_OPTION_VALUES.iter().find(|(k, _)| k == &debug_flag.trim()).map(|d| d.1);
match apply_fn {
Some(func) => func(destination_config),
None => panic!("no debugging flag named '{}'", debug_flag),
}
}
}
if matches.is_present("debug-all") {
for (_, debug_flag_fn) in DEBUG_OPTION_VALUES {
debug_flag_fn(destination_config);
}
}
if let Some(cli_show_context_lines) = matches.value_of("show-context-lines") {
match cli_show_context_lines.parse::<isize>() {
Ok(-1) => {
destination_config.truncate_output_context_to_number_of_lines = None;
},
Ok(lines) if lines < 0 => fatal_error(format!("invalid number of context lines: '{}' - must be a positive integer, or '-1' to disable truncation", cli_show_context_lines)),
Ok(lines) => {
destination_config.truncate_output_context_to_number_of_lines = Some(lines as usize);
},
Err(_) => fatal_error(format!("invalid number of context lines: '{}' - must be a positive integer, or '-1' to disable truncation", cli_show_context_lines)),
}
}
if let Some(matches) = matches.subcommand_matches("show") {
let what_fns: Vec<_> = match matches.value_of("what") {
Some(what) => {
match SHOW_OPTION_VALUES.iter().find(|(name, _)| *name == what) {
Some((name, what_fn)) => vec![(name, what_fn)],
None => {
fatal_error(format!("error: unknown show value: '{}'", what));
},
}
},
None => {
SHOW_OPTION_VALUES.iter().map(|(name, f)| (name, f)).collect()
},
};
let writer = &mut std::io::stdout();
let show_labels = what_fns.len() > 1;
for (label, what_fn) in what_fns {
if show_labels {
writeln!(writer, "=================================================================").unwrap();
writeln!(writer, "{}:", label).unwrap();
writeln!(writer, "=================================================================").unwrap();
writeln!(writer, "").unwrap();
}
what_fn(&destination_config, writer).unwrap();
if show_labels {
writeln!(writer, "").unwrap();
}
}
std::process::exit(0);
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
struct ConstantDefinition {
pub name: String,
pub value: String,
}
impl std::str::FromStr for ConstantDefinition {
type Err = String;
fn from_str(s: &str) -> Result<Self, String> {
if s.chars().filter(|&c| c == '=').count() != 1 {
return Err(format!("constant definition must have exactly one equals sign but got '{}", s))
}
if s.len() < 3 {
return Err(format!("constant definitions must include both a <NAME> and a <VALUE>, separated by equals"));
}
let (name, value) = s.split_at(s.find('=').unwrap());
let value = &value[1..]; let (name, value) = (name.trim().to_owned(), value.trim().to_owned());
Ok(ConstantDefinition { name, value })
}
}
fn fatal_error(msg: impl AsRef<str>) -> ! {
eprintln!("error: {}", msg.as_ref());
std::process::exit(1);
}
fn warning(msg: impl AsRef<str>) {
eprintln!("warning: {}", msg.as_ref());
}