From 3b6a6f6673041cf9ee315c00f9b0e24e2c067091 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Mon, 30 Jul 2018 16:16:58 +0300 Subject: Add render test functionality --- .cargo/config | 3 +- Cargo.toml | 2 +- cli/Cargo.toml | 11 +++ cli/src/main.rs | 68 ++++++++++++++ src/bin/cli.rs | 20 ----- src/parser/grammar/expressions.rs | 4 + tools/src/bin/main.rs | 180 -------------------------------------- tools/src/lib.rs | 50 +++++++++++ tools/src/main.rs | 141 +++++++++++++++++++++++++++++ 9 files changed, 277 insertions(+), 202 deletions(-) create mode 100644 cli/Cargo.toml create mode 100644 cli/src/main.rs delete mode 100644 src/bin/cli.rs delete mode 100644 tools/src/bin/main.rs create mode 100644 tools/src/lib.rs create mode 100644 tools/src/main.rs diff --git a/.cargo/config b/.cargo/config index 1898d28d3..7903b919c 100644 --- a/.cargo/config +++ b/.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" diff --git a/Cargo.toml b/Cargo.toml index 954f3e94b..b89573e2b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,7 +5,7 @@ authors = ["Aleksey Kladov "] license = "MIT OR Apache-2.0" [workspace] -members = [ "tools" ] +members = [ "tools", "cli" ] [dependencies] unicode-xid = "0.1.0" diff --git a/cli/Cargo.toml b/cli/Cargo.toml new file mode 100644 index 000000000..a259eef63 --- /dev/null +++ b/cli/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "cli" +version = "0.1.0" +authors = ["Aleksey Kladov "] +publish = false + +[dependencies] +clap = "2.32.0" +failure = "0.1.1" +libsyntax2 = { path = "../" } +tools = { path = "../tools" } diff --git a/cli/src/main.rs b/cli/src/main.rs new file mode 100644 index 000000000..94183c552 --- /dev/null +++ b/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 = ::std::result::Result; + +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 { + let text = read_stdin()?; + let file = libsyntax2::parse(text); + let tree = libsyntax2::utils::dump_tree(&file); + Ok(tree) +} + +fn read_stdin() -> Result { + 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)) +} diff --git a/src/bin/cli.rs b/src/bin/cli.rs deleted file mode 100644 index 9e513edb2..000000000 --- a/src/bin/cli.rs +++ /dev/null @@ -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 -} diff --git a/src/parser/grammar/expressions.rs b/src/parser/grammar/expressions.rs index 2145b8d8b..40f41535e 100644 --- a/src/parser/grammar/expressions.rs +++ b/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 diff --git a/tools/src/bin/main.rs b/tools/src/bin/main.rs deleted file mode 100644 index f4f6e82ae..000000000 --- a/tools/src/bin/main.rs +++ /dev/null @@ -1,180 +0,0 @@ -extern crate clap; -#[macro_use] -extern crate failure; -extern crate itertools; -extern crate ron; -extern crate tera; -extern crate walkdir; - -use clap::{App, Arg, SubCommand}; -use itertools::Itertools; -use std::{collections::HashSet, fs, path::Path}; - -type Result = ::std::result::Result; - -const GRAMMAR_DIR: &str = "./src/parser/grammar"; -const INLINE_TESTS_DIR: &str = "tests/data/parser/inline"; -const GRAMMAR: &str = "./src/grammar.ron"; -const SYNTAX_KINDS: &str = "./src/syntax_kinds/generated.rs"; -const SYNTAX_KINDS_TEMPLATE: &str = "./src/syntax_kinds/generated.rs.tera"; - -fn main() -> Result<()> { - let matches = App::new("tasks") - .setting(clap::AppSettings::SubcommandRequiredElseHelp) - .arg( - Arg::with_name("verify") - .long("--verify") - .help("Verify that generated code is up-to-date") - .global(true), - ) - .subcommand(SubCommand::with_name("gen-kinds")) - .subcommand(SubCommand::with_name("gen-tests")) - .get_matches(); - match matches.subcommand() { - (name, Some(matches)) => run_gen_command(name, matches.is_present("verify"))?, - _ => unreachable!(), - } - Ok(()) -} - -fn run_gen_command(name: &str, verify: bool) -> Result<()> { - match name { - "gen-kinds" => update(Path::new(SYNTAX_KINDS), &get_kinds()?, verify), - "gen-tests" => gen_tests(verify), - _ => unreachable!(), - } -} - -fn update(path: &Path, contents: &str, verify: bool) -> Result<()> { - match fs::read_to_string(path) { - Ok(ref old_contents) if old_contents == contents => { - return Ok(()); - } - _ => (), - } - if verify { - bail!("`{}` is not up-to-date", path.display()); - } - eprintln!("updating {}", path.display()); - fs::write(path, contents)?; - Ok(()) -} - -fn get_kinds() -> Result { - let grammar = grammar()?; - let template = fs::read_to_string(SYNTAX_KINDS_TEMPLATE)?; - let ret = tera::Tera::one_off(&template, &grammar, false) - .map_err(|e| format_err!("template error: {}", e))?; - Ok(ret) -} - -fn grammar() -> Result { - let text = fs::read_to_string(GRAMMAR)?; - let ret = ron::de::from_str(&text)?; - Ok(ret) -} - -fn gen_tests(verify: bool) -> Result<()> { - let tests = tests_from_dir(Path::new(GRAMMAR_DIR))?; - - let inline_tests_dir = Path::new(INLINE_TESTS_DIR); - if !inline_tests_dir.is_dir() { - fs::create_dir_all(inline_tests_dir)?; - } - let existing = existing_tests(inline_tests_dir)?; - - for t in existing.difference(&tests) { - panic!("Test is deleted: {}\n{}", t.name, t.text); - } - - let new_tests = tests.difference(&existing); - for (i, t) in new_tests.enumerate() { - let name = format!("{:04}_{}.rs", existing.len() + i + 1, t.name); - let path = inline_tests_dir.join(name); - update(&path, &t.text, verify)?; - } - 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(&self, state: &mut H) { - self.name.hash(state) - } -} - -fn tests_from_dir(dir: &Path) -> Result> { - let mut res = HashSet::new(); - for entry in ::walkdir::WalkDir::new(dir) { - let entry = entry.unwrap(); - if !entry.file_type().is_file() { - continue; - } - if entry.path().extension().unwrap_or_default() != "rs" { - continue; - } - let text = fs::read_to_string(entry.path())?; - - for test in collect_tests(&text) { - if let Some(old_test) = res.replace(test) { - bail!("Duplicate test: {}", old_test.name) - } - } - } - Ok(res) -} - -fn collect_tests(s: &str) -> Vec { - 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> { - let mut res = HashSet::new(); - for file in fs::read_dir(dir)? { - let file = file?; - let path = file.path(); - if path.extension().unwrap_or_default() != "rs" { - continue; - } - let name = path.file_name().unwrap().to_str().unwrap(); - let name = name["0000_".len()..name.len() - 3].to_string(); - let text = fs::read_to_string(&path)?; - res.insert(Test { name, text }); - } - Ok(res) -} diff --git a/tools/src/lib.rs b/tools/src/lib.rs new file mode 100644 index 000000000..157818bdf --- /dev/null +++ b/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 { + 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 +} diff --git a/tools/src/main.rs b/tools/src/main.rs new file mode 100644 index 000000000..671f05388 --- /dev/null +++ b/tools/src/main.rs @@ -0,0 +1,141 @@ +extern crate clap; +#[macro_use] +extern crate failure; +extern crate ron; +extern crate tera; +extern crate walkdir; +extern crate tools; + +use std::{collections::HashSet, fs, path::Path}; +use clap::{App, Arg, SubCommand}; +use tools::{collect_tests, Test}; + +type Result = ::std::result::Result; + +const GRAMMAR_DIR: &str = "./src/parser/grammar"; +const INLINE_TESTS_DIR: &str = "tests/data/parser/inline"; +const GRAMMAR: &str = "./src/grammar.ron"; +const SYNTAX_KINDS: &str = "./src/syntax_kinds/generated.rs"; +const SYNTAX_KINDS_TEMPLATE: &str = "./src/syntax_kinds/generated.rs.tera"; + +fn main() -> Result<()> { + let matches = App::new("tasks") + .setting(clap::AppSettings::SubcommandRequiredElseHelp) + .arg( + Arg::with_name("verify") + .long("--verify") + .help("Verify that generated code is up-to-date") + .global(true), + ) + .subcommand(SubCommand::with_name("gen-kinds")) + .subcommand(SubCommand::with_name("gen-tests")) + .get_matches(); + match matches.subcommand() { + (name, Some(matches)) => run_gen_command(name, matches.is_present("verify"))?, + _ => unreachable!(), + } + Ok(()) +} + +fn run_gen_command(name: &str, verify: bool) -> Result<()> { + match name { + "gen-kinds" => update(Path::new(SYNTAX_KINDS), &get_kinds()?, verify), + "gen-tests" => gen_tests(verify), + _ => unreachable!(), + } +} + +fn update(path: &Path, contents: &str, verify: bool) -> Result<()> { + match fs::read_to_string(path) { + Ok(ref old_contents) if old_contents == contents => { + return Ok(()); + } + _ => (), + } + if verify { + bail!("`{}` is not up-to-date", path.display()); + } + eprintln!("updating {}", path.display()); + fs::write(path, contents)?; + Ok(()) +} + +fn get_kinds() -> Result { + let grammar = grammar()?; + let template = fs::read_to_string(SYNTAX_KINDS_TEMPLATE)?; + let ret = tera::Tera::one_off(&template, &grammar, false) + .map_err(|e| format_err!("template error: {}", e))?; + Ok(ret) +} + +fn grammar() -> Result { + let text = fs::read_to_string(GRAMMAR)?; + let ret = ron::de::from_str(&text)?; + Ok(ret) +} + +fn gen_tests(verify: bool) -> Result<()> { + let tests = tests_from_dir(Path::new(GRAMMAR_DIR))?; + + let inline_tests_dir = Path::new(INLINE_TESTS_DIR); + if !inline_tests_dir.is_dir() { + fs::create_dir_all(inline_tests_dir)?; + } + let existing = existing_tests(inline_tests_dir)?; + + for t in existing.difference(&tests) { + panic!("Test is deleted: {}\n{}", t.name, t.text); + } + + let new_tests = tests.difference(&existing); + for (i, t) in new_tests.enumerate() { + let name = format!("{:04}_{}.rs", existing.len() + i + 1, t.name); + let path = inline_tests_dir.join(name); + update(&path, &t.text, verify)?; + } + Ok(()) +} + + +impl ::std::hash::Hash for Test { + fn hash(&self, state: &mut H) { + self.name.hash(state) + } +} + +fn tests_from_dir(dir: &Path) -> Result> { + let mut res = HashSet::new(); + for entry in ::walkdir::WalkDir::new(dir) { + let entry = entry.unwrap(); + if !entry.file_type().is_file() { + continue; + } + if entry.path().extension().unwrap_or_default() != "rs" { + continue; + } + let text = fs::read_to_string(entry.path())?; + + for test in collect_tests(&text) { + if let Some(old_test) = res.replace(test) { + bail!("Duplicate test: {}", old_test.name) + } + } + } + Ok(res) +} + +fn existing_tests(dir: &Path) -> Result> { + let mut res = HashSet::new(); + for file in fs::read_dir(dir)? { + let file = file?; + let path = file.path(); + if path.extension().unwrap_or_default() != "rs" { + continue; + } + let name = path.file_name().unwrap().to_str().unwrap(); + let name = name["0000_".len()..name.len() - 3].to_string(); + let text = fs::read_to_string(&path)?; + res.insert(Test { name, text }); + } + Ok(res) +} -- cgit v1.2.3