encode-decode roudtrip rustell ast tests

Author: functora

rust/rustell/src/encode.rs

@@ -3,55 +3,58 @@ use std::iter::{IntoIterator, once};
 use std::vec::IntoIter;
 
 pub fn expr<'a>(
-    ast: Vec<Expr<'a>>,
-) -> impl Iterator<Item = &'a str> {
-    ast.into_iter().flat_map(expr_one)
+    ast: &'a [Expr<'a>],
+) -> impl Iterator<Item = &'a str> + 'a {
+    ast.iter().flat_map(expr_one)
 }
 
-fn expr_one<'a>(ast: Expr<'a>) -> IntoIter<&'a str> {
+fn expr_one<'a>(ast: &'a Expr<'a>) -> IntoIter<&'a str> {
     match ast {
         Expr::Use(x) => expr_use(true, x)
-            .chain(vec![";"].into_iter())
-            .collect::<Vec<&'a str>>()
+            .chain(once(";"))
+            .collect::<Vec<_>>()
             .into_iter(),
-        Expr::Other(x) => vec![x].into_iter(),
+        Expr::Other(x) => vec![*x].into_iter(),
     }
 }
 
 fn expr_use<'a>(
     top: bool,
-    ast: ExprUse<'a>,
+    ast: &'a ExprUse<'a>,
 ) -> IntoIter<&'a str> {
     let x0 = if top { vec!["use"] } else { vec![] };
+
     let x1 = match ast {
         ExprUse::Item {
             module,
             rename,
             nested,
-        } => expr_use_item(module, rename, nested),
+        } => expr_use_item(
+            module,
+            *rename,
+            nested.as_deref(),
+        ),
         ExprUse::Many(xs) => expr_use_many(xs),
         ExprUse::Glob => vec!["*"].into_iter(),
     };
-    x0.into_iter()
-        .chain(x1.into_iter())
-        .collect::<Vec<_>>()
-        .into_iter()
+
+    x0.into_iter().chain(x1).collect::<Vec<_>>().into_iter()
 }
 
 fn expr_use_item<'a>(
     module: &'a str,
     rename: Option<&'a str>,
-    nested: Option<Box<ExprUse<'a>>>,
+    nested: Option<&'a ExprUse<'a>>,
 ) -> IntoIter<&'a str> {
     let module_iter = once(module);
 
     let rename_iter = rename
-        .map(|x| once("as").chain(once(x)))
+        .map(|x| once(" as ").chain(once(x)))
         .into_iter()
         .flatten();
 
     let nested_iter = nested
-        .map(|x| once("::").chain(expr_use(false, *x)))
+        .map(|x| once("::").chain(expr_use(false, x)))
         .into_iter()
         .flatten();
 
@@ -63,10 +66,23 @@ fn expr_use_item<'a>(
 }
 
 fn expr_use_many<'a>(
-    xs: Vec<ExprUse<'a>>,
+    xs: &'a [ExprUse<'a>],
 ) -> IntoIter<&'a str> {
-    xs.into_iter()
-        .flat_map(|x| expr_use(false, x))
+    let interspersed =
+        xs.iter().enumerate().flat_map(|(i, x)| {
+            let iter = expr_use(false, x);
+            if i + 1 < xs.len() {
+                iter.chain(once(","))
+                    .collect::<Vec<_>>()
+                    .into_iter()
+            } else {
+                iter
+            }
+        });
+
+    once("{")
+        .chain(interspersed)
+        .chain(once("}"))
         .collect::<Vec<_>>()
         .into_iter()
 }

rust/rustell/src/main.rs

@@ -10,7 +10,7 @@ fn main() {
         .expect("Failed to read stdin");
     match decode::expr().parse(src.trim()).into_result() {
         Ok(ast) => {
-            encode::expr(ast).for_each(|x| print!("{}", x))
+            encode::expr(&ast).for_each(|x| print!("{}", x))
         }
         Err(errs) => {
             errs.into_iter().for_each(|e| println!("{e:?}"))

rust/rustell/tests/integration.rs

@@ -4,9 +4,8 @@ use rustell::*;
 
 #[test]
 fn test_parser() {
-    let src = "use std::io::Read;";
-    let slp = sloppy(src);
-    let ast = vec![Expr::Use(ExprUse::Item {
+    let lhs = "use std::io::Read;";
+    let rhs = vec![Expr::Use(ExprUse::Item {
         module: "std",
         rename: None,
         nested: Some(Box::new(ExprUse::Item {
@@ -19,9 +18,9 @@ fn test_parser() {
             })),
         })),
     })];
-    assert_eq!(parse(src), ast);
-    assert_eq!(parse(&slp), ast);
-    assert_eq!(parse(&encode(ast.clone())), ast)
+    assert_eq!(decode(lhs), rhs);
+    assert_eq!(decode(&sloppy(lhs)), rhs);
+    assert_eq!(decode(&encode(&rhs)), rhs)
 }
 
 #[test]
@@ -51,8 +50,9 @@ fn test_parser_many() {
             },
         ]))),
     })];
-    assert_eq!(parse(lhs), rhs);
-    assert_eq!(parse(&sloppy(lhs)), rhs)
+    assert_eq!(decode(lhs), rhs);
+    assert_eq!(decode(&sloppy(lhs)), rhs);
+    assert_eq!(decode(&encode(&rhs)), rhs)
 }
 
 #[test]
@@ -67,8 +67,9 @@ fn test_parser_glob() {
             nested: Some(Box::new(ExprUse::Glob)),
         })),
     })];
-    assert_eq!(parse(lhs), rhs);
-    assert_eq!(parse(&sloppy(lhs)), rhs)
+    assert_eq!(decode(lhs), rhs);
+    assert_eq!(decode(&sloppy(lhs)), rhs);
+    assert_eq!(decode(&encode(&rhs)), rhs)
 }
 
 #[test]
@@ -87,8 +88,9 @@ fn test_parser_rename() {
             })),
         })),
     })];
-    assert_eq!(parse(lhs), rhs);
-    assert_eq!(parse(&sloppy(lhs)), rhs)
+    assert_eq!(decode(lhs), rhs);
+    assert_eq!(decode(&sloppy(lhs)), rhs);
+    assert_eq!(decode(&encode(&rhs)), rhs)
 }
 
 #[test]
@@ -114,8 +116,9 @@ fn test_parser_complex() {
             },
         ]))),
     })];
-    assert_eq!(parse(lhs), rhs);
-    assert_eq!(parse(&sloppy(lhs)), rhs)
+    assert_eq!(decode(lhs), rhs);
+    assert_eq!(decode(&sloppy(lhs)), rhs);
+    assert_eq!(decode(&encode(&rhs)), rhs)
 }
 
 #[test]
@@ -134,8 +137,9 @@ fn test_parser_crate() {
             })),
         })),
     })];
-    assert_eq!(parse(lhs), rhs);
-    assert_eq!(parse(&sloppy(lhs)), rhs)
+    assert_eq!(decode(lhs), rhs);
+    assert_eq!(decode(&sloppy(lhs)), rhs);
+    assert_eq!(decode(&encode(&rhs)), rhs)
 }
 
 #[test]
@@ -167,8 +171,9 @@ fn test_parser_other_then_use() {
             })),
         }),
     ];
-    assert_eq!(parse(lhs), rhs);
-    assert_eq!(parse(&sloppy(lhs)), rhs)
+    assert_eq!(decode(lhs), rhs);
+    assert_eq!(decode(&sloppy(lhs)), rhs);
+    assert_eq!(decode(&encode(&rhs)), rhs)
 }
 
 #[test]
@@ -200,8 +205,9 @@ fn test_parser_multiple() {
         }),
         Expr::Other("\n    "),
     ];
-    assert_eq!(parse(lhs), rhs);
-    assert_eq!(parse(&sloppy(lhs)), rhs)
+    assert_eq!(decode(lhs), rhs);
+    assert_eq!(decode(&sloppy(lhs)), rhs);
+    assert_eq!(decode(&encode(&rhs)), rhs)
 }
 
 #[test]
@@ -242,8 +248,9 @@ fn test_parser_multiple_with_other() {
         }),
         Expr::Other("\n    "),
     ];
-    assert_eq!(parse(lhs), rhs);
-    assert_eq!(parse(&sloppy(lhs)), rhs)
+    assert_eq!(decode(lhs), rhs);
+    assert_eq!(decode(&sloppy(lhs)), rhs);
+    assert_eq!(decode(&encode(&rhs)), rhs)
 }
 
 #[test]
@@ -313,18 +320,19 @@ fn test_parser_mixed_all_cases() {
     "#,
         ),
     ];
-    assert_eq!(parse(lhs), rhs);
-    assert_eq!(parse(&sloppy(lhs)), rhs)
+    assert_eq!(decode(lhs), rhs);
+    assert_eq!(decode(&sloppy(lhs)), rhs);
+    assert_eq!(decode(&encode(&rhs)), rhs)
 }
 
 fn sloppy(src: &str) -> String {
     src.replace(";", "")
 }
 
-fn parse(src: &str) -> Vec<Expr> {
+fn decode(src: &str) -> Vec<Expr> {
     decode::expr().parse(src).into_result().unwrap()
 }
 
-fn encode(ast: Vec<Expr>) -> String {
+fn encode(ast: &[Expr]) -> String {
     encode::expr(ast).collect()
 }