irevoire/brust - Change 5YD5TE7BVUUMNIT2WQPFPLZ75Z4GK74B2NPCZO33U2JWCEOSN4HAC

redo the whole bot, remove all the command and create a new tg command

Created by Thomas Campistron on April 11, 2020

5YD5TE7BVUUMNIT2WQPFPLZ75Z4GK74B2NPCZO33U2JWCEOSN4HAC

Dependencies

In channels

main

Change contents

File deletion: .dockerignore
BF:BFD[1.0] → [10.0:15]
BF:BFD[10.15] → [10.16:16]
B:BD[10.16] → [10.17:29]
```
target
.git
```
File deletion: Dockerfile
BF:BFD[1.0] → [11.0:12]
BF:BFD[11.12] → [11.13:13]
∅:D[10.48] → [11.24:25]
B:BD[11.24] → [11.24:25]
∅:D[10.196] → [11.55:56]
B:BD[11.55] → [11.55:56]
B:BD[11.95] → [11.95:118]
B:BD[11.118] → [10.212:224]
B:BD[11.56] → [10.197:211]
B:BD[11.25] → [10.49:196]
B:BD[11.13] → [10.30:48]
```
VOLUME /brust/config
CMD ./brust
WORKDIR brust
RUN git clone https://github.com/irevoire/brust && \
	cd brust && \
	cargo build --release && \
	mv target/release/brust . && \
	rm -rf src target
FROM rust:stretch
```
File deletion: config
BF:BFD[1.0] → [3.27:35]
BF:BFD[3.35] → [3.36:36]
File deletion: score
BF:BFD[3.36] → [3.37:44]
BF:BFD[3.44] → [3.45:45]

Replacement in .env at line 1 [12.7]

B:BD[12.7] → [12.8:42]

B:BD[12.42] → [3.0:26]

DISCORD_TOKEN=put your token here
SCORE_FILE=./config/score

[12.7]

DISCORD_TOKEN=NDY3NjAyMDAwMjA1MzE2MDk4.XnorOQ.KodGaGv3RldOlVGv6lbOmb1sjOI

Deletion in Cargo.toml at line 10 [14.6638]
B:BD[12.57] → [13.0:15]
```
clokwerk = "*"
```
Insertion in Cargo.toml at line 11 [14.6638]
[13.29]
```
rand = "*"
```
File deletion: hook
BF:BFD[14.6] → [13.30:36]
BF:BFD[13.36] → [13.37:37]

File deletion: pun.rs

BF:BFD[13.37] → [13.62:70]

BF:BFD[13.70] → [13.71:71]

B:BD[13.71] → [13.72:294]

B:BD[13.294] → [9.0:65]

∅:D[9.65] → [13.367:411]

B:BD[13.367] → [13.367:411]

B:BD[13.411] → [8.0:488]

∅:D[8.488] → [13.736:737]

B:BD[13.736] → [13.736:737]

B:BD[13.737] → [8.489:540]

∅:D[8.540] → [13.780:908]

B:BD[13.780] → [13.780:908]

use serenity::model::id::ChannelId;
// Scheduler, and trait for .seconds(), .minutes(), etc.
use clokwerk::{Scheduler, TimeUnits};
// Import week days and WeekDay
use std::thread;
use std::time::Duration;
pub fn init() {
    let channel = ChannelId(467653564936749056); // salon du bot
    let mut scheduler = Scheduler::new();
    scheduler
        .every(1.day())
        .at("08:15")
        .and_every(1.day())
        .at("11:50")
        .and_every(1.day())
        .at("17:45")
        .run(move || {
            println!("sending a new pun");
            let mut pun = reqwest::get("http:/pun.irevoire.ovh").unwrap();
            if !pun.status().is_success() {
                println!("server error when getting a new pun");
                return;
            }
            let pun = pun.text().unwrap();
            channel.say(pun).unwrap();
        });
    thread::spawn(move || loop {
        scheduler.run_pending();
        thread::sleep(Duration::from_millis(500));
    });
}

File deletion: mod.rs
BF:BFD[13.37] → [13.38:46]
BF:BFD[13.46] → [13.47:47]
B:BD[13.47] → [13.48:61]
```
pub mod pun;
```

File deletion: blague.rs

BF:BFD[15.11] → [15.12:23]

BF:BFD[15.23] → [15.24:24]

B:BD[15.24] → [16.0:115]

B:BD[16.115] → [17.0:115]

∅:D[18.77] → [19.101:191]

∅:D[17.115] → [19.101:191]

B:BD[19.101] → [19.101:191]

B:BD[19.191] → [17.116:256]

∅:D[18.134] → [19.231:292]

∅:D[17.256] → [19.231:292]

B:BD[19.231] → [19.231:292]

B:BD[19.292] → [17.257:293]

∅:D[17.293] → [19.336:547]

B:BD[19.336] → [19.336:547]

∅:D[19.547] → [15.64:65]

B:BD[15.64] → [15.64:65]

B:BD[15.65] → [19.548:1100]

B:BD[15.145] → [15.145:146]

B:BD[15.474] → [15.474:1112]

B:BD[15.1112] → [16.116:214]

B:BD[16.214] → [7.0:324]

∅:D[7.324] → [15.1441:1479]

B:BD[15.1441] → [15.1441:1479]

B:BD[15.1479] → [7.325:372]

∅:D[7.372] → [16.252:262]

B:BD[16.252] → [16.252:262]

B:BD[16.262] → [7.373:620]

∅:D[7.620] → [20.90:97]

B:BD[20.90] → [20.90:97]

B:BD[20.97] → [7.621:677]

∅:D[7.677] → [16.294:297]

B:BD[15.1785] → [16.294:297]

∅:D[17.773] → [16.297:378]

B:BD[16.297] → [16.297:378]

B:BD[16.378] → [17.774:795]

∅:D[17.795] → [16.378:397]

B:BD[16.378] → [16.378:397]

∅:D[16.397] → [15.1785:1821]

B:BD[15.1785] → [15.1785:1821]

B:BD[15.1821] → [16.398:448]

B:BD[16.448] → [17.796:817]

∅:D[17.817] → [16.448:467]

B:BD[16.448] → [16.448:467]

B:BD[16.467] → [17.818:822]

∅:D[6.399] → [17.822:1208]

B:BD[17.822] → [17.822:1208]

B:BD[17.1208] → [6.400:461]

∅:D[6.461] → [17.1280:1376]

B:BD[17.1280] → [17.1280:1376]

B:BD[17.1376] → [6.462:505]

∅:D[6.505] → [17.1429:1554]

B:BD[17.1429] → [17.1429:1554]

B:BD[17.822] → [6.0:399]

∅:D[16.467] → [15.2463:2467]

∅:D[17.1554] → [15.2463:2467]

B:BD[15.2463] → [15.2463:2467]

B:BD[16.297] → [17.294:329]

B:BD[17.329] → [2.0:32]

∅:D[2.32] → [17.365:627]

B:BD[17.365] → [17.365:627]

B:BD[17.627] → [2.33:109]

∅:D[2.109] → [17.701:773]

B:BD[17.701] → [17.701:773]

use serenity::{
    framework::standard::Args,
    model::channel::Message,
    prelude::{Context, TypeMapKey},
};
use std::{
    collections::HashMap,
    fmt::Write,
    fs::File,
    io::{Read, Write as wr},
    path::Path,
};
pub struct Score;
impl TypeMapKey for Score {
    type Value = HashMap<String, i64>;
}
pub struct FileScore;
impl TypeMapKey for FileScore {
    type Value = String;
}
pub fn init(filename: &String) -> HashMap<String, i64> {
    let mut hash: HashMap<String, i64> = HashMap::default();
    let path = Path::new(filename);
    let mut file = match File::open(&path) {
        Err(why) => panic!("couldn't open file {}", why),
        Ok(file) => file,
    };
    let mut s = String::new();
    file.read_to_string(&mut s).unwrap();
    for line in s.split("\n") {
        if line == "" {
            break;
        }
        let mut split = line.split(" ");
        let name = split
            .next()
            .unwrap_or_else(|| panic!(format!("can't parse this line: {}", line)));
        let nb: i64 = split
            .next()
            .unwrap_or_else(|| panic!(format!("need a score: {}", line)))
            .parse()
            .unwrap_or_else(|_| panic!(format!("can't parse this score: {}", line)));
        hash.insert(name.to_string(), nb);
    }
    return hash;
}
fn get_user_id(user: String) -> Result<String, String> {
    let start;
    if !user.starts_with("<@") || !user.ends_with(">") {
        return Err("Le nom est mal formé !".to_string());
    }
    if user.starts_with("<@!") {
        start = 3
    } else {
        start = 2
    }
    let user_id: u64 = match user[start..user.len() - 1].parse() {
        Err(_) => return Err("Le nom est mal formé !".to_string()),
        Ok(n) => n,
    };
    let user = serenity::model::id::UserId(user_id);
    return match user.to_user() {
        Err(_) => Err("Utilisateur inconnu".to_string()),
        Ok(u) => Ok(u.to_string()),
    };
}
fn update_score(ctx: &mut Context, msg: &Message, args: &mut Args, update: impl Fn(i64) -> i64) {
    let mut fail = false;
    for name in args.iter() {
        let name = match get_user_id(name.unwrap()) {
            Err(_) => {
                let _ = msg.react('❎');
                fail = true;
                continue;
            }
            Ok(u) => u,
        };
        if msg.author.to_string() == name {
            let _ = msg.react('❎');
            fail = true;
            continue;
        }
        let mut data = ctx.data.lock();
        let score = data
            .get_mut::<Score>()
            .expect("Expected Score in ShareMap.");
        let entry = score.entry(name.to_string()).or_insert(0);
        *entry = update(*entry);
    }
    if !fail {
        let _ = msg.react('👌');
    }
}
command!(mdr(ctx, msg, args) {
    update_score(ctx, msg, &mut args, |n| n + 1);
    save_score(ctx);
    return Ok(());
});
command!(nul(ctx, msg, args) {
    update_score(ctx, msg, &mut args, |n| n - 1);
    save_score(ctx);
    return Ok(());
});
command!(blague(ctx, msg, args) {
    let mut data = ctx.data.lock();
    let scores = data
        .get::<Score>()
        .expect("Expected Score in ShareMap.");
    let mut res = "Blagues :\n".to_string();
    if args.len() >= 1 {
        for name in args.iter() {
            let name = get_user_id(name.unwrap()).unwrap_or("".to_string());
            match scores.get(&name) {
                Some(v) => write_score(&mut res, &name, *v),
                None => (),
            }
        }
    } else {
        for (k, v) in scores {
            write_score(&mut res, &k, *v);
        }
    }
    if let Err(why) = msg.channel_id.say(&res) {
        println!("Error sending message: {:?}", why);
    }
fn write_score(base: &mut String, name: &String, value: i64) {
    let _ = write!(base, "- {}: {} ", name, value);
    let sym = match value {
        _ if value > 0 => "🔆",
        _ if value < 0 => "❌",
        _ => "",
    };
    let react: String = std::iter::repeat(sym)
        .take(value.abs() as usize)
        .take(10)
        .collect();
    let _ = write!(base, "{}\n", react);
}
});
fn save_score(ctx: &mut Context) {
    let data = ctx.data.lock();
    let scores = data.get::<Score>().expect("Expected Score in ShareMap.");
    let filename = data
        .get::<FileScore>()
        .expect("Expected FileScore in ShareMap.");
    let mut buffer = File::create(filename).unwrap();
    for (k, v) in scores {
        if let Err(e) = buffer.write(format!("{} {}\n", k, v).as_bytes()) {
            println!("Can't save the score: {}", e);
        }
    }
}

Replacement in src/commands/mod.rs at line 1 [15.2477]
B:BD[15.2477] → [15.2478:2494]
```
pub mod blague;
```
[15.2477]
```
pub mod tg;
```

File addition: tg.rs (----------)

[15.11]

use rand::seq::SliceRandom;
use rand::thread_rng;
use serenity::framework::standard::{macros::command, Args, CommandResult};
use serenity::{
    model::channel::Message,
    prelude::{Context, TypeMapKey},
};
pub struct Tg;
// we are going to store the insults in the first vector and random index in the second
impl TypeMapKey for Tg {
    type Value = (Vec<&'static str>, Vec<usize>);
}
#[command]
pub fn tg(ctx: &mut Context, msg: &Message, _args: Args) -> CommandResult {
    let mut data = ctx.data.write();
    let insults = data.get_mut::<Tg>();
    if insults.is_none() {
        let _ = msg.reply(&ctx, "Jesus is dead");
        return Ok(());
    }
    let insults = insults.unwrap();
    let mut index = insults.1.pop();
    // generate a new list of indexes
    if index.is_none() {
        let mut rng = thread_rng();
        insults.1 = (0..insults.0.len()).collect::<Vec<usize>>();
        insults.1.shuffle(&mut rng);
        index = insults.1.pop();
    }
    let index = index.expect("The insults vector look empty?");
    let _ = msg.channel_id.say(&ctx, insults.0[index]);
    Ok(())
}
pub fn init() -> (Vec<&'static str>, Vec<usize>) {
    let insults = vec![
        "Va marcher sur des Légos",
        "Gredin",
        "Tête de tétard",
        "Sac à puces",
        "Espèce d'épinard",
        "Patate",
        "Banane",
        "Capitaine de bateau-lavoir",
        "Cornichon",
        "Paltoquet",
        "Philistin",
        "Terrine",
        "Foutriquet",
        "Scélérat",
        "Mauviette",
        "Malotru",
        "Goujat",
        "Vil faquin",
        "Maraud",
        "Crétin des Alpes",
        "Parisien",
        "Pute",
        "Grosse pute",
        "Petite pute",
        "Trou duc",
        "Syndicaliste",
        "Gilet jaune",
        "Macroniste",
        "Fécalomes",
        "Raclure de bidet",
        "Balai à chiotte",
        "Fils de yack",
        "Filloniste",
        "Lepéniste",
        "Mélenchoniste",
        "Sarkozyste",
        "Capitaliste",
        "Homéopathe",
        "Antivax",
        "Moule à gaufre",
        "Escogriffe",
        "Andouille",
        "Tocard",
        "Bouffon",
        "Zigoto",
        "Saltimbanque",
        "Termaji",
        "Branquignole",
        "Enclume",
        "Va te faire cuire le cul",
        "Takezen",
        "Pimfle",
        "Caillou",
        "Goulamas",
        "Gougnafier",
        "Pouffre",
        "Poulpe",
        "Figure de pain sucé",
        "Figure d'angoisse",
        "Front d'endive",
        "Tronc de figuier",
        "Guit",
        "Féministe",
        "Sac à pus",
        "Blaireau",
        "Bordel à Cul",
        "Boudin",
        "Bouffon",
        "Bougre d’âne",
        "Bougre d’imbécile",
        "Bougre de congre",
        "Bougre de conne",
        "Boule de pus",
        "Boursemolle",
        "Branleur",
        "Branlotin",
        "Branque",
        "Branquignole",
        "Brêle",
        "Cagole",
        "Carburateur à Beaujolais",
        "Chiure de pigeon",
        "Clampin",
        "Cloaque",
        "Clodo",
        "Cornegidouille",
        "Couille de tétard",
        "Couille molle",
        "Crétin des îles",
        "Crétin goîtreux",
        "Cul de babouin",
        "Enculeur de mouches",
        "Erreur de la nature",
        "Fils de cheminot",
        "Fils de syndicaliste",
        "Face de cul",
        "Face de pet",
        "Face de rat",
        "Fiente",
        "Fiote",
        "Flaque de pus",
        "Fonctionnaire",
        "Four à merde",
        "Furoncle",
        "Garage à bite",
        "Glandus",
        "Gourdasse",
        "Gourgandine",
        "Grand cornichon",
        "Gras du bide",
        "Grognasse",
        "Gros caca poilu",
        "Grosse truie violette",
        "Gueule de fion",
        "Lèche-cul",
        "Manche à couille",
        "Mange merde",
        "Margoulin",
        "Merdaillon",
        "Merde molle",
        "Moudlabite",
        "Peau de bite",
        "Pecore",
        "Pignouf",
        "Pimbêche",
        "Pisse-vinaigre",
        "Pompe à merde",
        "Pouffe",
        "Pouffiasse",
        "Pute au rabais",
        "Pute borgne",
        "Ramassis de chiure de moineau",
        "Sac à Vin",
        "Sac à Foutre",
        "Vieux",
        "Sauvage",
        "Serpillière à foutre",
        "Tas de saindoux",
        "Thon",
        "Tire couilles",
        "Tête d’ampoule",
        "Tête de bite",
        "Tête de chibre",
        "Tête de con",
        "Tête de noeud",
        "Tête à claques",
        "Vioque",
        "Wisigoth",
        "T’es con comme du plastique",
        "T’es comme une pizza, sauf qu’elle on peut l’avoir sans champignons",
        "Ton père le chauve",
        "Ta mère elle boit l’eau des pâtes",
        "Va pisser sur un fil électrique",
        "Va jouer sur l’autoroute",
        "Va jouer sur la voie ferrée",
        "Beurre doux",
        "Rentre dans ton pays",
        "Avortement raté",
        "Va jouer dans le mixer",
        "Tes parents ils ont jeté le bébé et élevé le placenta",
        "Ta mère en sarouel",
        "T’es moche même de dos",
        "Puterelle",
    ];
    let mut rng = thread_rng();
    let mut indexes = (0..insults.len()).collect::<Vec<usize>>();
    indexes.shuffle(&mut rng);
    (insults, indexes)
}

Deletion in src/main.rs at line 1 [14.17]
B:BD[14.17] → [14.18:54]
B:BD[14.54] → [15.2495:2496]
```
#[macro_use]
extern crate serenity;
```
Deletion in src/main.rs at line 2 [14.17]
B:BD[15.2510] → [13.909:919]
```
mod hook;
```
Insertion in src/main.rs at line 3 [14.17]
[14.117]
[14.143]
```
use commands::tg::*;
```

Replacement in src/main.rs at line 5 [14.17]

B:BD[14.159] → [15.2577:2638]

∅:D[15.2638] → [21.0:27]

B:BD[22.165] → [21.0:27]

    framework::standard::{help_commands, StandardFramework},
    model::gateway::Ready,

[14.159]

[14.401]

    framework::{standard::macros::group, StandardFramework},
    model::{gateway::Ready},

Deletion in src/main.rs at line 9 [14.17]
B:BD[14.467] → [18.135:136]
Insertion in src/main.rs at line 11 [14.17]
[14.692]
[14.692]
Deletion in src/main.rs at line 17 [14.17]
B:BD[14.844] → [13.920:947]
```
        hook::pun::init();
```
Insertion in src/main.rs at line 19 [14.17]
[14.852]
[22.1158]
```
#[group]
#[commands(tg)]
struct General;
```

Replacement in src/main.rs at line 25 [14.17]

B:BD[14.904] → [12.58:113]

    kankyo::load().expect("Failed to load .env file");

[14.904]

[12.113]

    kankyo::load(false).expect("Failed to load .env file");

Deletion in src/main.rs at line 29 [14.17]
B:BD[14.1016] → [3.47:134]
∅:D[3.134] → [14.1016:1017]
∅:D[18.207] → [14.1016:1017]
B:BD[14.1016] → [14.1016:1017]
```
    let filename = env::var("SCORE_FILE").expect("Expected a file to save the score");
```

Replacement in src/main.rs at line 30 [14.17]

B:BD[14.1023] → [14.1023:1066]

B:BD[14.1066] → [17.1555:1700]

        let mut data = client.data.lock();
        data.insert::<commands::blague::Score>(commands::blague::init(&filename));
        data.insert::<commands::blague::FileScore>(filename);

[14.1023]

[14.1206]

        let mut data = client.data.write();
        data.insert::<commands::tg::Tg>(commands::tg::init());

Replacement in src/main.rs at line 36 [14.17]

B:BD[14.1273] → [14.1273:1381]

B:BD[14.1381] → [22.1228:1261]

B:BD[14.1459] → [14.1459:1528]

B:BD[14.2774] → [14.2774:2948]

B:BD[14.3004] → [14.3004:3073]

B:BD[14.3073] → [4.0:48]

∅:D[4.48] → [14.3073:3088]

B:BD[14.3073] → [14.3073:3088]

B:BD[14.3088] → [5.0:484]

            .configure(|c| {
                c.allow_whitespace(true)
                    .on_mention(true)
                    .prefix("!")
                    .delimiters(vec![", ", ",", " "])
            })
            .customised_help(help_commands::with_embeds, |c| {
                c.individual_command_tip("🦀 Bonjour 🦀")
                    .max_levenshtein_distance(5)
                    .command_not_found_text("Could not find: `{}`.")
                    .striked_commands_tip(None)
            })
            .group("Tribunal", |g| {
                g.desc("Commande du tribunal des blagues")
                    .command("nul", |c| c.cmd(commands::blague::nul).desc("Blague nulle"))
                    .command("mdr", |c| c.cmd(commands::blague::mdr).desc("Bonne blague"))
                    .command("blague", |c| {
                        c.cmd(commands::blague::blague)
                            .desc("Affiche le score des blagues")
                    })
            }),

[14.1273]

[14.3283]

            .configure(|c| c.prefix("!").delimiters(vec![", ", ",", " "]))
            .group(&GENERAL_GROUP),

redo the whole bot, remove all the command and create a new tg command

Dependencies

In channels

Change contents

File deletion: .dockerignore

File deletion: Dockerfile

File deletion: config

File deletion: score

Replacement in .env at line 1 [12.7]

Deletion in Cargo.toml at line 10 [14.6638]

Insertion in Cargo.toml at line 11 [14.6638]

File deletion: hook

File deletion: pun.rs

File deletion: mod.rs

File deletion: blague.rs

Replacement in src/commands/mod.rs at line 1 [15.2477]

File addition: tg.rs (----------)

Deletion in src/main.rs at line 1 [14.17]

Deletion in src/main.rs at line 2 [14.17]

Insertion in src/main.rs at line 3 [14.17]

Replacement in src/main.rs at line 5 [14.17]

Deletion in src/main.rs at line 9 [14.17]

Insertion in src/main.rs at line 11 [14.17]

Deletion in src/main.rs at line 17 [14.17]

Insertion in src/main.rs at line 19 [14.17]

Replacement in src/main.rs at line 25 [14.17]

Deletion in src/main.rs at line 29 [14.17]

Replacement in src/main.rs at line 30 [14.17]

Replacement in src/main.rs at line 36 [14.17]