Add Godbolt command

Author: kangalio

Cargo.lock

@@ -12,10 +12,12 @@ serenity = { version = "0.8.7", features = ["model"] }
 diesel = { version = "1.4.0", features = ["postgres", "r2d2"] }
 diesel_migrations = { version = "1.4.0", features = ["postgres"] }
 reqwest = { version = "0.10", features = ["blocking", "json"] }
-serde = "1.0"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
 serde_derive = "1.0"
 lazy_static = "1.4.0"
 log = "0.4.0"
 env_logger = "0.7.1"
 envy = "0.4"
 indexmap = "1.6"
+strip-ansi-escapes = "0.1.0" # For normalizing godbolt responses

Cargo.toml

@@ -0,0 +1,63 @@
+pub enum Compilation {
+    Success { asm: String },
+    Error { stderr: String },
+}
+
+#[derive(Debug, serde::Deserialize)]
+struct GodboltOutputSegment {
+    text: String,
+}
+
+#[derive(Debug, serde::Deserialize)]
+struct GodboltOutput(Vec<GodboltOutputSegment>);
+
+impl GodboltOutput {
+    pub fn full_with_ansi_codes_stripped(&self) -> Result<String, crate::Error> {
+        let mut complete_text = String::new();
+        for segment in self.0.iter() {
+            complete_text.push_str(&segment.text);
+            complete_text.push_str("\n");
+        }
+        Ok(String::from_utf8(strip_ansi_escapes::strip(
+            complete_text.trim(),
+        )?)?)
+    }
+}
+
+#[derive(Debug, serde::Deserialize)]
+struct GodboltResponse {
+    code: u8,
+    stdout: GodboltOutput,
+    stderr: GodboltOutput,
+    asm: GodboltOutput,
+}
+
+/// Compile a given Rust source code file on Godbolt using the latest nightly compiler with
+/// full optimizations (-O3)
+/// Returns a multiline string with the pretty printed assembly
+pub fn compile_rust_source(
+    http: &reqwest::blocking::Client,
+    source_code: &str,
+) -> Result<Compilation, crate::Error> {
+    let response: GodboltResponse = http
+        .execute(
+            http.post("https://godbolt.org/api/compiler/nightly/compile")
+                .query(&[("options", "-Copt-level=3")])
+                .header(reqwest::header::ACCEPT, "application/json")
+                .body(source_code.to_owned())
+                .build()?,
+        )?
+        .json()?;
+
+    dbg!(&response);
+
+    Ok(if response.code == 0 {
+        Compilation::Success {
+            asm: response.asm.full_with_ansi_codes_stripped()?,
+        }
+    } else {
+        Compilation::Error {
+            stderr: response.stderr.full_with_ansi_codes_stripped()?,
+        }
+    })
+}

src/godbolt.rs

@@ -13,6 +13,7 @@ mod command_history;
 mod commands;
 mod crates;
 mod db;
+mod godbolt;
 mod jobs;
 mod playground;
 mod schema;
@@ -147,6 +148,34 @@ fn app() -> Result<(), Error> {
         });
     }
 
+    cmds.add("?godbolt ```\ncode```", |args| {
+        let code = args
+            .params
+            .get("code")
+            .ok_or("Unable to retrieve param: code")?;
+        let (lang, text) = match godbolt::compile_rust_source(args.http, code)? {
+            godbolt::Compilation::Success { asm } => ("x86asm", asm),
+            godbolt::Compilation::Error { stderr } => ("rust", stderr),
+        };
+
+        reply_potentially_long_text(
+            &args,
+            &format!("```{}\n{}", lang, text),
+            "\n```",
+            "Note: the output was truncated",
+        )?;
+
+        Ok(())
+    });
+    cmds.help("?godbolt", "View assembly using Godbolt", |args| {
+        api::send_reply(
+            &args,
+            "Compile Rust code using https://rust.godbolt.org. Full optimizations are applied. \
+            ```?godbolt ``\u{200B}`code``\u{200B}` ```",
+        )?;
+        Ok(())
+    });
+
     // Slow mode.
     // 0 seconds disables slowmode
     cmds.add_protected("?slowmode {channel} {seconds}", api::slow_mode, api::is_mod);
@@ -201,6 +230,40 @@ fn app() -> Result<(), Error> {
     Ok(())
 }
 
+/// Send a Discord reply message and truncate the message with a given truncation message if the
+/// text is too long.
+///
+/// Only `text_body` is truncated. `text_end` will always be appended at the end. This is useful
+/// for example for large code blocks. You will want to truncate the code block contents, but the
+/// finalizing \`\`\` should always stay - that's what `text_end` is for.
+fn reply_potentially_long_text(
+    args: &Args,
+    text_body: &str,
+    text_end: &str,
+    truncation_msg: &str,
+) -> Result<(), Error> {
+    let msg = if text_body.len() + text_end.len() > 2000 {
+        // This is how long the text body may be at max to conform to Discord's limit
+        let available_space = 2000 - text_end.len() - truncation_msg.len();
+
+        let mut cut_off_point = available_space;
+        while !text_body.is_char_boundary(cut_off_point) {
+            cut_off_point -= 1;
+        }
+
+        format!(
+            "{}{}{}",
+            &text_body[..cut_off_point],
+            text_end,
+            truncation_msg
+        )
+    } else {
+        format!("{}{}", text_body, text_end)
+    };
+
+    api::send_reply(args, &msg)
+}
+
 fn main_menu(args: &Args, commands: &IndexMap<&str, (&str, GuardFn)>) -> String {
     let mut menu = commands.iter().fold(
         "Commands:\n".to_owned(),