Refactored the main() function

[evpf.git] / src / main.rs

diff --git a/src/main.rs b/src/main.rs
index bab1e52..d237193 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,8 +1,8 @@
 use std::io;
 use std::io::Write;
 use regex::Regex;
-use ansi_term::Colour;
-use ansi_term::Style;
+use colored::*;
+use std::env;
 
 const ILLEGAL_EXP : &'static str = "Illegal Expression";
 const ERR_PARSING_NOT_MATCH : &'static str = "Error parsing expression! \
@@ -11,13 +11,12 @@ const ERR_POSTFIX_INCOMPLETE : &'static str = "Postfix expression incomplete!";
 const ERR_FLUSHING : &'static str = "Error flushing!";
 const ERR_READING_LINE : &'static str = "Error reading line!";
 const HELP_TEXT : [&str ; 4] = 
-                               ["Type an expression in postfix style to evaluate.",
+                               ["Type a postfix expression to evaluate.",
                                 "Example: 4 5 + 12 -",
                                 "Supported operators: +, -, *, /",
                                 "Type q, Q to quit"
                                 ];
 
-const RESULT : &'static str = "Result";
 const ERROR : &'static str = "Error";
 const ERROR_HELP : &'static str = "Type ? or h or H for help";
 
@@ -133,15 +132,43 @@ fn evaluate (expr : &str, match_num : &regex::Regex) -> Result<f32,String> {
        }
 }
 
-fn main() {
+// Single command mode - command line arguments mode - evaluate the expression
+// given in the command line and quit
+fn run_command_line (args : &Vec<String>, match_num : &regex::Regex) {
+       let mut expr = String::new ();
+       let mut i = 0;
+       // create the expression string to evaluate
+       for arg in args.iter() {
+               if i > 0 {
+                       expr.push_str (&arg);
+                       expr.push_str (" ");
+               }
+               i += 1;
+       }
+       // evaluate the result 
+       let res = evaluate (&expr, &match_num);
+       // if Result is OK then print the result in green
+       if res.is_ok () {
+               let restxt = format! ("{}", res.unwrap());
+               println! ("{}", restxt.green ());
+       } else {
+       // print the error in purple
+               let errtxt = format! ("{}: {}", ERROR, 
+                                                                               res.unwrap_err());
+               eprintln! ("{}", errtxt.purple ());
+       }
+}
+
+// Interactive mode - display the prompt and evaluate expressions entered into
+// the prompt - until user quits
+fn run_interactive_mode (match_num : &regex::Regex) {
        // get a line from input and evaluate it 
        let mut expr = String::new ();
-       // regular expression to match a number 
-       let match_num = Regex::new (r"^\d+?\.*?\d*?$").unwrap ();
+
        // loop until a blank line is received  
        loop {
                expr.clear ();  
-               print!("{}", Style::new().bold().paint("evpf>"));
+               print!("{}", "evpf>".bold() );
                io::stdout().flush ().expect (ERR_FLUSHING);
                // read a line of text
                io::stdin().read_line (&mut expr).expect (ERR_READING_LINE);
@@ -154,7 +181,7 @@ fn main() {
                } else if expr == "?" || expr == "h" || expr == "H" {
                // display help text
                        for text in HELP_TEXT.iter() {
-                               println! ("{}", Colour::Cyan.paint(*text));
+                               println! ("{}", text.cyan() );
                        }
 
                        continue;
@@ -168,15 +195,34 @@ fn main() {
                
                // if Result is OK then print the result in green
                if res.is_ok () {
-                       let restxt = format! ("{}: {}", RESULT, 
-                                                                                       res.unwrap());
-                       println! ("{}", Colour::Green.paint (restxt));
+                       let restxt = format! ("{}", res.unwrap());
+                       println! ("{}", restxt.green ());
                } else {
                // print the error in purple
                        let errtxt = format! ("{}: {}", ERROR, 
                                                                                        res.unwrap_err());
-                       eprintln! ("{}", Colour::Purple.paint (errtxt));
-                       eprintln! ("{}", Colour::Purple.paint (ERROR_HELP));
+                       eprintln! ("{}", errtxt.purple());
+                       eprintln! ("{}", ERROR_HELP.purple());
                }
        }
 }
+
+fn main() {
+       // collect the command line arguments - if any 
+       let args : Vec<String> = env::args().collect ();
+       // regular expression to match a number 
+       let match_num = Regex::new (r"^\d+?\.*?\d*?$").unwrap ();
+       
+       if args.len () > 1 {
+       // if arguments are provided run in command line mode - i.e. print the 
+       // result and exit      
+               run_command_line (&args, &match_num);
+               
+       } else {
+               // if arguments are not provided run in interactive mode - 
+               // display a prompt and get the expression 
+               // repeat until the user quits
+               run_interactive_mode (&match_num);
+
+       }
+}