second-brain-cli 0.13.4

Memory layer for AI coding agents: ingest, recall, and sync across machines
use std::fmt;

use serde::de::{self, Deserialize, Deserializer, MapAccess, SeqAccess, Visitor};
use serde::ser::{Serialize, SerializeMap, Serializer};

/// A JSON value that keeps object keys in file order, so rewriting a file
/// someone edits by hand does not reshuffle it.
#[derive(Debug, Clone, PartialEq)]
pub(crate) enum Json {
    Null,
    Bool(bool),
    Number(serde_json::Number),
    String(String),
    Array(Vec<Json>),
    Object(Vec<(String, Json)>),
}

impl Json {
    pub(crate) fn object<K: Into<String>>(entries: impl IntoIterator<Item = (K, Json)>) -> Json {
        Json::Object(entries.into_iter().map(|(k, v)| (k.into(), v)).collect())
    }

    pub(crate) fn as_str(&self) -> Option<&str> {
        match self {
            Json::String(s) => Some(s),
            _ => None,
        }
    }

    pub(crate) fn get(&self, key: &str) -> Option<&Json> {
        match self {
            Json::Object(entries) => entries.iter().rev().find(|(k, _)| k == key).map(|(_, v)| v),
            _ => None,
        }
    }

    pub(crate) fn get_mut(&mut self, key: &str) -> Option<&mut Json> {
        match self {
            Json::Object(entries) => entries
                .iter_mut()
                .rev()
                .find(|(k, _)| k == key)
                .map(|(_, v)| v),
            _ => None,
        }
    }

    /// The value under `key`, appending `default()` at the end when the key is
    /// absent; `None` when `self` is not an object.
    pub(crate) fn entry(&mut self, key: &str, default: impl FnOnce() -> Json) -> Option<&mut Json> {
        let Json::Object(entries) = self else {
            return None;
        };
        let at = match entries.iter().rposition(|(k, _)| k == key) {
            Some(at) => at,
            None => {
                entries.push((key.to_string(), default()));
                entries.len() - 1
            }
        };
        Some(&mut entries[at].1)
    }
}

impl From<&str> for Json {
    fn from(s: &str) -> Self {
        Json::String(s.to_string())
    }
}

impl From<u64> for Json {
    fn from(n: u64) -> Self {
        Json::Number(n.into())
    }
}

impl Serialize for Json {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Json::Null => serializer.serialize_unit(),
            Json::Bool(b) => serializer.serialize_bool(*b),
            Json::Number(n) => n.serialize(serializer),
            Json::String(s) => serializer.serialize_str(s),
            Json::Array(items) => serializer.collect_seq(items),
            Json::Object(entries) => {
                let mut map = serializer.serialize_map(Some(entries.len()))?;
                for (key, value) in entries {
                    map.serialize_entry(key, value)?;
                }
                map.end()
            }
        }
    }
}

impl<'de> Deserialize<'de> for Json {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        deserializer.deserialize_any(JsonVisitor)
    }
}

struct JsonVisitor;

impl<'de> Visitor<'de> for JsonVisitor {
    type Value = Json;

    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("any JSON value")
    }

    fn visit_unit<E>(self) -> Result<Json, E> {
        Ok(Json::Null)
    }

    fn visit_bool<E>(self, b: bool) -> Result<Json, E> {
        Ok(Json::Bool(b))
    }

    fn visit_i64<E>(self, n: i64) -> Result<Json, E> {
        Ok(Json::Number(n.into()))
    }

    fn visit_u64<E>(self, n: u64) -> Result<Json, E> {
        Ok(Json::Number(n.into()))
    }

    fn visit_f64<E: de::Error>(self, n: f64) -> Result<Json, E> {
        serde_json::Number::from_f64(n)
            .map(Json::Number)
            .ok_or_else(|| E::custom("a JSON number must be finite"))
    }

    fn visit_str<E>(self, s: &str) -> Result<Json, E> {
        Ok(Json::String(s.to_string()))
    }

    fn visit_string<E>(self, s: String) -> Result<Json, E> {
        Ok(Json::String(s))
    }

    fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Json, A::Error> {
        let mut items = Vec::new();
        while let Some(item) = seq.next_element()? {
            items.push(item);
        }
        Ok(Json::Array(items))
    }

    fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Json, A::Error> {
        let mut entries = Vec::new();
        while let Some((key, value)) = map.next_entry::<String, Json>()? {
            entries.push((key, value));
        }
        Ok(Json::Object(entries))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    const TEXT: &str = r#"{
  "zeta": 1,
  "alpha": {
    "mid": [
      true,
      null,
      -2,
      1.5,
      "s"
    ],
    "beta": {}
  },
  "empty": []
}"#;

    #[test]
    fn a_pretty_file_round_trips_byte_for_byte_in_key_order() {
        let doc: Json = serde_json::from_str(TEXT).unwrap();
        assert_eq!(serde_json::to_string_pretty(&doc).unwrap(), TEXT);
    }

    #[test]
    fn entry_appends_a_missing_key_at_the_end_and_keeps_an_existing_one() {
        let mut doc: Json = serde_json::from_str(TEXT).unwrap();
        *doc.entry("new", || Json::Null).unwrap() = Json::from(7);
        assert_eq!(doc.entry("zeta", || Json::Null).unwrap(), &Json::from(1));
        let Json::Object(entries) = &doc else {
            panic!("{doc:?}")
        };
        let keys: Vec<&str> = entries.iter().map(|(k, _)| k.as_str()).collect();
        assert_eq!(keys, ["zeta", "alpha", "empty", "new"]);
        assert_eq!(doc.get("new"), Some(&Json::from(7)));
    }

    #[test]
    fn entry_on_a_non_object_is_none() {
        assert!(Json::Array(vec![]).entry("k", || Json::Null).is_none());
    }
}