Change phase setup

TheOnlyMrCat · TheOnlyMrCat · commit 30b3de463b91 · 2022-02-20T17:10:22.000+11:00
diff --git a/README.md b/README.md
@@ -36,11 +36,11 @@ cargo install runscript
 
 Licensed under either of
 
-- Apache License, Version 2.0, (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
-- MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)
+- Apache License, Version 2.0, (LICENSE-APACHE or <http://www.apache.org/licenses/LICENSE-2.0>)
+- MIT license (LICENSE-MIT or <http://opensource.org/licenses/MIT>)
 
 at your option.
 
 ### Contribution
 
-Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
diff --git a/src/exec.rs b/src/exec.rs
@@ -471,7 +471,7 @@ struct ShellContext {
     /// PID of most recent job
     pid: i32,
     /// Exit code of most recent top-level command
-    exit_code: i32, //TODO: This will always be 0..
+    exit_code: i32, //TODO: This will always be 0...
 }
 
 impl ShellContext {
diff --git a/src/main.rs b/src/main.rs
@@ -93,8 +93,6 @@ you ran it on.
 }
 
 fn main() {
-    std::panic::set_hook(Box::new(panic_hook));
-
     let mut args = env::args().skip(1).collect::<Vec<String>>();
     loop {
         match std::panic::catch_unwind(|| {
@@ -115,42 +113,33 @@ fn main() {
 }
 
 pub fn run(args: &[String]) -> ExitCode {
-    let output_stream = Arc::new(StandardStream::stderr(ColorChoice::Auto));
-
     let mut app = clap::App::new("run")
         .about("Project script manager and executor")
         .version(VERSION)
         .author("TheOnlyMrCat")
         .setting(clap::AppSettings::NoBinaryName)
         .setting(clap::AppSettings::TrailingVarArg)
         .setting(clap::AppSettings::DeriveDisplayOrder)
-        .override_usage("run [OPTIONS] [TARGET] [ARGS]")
+        .override_usage("run [OPTIONS] [TARGET:PHASE] [--] [ARGS]")
         .arg(arg!([target] "Target to run in the script").hide(true))
         .arg(arg!([args] ... "Arguments to pass to the script").hide(true))
         .arg(
             arg!(-c --command <COMMAND> "Execute a command")
                 .required(false)
                 .value_hint(ValueHint::CommandString)
-                .conflicts_with_all(&["file", "list", "phase", "target", "args"])
+                .conflicts_with_all(&["file", "list", "target", "args", "build", "run", "test"])
         )
         .arg(arg!(-f --file <FILE> "Explicitly specify a script file to run").required(false).value_hint(ValueHint::FilePath))
-        .arg(arg!(-l --list "List targets in the script file"))
-        .help_heading("PHASE SELECTION")
-        .arg(
-            arg!(-p --phase <PHASE> "Run a specific phase of the script")
-                .required(false)
-                .use_delimiter(true)
-                .default_value_if("build", None, Some("build"))
-                .default_value_if("run", None, Some("run"))
-                .conflicts_with("list")
-        )
+        .arg(arg!(-l --list "List targets in the script file").conflicts_with_all(&["build", "run", "test"]))
+        .arg(arg!(--color <WHEN>).possible_values(&["auto", "always", "ansi", "never"]).required(false).default_value("auto"))
         .arg(arg!(-b --build "Shorthand for `--phase build`"))
-        .arg(arg!(-r --run "Shorthand for `--phase run`"));
+        .arg(arg!(-r --run "Shorthand for `--phase run`"))
+        .arg(arg!(-t --test "Shorthand for `--phase test`"));
 
     let options = match app.try_get_matches_from_mut(args) {
         Ok(m) => m,
         Err(clap::Error { kind: clap::ErrorKind::DisplayHelp, .. }) => {
-            app.print_help().expect("Failed to write clap help");
+            app.print_help().expect("Failed to print clap help");
             return exitcode::OK;
         }
         Err(clap::Error { kind: clap::ErrorKind::DisplayVersion, .. }) => {
@@ -171,12 +160,12 @@ pub fn run(args: &[String]) -> ExitCode {
         config.set_default("colors.phases.enabled", true).unwrap();
         if std::env::var_os("\x52\x55\x4E\x53\x43\x52\x49\x50\x54\x5F\x54\x52\x41\x4E\x53").is_some() {
             config.set_default("colors.phases.build", 6).unwrap();
-            config.set_default("colors.phases.exec", 7).unwrap();
             config.set_default("colors.phases.run", 13).unwrap();
+            config.set_default("colors.phases.test", 7).unwrap();
         } else {
             config.set_default("colors.phases.build", 1).unwrap();
-            config.set_default("colors.phases.exec", 2).unwrap();
             config.set_default("colors.phases.run", 4).unwrap();
+            config.set_default("colors.phases.test", 2).unwrap();
         }
         config.set_default("dev.panic", false).unwrap();
 
@@ -195,7 +184,7 @@ pub fn run(args: &[String]) -> ExitCode {
         } else {
             #[cfg(unix)]
             {
-                config_dir = Some(PathBuf::from("~/.config/runscript"));
+                config_dir = None;
             }
             #[cfg(windows)]
             unsafe {
@@ -226,8 +215,10 @@ pub fn run(args: &[String]) -> ExitCode {
         config
     };
 
-    if config.get_bool("dev.panic").unwrap_or(false) {
-        let _ = std::panic::take_hook();
+    let output_stream = Arc::new(StandardStream::stderr(ColorChoice::Auto));
+
+    if !config.get_bool("dev.panic").unwrap_or(false) {
+        std::panic::set_hook(Box::new(panic_hook));
     }
     
     let cwd = match env::current_dir() {
@@ -326,59 +317,34 @@ pub fn run(args: &[String]) -> ExitCode {
                     positional_args: options.values_of("args").into_iter().flatten().map(ToOwned::to_owned).collect(),
                 };
 
-                let target = options.value_of("target");
+                let target = options.value_of("target").unwrap_or("");
+                let (target, phase) = target.split_once(':').unwrap_or((target, "run"));
 
-                match match &target {
-                    Some(target) => rf.get_target(target),
-                    None => rf.get_target(""),
+                match if target.is_empty() {
+                    rf.get_default_target()
+                } else {
+                    rf.get_target(target)
                 } {
-                    Some(target_scripts) => {
-                        let phase = options.value_of("phase").unwrap_or("exec");
-                        if let Some(script) = target_scripts.get(phase) {
+                    Some((name, scripts)) => {
+                        if let Some(script) = scripts.get(phase) {
                             out::phase_message(
                                 &output_stream,
                                 &config,
                                 phase,
-                                target.unwrap_or("default"),
+                                name,
                             );
                             exec_script(script, &exec_cfg).unwrap();
                             exitcode::OK
-                        } else if phase == "exec" {
-                            let build_script = target_scripts.get("build");
-                            let run_script = target_scripts.get("run");
-                            if build_script.is_none() && run_script.is_none() {
-                                out::bad_script_phase(&output_stream);
-                                exitcode::NOINPUT
-                            } else {
-                                if let Some(script) = build_script {
-                                    out::phase_message(
-                                        &output_stream,
-                                        &config,
-                                        "build",
-                                        target.unwrap_or("default"),
-                                    );
-                                    exec_script(script, &exec_cfg).unwrap();
-                                }
-                                if let Some(script) = run_script {
-                                    out::phase_message(
-                                        &output_stream,
-                                        &config,
-                                        "run",
-                                        target.unwrap_or("default"),
-                                    );
-                                    exec_script(script, &exec_cfg).unwrap();
-                                }
-                                exitcode::OK
-                            }
                         } else {
                             out::bad_script_phase(&output_stream);
                             exitcode::NOINPUT
                         }
                     }
                     None => {
-                        match target {
-                            Some(name) => out::bad_target(&output_stream, name),
-                            None => out::bad_default(&output_stream),
+                        if target.is_empty() {
+                            out::bad_default(&output_stream);
+                        } else {
+                            out::bad_target(&output_stream, target);
                         }
                         exitcode::NOINPUT
                     }
@@ -468,6 +434,7 @@ fn print_phase_list(
         name_length
     )
     .expect("Failed to write");
+    //TODO: This could be configured
     if target.contains_key("build") {
         lock.set_color(
             ColorSpec::new()
@@ -487,47 +454,47 @@ fn print_phase_list(
         .expect("Failed to set colour");
         write!(lock, ".").unwrap();
     }
-    if target.contains_key("exec") {
+    if target.contains_key("run") {
         lock.set_color(
             ColorSpec::new()
                 .set_bold(true)
                 .set_intense(true)
-                .set_fg(Some(out::phase_color(config, "exec"))),
+                .set_fg(Some(out::phase_color(config, "run"))),
         )
         .expect("Failed to set colour");
-        write!(lock, "&").unwrap();
+        write!(lock, "R").unwrap();
     } else {
         lock.set_color(
             ColorSpec::new()
                 .set_bold(false)
                 .set_intense(false)
-                .set_fg(Some(out::phase_color(config, "exec"))),
+                .set_fg(Some(out::phase_color(config, "run"))),
         )
         .expect("Failed to set colour");
         write!(lock, ".").unwrap();
     }
-    if target.contains_key("run") {
+    if target.contains_key("test") {
         lock.set_color(
             ColorSpec::new()
                 .set_bold(true)
                 .set_intense(true)
-                .set_fg(Some(out::phase_color(config, "run"))),
+                .set_fg(Some(out::phase_color(config, "test"))),
         )
         .expect("Failed to set colour");
-        write!(lock, "R").unwrap();
+        write!(lock, "T").unwrap();
     } else {
         lock.set_color(
             ColorSpec::new()
                 .set_bold(false)
                 .set_intense(false)
-                .set_fg(Some(out::phase_color(config, "run"))),
+                .set_fg(Some(out::phase_color(config, "test"))),
         )
         .expect("Failed to set colour");
         write!(lock, ".").unwrap();
     }
     
     for phase in target.keys() {
-        if phase == "exec" || phase == "build" || phase == "run" {
+        if phase == "test" || phase == "build" || phase == "run" {
             continue;
         }
         lock.set_color(
diff --git a/src/out.rs b/src/out.rs
@@ -407,11 +407,11 @@ pub fn process_finish(status: &crate::exec::ProcessExit) {
             77 => "exit 77 (EX_NOPERM)".to_owned(),
             78 => "exit 78 (EX_CONFIG)".to_owned(),
             101 => "exit 101 (Process panicked)".to_owned(),
-            _ => format!("exit {}", code),
+            _ => format!("exit {code}"),
         }
     }
 
-    fn signal(signal: i32, core: Option<bool>) -> String {
+    fn signal(signal: i32, core: bool) -> String {
         use std::ffi::CStr;
 
         // SAFETY: No input is invalid.
@@ -423,29 +423,12 @@ pub fn process_finish(status: &crate::exec::ProcessExit) {
             // SAFETY: The returned string is valid until the next call to strsignal, and has been verified to be non-null.
             let sigstr = unsafe { CStr::from_ptr(sigstr_ptr) };
             format!(
-                "signal {} ({}{})",
-                signal,
+                "signal {signal} ({}){}",
                 sigstr.to_string_lossy(),
-                match core {
-                    Some(true) => " - core dumped",
-                    Some(false) => "",
-                    None => {
-                        // Signals that core dump by default.
-                        if signal == 3
-                            || signal == 4
-                            || signal == 5
-                            || signal == 6
-                            || signal == 7
-                            || signal == 8
-                            || signal == 10
-                            || signal == 11
-                            || signal == 12
-                        {
-                            " - core dumped?"
-                        } else {
-                            ""
-                        }
-                    }
+                if core {
+                    " - core dumped"
+                } else {
+                    ""
                 }
             )
         }
@@ -464,7 +447,7 @@ pub fn process_finish(status: &crate::exec::ProcessExit) {
                 } else {
                     use std::os::unix::process::ExitStatusExt;
 
-                    println!("=> {}", signal(status.signal().unwrap(), None));
+                    println!("=> {}", signal(status.signal().unwrap(), status.core_dumped()));
                 }
             }
         }
@@ -475,7 +458,7 @@ pub fn process_finish(status: &crate::exec::ProcessExit) {
                 }
             }
             nix::sys::wait::WaitStatus::Signaled(_, sig, core) => {
-                signal((*sig) as i32, Some(*core));
+                signal((*sig) as i32, *core);
             }
             _ => println!("=> exit ?"),
         },
diff --git a/src/parser.rs b/src/parser.rs
@@ -155,7 +155,7 @@ fn parse_root<T: Iterator<Item = (usize, char)> + std::fmt::Debug>(
         location: context.get_loc(0),
     };
     let mut current_script_target = "".to_owned();
-    let mut current_script_phase = "exec".to_owned();
+    let mut current_script_phase = "run".to_owned();
     while let Some(tk) = context.iterator.peek().copied() {
         match tk {
             // Comment
@@ -173,9 +173,12 @@ fn parse_root<T: Iterator<Item = (usize, char)> + std::fmt::Debug>(
                         .collect::<String>();
                     let phase = name
                         .rfind(':')
-                        .map(|idx| name.split_off(idx + 1))
-                        .unwrap_or_else(|| "exec".to_owned());
-                    name.pop();
+                        .map(|idx| {
+                            let phase = name.split_off(idx + 1);
+                            name.pop(); // To remove the `:` as well
+                            phase
+                        })
+                        .unwrap_or_else(|| "run".to_owned());
                     (name, phase)
                 };
 
diff --git a/src/script.rs b/src/script.rs
@@ -56,10 +56,17 @@ impl Runscript {
         }
     }
 
-    pub fn get_target(&self, target: &str) -> Option<&HashMap<String, Script>> {
+    pub fn get_default_target(&self) -> Option<(&String, &HashMap<String, Script>)> {
         self
             .scripts
             .targets
-            .get(target)
+            .get_index(0)
+    }
+
+    pub fn get_target(&self, target: &str) -> Option<(&String, &HashMap<String, Script>)> {
+        self
+            .scripts
+            .targets
+            .get_key_value(target)
     }
 }
diff --git a/test/run b/test/run

Original file line number	Diff line number	Diff line change
`@@ -471,7 +471,7 @@ struct ShellContext {`
`471`	`471`	`/// PID of most recent job`
`472`	`472`	`pid: i32,`
`473`	`473`	`/// Exit code of most recent top-level command`
`474`		`- exit_code: i32, //TODO: This will always be 0..`
	`474`	`+ exit_code: i32, //TODO: This will always be 0...`
`475`	`475`	`}`
`476`	`476`
`477`	`477`	`impl ShellContext {`
Original file line number	Diff line number	Diff line change
`@@ -56,10 +56,17 @@ impl Runscript {`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`		`- pub fn get_target(&self, target: &str) -> Option<&HashMap<String, Script>> {`
	`59`	`+ pub fn get_default_target(&self) -> Option<(&String, &HashMap<String, Script>)> {`
`60`	`60`	`self`
`61`	`61`	`.scripts`
`62`	`62`	`.targets`
`63`		`- .get(target)`
	`63`	`+ .get_index(0)`
	`64`	`+ }`
	`65`	`+`
	`66`	`+ pub fn get_target(&self, target: &str) -> Option<(&String, &HashMap<String, Script>)> {`
	`67`	`+ self`
	`68`	`+ .scripts`
	`69`	`+ .targets`
	`70`	`+ .get_key_value(target)`
`64`	`71`	`}`
`65`	`72`	`}`