rsapar 0.1.1

RSaPar is a Rust library for schema-based parsing and validation of structured data files, inspired by JSaPar for Java.
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
90
91
92
93
94
95
96
97
98
99

use regex::Regex;

pub struct DecimalFormat {
    positive_pattern: String,
    negative_pattern: String,
}
/// Convert DecimalFormat (Java) pattern to regex.
/// @see: [DecimalFormat](https://docs.oracle.com/javase/8/docs/api/java/text/DecimalFormat.html)
impl DecimalFormat {
    pub fn new(pattern: &str) -> Result<Self, String> {
        let special_chars = ['\'', '(', ')', '0', '.', ',', '#', ';', '¤', '%'];
        let mut in_quotes = false;
        let mut patterns = vec![String::new()];
        for c in pattern.chars() {
            if !in_quotes && c == '\'' {
                in_quotes = true;
                patterns.last_mut().unwrap().push(c);
                continue;
            }
            if in_quotes && c == '\'' {
                in_quotes = false;
                patterns.last_mut().unwrap().push(c);
                continue;
            }
            if !in_quotes && !special_chars.contains(&c) {
                return Err(format!("Invalid character: {}", c));
            }

            if c == ';' && !in_quotes {
                patterns.push(String::new()); // Start a new pattern.
            } else {
                patterns.last_mut().unwrap().push(c); // Append to the current pattern.
            }
        }

        if patterns.len() > 2 {
            return Err("Invalid pattern".to_string());
        }

        let positive_pattern = patterns.first().ok_or("Missing positive pattern")?.clone();
        let negative_pattern = patterns
            .get(1)
            .map(|p| format!("-{}", p))
            .unwrap_or_else(|| format!("-{}", positive_pattern));

        Ok(DecimalFormat {
            positive_pattern,
            negative_pattern,
        })
    }

    pub fn validate_number(&self, input: &str) -> Result<(), &'static str> {
        let positive_regex = Self::pattern_to_regex(&self.positive_pattern)?;
        let negative_regex = Self::pattern_to_regex(&self.negative_pattern)?;

        let positive_re = Regex::new(&positive_regex).map_err(|_| "Invalid regex pattern")?;
        let negative_re = Regex::new(&negative_regex).map_err(|_| "Invalid regex pattern")?;

        if positive_re.is_match(input) || negative_re.is_match(input) {
            Ok(())
        } else {
            Err("Input does not match pattern")
        }
    }

    fn pattern_to_regex(pattern: &str) -> Result<String, &'static str> {
        let mut regex_pattern = String::new();
        let mut in_quotes = false;

        for c in pattern.chars() {
            if !in_quotes && c == '\'' {
                in_quotes = true;
                continue;
            }
            if in_quotes && c == '\'' {
                in_quotes = false;
                continue;
            }

            if in_quotes {
                regex_pattern.push(c);
            } else {
                match c {
                    '0' => regex_pattern.push_str("\\d"), // Match a digit.
                    '#' => regex_pattern.push_str("\\d?"), // Match an optional digit.
                    ',' => regex_pattern.push_str("\\,?"),
                    '.' => regex_pattern.push_str("\\."),
                    ';' => regex_pattern.push_str("\\;"),
                    '¤' => regex_pattern.push_str("\\$"),
                    _ => regex_pattern.push(c),
                }
            }
        }

        regex_pattern.insert(0, '^');
        regex_pattern.push('$');
        Ok(regex_pattern)
    }
}