Merge branch 'master' into perf

Author: InfinityGhost

flake.lock

@@ -11,10 +11,7 @@
 
     importPkgs = pkgs: import pkgs { inherit system; };
 
-    pkgs = import nixpkgs {
-      inherit system;
-      config.allowUnfree = true;
-    };
+    pkgs = importPkgs nixpkgs;
 
   in rec {
 

flake.nix

@@ -8,8 +8,9 @@ pub(crate) const ERROR_COLOUR: Colour = Colour(0xe74c3c);
 use crate::{Context, Error};
 
 use poise::serenity_prelude::{
-    self as serenity, Colour, ComponentInteractionCollector, CreateActionRow, CreateButton,
-    CreateEmbed, CreateEmbedFooter, CreateInteractionResponse, CreateInteractionResponseMessage,
+    self as serenity, Colour, ComponentInteraction, ComponentInteractionCollector, CreateActionRow,
+    CreateButton, CreateEmbed, CreateEmbedFooter, CreateInteractionResponse,
+    CreateInteractionResponseMessage,
 };
 use poise::CreateReply;
 
@@ -49,6 +50,20 @@ pub async fn respond_err(ctx: &Context<'_>, title: &str, content: &str) {
     respond_embed(ctx, embed, false).await;
 }
 
+pub async fn interaction_err(ctx: &serenity::Context, press: &ComponentInteraction, content: &str) {
+    let builder = CreateInteractionResponse::Message(
+        CreateInteractionResponseMessage::new()
+            .embed(
+                CreateEmbed::new()
+                    .title("Unable to execute interaction")
+                    .description(content)
+                    .colour(ERROR_COLOUR),
+            )
+            .ephemeral(true),
+    );
+    let _ = press.create_response(ctx, builder).await;
+}
+
 pub async fn paginate_lists<U, E>(
     ctx: poise::Context<'_, U, E>,
     pages: &[Vec<(String, String, bool)>],

src/commands/mod.rs

@@ -4,7 +4,10 @@ use crate::{
     Context, Error,
 };
 use ::serenity::futures::{Stream, StreamExt};
-use poise::serenity_prelude::{futures, CreateAttachment, CreateEmbed};
+use poise::serenity_prelude::{
+    self as serenity, futures, CreateAttachment, CreateEmbed, CreateInteractionResponse,
+    CreateInteractionResponseMessage,
+};
 
 async fn autocomplete_snippet<'a>(
     ctx: Context<'a>,
@@ -17,14 +20,12 @@ async fn autocomplete_snippet<'a>(
             .unwrap()
             .snippets
             .iter()
-            .take(25)
             .map(|s| format!("{}: {}", s.id, s.title))
             .collect()
     };
 
     futures::stream::iter(snippet_list)
-        .filter(move |name| futures::future::ready(name.starts_with(partial)))
-        .map(|name| name.to_string())
+        .filter(move |name| futures::future::ready(name.contains(partial)))
 }
 
 /// Show a snippet
@@ -150,10 +151,7 @@ pub async fn remove_snippet(
 ) -> Result<(), Error> {
     match get_snippet_lazy(&ctx, &id).await {
         Some(snippet) => {
-            rm_snippet(&ctx, &snippet).await;
-            let title = &"Snippet successfully removed";
-            let content = &&format!("Removed snippet '{}: {}'", snippet.id, snippet.title);
-            respond_ok(&ctx, title, content).await;
+            remove_snippet_confirm(&ctx, &snippet).await?;
         }
         None => {
             let title = &"Failed to remove snippet";
@@ -213,10 +211,8 @@ pub async fn export_snippet(
 ) -> Result<(), Error> {
     match get_snippet_lazy(&ctx, &id).await {
         Some(snippet) => {
-            let attachment = CreateAttachment::bytes(
-                format!("{}", &snippet.content.replace('\n', r"\n")),
-                "snippet.txt",
-            );
+            let attachment =
+                CreateAttachment::bytes(snippet.content.replace('\n', r"\n"), "snippet.txt");
             let message = poise::CreateReply::default()
                 .attachment(attachment)
                 .embed(snippet.embed());
@@ -280,3 +276,83 @@ async fn rm_snippet(ctx: &Context<'_>, snippet: &Snippet) {
     rwlock_guard.snippets.remove(index);
     rwlock_guard.write();
 }
+
+async fn remove_snippet_confirm(ctx: &Context<'_>, snippet: &Snippet) -> Result<(), Error> {
+    let snippet_embed = snippet.embed();
+
+    let ctx_id = ctx.id();
+    let delete_id = format!("{}cancel", ctx_id);
+    let cancel_id = format!("{}delete", ctx_id);
+
+    let components = serenity::CreateActionRow::Buttons(vec![
+        serenity::CreateButton::new(&cancel_id).label("Cancel"),
+        serenity::CreateButton::new(&delete_id)
+            .label("Delete")
+            .style(serenity::ButtonStyle::Danger),
+    ]);
+
+    let builder: poise::CreateReply = poise::CreateReply::default()
+        .content(format!("Are you sure you want to delete snippet `{}`?", snippet.id))
+        .ephemeral(true)
+        .embed(snippet_embed)
+        .components(vec![components]);
+
+    ctx.send(builder).await?;
+
+    while let Some(press) = serenity::ComponentInteractionCollector::new(ctx)
+        .filter(move |press| press.data.custom_id.starts_with(&ctx_id.to_string()))
+        .timeout(std::time::Duration::from_secs(60))
+        .await
+    {
+        if press.data.custom_id == delete_id {
+            handle_delete(ctx, snippet, press).await?;
+        } else if press.data.custom_id == cancel_id {
+            handle_cancel(ctx, press).await?;
+        }
+    }
+
+    Ok(())
+}
+
+async fn handle_delete(
+    ctx: &Context<'_>,
+    snippet: &Snippet,
+    interaction: serenity::ComponentInteraction,
+) -> Result<(), Error> {
+
+    rm_snippet(ctx, snippet).await;
+    interaction
+        .create_response(
+            ctx,
+            CreateInteractionResponse::UpdateMessage(
+                CreateInteractionResponseMessage::new().content("Deleted!")
+                    .embeds(vec![])
+                    .components(vec![]),
+            ),
+        )
+        .await?;
+
+        let title = format!("{} removed a snippet", ctx.author().tag());
+        let content = &&format!("Removed snippet `{}`", snippet.format_output());
+        respond_ok(ctx, &title, content).await;
+
+    Ok(())
+}
+
+async fn handle_cancel(
+    ctx: &Context<'_>,
+    interaction: serenity::ComponentInteraction,
+) -> Result<(), Error> {
+    interaction
+        .create_response(
+            ctx,
+            CreateInteractionResponse::UpdateMessage(
+                CreateInteractionResponseMessage::new()
+                    .content("Aborted.")
+                    .embeds(vec![])
+                    .components(vec![]),
+            ),
+        )
+        .await?;
+    Ok(())
+}

src/commands/snippets.rs

@@ -19,14 +19,12 @@ async fn autocomplete_key<'a>(
             .unwrap()
             .issue_prefixes
             .iter()
-            .take(25)
             .map(|s| s.0.clone())
             .collect()
     };
 
     futures::stream::iter(snippet_list)
-        .filter(move |name| futures::future::ready(name.starts_with(partial)))
-        .map(|name| name.to_string())
+        .filter(move |name| futures::future::ready(name.contains(partial)))
 }
 
 /// Create an embed in the current channel.
@@ -379,7 +377,7 @@ pub async fn list_repos(ctx: Context<'_>) -> Result<(), Error> {
         .map(|token| {
             (
                 token.0.clone(),
-                format!("{}/{}", token.1.name, token.1.owner),
+                format!("{}/{}", token.1.owner, token.1.name),
                 true,
             )
         })

src/commands/utils.rs

@@ -1,11 +1,12 @@
 use std::time::Duration;
 
-use crate::{structures::Embeddable, Data};
+use crate::{commands::interaction_err, structures::Embeddable, Data};
 use ::serenity::builder::CreateEmbedAuthor;
 use octocrab::models::issues::Issue;
 use octocrab::models::pulls::PullRequest;
 use poise::serenity_prelude::{
-    self as serenity, Colour, Context, CreateEmbed, Message, Permissions,
+    self as serenity, ButtonStyle, Colour, Context, CreateActionRow, CreateButton, CreateEmbed,
+    CreateInteractionResponse, Message, Permissions,
 };
 use regex::Regex;
 
@@ -23,11 +24,15 @@ pub async fn message(data: &Data, ctx: &Context, message: &Message) {
         let ctx_id = message.id.get(); // poise context isn't available here.
         let remove_id = format!("{}remove", ctx_id);
         let hide_body_id = format!("{}hide_body", ctx_id);
+        let remove = CreateActionRow::Buttons(vec![CreateButton::new(&remove_id)
+            .label("delete")
+            .style(ButtonStyle::Danger)]);
+
         let components = serenity::CreateActionRow::Buttons(vec![
-            serenity::CreateButton::new(&remove_id)
+            CreateButton::new(&remove_id)
                 .label("delete")
-                .style(serenity::ButtonStyle::Danger),
-            serenity::CreateButton::new(&hide_body_id).label("hide body"),
+                .style(ButtonStyle::Danger),
+            CreateButton::new(&hide_body_id).label("hide body"),
         ]);
 
         let content: serenity::CreateMessage = serenity::CreateMessage::default()
@@ -56,12 +61,19 @@ pub async fn message(data: &Data, ctx: &Context, message: &Message) {
                 && (press.user.id == message.author.id || has_perms)
             {
                 let _ = press
-                    .create_response(ctx, serenity::CreateInteractionResponse::Acknowledge)
+                    .create_response(ctx, CreateInteractionResponse::Acknowledge)
                     .await;
                 if let Ok(ref msg) = msg_result {
                     let _ = msg.delete(ctx).await;
                 }
                 msg_deleted = true;
+            } else {
+                interaction_err(
+                    ctx,
+                    &press,
+                    "Unable to use interaction because you are missing `MANAGE_MESSAGES`.",
+                )
+                .await;
             }
 
             if press.data.custom_id == hide_body_id
@@ -82,12 +94,20 @@ pub async fn message(data: &Data, ctx: &Context, message: &Message) {
                             ctx,
                             serenity::CreateInteractionResponse::UpdateMessage(
                                 serenity::CreateInteractionResponseMessage::new()
-                                    .embeds(hid_body_embeds),
+                                    .embeds(hid_body_embeds)
+                                    .components(vec![remove.clone()]),
                             ),
                         )
                         .await;
                 }
                 body_hid = true;
+            } else {
+                interaction_err(
+                    ctx,
+                    &press,
+                    "Unable to use interaction because you are missing `MANAGE_MESSAGES`.",
+                )
+                .await;
             }
         }
         // Triggers on timeout.
@@ -98,7 +118,6 @@ pub async fn message(data: &Data, ctx: &Context, message: &Message) {
                     .await;
             }
         }
-        //
     }
 }
 
@@ -107,8 +126,7 @@ async fn issue_embeds(data: &Data, message: &Message) -> Option<Vec<CreateEmbed>
     let client = octocrab::instance();
     let ratelimit = client.ratelimit();
 
-    let regex =
-        Regex::new(r#" ?([a-zA-Z0-9-_.]+)?#([0-9]+[0-9]) ?"#).expect("Expected numbers regex");
+    let regex = Regex::new(r#" ?([a-zA-Z0-9-_.]+)?#([0-9]+) ?"#).expect("Expected numbers regex");
 
     let custom_repos = { data.state.read().unwrap().issue_prefixes.clone() };
 
@@ -126,7 +144,9 @@ async fn issue_embeds(data: &Data, message: &Message) -> Option<Vec<CreateEmbed>
 
                     issues = client.issues(owner, repo);
                     prs = client.pulls(owner, repo);
-                }
+                } else {
+                    continue; // discards when it doesn't match a repo.
+                };
             }
 
             let ratelimit = ratelimit

src/events/issue.rs

@@ -21,9 +21,38 @@ type Context<'a> = poise::Context<'a, Data, Error>;
 async fn on_error(error: poise::FrameworkError<'_, Data, Error>) {
     match error {
         poise::FrameworkError::Setup { error, .. } => panic!("Failed to start bot: {:?}", error),
-        poise::FrameworkError::Command { error, ctx, .. } => {
-            println!("Error in command `{}`: {:?}", ctx.command().name, error,);
+        poise::FrameworkError::Command { ctx, error, .. } => {
+            let error = error.to_string();
+            eprintln!("An error occured in a command: {}", error);
+            commands::respond_err(&ctx, "Command Error", &error).await;
         }
+
+        poise::FrameworkError::ArgumentParse {
+            error, input, ctx, ..
+        } => {
+            let usage = match &ctx.command().help_text {
+                Some(help_text) => &**help_text,
+                None => "Please check the help menu for usage information",
+            };
+            let response = if let Some(input) = input {
+                format!(
+                    "**Cannot parse `{}` as argument: {}**\n{}",
+                    input, error, usage
+                )
+            } else {
+                format!("### {}\n{}", error, usage)
+            };
+            commands::respond_err(&ctx, "Argument Parsing Error", &response).await;
+        }
+        poise::FrameworkError::GuildOnly { ctx, .. } => {
+            commands::respond_err(
+                &ctx,
+                "This command cannot be ran in DMs.",
+                "You cannot run this command in DMs.",
+            )
+            .await;
+        }
+
         error => {
             if let Err(e) = poise::builtins::on_error(error).await {
                 println!("Error while handling error: {}", e)