Offline, privacy-first grammar checker. Fast, open-source, Rust-powered
feat(core): create first draft of `SingleBe` rule
Elijah Potterbf00f274f89d
diff --git a/harper-core/src/linting/lint_group.rs b/harper-core/src/linting/lint_group.rsindex abd8fcb2e..60913b331 100644--- a/harper-core/src/linting/lint_group.rs+++ b/harper-core/src/linting/lint_group.rs@@ -141,6 +141,7 @@ use super::sentence_capitalization::SentenceCapitalization;use super::shoot_oneself_in_the_foot::ShootOneselfInTheFoot;use super::simple_past_to_past_participle::SimplePastToPastParticiple;use super::since_duration::SinceDuration;+use super::single_be::SingleBe;use super::some_without_article::SomeWithoutArticle;use super::something_is::SomethingIs;use super::somewhat_something::SomewhatSomething;@@ -586,6 +587,7 @@ impl LintGroup {insert_expr_rule!(ShootOneselfInTheFoot, true);insert_expr_rule!(SimplePastToPastParticiple, true);insert_expr_rule!(SinceDuration, true);+ insert_expr_rule!(SingleBe, true);insert_expr_rule!(SomeWithoutArticle, true);insert_expr_rule!(SomethingIs, true);insert_expr_rule!(SomewhatSomething, true);diff --git a/harper-core/src/linting/mod.rs b/harper-core/src/linting/mod.rsindex 0439cf970..a196df939 100644--- a/harper-core/src/linting/mod.rs+++ b/harper-core/src/linting/mod.rs@@ -156,6 +156,7 @@ mod sentence_capitalization;mod shoot_oneself_in_the_foot;mod simple_past_to_past_participle;mod since_duration;+mod single_be;mod some_without_article;mod something_is;mod somewhat_something;@@ -332,6 +333,7 @@ pub use sentence_capitalization::SentenceCapitalization;pub use shoot_oneself_in_the_foot::ShootOneselfInTheFoot;pub use simple_past_to_past_participle::SimplePastToPastParticiple;pub use since_duration::SinceDuration;+pub use single_be::SingleBe;pub use some_without_article::SomeWithoutArticle;pub use something_is::SomethingIs;pub use somewhat_something::SomewhatSomething;diff --git a/harper-core/src/linting/single_be.rs b/harper-core/src/linting/single_be.rsnew file mode 100644index 000000000..853530a98--- /dev/null+++ b/harper-core/src/linting/single_be.rs@@ -0,0 +1,294 @@+use crate::dict_word_metadata::VerbFormFlags;+use crate::{+ Span, Token,+ expr::{Expr, SequenceExpr},+ linting::{ExprLinter, Lint, LintKind, Suggestion},+ patterns::{InflectionOfBe, SingleTokenPattern},+ spell::WordId,+};++fn is_be_inflection(token: &Token, source: &[char]) -> bool {+ let be_id = WordId::from_word_str("be");+ let Some(metadata) = token.kind.as_word() else {+ return InflectionOfBe::new().matches_token(token, source);+ };++ if let Some(metadata) = metadata.as_ref() {+ if metadata.derived_from == Some(be_id) {+ return true;+ }+ }++ let word_id = WordId::from_word_chars(token.span.get_content(source));++ word_id == be_id || InflectionOfBe::new().matches_token(token, source)+}++fn be_forms(token: &Token) -> Option<VerbFormFlags> {+ let metadata = token+ .kind+ .as_word()+ .and_then(|metadata| metadata.as_ref())?;+ let verb_data = metadata.verb.as_ref()?;++ verb_data.verb_forms+}++fn is_finite_be(token: &Token, source: &[char]) -> bool {+ if !is_be_inflection(token, source) {+ return false;+ };++ if let Some(forms) = be_forms(token) {+ if forms.intersects(VerbFormFlags::PROGRESSIVE | VerbFormFlags::PAST_PARTICIPLE) {+ return false;+ }+ }++ true+}++fn is_past_flag(forms: VerbFormFlags) -> bool {+ forms.intersects(VerbFormFlags::PAST | VerbFormFlags::PRETERITE)+}++fn looks_like_be_contraction(token: &Token, source: &[char]) -> bool {+ let Some(_) = token.kind.as_word() else {+ return false;+ };++ if token.kind.is_possessive_nominal() && token.kind.is_proper_noun() {+ return false;+ }++ let content = token.span.get_content(source);+ let Some(apostrophe_idx) = content.iter().rposition(|c| matches!(*c, '\'' | '’')) else {+ return false;+ };+ let base_slice = &content[..apostrophe_idx];+ if token.kind.is_possessive_nominal() && token.kind.is_proper_noun() {+ return false;+ }+ if base_slice+ .first()+ .is_some_and(|c| c.is_uppercase() && token.kind.is_nominal() && !token.kind.is_pronoun())+ {+ return false;+ }+ let base: Vec<char> = base_slice.iter().map(|c| c.to_ascii_lowercase()).collect();+ if base == ['l', 'e', 't'] {+ return false;+ }+ let suffix: Vec<char> = content[apostrophe_idx + 1..]+ .iter()+ .map(|c| c.to_ascii_lowercase())+ .collect();++ matches!(suffix.as_slice(), ['s'] | ['r', 'e'] | ['m']) && apostrophe_idx > 0+}++fn is_be_like(token: &Token, source: &[char]) -> bool {+ is_finite_be(token, source) || looks_like_be_contraction(token, source)+}++pub struct SingleBe {+ expr: Box<dyn Expr>,+}++impl Default for SingleBe {+ fn default() -> Self {+ let expr = SequenceExpr::default()+ .then(is_be_like)+ .t_ws()+ .then(is_finite_be);++ Self {+ expr: Box::new(expr),+ }+ }+}++impl ExprLinter for SingleBe {+ fn expr(&self) -> &dyn Expr {+ self.expr.as_ref()+ }++ fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Option<Lint> {+ let first = matched_tokens.first()?;+ let second = matched_tokens.last()?;++ if first.kind.is_possessive_nominal() && first.kind.is_proper_noun() {+ return None;+ }+ if first.kind.is_possessive_nominal()+ && first+ .span+ .get_content(source)+ .first()+ .is_some_and(|c| c.is_uppercase())+ {+ return None;+ }++ let first_is_past = be_forms(first)+ .map(is_past_flag)+ .unwrap_or_else(|| first.kind.is_verb_past_form());+ let second_is_past = be_forms(second)+ .map(is_past_flag)+ .unwrap_or_else(|| second.kind.is_verb_past_form());++ let first_chars = first.span.get_content(source);+ let base_before_apostrophe = first_chars+ .iter()+ .rposition(|c| matches!(*c, '\'' | '’'))+ .map(|idx| &first_chars[..idx]);++ if let Some(base) = base_before_apostrophe {+ let base_first_upper = base.first().is_some_and(|c| c.is_uppercase());+ let base_lower: Vec<char> = base.iter().map(|c| c.to_ascii_lowercase()).collect();+ let is_common_pronoun = matches!(+ base_lower.as_slice(),+ ['i']+ | ['w', 'e']+ | ['t', 'h', 'e', 'y']+ | ['y', 'o', 'u']+ | ['h', 'e']+ | ['s', 'h', 'e']+ | ['i', 't']+ | ['t', 'h', 'a', 't']+ | ['t', 'h', 'e', 'r', 'e']+ );++ if base_first_upper && !first.kind.is_pronoun() && !is_common_pronoun {+ return None;+ }+ }++ if first_is_past && second_is_past {+ return None;+ }++ let whitespace_start = matched_tokens.get(1)?.span.start;+ let second_be_end = second.span.end;++ Some(Lint {+ span: Span::new(whitespace_start, second_be_end),+ lint_kind: LintKind::Grammar,+ suggestions: vec![Suggestion::ReplaceWith(vec![])],+ message: "Drop the repeated verb form so only one instance of `be` remains.".to_owned(),+ priority: 31,+ })+ }++ fn description(&self) -> &'static str {+ "Removes adjacent duplicate inflections of `be`, including contracted forms followed by another `be` verb."+ }+}++#[cfg(test)]+mod tests {+ use crate::linting::tests::{assert_no_lints, assert_suggestion_result};++ use super::SingleBe;++ #[test]+ fn removes_double_is() {+ assert_suggestion_result(+ "The server is is slow.",+ SingleBe::default(),+ "The server is slow.",+ );+ }++ #[test]+ fn removes_is_are() {+ assert_suggestion_result(+ "This is are unusual.",+ SingleBe::default(),+ "This is unusual.",+ );+ }++ #[test]+ fn removes_are_were_mismatch() {+ assert_suggestion_result(+ "They are were excited.",+ SingleBe::default(),+ "They are excited.",+ );+ }++ #[test]+ fn removes_mismatched_pair() {+ assert_suggestion_result("That is was odd.", SingleBe::default(), "That is odd.");+ }++ #[test]+ fn handles_s_contraction() {+ assert_suggestion_result(+ "The error's are gone.",+ SingleBe::default(),+ "The error's gone.",+ );+ }++ #[test]+ fn handles_re_contraction() {+ assert_suggestion_result(+ "We're are ready to ship.",+ SingleBe::default(),+ "We're ready to ship.",+ );+ }++ #[test]+ fn handles_m_contraction() {+ assert_suggestion_result("I'm am aware.", SingleBe::default(), "I'm aware.");+ }++ #[test]+ fn handles_future_repetition() {+ assert_suggestion_result(+ "That will be be an issue.",+ SingleBe::default(),+ "That will be an issue.",+ );+ }++ #[test]+ fn skips_being_chain() {+ assert_no_lints("It's been being rebuilt for months.", SingleBe::default());+ }++ #[test]+ fn allows_simple_be_statement() {+ assert_no_lints("Let's be honest.", SingleBe::default());+ }++ #[test]+ fn allows_possessive_before_are() {+ assert_no_lints(+ "Stories like Mateo's are the heart of what we do.",+ SingleBe::default(),+ );+ }++ #[test]+ fn removes_across_newline() {+ assert_suggestion_result(+ "That is\nis tricky.",+ SingleBe::default(),+ "That is tricky.",+ );+ }++ #[test]+ fn ignores_separated_forms() {+ assert_no_lints("The server is not is down.", SingleBe::default());+ }++ #[test]+ fn ignores_single_be() {+ assert_no_lints("This is ready.", SingleBe::default());+ }+}