pvcrypt 1.0.0

System level data encryption using aes_gcm
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

use clap::{Arg, Command};
use std::env;

pub struct Args {
    pub infile: String,
    pub outfile: String,
    pub silent: bool,
    pub decrypt: String,
}

impl Args {
    pub fn parse() -> Self {
        let matches = Command::new(" filencryp")
            .arg(Arg::new("infile").help("Read from a file instead of stdin"))
            .arg(
                Arg::new("outfile")
                    .short('o')
                    .long("outfile")
                    // .takes_value(true)
                    .help("Write output to file instead of stdout"),
            )
            .arg(
                Arg::new("silent")
                    .short('s')
                    .long("silent")
                    .help("Silence the output"),
            )
            .arg(
                Arg::new("decrypt")
                    .short('d')
                    .long("decrypt")
                    .help("Indicate Decryption, and provide key file"),
            )
            .get_matches(); // Get the matches from the command line

        let infile = matches
            .get_many::<String>("infile")
            .unwrap_or_default()
            .map(|s| s.to_string())
            .collect(); //? Make it a String instead of Option<ValuesFer<'_, String>>
        let outfile = matches
            .get_many::<String>("outfile")
            .unwrap_or_default()
            .map(|s| s.to_string())
            .collect();

        let silent = if matches.contains_id("silent") {
            true
        } else {
            !env::var("PV_SILENT").unwrap_or_default().is_empty()
        }; // Get the silent value from the matches
           // dbg!(infile, outfile, silent);
        let decrypt= matches
            .get_many::<String>("decrypt")
            .unwrap_or_default()
            .map(|s| s.to_string())
            .collect();
        Self {
            infile,
            outfile,
            silent,
            decrypt,
        }
    }
}