trim, triml, trimr

Author: erkkikeranen

src/clojure_string.rs

@@ -5,4 +5,7 @@ pub(crate) mod join;
 pub(crate) mod lower_case;
 pub(crate) mod reverse;
 pub(crate) mod starts_with_qmark_;
+pub(crate) mod trim;
+pub(crate) mod triml;
+pub(crate) mod trimr;
 pub(crate) mod upper_case;

src/clojure_string/ends_with_qmark_.rs

@@ -5,7 +5,7 @@ use std::rc::Rc;
 use crate::error_message;
 use crate::type_tag::TypeTag;
 
-/// clojure.string/blank? ; returns true if nil, empty or whitespace
+/// clojure.string/ends-with? ; returns true if string ends with substring
 #[derive(Debug, Clone)]
 pub struct EndsWithFn {}
 impl ToValue for EndsWithFn {
@@ -41,38 +41,38 @@ mod tests {
 
         #[test]
         fn hello_ends_with_lo() {
-            let blank = EndsWithFn {};
+            let ends_with = 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));
+            assert_eq!(Value::Boolean(true), ends_with.invoke(args));
         }
 
         #[test]
         fn hello_does_not_end_with_klo() {
-            let blank = EndsWithFn {};
+            let ends_with = 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));
+            assert_eq!(Value::Boolean(false), ends_with.invoke(args));
         }
 
         #[test]
         fn hello_ends_with_empty_string() {
-            let blank = EndsWithFn {};
+            let ends_with = 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));
+            assert_eq!(Value::Boolean(true), ends_with.invoke(args));
         }
     }
 }

src/clojure_string/includes_qmark_.rs

@@ -5,7 +5,7 @@ use std::rc::Rc;
 use crate::error_message;
 use crate::type_tag::TypeTag;
 
-/// clojure.string/blank? ; returns true if nil, empty or whitespace
+/// clojure.string/includes? ; returns true if string contains substring
 #[derive(Debug, Clone)]
 pub struct IncludesFn {}
 impl ToValue for IncludesFn {
@@ -41,38 +41,38 @@ mod tests {
 
         #[test]
         fn hello_includes_ell() {
-            let blank = IncludesFn {};
+            let includes = IncludesFn {};
             let s = "hello";
             let substring = "ell";
             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));
+            assert_eq!(Value::Boolean(true), includes.invoke(args));
         }
 
         #[test]
         fn hello_does_not_include_leh() {
-            let blank = IncludesFn {};
+            let includes = IncludesFn {};
             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));
+            assert_eq!(Value::Boolean(false), includes.invoke(args));
         }
 
         #[test]
         fn hello_includes_empty_string() {
-            let blank = IncludesFn {};
+            let includes = IncludesFn {};
             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));
+            assert_eq!(Value::Boolean(true), includes.invoke(args));
         }
     }
 }

src/clojure_string/lower_case.rs

@@ -5,7 +5,7 @@ use std::rc::Rc;
 use crate::error_message;
 use crate::type_tag::TypeTag;
 
-/// clojure.string/upper-case ; converts characters to uppercase
+/// clojure.string/lower-case ; converts characters to lower case
 #[derive(Debug, Clone)]
 pub struct LowerCaseFn {}
 impl ToValue for LowerCaseFn {
@@ -28,20 +28,20 @@ impl IFn for LowerCaseFn {
 
 #[cfg(test)]
 mod tests {
-    mod reverse_tests {
+    mod lower_case_tests {
         use crate::clojure_string::lower_case::LowerCaseFn;
         use crate::ifn::IFn;
         use crate::value::Value;
         use std::rc::Rc;
 
         #[test]
-        fn reverse_string() {
-            let reverse = LowerCaseFn {};
+        fn lower_case_string() {
+            let lower_case = LowerCaseFn {};
             let s = "1.2.3 HELLO";
             let args = vec![Rc::new(Value::String(String::from(s)))];
             assert_eq!(
                 Value::String(String::from("1.2.3 hello")),
-                reverse.invoke(args)
+                lower_case.invoke(args)
             );
         }
     }

src/clojure_string/starts_with_qmark_.rs

@@ -5,7 +5,7 @@ use std::rc::Rc;
 use crate::error_message;
 use crate::type_tag::TypeTag;
 
-/// clojure.string/blank? ; returns true if nil, empty or whitespace
+/// clojure.string/starts-with? ; returns true if string starts with substring
 #[derive(Debug, Clone)]
 pub struct StartsWithFn {}
 impl ToValue for StartsWithFn {
@@ -41,38 +41,38 @@ mod tests {
 
         #[test]
         fn hello_starts_with_hel() {
-            let blank = StartsWithFn {};
+            let starts_with = 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));
+            assert_eq!(Value::Boolean(true), starts_with.invoke(args));
         }
 
         #[test]
         fn hello_does_not_start_with_leh() {
-            let blank = StartsWithFn {};
+            let starts_with = 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));
+            assert_eq!(Value::Boolean(false), starts_with.invoke(args));
         }
 
         #[test]
         fn hello_starts_with_empty_string() {
-            let blank = StartsWithFn {};
+            let starts_with = 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));
+            assert_eq!(Value::Boolean(true), starts_with.invoke(args));
         }
     }
 }

src/clojure_string/trim.rs

@@ -0,0 +1,45 @@
+use crate::ifn::IFn;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+use crate::error_message;
+use crate::type_tag::TypeTag;
+
+/// clojure.string/trim trims white space from start and end of string
+#[derive(Debug, Clone)]
+pub struct TrimFn {}
+impl ToValue for TrimFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for TrimFn {
+    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::String(s) => Value::String(s.trim().to_string()),
+                _a => error_message::type_mismatch(TypeTag::String, &_a.to_value()),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    mod trim_tests {
+        use crate::clojure_string::trim::TrimFn;
+        use crate::ifn::IFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn trim() {
+            let trim = TrimFn {};
+            let s = " \r \t  hello   \n";
+            let args = vec![Rc::new(Value::String(String::from(s)))];
+            assert_eq!(Value::String(String::from("hello")), trim.invoke(args));
+        }
+    }
+}

src/clojure_string/triml.rs

@@ -0,0 +1,48 @@
+use crate::ifn::IFn;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+use crate::error_message;
+use crate::type_tag::TypeTag;
+
+/// clojure.string/triml trims white space from start of string
+#[derive(Debug, Clone)]
+pub struct TrimLFn {}
+impl ToValue for TrimLFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for TrimLFn {
+    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::String(s) => Value::String(s.trim_start().to_string()),
+                _a => error_message::type_mismatch(TypeTag::String, &_a.to_value()),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    mod triml_tests {
+        use crate::clojure_string::triml::TrimLFn;
+        use crate::ifn::IFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn triml() {
+            let triml = TrimLFn {};
+            let s = " \r \t  hello   \n";
+            let args = vec![Rc::new(Value::String(String::from(s)))];
+            assert_eq!(
+                Value::String(String::from("hello   \n")),
+                triml.invoke(args)
+            );
+        }
+    }
+}

src/clojure_string/trimr.rs

@@ -0,0 +1,48 @@
+use crate::ifn::IFn;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+use crate::error_message;
+use crate::type_tag::TypeTag;
+
+/// clojure.string/trimr trims white space from start of string
+#[derive(Debug, Clone)]
+pub struct TrimRFn {}
+impl ToValue for TrimRFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for TrimRFn {
+    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::String(s) => Value::String(s.trim_end().to_string()),
+                _a => error_message::type_mismatch(TypeTag::String, &_a.to_value()),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    mod trimr_tests {
+        use crate::clojure_string::trimr::TrimRFn;
+        use crate::ifn::IFn;
+        use crate::value::Value;
+        use std::rc::Rc;
+
+        #[test]
+        fn trimr() {
+            let trimr = TrimRFn {};
+            let s = " \r \t  hello   \n";
+            let args = vec![Rc::new(Value::String(String::from(s)))];
+            assert_eq!(
+                Value::String(String::from(" \r \t  hello")),
+                trimr.invoke(args)
+            );
+        }
+    }
+}

src/clojure_string/upper_case.rs

@@ -5,7 +5,7 @@ use std::rc::Rc;
 use crate::error_message;
 use crate::type_tag::TypeTag;
 
-/// clojure.string/upper-case ; converts characters to uppercase
+/// clojure.string/upper-case ; converts characters to upper case
 #[derive(Debug, Clone)]
 pub struct UpperCaseFn {}
 impl ToValue for UpperCaseFn {
@@ -28,20 +28,20 @@ impl IFn for UpperCaseFn {
 
 #[cfg(test)]
 mod tests {
-    mod reverse_tests {
+    mod upper_case_tests {
         use crate::clojure_string::upper_case::UpperCaseFn;
         use crate::ifn::IFn;
         use crate::value::Value;
         use std::rc::Rc;
 
         #[test]
-        fn reverse_string() {
-            let reverse = UpperCaseFn {};
+        fn upper_case_string() {
+            let upper_case = UpperCaseFn {};
             let s = "1.2.3 hello";
             let args = vec![Rc::new(Value::String(String::from(s)))];
             assert_eq!(
                 Value::String(String::from("1.2.3 HELLO")),
-                reverse.invoke(args)
+                upper_case.invoke(args)
             );
         }
     }