Merge pull request #51 from Ma27/exp-and-round

Add functions `exp()`, `exp2()` & `round()`; fix minor readline issues

3 files changed, 81 insertions, 17 deletions

diff --git a/src/lex.rs b/src/lex.rs
index 76f61a0..1220a1f 100644
--- a/src/lex.rs
+++ b/src/lex.rs
@@ -101,6 +101,9 @@ lazy_static! {
         m.insert("acsc",  Function::token_from_fn("acsc".into(),  |x| (1./x).asin()));
         m.insert("asec",  Function::token_from_fn("asec".into(),  |x| (1./x).acos()));
         m.insert("acot",  Function::token_from_fn("acot".into(),  |x| (1./x).atan()));
+        m.insert("exp",   Function::token_from_fn("exp".into(),   |x| x.exp()));
+        m.insert("exp2",  Function::token_from_fn("exp2".into(),  |x| x.exp2()));
+        m.insert("round", Function::token_from_fn("round".into(), |x| x.round()));
         // single arg function s can be added here
         m
     };
@@ -134,19 +137,29 @@ pub fn lexer(input: &str, prev_ans: Option<f64>) -> Result<Vec<Token>, CalcError
             '0'..='9' | '.' => {
                 if !char_vec.is_empty() {
                     if FUNCTIONS.get(&char_vec[..]).is_some() {
-                        return Err(CalcError::Syntax(format!(
-                            "Function '{}' expected parentheses",
-                            char_vec
-                        )));
+                        char_vec.push(letter);
+                        if !FUNCTIONS.get(&char_vec[..]).is_some() {
+                            return Err(CalcError::Syntax(format!(
+                                "Function '{}' expected parentheses",
+                                &char_vec[..char_vec.chars().count()-1]
+                            )));
+                        }
+                    } else if CONSTANTS.get(&char_vec[..]).is_some() {
+                        result.push(CONSTANTS.get(&char_vec[..]).unwrap().clone());
+                        result.push(OPERATORS.get(&'*').unwrap().clone());
+                        char_vec.clear();
+                        num_vec.push(letter);
+                        last_char_is_op = false;
                     } else {
                         return Err(CalcError::Syntax(format!(
                             "Unexpected character '{}'",
                             char_vec
                         )));
                     }
+                } else {
+                    num_vec.push(letter);
+                    last_char_is_op = false;
                 }
-                num_vec.push(letter);
-                last_char_is_op = false;
             }
             '_' => {
                 if prev_ans.is_none() {
diff --git a/src/main.rs b/src/main.rs
index 75c33bb..e6a865e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -259,4 +259,35 @@ mod tests {
         let evaled = eval_math_expression("9 + _ ", Some(0f64)).unwrap();
         assert_eq!(9., evaled);
     }
+    #[test]
+    fn eval_const_multiplication() {
+        let evaled = eval_math_expression("e2", None).unwrap();
+        assert_eq!(5.4365636569, evaled);
+    }
+    #[test]
+    fn eval_round() {
+        let evaled = eval_math_expression("round(0.5)+round(2.4)", None).unwrap();
+        assert_eq!(3., evaled);
+    }
+    #[test]
+    fn eval_exp2() {
+        assert_eq!(
+            256.,
+            eval_math_expression("exp2(8)", None).unwrap()
+        );
+    }
+    #[test]
+    fn eval_exp() {
+        assert_eq!(
+            20.0855369232 as f64,
+            eval_math_expression("exp(3)", None).unwrap()
+        );
+    }
+    #[test]
+    fn eval_e_times_n() {
+        assert_eq!(
+            0. as f64,
+            eval_math_expression("e0", None).unwrap()
+        );
+    }
 }
diff --git a/src/readline.rs b/src/readline.rs
index d689f95..8906a4f 100644
--- a/src/readline.rs
+++ b/src/readline.rs
@@ -7,6 +7,7 @@ use rustyline::error::ReadlineError;
 use rustyline::highlight::Highlighter;
 use rustyline::hint::{Hinter, HistoryHinter};
 use rustyline::{Context, Editor, Helper};
+use rustyline::validate::Validator;
 
 use directories::ProjectDirs;
 
@@ -14,6 +15,7 @@ use regex::Regex;
 
 use crate::error::CalcError;
 use crate::eval_math_expression;
+use crate::lex::{CONSTANTS, FUNCTIONS};
 
 pub struct RLHelper {
     completer: FilenameCompleter,
@@ -51,20 +53,34 @@ impl Highlighter for LineHighlighter {
         let op = eval_math_expression(line, prev_ans);
         match op {
             Ok(_) => {
-                let constants = ["e", "pi"];
-                let functions = [
-                    "sin", "cos", "tan", "csc", "sec", "cot", "sinh", "cosh", "tanh", "ln", "log",
-                    "sqrt", "ceil", "floor", "rad", "deg", "abs", "asin", "acos", "atan", "acsc",
-                    "asec", "acot",
-                ];
+                let constants = CONSTANTS.keys();
+                let functions = FUNCTIONS.keys();
                 let ops = Regex::new(r"(?P<o>[\+-/\*%\^!])").unwrap();
                 let mut coloured: String = ops.replace_all(line, "\x1b[35m$o\x1b[0m").into();
 
-                for c in &constants {
-                    coloured = coloured.replace(c, &format!("\x1b[33m{}\x1b[0m", c));
+                for c in constants {
+                    // This regex consists of the following pieces:
+                    // * the constant (`o`) to highlight (to be substituted as `{}` via `format!`),
+                    //   e.g. `e`  or `pi`.
+                    // * (optionally) an ANSI escape-code (`\x1b\[35m`) that is used to highlight
+                    //   a binary operator (e.g. `+`/`-`/...). With this one it is ensured that
+                    //   binary operators are always correctly detected after a constant
+                    //   (see the next bullet-point for why that's needed).
+                    // * the following operator (e.g. `+`/`-`/...), a space or the end
+                    //   of the expression (to highlight e.g. `1+e` correctly). This is
+                    //   required to distinguish a constant in an expression from a function-call,
+                    //   e.g. `e+1` from `exp(1)`, without this matching logic, the `e` from
+                    //   `exp` would be improperly interpreted as constant.
+                    //
+                    // To make sure none of existing highlighting (i.e. highlighting
+                    // of binary operators that happens before) breaks, the escape-codes & operator
+                    // (called `r`) are appended after the highlighted constant.
+                    let re = Regex::new(format!("(?P<o>{})(?P<r>(\x1b\\[35m)?([\\+-/\\*%\\^! ]|$))", c).as_str()).unwrap();
+                    coloured = re.replace_all(&coloured, "\x1b[33m$o\x1b[0m$r").into();
                 }
-                for f in &functions {
-                    coloured = coloured.replace(f, &format!("\x1b[34m{}\x1b[0m", f));
+                for f in functions {
+                    let re = Regex::new(format!("(?P<o>{})(?P<r>(\\(|$))", f).as_str()).unwrap();
+                    coloured = re.replace_all(&coloured, "\x1b[34m$o\x1b[0m$r").into();
                 }
                 Owned(coloured)
             }
@@ -75,6 +91,7 @@ impl Highlighter for LineHighlighter {
 }
 
 impl Highlighter for RLHelper {
+    fn highlight_char(&self, _: &str, _: usize) -> bool { true }
     fn highlight_hint<'h>(&self, hint: &'h str) -> Cow<'h, str> {
         self.highlighter.highlight_hint(hint)
     }
@@ -96,11 +113,14 @@ impl Completer for RLHelper {
 }
 
 impl Hinter for RLHelper {
-    fn hint(&self, line: &str, a: usize, b: &Context) -> Option<String> {
+    type Hint = String;
+    fn hint(&self, line: &str, a: usize, b: &Context) -> Option<Self::Hint> {
         self.hinter.hint(line, a, b)
     }
 }
 
+impl Validator for RLHelper {}
+
 impl Helper for RLHelper {}
 
 pub fn create_readline() -> Editor<RLHelper> {