mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge #128

Browse Source 
128: Add a test to verify if the generated codes are up-to-date. r=matklad a=mominul

This test checks if the generated codes are up-to-date every time during `cargo test`.

I have confirmed that the test works by manually editing the `grammar.ron` file.

Closes #126 

Thanks!

Co-authored-by: Muhammad Mominul Huque <mominul2082@gmail.com>
This commit is contained in:
bors[bot] 2018-10-16 12:24:26 +00:00
commit 39cb6c6d3f
3 changed files with 93 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
crates/tools/src/lib.rs
View File

@ -1,6 +1,25 @@
extern crate itertools;
#[macro_use]
extern crate failure;
extern crate ron;
extern crate tera;
extern crate heck;
use std::{
collections::HashMap,
fs,
path::{Path, PathBuf},
};
use itertools::Itertools;
use heck::{CamelCase, ShoutySnakeCase, SnakeCase};
pub type Result<T> = ::std::result::Result<T, failure::Error>;
const GRAMMAR: &str = "ra_syntax/src/grammar.ron";
pub const SYNTAX_KINDS: &str = "ra_syntax/src/syntax_kinds/generated.rs";
pub const SYNTAX_KINDS_TEMPLATE: &str = "ra_syntax/src/syntax_kinds/generated.rs.tera";
pub const AST: &str = "ra_syntax/src/ast/generated.rs";
pub const AST_TEMPLATE: &str = "ra_syntax/src/ast/generated.rs.tera";
#[derive(Debug)]
pub struct Test {
@ -41,3 +60,61 @@ pub fn collect_tests(s: &str) -> Vec<(usize, Test)> {
}
res
}
pub 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(())
}
pub fn render_template(template: &Path) -> Result<String> {
let grammar: ron::value::Value = {
let text = fs::read_to_string(project_root().join(GRAMMAR))?;
ron::de::from_str(&text)?
};
let template = fs::read_to_string(template)?;
let mut tera = tera::Tera::default();
tera.add_raw_template("grammar", &template)
.map_err(|e| format_err!("template error: {:?}", e))?;
tera.register_function("concat", Box::new(concat));
tera.register_filter("camel", |arg, _| {
Ok(arg.as_str().unwrap().to_camel_case().into())
});
tera.register_filter("snake", |arg, _| {
Ok(arg.as_str().unwrap().to_snake_case().into())
});
tera.register_filter("SCREAM", |arg, _| {
Ok(arg.as_str().unwrap().to_shouty_snake_case().into())
});
let ret = tera
.render("grammar", &grammar)
.map_err(|e| format_err!("template error: {:?}", e))?;
return Ok(ret);
fn concat(args: HashMap<String, tera::Value>) -> tera::Result<tera::Value> {
let mut elements = Vec::new();
for &key in ["a", "b", "c"].iter() {
let val = match args.get(key) {
Some(val) => val,
None => continue,
};
let val = val.as_array().unwrap();
elements.extend(val.iter().cloned());
}
Ok(tera::Value::Array(elements))
}
}
pub fn project_root() -> PathBuf {
Path::new(&std::env::var("CARGO_MANIFEST_DIR").unwrap()).parent().unwrap().to_path_buf()
}

69
crates/tools/src/main.rs
View File

@ -1,31 +1,20 @@
extern crate clap;
#[macro_use]
extern crate failure;
extern crate ron;
extern crate tera;
extern crate tools;
extern crate walkdir;
extern crate heck;
use clap::{App, Arg, SubCommand};
use heck::{CamelCase, ShoutySnakeCase, SnakeCase};
use std::{
collections::HashMap,
fs,
path::{Path, PathBuf},
process::Command,
};
use tools::{collect_tests, Test};
type Result<T> = ::std::result::Result<T, failure::Error>;
use tools::{AST, AST_TEMPLATE, Result, SYNTAX_KINDS, SYNTAX_KINDS_TEMPLATE, Test, collect_tests, render_template, update, project_root};
const GRAMMAR_DIR: &str = "./crates/ra_syntax/src/grammar";
const INLINE_TESTS_DIR: &str = "./crates/ra_syntax/tests/data/parser/inline";
const GRAMMAR: &str = "./crates/ra_syntax/src/grammar.ron";
const SYNTAX_KINDS: &str = "./crates/ra_syntax/src/syntax_kinds/generated.rs";
const SYNTAX_KINDS_TEMPLATE: &str = "./crates/ra_syntax/src/syntax_kinds/generated.rs.tera";
const AST: &str = "./crates/ra_syntax/src/ast/generated.rs";
const AST_TEMPLATE: &str = "./crates/ra_syntax/src/ast/generated.rs.tera";
fn main() -> Result<()> {
let matches = App::new("tasks")
@ -51,8 +40,8 @@ fn main() -> Result<()> {
fn run_gen_command(name: &str, verify: bool) -> Result<()> {
match name {
"gen-kinds" => {
update(Path::new(SYNTAX_KINDS), &render_template(SYNTAX_KINDS_TEMPLATE)?, verify)?;
update(Path::new(AST), &render_template(AST_TEMPLATE)?, verify)?;
update(&project_root().join(SYNTAX_KINDS), &render_template(&project_root().join(SYNTAX_KINDS_TEMPLATE))?, verify)?;
update(&project_root().join(AST), &render_template(&project_root().join(AST_TEMPLATE))?, verify)?;
},
"gen-tests" => {
gen_tests(verify)?
@ -62,58 +51,6 @@ fn run_gen_command(name: &str, verify: bool) -> Result<()> {
Ok(())
}
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 render_template(template: &str) -> Result<String> {
let grammar: ron::value::Value = {
let text = fs::read_to_string(GRAMMAR)?;
ron::de::from_str(&text)?
};
let template = fs::read_to_string(template)?;
let mut tera = tera::Tera::default();
tera.add_raw_template("grammar", &template)
.map_err(|e| format_err!("template error: {:?}", e))?;
tera.register_function("concat", Box::new(concat));
tera.register_filter("camel", |arg, _| {
Ok(arg.as_str().unwrap().to_camel_case().into())
});
tera.register_filter("snake", |arg, _| {
Ok(arg.as_str().unwrap().to_snake_case().into())
});
tera.register_filter("SCREAM", |arg, _| {
Ok(arg.as_str().unwrap().to_shouty_snake_case().into())
});
let ret = tera
.render("grammar", &grammar)
.map_err(|e| format_err!("template error: {:?}", e))?;
return Ok(ret);
fn concat(args: HashMap<String, tera::Value>) -> tera::Result<tera::Value> {
let mut elements = Vec::new();
for &key in ["a", "b", "c"].iter() {
let val = match args.get(key) {
Some(val) => val,
None => continue,
};
let val = val.as_array().unwrap();
elements.extend(val.iter().cloned());
}
Ok(tera::Value::Array(elements))
}
}
fn gen_tests(verify: bool) -> Result<()> {
let tests = tests_from_dir(Path::new(GRAMMAR_DIR))?;

13
crates/tools/tests/cli.rs Normal file
View File

@ -0,0 +1,13 @@
extern crate tools;
use tools::{AST, AST_TEMPLATE, SYNTAX_KINDS, SYNTAX_KINDS_TEMPLATE, render_template, update, project_root};
#[test]
fn verify_template_generation() {
if let Err(error) = update(&project_root().join(SYNTAX_KINDS), &render_template(&project_root().join(SYNTAX_KINDS_TEMPLATE)).unwrap(), true) {
panic!("{}. Please update it by running `cargo gen-kinds`", error);
}
if let Err(error) = update(&project_root().join(AST), &render_template(&project_root().join(AST_TEMPLATE)).unwrap(), true) {
panic!("{}. Please update it by running `cargo gen-kinds`", error);
}
}