feat: warn if init seems out of date

This is a fairly large feature, as it involves persisting data about
runs to disk. This scheme is fairly general, and can be used to store a
lot of things (for example, debug output for a future rage command).

Author: suo

Cargo.toml

@@ -22,6 +22,8 @@ env_logger = "0.9.0"
 indicatif = "0.16.2"
 regex = "1.5"
 itertools = "0.10.3"
+directories = "4.0"
+blake3 = "1.3.1"
 
 [dev-dependencies]
 assert_cmd = "2.0"

src/init.rs

@@ -0,0 +1,66 @@
+use anyhow::Result;
+use console::Term;
+use log::debug;
+use std::path::{Path, PathBuf};
+
+use crate::{lint_config::LintRunnerConfig, path::AbsPath};
+
+fn get_data_file(config_path: &AbsPath, data_path: &Path) -> Result<PathBuf> {
+    // We store the old copy of the config in `data_dir/<hash of path>`
+    let config_path_hash = blake3::hash(config_path.to_string_lossy().as_bytes()).to_string();
+    let data_file = data_path.join(config_path_hash);
+    Ok(data_file)
+}
+
+// Check whether or not the currently configured init commands are different
+// from the last time we ran `init`, and warn the user if so.
+pub fn check_init_changed(
+    config_path: &AbsPath,
+    data_path: &Path,
+    current_config: &LintRunnerConfig,
+) -> Result<()> {
+    let stderr = Term::stderr();
+
+    let data_file = get_data_file(config_path, data_path)?;
+    debug!(
+        "Checking data file {} to see if config has changed",
+        data_file.display()
+    );
+
+    if !data_file.exists() {
+        stderr.write_line(
+            "No previous init data found. If this is the first time you're \
+             running lintrunner, you should run `lintrunner init`",
+        )?;
+        return Ok(());
+    }
+    let data_file = AbsPath::try_from(data_file)?;
+
+    let old_config = LintRunnerConfig::new(&data_file)?;
+
+    let old_init_commands: Vec<_> = old_config.linters.iter().map(|l| &l.init_command).collect();
+    let current_init_commands: Vec<_> = current_config
+        .linters
+        .iter()
+        .map(|l| &l.init_command)
+        .collect();
+
+    if old_init_commands != current_init_commands {
+        stderr.write_line(
+            "The init commands have changed since you last ran lintrunner. \
+             You may need to run `lintrunner init`",
+        )?;
+    }
+
+    Ok(())
+}
+
+pub fn write_config(config_path: &AbsPath, data_path: &Path) -> Result<()> {
+    let data_file = get_data_file(config_path, data_path)?;
+    debug!("Writing used config to {}", data_file.display());
+
+    let config_contents = std::fs::read_to_string(config_path)?;
+    std::fs::write(data_file, config_contents)?;
+
+    Ok(())
+}

src/lib.rs

@@ -9,10 +9,12 @@ use render::{render_lint_messages, render_lint_messages_json};
 use std::collections::HashMap;
 use std::collections::HashSet;
 use std::convert::TryFrom;
+use std::path::Path;
 use std::sync::{Arc, Mutex};
 use std::thread;
 
 mod git;
+pub mod init;
 pub mod lint_config;
 pub mod lint_message;
 pub mod linter;
@@ -27,6 +29,7 @@ use lint_message::LintMessage;
 use render::PrintedLintErrors;
 
 use crate::git::get_merge_base_with;
+use crate::init::write_config;
 use crate::render::render_lint_messages_oneline;
 
 fn group_lints_by_file(
@@ -64,7 +67,12 @@ fn apply_patches(lint_messages: &[LintMessage]) -> Result<()> {
     Ok(())
 }
 
-pub fn do_init(linters: Vec<Linter>, dry_run: bool) -> Result<i32> {
+pub fn do_init(
+    config_path: &AbsPath,
+    data_path: &Path,
+    linters: Vec<Linter>,
+    dry_run: bool,
+) -> Result<i32> {
     debug!(
         "Initializing linters: {:?}",
         linters.iter().map(|l| &l.code).collect::<Vec<_>>()
@@ -74,6 +82,8 @@ pub fn do_init(linters: Vec<Linter>, dry_run: bool) -> Result<i32> {
         linter.init(dry_run)?;
     }
 
+    write_config(config_path, data_path)?;
+
     Ok(0)
 }
 

src/lint_config.rs

@@ -7,9 +7,9 @@ use log::debug;
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
-struct LintRunnerConfig {
+pub struct LintRunnerConfig {
     #[serde(rename = "linter")]
-    linters: Vec<LintConfig>,
+    pub linters: Vec<LintConfig>,
 }
 
 /// Represents a single linter, along with all the information necessary to invoke it.
@@ -107,13 +107,13 @@ pub struct LintConfig {
 
 /// Given options specified by the user, return a list of linters to run.
 pub fn get_linters_from_config(
-    config_path: &AbsPath,
+    linter_configs: &[LintConfig],
     skipped_linters: Option<HashSet<String>>,
     taken_linters: Option<HashSet<String>>,
+    config_path: &AbsPath,
 ) -> Result<Vec<Linter>> {
-    let lint_runner_config = LintRunnerConfig::new(config_path)?;
     let mut linters = Vec::new();
-    for lint_config in lint_runner_config.linters {
+    for lint_config in linter_configs {
         let include_patterns = patterns_from_strs(&lint_config.include_patterns)?;
         let exclude_patterns = if let Some(exclude_patterns) = &lint_config.exclude_patterns {
             patterns_from_strs(exclude_patterns)?
@@ -127,11 +127,11 @@ pub fn get_linters_from_config(
             lint_config.code
         );
         linters.push(Linter {
-            code: lint_config.code,
+            code: lint_config.code.clone(),
             include_patterns,
             exclude_patterns,
-            commands: lint_config.command,
-            init_commands: lint_config.init_command,
+            commands: lint_config.command.clone(),
+            init_commands: lint_config.init_command.clone(),
             config_path: config_path.clone(),
         });
     }

src/main.rs

@@ -1,10 +1,15 @@
 use std::{collections::HashSet, convert::TryFrom, io::Write};
 
-use anyhow::{Context, Result};
+use anyhow::{anyhow, Context, Result};
 use clap::Parser;
 
+use directories::ProjectDirs;
 use lintrunner::{
-    do_init, do_lint, lint_config::get_linters_from_config, path::AbsPath, render::print_error,
+    do_init, do_lint,
+    init::check_init_changed,
+    lint_config::{get_linters_from_config, LintRunnerConfig},
+    path::AbsPath,
+    render::print_error,
     PathsToLint, RenderOpt, RevisionOpt,
 };
 
@@ -72,6 +77,12 @@ struct Args {
     /// not a user-attended terminal.
     #[clap(long)]
     force_color: bool,
+
+    /// If set, use ths provided path to store any metadata generated by
+    /// lintrunner. By default, this is a platform-specific location for
+    /// application data (e.g. $XDG_DATA_HOME for UNIX systems.)
+    #[clap(long)]
+    data_path: Option<String>,
 }
 
 #[derive(Debug, Parser)]
@@ -120,7 +131,14 @@ fn do_main() -> Result<i32> {
             .collect::<HashSet<_>>()
     });
 
-    let linters = get_linters_from_config(&config_path, skipped_linters, taken_linters)?;
+    let lint_runner_config = LintRunnerConfig::new(&config_path)?;
+
+    let linters = get_linters_from_config(
+        &lint_runner_config.linters,
+        skipped_linters,
+        taken_linters,
+        &config_path,
+    )?;
 
     let enable_spinners = args.verbose == 0 && args.output == RenderOpt::Default;
 
@@ -144,13 +162,18 @@ fn do_main() -> Result<i32> {
         RevisionOpt::Head
     };
 
+    let project_dirs = ProjectDirs::from("", "", "lintrunner");
+    let project_dirs = project_dirs.ok_or(anyhow!("Could not find project directories"))?;
+    let data_dir = project_dirs.data_dir();
+
     match args.cmd {
         Some(SubCommand::Init { dry_run }) => {
             // Just run initialization commands, don't actually lint.
-            do_init(linters, dry_run)
+            do_init(&config_path, data_dir, linters, dry_run)
         }
         None => {
             // Default command is to just lint.
+            check_init_changed(&config_path, data_dir, &lint_runner_config)?;
             do_lint(
                 linters,
                 paths_to_lint,