sonicop 26.8.101

data/src/lib.rs

@@ -0,0 +1,42 @@
+//! The modules left public are the ones an embedder -- today, the integration tests -- drives the
+//! linter through: load a [`config::Config`], inspect with [`engine`], read [`diagnostic`] types
+//! back. Everything else is an implementation detail, kept private so that the cop registry and
+//! the output layer stay free to change.
+
+mod cli;
+pub mod config;
+pub mod cop_name;
+pub mod diagnostic;
+mod directives;
+pub mod engine;
+mod formatter;
+mod ruby_version;
+pub mod rules;
+pub mod source;
+
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+/// Full RuboCop release Sonicop mirrors; the JSON metadata reports this verbatim.
+pub const RUBOCOP_COMPAT_FULL_VERSION: &str = "1.89.0";
+/// `MAJOR.MINOR` form used where RuboCop itself omits the patch level (docs URLs, `-V`). Spelled
+/// out rather than sliced from the full version because `&str` slicing is not const at this
+/// crate's MSRV; the test below is what keeps the two from drifting apart.
+pub const RUBOCOP_COMPAT_VERSION: &str = "1.89";
+
+pub use cli::run;
+/// Re-exported because [`config::Config::target_ruby_version`] hands it out.
+pub use ruby_version::RubyVersion;
+
+#[cfg(test)]
+mod tests {
+    use super::{RUBOCOP_COMPAT_FULL_VERSION, RUBOCOP_COMPAT_VERSION};
+
+    #[test]
+    fn both_compat_versions_name_the_same_release() {
+        assert_eq!(
+            RUBOCOP_COMPAT_FULL_VERSION
+                .rsplit_once('.')
+                .map(|(short, _)| short),
+            Some(RUBOCOP_COMPAT_VERSION)
+        );
+    }
+}

data/src/main.rs

@@ -0,0 +1,3 @@
+fn main() {
+    std::process::exit(sonicop::run());
+}

data/src/ruby_version.rs

@@ -0,0 +1,393 @@
+use std::fmt;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::LazyLock;
+
+use anyhow::{Context, Result, bail};
+use regex::Regex;
+use tree_sitter::{Node, Parser};
+
+const KNOWN_RUBIES: &[RubyVersion] = &[
+    RubyVersion::new(2, 0),
+    RubyVersion::new(2, 1),
+    RubyVersion::new(2, 2),
+    RubyVersion::new(2, 3),
+    RubyVersion::new(2, 4),
+    RubyVersion::new(2, 5),
+    RubyVersion::new(2, 6),
+    RubyVersion::new(2, 7),
+    RubyVersion::new(3, 0),
+    RubyVersion::new(3, 1),
+    RubyVersion::new(3, 2),
+    RubyVersion::new(3, 3),
+    RubyVersion::new(3, 4),
+    RubyVersion::new(4, 0),
+    RubyVersion::new(4, 1),
+];
+
+const DEFAULT_TARGET_RUBY: RubyVersion = RubyVersion::new(2, 7);
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct RubyVersion {
+    major: u16,
+    minor: u16,
+}
+
+impl RubyVersion {
+    pub const fn new(major: u16, minor: u16) -> Self {
+        Self { major, minor }
+    }
+
+    pub fn parse(value: &str) -> Option<Self> {
+        let mut parts = value.trim().trim_start_matches("ruby-").split('.');
+        let major = parts.next()?.parse().ok()?;
+        let minor = parts.next()?.parse().ok()?;
+        Some(Self::new(major, minor))
+    }
+}
+
+impl fmt::Display for RubyVersion {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(formatter, "{}.{}", self.major, self.minor)
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) enum TargetRubySource {
+    Environment,
+    Configuration,
+    Gemspec(PathBuf),
+    RubyVersionFile(PathBuf),
+    MiseToml(PathBuf),
+    ToolVersions(PathBuf),
+    BundlerLock(PathBuf),
+    Default,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct ResolvedTargetRuby {
+    pub(crate) version: RubyVersion,
+    pub(crate) source: TargetRubySource,
+}
+
+pub(crate) fn resolve_target_ruby(
+    configured: Option<RubyVersion>,
+    base_directory: &Path,
+) -> Result<ResolvedTargetRuby> {
+    if let Some(value) = std::env::var_os("RUBOCOP_TARGET_RUBY_VERSION") {
+        let value = value
+            .into_string()
+            .map_err(|_| anyhow::anyhow!("RUBOCOP_TARGET_RUBY_VERSION is not valid UTF-8"))?;
+        let version = RubyVersion::parse(&value)
+            .with_context(|| format!("invalid RUBOCOP_TARGET_RUBY_VERSION: {value}"))?;
+        return Ok(ResolvedTargetRuby {
+            version,
+            source: TargetRubySource::Environment,
+        });
+    }
+    if let Some(version) = configured {
+        return Ok(ResolvedTargetRuby {
+            version,
+            source: TargetRubySource::Configuration,
+        });
+    }
+    if let Some(path) = find_single_gemspec(base_directory)
+        && let Some(version) = target_from_gemspec(&path)?
+    {
+        return Ok(ResolvedTargetRuby {
+            version,
+            source: TargetRubySource::Gemspec(path),
+        });
+    }
+    if let Some(path) = find_upwards(base_directory, ".ruby-version")
+        && let Some(version) = version_file_value(&path, None)?
+    {
+        return Ok(ResolvedTargetRuby {
+            version,
+            source: TargetRubySource::RubyVersionFile(path),
+        });
+    }
+    if let Some(path) = find_upwards(base_directory, "mise.toml")
+        && let Some(version) = version_file_value(&path, Some("ruby ="))?
+    {
+        return Ok(ResolvedTargetRuby {
+            version,
+            source: TargetRubySource::MiseToml(path),
+        });
+    }
+    if let Some(path) = find_upwards(base_directory, ".tool-versions")
+        && let Some(version) = version_file_value(&path, Some("ruby "))?
+    {
+        return Ok(ResolvedTargetRuby {
+            version,
+            source: TargetRubySource::ToolVersions(path),
+        });
+    }
+    for filename in ["Gemfile.lock", "gems.locked"] {
+        if let Some(path) = find_upwards(base_directory, filename)
+            && let Some(version) = target_from_lockfile(&path)?
+        {
+            return Ok(ResolvedTargetRuby {
+                version,
+                source: TargetRubySource::BundlerLock(path),
+            });
+        }
+    }
+    Ok(ResolvedTargetRuby {
+        version: DEFAULT_TARGET_RUBY,
+        source: TargetRubySource::Default,
+    })
+}
+
+fn find_upwards(start: &Path, filename: &str) -> Option<PathBuf> {
+    start.ancestors().find_map(|directory| {
+        let candidate = directory.join(filename);
+        candidate.is_file().then_some(candidate)
+    })
+}
+
+fn find_single_gemspec(start: &Path) -> Option<PathBuf> {
+    for directory in start.ancestors() {
+        // An unreadable ancestor must not abort the walk: a gemspec may still live above it.
+        let Ok(entries) = fs::read_dir(directory) else {
+            continue;
+        };
+        let mut candidates = entries
+            .filter_map(Result::ok)
+            .map(|entry| entry.path())
+            .filter(|path| {
+                path.extension()
+                    .is_some_and(|extension| extension == "gemspec")
+            });
+        let first = candidates.next();
+        if first.is_some() && candidates.next().is_none() {
+            return first;
+        }
+    }
+    None
+}
+
+fn target_from_gemspec(path: &Path) -> Result<Option<RubyVersion>> {
+    let source = fs::read_to_string(path)
+        .with_context(|| format!("failed to read {} as UTF-8", path.display()))?;
+    let mut parser = Parser::new();
+    parser
+        .set_language(&tree_sitter_ruby::LANGUAGE.into())
+        .context("failed to initialize the Ruby parser")?;
+    let tree = parser
+        .parse(&source, None)
+        .context("Ruby parser returned no syntax tree for gemspec")?;
+    if tree.root_node().has_error() {
+        return Ok(None);
+    }
+
+    let Some(value) = required_ruby_version_value(tree.root_node(), &source) else {
+        return Ok(None);
+    };
+    let Some(requirements) = literal_requirements(value, &source) else {
+        return Ok(None);
+    };
+    let parsed = requirements
+        .iter()
+        .map(|requirement| Requirement::parse(requirement))
+        .collect::<Option<Vec<_>>>();
+    Ok(parsed.and_then(|requirements| {
+        KNOWN_RUBIES.iter().copied().find(|version| {
+            requirements
+                .iter()
+                .all(|requirement| requirement.matches(*version))
+        })
+    }))
+}
+
+fn required_ruby_version_value<'tree>(node: Node<'tree>, source: &str) -> Option<Node<'tree>> {
+    if node.kind() == "assignment"
+        && let Some(left) = node.child_by_field_name("left")
+        && left.kind() == "call"
+        && let Some(method) = left.child_by_field_name("method")
+        && &source[method.byte_range()] == "required_ruby_version"
+    {
+        return node.child_by_field_name("right");
+    }
+    let mut cursor = node.walk();
+    node.named_children(&mut cursor)
+        .find_map(|child| required_ruby_version_value(child, source))
+}
+
+fn literal_requirements(node: Node<'_>, source: &str) -> Option<Vec<String>> {
+    if contains_kind(node, "interpolation") {
+        return None;
+    }
+    let mut strings = Vec::new();
+    collect_string_literals(node, source, &mut strings);
+    (!strings.is_empty()).then_some(strings)
+}
+
+fn collect_string_literals(node: Node<'_>, source: &str, strings: &mut Vec<String>) {
+    if node.kind() == "string" {
+        let mut cursor = node.walk();
+        let contents = node
+            .named_children(&mut cursor)
+            .filter(|child| child.kind() == "string_content")
+            .map(|child| &source[child.byte_range()])
+            .collect::<String>();
+        strings.push(contents);
+        return;
+    }
+    let mut cursor = node.walk();
+    for child in node.named_children(&mut cursor) {
+        collect_string_literals(child, source, strings);
+    }
+}
+
+fn contains_kind(node: Node<'_>, kind: &str) -> bool {
+    if node.kind() == kind {
+        return true;
+    }
+    let mut cursor = node.walk();
+    node.named_children(&mut cursor)
+        .any(|child| contains_kind(child, kind))
+}
+
+#[derive(Clone, Copy, Debug)]
+enum RequirementOperator {
+    Equal,
+    Greater,
+    GreaterOrEqual,
+    Less,
+    LessOrEqual,
+    Pessimistic,
+}
+
+#[derive(Clone, Debug)]
+struct Requirement {
+    operator: RequirementOperator,
+    version: Vec<u16>,
+}
+
+static REQUIREMENT_PATTERN: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"^\s*(~>|>=|<=|>|<|=)?\s*(\d+(?:\.\d+){0,2})\s*$")
+        .expect("the requirement pattern is a valid constant regex")
+});
+
+impl Requirement {
+    fn parse(value: &str) -> Option<Self> {
+        let captures = REQUIREMENT_PATTERN.captures(value)?;
+        let operator = match captures.get(1).map(|capture| capture.as_str()) {
+            Some("~>") => RequirementOperator::Pessimistic,
+            Some(">=") => RequirementOperator::GreaterOrEqual,
+            Some("<=") => RequirementOperator::LessOrEqual,
+            Some(">") => RequirementOperator::Greater,
+            Some("<") => RequirementOperator::Less,
+            Some("=") | None => RequirementOperator::Equal,
+            Some(_) => return None,
+        };
+        let version = captures[2]
+            .split('.')
+            .map(str::parse)
+            .collect::<std::result::Result<Vec<_>, _>>()
+            .ok()?;
+        Some(Self { operator, version })
+    }
+
+    fn matches(&self, candidate: RubyVersion) -> bool {
+        let candidate = [candidate.major, candidate.minor, 99];
+        let required = [
+            self.version[0],
+            self.version.get(1).copied().unwrap_or(0),
+            self.version.get(2).copied().unwrap_or(0),
+        ];
+        match self.operator {
+            RequirementOperator::Equal => candidate == required,
+            RequirementOperator::Greater => candidate > required,
+            RequirementOperator::GreaterOrEqual => candidate >= required,
+            RequirementOperator::Less => candidate < required,
+            RequirementOperator::LessOrEqual => candidate <= required,
+            RequirementOperator::Pessimistic => {
+                let upper = if self.version.len() <= 2 {
+                    [required[0] + 1, 0, 0]
+                } else {
+                    [required[0], required[1] + 1, 0]
+                };
+                candidate >= required && candidate < upper
+            }
+        }
+    }
+}
+
+fn version_file_value(path: &Path, prefix: Option<&str>) -> Result<Option<RubyVersion>> {
+    let source = fs::read_to_string(path)
+        .with_context(|| format!("failed to read {} as UTF-8", path.display()))?;
+    let value = match prefix {
+        None => source.lines().next().map(str::trim),
+        Some(prefix) => source.lines().find_map(|line| {
+            let line = line.trim();
+            line.strip_prefix(prefix).map(|value| {
+                value
+                    .trim()
+                    .trim_matches(|character| matches!(character, '\'' | '"'))
+            })
+        }),
+    };
+    Ok(value.and_then(RubyVersion::parse))
+}
+
+fn target_from_lockfile(path: &Path) -> Result<Option<RubyVersion>> {
+    let source = fs::read_to_string(path)
+        .with_context(|| format!("failed to read {} as UTF-8", path.display()))?;
+    let mut in_ruby_version = false;
+    for line in source.lines() {
+        if line.trim() == "RUBY VERSION" {
+            in_ruby_version = true;
+            continue;
+        }
+        if in_ruby_version {
+            let value = line.trim().strip_prefix("ruby ");
+            return Ok(value.and_then(RubyVersion::parse));
+        }
+    }
+    Ok(None)
+}
+
+pub(crate) fn validate_supported(version: RubyVersion) -> Result<()> {
+    if KNOWN_RUBIES.contains(&version) {
+        Ok(())
+    } else {
+        bail!("unsupported TargetRubyVersion: {version}")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::fs;
+
+    use tempfile::tempdir;
+
+    use super::{RubyVersion, TargetRubySource, resolve_target_ruby};
+
+    #[test]
+    fn resolves_minimum_known_version_from_gemspec_requirements() {
+        let directory = tempdir().unwrap();
+        fs::write(
+            directory.path().join("example.gemspec"),
+            "Gem::Specification.new do |spec|\n  spec.required_ruby_version = Gem::Requirement.new(['>= 2.6.0', '< 4.0'])\nend\n",
+        )
+        .unwrap();
+
+        let resolved = resolve_target_ruby(None, directory.path()).unwrap();
+
+        assert_eq!(resolved.version, RubyVersion::new(2, 6));
+        assert!(matches!(resolved.source, TargetRubySource::Gemspec(_)));
+    }
+
+    #[test]
+    fn explicit_configuration_precedes_project_files() {
+        let directory = tempdir().unwrap();
+        fs::write(directory.path().join(".ruby-version"), "2.6.10\n").unwrap();
+
+        let resolved = resolve_target_ruby(Some(RubyVersion::new(3, 3)), directory.path()).unwrap();
+
+        assert_eq!(resolved.version, RubyVersion::new(3, 3));
+        assert_eq!(resolved.source, TargetRubySource::Configuration);
+    }
+}

data/src/rules/layout/empty_line_after_magic_comment.rs

@@ -0,0 +1,49 @@
+use crate::diagnostic::{Edit, Offense};
+use crate::rules::RuleContext;
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let mut last_magic = None;
+    for line_number in 1..=context.source.line_count().min(4) {
+        let line = context.source.line(line_number).trim();
+        if line_number == 1 && line.starts_with("#!") {
+            continue;
+        }
+        if is_magic_comment(line) {
+            last_magic = Some(line_number);
+            continue;
+        }
+        if line.is_empty() {
+            continue;
+        }
+        break;
+    }
+    let Some(line_number) = last_magic else {
+        return;
+    };
+    let next = line_number + 1;
+    if next > context.source.line_count() || context.source.line(next).trim().is_empty() {
+        return;
+    }
+    let insertion = context.source.line_start(next);
+    offenses.push(
+        context
+            .offense(
+                "Add an empty line after magic comments.",
+                insertion..insertion,
+            )
+            .corrected_by(Edit {
+                start: insertion,
+                end: insertion,
+                replacement: "\n".to_owned(),
+                safe: true,
+            }),
+    );
+}
+
+fn is_magic_comment(line: &str) -> bool {
+    let lower = line.to_ascii_lowercase();
+    lower.starts_with("# frozen_string_literal:")
+        || lower.starts_with("# encoding:")
+        || lower.starts_with("# coding:")
+        || (lower.starts_with("# -") && lower.contains("coding:"))
+}

data/src/rules/layout/end_of_line.rs

@@ -0,0 +1,35 @@
+use crate::diagnostic::Offense;
+use crate::rules::RuleContext;
+
+/// Reports only, like RuboCop: this cop has no autocorrector upstream.
+///
+/// Rewriting line endings here would fight `Layout/TrailingEmptyLines`, which normalizes the end
+/// of the file to `\n`. On Windows, where `native` means CRLF, the two would undo each other on
+/// every pass and autocorrect would never settle.
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let style: String = context
+        .setting("EnforcedStyle")
+        .unwrap_or_else(|| "native".to_owned());
+    let crlf_expected = style == "crlf" || (style == "native" && cfg!(windows));
+    let bytes = context.source.text().as_bytes();
+    for (index, byte) in bytes.iter().enumerate() {
+        if *byte != b'\n' {
+            continue;
+        }
+        let has_cr = index > 0 && bytes[index - 1] == b'\r';
+        if has_cr == crlf_expected {
+            continue;
+        }
+        let (start, end) = if crlf_expected {
+            (index, index)
+        } else {
+            (index - 1, index + 1)
+        };
+        let message = if crlf_expected {
+            "Carriage return character missing."
+        } else {
+            "Carriage return character detected."
+        };
+        offenses.push(context.offense(message, start..end));
+    }
+}

data/src/rules/layout/line_length.rs

@@ -0,0 +1,167 @@
+use std::collections::{HashMap, HashSet};
+use std::sync::LazyLock;
+
+use regex::Regex;
+use tree_sitter::Node;
+use unicode_width::UnicodeWidthStr;
+
+use crate::diagnostic::{Edit, Offense};
+use crate::rules::RuleContext;
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let max: usize = context.setting("Max").unwrap_or(120);
+    let allow_uri: bool = context.setting("AllowURI").unwrap_or(true);
+    let allow_directives: bool = context.setting("AllowCopDirectives").unwrap_or(true);
+    let allow_qualified_name: bool = context.setting("AllowQualifiedName").unwrap_or(true);
+    let break_edits = line_break_edits(context, max);
+    for line_number in 1..=context.source.line_count() {
+        let raw = context.source.line(line_number);
+        let line = raw.trim_end_matches(['\r', '\n']);
+        let width = UnicodeWidthStr::width(line);
+        let line_start = context.source.line_start(line_number);
+        let line_range = line_start..line_start + line.len();
+        if width <= max
+            || context.in_heredoc(line_range)
+            || (allow_uri && (line.contains("http://") || line.contains("https://")))
+            || (allow_qualified_name && qualified_name_exempts_line(line, max))
+            || (allow_directives && line.contains("rubocop:"))
+        {
+            continue;
+        }
+        let start = line_start
+            + line
+                .char_indices()
+                .nth(max)
+                .map_or(line.len(), |(index, _)| index);
+        let offense = context.offense(
+            format!("Line is too long. [{width}/{max}]"),
+            start..line_start + line.len(),
+        );
+        offenses.push(match break_edits.get(&line_number) {
+            Some(edit) => offense.corrected_by(edit.clone()),
+            None => offense,
+        });
+    }
+}
+
+fn qualified_name_exempts_line(line: &str, max: usize) -> bool {
+    static QUALIFIED_NAME: LazyLock<Regex> = LazyLock::new(|| {
+        Regex::new(r"\b(?:[A-Z][A-Za-z0-9_]*::)+[A-Za-z_][A-Za-z0-9_]*\b").unwrap()
+    });
+    let Some(name) = QUALIFIED_NAME.find_iter(line).last() else {
+        return false;
+    };
+    let start = line[..name.start()].chars().count();
+    if start >= max {
+        return false;
+    }
+
+    let suffix = &line[name.end()..];
+    suffix.chars().all(|character| !character.is_whitespace())
+        || (line.contains('{') && line.ends_with('}'))
+}
+
+fn line_break_edits(context: &RuleContext<'_>, max: usize) -> HashMap<usize, Edit> {
+    let comments: HashSet<usize> = context
+        .nodes_of("comment")
+        .map(|node| node.start_position().row + 1)
+        .collect();
+    let mut edits = HashMap::new();
+
+    // RuboCop gives a single-line block precedence over the call that owns it.
+    // Breaking immediately after `{` / `do` is syntax preserving even when the
+    // line has a trailing comment.
+    for node in context
+        .nodes_of_any(&["block", "do_block"])
+        .filter(|node| node.start_position().row == node.end_position().row)
+    {
+        let start = node
+            .child_by_field_name("parameters")
+            .map_or_else(
+                || node.start_byte() + if node.kind() == "block" { 1 } else { 2 },
+                |parameters| parameters.end_byte(),
+            )
+            .min(node.end_byte());
+        edits.entry(node.start_position().row + 1).or_insert(Edit {
+            start,
+            end: start,
+            replacement: "\n".to_owned(),
+            safe: true,
+        });
+    }
+
+    for node in context
+        .nodes_of_any(&["call", "array", "hash", "method", "singleton_method"])
+        .filter(|node| breakable_collection_on_one_line(*node))
+    {
+        let line_number = node.start_position().row + 1;
+        if edits.contains_key(&line_number) || comments.contains(&line_number) {
+            continue;
+        }
+
+        let Some(mut elements) = breakable_elements(node, context) else {
+            continue;
+        };
+        if elements.len() < 2 {
+            continue;
+        }
+
+        if node.kind() == "call" && !call_parenthesized(node, context) {
+            elements.remove(0);
+        }
+        let Some(element) = elements
+            .iter()
+            .position(|element| element.start_position().column > max)
+            .map_or_else(
+                || elements.last().copied(),
+                |index| elements.get(index.saturating_sub(1)).copied(),
+            )
+        else {
+            continue;
+        };
+        let start = element.start_byte();
+        edits.insert(
+            line_number,
+            Edit {
+                start,
+                end: start,
+                replacement: "\n".to_owned(),
+                safe: true,
+            },
+        );
+    }
+
+    edits
+}
+
+fn breakable_collection_on_one_line(node: Node<'_>) -> bool {
+    if node.kind() == "call" {
+        return node
+            .child_by_field_name("arguments")
+            .is_some_and(|arguments| {
+                node.start_position().row == arguments.start_position().row
+                    && arguments.start_position().row == arguments.end_position().row
+            });
+    }
+    node.start_position().row == node.end_position().row
+}
+
+fn breakable_elements<'tree>(
+    node: Node<'tree>,
+    context: &RuleContext<'_>,
+) -> Option<Vec<Node<'tree>>> {
+    let container = match node.kind() {
+        "call" => node.child_by_field_name("arguments")?,
+        "method" | "singleton_method" => node.child_by_field_name("parameters")?,
+        "array" => node,
+        "hash" if context.source.node_text(node).starts_with('{') => node,
+        _ => return None,
+    };
+    let mut cursor = container.walk();
+    Some(container.named_children(&mut cursor).collect())
+}
+
+fn call_parenthesized(node: Node<'_>, context: &RuleContext<'_>) -> bool {
+    node.child_by_field_name("arguments")
+        .is_some_and(|arguments| context.source.node_text(arguments).starts_with('('))
+}