Skip to main content

muse_code_sdk/fold/
items.rs

1use std::collections::{HashMap, hash_map::Entry};
2
3use serde_json::{Map, Value};
4
5use super::{FoldOutcome, SessionFold, string};
6
7/// What one item event did to the item it names.
8#[derive(Debug, Clone, PartialEq, Eq)]
9#[non_exhaustive]
10pub enum ItemOutcome {
11    /// The first revision of an item the fold did not hold.
12    Inserted,
13    /// A newer revision, or the completed form of the held revision,
14    /// replaced the held one and dropped its accumulated deltas.
15    Replaced {
16        /// The revision held before.
17        from: u64,
18        /// The revision held now.
19        to: u64,
20    },
21    /// The offered revision is older, or repeats the held one without
22    /// completing an open item, so the held one stays.
23    IgnoredStale {
24        /// The revision the fold keeps.
25        held: u64,
26        /// The revision the event carried.
27        offered: u64,
28    },
29}
30
31#[derive(Debug, Clone)]
32struct StoredItem {
33    revision: u64,
34    value: Value,
35    open: bool,
36}
37
38/// Sealed item read view: mutation is available only through `SessionFold`.
39#[derive(Debug, Default)]
40pub struct Items {
41    values: HashMap<String, StoredItem>,
42    deltas: HashMap<String, HashMap<String, String>>,
43    // Item ids in first-seen order; items are never removed.
44    order: Vec<String>,
45}
46
47impl Items {
48    /// Item `id` at its latest revision, with the deltas since that revision
49    /// appended, or `None` when the fold holds no such item.
50    pub fn get(&self, id: &str) -> Option<&Value> {
51        self.values.get(id).map(|item| &item.value)
52    }
53
54    /// How many items the fold holds; items are never removed.
55    pub fn len(&self) -> usize {
56        self.values.len()
57    }
58
59    /// True until the fold holds an item.
60    pub fn is_empty(&self) -> bool {
61        self.values.is_empty()
62    }
63
64    /// The `item/delta` text appended to item `id`'s `field` since its latest
65    /// revision arrived, or `None` when none has.
66    pub fn accumulated(&self, id: &str, field: &str) -> Option<&str> {
67        self.deltas.get(id)?.get(field).map(String::as_str)
68    }
69
70    pub(crate) fn ids(&self) -> &[String] {
71        &self.order
72    }
73}
74
75impl SessionFold {
76    pub(super) fn item(&mut self, method: &str, params: &Map<String, Value>) -> FoldOutcome {
77        let Some(item) = params.get("item").and_then(Value::as_object) else {
78            return FoldOutcome::Ignored;
79        };
80        let (Some(id), Some(revision)) = (
81            string(item, "itemId"),
82            item.get("revision").and_then(Value::as_u64),
83        ) else {
84            return FoldOutcome::Ignored;
85        };
86        let value = Value::Object(item.clone());
87        let open = method != "item/completed";
88        let outcome = match self.items.values.entry(id.to_owned()) {
89            Entry::Vacant(slot) => {
90                self.items.order.push(id.to_owned());
91                slot.insert(StoredItem {
92                    revision,
93                    value,
94                    open,
95                });
96                ItemOutcome::Inserted
97            }
98            Entry::Occupied(mut slot)
99                if revision > slot.get().revision
100                    || (revision == slot.get().revision && !open && slot.get().open) =>
101            {
102                let from = slot.get().revision;
103                slot.insert(StoredItem {
104                    revision,
105                    value,
106                    open,
107                });
108                ItemOutcome::Replaced { from, to: revision }
109            }
110            Entry::Occupied(slot) => ItemOutcome::IgnoredStale {
111                held: slot.get().revision,
112                offered: revision,
113            },
114        };
115        if !matches!(outcome, ItemOutcome::IgnoredStale { .. }) {
116            self.items.deltas.remove(id);
117        }
118        FoldOutcome::Item(outcome)
119    }
120
121    pub(super) fn delta(&mut self, params: &Map<String, Value>) -> FoldOutcome {
122        let (Some(id), Some(delta)) = (string(params, "itemId"), string(params, "delta")) else {
123            return FoldOutcome::Ignored;
124        };
125        let field = string(params, "field").unwrap_or("text");
126        let Some(item) = self.items.values.get_mut(id) else {
127            return FoldOutcome::Ignored;
128        };
129        if !item.open || !append_delta(&mut item.value, field, delta) {
130            return FoldOutcome::Ignored;
131        }
132        self.items
133            .deltas
134            .entry(id.to_owned())
135            .or_default()
136            .entry(field.to_owned())
137            .or_default()
138            .push_str(delta);
139        FoldOutcome::Applied
140    }
141}
142
143fn append_delta(value: &mut Value, field: &str, delta: &str) -> bool {
144    let mut segments = field.split('.').peekable();
145    let Some(first) = segments.next().filter(|segment| !segment.is_empty()) else {
146        return false;
147    };
148    let Value::Object(root) = value else {
149        return false;
150    };
151    let mut target = match root.get_mut(first) {
152        Some(value) => value,
153        None if segments.peek().is_none() => {
154            root.insert(first.to_owned(), Value::String(delta.to_owned()));
155            return true;
156        }
157        None => return false,
158    };
159    while let Some(segment) = segments.next() {
160        if segment.is_empty() {
161            return false;
162        }
163        let is_last = segments.peek().is_none();
164        if let Ok(index) = segment.parse::<usize>() {
165            let Value::Array(values) = target else {
166                return false;
167            };
168            if index > values.len() {
169                return false;
170            }
171            if index == values.len() {
172                if !is_last {
173                    return false;
174                }
175                values.push(Value::String(delta.to_owned()));
176                return true;
177            }
178            target = &mut values[index];
179        } else {
180            let Value::Object(object) = target else {
181                return false;
182            };
183            if object.contains_key(segment) {
184                target = &mut object[segment];
185            } else if is_last {
186                object.insert(segment.to_owned(), Value::String(delta.to_owned()));
187                return true;
188            } else {
189                return false;
190            }
191        }
192    }
193    match target {
194        Value::Null => {
195            *target = Value::String(delta.to_owned());
196            true
197        }
198        Value::String(text) => {
199            text.push_str(delta);
200            true
201        }
202        _ => false,
203    }
204}