ephemeris_documents/json/

cst.rs

//! Concrete syntax tree of a JSON5 document.
//!
//! Every byte of the source is owned by exactly one node, so printing the tree
//! returns the source unchanged. The document stores its [`Dialect`] because
//! the comma rule and the spelling of new keys depend on it, and that keeps
//! `to_string` the one way to emit.

mod array;
mod key;
mod object;
mod quote;
mod scalar;
mod tail;
mod trivia;

use std::fmt;

pub(super) use self::array::{Array, Item};
pub(super) use self::key::Key;
pub(super) use self::object::{Member, Object};
pub(super) use self::scalar::Scalar;
pub(super) use self::tail::{Comma, Position, Tail};
use self::trivia::Indent;
pub(super) use self::trivia::Trivia;
use super::Dialect;
use super::parser::Parser;
use crate::annotation::{Annotated, AnnotatedValue};
use crate::backend::Editable;
use crate::error::JsonError;
use crate::header::Applied;

/// The root of a parsed or built document.
#[derive(Debug, Clone)]
pub(crate) struct Document {
    dialect: Dialect,
    pub(super) value: Value,
    trailing: Trivia,
    /// One level of indentation, for members inserted into the document.
    indent: Indent,
}

impl Document {
    /// A parsed document. Its indent is the unit of its first multi-line
    /// member, or two spaces.
    pub(super) fn parsed(dialect: Dialect, value: Value, trailing: Trivia) -> Self {
        let indent = value
            .as_object()
            .and_then(Object::indent_unit)
            .unwrap_or_default();
        Self {
            dialect,
            value,
            trailing,
            indent,
        }
    }

    /// End the document with exactly one line break.
    pub(super) fn end_with_newline(&mut self) {
        let text = [self.trailing.as_str().trim_end_matches('\n'), "\n"].concat();
        self.trailing = Trivia::new(text);
    }

    /// Parse source as JSON5, whatever the dialect. The dialect only governs
    /// how the document is written back.
    ///
    /// # Errors
    /// Returns the first syntax error, with its byte offset.
    pub(super) fn parse(source: &str, dialect: Dialect) -> Result<Self, JsonError> {
        Parser::parse(source, dialect)
    }

    /// The canonical rendering of `tree`.
    pub(super) fn build(tree: &Annotated, dialect: Dialect) -> Self {
        let leading = Trivia::root(tree.comment.as_ref(), dialect);
        Self {
            dialect,
            value: Value::build(tree, dialect, 0, leading),
            trailing: Trivia::new("\n".to_owned()),
            indent: Indent::default(),
        }
    }
}

impl Editable for Document {
    type Node = Value;

    fn header_text(&self) -> &str {
        self.value.leading.as_str()
    }

    fn leading(&self) -> (&str, &str) {
        ("", self.value.leading.as_str())
    }

    fn set_leading(&mut self, applied: Applied<'_>) {
        self.value.leading = Trivia::new(applied.into_text());
    }

    fn root(&self) -> &Value {
        &self.value
    }

    /// The root value, ready for members to be inserted.
    fn root_mut(&mut self) -> &mut Value {
        if let Kind::Object(object) = &mut self.value.kind {
            object.set_unit(&self.indent);
        }
        &mut self.value
    }
}

impl fmt::Display for Document {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.value.write(f, self.dialect)?;
        write!(f, "{}", self.trailing)
    }
}

/// A value with the trivia that precedes it.
///
/// For an object member or an array item the leading trivia is everything
/// since the previous element, so a comment above a member moves with its
/// value. In an object member it comes before the key.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Value {
    pub(super) leading: Trivia,
    pub(super) kind: Kind,
}

/// A container or a literal token.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum Kind {
    Object(Object),
    Array(Array),
    Scalar(Scalar),
}

impl Value {
    pub(super) const fn new(leading: Trivia, kind: Kind) -> Self {
        Self { leading, kind }
    }

    pub(super) const fn is_object(&self) -> bool {
        matches!(self.kind, Kind::Object(_))
    }

    pub(super) const fn as_object(&self) -> Option<&Object> {
        match &self.kind {
            Kind::Object(object) => Some(object),
            Kind::Array(_) | Kind::Scalar(_) => None,
        }
    }

    pub(super) const fn as_object_mut(&mut self) -> Option<&mut Object> {
        match &mut self.kind {
            Kind::Object(object) => Some(object),
            Kind::Array(_) | Kind::Scalar(_) => None,
        }
    }

    fn build(node: &Annotated, dialect: Dialect, depth: usize, leading: Trivia) -> Self {
        let kind = match &node.value {
            AnnotatedValue::Scalar(leaf) => Kind::Scalar(Scalar::build(leaf, dialect)),
            AnnotatedValue::Array(items) => Kind::Array(Array::build(items, dialect, depth)),
            AnnotatedValue::Object(entries) => Kind::Object(Object::build(entries, dialect, depth)),
        };
        Self { leading, kind }
    }

    fn write(&self, f: &mut fmt::Formatter<'_>, dialect: Dialect) -> fmt::Result {
        write!(f, "{}", self.leading)?;
        self.kind.write(f, dialect)
    }

    /// Visit every piece of trivia in the value, including its leading trivia.
    fn trivia_mut(&mut self, visit: &mut dyn FnMut(&mut Trivia)) {
        visit(&mut self.leading);
        self.kind.trivia_mut(visit);
    }

    /// Convert the indent of every line from the canonical two spaces per
    /// level to `unit`, including the leading trivia.
    fn reindent_unit(&mut self, unit: &Indent) {
        self.trivia_mut(&mut |trivia| trivia.reindent_unit(unit));
    }
}

impl Kind {
    fn write(&self, f: &mut fmt::Formatter<'_>, dialect: Dialect) -> fmt::Result {
        match self {
            Self::Object(object) => object.write(f, dialect),
            Self::Array(array) => array.write(f, dialect),
            Self::Scalar(scalar) => f.write_str(scalar.text()),
        }
    }

    fn trivia_mut(&mut self, visit: &mut dyn FnMut(&mut Trivia)) {
        match self {
            Self::Object(object) => object.trivia_mut(visit),
            Self::Array(array) => array.trivia_mut(visit),
            Self::Scalar(_) => {}
        }
    }

    /// Replace the indent `from` at the start of every line with `to`.
    fn reindent_from(&mut self, from: &str, to: &str) {
        self.trivia_mut(&mut |trivia| trivia.reindent_from(from, to));
    }
}