Skip to content

Commit 4a9f4fe

Browse files
TptTpt
committed
Rename write_event into serialize_event
1 parent 0254376 commit 4a9f4fe

File tree

4 files changed

+44
-27
lines changed

4 files changed

+44
-27
lines changed

‎fuzz/fuzz_targets/parse.rs

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,21 +1,21 @@
11
#![no_main]
22

33
use json_event_parser::{
4-
JsonEvent, LowLevelJsonReader, LowLevelJsonReaderResult, SyntaxError, ToWriteJsonWriter,
4+
JsonEvent, JsonSyntaxError, LowLevelJsonParser, LowLevelJsonParserResult, WriterJsonSerializer,
55
};
66
use libfuzzer_sys::fuzz_target;
77

8-
fn parse_chunks(chunks: &[&[u8]]) -> (String, Option<SyntaxError>) {
8+
fn parse_chunks(chunks: &[&[u8]]) -> (String, Option<JsonSyntaxError>) {
99
let mut input_buffer = Vec::new();
1010
let mut input_cursor = 0;
1111
let mut output_buffer = Vec::new();
12-
let mut reader = LowLevelJsonReader::new();
13-
let mut writer = ToWriteJsonWriter::new(&mut output_buffer);
12+
let mut reader = LowLevelJsonParser::new();
13+
let mut writer = WriterJsonSerializer::new(&mut output_buffer);
1414
let mut error = None;
1515
for (i, chunk) in chunks.iter().enumerate() {
1616
input_buffer.extend_from_slice(chunk);
1717
loop {
18-
let LowLevelJsonReaderResult {
18+
let LowLevelJsonParserResult {
1919
event,
2020
consumed_bytes,
2121
} = reader.parse_next(&input_buffer[input_cursor..], i == chunks.len() - 1);
@@ -29,9 +29,9 @@ fn parse_chunks(chunks: &[&[u8]]) -> (String, Option<SyntaxError>) {
2929
}
3030
Some(Ok(event)) => {
3131
if error.is_none() {
32-
writer.write_event(event).unwrap();
32+
writer.serialize_event(event).unwrap();
3333
} else {
34-
let _ = writer.write_event(event); // We don't know if we write ok structure
34+
let _ = writer.serialize_event(event); // We don't know if we write ok structure
3535
}
3636
}
3737
Some(Err(e)) => {

‎src/write.rs

Lines changed: 33 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -9,10 +9,10 @@ use tokio::io::{AsyncWrite, AsyncWriteExt};
99
/// use json_event_parser::{JsonEvent, WriterJsonSerializer};
1010
///
1111
/// let mut writer = WriterJsonSerializer::new(Vec::new());
12-
/// writer.write_event(JsonEvent::StartObject)?;
13-
/// writer.write_event(JsonEvent::ObjectKey("foo".into()))?;
14-
/// writer.write_event(JsonEvent::Number("1".into()))?;
15-
/// writer.write_event(JsonEvent::EndObject)?;
12+
/// writer.serialize_event(JsonEvent::StartObject)?;
13+
/// writer.serialize_event(JsonEvent::ObjectKey("foo".into()))?;
14+
/// writer.serialize_event(JsonEvent::Number("1".into()))?;
15+
/// writer.serialize_event(JsonEvent::EndObject)?;
1616
///
1717
/// assert_eq!(writer.finish()?.as_slice(), b"{\"foo\":1}");
1818
/// # std::io::Result::Ok(())
@@ -30,8 +30,13 @@ impl<W: Write> WriterJsonSerializer<W> {
3030
}
3131
}
3232

33+
pub fn serialize_event(&mut self, event: JsonEvent<'_>) -> Result<()> {
34+
self.writer.serialize_event(event, &mut self.write)
35+
}
36+
37+
#[deprecated(note = "Use serialize_event() instead")]
3338
pub fn write_event(&mut self, event: JsonEvent<'_>) -> Result<()> {
34-
self.writer.write_event(event, &mut self.write)
39+
self.serialize_event(event)
3540
}
3641

3742
pub fn finish(self) -> Result<W> {
@@ -48,12 +53,14 @@ impl<W: Write> WriterJsonSerializer<W> {
4853
/// # #[tokio::main(flavor = "current_thread")]
4954
/// # async fn main() -> ::std::io::Result<()> {
5055
/// let mut writer = TokioAsyncWriterJsonSerializer::new(Vec::new());
51-
/// writer.write_event(JsonEvent::StartObject).await?;
56+
/// writer.serialize_event(JsonEvent::StartObject).await?;
5257
/// writer
53-
/// .write_event(JsonEvent::ObjectKey("foo".into()))
58+
/// .serialize_event(JsonEvent::ObjectKey("foo".into()))
5459
/// .await?;
55-
/// writer.write_event(JsonEvent::Number("1".into())).await?;
56-
/// writer.write_event(JsonEvent::EndObject).await?;
60+
/// writer
61+
/// .serialize_event(JsonEvent::Number("1".into()))
62+
/// .await?;
63+
/// writer.serialize_event(JsonEvent::EndObject).await?;
5764
/// assert_eq!(writer.finish()?.as_slice(), b"{\"foo\":1}");
5865
/// # Ok(())
5966
/// # }
@@ -75,13 +82,18 @@ impl<W: AsyncWrite + Unpin> TokioAsyncWriterJsonSerializer<W> {
7582
}
7683
}
7784

78-
pub async fn write_event(&mut self, event: JsonEvent<'_>) -> Result<()> {
79-
self.writer.write_event(event, &mut self.buffer)?;
85+
pub async fn serialize_event(&mut self, event: JsonEvent<'_>) -> Result<()> {
86+
self.writer.serialize_event(event, &mut self.buffer)?;
8087
self.write.write_all(&self.buffer).await?;
8188
self.buffer.clear();
8289
Ok(())
8390
}
8491

92+
#[deprecated(note = "Use serialize_event() instead")]
93+
pub fn write_event(&mut self, event: JsonEvent<'_>) -> Result<()> {
94+
self.serialize_event(event)
95+
}
96+
8597
pub fn finish(self) -> Result<W> {
8698
self.writer.validate_eof()?;
8799
Ok(self.write)
@@ -97,10 +109,10 @@ impl<W: AsyncWrite + Unpin> TokioAsyncWriterJsonSerializer<W> {
97109
///
98110
/// let mut writer = LowLevelJsonSerializer::new();
99111
/// let mut output = Vec::new();
100-
/// writer.write_event(JsonEvent::StartObject, &mut output)?;
101-
/// writer.write_event(JsonEvent::ObjectKey("foo".into()), &mut output)?;
102-
/// writer.write_event(JsonEvent::Number("1".into()), &mut output)?;
103-
/// writer.write_event(JsonEvent::EndObject, &mut output)?;
112+
/// writer.serialize_event(JsonEvent::StartObject, &mut output)?;
113+
/// writer.serialize_event(JsonEvent::ObjectKey("foo".into()), &mut output)?;
114+
/// writer.serialize_event(JsonEvent::Number("1".into()), &mut output)?;
115+
/// writer.serialize_event(JsonEvent::EndObject, &mut output)?;
104116
///
105117
/// assert_eq!(output.as_slice(), b"{\"foo\":1}");
106118
/// # std::io::Result::Ok(())
@@ -120,7 +132,7 @@ impl LowLevelJsonSerializer {
120132
}
121133
}
122134

123-
pub fn write_event(&mut self, event: JsonEvent<'_>, mut write: impl Write) -> Result<()> {
135+
pub fn serialize_event(&mut self, event: JsonEvent<'_>, mut write: impl Write) -> Result<()> {
124136
match event {
125137
JsonEvent::String(s) => {
126138
self.before_value(&mut write)?;
@@ -203,6 +215,11 @@ impl LowLevelJsonSerializer {
203215
}
204216
}
205217

218+
#[deprecated(note = "Use serialize_event() instead")]
219+
pub fn write_event(&mut self, event: JsonEvent<'_>, write: impl Write) -> Result<()> {
220+
self.serialize_event(event, write)
221+
}
222+
206223
fn before_value(&mut self, mut write: impl Write) -> Result<()> {
207224
match self.state_stack.pop() {
208225
Some(JsonState::OpenArray) => {

‎tests/errors.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ fn test_recovery() {
1919
loop {
2020
match reader.parse_next() {
2121
Ok(JsonEvent::Eof) => break,
22-
Ok(event) => writer.write_event(event).unwrap(),
22+
Ok(event) => writer.serialize_event(event).unwrap(),
2323
Err(_) => (),
2424
}
2525
}

‎tests/test_suite.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -67,7 +67,7 @@ fn test_testsuite_parsing() -> Result<()> {
6767
assert_eq!(
6868
serialization_str,
6969
other_serialization_str,
70-
"Roundtrip {other_serialization_str} serialization of {serialization_str} is not identical (test {file_name})",
70+
"Roundtrip {other_serialization_str} serialization of {serialization_str} is not identical (test {file_name})",
7171
)
7272
}
7373
Err(error) => {
@@ -98,7 +98,7 @@ fn parse_buffer_result(read: &[u8]) -> Result<Vec<u8>> {
9898
loop {
9999
match reader.parse_next()? {
100100
JsonEvent::Eof => return writer.finish(),
101-
e => writer.write_event(e)?,
101+
e => writer.serialize_event(e)?,
102102
}
103103
}
104104
}
@@ -109,7 +109,7 @@ fn parse_read_result(read: impl Read) -> Result<Vec<u8>> {
109109
loop {
110110
match reader.parse_next()? {
111111
JsonEvent::Eof => return writer.finish(),
112-
e => writer.write_event(e)?,
112+
e => writer.serialize_event(e)?,
113113
}
114114
}
115115
}

0 commit comments

Comments
 (0)