rustell wip

Author: functora

rust/rustell/src/lib.rs

@@ -54,8 +54,9 @@ fn use_parser<'src>()
 
         let group = use_parser
             .separated_by(just(','))
+            .allow_trailing()
             .collect::<Vec<_>>()
-            .delimited_by(just('{'), just('}'))
+            .delimited_by(just('{').padded(), just('}').padded())
             .map(UseExpr::Group);
 
         let glob = just("*").padded().map(|_| UseExpr::Glob);

rust/rustell/tests/integration.rs

@@ -165,3 +165,136 @@ fn test_parser_other_then_use() {
     ];
     assert_eq!(lhs, rhs)
 }
+
+#[test]
+fn test_parser_multiple() {
+    let src = r#"
+    use std::io;
+    use std::fs;
+    "#;
+    let lhs = parser().parse(src).into_result().unwrap();
+    let rhs = vec![
+        Expr::Use(UseExpr::Path {
+            ident: "std",
+            rename: None,
+            nested: Some(Box::new(UseExpr::Path {
+                ident: "io",
+                rename: None,
+                nested: None,
+            })),
+        }),
+        Expr::Use(UseExpr::Path {
+            ident: "std",
+            rename: None,
+            nested: Some(Box::new(UseExpr::Path {
+                ident: "fs",
+                rename: None,
+                nested: None,
+            })),
+        }),
+    ];
+    assert_eq!(lhs, rhs)
+}
+
+#[test]
+fn test_parser_multiple_with_other() {
+    let src = r#"
+    use std::io;
+    fn test() {
+        println!("Hello");
+    }
+    use std::fs;
+    "#;
+    let lhs = parser().parse(src).into_result().unwrap();
+    let rhs = vec![
+        Expr::Use(UseExpr::Path {
+            ident: "std",
+            rename: None,
+            nested: Some(Box::new(UseExpr::Path {
+                ident: "io",
+                rename: None,
+                nested: None,
+            })),
+        }),
+        Expr::Other(
+            r#"fn test() {
+        println!("Hello");
+    }"#,
+        ),
+        Expr::Use(UseExpr::Path {
+            ident: "std",
+            rename: None,
+            nested: Some(Box::new(UseExpr::Path {
+                ident: "fs",
+                rename: None,
+                nested: None,
+            })),
+        }),
+    ];
+    assert_eq!(lhs, rhs)
+}
+
+#[test]
+fn test_parser_mixed_all_cases() {
+    let src = r#"
+    use std::{
+        io::{self, Read as R},
+        fs::*,
+    };
+    use crate::module::Type as T;
+
+    fn hello() {
+        println!("Hello");
+    }
+    "#;
+    let lhs = parser().parse(src).into_result().unwrap();
+    let rhs = vec![
+        Expr::Use(UseExpr::Path {
+            ident: "std",
+            rename: None,
+            nested: Some(Box::new(UseExpr::Group(vec![
+                UseExpr::Path {
+                    ident: "io",
+                    rename: None,
+                    nested: Some(Box::new(UseExpr::Group(vec![
+                        UseExpr::Path {
+                            ident: "self",
+                            rename: None,
+                            nested: None,
+                        },
+                        UseExpr::Path {
+                            ident: "Read",
+                            rename: Some("R"),
+                            nested: None,
+                        },
+                    ]))),
+                },
+                UseExpr::Path {
+                    ident: "fs",
+                    rename: None,
+                    nested: Some(Box::new(UseExpr::Glob)),
+                },
+            ]))),
+        }),
+        Expr::Use(UseExpr::Path {
+            ident: "crate",
+            rename: None,
+            nested: Some(Box::new(UseExpr::Path {
+                ident: "module",
+                rename: None,
+                nested: Some(Box::new(UseExpr::Path {
+                    ident: "Type",
+                    rename: Some("T"),
+                    nested: None,
+                })),
+            })),
+        }),
+        Expr::Other(
+            r#"fn hello() {
+        println!("Hello");
+    }
+    "#,
+        ),
+    ];
+    assert_eq!(lhs, rhs)
+}