1 files changed, 48 insertions, 38 deletions

diff --git a/src/commands/roll.rs b/src/commands/roll.rs
index 5f5ff6d..6aefe34 100644
--- a/src/commands/roll.rs
+++ b/src/commands/roll.rs
@@ -7,23 +7,26 @@ use log::{
 use rand::prelude::*;
 use serenity::{
     framework::standard::{
-        Args,
         macros::command,
+        Args,
     },
     model::channel::Message,
     prelude::*,
 };
-use statrs;
 use thiserror::Error;
 
 use lazy_static::lazy_static;
-
-use crate::{
-    Result,
-    util::CtxExt,
+use serenity::{
+    framework::standard::{
+        CommandError,
+        CommandResult,
+    },
+    futures::TryFutureExt,
 };
 
-#[derive(Parser)]
+use crate::util;
+
+#[derive(pest_derive::Parser)]
 #[grammar = "commands/calc.pest"]
 struct Calc;
 
@@ -42,9 +45,12 @@ pub(crate) enum CalcError {
 impl Calc {
     fn eval<S: AsRef<str>>(s: S) -> StdResult<f64, CalcError> {
         use pest::{
-            Parser,
+            iterators::{
+                Pair,
+                Pairs,
+            },
             prec_climber::PrecClimber,
-            iterators::{Pair, Pairs},
+            Parser,
         };
 
         use self::Rule::*;
@@ -52,12 +58,14 @@ impl Calc {
         lazy_static! {
             static ref CLIMBER: PrecClimber<self::Rule> = {
                 use pest::prec_climber::{
-                    Operator,
                     Assoc::*,
+                    Operator,
                 };
 
                 PrecClimber::new(vec![
-                    Operator::new(add, Left) | Operator::new(sub, Left) | Operator::new(modulo, Left),
+                    Operator::new(add, Left)
+                        | Operator::new(sub, Left)
+                        | Operator::new(modulo, Left),
                     Operator::new(mul, Left) | Operator::new(div, Left),
                     Operator::new(dice, Left),
                     Operator::new(pow, Right),
@@ -77,7 +85,8 @@ impl Calc {
                         _ => unreachable!(),
                     };
 
-                    u64::from_str_radix(&pair.as_str()[2..], base).map_err(|_| CalcError::NumberFormat)? as f64
+                    u64::from_str_radix(&pair.as_str()[2..], base)
+                        .map_err(|_| CalcError::NumberFormat)? as f64
                 },
                 float => pair.as_str().parse::<f64>().map_err(|_| CalcError::NumberFormat)?,
                 expr | num => eval_expr(pair.into_inner())?,
@@ -151,32 +160,29 @@ impl Calc {
         }
 
         fn eval_expr(p: Pairs<self::Rule>) -> StdResult<f64, CalcError> {
-            CLIMBER.climb(
-                p,
-                eval_single_pair,
-                |lhs, op, rhs| {
-                    let lhs = lhs?;
-                    let rhs = rhs?;
+            CLIMBER.climb(p, eval_single_pair, |lhs, op, rhs| {
+                let lhs = lhs?;
+                let rhs = rhs?;
 
-                    let result = match op.as_rule() {
-                        add => lhs + rhs,
-                        sub => lhs - rhs,
-                        mul => lhs * rhs,
-                        div => lhs / rhs,
-                        pow => lhs.powf(rhs),
-                        dice => {
-                            let dice_count = lhs as usize;
-                            let dice_faces = rhs as usize;
+                let result = match op.as_rule() {
+                    add => lhs + rhs,
+                    sub => lhs - rhs,
+                    mul => lhs * rhs,
+                    div => lhs / rhs,
+                    pow => lhs.powf(rhs),
+                    dice => {
+                        let dice_count = lhs as usize;
+                        let dice_faces = rhs as usize;
 
-                            let mut rng = thread_rng();
-                            (0..dice_count).map(|_| rng.gen_range(1, dice_faces + 1)).sum::<usize>() as f64
-                        },
-                        _ => unreachable!(),
-                    };
+                        let mut rng = thread_rng();
+                        (0..dice_count).map(|_| rng.gen_range(1..(dice_faces + 1))).sum::<usize>()
+                            as f64
+                    },
+                    _ => unreachable!(),
+                };
 
-                    Ok(result)
-                }
-            )
+                Ok(result)
+            })
         }
 
         eval_expr(result)
@@ -208,15 +214,19 @@ mod test {
 
 #[command]
 #[aliases("calc", "calculate")]
-pub fn roll(ctx: &mut Context, msg: &Message, args: Args) -> Result<()> {
+pub async fn roll(ctx: &Context, msg: &Message, args: Args) -> CommandResult {
     match Calc::eval(args.rest()) {
         Ok(result) => {
             debug!("got calc result '{}'", result);
-            ctx.send(msg.channel_id, &format!("{}", result), msg.tts)
+            util::send(ctx, msg.channel_id, &format!("{}", result), msg.tts)
+                .map_err(CommandError::from)
+                .await
         },
         Err(e) => {
             error!("error encountered reading calc '{}': {}", args.rest(), e);
-            ctx.send(msg.channel_id, "I COULDN'T READ THAT YOU FUCK", msg.tts)
+            util::send(ctx, msg.channel_id, "I COULDN'T READ THAT YOU FUCK", msg.tts)
+                .map_err(CommandError::from)
+                .await
         },
     }
 }