feat: implement flatten and nest mapping operations (#49)

feat: implement flatten and nest mapping operations (closes #20)

Author: alvinreal

src/mapping/ast.rs

@@ -94,6 +94,18 @@ pub enum Statement {
         target_type: CastType,
         span: Span,
     },
+    /// `flatten .address` or `flatten .address -> prefix "addr"`
+    Flatten {
+        path: Path,
+        prefix: Option<String>,
+        span: Span,
+    },
+    /// `nest .a_x, .a_y -> .a`
+    Nest {
+        paths: Vec<Path>,
+        target: Path,
+        span: Span,
+    },
 }
 
 /// A parsed mapping program: a list of statements.

src/mapping/eval.rs

@@ -24,6 +24,8 @@ fn eval_statement(stmt: &Statement, value: &Value) -> error::Result<Value> {
         Statement::Cast {
             path, target_type, ..
         } => eval_cast(value, path, target_type),
+        Statement::Flatten { path, prefix, .. } => eval_flatten(value, path, prefix.as_deref()),
+        Statement::Nest { paths, target, .. } => eval_nest(value, paths, target),
     }
 }
 
@@ -175,6 +177,88 @@ fn cast_value(value: &Value, target_type: &CastType) -> error::Result<Value> {
     }
 }
 
+// ---------------------------------------------------------------------------
+// flatten
+// ---------------------------------------------------------------------------
+
+fn eval_flatten(value: &Value, path: &Path, prefix: Option<&str>) -> error::Result<Value> {
+    let target_val = resolve_path(value, &path.segments);
+    match target_val {
+        Some(Value::Map(inner_map)) => {
+            // Determine the prefix for flattened keys
+            let key_prefix = match prefix {
+                Some(p) => p.to_string(),
+                None => {
+                    // Use the last segment of the path as the prefix
+                    last_field_name(&path.segments).unwrap_or_default()
+                }
+            };
+
+            // Remove the original nested field
+            let mut result = remove_path(value, &path.segments);
+
+            // Insert flattened key-value pairs into the parent map
+            if let Value::Map(ref mut parent_map) = result {
+                for (key, val) in &inner_map {
+                    let flat_key = format!("{key_prefix}_{key}");
+                    parent_map.insert(flat_key, val.clone());
+                }
+            }
+
+            Ok(result)
+        }
+        Some(_) => {
+            // Non-object: no-op
+            Ok(value.clone())
+        }
+        None => {
+            // Path doesn't exist: no-op
+            Ok(value.clone())
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// nest
+// ---------------------------------------------------------------------------
+
+fn eval_nest(value: &Value, paths: &[Path], target: &Path) -> error::Result<Value> {
+    // Get the target field name to strip as prefix
+    let target_name = last_field_name(&target.segments).unwrap_or_default();
+
+    let mut nested_map = IndexMap::new();
+    let mut result = value.clone();
+
+    for path in paths {
+        if let Some(val) = resolve_path(value, &path.segments) {
+            // Get the field name from the path
+            let field_name = last_field_name(&path.segments).unwrap_or_default();
+
+            // Strip target prefix (e.g., "a_x" with target "a" → "x")
+            let nested_key = if !target_name.is_empty() {
+                let prefix_with_underscore = format!("{target_name}_");
+                if field_name.starts_with(&prefix_with_underscore) {
+                    field_name[prefix_with_underscore.len()..].to_string()
+                } else {
+                    field_name
+                }
+            } else {
+                field_name
+            };
+
+            nested_map.insert(nested_key, val);
+
+            // Remove the original field
+            result = remove_path(&result, &path.segments);
+        }
+    }
+
+    // Set the nested map at the target path
+    result = set_path(&result, &target.segments, Value::Map(nested_map));
+
+    Ok(result)
+}
+
 // ---------------------------------------------------------------------------
 // Expression evaluation
 // ---------------------------------------------------------------------------

src/mapping/parser.rs

@@ -97,6 +97,8 @@ impl Parser {
             TokenKind::Set => self.parse_set(),
             TokenKind::Default => self.parse_default(),
             TokenKind::Cast => self.parse_cast(),
+            TokenKind::Flatten => self.parse_flatten(),
+            TokenKind::Nest => self.parse_nest(),
             _ => {
                 let suggestion = suggest_keyword(&token.kind);
                 let msg = if let Some(s) = suggestion {
@@ -213,6 +215,65 @@ impl Parser {
         }
     }
 
+    fn parse_flatten(&mut self) -> error::Result<Statement> {
+        let start = self.advance().unwrap(); // consume 'flatten'
+        let path = self.parse_path()?;
+
+        // Check for optional -> prefix "..."
+        let prefix = if matches!(self.peek_kind(), Some(TokenKind::Arrow)) {
+            self.advance(); // consume '->'
+                            // Expect the identifier "prefix"
+            match self.peek_kind() {
+                Some(TokenKind::Ident(name)) if name == "prefix" => {
+                    self.advance(); // consume 'prefix'
+                }
+                _ => {
+                    let span = self.current_span();
+                    return Err(error::MorphError::mapping_at(
+                        "expected 'prefix' after '->' in flatten",
+                        span.line,
+                        span.column,
+                    ));
+                }
+            }
+            // Expect a string literal for the prefix value
+            match self.advance() {
+                Some(Token {
+                    kind: TokenKind::StringLit(s),
+                    ..
+                }) => Some(s),
+                _ => {
+                    let span = self.current_span();
+                    return Err(error::MorphError::mapping_at(
+                        "expected string literal for prefix value in flatten",
+                        span.line,
+                        span.column,
+                    ));
+                }
+            }
+        } else {
+            None
+        };
+
+        Ok(Statement::Flatten {
+            path,
+            prefix,
+            span: start.span,
+        })
+    }
+
+    fn parse_nest(&mut self) -> error::Result<Statement> {
+        let start = self.advance().unwrap(); // consume 'nest'
+        let paths = self.parse_path_list()?;
+        self.expect_exact(&TokenKind::Arrow)?;
+        let target = self.parse_path()?;
+        Ok(Statement::Nest {
+            paths,
+            target,
+            span: start.span,
+        })
+    }
+
     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() {