chore: fix formatting and imports

src/commands/bot/bot.rs

···
 use crate::Context;
 use color_eyre::eyre::Result;
-use poise::{serenity_prelude as serenity, CreateReply};
+use poise::{serenity_prelude::CreateEmbed, CreateReply};
 use std::env;
 
 /// Displays information about the bot
···
     let rev = env::var("BUILD_REV").unwrap_or("unknown".to_string());
 
     let embed = CreateReply::default().embed(
-        serenity::CreateEmbed::default()
+        CreateEmbed::default()
             .title("Bot Info")
             //.thumbnail(bot.avatar_url().expect("avatar failed"))
             .color(0x00ff_ffff)

src/commands/fun/bottom.rs

···
 /// Translate your words for the tops and normies to understand
 #[poise::command(slash_command, guild_only)]
 pub async fn topify(ctx: Context<'_>, #[description = "text"] input: String) -> Result<()> {
-	const MAX_LEN: usize = 1994;
-	const WRAP: &'static str = "```";
+    const MAX_LEN: usize = 1994;
+    const WRAP: &'static str = "```";
     let out = bottom::decode_string(&input);
 
-	if let Ok(out) = out {
-		let mut out = out.as_str();
-		let len = out.len();
-		for _ in 0..(len / MAX_LEN) {
-			let (x, xs) = out.split_at(MAX_LEN);
-			ctx.say(format!("{WRAP}{x}{WRAP}")).await?;
-			out = xs;
-		}
-		if len % MAX_LEN != 0 {
-			ctx.say(format!("{WRAP}{out}{WRAP}")).await?;
-		}
+    if let Ok(out) = out {
+        let mut out = out.as_str();
+        let len = out.len();
+        for _ in 0..(len / MAX_LEN) {
+            let (x, xs) = out.split_at(MAX_LEN);
+            ctx.say(format!("{WRAP}{x}{WRAP}")).await?;
+            out = xs;
+        }
+        if len % MAX_LEN != 0 {
+            ctx.say(format!("{WRAP}{out}{WRAP}")).await?;
+        }
     } else {
         ctx.say("I couldn't decode that message.").await?;
     }

src/commands/misc/nixpkgs.rs

···
 use color_eyre::eyre::Result;
 use git_tracker::Tracker;
-use poise::{serenity_prelude as serenity, CreateReply};
+use poise::{serenity_prelude::CreateEmbed, CreateReply};
 use serde::Deserialize;
 use std::env;
 
···
     let github_token = env::var("GITHUB_TOKEN").expect("GITHUB_TOKEN not set");
     let tracker = Tracker::from_path(&nixpkgs_path)?;
 
-	let client = &ctx.data().client;
+    let client = &ctx.data().client;
 
     // find out what commit our PR was merged in
     let Some(commit_sha) = ({
···
     };
 
     let embed = CreateReply::default().embed(
-        serenity::CreateEmbed::new()
+        CreateEmbed::new()
             .title(format!("Nixpkgs PR #{pr} Status"))
             .url(format!("{NIXPKGS_URL}/pull/{pr}"))
             .description(embed_description),

src/commands/user/avatar.rs

···
 use crate::Context;
 use color_eyre::eyre::Result;
-use poise::serenity_prelude as serenity;
+use poise::serenity_prelude::User;
 
 /// Displays your or another user's avatar
 #[poise::command(slash_command)]
 pub async fn avatar(
     ctx: Context<'_>,
-    #[description = "Selected user"] user: Option<serenity::User>,
+    #[description = "Selected user"] user: Option<User>,
 ) -> Result<()> {
     let user = user.as_ref().unwrap_or_else(|| ctx.author());
     let avatar = user.avatar_url().expect("Could not get avatar URL");

src/commands/user/whois.rs

···
 use crate::Context;
 use color_eyre::eyre::Result;
-use poise::{serenity_prelude as serenity, CreateReply};
+use poise::{
+    serenity_prelude::{CreateEmbed, User},
+    CreateReply,
+};
 
 /// Displays your or another user's info
 #[poise::command(slash_command)]
 pub async fn whois(
     ctx: Context<'_>,
-    #[description = "Selected user"] user: Option<serenity::User>,
+    #[description = "Selected user"] user: Option<User>,
 ) -> Result<()> {
     let user = user.as_ref().unwrap_or_else(|| ctx.author());
     let membership = ctx.guild_id().unwrap().member(ctx.http(), user.id).await?;
···
     let joined_at = membership.joined_at.unwrap().unix_timestamp();
 
     let embed = CreateReply::default().embed(
-        serenity::CreateEmbed::default()
+        CreateEmbed::default()
             .title(&user.name)
             .thumbnail(user.avatar_url().expect("avatar failed"))
             .color(0x00ff_ffff)

src/event_handler/code_expantion.rs

···
 // the logic here is pretty much ripped from https://github.com/uncenter/discord-forum-bot/blob/main/src/modules/expandGitHubLinks.ts
 // with some modifications so I can make it work on diffrent git hosts
 
-use color_eyre::eyre::{self, Result};
+use color_eyre::eyre::{eyre, Result};
 use poise::serenity_prelude::{Context, FullEvent};
 use regex::Regex;
 use reqwest::Client;
 
-pub async fn handle(ctx: &Context, event: &FullEvent) -> Result<()> {
+pub async fn handle(ctx: &Context, event: &FullEvent, client: &Client) -> Result<()> {
     if let FullEvent::Message { new_message } = event {
-        let code_blocks = extract_code_blocks(new_message.content.clone()).await?;
+        let code_blocks = extract_code_blocks(new_message.content.clone(), client).await?;
 
         if !code_blocks.is_empty() {
             new_message
···
     Ok(())
 }
 
-async fn extract_code_blocks(msg: String) -> Result<Vec<String>> {
+async fn extract_code_blocks(msg: String, client: &Client) -> Result<Vec<String>> {
     let re = Regex::new(
-        r"https?://(?P<host>(git.*|codeberg\.org))/(?P<repo>[\w-]+/[\w.-]+)/(blob|(src/(commit|branch)))?/(?P<reference>\S+?)/(?P<file>\S+)#L(?P<start>\d+)(?:[~-]L?(?P<end>\d+)?)?",
+        r#"(?x)
+        https?://
+		(?P<host>
+			(git.*|codeberg\.org))		/
+		(?P<repo>		[\w-]+/[\w.-]+)	/
+		(blob|(src/(commit|branch)))?	/
+		(?P<reference>	\S+?)			/
+		(?P<file>		\S+)			#L
+		(?P<start>		\d+)
+		(?:[~-]L?(?P<end>\d+)?)?
+    "#,
     )?;
 
     let mut blocks: Vec<String> = Vec::new();
-    let client = Client::new();
 
     for caps in re.captures_iter(&msg) {
         let (host, repo, reference, file, start, end) = extract_url_components(&caps)?;
···
 ) -> Result<String> {
     let response = client.get(raw_url).send().await?;
     if !response.status().is_success() {
-        return Err(eyre::eyre!("Failed to fetch content from {}", raw_url));
+        return Err(eyre!("Failed to fetch content from {}", raw_url));
     }
 
     let text = response.text().await?;

src/event_handler/mod.rs

···
         println!("Logged in as {}", data_about_bot.user.name);
     }
 
-    code_expantion::handle(ctx, event).await?;
+	let client = &_data.client;
 
-    Ok(())
+    code_expantion::handle(ctx, event, client).await
 }

src/main.rs

···
 use std::env;
 
 use color_eyre::eyre::{Report, Result};
-use poise::serenity_prelude::{self as serenity, ActivityData, GatewayIntents};
+use poise::serenity_prelude::{ActivityData, ClientBuilder, GatewayIntents};
 
 #[derive(Debug)]
-pub struct Data { // User data, which is stored and accessible in all command invocations
-	client: Client,
-} 
+// User data, which is stored and accessible in all command invocations
+pub struct Data {
+    client: Client,
+}
 
 pub type Context<'a> = poise::Context<'a, Data, Report>;
 
···
             commands::fun::bottom::topify(),
             commands::fun::bottom::bottomify(),
         ],
-        event_handler: |ctx, event, _, data| Box::pin(crate::event_handler::event_handler(ctx, event, data)),
+        event_handler: |ctx, event, _, data| {
+            Box::pin(crate::event_handler::event_handler(ctx, event, data))
+        },
         ..Default::default()
     };
 
···
             Box::pin(async move {
                 ctx.set_activity(Some(ActivityData::custom("new bot, who dis?")));
 
-				poise::builtins::register_globally(ctx, &framework.options().commands).await?;
+                poise::builtins::register_globally(ctx, &framework.options().commands).await?;
 
                 Ok(Data {
-					client: Client::builder()
-						.user_agent("blahaj")
-						.build()?,
-				})
+                    client: Client::builder().user_agent("blahaj").build()?,
+                })
             })
         })
         .options(opts)
         .build();
 
-    let client = serenity::ClientBuilder::new(token, intents)
+    let client = ClientBuilder::new(token, intents)
         .framework(framework)
         .await;