trim whitespace when parsing to typed values

Author: cammeresi

src/parse/mod.rs

@@ -106,25 +106,25 @@ impl TagDecoder {
     ) -> Result<Datum, Error> {
         match typ {
             Some("n") | Some("N") => {
-                let num =
-                    Decimal::from_str(v).map_err(|_| self.invalid_tag(tag))?;
+                let num = Decimal::from_str(v.trim())
+                    .map_err(|_| self.invalid_tag(tag))?;
                 Ok(Datum::Number(num))
             }
             Some("b") | Some("B") => {
-                let b = match v {
+                let b = match v.trim() {
                     "Y" | "y" => true,
                     "N" | "n" => false,
                     _ => return Err(self.invalid_tag(tag)),
                 };
                 Ok(Datum::Boolean(b))
             }
             Some("d") | Some("D") => {
-                let date = NaiveDate::parse_from_str(v, "%Y%m%d")
+                let date = NaiveDate::parse_from_str(v.trim(), "%Y%m%d")
                     .map_err(|_| self.invalid_tag(tag))?;
                 Ok(Datum::Date(date))
             }
             Some("t") | Some("T") => {
-                let time = NaiveTime::parse_from_str(v, "%H%M%S")
+                let time = NaiveTime::parse_from_str(v.trim(), "%H%M%S")
                     .map_err(|_| self.invalid_tag(tag))?;
                 Ok(Datum::Time(time))
             }

src/parse/test.rs

@@ -192,6 +192,38 @@ async fn underscore() {
     no_tags(&mut f).await;
 }
 
+#[tokio::test]
+async fn trim_typed() {
+    let mut f = tags("<a:5:n> 1.0 <b:3:b> Y <c:10:d> 20200101 <d:8:t> 123456 ");
+
+    let field = next_field(&mut f).await;
+    assert_eq!(field.name(), "a");
+    assert_eq!(
+        field.value().as_number().unwrap(),
+        Decimal::from_str("1.0").unwrap()
+    );
+
+    let field = next_field(&mut f).await;
+    assert_eq!(field.name(), "b");
+    assert!(field.value().as_bool().unwrap());
+
+    let field = next_field(&mut f).await;
+    assert_eq!(field.name(), "c");
+    assert_eq!(
+        field.value().as_date().unwrap(),
+        NaiveDate::from_ymd_opt(2020, 1, 1).unwrap()
+    );
+
+    let field = next_field(&mut f).await;
+    assert_eq!(field.name(), "d");
+    assert_eq!(
+        field.value().as_time().unwrap(),
+        NaiveTime::from_hms_opt(12, 34, 56).unwrap()
+    );
+
+    no_tags(&mut f).await;
+}
+
 #[tokio::test]
 async fn case_insensitive_lookup() {
     let mut s = RecordStream::new("<FOO:3>Bar<eor>".as_bytes(), true);