success compilation command

Author: kingananas20

src/bin/main.rs

@@ -32,6 +32,7 @@ async fn main() -> Result<(), Error> {
             commands::miri_code_block(),
             commands::macro_expansion_code_block(),
             commands::clippy_code_block(),
+            commands::compile_code_block(),
             commands::publish(),
             commands::explain(),
             commands::krate(),

src/commands/cargo.rs

@@ -1,6 +1,7 @@
 mod clippy;
 mod code_block;
 mod common;
+mod compile;
 mod crates;
 mod file;
 mod gist;
@@ -12,6 +13,7 @@ mod run;
 mod version;
 
 pub use clippy::clippy_code_block;
+pub use compile::compile_code_block;
 pub use macro_expansion::macro_expansion_code_block;
 pub use miri::miri_code_block;
 pub use publish::publish;

src/commands/cargo/clippy.rs

@@ -72,18 +72,20 @@ async fn clippy_file(
 fn parse_clippy(input: &str) -> ClippyRequest<'_> {
     let mut req = ClippyRequest::default();
 
-    input.split_whitespace().for_each(|arg| match arg {
-        "stable" => req.channel = Channel::Stable,
-        "beta" => req.channel = Channel::Beta,
-        "nightly" => req.channel = Channel::Nightly,
-        "bin" => req.crate_type = CrateType::Binary,
-        "lib" => req.crate_type = CrateType::Library,
-        "2015" => req.edition = Edition::Edition2015,
-        "2018" => req.edition = Edition::Edition2018,
-        "2021" => req.edition = Edition::Edition2021,
-        "2024" => req.edition = Edition::Edition2024,
-        _ => {}
-    });
+    input
+        .split_whitespace()
+        .for_each(|arg| match arg.to_lowercase().as_str() {
+            "stable" => req.channel = Channel::Stable,
+            "beta" => req.channel = Channel::Beta,
+            "nightly" => req.channel = Channel::Nightly,
+            "bin" => req.crate_type = CrateType::Binary,
+            "lib" => req.crate_type = CrateType::Library,
+            "2015" => req.edition = Edition::Edition2015,
+            "2018" => req.edition = Edition::Edition2018,
+            "2021" => req.edition = Edition::Edition2021,
+            "2024" => req.edition = Edition::Edition2024,
+            _ => {}
+        });
 
     req
 }

src/commands/cargo/code_block.rs

@@ -21,6 +21,7 @@ where
     req.with_code(code);
 
     let res: Res = ctx.data().playground_client.post(&req).await?;
+    println!("{res:?}");
     let out = res.output();
 
     let bot_res = BotResponse::new(&out, "code_block", None, tool_name);

src/commands/cargo/compile.rs

@@ -0,0 +1,104 @@
+use crate::{Context, Error};
+use playground_api::endpoints::{
+    AssemblyFlavor, Channel, CompileRequest, CompileResponse, CompileTarget, CrateType,
+    DemangleAssembly, Edition, Mode, ProcessAssembly,
+};
+use std::borrow::Cow;
+
+const COMPILE_RES: CompileResponse = CompileResponse {
+    success: false,
+    stdout: Cow::Borrowed(""),
+    stderr: Cow::Borrowed(""),
+    exit_detail: Cow::Borrowed(""),
+    code: Cow::Borrowed(""),
+};
+
+#[poise::command(
+    prefix_command,
+    slash_command,
+    rename = "compile",
+    category = "cargo",
+    subcommands("compile_gist", "compile_file"),
+    broadcast_typing,
+    track_edits
+)]
+pub async fn compile_code_block(ctx: Context<'_>, #[rest] input: String) -> Result<(), Error> {
+    super::code_block(ctx, &input, parse_compile, true, COMPILE_RES, "compile").await
+}
+
+#[poise::command(
+    slash_command,
+    rename = "gist",
+    category = "cargo",
+    member_cooldown = 60
+)]
+async fn compile_gist(ctx: Context<'_>) -> Result<(), Error> {
+    Ok(())
+}
+
+#[poise::command(
+    slash_command,
+    rename = "gist",
+    category = "cargo",
+    member_cooldown = 60
+)]
+async fn compile_file(ctx: Context<'_>) -> Result<(), Error> {
+    Ok(())
+}
+
+fn parse_compile(input: &str) -> CompileRequest<'_> {
+    let mut req = CompileRequest::default();
+
+    input
+        .split_whitespace()
+        .for_each(|arg| match arg.to_lowercase().as_str() {
+            "asm" | "assembly" => req.target = CompileTarget::Assembly,
+            "hir" => req.target = CompileTarget::Hir,
+            "llvmir" => req.target = CompileTarget::LlvmIr,
+            "mir" => req.target = CompileTarget::Mir,
+            "wasm" => req.target = CompileTarget::Wasm,
+            "att" => req.assembly_flavor = Some(AssemblyFlavor::Att),
+            "intel" => req.assembly_flavor = Some(AssemblyFlavor::Intel),
+            "demangle" => req.demangle_assembly = Some(DemangleAssembly::Demangle),
+            "mangle" => req.demangle_assembly = Some(DemangleAssembly::Mangle),
+            "filter" => req.process_assembly = Some(ProcessAssembly::Filter),
+            "raw" => req.process_assembly = Some(ProcessAssembly::Raw),
+            "stable" => req.channel = Channel::Stable,
+            "beta" => req.channel = Channel::Beta,
+            "nightly" => req.channel = Channel::Nightly,
+            "debug" => req.mode = Mode::Debug,
+            "release" | "-r" => req.mode = Mode::Release,
+            "2015" => req.edition = Edition::Edition2015,
+            "2018" => req.edition = Edition::Edition2018,
+            "2021" => req.edition = Edition::Edition2021,
+            "2024" => req.edition = Edition::Edition2024,
+            "binary" | "bin" => req.crate_type = CrateType::Binary,
+            "library" | "lib" => req.crate_type = CrateType::Library,
+            "tests" => req.tests = true,
+            "backtrace" => req.backtrace = true,
+            _ => {}
+        });
+
+    req
+}
+
+impl<'wc> super::WithCode<'wc> for CompileRequest<'wc> {
+    fn with_code(&mut self, code: impl Into<Cow<'wc, str>>) {
+        self.code = code.into();
+    }
+}
+
+impl<'a> super::Output for CompileResponse<'a> {
+    fn success(&self) -> bool {
+        self.success
+    }
+
+    #[expect(clippy::misnamed_getters)]
+    fn stdout(&self) -> &str {
+        &self.code
+    }
+
+    fn stderr(&self) -> &str {
+        &self.stderr
+    }
+}

src/common/separate_cargo.rs

@@ -2,7 +2,7 @@ use regex::Regex;
 use std::sync::LazyLock;
 
 static REGEX: LazyLock<Regex> = LazyLock::new(|| unsafe {
-    Regex::new(r"(?sm)^(.*?^\s*(?:Running|error: could not compile)[^\n]*\n?)(.*)")
+    Regex::new(r"(?sm)^(.*?^\s*(?:Running|error: could not compile|Finished)[^\n]*\n?)(.*)")
         .unwrap_unchecked()
 });