csv_utility 0.1.1

CLI to map csv files and some other utilities.
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
100
101

use std::fs::File;
use std::path::Path;
use seahorse::Context;
use seahorse::error::FlagError;

pub fn get_file(c: &Context, string_flag: &str) -> File {
    match c.string_flag(string_flag) {
        Ok(path) => {
            match Path::new(&path).exists() {
                true => {
                    File::open(path).unwrap()
                }
                false => {
                    eprintln!("Source file: '{}' does not exists!", path);
                    std::process::exit(0);
                }
            }
        }
        Err(e) => match e {
            FlagError::Undefined => panic!("undefined operator..."),
            FlagError::ArgumentError => panic!("argument error..."),
            FlagError::NotFound => panic!("not found flag..."),
            FlagError::ValueTypeError => panic!("value type mismatch..."),
            FlagError::TypeError => panic!("flag type mismatch..."),
        },
    }
}

pub fn create_output_file(c: &Context) -> File {
    match c.string_flag("output") {
        Ok(path) => {
            match File::create(&path) {
                Ok(file) => {
                    file
                }
                Err(_) => {
                    eprintln!("Could not create output file: '{}'!", path);
                    std::process::exit(0);
                }
            }
        }
        Err(e) => match e {
            FlagError::Undefined => panic!("undefined operator..."),
            FlagError::ArgumentError => panic!("argument error..."),
            FlagError::NotFound => panic!("not found flag..."),
            FlagError::ValueTypeError => panic!("value type mismatch..."),
            FlagError::TypeError => panic!("flag type mismatch..."),
        },
    }
}

pub fn get_threshold(c: &Context) -> usize {
    match c.string_flag("threshold") {
        Ok(threshold) => {
            match threshold.parse::<usize>() {
                Ok(threshold) => {
                    threshold
                }
                Err(_) => {
                    eprintln!("Could not convert {}", threshold);
                    std::process::exit(0);
                }
            }
        }
        Err(e) => match e {
            FlagError::Undefined => panic!("undefined operator..."),
            FlagError::ArgumentError => panic!("argument error..."),
            FlagError::NotFound => panic!("not found flag..."),
            FlagError::ValueTypeError => panic!("value type mismatch..."),
            FlagError::TypeError => panic!("flag type mismatch..."),
        },
    }
}

pub fn get_mappings_file(c: &Context) -> Option<(Option<File>, String)> {
    match c.string_flag("mappings") {
        Ok(path) => {
            let file: Option<File>;

            match Path::new(&path).exists() {
                true => {
                    file = Some(File::open(&path).unwrap());
                }
                false => {
                    file = None;
                }
            }

            Some((file, path))
        }
        Err(e) => match e {
            FlagError::Undefined => panic!("undefined operator..."),
            FlagError::ArgumentError => panic!("argument error..."),
            FlagError::NotFound => {
                None
            },
            FlagError::ValueTypeError => panic!("value type mismatch..."),
            FlagError::TypeError => panic!("flag type mismatch..."),
        },
    }
}