Add basic scryfall plugin (#78)

* Add basic scryfall plugin
* Update rust to 1.88
* nix flake update (and more Rust 1.88.0)

Author: belak

Cargo.lock

@@ -24,6 +24,7 @@ lazy_static = "1.4"
 rand = "0.8"
 regex = "1.10"
 reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "gzip", "json", "stream"] }
+scryfall = "0.21"
 serde = { version = "1.0", features = ["derive"] }
 sqlx = { version = "0.8", features = ["runtime-tokio", "macros", "migrate", "postgres"] }
 time = { version = "0.3", features = ["formatting"] }

Cargo.toml

@@ -1,4 +1,4 @@
-FROM rust:1.81-bullseye as builder
+FROM rust:1.88-bullseye AS builder
 WORKDIR /usr/src/app
 
 # Workaround to allow arm64 builds to work properly

Dockerfile

@@ -17,7 +17,7 @@
         {
           devShells.default = pkgs.mkShell {
             nativeBuildInputs = [
-              (pkgs.rust-bin.stable."1.81.0".default.override {
+              (pkgs.rust-bin.stable."1.88.0".default.override {
                 extensions = ["rust-src"];
               })
               pkgs.rust-analyzer

flake.lock

@@ -53,6 +53,7 @@ pub async fn load(bot: Arc<Client>) -> Result<Vec<PluginMetadata>> {
         "net_tools",
         "noaa",
         "riddle",
+        "scryfall",
         "introspection",
         "help",
     ];
@@ -140,6 +141,10 @@ pub async fn load(bot: Arc<Client>) -> Result<Vec<PluginMetadata>> {
         ret.push(start_plugin::<plugins::RiddlePlugin>(&bot)?);
     }
 
+    if config.plugin_enabled("scryfall") {
+        ret.push(start_plugin::<plugins::ScryfallPlugin>(&bot)?);
+    }
+
     if config.plugin_enabled("introspection") {
         ret.push(start_plugin::<plugins::IntrospectionPlugin>(&bot)?);
     }

flake.nix

@@ -25,6 +25,9 @@ pub use self::noaa::NoaaPlugin;
 mod riddle;
 pub use self::riddle::RiddlePlugin;
 
+mod scryfall;
+pub use self::scryfall::ScryfallPlugin;
+
 mod introspection;
 pub use self::introspection::IntrospectionPlugin;
 

src/plugin.rs

@@ -0,0 +1,98 @@
+use regex::Regex;
+use scryfall::Card;
+
+use crate::prelude::*;
+
+pub struct ScryfallPlugin {
+    re: Regex,
+}
+
+impl ScryfallPlugin {
+    pub fn new() -> Self {
+        ScryfallPlugin {
+            re: Regex::new(r#"\[\[(.+?)\]\]"#).unwrap(),
+        }
+    }
+}
+
+impl ScryfallPlugin {
+    async fn handle_scryfall(&self, ctx: &Arc<Context>, arg: &str) -> Result<()> {
+        let card = Card::named_fuzzy(arg).await?;
+
+        let card_uri = card.scryfall_uri;
+        let image_uri = card.image_uris.and_then(|uris| uris.png);
+
+        match image_uri {
+            Some(image_uri) => {
+                ctx.mention_reply(&format!("{} ({})", card_uri, image_uri.as_str()))
+                    .await?
+            }
+            None => ctx.mention_reply(&format!("{}", card_uri)).await?,
+        }
+
+        Ok(())
+    }
+
+    async fn handle_privmsg(&self, ctx: &Arc<Context>, msg: &str) -> Result<()> {
+        let captures: Vec<_> = self.re.captures_iter(msg).collect();
+
+        if captures.is_empty() {
+            return Ok(());
+        }
+
+        let mut change_errors = Vec::new();
+
+        // Loop through all captures, adding them to the output.
+        for capture in captures {
+            match self.handle_scryfall(ctx, &capture[1]).await {
+                Ok(_) => {}
+                Err(e) => {
+                    change_errors.push(format!("failed to look up \"{}\": {}", &capture[1], e));
+                }
+            };
+        }
+
+        if !change_errors.is_empty() {
+            ctx.mention_reply(&change_errors.join(", ")).await?;
+        }
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl Plugin for ScryfallPlugin {
+    fn new_from_env() -> Result<Self> {
+        Ok(ScryfallPlugin::new())
+    }
+
+    fn command_metadata(&self) -> Vec<CommandMetadata> {
+        vec![CommandMetadata {
+            name: "scryfall".to_string(),
+            short_help: "usage: scryfall [card name]. gives a link to a card on Scryfall."
+                .to_string(),
+            full_help: "gives a link to a given card on Scryfall if it exists".to_string(),
+        }]
+    }
+
+    async fn run(self, bot: Arc<Client>) -> Result<()> {
+        let mut stream = bot.subscribe();
+
+        while let Ok(ctx) = stream.recv().await {
+            let res = match ctx.as_event() {
+                Ok(Event::Command("scryfall", possible_arg)) => {
+                    match possible_arg.or_else(|| ctx.sender()) {
+                        Some(nick) => self.handle_scryfall(&ctx, nick).await,
+                        None => Err(format_err!("no card name found")),
+                    }
+                }
+                Ok(Event::Message(_, msg)) => self.handle_privmsg(&ctx, msg).await,
+                _ => Ok(()),
+            };
+
+            crate::check_err(&ctx, res).await;
+        }
+
+        Err(format_err!("karma plugin lagged"))
+    }
+}