rustell::encode module wip

Author: functora

rust/rustell/src/encode.rs

@@ -0,0 +1,72 @@
+use super::*;
+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)
+}
+
+fn expr_one<'a>(ast: Expr<'a>) -> IntoIter<&'a str> {
+    match ast {
+        Expr::Use(x) => expr_use(true, x)
+            .chain(vec![";"].into_iter())
+            .collect::<Vec<&'a str>>()
+            .into_iter(),
+        Expr::Other(x) => vec![x].into_iter(),
+    }
+}
+
+fn expr_use<'a>(
+    top: bool,
+    ast: 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),
+        ExprUse::Many(xs) => expr_use_many(xs),
+        ExprUse::Glob => vec!["*"].into_iter(),
+    };
+    x0.into_iter()
+        .chain(x1.into_iter())
+        .collect::<Vec<_>>()
+        .into_iter()
+}
+
+fn expr_use_item<'a>(
+    module: &'a str,
+    rename: Option<&'a str>,
+    nested: Option<Box<ExprUse<'a>>>,
+) -> IntoIter<&'a str> {
+    let module_iter = once(module);
+
+    let rename_iter = rename
+        .map(|x| once("as").chain(once(x)))
+        .into_iter()
+        .flatten();
+
+    let nested_iter = nested
+        .map(|x| once("::").chain(expr_use(false, *x)))
+        .into_iter()
+        .flatten();
+
+    module_iter
+        .chain(rename_iter)
+        .chain(nested_iter)
+        .collect::<Vec<_>>()
+        .into_iter()
+}
+
+fn expr_use_many<'a>(
+    xs: Vec<ExprUse<'a>>,
+) -> IntoIter<&'a str> {
+    xs.into_iter()
+        .flat_map(|x| expr_use(false, x))
+        .collect::<Vec<_>>()
+        .into_iter()
+}

rust/rustell/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod decode;
+pub mod encode;
 pub use chumsky::prelude::Parser;
 
 #[derive(Eq, PartialEq, Debug, Clone)]

rust/rustell/src/main.rs

@@ -1,4 +1,5 @@
 use rustell::decode;
+use rustell::encode;
 use rustell::*;
 use std::io::{self, Read};
 
@@ -8,7 +9,9 @@ fn main() {
         .read_to_string(&mut src)
         .expect("Failed to read stdin");
     match decode::expr().parse(src.trim()).into_result() {
-        Ok(ast) => println!("{:#?}", ast),
+        Ok(ast) => {
+            encode::expr(ast).for_each(|x| print!("{}", x))
+        }
         Err(errs) => {
             errs.into_iter().for_each(|e| println!("{e:?}"))
         }

rust/rustell/tests/integration.rs

@@ -1,10 +1,12 @@
 use rustell::decode;
+use rustell::encode;
 use rustell::*;
 
 #[test]
 fn test_parser() {
-    let lhs = "use std::io::Read;";
-    let rhs = vec![Expr::Use(ExprUse::Item {
+    let src = "use std::io::Read;";
+    let slp = sloppy(src);
+    let ast = vec![Expr::Use(ExprUse::Item {
         module: "std",
         rename: None,
         nested: Some(Box::new(ExprUse::Item {
@@ -17,8 +19,9 @@ fn test_parser() {
             })),
         })),
     })];
-    assert_eq!(parse(lhs), rhs);
-    assert_eq!(parse(&sloppy(lhs)), rhs)
+    assert_eq!(parse(src), ast);
+    assert_eq!(parse(&slp), ast);
+    assert_eq!(parse(&encode(ast.clone())), ast)
 }
 
 #[test]
@@ -321,3 +324,7 @@ fn sloppy(src: &str) -> String {
 fn parse(src: &str) -> Vec<Expr> {
     decode::expr().parse(src).into_result().unwrap()
 }
+
+fn encode(ast: Vec<Expr>) -> String {
+    encode::expr(ast).collect()
+}