From 5bfa1f01bfd0190b552d6d1cc4640bf60e78c196 Mon Sep 17 00:00:00 2001 From: Ali Ghahremani Date: Sun, 21 Apr 2024 19:44:29 +0330 Subject: [PATCH] feat: separator option for abbreviate --- README.md | 2 +- src/calculation.rs | 10 +-- src/lib.rs | 74 ++++++++++--------- tests/abbreviate_tests.rs | 110 +++++++++++++++-------------- tests/fraction_abbreviate_tests.rs | 16 ++--- 5 files changed, 115 insertions(+), 97 deletions(-) diff --git a/README.md b/README.md index c4a2842..26afd2c 100644 --- a/README.md +++ b/README.md @@ -105,7 +105,7 @@ Program Will Automaticly Remove Leading Zero (001 Will Become 1 and etc) ```[tasklist] - [ ] Optimize Code - [ ] Create Custom Symbols -- [ ] Create Padding For Symbols +- [x] Custom separator pass by option - [ ] Create Unit Conversion ``` diff --git a/src/calculation.rs b/src/calculation.rs index 8cd63b7..7fe4eb9 100644 --- a/src/calculation.rs +++ b/src/calculation.rs @@ -1,10 +1,12 @@ +use crate::AbbreviationOptions; + const SYMBOLS: [&str; 21] = [ "q", "r", "y", "z", "a", "f", "p", "n", "μ", "m", "", "K", "M", "G", "T", "P", "E", "Z", "Y", "R", "Q", ]; const FRACTION_COUNT: usize = 10; -pub fn abbreviate_number(num: f64) -> String { +pub fn abbreviate_number(num: f64, options: &AbbreviationOptions) -> String { let base: f64 = 1000.0; let mut number = num; let max_legal_index = SYMBOLS.len() - 1; @@ -15,7 +17,7 @@ pub fn abbreviate_number(num: f64) -> String { let symbol = *SYMBOLS.get(index_of_symbol).unwrap(); let pw: f64 = base.powf((index_of_symbol - FRACTION_COUNT) as f64); number /= pw; - format!("{}{}", remove_floating_zero(number), symbol) + format!("{}{}{}", remove_floating_zero(number), options.separator, symbol) } pub fn unabbreviate_number(number: &str) -> f64 { @@ -50,7 +52,7 @@ pub fn unabbreviate_number(number: &str) -> f64 { } } -pub fn abbreviate_fraction_number(num: f64) -> String { +pub fn abbreviate_fraction_number(num: f64, options: &AbbreviationOptions) -> String { let mut number = num.abs(); let mut ten_th_counter = 0; const THOUSAND: f64 = 1000.0; @@ -67,7 +69,7 @@ pub fn abbreviate_fraction_number(num: f64) -> String { let symbol = *SYMBOLS.get(symbol_index as usize).unwrap_or(&""); let result = (num * THOUSAND.powf(thousand_raise)) as i128; - format!("{result}{symbol}") + format!("{}{}{}", result, options.separator, symbol) } fn remove_floating_zero(number: f64) -> String { diff --git a/src/lib.rs b/src/lib.rs index cb52e34..8df1996 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -6,14 +6,14 @@ pub trait NumericAbbreviate { /// ``` /// use rs_abbreviation_number::*; /// let number=110_000; - /// let result=number.abbreviate_number(); + /// let result=number.abbreviate_number(&Default::default()); /// assert_eq!("110K",result); /// /// let number=0.000_1; - /// let result=number.abbreviate_number(); + /// let result=number.abbreviate_number(&Default::default()); /// assert_eq!("100μ",result); /// ``` - fn abbreviate_number(&self) -> String; + fn abbreviate_number(&self, options: &AbbreviationOptions) -> String; } pub trait NumericUnAbbreviate { @@ -35,80 +35,80 @@ pub trait NumericUnAbbreviate { } impl NumericAbbreviate for f64 { - fn abbreviate_number(&self) -> String { - handle_abbreviation(*self) + fn abbreviate_number(&self, options: &AbbreviationOptions) -> String { + handle_abbreviation(*self,options) } } impl NumericAbbreviate for f32 { - fn abbreviate_number(&self) -> String { - handle_abbreviation(*self as f64) + fn abbreviate_number(&self, options: &AbbreviationOptions) -> String { + handle_abbreviation(*self as f64,options) } } impl NumericAbbreviate for i128 { - fn abbreviate_number(&self) -> String { - handle_abbreviation(*self as f64) + fn abbreviate_number(&self, options: &AbbreviationOptions) -> String { + handle_abbreviation(*self as f64,options) } } impl NumericAbbreviate for i64 { - fn abbreviate_number(&self) -> String { - handle_abbreviation(*self as f64) + fn abbreviate_number(&self, options: &AbbreviationOptions) -> String { + handle_abbreviation(*self as f64,options) } } impl NumericAbbreviate for i32 { - fn abbreviate_number(&self) -> String { - handle_abbreviation(*self as f64) + fn abbreviate_number(&self, options: &AbbreviationOptions) -> String { + handle_abbreviation(*self as f64,options) } } impl NumericAbbreviate for i16 { - fn abbreviate_number(&self) -> String { - handle_abbreviation(*self as f64) + fn abbreviate_number(&self, options: &AbbreviationOptions) -> String { + handle_abbreviation(*self as f64,options) } } impl NumericAbbreviate for i8 { - fn abbreviate_number(&self) -> String { - handle_abbreviation(*self as f64) + fn abbreviate_number(&self, options: &AbbreviationOptions) -> String { + handle_abbreviation(*self as f64,options) } } impl NumericAbbreviate for usize { - fn abbreviate_number(&self) -> String { - handle_abbreviation(*self as f64) + fn abbreviate_number(&self, options: &AbbreviationOptions) -> String { + handle_abbreviation(*self as f64,options) } } impl NumericAbbreviate for u128 { - fn abbreviate_number(&self) -> String { - handle_abbreviation(*self as f64) + fn abbreviate_number(&self, options: &AbbreviationOptions) -> String { + handle_abbreviation(*self as f64,options) } } impl NumericAbbreviate for u64 { - fn abbreviate_number(&self) -> String { - handle_abbreviation(*self as f64) + fn abbreviate_number(&self, options: &AbbreviationOptions) -> String { + handle_abbreviation(*self as f64,options) } } impl NumericAbbreviate for u32 { - fn abbreviate_number(&self) -> String { - handle_abbreviation(*self as f64) + fn abbreviate_number(&self, options: &AbbreviationOptions) -> String { + handle_abbreviation(*self as f64,options) } } impl NumericAbbreviate for u16 { - fn abbreviate_number(&self) -> String { - handle_abbreviation(*self as f64) + fn abbreviate_number(&self, options: &AbbreviationOptions) -> String { + handle_abbreviation(*self as f64,options) } } impl NumericAbbreviate for u8 { - fn abbreviate_number(&self) -> String { - handle_abbreviation(*self as f64) + fn abbreviate_number(&self, options: &AbbreviationOptions) -> String { + handle_abbreviation(*self as f64,options) } } @@ -124,10 +124,20 @@ impl NumericUnAbbreviate for &str { } } -fn handle_abbreviation(number: f64) -> String { +fn handle_abbreviation(number: f64, options: &AbbreviationOptions) -> String { if number.abs() >= 1.0 || number == 0.0 { - abbreviate_number(number) + abbreviate_number(number,options) } else { - abbreviate_fraction_number(number) + abbreviate_fraction_number(number,options) } } + +pub struct AbbreviationOptions{ + pub separator: String +} + +impl Default for AbbreviationOptions { + fn default() -> Self { + Self { separator: "".to_string() } + } +} \ No newline at end of file diff --git a/tests/abbreviate_tests.rs b/tests/abbreviate_tests.rs index 010fdef..a4e9025 100644 --- a/tests/abbreviate_tests.rs +++ b/tests/abbreviate_tests.rs @@ -5,63 +5,63 @@ mod abbreviate_tests { #[test] fn mix_floating_test() { - assert_eq!("1.43K", 1435.549.abbreviate_number()); + assert_eq!("1.43K", 1435.549.abbreviate_number(&Default::default())); } #[test] fn mix_negative_floating_test() { - assert_eq!("-1.43K", (-1435.549).abbreviate_number()); + assert_eq!("-1.43K", (-1435.549).abbreviate_number(&Default::default())); } #[test] fn abbreviate_number_less_then_thousand_test() { - assert_eq!("1", 1.abbreviate_number()); - assert_eq!("0", 0.abbreviate_number()); - assert_eq!("123", 123.0.abbreviate_number()); + assert_eq!("1", 1.abbreviate_number(&Default::default())); + assert_eq!("0", 0.abbreviate_number(&Default::default())); + assert_eq!("123", 123.0.abbreviate_number(&Default::default())); } #[test] fn abbreviate_number_ceil_test() { - assert_eq!("1K", 1_000.0.abbreviate_number()); - assert_eq!("1M", 1_000_000.0.abbreviate_number()); - assert_eq!("16G", 16_000_000_000.0.abbreviate_number()); - assert_eq!("1T", (1_000_000_000_000.0).abbreviate_number()); - assert_eq!("54P", (54_000_000_000_000_000.0).abbreviate_number()); - assert_eq!("123E", 123_000_000_000_000_000_000.0.abbreviate_number()); + assert_eq!("1K", 1_000.0.abbreviate_number(&Default::default())); + assert_eq!("1M", 1_000_000.0.abbreviate_number(&Default::default())); + assert_eq!("16G", 16_000_000_000.0.abbreviate_number(&Default::default())); + assert_eq!("1T", (1_000_000_000_000.0).abbreviate_number(&Default::default())); + assert_eq!("54P", (54_000_000_000_000_000.0).abbreviate_number(&Default::default())); + assert_eq!("123E", 123_000_000_000_000_000_000.0.abbreviate_number(&Default::default())); } #[test] fn abbreviate_number_randoms_test() { - assert_eq!("5K", 5_000.0.abbreviate_number()); - assert_eq!("12M", 12_000_430.0.abbreviate_number()); - assert_eq!("1G", 1_000_345_000.0.abbreviate_number()); - assert_eq!("133T", 133_000_000_055_000.0.abbreviate_number()); - assert_eq!("166P", 166_000_643_300_000_000.0.abbreviate_number()); - assert_eq!("999E", 999_000_123_123_000_000_123.0.abbreviate_number()); + assert_eq!("5K", 5_000.0.abbreviate_number(&Default::default())); + assert_eq!("12M", 12_000_430.0.abbreviate_number(&Default::default())); + assert_eq!("1G", 1_000_345_000.0.abbreviate_number(&Default::default())); + assert_eq!("133T", 133_000_000_055_000.0.abbreviate_number(&Default::default())); + assert_eq!("166P", 166_000_643_300_000_000.0.abbreviate_number(&Default::default())); + assert_eq!("999E", 999_000_123_123_000_000_123.0.abbreviate_number(&Default::default())); } #[test] fn abbreviate_number_randoms_floating_test() { - assert_eq!("5.1K", 5_100.0.abbreviate_number()); - assert_eq!("5.09K", 5_090.0.abbreviate_number()); - assert_eq!("12.01M", 12_010_430.0.abbreviate_number()); - assert_eq!("1.1G", 1_100_345_000.0.abbreviate_number()); - assert_eq!("133.09T", 133_090_000_055_000.0.abbreviate_number()); - assert_eq!("166.05P", 166_050_643_300_000_000.0.abbreviate_number()); - assert_eq!("999.5E", 999_500_123_123_000_000_123.0.abbreviate_number()); + assert_eq!("5.1K", 5_100.0.abbreviate_number(&Default::default())); + assert_eq!("5.09K", 5_090.0.abbreviate_number(&Default::default())); + assert_eq!("12.01M", 12_010_430.0.abbreviate_number(&Default::default())); + assert_eq!("1.1G", 1_100_345_000.0.abbreviate_number(&Default::default())); + assert_eq!("133.09T", 133_090_000_055_000.0.abbreviate_number(&Default::default())); + assert_eq!("166.05P", 166_050_643_300_000_000.0.abbreviate_number(&Default::default())); + assert_eq!("999.5E", 999_500_123_123_000_000_123.0.abbreviate_number(&Default::default())); } #[test] fn abbreviate_number_negative_test() { - assert_eq!("-5.1K", (-5_100.0).abbreviate_number()); - assert_eq!("-5.09K", (-5_090.0).abbreviate_number()); - assert_eq!("-12.01M", (-12_010_430.0).abbreviate_number()); - assert_eq!("-1.1G", (-1_100_345_000.0).abbreviate_number()); - assert_eq!("-133.09T", (-133_090_000_055_000.0).abbreviate_number()); - assert_eq!("-166.05P", (-166_050_643_300_000_000.0).abbreviate_number()); + assert_eq!("-5.1K", (-5_100.0).abbreviate_number(&Default::default())); + assert_eq!("-5.09K", (-5_090.0).abbreviate_number(&Default::default())); + assert_eq!("-12.01M", (-12_010_430.0).abbreviate_number(&Default::default())); + assert_eq!("-1.1G", (-1_100_345_000.0).abbreviate_number(&Default::default())); + assert_eq!("-133.09T", (-133_090_000_055_000.0).abbreviate_number(&Default::default())); + assert_eq!("-166.05P", (-166_050_643_300_000_000.0).abbreviate_number(&Default::default())); assert_eq!( "-999.5E", - (-999_500_123_123_000_000_123.0).abbreviate_number() + (-999_500_123_123_000_000_123.0).abbreviate_number(&Default::default()) ); } @@ -69,18 +69,24 @@ mod abbreviate_tests { fn abbreviate_number_big_negative_number_test() { assert_eq!( "-999.5Q", - (-999_509_999_999_999_000_123_123_000_000_123.0).abbreviate_number() + (-999_509_999_999_999_000_123_123_000_000_123.0).abbreviate_number(&Default::default()) ); let big_num: i128 = -999_509_999_999_999_000_123_123_000_000_123; - assert_eq!("-999.5Q", big_num.abbreviate_number()); + assert_eq!("-999.5Q", big_num.abbreviate_number(&Default::default())); } #[test] fn abbreviate_number_big_number_test() { let big_num: i128 = 999_509_999_999_999_000_123_123_000_000_123; - assert_eq!("999.5Q", big_num.abbreviate_number()); + assert_eq!("999.5Q", big_num.abbreviate_number(&Default::default())); + } + + #[test] + fn abbreviate_number_with_option_test() { + assert_eq!("1-K", 1_000.0.abbreviate_number(&AbbreviationOptions { separator: "-".to_string() })); + assert_eq!("1 - K", 1_000.0.abbreviate_number(&AbbreviationOptions { separator: " - ".to_string() })); } } @@ -89,30 +95,30 @@ mod integer_abbreviate_tests { use rs_abbreviation_number::*; #[test] fn abbreviate_inumber_less_then_thousand_test() { - assert_eq!("1", 1.abbreviate_number()); - assert_eq!("0", 0.abbreviate_number()); - assert_eq!("123", 123.abbreviate_number()); + assert_eq!("1", 1.abbreviate_number(&Default::default())); + assert_eq!("0", 0.abbreviate_number(&Default::default())); + assert_eq!("123", 123.abbreviate_number(&Default::default())); } #[test] fn abbreviate_number_ceil_test() { - assert_eq!("1K", 1_000.abbreviate_number()); - assert_eq!("1M", 1_000_000.abbreviate_number()); + assert_eq!("1K", 1_000.abbreviate_number(&Default::default())); + assert_eq!("1M", 1_000_000.abbreviate_number(&Default::default())); } #[test] fn abbreviate_number_randoms_test() { - assert_eq!("5K", 5_000.abbreviate_number()); - assert_eq!("12M", 12_000_430.abbreviate_number()); - assert_eq!("1G", 1_000_345_000.abbreviate_number()); + assert_eq!("5K", 5_000.abbreviate_number(&Default::default())); + assert_eq!("12M", 12_000_430.abbreviate_number(&Default::default())); + assert_eq!("1G", 1_000_345_000.abbreviate_number(&Default::default())); } #[test] fn abbreviate_number_negative_test() { - assert_eq!("-5.1K", (-5_100).abbreviate_number()); - assert_eq!("-5.09K", (-5_090).abbreviate_number()); - assert_eq!("-12.01M", (-12_010_430).abbreviate_number()); - assert_eq!("-1.1G", (-1_100_345_000).abbreviate_number()); + assert_eq!("-5.1K", (-5_100).abbreviate_number(&Default::default())); + assert_eq!("-5.09K", (-5_090).abbreviate_number(&Default::default())); + assert_eq!("-12.01M", (-12_010_430).abbreviate_number(&Default::default())); + assert_eq!("-1.1G", (-1_100_345_000).abbreviate_number(&Default::default())); } } @@ -122,21 +128,21 @@ mod utype_tests { #[test] fn abbreviate_number_randoms_test() { let num128: u128 = 999_509_999_999_999_000_123_123_000_000_123; - assert_eq!("999.5Q", num128.abbreviate_number()); + assert_eq!("999.5Q", num128.abbreviate_number(&Default::default())); let num64: u64 = 999_509_999_999_999_000; - assert_eq!("999.5P", num64.abbreviate_number()); + assert_eq!("999.5P", num64.abbreviate_number(&Default::default())); let num32: u32 = 999_509_999; - assert_eq!("999.5M", num32.abbreviate_number()); + assert_eq!("999.5M", num32.abbreviate_number(&Default::default())); let num16: u16 = 9999; - assert_eq!("9.99K", num16.abbreviate_number()); + assert_eq!("9.99K", num16.abbreviate_number(&Default::default())); let num8: u8 = 99; - assert_eq!("99", num8.abbreviate_number()); + assert_eq!("99", num8.abbreviate_number(&Default::default())); let num: usize = 10_000_000_000_000_000_000; - assert_eq!("10E", num.abbreviate_number()); + assert_eq!("10E", num.abbreviate_number(&Default::default())); } } diff --git a/tests/fraction_abbreviate_tests.rs b/tests/fraction_abbreviate_tests.rs index 6aaef92..3d0606b 100644 --- a/tests/fraction_abbreviate_tests.rs +++ b/tests/fraction_abbreviate_tests.rs @@ -4,25 +4,25 @@ mod tests { #[test] fn small_number_test() { - assert_eq!("10n", (0.000_000_010).abbreviate_number()); - assert_eq!("643n", (0.000_000_643).abbreviate_number()); + assert_eq!("10n", (0.000_000_010).abbreviate_number(&Default::default())); + assert_eq!("643n", (0.000_000_643).abbreviate_number(&Default::default())); } #[test] fn small_negative_number_test() { - assert_eq!("-10n", (-0.000_000_010).abbreviate_number()); - assert_eq!("-643n", (-0.000_000_643).abbreviate_number()); + assert_eq!("-10n", (-0.000_000_010).abbreviate_number(&Default::default())); + assert_eq!("-643n", (-0.000_000_643).abbreviate_number(&Default::default())); } #[test] fn deep_number_test() { assert_eq!( "100q", - (0.000_000_000_000_000_000_000_000_000_1).abbreviate_number() + (0.000_000_000_000_000_000_000_000_000_1).abbreviate_number(&Default::default()) ); assert_eq!( "0", - 0.000_000_000_000_000_000_000_000_000_000_1.abbreviate_number() + 0.000_000_000_000_000_000_000_000_000_000_1.abbreviate_number(&Default::default()) ); } @@ -30,12 +30,12 @@ mod tests { fn deep_negative_number_test() { assert_eq!( "-100q", - (-0.000_000_000_000_000_000_000_000_000_1).abbreviate_number() + (-0.000_000_000_000_000_000_000_000_000_1).abbreviate_number(&Default::default()) ); assert_eq!( "0", - (-0.000_000_000_000_000_000_000_000_000_000_1).abbreviate_number() + (-0.000_000_000_000_000_000_000_000_000_000_1).abbreviate_number(&Default::default()) ); } }