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

mod decimal_format;
mod parser;
mod schema;

pub use parser::*;
pub use schema::*;
pub use decimal_format::*;

pub fn parser(config: parser::ParserConfig) -> Result<(), Vec<ValidationError>> {
    parser::Parser::new(config).start()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_schema() {
        let schema: schema::Schema =
            schema::Schema::load("./example/schema.xml").expect("Failed to load schema");
        assert!(schema.fixedwidthschema.is_some());
    }

    #[test]
    fn test_parser() {
        let parser = parser::Parser::new(parser::ParserConfig {
            file_path: "./example/data.txt".to_string(),
            fn_worker: None,
            n_workers: 4,
            file_schema: "./example/schema.xml".to_string(),
        });
        let result = parser.start();

        match result {
            Ok(_) => (),
            Err(errors) => {
                for v in errors {
                    println!("Line {}: {:?}", v.line, v.message);
                }
                //panic!("Failed to parse file");
            }
        }

        //assert!(result.is_ok(), "ERROR: {:?}", result.unwrap_err());
    }

    #[test]
    fn test_validate_number() {
        // # is optional digit, 0 is required digit
        let pattern = "0,##0.00;(#,##0.000)";
        let formatter = decimal_format::DecimalFormat::new(pattern).unwrap();
        assert!(formatter.validate_number("2,234.56").is_ok());
        assert!(formatter.validate_number("-1,234.560").is_ok());
        assert!(formatter.validate_number("1234.56").is_ok());
        assert!(formatter.validate_number("1234").is_err());

        let pattern = "0.#0,##0";
        let formatter = decimal_format::DecimalFormat::new(pattern).unwrap();
        assert!(formatter.validate_number("2.20,125").is_ok());
        
        let pattern = "';#'##0";
        let formatter = decimal_format::DecimalFormat::new(pattern).unwrap();
        assert!(formatter.validate_number(";#123").is_ok());

        let pattern = "#######0.00";
        let formatter = decimal_format::DecimalFormat::new(pattern).unwrap();
        assert!(formatter.validate_number("00204000.00").is_ok());
    }
}