hacker_text/

lib.rs

//! A really dumb library that generates bogus lines of "hacker text".
//!
//! Example:
//! ```
//! use hacker_text::*;
//! 
//! let foo = make_line();
//! // since the thing is randomized, it is impossible to know what foo will be.
//! ```
//!
//! Some generated examples are:
//! 
//! * detonating python
//! * sadly lying to golden trans rights
//! * happily detonating all of gnu
//! * destroying 20 million copies of the game tux kart racing
//! * smoking tomato sauce
//! * happily compiling windows
//!
//! (probably don't use the make_line() function, the adverbs and adjectives are really weird)

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn verb_test() {
        assert!(verb_list().contains(&get_verb()));
    }

    #[test]
    fn noun_test() {
        assert!(noun_list().contains(&get_verb()));
    }
}

fn verb_list() -> Vec<&'static str> {
    vec![
        "launching",
        "exploding",
        "starting",
        "stopping",
        "activating",
        "deactivating",
        "destroying",
        "defenstrating",
        "shooting",
        "compiling",
        "connecting to",
        "leaking",
        "liquefying",
        "revoking",
        "exiting",
        "spoofing",
        "solving",
        "lying to",
        "walking to",
        "decimating",
        "obliterating",
        "crushing",
        "squishing",
        "lightly tapping",
        "performing percussive maintenance on",
        "killing",
        "uninstalling",
        "reinstalling",
        "updating",
        "detonating",
        "spending",
        "smoking",
        "snorting",
        "synchronizing",
        "sacrificing",
        "smelting",
        "attaching",
        "crafting",
        "inflating",
        "rendering",
        "recieving",
    ]
}

/// Gets a verb from the list of verbs used in the `make_line()` functions.
pub fn get_verb() -> &'static str {
    let v = verb_list();
    v[fastrand::usize(..v.len())]
}

fn noun_list() -> Vec<&'static str> {
    vec![
        "nukes",
        "super epic hacking program",
        "https injector", 
        "installer",
        "operating system",
        "linux",
        "all of gnu",
        "explosions",
        "artillery",
        "UFOs",
        "the abyss",
        "anthropologists",
        "castles",
        "obliterators",
        "bloodstained floorboards",
        "700 cans of paint",
        "around 0,000 04 gigatons of steel",
        "france",
        "neovim",
        "vim",
        "emacs",
        "vi",
        "nano",
        "ipod nano",
        "notepad",
        "internet explorer",
        "windows",
        "mac",
        "macOS",
        "apple",
        "garbage",
        "windows phone",
        "microsoft",
        "holyc",
        "c",
        "rust",
        "go",
        "python",
        "c++",
        "html",
        "css",
        "20 million copies of the game tux kart racing",
        "every single integer",
        "hell",
        "3 000 foobucks",
        "somebody's mom's credit card",
        "everything",
        "sensor",
        "noise",
        "flux",
        "phase",
        "widget",
        "protocol",
        "all of the internet",
        "magnet",
        "tomato sauce",
        "spaghetti",
        "boiling water",
        "pot",
        "strainer",
        "meatballs",
        "yummy plate of spaghetti and meatballs",
        "voltage",
        "cocaine",
        "meth",
        "you",
        "log by bolb",
        "trans rights",
        "lgbtq+ rights",
        "myself",
        "ether",
        "electrons",
        "positrons",
        "rocket silo",
    ]
}

/// Gets a noun from the list of nouns used in the `make_line()` functions.
pub fn get_noun() -> &'static str {
    let v = noun_list();
    v[fastrand::usize(..v.len())]
}

fn adjective_list() -> Vec<&'static str> {
    vec![
        "large",
        "red",
        "blue",
        "green",
        "orange",
        "yellow",
        "golden",
        "explosive",
        "small",
        "arrogant",
        "bad",
        "very green",
        "incredibly green",
        "indescribably green",
        "inexplainibly green",
        "supremely green",
        "oxidized",
        "rusted",
    ]
}

/// Gets an adjective from the list of adjectives used in the `make_line()` functions.
pub fn get_adjective() -> &'static str {
    let v = adjective_list();
    v[fastrand::usize(..v.len())]
}

fn adverb_list() -> Vec<&'static str> {
    vec![
        "happily",
        "sadly",
        "awfully",
        "grealty",
        "speedily",
        "explosively",
        "painfully",
        "terribly",
        "hopelessly",
        "hopefully",
        "wearily",
        "achingly",
        "smartly",
        "stupidly",
    ]
}

/// Gets an adverb from the list of adverbs used in the `make_line()` functions.
pub fn get_adverb() -> &'static str {
    let v = adverb_list();
    v[fastrand::usize(..v.len())]
}


/// Returns a `String` with verbs and nouns.
pub fn make_verb_line() -> String {
    format!("{} {}", get_verb(), get_noun())
}

/// Returns a `String` with verbs, nouns, and adjectives.
pub fn make_adjective_line() -> String {
    format!("{} {} {}", get_verb(), get_adjective(), get_noun())
}

/// Returns a `String` with adverbs, verbs, and nouns.
pub fn make_adverb_line() -> String {
    format!("{} {} {}", get_adverb(), get_verb(), get_noun())
}

/// Returns a `String` with adverbs, verbs, nouns, and adjectives.
pub fn make_everything_line() -> String {
    format!("{} {} {} {}", get_adverb(), get_verb(), get_adjective(), get_noun())
}

/// Randomly picks one of the other `make_line` functions and returns a `String` from them.
pub fn make_line() -> String {
    match fastrand::i32(0..3) {
        0 => make_verb_line(),
        1 => make_adjective_line(),
        2 => make_adverb_line(),
        3 => make_line(),
        _ => panic!("somehow got something other then 0, 1, 2 or 3 from randomizing a range of 0..3. this should be impossible!")
    }
}