Round filter with method parameter.

morenol · Aug 19, 2020 · 80b496a · 80b496a
1 parent d12bd48
commit 80b496a
Show file tree

Hide file tree

Showing 3 changed files with 39 additions and 0 deletions.
diff --git a/src/filters.rs b/src/filters.rs
@@ -18,6 +18,7 @@ pub enum Filter {
     Lower,
     Max,
     Min,
+    Round,
     String,
     Sum,
     Title,
@@ -41,6 +42,7 @@ impl Filter {
             "lower" => Ok(Filter::Lower),
             "max" => Ok(Filter::Max),
             "min" => Ok(Filter::Min),
+            "round" => Ok(Filter::Round),
             "string" => Ok(Filter::String),
             "sum" => Ok(Filter::Sum),
             "title" => Ok(Filter::Title),
@@ -107,6 +109,14 @@ impl Filter {
             Filter::Lower => base_value.lower(),
             Filter::Max => base_value.max(), // TODO Accept params
             Filter::Min => base_value.min(), // TODO Accept params
+            Filter::Round => {
+                let parameters = if params.is_some() {
+                    params.as_ref().unwrap().parse(vec!["method"], context)?
+                } else {
+                    HashMap::default()
+                };
+                base_value.round(parameters)
+            }
             Filter::String => Ok(Value::String(base_value.to_string())),
             Filter::Sum => base_value.sum(), // TODO: ACcept params
             Filter::Title => base_value.title(),

diff --git a/src/value/filters.rs b/src/value/filters.rs
@@ -192,6 +192,28 @@ impl Value {
             _ => Err(Error::from(ErrorKind::InvalidOperation)),
         }
     }
+    pub fn round(self, mut params: HashMap<&str, Value>) -> Result<Self> {
+        let method = params
+            .remove("method")
+            .unwrap_or_else(|| Value::String("common".to_string()));
+
+        if let Value::Double(value) = self {
+            if let Value::String(method_str) = method {
+                match method_str.as_str() {
+                    "common" => Ok(Value::Double(value.round())),
+                    "ceil" => Ok(Value::Double(value.ceil())),
+                    "floor" => Ok(Value::Double(value.floor())),
+                    _ => Err(Error::from(ErrorKind::InvalidValueType)),
+                }
+            } else {
+                Err(Error::from(ErrorKind::InvalidValueType))
+            }
+        } else if let Value::Integer(value) = self {
+            Ok(Value::Integer(value))
+        } else {
+            Err(Error::from(ErrorKind::InvalidValueType))
+        }
+    }
     pub fn sum(self) -> Result<Self> {
         if let Value::ValuesList(values_list) = self {
             let value: f64 = values_list

diff --git a/tests/filters.rs b/tests/filters.rs
@@ -191,3 +191,10 @@ fn title_filter() -> Result<()> {
     assert_render_template_eq("{{ 'hello world!' | title }}", "Hello World!", None)?;
     assert_render_template_eq("{{ 'HellO wOrlD!' | title }}", "Hello World!", None)
 }
+
+#[test]
+fn round_filter() -> Result<()> {
+    assert_render_template_eq("{{ 5.8 | round }}", "6.0", None)?;
+    assert_render_template_eq("{{ 3.14 | round(method='ceil') }}", "4.0", None)?;
+    assert_render_template_eq("{{ 5.8 | round(method='floor') }}", "5.0", None)
+}