alphanumeric 0.1.0

International number format parsing and validation with support for multiple separator conventions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

/// Detect if a numeric string uses the European format with , as the decimal separator and dots as thousand separators
/// If only one comma is present, *enforce_euro_mode* will treat the comma as a decimal separator.
/// Otherwise it will be assumed to be a thousand separator
pub fn uses_decimal_comma(txt: &str, enforce_euro_mode: bool) -> bool {
    let chs = txt.char_indices();
    let mut num_indices = 0;
    let mut dot_pos: Option<usize> = None;
    let mut num_dots = 0;
    let mut num_commas = 0;
    let mut comma_pos: Option<usize> = None;
    for (index, ch) in chs {
        match ch {
            '.' => {
                if dot_pos.is_none() {
                    dot_pos = Some(index);
                }
                num_dots += 1;
            }
            ',' => {
                if comma_pos.is_none() {
                    comma_pos = Some(index);
                }
                num_commas += 1;
            }
            _ => (),
        }
        num_indices += 1; // count indices here to avoid cloning above
    }
    if let Some(d_pos) = dot_pos {
        if let Some(c_pos) = comma_pos {
            d_pos < c_pos
        } else {
            // if it only has one dot only interpate as decimal separator if enforce_euro_mode is true
            num_dots > 1 || enforce_euro_mode
        }
    } else {
        // no dots
        if let Some(c_pos) = comma_pos {
            if num_commas > 1 {
                false
            } else {
                // with only one comma, assume it's a decimal separator
                // if it is not exactly 4 positions from the right or if enforce
                num_indices - c_pos != 4 || enforce_euro_mode
            }
        } else {
            false
        }
    }
}

#[cfg(test)]
mod tests {
    // Note this useful idiom: importing names from outer (for mod tests) scope.
    use super::*;

    #[test]
    fn test_number_format_1() {
        let sample = "1.256";
        assert_eq!(uses_decimal_comma(sample, false), false);
    }

    #[test]
    fn test_number_format_2() {
        let sample = "1,256";
        assert_eq!(uses_decimal_comma(sample, false), false);
    }

    #[test]
    fn test_number_format_3() {
        let sample = "12,56";

        assert_eq!(uses_decimal_comma(sample, false), true);
    }

    #[test]
    fn test_number_format_4() {
        let sample = "1,256.67";

        assert_eq!(uses_decimal_comma(sample, false), false);
    }

    #[test]
    fn test_number_format_5() {
        let sample = "1.256,67";

        assert_eq!(uses_decimal_comma(sample, false), true);
    }
}