Merge branch 'dev'

1 files changed, 73 insertions, 58 deletions

diff --git a/src/plugins/currency.rs b/src/plugins/currency.rs
index d6cf928..53a245c 100644
--- a/src/plugins/currency.rs
+++ b/src/plugins/currency.rs
@@ -6,7 +6,6 @@ use std::io::Read;
 use std::num::ParseFloatError;
 
 use irc::client::prelude::*;
-use irc::error::Error as IrcError;
 
 use self::reqwest::Client;
 use self::reqwest::header::Connection;
@@ -14,7 +13,11 @@ use self::serde_json::Value;
 
 use plugin::*;
 
-#[derive(PluginName, Debug)]
+use error::FrippyError;
+use error::ErrorKind as FrippyErrorKind;
+use failure::ResultExt;
+
+#[derive(PluginName, Default, Debug)]
 pub struct Currency;
 
 struct ConvertionRequest<'a> {
@@ -23,18 +26,8 @@ struct ConvertionRequest<'a> {
     target: &'a str,
 }
 
-macro_rules! try_option {
-    ($e:expr) => {
-        match $e {
-            Some(v) => v,
-            None    => { return None; }
-        }
-    }
-}
-
 impl<'a> ConvertionRequest<'a> {
     fn send(&self) -> Option<f64> {
-
         let response = Client::new()
             .get("https://api.fixer.io/latest")
             .form(&[("base", self.source)])
@@ -44,16 +37,14 @@ impl<'a> ConvertionRequest<'a> {
         match response {
             Ok(mut response) => {
                 let mut body = String::new();
-                try_option!(response.read_to_string(&mut body).ok());
+                response.read_to_string(&mut body).ok()?;
 
                 let convertion_rates: Result<Value, _> = serde_json::from_str(&body);
                 match convertion_rates {
                     Ok(convertion_rates) => {
-
-                        let rates: &Value = try_option!(convertion_rates.get("rates"));
-                        let target_rate: &Value =
-                            try_option!(rates.get(self.target.to_uppercase()));
-                        Some(self.value * try_option!(target_rate.as_f64()))
+                        let rates: &Value = convertion_rates.get("rates")?;
+                        let target_rate: &Value = rates.get(self.target.to_uppercase())?;
+                        Some(self.value * target_rate.as_f64()?)
                     }
                     Err(_) => None,
                 }
@@ -68,7 +59,10 @@ impl Currency {
         Currency {}
     }
 
-    fn eval_command<'a>(&self, tokens: &'a [String]) -> Result<ConvertionRequest<'a>, ParseFloatError> {
+    fn eval_command<'a>(
+        &self,
+        tokens: &'a [String],
+    ) -> Result<ConvertionRequest<'a>, ParseFloatError> {
         Ok(ConvertionRequest {
             value: tokens[0].parse()?,
             source: &tokens[1],
@@ -76,76 +70,97 @@ impl Currency {
         })
     }
 
-    fn convert(&self, server: &IrcServer, command: PluginCommand) -> Result<(), IrcError> {
-
+    fn convert(&self, client: &IrcClient, command: &mut PluginCommand) -> Result<String, String> {
         if command.tokens.len() < 3 {
-            return self.invalid_command(server, &command);
+            return Err(self.invalid_command(client));
         }
 
         let request = match self.eval_command(&command.tokens) {
             Ok(request) => request,
             Err(_) => {
-                return self.invalid_command(server, &command);
+                return Err(self.invalid_command(client));
             }
         };
 
         match request.send() {
             Some(response) => {
-                let response = format!("{} {} => {:.4} {}",
-                                       request.value,
-                                       request.source.to_lowercase(),
-                                       response / 1.00000000,
-                                       request.target.to_lowercase());
-
-                server.send_privmsg(&command.target, &response)
+                let response = format!(
+                    "{} {} => {:.4} {}",
+                    request.value,
+                    request.source.to_lowercase(),
+                    response / 1.00000000,
+                    request.target.to_lowercase()
+                );
+
+                Ok(response)
             }
-            None => server.send_notice(&command.source, "Error while converting given currency"),
+            None => Err(String::from(
+                "An error occured during the conversion of the given currency",
+            )),
         }
     }
 
-    fn help(&self, server: &IrcServer, command: &mut PluginCommand) -> Result<(), IrcError> {
-        let help = format!("usage: {} currency value from_currency to_currency\r\n\
-                            example: 1.5 eur usd\r\n\
-                            available currencies: AUD, BGN, BRL, CAD, \
-                            CHF, CNY, CZK, DKK, GBP, HKD, HRK, HUF, \
-                            IDR, ILS, INR, JPY, KRW, MXN, MYR, NOK, \
-                            NZD, PHP, PLN, RON, RUB, SEK, SGD, THB, \
-                            TRY, USD, ZAR",
-                           server.current_nickname());
-
-        server.send_notice(&command.source, &help)
+    fn help(&self, client: &IrcClient) -> String {
+        format!(
+            "usage: {} currency value from_currency to_currency\r\n\
+             example: {0} currency 1.5 eur usd\r\n\
+             available currencies: AUD, BGN, BRL, CAD, \
+             CHF, CNY, CZK, DKK, GBP, HKD, HRK, HUF, \
+             IDR, ILS, INR, JPY, KRW, MXN, MYR, NOK, \
+             NZD, PHP, PLN, RON, RUB, SEK, SGD, THB, \
+             TRY, USD, ZAR",
+            client.current_nickname()
+        )
     }
 
-    fn invalid_command(&self, server: &IrcServer, command: &PluginCommand) -> Result<(), IrcError> {
-        let help = format!("Incorrect Command. \
-                           Send \"{} currency help\" for help.",
-                           server.current_nickname());
-
-        server.send_notice(&command.source, &help)
+    fn invalid_command(&self, client: &IrcClient) -> String {
+        format!(
+            "Incorrect Command. \
+             Send \"{} currency help\" for help.",
+            client.current_nickname()
+        )
     }
 }
 
 impl Plugin for Currency {
-    fn is_allowed(&self, _: &IrcServer, _: &Message) -> bool {
-        false
+    fn execute(&self, _: &IrcClient, _: &Message) -> ExecutionStatus {
+        ExecutionStatus::Done
     }
 
-    fn execute(&self, _: &IrcServer, _: &Message) -> Result<(), IrcError> {
+    fn execute_threaded(&self, _: &IrcClient, _: &Message) -> Result<(), FrippyError> {
         panic!("Currency does not implement the execute function!")
     }
 
-    fn command(&self, server: &IrcServer, mut command: PluginCommand) -> Result<(), IrcError> {
+    fn command(&self, client: &IrcClient, mut command: PluginCommand) -> Result<(), FrippyError> {
+        if command.tokens.is_empty() {
+            return Ok(client
+                .send_notice(&command.source, &self.invalid_command(client))
+                .context(FrippyErrorKind::Connection)?);
+        }
+
+        match command.tokens[0].as_ref() {
+            "help" => Ok(client
+                .send_notice(&command.source, &self.help(client))
+                .context(FrippyErrorKind::Connection)?),
+            _ => match self.convert(client, &mut command) {
+                Ok(msg) => Ok(client
+                    .send_privmsg(&command.target, &msg)
+                    .context(FrippyErrorKind::Connection)?),
+                Err(msg) => Ok(client
+                    .send_notice(&command.source, &msg)
+                    .context(FrippyErrorKind::Connection)?),
+            },
+        }
+    }
 
+    fn evaluate(&self, client: &IrcClient, mut command: PluginCommand) -> Result<String, String> {
         if command.tokens.is_empty() {
-            return self.invalid_command(server, &command);
+            return Err(self.invalid_command(client));
         }
 
         match command.tokens[0].as_ref() {
-            "help" => self.help(server, &mut command),
-            _ => self.convert(server, command),
+            "help" => Ok(self.help(client)),
+            _ => self.convert(client, &mut command),
         }
     }
 }
-
-#[cfg(test)]
-mod tests {}