style: use tabs over spaces

Author: getchoo

.rustfmt.toml

@@ -0,0 +1 @@
+hard_tabs = true

build.rs

@@ -8,15 +8,15 @@ include!("src/tags.rs");
 /// generate the ChoiceParameter enum and tag data we will use in the `tag` command
 #[allow(dead_code)]
 fn main() {
-    let out_dir = env::var_os("OUT_DIR").unwrap();
-    let generated = Path::new(&out_dir).join("generated.rs");
+	let out_dir = env::var_os("OUT_DIR").unwrap();
+	let generated = Path::new(&out_dir).join("generated.rs");
 
-    let tag_files: Vec<String> = fs::read_dir(TAG_DIR)
-        .unwrap()
-        .map(|f| f.unwrap().file_name().to_string_lossy().to_string())
-        .collect();
+	let tag_files: Vec<String> = fs::read_dir(TAG_DIR)
+		.unwrap()
+		.map(|f| f.unwrap().file_name().to_string_lossy().to_string())
+		.collect();
 
-    let tags: Vec<Tag> = tag_files
+	let tags: Vec<Tag> = tag_files
         .clone()
         .into_iter()
         .map(|name| {
@@ -45,23 +45,23 @@ fn main() {
         })
         .collect();
 
-    let formatted_names: Vec<String> = tags
-        .iter()
-        .map(|t| t.file_name.replace(".md", "").replace('-', "_"))
-        .collect();
+	let formatted_names: Vec<String> = tags
+		.iter()
+		.map(|t| t.file_name.replace(".md", "").replace('-', "_"))
+		.collect();
 
-    let tag_choice = format!(
-        r#"
+	let tag_choice = format!(
+		r#"
     #[allow(non_camel_case_types, clippy::upper_case_acronyms)]
     #[derive(Clone, Debug, poise::ChoiceParameter)]
     pub enum TagChoice {{
     {}
     }}"#,
-        formatted_names.join(",\n")
-    );
+		formatted_names.join(",\n")
+	);
 
-    let to_str = format!(
-        r#"
+	let to_str = format!(
+		r#"
     impl TagChoice {{
     fn as_str(&self) -> &str {{
     match &self {{
@@ -70,22 +70,22 @@ fn main() {
     }}
     }}
     "#,
-        formatted_names
-            .iter()
-            .map(|n| {
-                let file_name = n.replace('_', "-") + ".md";
-                format!("Self::{n} => \"{file_name}\",")
-            })
-            .collect::<Vec<String>>()
-            .join("\n")
-    );
+		formatted_names
+			.iter()
+			.map(|n| {
+				let file_name = n.replace('_', "-") + ".md";
+				format!("Self::{n} => \"{file_name}\",")
+			})
+			.collect::<Vec<String>>()
+			.join("\n")
+	);
 
-    let contents = Vec::from([tag_choice, to_str]).join("\n\n");
+	let contents = Vec::from([tag_choice, to_str]).join("\n\n");
 
-    fs::write(generated, contents).unwrap();
-    println!(
-        "cargo:rustc-env=TAGS={}",
-        // make sure we can deserialize with env! at runtime
-        serde_json::to_string(&tags).unwrap()
-    );
+	fs::write(generated, contents).unwrap();
+	println!(
+		"cargo:rustc-env=TAGS={}",
+		// make sure we can deserialize with env! at runtime
+		serde_json::to_string(&tags).unwrap()
+	);
 }

src/api/dadjoke.rs

@@ -7,15 +7,15 @@ use reqwest::StatusCode;
 const DADJOKE: &str = "https://icanhazdadjoke.com";
 
 pub async fn get_joke() -> Result<String> {
-    let req = REQWEST_CLIENT.get(DADJOKE).build()?;
+	let req = REQWEST_CLIENT.get(DADJOKE).build()?;
 
-    debug!("Making request to {}", req.url());
-    let resp = REQWEST_CLIENT.execute(req).await?;
-    let status = resp.status();
+	debug!("Making request to {}", req.url());
+	let resp = REQWEST_CLIENT.execute(req).await?;
+	let status = resp.status();
 
-    if let StatusCode::OK = status {
-        Ok(resp.text().await?)
-    } else {
-        Err(eyre!("Couldn't get a joke!"))
-    }
+	if let StatusCode::OK = status {
+		Ok(resp.text().await?)
+	} else {
+		Err(eyre!("Couldn't get a joke!"))
+	}
 }

src/api/mod.rs

@@ -6,14 +6,14 @@ pub mod prism_meta;
 pub mod rory;
 
 pub static USER_AGENT: Lazy<String> = Lazy::new(|| {
-    let version = option_env!("CARGO_PKG_VERSION").unwrap_or("development");
+	let version = option_env!("CARGO_PKG_VERSION").unwrap_or("development");
 
-    format!("refraction/{version}")
+	format!("refraction/{version}")
 });
 
 pub static REQWEST_CLIENT: Lazy<reqwest::Client> = Lazy::new(|| {
-    reqwest::Client::builder()
-        .user_agent(USER_AGENT.to_string())
-        .build()
-        .unwrap_or_default()
+	reqwest::Client::builder()
+		.user_agent(USER_AGENT.to_string())
+		.build()
+		.unwrap_or_default()
 });

src/api/pluralkit.rs

@@ -8,30 +8,32 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct PluralKitMessage {
-    pub sender: String,
+	pub sender: String,
 }
 
 const PLURAL_KIT: &str = "https://api.pluralkit.me/v2";
 const MESSAGES_ENDPOINT: &str = "/messages";
 
 pub async fn get_sender(message_id: MessageId) -> Result<UserId> {
-    let req = REQWEST_CLIENT
-        .get(format!("{PLURAL_KIT}{MESSAGES_ENDPOINT}/{message_id}"))
-        .build()?;
+	let req = REQWEST_CLIENT
+		.get(format!("{PLURAL_KIT}{MESSAGES_ENDPOINT}/{message_id}"))
+		.build()?;
 
-    debug!("Making request to {}", req.url());
-    let resp = REQWEST_CLIENT.execute(req).await?;
-    let status = resp.status();
+	debug!("Making request to {}", req.url());
+	let resp = REQWEST_CLIENT.execute(req).await?;
+	let status = resp.status();
 
-    if let StatusCode::OK = status {
-        let data = resp.json::<PluralKitMessage>().await?;
-        let id: u64 = data.sender.parse().wrap_err_with(|| format!("Couldn't parse response from PluralKit as a UserId! Here's the response:\n{data:#?}"))?;
-        let sender = UserId::from(id);
+	if let StatusCode::OK = status {
+		let data = resp.json::<PluralKitMessage>().await?;
+		let id: u64 = data.sender.parse().wrap_err_with(|| {
+			format!("Couldn't parse response from PluralKit as a UserId! Here's the response:\n{data:#?}")
+		})?;
+		let sender = UserId::from(id);
 
-        Ok(sender)
-    } else {
-        Err(eyre!(
+		Ok(sender)
+	} else {
+		Err(eyre!(
             "Failed to get PluralKit message information from {PLURAL_KIT}{MESSAGES_ENDPOINT}/{message_id} with {status}",
         ))
-    }
+	}
 }

src/api/prism_meta.rs

@@ -8,39 +8,39 @@ use serde::{Deserialize, Serialize};
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct MinecraftPackageJson {
-    pub format_version: u8,
-    pub name: String,
-    pub recommended: Vec<String>,
-    pub uid: String,
+	pub format_version: u8,
+	pub name: String,
+	pub recommended: Vec<String>,
+	pub uid: String,
 }
 
 const PRISM_META: &str = "https://meta.prismlauncher.org/v1";
 const MINECRAFT_PACKAGEJSON_ENDPOINT: &str = "/net.minecraft/package.json";
 
 pub async fn get_latest_minecraft_version() -> Result<String> {
-    let req = REQWEST_CLIENT
-        .get(format!("{PRISM_META}{MINECRAFT_PACKAGEJSON_ENDPOINT}"))
-        .build()?;
-
-    debug!("Making request to {}", req.url());
-    let resp = REQWEST_CLIENT.execute(req).await?;
-    let status = resp.status();
-
-    if let StatusCode::OK = status {
-        let data = resp
-            .json::<MinecraftPackageJson>()
-            .await
-            .wrap_err_with(|| "Couldn't parse Minecraft versions!")?;
-
-        let version = data
-            .recommended
-            .first()
-            .ok_or_else(|| eyre!("Couldn't find latest version of Minecraft!"))?;
-
-        Ok(version.clone())
-    } else {
-        Err(eyre!(
+	let req = REQWEST_CLIENT
+		.get(format!("{PRISM_META}{MINECRAFT_PACKAGEJSON_ENDPOINT}"))
+		.build()?;
+
+	debug!("Making request to {}", req.url());
+	let resp = REQWEST_CLIENT.execute(req).await?;
+	let status = resp.status();
+
+	if let StatusCode::OK = status {
+		let data = resp
+			.json::<MinecraftPackageJson>()
+			.await
+			.wrap_err_with(|| "Couldn't parse Minecraft versions!")?;
+
+		let version = data
+			.recommended
+			.first()
+			.ok_or_else(|| eyre!("Couldn't find latest version of Minecraft!"))?;
+
+		Ok(version.clone())
+	} else {
+		Err(eyre!(
             "Failed to get latest Minecraft version from {PRISM_META}{MINECRAFT_PACKAGEJSON_ENDPOINT} with {status}",
         ))
-    }
+	}
 }

src/api/rory.rs

@@ -7,40 +7,40 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
 pub struct RoryResponse {
-    pub id: u64,
-    pub url: String,
-    pub error: Option<String>,
+	pub id: u64,
+	pub url: String,
+	pub error: Option<String>,
 }
 
 const RORY: &str = "https://rory.cat";
 const ENDPOINT: &str = "/purr";
 
 pub async fn get_rory(id: Option<u64>) -> Result<RoryResponse> {
-    let target = id.map(|id| id.to_string()).unwrap_or_default();
-
-    let req = REQWEST_CLIENT
-        .get(format!("{RORY}{ENDPOINT}/{target}"))
-        .build()
-        .wrap_err_with(|| "Couldn't build reqwest client!")?;
-
-    debug!("Making request to {}", req.url());
-    let resp = REQWEST_CLIENT
-        .execute(req)
-        .await
-        .wrap_err_with(|| "Couldn't make request for rory!")?;
-
-    let status = resp.status();
-
-    if let StatusCode::OK = status {
-        let data = resp
-            .json::<RoryResponse>()
-            .await
-            .wrap_err_with(|| "Couldn't parse the rory response!")?;
-
-        Ok(data)
-    } else {
-        Err(eyre!(
-            "Failed to get rory from {RORY}{ENDPOINT}/{target} with {status}",
-        ))
-    }
+	let target = id.map(|id| id.to_string()).unwrap_or_default();
+
+	let req = REQWEST_CLIENT
+		.get(format!("{RORY}{ENDPOINT}/{target}"))
+		.build()
+		.wrap_err_with(|| "Couldn't build reqwest client!")?;
+
+	debug!("Making request to {}", req.url());
+	let resp = REQWEST_CLIENT
+		.execute(req)
+		.await
+		.wrap_err_with(|| "Couldn't make request for rory!")?;
+
+	let status = resp.status();
+
+	if let StatusCode::OK = status {
+		let data = resp
+			.json::<RoryResponse>()
+			.await
+			.wrap_err_with(|| "Couldn't parse the rory response!")?;
+
+		Ok(data)
+	} else {
+		Err(eyre!(
+			"Failed to get rory from {RORY}{ENDPOINT}/{target} with {status}",
+		))
+	}
 }

src/commands/general/joke.rs

@@ -6,8 +6,8 @@ use color_eyre::eyre::Result;
 /// It's a joke
 #[poise::command(slash_command, prefix_command)]
 pub async fn joke(ctx: Context<'_>) -> Result<()> {
-    let joke = dadjoke::get_joke().await?;
+	let joke = dadjoke::get_joke().await?;
 
-    ctx.reply(joke).await?;
-    Ok(())
+	ctx.reply(joke).await?;
+	Ok(())
 }

src/commands/general/members.rs

@@ -5,22 +5,22 @@ use color_eyre::eyre::{eyre, Result};
 /// Returns the number of members in the server
 #[poise::command(slash_command, prefix_command)]
 pub async fn members(ctx: Context<'_>) -> Result<()> {
-    let guild = ctx.guild().ok_or_else(|| eyre!("Couldn't fetch guild!"))?;
+	let guild = ctx.guild().ok_or_else(|| eyre!("Couldn't fetch guild!"))?;
 
-    let count = guild.member_count;
-    let online = if let Some(count) = guild.approximate_presence_count {
-        count.to_string()
-    } else {
-        "Undefined".to_string()
-    };
+	let count = guild.member_count;
+	let online = if let Some(count) = guild.approximate_presence_count {
+		count.to_string()
+	} else {
+		"Undefined".to_string()
+	};
 
-    ctx.send(|m| {
-        m.embed(|e| {
-            e.title(format!("{count} total members!"))
-                .description(format!("{online} online members"))
-                .color(consts::COLORS["blue"])
-        })
-    })
-    .await?;
-    Ok(())
+	ctx.send(|m| {
+		m.embed(|e| {
+			e.title(format!("{count} total members!"))
+				.description(format!("{online} online members"))
+				.color(consts::COLORS["blue"])
+		})
+	})
+	.await?;
+	Ok(())
 }

src/commands/general/ping.rs

@@ -5,6 +5,6 @@ use color_eyre::eyre::Result;
 /// Replies with pong!
 #[poise::command(slash_command, prefix_command, ephemeral)]
 pub async fn ping(ctx: Context<'_>) -> Result<()> {
-    ctx.reply("Pong!").await?;
-    Ok(())
+	ctx.reply("Pong!").await?;
+	Ok(())
 }