Merge pull request #398 from gnpaone/sync-action

Sync source repo

Author: github-actions[bot]

README.md

@@ -1617,24 +1617,61 @@ Use `{{{{` to include a literal `{{` in a format string:
 foo := f'I {{{{LOVE} curly braces!'
 ```
 
-### Ignoring Errors
+### Sigils
 
-Normally, if a command returns a non-zero exit status, execution will stop. To
-continue execution after a command, even if it fails, prefix the command with
-`-`:
+Commands in linewise recipes may be prefixed with any combination of the sigils
+`-`, `@`, and `?`.
+
+The `@` sigil toggles command echoing:
 
 ```just
 foo:
-  -cat foo
-  echo 'Done!'
+  @echo "This line won't be echoed!"
+  echo "This line will be echoed!"
+
+@bar:
+  @echo "This line will be echoed!"
+  echo "This line won't be echoed!"
+```
+
+The `-` sigil cause recipe execution to continue even if the command returns a
+nonzero exit status:
+
+```just
+# execution will continue, even if bar doesn't exist
+foo:
+  -rmdir bar
+  mkdir bar
+  echo 'so much good stuff' > bar/stuff.txt
+```
+
+The `?` sigil<sup>master</sup> causes the current recipe to stop executing if
+the command exits with status code `1`, however execution of other recipes will
+continue. Exit status `0` causes the current recipe to continue execution as
+normal. All other exit codes are reserved and should not be used, as they may
+be given meaning in a future version of `just`.
+
+If the `guards` setting is unset or false, `?` sigils are ignored and instead
+treated as part of the command.
+
+```just
+set guards
+
+@foo: bar
+  echo FOO
+
+@bar:
+  ?[[ -f baz ]]
+  echo BAR
 ```
 
 ```console
 $ just foo
-cat foo
-cat: foo: No such file or directory
-echo 'Done!'
-Done!
+FOO
+$ touch baz
+$ just foo
+BAR
+FOO
 ```
 
 ### Functions

src/analyzer.rs

@@ -177,6 +177,23 @@ impl<'run, 'src> Analyzer<'run, 'src> {
       {
         deduplicated_recipes.insert(recipe.clone());
       }
+
+      if !recipe.is_script() {
+        for line in &recipe.body {
+          let sigils = line.sigils(&settings);
+
+          if sigils.contains(&Sigil::Guard) && sigils.contains(&Sigil::Infallible) {
+            let Fragment::Text { token } = line.fragments.first().unwrap() else {
+              unreachable!();
+            };
+            return Err(
+              token
+                .error(CompileErrorKind::GuardAndInfallibleSigil)
+                .into(),
+            );
+          }
+        }
+      }
     }
 
     let recipes = RecipeResolver::resolve_recipes(

src/compile_error.rs

@@ -195,6 +195,10 @@ impl Display for CompileError<'_> {
         Count("argument", *found),
         expected.display(),
       ),
+      GuardAndInfallibleSigil => write!(
+        f,
+        "The guard `?` and infallible `-` sigils may not be used together"
+      ),
       Include => write!(
         f,
         "The `!include` directive has been stabilized as `import`"

src/compile_error_kind.rs

@@ -83,6 +83,7 @@ pub(crate) enum CompileErrorKind<'src> {
     found: usize,
     expected: RangeInclusive<usize>,
   },
+  GuardAndInfallibleSigil,
   Include,
   InconsistentLeadingWhitespace {
     expected: &'src str,

src/error.rs

@@ -120,6 +120,11 @@ pub(crate) enum Error<'src> {
   GetConfirmation {
     io_error: io::Error,
   },
+  GuardCode {
+    recipe: &'src str,
+    line_number: usize,
+    code: i32,
+  },
   Homedir,
   InitExists {
     justfile: PathBuf,
@@ -353,10 +358,6 @@ impl ColorDisplay for Error<'_> {
     write!(f, "{error}: {message}")?;
 
     match self {
-      Const { const_error } => write!(
-        f,
-        "{const_error}",
-      )?,
       AmbiguousModuleFile { module, found } => write!(
         f,
         "Found multiple source files for module `{module}`: {}",
@@ -469,6 +470,10 @@ impl ColorDisplay for Error<'_> {
       }
       Compile { compile_error } => Display::fmt(compile_error, f)?,
       Config { config_error } => Display::fmt(config_error, f)?,
+      Const { const_error } => write!(
+        f,
+        "{const_error}",
+      )?,
       Cygpath {
         recipe,
         output_error,
@@ -574,6 +579,16 @@ impl ColorDisplay for Error<'_> {
       GetConfirmation { io_error } => {
         write!(f, "Failed to read confirmation from stdin: {io_error}")?;
       }
+      GuardCode {
+        recipe,
+        line_number,
+        code,
+      } => {
+        write!(
+          f,
+          "Guard line in recipe `{recipe}` on line {line_number} returned reserved exit code {code}",
+        )?;
+      }
       Homedir => {
         write!(f, "Failed to get homedir")?;
       }

src/evaluator.rs

@@ -103,6 +103,9 @@ impl<'src, 'run> Evaluator<'src, 'run> {
         Setting::Fallback(value) => {
           settings.fallback = value;
         }
+        Setting::Guards(guards) => {
+          settings.guards = guards;
+        }
         Setting::IgnoreComments(value) => {
           settings.ignore_comments = value;
         }

src/justfile.rs

@@ -128,6 +128,33 @@ impl<'src> Justfile<'src> {
     let scope = scopes.get(&self.module_path).unwrap().1;
 
     match &config.subcommand {
+      Subcommand::Choose { .. } | Subcommand::Run { .. } => {
+        let arguments = arguments.iter().map(String::as_str).collect::<Vec<&str>>();
+
+        let invocations = InvocationParser::parse_invocations(self, &arguments)?;
+
+        if config.one && invocations.len() > 1 {
+          return Err(Error::ExcessInvocations {
+            invocations: invocations.len(),
+          });
+        }
+
+        let ran = Ran::default();
+        for invocation in invocations {
+          Self::run_recipe(
+            &invocation.arguments,
+            config,
+            &dotenv,
+            false,
+            &ran,
+            invocation.recipe,
+            &scopes,
+            search,
+          )?;
+        }
+
+        Ok(())
+      }
       Subcommand::Command {
         binary, arguments, ..
       } => {
@@ -167,7 +194,7 @@ impl<'src> Justfile<'src> {
           return Err(Error::Interrupted { signal });
         }
 
-        return Ok(());
+        Ok(())
       }
       Subcommand::Evaluate { variable, .. } => {
         if let Some(variable) = variable {
@@ -194,36 +221,10 @@ impl<'src> Justfile<'src> {
           }
         }
 
-        return Ok(());
+        Ok(())
       }
-      _ => {}
+      _ => unreachable!(),
     }
-
-    let arguments = arguments.iter().map(String::as_str).collect::<Vec<&str>>();
-
-    let invocations = InvocationParser::parse_invocations(self, &arguments)?;
-
-    if config.one && invocations.len() > 1 {
-      return Err(Error::ExcessInvocations {
-        invocations: invocations.len(),
-      });
-    }
-
-    let ran = Ran::default();
-    for invocation in invocations {
-      Self::run_recipe(
-        &invocation.arguments,
-        config,
-        &dotenv,
-        false,
-        &ran,
-        invocation.recipe,
-        &scopes,
-        search,
-      )?;
-    }
-
-    Ok(())
   }
 
   pub(crate) fn check_unstable(&self, config: &Config) -> RunResult<'src> {

src/keyword.rs

@@ -17,6 +17,7 @@ pub(crate) enum Keyword {
   F,
   Fallback,
   False,
+  Guards,
   If,
   IgnoreComments,
   Import,

src/lib.rs

@@ -82,6 +82,7 @@ pub(crate) use {
     settings::Settings,
     shebang::Shebang,
     show_whitespace::ShowWhitespace,
+    sigil::Sigil,
     signal::Signal,
     signal_handler::SignalHandler,
     source::Source,
@@ -268,6 +269,7 @@ mod setting;
 mod settings;
 mod shebang;
 mod show_whitespace;
+mod sigil;
 mod signal;
 mod signal_handler;
 #[cfg(unix)]

src/line.rs

@@ -18,6 +18,27 @@ impl Line<'_> {
     }
   }
 
+  pub(crate) fn sigils(&self, settings: &Settings) -> BTreeSet<Sigil> {
+    let mut sigils = BTreeSet::new();
+
+    if let Some(first) = self.first() {
+      for c in first.chars() {
+        let sigil = match c {
+          '-' => Sigil::Infallible,
+          '?' if settings.guards => Sigil::Guard,
+          '@' => Sigil::Quiet,
+          _ => break,
+        };
+
+        if !sigils.insert(sigil) {
+          break;
+        }
+      }
+    }
+
+    sigils
+  }
+
   pub(crate) fn is_comment(&self) -> bool {
     self.first().is_some_and(|text| text.starts_with('#'))
   }
@@ -33,18 +54,6 @@ impl Line<'_> {
     self.fragments.is_empty()
   }
 
-  pub(crate) fn is_infallible(&self) -> bool {
-    self
-      .first()
-      .is_some_and(|text| text.starts_with('-') || text.starts_with("@-"))
-  }
-
-  pub(crate) fn is_quiet(&self) -> bool {
-    self
-      .first()
-      .is_some_and(|text| text.starts_with('@') || text.starts_with("-@"))
-  }
-
   pub(crate) fn is_shebang(&self) -> bool {
     self.first().is_some_and(|text| text.starts_with("#!"))
   }