Add apt package search

src/commands/apt.rs

@@ -0,0 +1,68 @@
+use crate::commands::*;
+use serde::Deserialize;
+use serenity::model::channel::Message;
+use std::fmt;
+
+pub fn query_apt(ctx: Context, msg: Message, args: Vec<&str>) {
+    let query = args.join(" ");
+    let response: Response = search(
+        &format!("https://sources.debian.org/api/src/{}/", &query),
+        EMPTY_RESULT,
+    );
+    if response.versions.len() == 0 {
+        send(msg.channel_id, "No results", &ctx);
+        return;
+    }
+    let packages = convert_versions(response);
+    respond_with_results(msg.channel_id, &packages, &ctx);
+}
+
+fn convert_versions(res: Response) -> Vec<Package> {
+    let mut packages = Vec::new();
+    for version in res.versions {
+        for suite in version.suites {
+            packages.push(Package {
+                area: version.area.clone(),
+                name: res.package.clone(),
+                suite: suite,
+                version: version.version.clone(),
+            });
+        }
+    }
+    packages
+}
+
+const EMPTY_RESULT: Response = Response {
+    package: String::new(),
+    versions: Vec::new(),
+};
+
+#[derive(Deserialize)]
+struct Response {
+    package: String,
+    versions: Vec<Version>,
+}
+
+#[derive(Deserialize)]
+struct Version {
+    area: String,
+    suites: Vec<String>,
+    version: String,
+}
+
+struct Package {
+    area: String,
+    name: String,
+    suite: String,
+    version: String,
+}
+
+impl fmt::Display for Package {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{}/{} {} ({})",
+            self.area, self.name, self.version, self.suite
+        )
+    }
+}

src/commands/mod.rs

@@ -3,11 +3,12 @@ use std::fmt;
 use serenity::model::id::ChannelId;
 use serde::de::DeserializeOwned;
 use serenity::prelude::*;
+mod apt;
 mod pacman;
 extern crate reqwest;
 
 pub struct Handler;
-pub type CommandHandler = dyn Fn(Context, Message);
+pub type CommandHandler = dyn Fn(Context, Message, Vec<&str>);
 struct Command {
     trigger: String,
     handler: Box<CommandHandler>,
@@ -25,7 +26,19 @@ impl EventHandler for Handler {
                 .filter(|&c| msg.content.starts_with(&c.trigger))
                 .next()
             {
-                (*command.handler)(ctx, msg);
+                let content = msg.content.clone();
+                let mut args = content.split_whitespace().collect::<Vec<_>>();
+                // the prefix + trigger
+                args.remove(0);
+                if args.len() == 0 {
+                    send(
+                        msg.channel_id,
+                        "Error: expected at least 1 additional argument",
+                        &ctx,
+                    );
+                    return;
+                }
+                (*command.handler)(ctx, msg, args);
             };
         }
     }
@@ -35,12 +48,13 @@ lazy_static! {
     static ref COMMANDS: Vec<Command> = {
         let mut command_list = Vec::new();
         command_list.push(Command::new("pacman", pacman::query_pacman));
+        command_list.push(Command::new("apt", apt::query_apt));
         command_list
     };
 }
 
 impl Command {
-    pub fn new(trigger: &str, handler: fn(Context, Message)) -> Self {
+    pub fn new(trigger: &str, handler: fn(Context, Message, Vec<&str>)) -> Self {
         let mut trigger_with_prefix = trigger.to_string();
         trigger_with_prefix.insert(0, PREFIX);
         Self {

src/commands/pacman.rs

@@ -1,21 +1,10 @@
 use crate::commands::*;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 use serenity::model::channel::Message;
 use std::fmt;
 
-pub fn query_pacman(ctx: Context, msg: Message) {
-    let mut args = msg.content.split_whitespace().collect::<Vec<_>>();
-    // the !pacman
-    args.remove(0);
-    if args.len() == 0 {
-        send(
-            msg.channel_id,
-            "Error: expected at least 1 additional argument",
-            &ctx,
-        );
-        return;
-    }
-    if args.len() == 1 {
+pub fn query_pacman(ctx: Context, msg: Message, args: Vec<&str>) {
+   if args.len() == 1 {
         // try by full package name
         let response: Response = search(
             &format!(
@@ -46,33 +35,27 @@ pub fn query_pacman(ctx: Context, msg: Message) {
 }
 
 const EMPTY_RESULT: Response = Response {
-    version: 0,
-    limit: 0,
-    valid: false,
     results: Vec::new(),
 };
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Deserialize)]
 struct Response {
-    version: i8,
-    limit: i32,
-    valid: bool,
     results: Vec<Package>,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Deserialize)]
 struct Package {
     pkgname: String,
-    pkgbase: String,
+    //pkgbase: String,
     repo: String,
     pkgver: String,
     pkgdesc: String,
-    url: String,
-    compressed_size: i64,
-    installed_size: i64,
-    build_date: String,
-    last_update: String,
-    flag_date: Option<String>,
+    //url: String,
+    //compressed_size: i64,
+    //installed_size: i64,
+    //build_date: String,
+    //last_update: String,
+    //flag_date: Option<String>,
 }
 
 impl fmt::Display for Package {