sonicop 26.8.111 → 26.8.113

data/src/config/mod.rs

@@ -7,6 +7,7 @@ mod store;
 use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::path::{Path, PathBuf};
+use std::sync::{Arc, OnceLock};
 
 use anyhow::{Context, Result, bail};
 use serde::de::DeserializeOwned;
@@ -44,9 +45,39 @@ pub struct Config {
     includes: PathPatterns,
     excludes: HashMap<String, PathPatterns>,
     cop_includes: HashMap<String, PathPatterns>,
+    /// The result cache's digest of this configuration, folded on first use.
+    ///
+    /// Nothing here changes after the configuration is built, and every file in a run mixes the
+    /// digest into its own cache key -- so serializing the merged configuration again per file, all
+    /// several hundred kilobytes of it once the default set is in, cost a cached run more than
+    /// reading the files did. The `Arc` is what lets a cloned `Config` share the answer instead of
+    /// working it out again.
+    cache_digest: Arc<OnceLock<Option<[u8; 32]>>>,
 }
 
 impl Config {
+    /// Stable digest of the on-disk result cache's view of this configuration. The merged raw
+    /// configuration determines cop behaviour, while the resolved paths and Ruby version cover
+    /// behaviour derived from where the configuration was loaded and from the surrounding project.
+    pub(crate) fn cache_digest(&self) -> Result<&[u8; 32]> {
+        self.cache_digest
+            .get_or_init(|| {
+                let material = serde_json::to_vec(&(
+                    &self.raw,
+                    self.path_base.to_string_lossy(),
+                    self.cwd.to_string_lossy(),
+                    self.config_path
+                        .as_deref()
+                        .map(|path| path.to_string_lossy()),
+                    self.target_ruby.version.to_string(),
+                ))
+                .ok()?;
+                Some(*blake3::hash(&material).as_bytes())
+            })
+            .as_ref()
+            .context("failed to fingerprint the resolved configuration")
+    }
+
     pub fn load(explicit: Option<&Path>, cwd: &Path) -> Result<Self> {
         Self::load_with_options(explicit, cwd, false)
     }
@@ -117,6 +148,7 @@ impl Config {
             includes,
             excludes,
             cop_includes,
+            cache_digest: Arc::new(OnceLock::new()),
         })
     }
 
@@ -124,6 +156,15 @@ impl Config {
         &self.cwd
     }
 
+    /// Project boundary used by the result cache.
+    ///
+    /// RuboCop resolves every configured path against this directory. Keeping it in the cache
+    /// identity prevents unrelated projects that happen to use the same cop selection from
+    /// accumulating in one ever-growing index.
+    pub(crate) fn path_base(&self) -> &Path {
+        &self.path_base
+    }
+
     pub fn config_path(&self) -> Option<&Path> {
         self.config_path.as_deref()
     }
@@ -199,8 +240,52 @@ impl Config {
             .unwrap_or(true)
     }
 
+    /// Whether the run may use this cop's corrector at all, which is the cop's own `AutoCorrect`
+    /// setting rather than anything the command line asked for.
+    ///
+    /// This answers two upstream questions at once, because for every value RuboCop accepts they
+    /// have the same answer. `AutocorrectLogic#autocorrect_enabled?`
+    /// (`cop/autocorrect_logic.rb:31-46`) refuses `'disabled'` and `false` outright, and refuses
+    /// `'contextual'` while `LSP.enabled?` -- which `--editor-mode` and `--lsp` set. `Base#use_corrector`
+    /// (`cop/base.rb:445-453`) then decides what the offense is reported as, and its condition
+    /// `always_autocorrect? || (contextual_autocorrect? && !LSP.enabled?)` is false in exactly
+    /// those cases: the offense keeps status `:unsupported`, so it is **not** `correctable?` and no
+    /// `-a`/`-A` run rewrites it. Answering `false` here therefore has to do both -- withhold the
+    /// edits and clear the correctable marker -- or a user who opted out of a cop's autocorrection
+    /// still gets their code rewritten.
+    ///
+    /// `editor_mode` is `LSP.enabled?`. `AutoCorrect: contextual` is not an oddity to guard
+    /// against: `config/default.yml` ships it on 19 cops, `Lint/UselessAssignment` among them, and
+    /// deleting a half-typed assignment is precisely what an editor must not do.
+    ///
+    /// An absent key means `'always'` (`cop_config.fetch('AutoCorrect', 'always')`). A boolean is
+    /// the backward-compatible spelling of `'always'`/`'disabled'`, and
+    /// `ConfigValidator::CONFIG_CHECK_AUTOCORRECTS` refuses any other string, so the values below
+    /// are the whole reachable set. Anything else -- a number, a list -- is read as `'always'`:
+    /// upstream's `autocorrect_enabled?` says the same, and folding it the other way would let a
+    /// value RuboCop rejects outright silently switch a cop's corrections off.
+    pub fn rule_autocorrect_enabled(&self, name: &str, editor_mode: bool) -> bool {
+        match self.cop_raw_value(name, "AutoCorrect") {
+            Some(Value::Bool(value)) => *value,
+            Some(Value::String(value)) => match value.as_str() {
+                "disabled" => false,
+                "contextual" => !editor_mode,
+                _ => true,
+            },
+            _ => true,
+        }
+    }
+
     pub fn cop_value<T: DeserializeOwned>(&self, name: &str, key: &str) -> Option<T> {
-        serde_yaml_ng::from_value(self.cop_raw_value(name, key)?.clone()).ok()
+        // Deserialized from the borrowed value rather than a clone of it. Every cop reads its
+        // settings once per file, so a clone here is one deep copy of the value per cop per file
+        // -- and the values are not all small: `Lint/Debugger`'s method list is a nested map.
+        //
+        // Measured 2026-08-19: this cuts the profiler's per-cop CPU total from 44.4s to 17.7s on
+        // rubocop/rubocop, but an A/B of the two binaries showed **no wall-clock difference**
+        // outside the noise. The saving is real and the copy was pointless, so it stays -- but it
+        // is not what the run is waiting on.
+        T::deserialize(self.cop_raw_value(name, key)?).ok()
     }
 
     pub fn all_cops_value<T: DeserializeOwned>(&self, key: &str) -> Option<T> {
@@ -224,6 +309,25 @@ impl Config {
         self.includes.is_empty() || self.includes.matches_includes(path, &self.path_base)
     }
 
+    /// `Config#allowed_camel_case_file?`: a gemspec may use dashes to spell a namespace, and a file
+    /// that only reaches the run through an `Include` pattern written with capitals -- `Rakefile`,
+    /// `Gemfile` -- is named after that pattern rather than after Ruby's conventions.
+    ///
+    /// This belongs to the configuration rather than to `Naming/FileName`, exactly as upstream has
+    /// it, and the reason is not only tidiness: the cop is put to every file in the run, so
+    /// answering it from the cop meant re-reading `AllCops.Include` and recompiling its globs once
+    /// per file. Measured on rubocop/rubocop, that was 1.0 of the run's 19.0 seconds of cop time.
+    pub fn allowed_camel_case_file(&self, path: &Path) -> bool {
+        if path
+            .extension()
+            .is_some_and(|extension| extension == "gemspec")
+        {
+            return true;
+        }
+        self.includes
+            .matches_uppercase_includes(path, &self.path_base)
+    }
+
     fn top_level_hidden(&self, path: &Path) -> bool {
         paths::project_relative(path, &self.path_base).is_some_and(|relative| {
             relative
@@ -500,6 +604,31 @@ mod tests {
         assert!(Config::load(None, directory.path()).is_err());
     }
 
+    #[test]
+    fn autocorrect_is_read_per_cop_and_contextual_defers_to_the_editor() {
+        let directory = tempdir().unwrap();
+        fs::write(directory.path().join("Gemfile"), "").unwrap();
+        fs::write(
+            directory.path().join(".rubocop.yml"),
+            "Layout/TrailingWhitespace:\n  AutoCorrect: false\nStyle/StringLiterals:\n  AutoCorrect: disabled\nStyle/HashSyntax:\n  AutoCorrect: always\n",
+        )
+        .unwrap();
+
+        let config = Config::load(None, directory.path()).unwrap();
+
+        for editor_mode in [false, true] {
+            assert!(!config.rule_autocorrect_enabled("Layout/TrailingWhitespace", editor_mode));
+            assert!(!config.rule_autocorrect_enabled("Style/StringLiterals", editor_mode));
+            assert!(config.rule_autocorrect_enabled("Style/HashSyntax", editor_mode));
+            // No `AutoCorrect` key at all, which upstream reads as `'always'`.
+            assert!(config.rule_autocorrect_enabled("Layout/SpaceAfterComma", editor_mode));
+        }
+
+        // `AutoCorrect: contextual` ships in the default configuration for this cop.
+        assert!(config.rule_autocorrect_enabled("Lint/UselessAssignment", false));
+        assert!(!config.rule_autocorrect_enabled("Lint/UselessAssignment", true));
+    }
+
     #[test]
     fn relative_excludes_do_not_match_paths_outside_the_project_root() {
         let project = tempdir().unwrap();