Add Unicode aware Capitalize filter

src/filters.rs

@@ -54,6 +54,23 @@ pub fn upcase(input: &Value, _args: &[Value]) -> FilterResult {
     }
 }
 
+
+pub fn capitalize(input: &Value, _args: &[Value]) -> FilterResult {
+    match *input {
+        Str(ref s) => Ok(Str(s.char_indices().fold(String::new(), |word, (_, chr)| {
+            let next_char = match word.chars().last() {
+                Some(last) => match last.is_whitespace() {
+                    true => chr.to_uppercase().next().unwrap(),
+                    false => chr,
+                },
+                _ => chr.to_uppercase().next().unwrap(),
+            }.to_string();
+            word + &next_char
+        }))),
+        _ => Err(InvalidType("String expected".to_owned())),
+    }
+}
+
 pub fn minus(input: &Value, args: &[Value]) -> FilterResult {
 
     let num = match *input {
@@ -120,6 +137,22 @@ mod tests {
                    tos!("HELLO WORLD 21"));
     }
 
+    #[test]
+    fn unit_capitalize() {
+        assert_eq!(unit!(capitalize, tos!("abc")), tos!("Abc"));
+        assert_eq!(unit!(capitalize, tos!("hello world 21")),
+                   tos!("Hello World 21"));
+
+        // sure that Umlauts work
+        assert_eq!(unit!(capitalize, tos!("über ètat, y̆es?")),
+                    tos!("Über Ètat, Y\u{306}es?"));
+
+        // Weird UTF-8 White space is kept – this is a no-break whitespace!
+        assert_eq!(unit!(capitalize, tos!("hello world​")),
+                   tos!("Hello World​"));
+
+    }
+
     #[test]
     fn unit_minus() {
         assert_eq!(unit!(minus, Num(2f32), &[Num(1f32)]), Num(1f32));

src/template.rs

@@ -1,6 +1,6 @@
 use Renderable;
 use context::Context;
-use filters::{size, upcase, minus, replace};
+use filters::{size, upcase, minus, capitalize, replace};
 use error::Result;
 
 pub struct Template {
@@ -11,6 +11,7 @@ impl Renderable for Template {
     fn render(&self, context: &mut Context) -> Result<Option<String>> {
         context.filters.insert("size".to_owned(), Box::new(size));
         context.filters.insert("upcase".to_owned(), Box::new(upcase));
+        context.filters.insert("capitalize".to_owned(), Box::new(capitalize));
         context.filters.insert("minus".to_owned(), Box::new(minus));
         context.filters.insert("replace".to_owned(), Box::new(replace));
 

tests/filters.rs

@@ -20,6 +20,20 @@ pub fn upcase() {
     assert_eq!(output.unwrap(), Some("HELLO".to_string()));
 }
 
+
+#[test]
+pub fn capitalize() {
+    let text = "{{ text | capitalize}}";
+    let options : LiquidOptions = Default::default();
+    let template = parse(&text, options).unwrap();
+
+    let mut data = Context::new();
+    data.set_val("text", Value::Str("hello world".to_string()));
+
+    let output = template.render(&mut data);
+    assert_eq!(output.unwrap(), Some("Hello World".to_string()));
+}
+
 #[test]
 pub fn minus() {
     let text = "{{ num | minus : 2 }}";