From 10d34532e3e96ffd92c11e667deb453188c28282 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 11 Jun 2019 01:47:37 +0300 Subject: rename tools -> ra_tools This should help with caching on CI I hope (see .travis.yml before_cache) --- crates/ra_cli/Cargo.toml | 1 - crates/ra_tools/Cargo.toml | 13 ++ crates/ra_tools/src/bin/pre-commit.rs | 28 ++++ crates/ra_tools/src/lib.rs | 290 ++++++++++++++++++++++++++++++++++ crates/ra_tools/src/main.rs | 106 +++++++++++++ crates/ra_tools/tests/cli.rs | 46 ++++++ crates/tools/Cargo.toml | 13 -- crates/tools/src/bin/pre-commit.rs | 28 ---- crates/tools/src/lib.rs | 290 ---------------------------------- crates/tools/src/main.rs | 106 ------------- crates/tools/tests/cli.rs | 46 ------ 11 files changed, 483 insertions(+), 484 deletions(-) create mode 100644 crates/ra_tools/Cargo.toml create mode 100644 crates/ra_tools/src/bin/pre-commit.rs create mode 100644 crates/ra_tools/src/lib.rs create mode 100644 crates/ra_tools/src/main.rs create mode 100644 crates/ra_tools/tests/cli.rs delete mode 100644 crates/tools/Cargo.toml delete mode 100644 crates/tools/src/bin/pre-commit.rs delete mode 100644 crates/tools/src/lib.rs delete mode 100644 crates/tools/src/main.rs delete mode 100644 crates/tools/tests/cli.rs (limited to 'crates') diff --git a/crates/ra_cli/Cargo.toml b/crates/ra_cli/Cargo.toml index 328b2436f..3117f4fda 100644 --- a/crates/ra_cli/Cargo.toml +++ b/crates/ra_cli/Cargo.toml @@ -14,7 +14,6 @@ indicatif = "0.11.0" ra_syntax = { path = "../ra_syntax" } ra_ide_api = { path = "../ra_ide_api" } -tools = { path = "../tools" } ra_batch = { path = "../ra_batch" } ra_hir = { path = "../ra_hir" } ra_db = { path = "../ra_db" } diff --git a/crates/ra_tools/Cargo.toml b/crates/ra_tools/Cargo.toml new file mode 100644 index 000000000..35ea3231b --- /dev/null +++ b/crates/ra_tools/Cargo.toml @@ -0,0 +1,13 @@ +[package] +edition = "2018" +name = "ra_tools" +version = "0.1.0" +authors = ["rust-analyzer developers"] +publish = false + +[dependencies] +teraron = "0.0.1" +walkdir = "2.1.3" +itertools = "0.8.0" +clap = "2.32.0" +failure = "0.1.4" diff --git a/crates/ra_tools/src/bin/pre-commit.rs b/crates/ra_tools/src/bin/pre-commit.rs new file mode 100644 index 000000000..c514e992b --- /dev/null +++ b/crates/ra_tools/src/bin/pre-commit.rs @@ -0,0 +1,28 @@ +use std::process::Command; + +use failure::bail; + +use ra_tools::{Result, run_rustfmt, run, project_root, Overwrite}; + +fn main() -> Result<()> { + run_rustfmt(Overwrite)?; + update_staged() +} + +fn update_staged() -> Result<()> { + let root = project_root(); + let output = Command::new("git") + .arg("diff") + .arg("--diff-filter=MAR") + .arg("--name-only") + .arg("--cached") + .current_dir(&root) + .output()?; + if !output.status.success() { + bail!("`git diff --diff-filter=MAR --name-only --cached` exited with {}", output.status); + } + for line in String::from_utf8(output.stdout)?.lines() { + run(&format!("git update-index --add {}", root.join(line).to_string_lossy()), ".")?; + } + Ok(()) +} diff --git a/crates/ra_tools/src/lib.rs b/crates/ra_tools/src/lib.rs new file mode 100644 index 000000000..61f6b08cd --- /dev/null +++ b/crates/ra_tools/src/lib.rs @@ -0,0 +1,290 @@ +use std::{ + fs, + collections::HashMap, + path::{Path, PathBuf}, + process::{Command, Output, Stdio}, + io::{Error, ErrorKind} +}; + +use failure::bail; +use itertools::Itertools; + +pub use teraron::{Mode, Overwrite, Verify}; + +pub type Result = std::result::Result; + +pub const GRAMMAR: &str = "crates/ra_syntax/src/grammar.ron"; +const GRAMMAR_DIR: &str = "crates/ra_parser/src/grammar"; +const OK_INLINE_TESTS_DIR: &str = "crates/ra_syntax/tests/data/parser/inline/ok"; +const ERR_INLINE_TESTS_DIR: &str = "crates/ra_syntax/tests/data/parser/inline/err"; + +pub const SYNTAX_KINDS: &str = "crates/ra_parser/src/syntax_kind/generated.rs.tera"; +pub const AST: &str = "crates/ra_syntax/src/ast/generated.rs.tera"; +const TOOLCHAIN: &str = "stable"; + +#[derive(Debug)] +pub struct Test { + pub name: String, + pub text: String, + pub ok: bool, +} + +pub fn collect_tests(s: &str) -> Vec<(usize, Test)> { + let mut res = vec![]; + let prefix = "// "; + let comment_blocks = s + .lines() + .map(str::trim_start) + .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 mut ok = true; + let (start_line, name) = loop { + match block.next() { + Some((idx, line)) if line.starts_with("test ") => { + break (idx, line["test ".len()..].to_string()); + } + Some((idx, line)) if line.starts_with("test_err ") => { + ok = false; + break (idx, line["test_err ".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((start_line, Test { name, text, ok })) + } + res +} + +pub fn generate(mode: Mode) -> Result<()> { + let grammar = project_root().join(GRAMMAR); + let syntax_kinds = project_root().join(SYNTAX_KINDS); + let ast = project_root().join(AST); + teraron::generate(&syntax_kinds, &grammar, mode)?; + teraron::generate(&ast, &grammar, mode)?; + Ok(()) +} + +pub fn project_root() -> PathBuf { + Path::new(&env!("CARGO_MANIFEST_DIR")).ancestors().nth(2).unwrap().to_path_buf() +} + +pub fn run(cmdline: &str, dir: &str) -> Result<()> { + do_run(cmdline, dir, |c| { + c.stdout(Stdio::inherit()); + }) + .map(|_| ()) +} + +pub fn run_with_output(cmdline: &str, dir: &str) -> Result { + do_run(cmdline, dir, |_| {}) +} + +pub fn run_rustfmt(mode: Mode) -> Result<()> { + match Command::new("rustup") + .args(&["run", TOOLCHAIN, "--", "cargo", "fmt", "--version"]) + .stderr(Stdio::null()) + .stdout(Stdio::null()) + .status() + { + Ok(status) if status.success() => (), + _ => install_rustfmt()?, + }; + + if mode == Verify { + run(&format!("rustup run {} -- cargo fmt -- --check", TOOLCHAIN), ".")?; + } else { + run(&format!("rustup run {} -- cargo fmt", TOOLCHAIN), ".")?; + } + Ok(()) +} + +pub fn install_rustfmt() -> Result<()> { + run(&format!("rustup install {}", TOOLCHAIN), ".")?; + run(&format!("rustup component add rustfmt --toolchain {}", TOOLCHAIN), ".") +} + +pub fn install_format_hook() -> Result<()> { + let result_path = Path::new(if cfg!(windows) { + "./.git/hooks/pre-commit.exe" + } else { + "./.git/hooks/pre-commit" + }); + if !result_path.exists() { + run("cargo build --package ra_tools --bin pre-commit", ".")?; + if cfg!(windows) { + fs::copy("./target/debug/pre-commit.exe", result_path)?; + } else { + fs::copy("./target/debug/pre-commit", result_path)?; + } + } else { + return Err(Error::new(ErrorKind::AlreadyExists, "Git hook already created").into()); + } + Ok(()) +} + +pub fn run_clippy() -> Result<()> { + match Command::new("rustup") + .args(&["run", TOOLCHAIN, "--", "cargo", "clippy", "--version"]) + .stderr(Stdio::null()) + .stdout(Stdio::null()) + .status() + { + Ok(status) if status.success() => (), + _ => install_clippy()?, + }; + + let allowed_lints = [ + "clippy::collapsible_if", + "clippy::map_clone", // FIXME: remove when Iterator::copied stabilizes (1.36.0) + "clippy::needless_pass_by_value", + "clippy::nonminimal_bool", + "clippy::redundant_pattern_matching", + ]; + run( + &format!( + "rustup run {} -- cargo clippy --all-features --all-targets -- -A {}", + TOOLCHAIN, + allowed_lints.join(" -A ") + ), + ".", + )?; + Ok(()) +} + +pub fn install_clippy() -> Result<()> { + run(&format!("rustup install {}", TOOLCHAIN), ".")?; + run(&format!("rustup component add clippy --toolchain {}", TOOLCHAIN), ".") +} + +pub fn run_fuzzer() -> Result<()> { + match Command::new("cargo") + .args(&["fuzz", "--help"]) + .stderr(Stdio::null()) + .stdout(Stdio::null()) + .status() + { + Ok(status) if status.success() => (), + _ => run("cargo install cargo-fuzz", ".")?, + }; + + run("rustup run nightly -- cargo fuzz run parser", "./crates/ra_syntax") +} + +pub fn gen_tests(mode: Mode) -> Result<()> { + let tests = tests_from_dir(&project_root().join(Path::new(GRAMMAR_DIR)))?; + fn install_tests(tests: &HashMap, into: &str, mode: Mode) -> Result<()> { + let tests_dir = project_root().join(into); + if !tests_dir.is_dir() { + fs::create_dir_all(&tests_dir)?; + } + // ok is never actually read, but it needs to be specified to create a Test in existing_tests + let existing = existing_tests(&tests_dir, true)?; + for t in existing.keys().filter(|&t| !tests.contains_key(t)) { + panic!("Test is deleted: {}", t); + } + + let mut new_idx = existing.len() + 1; + for (name, test) in tests { + let path = match existing.get(name) { + Some((path, _test)) => path.clone(), + None => { + let file_name = format!("{:04}_{}.rs", new_idx, name); + new_idx += 1; + tests_dir.join(file_name) + } + }; + teraron::update(&path, &test.text, mode)?; + } + Ok(()) + } + install_tests(&tests.ok, OK_INLINE_TESTS_DIR, mode)?; + install_tests(&tests.err, ERR_INLINE_TESTS_DIR, mode) +} + +fn do_run(cmdline: &str, dir: &str, mut f: F) -> Result +where + F: FnMut(&mut Command), +{ + eprintln!("\nwill run: {}", cmdline); + let proj_dir = project_root().join(dir); + let mut args = cmdline.split_whitespace(); + let exec = args.next().unwrap(); + let mut cmd = Command::new(exec); + f(cmd.args(args).current_dir(proj_dir).stderr(Stdio::inherit())); + let output = cmd.output()?; + if !output.status.success() { + bail!("`{}` exited with {}", cmdline, output.status); + } + Ok(output) +} + +#[derive(Default, Debug)] +struct Tests { + pub ok: HashMap, + pub err: HashMap, +} + +fn tests_from_dir(dir: &Path) -> Result { + let mut res = Tests::default(); + 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; + } + process_file(&mut res, entry.path())?; + } + let grammar_rs = dir.parent().unwrap().join("grammar.rs"); + process_file(&mut res, &grammar_rs)?; + return Ok(res); + fn process_file(res: &mut Tests, path: &Path) -> Result<()> { + let text = fs::read_to_string(path)?; + + for (_, test) in collect_tests(&text) { + if test.ok { + if let Some(old_test) = res.ok.insert(test.name.clone(), test) { + bail!("Duplicate test: {}", old_test.name) + } + } else { + if let Some(old_test) = res.err.insert(test.name.clone(), test) { + bail!("Duplicate test: {}", old_test.name) + } + } + } + Ok(()) + } +} + +fn existing_tests(dir: &Path, ok: bool) -> Result> { + let mut res = HashMap::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 = { + let file_name = path.file_name().unwrap().to_str().unwrap(); + file_name[5..file_name.len() - 3].to_string() + }; + let text = fs::read_to_string(&path)?; + let test = Test { name: name.clone(), text, ok }; + if let Some(old) = res.insert(name, (path, test)) { + println!("Duplicate test: {:?}", old); + } + } + Ok(res) +} diff --git a/crates/ra_tools/src/main.rs b/crates/ra_tools/src/main.rs new file mode 100644 index 000000000..285071ea5 --- /dev/null +++ b/crates/ra_tools/src/main.rs @@ -0,0 +1,106 @@ +use clap::{App, SubCommand}; +use core::str; +use failure::bail; +use ra_tools::{ + generate, gen_tests, install_format_hook, run, run_with_output, run_rustfmt, + Overwrite, Result, run_fuzzer, run_clippy, +}; +use std::{path::{PathBuf}, env}; + +fn main() -> Result<()> { + let matches = App::new("tasks") + .setting(clap::AppSettings::SubcommandRequiredElseHelp) + .subcommand(SubCommand::with_name("gen-syntax")) + .subcommand(SubCommand::with_name("gen-tests")) + .subcommand(SubCommand::with_name("install-code")) + .subcommand(SubCommand::with_name("format")) + .subcommand(SubCommand::with_name("format-hook")) + .subcommand(SubCommand::with_name("fuzz-tests")) + .subcommand(SubCommand::with_name("lint")) + .get_matches(); + match matches.subcommand_name().expect("Subcommand must be specified") { + "install-code" => { + if cfg!(target_os = "macos") { + fix_path_for_mac()?; + } + install_code_extension()?; + } + "gen-tests" => gen_tests(Overwrite)?, + "gen-syntax" => generate(Overwrite)?, + "format" => run_rustfmt(Overwrite)?, + "format-hook" => install_format_hook()?, + "lint" => run_clippy()?, + "fuzz-tests" => run_fuzzer()?, + _ => unreachable!(), + } + Ok(()) +} + +fn install_code_extension() -> Result<()> { + run("cargo install --path crates/ra_lsp_server --force", ".")?; + if cfg!(windows) { + run(r"cmd.exe /c npm.cmd ci", "./editors/code")?; + run(r"cmd.exe /c npm.cmd run package", "./editors/code")?; + } else { + run(r"npm ci", "./editors/code")?; + run(r"npm run package", "./editors/code")?; + } + if cfg!(windows) { + run( + r"cmd.exe /c code.cmd --install-extension ./ra-lsp-0.0.1.vsix --force", + "./editors/code", + )?; + } else { + run(r"code --install-extension ./ra-lsp-0.0.1.vsix --force", "./editors/code")?; + } + verify_installed_extensions()?; + Ok(()) +} + +fn verify_installed_extensions() -> Result<()> { + let exts = if cfg!(windows) { + run_with_output(r"cmd.exe /c code.cmd --list-extensions", ".")? + } else { + run_with_output(r"code --list-extensions", ".")? + }; + if !str::from_utf8(&exts.stdout)?.contains("ra-lsp") { + bail!( + "Could not install the Visual Studio Code extension. Please make sure you \ + have at least NodeJS 10.x installed and try again." + ); + } + Ok(()) +} + +fn fix_path_for_mac() -> Result<()> { + let mut vscode_path: Vec = { + const COMMON_APP_PATH: &str = + r"/Applications/Visual Studio Code.app/Contents/Resources/app/bin"; + const ROOT_DIR: &str = ""; + let home_dir = match env::var("HOME") { + Ok(home) => home, + Err(e) => bail!("Failed getting HOME from environment with error: {}.", e), + }; + + [ROOT_DIR, &home_dir] + .iter() + .map(|dir| String::from(*dir) + COMMON_APP_PATH) + .map(PathBuf::from) + .filter(|path| path.exists()) + .collect() + }; + + if !vscode_path.is_empty() { + let vars = match env::var_os("PATH") { + Some(path) => path, + None => bail!("Could not get PATH variable from env."), + }; + + let mut paths = env::split_paths(&vars).collect::>(); + paths.append(&mut vscode_path); + let new_paths = env::join_paths(paths)?; + env::set_var("PATH", &new_paths); + } + + Ok(()) +} diff --git a/crates/ra_tools/tests/cli.rs b/crates/ra_tools/tests/cli.rs new file mode 100644 index 000000000..83640218f --- /dev/null +++ b/crates/ra_tools/tests/cli.rs @@ -0,0 +1,46 @@ +use walkdir::WalkDir; + +use ra_tools::{generate, gen_tests, run_rustfmt, Verify, project_root}; + +#[test] +fn generated_grammar_is_fresh() { + if let Err(error) = generate(Verify) { + panic!("{}. Please update it by running `cargo gen-syntax`", error); + } +} + +#[test] +fn generated_tests_are_fresh() { + if let Err(error) = gen_tests(Verify) { + panic!("{}. Please update tests by running `cargo gen-tests`", error); + } +} + +#[test] +fn check_code_formatting() { + if let Err(error) = run_rustfmt(Verify) { + panic!("{}. Please format the code by running `cargo format`", error); + } +} + +#[test] +fn no_todo() { + WalkDir::new(project_root().join("crates")).into_iter().for_each(|e| { + let e = e.unwrap(); + if e.path().extension().map(|it| it != "rs").unwrap_or(true) { + return; + } + if e.path().ends_with("tests/cli.rs") { + return; + } + let text = std::fs::read_to_string(e.path()).unwrap(); + if text.contains("TODO") { + panic!( + "\nTODO markers should not be commited to the master branch,\n\ + use FIXME instead\n\ + {}\n", + e.path().display(), + ) + } + }) +} diff --git a/crates/tools/Cargo.toml b/crates/tools/Cargo.toml deleted file mode 100644 index f03256a74..000000000 --- a/crates/tools/Cargo.toml +++ /dev/null @@ -1,13 +0,0 @@ -[package] -edition = "2018" -name = "tools" -version = "0.1.0" -authors = ["rust-analyzer developers"] -publish = false - -[dependencies] -teraron = "0.0.1" -walkdir = "2.1.3" -itertools = "0.8.0" -clap = "2.32.0" -failure = "0.1.4" diff --git a/crates/tools/src/bin/pre-commit.rs b/crates/tools/src/bin/pre-commit.rs deleted file mode 100644 index ea18c0863..000000000 --- a/crates/tools/src/bin/pre-commit.rs +++ /dev/null @@ -1,28 +0,0 @@ -use std::process::Command; - -use failure::bail; - -use tools::{Result, run_rustfmt, run, project_root}; - -fn main() -> tools::Result<()> { - run_rustfmt(tools::Overwrite)?; - update_staged() -} - -fn update_staged() -> Result<()> { - let root = project_root(); - let output = Command::new("git") - .arg("diff") - .arg("--diff-filter=MAR") - .arg("--name-only") - .arg("--cached") - .current_dir(&root) - .output()?; - if !output.status.success() { - bail!("`git diff --diff-filter=MAR --name-only --cached` exited with {}", output.status); - } - for line in String::from_utf8(output.stdout)?.lines() { - run(&format!("git update-index --add {}", root.join(line).to_string_lossy()), ".")?; - } - Ok(()) -} diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rs deleted file mode 100644 index 2446fdf28..000000000 --- a/crates/tools/src/lib.rs +++ /dev/null @@ -1,290 +0,0 @@ -use std::{ - fs, - collections::HashMap, - path::{Path, PathBuf}, - process::{Command, Output, Stdio}, - io::{Error, ErrorKind} -}; - -use failure::bail; -use itertools::Itertools; - -pub use teraron::{Mode, Overwrite, Verify}; - -pub type Result = std::result::Result; - -pub const GRAMMAR: &str = "crates/ra_syntax/src/grammar.ron"; -const GRAMMAR_DIR: &str = "crates/ra_parser/src/grammar"; -const OK_INLINE_TESTS_DIR: &str = "crates/ra_syntax/tests/data/parser/inline/ok"; -const ERR_INLINE_TESTS_DIR: &str = "crates/ra_syntax/tests/data/parser/inline/err"; - -pub const SYNTAX_KINDS: &str = "crates/ra_parser/src/syntax_kind/generated.rs.tera"; -pub const AST: &str = "crates/ra_syntax/src/ast/generated.rs.tera"; -const TOOLCHAIN: &str = "stable"; - -#[derive(Debug)] -pub struct Test { - pub name: String, - pub text: String, - pub ok: bool, -} - -pub fn collect_tests(s: &str) -> Vec<(usize, Test)> { - let mut res = vec![]; - let prefix = "// "; - let comment_blocks = s - .lines() - .map(str::trim_start) - .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 mut ok = true; - let (start_line, name) = loop { - match block.next() { - Some((idx, line)) if line.starts_with("test ") => { - break (idx, line["test ".len()..].to_string()); - } - Some((idx, line)) if line.starts_with("test_err ") => { - ok = false; - break (idx, line["test_err ".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((start_line, Test { name, text, ok })) - } - res -} - -pub fn generate(mode: Mode) -> Result<()> { - let grammar = project_root().join(GRAMMAR); - let syntax_kinds = project_root().join(SYNTAX_KINDS); - let ast = project_root().join(AST); - teraron::generate(&syntax_kinds, &grammar, mode)?; - teraron::generate(&ast, &grammar, mode)?; - Ok(()) -} - -pub fn project_root() -> PathBuf { - Path::new(&env!("CARGO_MANIFEST_DIR")).ancestors().nth(2).unwrap().to_path_buf() -} - -pub fn run(cmdline: &str, dir: &str) -> Result<()> { - do_run(cmdline, dir, |c| { - c.stdout(Stdio::inherit()); - }) - .map(|_| ()) -} - -pub fn run_with_output(cmdline: &str, dir: &str) -> Result { - do_run(cmdline, dir, |_| {}) -} - -pub fn run_rustfmt(mode: Mode) -> Result<()> { - match Command::new("rustup") - .args(&["run", TOOLCHAIN, "--", "cargo", "fmt", "--version"]) - .stderr(Stdio::null()) - .stdout(Stdio::null()) - .status() - { - Ok(status) if status.success() => (), - _ => install_rustfmt()?, - }; - - if mode == Verify { - run(&format!("rustup run {} -- cargo fmt -- --check", TOOLCHAIN), ".")?; - } else { - run(&format!("rustup run {} -- cargo fmt", TOOLCHAIN), ".")?; - } - Ok(()) -} - -pub fn install_rustfmt() -> Result<()> { - run(&format!("rustup install {}", TOOLCHAIN), ".")?; - run(&format!("rustup component add rustfmt --toolchain {}", TOOLCHAIN), ".") -} - -pub fn install_format_hook() -> Result<()> { - let result_path = Path::new(if cfg!(windows) { - "./.git/hooks/pre-commit.exe" - } else { - "./.git/hooks/pre-commit" - }); - if !result_path.exists() { - run("cargo build --package tools --bin pre-commit", ".")?; - if cfg!(windows) { - fs::copy("./target/debug/pre-commit.exe", result_path)?; - } else { - fs::copy("./target/debug/pre-commit", result_path)?; - } - } else { - return Err(Error::new(ErrorKind::AlreadyExists, "Git hook already created").into()); - } - Ok(()) -} - -pub fn run_clippy() -> Result<()> { - match Command::new("rustup") - .args(&["run", TOOLCHAIN, "--", "cargo", "clippy", "--version"]) - .stderr(Stdio::null()) - .stdout(Stdio::null()) - .status() - { - Ok(status) if status.success() => (), - _ => install_clippy()?, - }; - - let allowed_lints = [ - "clippy::collapsible_if", - "clippy::map_clone", // FIXME: remove when Iterator::copied stabilizes (1.36.0) - "clippy::needless_pass_by_value", - "clippy::nonminimal_bool", - "clippy::redundant_pattern_matching", - ]; - run( - &format!( - "rustup run {} -- cargo clippy --all-features --all-targets -- -A {}", - TOOLCHAIN, - allowed_lints.join(" -A ") - ), - ".", - )?; - Ok(()) -} - -pub fn install_clippy() -> Result<()> { - run(&format!("rustup install {}", TOOLCHAIN), ".")?; - run(&format!("rustup component add clippy --toolchain {}", TOOLCHAIN), ".") -} - -pub fn run_fuzzer() -> Result<()> { - match Command::new("cargo") - .args(&["fuzz", "--help"]) - .stderr(Stdio::null()) - .stdout(Stdio::null()) - .status() - { - Ok(status) if status.success() => (), - _ => run("cargo install cargo-fuzz", ".")?, - }; - - run("rustup run nightly -- cargo fuzz run parser", "./crates/ra_syntax") -} - -pub fn gen_tests(mode: Mode) -> Result<()> { - let tests = tests_from_dir(&project_root().join(Path::new(GRAMMAR_DIR)))?; - fn install_tests(tests: &HashMap, into: &str, mode: Mode) -> Result<()> { - let tests_dir = project_root().join(into); - if !tests_dir.is_dir() { - fs::create_dir_all(&tests_dir)?; - } - // ok is never actually read, but it needs to be specified to create a Test in existing_tests - let existing = existing_tests(&tests_dir, true)?; - for t in existing.keys().filter(|&t| !tests.contains_key(t)) { - panic!("Test is deleted: {}", t); - } - - let mut new_idx = existing.len() + 1; - for (name, test) in tests { - let path = match existing.get(name) { - Some((path, _test)) => path.clone(), - None => { - let file_name = format!("{:04}_{}.rs", new_idx, name); - new_idx += 1; - tests_dir.join(file_name) - } - }; - teraron::update(&path, &test.text, mode)?; - } - Ok(()) - } - install_tests(&tests.ok, OK_INLINE_TESTS_DIR, mode)?; - install_tests(&tests.err, ERR_INLINE_TESTS_DIR, mode) -} - -fn do_run(cmdline: &str, dir: &str, mut f: F) -> Result -where - F: FnMut(&mut Command), -{ - eprintln!("\nwill run: {}", cmdline); - let proj_dir = project_root().join(dir); - let mut args = cmdline.split_whitespace(); - let exec = args.next().unwrap(); - let mut cmd = Command::new(exec); - f(cmd.args(args).current_dir(proj_dir).stderr(Stdio::inherit())); - let output = cmd.output()?; - if !output.status.success() { - bail!("`{}` exited with {}", cmdline, output.status); - } - Ok(output) -} - -#[derive(Default, Debug)] -struct Tests { - pub ok: HashMap, - pub err: HashMap, -} - -fn tests_from_dir(dir: &Path) -> Result { - let mut res = Tests::default(); - 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; - } - process_file(&mut res, entry.path())?; - } - let grammar_rs = dir.parent().unwrap().join("grammar.rs"); - process_file(&mut res, &grammar_rs)?; - return Ok(res); - fn process_file(res: &mut Tests, path: &Path) -> Result<()> { - let text = fs::read_to_string(path)?; - - for (_, test) in collect_tests(&text) { - if test.ok { - if let Some(old_test) = res.ok.insert(test.name.clone(), test) { - bail!("Duplicate test: {}", old_test.name) - } - } else { - if let Some(old_test) = res.err.insert(test.name.clone(), test) { - bail!("Duplicate test: {}", old_test.name) - } - } - } - Ok(()) - } -} - -fn existing_tests(dir: &Path, ok: bool) -> Result> { - let mut res = HashMap::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 = { - let file_name = path.file_name().unwrap().to_str().unwrap(); - file_name[5..file_name.len() - 3].to_string() - }; - let text = fs::read_to_string(&path)?; - let test = Test { name: name.clone(), text, ok }; - if let Some(old) = res.insert(name, (path, test)) { - println!("Duplicate test: {:?}", old); - } - } - Ok(res) -} diff --git a/crates/tools/src/main.rs b/crates/tools/src/main.rs deleted file mode 100644 index 8027ff833..000000000 --- a/crates/tools/src/main.rs +++ /dev/null @@ -1,106 +0,0 @@ -use clap::{App, SubCommand}; -use core::str; -use failure::bail; -use tools::{ - generate, gen_tests, install_format_hook, run, run_with_output, run_rustfmt, - Overwrite, Result, run_fuzzer, run_clippy, -}; -use std::{path::{PathBuf}, env}; - -fn main() -> Result<()> { - let matches = App::new("tasks") - .setting(clap::AppSettings::SubcommandRequiredElseHelp) - .subcommand(SubCommand::with_name("gen-syntax")) - .subcommand(SubCommand::with_name("gen-tests")) - .subcommand(SubCommand::with_name("install-code")) - .subcommand(SubCommand::with_name("format")) - .subcommand(SubCommand::with_name("format-hook")) - .subcommand(SubCommand::with_name("fuzz-tests")) - .subcommand(SubCommand::with_name("lint")) - .get_matches(); - match matches.subcommand_name().expect("Subcommand must be specified") { - "install-code" => { - if cfg!(target_os = "macos") { - fix_path_for_mac()?; - } - install_code_extension()?; - } - "gen-tests" => gen_tests(Overwrite)?, - "gen-syntax" => generate(Overwrite)?, - "format" => run_rustfmt(Overwrite)?, - "format-hook" => install_format_hook()?, - "lint" => run_clippy()?, - "fuzz-tests" => run_fuzzer()?, - _ => unreachable!(), - } - Ok(()) -} - -fn install_code_extension() -> Result<()> { - run("cargo install --path crates/ra_lsp_server --force", ".")?; - if cfg!(windows) { - run(r"cmd.exe /c npm.cmd ci", "./editors/code")?; - run(r"cmd.exe /c npm.cmd run package", "./editors/code")?; - } else { - run(r"npm ci", "./editors/code")?; - run(r"npm run package", "./editors/code")?; - } - if cfg!(windows) { - run( - r"cmd.exe /c code.cmd --install-extension ./ra-lsp-0.0.1.vsix --force", - "./editors/code", - )?; - } else { - run(r"code --install-extension ./ra-lsp-0.0.1.vsix --force", "./editors/code")?; - } - verify_installed_extensions()?; - Ok(()) -} - -fn verify_installed_extensions() -> Result<()> { - let exts = if cfg!(windows) { - run_with_output(r"cmd.exe /c code.cmd --list-extensions", ".")? - } else { - run_with_output(r"code --list-extensions", ".")? - }; - if !str::from_utf8(&exts.stdout)?.contains("ra-lsp") { - bail!( - "Could not install the Visual Studio Code extension. Please make sure you \ - have at least NodeJS 10.x installed and try again." - ); - } - Ok(()) -} - -fn fix_path_for_mac() -> Result<()> { - let mut vscode_path: Vec = { - const COMMON_APP_PATH: &str = - r"/Applications/Visual Studio Code.app/Contents/Resources/app/bin"; - const ROOT_DIR: &str = ""; - let home_dir = match env::var("HOME") { - Ok(home) => home, - Err(e) => bail!("Failed getting HOME from environment with error: {}.", e), - }; - - [ROOT_DIR, &home_dir] - .iter() - .map(|dir| String::from(*dir) + COMMON_APP_PATH) - .map(PathBuf::from) - .filter(|path| path.exists()) - .collect() - }; - - if !vscode_path.is_empty() { - let vars = match env::var_os("PATH") { - Some(path) => path, - None => bail!("Could not get PATH variable from env."), - }; - - let mut paths = env::split_paths(&vars).collect::>(); - paths.append(&mut vscode_path); - let new_paths = env::join_paths(paths)?; - env::set_var("PATH", &new_paths); - } - - Ok(()) -} diff --git a/crates/tools/tests/cli.rs b/crates/tools/tests/cli.rs deleted file mode 100644 index 6f82ae61d..000000000 --- a/crates/tools/tests/cli.rs +++ /dev/null @@ -1,46 +0,0 @@ -use walkdir::WalkDir; - -use tools::{generate, gen_tests, run_rustfmt, Verify, project_root}; - -#[test] -fn generated_grammar_is_fresh() { - if let Err(error) = generate(Verify) { - panic!("{}. Please update it by running `cargo gen-syntax`", error); - } -} - -#[test] -fn generated_tests_are_fresh() { - if let Err(error) = gen_tests(Verify) { - panic!("{}. Please update tests by running `cargo gen-tests`", error); - } -} - -#[test] -fn check_code_formatting() { - if let Err(error) = run_rustfmt(Verify) { - panic!("{}. Please format the code by running `cargo format`", error); - } -} - -#[test] -fn no_todo() { - WalkDir::new(project_root().join("crates")).into_iter().for_each(|e| { - let e = e.unwrap(); - if e.path().extension().map(|it| it != "rs").unwrap_or(true) { - return; - } - if e.path().ends_with("tests/cli.rs") { - return; - } - let text = std::fs::read_to_string(e.path()).unwrap(); - if text.contains("TODO") { - panic!( - "\nTODO markers should not be commited to the master branch,\n\ - use FIXME instead\n\ - {}\n", - e.path().display(), - ) - } - }) -} -- cgit v1.2.3