Refactor the parsing of call parameters

src/expression_evaluator.rs

@@ -211,3 +211,31 @@ pub struct CallParams<'a> {
     pub kw_params: HashMap<String, FullExpressionEvaluator<'a>>,
     pub pos_params: Vec<FullExpressionEvaluator<'a>>,
 }
+
+impl<'a> CallParams<'a> {
+    pub fn parse<'b>(
+        &self,
+        param_names: Vec<&'b str>,
+        context: Context,
+    ) -> Result<HashMap<&'b str, Value>> {
+        let mut parameters = HashMap::default();
+        let mut idx = 0;
+        for name in param_names {
+            match self.kw_params.get(name) {
+                Some(expression) => {
+                    let value = expression.evaluate(context.clone())?;
+                    parameters.insert(name, value);
+                }
+                None => match self.pos_params.get(idx) {
+                    Some(expression) => {
+                        idx += 1;
+                        let value = expression.evaluate(context.clone())?;
+                        parameters.insert(name, value);
+                    }
+                    None => {}
+                },
+            }
+        }
+        Ok(parameters)
+    }
+}

src/filters.rs

@@ -2,6 +2,8 @@ use crate::context::Context;
 use crate::error::Result;
 use crate::expression_evaluator::CallParams;
 use crate::value::Value;
+use std::collections::HashMap;
+
 pub enum Filter {
     Abs,
     Capitalize,
@@ -53,7 +55,18 @@ impl Filter {
         match &self {
             Filter::Abs => base_value.abs(),
             Filter::Capitalize => base_value.capitalize(),
-            Filter::Default => base_value.default_filter(params, context),
+            Filter::Default => {
+                let parameters = if params.is_some() {
+                    params
+                        .as_ref()
+                        .unwrap()
+                        .parse(vec!["default_value"], context)?
+                } else {
+                    HashMap::default()
+                };
+
+                base_value.default_filter(parameters)
+            }
             Filter::Escape => base_value.escape(),
             Filter::First => base_value.first(),
             Filter::Int => Ok(Value::Integer(base_value.int()?)), // TODO change to accept parameters

src/value/filters.rs

@@ -3,6 +3,7 @@ use crate::context::Context;
 use crate::error::{Error, ErrorKind, Result};
 use crate::expression_evaluator::CallParams;
 use crate::expression_evaluator::Evaluate;
+use std::collections::HashMap;
 use std::convert::TryInto;
 
 use regex::Regex;
@@ -25,20 +26,15 @@ impl Value {
             _ => Err(Error::from(ErrorKind::InvalidOperation)),
         }
     }
-    pub fn default_filter(self, params: &Option<CallParams>, context: Context) -> Result<Self> {
+    pub fn default_filter(self, mut params: HashMap<&str, Value>) -> Result<Self> {
         match self {
-            Value::Empty => match params {
-                None => Ok(Value::String("".to_string())),
-                Some(call_params) => {
-                    if let Some(value) = call_params.kw_params.get("default_value") {
-                        Ok(value.evaluate(context)?)
-                    } else if let Some(value) = call_params.pos_params.first() {
-                        Ok(value.evaluate(context)?)
-                    } else {
-                        Ok(Value::String("".to_string()))
-                    }
-                }
-            },
+            Value::Empty => {
+                let default_value = params
+                    .remove("default_value")
+                    .unwrap_or(Value::String("".to_string()));
+                Ok(default_value)
+            }
+
             value => Ok(value),
         }
     }