clojure.string/blank?

Author: erkkikeranen

src/clojure_string.rs

@@ -1,2 +1,3 @@
 pub (crate) mod reverse;
-pub (crate) mod join;
+pub (crate) mod join;
+pub (crate) mod blank_qmark_;

src/clojure_string/blank_qmark_.rs

@@ -0,0 +1,84 @@
+use crate::ifn::IFn;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+use crate::error_message;
+use crate::type_tag::TypeTag;
+
+/// clojure.string/blank? ; returns true if nil, empty or whitespace
+#[derive(Debug, Clone)]
+pub struct BlankFn {}
+impl ToValue for BlankFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for BlankFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 1 {
+            return error_message::wrong_arg_count(1, args.len());
+        } else {
+            match args.get(0).unwrap().to_value() {
+                Value::Nil => Value::Boolean(true),
+                Value::String(s) => {
+                    if s.len() == 0 {
+                        Value::Boolean(true)
+                    } else {
+                        return Value::Boolean(s.chars().filter(|c| !c.is_whitespace()).collect::<Vec<char>>().len() == 0)
+                    }
+                }
+                Value::String(s) => Value::String(s.chars().rev().collect()),
+                _a => error_message::type_mismatch(TypeTag::String, &_a.to_value())
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    mod reverse_tests {
+        use crate::value::Value;
+        use std::rc::Rc;
+        use crate::clojure_string::blank_qmark_::BlankFn;
+        use crate::ifn::IFn;
+
+        #[test]
+        fn is_non_empty_string_blank() {
+            let blank = BlankFn {};
+            let s = "hello";
+            let args = vec![Rc::new(Value::String(String::from(s)))];
+            assert_eq!(Value::Boolean(false), blank.invoke(args));
+        }
+
+        #[test]
+        fn is_empty_string_blank() {
+            let blank = BlankFn {};
+            let s = "";
+            let args = vec![Rc::new(Value::String(String::from(s)))];
+            assert_eq!(Value::Boolean(true), blank.invoke(args));
+        }
+
+        #[test]
+        fn is_string_with_whitespace_only_blank() {
+            let blank = BlankFn {};
+            let s = " \t \n   \r ";
+            let args = vec![Rc::new(Value::String(String::from(s)))];
+            assert_eq!(Value::Boolean(true), blank.invoke(args));
+        }
+
+        #[test]
+        fn is_string_with_whitespace_and_text_blank() {
+            let blank = BlankFn {};
+            let s = " \thello \n   \r ";
+            let args = vec![Rc::new(Value::String(String::from(s)))];
+            assert_eq!(Value::Boolean(true), blank.invoke(args));
+        }
+
+        #[test]
+        fn is_nil_blank() {
+            let blank = BlankFn {};
+            let args = vec![Rc::new(Value::Nil)];
+            assert_eq!(Value::Boolean(true), blank.invoke(args));
+        }
+    }
+}

src/environment.rs

@@ -205,6 +205,7 @@ impl Environment {
         // clojure.string
         let reverse_fn = clojure_string::reverse::ReverseFn {};
 		let join_fn = clojure_string::join::JoinFn {};
+		let blank_fn = clojure_string::blank_qmark_::BlankFn {};
 
         // Hardcoded fns
         let lexical_eval_fn = Value::LexicalEvalFn {};
@@ -262,6 +263,11 @@ impl Environment {
 			Symbol::intern("join"),
 			join_fn.to_rc_value());
 
+		environment.insert_into_namespace(
+			&Symbol::intern("clojure.string"),
+			Symbol::intern("blank?"),
+			blank_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());