Implement upper filter

src/filters.rs

@@ -15,6 +15,7 @@ pub enum FilterType {
     Lower(LowerFilter),
     Safe(SafeFilter),
     Slugify(SlugifyFilter),
+    Upper(UpperFilter),
 }
 
 #[derive(Clone, Debug, PartialEq)]
@@ -81,3 +82,6 @@ pub struct SafeFilter;
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct SlugifyFilter;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct UpperFilter;

src/parse.rs

@@ -18,6 +18,7 @@ use crate::filters::FilterType;
 use crate::filters::LowerFilter;
 use crate::filters::SafeFilter;
 use crate::filters::SlugifyFilter;
+use crate::filters::UpperFilter;
 use crate::lex::START_TAG_LEN;
 use crate::lex::autoescape::{AutoescapeEnabled, AutoescapeError, lex_autoescape_argument};
 use crate::lex::common::LexerError;
@@ -123,6 +124,10 @@ impl Filter {
                 Some(right) => return Err(unexpected_argument("slugify", right)),
                 None => FilterType::Slugify(SlugifyFilter),
             },
+            "upper" => match right {
+                Some(right) => return Err(unexpected_argument("upper", right)),
+                None => FilterType::Upper(UpperFilter),
+            },
             external => {
                 let external = match parser.external_filters.get(external) {
                     Some(external) => external.clone().unbind(),

src/render/filters.rs

@@ -8,7 +8,7 @@ use pyo3::types::PyType;
 
 use crate::filters::{
     AddFilter, AddSlashesFilter, CapfirstFilter, DefaultFilter, EscapeFilter, ExternalFilter,
-    FilterType, LowerFilter, SafeFilter, SlugifyFilter,
+    FilterType, LowerFilter, SafeFilter, SlugifyFilter, UpperFilter,
 };
 use crate::parse::Filter;
 use crate::render::types::{Content, Context};
@@ -72,6 +72,7 @@ impl Resolve for Filter {
             FilterType::Lower(filter) => filter.resolve(left, py, template, context),
             FilterType::Safe(filter) => filter.resolve(left, py, template, context),
             FilterType::Slugify(filter) => filter.resolve(left, py, template, context),
+            FilterType::Upper(filter) => filter.resolve(left, py, template, context),
         };
         result
     }
@@ -322,10 +323,30 @@ impl ResolveFilter for SlugifyFilter {
     }
 }
 
+impl ResolveFilter for UpperFilter {
+    fn resolve<'t, 'py>(
+        &self,
+        variable: Option<Content<'t, 'py>>,
+        _py: Python<'py>,
+        _template: TemplateString<'t>,
+        context: &mut Context,
+    ) -> ResolveResult<'t, 'py> {
+        let content = match variable {
+            Some(content) => Some(
+                content
+                    .resolve_string(context)?
+                    .map_content(|content| Cow::Owned(content.to_uppercase())),
+            ),
+            None => "".as_content(),
+        };
+        Ok(content)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::filters::{AddSlashesFilter, DefaultFilter, LowerFilter};
+    use crate::filters::{AddSlashesFilter, DefaultFilter, LowerFilter, UpperFilter};
     use crate::parse::TagElement;
     use crate::render::Render;
     use crate::template::django_rusty_templates::{EngineData, Template};
@@ -800,4 +821,53 @@ mod tests {
             assert_eq!(rendered, "bryony");
         })
     }
+
+    #[test]
+    fn test_render_filter_upper() {
+        pyo3::prepare_freethreaded_python();
+
+        Python::with_gil(|py| {
+            let name = PyString::new(py, "Foo").into_any();
+            let context = HashMap::from([("name".to_string(), name.unbind())]);
+            let mut context = Context {
+                context,
+                request: None,
+                autoescape: false,
+            };
+            let template = TemplateString("{{ name|upper }}");
+            let variable = Variable::new((3, 4));
+            let filter = Filter {
+                at: (8, 5),
+                left: TagElement::Variable(variable),
+                filter: FilterType::Upper(UpperFilter),
+            };
+
+            let rendered = filter.render(py, template, &mut context).unwrap();
+            assert_eq!(rendered, "FOO");
+        })
+    }
+
+    #[test]
+    fn test_render_filter_upper_missing_left() {
+        pyo3::prepare_freethreaded_python();
+
+        Python::with_gil(|py| {
+            let context = HashMap::new();
+            let mut context = Context {
+                context,
+                request: None,
+                autoescape: false,
+            };
+            let template = TemplateString("{{ name|upper }}");
+            let variable = Variable::new((3, 4));
+            let filter = Filter {
+                at: (8, 5),
+                left: TagElement::Variable(variable),
+                filter: FilterType::Upper(UpperFilter),
+            };
+
+            let rendered = filter.render(py, template, &mut context).unwrap();
+            assert_eq!(rendered, "");
+        })
+    }
 }

tests/filters/test_upper.py

@@ -0,0 +1,30 @@
+from django.template import engines
+
+
+def test_upper_string():
+    template = "{{ var|upper }}"
+    django_template = engines["django"].from_string(template)
+    rust_template = engines["rusty"].from_string(template)
+
+    var = "foo"
+    uppered = "FOO"
+    assert django_template.render({"var": var}) == uppered
+    assert rust_template.render({"var": var}) == uppered
+
+def test_upper_undefined():
+    template = "{{ var|upper }}"
+    django_template = engines["django"].from_string(template)
+    rust_template = engines["rusty"].from_string(template)
+
+    assert django_template.render() == ""
+    assert rust_template.render() == ""
+
+def test_upper_integer():
+    template = "{{ var|upper }}"
+    django_template = engines["django"].from_string(template)
+    rust_template = engines["rusty"].from_string(template)
+
+    var = "3"
+    uppered = "3"
+    assert django_template.render({"var": var}) == uppered
+    assert rust_template.render({"var": var}) == uppered