From 3d18b71865b38d9f0a3aa4722d0a7adad13c2016 Mon Sep 17 00:00:00 2001 From: Ed Page Date: Tue, 25 Sep 2018 20:10:16 -0600 Subject: [PATCH] fix(filter): Switch to standard error type BREAKING CHANGE: Error type for filters changed. --- liquid-interpreter/src/filter.rs | 47 +----------- liquid-interpreter/src/text.rs | 4 +- src/filters/date.rs | 45 ++++------- src/filters/html.rs | 5 +- src/filters/math.rs | 45 +++++------ src/filters/mod.rs | 128 +++++++++++++++---------------- src/filters/url.rs | 6 +- 7 files changed, 103 insertions(+), 177 deletions(-) diff --git a/liquid-interpreter/src/filter.rs b/liquid-interpreter/src/filter.rs index 50362e1a8..0e982c1f5 100644 --- a/liquid-interpreter/src/filter.rs +++ b/liquid-interpreter/src/filter.rs @@ -1,52 +1,9 @@ -use std::fmt; +use liquid_error; -use std::error::Error; use value::Value; -/// Replace this with `liquid_error::Error`. -#[derive(Debug, PartialEq, Eq)] -pub enum FilterError { - /// Invalid data type. - InvalidType(String), - /// Invalid number of arguments. - InvalidArgumentCount(String), - /// Invalid argument at a given position. - InvalidArgument(u16, String), -} - -impl FilterError { - /// Quick and dirty way to create an error. - pub fn invalid_type(s: &str) -> Result { - Err(FilterError::InvalidType(s.to_owned())) - } -} - -impl fmt::Display for FilterError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match *self { - FilterError::InvalidType(ref e) => write!(f, "Invalid type : {}", e), - FilterError::InvalidArgumentCount(ref e) => { - write!(f, "Invalid number of arguments : {}", e) - } - FilterError::InvalidArgument(ref pos, ref e) => { - write!(f, "Invalid argument given at position {} : {}", pos, e) - } - } - } -} - -impl Error for FilterError { - fn description(&self) -> &str { - match *self { - FilterError::InvalidType(ref e) - | FilterError::InvalidArgumentCount(ref e) - | FilterError::InvalidArgument(_, ref e) => e, - } - } -} - /// Expected return type of a `Filter`. -pub type FilterResult = Result; +pub type FilterResult = Result; /// A trait for creating custom tags. This is a simple type alias for a function. /// diff --git a/liquid-interpreter/src/text.rs b/liquid-interpreter/src/text.rs index e5c3a603c..5f4b86bc5 100644 --- a/liquid-interpreter/src/text.rs +++ b/liquid-interpreter/src/text.rs @@ -13,9 +13,7 @@ pub struct Text { impl Text { /// Create a raw template expression. pub fn new>(text: S) -> Text { - Text { - text: text.into(), - } + Text { text: text.into() } } } diff --git a/src/filters/date.rs b/src/filters/date.rs index 10d428c8f..0ef46fad7 100644 --- a/src/filters/date.rs +++ b/src/filters/date.rs @@ -1,13 +1,11 @@ use liquid_value::Scalar; use liquid_value::Value; -use super::check_args_len; +use super::{check_args_len, invalid_argument, invalid_input}; use interpreter::FilterResult; #[cfg(feature = "extra-filters")] use chrono::FixedOffset; -#[cfg(feature = "extra-filters")] -use interpreter::FilterError; pub fn date(input: &Value, args: &[Value]) -> FilterResult { check_args_len(args, 1, 0)?; @@ -37,14 +35,14 @@ pub fn date_in_tz(input: &Value, args: &[Value]) -> FilterResult { let date = input .as_scalar() .and_then(Scalar::to_date) - .ok_or_else(|| FilterError::InvalidType("Invalid date format".into()))?; + .ok_or_else(|| invalid_input("Invalid date format"))?; let format = args[0].to_str(); let n = args[1] .as_scalar() .and_then(Scalar::to_integer) - .ok_or_else(|| FilterError::InvalidArgument(1, "Whole number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(1, "Whole number expected"))?; let timezone = FixedOffset::east(n * 3600); Ok(Value::scalar( @@ -145,21 +143,15 @@ mod tests { #[test] fn unit_date_missing_format() { - assert_eq!( - failed!(date, tos!("13 Jun 2016 02:30:00 +0300")), - FilterError::InvalidArgumentCount("expected at least 1, 0 given".to_owned()) - ); + failed!(date, tos!("13 Jun 2016 02:30:00 +0300")); } #[test] fn unit_date_extra_param() { - assert_eq!( - failed!( - date, - tos!("13 Jun 2016 02:30:00 +0300"), - &[Value::scalar(0f64), Value::scalar(1f64)] - ), - FilterError::InvalidArgumentCount("expected at most 1, 2 given".to_owned()) + failed!( + date, + tos!("13 Jun 2016 02:30:00 +0300"), + &[Value::scalar(0f64), Value::scalar(1f64)] ); } @@ -195,8 +187,7 @@ mod tests { fn unit_date_in_tz_input_not_a_string() { let input = &Value::scalar(0f64); let args = &[tos!("%Y-%m-%d %H:%M:%S %z"), Value::scalar(0i32)]; - let desired_result = FilterError::InvalidType("Invalid date format".to_owned()); - assert_eq!(failed!(date_in_tz, input, args), desired_result); + failed!(date_in_tz, input, args); } #[test] @@ -204,8 +195,7 @@ mod tests { fn unit_date_in_tz_input_not_a_date_string() { let input = &tos!("blah blah blah"); let args = &[tos!("%Y-%m-%d %H:%M:%S %z"), Value::scalar(0i32)]; - let desired_result = FilterError::InvalidType("Invalid date format".to_owned()); - assert_eq!(failed!(date_in_tz, input, args), desired_result); + failed!(date_in_tz, input, args); } #[test] @@ -213,8 +203,7 @@ mod tests { fn unit_date_in_tz_offset_not_a_num() { let input = &tos!("13 Jun 2016 12:00:00 +0000"); let args = &[tos!("%Y-%m-%d %H:%M:%S %z"), tos!("Hello")]; - let desired_result = FilterError::InvalidArgument(1, "Whole number expected".to_owned()); - assert_eq!(failed!(date_in_tz, input, args), desired_result); + failed!(date_in_tz, input, args); } #[test] @@ -222,9 +211,7 @@ mod tests { fn unit_date_in_tz_zero_arguments() { let input = &tos!("13 Jun 2016 12:00:00 +0000"); let args = &[]; - let desired_result = - FilterError::InvalidArgumentCount("expected at least 2, 0 given".to_owned()); - assert_eq!(failed!(date_in_tz, input, args), desired_result); + failed!(date_in_tz, input, args); } #[test] @@ -232,9 +219,7 @@ mod tests { fn unit_date_in_tz_one_argument() { let input = &tos!("13 Jun 2016 12:00:00 +0000"); let args = &[tos!("%Y-%m-%d %H:%M:%S %z")]; - let desired_result = - FilterError::InvalidArgumentCount("expected at least 2, 1 given".to_owned()); - assert_eq!(failed!(date_in_tz, input, args), desired_result); + failed!(date_in_tz, input, args); } #[test] @@ -246,8 +231,6 @@ mod tests { Value::scalar(0f64), Value::scalar(1f64), ]; - let desired_result = - FilterError::InvalidArgumentCount("expected at most 2, 3 given".to_owned()); - assert_eq!(failed!(date_in_tz, input, args), desired_result); + failed!(date_in_tz, input, args); } } diff --git a/src/filters/html.rs b/src/filters/html.rs index abe0053f0..604c8c780 100644 --- a/src/filters/html.rs +++ b/src/filters/html.rs @@ -101,7 +101,6 @@ pub fn newline_to_br(input: &Value, args: &[Value]) -> FilterResult { mod tests { use super::*; - use interpreter::FilterError; macro_rules! unit { ($a:ident, $b:expr) => {{ @@ -218,8 +217,6 @@ mod tests { fn unit_newline_to_br_one_argument() { let input = &tos!("a\nb"); let args = &[Value::scalar(0f64)]; - let desired_result = - FilterError::InvalidArgumentCount("expected at most 0, 1 given".to_owned()); - assert_eq!(failed!(newline_to_br, input, args), desired_result); + failed!(newline_to_br, input, args); } } diff --git a/src/filters/math.rs b/src/filters/math.rs index 990e6fc6b..6b77e4ba3 100644 --- a/src/filters/math.rs +++ b/src/filters/math.rs @@ -1,7 +1,7 @@ use liquid_value::Value; -use super::check_args_len; -use interpreter::{FilterError, FilterResult}; +use super::{check_args_len, invalid_argument, invalid_input}; +use interpreter::FilterResult; /// Returns the absolute value of a number. pub fn abs(input: &Value, args: &[Value]) -> FilterResult { @@ -12,8 +12,8 @@ pub fn abs(input: &Value, args: &[Value]) -> FilterResult { .to_integer() .map(|i| Value::scalar(i.abs())) .or_else(|| s.to_float().map(|i| Value::scalar(i.abs()))) - .ok_or_else(|| FilterError::InvalidType("Numeric value expected".to_owned())), - _ => Err(FilterError::InvalidType("Number expected".to_owned())), + .ok_or_else(|| invalid_input("Numeric value expected")), + _ => Err(invalid_input("Number expected")), } } @@ -22,11 +22,11 @@ pub fn plus(input: &Value, args: &[Value]) -> FilterResult { let input = input .as_scalar() - .ok_or_else(|| FilterError::InvalidType("Number expected".to_owned()))?; + .ok_or_else(|| invalid_input("Number expected"))?; let operand = args[0] .as_scalar() - .ok_or_else(|| FilterError::InvalidArgument(0, "Number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Number expected"))?; let result = input .to_integer() @@ -36,7 +36,7 @@ pub fn plus(input: &Value, args: &[Value]) -> FilterResult { .to_float() .and_then(|i| operand.to_float().map(|o| Value::scalar(i + o))) }) - .ok_or_else(|| FilterError::InvalidArgument(0, "Number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Number expected"))?; Ok(result) } @@ -46,11 +46,11 @@ pub fn minus(input: &Value, args: &[Value]) -> FilterResult { let input = input .as_scalar() - .ok_or_else(|| FilterError::InvalidType("Number expected".to_owned()))?; + .ok_or_else(|| invalid_input("Number expected"))?; let operand = args[0] .as_scalar() - .ok_or_else(|| FilterError::InvalidArgument(0, "Number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Number expected"))?; let result = input .to_integer() @@ -60,7 +60,7 @@ pub fn minus(input: &Value, args: &[Value]) -> FilterResult { .to_float() .and_then(|i| operand.to_float().map(|o| Value::scalar(i - o))) }) - .ok_or_else(|| FilterError::InvalidArgument(0, "Number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Number expected"))?; Ok(result) } @@ -70,11 +70,11 @@ pub fn times(input: &Value, args: &[Value]) -> FilterResult { let input = input .as_scalar() - .ok_or_else(|| FilterError::InvalidType("Number expected".to_owned()))?; + .ok_or_else(|| invalid_input("Number expected"))?; let operand = args[0] .as_scalar() - .ok_or_else(|| FilterError::InvalidArgument(0, "Number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Number expected"))?; let result = input .to_integer() @@ -84,7 +84,7 @@ pub fn times(input: &Value, args: &[Value]) -> FilterResult { .to_float() .and_then(|i| operand.to_float().map(|o| Value::scalar(i * o))) }) - .ok_or_else(|| FilterError::InvalidArgument(0, "Number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Number expected"))?; Ok(result) } @@ -94,11 +94,11 @@ pub fn divided_by(input: &Value, args: &[Value]) -> FilterResult { let input = input .as_scalar() - .ok_or_else(|| FilterError::InvalidType("Number expected".to_owned()))?; + .ok_or_else(|| invalid_input("Number expected"))?; let operand = args[0] .as_scalar() - .ok_or_else(|| FilterError::InvalidArgument(0, "Number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Number expected"))?; let result = input .to_integer() @@ -108,7 +108,7 @@ pub fn divided_by(input: &Value, args: &[Value]) -> FilterResult { .to_float() .and_then(|i| operand.to_float().map(|o| Value::scalar(i / o))) }) - .ok_or_else(|| FilterError::InvalidArgument(0, "Number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Number expected"))?; Ok(result) } @@ -118,11 +118,11 @@ pub fn modulo(input: &Value, args: &[Value]) -> FilterResult { let input = input .as_scalar() - .ok_or_else(|| FilterError::InvalidType("Number expected".to_owned()))?; + .ok_or_else(|| invalid_input("Number expected"))?; let operand = args[0] .as_scalar() - .ok_or_else(|| FilterError::InvalidArgument(0, "Number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Number expected"))?; let result = input .to_integer() @@ -132,7 +132,7 @@ pub fn modulo(input: &Value, args: &[Value]) -> FilterResult { .to_float() .and_then(|i| operand.to_float().map(|o| Value::scalar(i % o))) }) - .ok_or_else(|| FilterError::InvalidArgument(0, "Number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Number expected"))?; Ok(result) } @@ -186,17 +186,14 @@ mod tests { fn unit_abs_not_number_or_string() { let input = &Value::scalar(true); let args = &[]; - let desired_result = FilterError::InvalidType("Numeric value expected".to_owned()); - assert_eq!(failed!(abs, input, args), desired_result); + failed!(abs, input, args); } #[test] fn unit_abs_one_argument() { let input = &Value::scalar(-1f64); let args = &[Value::scalar(0f64)]; - let desired_result = - FilterError::InvalidArgumentCount("expected at most 0, 1 given".to_owned()); - assert_eq!(failed!(abs, input, args), desired_result); + failed!(abs, input, args); } #[test] diff --git a/src/filters/mod.rs b/src/filters/mod.rs index 9111740d4..67a91ce81 100644 --- a/src/filters/mod.rs +++ b/src/filters/mod.rs @@ -10,27 +10,50 @@ pub use self::html::{escape, escape_once, newline_to_br, strip_html}; pub use self::math::{abs, divided_by, minus, modulo, plus, times}; pub use self::url::{url_decode, url_encode}; +use std::borrow::Cow; use std::cmp; use itertools; +use liquid_error; use liquid_value::Index; use liquid_value::Scalar; use liquid_value::Value; use unicode_segmentation::UnicodeSegmentation; -use interpreter::{FilterError, FilterResult}; +use interpreter::FilterResult; + +pub fn invalid_input<'s, S: Into>>(cause: S) -> liquid_error::Error { + liquid_error::Error::with_msg("Invalid input").context("cause", &cause.into()) +} + +pub fn invalid_argument_count<'s, S: Into>>(cause: S) -> liquid_error::Error { + liquid_error::Error::with_msg("Invalid number of arguments").context("cause", &cause.into()) +} + +pub fn invalid_argument<'s, S: Into>>( + position: usize, + cause: S, +) -> liquid_error::Error { + liquid_error::Error::with_msg("Invalid argument") + .context("position", &position) + .context("cause", &cause.into()) +} // Helper functions for the filters. -fn check_args_len(args: &[Value], required: usize, optional: usize) -> Result<(), FilterError> { +fn check_args_len( + args: &[Value], + required: usize, + optional: usize, +) -> Result<(), liquid_error::Error> { if args.len() < required { - return Err(FilterError::InvalidArgumentCount(format!( + return Err(invalid_argument_count(&format!( "expected at least {}, {} given", required, args.len() ))); } if required + optional < args.len() { - return Err(FilterError::InvalidArgumentCount(format!( + return Err(invalid_argument_count(&format!( "expected at most {}, {} given", required + optional, args.len() @@ -111,7 +134,7 @@ pub fn slice(input: &Value, args: &[Value]) -> FilterResult { let offset = args[0] .as_scalar() .and_then(Scalar::to_integer) - .ok_or_else(|| FilterError::InvalidArgument(0, "Whole number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Whole number expected"))?; let offset = offset as isize; let length = args @@ -119,12 +142,9 @@ pub fn slice(input: &Value, args: &[Value]) -> FilterResult { .unwrap_or(&Value::scalar(1)) .as_scalar() .and_then(Scalar::to_integer) - .ok_or_else(|| FilterError::InvalidArgument(0, "Whole number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Whole number expected"))?; if length < 1 { - return Err(FilterError::InvalidArgument( - 1, - "Positive number expected".to_owned(), - )); + return Err(invalid_argument(1, "Positive number expected")); } let length = length as isize; @@ -184,7 +204,7 @@ pub fn truncate(input: &Value, args: &[Value]) -> FilterResult { .unwrap_or(&Value::scalar(50i32)) .as_scalar() .and_then(Scalar::to_integer) - .ok_or_else(|| FilterError::InvalidArgument(0, "Whole number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Whole number expected"))?; let length = length as usize; let truncate_string = args @@ -217,7 +237,7 @@ pub fn truncatewords(input: &Value, args: &[Value]) -> FilterResult { .unwrap_or(&Value::scalar(50i32)) .as_scalar() .and_then(Scalar::to_integer) - .ok_or_else(|| FilterError::InvalidArgument(0, "Whole number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Whole number expected"))?; let words = words as usize; let truncate_string = args @@ -315,7 +335,7 @@ pub fn join(input: &Value, args: &[Value]) -> FilterResult { let input = input .as_array() - .ok_or_else(|| FilterError::InvalidType("Array of strings expected".to_owned()))?; + .ok_or_else(|| invalid_input("Array of strings expected"))?; let input = input.iter().map(|x| x.to_str()); Ok(Value::scalar(itertools::join(input, glue.as_ref()))) @@ -328,7 +348,7 @@ pub fn sort(input: &Value, args: &[Value]) -> FilterResult { let array = input .as_array() - .ok_or_else(|| FilterError::InvalidType("Array expected".to_owned()))?; + .ok_or_else(|| invalid_input("Array expected"))?; let mut sorted = array.clone(); sorted.sort_by(|a, b| a.partial_cmp(b).unwrap_or(cmp::Ordering::Equal)); Ok(Value::array(sorted)) @@ -341,7 +361,7 @@ pub fn sort_natural(input: &Value, args: &[Value]) -> FilterResult { let array = input .as_array() - .ok_or_else(|| FilterError::InvalidType("Array expected".to_owned()))?; + .ok_or_else(|| invalid_input("Array expected"))?; let mut sorted: Vec<_> = array .iter() .map(|v| (v.to_str().to_lowercase(), v.clone())) @@ -361,7 +381,7 @@ pub fn uniq(input: &Value, args: &[Value]) -> FilterResult { let array = input .as_array() - .ok_or_else(|| FilterError::InvalidType("Array expected".to_owned()))?; + .ok_or_else(|| invalid_input("Array expected"))?; let mut deduped: Vec = Vec::new(); for x in array.iter() { if !deduped.contains(x) { @@ -377,7 +397,7 @@ pub fn reverse(input: &Value, args: &[Value]) -> FilterResult { let array = input .as_array() - .ok_or_else(|| FilterError::InvalidType("Array expected".to_owned()))?; + .ok_or_else(|| invalid_input("Array expected"))?; let mut reversed = array.clone(); reversed.reverse(); Ok(Value::array(reversed)) @@ -389,7 +409,7 @@ pub fn map(input: &Value, args: &[Value]) -> FilterResult { let array = input .as_array() - .ok_or_else(|| FilterError::InvalidType("Array expected".to_owned()))?; + .ok_or_else(|| invalid_input("Array expected"))?; let property = args[0].to_str(); let property = Index::with_key(property.into_owned()); @@ -408,7 +428,7 @@ pub fn compact(input: &Value, args: &[Value]) -> FilterResult { let array = input .as_array() - .ok_or_else(|| FilterError::InvalidType("Array expected".to_owned()))?; + .ok_or_else(|| invalid_input("Array expected"))?; // TODO optional property parameter @@ -487,12 +507,12 @@ pub fn concat(input: &Value, args: &[Value]) -> FilterResult { let input = input .as_array() - .ok_or_else(|| FilterError::InvalidType("Array expected".to_owned()))?; + .ok_or_else(|| invalid_input("Array expected"))?; let input = input.iter().cloned(); let array = args[0] .as_array() - .ok_or_else(|| FilterError::InvalidArgument(0, "Array expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Array expected"))?; let array = array.iter().cloned(); let result = input.chain(array); @@ -526,9 +546,7 @@ pub fn first(input: &Value, args: &[Value]) -> FilterResult { Ok(Value::scalar(c)) } Value::Array(ref x) => Ok(x.first().cloned().unwrap_or_else(|| Value::scalar(""))), - _ => Err(FilterError::InvalidType( - "String or Array expected".to_owned(), - )), + _ => Err(invalid_input("String or Array expected")), } } @@ -546,9 +564,7 @@ pub fn last(input: &Value, args: &[Value]) -> FilterResult { Ok(Value::scalar(c)) } Value::Array(ref x) => Ok(x.last().cloned().unwrap_or_else(|| Value::scalar(""))), - _ => Err(FilterError::InvalidType( - "String or Array expected".to_owned(), - )), + _ => Err(invalid_input("String or Array expected")), } } @@ -560,20 +576,17 @@ pub fn round(input: &Value, args: &[Value]) -> FilterResult { .unwrap_or(&Value::scalar(0i32)) .as_scalar() .and_then(Scalar::to_integer) - .ok_or_else(|| FilterError::InvalidArgument(0, "Whole number expected".to_owned()))?; + .ok_or_else(|| invalid_argument(0, "Whole number expected"))?; let input = input .as_scalar() .and_then(Scalar::to_float) - .ok_or_else(|| FilterError::InvalidType("Number expected".to_owned()))?; + .ok_or_else(|| invalid_input("Number expected"))?; if n == 0 { Ok(Value::scalar(input.round() as i32)) } else if n < 0 { - Err(FilterError::InvalidArgument( - 0, - "Positive number expected".to_owned(), - )) + Err(invalid_argument(0, "Positive number expected")) } else { let multiplier = 10.0_f64.powi(n); Ok(Value::scalar((input * multiplier).round() / multiplier)) @@ -586,7 +599,7 @@ pub fn ceil(input: &Value, args: &[Value]) -> FilterResult { let n = input .as_scalar() .and_then(Scalar::to_float) - .ok_or_else(|| FilterError::InvalidType("Number expected".to_owned()))?; + .ok_or_else(|| invalid_input("Number expected"))?; Ok(Value::scalar(n.ceil() as i32)) } @@ -596,7 +609,7 @@ pub fn floor(input: &Value, args: &[Value]) -> FilterResult { let n = input .as_scalar() .and_then(Scalar::to_float) - .ok_or_else(|| FilterError::InvalidType("Number expected".to_owned()))?; + .ok_or_else(|| invalid_input("Number expected"))?; Ok(Value::scalar(n.floor() as i32)) } @@ -619,7 +632,7 @@ pub fn pluralize(input: &Value, args: &[Value]) -> FilterResult { let n = input .as_scalar() .and_then(Scalar::to_integer) - .ok_or_else(|| FilterError::InvalidType("Whole number expected".to_owned()))?; + .ok_or_else(|| invalid_input("Whole number expected"))?; if (n as isize) == 1 { Ok(args[0].clone()) } else { @@ -700,16 +713,14 @@ mod tests { fn unit_concat_wrong_type() { let input = Value::Array(vec![Value::scalar(1f64), Value::scalar(2f64)]); let args = &[Value::scalar(1f64)]; - let result = FilterError::InvalidArgument(0, "Array expected".to_owned()); - assert_eq!(failed!(concat, input, args), result); + failed!(concat, input, args); } #[test] fn unit_concat_no_args() { let input = Value::Array(vec![Value::scalar(1f64), Value::scalar(2f64)]); let args = &[]; - let result = FilterError::InvalidArgumentCount("expected at least 1, 0 given".to_owned()); - assert_eq!(failed!(concat, input, args), result); + failed!(concat, input, args); } #[test] @@ -719,8 +730,7 @@ mod tests { Value::Array(vec![Value::scalar(3f64), Value::scalar("a")]), Value::scalar(2f64), ]; - let result = FilterError::InvalidArgumentCount("expected at most 1, 2 given".to_owned()); - assert_eq!(failed!(concat, input, args), result); + failed!(concat, input, args); } #[test] @@ -893,9 +903,7 @@ mod tests { fn unit_lstrip_one_argument() { let input = &tos!(" \n \r test"); let args = &[Value::scalar(0f64)]; - let desired_result = - FilterError::InvalidArgumentCount("expected at most 0, 1 given".to_owned()); - assert_eq!(failed!(lstrip, input, args), desired_result); + failed!(lstrip, input, args); } #[test] @@ -1040,9 +1048,7 @@ mod tests { Value::scalar(2f64), ]); let args = &[Value::scalar(0f64)]; - let desired_result = - FilterError::InvalidArgumentCount("expected at most 0, 1 given".to_owned()); - assert_eq!(failed!(reverse, input, args), desired_result); + failed!(reverse, input, args); } #[test] @@ -1116,8 +1122,7 @@ mod tests { fn unit_reverse_string() { let input = &tos!("abc"); let args = &[]; - let desired_result = FilterError::InvalidType("Array expected".to_owned()); - assert_eq!(failed!(reverse, input, args), desired_result); + failed!(reverse, input, args); } #[test] @@ -1156,9 +1161,7 @@ mod tests { fn unit_rstrip_one_argument() { let input = &tos!(" \n \r test"); let args = &[Value::scalar(0f64)]; - let desired_result = - FilterError::InvalidArgumentCount("expected at most 0, 1 given".to_owned()); - assert_eq!(failed!(rstrip, input, args), desired_result); + failed!(rstrip, input, args); } #[test] @@ -1278,9 +1281,7 @@ mod tests { fn unit_strip_one_argument() { let input = &tos!(" \n \r test \n \r "); let args = &[Value::scalar(0f64)]; - let desired_result = - FilterError::InvalidArgumentCount("expected at most 0, 1 given".to_owned()); - assert_eq!(failed!(strip, input, args), desired_result); + failed!(strip, input, args); } #[test] @@ -1336,9 +1337,7 @@ mod tests { fn unit_strip_newlines_one_argument() { let input = &tos!("ab\n"); let args = &[Value::scalar(0f64)]; - let desired_result = - FilterError::InvalidArgumentCount("expected at most 0, 1 given".to_owned()); - assert_eq!(failed!(strip_newlines, input, args), desired_result); + failed!(strip_newlines, input, args); } #[test] @@ -1403,9 +1402,7 @@ mod tests { fn unit_truncate_three_arguments() { let input = &tos!("I often quote myself. It adds spice to my conversation."); let args = &[Value::scalar(17i32), tos!("..."), Value::scalar(0i32)]; - let desired_result = - FilterError::InvalidArgumentCount("expected at most 2, 3 given".to_string()); - assert_eq!(failed!(truncate, input, args), desired_result); + failed!(truncate, input, args); } #[test] @@ -1513,17 +1510,14 @@ mod tests { fn unit_uniq_non_array() { let input = &Value::scalar(0f64); let args = &[]; - let desired_result = FilterError::InvalidType("Array expected".to_string()); - assert_eq!(failed!(uniq, input, args), desired_result); + failed!(uniq, input, args); } #[test] fn unit_uniq_one_argument() { let input = &Value::Array(vec![tos!("a"), tos!("b"), tos!("a")]); let args = &[Value::scalar(0f64)]; - let desired_result = - FilterError::InvalidArgumentCount("expected at most 0, 1 given".to_string()); - assert_eq!(failed!(uniq, input, args), desired_result); + failed!(uniq, input, args); } #[test] diff --git a/src/filters/url.rs b/src/filters/url.rs index 6f5d32ff1..759f3eefa 100644 --- a/src/filters/url.rs +++ b/src/filters/url.rs @@ -2,9 +2,9 @@ use liquid_value::Value; use url::percent_encoding; use url::percent_encoding::EncodeSet; -use interpreter::{FilterError, FilterResult}; +use interpreter::FilterResult; -use super::check_args_len; +use super::{check_args_len, invalid_input}; #[derive(Clone)] struct UrlEncodeSet(String); @@ -52,7 +52,7 @@ pub fn url_decode(input: &Value, args: &[Value]) -> FilterResult { let result = percent_encoding::percent_decode(s.as_bytes()) .decode_utf8() - .map_err(|_| FilterError::InvalidType("Malformed UTF-8".to_owned()))? + .map_err(|_| invalid_input("Malformed UTF-8"))? .into_owned(); Ok(Value::scalar(result)) }