Allow sort filter to be case insensitive

docs/content/docs/_index.md

@@ -956,6 +956,12 @@ or by age:
 {{ people | sort(attribute="age") }}
 ```
 
+The `case_sensitive` argument (default is true) can be used to control the order of strings.
+
+```jinja2
+{{ people | sort(attribute="name.1", case_sensitive=false) }}
+```
+
 #### unique
 Removes duplicate items from an array.  The `attribute` argument can be used to select items based on the values of an inner attribute.  For strings, the `case_sensitive` argument (default is false) can be used to control the comparison.
 

src/builtins/filters/array.rs

@@ -85,7 +85,12 @@ pub fn sort(value: &Value, args: &HashMap<String, Value>) -> Result<Value> {
         Error::msg(format!("attribute '{}' does not reference a field", attribute))
     })?;
 
-    let mut strategy = get_sort_strategy_for_type(first)?;
+    let case_sensitive = match args.get("case_sensitive") {
+        Some(val) => try_get_value!("sort", "case_sensitive", bool, val),
+        None => true,
+    };
+
+    let mut strategy = get_sort_strategy_for_type(first, case_sensitive)?;
     for v in &arr {
         let key = dotted_pointer(v, &attribute).ok_or_else(|| {
             Error::msg(format!("attribute '{}' does not reference a field", attribute))
@@ -451,6 +456,19 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_sort_case_insensitive() {
+        let v = to_value(vec!["apple", "coconut", "Banana", "Dog"]).unwrap();
+        let mut args = HashMap::new();
+        args.insert("case_sensitive".to_string(), to_value(false).unwrap());
+        let result = sort(&v, &args);
+        assert!(result.is_ok());
+        assert_eq!(
+            result.unwrap(),
+            to_value(vec!["apple", "Banana", "coconut", "Dog"]).unwrap()
+        );
+    }
+
     #[test]
     fn test_sort_invalid_attribute() {
         let v = to_value(vec![Foo { a: 3, b: 5 }]).unwrap();

src/filter_utils.rs

@@ -119,7 +119,6 @@ pub struct SortPairs<K: Ord> {
 
 type SortNumbers = SortPairs<OrderedF64>;
 type SortBools = SortPairs<bool>;
-type SortStrings = SortPairs<String>;
 type SortArrays = SortPairs<ArrayLen>;
 
 impl<K: GetValue> SortPairs<K> {
@@ -150,13 +149,42 @@ impl<K: GetValue> SortStrategy for SortPairs<K> {
     }
 }
 
-pub fn get_sort_strategy_for_type(ty: &Value) -> Result<Box<dyn SortStrategy>> {
+pub struct SortStrings {
+    pairs: Vec<(Value, String)>,
+    case_sensitive: bool,
+}
+impl SortStrings {
+    fn new(case_sensitive: bool) -> SortStrings {
+        SortStrings { pairs: Vec::new(), case_sensitive }
+    }
+}
+impl SortStrategy for SortStrings {
+    fn try_add_pair(&mut self, val: &Value, key: &Value) -> Result<()> {
+        let key_str = String::get_value(key)?;
+        self.pairs.push((val.clone(), key_str));
+        Ok(())
+    }
+    fn sort(&mut self) -> Vec<Value> {
+        if self.case_sensitive {
+            self.pairs.sort_by_key(|a| a.1.clone());
+        } else {
+            self.pairs.sort_by_key(|a| a.1.to_lowercase());
+        }
+
+        self.pairs.iter().map(|a| a.0.clone()).collect()
+    }
+}
+
+pub fn get_sort_strategy_for_type(
+    ty: &Value,
+    case_sensitive: bool,
+) -> Result<Box<dyn SortStrategy>> {
     use crate::Value::*;
     match *ty {
         Null => Err(Error::msg("Null is not a sortable value")),
         Bool(_) => Ok(Box::<SortBools>::default()),
         Number(_) => Ok(Box::<SortNumbers>::default()),
-        String(_) => Ok(Box::<SortStrings>::default()),
+        String(_) => Ok(Box::new(SortStrings::new(case_sensitive))),
         Array(_) => Ok(Box::<SortArrays>::default()),
         Object(_) => Err(Error::msg("Object is not a sortable value")),
     }