sonicop 26.8.101

data/src/config/store.rs

@@ -0,0 +1,141 @@
+use std::collections::HashMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
+
+use anyhow::{Result, bail};
+
+use super::Config;
+use super::loader::find_config;
+
+type ConfigCache = Mutex<HashMap<PathBuf, Arc<Config>>>;
+
+#[derive(Debug)]
+pub struct ConfigStore {
+    root: Arc<Config>,
+    discover_per_path: bool,
+    ignore_unrecognized: bool,
+    directories: ConfigCache,
+    cache: ConfigCache,
+}
+
+impl ConfigStore {
+    pub fn new(config: Config, discover_per_path: bool, ignore_unrecognized: bool) -> Self {
+        Self {
+            root: Arc::new(config),
+            discover_per_path,
+            ignore_unrecognized,
+            directories: Mutex::new(HashMap::new()),
+            cache: Mutex::new(HashMap::new()),
+        }
+    }
+
+    pub fn root(&self) -> &Config {
+        &self.root
+    }
+
+    pub fn for_path(&self, path: &Path) -> Result<Arc<Config>> {
+        if !self.discover_per_path {
+            return Ok(Arc::clone(&self.root));
+        }
+
+        let start = if path.is_dir() {
+            path
+        } else {
+            path.parent()
+                .filter(|parent| !parent.as_os_str().is_empty())
+                .unwrap_or(Path::new("."))
+        };
+        // `find_config` canonicalizes and stats every ancestor directory, so keying only
+        // the resolved configuration path made every file pay that cost again. Directories
+        // are far fewer than the files below them, so memoize on the directory itself.
+        if let Some(config) = cached(&self.directories, start)? {
+            return Ok(config);
+        }
+
+        let discovered = find_config(start);
+        let config = if discovered.as_deref() == self.root.config_path() {
+            Arc::clone(&self.root)
+        } else {
+            let key = discovered
+                .clone()
+                .unwrap_or_else(|| fs::canonicalize(start).unwrap_or_else(|_| start.to_path_buf()));
+            match cached(&self.cache, &key)? {
+                Some(config) => config,
+                None => {
+                    let config = Arc::new(Config::load(discovered.as_deref(), start)?);
+                    if !self.ignore_unrecognized && !config.unrecognized_cop_names().is_empty() {
+                        bail!(
+                            "unrecognized cop(s): {}",
+                            config.unrecognized_cop_names().join(", ")
+                        );
+                    }
+                    store(&self.cache, key, &config)?;
+                    config
+                }
+            }
+        };
+        store(&self.directories, start.to_path_buf(), &config)?;
+        Ok(config)
+    }
+}
+
+fn cached(cache: &ConfigCache, key: &Path) -> Result<Option<Arc<Config>>> {
+    Ok(lock(cache)?.get(key).cloned())
+}
+
+fn store(cache: &ConfigCache, key: PathBuf, config: &Arc<Config>) -> Result<()> {
+    lock(cache)?.insert(key, Arc::clone(config));
+    Ok(())
+}
+
+fn lock(cache: &ConfigCache) -> Result<std::sync::MutexGuard<'_, HashMap<PathBuf, Arc<Config>>>> {
+    cache
+        .lock()
+        .map_err(|_| anyhow::anyhow!("configuration cache lock is poisoned"))
+}
+
+#[cfg(test)]
+mod tests {
+    use std::fs;
+
+    use tempfile::tempdir;
+
+    use super::{Config, ConfigStore};
+
+    #[test]
+    fn store_resolves_nested_configuration_from_target_path() {
+        let directory = tempdir().unwrap();
+        let nested = directory.path().join("nested");
+        fs::create_dir(&nested).unwrap();
+        fs::write(directory.path().join("Gemfile"), "").unwrap();
+        fs::write(
+            directory.path().join(".rubocop.yml"),
+            "AllCops:\n  DisabledByDefault: true\nLayout/TrailingWhitespace:\n  Enabled: true\n",
+        )
+        .unwrap();
+        fs::write(
+            nested.join(".rubocop.yml"),
+            "inherit_from: ../.rubocop.yml\nLayout/TrailingWhitespace:\n  Enabled: false\n",
+        )
+        .unwrap();
+
+        let root = Config::load(None, directory.path()).unwrap();
+        let store = ConfigStore::new(root, true, false);
+        let root_config = store.for_path(&directory.path().join("root.rb")).unwrap();
+        let nested_config = store.for_path(&nested.join("nested.rb")).unwrap();
+
+        assert!(root_config.rule_enabled("Layout/TrailingWhitespace"));
+        assert!(!nested_config.rule_enabled("Layout/TrailingWhitespace"));
+        assert_eq!(
+            nested_config.config_path(),
+            Some(
+                nested
+                    .join(".rubocop.yml")
+                    .canonicalize()
+                    .unwrap()
+                    .as_path()
+            )
+        );
+    }
+}

data/src/cop_name.rs

@@ -0,0 +1,71 @@
+//! How a cop's qualified name decomposes, and when a user-supplied selector names it.
+//!
+//! RuboCop settles both questions in `Cop::Badge` and `Cop::Registry`. Keeping them in one place
+//! here is what stops `--only`, `# rubocop:disable`, configuration inheritance and `--show-cops`
+//! from disagreeing about a nested cop such as `Chef/Correctness/ServiceResource`.
+
+/// Everything before the last `/`, or the whole name when it has none.
+///
+/// `Badge#initialize` joins every segment but the last, so the department of
+/// `Chef/Correctness/ServiceResource` is `Chef/Correctness` rather than `Chef`.
+pub fn department(cop_name: &str) -> &str {
+    cop_name
+        .rsplit_once('/')
+        .map_or(cop_name, |(department, _)| department)
+}
+
+/// The cop's department and every namespace enclosing it, the department itself first.
+///
+/// Only plugin ownership widens like this: a gem that declares `I18n` also ships the nested
+/// `I18n/GetText` department. Selectors and configuration lookups must keep using [`department`],
+/// which stops at the one department the cop actually belongs to.
+pub fn department_ancestors(cop_name: &str) -> impl Iterator<Item = &str> {
+    let department = department(cop_name);
+    std::iter::once(department).chain(
+        department
+            .match_indices('/')
+            .map(move |(offset, _)| &department[..offset]),
+    )
+}
+
+/// Whether a selector the user wrote -- in `--only`, `--except`, or a `rubocop:disable` comment --
+/// names this cop.
+///
+/// `Badge#match_name?` compares the qualified name and the department, both in full, so an outer
+/// namespace does not reach a nested cop: `Chef` leaves `Chef/Correctness/ServiceResource` alone
+/// and only `Chef/Correctness` selects it.
+pub fn selector_matches(selector: &str, cop_name: &str) -> bool {
+    selector == cop_name || selector == department(cop_name)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{department, selector_matches};
+
+    #[test]
+    fn department_is_every_segment_but_the_last() {
+        assert_eq!(department("Layout/LineLength"), "Layout");
+        assert_eq!(
+            department("Chef/Correctness/ServiceResource"),
+            "Chef/Correctness"
+        );
+        assert_eq!(department("Syntax"), "Syntax");
+    }
+
+    #[test]
+    fn a_selector_names_a_cop_by_full_name_or_whole_department() {
+        assert!(selector_matches("Layout/LineLength", "Layout/LineLength"));
+        assert!(selector_matches("Layout", "Layout/LineLength"));
+        assert!(!selector_matches("Lay", "Layout/LineLength"));
+        assert!(!selector_matches("Layout/Line", "Layout/LineLength"));
+    }
+
+    /// An outer namespace is not a department of its own, so it selects nothing below it.
+    #[test]
+    fn an_outer_namespace_does_not_select_a_nested_cop() {
+        let cop = "Chef/Correctness/ServiceResource";
+        assert!(selector_matches("Chef/Correctness", cop));
+        assert!(!selector_matches("Chef", cop));
+        assert!(selector_matches(cop, cop));
+    }
+}

data/src/diagnostic.rs

@@ -0,0 +1,205 @@
+use std::fmt;
+
+use serde::Serialize;
+
+use crate::source::SourceFile;
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Severity {
+    Info,
+    Refactor,
+    Convention,
+    Warning,
+    Error,
+    Fatal,
+}
+
+impl Severity {
+    /// The canonical RuboCop name (`Severity#to_s`). Every textual rendering derives from this so
+    /// that renaming a variant cannot silently change user-visible output.
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Info => "info",
+            Self::Refactor => "refactor",
+            Self::Convention => "convention",
+            Self::Warning => "warning",
+            Self::Error => "error",
+            Self::Fatal => "fatal",
+        }
+    }
+
+    pub fn code(self) -> char {
+        match self {
+            Self::Info => 'I',
+            Self::Refactor => 'R',
+            Self::Convention => 'C',
+            Self::Warning => 'W',
+            Self::Error => 'E',
+            Self::Fatal => 'F',
+        }
+    }
+
+    pub fn parse(value: &str) -> Option<Self> {
+        match value.to_ascii_lowercase().as_str() {
+            "info" | "i" => Some(Self::Info),
+            "refactor" | "r" => Some(Self::Refactor),
+            "convention" | "c" => Some(Self::Convention),
+            "warning" | "w" => Some(Self::Warning),
+            "error" | "e" => Some(Self::Error),
+            "fatal" | "f" => Some(Self::Fatal),
+            _ => None,
+        }
+    }
+}
+
+impl fmt::Display for Severity {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str(self.as_str())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Edit {
+    pub start: usize,
+    pub end: usize,
+    pub replacement: String,
+    pub safe: bool,
+}
+
+/// Position and source line captured from the text an offense was found in. An autocorrect pass
+/// rewrites that text, so a corrected offense carried into the final report can no longer resolve
+/// its byte offsets against the report it travels with.
+#[derive(Clone, Debug)]
+pub struct OffenseSnapshot {
+    pub location: Location,
+    pub source_line: String,
+}
+
+#[derive(Clone, Debug)]
+pub struct Offense {
+    pub cop_name: &'static str,
+    pub severity: Severity,
+    pub message: String,
+    pub start: usize,
+    pub end: usize,
+    pub corrected: bool,
+    pub correctable: bool,
+    pub suppressed: bool,
+    pub justification: Option<String>,
+    pub correction: Option<Edit>,
+    pub snapshot: Option<OffenseSnapshot>,
+}
+
+impl Offense {
+    /// Cops do not call this: `RuleContext::offense` supplies the name and severity from the
+    /// registry so that a cop never names itself. It stays reachable inside the crate for the
+    /// engine's own offenses, which belong to no cop -- a file that is not valid UTF-8 never
+    /// reaches one.
+    pub(crate) fn new(
+        cop_name: &'static str,
+        severity: Severity,
+        message: impl Into<String>,
+        start: usize,
+        end: usize,
+    ) -> Self {
+        Self {
+            cop_name,
+            severity,
+            message: message.into(),
+            start,
+            end: end.max(start),
+            corrected: false,
+            correctable: false,
+            suppressed: false,
+            justification: None,
+            correction: None,
+            snapshot: None,
+        }
+    }
+
+    pub fn corrected_by(mut self, edit: Edit) -> Self {
+        self.correctable = true;
+        self.correction = Some(edit);
+        self
+    }
+
+    /// RuboCop derives `correctable?` from the offense status, so an offense a directive comment
+    /// suppressed is never correctable however the cop flagged it. Every count, filter and exit
+    /// code decision goes through here rather than reading the raw flag.
+    pub fn is_correctable(&self) -> bool {
+        self.correctable && !self.suppressed
+    }
+
+    /// Freeze the position and source line so the offense keeps reporting against the text it was
+    /// found in once autocorrect replaces that text.
+    pub fn freeze_location(&mut self, source: &SourceFile) {
+        if self.snapshot.is_some() {
+            return;
+        }
+        let location = self.location(source);
+        self.snapshot = Some(OffenseSnapshot {
+            location,
+            source_line: source.line(location.line).to_owned(),
+        });
+    }
+
+    /// Where the offense starts. Ordering and identity only ever need this, and resolving it alone
+    /// avoids touching the end of the range, which callers may not have placed on a char boundary.
+    pub fn start_position(&self, source: &SourceFile) -> (usize, usize) {
+        match &self.snapshot {
+            Some(snapshot) => (snapshot.location.line, snapshot.location.column),
+            None => source.line_column(self.start),
+        }
+    }
+
+    /// The source line the offense points at, taken from the frozen snapshot when the report's own
+    /// text has since been rewritten.
+    pub fn source_line<'a>(&'a self, source: &'a SourceFile) -> &'a str {
+        match &self.snapshot {
+            Some(snapshot) => &snapshot.source_line,
+            None => source.line(self.location(source).line),
+        }
+    }
+
+    pub fn location(&self, source: &SourceFile) -> Location {
+        if let Some(snapshot) = &self.snapshot {
+            return snapshot.location;
+        }
+        let (start_line, start_column) = source.line_column(self.start);
+        // Stepping back one byte from the exclusive end can land inside a multibyte character,
+        // which `line_column` cannot slice at; walk back to the character that byte belongs to.
+        let mut inclusive_end = self.end.saturating_sub(1).max(self.start);
+        while inclusive_end > self.start && !source.text().is_char_boundary(inclusive_end) {
+            inclusive_end -= 1;
+        }
+        let (last_line, last_column) = source.line_column(inclusive_end);
+        Location {
+            start_line,
+            start_column,
+            last_line,
+            last_column,
+            length: self.end.saturating_sub(self.start),
+            line: start_line,
+            column: start_column,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Serialize)]
+pub struct Location {
+    pub start_line: usize,
+    pub start_column: usize,
+    pub last_line: usize,
+    pub last_column: usize,
+    pub length: usize,
+    pub line: usize,
+    pub column: usize,
+}
+
+#[derive(Clone, Debug)]
+pub struct FileReport {
+    pub path: std::path::PathBuf,
+    pub source: SourceFile,
+    pub offenses: Vec<Offense>,
+}