Merge pull request #455 from Automattic/somewhat-something

feat(core): created a  new rule that resolves #414

Author: elijah-potter

harper-core/src/linting/lint.rs

@@ -69,6 +69,11 @@ pub enum Suggestion {
 }
 
 impl Suggestion {
+    /// Variant of [`Self::replace_with_match_case`] that accepts a static string.
+    pub fn replace_with_match_case_str(value: &'static str, template: &[char]) -> Self {
+        Self::replace_with_match_case(value.chars().collect(), template)
+    }
+
     /// Construct an instance of [`Self::ReplaceWith`], but make the content match the case of the
     /// provided template.
     ///

harper-core/src/linting/lint_group.rs

@@ -22,6 +22,7 @@ use super::proper_noun_capitalization_linters::{
 };
 use super::repeated_words::RepeatedWords;
 use super::sentence_capitalization::SentenceCapitalization;
+use super::somewhat_something::SomewhatSomething;
 use super::spaces::Spaces;
 use super::spell_check::SpellCheck;
 use super::spelled_numbers::SpelledNumbers;
@@ -187,7 +188,8 @@ create_lint_group_config!(
     PluralConjugate => false,
     OxfordComma => true,
     PronounContraction => true,
-    CurrencyPlacement => true
+    CurrencyPlacement => true,
+    SomewhatSomething => true
 );
 
 impl<T: Dictionary + Default> Default for LintGroup<T> {

harper-core/src/linting/mod.rs

@@ -23,6 +23,7 @@ mod pronoun_contraction;
 mod proper_noun_capitalization_linters;
 mod repeated_words;
 mod sentence_capitalization;
+mod somewhat_something;
 mod spaces;
 mod spell_check;
 mod spelled_numbers;
@@ -58,6 +59,7 @@ pub use proper_noun_capitalization_linters::{
 };
 pub use repeated_words::RepeatedWords;
 pub use sentence_capitalization::SentenceCapitalization;
+pub use somewhat_something::SomewhatSomething;
 pub use spaces::Spaces;
 pub use spell_check::SpellCheck;
 pub use spelled_numbers::SpelledNumbers;

harper-core/src/linting/somewhat_something.rs

@@ -0,0 +1,63 @@
+use crate::{
+    patterns::{Pattern, SequencePattern},
+    Token,
+};
+
+use super::{Lint, LintKind, PatternLinter, Suggestion};
+
+pub struct SomewhatSomething {
+    pattern: Box<dyn Pattern>,
+}
+
+impl Default for SomewhatSomething {
+    fn default() -> Self {
+        let pattern = SequencePattern::aco("somewhat")
+            .then_whitespace()
+            .t_aco("of")
+            .then_whitespace()
+            .t_aco("a");
+
+        Self {
+            pattern: Box::new(pattern),
+        }
+    }
+}
+
+impl PatternLinter for SomewhatSomething {
+    fn pattern(&self) -> &dyn Pattern {
+        self.pattern.as_ref()
+    }
+
+    fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Lint {
+        let span = matched_tokens.first().unwrap().span;
+        let og = span.get_content(source);
+
+        Lint {
+            span,
+            lint_kind: LintKind::Style,
+            suggestions: vec![Suggestion::replace_with_match_case_str("something", og)],
+            message: "Use the traditional form.".to_owned(),
+            priority: 63,
+        }
+    }
+
+    fn description(&self) -> &'static str {
+        "When describing a single instance of a noun, use `something` rather than `somewhat`."
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::linting::tests::assert_suggestion_result;
+
+    use super::SomewhatSomething;
+
+    #[test]
+    fn issue_414() {
+        assert_suggestion_result(
+            "This may be somewhat of a surprise.",
+            SomewhatSomething::default(),
+            "This may be something of a surprise.",
+        );
+    }
+}