muse_code_sdk/fold/
items.rs1use std::collections::{HashMap, hash_map::Entry};
2
3use serde_json::{Map, Value};
4
5use super::{FoldOutcome, SessionFold, string};
6
7#[derive(Debug, Clone, PartialEq, Eq)]
9#[non_exhaustive]
10pub enum ItemOutcome {
11 Inserted,
13 Replaced {
16 from: u64,
18 to: u64,
20 },
21 IgnoredStale {
24 held: u64,
26 offered: u64,
28 },
29}
30
31#[derive(Debug, Clone)]
32struct StoredItem {
33 revision: u64,
34 value: Value,
35 open: bool,
36}
37
38#[derive(Debug, Default)]
40pub struct Items {
41 values: HashMap<String, StoredItem>,
42 deltas: HashMap<String, HashMap<String, String>>,
43 order: Vec<String>,
45}
46
47impl Items {
48 pub fn get(&self, id: &str) -> Option<&Value> {
51 self.values.get(id).map(|item| &item.value)
52 }
53
54 pub fn len(&self) -> usize {
56 self.values.len()
57 }
58
59 pub fn is_empty(&self) -> bool {
61 self.values.is_empty()
62 }
63
64 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}