ROX-36673: Allow instructions with multiple arguments

src/main.rs

@@ -294,17 +294,54 @@ mod tests {
     }
 
     #[test]
-    fn test_task_script() {
+    fn test_task_script_random_arg() {
+        let input = r#"
+            main () {
+              task(stub, random_string());
+            }
+        "#;
+
+        let nodes: Vec<Node> = parse_instructions(input).unwrap();
+        assert_eq!(nodes.len(), 1);
+        let prepared_nodes = apply_rules(nodes);
+
+        new_script_worker(prepared_nodes[0].clone())
+            .run_payload()
+            .unwrap();
+    }
+
+    #[test]
+    fn test_task_script_no_arg() {
         let input = r#"
             main () {
               task(stub);
             }
         "#;
 
-        let ast: Vec<Node> = parse_instructions(input).unwrap();
-        assert_eq!(ast.len(), 1);
+        let nodes: Vec<Node> = parse_instructions(input).unwrap();
+        assert_eq!(nodes.len(), 1);
+        let prepared_nodes = apply_rules(nodes);
 
-        new_script_worker(ast[0].clone()).run_payload().unwrap();
+        new_script_worker(prepared_nodes[0].clone())
+            .run_payload()
+            .unwrap();
+    }
+
+    #[test]
+    fn test_task_script_fixed_arg() {
+        let input = r#"
+            main () {
+              task(stub, "arg1 arg2");
+            }
+        "#;
+
+        let nodes: Vec<Node> = parse_instructions(input).unwrap();
+        assert_eq!(nodes.len(), 1);
+        let prepared_nodes = apply_rules(nodes);
+
+        new_script_worker(prepared_nodes[0].clone())
+            .run_payload()
+            .unwrap();
     }
 
     #[test]

src/script/ast.rs

@@ -2,6 +2,9 @@ use std::collections::HashMap;
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Arg {
+    /// Null constant
+    Null,
+
     /// Simple constant
     Const { text: String },
 
@@ -14,9 +17,16 @@ pub enum Arg {
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Instruction {
+    /// Execute a binary with specified name and arguments
     Task { name: Arg, args: Vec<Arg> },
+
+    /// Open a file at specified path
     Open { path: Arg },
+
+    /// Print a debugging message (subject to configured log level)
     Debug { text: Arg },
+
+    /// Send a message to a server at specified address
     Ping { server: Arg },
 }
 

src/script/grammar.peg

@@ -27,7 +27,7 @@ arg = {
 }
 
 args = {"(" ~ (arg ~ ("," ~ arg)* ~ ","?)? ~ ")"}
-value = {(ASCII_ALPHANUMERIC| "." | " " | "/" | ":")*}
+value = {(ASCII_ALPHANUMERIC | "." | " " | "/" | ":" | "_")*}
 
 param = {ident ~ "=" ~ value}
 params = {"(" ~ (param ~ ("," ~ param)* ~ ","?)? ~ ")"}

src/script/rules.rs

@@ -1,13 +1,39 @@
 use log::debug;
 
-use crate::script::ast::{Instruction, Node};
+use crate::script::ast::{Arg, Instruction, Node};
 use std::collections::HashMap;
 
-fn apply_instruction_rules(
+/// Apply following transformations to task instruction:
+/// * If no arguments provided for the task, add an empty argument
+fn apply_task_rules(task: &Instruction, _node: &Node) -> Instruction {
+    let Instruction::Task { name, args } = task else {
+        unreachable!()
+    };
+
+    let new_args = if args.is_empty() {
+        vec![Arg::Null {}]
+    } else {
+        args.to_vec()
+    };
+
+    Instruction::Task {
+        name: name.clone(),
+        args: new_args,
+    }
+}
+
+fn apply_instructions_rules(
     instructions: &[Instruction],
-    _node: &Node,
+    node: &Node,
 ) -> Vec<Instruction> {
-    instructions.to_vec()
+    instructions
+        .iter()
+        .map(|i| match i {
+            Instruction::Task { .. } => apply_task_rules(i, node),
+            _ => i.clone(),
+        })
+        .collect::<Vec<_>>()
+        .to_vec()
 }
 
 fn apply_arg_rules(
@@ -43,7 +69,7 @@ fn apply_work_rules(work: Node) -> Node {
     Node::Work {
         name: name.clone(),
         args: apply_arg_rules(args, &work),
-        instructions: apply_instruction_rules(instructions, &work),
+        instructions: apply_instructions_rules(instructions, &work),
         dist: dist.clone(),
     }
 }