use common::*; use std::{convert, ffi}; use clap::{App, Arg, ArgGroup, AppSettings}; use misc::maybe_s; use configuration::DEFAULT_SHELL; macro_rules! die { ($($arg:tt)*) => {{ extern crate std; eprintln!($($arg)*); process::exit(EXIT_FAILURE) }}; } fn edit>(path: P) -> ! { let editor = env::var_os("EDITOR") .unwrap_or_else(|| die!("Error getting EDITOR environment variable")); let error = Command::new(editor) .arg(path) .status(); match error { Ok(status) => process::exit(status.code().unwrap_or(EXIT_FAILURE)), Err(error) => die!("Failed to invoke editor: {}", error), } } trait Slurp { fn slurp(&mut self) -> Result; } impl Slurp for fs::File { fn slurp(&mut self) -> io::Result { let mut destination = String::new(); self.read_to_string(&mut destination)?; Ok(destination) } } pub fn run() { let matches = App::new("just") .version(concat!("v", env!("CARGO_PKG_VERSION"))) .author(env!("CARGO_PKG_AUTHORS")) .about(concat!(env!("CARGO_PKG_DESCRIPTION"), " - ", env!("CARGO_PKG_HOMEPAGE"))) .help_message("Print help information") .version_message("Print version information") .setting(AppSettings::ColoredHelp) .setting(AppSettings::TrailingVarArg) .arg(Arg::with_name("ARGUMENTS") .multiple(true) .help("The recipe(s) to run, defaults to the first recipe in the justfile")) .arg(Arg::with_name("COLOR") .long("color") .takes_value(true) .possible_values(&["auto", "always", "never"]) .default_value("auto") .help("Print colorful output")) .arg(Arg::with_name("DRY-RUN") .long("dry-run") .help("Print what just would do without doing it") .conflicts_with("QUIET")) .arg(Arg::with_name("DUMP") .long("dump") .help("Print entire justfile")) .arg(Arg::with_name("EDIT") .short("e") .long("edit") .help("Open justfile with $EDITOR")) .arg(Arg::with_name("EVALUATE") .long("evaluate") .help("Print evaluated variables")) .arg(Arg::with_name("HIGHLIGHT") .long("highlight") .help("Highlight echoed recipe lines in bold")) .arg(Arg::with_name("JUSTFILE") .short("f") .long("justfile") .takes_value(true) .help("Use as justfile. --working-directory must also be set") .requires("WORKING-DIRECTORY")) .arg(Arg::with_name("LIST") .short("l") .long("list") .help("List available recipes and their arguments")) .arg(Arg::with_name("QUIET") .short("q") .long("quiet") .help("Suppress all output") .conflicts_with("DRY-RUN")) .arg(Arg::with_name("SET") .long("set") .takes_value(true) .number_of_values(2) .value_names(&["VARIABLE", "VALUE"]) .multiple(true) .help("Set to ")) .arg(Arg::with_name("SHELL") .long("shell") .takes_value(true) .default_value(DEFAULT_SHELL) .help("Invoke to run recipes")) .arg(Arg::with_name("SHOW") .short("s") .long("show") .takes_value(true) .value_name("RECIPE") .help("Show information about ")) .arg(Arg::with_name("SUMMARY") .long("summary") .help("List names of available recipes")) .arg(Arg::with_name("VERBOSE") .short("v") .long("verbose") .help("Use verbose output")) .arg(Arg::with_name("WORKING-DIRECTORY") .short("d") .long("working-directory") .takes_value(true) .help("Use as working directory. --justfile must also be set") .requires("JUSTFILE")) .group(ArgGroup::with_name("EARLY-EXIT") .args(&["DUMP", "EDIT", "LIST", "SHOW", "SUMMARY", "ARGUMENTS", "EVALUATE"])) .get_matches(); let color = match matches.value_of("COLOR").expect("`--color` had no value") { "auto" => Color::auto(), "always" => Color::always(), "never" => Color::never(), other => die!("Invalid argument `{}` to --color. This is a bug in just.", other), }; let set_count = matches.occurrences_of("SET"); let mut overrides = Map::new(); if set_count > 0 { let mut values = matches.values_of("SET").unwrap(); for _ in 0..set_count { overrides.insert(values.next().unwrap(), values.next().unwrap()); } } let override_re = Regex::new("^([^=]+)=(.*)$").unwrap(); let raw_arguments = matches.values_of("ARGUMENTS").map(|values| values.collect::>()) .unwrap_or_default(); for argument in raw_arguments.iter().take_while(|arg| override_re.is_match(arg)) { let captures = override_re.captures(argument).unwrap(); overrides.insert(captures.get(1).unwrap().as_str(), captures.get(2).unwrap().as_str()); } let rest = raw_arguments.iter().skip_while(|arg| override_re.is_match(arg)) .enumerate() .flat_map(|(i, argument)| { if i == 0 { if let Some(i) = argument.rfind('/') { if matches.is_present("WORKING-DIRECTORY") { die!("--working-directory and a path prefixed recipe may not be used together."); } let (dir, recipe) = argument.split_at(i + 1); if let Err(error) = env::set_current_dir(dir) { die!("Error changing directory: {}", error); } if recipe.is_empty() { return None; } else { return Some(recipe); } } } Some(*argument) }) .collect::>(); let justfile_option = matches.value_of("JUSTFILE"); let working_directory_option = matches.value_of("WORKING-DIRECTORY"); let text; if let (Some(file), Some(directory)) = (justfile_option, working_directory_option) { if matches.is_present("EDIT") { edit(file); } text = fs::File::open(file) .unwrap_or_else(|error| die!("Error opening justfile: {}", error)) .slurp() .unwrap_or_else(|error| die!("Error reading justfile: {}", error)); if let Err(error) = env::set_current_dir(directory) { die!("Error changing directory to {}: {}", directory, error); } } else { let name; 'outer: loop { for candidate in &["justfile", "Justfile"] { match fs::metadata(candidate) { Ok(metadata) => if metadata.is_file() { name = *candidate; break 'outer; }, Err(error) => { if error.kind() != io::ErrorKind::NotFound { die!("Error fetching justfile metadata: {}", error) } } } } match env::current_dir() { Ok(pathbuf) => if pathbuf.as_os_str() == "/" { die!("No justfile found."); }, Err(error) => die!("Error getting current dir: {}", error), } if let Err(error) = env::set_current_dir("..") { die!("Error changing directory: {}", error); } } if matches.is_present("EDIT") { edit(name); } text = fs::File::open(name) .unwrap_or_else(|error| die!("Error opening justfile: {}", error)) .slurp() .unwrap_or_else(|error| die!("Error reading justfile: {}", error)); } let justfile = Parser::parse(&text).unwrap_or_else(|error| if color.stderr().active() { die!("{:#}", error); } else { die!("{}", error); } ); if matches.is_present("SUMMARY") { if justfile.count() == 0 { eprintln!("Justfile contains no recipes."); } else { let summary = justfile.recipes.iter() .filter(|&(_, recipe)| !recipe.private) .map(|(name, _)| name) .cloned() .collect::>() .join(" "); println!("{}", summary); } process::exit(EXIT_SUCCESS); } if matches.is_present("DUMP") { println!("{}", justfile); process::exit(EXIT_SUCCESS); } if matches.is_present("LIST") { let doc_color = color.stdout().doc(); println!("Available recipes:"); for (name, recipe) in &justfile.recipes { if recipe.private { continue; } print!(" {}", name); for parameter in &recipe.parameters { if color.stdout().active() { print!(" {:#}", parameter); } else { print!(" {}", parameter); } } if let Some(doc) = recipe.doc { print!(" {} {}", doc_color.paint("#"), doc_color.paint(doc)); } println!(); } process::exit(EXIT_SUCCESS); } if let Some(name) = matches.value_of("SHOW") { match justfile.recipes.get(name) { Some(recipe) => { println!("{}", recipe); process::exit(EXIT_SUCCESS); } None => { eprintln!("Justfile does not contain recipe `{}`.", name); if let Some(suggestion) = justfile.suggest(name) { eprintln!("Did you mean `{}`?", suggestion); } process::exit(EXIT_FAILURE) } } } let arguments = if !rest.is_empty() { rest } else if let Some(recipe) = justfile.first() { let min_arguments = recipe.min_arguments(); if min_arguments > 0 { die!("Recipe `{}` cannot be used as default recipe since it requires at least {} argument{}.", recipe.name, min_arguments, maybe_s(min_arguments)); } vec![recipe.name] } else { die!("Justfile contains no recipes."); }; let configuration = Configuration { dry_run: matches.is_present("DRY-RUN"), evaluate: matches.is_present("EVALUATE"), highlight: matches.is_present("HIGHLIGHT"), overrides: overrides, quiet: matches.is_present("QUIET"), shell: matches.value_of("SHELL").unwrap(), color: color, verbose: matches.is_present("VERBOSE"), }; if let Err(run_error) = justfile.run(&arguments, &configuration) { if !configuration.quiet { if color.stderr().active() { eprintln!("{:#}", run_error); } else { eprintln!("{}", run_error); } } process::exit(run_error.code().unwrap_or(EXIT_FAILURE)); } }