Add render test functionality

.cargo/config

@@ -1,4 +1,5 @@
 [alias]
-parse = "run --package tools --bin parse"
 gen-kinds = "run --package tools -- gen-kinds"
 gen-tests = "run --package tools -- gen-tests"
+render-test = "run --package cli -- render-test"
+parse = "run --package cli -- parse"

Cargo.toml

@@ -5,7 +5,7 @@ authors = ["Aleksey Kladov <aleksey.kladov@gmail.com>"]
 license = "MIT OR Apache-2.0"
 
 [workspace]
-members = [ "tools" ]
+members = [ "tools", "cli" ]
 
 [dependencies]
 unicode-xid = "0.1.0"

cli/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "cli"
+version = "0.1.0"
+authors = ["Aleksey Kladov <aleksey.kladov@gmail.com>"]
+publish = false
+
+[dependencies]
+clap = "2.32.0"
+failure = "0.1.1"
+libsyntax2 = { path = "../" }
+tools = { path = "../tools" }

cli/src/main.rs

@@ -0,0 +1,68 @@
+extern crate clap;
+#[macro_use]
+extern crate failure;
+extern crate libsyntax2;
+extern crate tools;
+
+use std::{fs, path::Path, io::Read};
+use clap::{App, Arg, SubCommand};
+use tools::collect_tests;
+
+type Result<T> = ::std::result::Result<T, failure::Error>;
+
+fn main() -> Result<()> {
+    let matches = App::new("libsyntax2-cli")
+        .setting(clap::AppSettings::SubcommandRequiredElseHelp)
+        .subcommand(
+            SubCommand::with_name("render-test")
+                .arg(Arg::with_name("line").long("--line").required(true).takes_value(true))
+                .arg(Arg::with_name("file").long("--file").required(true).takes_value(true))
+        )
+        .subcommand(SubCommand::with_name("parse"))
+        .get_matches();
+    match matches.subcommand() {
+        ("parse", _) => {
+            let tree = parse()?;
+            println!("{}", tree);
+        },
+        ("render-test", Some(matches)) => {
+            let file = matches.value_of("file").unwrap();
+            let file = Path::new(file);
+            let line: usize = matches.value_of("line").unwrap().parse()?;
+            let line = line - 1;
+            let (test, tree) = render_test(file, line)?;
+            println!("{}\n{}", test, tree);
+        }
+        _ => unreachable!(),
+    }
+    Ok(())
+
+}
+
+fn parse() -> Result<String> {
+    let text = read_stdin()?;
+    let file = libsyntax2::parse(text);
+    let tree = libsyntax2::utils::dump_tree(&file);
+    Ok(tree)
+}
+
+fn read_stdin() -> Result<String> {
+    let mut buff = String::new();
+    ::std::io::stdin().read_to_string(&mut buff)?;
+    Ok(buff)
+}
+
+fn render_test(file: &Path, line: usize) -> Result<(String, String)> {
+    let text = fs::read_to_string(file)?;
+    let tests = collect_tests(&text);
+    let test = tests.into_iter().find(|t| {
+        t.start_line <= line && line <= t.start_line + t.text.lines().count()
+    });
+    let test = match test {
+        None => bail!("No test found at line {} at {}", line, file.display()),
+        Some(test) => test,
+    };
+    let file = libsyntax2::parse(test.text.clone());
+    let tree = libsyntax2::utils::dump_tree(&file);
+    Ok((test.text, tree))
+}

src/bin/cli.rs

@@ -1,20 +0,0 @@
-extern crate libsyntax2;
-
-use std::io::Read;
-
-use libsyntax2::{
-    parse, utils::dump_tree
-};
-
-fn main() {
-    let text = read_input();
-    let file = parse(text);
-    let tree = dump_tree(&file);
-    println!("{}", tree);
-}
-
-fn read_input() -> String {
-    let mut buff = String::new();
-    ::std::io::stdin().read_to_string(&mut buff).unwrap();
-    buff
-}

src/parser/grammar/expressions.rs

@@ -1,5 +1,9 @@
 use super::*;
 
+// test expr_literals
+// fn foo() {
+//     let _ = 92;
+// }
 pub(super) fn literal(p: &mut Parser) -> bool {
     match p.current() {
         TRUE_KW | FALSE_KW | INT_NUMBER | FLOAT_NUMBER | BYTE | CHAR | STRING | RAW_STRING

tools/src/lib.rs

@@ -0,0 +1,50 @@
+extern crate itertools;
+use itertools::Itertools;
+
+#[derive(Debug, Eq)]
+pub struct Test {
+    pub start_line: usize,
+    pub name: String,
+    pub text: String,
+}
+
+impl PartialEq for Test {
+    fn eq(&self, other: &Test) -> bool {
+        self.name.eq(&other.name)
+    }
+}
+
+pub fn collect_tests(s: &str) -> Vec<Test> {
+    let mut res = vec![];
+    let prefix = "// ";
+    let comment_blocks = s
+        .lines()
+        .map(str::trim_left)
+        .enumerate()
+        .group_by(|(idx, line)| line.starts_with(prefix));
+
+    'outer: for (is_comment, block) in comment_blocks.into_iter() {
+        if !is_comment {
+            continue;
+        }
+        let mut block = block.map(|(idx, line)| (idx, &line[prefix.len()..]));
+
+        let (start_line, name) = loop {
+            match block.next() {
+                Some((idx, line)) if line.starts_with("test ") => {
+                    break (idx, line["test ".len()..].to_string())
+                },
+                Some(_) => (),
+                None => continue 'outer,
+            }
+        };
+        let text: String = itertools::join(
+            block.map(|(_, line)| line)
+                .chain(::std::iter::once("")),
+            "\n"
+        );
+        assert!(!text.trim().is_empty() && text.ends_with("\n"));
+        res.push(Test { start_line, name, text })
+    }
+    res
+}

tools/src/main.rs

@@ -1,14 +1,14 @@
 extern crate clap;
 #[macro_use]
 extern crate failure;
-extern crate itertools;
 extern crate ron;
 extern crate tera;
 extern crate walkdir;
+extern crate tools;
 
-use clap::{App, Arg, SubCommand};
-use itertools::Itertools;
 use std::{collections::HashSet, fs, path::Path};
+use clap::{App, Arg, SubCommand};
+use tools::{collect_tests, Test};
 
 type Result<T> = ::std::result::Result<T, failure::Error>;
 
@@ -96,17 +96,6 @@ fn gen_tests(verify: bool) -> Result<()> {
     Ok(())
 }
 
-#[derive(Debug, Eq)]
-struct Test {
-    name: String,
-    text: String,
-}
-
-impl PartialEq for Test {
-    fn eq(&self, other: &Test) -> bool {
-        self.name.eq(&other.name)
-    }
-}
 
 impl ::std::hash::Hash for Test {
     fn hash<H: ::std::hash::Hasher>(&self, state: &mut H) {
@@ -135,34 +124,6 @@ fn tests_from_dir(dir: &Path) -> Result<HashSet<Test>> {
     Ok(res)
 }
 
-fn collect_tests(s: &str) -> Vec<Test> {
-    let mut res = vec![];
-    let prefix = "// ";
-    let comment_blocks = s
-        .lines()
-        .map(str::trim_left)
-        .group_by(|line| line.starts_with(prefix));
-
-    'outer: for (is_comment, block) in comment_blocks.into_iter() {
-        if !is_comment {
-            continue;
-        }
-        let mut block = block.map(|line| &line[prefix.len()..]);
-
-        let name = loop {
-            match block.next() {
-                Some(line) if line.starts_with("test ") => break line["test ".len()..].to_string(),
-                Some(_) => (),
-                None => continue 'outer,
-            }
-        };
-        let text: String = itertools::join(block.chain(::std::iter::once("")), "\n");
-        assert!(!text.trim().is_empty() && text.ends_with("\n"));
-        res.push(Test { name, text })
-    }
-    res
-}
-
 fn existing_tests(dir: &Path) -> Result<HashSet<Test>> {
     let mut res = HashSet::new();
     for file in fs::read_dir(dir)? {