Merge remote-tracking branch 'origin/feature/value-regex' into feature/value-regex

erkkikeranen · erkkikeranen · commit ac4136cf8a9a · 2020-05-16T21:50:59.000+03:00
diff --git a/examples/hello_world.clj b/examples/hello_world.clj
@@ -0,0 +1,4 @@
+(defn hello-world[]
+  (println "Hello, world"))
+
+(hello-world)
diff --git a/src/main.rs b/src/main.rs
@@ -23,11 +23,26 @@ mod symbol;
 mod type_tag;
 mod util;
 mod value;
+mod user_action;
 
 fn main() {
-    //
-    // Start repl
-    //
+    let cli_args: user_action::Action = user_action::parse_args( std::env::args().collect() );
+
+    // instantiate the core environment
     let repl = repl::Repl::default();
-    repl.run();
+    
+    match cli_args {
+        // eval the file/script
+        user_action::Action::RunScript(script) => {
+            println!("{}", repl::Repl::eval_file(&repl, script.as_str()));
+        },
+
+        // eval the expression
+        user_action::Action::Evaluate(expression) => {
+            println!("{}", repl::Repl::eval(&repl, &repl::Repl::read_string(&expression)));
+        }, 
+
+        // Start repl
+        user_action::Action::Nothing => { repl.run(); }
+    }
 }
diff --git a/src/reader.rs b/src/reader.rs
@@ -379,68 +379,46 @@ pub fn try_read_string(input: &str) -> IResult<&str, Value> {
 
     let (rest_input, _) = quotation(input)?;
 
+    named!(escaped_string_parser<&str, String >, escaped_transform!(take_till1!(|ch| { ch == '\\' || ch == '\"'}), '\\', alt!(
+        tag!("t")   => { |_| "\t"   } |
+        tag!("b")   => { |_| "\x08" } |
+        tag!("n")   => { |_| "\n"   } |
+        tag!("r")   => { |_| "\r"   } |
+        tag!("f")   => { |_| "\x0C" } |
+        tag!("'")   => { |_| "'"    } |
+        tag!("\"")  => { |_| "\""   } |
+        tag!("\\")  => { |_| "\\"   }
+    )));
+
     named!(
         string_parser<&str, String>,
         map!(
-            terminated!(take_until!("\""), tag("\"")),
+            terminated!(escaped_string_parser, tag("\"")),
             |v| String::from(v)
         )
     );
 
     to_value_parser(string_parser)(rest_input)
 }
 
-/// Tries to parse &str into Value::Pattern
-/// Reader Macro for Regex
-/// Example Successes:
-///    #"this is pretty straightforward" => Value::Pattern("this is pretty straightforward")
 pub fn try_read_pattern(input: &str) -> IResult<&str, Value> {
-    named!(hash_quotation<&str, &str>, preceded!(consume_clojure_whitespaces_parser, tag!("#\"")));
-
-    let (rest_input, _) = hash_quotation(input)?;
-
-    // println!("regexquoted: {:#?}", regex::Regex::quote(rest_input));
-    let mut iterator = rest_input.escape_default();
-    let mut prev: char = iterator.next().unwrap();
-    let mut prev_prev_was_escape = false;
-    let mut is_escaping = false;
-    let mut till_quote: String = String::from(prev.to_string());
-    println!("first char: {:#?}", till_quote);
-    while let ch = iterator.next().unwrap() {
-        if ch == '\\' && prev == '\\' {
-            is_escaping = true;
-        }
-        println!(
-            "LOOP: next char to handle: {:#?} prev: {:#?} is escaping {} and prev prev was escaping {}",
-            ch, prev, is_escaping, prev_prev_was_escape
-        );
-        if ch == '\"' && prev == '\\' && !prev_prev_was_escape {
-            println!(
-                "GONNA END: next char to handle: {:#?} prev: {:#?} is escaping {}",
-                ch, prev, is_escaping
-            );
-            till_quote = till_quote.trim_end_matches("\"").to_string();
-            break;
-        };
-        if ch == '\"' && is_escaping {
-            till_quote = String::from(till_quote + ch.to_string().as_str());
-        } else if ch != '\\' {
-            till_quote = String::from(till_quote + ch.to_string().as_str());
-            //is_escaping = false;
-            prev_prev_was_escape = false;
-        }
-        prev_prev_was_escape = is_escaping;
-        prev = ch;
+    named!(hash_parser<&str, &str>, preceded!(consume_clojure_whitespaces_parser, tag!("#")));
+
+    let (rest_input, _) = hash_parser(input)?; 
+    let (rest_input,regex_string_val) = try_read_string(rest_input)?;
+
+    let mut regex_string = String::from("");
+
+    // @TODO separate try_read_string into a parser, so we don't have to read a Value
+    // and then unwrap it 
+    match regex_string_val {
+        Value::String(reg_str) => { regex_string = reg_str; },
+        _ => { panic!("try_read_string returned something that wasn't string"); }
     }
-    println!("till quote: {} {:#?}", till_quote, till_quote);
-    let to_trim = till_quote.to_owned() + "\"";
-    println!(
-        "rest input trimmed: {}",
-        rest_input.trim_start_matches(&to_trim)
-    );
-    let regex = regex::Regex::new(till_quote.as_str()).unwrap();
+
+    let regex = regex::Regex::new(regex_string.as_str()).unwrap();
     Ok((
-        rest_input.trim_start_matches(&to_trim),
+        rest_input,
         Value::Pattern(regex),
     ))
 }
@@ -921,7 +899,50 @@ mod tests {
             }
         }
     }
+    mod regex_tests {
+        use crate::reader::try_read;
+        use crate::value::Value;
+
+        #[test]
+        fn try_read_simple_regex_pattern_test() {
+            assert_eq!(
+                Value::Pattern(regex::Regex::new("a").unwrap()),
+                try_read(r###"#"a" "###).ok().unwrap().1
+            );
+        }
+
+        #[test]
+        fn try_read_regex_pattern_test() {
+            assert_eq!(
+                Value::Pattern(regex::Regex::new("hello").unwrap()),
+                try_read("#\"hello\" ").ok().unwrap().1
+            );
+        }
+
+        #[test]
+        fn try_read_regex_pattern_escaped_quote_test() {
+            assert_eq!(
+                Value::Pattern(regex::Regex::new("h\"e\"l\"l\"o\"").unwrap()),
+                try_read(r#"#"h\"e\"l\"l\"o\"" something"#).ok().unwrap().1
+            );
+        }
+
+        #[test]
+        fn try_read_regex_pattern_escaped_quote_prefixed_by_whitespace_test() {
+            assert_eq!(
+                Value::Pattern(regex::Regex::new("h\"e\"l\"l \"o").unwrap()),
+                try_read(r#"#"h\"e\"l\"l \"o""#).ok().unwrap().1
+            );
+        }
 
+        #[test]
+        fn try_read_regex_pattern_escaped_quote_suffixed_by_whitespace_test() {
+            assert_eq!(
+                Value::Pattern(regex::Regex::new("h\"e\"l\" l \"o").unwrap()),
+                try_read(r#"#"h\"e\"l\" l \"o" something"#).ok().unwrap().1
+            );
+        }
+    }
     mod consume_clojure_whitespaces_tests {
         use crate::reader::consume_clojure_whitespaces_parser;
         #[test]
diff --git a/src/repl.rs b/src/repl.rs
@@ -6,8 +6,7 @@ use std::io::Write;
 
 use crate::environment::Environment;
 use crate::reader;
-use crate::value::Evaluable;
-use crate::value::Value;
+use crate::value::{Value,Evaluable,ToValue};
 use std::rc::Rc;
 
 pub struct Repl {
@@ -84,6 +83,9 @@ impl Repl {
             last_val = Repl::read(&mut reader);
         }
     }
+    pub fn eval_file(&self, filepath: &str) -> Value {
+        self.try_eval_file(filepath).to_value()
+    }
 }
 
 impl Default for Repl {
diff --git a/src/user_action.rs b/src/user_action.rs
@@ -0,0 +1,83 @@
+use std::fmt;
+
+#[derive(PartialEq,Eq)]
+pub enum Action{
+    RunScript(String),
+    Evaluate(String),
+    Nothing,  
+}
+
+impl fmt::Debug for Action {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match &*self {
+            Action::RunScript(filepath) => write!(f, "RunScript: {}", filepath),
+            Action::Evaluate(expression) => write!(f, "Evaluate: {}", expression),
+            Action::Nothing => write!(f, "Nothing"),
+        }
+    }
+}
+
+pub fn parse_args(arguments: Vec<String>) -> Action{
+
+    if arguments.len() >= 2 {
+        if arguments[1] == "-i" || arguments[1] == "--init" {
+            return Action::RunScript(arguments[2].clone());
+        }else if arguments[1] == "-e" || arguments[1] == "--eval" {
+            return Action::Evaluate(arguments[2].clone());
+        }else { Action::RunScript(arguments[1].clone()) } // for path as argument
+    }else {
+        return Action::Nothing;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    mod parse_args_test {
+        use crate::user_action;
+
+        #[test]
+        fn parses_args_given_path() {
+            let arguments = vec!["target/debug/rust_clojure".to_string(), "examples/hello_world.clj".to_string()];
+            assert_eq!(user_action::Action::RunScript("examples/hello_world.clj".to_string()),
+                       user_action::parse_args(arguments));
+        }
+
+        #[test]
+        fn parses_args_given_i() {
+            let arguments = vec!["target/debug/rust_clojure".to_string(), "-i".to_string(), "test.clj".to_string()];
+            
+            assert_eq!(user_action::Action::RunScript("test.clj".to_string()),
+                       user_action::parse_args(arguments));
+        }
+
+        #[test]
+        fn parses_args_given_init() {
+            let arguments = vec!["target/debug/rust_clojure".to_string(), "--init".to_string(), "testing.clj".to_string()];
+            
+            assert_eq!(user_action::Action::RunScript("testing.clj".to_string()),
+                       user_action::parse_args(arguments));
+        }
+
+        #[test]
+        fn parses_args_given_e() {
+            let arguments = vec!["target/debug/rust_clojure".to_string(), "-e".to_string(), "(+ 1 2 3)".to_string()];
+            
+            assert_eq!(user_action::Action::Evaluate("(+ 1 2 3)".to_string()),
+                       user_action::parse_args(arguments));
+        }
+
+        #[test]
+        fn parses_args_given_eval() {
+            let arguments = vec!["target/debug/rust_clojure".to_string(), "--eval".to_string(), "(println \"eh\")".to_string()];
+            
+            assert_eq!(user_action::Action::Evaluate("(println \"eh\")".to_string()),
+                       user_action::parse_args(arguments));
+        }
+
+        #[test]
+        fn parses_args_given_nil() {
+            assert_eq!(user_action::Action::Nothing, user_action::parse_args(vec!["target/debug/rust_clojure".to_string()]));
+        }
+    }
+}
+
diff --git a/src/value.rs b/src/value.rs
@@ -1,3 +1,4 @@
+use core::fmt::Display;
 use crate::environment::Environment;
 use crate::ifn::IFn;
 use crate::keyword::Keyword;
@@ -623,6 +624,14 @@ impl ToValue for PersistentListMap {
         Value::PersistentListMap(self.clone())
     }
 }
+impl<T: Display> ToValue for Result<Value,T> {
+    fn to_value(&self) -> Value {
+        match self {
+            Ok(val) => val.clone(),
+            Err(err) => Value::Condition(err.to_string())
+        }
+    }
+}
 
 /// Allows a type to be evaluated, abstracts evaluation
 ///

Original file line number	Diff line number	Diff line change
`@@ -6,8 +6,7 @@ use std::io::Write;`
`6`	`6`
`7`	`7`	`use crate::environment::Environment;`
`8`	`8`	`use crate::reader;`
`9`		`-use crate::value::Evaluable;`
`10`		`-use crate::value::Value;`
	`9`	`+use crate::value::{Value,Evaluable,ToValue};`
`11`	`10`	`use std::rc::Rc;`
`12`	`11`
`13`	`12`	`pub struct Repl {`
`@@ -84,6 +83,9 @@ impl Repl {`
`84`	`83`	`last_val = Repl::read(&mut reader);`
`85`	`84`	`}`
`86`	`85`	`}`
	`86`	`+ pub fn eval_file(&self, filepath: &str) -> Value {`
	`87`	`+ self.try_eval_file(filepath).to_value()`
	`88`	`+ }`
`87`	`89`	`}`
`88`	`90`
`89`	`91`	`impl Default for Repl {`