Skip to content

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

feat: would've never/would never have→never would have (#1794)

Andrew Dunbarf3e9a6a47e0f
diff --git a/harper-core/src/linting/lint_group.rs b/harper-core/src/linting/lint_group.rs
index ade9b36dc..d4c4822bb 100644
--- a/harper-core/src/linting/lint_group.rs
+++ b/harper-core/src/linting/lint_group.rs
@@ -125,6 +125,7 @@ use super::whereas::Whereas;
use super::widely_accepted::WidelyAccepted;
use super::win_prize::WinPrize;
use super::wordpress_dotcom::WordPressDotcom;
+use super::would_never_have::WouldNeverHave;
use super::{CurrencyPlacement, HtmlDescriptionLinter, Linter, NoOxfordComma, OxfordComma};
use super::{ExprLinter, Lint};
use crate::linting::dashes::Dashes;
@@ -514,6 +515,7 @@ impl LintGroup {
insert_expr_rule!(WidelyAccepted, true);
insert_expr_rule!(WinPrize, true);
insert_struct_rule!(WordPressDotcom, true);
+ insert_expr_rule!(WouldNeverHave, true);
out.add("SpellCheck", SpellCheck::new(dictionary.clone(), dialect));
out.config.set_rule_enabled("SpellCheck", true);
diff --git a/harper-core/src/linting/mod.rs b/harper-core/src/linting/mod.rs
index c27e3cf3b..2b5cb774b 100644
--- a/harper-core/src/linting/mod.rs
+++ b/harper-core/src/linting/mod.rs
@@ -139,6 +139,7 @@ mod whereas;
mod widely_accepted;
mod win_prize;
mod wordpress_dotcom;
+mod would_never_have;
pub use a_part::APart;
pub use adjective_double_degree::AdjectiveDoubleDegree;
@@ -263,6 +264,7 @@ pub use whereas::Whereas;
pub use widely_accepted::WidelyAccepted;
pub use win_prize::WinPrize;
pub use wordpress_dotcom::WordPressDotcom;
+pub use would_never_have::WouldNeverHave;
use crate::{Document, LSend, render_markdown};
diff --git a/harper-core/src/linting/would_never_have.rs b/harper-core/src/linting/would_never_have.rs
new file mode 100644
index 000000000..060ffa532
--- /dev/null
+++ b/harper-core/src/linting/would_never_have.rs
@@ -0,0 +1,180 @@
+use crate::{
+ Token,
+ expr::{Expr, FixedPhrase, SequenceExpr},
+ linting::{ExprLinter, Lint, LintKind, Suggestion},
+ token_string_ext::TokenStringExt,
+};
+
+pub struct WouldNeverHave {
+ expr: Box<dyn Expr>,
+}
+
+impl Default for WouldNeverHave {
+ fn default() -> Self {
+ let phrases = [
+ "could have never",
+ "could never have",
+ "could've never",
+ "couldve never",
+ "would have never",
+ "would never have",
+ "would've never",
+ "wouldve never",
+ ];
+
+ let expr: Vec<Box<dyn Expr>> = phrases
+ .iter()
+ .map(|&phrase| Box::new(FixedPhrase::from_phrase(phrase)) as Box<dyn Expr>)
+ .collect();
+
+ // TODO: verb should be perfect form ("done", "happened", etc.) when verb property changes are merged
+ let expr = SequenceExpr::any_of(expr).then_whitespace().then_verb();
+
+ Self {
+ expr: Box::new(expr),
+ }
+ }
+}
+
+impl ExprLinter for WouldNeverHave {
+ fn expr(&self) -> &dyn Expr {
+ self.expr.as_ref()
+ }
+
+ fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
+ let modal_have_toks = toks.first()?;
+ let modal_have_chars = modal_have_toks.span.get_content(src);
+ let modal_have_str = modal_have_toks.span.get_content_string(src).to_lowercase();
+
+ let modal = if modal_have_str.starts_with("could") {
+ "could"
+ } else if modal_have_str.starts_with("would") {
+ "would"
+ } else {
+ return None;
+ };
+
+ let is_contraction = modal_have_str.ends_with("ve");
+
+ let new_phrasing = format!(
+ "never {modal}{}",
+ if is_contraction { "'ve" } else { " have" }
+ );
+
+ let suggestions = vec![Suggestion::replace_with_match_case(
+ new_phrasing.chars().collect(),
+ modal_have_chars,
+ )];
+
+ let message = format!("For a more standard style, consider using `{new_phrasing}`.");
+
+ Some(Lint {
+ span: toks[..toks.len() - 2].span()?,
+ lint_kind: LintKind::Style,
+ suggestions,
+ message,
+ ..Default::default()
+ })
+ }
+
+ fn description(&self) -> &str {
+ "Corrects `would/could have never` to `never would/could have`."
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::WouldNeverHave;
+ use crate::linting::tests::assert_suggestion_result;
+
+ #[test]
+ fn fix_could_have_never_been() {
+ assert_suggestion_result(
+ "Having a conversation would have never been easier with Ramen!",
+ WouldNeverHave::default(),
+ "Having a conversation never would have been easier with Ramen!",
+ );
+ }
+
+ #[test]
+ fn fix_would_have_never_come() {
+ assert_suggestion_result(
+ "This would have never come about without the help and encouragement of many people, too numerous to mention here.",
+ WouldNeverHave::default(),
+ "This never would have come about without the help and encouragement of many people, too numerous to mention here.",
+ );
+ }
+
+ #[test]
+ fn fix_would_have_never_find() {
+ assert_suggestion_result(
+ "Thanks for the help, think I would have never find it out alone.",
+ WouldNeverHave::default(),
+ "Thanks for the help, think I never would have find it out alone.",
+ );
+ }
+
+ #[test]
+ fn fix_all_caps() {
+ assert_suggestion_result(
+ "I WOULD'VE NEVER THOUGHT TO TEST ALL CAPS.",
+ WouldNeverHave::default(),
+ "I NEVER WOULD'VE THOUGHT TO TEST ALL CAPS.",
+ );
+ }
+
+ #[test]
+ #[ignore = "Fails due to the strange way replace_with_match_case works"]
+ fn fix_title_case() {
+ assert_suggestion_result(
+ "I Would Never Have Thought To Test Title Case English.",
+ WouldNeverHave::default(),
+ "I Never Would Have Thought To Test Title Case English.",
+ );
+ }
+
+ #[test]
+ fn fix_could_never_have_worked() {
+ assert_suggestion_result(
+ "ft_quantile_discretizer could never have worked",
+ WouldNeverHave::default(),
+ "ft_quantile_discretizer never could have worked",
+ );
+ }
+
+ #[test]
+ fn fix_would_never_have_thought_of() {
+ assert_suggestion_result(
+ "We discover security flaws that your team would never have thought of.",
+ WouldNeverHave::default(),
+ "We discover security flaws that your team never would have thought of.",
+ );
+ }
+
+ #[test]
+ fn fix_wouldve_never_known_missing_apostrophe() {
+ assert_suggestion_result(
+ "We wouldve never known from the current api docs",
+ WouldNeverHave::default(),
+ "We never would've known from the current api docs",
+ );
+ }
+
+ #[test]
+ fn fix_wouldve_never_grokked() {
+ assert_suggestion_result(
+ "I would've never grokked that it's an issue in rollup.",
+ WouldNeverHave::default(),
+ "I never would've grokked that it's an issue in rollup.",
+ );
+ }
+
+ #[test]
+ fn fix_couldve_never_designed() {
+ assert_suggestion_result(
+ "Without my subscription I could've never designed this in such little time without it.",
+ WouldNeverHave::default(),
+ "Without my subscription I never could've designed this in such little time without it.",
+ );
+ }
+}