Skip to content

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

feat: worth to do → worth doing (#2638)

Andrew Dunbar639ef0ee4eb6
diff --git a/harper-core/src/linting/lint_group.rs b/harper-core/src/linting/lint_group.rs
index 9df3c2eaa..6e50e2bda 100644
--- a/harper-core/src/linting/lint_group.rs
+++ b/harper-core/src/linting/lint_group.rs
@@ -222,7 +222,9 @@ use super::widely_accepted::WidelyAccepted;
use super::win_prize::WinPrize;
use super::wish_could::WishCould;
use super::wordpress_dotcom::WordPressDotcom;
+use super::worth_to_do::WorthToDo;
use super::would_never_have::WouldNeverHave;
+
use super::{ExprLinter, Lint};
use super::{HtmlDescriptionLinter, Linter};
use crate::linting::dashes::Dashes;
@@ -672,6 +674,9 @@ impl LintGroup {
out.add("MoreAdjective", MoreAdjective::new(dictionary.clone()));
out.config.set_rule_enabled("MoreAdjective", true);
+ out.add("WorthToDo", WorthToDo::new(dictionary.clone()));
+ out.config.set_rule_enabled("WorthToDo", true);
+
out
}
diff --git a/harper-core/src/linting/mod.rs b/harper-core/src/linting/mod.rs
index 8eb9756ef..484f26764 100644
--- a/harper-core/src/linting/mod.rs
+++ b/harper-core/src/linting/mod.rs
@@ -232,6 +232,7 @@ mod widely_accepted;
mod win_prize;
mod wish_could;
mod wordpress_dotcom;
+mod worth_to_do;
mod would_never_have;
pub use expr_linter::{Chunk, ExprLinter};
diff --git a/harper-core/src/linting/worth_to_do.rs b/harper-core/src/linting/worth_to_do.rs
new file mode 100644
index 000000000..76a6144a8
--- /dev/null
+++ b/harper-core/src/linting/worth_to_do.rs
@@ -0,0 +1,321 @@
+use crate::{
+ CharStringExt, Lint, Token, TokenStringExt,
+ char_ext::CharExt,
+ expr::{Expr, SequenceExpr},
+ linting::{ExprLinter, LintKind, Suggestion, expr_linter::Chunk},
+ spell::Dictionary,
+};
+
+pub struct WorthToDo<D>
+where
+ D: Dictionary,
+{
+ expr: Box<dyn Expr>,
+ dict: D,
+}
+
+impl<D> WorthToDo<D>
+where
+ D: Dictionary,
+{
+ pub fn new(dict: D) -> Self {
+ Self {
+ expr: Box::new(
+ SequenceExpr::aco("worth")
+ .t_ws()
+ .t_aco("to")
+ .t_ws()
+ .then_verb_lemma(),
+ ),
+ dict,
+ }
+ }
+}
+
+impl<D> ExprLinter for WorthToDo<D>
+where
+ D: Dictionary,
+{
+ type Unit = Chunk;
+
+ fn expr(&self) -> &dyn Expr {
+ self.expr.as_ref()
+ }
+
+ fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
+ let tolemtoks = &toks[toks.len() - 3..];
+ let lemtok = toks.last()?;
+ let tolemspan = tolemtoks.span()?;
+ let lemspan = lemtok.span;
+ let tolemchars = tolemspan.get_content(src);
+ let lemchars = lemspan.get_content(src);
+ let lemstr = lemspan.get_content_string(src);
+
+ let mut gerunds = Vec::new();
+
+ let glom_ing = format!("{}ing", lemstr);
+ if self.dict.contains_word_str(&glom_ing) {
+ gerunds.push(glom_ing);
+ }
+
+ if lemchars.ends_with_ignore_ascii_case_chars(&['e']) {
+ let replace_e_with_ing = format!("{}ing", &lemstr[..lemstr.len() - 1]);
+ if self.dict.contains_word_str(&replace_e_with_ing) {
+ gerunds.push(replace_e_with_ing);
+ }
+ }
+
+ if let Some(last_letter) = lemstr.chars().last()
+ && !last_letter.is_vowel()
+ {
+ let double_consonant = format!("{}{}ing", lemstr, last_letter);
+ if self.dict.contains_word_str(&double_consonant) {
+ gerunds.push(double_consonant);
+ }
+ }
+
+ let suggestions = gerunds
+ .into_iter()
+ .map(|gerund| {
+ Suggestion::replace_with_match_case(
+ gerund.chars().collect::<Vec<char>>(),
+ tolemchars,
+ )
+ })
+ .collect();
+
+ Some(Lint {
+ span: tolemspan,
+ lint_kind: LintKind::Grammar,
+ suggestions,
+ message: "Use the `gerund` of the verb, the form that ends in `-ing`".to_string(),
+ ..Default::default()
+ })
+ }
+
+ fn description(&self) -> &str {
+ "Corrects `worth to` + a verb to `worth` + the gerund of the verb."
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::WorthToDo;
+ use crate::{linting::tests::assert_suggestion_result, spell::FstDictionary};
+
+ #[test]
+ fn worth_to_add() {
+ assert_suggestion_result(
+ "Is it worth to add those files?",
+ WorthToDo::new(FstDictionary::curated()),
+ "Is it worth adding those files?",
+ );
+ }
+
+ #[test]
+ fn worth_to_adjust() {
+ assert_suggestion_result(
+ "If yes, it would be worth to adjust the description to make it easier to understand",
+ WorthToDo::new(FstDictionary::curated()),
+ "If yes, it would be worth adjusting the description to make it easier to understand",
+ );
+ }
+
+ #[test]
+ fn worth_to_ask() {
+ assert_suggestion_result(
+ "So it is worth to ask for this there or take a look at their wiki pages. ",
+ WorthToDo::new(FstDictionary::curated()),
+ "So it is worth asking for this there or take a look at their wiki pages. ",
+ );
+ }
+
+ #[test]
+ fn worth_to_buy() {
+ assert_suggestion_result(
+ "and it makes it really worth to buy the software",
+ WorthToDo::new(FstDictionary::curated()),
+ "and it makes it really worth buying the software",
+ );
+ }
+
+ #[test]
+ fn worth_to_deal() {
+ assert_suggestion_result(
+ "CC2531 is considered as crap in 2024 and its not worth to deal with it.",
+ WorthToDo::new(FstDictionary::curated()),
+ "CC2531 is considered as crap in 2024 and its not worth dealing with it.",
+ );
+ }
+
+ #[test]
+ fn worth_to_do() {
+ assert_suggestion_result(
+ "Is it worth to do the credit-card-balance-transfer?",
+ WorthToDo::new(FstDictionary::curated()),
+ "Is it worth doing the credit-card-balance-transfer?",
+ );
+ }
+
+ #[test]
+ fn worth_to_experiment() {
+ assert_suggestion_result(
+ "Hello @tkchia, thanks for the hint, I agree it is worth to experiment.",
+ WorthToDo::new(FstDictionary::curated()),
+ "Hello @tkchia, thanks for the hint, I agree it is worth experimenting.",
+ );
+ }
+
+ #[test]
+ fn worth_to_fix() {
+ assert_suggestion_result(
+ "i dont know if this is worth to fix, i just wanted to point this and start a discussion about this.",
+ WorthToDo::new(FstDictionary::curated()),
+ "i dont know if this is worth fixing, i just wanted to point this and start a discussion about this.",
+ );
+ }
+
+ #[test]
+ fn worth_to_get_published() {
+ assert_suggestion_result(
+ "think that would be worth to get published in my Thesis.",
+ WorthToDo::new(FstDictionary::curated()),
+ "think that would be worth getting published in my Thesis.",
+ );
+ }
+
+ #[test]
+ fn worth_to_imagine() {
+ assert_suggestion_result(
+ "Might be worth to imagine how the current Nu style would look like in other programming languages.",
+ WorthToDo::new(FstDictionary::curated()),
+ "Might be worth imagining how the current Nu style would look like in other programming languages.",
+ );
+ }
+
+ #[test]
+ fn worth_to_invest() {
+ assert_suggestion_result(
+ "It doesn't seem worth to invest much effort in this though...",
+ WorthToDo::new(FstDictionary::curated()),
+ "It doesn't seem worth investing much effort in this though...",
+ );
+ }
+
+ #[test]
+ fn worth_to_investigate() {
+ assert_suggestion_result(
+ "to get a feeling how CP-SAT works and what are directions worth to investigate i wanted to ask",
+ WorthToDo::new(FstDictionary::curated()),
+ "to get a feeling how CP-SAT works and what are directions worth investigating i wanted to ask",
+ );
+ }
+
+ #[test]
+ fn worth_to_play() {
+ assert_suggestion_result(
+ "Is worth to play with thread count if there are no issues?",
+ WorthToDo::new(FstDictionary::curated()),
+ "Is worth playing with thread count if there are no issues?",
+ );
+ }
+
+ #[test]
+ fn worth_to_put() {
+ assert_suggestion_result(
+ "Do you think it would be worth to put a suggestion to remove the kind network if cluster creation fails",
+ WorthToDo::new(FstDictionary::curated()),
+ "Do you think it would be worth putting a suggestion to remove the kind network if cluster creation fails",
+ );
+ }
+
+ #[test]
+ fn worth_to_read() {
+ assert_suggestion_result(
+ "Stored books worth to read.",
+ WorthToDo::new(FstDictionary::curated()),
+ "Stored books worth reading.",
+ );
+ }
+
+ #[test]
+ fn worth_to_revisit() {
+ assert_suggestion_result(
+ "we've had discussions before #260 and it maybe worth to revisit again",
+ WorthToDo::new(FstDictionary::curated()),
+ "we've had discussions before #260 and it maybe worth revisiting again",
+ );
+ }
+
+ #[test]
+ fn worth_to_rewrite() {
+ assert_suggestion_result(
+ "is puppet so bad that it is worth to rewrite everything?",
+ WorthToDo::new(FstDictionary::curated()),
+ "is puppet so bad that it is worth rewriting everything?",
+ );
+ }
+
+ #[test]
+ fn worth_to_try() {
+ assert_suggestion_result(
+ "is it really worth to try and what are facebook long-term plans about this engine.",
+ WorthToDo::new(FstDictionary::curated()),
+ "is it really worth trying and what are facebook long-term plans about this engine.",
+ );
+ }
+
+ #[test]
+ fn worth_to_update() {
+ assert_suggestion_result(
+ "Hi, maybe it's worth to update doc with the script for Bullseye given by @frenchfaso ?",
+ WorthToDo::new(FstDictionary::curated()),
+ "Hi, maybe it's worth updating doc with the script for Bullseye given by @frenchfaso ?",
+ );
+ }
+
+ #[test]
+ fn worth_to_upgrade() {
+ assert_suggestion_result(
+ "Your PR should've fixed that issue so I think it's worth to upgrade to 10.33 and see if that brings the delta down.",
+ WorthToDo::new(FstDictionary::curated()),
+ "Your PR should've fixed that issue so I think it's worth upgrading to 10.33 and see if that brings the delta down.",
+ );
+ }
+
+ #[test]
+ fn worth_to_use_and_develop() {
+ assert_suggestion_result(
+ "I think It worth to use and worth to develop further",
+ WorthToDo::new(FstDictionary::curated()),
+ "I think It worth using and worth developing further",
+ );
+ }
+
+ #[test]
+ fn works_with_uppercase_glom() {
+ assert_suggestion_result(
+ " YES IT IS WORTH TO DO",
+ WorthToDo::new(FstDictionary::curated()),
+ " YES IT IS WORTH DOING",
+ );
+ }
+
+ #[test]
+ fn works_with_uppercase_final_e() {
+ assert_suggestion_result(
+ "THIS LINTER WAS WORTH TO MAKE",
+ WorthToDo::new(FstDictionary::curated()),
+ "THIS LINTER WAS WORTH MAKING",
+ );
+ }
+
+ #[test]
+ fn works_with_uppercase_double_consonant() {
+ assert_suggestion_result(
+ "SO YEAH IT WAS WORTH TO GET THIS DONE",
+ WorthToDo::new(FstDictionary::curated()),
+ "SO YEAH IT WAS WORTH GETTING THIS DONE",
+ );
+ }
+}