De-macro-fy data parsing

The code is more legible without them, I think. I'm not sure their
complexity is justified.

Signed-off-by: Jim Crossley <[email protected]>

Author: jcrossley3

src/event/format.rs

@@ -48,33 +48,23 @@ macro_rules! extract_field {
     };
 }
 
-macro_rules! parse_data_json {
-    ($in:ident, $error:ty) => {
-        serde_json::Value::deserialize($in.into_deserializer()).map_err(<$error>::custom)
-    };
+pub fn parse_data_json<E: serde::de::Error>(v: Value) -> Result<Value, E> {
+    Value::deserialize(v.into_deserializer()).map_err(E::custom)
 }
 
-macro_rules! parse_data_string {
-    ($in:ident, $error:ty) => {
-        parse_field!($in, String, $error)
-    };
+pub fn parse_data_string<E: serde::de::Error>(v: Value) -> Result<String, E> {
+    parse_field!(v, String, E)
 }
 
-macro_rules! parse_json_data_base64 {
-    ($in:ident, $error:ty) => {{
-        let data = parse_data_base64!($in, $error)?;
-        serde_json::from_slice(&data).map_err(<$error>::custom)
-    }};
+pub fn parse_data_base64<E: serde::de::Error>(v: Value) -> Result<Vec<u8>, E> {
+    parse_field!(v, String, E).and_then(|s| {
+        base64::decode(&s).map_err(|e| E::custom(format_args!("decode error `{}`", e)))
+    })
 }
 
-macro_rules! parse_data_base64 {
-    ($in:ident, $error:ty) => {
-        parse_field!($in, String, $error).and_then(|s| {
-            base64::decode(&s).map_err(|e| {
-                <$error>::invalid_value(serde::de::Unexpected::Str(&s), &e.to_string().as_str())
-            })
-        })
-    };
+pub fn parse_data_base64_json<E: serde::de::Error>(v: Value) -> Result<Value, E> {
+    let data = parse_data_base64(v)?;
+    serde_json::from_slice(&data).map_err(E::custom)
 }
 
 pub(crate) trait EventFormatDeserializer {

src/event/v03/format.rs

@@ -1,5 +1,8 @@
 use super::Attributes;
 use crate::event::data::is_json_content_type;
+use crate::event::format::{
+    parse_data_base64, parse_data_base64_json, parse_data_json, parse_data_string,
+};
 use crate::event::{Data, ExtensionValue};
 use chrono::{DateTime, Utc};
 use serde::de::IntoDeserializer;
@@ -45,10 +48,10 @@ impl crate::event::format::EventFormatDeserializer for EventFormatDeserializer {
         let is_json = is_json_content_type(content_type);
 
         Ok(match (data, is_base64, is_json) {
-            (Some(d), false, true) => Some(Data::Json(parse_data_json!(d, E)?)),
-            (Some(d), false, false) => Some(Data::String(parse_data_string!(d, E)?)),
-            (Some(d), true, true) => Some(Data::Json(parse_json_data_base64!(d, E)?)),
-            (Some(d), true, false) => Some(Data::Binary(parse_data_base64!(d, E)?)),
+            (Some(d), false, true) => Some(Data::Json(parse_data_json(d)?)),
+            (Some(d), false, false) => Some(Data::String(parse_data_string(d)?)),
+            (Some(d), true, true) => Some(Data::Json(parse_data_base64_json(d)?)),
+            (Some(d), true, false) => Some(Data::Binary(parse_data_base64(d)?)),
             (None, _, _) => None,
         })
     }

src/event/v10/format.rs

@@ -1,5 +1,8 @@
 use super::Attributes;
 use crate::event::data::is_json_content_type;
+use crate::event::format::{
+    parse_data_base64, parse_data_base64_json, parse_data_json, parse_data_string,
+};
 use crate::event::{Data, ExtensionValue};
 use chrono::{DateTime, Utc};
 use serde::de::IntoDeserializer;
@@ -40,16 +43,13 @@ impl crate::event::format::EventFormatDeserializer for EventFormatDeserializer {
         let is_json = is_json_content_type(content_type);
 
         Ok(match (data, data_base64, is_json) {
-            (Some(d), None, true) => Some(Data::Json(parse_data_json!(d, E)?)),
-            (Some(d), None, false) => Some(Data::String(parse_data_string!(d, E)?)),
-            (None, Some(d), true) => {
-                let dc = d.to_owned();
-                match parse_json_data_base64!(dc, E) {
-                    Ok(x) => Some(Data::Json(x)),
-                    Err(_) => Some(Data::Binary(parse_data_base64!(d, E)?)),
-                }
-            }
-            (None, Some(d), false) => Some(Data::Binary(parse_data_base64!(d, E)?)),
+            (Some(d), None, true) => Some(Data::Json(parse_data_json(d)?)),
+            (Some(d), None, false) => Some(Data::String(parse_data_string(d)?)),
+            (None, Some(d), true) => match parse_data_base64_json::<E>(d.to_owned()) {
+                Ok(x) => Some(Data::Json(x)),
+                Err(_) => Some(Data::Binary(parse_data_base64(d)?)),
+            },
+            (None, Some(d), false) => Some(Data::Binary(parse_data_base64(d)?)),
             (Some(_), Some(_), _) => {
                 return Err(E::custom("Cannot have both data and data_base64 field"))
             }