kpw 0.1.0

A password manager
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use std::{
    env,
    error::Error,
    fs::{self, File, OpenOptions},
    path::Path, io::{Write, self, Read},
};

pub struct Config {
    name: String,
    username: String,
    password: String,
}

impl Config {
    pub fn new(mut args: env::Args) -> Result<Config, &'static str> {
        args.next();
        let name = match args.next() {
            Some(arg) => arg,
            None => return Err("Didn't get a name"),
        };
        let username = match args.next() {
            Some(arg) => arg,
            None => return Err("Didn't get a username"),
        };
        let password = match args.next() {
            Some(arg) => arg,
            None => return Err("Didn't get a password"),
        };
        Ok(Config {
            name,
            username,
            password,
        })
    }
}

pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
    println!(
        "Saving {}, {}, {}",
        config.name, config.username, config.password
    );

    let file = get_config_file()?;

    let contents = read(&file);

    save(config, &file);

    Ok(())
}

fn get_config_file() -> io::Result<File> {
    let path = String::from("/Users/jing/Downloads/.kpw/");
    let dir = Path::new(&path);
    let exists = dir.exists();
    if !exists {
        match fs::create_dir(dir) {
            Ok(()) => true,
            Err(e) => panic!("Coludn't create directory: {}", e),
        };
    }
    let path = path + "pass";
    let file = match OpenOptions::new()
        .create(true)
        .read(true)
        .append(true)
        .open(path) {
        Ok(file) => file,
        Err(e) => panic!("Error: {}", e),
    };
    Ok(file)
}

fn save(config: Config, mut file: &File) {
    let contents = read(file);
    let line = (config.name + " " + &config.username + " " + &config.password).to_lowercase();

    for item in contents.lines() {
        println!("item: {}, line: {}", item, line.to_lowercase());
        if line.contains(&item.to_lowercase()) {
            return
        }
    }
    file.write((line + "\n").as_bytes());
}

fn read(mut file: &File) -> String {
    let mut contents = String::from("");
    file.read_to_string(&mut contents);
    contents
}

fn copy_to_clipboard() {}

#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn test_save() {
        let result = get_config_file();
        let file = result.unwrap();
        save(Config {
            name: String::from("dilibili"),
            username: String::from("jing"),
            password: String::from("123456"),
        }, &file);
    }

    #[test]
    fn test_get_config_file() {
        get_config_file();
    }
}