Rename write_event into serialize_event

Author: Tpt

fuzz/fuzz_targets/parse.rs

@@ -1,21 +1,21 @@
 #![no_main]
 
 use json_event_parser::{
-    JsonEvent, LowLevelJsonReader, LowLevelJsonReaderResult, SyntaxError, ToWriteJsonWriter,
+    JsonEvent, JsonSyntaxError, LowLevelJsonParser, LowLevelJsonParserResult, WriterJsonSerializer,
 };
 use libfuzzer_sys::fuzz_target;
 
-fn parse_chunks(chunks: &[&[u8]]) -> (String, Option<SyntaxError>) {
+fn parse_chunks(chunks: &[&[u8]]) -> (String, Option<JsonSyntaxError>) {
     let mut input_buffer = Vec::new();
     let mut input_cursor = 0;
     let mut output_buffer = Vec::new();
-    let mut reader = LowLevelJsonReader::new();
-    let mut writer = ToWriteJsonWriter::new(&mut output_buffer);
+    let mut reader = LowLevelJsonParser::new();
+    let mut writer = WriterJsonSerializer::new(&mut output_buffer);
     let mut error = None;
     for (i, chunk) in chunks.iter().enumerate() {
         input_buffer.extend_from_slice(chunk);
         loop {
-            let LowLevelJsonReaderResult {
+            let LowLevelJsonParserResult {
                 event,
                 consumed_bytes,
             } = reader.parse_next(&input_buffer[input_cursor..], i == chunks.len() - 1);
@@ -29,9 +29,9 @@ fn parse_chunks(chunks: &[&[u8]]) -> (String, Option<SyntaxError>) {
                 }
                 Some(Ok(event)) => {
                     if error.is_none() {
-                        writer.write_event(event).unwrap();
+                        writer.serialize_event(event).unwrap();
                     } else {
-                        let _ = writer.write_event(event); // We don't know if we write ok structure
+                        let _ = writer.serialize_event(event); // We don't know if we write ok structure
                     }
                 }
                 Some(Err(e)) => {

src/write.rs

@@ -9,10 +9,10 @@ use tokio::io::{AsyncWrite, AsyncWriteExt};
 /// use json_event_parser::{JsonEvent, WriterJsonSerializer};
 ///
 /// let mut writer = WriterJsonSerializer::new(Vec::new());
-/// writer.write_event(JsonEvent::StartObject)?;
-/// writer.write_event(JsonEvent::ObjectKey("foo".into()))?;
-/// writer.write_event(JsonEvent::Number("1".into()))?;
-/// writer.write_event(JsonEvent::EndObject)?;
+/// writer.serialize_event(JsonEvent::StartObject)?;
+/// writer.serialize_event(JsonEvent::ObjectKey("foo".into()))?;
+/// writer.serialize_event(JsonEvent::Number("1".into()))?;
+/// writer.serialize_event(JsonEvent::EndObject)?;
 ///
 /// assert_eq!(writer.finish()?.as_slice(), b"{\"foo\":1}");
 /// # std::io::Result::Ok(())
@@ -30,8 +30,13 @@ impl<W: Write> WriterJsonSerializer<W> {
         }
     }
 
+    pub fn serialize_event(&mut self, event: JsonEvent<'_>) -> Result<()> {
+        self.writer.serialize_event(event, &mut self.write)
+    }
+
+    #[deprecated(note = "Use serialize_event() instead")]
     pub fn write_event(&mut self, event: JsonEvent<'_>) -> Result<()> {
-        self.writer.write_event(event, &mut self.write)
+        self.serialize_event(event)
     }
 
     pub fn finish(self) -> Result<W> {
@@ -48,12 +53,14 @@ impl<W: Write> WriterJsonSerializer<W> {
 /// # #[tokio::main(flavor = "current_thread")]
 /// # async fn main() -> ::std::io::Result<()> {
 /// let mut writer = TokioAsyncWriterJsonSerializer::new(Vec::new());
-/// writer.write_event(JsonEvent::StartObject).await?;
+/// writer.serialize_event(JsonEvent::StartObject).await?;
 /// writer
-///     .write_event(JsonEvent::ObjectKey("foo".into()))
+///     .serialize_event(JsonEvent::ObjectKey("foo".into()))
 ///     .await?;
-/// writer.write_event(JsonEvent::Number("1".into())).await?;
-/// writer.write_event(JsonEvent::EndObject).await?;
+/// writer
+///     .serialize_event(JsonEvent::Number("1".into()))
+///     .await?;
+/// writer.serialize_event(JsonEvent::EndObject).await?;
 /// assert_eq!(writer.finish()?.as_slice(), b"{\"foo\":1}");
 /// # Ok(())
 /// # }
@@ -75,13 +82,18 @@ impl<W: AsyncWrite + Unpin> TokioAsyncWriterJsonSerializer<W> {
         }
     }
 
-    pub async fn write_event(&mut self, event: JsonEvent<'_>) -> Result<()> {
-        self.writer.write_event(event, &mut self.buffer)?;
+    pub async fn serialize_event(&mut self, event: JsonEvent<'_>) -> Result<()> {
+        self.writer.serialize_event(event, &mut self.buffer)?;
         self.write.write_all(&self.buffer).await?;
         self.buffer.clear();
         Ok(())
     }
 
+    #[deprecated(note = "Use serialize_event() instead")]
+    pub fn write_event(&mut self, event: JsonEvent<'_>) -> Result<()> {
+        self.serialize_event(event)
+    }
+
     pub fn finish(self) -> Result<W> {
         self.writer.validate_eof()?;
         Ok(self.write)
@@ -97,10 +109,10 @@ impl<W: AsyncWrite + Unpin> TokioAsyncWriterJsonSerializer<W> {
 ///
 /// let mut writer = LowLevelJsonSerializer::new();
 /// let mut output = Vec::new();
-/// writer.write_event(JsonEvent::StartObject, &mut output)?;
-/// writer.write_event(JsonEvent::ObjectKey("foo".into()), &mut output)?;
-/// writer.write_event(JsonEvent::Number("1".into()), &mut output)?;
-/// writer.write_event(JsonEvent::EndObject, &mut output)?;
+/// writer.serialize_event(JsonEvent::StartObject, &mut output)?;
+/// writer.serialize_event(JsonEvent::ObjectKey("foo".into()), &mut output)?;
+/// writer.serialize_event(JsonEvent::Number("1".into()), &mut output)?;
+/// writer.serialize_event(JsonEvent::EndObject, &mut output)?;
 ///
 /// assert_eq!(output.as_slice(), b"{\"foo\":1}");
 /// # std::io::Result::Ok(())
@@ -120,7 +132,7 @@ impl LowLevelJsonSerializer {
         }
     }
 
-    pub fn write_event(&mut self, event: JsonEvent<'_>, mut write: impl Write) -> Result<()> {
+    pub fn serialize_event(&mut self, event: JsonEvent<'_>, mut write: impl Write) -> Result<()> {
         match event {
             JsonEvent::String(s) => {
                 self.before_value(&mut write)?;
@@ -203,6 +215,11 @@ impl LowLevelJsonSerializer {
         }
     }
 
+    #[deprecated(note = "Use serialize_event() instead")]
+    pub fn write_event(&mut self, event: JsonEvent<'_>, write: impl Write) -> Result<()> {
+        self.serialize_event(event, write)
+    }
+
     fn before_value(&mut self, mut write: impl Write) -> Result<()> {
         match self.state_stack.pop() {
             Some(JsonState::OpenArray) => {

tests/errors.rs

@@ -19,7 +19,7 @@ fn test_recovery() {
         loop {
             match reader.parse_next() {
                 Ok(JsonEvent::Eof) => break,
-                Ok(event) => writer.write_event(event).unwrap(),
+                Ok(event) => writer.serialize_event(event).unwrap(),
                 Err(_) => (),
             }
         }

tests/test_suite.rs

@@ -67,7 +67,7 @@ fn test_testsuite_parsing() -> Result<()> {
                             assert_eq!(
                                 serialization_str,
                                 other_serialization_str,
-                                "Roundtrip {other_serialization_str} serialization of {serialization_str} is not identical (test {file_name})", 
+                                "Roundtrip {other_serialization_str} serialization of {serialization_str} is not identical (test {file_name})",
                             )
                         }
                         Err(error) => {
@@ -98,7 +98,7 @@ fn parse_buffer_result(read: &[u8]) -> Result<Vec<u8>> {
     loop {
         match reader.parse_next()? {
             JsonEvent::Eof => return writer.finish(),
-            e => writer.write_event(e)?,
+            e => writer.serialize_event(e)?,
         }
     }
 }
@@ -109,7 +109,7 @@ fn parse_read_result(read: impl Read) -> Result<Vec<u8>> {
     loop {
         match reader.parse_next()? {
             JsonEvent::Eof => return writer.finish(),
-            e => writer.write_event(e)?,
+            e => writer.serialize_event(e)?,
         }
     }
 }