ephemeris_documents/yaml/source/

mapping.rs

//! Block mappings and their entries.

use std::fmt;

use super::Value;
use super::text::{Origin, Reindent, Text};
use crate::yaml::CANONICAL_STEP;
use crate::yaml::scalar_text::ScalarText;

/// A mapping whose entries can be listed, replaced, appended, and removed.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Mapping {
    shape: Shape,
    entries: Vec<Entry>,
    indent: usize,
    step: usize,
}

/// How a mapping is spelled in the source.
#[derive(Debug, Clone, PartialEq, Eq)]
enum Shape {
    /// Entries on their own lines. The text is what follows the owning key
    /// on its line, including the line break.
    Block(Text),
    /// An empty `{}`, possibly with whitespace between the braces. The
    /// texts surround the braces, and the last one runs to the end of the
    /// line.
    EmptyFlow {
        before: Text,
        braces: Text,
        after: Text,
    },
}

impl Mapping {
    /// A block mapping whose keys sit at `indent`, with nested mappings
    /// `step` columns deeper.
    pub(super) const fn block(
        opening: Text,
        entries: Vec<Entry>,
        indent: usize,
        step: usize,
    ) -> Self {
        Self {
            shape: Shape::Block(opening),
            entries,
            indent,
            step,
        }
    }

    /// An empty flow mapping whose block entries will sit at `indent`.
    pub(super) const fn empty_flow(
        before: Text,
        braces: Text,
        after: Text,
        indent: usize,
        step: usize,
    ) -> Self {
        Self {
            shape: Shape::EmptyFlow {
                before,
                braces,
                after,
            },
            entries: Vec::new(),
            indent,
            step,
        }
    }

    /// This mapping opened by `opening`, with its keys moved to `indent` and
    /// nested mappings `step` columns deeper.
    pub(super) fn reopened(mut self, opening: Text, indent: usize, step: usize) -> Self {
        self.reindent_to(indent, step);
        self.shape = Shape::Block(opening);
        self
    }

    /// Split off the leading text of the first entry, except for the comment
    /// block directly above its key.
    pub(super) fn take_header(&mut self) -> Text {
        self.entries
            .first_mut()
            .map(|entry| entry.leading.take_before_comment_block())
            .unwrap_or_default()
    }

    pub(crate) fn keys(&self) -> impl Iterator<Item = &str> {
        self.entries.iter().map(Entry::key)
    }

    pub(crate) fn get(&self, key: &str) -> Option<&Entry> {
        self.entries.iter().find(|entry| entry.key == key)
    }

    pub(crate) fn get_mut(&mut self, key: &str) -> Option<&mut Entry> {
        self.entries.iter_mut().find(|entry| entry.key == key)
    }

    /// Put `entry` in the mapping, laid out at this mapping's indent and
    /// step.
    ///
    /// An entry with the same key is replaced in place. It keeps the
    /// existing key text, trailing comment of a plain value, and leading
    /// text unless the new entry brings a comment. Any other entry is
    /// appended.
    pub(crate) fn insert(&mut self, mut entry: Entry) {
        entry.reindent_to(self.indent, self.step);
        entry.value.terminate();
        self.expand();
        if let Some(existing) = self.get_mut(&entry.key) {
            existing.replace_keeping_decor(entry);
            return;
        }
        self.terminate();
        self.entries.push(entry);
    }

    /// Remove the entry with `key`, together with its leading text.
    /// A mapping left without entries becomes `{}`.
    pub(crate) fn remove(&mut self, key: &str) {
        let Some(index) = self.entries.iter().position(|entry| entry.key == key) else {
            return;
        };
        self.entries.remove(index);
        if self.entries.is_empty() {
            self.collapse();
        }
    }

    /// The comment on the key line, with the whitespace before it.
    pub(super) fn comment(&self) -> Option<&str> {
        Text::comment_in(self.key_line().as_str())
    }

    /// Put `comment` on the key line unless it has one.
    pub(super) fn keep_comment(&mut self, comment: &str) {
        if self.comment().is_some() {
            return;
        }
        let text = self.key_line_mut();
        if !text.is_empty() {
            *text = Text::from(format!("{}{comment}\n", text.as_str().trim_end()));
        }
    }

    /// What follows the owning key on its line.
    const fn key_line(&self) -> &Text {
        let (Shape::Block(text)
        | Shape::EmptyFlow {
            before: _,
            braces: _,
            after: text,
        }) = &self.shape;
        text
    }

    const fn key_line_mut(&mut self) -> &mut Text {
        let (Shape::Block(text)
        | Shape::EmptyFlow {
            before: _,
            braces: _,
            after: text,
        }) = &mut self.shape;
        text
    }

    /// Turn an emptied block mapping into `{}`, as an empty value would read
    /// back as null. Anchors and a trailing comment stay.
    pub(super) fn collapse(&mut self) {
        let opening = match &self.shape {
            Shape::Block(opening) => opening,
            Shape::EmptyFlow {
                before: _,
                braces: _,
                after: _,
            } => return,
        };
        if opening.is_empty() {
            self.shape = Shape::EmptyFlow {
                before: Text::default(),
                braces: Text::from("{}"),
                after: Text::from("\n"),
            };
            return;
        }
        let line = opening.as_str().trim_end_matches('\n');
        let comment = Text::comment_start(line).unwrap_or(line.len());
        let (properties, note) = line.split_at_checked(comment).unwrap_or((line, ""));
        let note = note.trim_start();
        let before = Text::from(format!("{} ", properties.trim_end()));
        let after = Text::from(if note.is_empty() {
            "\n".to_owned()
        } else {
            format!(" {note}\n")
        });
        self.shape = Shape::EmptyFlow {
            before,
            braces: Text::from("{}"),
            after,
        };
    }

    /// Move the keys to `indent` and nested mappings to `step` columns per
    /// level, carrying every entry's lines along.
    fn reindent_to(&mut self, indent: usize, step: usize) {
        self.indent = indent;
        self.step = step;
        for entry in &mut self.entries {
            entry.reindent_to(indent, step);
        }
    }

    /// Make the last line of the mapping end with a line break.
    pub(super) fn terminate(&mut self) {
        match (self.entries.last_mut(), &mut self.shape) {
            (
                _,
                Shape::EmptyFlow {
                    before: _,
                    braces: _,
                    after,
                },
            ) => after.terminate(),
            (Some(last), Shape::Block(_)) => last.value.terminate(),
            (None, Shape::Block(opening)) if !opening.is_empty() => opening.terminate(),
            (None, Shape::Block(_)) => {}
        }
    }

    /// Turn an empty flow mapping into a block mapping, keeping what
    /// surrounds it.
    ///
    /// The line holding the braces stays when something else is on it, such
    /// as a key or a `---` marker. A bare `{}` line disappears. A comment
    /// after the closing brace moves up to the key's line.
    fn expand(&mut self) {
        let Shape::EmptyFlow {
            before,
            braces: _,
            after,
        } = &self.shape
        else {
            return;
        };
        let before = before.as_str();
        let kept = before.trim_end();
        let owned = self.indent > 0 || before.starts_with([' ', '\t']) || !kept.is_empty();
        let mut opening = Text::from(format!("{kept}{after}"));
        if owned {
            opening.terminate();
        } else if after.as_str().trim().is_empty() {
            opening = Text::default();
        }
        self.shape = Shape::Block(opening);
    }
}

impl fmt::Display for Mapping {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self.shape {
            Shape::Block(opening) => write!(f, "{opening}")?,
            Shape::EmptyFlow {
                before,
                braces,
                after,
            } => write!(f, "{before}{braces}{after}")?,
        }
        self.entries
            .iter()
            .try_for_each(|entry| write!(f, "{entry}"))
    }
}

/// One `key: value` pair with the text before it.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Entry {
    leading: Text,
    key: String,
    head: Text,
    value: Value,
}

impl Entry {
    pub(super) const fn new(leading: Text, key: String, head: Text, value: Value) -> Self {
        Self {
            leading,
            key,
            head,
            value,
        }
    }

    /// The root of a document, which has no key.
    pub(super) fn root(value: Value) -> Self {
        Self::new(Text::default(), String::new(), Text::default(), value)
    }

    /// An empty mapping that prints as `{}` until entries are inserted.
    pub(crate) fn empty_mapping() -> Self {
        let mapping = Mapping::empty_flow(
            Text::from(" "),
            Text::from("{}"),
            Text::from("\n"),
            0,
            CANONICAL_STEP,
        );
        Self::root(Value::Mapping(mapping))
    }

    /// An empty mapping with this entry's leading text and key.
    #[must_use]
    pub(crate) fn empty_with_decor(&self) -> Self {
        let mut empty = Self::empty_mapping();
        empty.leading.clone_from(&self.leading);
        empty.head.clone_from(&self.head);
        empty.key.clone_from(&self.key);
        empty
    }

    /// This entry under another key, spelled as the canonical renderer
    /// spells keys.
    #[must_use]
    pub(crate) fn named(mut self, key: &str) -> Self {
        let indent = " ".repeat(self.indent());
        self.head = Text::from(format!("{indent}{}:", ScalarText::key(key)));
        key.clone_into(&mut self.key);
        self
    }

    /// Take the value of `incoming`, and its leading text when that holds
    /// a comment. The key text and the comment on the key line stay.
    fn replace_keeping_decor(&mut self, incoming: Self) {
        if !incoming.leading.as_str().trim().is_empty() {
            self.leading = incoming.leading;
        }
        let comment = self.value.comment().map(str::to_owned);
        self.value = incoming.value;
        if let Some(comment) = comment {
            self.value.keep_comment(&comment);
        }
        self.value.terminate();
    }

    pub(crate) fn key(&self) -> &str {
        &self.key
    }

    pub(crate) const fn value(&self) -> &Value {
        &self.value
    }

    pub(crate) const fn value_mut(&mut self) -> &mut Value {
        &mut self.value
    }

    pub(super) fn into_value(self) -> Value {
        self.value
    }

    /// The column of the key.
    pub(super) fn indent(&self) -> usize {
        self.head
            .as_str()
            .bytes()
            .take_while(|byte| *byte == b' ')
            .count()
    }

    /// Move the key to `indent` and nested mappings `step` columns per
    /// level. Text lines of the value, such as block scalar content, move
    /// with the key.
    fn reindent_to(&mut self, indent: usize, step: usize) {
        let shift = Reindent::new(self.indent(), indent);
        self.leading.reindent(shift, Origin::LineStart);
        self.head.reindent(shift, Origin::LineStart);
        match &mut self.value {
            Value::Leaf(leaf) => leaf.reindent(shift),
            Value::Opaque(opaque) => opaque.reindent(shift),
            Value::Mapping(mapping) => mapping.reindent_to(indent.saturating_add(step), step),
        }
    }
}

impl fmt::Display for Entry {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}{}{}", self.leading, self.head, self.value)
    }
}