Skip to content

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

refactor(core): create dedicated type for numbers

Elijah Potter70c333d4e99d
diff --git a/harper-core/src/currency.rs b/harper-core/src/currency.rs
index 7f7532ee8..bf16f25d7 100644
--- 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, NumberSuffix};
#[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
index 12cd3074a..237b249d6 100644
--- 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
index bb48bf8d5..fed406647 100644
--- 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 {
@@ -80,7 +80,11 @@ pub fn lex_number(source: &[char]) -> Option<FoundToken> {
while !s.is_empty() {
if let Ok(n) = s.parse::<f64>() {
return Some(FoundToken {
- token: TokenKind::Number(n.into(), None),
+ token: TokenKind::Number(Number {
+ value: n.into(),
+ suffix: None,
+ radix: 10,
+ }),
next_index: s.len(),
});
}
@@ -119,7 +123,11 @@ 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,
+ }),
next_index: s.len() + 2,
});
}
@@ -232,7 +240,7 @@ mod tests {
assert!(matches!(
lex_hex_number(&source),
Some(FoundToken {
- token: TokenKind::Number(_, None),
+ token: TokenKind::Number(_),
..
})
));
@@ -244,7 +252,7 @@ mod tests {
assert!(matches!(
lex_hex_number(&source),
Some(FoundToken {
- token: TokenKind::Number(_, None),
+ token: TokenKind::Number(_),
..
})
));
@@ -256,7 +264,7 @@ mod tests {
assert!(matches!(
lex_hex_number(&source),
Some(FoundToken {
- token: TokenKind::Number(_, None),
+ token: TokenKind::Number(_),
..
})
));
@@ -268,7 +276,7 @@ mod tests {
assert!(matches!(
lex_hex_number(&source),
Some(FoundToken {
- token: TokenKind::Number(_, None),
+ token: TokenKind::Number(_),
..
})
));
@@ -280,7 +288,7 @@ mod tests {
assert!(matches!(
lex_hex_number(&source),
Some(FoundToken {
- token: TokenKind::Number(_, None),
+ token: TokenKind::Number(_),
..
})
));
@@ -292,7 +300,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
index ccf9df6cb..b24da7648 100644
--- 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
index a2fbfb0a3..38e38d871 100644
--- 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
index 53d637e62..1ea72ab9f 100644
--- 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 {
diff --git a/harper-core/src/linting/number_suffix_capitalization.rs b/harper-core/src/linting/number_suffix_capitalization.rs
index b7763a670..cc3dda170 100644
--- 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
index 936f2e413..b5d4ba74d 100644
--- 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,15 @@ 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();
+ let Number { value, suffix, .. } = number_tok.kind.number().unwrap();
+ let value: f64 = value.into();
- if (number - number.floor()).abs() < f64::EPSILON && number < 10. {
+ 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
new file mode 100644
index 000000000..9447eb00e
--- /dev/null
+++ b/harper-core/src/number.rs
@@ -0,0 +1,104 @@
+use std::fmt::Display;
+
+use is_macro::Is;
+use ordered_float::OrderedFloat;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Clone, Copy, Default, PartialEq, Eq, Hash, PartialOrd)]
+pub struct Number {
+ pub value: OrderedFloat<f64>,
+ pub suffix: Option<NumberSuffix>,
+ pub radix: u32,
+}
+
+impl Display for Number {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(f, "{}", self.value)?;
+
+ if let Some(suffix) = self.suffix {
+ for c in suffix.to_chars() {
+ write!(f, "{}", c)?;
+ }
+ }
+
+ Ok(())
+ }
+}
+
+#[derive(
+ Debug, Serialize, Deserialize, Default, PartialEq, PartialOrd, Clone, Copy, Is, Hash, Eq,
+)]
+pub enum NumberSuffix {
+ #[default]
+ Th,
+ St,
+ Nd,
+ Rd,
+}
+
+impl NumberSuffix {
+ pub fn correct_suffix_for(number: impl Into<f64>) -> Option<Self> {
+ let number = number.into();
+
+ if number < 0.0 || number - number.floor() > f64::EPSILON || number > u64::MAX as f64 {
+ return None;
+ }
+
+ let integer = number as u64;
+
+ if let 11..=13 = integer % 100 {
+ return Some(Self::Th);
+ };
+
+ match integer % 10 {
+ 0 => Some(Self::Th),
+ 1 => Some(Self::St),
+ 2 => Some(Self::Nd),
+ 3 => Some(Self::Rd),
+ 4 => Some(Self::Th),
+ 5 => Some(Self::Th),
+ 6 => Some(Self::Th),
+ 7 => Some(Self::Th),
+ 8 => Some(Self::Th),
+ 9 => Some(Self::Th),
+ _ => None,
+ }
+ }
+
+ pub fn to_chars(self) -> Vec<char> {
+ match self {
+ NumberSuffix::Th => vec!['t', 'h'],
+ NumberSuffix::St => vec!['s', 't'],
+ NumberSuffix::Nd => vec!['n', 'd'],
+ NumberSuffix::Rd => vec!['r', 'd'],
+ }
+ }
+
+ /// Check the first several characters in a buffer to see if it matches a
+ /// number suffix.
+ pub fn from_chars(chars: &[char]) -> Option<Self> {
+ if chars.len() < 2 {
+ return None;
+ }
+
+ match (chars[0], chars[1]) {
+ ('t', 'h') => Some(NumberSuffix::Th),
+ ('T', 'h') => Some(NumberSuffix::Th),
+ ('t', 'H') => Some(NumberSuffix::Th),
+ ('T', 'H') => Some(NumberSuffix::Th),
+ ('s', 't') => Some(NumberSuffix::St),
+ ('S', 't') => Some(NumberSuffix::St),
+ ('s', 'T') => Some(NumberSuffix::St),
+ ('S', 'T') => Some(NumberSuffix::St),
+ ('n', 'd') => Some(NumberSuffix::Nd),
+ ('N', 'd') => Some(NumberSuffix::Nd),
+ ('n', 'D') => Some(NumberSuffix::Nd),
+ ('N', 'D') => Some(NumberSuffix::Nd),
+ ('r', 'd') => Some(NumberSuffix::Rd),
+ ('R', 'd') => Some(NumberSuffix::Rd),
+ ('r', 'D') => Some(NumberSuffix::Rd),
+ ('R', 'D') => Some(NumberSuffix::Rd),
+ _ => None,
+ }
+ }
+}
diff --git a/harper-core/src/token_kind.rs b/harper-core/src/token_kind.rs
index 0e5a09597..5505e668f 100644
--- a/harper-core/src/token_kind.rs
+++ b/harper-core/src/token_kind.rs
@@ -2,7 +2,7 @@ use is_macro::Is;
use ordered_float::OrderedFloat;
use serde::{Deserialize, Serialize};
-use crate::{ConjunctionData, NounData, Punctuation, Quote, WordMetadata};
+use crate::{ConjunctionData, NounData, Number, Punctuation, Quote, WordMetadata};
#[derive(
Debug, Is, Clone, Copy, Serialize, Deserialize, Default, PartialOrd, Hash, Eq, PartialEq,
@@ -11,7 +11,7 @@ use crate::{ConjunctionData, NounData, Punctuation, Quote, WordMetadata};
pub enum TokenKind {
Word(WordMetadata),
Punctuation(Punctuation),
- Number(OrderedFloat<f64>, Option<NumberSuffix>),
+ Number(Number),
/// A sequence of " " spaces.
Space(usize),
/// A sequence of "\n" newlines
@@ -162,7 +162,7 @@ impl TokenKind {
match self {
TokenKind::Word(_) => TokenKind::Word(Default::default()),
TokenKind::Punctuation(_) => TokenKind::Punctuation(Default::default()),
- TokenKind::Number(..) => TokenKind::Number(Default::default(), Default::default()),
+ TokenKind::Number(..) => TokenKind::Number(Default::default()),
TokenKind::Space(_) => TokenKind::Space(Default::default()),
TokenKind::Newline(_) => TokenKind::Newline(Default::default()),
_ => *self,
@@ -177,84 +177,6 @@ impl TokenKind {
}
}
-#[derive(
- Debug, Serialize, Deserialize, Default, PartialEq, PartialOrd, Clone, Copy, Is, Hash, Eq,
-)]
-pub enum NumberSuffix {
- #[default]
- Th,
- St,
- Nd,
- Rd,
-}
-
-impl NumberSuffix {
- pub fn correct_suffix_for(number: impl Into<f64>) -> Option<Self> {
- let number = number.into();
-
- if number < 0.0 || number - number.floor() > f64::EPSILON || number > u64::MAX as f64 {
- return None;
- }
-
- let integer = number as u64;
-
- if let 11..=13 = integer % 100 {
- return Some(Self::Th);
- };
-
- match integer % 10 {
- 0 => Some(Self::Th),
- 1 => Some(Self::St),
- 2 => Some(Self::Nd),
- 3 => Some(Self::Rd),
- 4 => Some(Self::Th),
- 5 => Some(Self::Th),
- 6 => Some(Self::Th),
- 7 => Some(Self::Th),
- 8 => Some(Self::Th),
- 9 => Some(Self::Th),
- _ => None,
- }
- }
-
- pub fn to_chars(self) -> Vec<char> {
- match self {
- NumberSuffix::Th => vec!['t', 'h'],
- NumberSuffix::St => vec!['s', 't'],
- NumberSuffix::Nd => vec!['n', 'd'],
- NumberSuffix::Rd => vec!['r', 'd'],
- }
- }
-
- /// Check the first several characters in a buffer to see if it matches a
- /// number suffix.
- pub fn from_chars(chars: &[char]) -> Option<Self> {
- if chars.len() < 2 {
- return None;
- }
-
- match (chars[0], chars[1]) {
- ('t', 'h') => Some(NumberSuffix::Th),
- ('T', 'h') => Some(NumberSuffix::Th),
- ('t', 'H') => Some(NumberSuffix::Th),
- ('T', 'H') => Some(NumberSuffix::Th),
- ('s', 't') => Some(NumberSuffix::St),
- ('S', 't') => Some(NumberSuffix::St),
- ('s', 'T') => Some(NumberSuffix::St),
- ('S', 'T') => Some(NumberSuffix::St),
- ('n', 'd') => Some(NumberSuffix::Nd),
- ('N', 'd') => Some(NumberSuffix::Nd),
- ('n', 'D') => Some(NumberSuffix::Nd),
- ('N', 'D') => Some(NumberSuffix::Nd),
- ('r', 'd') => Some(NumberSuffix::Rd),
- ('R', 'd') => Some(NumberSuffix::Rd),
- ('r', 'D') => Some(NumberSuffix::Rd),
- ('R', 'D') => Some(NumberSuffix::Rd),
- _ => None,
- }
- }
-}
-
impl TokenKind {
pub fn as_mut_quote(&mut self) -> Option<&mut Quote> {
self.as_mut_punctuation()?.as_mut_quote()
diff --git a/harper-typst/src/lib.rs b/harper-typst/src/lib.rs
index 9668fc527..28288be2d 100644
--- a/harper-typst/src/lib.rs
+++ b/harper-typst/src/lib.rs
@@ -39,7 +39,7 @@ mod tests {
use ordered_float::OrderedFloat;
use super::Typst;
- use harper_core::{Document, NounData, Punctuation, TokenKind, WordMetadata};
+ use harper_core::{Document, NounData, Number, Punctuation, TokenKind, WordMetadata};
#[test]
fn number() {
@@ -52,7 +52,11 @@ mod tests {
assert!(matches!(
token_kinds.as_slice(),
&[
- TokenKind::Number(OrderedFloat(12.0), None),
+ TokenKind::Number(Number {
+ value: OrderedFloat(12.0),
+ suffix: None,
+ ..
+ }),
TokenKind::Space(1),
TokenKind::Word(_),
TokenKind::Space(1),
@@ -60,7 +64,11 @@ mod tests {
TokenKind::Space(1),
TokenKind::Word(_),
TokenKind::Space(1),
- TokenKind::Number(OrderedFloat(11.0), None),
+ TokenKind::Number(Number {
+ value: OrderedFloat(11.0),
+ suffix: None,
+ ..
+ }),
TokenKind::Punctuation(Punctuation::Comma),
TokenKind::Space(1),
TokenKind::Word(_),
@@ -71,7 +79,11 @@ mod tests {
TokenKind::Space(1),
TokenKind::Word(_),
TokenKind::Space(1),
- TokenKind::Number(OrderedFloat(11.0), None),
+ TokenKind::Number(Number {
+ value: OrderedFloat(11.0),
+ suffix: None,
+ ..
+ }),
TokenKind::Punctuation(Punctuation::Bang),
]
))