csv-sanity 0.1.0

Sanitize and transform large CSVs with millions of records quickly and efficiently.
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

use Transformer;
use transformer::{
    TransformResultHelper,
    TransformResult
};
use newtypes::Regex;

use regex;

#[derive(Serialize, Deserialize, PartialEq, Eq, Hash, Clone, Debug)]
pub struct RegexTransformer
{
    regex: Regex,
    template: String
}

impl RegexTransformer
{
    pub fn new(regex: regex::Regex, template: &str) -> RegexTransformer {
        RegexTransformer {
            regex: Regex::from(regex),
            template: template.to_string()
        }
    }
}

impl Transformer for RegexTransformer
{
    fn transform(&self, field_value: &str, field_name: &str, record_n: usize) -> TransformResult {
        if let Some(captures) = self.regex.captures(field_value) {
            let mut expansion = String::new();
            captures.expand(&self.template, &mut expansion);
            TransformResult::present(&expansion)
        } else {
            TransformResult::error(
                field_value,
                field_name,
                record_n,
                &format!("did not match pattern {}", self.regex)
            )
        }
    }
}

#[derive(Serialize, Deserialize, PartialEq, Eq, Hash, Clone, Debug)]
pub struct RegexMatchTransformer
{
    regex: Regex,
    negate: bool
}

impl RegexMatchTransformer
{
    pub fn matching(regex: regex::Regex) -> RegexMatchTransformer {
        RegexMatchTransformer {
            regex: Regex::from(regex),
            negate: false
        }
    }

    pub fn not_matching(regex: regex::Regex) -> RegexMatchTransformer {
        RegexMatchTransformer {
            regex: Regex::from(regex),
            negate: true
        }
    }
}

impl Transformer for RegexMatchTransformer
{
    fn transform(&self, field_value: &str, field_name: &str, record_n: usize) -> TransformResult {
        let mut is_match = self.regex.is_match(field_value);
        if self.negate {
            is_match = !is_match;
        }

        if is_match {
            TransformResult::present(field_value)
        } else {
            let reason = if self.negate {
                format!("matched exclusionary pattern {}", self.regex)
            } else {
                format!("did not match pattern {}", self.regex)
            };
            TransformResult::error(field_value, field_name, record_n, &reason)
        }
    }
}