Merge pull request #529 from Automattic/ignore-lints

Ignore Lints

Author: elijah-potter

harper-core/src/document.rs

@@ -25,6 +25,16 @@ impl Default for Document {
 }
 
 impl Document {
+    /// Locate all the tokens that intersect a provided span.
+    ///
+    /// Desperately needs optimization.
+    pub fn token_indices_intersecting(&self, span: Span) -> Vec<usize> {
+        self.tokens()
+            .enumerate()
+            .filter_map(|(idx, tok)| tok.span.overlaps_with(span).then_some(idx))
+            .collect()
+    }
+
     /// Lexes and parses text to produce a document using a provided language
     /// parser and dictionary.
     pub fn new(text: &str, parser: &impl Parser, dictionary: &impl Dictionary) -> Self {

harper-core/src/fat_token.rs

@@ -4,7 +4,7 @@ use crate::TokenKind;
 
 /// A [`Token`](crate::Token) that holds its content as a fat [`Vec<char>`] rather than as a
 /// [`Span`](crate::Span).
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, PartialOrd, Hash)]
 pub struct FatToken {
     pub content: Vec<char>,
     pub kind: TokenKind,

harper-core/src/ignored_lints/lint_context.rs

@@ -0,0 +1,54 @@
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    linting::{Lint, LintKind, Suggestion},
+    Document, FatToken,
+};
+
+/// A location-agnostic structure that attempts to captures the context and content that a [`Lint`]
+/// occurred.
+#[derive(Debug, Hash, Serialize, Deserialize)]
+pub struct LintContext {
+    pub lint_kind: LintKind,
+    pub suggestions: Vec<Suggestion>,
+    pub message: String,
+    pub priority: u8,
+    pub tokens: Vec<FatToken>,
+}
+
+impl LintContext {
+    pub fn from_lint(lint: &Lint, document: &Document) -> Self {
+        let Lint {
+            lint_kind,
+            suggestions,
+            message,
+            priority,
+            ..
+        } = lint.clone();
+
+        let problem_tokens = document.token_indices_intersecting(lint.span);
+        let prequel_tokens = lint
+            .span
+            .with_len(2)
+            .pulled_by(2)
+            .map(|v| document.token_indices_intersecting(v))
+            .unwrap_or_default();
+        let sequel_tokens = document.token_indices_intersecting(lint.span.with_len(2).pushed_by(2));
+
+        let tokens = prequel_tokens
+            .into_iter()
+            .chain(problem_tokens)
+            .chain(sequel_tokens)
+            .flat_map(|idx| document.get_token(idx))
+            .map(|t| t.to_fat(document.get_source()))
+            .collect();
+
+        Self {
+            lint_kind,
+            suggestions,
+            message,
+            priority,
+            tokens,
+        }
+    }
+}

harper-core/src/ignored_lints/mod.rs

@@ -0,0 +1,139 @@
+mod lint_context;
+
+use std::hash::{DefaultHasher, Hash, Hasher};
+
+use hashbrown::HashSet;
+use lint_context::LintContext;
+use serde::{Deserialize, Serialize};
+
+use crate::{linting::Lint, Document};
+
+/// A structure that keeps track of lints that have been ignored by users.
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct IgnoredLints {
+    context_hashes: HashSet<u64>,
+}
+
+impl IgnoredLints {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Move entries from another instance to this one.
+    pub fn append(&mut self, other: Self) {
+        self.context_hashes.extend(other.context_hashes)
+    }
+
+    fn hash_lint_context(&self, lint: &Lint, document: &Document) -> u64 {
+        let context = LintContext::from_lint(lint, document);
+
+        let mut hasher = DefaultHasher::default();
+        context.hash(&mut hasher);
+
+        hasher.finish()
+    }
+
+    /// Add a lint to the list.
+    pub fn ignore_lint(&mut self, lint: &Lint, document: &Document) {
+        let context_hash = self.hash_lint_context(lint, document);
+
+        self.context_hashes.insert(context_hash);
+    }
+
+    pub fn is_ignored(&self, lint: &Lint, document: &Document) -> bool {
+        let hash = self.hash_lint_context(lint, document);
+
+        self.context_hashes.contains(&hash)
+    }
+
+    /// Remove ignored Lints from a [`Vec`].
+    pub fn remove_ignored(&self, lints: &mut Vec<Lint>, document: &Document) {
+        lints.retain(|lint| !self.is_ignored(lint, document));
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use quickcheck::TestResult;
+    use quickcheck_macros::quickcheck;
+
+    use super::IgnoredLints;
+    use crate::{
+        linting::{LintGroup, LintGroupConfig, Linter},
+        Document, FstDictionary,
+    };
+
+    #[quickcheck]
+    fn can_ignore_all(text: String) -> bool {
+        let document = Document::new_markdown_default_curated(&text);
+
+        let mut lints =
+            LintGroup::new(LintGroupConfig::default(), FstDictionary::curated()).lint(&document);
+
+        let mut ignored = IgnoredLints::new();
+
+        for lint in &lints {
+            ignored.ignore_lint(lint, &document);
+        }
+
+        ignored.remove_ignored(&mut lints, &document);
+        lints.is_empty()
+    }
+
+    #[quickcheck]
+    fn can_ignore_first(text: String) -> TestResult {
+        let document = Document::new_markdown_default_curated(&text);
+
+        let mut lints =
+            LintGroup::new(LintGroupConfig::default(), FstDictionary::curated()).lint(&document);
+
+        let Some(first) = lints.first().cloned() else {
+            return TestResult::discard();
+        };
+
+        let mut ignored = IgnoredLints::new();
+        ignored.ignore_lint(&first, &document);
+
+        ignored.remove_ignored(&mut lints, &document);
+
+        TestResult::from_bool(!lints.contains(&first))
+    }
+
+    // Check that ignoring the nth lint found in source text actually removes it (and no others).
+    fn assert_ignore_lint_reduction(source: &str, nth_lint: usize) {
+        let document = Document::new_markdown_default_curated(&source);
+
+        let mut lints =
+            LintGroup::new(LintGroupConfig::default(), FstDictionary::curated()).lint(&document);
+
+        let nth = lints.get(nth_lint).cloned().unwrap_or_else(|| {
+            panic!("If ignoring the lint at {nth_lint}, make sure there are enough problems.")
+        });
+
+        let mut ignored = IgnoredLints::new();
+        ignored.ignore_lint(&nth, &document);
+
+        let prev_count = lints.len();
+
+        ignored.remove_ignored(&mut lints, &document);
+
+        assert_eq!(prev_count, lints.len() + 1);
+        assert!(!lints.contains(&nth));
+    }
+
+    #[test]
+    fn an_a() {
+        let source = "There is an problem in this text. Here is an second one.";
+
+        assert_ignore_lint_reduction(source, 0);
+        assert_ignore_lint_reduction(source, 1);
+    }
+
+    #[test]
+    fn spelling() {
+        let source = "There is a problm in this text. Here is a scond one.";
+
+        assert_ignore_lint_reduction(source, 0);
+        assert_ignore_lint_reduction(source, 1);
+    }
+}

harper-core/src/lib.rs

@@ -6,6 +6,7 @@ mod char_string;
 mod currency;
 mod document;
 mod fat_token;
+mod ignored_lints;
 pub mod language_detection;
 mod lexing;
 pub mod linting;
@@ -28,6 +29,7 @@ pub use char_string::{CharString, CharStringExt};
 pub use currency::Currency;
 pub use document::Document;
 pub use fat_token::FatToken;
+pub use ignored_lints::IgnoredLints;
 use linting::Lint;
 pub use mask::{Mask, Masker};
 pub use punctuation::{Punctuation, Quote};

harper-core/src/linting/correct_number_suffix.rs

@@ -11,7 +11,9 @@ impl Linter for CorrectNumberSuffix {
         let mut output = Vec::new();
 
         for number_tok in document.iter_numbers() {
-            let suffix_span = Span::new_with_len(number_tok.span.end, 2).pulled_by(2);
+            let Some(suffix_span) = Span::new_with_len(number_tok.span.end, 2).pulled_by(2) else {
+                continue;
+            };
 
             if let TokenKind::Number(number, Some(suffix)) = number_tok.kind {
                 if let Some(correct_suffix) = NumberSuffix::correct_suffix_for(number) {