rename tools -> ra_tools

This should help with caching on CI I hope (see .travis.yml
before_cache)

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(())
+}

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<T> = std::result::Result<T, failure::Error>;
+
+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<Output> {
+    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<String, Test>, 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<F>(cmdline: &str, dir: &str, mut f: F) -> Result<Output>
+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<String, Test>,
+    pub err: HashMap<String, Test>,
+}
+
+fn tests_from_dir(dir: &Path) -> Result<Tests> {
+    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<HashMap<String, (PathBuf, Test)>> {
+    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)
+}

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<PathBuf> = {
+        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::<Vec<_>>();
+        paths.append(&mut vscode_path);
+        let new_paths = env::join_paths(paths)?;
+        env::set_var("PATH", &new_paths);
+    }
+
+    Ok(())
+}