diceware 0.3.3

A command line diceware, sans dice.
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
116

use std::env;
use std::fs::File;
use std::io::Read;
use std::io::Write;
use std::path::Path;
use std::string::String;

fn make_wordlist(contents: &str) -> Vec<&str> {
    contents
        .split('\n')
        .skip(2)
        .take(7776)
        .map(|s| s.split_once('\t').unwrap().1)
        .collect()
}

fn make_minilock_wordlist(contents: &str) -> Vec<&str> {
    (&contents[1023..543718]).split(',').collect()
}

fn make_beale_struct(wordlist: Vec<&str>) -> std::string::String {
    let mut output = std::string::String::new();

    // 7776 words = 6*6*6*6*6; five 6 faced dice throws.
    output.push_str("static BEALE_WORDLIST: [BealeWord; 7776] = [\n");
    for word in wordlist {
        output.push_str("    BealeWord(\"");
        for c in word.chars() {
            if c == '"' {
                output.push_str("\\\"");
            } else {
                output.push(c);
            }
        }
        output.push_str("\"),\n");
    }
    output.push_str("];\n");
    output
}

fn make_reinhold_struct(wordlist: Vec<&str>) -> std::string::String {
    let mut output = std::string::String::new();

    // 7776 words = 6*6*6*6*6; five 6 faced dice throws.
    output.push_str("static REINHOLD_WORDLIST: [ReinholdWord; 7776] = [\n");
    for word in wordlist {
        output.push_str("    ReinholdWord(\"");
        for c in word.chars() {
            if c == '"' {
                output.push_str("\\\"");
            } else {
                output.push(c);
            }
        }
        output.push_str("\"),\n");
    }
    output.push_str("];\n");
    output
}

fn make_minilock_struct(wordlist: Vec<&str>) -> std::string::String {
    let mut output = std::string::String::new();

    // 58110 words in the MiniLock wordlist.
    output.push_str("static MINILOCK_WORDLIST: [MiniLockWord; 58110] = [\n");
    for word in wordlist {
        output.push_str("    MiniLockWord(\"");
        for c in word.chars() {
            if c == '"' {
                panic!("Not supposed to have any double quotes.");
            } else {
                output.push(c);
            }
        }
        output.push_str("\"),\n");
    }
    output.push_str("];\n");
    output
}

fn main() {
    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
    println!("{}", manifest_dir);
    let wordlists_dir = Path::new(&manifest_dir).join("bin").join("wordlists");
    let mut beale_wordlist_file = File::open(&wordlists_dir.join("beale.wordlist.asc")).unwrap();
    let mut reinhold_wordlist_file =
        File::open(&wordlists_dir.join("diceware.wordlist.asc")).unwrap();
    let mut minilock_wordlist_file = File::open(&wordlists_dir.join("phrase.js")).unwrap();

    let mut beale_wordlist_string = String::new();
    let mut reinhold_wordlist_string = String::new();
    let mut minilock_wordlist_string = String::new();

    beale_wordlist_file
        .read_to_string(&mut beale_wordlist_string)
        .unwrap();
    reinhold_wordlist_file
        .read_to_string(&mut reinhold_wordlist_string)
        .unwrap();
    minilock_wordlist_file
        .read_to_string(&mut minilock_wordlist_string)
        .unwrap();

    let out_dir = env::var("OUT_DIR").unwrap();
    let dest_path = Path::new(&out_dir).join("diceware.rs");
    let mut f = File::create(&dest_path).unwrap();

    f.write_all(make_beale_struct(make_wordlist(&beale_wordlist_string)).as_bytes())
        .unwrap();

    f.write_all(make_reinhold_struct(make_wordlist(&reinhold_wordlist_string)).as_bytes())
        .unwrap();

    f.write_all(make_minilock_struct(make_minilock_wordlist(&minilock_wordlist_string)).as_bytes())
        .unwrap();
}