irevoire/brust - Change 35EVA5MHEJMVJWQUXIJWAX43LJZ7YLE5Y4YN5T2SOSTBTQB6HTTQC

split the commands in multiple files

Created by Thomas Campistron on March 29, 2019

35EVA5MHEJMVJWQUXIJWAX43LJZ7YLE5Y4YN5T2SOSTBTQB6HTTQC

Dependencies

In channels

main

Change contents

File addition: commands (d--x------)
[3.6]

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

[0.11]

use crate::Score;
use std::fmt::Write;
command!(blague(ctx, msg, _args) {
    let mut res = "Blagues :\n".to_string();
    let mut data = ctx.data.lock();
    let scores = data
        .get::<Score>()
        .expect("Expected Score in ShareMap.");
    for (k, v) in scores {
        let _ = write!(res, "- {}: {}\n", k, v);
    }
    if let Err(why) = msg.channel_id.say(&res) {
        println!("Error sending message: {:?}", why);
    }
});
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()),
    };
}
command!(mdr(ctx, msg, args) {
    if args.len() != 1 {
        let _ = msg.reply("Donne moi **un** nom !");
        let _ = msg.react('❎');
        return Ok(());
    }
    let user: String = args.iter().next().unwrap().unwrap();
    let user = match get_user_id(user) {
        Err(e) => {
            let _ = msg.reply(&e);
            let _ = msg.react('❎');
            return Ok(());
        },
        Ok(u) => u,
    };
    let mut data = ctx.data.lock();
    let score = data
        .get_mut::<Score>()
        .expect("Expected Score in ShareMap.");
    let entry = score.entry(user.to_string()).or_insert(0);
    *entry += 1;
    let _ = msg.react('👌');
});
command!(nul(ctx, msg, args) {
    if args.len() != 1 {
        let _ = msg.reply("Donne moi **un** nom !");
        let _ = msg.react('❎');
        return Ok(());
    }
    let user: String = args.iter().next().unwrap().unwrap();
    let user = match get_user_id(user) {
        Err(e) => {
            let _ = msg.reply(&e);
            let _ = msg.react('❎');
            return Ok(());
        },
        Ok(u) => u,
    };
    let mut data = ctx.data.lock();
    let score = data
        .get_mut::<Score>()
        .expect("Expected Score in ShareMap.");
    let entry = score.entry(user.to_string()).or_insert(0);
    *entry -= 1;
    let _ = msg.react('👌');
});

File addition: mod.rs (----------)
[0.11]
```
pub mod blague;
```
Insertion in src/main.rs at line 3 [3.17]
[3.54]
[3.54]
```
mod commands;
```

Replacement in src/main.rs at line 6 [3.17]

B:BD[3.55] → [4.0:88]

use std::{collections::HashMap, fmt::Write, fs::File, io::Read, path::Path, sync::Arc};

[3.55]

[3.116]

use std::{collections::HashMap, fs::File, io::Read, path::Path};

Replacement in src/main.rs at line 9 [3.17]

B:BD[3.159] → [3.159:213]

B:BD[3.213] → [4.89:165]

    client::bridge::gateway::{ShardId, ShardManager},
    framework::standard::{help_commands, DispatchError, StandardFramework},

[3.159]

[2.0]

    framework::standard::{help_commands, StandardFramework},

Deletion in src/main.rs at line 13 [3.17]
B:BD[3.467] → [3.467:498]
```
struct ShardManagerContainer;
```

Deletion in src/main.rs at line 14 [3.17]

B:BD[3.499] → [3.499:689]

B:BD[3.689] → [4.166:169]

impl TypeMapKey for ShardManagerContainer {
    type Value = Arc<Mutex<ShardManager>>;
}
struct CommandCounter;
impl TypeMapKey for CommandCounter {
    type Value = HashMap<String, u64>;
}

Deletion in src/main.rs at line 67 [3.17]
B:BD[3.1066] → [3.1066:1125]
```
        data.insert::<CommandCounter>(HashMap::default());
```
Deletion in src/main.rs at line 68 [3.17]
∅:D[4.1227] → [3.1125:1206]
B:BD[3.1125] → [3.1125:1206]
```
        data.insert::<ShardManagerContainer>(Arc::clone(&client.shard_manager));
```

Replacement in src/main.rs at line 79 [3.17]

B:BD[3.1528] → [3.1528:1575]

            .before(|ctx, msg, command_name| {

[3.1528]

[3.1575]

            .before(|_, msg, command_name| {

Deletion in src/main.rs at line 84 [3.17]

B:BD[3.1723] → [3.1723:2037]


                let mut data = ctx.data.lock();
                let counter = data
                    .get_mut::<CommandCounter>()
                    .expect("Expected CommandCounter in ShareMap.");
                let entry = counter.entry(command_name.to_string()).or_insert(0);
                *entry += 1;

Deletion in src/main.rs at line 89 [3.17]

B:BD[3.2368] → [3.2368:2383]

B:BD[3.2470] → [3.2470:2759]

            })
            .on_dispatch_error(|_ctx, msg, error| {
                if let DispatchError::RateLimited(seconds) = error {
                    let _ = msg
                        .channel_id
                        .say(&format!("Try this again in {} seconds.", seconds));
                }

Replacement in src/main.rs at line 96 [3.17]

B:BD[3.3088] → [3.3088:3142]

B:BD[3.3186] → [3.3186:3238]

B:BD[3.3238] → [4.1262:1401]

            .command("commands", |c| c.cmd(commands))
            .command("latency", |c| c.cmd(latency))
            .command("nul", |c| c.cmd(nul))
            .command("mdr", |c| c.cmd(nul))
            .command("blague", |c| c.cmd(blague)),

[3.3088]

[3.3283]

            .command("nul", |c| c.cmd(commands::blague::nul))
            .command("mdr", |c| c.cmd(commands::blague::mdr))
            .command("blague", |c| c.cmd(commands::blague::blague)),

Deletion in src/main.rs at line 103 [3.17]

B:BD[3.3375] → [3.3375:3383]

B:BD[3.3383] → [4.1402:1403]

B:BD[4.1403] → [2.54:89]

∅:D[2.89] → [4.1437:1482]

B:BD[4.1437] → [4.1437:1482]

∅:D[4.1482] → [3.3383:3384]

B:BD[3.3383] → [3.3383:3384]

B:BD[3.3384] → [4.1483:1696]

∅:D[4.1696] → [3.3454:3455]

B:BD[3.3454] → [3.3454:3455]

B:BD[3.3455] → [4.1697:1810]

∅:D[4.1810] → [3.3605:3606]

B:BD[3.3605] → [3.3605:3606]

B:BD[3.3606] → [4.1811:1900]

B:BD[4.1900] → [2.90:105]

∅:D[2.105] → [4.1923:2039]

B:BD[4.1923] → [4.1923:2039]

    }
}
command!(blague(ctx, msg, _args) {
    let mut res = "Blagues :\n".to_string();
    let mut data = ctx.data.lock();
    let scores = data
        .get::<Score>()
        .expect("Expected Score in ShareMap.");
    for (k, v) in scores {
        let _ = write!(res, "- {}: {}\n", k, v);
    }
    if let Err(why) = msg.channel_id.say(&res) {
        println!("Error sending message: {:?}", why);
    }
});
fn get_user_id(user: String) -> Result<String, String> {
    println!("user: {}", user);
    let start;
    if !user.starts_with("<@") || !user.ends_with(">") {
        return Err("Le nom est mal formé !".to_string());

Deletion in src/main.rs at line 104 [3.17]

B:BD[3.3820] → [4.2040:2122]

∅:D[4.2122] → [3.4033:4039]

B:BD[3.4033] → [3.4033:4039]

B:BD[3.4039] → [4.2123:2476]

    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()),
    };

Deletion in src/main.rs at line 105 [3.17]

B:BD[3.4067] → [3.4067:4068]

B:BD[3.4068] → [4.2477:2508]

∅:D[4.2508] → [3.4099:4124]

B:BD[3.4099] → [3.4099:4124]

B:BD[3.4124] → [4.2509:2596]

∅:D[4.2596] → [3.4169:4259]

B:BD[3.4169] → [3.4169:4259]

B:BD[3.4259] → [4.2597:2731]

∅:D[4.2731] → [3.4530:4568]

B:BD[3.4530] → [3.4530:4568]

B:BD[3.4568] → [4.2732:2752]

∅:D[4.2752] → [3.4588:4595]

B:BD[3.4588] → [3.4588:4595]

B:BD[3.4595] → [4.2753:2998]

∅:D[4.2998] → [3.4595:4596]

B:BD[3.4595] → [3.4595:4596]

B:BD[3.4596] → [4.2999:3366]

∅:D[4.3366] → [3.4779:4844]

B:BD[3.4779] → [3.4779:4844]

B:BD[3.4844] → [4.3367:3608]

∅:D[4.3608] → [3.4976:5367]

B:BD[3.4976] → [3.4976:5367]

B:BD[3.5883] → [3.5883:6624]


command!(mdr(ctx, msg, args) {
    if args.len() != 1 {
        let _ = msg.reply("Donne moi **un** nom !");
        let _ = msg.react('❎');
        return Ok(());
    }
    let user: String = args.iter().next().unwrap().unwrap();
    let user = match get_user_id(user) {
        Err(e) => {
            let _ = msg.reply(&e);
            let _ = msg.react('❎');
            return Ok(());
        },
        Ok(u) => u,
    };
    let mut data = ctx.data.lock();
    let score = data
        .get_mut::<Score>()
        .expect("Expected Score in ShareMap.");
    let entry = score.entry(user.to_string()).or_insert(0);
    *entry += 1;
    let _ = msg.react('👌');
});
command!(nul(ctx, msg, args) {
    if args.len() != 1 {
        let _ = msg.reply("Donne moi **un** nom !");
        let _ = msg.react('❎');
        return Ok(());
    }
    let user: String = args.iter().next().unwrap().unwrap();
    let user = match get_user_id(user) {
        Err(e) => {
            let _ = msg.reply(&e);
            let _ = msg.react('❎');
            return Ok(());
        },
        Ok(u) => u,
    };
    let mut data = ctx.data.lock();
    let score = data
        .get_mut::<Score>()
        .expect("Expected Score in ShareMap.");
    let entry = score.entry(user.to_string()).or_insert(0);
    *entry -= 1;
    let _ = msg.react('👌');
});
command!(commands(ctx, msg, _args) {
    let mut contents = "Commands used:\n".to_string();
    let data = ctx.data.lock();
    let counter = data.get::<CommandCounter>().expect("Expected CommandCounter in ShareMap.");
    for (k, v) in counter {
        let _ = write!(contents, "- {name}: {amount}\n", name=k, amount=v);
    }
    if let Err(why) = msg.channel_id.say(&contents) {
        println!("Error sending message: {:?}", why);
    }
});
command!(latency(ctx, msg, _args) {
    let data = ctx.data.lock();
    let shard_manager = match data.get::<ShardManagerContainer>() {
        Some(v) => v,
        None => {
            let _ = msg.reply("There was a problem getting the shard manager");
            return Ok(());
        },
    };
    let manager = shard_manager.lock();
    let runners = manager.runners.lock();
    let runner = match runners.get(&ShardId(ctx.shard_id)) {
        Some(runner) => runner,
        None => {
            let _ = msg.reply("No shard found");
            return Ok(());
        },
    };
    let _ = msg.reply(&format!("The shard latency is {:?}", runner.latency));
});