clojure.string/split and split-lines works with regex pattern type

erkkikeranen · erkkikeranen · commit 00ac5970b8d4 · 2020-05-16T23:42:18.000+03:00
diff --git a/src/clojure/string.clj b/src/clojure/string.clj
@@ -0,0 +1,7 @@
+"clojure.string"
+
+"TODO : some special syntax required because of missing require"
+
+(def clojure.string/split-lines
+  (fn [s]
+    (clojure.string/split s #"\r?\n")))
diff --git a/src/clojure_string.rs b/src/clojure_string.rs
@@ -4,6 +4,7 @@ pub(crate) mod includes_qmark_;
 pub(crate) mod join;
 pub(crate) mod lower_case;
 pub(crate) mod reverse;
+pub(crate) mod split;
 pub(crate) mod starts_with_qmark_;
 pub(crate) mod trim;
 pub(crate) mod trim_newline;
diff --git a/src/clojure_string/split.rs b/src/clojure_string/split.rs
@@ -0,0 +1,120 @@
+use crate::ifn::IFn;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+use crate::error_message;
+use crate::persistent_vector::PersistentVector;
+use crate::type_tag::TypeTag;
+
+/// clojure.string/split [s re & [limit]] splits strings by pattern, optionally maximum of limit
+/// amount
+#[derive(Debug, Clone)]
+pub struct SplitFn {}
+impl ToValue for SplitFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for SplitFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 2 && args.len() != 3 {
+            return error_message::wrong_varg_count(&[2, 3], args.len());
+        } else {
+            match (
+                args.get(0).unwrap().to_value(),
+                args.get(1).unwrap().to_value(),
+            ) {
+                (Value::String(s), Value::Pattern(re)) => {
+                    let splits: Vec<Rc<Value>> = re
+                        .split(&s)
+                        .collect::<Vec<&str>>()
+                        .into_iter()
+                        .filter(|ss| !ss.is_empty())
+                        .map(|ss| Rc::new(Value::String(ss.to_string())))
+                        .collect();
+                    return Value::PersistentVector(
+                        splits.into_iter().collect::<PersistentVector>(),
+                    );
+                }
+                (_a, Value::Pattern(_)) => error_message::type_mismatch(TypeTag::String, &_a),
+                (Value::String(_), _b) => error_message::type_mismatch(TypeTag::Pattern, &_b),
+                (_, _) => error_message::unknown_err(String::from("Unknown error")),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    mod split_tests {
+        use crate::clojure_string::split::SplitFn;
+        use crate::ifn::IFn;
+        use crate::persistent_vector::PersistentVector;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn split_by_comma() {
+            let split = SplitFn {};
+            let s = "hello,world,again";
+            let re = ",";
+            let args = vec![
+                Rc::new(Value::String(String::from(s))),
+                Rc::new(Value::Pattern(regex::Regex::new(re).unwrap())),
+            ];
+            assert_eq!(
+                Value::PersistentVector(
+                    vec![
+                        Rc::new(Value::String(String::from("hello"))),
+                        Rc::new(Value::String(String::from("world"))),
+                        Rc::new(Value::String(String::from("again")))
+                    ]
+                    .into_iter()
+                    .collect::<PersistentVector>()
+                ),
+                split.invoke(args)
+            );
+        }
+
+        #[test]
+        fn split_by_comma_not_in_string() {
+            let split = SplitFn {};
+            let s = "hello world again";
+            let re = ",";
+            let args = vec![
+                Rc::new(Value::String(String::from(s))),
+                Rc::new(Value::Pattern(regex::Regex::new(re).unwrap())),
+            ];
+            assert_eq!(
+                Value::PersistentVector(
+                    vec![Rc::new(Value::String(String::from("hello world again")))]
+                        .into_iter()
+                        .collect::<PersistentVector>()
+                ),
+                split.invoke(args)
+            );
+        }
+
+        #[test]
+        fn split_by_doublequotes() {
+            let split = SplitFn {};
+            let s = r#"hello world"again""#;
+            let re = "\"";
+            let args = vec![
+                Rc::new(Value::String(String::from(s))),
+                Rc::new(Value::Pattern(regex::Regex::new(re).unwrap())),
+            ];
+            assert_eq!(
+                Value::PersistentVector(
+                    vec![
+                        Rc::new(Value::String(String::from("hello world"))),
+                        Rc::new(Value::String(String::from("again")))
+                    ]
+                    .into_iter()
+                    .collect::<PersistentVector>()
+                ),
+                split.invoke(args)
+            );
+        }
+    }
+}
diff --git a/src/environment.rs b/src/environment.rs
@@ -1,6 +1,6 @@
 use crate::clojure_std;
 use crate::clojure_string;
-use crate::namespace::{Namespaces};
+use crate::namespace::Namespaces;
 use crate::repl::Repl;
 use crate::rust_core;
 use crate::symbol::Symbol;
@@ -219,6 +219,7 @@ impl Environment {
         let triml_fn = clojure_string::triml::TrimLFn {};
         let trimr_fn = clojure_string::trimr::TrimRFn {};
         let trim_newline_fn = clojure_string::trim_newline::TrimNewlineFn {};
+        let split_fn = clojure_string::split::SplitFn {};
 
         // Hardcoded fns
         let lexical_eval_fn = Value::LexicalEvalFn {};
@@ -255,23 +256,23 @@ impl Environment {
         environment.insert(Symbol::intern("eval"), eval_fn.to_rc_value());
 
         // Thread namespace
-		environment.insert_into_namespace(
-			&Symbol::intern("Thread"),
-			Symbol::intern("sleep"),
-			thread_sleep_fn.to_rc_value()
-		);
-
-		// System namespace
-		environment.insert_into_namespace(
-			&Symbol::intern("System"),
-			Symbol::intern("nanoTime"),
-			nanotime_fn.to_rc_value()
-		);
-		environment.insert_into_namespace(
-			&Symbol::intern("System"),
-			Symbol::intern("getenv"),
-			get_env_fn.to_rc_value()
-		);
+        environment.insert_into_namespace(
+            &Symbol::intern("Thread"),
+            Symbol::intern("sleep"),
+            thread_sleep_fn.to_rc_value(),
+        );
+
+        // System namespace
+        environment.insert_into_namespace(
+            &Symbol::intern("System"),
+            Symbol::intern("nanoTime"),
+            nanotime_fn.to_rc_value(),
+        );
+        environment.insert_into_namespace(
+            &Symbol::intern("System"),
+            Symbol::intern("getenv"),
+            get_env_fn.to_rc_value(),
+        );
 
         // core.clj wraps calls to the rust implementations
         // @TODO add this to clojure.rs.core namespace as clojure.rs.core/slurp
@@ -350,6 +351,12 @@ impl Environment {
             trim_newline_fn.to_rc_value(),
         );
 
+        environment.insert_into_namespace(
+            &Symbol::intern("clojure.string"),
+            Symbol::intern("split"),
+            split_fn.to_rc_value(),
+        );
+
         environment.insert(Symbol::intern("+"), add_fn.to_rc_value());
         environment.insert(Symbol::intern("let"), let_macro.to_rc_value());
         environment.insert(Symbol::intern("str"), str_fn.to_rc_value());
@@ -389,12 +396,19 @@ impl Environment {
         );
         environment.insert(Symbol::intern("read-line"), read_line_fn.to_rc_value());
 
-        environment.insert(Symbol::intern("="),equals_fn.to_rc_value());
+        environment.insert(Symbol::intern("="), equals_fn.to_rc_value());
         //
         // Read in clojure.core
         //
         // @TODO its time for a RT (runtime), which environment seems to be becoming
         let _ = Repl::new(Rc::clone(&environment)).try_eval_file("./src/clojure/core.clj");
+        println!(
+            "{:#?} {:#?}",
+            &environment.get_current_namespace(),
+            &environment.get_current_namespace_name()
+        );
+        // TODO: should read into namespace if (ns ..) is given in source file
+        let _ = Repl::new(Rc::clone(&environment)).try_eval_file("./src/clojure/string.clj");
 
         // We can add this back once we have requires
         // environment.change_namespace(Symbol::intern("user"));
@@ -528,8 +542,7 @@ mod tests {
                 MainEnvironment(EnvironmentVal {
                     curr_ns_sym: _,
                     namespaces,
-                }) => namespaces
-                    .get(&Symbol::intern("user"),&Symbol::intern("+")),
+                }) => namespaces.get(&Symbol::intern("user"), &Symbol::intern("+")),
                 _ => panic!("new_main_environment() should return Main"),
             };
 
diff --git a/src/error_message.rs b/src/error_message.rs
@@ -44,3 +44,7 @@ pub fn index_cannot_be_negative(ind: usize) -> Value {
 pub fn generic_err(error: Box<dyn Error>) -> Value {
     Value::Condition(error.to_string())
 }
+
+pub fn unknown_err(error: String) -> Value {
+    Value::Condition(error)
+}
diff --git a/src/reader.rs b/src/reader.rs
@@ -404,23 +404,24 @@ pub fn try_read_string(input: &str) -> IResult<&str, Value> {
 pub fn try_read_pattern(input: &str) -> IResult<&str, Value> {
     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 (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 
+    // 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"); }
+        Value::String(reg_str) => {
+            regex_string = reg_str;
+        }
+        _ => {
+            panic!("try_read_string returned something that wasn't string");
+        }
     }
 
     let regex = regex::Regex::new(regex_string.as_str()).unwrap();
-    Ok((
-        rest_input,
-        Value::Pattern(regex),
-    ))
+    Ok((rest_input, Value::Pattern(regex)))
 }
 
 // @TODO Perhaps generalize this, or even generalize it as a reader macro
@@ -845,60 +846,8 @@ mod tests {
         fn try_read_bool_false_test() {
             assert_eq!(Value::Boolean(false), try_read("false ").ok().unwrap().1)
         }
-
-        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_simple_with_escaped_quote_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("#\"h\"e\"l\"l \"o\" something").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("#\"h\"e\"l\" l \"o\" something").ok().unwrap().1
-                );
-            }
-        }
     }
+
     mod regex_tests {
         use crate::reader::try_read;
         use crate::value::Value;
@@ -943,6 +892,7 @@ mod tests {
             );
         }
     }
+
     mod consume_clojure_whitespaces_tests {
         use crate::reader::consume_clojure_whitespaces_parser;
         #[test]

Original file line number	Diff line number	Diff line change
`@@ -44,3 +44,7 @@ pub fn index_cannot_be_negative(ind: usize) -> Value {`
`44`	`44`	`pub fn generic_err(error: Box<dyn Error>) -> Value {`
`45`	`45`	`Value::Condition(error.to_string())`
`46`	`46`	`}`
	`47`	`+`
	`48`	`+pub fn unknown_err(error: String) -> Value {`
	`49`	`+ Value::Condition(error)`
	`50`	`+}`