use alloc::{string::String, vec::Vec};
use core::fmt;
use crate::{
Format, ToJson,
encode::{Flush, Keep, Out, ValueWriter, Written},
reader::Event,
write,
};
#[derive(Debug)]
#[non_exhaustive]
pub enum WriteError {
#[cfg(feature = "std")]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
Io(std::io::Error),
Fmt,
ExpectedKey,
UnexpectedKey,
MismatchedEnd,
DocumentComplete,
Incomplete,
}
impl fmt::Display for WriteError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
#[cfg(feature = "std")]
Self::Io(e) => return write!(f, "writing JSON failed: {e}"),
Self::Fmt => "writing JSON failed: the formatter returned an error",
Self::ExpectedKey => "expected an object key before this value",
Self::UnexpectedKey => "a key is only allowed where an object member starts",
Self::MismatchedEnd => "this end does not close the innermost open container",
Self::DocumentComplete => "the document already has its value",
Self::Incomplete => "the document is not complete",
})
}
}
impl core::error::Error for WriteError {
fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
match self {
#[cfg(feature = "std")]
Self::Io(e) => Some(e),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug)]
struct Frame {
object: bool,
first: bool,
key: bool,
}
enum Target<'o> {
Keep(Keep),
#[cfg(feature = "std")]
Io {
writer: &'o mut dyn std::io::Write,
error: Option<std::io::Error>,
failed: Option<std::io::ErrorKind>,
},
Fmt {
writer: &'o mut dyn fmt::Write,
failed: bool,
},
}
impl Flush for Target<'_> {
fn flush(&mut self, buf: &mut String) {
match self {
Self::Keep(keep) => keep.flush(buf),
#[cfg(feature = "std")]
Self::Io {
writer,
error,
failed,
} => {
if error.is_none() && failed.is_none() {
if let Err(e) = writer.write_all(buf.as_bytes()) {
*error = Some(e);
}
}
buf.clear();
}
Self::Fmt { writer, failed } => {
if !*failed && writer.write_str(buf).is_err() {
*failed = true;
}
buf.clear();
}
}
}
}
impl Target<'_> {
fn error(&mut self) -> Option<WriteError> {
match self {
Self::Keep(_) => None,
#[cfg(feature = "std")]
Self::Io { error, failed, .. } => {
if let Some(e) = error.take() {
*failed = Some(e.kind());
return Some(WriteError::Io(e));
}
failed.map(|kind| WriteError::Io(std::io::Error::from(kind)))
}
Self::Fmt { failed, .. } => failed.then_some(WriteError::Fmt),
}
}
}
enum Buffer<'o> {
Borrowed(&'o mut String),
Owned(String),
}
impl Buffer<'_> {
#[inline]
fn get(&mut self) -> &mut String {
match self {
Self::Borrowed(s) => s,
Self::Owned(s) => s,
}
}
}
pub struct Writer<'o> {
buf: Buffer<'o>,
target: Target<'o>,
format: Format,
flush_at: usize,
stack: Vec<Frame>,
done: bool,
}
impl fmt::Debug for Writer<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Writer")
.field("format", &self.format)
.field("depth", &self.stack.len())
.field("complete", &self.is_complete())
.finish_non_exhaustive()
}
}
impl<'o> Writer<'o> {
#[must_use]
pub fn new(out: &'o mut String) -> Self {
Self::with_target(Buffer::Borrowed(out), Target::Keep(Keep), usize::MAX)
}
#[cfg(feature = "std")]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
#[must_use]
pub fn io(out: &'o mut dyn std::io::Write) -> Self {
let target = Target::Io {
writer: out,
error: None,
failed: None,
};
let buf = Buffer::Owned(String::with_capacity(write::CHUNK + 256));
Self::with_target(buf, target, write::CHUNK)
}
#[must_use]
pub fn fmt(out: &'o mut dyn fmt::Write) -> Self {
let target = Target::Fmt {
writer: out,
failed: false,
};
let buf = Buffer::Owned(String::with_capacity(write::CHUNK + 256));
Self::with_target(buf, target, write::CHUNK)
}
fn with_target(buf: Buffer<'o>, target: Target<'o>, flush_at: usize) -> Self {
Self {
buf,
target,
format: Format::compact(),
flush_at,
stack: Vec::new(),
done: false,
}
}
#[must_use]
pub fn pretty(self) -> Self {
self.with_format(Format::pretty())
}
#[must_use]
pub fn with_format(mut self, format: Format) -> Self {
self.format = format;
self
}
pub fn begin_object(&mut self) -> Result<(), WriteError> {
self.open(true)
}
pub fn begin_array(&mut self) -> Result<(), WriteError> {
self.open(false)
}
pub fn end_object(&mut self) -> Result<(), WriteError> {
self.close(true)
}
pub fn end_array(&mut self) -> Result<(), WriteError> {
self.close(false)
}
pub fn key(&mut self, key: &str) -> Result<(), WriteError> {
self.check()?;
let format = self.format;
let depth = self.stack.len();
let Some(frame) = self.stack.last_mut() else {
return Err(WriteError::UnexpectedKey);
};
if !frame.object || frame.key {
return Err(WriteError::UnexpectedKey);
}
let buf = self.buf.get();
if !frame.first {
buf.push(',');
}
frame.first = false;
frame.key = true;
if format.pretty {
write::newline(buf, depth, format);
}
write::write_str(buf, key, format);
if format.pretty {
buf.push_str(": ");
} else {
buf.push(':');
}
self.flushed()
}
pub fn value<T: ToJson + ?Sized>(&mut self, value: &T) -> Result<(), WriteError> {
self.before_value()?;
let out = Out {
buf: self.buf.get(),
sink: &mut self.target,
flush_at: self.flush_at,
format: self.format,
depth: self.stack.len(),
};
let Written(()) = value.to_json(ValueWriter::new(out));
self.after_value();
self.flushed()
}
pub fn event(&mut self, event: &Event<'_>) -> Result<(), WriteError> {
match event {
Event::StartObject => self.begin_object(),
Event::EndObject => self.end_object(),
Event::StartArray => self.begin_array(),
Event::EndArray => self.end_array(),
Event::Key(key) => self.key(key),
Event::String(text) => self.value(&**text),
Event::Number(number) => self.value(number),
Event::Bool(b) => self.value(b),
Event::Null => self.value(&()),
}
}
#[must_use]
pub fn depth(&self) -> usize {
self.stack.len()
}
#[must_use]
pub fn is_complete(&self) -> bool {
self.done
}
pub fn finish(mut self) -> Result<(), WriteError> {
self.check()?;
if !self.done {
return Err(WriteError::Incomplete);
}
self.target.flush(self.buf.get());
self.check()
}
fn check(&mut self) -> Result<(), WriteError> {
self.target.error().map_or(Ok(()), Err)
}
fn flushed(&mut self) -> Result<(), WriteError> {
let buf = self.buf.get();
if buf.len() >= self.flush_at {
self.target.flush(buf);
}
self.check()
}
fn before_value(&mut self) -> Result<(), WriteError> {
self.check()?;
let format = self.format;
let depth = self.stack.len();
match self.stack.last_mut() {
None if self.done => Err(WriteError::DocumentComplete),
None => Ok(()),
Some(frame) if frame.object => {
if frame.key {
frame.key = false;
Ok(())
} else {
Err(WriteError::ExpectedKey)
}
}
Some(frame) => {
let buf = self.buf.get();
if !frame.first {
buf.push(',');
}
frame.first = false;
if format.pretty {
write::newline(buf, depth, format);
}
Ok(())
}
}
}
#[inline]
fn after_value(&mut self) {
if self.stack.is_empty() {
self.done = true;
}
}
fn open(&mut self, object: bool) -> Result<(), WriteError> {
self.before_value()?;
self.buf.get().push(if object { '{' } else { '[' });
self.stack.push(Frame {
object,
first: true,
key: false,
});
self.flushed()
}
fn close(&mut self, object: bool) -> Result<(), WriteError> {
self.check()?;
match self.stack.last() {
Some(frame) if frame.object == object && !frame.key => {}
_ => return Err(WriteError::MismatchedEnd),
}
let Some(frame) = self.stack.pop() else {
return Err(WriteError::MismatchedEnd);
};
let format = self.format;
let depth = self.stack.len();
let buf = self.buf.get();
if !frame.first && format.pretty {
write::newline(buf, depth, format);
}
buf.push(if object { '}' } else { ']' });
self.after_value();
self.flushed()
}
}
#[cfg(test)]
mod tests {
use alloc::string::ToString;
use super::*;
#[test]
fn test_sequence_errors_write_nothing_and_leave_the_writer_usable() {
let mut out = String::new();
let mut w = Writer::new(&mut out);
assert!(matches!(w.end_array(), Err(WriteError::MismatchedEnd)));
assert!(matches!(w.key("k"), Err(WriteError::UnexpectedKey)));
assert!(w.begin_object().is_ok());
assert!(matches!(w.begin_array(), Err(WriteError::ExpectedKey)));
assert!(w.key("a").is_ok());
assert!(matches!(w.key("b"), Err(WriteError::UnexpectedKey)));
assert!(matches!(w.end_object(), Err(WriteError::MismatchedEnd)));
assert!(w.value(&1).is_ok());
assert!(matches!(w.end_array(), Err(WriteError::MismatchedEnd)));
assert!(w.end_object().is_ok());
assert!(matches!(w.value(&2), Err(WriteError::DocumentComplete)));
assert!(matches!(w.begin_array(), Err(WriteError::DocumentComplete)));
assert_eq!(w.depth(), 0);
assert!(w.finish().is_ok());
assert_eq!(out, r#"{"a":1}"#);
let mut out = String::new();
assert!(matches!(
Writer::new(&mut out).finish(),
Err(WriteError::Incomplete)
));
for e in [
WriteError::Fmt,
WriteError::ExpectedKey,
WriteError::UnexpectedKey,
WriteError::MismatchedEnd,
WriteError::DocumentComplete,
WriteError::Incomplete,
] {
assert!(!e.to_string().is_empty());
assert!(core::error::Error::source(&e).is_none());
}
}
#[test]
fn test_pretty_events_match_pretty_values() {
let v = crate::json!({ "a": [], "b": {}, "c": [{ "d": [1, 2] }], "e": "x" });
let mut out = String::new();
let mut w = Writer::new(&mut out).pretty();
for event in crate::Reader::new(&v.to_string()) {
assert!(event.is_ok_and(|e| w.event(&e).is_ok()));
}
assert!(w.finish().is_ok());
assert_eq!(out, crate::to_string_pretty(&v));
}
#[test]
fn test_fmt_target_reports_failure() {
struct Full;
impl fmt::Write for Full {
fn write_str(&mut self, _: &str) -> fmt::Result {
Err(fmt::Error)
}
}
let mut full = Full;
let mut w = Writer::fmt(&mut full);
assert!(w.value(&"x").is_ok()); assert!(matches!(w.finish(), Err(WriteError::Fmt)));
let mut full = Full;
let mut w = Writer::fmt(&mut full);
assert!(w.begin_array().is_ok());
let long = "y".repeat(write::CHUNK);
assert!(matches!(w.value(&long), Err(WriteError::Fmt)));
assert!(matches!(w.value(&1), Err(WriteError::Fmt)));
assert!(alloc::format!("{w:?}").contains("depth: 1"));
}
#[cfg(feature = "std")]
#[test]
fn test_io_target_returns_the_error_then_its_kind() {
struct Broken;
impl std::io::Write for Broken {
fn write(&mut self, _: &[u8]) -> std::io::Result<usize> {
Err(std::io::Error::other("disk full"))
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
let mut broken = Broken;
let mut w = Writer::io(&mut broken);
assert!(w.begin_array().is_ok());
let long = "z".repeat(write::CHUNK);
let first = w.value(&long).err();
assert_eq!(
first.map(|e| e.to_string()),
Some("writing JSON failed: disk full".to_string())
);
let later = w.end_array().err();
assert!(
matches!(later, Some(WriteError::Io(ref e)) if e.kind() == std::io::ErrorKind::Other)
);
assert!(later.is_some_and(|e| core::error::Error::source(&e).is_some()));
}
}