Skip to content

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

feat:by my own→on my own/by myself (#3322)

Andrew Dunbar46370338a529
diff --git a/harper-core/default_config.json b/harper-core/default_config.json
index debcb5a57..84980e289 100644
--- a/harper-core/default_config.json
+++ b/harper-core/default_config.json
@@ -3962,6 +3962,13 @@
"label": "Bought"
}
},
+ {
+ "Bool": {
+ "name": "ByOnesOwn",
+ "state": true,
+ "label": "By One's Own"
+ }
+ },
{
"Bool": {
"name": "CallThem",
diff --git a/harper-core/src/linting/by_ones_own.rs b/harper-core/src/linting/by_ones_own.rs
new file mode 100644
index 000000000..b56b4e5aa
--- /dev/null
+++ b/harper-core/src/linting/by_ones_own.rs
@@ -0,0 +1,358 @@
+use crate::{
+ Lint, Token, TokenStringExt,
+ char_string::CharStringExt,
+ expr::{Expr, SequenceExpr},
+ linting::{
+ ExprLinter, LintKind, Suggestion,
+ expr_linter::{Chunk, followed_by_word},
+ },
+};
+
+pub struct ByOnesOwn {
+ expr: SequenceExpr,
+}
+
+impl Default for ByOnesOwn {
+ fn default() -> Self {
+ Self {
+ expr: SequenceExpr::aco("by")
+ .t_ws()
+ .then_possessive_determiner()
+ .t_ws()
+ .t_aco("own"),
+ }
+ }
+}
+
+impl ExprLinter for ByOnesOwn {
+ type Unit = Chunk;
+
+ fn match_to_lint_with_context(
+ &self,
+ toks: &[Token],
+ src: &[char],
+ ctx: Option<(&[Token], &[Token])>,
+ ) -> Option<Lint> {
+ // If any word comes next then "own" is probably a qualifier.
+ if followed_by_word(ctx, |_| true) {
+ return None;
+ }
+
+ let span = toks.span()?;
+
+ let (by_idx, ws1_idx, whose_idx) = (0, 1, 2);
+
+ let by_ws = toks[by_idx..=ws1_idx].span()?.get_content(src);
+ let ws_1 = toks[ws1_idx].get_ch(src);
+
+ // my, its
+ let whose = toks[whose_idx].get_ch(src);
+ // my own, its own
+ let whose_own = toks[whose_idx..].span()?.get_content(src);
+
+ // my -> myself, its -> itself
+ let reflexive = match whose {
+ _ if whose.eq_ch(&['m', 'y']) => &["myself"][..],
+ _ if whose.eq_ch(&['o', 'u', 'r']) => &["ourselves"][..],
+ _ if whose.eq_ch(&['y', 'o', 'u', 'r']) => &["yourself", "yourselves"][..],
+ _ if whose.eq_ch(&['h', 'i', 's']) => &["himself"][..],
+ _ if whose.eq_ch(&['h', 'e', 'r']) => &["herself"][..],
+ _ if whose.eq_ch(&['i', 't', 's']) => &["itself"][..],
+ _ if whose.eq_ch(&['t', 'h', 'e', 'i', 'r']) => &["themselves", "themself"][..],
+ _ if whose.eq_ch(&['o', 'n', 'e', '\'', 's']) => &["oneself"][..],
+ _ => return None, // Actually unreachable
+ };
+
+ let sugg_on_ones_own = Suggestion::replace_with_match_case(
+ "on".chars()
+ .chain(ws_1.iter().copied())
+ .chain(whose_own.iter().copied())
+ .collect::<Vec<char>>(),
+ span.get_content(src),
+ );
+
+ let suggestions = std::iter::once(sugg_on_ones_own)
+ .chain(reflexive.iter().map(|reflexive_str| {
+ let by_whoseself = by_ws
+ .iter()
+ .copied()
+ .chain(reflexive_str.chars())
+ .collect::<Vec<char>>();
+ Suggestion::replace_with_match_case(by_whoseself, span.get_content(src))
+ }))
+ .collect();
+
+ Some(Lint {
+ span,
+ lint_kind: LintKind::Usage,
+ suggestions,
+ message:
+ "`By one's own` is not idiomatic. Consider either `on one's own` or `by oneself`."
+ .to_string(),
+ ..Default::default()
+ })
+ }
+
+ fn expr(&self) -> &dyn Expr {
+ &self.expr
+ }
+
+ fn description(&self) -> &str {
+ "Fixes incorrect phrases like `by my own` by suggesting `on my own` or `by myself`."
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use crate::linting::tests::{assert_good_and_bad_suggestions, assert_no_lints};
+
+ use super::ByOnesOwn;
+
+ #[test]
+ fn fix_by_her_own() {
+ assert_good_and_bad_suggestions(
+ "If she is not managing by her own, it means that there is something wrong with either our documentation, or our error messages, or our ...",
+ ByOnesOwn::default(),
+ &[
+ "If she is not managing on her own, it means that there is something wrong with either our documentation, or our error messages, or our ...",
+ "If she is not managing by herself, it means that there is something wrong with either our documentation, or our error messages, or our ...",
+ ],
+ &[],
+ );
+ }
+
+ #[test]
+ fn dont_flag_by_her_breathing() {
+ assert_no_lints(
+ "The silence of this deep section of the Spire was profound, broken only by her own ragged breathing.",
+ ByOnesOwn::default(),
+ );
+ }
+
+ #[test]
+ fn fix_by_his_own() {
+ assert_good_and_bad_suggestions(
+ "And make the hover info function creating the <title> tag by his own.",
+ ByOnesOwn::default(),
+ &[
+ "And make the hover info function creating the <title> tag on his own.",
+ "And make the hover info function creating the <title> tag by himself.",
+ ],
+ &[],
+ );
+ }
+
+ #[test]
+ fn fix_by_his_own_comma() {
+ assert_good_and_bad_suggestions(
+ "it also makes a report all by his own, without touching anything",
+ ByOnesOwn::default(),
+ &[
+ "it also makes a report all on his own, without touching anything",
+ "it also makes a report all by himself, without touching anything",
+ ],
+ &[],
+ );
+ }
+
+ #[test]
+ fn dont_flag_by_his_own_efforts() {
+ assert_no_lints(
+ "My point is if someone needs jemalloc he gets it by his own efforts clearly realising why/when and so on.",
+ ByOnesOwn::default(),
+ );
+ }
+
+ #[test]
+ fn fix_by_its_own_in_quotes() {
+ assert_good_and_bad_suggestions(
+ "I set AdGuard DNS via Windows 11 settings, and I always found them to be changed \"by its own\".",
+ ByOnesOwn::default(),
+ &[
+ "I set AdGuard DNS via Windows 11 settings, and I always found them to be changed \"on its own\".",
+ "I set AdGuard DNS via Windows 11 settings, and I always found them to be changed \"by itself\".",
+ ],
+ &[],
+ );
+ }
+
+ #[test]
+ fn fix_by_its_own_at_end() {
+ assert_good_and_bad_suggestions(
+ "The wheel starts speeding and spinning by its own.",
+ ByOnesOwn::default(),
+ &[
+ "The wheel starts speeding and spinning on its own.",
+ "The wheel starts speeding and spinning by itself.",
+ ],
+ &[],
+ );
+ }
+
+ #[test]
+ fn dont_flag_by_its_own_changes() {
+ assert_no_lints("Remix is spooked by its own changes", ByOnesOwn::default());
+ }
+
+ #[test]
+ fn fix_by_my_own() {
+ assert_good_and_bad_suggestions(
+ "how can I build a project by my own",
+ ByOnesOwn::default(),
+ &[
+ "how can I build a project on my own",
+ "how can I build a project by myself",
+ ],
+ &[],
+ );
+ }
+
+ #[test]
+ fn dont_flag_by_my_own_hr() {
+ assert_no_lints(
+ "My colledge' ID is totally messed up by my own HR",
+ ByOnesOwn::default(),
+ );
+ }
+
+ #[test]
+ fn fix_by_our_own() {
+ assert_good_and_bad_suggestions(
+ "So, I think we should have the alternative BN implementation by our own.",
+ ByOnesOwn::default(),
+ &[
+ "So, I think we should have the alternative BN implementation on our own.",
+ "So, I think we should have the alternative BN implementation by ourselves.",
+ ],
+ &[],
+ );
+ }
+
+ #[test]
+ fn dont_flag_by_our_own_standards() {
+ assert_no_lints("Better by our own standards.", ByOnesOwn::default());
+ }
+
+ #[test]
+ fn fix_by_their_own() {
+ assert_good_and_bad_suggestions(
+ "Therefore, it would be great to allow the users to do the serialization by their own, rather than giving the full control to the SDK internally.",
+ ByOnesOwn::default(),
+ &[
+ "Therefore, it would be great to allow the users to do the serialization on their own, rather than giving the full control to the SDK internally.",
+ "Therefore, it would be great to allow the users to do the serialization by themselves, rather than giving the full control to the SDK internally.",
+ ],
+ &[],
+ );
+ }
+
+ #[test]
+ fn dont_flag_by_their_own_bots() {
+ assert_no_lints(
+ "GitHub needs a way to report issues and comments, even by their own bots.",
+ ByOnesOwn::default(),
+ );
+ }
+
+ #[test]
+ fn fix_by_your_own() {
+ assert_good_and_bad_suggestions(
+ "You should be able to see a new wallpaper slideshow created by your own.",
+ ByOnesOwn::default(),
+ &[
+ "You should be able to see a new wallpaper slideshow created on your own.",
+ "You should be able to see a new wallpaper slideshow created by yourself.",
+ ],
+ &[],
+ );
+ }
+
+ #[test]
+ fn dont_flag_by_your_own_lib() {
+ assert_no_lints(
+ "Design with JSX, powered by your own component library.",
+ ByOnesOwn::default(),
+ );
+ }
+
+ // For future contributors who want to improve this linter
+
+ #[test]
+ #[ignore = "We can't detect the end of sentence when punctuation is missing."]
+ fn dont_flag_by_its_own_end_no_punc() {
+ assert_no_lints(
+ "same infininte running and when i stop this node forcefully it show s the currect output dont know why it dont stop by its own i think its a bug",
+ ByOnesOwn::default(),
+ );
+ }
+
+ #[test]
+ #[ignore = "We might be able to handle this one"]
+ fn fix_by_your_own_and() {
+ assert_good_and_bad_suggestions(
+ "After you install SPAdes by your own and add spades bin to the $PATH, ",
+ ByOnesOwn::default(),
+ &[
+ "After you install SPAdes on your own and add spades bin to the $PATH, ",
+ "After you install SPAdes by yourself and add spades bin to the $PATH, ",
+ ],
+ &[],
+ );
+ }
+
+ #[test]
+ #[ignore = "A construct that needs to be fixed that we can't handle yet"]
+ fn fix_by_your_own_using() {
+ assert_good_and_bad_suggestions(
+ "I made some steps to this direction and currently you can implement it by your own using middleware",
+ ByOnesOwn::default(),
+ &[
+ "I made some steps in this direction and currently you can implement it on your own using middleware",
+ "I made some steps in this direction and currently you can implement it by yourself using middleware",
+ ],
+ &[],
+ );
+ }
+
+ #[test]
+ #[ignore = "We might be able to handle this"]
+ fn fix_by_your_own_preposition() {
+ assert_good_and_bad_suggestions(
+ "Of course feel free to add this by your own by pull request :)",
+ ByOnesOwn::default(),
+ &[
+ "Of course feel free to add this on your own by pull request :)",
+ "Of course feel free to add this by yourself by pull request :)",
+ ],
+ &[],
+ );
+ }
+
+ #[test]
+ #[ignore = "Another construction we should fix but can't yet"]
+ fn fix_by_your_own_we() {
+ assert_good_and_bad_suggestions(
+ "If you would like to develop this feature by your own we would be happy to help with this but",
+ ByOnesOwn::default(),
+ &[
+ "If you would like to develop this feature on your own we would be happy to help with this but",
+ "If you would like to develop this feature by yourself we would be happy to help with this but",
+ ],
+ &[],
+ );
+ }
+
+ #[test]
+ #[ignore = "See if it's always a legit error when the next word is a preposition"]
+ fn fix_by_her_own_during() {
+ assert_good_and_bad_suggestions(
+ "most of the time she gets mad by her own during topics which can end her in an angry/annoyed mood",
+ ByOnesOwn::default(),
+ &[
+ "most of the time she gets mad on her own during topics which can end her in an angry/annoyed mood",
+ "most of the time she gets mad by herself during topics which can end her in an angry/annoyed mood",
+ ],
+ &[],
+ );
+ }
+}
diff --git a/harper-core/src/linting/lint_group/mod.rs b/harper-core/src/linting/lint_group/mod.rs
index 35f0bd45d..1b41ea997 100644
--- a/harper-core/src/linting/lint_group/mod.rs
+++ b/harper-core/src/linting/lint_group/mod.rs
@@ -42,6 +42,7 @@ use super::boring_words::BoringWords;
use super::bought::Bought;
use super::brand_brandish::BrandBrandish;
use super::by_accident::ByAccident;
+use super::by_ones_own::ByOnesOwn;
use super::by_the_book::ByTheBook;
use super::call_them::CallThem;
use super::cant::Cant;
@@ -617,6 +618,7 @@ impl LintGroup {
insert_expr_rule!(Bought, true);
insert_expr_rule!(BrandBrandish, true);
insert_expr_rule!(ByAccident, true);
+ insert_expr_rule!(ByOnesOwn, true);
insert_expr_rule!(ByTheBook, true);
insert_expr_rule!(CallThem, true);
insert_expr_rule!(Cant, true);
diff --git a/harper-core/src/linting/mod.rs b/harper-core/src/linting/mod.rs
index 1848ae6bf..7adbb3b15 100644
--- a/harper-core/src/linting/mod.rs
+++ b/harper-core/src/linting/mod.rs
@@ -35,6 +35,7 @@ mod boring_words;
mod bought;
mod brand_brandish;
mod by_accident;
+mod by_ones_own;
mod by_the_book;
mod call_them;
mod cant;