Merge pull request #604 from Automattic/fix-decimals

elijah-potter · web-flow · commit 8e97e9ed7917 · 2025-02-10T14:58:21.000-07:00
fix(core): currency placement with certain decimal positions
diff --git a/harper-core/src/currency.rs b/harper-core/src/currency.rs
@@ -1,7 +1,7 @@
 use is_macro::Is;
 use serde::{Deserialize, Serialize};
 
-use crate::NumberSuffix;
+use crate::Number;
 
 #[derive(Debug, Is, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Hash)]
 pub enum Currency {
@@ -62,14 +62,10 @@ impl Currency {
     }
 
     /// Format an amount of the specific currency.
-    pub fn format_amount(&self, value: f64, suffix: Option<NumberSuffix>) -> String {
+    pub fn format_amount(&self, amount: Number) -> String {
         let c = self.to_char();
 
-        let mut amount = value.to_string();
-
-        if let Some(suffix) = suffix {
-            amount.extend(suffix.to_chars());
-        }
+        let amount = amount.to_string();
 
         match self {
             Currency::Dollar => format!("{}{amount}", c),
diff --git a/harper-core/src/document.rs b/harper-core/src/document.rs
@@ -286,7 +286,7 @@ impl Document {
             if let (TokenKind::Number(..), TokenKind::Word(..)) = (a.kind, b.kind) {
                 if let Some(found_suffix) = NumberSuffix::from_chars(self.get_span_content(b.span))
                 {
-                    *self.tokens[idx].kind.as_mut_number().unwrap().1 = Some(found_suffix);
+                    self.tokens[idx].kind.as_mut_number().unwrap().suffix = Some(found_suffix);
                     replace_starts.push(idx);
                 }
             }
diff --git a/harper-core/src/lexing/mod.rs b/harper-core/src/lexing/mod.rs
@@ -9,7 +9,7 @@ use url::lex_url;
 use self::email_address::lex_email_address;
 use crate::char_ext::CharExt;
 use crate::punctuation::{Punctuation, Quote};
-use crate::{TokenKind, WordMetadata};
+use crate::{Number, TokenKind, WordMetadata};
 
 #[derive(Debug)]
 pub struct FoundToken {
@@ -79,8 +79,15 @@ pub fn lex_number(source: &[char]) -> Option<FoundToken> {
     // Find the longest possible valid number
     while !s.is_empty() {
         if let Ok(n) = s.parse::<f64>() {
+            let precision = s.chars().rev().position(|c| c == '.').unwrap_or_default();
+
             return Some(FoundToken {
-                token: TokenKind::Number(n.into(), None),
+                token: TokenKind::Number(Number {
+                    value: n.into(),
+                    suffix: None,
+                    radix: 10,
+                    precision,
+                }),
                 next_index: s.len(),
             });
         }
@@ -119,7 +126,12 @@ pub fn lex_hex_number(source: &[char]) -> Option<FoundToken> {
     // Should always succeed unless the logic above is broken
     if let Ok(n) = u64::from_str_radix(&s, 16) {
         return Some(FoundToken {
-            token: TokenKind::Number(OrderedFloat(n as f64), None),
+            token: TokenKind::Number(Number {
+                value: OrderedFloat(n as f64),
+                suffix: None,
+                radix: 16,
+                precision: 0,
+            }),
             next_index: s.len() + 2,
         });
     }
@@ -232,7 +244,7 @@ mod tests {
         assert!(matches!(
             lex_hex_number(&source),
             Some(FoundToken {
-                token: TokenKind::Number(_, None),
+                token: TokenKind::Number(_),
                 ..
             })
         ));
@@ -244,7 +256,7 @@ mod tests {
         assert!(matches!(
             lex_hex_number(&source),
             Some(FoundToken {
-                token: TokenKind::Number(_, None),
+                token: TokenKind::Number(_),
                 ..
             })
         ));
@@ -256,7 +268,7 @@ mod tests {
         assert!(matches!(
             lex_hex_number(&source),
             Some(FoundToken {
-                token: TokenKind::Number(_, None),
+                token: TokenKind::Number(_),
                 ..
             })
         ));
@@ -268,7 +280,7 @@ mod tests {
         assert!(matches!(
             lex_hex_number(&source),
             Some(FoundToken {
-                token: TokenKind::Number(_, None),
+                token: TokenKind::Number(_),
                 ..
             })
         ));
@@ -280,7 +292,7 @@ mod tests {
         assert!(matches!(
             lex_hex_number(&source),
             Some(FoundToken {
-                token: TokenKind::Number(_, None),
+                token: TokenKind::Number(_),
                 ..
             })
         ));
@@ -292,7 +304,7 @@ mod tests {
         assert!(matches!(
             lex_hex_number(&source),
             Some(FoundToken {
-                token: TokenKind::Number(_, None),
+                token: TokenKind::Number(_),
                 ..
             })
         ));
diff --git a/harper-core/src/lib.rs b/harper-core/src/lib.rs
@@ -12,6 +12,7 @@ pub mod language_detection;
 mod lexing;
 pub mod linting;
 mod mask;
+mod number;
 pub mod parsers;
 pub mod patterns;
 mod punctuation;
@@ -34,13 +35,14 @@ pub use fat_token::FatToken;
 pub use ignored_lints::IgnoredLints;
 use linting::Lint;
 pub use mask::{Mask, Masker};
+pub use number::{Number, NumberSuffix};
 pub use punctuation::{Punctuation, Quote};
 pub use span::Span;
 pub use spell::{Dictionary, FstDictionary, FullDictionary, MergedDictionary};
 pub use sync::Lrc;
 pub use title_case::{make_title_case, make_title_case_str};
 pub use token::Token;
-pub use token_kind::{NumberSuffix, TokenKind};
+pub use token_kind::TokenKind;
 pub use token_string_ext::TokenStringExt;
 pub use vec_ext::VecExt;
 pub use word_metadata::{AdverbData, ConjunctionData, NounData, Tense, VerbData, WordMetadata};
diff --git a/harper-core/src/linting/correct_number_suffix.rs b/harper-core/src/linting/correct_number_suffix.rs
@@ -1,6 +1,6 @@
 use super::{Lint, LintKind, Linter, Suggestion};
-use crate::TokenStringExt;
 use crate::{Document, NumberSuffix, Span, TokenKind};
+use crate::{Number, TokenStringExt};
 
 /// Detect and warn that the sentence is too long.
 #[derive(Debug, Clone, Copy, Default)]
@@ -15,8 +15,13 @@ impl Linter for CorrectNumberSuffix {
                 continue;
             };
 
-            if let TokenKind::Number(number, Some(suffix)) = number_tok.kind {
-                if let Some(correct_suffix) = NumberSuffix::correct_suffix_for(number) {
+            if let TokenKind::Number(Number {
+                value,
+                suffix: Some(suffix),
+                ..
+            }) = number_tok.kind
+            {
+                if let Some(correct_suffix) = NumberSuffix::correct_suffix_for(value) {
                     if suffix != correct_suffix {
                         output.push(Lint {
                             span: suffix_span,
diff --git a/harper-core/src/linting/currency_placement.rs b/harper-core/src/linting/currency_placement.rs
@@ -45,14 +45,11 @@ fn generate_lint_for_tokens(a: Token, b: Token, document: &Document) -> Option<L
         .expect_punctuation();
     let currency = punct.as_currency()?;
 
-    let (value, suffix) = matched_tokens.first_number()?.kind.expect_number();
+    let number = matched_tokens.first_number()?.kind.expect_number();
 
     let span = matched_tokens.span().unwrap();
 
-    let correct: Vec<_> = currency
-        .format_amount(value.into(), suffix)
-        .chars()
-        .collect();
+    let correct: Vec<_> = currency.format_amount(number).chars().collect();
     let actual = document.get_span_content(span);
 
     if correct != actual {
@@ -141,4 +138,9 @@ mod tests {
             "It was my $20th.",
         );
     }
+
+    #[test]
+    fn seven_even_two_decimal_clean() {
+        assert_lint_count("$7.00", CurrencyPlacement::default(), 0);
+    }
 }
diff --git a/harper-core/src/linting/number_suffix_capitalization.rs b/harper-core/src/linting/number_suffix_capitalization.rs
@@ -1,6 +1,6 @@
 use super::{Lint, LintKind, Linter, Suggestion};
-use crate::TokenStringExt;
 use crate::{Document, Span, TokenKind};
+use crate::{Number, TokenStringExt};
 
 /// Detect and warn that the sentence is too long.
 #[derive(Debug, Clone, Copy, Default)]
@@ -11,7 +11,7 @@ impl Linter for NumberSuffixCapitalization {
         let mut output = Vec::new();
 
         for number_tok in document.iter_numbers() {
-            if let TokenKind::Number(_, None) = number_tok.kind {
+            if let TokenKind::Number(Number { suffix: None, .. }) = number_tok.kind {
                 continue;
             }
 
diff --git a/harper-core/src/linting/spelled_numbers.rs b/harper-core/src/linting/spelled_numbers.rs
@@ -1,5 +1,5 @@
 use crate::linting::{LintKind, Linter, Suggestion};
-use crate::{Document, Lint, TokenStringExt};
+use crate::{Document, Lint, Number, TokenStringExt};
 
 /// Linter that checks to make sure small integers (< 10) are spelled
 /// out.
@@ -11,15 +11,22 @@ impl Linter for SpelledNumbers {
         let mut lints = Vec::new();
 
         for number_tok in document.iter_numbers() {
-            let (number, _suffix) = number_tok.kind.number().unwrap();
-            let number: f64 = number.into();
-
-            if (number - number.floor()).abs() < f64::EPSILON && number < 10. {
+            let Number {
+                value,
+                suffix: None,
+                ..
+            } = number_tok.kind.number().unwrap()
+            else {
+                continue;
+            };
+            let value: f64 = value.into();
+
+            if (value - value.floor()).abs() < f64::EPSILON && value < 10. {
                 lints.push(Lint {
                     span: number_tok.span,
                     lint_kind: LintKind::Readability,
                     suggestions: vec![Suggestion::ReplaceWith(
-                        spell_out_number(number as u64).unwrap().chars().collect(),
+                        spell_out_number(value as u64).unwrap().chars().collect(),
                     )],
                     message: "Try to spell out numbers less than ten.".to_string(),
                     priority: 63,
diff --git a/harper-core/src/number.rs b/harper-core/src/number.rs
diff --git a/harper-core/src/token_kind.rs b/harper-core/src/token_kind.rs
diff --git a/harper-typst/src/lib.rs b/harper-typst/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -286,7 +286,7 @@ impl Document {`
`286`	`286`	`if let (TokenKind::Number(..), TokenKind::Word(..)) = (a.kind, b.kind) {`
`287`	`287`	`if let Some(found_suffix) = NumberSuffix::from_chars(self.get_span_content(b.span))`
`288`	`288`	`{`
`289`		`- *self.tokens[idx].kind.as_mut_number().unwrap().1 = Some(found_suffix);`
	`289`	`+ self.tokens[idx].kind.as_mut_number().unwrap().suffix = Some(found_suffix);`
`290`	`290`	`replace_starts.push(idx);`
`291`	`291`	`}`
`292`	`292`	`}`