feat: implement each and when block statements (#52)

feat: implement each and when blocks (closes #23)

Author: alvinreal

src/mapping/ast.rs

@@ -110,6 +110,18 @@ pub enum Statement {
     Where { condition: Expr, span: Span },
     /// `sort .field asc, .field2 desc` — sort array elements
     Sort { keys: Vec<SortKey>, span: Span },
+    /// `each .path { ... }` — apply block to each array element
+    Each {
+        path: Path,
+        body: Vec<Statement>,
+        span: Span,
+    },
+    /// `when <condition> { ... }` — conditional block
+    When {
+        condition: Expr,
+        body: Vec<Statement>,
+        span: Span,
+    },
 }
 
 /// A sort direction.

src/mapping/eval.rs

@@ -28,6 +28,10 @@ fn eval_statement(stmt: &Statement, value: &Value) -> error::Result<Value> {
         Statement::Nest { paths, target, .. } => eval_nest(value, paths, target),
         Statement::Where { condition, .. } => eval_where(value, condition),
         Statement::Sort { keys, .. } => eval_sort(value, keys),
+        Statement::Each { path, body, .. } => eval_each(value, path, body),
+        Statement::When {
+            condition, body, ..
+        } => eval_when(value, condition, body),
     }
 }
 
@@ -334,6 +338,48 @@ fn eval_sort(value: &Value, keys: &[SortKey]) -> error::Result<Value> {
     }
 }
 
+// ---------------------------------------------------------------------------
+// each
+// ---------------------------------------------------------------------------
+
+fn eval_each(value: &Value, path: &Path, body: &[Statement]) -> error::Result<Value> {
+    let target = resolve_path(value, &path.segments);
+    match target {
+        Some(Value::Array(arr)) => {
+            let mut updated = Vec::with_capacity(arr.len());
+            for item in &arr {
+                let mut result = item.clone();
+                for stmt in body {
+                    result = eval_statement(stmt, &result)?;
+                }
+                updated.push(result);
+            }
+            Ok(set_path(value, &path.segments, Value::Array(updated)))
+        }
+        Some(_) => Err(error::MorphError::mapping("each requires an array target")),
+        None => Err(error::MorphError::mapping(
+            "each target path does not exist",
+        )),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// when
+// ---------------------------------------------------------------------------
+
+fn eval_when(value: &Value, condition: &Expr, body: &[Statement]) -> error::Result<Value> {
+    let cond_result = eval_expr(condition, value)?;
+    if is_truthy(&cond_result) {
+        let mut result = value.clone();
+        for stmt in body {
+            result = eval_statement(stmt, &result)?;
+        }
+        Ok(result)
+    } else {
+        Ok(value.clone())
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Expression evaluation
 // ---------------------------------------------------------------------------

src/mapping/parser.rs

@@ -101,6 +101,8 @@ impl Parser {
             TokenKind::Nest => self.parse_nest(),
             TokenKind::Where => self.parse_where(),
             TokenKind::Sort => self.parse_sort(),
+            TokenKind::Each => self.parse_each(),
+            TokenKind::When => self.parse_when(),
             _ => {
                 let suggestion = suggest_keyword(&token.kind);
                 let msg = if let Some(s) = suggestion {
@@ -322,6 +324,49 @@ impl Parser {
         }
     }
 
+    fn parse_each(&mut self) -> error::Result<Statement> {
+        let start = self.advance().unwrap(); // consume 'each'
+        let path = self.parse_path()?;
+        let body = self.parse_block()?;
+        Ok(Statement::Each {
+            path,
+            body,
+            span: start.span,
+        })
+    }
+
+    fn parse_when(&mut self) -> error::Result<Statement> {
+        let start = self.advance().unwrap(); // consume 'when'
+        let condition = self.parse_expr()?;
+        let body = self.parse_block()?;
+        Ok(Statement::When {
+            condition,
+            body,
+            span: start.span,
+        })
+    }
+
+    fn parse_block(&mut self) -> error::Result<Vec<Statement>> {
+        self.skip_newlines();
+        self.expect_exact(&TokenKind::LBrace)?;
+        self.skip_newlines();
+
+        let mut statements = Vec::new();
+        while self.peek_kind() != Some(&TokenKind::RBrace) {
+            if self.peek().is_none() {
+                return Err(error::MorphError::mapping(
+                    "unexpected end of input, expected '}'",
+                ));
+            }
+            let stmt = self.parse_statement()?;
+            statements.push(stmt);
+            self.skip_newlines();
+        }
+
+        self.expect_exact(&TokenKind::RBrace)?;
+        Ok(statements)
+    }
+
     fn parse_path_list(&mut self) -> error::Result<Vec<Path>> {
         let mut paths = vec![self.parse_path()?];
         while let Some(TokenKind::Comma) = self.peek_kind() {