Skip to content

Offline, privacy-first grammar checker. Fast, open-source, Rust-powered

feat(core): rule to fix affect -> effect (#1954)

Elijah Potter6cf090d2f1f9
diff --git a/harper-core/src/expr/mod.rs b/harper-core/src/expr/mod.rs
index 0ba2d1a4f..6e92753fa 100644
--- a/harper-core/src/expr/mod.rs
+++ b/harper-core/src/expr/mod.rs
@@ -130,7 +130,7 @@ where
&'a self,
tokens: &'a [Token],
source: &'a [char],
- ) -> Box<(dyn Iterator<Item = Span<Token>> + 'a)> {
+ ) -> Box<dyn Iterator<Item = Span<Token>> + 'a> {
let mut last_end = 0usize;
Box::new((0..tokens.len()).filter_map(move |i| {
@@ -147,7 +147,7 @@ where
fn iter_matches_in_doc<'a>(
&'a self,
doc: &'a Document,
- ) -> Box<(dyn Iterator<Item = Span<Token>> + 'a)> {
+ ) -> Box<dyn Iterator<Item = Span<Token>> + 'a> {
Box::new(self.iter_matches(doc.get_tokens(), doc.get_source()))
}
}
diff --git a/harper-core/src/linting/lint_group.rs b/harper-core/src/linting/lint_group.rs
index eba823e57..356797d08 100644
--- a/harper-core/src/linting/lint_group.rs
+++ b/harper-core/src/linting/lint_group.rs
@@ -139,7 +139,8 @@ use super::{ExprLinter, Lint};
use crate::linting::dashes::Dashes;
use crate::linting::open_compounds::OpenCompounds;
use crate::linting::{
- MassPlurals, closed_compounds, initialisms, phrase_corrections, phrase_set_corrections,
+ MassPlurals, NounVerbConfusion, closed_compounds, initialisms, phrase_corrections,
+ phrase_set_corrections,
};
use crate::spell::{Dictionary, MutableDictionary};
use crate::{CharString, Dialect, Document, TokenStringExt};
@@ -480,6 +481,7 @@ impl LintGroup {
insert_struct_rule!(NoOxfordComma, false);
insert_expr_rule!(Nobody, true);
insert_struct_rule!(NominalWants, true);
+ insert_struct_rule!(NounVerbConfusion, true);
insert_expr_rule!(NounCountability, true);
insert_struct_rule!(NumberSuffixCapitalization, true);
insert_struct_rule!(OfCourse, true);
diff --git a/harper-core/src/linting/noun_verb_confusion/effect_affect/affect_to_effect.rs b/harper-core/src/linting/noun_verb_confusion/effect_affect/affect_to_effect.rs
new file mode 100644
index 000000000..73e959921
--- /dev/null
+++ b/harper-core/src/linting/noun_verb_confusion/effect_affect/affect_to_effect.rs
@@ -0,0 +1,219 @@
+use std::sync::Arc;
+
+use harper_brill::UPOS;
+
+use crate::{
+ CharStringExt, Token, TokenKind,
+ expr::{Expr, ExprMap, SequenceExpr},
+ linting::{ExprLinter, Lint, LintKind, Suggestion},
+ patterns::{ModalVerb, Pattern, UPOSSet},
+};
+
+pub(super) struct AffectToEffect {
+ expr: Box<dyn Expr>,
+ map: Arc<ExprMap<usize>>,
+}
+
+impl Default for AffectToEffect {
+ fn default() -> Self {
+ let mut map = ExprMap::default();
+
+ let adj_then_noun_follow = SequenceExpr::default()
+ .then(|tok: &Token, source: &[char]| matches_preceding_context_adj_noun(tok, source))
+ .t_ws()
+ .then(|tok: &Token, source: &[char]| is_affect_word(tok, source))
+ .t_ws()
+ .then(UPOSSet::new(&[UPOS::ADJ]))
+ .t_ws()
+ .then(UPOSSet::new(&[UPOS::NOUN]));
+
+ map.insert(adj_then_noun_follow, 2);
+
+ let word_follow = SequenceExpr::default()
+ .then(|tok: &Token, source: &[char]| matches_preceding_context(tok, source))
+ .t_ws()
+ .then(|tok: &Token, source: &[char]| is_affect_word(tok, source))
+ .t_ws()
+ .then(UPOSSet::new(&[
+ UPOS::PROPN,
+ UPOS::INTJ,
+ UPOS::ADP,
+ UPOS::SCONJ,
+ ]));
+
+ map.insert(word_follow, 2);
+
+ let verb_follow = SequenceExpr::default()
+ .then(|tok: &Token, source: &[char]| matches_preceding_context_verb_follow(tok, source))
+ .t_ws()
+ .then(|tok: &Token, source: &[char]| is_affect_word(tok, source))
+ .t_ws()
+ .then(UPOSSet::new(&[UPOS::AUX, UPOS::VERB]));
+
+ map.insert(verb_follow, 2);
+
+ let punctuation_follow = SequenceExpr::default()
+ .then(|tok: &Token, source: &[char]| matches_preceding_context(tok, source))
+ .t_ws()
+ .then(|tok: &Token, source: &[char]| is_affect_word(tok, source))
+ .then(|tok: &Token, _source: &[char]| matches!(tok.kind, TokenKind::Punctuation(_)));
+
+ map.insert(punctuation_follow, 2);
+
+ let great_affect = SequenceExpr::default()
+ .t_aco("great")
+ .t_ws()
+ .then(|tok: &Token, source: &[char]| is_affect_word(tok, source));
+
+ map.insert(great_affect, 2);
+
+ let map = Arc::new(map);
+
+ Self {
+ expr: Box::new(map.clone()),
+ map,
+ }
+ }
+}
+
+impl ExprLinter for AffectToEffect {
+ fn expr(&self) -> &dyn Expr {
+ self.expr.as_ref()
+ }
+
+ fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Option<Lint> {
+ let offending_index = *self.map.lookup(0, matched_tokens, source)?;
+ let target = &matched_tokens[offending_index];
+
+ let token_text = target.span.get_content_string(source);
+ let lower = token_text.to_lowercase();
+ let replacement = match lower.as_str() {
+ "affect" => "effect",
+ "affects" => "effects",
+ _ => return None,
+ };
+
+ Some(Lint {
+ span: target.span,
+ lint_kind: LintKind::WordChoice,
+ suggestions: vec![Suggestion::replace_with_match_case_str(
+ replacement,
+ target.span.get_content(source),
+ )],
+ message: "`affect` is usually a verb; use `effect` here for the result or outcome."
+ .into(),
+ priority: 63,
+ })
+ }
+
+ fn description(&self) -> &'static str {
+ "Corrects `affect` to `effect` when the context shows the noun meaning `result`."
+ }
+}
+
+fn is_affect_word(token: &Token, source: &[char]) -> bool {
+ const AFFECT: &[char] = &['a', 'f', 'f', 'e', 'c', 't'];
+ const AFFECTS: &[char] = &['a', 'f', 'f', 'e', 'c', 't', 's'];
+
+ if !matches!(token.kind, TokenKind::Word(_)) {
+ return false;
+ }
+
+ let text = token.span.get_content(source);
+ text.eq_ignore_ascii_case_chars(AFFECT) || text.eq_ignore_ascii_case_chars(AFFECTS)
+}
+
+fn is_take_form(chars: &[char]) -> bool {
+ chars.eq_ignore_ascii_case_str("take")
+ || chars.eq_ignore_ascii_case_str("takes")
+ || chars.eq_ignore_ascii_case_str("taking")
+ || chars.eq_ignore_ascii_case_str("took")
+ || chars.eq_ignore_ascii_case_str("taken")
+}
+
+fn is_modal_like(token: &Token, source: &[char], prev: &[char]) -> bool {
+ if ModalVerb::default()
+ .matches(std::slice::from_ref(token), source)
+ .is_some()
+ {
+ return true;
+ }
+
+ prev.eq_ignore_ascii_case_str("do")
+ || prev.eq_ignore_ascii_case_str("does")
+ || prev.eq_ignore_ascii_case_str("did")
+ || prev.eq_ignore_ascii_case_str("don't")
+ || prev.eq_ignore_ascii_case_str("dont")
+ || prev.eq_ignore_ascii_case_str("doesn't")
+ || prev.eq_ignore_ascii_case_str("doesnt")
+ || prev.eq_ignore_ascii_case_str("didn't")
+ || prev.eq_ignore_ascii_case_str("didnt")
+}
+
+fn matches_preceding_context(token: &Token, source: &[char]) -> bool {
+ matches_preceding_context_impl(token, source, true, true)
+}
+
+fn matches_preceding_context_adj_noun(token: &Token, source: &[char]) -> bool {
+ matches_preceding_context_impl(token, source, false, true)
+}
+
+fn matches_preceding_context_verb_follow(token: &Token, source: &[char]) -> bool {
+ matches_preceding_context_impl(token, source, true, false)
+}
+
+fn matches_preceding_context_impl(
+ token: &Token,
+ source: &[char],
+ allow_noun_like: bool,
+ allow_verb_like: bool,
+) -> bool {
+ if token.kind.is_possessive_nominal() {
+ return false;
+ }
+
+ if !is_preceding_context(token) {
+ return false;
+ }
+
+ let content = token.span.get_content(source);
+ let is_take_form_word = is_take_form(content);
+
+ if behaves_like_verb(token, source, content) && !is_take_form_word {
+ return false;
+ }
+
+ if !allow_verb_like && token.kind.is_upos(UPOS::VERB) && !is_take_form_word {
+ return false;
+ }
+
+ if !allow_noun_like
+ && (token.kind.is_noun() || token.kind.is_proper_noun())
+ && !is_take_form_word
+ {
+ return false;
+ }
+
+ true
+}
+
+fn behaves_like_verb(token: &Token, source: &[char], prev: &[char]) -> bool {
+ token.kind.is_upos(UPOS::AUX)
+ || token.kind.is_auxiliary_verb()
+ || is_modal_like(token, source, prev)
+}
+
+fn is_preceding_context(token: &Token) -> bool {
+ if token.kind.is_adverb() {
+ return false;
+ }
+
+ matches!(token.kind, TokenKind::Punctuation(_))
+ || token.kind.is_preposition()
+ || token.kind.is_conjunction()
+ || token.kind.is_proper_noun()
+ || token.kind.is_verb()
+ || token.kind.is_adjective()
+ || token.kind.is_determiner()
+ || token.kind.is_noun()
+}
diff --git a/harper-core/src/linting/noun_verb_confusion/effect_affect/effect_to_affect.rs b/harper-core/src/linting/noun_verb_confusion/effect_affect/effect_to_affect.rs
new file mode 100644
index 000000000..b122ae7ce
--- /dev/null
+++ b/harper-core/src/linting/noun_verb_confusion/effect_affect/effect_to_affect.rs
@@ -0,0 +1,239 @@
+use std::sync::Arc;
+
+use harper_brill::UPOS;
+
+use crate::{
+ CharStringExt, Token, TokenKind,
+ expr::{Expr, ExprMap, SequenceExpr},
+ linting::{ExprLinter, Lint, LintKind, Suggestion},
+ patterns::WhitespacePattern,
+};
+
+pub(super) struct EffectToAffect {
+ expr: Box<dyn Expr>,
+ map: Arc<ExprMap<usize>>,
+}
+
+impl Default for EffectToAffect {
+ fn default() -> Self {
+ let mut map = ExprMap::default();
+
+ let context = SequenceExpr::default()
+ .then(matches_preceding_context)
+ .t_ws()
+ .then(|tok: &Token, source: &[char]| is_effect_word(tok, source))
+ .t_ws()
+ .then(matches_following_context)
+ .then_optional(WhitespacePattern)
+ .then_optional(matches_optional_following)
+ .then_optional(WhitespacePattern);
+
+ map.insert(context, 2);
+
+ let map = Arc::new(map);
+
+ Self {
+ expr: Box::new(map.clone()),
+ map,
+ }
+ }
+}
+
+impl ExprLinter for EffectToAffect {
+ fn expr(&self) -> &dyn Expr {
+ self.expr.as_ref()
+ }
+
+ fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Option<Lint> {
+ let offending_idx = *self.map.lookup(0, matched_tokens, source)?;
+ let target = &matched_tokens[offending_idx];
+
+ let preceding = matched_tokens[..offending_idx]
+ .iter()
+ .rfind(|tok| !tok.kind.is_whitespace());
+
+ let mut following = matched_tokens[offending_idx + 1..]
+ .iter()
+ .filter(|tok| !tok.kind.is_whitespace());
+
+ let first_following = following.next()?;
+ let second_following = following.next();
+
+ if let Some(prev) = preceding {
+ let lower_prev = prev.span.get_content_string(source).to_lowercase();
+
+ if matches!(
+ lower_prev.as_str(),
+ "take" | "takes" | "taking" | "took" | "taken"
+ ) {
+ return None;
+ }
+ }
+
+ if first_following.kind.is_upos(UPOS::AUX) || first_following.kind.is_linking_verb() {
+ return None;
+ }
+
+ let first_following_lower = first_following
+ .span
+ .get_content_string(source)
+ .to_lowercase();
+
+ if matches!(
+ first_following_lower.as_str(),
+ "is" | "are" | "was" | "were" | "be" | "been" | "being"
+ ) {
+ return None;
+ }
+
+ // Avoid "to effect change", which uses the legitimate verb "effect".
+ if let Some(prev) = preceding
+ && is_token_to(prev, source)
+ && is_change_like(first_following, source)
+ {
+ return None;
+ }
+
+ if first_following.kind.is_upos(UPOS::VERB)
+ && preceding.is_some_and(|tok| {
+ tok.kind.is_upos(UPOS::NOUN)
+ || tok.kind.is_upos(UPOS::DET)
+ || tok.kind.is_upos(UPOS::ADJ)
+ || (tok.kind.is_noun()
+ && !tok.kind.is_upos(UPOS::VERB)
+ && !tok.kind.is_upos(UPOS::AUX))
+ })
+ {
+ return None;
+ }
+
+ // Skip when the context already shows a clear noun usage (e.g., "the effect your idea had").
+ if let Some(prev) = preceding
+ && (prev.kind.is_upos(UPOS::DET) || prev.kind.is_upos(UPOS::ADJ))
+ {
+ return None;
+ }
+
+ // Do not flag when the following noun is clearly the result of "effect" in the idiomatic sense.
+ if let Some(next) = second_following
+ && next.kind.is_noun()
+ && is_change_like(next, source)
+ {
+ return None;
+ }
+
+ let token_text = target.span.get_content_string(source);
+ let lower = token_text.to_lowercase();
+
+ let replacement = match lower.as_str() {
+ "effect" => "affect",
+ "effects" => "affects",
+ _ => return None,
+ };
+
+ Some(Lint {
+ span: target.span,
+ lint_kind: LintKind::WordChoice,
+ suggestions: vec![Suggestion::replace_with_match_case_str(
+ replacement,
+ target.span.get_content(source),
+ )],
+ message:
+ "Use `affect` for the verb meaning to influence; `effect` usually names the result."
+ .into(),
+ priority: 63,
+ })
+ }
+
+ fn description(&self) -> &'static str {
+ "Corrects `effect` to `affect` when the context shows the verb meaning `influence`."
+ }
+}
+
+fn is_effect_word(token: &Token, source: &[char]) -> bool {
+ if !matches!(token.kind, TokenKind::Word(_)) {
+ return false;
+ }
+
+ const EFFECT: &[char] = &['e', 'f', 'f', 'e', 'c', 't'];
+ const EFFECTS: &[char] = &['e', 'f', 'f', 'e', 'c', 't', 's'];
+
+ let text = token.span.get_content(source);
+ text.eq_ignore_ascii_case_chars(EFFECT) || text.eq_ignore_ascii_case_chars(EFFECTS)
+}
+
+fn is_token_to(token: &Token, source: &[char]) -> bool {
+ token
+ .span
+ .get_content(source)
+ .eq_ignore_ascii_case_chars(&['t', 'o'])
+}
+
+fn is_change_like(token: &Token, source: &[char]) -> bool {
+ if !token.kind.is_word() {
+ return false;
+ }
+
+ matches!(
+ token
+ .span
+ .get_content_string(source)
+ .to_lowercase()
+ .as_str(),
+ "change" | "changes" | "substitution" | "substitutions"
+ )
+}
+
+fn matches_preceding_context(token: &Token, _source: &[char]) -> bool {
+ tag_matches_any(
+ token,
+ &[
+ UPOS::PART,
+ UPOS::NOUN,
+ UPOS::PRON,
+ UPOS::PROPN,
+ UPOS::ADV,
+ UPOS::AUX,
+ UPOS::VERB,
+ UPOS::ADJ,
+ ],
+ )
+}
+
+fn matches_following_context(token: &Token, _source: &[char]) -> bool {
+ tag_matches_any(
+ token,
+ &[
+ UPOS::ADV,
+ UPOS::AUX,
+ UPOS::PRON,
+ UPOS::PROPN,
+ UPOS::VERB,
+ UPOS::NUM,
+ UPOS::NOUN,
+ UPOS::INTJ,
+ UPOS::SCONJ,
+ UPOS::DET,
+ UPOS::ADJ,
+ ],
+ )
+}
+
+fn matches_optional_following(token: &Token, _source: &[char]) -> bool {
+ if token.kind.is_punctuation() {
+ return true;
+ }
+
+ tag_matches_any(token, &[UPOS::NOUN])
+}
+
+fn tag_matches_any(token: &Token, allowed: &[UPOS]) -> bool {
+ let Some(word_meta_opt) = token.kind.as_word() else {
+ return false;
+ };
+
+ match word_meta_opt {
+ Some(meta) => meta.pos_tag.is_none_or(|tag| allowed.contains(&tag)),
+ None => true,
+ }
+}
diff --git a/harper-core/src/linting/noun_verb_confusion/effect_affect/mod.rs b/harper-core/src/linting/noun_verb_confusion/effect_affect/mod.rs
new file mode 100644
index 000000000..e030f94c8
--- /dev/null
+++ b/harper-core/src/linting/noun_verb_confusion/effect_affect/mod.rs
@@ -0,0 +1,14 @@
+mod affect_to_effect;
+mod effect_to_affect;
+
+use affect_to_effect::AffectToEffect;
+use effect_to_affect::EffectToAffect;
+
+use crate::linting::merge_linters::merge_linters;
+
+merge_linters!(
+ EffectAffect =>
+ EffectToAffect,
+ AffectToEffect
+ => "Guides writers toward the right choice between `effect` and `affect`, correcting each term when it shows up in the other one's role."
+);
diff --git a/harper-core/src/linting/noun_verb_confusion/mod.rs b/harper-core/src/linting/noun_verb_confusion/mod.rs
index 2b6eac4f8..b8a592e6a 100644
--- a/harper-core/src/linting/noun_verb_confusion/mod.rs
+++ b/harper-core/src/linting/noun_verb_confusion/mod.rs
@@ -1,5 +1,6 @@
use super::merge_linters::merge_linters;
+mod effect_affect;
mod noun_instead_of_verb;
mod verb_instead_of_noun;
@@ -16,13 +17,1324 @@ pub(crate) const NOUN_VERB_PAIRS: &[(&str, &str)] = &[
// Add more pairs here as needed
];
-pub use noun_instead_of_verb::NounInsteadOfVerb;
-pub use verb_instead_of_noun::VerbInsteadOfNoun;
+use noun_instead_of_verb::NounInsteadOfVerb;
+use verb_instead_of_noun::VerbInsteadOfNoun;
-// Merge the two linters with a descriptive message
merge_linters! {
NounVerbConfusion =>
NounInsteadOfVerb,
VerbInsteadOfNoun
=> "Handles common confusions between related nouns and verbs (e.g., 'advice/advise', 'breath/breathe')"
}
+
+#[cfg(test)]
+mod tests {
+ use super::NounVerbConfusion;
+ use crate::linting::tests::{assert_lint_count, assert_suggestion_result};
+
+ #[test]
+ fn corrects_good_advise() {
+ assert_suggestion_result("Good advise", NounVerbConfusion::default(), "Good advice");
+ }
+
+ #[test]
+ fn corrects_bad_advise() {
+ assert_suggestion_result(
+ "I just wanted to bring attention to this because it stood out to me as potentially bad advise.",
+ NounVerbConfusion::default(),
+ "I just wanted to bring attention to this because it stood out to me as potentially bad advice.",
+ );
+ }
+
+ #[test]
+ fn dont_flag_correct_better_advise() {
+ assert_lint_count(
+ "Hello! I am an engineer at Plexon and am conducting tests with Kilosort4 so we can better advise our clients.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ #[ignore = "'better advise' can be correct as above, or a mistake like here"]
+ fn correct_better_advise() {
+ assert_suggestion_result(
+ "Maybe this will be a decent idea, .or anybody has better advise :)",
+ NounVerbConfusion::default(),
+ "Maybe this will be a decent idea, .or anybody has better advice :)",
+ );
+ }
+
+ #[test]
+ fn dont_flag_correct_better_believe() {
+ assert_lint_count(
+ "You'd better believe this is bbedit-gist-maker.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn correct_strong_believe() {
+ assert_suggestion_result(
+ "cause my strong believe is that we must give any user to describe whether a post is meant factual",
+ NounVerbConfusion::default(),
+ "cause my strong belief is that we must give any user to describe whether a post is meant factual",
+ );
+ }
+
+ #[test]
+ fn correct_deep_breathe() {
+ assert_suggestion_result(
+ "Take deep breathe and Do it again!",
+ NounVerbConfusion::default(),
+ "Take deep breath and Do it again!",
+ );
+ }
+
+ #[test]
+ fn correct_bad_intend() {
+ assert_suggestion_result(
+ "What do you do if you only see slightly longer posts that may still be acceptable (and not bad intend from the poster)",
+ NounVerbConfusion::default(),
+ "What do you do if you only see slightly longer posts that may still be acceptable (and not bad intent from the poster)",
+ );
+ }
+
+ #[test]
+ fn corrects_belief_instead_of_verb() {
+ assert_suggestion_result(
+ "I belief in you.",
+ NounVerbConfusion::default(),
+ "I believe in you.",
+ );
+ }
+
+ #[test]
+ #[ignore = "`to` can't disambiguate since it's valid between verbs and nouns"]
+ fn corrects_breath_instead_of_verb() {
+ assert_suggestion_result(
+ "Remember to breath deeply.",
+ NounVerbConfusion::default(),
+ "Remember to breathe deeply.",
+ );
+ }
+
+ #[test]
+ fn does_not_flag_correct_believe() {
+ assert_lint_count("I believe in you.", NounVerbConfusion::default(), 0);
+ }
+
+ #[test]
+ fn does_not_flag_correct_breath() {
+ assert_lint_count("Take a deep breath.", NounVerbConfusion::default(), 0);
+ }
+
+ // real-world example unit tests
+
+ #[test]
+ fn fix_when_i_breath_you_breath() {
+ assert_suggestion_result(
+ "When I breath, you breath!",
+ NounVerbConfusion::default(),
+ "When I breathe, you breathe!",
+ );
+ }
+
+ #[test]
+ fn fix_weather_climate_and_the_air_we_breath() {
+ assert_suggestion_result(
+ "Weather Climate and the Air We Breath",
+ NounVerbConfusion::default(),
+ "Weather Climate and the Air We Breathe",
+ );
+ }
+
+ #[test]
+ fn fix_always_breath() {
+ assert_suggestion_result(
+ "breathing. remember to always breath.",
+ NounVerbConfusion::default(),
+ "breathing. remember to always breathe.",
+ );
+ }
+
+ #[test]
+ fn fix_never_breath_a_word() {
+ assert_suggestion_result(
+ "And never breath a word about your loss; If you can force your heart and nerve and sinew.",
+ NounVerbConfusion::default(),
+ "And never breathe a word about your loss; If you can force your heart and nerve and sinew.",
+ );
+ }
+
+ #[test]
+ fn fix_breath_for_seconds() {
+ assert_suggestion_result(
+ "Once turned on, the LED on the TX unit would breath for a few seconds, then go completely dead and not responding to objects in front of the sensors.",
+ NounVerbConfusion::default(),
+ "Once turned on, the LED on the TX unit would breathe for a few seconds, then go completely dead and not responding to objects in front of the sensors.",
+ );
+ }
+
+ #[test]
+ fn fix_breath_a_little_more_life() {
+ assert_suggestion_result(
+ "... up to 12% more performance, could breath a little more life into systems as old as Sandy Bridge.",
+ NounVerbConfusion::default(),
+ "... up to 12% more performance, could breathe a little more life into systems as old as Sandy Bridge.",
+ );
+ }
+
+ #[test]
+ fn fix_the_diversity_we_breath() {
+ assert_suggestion_result(
+ "The Diversity We Breath: Community Diversity",
+ NounVerbConfusion::default(),
+ "The Diversity We Breathe: Community Diversity",
+ );
+ }
+
+ #[test]
+ fn fix_belief() {
+ assert_suggestion_result(
+ "While I have no plans to return to aerospace I belief it gives me a unique perspective to many challenges.",
+ NounVerbConfusion::default(),
+ "While I have no plans to return to aerospace I believe it gives me a unique perspective to many challenges.",
+ );
+ }
+
+ #[test]
+ fn fix_we_belief() {
+ assert_suggestion_result(
+ "In contrast to other vendors in e-mobility, we belief that true transparency is only trustworthy if the entire process ...",
+ NounVerbConfusion::default(),
+ "In contrast to other vendors in e-mobility, we believe that true transparency is only trustworthy if the entire process ...",
+ );
+ }
+
+ #[test]
+ #[ignore = "`underwater` is a marginal noun so `breath underwater` matches the compound noun test."]
+ fn fix_i_can_breath() {
+ assert_suggestion_result(
+ "Steps to reproduce Expected behaviour I can breath underwater.",
+ NounVerbConfusion::default(),
+ "Steps to reproduce Expected behaviour I can breathe underwater.",
+ );
+ }
+
+ #[test]
+ fn fix_caps_should_breath() {
+ assert_suggestion_result(
+ "CAPS 1 2 3 4 5 A B C D SHOULD BREATH A BIT MORE ?",
+ NounVerbConfusion::default(),
+ "CAPS 1 2 3 4 5 A B C D SHOULD BREATHE A BIT MORE ?",
+ );
+ }
+
+ #[test]
+ fn fix_can_you_advice_me() {
+ assert_suggestion_result(
+ "Can you advice me how to train?",
+ NounVerbConfusion::default(),
+ "Can you advise me how to train?",
+ );
+ }
+
+ #[test]
+ fn fix_we_can_advice_you() {
+ assert_suggestion_result(
+ "Feel free to share more details about your use case, so we can advice you specifically based on your case.",
+ NounVerbConfusion::default(),
+ "Feel free to share more details about your use case, so we can advise you specifically based on your case.",
+ );
+ }
+
+ #[test]
+ fn fix_would_advice_against() {
+ assert_suggestion_result(
+ "So that I would advice against using a spindle in laser mode.",
+ NounVerbConfusion::default(),
+ "So that I would advise against using a spindle in laser mode.",
+ );
+ }
+
+ #[test]
+ fn fix_advice_to_listen() {
+ assert_suggestion_result(
+ "The idea of this applicaton was inspired by Ray Dalio, who always advice to listen to people who know more than us by experience.",
+ NounVerbConfusion::default(),
+ "The idea of this applicaton was inspired by Ray Dalio, who always advise to listen to people who know more than us by experience.",
+ );
+ }
+
+ #[test]
+ #[ignore = "`You` is an object pronoun in this example. `It` is also both subject and object."]
+ fn dont_fix_advice_on_that() {
+ assert_lint_count(
+ "I don't do table returning functions in my code so can't offer you advice on that.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn fix_advice_to_stick_with_openvscode() {
+ assert_suggestion_result(
+ "But unless you really need it, I would advice to stick with openvscode as there are nearly the same.",
+ NounVerbConfusion::default(),
+ "But unless you really need it, I would advise to stick with openvscode as there are nearly the same.",
+ );
+ }
+
+ #[test]
+ fn fix_advice_to_back_up_os_image() {
+ assert_suggestion_result(
+ "I would advice to back up all OS image before any update, because you could lose something what was working previously.",
+ NounVerbConfusion::default(),
+ "I would advise to back up all OS image before any update, because you could lose something what was working previously.",
+ );
+ }
+
+ #[test]
+ fn fix_advice_to_use_ms_store() {
+ assert_suggestion_result(
+ "I know we can always advice to use the MS store to download JASP instead",
+ NounVerbConfusion::default(),
+ "I know we can always advise to use the MS store to download JASP instead",
+ );
+ }
+
+ #[test]
+ fn fix_should_intent_be() {
+ assert_suggestion_result(
+ "Should intent be on the blocklist?",
+ NounVerbConfusion::default(),
+ "Should intent be on the blocklist?",
+ );
+ }
+
+ #[test]
+ fn fix_if_you_intent() {
+ assert_suggestion_result(
+ "If you intent to use a 64 bits machine, change line 74",
+ NounVerbConfusion::default(),
+ "If you intend to use a 64 bits machine, change line 74",
+ );
+ }
+
+ #[test]
+ fn fix_what_you_would_intent_to_do() {
+ assert_suggestion_result(
+ "May I ask what you would intent to do with such a feature?",
+ NounVerbConfusion::default(),
+ "May I ask what you would intend to do with such a feature?",
+ );
+ }
+
+ #[test]
+ fn dont_flag_intent_records() {
+ assert_lint_count(
+ "there are always intent records associated to the txns",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn fix_did_you_always_intent_to() {
+ assert_suggestion_result(
+ "Did you always intent to fight malware? No.",
+ NounVerbConfusion::default(),
+ "Did you always intend to fight malware? No.",
+ );
+ }
+
+ #[test]
+ fn fix_we_recommend_you_create_a_new_issue_on_github_explaining_what_you_intent_to_do() {
+ assert_suggestion_result(
+ "... we recommend you create a new issue on github explaining what you intent to do.",
+ NounVerbConfusion::default(),
+ "... we recommend you create a new issue on github explaining what you intend to do.",
+ );
+ }
+
+ #[test]
+ fn fix_intent_to_use_non_imported_symbol() {
+ assert_suggestion_result(
+ "There's a warning reported for this code, saying that it may intent to use non-imported symbol",
+ NounVerbConfusion::default(),
+ "There's a warning reported for this code, saying that it may intend to use non-imported symbol",
+ );
+ }
+
+ // tests for preceding "to"
+
+ #[test]
+ fn fix_to_emphasis_the() {
+ assert_suggestion_result(
+ "This one could be used in a dialog to emphasis the surprise.",
+ NounVerbConfusion::default(),
+ "This one could be used in a dialog to emphasize the surprise.",
+ );
+ }
+
+ #[test]
+ fn allow_to_emphasis_at_end() {
+ assert_lint_count(
+ "Changes literal underscores to emphasis",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn allow_to_intent_adjective() {
+ assert_lint_count(
+ "Cleanup passing statistics to intent aware iterator",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn fix_to_advice_a_class() {
+ assert_suggestion_result(
+ "How to advice a class that have been intercepted by another javaagent",
+ NounVerbConfusion::default(),
+ "How to advise a class that have been intercepted by another javaagent",
+ );
+ }
+
+ #[test]
+ fn fix_to_breath_some() {
+ assert_suggestion_result(
+ "You go to the balcony to breath some fresh air and look down at the things outside.",
+ NounVerbConfusion::default(),
+ "You go to the balcony to breathe some fresh air and look down at the things outside.",
+ );
+ }
+
+ #[test]
+ fn fix_to_emphasis_a() {
+ assert_suggestion_result(
+ "we'd like to emphasis a few points below",
+ NounVerbConfusion::default(),
+ "we'd like to emphasize a few points below",
+ );
+ }
+
+ #[test]
+ fn fix_to_advice_their() {
+ assert_suggestion_result(
+ "People who are managing this situation tend to advice their users to lock+unlock their screen",
+ NounVerbConfusion::default(),
+ "People who are managing this situation tend to advise their users to lock+unlock their screen",
+ );
+ }
+
+ // affect vs. effect sentences gathered from user reports
+
+ #[test]
+ fn fix_positive_affect_on_small_businesses() {
+ assert_suggestion_result(
+ "The new law had a positive affect on small businesses.",
+ NounVerbConfusion::default(),
+ "The new law had a positive effect on small businesses.",
+ );
+ }
+
+ #[test]
+ fn fix_measured_the_affect_of_caffeine() {
+ assert_suggestion_result(
+ "We measured the affect of caffeine on reaction time.",
+ NounVerbConfusion::default(),
+ "We measured the effect of caffeine on reaction time.",
+ );
+ }
+
+ #[test]
+ fn fix_side_affects_included_nausea() {
+ assert_suggestion_result(
+ "The side affects included nausea and fatigue.",
+ NounVerbConfusion::default(),
+ "The side effects included nausea and fatigue.",
+ );
+ }
+
+ #[test]
+ fn fix_cause_and_affect_not_same() {
+ assert_suggestion_result(
+ "Cause and affect are not the same thing.",
+ NounVerbConfusion::default(),
+ "Cause and effect are not the same thing.",
+ );
+ }
+
+ #[test]
+ fn fix_change_will_have_an_affect_on_revenue() {
+ assert_suggestion_result(
+ "The change will have an affect on our revenue.",
+ NounVerbConfusion::default(),
+ "The change will have an effect on our revenue.",
+ );
+ }
+
+ #[test]
+ fn fix_medicine_took_affect_within_minutes() {
+ assert_suggestion_result(
+ "The medicine took affect within minutes.",
+ NounVerbConfusion::default(),
+ "The medicine took effect within minutes.",
+ );
+ }
+
+ #[test]
+ fn fix_policy_will_come_into_affect() {
+ assert_suggestion_result(
+ "The policy will come into affect on October 1.",
+ NounVerbConfusion::default(),
+ "The policy will come into effect on October 1.",
+ );
+ }
+
+ #[test]
+ fn fix_rules_are_now_in_affect() {
+ assert_suggestion_result(
+ "The rules are now in affect.",
+ NounVerbConfusion::default(),
+ "The rules are now in effect.",
+ );
+ }
+
+ #[test]
+ fn fix_with_immediate_affect_office_closed() {
+ assert_suggestion_result(
+ "With immediate affect, the office is closed.",
+ NounVerbConfusion::default(),
+ "With immediate effect, the office is closed.",
+ );
+ }
+
+ #[test]
+ fn fix_stunning_special_affects() {
+ assert_suggestion_result(
+ "The director used stunning special affects.",
+ NounVerbConfusion::default(),
+ "The director used stunning special effects.",
+ );
+ }
+
+ #[test]
+ fn fix_placebo_affect_can_be_powerful() {
+ assert_suggestion_result(
+ "The placebo affect can be powerful.",
+ NounVerbConfusion::default(),
+ "The placebo effect can be powerful.",
+ );
+ }
+
+ #[test]
+ fn fix_ripple_affect_across_market() {
+ assert_suggestion_result(
+ "We felt the ripple affect across the entire market.",
+ NounVerbConfusion::default(),
+ "We felt the ripple effect across the entire market.",
+ );
+ }
+
+ #[test]
+ fn fix_snowball_affect_amplified_problem() {
+ assert_suggestion_result(
+ "The snowball affect amplified the problem.",
+ NounVerbConfusion::default(),
+ "The snowball effect amplified the problem.",
+ );
+ }
+
+ #[test]
+ fn fix_knock_on_affect_throughout_team() {
+ assert_suggestion_result(
+ "That decision had a knock-on affect throughout the team.",
+ NounVerbConfusion::default(),
+ "That decision had a knock-on effect throughout the team.",
+ );
+ }
+
+ #[test]
+ fn fix_greenhouse_affect_warms_planet() {
+ assert_suggestion_result(
+ "The greenhouse affect warms the planet.",
+ NounVerbConfusion::default(),
+ "The greenhouse effect warms the planet.",
+ );
+ }
+
+ #[test]
+ fn fix_apology_had_little_affect() {
+ assert_suggestion_result(
+ "Her apology had little affect.",
+ NounVerbConfusion::default(),
+ "Her apology had little effect.",
+ );
+ }
+
+ #[test]
+ fn fix_settings_go_into_affect() {
+ assert_suggestion_result(
+ "The new settings go into affect after a restart.",
+ NounVerbConfusion::default(),
+ "The new settings go into effect after a restart.",
+ );
+ }
+
+ #[test]
+ fn fix_put_plan_into_affect() {
+ assert_suggestion_result(
+ "They put the new plan into affect last week.",
+ NounVerbConfusion::default(),
+ "They put the new plan into effect last week.",
+ );
+ }
+
+ #[test]
+ fn fix_contract_comes_into_affect() {
+ assert_suggestion_result(
+ "The contract comes into affect at midnight.",
+ NounVerbConfusion::default(),
+ "The contract comes into effect at midnight.",
+ );
+ }
+
+ #[test]
+ fn fix_warning_had_no_affect_on_behavior() {
+ assert_suggestion_result(
+ "The warning had no affect on his behavior.",
+ NounVerbConfusion::default(),
+ "The warning had no effect on his behavior.",
+ );
+ }
+
+ #[test]
+ fn fix_inflation_had_opposite_affect() {
+ assert_suggestion_result(
+ "Inflation had the opposite affect than expected.",
+ NounVerbConfusion::default(),
+ "Inflation had the opposite effect than expected.",
+ );
+ }
+
+ #[test]
+ fn fix_regulation_remains_in_affect() {
+ assert_suggestion_result(
+ "The regulation remains in affect until further notice.",
+ NounVerbConfusion::default(),
+ "The regulation remains in effect until further notice.",
+ );
+ }
+
+ #[test]
+ fn fix_app_changes_take_affect() {
+ assert_suggestion_result(
+ "The app changes take affect next week.",
+ NounVerbConfusion::default(),
+ "The app changes take effect next week.",
+ );
+ }
+
+ #[test]
+ fn fix_sound_affects_were_added() {
+ assert_suggestion_result(
+ "Sound affects were added in post.",
+ NounVerbConfusion::default(),
+ "Sound effects were added in post.",
+ );
+ }
+
+ // Effect/affect-specific checks
+ // `effect` mistakenly used as the verb `affect`.
+ #[test]
+ fn corrects_noun_subject_effects_object() {
+ assert_suggestion_result(
+ "System outages effect our customers.",
+ NounVerbConfusion::default(),
+ "System outages affect our customers.",
+ );
+ }
+
+ #[test]
+ fn corrects_effects_variant() {
+ assert_suggestion_result(
+ "This policy effects employee morale.",
+ NounVerbConfusion::default(),
+ "This policy affects employee morale.",
+ );
+ }
+
+ #[test]
+ fn ignores_effect_change_idiom() {
+ assert_lint_count(
+ "Leaders work to effect change in their communities.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn ignores_effect_noun_phrase() {
+ assert_lint_count(
+ "The effect your plan had was dramatic.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn ignores_effect_as_result_noun() {
+ assert_lint_count(
+ "The effect was immediate and obvious.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn ignores_to_effect_substitutions() {
+ assert_lint_count(
+ "or it may be desired to effect substitutions",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn ignores_effect_followed_by_of_phrase() {
+ assert_lint_count(
+ "We measured the effect of caffeine on sleep.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn ignores_side_effects_usage() {
+ assert_lint_count(
+ "Side effects may include mild nausea.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn ignores_special_effects_phrase() {
+ assert_lint_count(
+ "She admired the special effects in the film.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn ignores_effect_in_cause_and_effect() {
+ assert_lint_count(
+ "The diagram explains cause and effect relationships.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn ignores_effects_with_pronoun_subject() {
+ assert_lint_count(
+ "Those effects were less severe than expected.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn corrects_tariff_effect_import_prices() {
+ assert_suggestion_result(
+ "The new tariff will effect import prices next quarter.",
+ NounVerbConfusion::default(),
+ "The new tariff will affect import prices next quarter.",
+ );
+ }
+
+ #[test]
+ fn corrects_droughts_effect_crop_yields() {
+ assert_suggestion_result(
+ "Prolonged droughts severely effect crop yields across the valley.",
+ NounVerbConfusion::default(),
+ "Prolonged droughts severely affect crop yields across the valley.",
+ );
+ }
+
+ #[test]
+ fn corrects_caffeine_effect_sleep() {
+ assert_suggestion_result(
+ "Caffeine can effect your sleep architecture.",
+ NounVerbConfusion::default(),
+ "Caffeine can affect your sleep architecture.",
+ );
+ }
+
+ #[test]
+ fn corrects_bug_effect_devices() {
+ assert_suggestion_result(
+ "The firmware bug doesn't effect older devices.",
+ NounVerbConfusion::default(),
+ "The firmware bug doesn't affect older devices.",
+ );
+ }
+
+ #[test]
+ fn corrects_sarcasm_effect_morale() {
+ assert_suggestion_result(
+ "Her sarcasm seemed to effect the team's morale.",
+ NounVerbConfusion::default(),
+ "Her sarcasm seemed to affect the team's morale.",
+ );
+ }
+
+ #[test]
+ fn corrects_outage_effect_timeline() {
+ assert_suggestion_result(
+ "How will this outage effect our deployment timeline?",
+ NounVerbConfusion::default(),
+ "How will this outage affect our deployment timeline?",
+ );
+ }
+
+ #[test]
+ fn corrects_temperatures_effect_battery() {
+ assert_suggestion_result(
+ "Cold temperatures drastically effect lithium-ion battery performance.",
+ NounVerbConfusion::default(),
+ "Cold temperatures drastically affect lithium-ion battery performance.",
+ );
+ }
+
+ #[test]
+ fn corrects_policy_effect_eligibility() {
+ assert_suggestion_result(
+ "The policy change could effect your eligibility for benefits.",
+ NounVerbConfusion::default(),
+ "The policy change could affect your eligibility for benefits.",
+ );
+ }
+
+ #[test]
+ fn corrects_variables_effect_results() {
+ assert_suggestion_result(
+ "These confounding variables may effect the study's results.",
+ NounVerbConfusion::default(),
+ "These confounding variables may affect the study's results.",
+ );
+ }
+
+ #[test]
+ fn corrects_fans_effect_concentration() {
+ assert_suggestion_result(
+ "The noisy HVAC fans constantly effect concentration in the lab.",
+ NounVerbConfusion::default(),
+ "The noisy HVAC fans constantly affect concentration in the lab.",
+ );
+ }
+
+ #[test]
+ fn corrects_hormones_effect_immunity() {
+ assert_suggestion_result(
+ "Stress hormones can effect immune response during recovery.",
+ NounVerbConfusion::default(),
+ "Stress hormones can affect immune response during recovery.",
+ );
+ }
+
+ #[test]
+ fn corrects_pacing_effect_engagement() {
+ assert_suggestion_result(
+ "The instructor's pacing tended to effect student engagement.",
+ NounVerbConfusion::default(),
+ "The instructor's pacing tended to affect student engagement.",
+ );
+ }
+
+ #[test]
+ fn corrects_humidity_effect_paint() {
+ assert_suggestion_result(
+ "Humidity levels directly effect paint curing time.",
+ NounVerbConfusion::default(),
+ "Humidity levels directly affect paint curing time.",
+ );
+ }
+
+ #[test]
+ fn corrects_exchange_effect_invoice() {
+ assert_suggestion_result(
+ "The exchange rate will surely effect the final invoice.",
+ NounVerbConfusion::default(),
+ "The exchange rate will surely affect the final invoice.",
+ );
+ }
+
+ #[test]
+ fn corrects_brightness_effect_contrast() {
+ assert_suggestion_result(
+ "Screen brightness settings can effect perceived contrast.",
+ NounVerbConfusion::default(),
+ "Screen brightness settings can affect perceived contrast.",
+ );
+ }
+
+ #[test]
+ fn corrects_medication_effect_him() {
+ assert_suggestion_result(
+ "The medication didn't effect him the way the doctor expected.",
+ NounVerbConfusion::default(),
+ "The medication didn't affect him the way the doctor expected.",
+ );
+ }
+
+ #[test]
+ fn corrects_payments_effect_credit() {
+ assert_suggestion_result(
+ "Late payments will negatively effect your credit score.",
+ NounVerbConfusion::default(),
+ "Late payments will negatively affect your credit score.",
+ );
+ }
+
+ #[test]
+ fn corrects_wording_effect_interpretation() {
+ assert_suggestion_result(
+ "Minor wording tweaks shouldn't effect the legal interpretation.",
+ NounVerbConfusion::default(),
+ "Minor wording tweaks shouldn't affect the legal interpretation.",
+ );
+ }
+
+ #[test]
+ fn corrects_traffic_effect_delivery() {
+ assert_suggestion_result(
+ "Traffic patterns often effect delivery windows downtown.",
+ NounVerbConfusion::default(),
+ "Traffic patterns often affect delivery windows downtown.",
+ );
+ }
+
+ #[test]
+ fn corrects_rumor_effect_confidence() {
+ assert_suggestion_result(
+ "The rumor started to effect investor confidence by noon.",
+ NounVerbConfusion::default(),
+ "The rumor started to affect investor confidence by noon.",
+ );
+ }
+
+ #[test]
+ fn corrects_allergies_effect_productivity() {
+ assert_suggestion_result(
+ "Seasonal allergies badly effect her productivity each April.",
+ NounVerbConfusion::default(),
+ "Seasonal allergies badly affect her productivity each April.",
+ );
+ }
+
+ #[test]
+ fn corrects_feedback_effect_roadmap() {
+ assert_suggestion_result(
+ "Your feedback won't immediately effect the roadmap.",
+ NounVerbConfusion::default(),
+ "Your feedback won't immediately affect the roadmap.",
+ );
+ }
+
+ #[test]
+ fn corrects_rules_effect_honeypot() {
+ assert_suggestion_result(
+ "I cant seem to get my additional rules to effect the honeypot",
+ NounVerbConfusion::default(),
+ "I cant seem to get my additional rules to affect the honeypot",
+ );
+ }
+
+ #[test]
+ fn corrects_bandwidth_effect_video() {
+ assert_suggestion_result(
+ "Fluctuating bandwidth can effect video call quality.",
+ NounVerbConfusion::default(),
+ "Fluctuating bandwidth can affect video call quality.",
+ );
+ }
+
+ #[test]
+ fn corrects_gradient_effect_sensor() {
+ assert_suggestion_result(
+ "The temperature gradient might effect the sensor's calibration.",
+ NounVerbConfusion::default(),
+ "The temperature gradient might affect the sensor's calibration.",
+ );
+ }
+
+ #[test]
+ fn corrects_delays_effect_satisfaction() {
+ assert_suggestion_result(
+ "Even tiny delays can effect user satisfaction metrics.",
+ NounVerbConfusion::default(),
+ "Even tiny delays can affect user satisfaction metrics.",
+ );
+ }
+
+ #[test]
+ fn corrects_architecture_effect_gps() {
+ assert_suggestion_result(
+ "The surrounding architecture can effect GPS accuracy.",
+ NounVerbConfusion::default(),
+ "The surrounding architecture can affect GPS accuracy.",
+ );
+ }
+
+ #[test]
+ fn corrects_lighting_effect_color() {
+ assert_suggestion_result(
+ "Lighting conditions strongly effect color perception.",
+ NounVerbConfusion::default(),
+ "Lighting conditions strongly affect color perception.",
+ );
+ }
+
+ #[test]
+ fn corrects_coach_effect_roles() {
+ assert_suggestion_result(
+ "The new coach's strategy will effect players' roles.",
+ NounVerbConfusion::default(),
+ "The new coach's strategy will affect players' roles.",
+ );
+ }
+
+ #[test]
+ fn corrects_overtraining_effect_reaction() {
+ assert_suggestion_result(
+ "Overtraining can effect reaction time and coordination.",
+ NounVerbConfusion::default(),
+ "Overtraining can affect reaction time and coordination.",
+ );
+ }
+
+ #[test]
+ fn corrects_label_effect_behavior() {
+ assert_suggestion_result(
+ "The warning label may effect how consumers use the product.",
+ NounVerbConfusion::default(),
+ "The warning label may affect how consumers use the product.",
+ );
+ }
+
+ // `affect` mistakenly used as the noun `effect`.
+ #[test]
+ fn corrects_because_affect_is() {
+ assert_suggestion_result(
+ "I worry because affect is hidden.",
+ NounVerbConfusion::default(),
+ "I worry because effect is hidden.",
+ );
+ }
+
+ #[test]
+ fn ignores_psychology_usage() {
+ assert_lint_count(
+ "The patient's affect is flat.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn corrects_positive_affect_on() {
+ assert_suggestion_result(
+ "The new law had a positive affect on small businesses.",
+ NounVerbConfusion::default(),
+ "The new law had a positive effect on small businesses.",
+ );
+ }
+
+ #[test]
+ fn corrects_great_affect() {
+ assert_suggestion_result(
+ "badges that they provide to users to allow them to promote their projects to great affect",
+ NounVerbConfusion::default(),
+ "badges that they provide to users to allow them to promote their projects to great effect",
+ );
+ }
+
+ #[test]
+ fn corrects_affect_of() {
+ assert_suggestion_result(
+ "We measured the affect of caffeine on reaction time.",
+ NounVerbConfusion::default(),
+ "We measured the effect of caffeine on reaction time.",
+ );
+ }
+
+ #[test]
+ fn corrects_side_affects() {
+ assert_suggestion_result(
+ "The side affects included nausea and fatigue.",
+ NounVerbConfusion::default(),
+ "The side effects included nausea and fatigue.",
+ );
+ }
+
+ #[test]
+ fn corrects_cause_and_affect() {
+ assert_suggestion_result(
+ "Cause and affect are not the same thing.",
+ NounVerbConfusion::default(),
+ "Cause and effect are not the same thing.",
+ );
+ }
+
+ #[test]
+ fn corrects_have_an_affect_on() {
+ assert_suggestion_result(
+ "The change will have an affect on our revenue.",
+ NounVerbConfusion::default(),
+ "The change will have an effect on our revenue.",
+ );
+ }
+
+ #[test]
+ fn corrects_took_affect() {
+ assert_suggestion_result(
+ "The medicine took affect within minutes.",
+ NounVerbConfusion::default(),
+ "The medicine took effect within minutes.",
+ );
+ }
+
+ #[test]
+ fn corrects_come_into_affect() {
+ assert_suggestion_result(
+ "The policy will come into affect on October 1.",
+ NounVerbConfusion::default(),
+ "The policy will come into effect on October 1.",
+ );
+ }
+
+ #[test]
+ fn corrects_in_affect_sentence() {
+ assert_suggestion_result(
+ "The rules are now in affect.",
+ NounVerbConfusion::default(),
+ "The rules are now in effect.",
+ );
+ }
+
+ #[test]
+ fn corrects_with_immediate_affect() {
+ assert_suggestion_result(
+ "With immediate affect, the office is closed.",
+ NounVerbConfusion::default(),
+ "With immediate effect, the office is closed.",
+ );
+ }
+
+ #[test]
+ fn corrects_special_affects() {
+ assert_suggestion_result(
+ "The director used stunning special affects.",
+ NounVerbConfusion::default(),
+ "The director used stunning special effects.",
+ );
+ }
+
+ #[test]
+ fn corrects_placebo_affect() {
+ assert_suggestion_result(
+ "The placebo affect can be powerful.",
+ NounVerbConfusion::default(),
+ "The placebo effect can be powerful.",
+ );
+ }
+
+ #[test]
+ fn corrects_ripple_affect() {
+ assert_suggestion_result(
+ "We felt the ripple affect across the entire market.",
+ NounVerbConfusion::default(),
+ "We felt the ripple effect across the entire market.",
+ );
+ }
+
+ #[test]
+ fn corrects_snowball_affect() {
+ assert_suggestion_result(
+ "The snowball affect amplified the problem.",
+ NounVerbConfusion::default(),
+ "The snowball effect amplified the problem.",
+ );
+ }
+
+ #[test]
+ fn corrects_knock_on_affect() {
+ assert_suggestion_result(
+ "That decision had a knock-on affect throughout the team.",
+ NounVerbConfusion::default(),
+ "That decision had a knock-on effect throughout the team.",
+ );
+ }
+
+ #[test]
+ fn corrects_greenhouse_affect() {
+ assert_suggestion_result(
+ "The greenhouse affect warms the planet.",
+ NounVerbConfusion::default(),
+ "The greenhouse effect warms the planet.",
+ );
+ }
+
+ #[test]
+ fn corrects_little_affect() {
+ assert_suggestion_result(
+ "Her apology had little affect.",
+ NounVerbConfusion::default(),
+ "Her apology had little effect.",
+ );
+ }
+
+ #[test]
+ fn corrects_go_into_affect() {
+ assert_suggestion_result(
+ "The new settings go into affect after a restart.",
+ NounVerbConfusion::default(),
+ "The new settings go into effect after a restart.",
+ );
+ }
+
+ #[test]
+ fn corrects_put_plan_into_affect() {
+ assert_suggestion_result(
+ "They put the new plan into affect last week.",
+ NounVerbConfusion::default(),
+ "They put the new plan into effect last week.",
+ );
+ }
+
+ #[test]
+ fn corrects_contract_into_affect() {
+ assert_suggestion_result(
+ "The contract comes into affect at midnight.",
+ NounVerbConfusion::default(),
+ "The contract comes into effect at midnight.",
+ );
+ }
+
+ #[test]
+ fn corrects_no_affect_on_behavior() {
+ assert_suggestion_result(
+ "The warning had no affect on his behavior.",
+ NounVerbConfusion::default(),
+ "The warning had no effect on his behavior.",
+ );
+ }
+
+ #[test]
+ fn corrects_opposite_affect() {
+ assert_suggestion_result(
+ "Inflation had the opposite affect than expected.",
+ NounVerbConfusion::default(),
+ "Inflation had the opposite effect than expected.",
+ );
+ }
+
+ #[test]
+ fn corrects_remains_in_affect() {
+ assert_suggestion_result(
+ "The regulation remains in affect until further notice.",
+ NounVerbConfusion::default(),
+ "The regulation remains in effect until further notice.",
+ );
+ }
+
+ #[test]
+ fn corrects_take_affect_next_week() {
+ assert_suggestion_result(
+ "The app changes take affect next week.",
+ NounVerbConfusion::default(),
+ "The app changes take effect next week.",
+ );
+ }
+
+ #[test]
+ fn corrects_sound_affects() {
+ assert_suggestion_result(
+ "Sound affects were added in post.",
+ NounVerbConfusion::default(),
+ "Sound effects were added in post.",
+ );
+ }
+
+ #[test]
+ fn does_not_flag_best_affect() {
+ assert_lint_count(
+ "Using linear regression to predict and understand what factors best affect house price",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn does_not_flag_sound_affect() {
+ assert_lint_count(
+ "The goal of this study was to learn what properties of sound affect human focus the most.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn corrects_sound_affect() {
+ assert_suggestion_result(
+ "Diesel Generator's animation returns to 'idle' state, but it's sound affect remains in the 'work' state.",
+ NounVerbConfusion::default(),
+ "Diesel Generator's animation returns to 'idle' state, but it's sound effect remains in the 'work' state.",
+ );
+ }
+
+ #[test]
+ fn does_not_flag_affect_as_verb() {
+ assert_lint_count(
+ "The change will affect our revenue significantly.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn does_not_flag_affects_as_verb() {
+ assert_lint_count(
+ "This policy directly affects remote workers.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn does_not_flag_correct_effect_noun() {
+ assert_lint_count(
+ "The placebo effect can be powerful.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+
+ #[test]
+ fn does_not_flag_sound_effects() {
+ assert_lint_count(
+ "Sound effects were added in post.",
+ NounVerbConfusion::default(),
+ 0,
+ );
+ }
+}
diff --git a/harper-core/src/linting/noun_verb_confusion/noun_instead_of_verb.rs b/harper-core/src/linting/noun_verb_confusion/noun_instead_of_verb.rs
deleted file mode 100644
index 99602b6b4..000000000
--- a/harper-core/src/linting/noun_verb_confusion/noun_instead_of_verb.rs
+++ /dev/null
@@ -1,515 +0,0 @@
-use crate::expr::{Expr, FirstMatchOf, LongestMatchOf, SequenceExpr};
-use crate::linting::{ExprLinter, Lint, LintKind, Suggestion};
-use crate::patterns::Word;
-use crate::{CharStringExt, Lrc, Token, patterns::WordSet};
-
-use super::NOUN_VERB_PAIRS;
-
-/// Pronouns that can come before verbs but not nouns
-const PRONOUNS: &[&str] = &["he", "I", "it", "she", "they", "we", "who", "you"];
-
-/// Adverbs that can come before verbs but not nouns
-/// Note: "Sometimes" can come before a noun.
-const ADVERBS: &[&str] = &["always", "never", "often", "seldom"];
-
-/// Modal verbs that can come before other verbs but not nouns
-const MODAL_VERBS_ETC: &[&str] = &[
- "can",
- "cannot",
- "can't",
- "could",
- "couldn't",
- "may",
- "might",
- "mightn't",
- "must",
- "mustn't",
- "shall",
- "shan't",
- "should",
- "shouldn't",
- "will",
- "won't",
- "would",
- "wouldn't",
- // not modals per se, but modal-like
- "do",
- "don't",
-];
-
-/// Linter that corrects common noun/verb confusions
-pub struct NounInsteadOfVerb {
- expr: Box<dyn Expr>,
-}
-
-impl Default for NounInsteadOfVerb {
- fn default() -> Self {
- let pre_context = FirstMatchOf::new(vec![
- Box::new(WordSet::new(PRONOUNS)),
- Box::new(WordSet::new(MODAL_VERBS_ETC)),
- Box::new(WordSet::new(ADVERBS)),
- Box::new(Word::new("to")),
- ]);
-
- let nouns = Lrc::new(WordSet::new(
- &NOUN_VERB_PAIRS
- .iter()
- .map(|&(noun, _)| noun)
- .collect::<Vec<_>>(),
- ));
-
- let basic_pattern = Lrc::new(
- SequenceExpr::default()
- .then(pre_context)
- .then_whitespace()
- .then(nouns.clone()),
- );
-
- let pattern_followed_by_punctuation = SequenceExpr::default()
- .then(basic_pattern.clone())
- .then_punctuation();
-
- let pattern_followed_by_word = SequenceExpr::default()
- .then(basic_pattern.clone())
- .then_whitespace()
- .then_any_word();
-
- Self {
- expr: Box::new(LongestMatchOf::new(vec![
- Box::new(pattern_followed_by_punctuation),
- Box::new(pattern_followed_by_word),
- Box::new(basic_pattern),
- ])),
- }
- }
-}
-
-impl ExprLinter for NounInsteadOfVerb {
- fn expr(&self) -> &dyn Expr {
- self.expr.as_ref()
- }
-
- fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
- let prev_tok = &toks[0];
-
- // If we have the next word token, try to rule out compound nouns
- if toks.len() > 4 {
- let following_tok = &toks[4];
- if following_tok.kind.is_noun() && !following_tok.kind.is_preposition() {
- // But first rule out marginal "nouns"
- let following_lower = following_tok.span.get_content_string(src).to_lowercase();
- if following_lower != "it"
- && following_lower != "me"
- && following_lower != "on"
- && following_lower != "that"
- {
- return None;
- }
- }
-
- // If the previous word is "to", use the following word to disambiguate
- if prev_tok
- .span
- .get_content(src)
- .eq_ignore_ascii_case_chars(&['t', 'o'])
- && !following_tok.kind.is_determiner()
- {
- return None;
- }
- }
-
- // If we don't have the next word token, don't continue if the previous token is "to"
- // since "to" is a preposition and an infinitive marker and there's not enough context to disambiguate.
- if toks.len() <= 4
- && prev_tok
- .span
- .get_content(src)
- .eq_ignore_ascii_case_chars(&['t', 'o'])
- {
- return None;
- }
-
- let noun_tok = &toks[2];
- let noun_chars = noun_tok.span.get_content(src);
- let noun_text = noun_tok.span.get_content_string(src);
- let noun_lower = noun_text.to_lowercase();
-
- let verb = NOUN_VERB_PAIRS
- .iter()
- .find(|(noun, _)| *noun == noun_lower)
- .map(|(_, verb)| verb)?;
-
- Some(Lint {
- span: noun_tok.span,
- lint_kind: LintKind::WordChoice,
- suggestions: vec![Suggestion::replace_with_match_case(
- verb.chars().collect(),
- noun_chars,
- )],
- message: format!("`{noun_text}` is a noun, the verb should be `{verb}`."),
- priority: 63,
- })
- }
-
- fn description(&self) -> &'static str {
- "Corrects nouns used instead of verbs when the two are related."
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::NounInsteadOfVerb;
- use crate::linting::tests::{assert_lint_count, assert_suggestion_result};
-
- // made up unit tests
-
- #[test]
- fn corrects_belief_instead_of_verb() {
- assert_suggestion_result(
- "I belief in you.",
- NounInsteadOfVerb::default(),
- "I believe in you.",
- );
- }
-
- #[test]
- #[ignore = "`to` can't disambiguate since it's valid between verbs and nouns"]
- fn corrects_breath_instead_of_verb() {
- assert_suggestion_result(
- "Remember to breath deeply.",
- NounInsteadOfVerb::default(),
- "Remember to breathe deeply.",
- );
- }
-
- #[test]
- fn does_not_flag_correct_believe() {
- assert_lint_count("I believe in you.", NounInsteadOfVerb::default(), 0);
- }
-
- #[test]
- fn does_not_flag_correct_breath() {
- assert_lint_count("Take a deep breath.", NounInsteadOfVerb::default(), 0);
- }
-
- // real-world example unit tests
-
- #[test]
- fn fix_when_i_breath_you_breath() {
- assert_suggestion_result(
- "When I breath, you breath!",
- NounInsteadOfVerb::default(),
- "When I breathe, you breathe!",
- );
- }
-
- #[test]
- fn fix_weather_climate_and_the_air_we_breath() {
- assert_suggestion_result(
- "Weather Climate and the Air We Breath",
- NounInsteadOfVerb::default(),
- "Weather Climate and the Air We Breathe",
- );
- }
-
- #[test]
- fn fix_always_breath() {
- assert_suggestion_result(
- "breathing. remember to always breath.",
- NounInsteadOfVerb::default(),
- "breathing. remember to always breathe.",
- );
- }
-
- #[test]
- fn fix_never_breath_a_word() {
- assert_suggestion_result(
- "And never breath a word about your loss; If you can force your heart and nerve and sinew.",
- NounInsteadOfVerb::default(),
- "And never breathe a word about your loss; If you can force your heart and nerve and sinew.",
- );
- }
-
- #[test]
- fn fix_breath_for_seconds() {
- assert_suggestion_result(
- "Once turned on, the LED on the TX unit would breath for a few seconds, then go completely dead and not responding to objects in front of the sensors.",
- NounInsteadOfVerb::default(),
- "Once turned on, the LED on the TX unit would breathe for a few seconds, then go completely dead and not responding to objects in front of the sensors.",
- );
- }
-
- #[test]
- fn fix_breath_a_little_more_life() {
- assert_suggestion_result(
- "... up to 12% more performance, could breath a little more life into systems as old as Sandy Bridge.",
- NounInsteadOfVerb::default(),
- "... up to 12% more performance, could breathe a little more life into systems as old as Sandy Bridge.",
- );
- }
-
- #[test]
- fn fix_the_diversity_we_breath() {
- assert_suggestion_result(
- "The Diversity We Breath: Community Diversity",
- NounInsteadOfVerb::default(),
- "The Diversity We Breathe: Community Diversity",
- );
- }
-
- #[test]
- fn fix_belief() {
- assert_suggestion_result(
- "While I have no plans to return to aerospace I belief it gives me a unique perspective to many challenges.",
- NounInsteadOfVerb::default(),
- "While I have no plans to return to aerospace I believe it gives me a unique perspective to many challenges.",
- );
- }
-
- #[test]
- fn fix_we_belief() {
- assert_suggestion_result(
- "In contrast to other vendors in e-mobility, we belief that true transparency is only trustworthy if the entire process ...",
- NounInsteadOfVerb::default(),
- "In contrast to other vendors in e-mobility, we believe that true transparency is only trustworthy if the entire process ...",
- );
- }
-
- #[test]
- #[ignore = "`underwater` is a marginal noun so `breath underwater` matches the compound noun test."]
- fn fix_i_can_breath() {
- assert_suggestion_result(
- "Steps to reproduce Expected behaviour I can breath underwater.",
- NounInsteadOfVerb::default(),
- "Steps to reproduce Expected behaviour I can breathe underwater.",
- );
- }
-
- #[test]
- fn fix_caps_should_breath() {
- assert_suggestion_result(
- "CAPS 1 2 3 4 5 A B C D SHOULD BREATH A BIT MORE ?",
- NounInsteadOfVerb::default(),
- "CAPS 1 2 3 4 5 A B C D SHOULD BREATHE A BIT MORE ?",
- );
- }
-
- #[test]
- fn fix_can_you_advice_me() {
- assert_suggestion_result(
- "Can you advice me how to train?",
- NounInsteadOfVerb::default(),
- "Can you advise me how to train?",
- );
- }
-
- #[test]
- fn fix_we_can_advice_you() {
- assert_suggestion_result(
- "Feel free to share more details about your use case, so we can advice you specifically based on your case.",
- NounInsteadOfVerb::default(),
- "Feel free to share more details about your use case, so we can advise you specifically based on your case.",
- );
- }
-
- #[test]
- fn fix_would_advice_against() {
- assert_suggestion_result(
- "So that I would advice against using a spindle in laser mode.",
- NounInsteadOfVerb::default(),
- "So that I would advise against using a spindle in laser mode.",
- );
- }
-
- #[test]
- fn fix_advice_to_listen() {
- assert_suggestion_result(
- "The idea of this applicaton was inspired by Ray Dalio, who always advice to listen to people who know more than us by experience.",
- NounInsteadOfVerb::default(),
- "The idea of this applicaton was inspired by Ray Dalio, who always advise to listen to people who know more than us by experience.",
- );
- }
-
- #[test]
- #[ignore = "`You` is an object pronoun in this example. `It` is also both subject and object."]
- fn dont_fix_advice_on_that() {
- assert_lint_count(
- "I don't do table returning functions in my code so can't offer you advice on that.",
- NounInsteadOfVerb::default(),
- 0,
- );
- }
-
- #[test]
- fn fix_advice_to_stick_with_openvscode() {
- assert_suggestion_result(
- "But unless you really need it, I would advice to stick with openvscode as there are nearly the same.",
- NounInsteadOfVerb::default(),
- "But unless you really need it, I would advise to stick with openvscode as there are nearly the same.",
- );
- }
-
- #[test]
- fn fix_advice_to_back_up_os_image() {
- assert_suggestion_result(
- "I would advice to back up all OS image before any update, because you could lose something what was working previously.",
- NounInsteadOfVerb::default(),
- "I would advise to back up all OS image before any update, because you could lose something what was working previously.",
- );
- }
-
- #[test]
- fn fix_advice_to_use_ms_store() {
- assert_suggestion_result(
- "I know we can always advice to use the MS store to download JASP instead",
- NounInsteadOfVerb::default(),
- "I know we can always advise to use the MS store to download JASP instead",
- );
- }
-
- #[test]
- fn fix_should_intent_be() {
- assert_suggestion_result(
- "Should intent be on the blocklist?",
- NounInsteadOfVerb::default(),
- "Should intent be on the blocklist?",
- );
- }
-
- #[test]
- fn fix_if_you_intent() {
- assert_suggestion_result(
- "If you intent to use a 64 bits machine, change line 74",
- NounInsteadOfVerb::default(),
- "If you intend to use a 64 bits machine, change line 74",
- );
- }
-
- #[test]
- fn fix_what_you_would_intent_to_do() {
- assert_suggestion_result(
- "May I ask what you would intent to do with such a feature?",
- NounInsteadOfVerb::default(),
- "May I ask what you would intend to do with such a feature?",
- );
- }
-
- #[test]
- fn dont_flag_intent_records() {
- assert_lint_count(
- "there are always intent records associated to the txns",
- NounInsteadOfVerb::default(),
- 0,
- );
- }
-
- #[test]
- fn fix_did_you_always_intent_to() {
- assert_suggestion_result(
- "Did you always intent to fight malware? No.",
- NounInsteadOfVerb::default(),
- "Did you always intend to fight malware? No.",
- );
- }
-
- #[test]
- fn fix_we_recommend_you_create_a_new_issue_on_github_explaining_what_you_intent_to_do() {
- assert_suggestion_result(
- "... we recommend you create a new issue on github explaining what you intent to do.",
- NounInsteadOfVerb::default(),
- "... we recommend you create a new issue on github explaining what you intend to do.",
- );
- }
-
- #[test]
- fn fix_intent_to_use_non_imported_symbol() {
- assert_suggestion_result(
- "There's a warning reported for this code, saying that it may intent to use non-imported symbol",
- NounInsteadOfVerb::default(),
- "There's a warning reported for this code, saying that it may intend to use non-imported symbol",
- );
- }
-
- // tests for preceding "to"
-
- #[test]
- fn fix_to_emphasis_the() {
- assert_suggestion_result(
- "This one could be used in a dialog to emphasis the surprise.",
- NounInsteadOfVerb::default(),
- "This one could be used in a dialog to emphasize the surprise.",
- );
- }
-
- #[test]
- fn allow_to_emphasis_at_end() {
- assert_lint_count(
- "Changes literal underscores to emphasis",
- NounInsteadOfVerb::default(),
- 0,
- );
- }
-
- #[test]
- fn allow_to_effect_noun() {
- assert_lint_count(
- "or it may be desired to effect substitutions",
- NounInsteadOfVerb::default(),
- 0,
- );
- }
-
- #[test]
- fn allow_to_intent_adjective() {
- assert_lint_count(
- "Cleanup passing statistics to intent aware iterator",
- NounInsteadOfVerb::default(),
- 0,
- );
- }
-
- #[test]
- fn fix_to_effect_the() {
- assert_suggestion_result(
- "I cant seem to get my additional rules to effect the honeypot",
- NounInsteadOfVerb::default(),
- "I cant seem to get my additional rules to affect the honeypot",
- );
- }
-
- #[test]
- fn fix_to_advice_a_class() {
- assert_suggestion_result(
- "How to advice a class that have been intercepted by another javaagent",
- NounInsteadOfVerb::default(),
- "How to advise a class that have been intercepted by another javaagent",
- );
- }
-
- #[test]
- fn fix_to_breath_some() {
- assert_suggestion_result(
- "You go to the balcony to breath some fresh air and look down at the things outside.",
- NounInsteadOfVerb::default(),
- "You go to the balcony to breathe some fresh air and look down at the things outside.",
- );
- }
-
- #[test]
- fn fix_to_emphasis_a() {
- assert_suggestion_result(
- "we'd like to emphasis a few points below",
- NounInsteadOfVerb::default(),
- "we'd like to emphasize a few points below",
- );
- }
-
- #[test]
- fn fix_to_advice_their() {
- assert_suggestion_result(
- "People who are managing this situation tend to advice their users to lock+unlock their screen",
- NounInsteadOfVerb::default(),
- "People who are managing this situation tend to advise their users to lock+unlock their screen",
- );
- }
-}
diff --git a/harper-core/src/linting/noun_verb_confusion/noun_instead_of_verb/general.rs b/harper-core/src/linting/noun_verb_confusion/noun_instead_of_verb/general.rs
new file mode 100644
index 000000000..35bd903ae
--- /dev/null
+++ b/harper-core/src/linting/noun_verb_confusion/noun_instead_of_verb/general.rs
@@ -0,0 +1,157 @@
+use crate::expr::{Expr, FirstMatchOf, LongestMatchOf, SequenceExpr};
+use crate::linting::{ExprLinter, Lint, LintKind, Suggestion};
+use crate::patterns::Word;
+use crate::{CharStringExt, Lrc, Token, patterns::WordSet};
+
+use super::super::NOUN_VERB_PAIRS;
+
+/// Pronouns that can come before verbs but not nouns
+const PRONOUNS: &[&str] = &["he", "I", "it", "she", "they", "we", "who", "you"];
+
+/// Adverbs that can come before verbs but not nouns
+/// Note: "Sometimes" can come before a noun.
+const ADVERBS: &[&str] = &["always", "never", "often", "seldom"];
+
+/// Modal verbs that can come before other verbs but not nouns
+const MODAL_VERBS_ETC: &[&str] = &[
+ "can",
+ "cannot",
+ "can't",
+ "could",
+ "couldn't",
+ "may",
+ "might",
+ "mightn't",
+ "must",
+ "mustn't",
+ "shall",
+ "shan't",
+ "should",
+ "shouldn't",
+ "will",
+ "won't",
+ "would",
+ "wouldn't",
+ // not modals per se, but modal-like
+ "do",
+ "don't",
+];
+
+/// Linter that corrects common noun/verb confusions
+pub(super) struct GeneralNounInsteadOfVerb {
+ expr: Box<dyn Expr>,
+}
+
+impl Default for GeneralNounInsteadOfVerb {
+ fn default() -> Self {
+ let pre_context = FirstMatchOf::new(vec![
+ Box::new(WordSet::new(PRONOUNS)),
+ Box::new(WordSet::new(MODAL_VERBS_ETC)),
+ Box::new(WordSet::new(ADVERBS)),
+ Box::new(Word::new("to")),
+ ]);
+
+ let nouns = Lrc::new(WordSet::new(
+ &NOUN_VERB_PAIRS
+ .iter()
+ .map(|&(noun, _)| noun)
+ .collect::<Vec<_>>(),
+ ));
+
+ let basic_pattern = Lrc::new(
+ SequenceExpr::default()
+ .then(pre_context)
+ .then_whitespace()
+ .then(nouns.clone()),
+ );
+
+ let pattern_followed_by_punctuation = SequenceExpr::default()
+ .then(basic_pattern.clone())
+ .then_punctuation();
+
+ let pattern_followed_by_word = SequenceExpr::default()
+ .then(basic_pattern.clone())
+ .then_whitespace()
+ .then_any_word();
+
+ Self {
+ expr: Box::new(LongestMatchOf::new(vec![
+ Box::new(pattern_followed_by_punctuation),
+ Box::new(pattern_followed_by_word),
+ Box::new(basic_pattern),
+ ])),
+ }
+ }
+}
+
+impl ExprLinter for GeneralNounInsteadOfVerb {
+ fn expr(&self) -> &dyn Expr {
+ self.expr.as_ref()
+ }
+
+ fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
+ let prev_tok = &toks[0];
+
+ // If we have the next word token, try to rule out compound nouns
+ if toks.len() > 4 {
+ let following_tok = &toks[4];
+ if following_tok.kind.is_noun() && !following_tok.kind.is_preposition() {
+ // But first rule out marginal "nouns"
+ let following_lower = following_tok.span.get_content_string(src).to_lowercase();
+ if following_lower != "it"
+ && following_lower != "me"
+ && following_lower != "on"
+ && following_lower != "that"
+ {
+ return None;
+ }
+ }
+
+ // If the previous word is "to", use the following word to disambiguate
+ if prev_tok
+ .span
+ .get_content(src)
+ .eq_ignore_ascii_case_chars(&['t', 'o'])
+ && !following_tok.kind.is_determiner()
+ {
+ return None;
+ }
+ }
+
+ // If we don't have the next word token, don't continue if the previous token is "to"
+ // since "to" is a preposition and an infinitive marker and there's not enough context to disambiguate.
+ if toks.len() <= 4
+ && prev_tok
+ .span
+ .get_content(src)
+ .eq_ignore_ascii_case_chars(&['t', 'o'])
+ {
+ return None;
+ }
+
+ let noun_tok = &toks[2];
+ let noun_chars = noun_tok.span.get_content(src);
+ let noun_text = noun_tok.span.get_content_string(src);
+ let noun_lower = noun_text.to_lowercase();
+
+ let verb = NOUN_VERB_PAIRS
+ .iter()
+ .find(|(noun, _)| *noun == noun_lower)
+ .map(|(_, verb)| verb)?;
+
+ Some(Lint {
+ span: noun_tok.span,
+ lint_kind: LintKind::WordChoice,
+ suggestions: vec![Suggestion::replace_with_match_case(
+ verb.chars().collect(),
+ noun_chars,
+ )],
+ message: format!("`{noun_text}` is a noun, the verb should be `{verb}`."),
+ priority: 63,
+ })
+ }
+
+ fn description(&self) -> &'static str {
+ "Corrects nouns used instead of verbs when the two are related."
+ }
+}
diff --git a/harper-core/src/linting/noun_verb_confusion/noun_instead_of_verb/mod.rs b/harper-core/src/linting/noun_verb_confusion/noun_instead_of_verb/mod.rs
new file mode 100644
index 000000000..494a34d56
--- /dev/null
+++ b/harper-core/src/linting/noun_verb_confusion/noun_instead_of_verb/mod.rs
@@ -0,0 +1,12 @@
+mod general;
+
+use super::effect_affect::EffectAffect;
+use crate::linting::merge_linters::merge_linters;
+use general::GeneralNounInsteadOfVerb;
+
+merge_linters! {
+ NounInsteadOfVerb =>
+ GeneralNounInsteadOfVerb,
+ EffectAffect
+ => "Corrects noun/verb confusions such as `advice/advise` and handles the common `effect/affect` mix-up."
+}
diff --git a/harper-core/src/linting/noun_verb_confusion/verb_instead_of_noun.rs b/harper-core/src/linting/noun_verb_confusion/verb_instead_of_noun.rs
index 1304f6012..cbb1c333b 100644
--- a/harper-core/src/linting/noun_verb_confusion/verb_instead_of_noun.rs
+++ b/harper-core/src/linting/noun_verb_confusion/verb_instead_of_noun.rs
@@ -4,6 +4,7 @@ use crate::{
linting::{ExprLinter, Lint, LintKind, Suggestion},
patterns::WordSet,
};
+use harper_brill::UPOS;
use super::NOUN_VERB_PAIRS;
@@ -43,6 +44,10 @@ impl ExprLinter for VerbInsteadOfNoun {
let verb_text = verb_tok.span.get_content_string(src);
let verb_lower = verb_text.to_lowercase();
+ if adj_tok.kind.is_auxiliary_verb() || adj_tok.kind.is_upos(UPOS::AUX) {
+ return None;
+ }
+
let noun = NOUN_VERB_PAIRS
.iter()
.find(|(_, verb)| *verb == verb_lower)
@@ -75,115 +80,3 @@ impl ExprLinter for VerbInsteadOfNoun {
"Corrects verbs used instead of nouns when the two are related."
}
}
-
-#[cfg(test)]
-mod tests {
- use super::VerbInsteadOfNoun;
- use crate::linting::tests::{assert_lint_count, assert_suggestion_result};
-
- #[test]
- fn corrects_good_advise() {
- assert_suggestion_result("Good advise", VerbInsteadOfNoun::default(), "Good advice");
- }
-
- #[test]
- fn corrects_bad_advise() {
- assert_suggestion_result(
- "I just wanted to bring attention to this because it stood out to me as potentially bad advise.",
- VerbInsteadOfNoun::default(),
- "I just wanted to bring attention to this because it stood out to me as potentially bad advice.",
- );
- }
-
- #[test]
- fn dont_flag_correct_better_advise() {
- assert_lint_count(
- "Hello! I am an engineer at Plexon and am conducting tests with Kilosort4 so we can better advise our clients.",
- VerbInsteadOfNoun::default(),
- 0,
- );
- }
-
- #[test]
- #[ignore = "'better advise' can be correct as above, or a mistake like here"]
- fn correct_better_advise() {
- assert_suggestion_result(
- "Maybe this will be a decent idea, .or anybody has better advise :)",
- VerbInsteadOfNoun::default(),
- "Maybe this will be a decent idea, .or anybody has better advice :)",
- );
- }
-
- #[test]
- fn dont_flag_correct_better_believe() {
- assert_lint_count(
- "You'd better believe this is bbedit-gist-maker.",
- VerbInsteadOfNoun::default(),
- 0,
- );
- }
-
- #[test]
- fn correct_great_affect() {
- assert_suggestion_result(
- "badges that they provide to users to allow them to promote their projects to great affect",
- VerbInsteadOfNoun::default(),
- "badges that they provide to users to allow them to promote their projects to great effect",
- );
- }
-
- #[test]
- fn correct_strong_believe() {
- assert_suggestion_result(
- "cause my strong believe is that we must give any user to describe whether a post is meant factual",
- VerbInsteadOfNoun::default(),
- "cause my strong belief is that we must give any user to describe whether a post is meant factual",
- );
- }
-
- #[test]
- fn dont_flag_best_affect() {
- assert_lint_count(
- "Using linear regression to predict and understand what factors best affect house price",
- VerbInsteadOfNoun::default(),
- 0,
- );
- }
-
- #[test]
- fn correct_deep_breathe() {
- assert_suggestion_result(
- "Take deep breathe and Do it again!",
- VerbInsteadOfNoun::default(),
- "Take deep breath and Do it again!",
- );
- }
-
- #[test]
- fn dont_flag_sound_affect() {
- assert_lint_count(
- "The goal of this study was to learn what properties of sound affect human focus the most.",
- VerbInsteadOfNoun::default(),
- 0,
- );
- }
-
- #[test]
- #[ignore = "`Affect` is both verb and noun, so we can't disambiguate without more context"]
- fn correct_sound_affect() {
- assert_suggestion_result(
- "Diesel Generator's animation returns to 'idle' state, but it's sound affect remains in the 'work' state.",
- VerbInsteadOfNoun::default(),
- "Diesel Generator's animation returns to 'idle' state, but it's sound effect remains in the 'work' state.",
- );
- }
-
- #[test]
- fn correct_bad_intend() {
- assert_suggestion_result(
- "What do you do if you only see slightly longer posts that may still be acceptable (and not bad intend from the poster)",
- VerbInsteadOfNoun::default(),
- "What do you do if you only see slightly longer posts that may still be acceptable (and not bad intent from the poster)",
- );
- }
-}