Skip to content

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 L
where
- 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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")