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.rsindex 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 @@ wherefn 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.rsindex 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsindex 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 messagemerge_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.rsdeleted file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsindex 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)",- );- }-}