Add confirm prompt

README.md

@@ -1456,6 +1456,7 @@ Recipes may be annotated with attributes that change their behavior.
 | Name | Description |
 |------|-------------|
 | `[confirm]`<sup>1.17.0</sup> | Require confirmation prior to executing recipe. |
+| `[confirm("custom prompt")]`<sup>unreleased</sup> | Same as above but with a user-defined prompt |
 | `[linux]`<sup>1.8.0</sup> | Enable recipe on Linux. |
 | `[macos]`<sup>1.8.0</sup> | Enable recipe on MacOS. |
 | `[no-cd]`<sup>1.9.0</sup> | Don't change directory before executing recipe. |
@@ -1544,6 +1545,16 @@ delete all:
   rm -rf *
 ```
 
+#### Customize recipe confirmation prompt <sup>unreleased</sup>
+
+The default prompt: ``Run recipe `foo`?`` can be overwritten with `[confirm(PROMPT)]`:
+
+```just
+[confirm("Are you sure you want to delete everything?")]
+delete-everything:
+  rm -rf *
+```
+
 ### Command Evaluation Using Backticks
 
 Backticks can be used to store the result of commands:

src/analyzer.rs

@@ -215,7 +215,7 @@ impl<'src> Analyzer<'src> {
       if *attr != Attribute::Private {
         return Err(alias.name.token.error(AliasInvalidAttribute {
           alias: name,
-          attr: *attr,
+          attr: attr.clone(),
         }));
       }
     }

src/attribute.rs

@@ -1,12 +1,10 @@
 use super::*;
 
-#[derive(
-  EnumString, PartialEq, Debug, Copy, Clone, Serialize, Ord, PartialOrd, Eq, IntoStaticStr,
-)]
+#[derive(EnumString, PartialEq, Debug, Clone, Serialize, Ord, PartialOrd, Eq, IntoStaticStr)]
 #[strum(serialize_all = "kebab-case")]
 #[serde(rename_all = "kebab-case")]
 pub(crate) enum Attribute {
-  Confirm,
+  Confirm(Option<String>),
   Linux,
   Macos,
   NoCd,
@@ -22,9 +20,41 @@ impl Attribute {
     name.lexeme().parse().ok()
   }
 
-  pub(crate) fn to_str(self) -> &'static str {
+  pub(crate) fn to_str(&self) -> &'static str {
     self.into()
   }
+
+  /// Returns a range from the min to max expected arguments of a given attribute
+  pub(crate) fn expect_args(&self) -> Range<usize> {
+    use Attribute::*;
+
+    match self {
+      Confirm(_) => 1..2,
+      _ => 0..0,
+    }
+  }
+
+  pub(crate) fn with_arguments(
+    self,
+    arguments: Vec<StringLiteral<'_>>,
+  ) -> Result<Attribute, CompileErrorKind<'_>> {
+    use Attribute::*;
+
+    if !self.expect_args().range_contains(&arguments.len()) {
+      return Err(CompileErrorKind::AttributeArgumentCountMismatch {
+        attribute: self.to_str(),
+        found: arguments.len(),
+        expected: self.expect_args(),
+      });
+    }
+
+    match self {
+      Confirm(_) => Ok(Attribute::Confirm(
+        arguments.first().map(|s| s.cooked.clone()),
+      )),
+      _ => unreachable!("Missing implementation for attribute that accepts arguments"),
+    }
+  }
 }
 
 #[cfg(test)]

src/compile_error.rs

@@ -43,6 +43,16 @@ impl Display for CompileError<'_> {
         self.token.line.ordinal(),
         recipe_line.ordinal(),
       ),
+      AttributeArgumentCountMismatch {
+        attribute,
+        found,
+        expected,
+      } => write!(
+        f,
+        "Attribute `{attribute}` called with {found} {} but takes {}",
+        Count("argument", *found),
+        expected.display(),
+      ),
       BacktickShebang => write!(f, "Backticks may not start with `#!`"),
       CircularRecipeDependency { recipe, ref circle } => {
         if circle.len() == 2 {

src/compile_error_kind.rs

@@ -10,6 +10,11 @@ pub(crate) enum CompileErrorKind<'src> {
     alias: &'src str,
     recipe_line: usize,
   },
+  AttributeArgumentCountMismatch {
+    attribute: &'src str,
+    found: usize,
+    expected: Range<usize>,
+  },
   BacktickShebang,
   CircularRecipeDependency {
     recipe: &'src str,

src/parser.rs

@@ -922,8 +922,33 @@ impl<'run, 'src> Parser<'run, 'src> {
             first: *line,
           }));
         }
+
+        let arguments = if self.accepted(ParenL)? {
+          let mut arguments = Vec::new();
+
+          while self.next_is(StringToken) {
+            arguments.push(self.parse_string_literal()?);
+          }
+          self.expect(ParenR)?;
+          Some(arguments)
+        } else {
+          None
+        };
+
+        let attribute = if let Some(arguments) = arguments {
+          match attribute.with_arguments(arguments) {
+            Ok(attribute) => attribute,
+            Err(kind) =>  {
+              return Err(name.error(kind));
+            },
+          }
+        } else {
+          attribute
+        };
+
         attributes.insert(attribute, name.line);
 
+
         if !self.accepted(Comma)? {
           break;
         }

src/range_ext.rs

@@ -13,11 +13,14 @@ pub(crate) struct DisplayRange<T>(T);
 impl Display for DisplayRange<&Range<usize>> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     if self.0.start == self.0.end {
+      write!(f, "0")?;
+    } else if self.0.start == self.0.end - 1 {
       write!(f, "{}", self.0.start)?;
     } else if self.0.end == usize::MAX {
       write!(f, "{} or more", self.0.start)?;
     } else {
-      write!(f, "{} to {}", self.0.start, self.0.end)?;
+      // the range is exclusive from above so it is "start to end-1"
+      write!(f, "{} to {}", self.0.start, self.0.end - 1)?;
     }
     Ok(())
   }
@@ -47,15 +50,11 @@ mod tests {
 
   #[test]
   fn exclusive() {
-    assert!(!(0..0).range_contains(&0));
     assert!(!(0..0).range_contains(&0));
     assert!(!(1..10).range_contains(&0));
     assert!(!(1..10).range_contains(&10));
     assert!(!(1..10).range_contains(&0));
-    assert!(!(1..10).range_contains(&10));
     assert!((0..1).range_contains(&0));
-    assert!((0..1).range_contains(&0));
-    assert!((10..20).range_contains(&15));
     assert!((10..20).range_contains(&15));
   }
 
@@ -75,8 +74,11 @@ mod tests {
 
   #[test]
   fn display() {
-    assert_eq!((1..1).display().to_string(), "1");
-    assert_eq!((1..2).display().to_string(), "1 to 2");
+    assert!(!(1..1).contains(&1));
+    assert!((1..1).len() == 0);
+    assert!((5..5).len() == 0);
+    assert_eq!((1..1).display().to_string(), "0");
+    assert_eq!((1..2).display().to_string(), "1");
     assert_eq!((1..usize::MAX).display().to_string(), "1 or more");
   }
 }

src/recipe.rs

@@ -71,17 +71,24 @@ impl<'src, D> Recipe<'src, D> {
   }
 
   pub(crate) fn confirm(&self) -> RunResult<'src, bool> {
-    if self.attributes.contains(&Attribute::Confirm) {
-      eprint!("Run recipe `{}`? ", self.name);
-      let mut line = String::new();
-      std::io::stdin()
-        .read_line(&mut line)
-        .map_err(|io_error| Error::GetConfirmation { io_error })?;
-      let line = line.trim().to_lowercase();
-      Ok(line == "y" || line == "yes")
-    } else {
-      Ok(true)
+    // Iterate through the attributes and check if any of them are a confirm
+    // If a `confirm` attribute is found, print a prompt and wait for user input
+    // else return true
+    for attribute in &self.attributes {
+      if let Attribute::Confirm(prompt) = attribute {
+        let prompt: String = prompt
+          .as_ref()
+          .map_or_else(|| format!("Run recipe `{}`?", self.name), std::borrow::ToOwned::to_owned);
+        eprint!("{prompt} ");
+        let mut line = String::new();
+        std::io::stdin()
+          .read_line(&mut line)
+          .map_err(|io_error| Error::GetConfirmation { io_error })?;
+        let line = line.trim().to_lowercase();
+        return Ok(line == "y" || line == "yes");
+      }
     }
+    Ok(true)
   }
 
   pub(crate) fn check_can_be_default_recipe(&self) -> RunResult<'src, ()> {

tests/confirm.rs

@@ -103,3 +103,35 @@ fn do_not_confirm_recipe_with_confirm_recipe_dependency() {
     .status(1)
     .run();
 }
+
+#[test]
+fn confirm_recipe_with_prompt() {
+  Test::new()
+    .justfile(
+      "
+        [confirm(\"This is dangerous - are you sure you want to run it?\")]
+        requires_confirmation:
+            echo confirmed
+        ",
+    )
+    .stderr("This is dangerous - are you sure you want to run it? echo confirmed\n")
+    .stdout("confirmed\n")
+    .stdin("y")
+    .run();
+}
+
+#[test]
+fn confirm_recipe_with_prompt_too_many_args() {
+  Test::new()
+    .justfile(
+      "
+        [confirm(\"This is dangerous - are you sure you want to run it?\" \"this second argument is not supported\")]
+        requires_confirmation:
+            echo confirmed
+        ",
+    )
+    .stderr("error: Attribute `confirm` called with 2 arguments but takes 1\n ——▶ justfile:1:2\n  │\n1 │ [confirm(\"This is dangerous - are you sure you want to run it?\" \"this second argument is not supported\")]\n  │  ^^^^^^^\n")
+    .stdout("")
+    .status(1)
+    .run();
+}