fakeit 1.3.0

Fake data generator library with 130+ functions
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
117
118
119
120
121
122
123
124
125
126

use crate::data::lorem;
use crate::hipster;
use crate::misc;
use crate::name;

pub struct ParagraphOpts {
    count: i64,
    sentence_count: i64,
    word_count: i64,
    separator: String,
}

pub fn word() -> String {
    misc::random_data(lorem::WORD).to_string()
}

pub fn sentence(word_count: i64) -> String {
    if word_count <= 0 {
        return "".to_string();
    }

    let mut sentence_vec = Vec::<String>::new();
    for i in 0..word_count {
        if i == 0 {
            sentence_vec.push(title(word()))
        } else if i == word_count - 1 {
            let word_with_dot = format!("{}.", word());
            sentence_vec.push(word_with_dot)
        } else {
            sentence_vec.push(word())
        }
    }

    sentence_vec.join(" ")
}

pub fn paragraph(count: i64, sentence_count: i64, word_count: i64, separator: String) -> String {
    let opts = ParagraphOpts {
        count: count,
        sentence_count: sentence_count,
        word_count: word_count,
        separator: separator,
    };

    paragraph_generator(opts, &sentence)
}

pub fn paragraph_generator(
    opts: ParagraphOpts,
    sentence_generator: &dyn Fn(i64) -> String,
) -> String {
    let mut paragraph_vec = Vec::<String>::new();
    for _i in 0..opts.count {
        let mut sentence_vec = Vec::<String>::new();
        for _i in 0..opts.sentence_count {
            sentence_vec.push(sentence_generator(opts.word_count));
        }
        paragraph_vec.push(sentence_vec.join(" "))
    }
    paragraph_vec.join(&opts.separator[..])
}

pub fn question() -> String {
    hipster::sentence(misc::random(3, 10)).replace(".", "?")
}

pub fn quote() -> String {
    format!(
        "\"{}\" - {} {}",
        hipster::sentence(misc::random(3, 10)),
        name::first(),
        name::last()
    )
}

fn title(s: String) -> String {
    let mut v: Vec<char> = s.chars().collect();
    v[0] = v[0].to_uppercase().nth(0).unwrap();
    v.into_iter().collect()
}

#[cfg(test)]
mod tests {
    use crate::testify::exec_mes;
    use crate::words;

    #[test]
    fn word() {
        exec_mes("words::word", || words::word());
    }

    #[test]
    fn sentence() {
        exec_mes("words::sentence", || words::sentence(10));
    }

    #[test]
    fn paragraph() {
        exec_mes("words::paragraph", || {
            words::paragraph(5, 4, 11, "\n".to_string())
        });
    }

    #[test]
    fn question() {
        exec_mes("words::question", || words::question());
    }

    #[test]
    fn quote() {
        exec_mes("words::quote", || words::quote());
    }

    #[test]
    fn paragraph_generator() {
        exec_mes("words::paragraph_generator", || {
            let opts = words::ParagraphOpts {
                count: 5,
                sentence_count: 4,
                word_count: 11,
                separator: "\n".to_string(),
            };
            words::paragraph_generator(opts, &words::sentence)
        });
    }
}