Refactor serialization and add error handling in blk_type.

src/blk/blk_type.rs

@@ -1,11 +1,13 @@
 use std::{
-	fmt::{Display, Formatter},
+	fmt::{Display, Formatter as StdFormatter},
 	sync::Arc,
 };
+use color_eyre::eyre::bail;
+use color_eyre::Report;
 
 use serde::{Deserialize, Serialize, Serializer};
 use serde::ser::{SerializeSeq, SerializeStruct};
-use serde_json::ser::PrettyFormatter;
+use serde_json::ser::{Formatter, PrettyFormatter};
 
 use crate::blk::{
 	blk_type::blk_type_id::*,
@@ -270,18 +272,20 @@ impl BlkType {
 			"c"
 		)
 	}
-	pub fn serialize_streaming(self, w: &mut serde_json::Serializer<Vec<u8>, PrettyFormatter>) {
+	pub fn serialize_streaming(&self, w: &mut Vec<u8>, ser: &mut PrettyFormatter) -> Result<(), Report> {
+		bail!("fuck");
 		match self {
 			BlkType::Str(s) => {
-				w.serialize_str(&s).unwrap();
+				ser.begin_string(w)?;
+				ser.write_string_fragment(w, s.as_ref())?;
+				ser.end_string(w)?;
 			}
 			BlkType::Int(s) => {
-				w.serialize_i32(s).unwrap();
+				ser.write_i32(w, *s)?;
 			}
 			BlkType::Int2(s) => {
-				let mut seq = w.serialize_seq(Some(2)).unwrap();
-				seq.serialize_element(&s).unwrap();
-				SerializeSeq::end(seq).unwrap();
+				ser.begin_array(w)?;
+				//ser.begin_ar
 			}
 			BlkType::Int3(s) => {
 				()
@@ -297,11 +301,19 @@ impl BlkType {
 			BlkType::Bool(s) => {}
 			BlkType::Color { r, g, b, a } => {}
 		}
+		Ok(())
 	}
 }
 
+fn ser_array_type<T>(arr_writer: fn(&mut Vec<u8>, &mut PrettyFormatter) -> Result<(), Report>, w: &mut Vec<u8>, ser: &mut PrettyFormatter) -> Result<(), Report> {
+	ser.begin_array(w)?;
+	arr_writer(w, ser)?;
+	ser.end_array(w)?;
+	Ok(())
+}
+
 impl Display for BlkType {
-	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+	fn fmt(&self, f: &mut StdFormatter<'_>) -> std::fmt::Result {
 		let value = match self {
 			BlkType::Str(v) => {
 				format!("\"{}\"", v)

src/blk/plaintext_serialize/json.rs

@@ -4,7 +4,7 @@ use color_eyre::Report;
 use serde::ser::{SerializeMap, SerializeSeq, SerializeStruct};
 use serde::Serializer;
 use serde_json::{json, Number, Value};
-use serde_json::ser::PrettyFormatter;
+use serde_json::ser::{Formatter, PrettyFormatter};
 
 use crate::blk::{blk_structure::BlkField, blk_type::BlkType};
 use crate::blk::blk_type::BlkString;
@@ -114,17 +114,31 @@ impl BlkField {
 		}
 	}
 
-	pub fn as_serde_json_streaming(&self, w: &mut serde_json::Serializer<Vec<u8>, PrettyFormatter>, apply_overrides: bool) -> Result<(), Report> {
+	pub fn as_serde_json_streaming(&self, w: &mut Vec<u8>, apply_overrides: bool) -> Result<(), Report> {
+		let mut ser = PrettyFormatter::with_indent(b"\t");
+		self._as_serde_json_streaming(w, apply_overrides, &mut ser)?;
+		Ok(())
+	}
+
+	fn _as_serde_json_streaming(&self, w: &mut Vec<u8>, apply_overrides: bool, ser: &mut PrettyFormatter) -> Result<(), Report> {
 		#[inline(always)]
 		fn std_num(num: f32) -> Value {
 			Value::Number(Number::from_str(&format!("{:?}", num)).expect("Infallible"))
 		}
 
 		match self {
 			BlkField::Value(k, v) => {
+				ser.begin_object_key(w, false)?;
+				ser.write_string_fragment(w, k.as_ref())?;
+				ser.begin_object_value(w)?;
+				v.serialize_streaming(w, ser)?;
 			}
 			BlkField::Struct(k, v) => {
-
+				ser.begin_object(w)?;
+				for value in v {
+					value._as_serde_json_streaming(w, apply_overrides, ser)?;
+				}
+				ser.end_object(w)?;
 			}
 			BlkField::Merged(k, v) => {}
 		}
@@ -284,10 +298,9 @@ mod test {
 		let mut blk = make_strict_test();
 		// println!("Found: {:#?}", blk.as_serde_obj());
 		// println!("Expected: {:#?}", expected);
-		let buf = vec![];
-		let mut ser = Serializer::pretty(buf);
-		blk.as_serde_json_streaming(&mut ser, false).unwrap();
-		println!("{}", String::from_utf8(ser.into_inner()).unwrap());
+		let mut buf = vec![];
+		blk.as_serde_json_streaming(&mut buf, false).unwrap();
+		println!("{}", String::from_utf8(buf).unwrap());
 	}
 
 	#[test]