Add recipe opts

justfile

@@ -182,8 +182,8 @@ build-book:
   mdbook build book/en
   mdbook build book/zh
 
-convert-integration-test test:
-  cargo expand --test integration {{test}} | \
+convert-integration-test TEST:
+  cargo expand --test integration {{ TEST }} | \
     sed \
     -E \
     -e 's/#\[cfg\(test\)\]/#\[test\]/' \

src/evaluator.rs

@@ -255,6 +255,7 @@ impl<'src, 'run> Evaluator<'src, 'run> {
     config: &'run Config,
     dotenv: &'run BTreeMap<String, String>,
     parameters: &[Parameter<'src>],
+    opts: BTreeMap<Name<'src>, &str>,
     arguments: &[&str],
     scope: &'run Scope<'src, 'run>,
     settings: &'run Settings,
@@ -271,6 +272,10 @@ impl<'src, 'run> Evaluator<'src, 'run> {
 
     let mut scope = scope.child();
 
+    for (name, value) in opts {
+      scope.bind(false, name, value.into());
+    }
+
     let mut positional = Vec::new();
 
     let mut rest = arguments;

src/justfile.rs

@@ -215,8 +215,25 @@ impl<'src> Justfile<'src> {
 
     while let Some((argument, mut tail)) = rest.split_first() {
       if let Some(recipe) = self.get_recipe(argument) {
+        let mut opts = BTreeMap::new();
+
+        for opt in &recipe.opts {
+          if let Some(arg) = tail.first() {
+            if opt.accepts(arg) {
+              if let Some(value) = tail.get(1) {
+                opts.insert(opt.variable, *value);
+              } else {
+                panic!("opt with no value");
+              }
+              tail = &tail[2..];
+              continue;
+            }
+          }
+          panic!("opt not found");
+        }
+
         if recipe.parameters.is_empty() {
-          grouped.push((recipe, &[][..]));
+          grouped.push((recipe, opts, &[][..]));
         } else {
           let argument_range = recipe.argument_range();
           let argument_count = cmp::min(tail.len(), recipe.max_arguments());
@@ -229,7 +246,7 @@ impl<'src> Justfile<'src> {
               max: recipe.max_arguments(),
             });
           }
-          grouped.push((recipe, &tail[0..argument_count]));
+          grouped.push((recipe, opts, &tail[0..argument_count]));
           tail = &tail[argument_count..];
         }
       } else {
@@ -258,8 +275,8 @@ impl<'src> Justfile<'src> {
     };
 
     let mut ran = BTreeSet::new();
-    for (recipe, arguments) in grouped {
-      Self::run_recipe(&context, recipe, arguments, &dotenv, search, &mut ran)?;
+    for (recipe, opts, arguments) in grouped {
+      Self::run_recipe(&context, recipe, opts, arguments, &dotenv, search, &mut ran)?;
     }
 
     Ok(())
@@ -280,6 +297,7 @@ impl<'src> Justfile<'src> {
   fn run_recipe(
     context: &RecipeContext<'src, '_>,
     recipe: &Recipe<'src>,
+    opts: BTreeMap<Name<'src>, &str>,
     arguments: &[&str],
     dotenv: &BTreeMap<String, String>,
     search: &Search,
@@ -304,6 +322,7 @@ impl<'src> Justfile<'src> {
       context.config,
       dotenv,
       &recipe.parameters,
+      opts,
       arguments,
       &context.scope,
       context.settings,
@@ -324,6 +343,7 @@ impl<'src> Justfile<'src> {
       Self::run_recipe(
         context,
         recipe,
+        BTreeMap::new(),
         &arguments.iter().map(String::as_ref).collect::<Vec<&str>>(),
         dotenv,
         search,
@@ -346,6 +366,7 @@ impl<'src> Justfile<'src> {
         Self::run_recipe(
           context,
           recipe,
+          BTreeMap::new(),
           &evaluated.iter().map(String::as_ref).collect::<Vec<&str>>(),
           dotenv,
           search,

src/lexer.rs

@@ -282,11 +282,7 @@ impl<'src> Lexer<'src> {
 
   /// True if `c` can be a continuation character of an identifier
   fn is_identifier_continue(c: char) -> bool {
-    if Self::is_identifier_start(c) {
-      return true;
-    }
-
-    matches!(c, '0'..='9' | '-')
+    Self::is_identifier_start(c) | matches!(c, '0'..='9' | '-')
   }
 
   /// Consume the text and produce a series of tokens
@@ -490,6 +486,7 @@ impl<'src> Lexer<'src> {
       '*' => self.lex_single(Asterisk),
       '+' => self.lex_single(Plus),
       ',' => self.lex_single(Comma),
+      '-' => self.lex_digraph('-', '-', DashDash),
       '/' => self.lex_single(Slash),
       ':' => self.lex_colon(),
       '\\' => self.lex_escape(),
@@ -990,6 +987,7 @@ mod tests {
       Colon => ":",
       ColonEquals => ":=",
       Comma => ",",
+      DashDash => "--",
       Dollar => "$",
       Eol => "\n",
       Equals => "=",
@@ -2205,8 +2203,8 @@ mod tests {
   }
 
   error! {
-    name:   invalid_name_start_dash,
-    input:  "-foo",
+    name:   invalid_name_start_caret,
+    input:  "^foo",
     offset: 0,
     line:   0,
     column: 0,

src/lib.rs

@@ -21,9 +21,9 @@ pub(crate) use {
     fragment::Fragment, function::Function, function_context::FunctionContext,
     interrupt_guard::InterruptGuard, interrupt_handler::InterruptHandler, item::Item,
     justfile::Justfile, keyed::Keyed, keyword::Keyword, lexer::Lexer, line::Line, list::List,
-    load_dotenv::load_dotenv, loader::Loader, name::Name, ordinal::Ordinal, output::output,
-    output_error::OutputError, parameter::Parameter, parameter_kind::ParameterKind, parser::Parser,
-    platform::Platform, platform_interface::PlatformInterface, position::Position,
+    load_dotenv::load_dotenv, loader::Loader, name::Name, opt::Opt, ordinal::Ordinal,
+    output::output, output_error::OutputError, parameter::Parameter, parameter_kind::ParameterKind,
+    parser::Parser, platform::Platform, platform_interface::PlatformInterface, position::Position,
     positional::Positional, range_ext::RangeExt, recipe::Recipe, recipe_context::RecipeContext,
     recipe_resolver::RecipeResolver, scope::Scope, search::Search, search_config::SearchConfig,
     search_error::SearchError, set::Set, setting::Setting, settings::Settings, shebang::Shebang,
@@ -145,6 +145,7 @@ mod list;
 mod load_dotenv;
 mod loader;
 mod name;
+mod opt;
 mod ordinal;
 mod output;
 mod output_error;

src/opt.rs

@@ -0,0 +1,34 @@
+use super::*;
+
+#[derive(PartialEq, Debug, Clone, Serialize)]
+pub(crate) struct Opt<'src> {
+  pub(crate) default: Option<Expression<'src>>,
+  pub(crate) key: Name<'src>,
+  pub(crate) variable: Name<'src>,
+}
+
+impl<'src> Opt<'src> {
+  pub(crate) fn accepts(&self, arg: &str) -> bool {
+    arg
+      .strip_prefix("--")
+      .map(|key| key == self.key.lexeme())
+      .unwrap_or_default()
+  }
+}
+
+impl<'src> ColorDisplay for Opt<'src> {
+  fn fmt(&self, f: &mut Formatter, color: Color) -> Result<(), fmt::Error> {
+    write!(
+      f,
+      "--{} {}",
+      color.annotation().paint(self.key.lexeme()),
+      color.parameter().paint(self.variable.lexeme())
+    )?;
+
+    if let Some(ref default) = self.default {
+      write!(f, "={}", color.string().paint(&default.to_string()))?;
+    }
+
+    Ok(())
+  }
+}

src/parser.rs

@@ -627,9 +627,16 @@ impl<'tokens, 'src> Parser<'tokens, 'src> {
     let name = self.parse_name()?;
 
     let mut positional = Vec::new();
+    let mut opts = Vec::new();
 
-    while self.next_is(Identifier) || self.next_is(Dollar) {
-      positional.push(self.parse_parameter(ParameterKind::Singular)?);
+    loop {
+      if self.next_is(Identifier) || self.next_is(Dollar) {
+        positional.push(self.parse_parameter(ParameterKind::Singular)?);
+      } else if self.next_is(DashDash) {
+        opts.push(self.parse_opt()?);
+      } else {
+        break;
+      }
     }
 
     let kind = if self.accepted(Plus)? {
@@ -687,11 +694,12 @@ impl<'tokens, 'src> Parser<'tokens, 'src> {
       private: name.lexeme().starts_with('_'),
       shebang: body.first().map_or(false, Line::is_shebang),
       attributes,
-      priors,
       body,
       dependencies,
       doc,
       name,
+      opts,
+      priors,
       quiet,
     })
   }
@@ -716,6 +724,27 @@ impl<'tokens, 'src> Parser<'tokens, 'src> {
     })
   }
 
+  /// Parse a recipe option --foo foo
+  fn parse_opt(&mut self) -> CompileResult<'src, Opt<'src>> {
+    self.presume(DashDash)?;
+
+    let key = self.parse_name()?;
+
+    let variable = self.parse_name()?;
+
+    let default = if self.accepted(Equals)? {
+      Some(self.parse_value()?)
+    } else {
+      None
+    };
+
+    Ok(Opt {
+      default,
+      key,
+      variable,
+    })
+  }
+
   /// Parse the body of a recipe
   fn parse_body(&mut self) -> CompileResult<'src, Vec<Line<'src>>> {
     let mut lines = Vec::new();
@@ -2014,7 +2043,7 @@ mod tests {
     column: 5,
     width:  1,
     kind:   UnexpectedToken{
-      expected: vec![Asterisk, Colon, Dollar, Equals, Identifier, Plus],
+      expected: vec![Asterisk, Colon, DashDash, Dollar, Equals, Identifier, Plus],
       found:    Eol
     },
   }
@@ -2149,7 +2178,7 @@ mod tests {
     column: 8,
     width:  0,
     kind:   UnexpectedToken {
-      expected: vec![Asterisk, Colon, Dollar, Equals, Identifier, Plus],
+      expected: vec![Asterisk, Colon, DashDash, Dollar, Equals, Identifier, Plus],
       found:    Eof
     },
   }

src/recipe.rs

@@ -32,6 +32,8 @@ pub(crate) struct Recipe<'src, D = Dependency<'src>> {
   pub(crate) private: bool,
   pub(crate) quiet: bool,
   pub(crate) shebang: bool,
+  #[serde(skip)]
+  pub(crate) opts: Vec<Opt<'src>>,
 }
 
 impl<'src, D> Recipe<'src, D> {
@@ -406,6 +408,10 @@ impl<'src, D: Display> ColorDisplay for Recipe<'src, D> {
       write!(f, "{}", self.name)?;
     }
 
+    for opt in &self.opts {
+      write!(f, " {}", opt.color_display(color))?;
+    }
+
     for parameter in &self.parameters {
       write!(f, " {}", parameter.color_display(color))?;
     }

src/recipe_resolver.rs

@@ -25,15 +25,15 @@ impl<'src: 'run, 'run> RecipeResolver<'src, 'run> {
       for parameter in &recipe.parameters {
         if let Some(expression) = &parameter.default {
           for variable in expression.variables() {
-            resolver.resolve_variable(&variable, &[])?;
+            resolver.resolve_variable(&variable, &Vec::new(), &[])?;
           }
         }
       }
 
       for dependency in &recipe.dependencies {
         for argument in &dependency.arguments {
           for variable in argument.variables() {
-            resolver.resolve_variable(&variable, &recipe.parameters)?;
+            resolver.resolve_variable(&variable, &recipe.opts, &recipe.parameters)?;
           }
         }
       }
@@ -42,7 +42,7 @@ impl<'src: 'run, 'run> RecipeResolver<'src, 'run> {
         for fragment in &line.fragments {
           if let Fragment::Interpolation { expression, .. } = fragment {
             for variable in expression.variables() {
-              resolver.resolve_variable(&variable, &recipe.parameters)?;
+              resolver.resolve_variable(&variable, &recipe.opts, &recipe.parameters)?;
             }
           }
         }
@@ -55,11 +55,15 @@ impl<'src: 'run, 'run> RecipeResolver<'src, 'run> {
   fn resolve_variable(
     &self,
     variable: &Token<'src>,
+    opts: &Vec<Opt<'src>>,
     parameters: &[Parameter],
   ) -> CompileResult<'src, ()> {
     let name = variable.lexeme();
-    let undefined =
-      !self.assignments.contains_key(name) && !parameters.iter().any(|p| p.name.lexeme() == name);
+    let undefined = !self.assignments.contains_key(name)
+      && !opts.iter().any(|opt| opt.variable.lexeme() == name)
+      && !parameters
+        .iter()
+        .any(|parameter| parameter.name.lexeme() == name);
 
     if undefined {
       return Err(variable.error(UndefinedVariable { variable: name }));

src/token_kind.rs

@@ -17,6 +17,7 @@ pub(crate) enum TokenKind {
   ColonEquals,
   Comma,
   Comment,
+  DashDash,
   Dedent,
   Dollar,
   Eof,
@@ -60,6 +61,7 @@ impl Display for TokenKind {
         ColonEquals => "':='",
         Comma => "','",
         Comment => "comment",
+        DashDash => "'--'",
         Dedent => "dedent",
         Dollar => "'$'",
         Eof => "end of file",

src/unresolved_recipe.rs

@@ -45,16 +45,17 @@ impl<'src> UnresolvedRecipe<'src> {
       .collect();
 
     Ok(Recipe {
+      attributes: self.attributes,
       body: self.body,
+      dependencies,
       doc: self.doc,
       name: self.name,
+      opts: self.opts,
       parameters: self.parameters,
+      priors: self.priors,
       private: self.private,
       quiet: self.quiet,
       shebang: self.shebang,
-      priors: self.priors,
-      attributes: self.attributes,
-      dependencies,
     })
   }
 }