starts-with? and ends-with?

Author: erkkikeranen

src/clojure_string.rs

@@ -1,5 +1,7 @@
 pub(crate) mod blank_qmark_;
+pub(crate) mod ends_with_qmark_;
 pub(crate) mod join;
 pub(crate) mod lower_case;
 pub(crate) mod reverse;
+pub(crate) mod starts_with_qmark_;
 pub(crate) mod upper_case;

src/clojure_string/ends_with_qmark_.rs

@@ -0,0 +1,78 @@
+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 EndsWithFn {}
+impl ToValue for EndsWithFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for EndsWithFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 2 {
+            return error_message::wrong_arg_count(2, args.len());
+        } else {
+            match (
+                args.get(0).unwrap().to_value(),
+                args.get(1).unwrap().to_value(),
+            ) {
+                (Value::String(s), Value::String(substring)) => {
+                    Value::Boolean(s.ends_with(&substring))
+                }
+                _a => error_message::type_mismatch(TypeTag::String, &_a.1.to_value()),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    mod reverse_tests {
+        use crate::clojure_string::ends_with_qmark_::EndsWithFn;
+        use crate::ifn::IFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn hello_ends_with_lo() {
+            let blank = EndsWithFn {};
+            let s = "hello";
+            let substring = "lo";
+            let args = vec![
+                Rc::new(Value::String(String::from(s))),
+                Rc::new(Value::String(String::from(substring))),
+            ];
+            assert_eq!(Value::Boolean(true), blank.invoke(args));
+        }
+
+        #[test]
+        fn hello_does_not_end_with_klo() {
+            let blank = EndsWithFn {};
+            let s = "hello";
+            let substring = "klo";
+            let args = vec![
+                Rc::new(Value::String(String::from(s))),
+                Rc::new(Value::String(String::from(substring))),
+            ];
+            assert_eq!(Value::Boolean(false), blank.invoke(args));
+        }
+
+        #[test]
+        fn hello_ends_with_empty_string() {
+            let blank = EndsWithFn {};
+            let s = "hello";
+            let substring = "";
+            let args = vec![
+                Rc::new(Value::String(String::from(s))),
+                Rc::new(Value::String(String::from(substring))),
+            ];
+            assert_eq!(Value::Boolean(true), blank.invoke(args));
+        }
+    }
+}

src/clojure_string/starts_with_qmark_.rs

@@ -0,0 +1,78 @@
+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 StartsWithFn {}
+impl ToValue for StartsWithFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for StartsWithFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 2 {
+            return error_message::wrong_arg_count(2, args.len());
+        } else {
+            match (
+                args.get(0).unwrap().to_value(),
+                args.get(1).unwrap().to_value(),
+            ) {
+                (Value::String(s), Value::String(substring)) => {
+                    Value::Boolean(s.starts_with(&substring))
+                }
+                _a => error_message::type_mismatch(TypeTag::String, &_a.1.to_value()),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    mod reverse_tests {
+        use crate::clojure_string::starts_with_qmark_::StartsWithFn;
+        use crate::ifn::IFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn hello_starts_with_hel() {
+            let blank = StartsWithFn {};
+            let s = "hello";
+            let substring = "hel";
+            let args = vec![
+                Rc::new(Value::String(String::from(s))),
+                Rc::new(Value::String(String::from(substring))),
+            ];
+            assert_eq!(Value::Boolean(true), blank.invoke(args));
+        }
+
+        #[test]
+        fn hello_does_not_start_with_leh() {
+            let blank = StartsWithFn {};
+            let s = "hello";
+            let substring = "leh";
+            let args = vec![
+                Rc::new(Value::String(String::from(s))),
+                Rc::new(Value::String(String::from(substring))),
+            ];
+            assert_eq!(Value::Boolean(false), blank.invoke(args));
+        }
+
+        #[test]
+        fn hello_starts_with_empty_string() {
+            let blank = StartsWithFn {};
+            let s = "hello";
+            let substring = "";
+            let args = vec![
+                Rc::new(Value::String(String::from(s))),
+                Rc::new(Value::String(String::from(substring))),
+            ];
+            assert_eq!(Value::Boolean(true), blank.invoke(args));
+        }
+    }
+}

src/environment.rs

@@ -208,6 +208,8 @@ impl Environment {
         let blank_fn = clojure_string::blank_qmark_::BlankFn {};
         let upper_case_fn = clojure_string::upper_case::UpperCaseFn {};
         let lower_case_fn = clojure_string::lower_case::LowerCaseFn {};
+        let starts_with_fn = clojure_string::starts_with_qmark_::StartsWithFn {};
+        let ends_with_fn = clojure_string::ends_with_qmark_::EndsWithFn {};
 
         // Hardcoded fns
         let lexical_eval_fn = Value::LexicalEvalFn {};
@@ -285,6 +287,18 @@ impl Environment {
             lower_case_fn.to_rc_value(),
         );
 
+        environment.insert_into_namespace(
+            &Symbol::intern("clojure.string"),
+            Symbol::intern("starts-with?"),
+            starts_with_fn.to_rc_value(),
+        );
+
+        environment.insert_into_namespace(
+            &Symbol::intern("clojure.string"),
+            Symbol::intern("ends-with?"),
+            ends_with_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());