diff options
author | Pro <twisted.fall@gmail.com> | 2024-02-09 21:50:53 +0100 |
---|---|---|
committer | Pro <twisted.fall@gmail.com> | 2024-02-09 21:50:53 +0100 |
commit | 3fe862d63b4be68f62f8de737c5322ce22ea8dd9 (patch) | |
tree | af204fc81bd4dc849ea20faf16a4c7e62104c94b /src/parser/timetype.rs | |
parent | fbf408b649322c7587dbda34656774a458c2ad46 (diff) |
Update nom and iso8601 dependencies
Diffstat (limited to 'src/parser/timetype.rs')
-rw-r--r-- | src/parser/timetype.rs | 340 |
1 files changed, 182 insertions, 158 deletions
diff --git a/src/parser/timetype.rs b/src/parser/timetype.rs index 7106d77..b957434 100644 --- a/src/parser/timetype.rs +++ b/src/parser/timetype.rs @@ -1,52 +1,69 @@ use std::str; -use std::str::FromStr; -use nom::digit; -use nom::whitespace::sp; use chrono::NaiveDate; +use iso8601::parsers::{parse_date, parse_datetime}; +use nom::branch::alt; +use nom::bytes::complete::tag; +use nom::character::complete::{digit1, multispace0, multispace1}; +use nom::combinator::{complete, map, map_opt, opt}; +use nom::IResult; +use nom::sequence::{delimited, tuple}; -use timetype::IntoTimeType; -use timetype; -use error::Result; use error::Error; +use error::Result; +use timetype; +use timetype::IntoTimeType; -named!(pub integer<i64>, alt!( - map_res!( - map_res!( - ws!(digit), - str::from_utf8 - ), - FromStr::from_str - ) -)); +pub fn integer(input: &[u8]) -> IResult<&[u8], i64> { + map_opt( + delimited(multispace0, digit1, multispace0), + |digit| str::from_utf8(digit).ok().and_then(|s| s.parse().ok()), + )(input) +} // WARNING: Order is important here. Long tags first, shorter tags later -named!(pub unit_parser<Unit>, alt_complete!( - tag!("seconds") => { |_| Unit::Second } | - tag!("second") => { |_| Unit::Second } | - tag!("secs") => { |_| Unit::Second } | - tag!("sec") => { |_| Unit::Second } | - tag!("s") => { |_| Unit::Second } | - tag!("minutes") => { |_| Unit::Minute } | - tag!("minute") => { |_| Unit::Minute } | - tag!("mins") => { |_| Unit::Minute } | - tag!("min") => { |_| Unit::Minute } | - tag!("hours") => { |_| Unit::Hour } | - tag!("hour") => { |_| Unit::Hour } | - tag!("hrs") => { |_| Unit::Hour } | - tag!("hr") => { |_| Unit::Hour } | - tag!("days") => { |_| Unit::Day } | - tag!("day") => { |_| Unit::Day } | - tag!("d") => { |_| Unit::Day } | - tag!("weeks") => { |_| Unit::Week } | - tag!("week") => { |_| Unit::Week } | - tag!("w") => { |_| Unit::Week } | - tag!("months") => { |_| Unit::Month } | - tag!("month") => { |_| Unit::Month } | - tag!("years") => { |_| Unit::Year } | - tag!("year") => { |_| Unit::Year } | - tag!("yrs") => { |_| Unit::Year } -)); +pub fn unit_parser(input: &[u8]) -> IResult<&[u8], Unit> { + complete(alt(( + map(alt(( + tag("seconds"), + tag("second"), + tag("secs"), + tag("sec"), + tag("s"), ) + ), |_| Unit::Second), + map(alt(( + tag("minutes"), + tag("minute"), + tag("mins"), + tag("min"), + )), |_| Unit::Minute), + map(alt(( + tag("hours"), + tag("hour"), + tag("hrs"), + tag("hr"), + )), |_| Unit::Hour), + map(alt(( + tag("days"), + tag("day"), + tag("d"), + )), |_| Unit::Day), + map(alt(( + tag("weeks"), + tag("week"), + tag("w"), + )), |_| Unit::Week), + map(alt(( + tag("months"), + tag("month"), + )), |_| Unit::Month), + map(alt(( + tag("years"), + tag("year"), + tag("yrs"), + )), |_| Unit::Year), + ))(input) +} #[derive(Debug, PartialEq, Eq)] pub enum Unit { @@ -84,10 +101,12 @@ impl From<UnitAlias> for Unit { } } -named!(pub operator_parser<Operator>, alt!( - tag!("+") => { |_| Operator::Plus } | - tag!("-") => { |_| Operator::Minus } -)); +pub fn operator_parser(input: &[u8]) -> IResult<&[u8], Operator> { + alt(( + map(tag("+"), |_| Operator::Plus), + map(tag("-"), |_| Operator::Minus), + ))(input) +} #[derive(Debug, PartialEq, Eq)] pub enum Operator { @@ -95,20 +114,24 @@ pub enum Operator { Minus, } -named!(pub unit_alias<UnitAlias>, alt_complete!( - tag!("secondly") => { |_| UnitAlias::Secondly } | - tag!("minutely") => { |_| UnitAlias::Minutely } | - tag!("hourly") => { |_| UnitAlias::Hourly } | - tag!("daily") => { |_| UnitAlias::Daily } | - tag!("weekly") => { |_| UnitAlias::Weekly } | - tag!("monthly") => { |_| UnitAlias::Monthly } | - tag!("yearly") => { |_| UnitAlias::Yearly } -)); - -named!(pub amount_parser<Amount>, alt!( - do_parse!(number: integer >> unit: unit_parser >> (Amount(number, unit))) | - do_parse!(unitalias: unit_alias >> (Amount(1, unitalias.into()))) -)); +pub fn unit_alias(input: &[u8]) -> IResult<&[u8], UnitAlias> { + complete(alt(( + map(tag("secondly"), |_| UnitAlias::Secondly), + map(tag("minutely"), |_| UnitAlias::Minutely), + map(tag("hourly"), |_| UnitAlias::Hourly), + map(tag("daily"), |_| UnitAlias::Daily), + map(tag("weekly"), |_| UnitAlias::Weekly), + map(tag("monthly"), |_| UnitAlias::Monthly), + map(tag("yearly"), |_| UnitAlias::Yearly), + )))(input) +} + +pub fn amount_parser(input: &[u8]) -> IResult<&[u8], Amount> { + alt(( + map(tuple((integer, unit_parser)), |(number, unit)| Amount(number, unit)), + map(unit_alias, |unit| Amount(1, unit.into())), + ))(input) +} #[derive(Debug, PartialEq, Eq)] pub struct Amount(i64, Unit); @@ -127,19 +150,18 @@ impl IntoTimeType for Amount { } } -named!(pub amount_expr_next<(Operator, Box<AmountExpr>)>, do_parse!( - op:operator_parser - >> opt!(sp) - >> amexp:amount_expr - >> ((op, Box::new(amexp))) -)); +pub fn amount_expr_next(input: &[u8]) -> IResult<&[u8], (Operator, Box<AmountExpr>)> { + map( + tuple((operator_parser, multispace0, amount_expr)), + |(op, _, amexp)| (op, Box::new(amexp)), + )(input) +} -named!(pub amount_expr<AmountExpr>, do_parse!( - amount:amount_parser >> - opt!(sp) >> - o: opt!(complete!(amount_expr_next)) >> - (AmountExpr { amount, next: o, }) -)); +pub fn amount_expr(input: &[u8]) -> IResult<&[u8], AmountExpr> { + map(tuple(( + amount_parser, multispace0, opt(complete(amount_expr_next)), + )), |(amount, _, next)| AmountExpr { amount, next })(input) +} #[derive(Debug, PartialEq, Eq)] pub struct AmountExpr { @@ -162,17 +184,17 @@ impl IntoTimeType for AmountExpr { } } -use iso8601::parsers::parse_date; -use iso8601::parsers::parse_datetime; // The order is relevant here, because datetime is longer than date, we must parse datetime before // date. -named!(pub exact_date_parser<ExactDate>, alt_complete!( - tag!("today") => { |_| ExactDate::Today } | - tag!("yesterday") => { |_| ExactDate::Yesterday } | - tag!("tomorrow") => { |_| ExactDate::Tomorrow } | - do_parse!(d: parse_datetime >> (ExactDate::Iso8601DateTime(d))) | - do_parse!(d: parse_date >> (ExactDate::Iso8601Date(d))) -)); +pub fn exact_date_parser(input: &[u8]) -> IResult<&[u8], ExactDate> { + complete(alt(( + map(tag("today"), |_| ExactDate::Today), + map(tag("yesterday"), |_| ExactDate::Yesterday), + map(tag("tomorrow"), |_| ExactDate::Tomorrow), + map(parse_datetime, ExactDate::Iso8601DateTime), + map(parse_date, ExactDate::Iso8601Date), + )))(input) +} #[derive(Debug, PartialEq, Eq)] pub enum ExactDate { @@ -252,13 +274,14 @@ impl IntoTimeType for ExactDate { } } -named!(pub date<Date>, do_parse!( - exact: exact_date_parser >> - o: opt!( - complete!(do_parse!(sp >> op:operator_parser >> sp >> a:amount_expr >> (op, a))) - ) >> - (Date(exact, o)) -)); +pub fn date(input: &[u8]) -> IResult<&[u8], Date> { + map( + tuple((exact_date_parser, + opt(complete(map(tuple((multispace1, operator_parser, multispace1, amount_expr)), |(_, op, _, a)| (op, a)))) + )), + |(exact, o)| Date(exact, o), + )(input) +} #[derive(Debug, PartialEq, Eq)] pub struct Date(ExactDate, Option<(Operator, AmountExpr)>); @@ -297,14 +320,15 @@ impl IntoTimeType for TimeType { // Note that this function returns a parser::TimeType, not a timetype::TimeType. Though, the // parser::TimeType can be `Into::into()`ed. // -named!(pub timetype<TimeType>, alt!( - do_parse!(d: date >> (TimeType::Date(d))) | - do_parse!(a: amount_expr >> (TimeType::AmountExpr(a))) -)); +pub fn timetype(input: &[u8]) -> IResult<&[u8], TimeType> { + alt(( + map(date, TimeType::Date), + map(amount_expr, TimeType::AmountExpr), + ))(input) +} #[cfg(test)] mod tests { - use nom::IResult; use super::*; use chrono::Timelike; @@ -312,99 +336,99 @@ mod tests { #[test] fn test_integer() { - assert_eq!(integer(&b"2"[..]), IResult::Done(&b""[..], 2)); - assert_eq!(integer(&b"217"[..]), IResult::Done(&b""[..], 217)); + assert_eq!(integer(&b"2"[..]), Ok((&b""[..], 2))); + assert_eq!(integer(&b"217"[..]), Ok((&b""[..], 217))); } #[test] fn test_unit() { - assert_eq!(unit_parser(&b"second"[..]), IResult::Done(&b""[..], Unit::Second)); - assert_eq!(unit_parser(&b"seconds"[..]), IResult::Done(&b""[..], Unit::Second)); - assert_eq!(unit_parser(&b"sec"[..]), IResult::Done(&b""[..], Unit::Second)); - assert_eq!(unit_parser(&b"secs"[..]), IResult::Done(&b""[..], Unit::Second)); - assert_eq!(unit_parser(&b"s"[..]), IResult::Done(&b""[..], Unit::Second)); - assert_eq!(unit_parser(&b"minute"[..]), IResult::Done(&b""[..], Unit::Minute)); - assert_eq!(unit_parser(&b"minutes"[..]), IResult::Done(&b""[..], Unit::Minute)); - assert_eq!(unit_parser(&b"min"[..]), IResult::Done(&b""[..], Unit::Minute)); - assert_eq!(unit_parser(&b"mins"[..]), IResult::Done(&b""[..], Unit::Minute)); - assert_eq!(unit_parser(&b"hour"[..]), IResult::Done(&b""[..], Unit::Hour)); - assert_eq!(unit_parser(&b"hours"[..]), IResult::Done(&b""[..], Unit::Hour)); - assert_eq!(unit_parser(&b"hr"[..]), IResult::Done(&b""[..], Unit::Hour)); - assert_eq!(unit_parser(&b"hrs"[..]), IResult::Done(&b""[..], Unit::Hour)); - assert_eq!(unit_parser(&b"day"[..]), IResult::Done(&b""[..], Unit::Day)); - assert_eq!(unit_parser(&b"days"[..]), IResult::Done(&b""[..], Unit::Day)); - assert_eq!(unit_parser(&b"d"[..]), IResult::Done(&b""[..], Unit::Day)); - assert_eq!(unit_parser(&b"week"[..]), IResult::Done(&b""[..], Unit::Week)); - assert_eq!(unit_parser(&b"weeks"[..]), IResult::Done(&b""[..], Unit::Week)); - assert_eq!(unit_parser(&b"w"[..]), IResult::Done(&b""[..], Unit::Week)); - assert_eq!(unit_parser(&b"month"[..]), IResult::Done(&b""[..], Unit::Month)); - assert_eq!(unit_parser(&b"months"[..]), IResult::Done(&b""[..], Unit::Month)); - assert_eq!(unit_parser(&b"year"[..]), IResult::Done(&b""[..], Unit::Year)); - assert_eq!(unit_parser(&b"years"[..]), IResult::Done(&b""[..], Unit::Year)); - assert_eq!(unit_parser(&b"yrs"[..]), IResult::Done(&b""[..], Unit::Year)); + assert_eq!(unit_parser(&b"second"[..]), Ok((&b""[..], Unit::Second))); + assert_eq!(unit_parser(&b"seconds"[..]), Ok((&b""[..], Unit::Second))); + assert_eq!(unit_parser(&b"sec"[..]), Ok((&b""[..], Unit::Second))); + assert_eq!(unit_parser(&b"secs"[..]), Ok((&b""[..], Unit::Second))); + assert_eq!(unit_parser(&b"s"[..]), Ok((&b""[..], Unit::Second))); + assert_eq!(unit_parser(&b"minute"[..]), Ok((&b""[..], Unit::Minute))); + assert_eq!(unit_parser(&b"minutes"[..]), Ok((&b""[..], Unit::Minute))); + assert_eq!(unit_parser(&b"min"[..]), Ok((&b""[..], Unit::Minute))); + assert_eq!(unit_parser(&b"mins"[..]), Ok((&b""[..], Unit::Minute))); + assert_eq!(unit_parser(&b"hour"[..]), Ok((&b""[..], Unit::Hour))); + assert_eq!(unit_parser(&b"hours"[..]), Ok((&b""[..], Unit::Hour))); + assert_eq!(unit_parser(&b"hr"[..]), Ok((&b""[..], Unit::Hour))); + assert_eq!(unit_parser(&b"hrs"[..]), Ok((&b""[..], Unit::Hour))); + assert_eq!(unit_parser(&b"day"[..]), Ok((&b""[..], Unit::Day))); + assert_eq!(unit_parser(&b"days"[..]), Ok((&b""[..], Unit::Day))); + assert_eq!(unit_parser(&b"d"[..]), Ok((&b""[..], Unit::Day))); + assert_eq!(unit_parser(&b"week"[..]), Ok((&b""[..], Unit::Week))); + assert_eq!(unit_parser(&b"weeks"[..]), Ok((&b""[..], Unit::Week))); + assert_eq!(unit_parser(&b"w"[..]), Ok((&b""[..], Unit::Week))); + assert_eq!(unit_parser(&b"month"[..]), Ok((&b""[..], Unit::Month))); + assert_eq!(unit_parser(&b"months"[..]), Ok((&b""[..], Unit::Month))); + assert_eq!(unit_parser(&b"year"[..]), Ok((&b""[..], Unit::Year))); + assert_eq!(unit_parser(&b"years"[..]), Ok((&b""[..], Unit::Year))); + assert_eq!(unit_parser(&b"yrs"[..]), Ok((&b""[..], Unit::Year))); } #[test] fn test_unit_alias() { - assert_eq!(unit_alias(&b"secondly"[..]), IResult::Done(&b""[..], UnitAlias::Secondly)); - assert_eq!(unit_alias(&b"minutely"[..]), IResult::Done(&b""[..], UnitAlias::Minutely)); - assert_eq!(unit_alias(&b"hourly"[..]), IResult::Done(&b""[..], UnitAlias::Hourly)); - assert_eq!(unit_alias(&b"daily"[..]), IResult::Done(&b""[..], UnitAlias::Daily)); - assert_eq!(unit_alias(&b"weekly"[..]), IResult::Done(&b""[..], UnitAlias::Weekly)); - assert_eq!(unit_alias(&b"monthly"[..]), IResult::Done(&b""[..], UnitAlias::Monthly)); - assert_eq!(unit_alias(&b"yearly"[..]), IResult::Done(&b""[..], UnitAlias::Yearly)); + assert_eq!(unit_alias(&b"secondly"[..]), Ok((&b""[..], UnitAlias::Secondly))); + assert_eq!(unit_alias(&b"minutely"[..]), Ok((&b""[..], UnitAlias::Minutely))); + assert_eq!(unit_alias(&b"hourly"[..]), Ok((&b""[..], UnitAlias::Hourly))); + assert_eq!(unit_alias(&b"daily"[..]), Ok((&b""[..], UnitAlias::Daily))); + assert_eq!(unit_alias(&b"weekly"[..]), Ok((&b""[..], UnitAlias::Weekly))); + assert_eq!(unit_alias(&b"monthly"[..]), Ok((&b""[..], UnitAlias::Monthly))); + assert_eq!(unit_alias(&b"yearly"[..]), Ok((&b""[..], UnitAlias::Yearly))); } #[test] fn test_operator() { - assert_eq!(operator_parser(&b"+"[..]), IResult::Done(&b""[..], Operator::Plus)); - assert_eq!(operator_parser(&b"-"[..]), IResult::Done(&b""[..], Operator::Minus)); + assert_eq!(operator_parser(&b"+"[..]), Ok((&b""[..], Operator::Plus))); + assert_eq!(operator_parser(&b"-"[..]), Ok((&b""[..], Operator::Minus))); } #[test] fn test_amount() { - assert_eq!(amount_parser(&b"5s"[..]), IResult::Done(&b""[..], Amount(5, Unit::Second))); - assert_eq!(amount_parser(&b"5min"[..]), IResult::Done(&b""[..], Amount(5, Unit::Minute))); - assert_eq!(amount_parser(&b"55hrs"[..]), IResult::Done(&b""[..], Amount(55, Unit::Hour))); - assert_eq!(amount_parser(&b"25days"[..]), IResult::Done(&b""[..], Amount(25, Unit::Day))); - assert_eq!(amount_parser(&b"15weeks"[..]), IResult::Done(&b""[..], Amount(15, Unit::Week))); + assert_eq!(amount_parser(&b"5s"[..]), Ok((&b""[..], Amount(5, Unit::Second)))); + assert_eq!(amount_parser(&b"5min"[..]), Ok((&b""[..], Amount(5, Unit::Minute)))); + assert_eq!(amount_parser(&b"55hrs"[..]), Ok((&b""[..], Amount(55, Unit::Hour)))); + assert_eq!(amount_parser(&b"25days"[..]), Ok((&b""[..], Amount(25, Unit::Day)))); + assert_eq!(amount_parser(&b"15weeks"[..]), Ok((&b""[..], Amount(15, Unit::Week)))); } #[test] fn test_unit_alias_with_amount_parser() { - assert_eq!(amount_parser(&b"secondly"[..]), IResult::Done(&b""[..], Amount(1, Unit::Second))); - assert_eq!(amount_parser(&b"minutely"[..]), IResult::Done(&b""[..], Amount(1, Unit::Minute))); - assert_eq!(amount_parser(&b"hourly"[..]), IResult::Done(&b""[..], Amount(1, Unit::Hour))); - assert_eq!(amount_parser(&b"daily"[..]), IResult::Done(&b""[..], Amount(1, Unit::Day))); - assert_eq!(amount_parser(&b"weekly"[..]), IResult::Done(&b""[..], Amount(1, Unit::Week))); - assert_eq!(amount_parser(&b"monthly"[..]), IResult::Done(&b""[..], Amount(1, Unit::Month))); - assert_eq!(amount_parser(&b"yearly"[..]), IResult::Done(&b""[..], Amount(1, Unit::Year))); + assert_eq!(amount_parser(&b"secondly"[..]), Ok((&b""[..], Amount(1, Unit::Second)))); + assert_eq!(amount_parser(&b"minutely"[..]), Ok((&b""[..], Amount(1, Unit::Minute)))); + assert_eq!(amount_parser(&b"hourly"[..]), Ok((&b""[..], Amount(1, Unit::Hour)))); + assert_eq!(amount_parser(&b"daily"[..]), Ok((&b""[..], Amount(1, Unit::Day)))); + assert_eq!(amount_parser(&b"weekly"[..]), Ok((&b""[..], Amount(1, Unit::Week)))); + assert_eq!(amount_parser(&b"monthly"[..]), Ok((&b""[..], Amount(1, Unit::Month)))); + assert_eq!(amount_parser(&b"yearly"[..]), Ok((&b""[..], Amount(1, Unit::Year)))); } #[test] fn test_amountexpr_next() { assert_eq!(amount_expr_next(&b"+ 12minutes"[..]), - IResult::Done(&b""[..], + Ok((&b""[..], ( Operator::Plus, Box::new(AmountExpr { amount: Amount(12, Unit::Minute), next: None }) ) - )); + ))); } #[test] fn test_amountexpr() { assert_eq!(amount_expr(&b"5minutes"[..]), - IResult::Done(&b""[..], + Ok((&b""[..], AmountExpr { amount: Amount(5, Unit::Minute), next: None }) - ); + )); assert_eq!(amount_expr(&b"5min + 12min"[..]), - IResult::Done(&b""[..], + Ok((&b""[..], AmountExpr { amount: Amount(5, Unit::Minute), next: Some((Operator::Plus, Box::new( @@ -412,14 +436,14 @@ mod tests { amount: Amount(12, Unit::Minute), next: None }))) - })); + }))); } #[test] fn test_parse_expressions_date() { use iso8601::Date; let res = exact_date_parser(&b"2017-01-01"[..]); - assert!(res.is_done()); + assert!(res.is_ok()); match res.unwrap().1 { ExactDate::Iso8601DateTime(_) => panic!("Unexpected enum variant"), @@ -443,7 +467,7 @@ mod tests { fn test_parse_expressions_datetime() { use iso8601::Date; let res = exact_date_parser(&b"2017-01-01T22:00:11"[..]); - assert!(res.is_done()); + assert!(res.is_ok()); match res.unwrap().1 { ExactDate::Iso8601DateTime(obj) => { @@ -469,16 +493,16 @@ mod tests { #[test] fn test_simple_date_1() { let res = exact_date_parser(&b"today"[..]); - assert!(res.is_done(), "Not done: {:?}", res); + assert!(res.is_ok(), "Not done: {:?}", res); let res = date(&b"today"[..]); - assert!(res.is_done(), "Not done: {:?}", res); + assert!(res.is_ok(), "Not done: {:?}", res); } #[test] fn test_simple_date_2() { let res = date(&b"2017-01-01"[..]); - assert!(res.is_done(), "Not done: {:?}", res); + assert!(res.is_ok(), "Not done: {:?}", res); let (_, o) = res.unwrap(); println!("{:#?}", o); @@ -501,7 +525,7 @@ mod tests { #[test] fn test_simple_date_3() { let res = date(&b"2017-01-01T01:02:03"[..]); - assert!(res.is_done(), "Not done: {:?}", res); + assert!(res.is_ok(), "Not done: {:?}", res); let (_, o) = res.unwrap(); println!("{:#?}", o); @@ -524,7 +548,7 @@ mod tests { #[test] fn test_expressions_to_date() { let res = amount_expr(&b"5min + 12min"[..]); - assert!(res.is_done()); + assert!(res.is_ok()); let (_, o) = res.unwrap(); let calc_res : timetype::TimeType = o.into_timetype().unwrap(); @@ -542,7 +566,7 @@ mod tests { #[test] fn test_expressions_to_date_2() { let res = amount_expr(&b"5min + 12min + 15hours"[..]); - assert!(res.is_done()); + assert!(res.is_ok()); let (_, o) = res.unwrap(); let calc_res : timetype::TimeType = o.into_timetype().unwrap(); @@ -560,7 +584,7 @@ mod tests { #[test] fn test_expressions_to_date_3() { let res = date(&b"today + 5min + 12min"[..]); - assert!(res.is_done(), "Not done: {:?}", res.unwrap_err().description()); + assert!(res.is_ok(), "Not done: {:?}", res.unwrap_err()); let (_, o) = res.unwrap(); let calc_res : timetype::TimeType = o.into_timetype().unwrap(); @@ -575,7 +599,7 @@ mod tests { #[test] fn test_expressions_to_date_4() { let res = date(&b"2017-01-01 + 5min + 12min"[..]); - assert!(res.is_done(), "Not done: {:?}", res.unwrap_err().description()); + assert!(res.is_ok(), "Not done: {:?}", res.unwrap_err()); let (_, o) = res.unwrap(); println!("{:#?}", o); @@ -598,7 +622,7 @@ mod tests { #[test] fn test_expressions_to_timetype() { let res = timetype(&b"5min + 12min + 15hours"[..]); - assert!(res.is_done()); + assert!(res.is_ok()); let (_, o) = res.unwrap(); let calc_res : ::timetype::TimeType = o.into_timetype().unwrap(); @@ -616,7 +640,7 @@ mod tests { #[test] fn test_expressions_to_timetype_2() { let res = timetype(&b"today + 5min + 12min"[..]); - assert!(res.is_done(), "Not done: {:?}", res.unwrap_err().description()); + assert!(res.is_ok(), "Not done: {:?}", res.unwrap_err()); let (_, o) = res.unwrap(); let calc_res : ::timetype::TimeType = o.into_timetype().unwrap(); @@ -631,7 +655,7 @@ mod tests { #[test] fn test_expressions_to_timetype_subtract() { let res = timetype(&b"5min + 12min + 15hours - 1hour"[..]); - assert!(res.is_done()); + assert!(res.is_ok()); let (_, o) = res.unwrap(); println!("{:#?}", o); |