ephemeris_documents/json/cst/

object.rs

//! Objects of the JSON syntax tree and their member edits.

use std::fmt::{self, Write as _};
use std::mem;

use super::key::Key;
use super::tail::{Comma, Position, Tail};
use super::trivia::{Indent, Trivia};
use super::{Kind, Value};
use crate::annotation::Annotated;
use crate::entries::Entries;
use crate::json::Dialect;

/// An object with its members in source order.
///
/// Member names are unique.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Object {
    members: Vec<Member>,
    /// Trivia before the closing brace.
    inner: Trivia,
    /// The indent of the member that holds this object. The first member
    /// inserted into an object with no line break of its own is placed
    /// relative to it.
    base: String,
    /// One level of indentation for members inserted into this object.
    unit: Indent,
}

/// A member name that an object already has.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(in crate::json) struct DuplicateKey {
    pub(in crate::json) name: String,
}

/// One `key: value` pair and the trivia around it. The leading trivia is the
/// value's.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Member {
    key: Key,
    /// Between the key and the colon.
    after_key: Trivia,
    /// Between the colon and the value.
    after_colon: Trivia,
    value: Value,
    tail: Tail,
}

impl Member {
    pub(in crate::json) const fn parsed(
        key: Key,
        after_key: Trivia,
        after_colon: Trivia,
        value: Value,
        tail: Tail,
    ) -> Self {
        Self {
            key,
            after_key,
            after_colon,
            value,
            tail,
        }
    }

    /// A member with a canonical key and colon.
    fn canonical(name: &str, value: Value, tail: Tail) -> Self {
        Self::parsed(
            Key::canonical(name),
            Trivia::default(),
            Trivia::new(" ".to_owned()),
            value,
            tail,
        )
    }

    fn build(name: &str, node: &Annotated, dialect: Dialect, depth: usize) -> Self {
        let leading = Trivia::above(node.comment.as_ref(), depth, dialect);
        Self::canonical(
            name,
            Value::build(node, dialect, depth, leading),
            Tail::canonical(),
        )
    }

    fn trivia_mut(&mut self, visit: &mut dyn FnMut(&mut Trivia)) {
        self.value.trivia_mut(visit);
        visit(&mut self.after_key);
        visit(&mut self.after_colon);
        self.tail.trivia_mut(visit);
    }
}

/// Where the next member of an object goes.
enum Layout {
    /// On a line of its own, after `head`, at `indent`.
    Lines { head: String, indent: String },
    /// On the line of the previous member.
    Inline,
}

impl Layout {
    /// The leading trivia of a new member holding `value`, which is moved
    /// from the indent `from` to its place.
    fn leading(self, value: &mut Value, from: &str) -> Trivia {
        match self {
            Self::Lines { head, indent } => {
                Object::reindent_incoming(value, from, &indent);
                let mut leading = mem::take(&mut value.leading);
                if leading.has_newline() {
                    leading.reindent_from(from, &indent);
                } else {
                    leading = Trivia::new(["\n", &indent, leading.as_str()].concat());
                }
                Trivia::new([head.as_str(), leading.as_str()].concat())
            }
            Self::Inline => {
                Object::reindent_incoming(value, from, "");
                Trivia::new(" ".to_owned())
            }
        }
    }
}

impl Object {
    pub(in crate::json) fn new() -> Self {
        Self {
            members: Vec::new(),
            inner: Trivia::new(String::new()),
            base: String::new(),
            unit: Indent::default(),
        }
    }

    /// The canonical object for `entries`, at `depth`.
    pub(super) fn build(entries: &Entries, dialect: Dialect, depth: usize) -> Self {
        let child = depth.saturating_add(1);
        Self {
            members: entries
                .into_iter()
                .map(|(name, value)| Member::build(name, value, dialect, child))
                .collect(),
            inner: if entries.is_empty() {
                Trivia::default()
            } else {
                Trivia::closing(depth)
            },
            base: String::new(),
            unit: Indent::default(),
        }
    }

    /// This object with the trivia before its closing brace.
    pub(in crate::json) fn closed_by(mut self, inner: Trivia) -> Self {
        self.inner = inner;
        self
    }

    /// The indent unit of the first multi-line member, if there is one.
    pub(super) fn indent_unit(&self) -> Option<Indent> {
        self.detect_unit("")
    }

    /// The same for an object that starts a line at indent `base`.
    fn detect_unit(&self, base: &str) -> Option<Indent> {
        for member in &self.members {
            let leading = &member.value.leading;
            if !leading.has_newline() {
                continue;
            }
            let own = leading.indent();
            if let Some(unit) = own.strip_prefix(base).and_then(Indent::from_blanks) {
                return Some(unit);
            }
            if let Kind::Object(child) = &member.value.kind
                && let Some(unit) = child.detect_unit(own)
            {
                return Some(unit);
            }
        }
        None
    }

    /// Set the indent unit for members inserted into this object.
    pub(super) fn set_unit(&mut self, unit: &Indent) {
        self.unit.clone_from(unit);
    }

    /// Append a parsed member.
    ///
    /// # Errors
    /// Returns the name when it is already present.
    pub(in crate::json) fn push(&mut self, member: Member) -> Result<(), DuplicateKey> {
        if self.position(member.key.name()).is_some() {
            return Err(DuplicateKey {
                name: member.key.name().to_owned(),
            });
        }
        self.members.push(member);
        Ok(())
    }

    fn position(&self, name: &str) -> Option<usize> {
        self.members
            .iter()
            .position(|member| member.key.name() == name)
    }

    /// The member names in source order.
    pub(in crate::json) fn keys(&self) -> impl Iterator<Item = &str> {
        self.members.iter().map(|member| member.key.name())
    }

    pub(in crate::json) fn get(&self, name: &str) -> Option<&Value> {
        self.members
            .iter()
            .find(|member| member.key.name() == name)
            .map(|member| &member.value)
    }

    /// Enter the value of `name` for editing. An object value takes this
    /// object's indent unit and the indent it is placed at, so that members
    /// inserted into it line up.
    pub(in crate::json) fn descend(&mut self, name: &str) -> Option<&mut Value> {
        let index = self.position(name)?;
        let member = self.members.get_mut(index)?;
        if let Kind::Object(object) = &mut member.value.kind {
            object.unit.clone_from(&self.unit);
            let base = if member.value.leading.has_newline() {
                member.value.leading.indent()
            } else {
                &self.base
            };
            object.base.clear();
            object.base.push_str(base);
        }
        Some(&mut member.value)
    }

    /// Replace the value of `name`, or append a member.
    ///
    /// An existing member keeps its own leading trivia, so the user's spacing
    /// and comments stay, unless `value` carries a comment of its own. Then
    /// the leading trivia of `value` replaces it. A new member takes the
    /// leading trivia of `value`, moved to the indent of its siblings, and
    /// a key spelled the canonical way for the dialect it is printed in.
    /// `value` is laid out like a canonical member value: its lines are
    /// indented relative to the indent of its leading trivia.
    ///
    /// An empty object stays as it is until a member is inserted into it.
    /// Then it takes a line break and the indent of the member that holds it,
    /// so that the new member and its closing brace line up.
    pub(in crate::json) fn insert(&mut self, name: &str, mut value: Value) {
        value.reindent_unit(&self.unit);
        let from = value.leading.indent().to_owned();
        let commented = !value.leading.is_blank();
        match self.position(name) {
            Some(index) => self.replace_member(index, value, &from),
            None => self.append_member(name, value, &from, commented),
        }
    }

    /// Give the member at `index` the body of `value`. `from` is the indent
    /// of the leading trivia of `value`.
    fn replace_member(&mut self, index: usize, mut value: Value, from: &str) {
        if !value.leading.is_blank() {
            self.expand_before(index);
        }
        let Some(member) = self.members.get_mut(index) else {
            return;
        };
        let to = member.value.leading.indent().to_owned();
        Self::reindent_incoming(&mut value, from, &to);
        if !value.leading.is_blank() && member.value.leading.has_newline() {
            value.leading.reindent_from(from, &to);
            member.value.leading = value.leading;
        }
        member.value.kind = value.kind;
    }

    /// Add a member for `value` after the last one. `from` is the indent of
    /// the leading trivia of `value`, which has a comment when `commented`.
    fn append_member(&mut self, name: &str, mut value: Value, from: &str, commented: bool) {
        let kept = self
            .members
            .last()
            .map_or(Comma::Present, |last| last.tail.comma);
        let mut layout = self.plan_layout();
        if self.members.is_empty() {
            self.expand_empty();
        } else if commented && matches!(layout, Layout::Inline) {
            layout = Layout::Lines {
                head: String::new(),
                indent: self.expand(),
            };
        }
        let inline = matches!(layout, Layout::Inline);
        let leading = layout.leading(&mut value, from);
        let trailing = match self.members.last_mut() {
            Some(last) if inline && last.tail.trailing.is_blank() => {
                mem::take(&mut last.tail.trailing)
            }
            _ => Trivia::default(),
        };
        let tail = Tail::new(Trivia::default(), kept, trailing);
        self.members.push(Member::canonical(
            name,
            Value::new(leading, value.kind),
            tail,
        ));
    }

    /// Put the member at `index` on a line of its own. A one-line object is
    /// expanded to one member per line.
    fn expand_before(&mut self, index: usize) {
        let indent = match self.plan_layout() {
            Layout::Lines { indent, head: _ } => indent,
            Layout::Inline => self.expand(),
        };
        if let Some(member) = self.members.get_mut(index)
            && !member.value.leading.has_newline()
        {
            let text = ["\n", &indent, member.value.leading.as_str().trim_start()].concat();
            member.value.leading = Trivia::new(text);
        }
    }

    /// Move every member to its own line and the closing brace to a line of
    /// its own. Returns the indent of the members.
    fn expand(&mut self) -> String {
        let indent = [self.base.as_str(), self.unit.as_str()].concat();
        for member in &mut self.members {
            let text = ["\n", &indent, member.value.leading.as_str().trim_start()].concat();
            member.value.leading = Trivia::new(text);
            if member.tail.trailing.is_blank() {
                member.tail.trailing = Trivia::default();
            }
        }
        let inner = ["\n", &self.base, self.inner.as_str().trim_start()].concat();
        self.inner = Trivia::new(inner);
        indent
    }

    /// Fit the body of an incoming value to its new place.
    fn reindent_incoming(value: &mut Value, from: &str, to: &str) {
        value.kind.reindent_from(from, to);
        if let Kind::Object(object) = &mut value.kind
            && object.members.is_empty()
        {
            to.clone_into(&mut object.base);
        }
    }

    /// Where a new member goes.
    fn plan_layout(&self) -> Layout {
        if self.members.is_empty() {
            let kept = self.inner.as_str().trim_end_matches([' ', '\t']);
            return Layout::Lines {
                head: kept.strip_suffix('\n').unwrap_or(kept).to_owned(),
                indent: [self.empty_base().as_str(), self.unit.as_str()].concat(),
            };
        }
        self.members
            .iter()
            .rev()
            .find(|member| member.value.leading.has_newline())
            .map_or(Layout::Inline, |member| Layout::Lines {
                head: String::new(),
                indent: member.value.leading.indent().to_owned(),
            })
    }

    /// The indent of the line that holds the closing brace of an empty
    /// object, once it has one.
    fn empty_base(&self) -> String {
        if self.inner.has_newline() {
            self.inner.indent().to_owned()
        } else {
            self.base.clone()
        }
    }

    /// Move the closing brace of an empty object to a line of its own.
    fn expand_empty(&mut self) {
        self.inner = Trivia::new(["\n", &self.empty_base()].concat());
    }

    /// Remove the member `name` with its leading trivia. A removed last member
    /// hands its comma style to the new last member. An object left empty
    /// prints as `{}` unless a comment is left inside it.
    pub(in crate::json) fn remove(&mut self, name: &str) {
        let Some(index) = self.position(name) else {
            return;
        };
        let removed = self.members.remove(index);
        if index == self.members.len()
            && let Some(last) = self.members.last_mut()
        {
            last.tail.comma = removed.tail.comma;
        }
        if self.members.is_empty() && self.inner.is_blank() {
            self.inner = Trivia::default();
        }
    }

    pub(super) fn trivia_mut(&mut self, visit: &mut dyn FnMut(&mut Trivia)) {
        for member in &mut self.members {
            member.trivia_mut(visit);
        }
        visit(&mut self.inner);
    }

    pub(super) fn write(&self, f: &mut fmt::Formatter<'_>, dialect: Dialect) -> fmt::Result {
        f.write_char('{')?;
        for (position, member) in Position::each(&self.members) {
            write!(
                f,
                "{}{}{}:{}",
                member.value.leading,
                member.key.spelling(dialect),
                member.after_key,
                member.after_colon
            )?;
            member.value.kind.write(f, dialect)?;
            member.tail.write(f, dialect, position)?;
        }
        write!(f, "{}}}", self.inner)
    }
}