Offline, privacy-first grammar checker. Fast, open-source, Rust-powered
feat: used pattern linter for `MultipleSequentialPronouns`
Elijah Potter9f180f6ca01f
diff --git a/harper-core/src/document.rs b/harper-core/src/document.rsindex 21739f390..6d948da55 100644--- a/harper-core/src/document.rs+++ b/harper-core/src/document.rs@@ -6,7 +6,6 @@ use itertools::Itertools;use paste::paste;use crate::parsers::{Markdown, Parser, PlainEnglish};-use crate::patterns::Pattern;use crate::punctuation::Punctuation;use crate::span::Span;use crate::token::NumberSuffix;diff --git a/harper-core/src/linting/lint_group.rs b/harper-core/src/linting/lint_group.rsindex abe9a8705..cc7bdcdb1 100644--- a/harper-core/src/linting/lint_group.rs+++ b/harper-core/src/linting/lint_group.rs@@ -15,7 +15,7 @@ use super::spell_check::SpellCheck;use super::spelled_numbers::SpelledNumbers;use super::unclosed_quotes::UnclosedQuotes;use super::wrong_quotes::WrongQuotes;-use super::{Lint, Linter, PatternLinter};+use super::{Lint, Linter};use crate::{Dictionary, Document};macro_rules! create_lint_group_config {diff --git a/harper-core/src/linting/multiple_sequential_pronouns.rs b/harper-core/src/linting/multiple_sequential_pronouns.rsindex 4efa14c22..0ca3ea728 100644--- a/harper-core/src/linting/multiple_sequential_pronouns.rs+++ b/harper-core/src/linting/multiple_sequential_pronouns.rs@@ -1,14 +1,14 @@use hashbrown::HashSet;use super::pattern_linter::PatternLinter;-use crate::linting::{LintKind, Linter};-use crate::patterns::{Pattern, TokenSequencePattern};-use crate::{CharString, Document, Lint, Lrc, Span, Token, TokenStringExt};+use crate::linting::LintKind;+use crate::patterns::{Pattern, SequencePattern};+use crate::{Lint, Lrc, Token, TokenStringExt};/// Linter that checks if multiple pronouns are being used right after each/// other. This is a common mistake to make during the revision process.pub struct MultipleSequentialPronouns {- pattern: Box<dyn Pattern + Send + Sync>+ pattern: Box<dyn Pattern>}impl MultipleSequentialPronouns {@@ -21,12 +21,16 @@ impl MultipleSequentialPronouns {let pronouns = Lrc::new(pronouns);- let mut pattern = TokenSequencePattern::default();- pattern- .then_any_word_in(pronouns.clone())+ let mut subsq_pat = SequencePattern::default();+ subsq_pat.then_whitespace().then_any_word_in(pronouns.clone());+ let mut pattern = SequencePattern::default();+ pattern+ .then_any_word_in(pronouns.clone())+ .then_one_or_more(Box::new(subsq_pat));+Self {pattern: Box::new(pattern)}diff --git a/harper-core/src/linting/pattern_linter.rs b/harper-core/src/linting/pattern_linter.rsindex 9572e9cbe..c44652d30 100644--- a/harper-core/src/linting/pattern_linter.rs+++ b/harper-core/src/linting/pattern_linter.rs@@ -2,28 +2,46 @@ use super::{Lint, Linter};use crate::patterns::Pattern;use crate::Token;+#[cfg(not(feature = "concurrent"))]pub trait PatternLinter {/// A simple getter for the pattern to be searched for.fn pattern(&self) -> &dyn Pattern;fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Lint;}+#[cfg(feature = "concurrent")]+pub trait PatternLinter: Send + Sync {+ /// A simple getter for the pattern to be searched for.+ fn pattern(&self) -> &dyn Pattern;+ fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Lint;+}+impl<L> Linter for Lwhere- L: PatternLinter + Send + Sync+ L: PatternLinter{fn lint(&mut self, document: &crate::Document) -> Vec<Lint> {let mut lints = Vec::new();let source = document.get_source();for chunk in document.chunks() {- for i in 0..chunk.len() {- let match_len = self.pattern().matches(&chunk[i..], source);+ let mut tok_cursor = 0;++ loop {+ if tok_cursor >= chunk.len() {+ break;+ }++ let match_len = self.pattern().matches(&chunk[tok_cursor..], source);if match_len != 0 {- let lint = self.match_to_lint(&chunk[i..i + match_len], source);+ let lint =+ self.match_to_lint(&chunk[tok_cursor..tok_cursor + match_len], source);lints.push(lint);+ tok_cursor += match_len;+ } else {+ tok_cursor += 1;}}}diff --git a/harper-core/src/patterns/mod.rs b/harper-core/src/patterns/mod.rsindex 94fcc2381..9cd709d97 100644--- a/harper-core/src/patterns/mod.rs+++ b/harper-core/src/patterns/mod.rs@@ -1,17 +1,25 @@use crate::Token;mod naive_pattern_group;+mod repeating_pattern;mod token_kind_pattern_group;mod token_pattern;mod token_sequence_pattern;mod word_pattern_group;pub use naive_pattern_group::NaivePatternGroup;+pub use repeating_pattern::RepeatingPattern;pub use token_kind_pattern_group::TokenKindPatternGroup;pub use token_pattern::TokenPattern;-pub use token_sequence_pattern::TokenSequencePattern;+pub use token_sequence_pattern::SequencePattern;pub use word_pattern_group::WordPatternGroup;+#[cfg(not(feature = "concurrent"))]pub trait Pattern {fn matches(&self, tokens: &[Token], source: &[char]) -> usize;}++#[cfg(feature = "concurrent")]+pub trait Pattern: Send + Sync {+ fn matches(&self, tokens: &[Token], source: &[char]) -> usize;+}diff --git a/harper-core/src/patterns/naive_pattern_group.rs b/harper-core/src/patterns/naive_pattern_group.rsindex a1be5b88c..9902aa924 100644--- a/harper-core/src/patterns/naive_pattern_group.rs+++ b/harper-core/src/patterns/naive_pattern_group.rs@@ -1,7 +1,9 @@use super::Pattern;+use crate::Token;/// A naive pattern collection that naively iterates through a list of patterns,/// returning the first one that matches..+#[derive(Default)]pub struct NaivePatternGroup {patterns: Vec<Box<dyn Pattern>>}@@ -13,7 +15,7 @@ impl NaivePatternGroup {}impl Pattern for NaivePatternGroup {- fn matches(&self, tokens: &[crate::Token], source: &[char]) -> usize {+ fn matches(&self, tokens: &[Token], source: &[char]) -> usize {self.patterns.iter().find_map(|p| {@@ -28,11 +30,3 @@ impl Pattern for NaivePatternGroup {.unwrap_or_default()}}--impl Default for NaivePatternGroup {- fn default() -> Self {- Self {- patterns: Default::default()- }- }-}diff --git a/harper-core/src/patterns/repeating_pattern.rs b/harper-core/src/patterns/repeating_pattern.rsnew file mode 100644index 000000000..3f4971b2c--- /dev/null+++ b/harper-core/src/patterns/repeating_pattern.rs@@ -0,0 +1,49 @@+use super::Pattern;+use crate::Token;++/// A pattern that will match one or more repetitions of the same pattern.+///+/// Somewhat reminiscent of the `.*` operator in Regex.+pub struct RepeatingPattern {+ inner: Box<dyn Pattern>+}++impl RepeatingPattern {+ pub fn new(pattern: Box<dyn Pattern>) -> Self {+ Self { inner: pattern }+ }+}++impl Pattern for RepeatingPattern {+ fn matches(&self, tokens: &[Token], source: &[char]) -> usize {+ let mut tok_cursor = 0;++ loop {+ let match_len = self.inner.matches(&tokens[tok_cursor..], source);++ if match_len == 0 {+ return tok_cursor;+ } else {+ tok_cursor += match_len;+ }+ }+ }+}++#[cfg(test)]+mod tests {+ use super::RepeatingPattern;+ use crate::patterns::{Pattern, TokenPattern};+ use crate::Document;++ #[test]+ fn matches_anything() {+ let doc = Document::new_plain_english_curated("This matcher will match anything!");+ let pat = RepeatingPattern::new(Box::new(TokenPattern::Any));++ assert_eq!(+ pat.matches(doc.get_tokens(), doc.get_source()),+ doc.get_tokens().len()+ )+ }+}diff --git a/harper-core/src/patterns/token_pattern.rs b/harper-core/src/patterns/token_pattern.rsindex 0cfcc15fe..1c4219532 100644--- a/harper-core/src/patterns/token_pattern.rs+++ b/harper-core/src/patterns/token_pattern.rs@@ -14,7 +14,9 @@ pub enum TokenPattern {KindStrict(TokenKind),WhiteSpace,WordExact(&'static str),- WordInSet(Lrc<HashSet<&'static str>>)+ WordInSet(Lrc<HashSet<&'static str>>),+ /// Matches any single token.+ Any}impl Pattern for TokenPattern {@@ -73,6 +75,7 @@ impl Pattern for TokenPattern {0}}+ TokenPattern::Any => 1}}}diff --git a/harper-core/src/patterns/token_sequence_pattern.rs b/harper-core/src/patterns/token_sequence_pattern.rsindex 275b588bf..e897ffa00 100644--- a/harper-core/src/patterns/token_sequence_pattern.rs+++ b/harper-core/src/patterns/token_sequence_pattern.rs@@ -1,50 +1,59 @@use hashbrown::HashSet;use super::token_pattern::TokenPattern;-use super::Pattern;+use super::{Pattern, RepeatingPattern};use crate::{Lrc, Token, TokenKind};/// A pattern that checks that a sequence of [`TokenPattern`] matches.-#[derive(Debug, Default)]-pub struct TokenSequencePattern {- token_patterns: Vec<TokenPattern>+#[derive(Default)]+pub struct SequencePattern {+ token_patterns: Vec<Box<dyn Pattern>>}-impl TokenSequencePattern {+impl SequencePattern {pub fn then_exact_word(&mut self, word: &'static str) -> &mut Self {- self.token_patterns.push(TokenPattern::WordExact(word));+ self.token_patterns+ .push(Box::new(TokenPattern::WordExact(word)));self}pub fn then_loose(&mut self, kind: TokenKind) -> &mut Self {- self.token_patterns.push(TokenPattern::KindLoose(kind));+ self.token_patterns+ .push(Box::new(TokenPattern::KindLoose(kind)));self}pub fn then_any_word(&mut self) -> &mut Self {self.token_patterns- .push(TokenPattern::KindLoose(TokenKind::blank_word()));+ .push(Box::new(TokenPattern::KindLoose(TokenKind::blank_word())));self}pub fn then_strict(&mut self, kind: TokenKind) -> &mut Self {- self.token_patterns.push(TokenPattern::KindStrict(kind));+ self.token_patterns+ .push(Box::new(TokenPattern::KindStrict(kind)));self}pub fn then_whitespace(&mut self) -> &mut Self {- self.token_patterns.push(TokenPattern::WhiteSpace);+ self.token_patterns.push(Box::new(TokenPattern::WhiteSpace));self}pub fn then_any_word_in(&mut self, word_set: Lrc<HashSet<&'static str>>) -> &mut Self {self.token_patterns- .push(TokenPattern::WordInSet(word_set.into()));+ .push(Box::new(TokenPattern::WordInSet(word_set)));+ self+ }++ pub fn then_one_or_more(&mut self, pat: Box<dyn Pattern>) -> &mut Self {+ self.token_patterns+ .push(Box::new(RepeatingPattern::new(pat)));self}}-impl Pattern for TokenSequencePattern {+impl Pattern for SequencePattern {fn matches(&self, tokens: &[Token], source: &[char]) -> usize {let mut tok_cursor = 0;@@ -66,13 +75,13 @@ impl Pattern for TokenSequencePattern {mod tests {use hashbrown::HashSet;- use super::TokenSequencePattern;+ use super::SequencePattern;use crate::patterns::Pattern;use crate::{Document, Lrc};#[test]fn matches_n_whitespace_tokens() {- let mut pat = TokenSequencePattern::default();+ let mut pat = SequencePattern::default();pat.then_any_word().then_whitespace().then_any_word();let doc = Document::new_plain_english_curated("word\n \nword");@@ -84,7 +93,7 @@ mod tests {#[test]fn matches_specific_words() {- let mut pat = TokenSequencePattern::default();+ let mut pat = SequencePattern::default();pat.then_exact_word("she").then_whitespace().then_exact_word("her");@@ -103,7 +112,7 @@ mod tests {pronouns.insert("hers");let pronouns = Lrc::new(pronouns);- let mut pat = TokenSequencePattern::default();+ let mut pat = SequencePattern::default();pat.then_exact_word("it").then_whitespace().then_exact_word("was")