irevoire/brust - Change YREDNL3G26AXAUNMTGBRZUMJM3MBZ2TGGJJ5JLIRWBSOTPSEWFHQC

update everything and move to async rust

Created by irevoire on December 28, 2020

YREDNL3G26AXAUNMTGBRZUMJM3MBZ2TGGJJ5JLIRWBSOTPSEWFHQC

Dependencies

In channels

main

Change contents

Insertion in Cargo.toml at line 8 [8.6638]
[8.6769]
[8.6769]
```
tokio = { version = "*", features = ["full"] }
```
Replacement in Cargo.toml at line 12 [8.6638]
B:BD[9.29] → [10.75:86]
```
rand = "*"
```
[11.57]
[2.0]
```
rand = { version = "*", features = ["small_rng"] }
```
Insertion in Cargo.toml at line 15 [8.6638]
[12.160]
```
anyhow = "*"
```

Replacement in src/commands/big.rs at line 7 [13.9]

∅:D[3.56] → [13.156:304]

B:BD[13.156] → [13.156:304]

pub fn big(ctx: &mut Context, msg: &Message, args: Args) -> CommandResult {
    let message = crate::utils::find_relative_content(ctx, msg, args)?;

[3.56]

[13.304]

pub async fn big(ctx: &Context, msg: &Message, args: Args) -> CommandResult {
    let message = crate::utils::find_relative_content(ctx, msg, args).await?;

Replacement in src/commands/big.rs at line 15 [13.9]
B:BD[13.423] → [13.423:459]
```
    msg.channel_id.say(&ctx, new)?;
```
[13.423]
[13.459]
```
    msg.channel_id.say(&ctx, new).await?;
```

Replacement in src/commands/choose.rs at line 7 [14.12]

B:BD[14.246] → [14.246:329]

B:BD[14.329] → [5.0:32]

pub fn choose(ctx: &mut Context, msg: &Message, mut args: Args) -> CommandResult {
    let data = ctx.data.read();

[14.246]

[5.32]

pub async fn choose(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
    let data = ctx.data.read().await;

Replacement in src/commands/choose.rs at line 12 [14.12]

B:BD[14.401] → [14.401:455]

        let _ = msg.reply(&ctx, "Give me arguments");

[14.401]

[14.455]

        let _ = msg.reply(&ctx, "Give me arguments").await?;

Replacement in src/commands/choose.rs at line 15 [14.12]

B:BD[14.484] → [5.72:144]

∅:D[5.144] → [14.516:562]

B:BD[14.516] → [14.516:562]

    let mut rng = data.get::<crate::Random>().unwrap().lock().unwrap();
    let choice = rng.gen_range(0, nb_choice);

[14.484]

[14.562]

    let mut rng = data.get::<crate::Random>().unwrap().lock().await;
    let choice = rng.gen_range(0..nb_choice);

Replacement in src/commands/choose.rs at line 18 [14.12]

B:BD[14.563] → [14.563:645]

    let _ = msg.reply(&ctx, args.iter::<String>().nth(choice).unwrap().unwrap());

[14.563]

[14.645]

    let _ = msg
        .reply(&ctx, args.iter::<String>().nth(choice).unwrap().unwrap())
        .await?;

Insertion in src/commands/cute/cat.rs at line 1 [15.31]
[15.31]
[15.32]
```
use anyhow::Result;
```
Deletion in src/commands/cute/cat.rs at line 3 [15.31]
B:BD[15.47] → [15.47:78]
```
use reqwest::blocking::Client;
```

Replacement in src/commands/cute/cat.rs at line 10 [15.31]

∅:D[16.71] → [15.357:434]

B:BD[15.357] → [15.357:434]

B:BD[15.434] → [5.145:249]

pub fn cat(ctx: &mut Context, msg: &Message, _args: Args) -> CommandResult {
    let data = ctx.data.read();
    let mut rng = data.get::<crate::Random>().unwrap().lock().unwrap();

[16.71]

[5.249]

pub async fn cat(ctx: &Context, msg: &Message, _args: Args) -> CommandResult {
    let data = ctx.data.read().await;
    let mut rng = data.get::<crate::Random>().unwrap().lock().await;

Replacement in src/commands/cute/cat.rs at line 14 [15.31]
B:BD[5.250] → [5.250:292]
```
    let page = fetch_cat_page(&mut *rng);
```
[5.250]
[17.33]
```
    let page = fetch_cat_page(&mut *rng).await;
```

Replacement in src/commands/cute/cat.rs at line 16 [15.31]

B:BD[17.60] → [17.60:315]

        let _ = msg.reply(
            &ctx,
            format!(
                "Catto express: was not able to deliver you cat: {}\n{}",
                e,
                "https://i.redd.it/4q32jedhkgi31.jpg" // crying catto
            ),
        );

[17.60]

[17.315]

        let _ = msg
            .reply(
                &ctx,
                format!(
                    "Catto express: was not able to deliver you cat: {}\n{}",
                    e,
                    "https://i.redd.it/4q32jedhkgi31.jpg" // crying catto
                ),
            )
            .await?;

Replacement in src/commands/cute/cat.rs at line 31 [15.31]

B:BD[17.412] → [17.412:549]

        let _ = msg.reply(
            &ctx,
            format!("Catto express: your catto got lost in the page :pensive:"),
        );

[17.412]

[17.549]

        let _ = msg
            .reply(
                &ctx,
                format!("Catto express: your catto got lost in the page :pensive:"),
            )
            .await?;

Replacement in src/commands/cute/cat.rs at line 47 [15.31]

B:BD[17.732] → [5.293:379]

∅:D[5.379] → [15.472:513]

B:BD[15.472] → [15.472:513]

B:BD[15.513] → [17.801:822]

∅:D[17.822] → [15.550:627]

B:BD[15.550] → [15.550:627]

B:BD[15.627] → [17.823:841]

fn fetch_cat_page(rng: &mut impl Rng) -> Result<String, Box<dyn std::error::Error>> {
    let cat_id = rng.gen_range(0, 1677);
    Ok(Client::new()
        .get(&format!("http://random.cat/view/{}", cat_id))
        .send()?
        .text()?)

[17.732]

[17.841]

async fn fetch_cat_page(rng: &mut impl Rng) -> Result<String> {
    let cat_id: usize = rng.gen_range(0..1677);
    Ok(reqwest::get(&format!("http://random.cat/view/{}", cat_id))
        .await?
        .text()
        .await?)

Replacement in src/commands/cute/dog.rs at line 1 [16.81]
B:BD[16.81] → [16.82:113]
```
use reqwest::blocking::Client;
```
[16.81]
[16.113]
```
use anyhow::{anyhow, bail, Result};
```

Replacement in src/commands/cute/dog.rs at line 10 [16.81]

B:BD[16.392] → [18.0:76]

pub fn dog(ctx: &mut Context, msg: &Message, args: Args) -> CommandResult {

[16.392]

[18.76]

pub async fn dog(ctx: &Context, msg: &Message, args: Args) -> CommandResult {

Replacement in src/commands/cute/dog.rs at line 12 [16.81]

B:BD[18.111] → [18.111:174]

        fetch_dog_breed_url(args.raw().collect::<Vec<&str>>())

[18.111]

[18.174]

        fetch_dog_breed_url(args.raw().collect::<Vec<&str>>()).await

Replacement in src/commands/cute/dog.rs at line 14 [16.81]
B:BD[18.187] → [18.187:218]
```
        fetch_random_dog_url()
```
[18.187]
[18.218]
```
        fetch_random_dog_url().await
```

Replacement in src/commands/cute/dog.rs at line 17 [16.81]

∅:D[7.24] → [18.241:455]

B:BD[18.241] → [18.241:455]

        Ok(url) => msg
            .channel_id
            .send_files(&ctx, vec![url.as_str()], |m| m.content(&msg.author)),
        Err(annoncement) => msg.reply(&ctx, format!("Doggo express: {}", annoncement)),

[7.24]

[18.455]

        Ok(url) => {
            msg.channel_id
                .send_files(&ctx, vec![url.as_str()], |m| m.content(&msg.author))
                .await?
        }
        Err(annoncement) => {
            msg.reply(&ctx, format!("Doggo express: {}", annoncement))
                .await?
        }

Replacement in src/commands/cute/dog.rs at line 31 [16.81]

B:BD[18.513] → [18.513:606]

fn fetch_dog_breed_url(mut breed: Vec<&str>) -> Result<String, Box<dyn std::error::Error>> {

[18.513]

[18.606]

async fn fetch_dog_breed_url(mut breed: Vec<&str>) -> Result<String> {

Replacement in src/commands/cute/dog.rs at line 34 [16.81]

B:BD[18.660] → [18.660:853]

    let resp: serde_json::Value = Client::new()
        .get(&format!(
            "https://dog.ceo/api/breed/{}/images/random",
            breed
        ))
        .send()?
        .json()?;

[18.660]

[18.853]

    let resp: serde_json::Value = reqwest::get(&format!(
        "https://dog.ceo/api/breed/{}/images/random",
        breed
    ))
    .await?
    .json()
    .await?;

Replacement in src/commands/cute/dog.rs at line 43 [16.81]

B:BD[18.899] → [18.899:965]

        "error" => Err(resp["message"].as_str().unwrap().into()),

[18.899]

[18.965]

        "error" => bail!("{}", resp["message"]),

Replacement in src/commands/cute/dog.rs at line 45 [16.81]

B:BD[18.1037] → [18.1037:1095]

        _ => Err("The doggo center looks closed".into()),

[18.1037]

[18.1095]

        _ => bail!("The doggo center looks closed"),

Replacement in src/commands/cute/dog.rs at line 50 [16.81]

B:BD[18.1145] → [18.1145:1336]

fn fetch_random_dog_url() -> Result<String, Box<dyn std::error::Error>> {
    let page = fetch_dog_page()?;
    let url = fetch_url_in_dog_page(page).ok_or("your doggo got lost :pensive:")?;

[18.1145]

[18.1336]

async fn fetch_random_dog_url() -> Result<String> {
    let page = fetch_dog_page().await?;
    let url = fetch_url_in_dog_page(page).ok_or(anyhow!("your doggo got lost :pensive:"))?;

Replacement in src/commands/cute/dog.rs at line 56 [16.81]

∅:D[18.1351] → [16.1120:1252]

B:BD[16.1120] → [16.1120:1252]

fn fetch_dog_page() -> Result<String, Box<dyn std::error::Error>> {
    Ok(Client::new().get("https://random.dog").send()?.text()?)

[18.1351]

[16.1252]

async fn fetch_dog_page() -> Result<String> {
    Ok(reqwest::get("https://random.dog").await?.text().await?)

Replacement in src/commands/mock.rs at line 10 [20.10]

∅:D[3.254] → [19.0:149]

B:BD[20.173] → [19.0:149]

pub fn mock(ctx: &mut Context, msg: &Message, args: Args) -> CommandResult {
    let message = crate::utils::find_relative_content(ctx, msg, args)?;

[3.254]

[20.251]

pub async fn mock(ctx: &Context, msg: &Message, args: Args) -> CommandResult {
    let message = crate::utils::find_relative_content(ctx, msg, args).await?;

Replacement in src/commands/mock.rs at line 27 [20.10]

B:BD[20.690] → [21.67:156]

    if let Ok(url) = crate::imgflip::generate_image_url(None, Some(&new), "102156234") {

[20.690]

[12.997]

    if let Ok(url) = crate::imgflip::generate_image_url(None, Some(&new), "102156234").await {

Replacement in src/commands/mock.rs at line 30 [20.10]

B:BD[12.1041] → [12.1041:1120]

            .send_files(&ctx, vec![url.as_str()], |m| m.content(&msg.author));

[12.1041]

[12.1120]

            .send_files(&ctx, vec![url.as_str()], |m| m.content(&msg.author))
            .await?;

Replacement in src/commands/mock.rs at line 33 [20.10]
B:BD[12.1133] → [12.1133:1171]
```
        let _ = msg.reply(&ctx, new);
```
[12.1133]
[12.1171]
```
        let _ = msg.reply(&ctx, new).await?;
```
Replacement in src/commands/mock.rs at line 35 [20.10]
B:BD[12.1177] → [12.1177:1207]
```
    let _ = msg.delete(&ctx);
```
[12.1177]
[20.690]
```
    let _ = msg.delete(&ctx).await?;
```
Insertion in src/commands/react.rs at line 2 [22.1114]
[22.1156]
[22.1156]
```
use anyhow::Result;
```

Replacement in src/commands/react.rs at line 14 [22.1114]

∅:D[3.481] → [22.1382:1464]

B:BD[22.1382] → [22.1382:1464]

pub fn react(ctx: &mut Context, msg: &Message, mut args: Args) -> CommandResult {

[3.481]

[22.1464]

pub async fn react(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {

Replacement in src/commands/react.rs at line 20 [22.1114]

B:BD[22.1591] → [22.1591:1662]

                .messages(&ctx, |retriever| retriever.before(msg.id))?

[22.1591]

[22.1662]

                .messages(&ctx, |retriever| retriever.before(msg.id))
                .await?

Replacement in src/commands/react.rs at line 27 [22.1114]

B:BD[4.128] → [4.128:183]

                message = get_last_message(ctx, msg)?;

[4.128]

[4.183]

                message = get_last_message(ctx, msg).await?;

Replacement in src/commands/react.rs at line 35 [22.1114]

B:BD[22.2042] → [22.2042:2125]

                .messages(&ctx, |retriever| retriever.before(msg.id).limit(1))?[0]

[22.2042]

[22.2125]

                .messages(&ctx, |retriever| retriever.before(msg.id).limit(1))
                .await?[0]

Replacement in src/commands/react.rs at line 55 [22.1114]

B:BD[22.2387] → [22.2387:2471]

                msg.react(&ctx, "🇵")?;
                msg.react(&ctx, "🇩")?;

[22.2387]

[22.2471]

                msg.react(&ctx, '🇵').await?;
                msg.react(&ctx, '🇩').await?;

Replacement in src/commands/react.rs at line 60 [22.1114]

B:BD[22.2527] → [22.2527:2572]

        message.react(&ctx, emoji.clone())?;

[22.2527]

[22.2572]

        message
            // TODO: does this « cast » to char really work with all emoji?
            .react(&ctx, emoji.clone().chars().next().unwrap())
            .await?;

Replacement in src/commands/react.rs at line 66 [22.1114]
B:BD[22.2620] → [22.2620:2643]
```
    msg.delete(&ctx)?;
```
[22.2620]
[22.2643]
```
    msg.delete(&ctx).await?;
```

Replacement in src/commands/react.rs at line 70 [22.1114]

B:BD[22.2657] → [4.504:618]

fn get_last_message(
    ctx: &mut Context,
    msg: &Message,
) -> Result<Message, Box<dyn std::error::Error>> {

[22.2657]

[4.618]

async fn get_last_message(ctx: &Context, msg: &Message) -> Result<Message> {

Replacement in src/commands/react.rs at line 73 [22.1114]

B:BD[4.649] → [4.649:724]

        .messages(&ctx, |retriever| retriever.before(msg.id).limit(1))?[0]

[4.649]

[4.724]

        .messages(&ctx, |retriever| retriever.before(msg.id).limit(1))
        .await?[0]

Replacement in src/commands/roasted.rs at line 11 [21.188]

∅:D[3.767] → [19.182:334]

B:BD[21.335] → [19.182:334]

∅:D[19.334] → [23.0:93]

B:BD[21.544] → [23.0:93]

∅:D[23.93] → [21.637:760]

B:BD[21.637] → [21.637:760]

pub fn roasted(ctx: &mut Context, msg: &Message, args: Args) -> CommandResult {
    let message = crate::utils::find_relative_content(ctx, msg, args)?;
    if let Ok(url) = crate::imgflip::generate_image_url(None, Some(&message), "122616222") {
        let _ = msg
            .channel_id
            .send_files(&ctx, vec![url.as_str()], |m| m.content(&msg.author));

[3.767]

[21.760]

pub async fn roasted(ctx: &Context, msg: &Message, args: Args) -> CommandResult {
    let message = crate::utils::find_relative_content(ctx, msg, args).await?;
    if let Ok(url) = crate::imgflip::generate_image_url(None, Some(&message), "122616222").await {
        msg.channel_id
            .send_files(&ctx, vec![url.as_str()], |m| m.content(&msg.author))
            .await?;

Replacement in src/commands/roasted.rs at line 18 [21.188]
B:BD[21.766] → [21.766:796]
```
    let _ = msg.delete(&ctx);
```
[21.766]
[21.796]
```
    msg.delete(&ctx).await?;
```
Insertion in src/commands/roll.rs at line 1 [6.39]
[6.39]
[6.40]
```
use anyhow::{anyhow, bail};
```

Replacement in src/commands/roll.rs at line 9 [6.39]

B:BD[6.256] → [6.256:441]

pub fn roll(ctx: &mut Context, msg: &Message, mut args: Args) -> CommandResult {
    let data = ctx.data.read();
    let mut rng = data.get::<crate::Random>().unwrap().lock().unwrap();

[6.256]

[6.441]

pub async fn roll(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
    let data = ctx.data.read().await;
    let mut rng = data.get::<crate::Random>().unwrap().lock().await;

Replacement in src/commands/roll.rs at line 17 [6.39]

B:BD[6.558] → [6.558:627]

        .collect::<Result<Vec<Term>, Box<dyn std::error::Error>>>();

[6.558]

[6.627]

        .collect::<anyhow::Result<Vec<Term>>>();

Replacement in src/commands/roll.rs at line 20 [6.39]

B:BD[6.660] → [6.660:741]

        let _ = msg.reply(&ctx, format!("{}", e));
        return Err(e.into());

[6.660]

[6.741]

        let _ = msg.reply(&ctx, format!("{}", e)).await?;
        return Ok(());

Replacement in src/commands/roll.rs at line 32 [6.39]

B:BD[6.985] → [6.985:1082]

                let _ = msg.reply(&ctx, format!("{}", e));
                return Err(e.into());

[6.985]

[6.1082]

                let _ = msg.reply(&ctx, format!("{}", e)).await?;
                return Ok(());

Insertion in src/commands/roll.rs at line 43 [6.39]

[6.1291]

    let parser = parser.total;
    if parser.is_none() {
        return Ok(());
    }

Replacement in src/commands/roll.rs at line 48 [6.39]

B:BD[6.1292] → [6.1292:1409]

    let _ = msg.reply(
        &ctx,
        format!("{} ({})", parser.total.ok_or("There was no op")?, res),
    );

[6.1292]

[6.1409]

    let _ = msg
        .reply(&ctx, format!("{} ({})", parser.unwrap(), res))
        .await;

Replacement in src/commands/roll.rs at line 76 [6.39]

B:BD[6.2052] → [6.2052:2139]

                (0..*rolls).fold(0, |acc, _| acc + rng.gen_range(1, faces + 1) as i64)

[6.2052]

[6.2139]

                (0..*rolls).fold(0, |acc, _| acc + rng.gen_range(1..faces + 1) as i64)

Replacement in src/commands/roll.rs at line 84 [6.39]
B:BD[6.2237] → [6.2237:2280]
```
    type Err = Box<dyn std::error::Error>;
```
[6.2237]
[6.2280]
```
    type Err = anyhow::Error;
```

Replacement in src/commands/roll.rs at line 86 [6.39]

B:BD[6.2281] → [6.2281:2335]

    fn from_str(s: &str) -> Result<Self, Self::Err> {

[6.2281]

[6.2335]

    fn from_str(s: &str) -> anyhow::Result<Self, Self::Err> {

Replacement in src/commands/roll.rs at line 92 [6.39]

B:BD[6.2505] → [6.2505:2564]

            return Err("Failed to parse the dice".into());

[6.2505]

[6.2564]

            bail!("Failed to parse the dice");

Replacement in src/commands/roll.rs at line 129 [6.39]
B:BD[6.3318] → [6.3318:3361]
```
    type Err = Box<dyn std::error::Error>;
```
[6.3318]
[6.3361]
```
    type Err = anyhow::Error;
```

Replacement in src/commands/roll.rs at line 131 [6.39]

B:BD[6.3362] → [6.3362:3416]

    fn from_str(s: &str) -> Result<Self, Self::Err> {

[6.3362]

[6.3416]

    fn from_str(s: &str) -> anyhow::Result<Self, Self::Err> {

Replacement in src/commands/roll.rs at line 136 [6.39]

B:BD[6.3546] → [6.3546:3614]

            s => Err(format!("Unsupported operator {}", s).into()),

[6.3546]

[6.3614]

            s => bail!("Unsupported operator {}", s),

Replacement in src/commands/roll.rs at line 147 [6.39]
B:BD[6.3706] → [6.3706:3749]
```
    type Err = Box<dyn std::error::Error>;
```
[6.3706]
[6.3749]
```
    type Err = anyhow::Error;
```

Replacement in src/commands/roll.rs at line 149 [6.39]

B:BD[6.3750] → [6.3750:3804]

    fn from_str(s: &str) -> Result<Self, Self::Err> {

[6.3750]

[6.3804]

    fn from_str(s: &str) -> anyhow::Result<Self, Self::Err> {

Replacement in src/commands/roll.rs at line 155 [6.39]

B:BD[6.3976] → [6.3976:4044]

            Err(format!("Can't parse this term: \"{}\"", s).into())

[6.3976]

[6.4044]

            bail!("Can't parse this term: \"{}\"", s)

Replacement in src/commands/roll.rs at line 167 [6.39]

B:BD[6.4165] → [6.4165:4300]

    pub fn and(
        &mut self,
        term: &Term,
        rng: &mut impl Rng,
    ) -> Result<i64, Box<dyn std::error::Error>> {

[6.4165]

[6.4300]

    pub fn and(&mut self, term: &Term, rng: &mut impl Rng) -> anyhow::Result<i64> {

Replacement in src/commands/roll.rs at line 171 [6.39]

B:BD[6.4423] → [6.4423:4463]

                    return Err(format!(

[6.4423]

[6.4463]

                    bail!(

Replacement in src/commands/roll.rs at line 174 [6.39]

B:BD[6.4581] → [6.4581:4633]

                    )
                    .into());

[6.4581]

[6.4633]

);

Replacement in src/commands/roll.rs at line 177 [6.39]

B:BD[6.4694] → [6.4694:4741]

                self.total.ok_or("Bug".into())

[6.4694]

[6.4741]

                self.total.ok_or(anyhow!("Bug"))

Replacement in src/commands/roll.rs at line 183 [6.39]
B:BD[6.4898] → [6.4898:4931]
```
                    Err(format!(
```
[6.4898]
[6.4931]
```
                    bail!(
```

Replacement in src/commands/roll.rs at line 186 [6.39]

B:BD[6.5053] → [6.5053:5104]

                    )
                    .into())

[6.5053]

[6.5104]

);

Replacement in src/commands/tg.rs at line 4 [10.108]
B:BD[10.234] → [5.396:418]
```
use std::sync::Mutex;
```
[10.234]
[10.234]
```
use std::sync::Arc;
use tokio::sync::Mutex;
```

Replacement in src/commands/tg.rs at line 16 [10.108]

B:BD[10.449] → [5.419:462]

    type Value = Mutex<Vec<&'static str>>;

[10.449]

[10.499]

    type Value = Arc<Mutex<Vec<&'static str>>>;

Replacement in src/commands/tg.rs at line 21 [10.108]

∅:D[3.812] → [10.513:589]

B:BD[10.513] → [10.513:589]

B:BD[10.589] → [5.463:495]

pub fn tg(ctx: &mut Context, msg: &Message, _args: Args) -> CommandResult {
    let data = ctx.data.read();

[3.812]

[10.626]

pub async fn tg(ctx: &Context, msg: &Message, _args: Args) -> CommandResult {
    let data = ctx.data.read().await;

Replacement in src/commands/tg.rs at line 24 [10.108]

B:BD[10.627] → [5.496:561]

    let mut insults = data.get::<Tg>().unwrap().lock().unwrap();

[10.627]

[24.37]

    let mut insults = data.get::<Tg>().unwrap().lock().await;

Replacement in src/commands/tg.rs at line 27 [10.108]

B:BD[24.99] → [5.562:640]

        let rng = &mut *data.get::<crate::Random>().unwrap().lock().unwrap();

[24.99]

[5.640]

        let rng = &mut *data.get::<crate::Random>().unwrap().lock().await;

Replacement in src/imgflip.rs at line 1 [21.823]
B:BD[21.823] → [2.50:91]
```
use reqwest::{blocking::Client, header};
```
[21.823]
[21.824]
```
use anyhow::{bail, Result};
use reqwest::header;
```

Replacement in src/imgflip.rs at line 9 [21.823]

B:BD[21.1000] → [21.1000:1135]

pub fn generate_image_url(
    h1: Option<&str>,
    h2: Option<&str>,
    id: &str,
) -> Result<String, Box<dyn std::error::Error>> {

[21.1000]

[21.1135]

pub async fn generate_image_url(h1: Option<&str>, h2: Option<&str>, id: &str) -> Result<String> {

Replacement in src/imgflip.rs at line 23 [21.823]

B:BD[21.1501] → [2.92:140]

    let resp: serde_json::Value = Client::new()

[21.1501]

[2.140]

    let resp: serde_json::Value = reqwest::Client::new()

Replacement in src/imgflip.rs at line 27 [21.823]

B:BD[2.289] → [2.289:324]

        .send()?
        .json()?;

[2.289]

[2.324]

        .send()
        .await?
        .json()
        .await?;

Replacement in src/imgflip.rs at line 35 [21.823]
B:BD[21.1790] → [21.1790:1829]
```
        Err("Could not as str".into())
```
[21.1790]
[21.1829]
```
        bail!("Could not as str")
```

Insertion in src/main.rs at line 9 [8.17]

[8.159]

[25.0]

    async_trait,
    client::bridge::gateway::ShardManager,

Replacement in src/main.rs at line 22 [8.17]

B:BD[26.150] → [5.810:832]

use std::sync::Mutex;

[26.150]

[8.691]

use std::sync::Arc;
use tokio::sync::Mutex;
struct ShardManagerContainer;
impl TypeMapKey for ShardManagerContainer {
    type Value = Arc<Mutex<ShardManager>>;
}

Insertion in src/main.rs at line 33 [8.17]
[8.709]
[8.709]
```
#[async_trait]
```

Replacement in src/main.rs at line 35 [8.17]

B:BD[8.741] → [8.741:789]

    fn ready(&self, _: Context, ready: Ready) {

[8.741]

[8.789]

    async fn ready(&self, _: Context, ready: Ready) {

Replacement in src/main.rs at line 43 [8.17]
B:BD[5.885] → [5.885:919]
```
    type Value = Mutex<SmallRng>;
```
[5.885]
[25.232]
```
    type Value = Arc<Mutex<SmallRng>>;
```
Replacement in src/main.rs at line 50 [8.17]
B:BD[25.430] → [25.430:469]
```
fn my_help(
    context: &mut Context,
```
[25.430]
[25.469]
```
async fn my_help(
    context: &Context,
```

Replacement in src/main.rs at line 58 [8.17]

B:BD[25.632] → [25.632:713]

    help_commands::with_embeds(context, msg, args, help_options, groups, owners)

[25.632]

[8.850]

    let _ = help_commands::with_embeds(context, msg, args, help_options, groups, owners).await;
    Ok(())

Replacement in src/main.rs at line 70 [8.17]
∅:D[15.1047] → [8.892:904]
∅:D[27.1159] → [8.892:904]
B:BD[8.892] → [8.892:904]
```
fn main() {
```
[15.1047]
[10.5696]
```
#[tokio::main]
async fn main() {
```

Replacement in src/main.rs at line 75 [8.17]

∅:D[11.203] → [8.935:1016]

B:BD[8.935] → [8.935:1016]

    let mut client = Client::new(&token, Handler).expect("Err creating client");

[11.203]

[5.920]


    let framework = StandardFramework::new()
        .configure(|c| c.prefix("!").delimiters(vec![", ", ",", " "]))
        .group(&GENERAL_GROUP)
        .group(&CUTE_GROUP)
        .help(&MY_HELP);
    let mut client = Client::builder(&token)
        .framework(framework)
        .event_handler(Handler)
        .await
        .expect("Err creating client");
    {
        let mut data = client.data.write().await;
        data.insert::<ShardManagerContainer>(client.shard_manager.clone());
    }

Replacement in src/main.rs at line 95 [8.17]

B:BD[8.1023] → [10.5757:5801]

B:BD[10.5801] → [5.966:1092]

        let mut data = client.data.write();
        data.insert::<commands::Tg>(Mutex::new(commands::init_tg(&mut rng)));
        data.insert::<Random>(Mutex::new(rng));

[8.1023]

[8.1206]

        let mut data = client.data.write().await;
        data.insert::<commands::Tg>(Arc::new(Mutex::new(commands::init_tg(&mut rng))));
        data.insert::<Random>(Arc::new(Mutex::new(rng)));

Replacement in src/main.rs at line 100 [8.17]

B:BD[8.1213] → [8.1213:1273]

B:BD[8.1273] → [10.5865:5940]

B:BD[10.5940] → [25.714:749]

B:BD[25.749] → [15.1048:1080]

∅:D[15.1080] → [25.749:778]

B:BD[25.749] → [25.749:778]

∅:D[28.484] → [8.3283:3290]

∅:D[25.778] → [8.3283:3290]

∅:D[27.1401] → [8.3283:3290]

∅:D[29.2878] → [8.3283:3290]

∅:D[10.5976] → [8.3283:3290]

B:BD[8.3283] → [8.3283:3290]

    client.with_framework(
        StandardFramework::new()
            .configure(|c| c.prefix("!").delimiters(vec![", ", ",", " "]))
            .group(&GENERAL_GROUP)
            .group(&CUTE_GROUP)
            .help(&MY_HELP),
    );

[8.1213]

[8.3290]

    let shard_manager = client.shard_manager.clone();
    tokio::spawn(async move {
        tokio::signal::ctrl_c()
            .await
            .expect("Could not register ctrl+c handler");
        shard_manager.lock().await.shutdown_all().await;
    });

Replacement in src/main.rs at line 109 [8.17]

B:BD[8.3291] → [8.3291:3375]

    if let Err(why) = client.start() {
        println!("Client error: {:?}", why);

[8.3291]

[8.3814]

    if let Err(why) = client.start().await {
        eprintln!("Client error: {:?}", why);

Replacement in src/utils.rs at line 5 [19.358]

B:BD[19.514] → [19.514:567]

pub fn find_relative_content(
    ctx: &mut Context,

[19.514]

[19.567]

pub async fn find_relative_content(
    ctx: &Context,

Replacement in src/utils.rs at line 14 [19.358]

B:BD[19.742] → [19.742:825]

                .messages(&ctx, |retriever| retriever.before(msg.id).limit(1))?[0]

[19.742]

[19.825]

                .messages(&ctx, |retriever| retriever.before(msg.id).limit(1))
                .await?[0]

Replacement in src/utils.rs at line 22 [19.358]

B:BD[19.1008] → [19.1008:1075]

            .messages(&ctx, |retriever| retriever.before(msg.id))?

[19.1008]

[19.1075]

            .messages(&ctx, |retriever| retriever.before(msg.id))
            .await?