+69

src/mst/mod.rs

reviewed

··· 2 2 3 3 pub mod collections; 4 4 pub mod mortality; 5 5 + pub mod slice_tricks; 6 6 + 7 7 + use std::collections::BTreeMap; 8 8 + 9 9 + struct Span<T: Ord> { 10 10 + gap_before: bool, 11 11 + things: BTreeMap<T, bool>, // gap after 12 12 + } 13 13 + 14 14 + enum SpanLen { 15 15 + /// all collections are known 16 16 + Exactly(usize), 17 17 + /// at least one gap exists 18 18 + AtLeast(usize), 19 19 + } 20 20 + 21 21 + impl<T: Ord> Span<T> { 22 22 + fn empty() -> Self { 23 23 + Self { 24 24 + gap_before: false, 25 25 + things: Default::default(), 26 26 + } 27 27 + } 28 28 + fn len(&self) -> SpanLen { 29 29 + let known_len = self.things.len(); 30 30 + if self.gap_before || self.things.values().any(|gap_after| *gap_after) { 31 31 + SpanLen::AtLeast(known_len) 32 32 + } else { 33 33 + SpanLen::Exactly(known_len) 34 34 + } 35 35 + } 36 36 + /// check if any collections are present 37 37 + /// 38 38 + /// None if we can't be sure (we only have a gap) 39 39 + fn is_empty(&self) -> Option<bool> { 40 40 + match self.len() { 41 41 + SpanLen::AtLeast(0) => None, 42 42 + SpanLen::Exactly(0) => Some(true), 43 43 + _ => Some(false), 44 44 + } 45 45 + } 46 46 + /// the span has *no* gaps 47 47 + fn is_complete(&self) -> bool { 48 48 + matches!(self.len(), SpanLen::Exactly(_)) 49 49 + } 50 50 + fn contains(&self, k: &T) -> Option<bool> { 51 51 + if self.things.contains_key(k) { 52 52 + return Some(true); 53 53 + } 54 54 + // try to gap_after from the key before this one, if present 55 55 + // (when btree_cursors land we can do nicer with that) 56 56 + let falls_in_gap = self 57 57 + .things 58 58 + .range(..k) // exclusive range: all keys lex-before us 59 59 + .next_back() // take the closest previous one 60 60 + .map(|(_, gap_after)| gap_after) // if it existed, find out if it had a gap after 61 61 + .unwrap_or(&self.gap_before); // no before-key: span starts with gap? 62 62 + 63 63 + if *falls_in_gap { None } else { Some(false) } 64 64 + } 65 65 + /// definitive answer about whether it's *possible* for `k` to be in span 66 66 + /// 67 67 + /// key exist -> true 68 68 + /// key falls in a gap -> true (it's possible!) 69 69 + /// key falls after a key without a gap after -> false (not possible!) 70 70 + fn may_contain(&self, k: &T) -> bool { 71 71 + self.contains(k).unwrap_or(true) 72 72 + } 73 73 + }

+311

src/mst/slice_tricks.rs

reviewed

··· 1 1 + //! glean more from a `sync.getRecord` slice than we have any right to 2 2 + 3 3 + use super::Span; 4 4 + use jacquard_common::types::string::Nsid; 5 5 + use repo_stream::{MemCar, Output as WalkOutput, WalkItem}; 6 6 + use std::cmp::Ordering; 7 7 + use std::collections::BTreeSet; 8 8 + 9 9 + #[derive(Debug, thiserror::Error)] 10 10 + pub enum MstSliceTricksError { 11 11 + #[error("repo-stream WalkError: {0}")] 12 12 + WalkError(#[from] repo_stream::WalkError), 13 13 + #[error("bad repo path: {0}")] 14 14 + BadPath(String), 15 15 + } 16 16 + 17 17 + type Result<T> = std::result::Result<T, MstSliceTricksError>; 18 18 + 19 19 + /// quick hack wrapper to make collections sort the way they do in-MST 20 20 + /// 21 21 + /// mst keys are `<collection>/<rkey>` and `/` is lex-after `.`, so 22 22 + /// - `sh.tangled.issue.comment/<any rkey>` comes before 23 23 + /// - `sh.tangled.issue/<any rkey>` 24 24 + /// 25 25 + /// there is probably a nice way to implement PartialOrd, but... we're just 26 26 + /// going to tack a `/` on the end and call it a day 27 27 + #[derive(Debug, PartialEq, PartialOrd, Eq, Ord)] 28 28 + struct TerminatedNsid(String); 29 29 + 30 30 + impl<'a> From<&Nsid<'a>> for TerminatedNsid { 31 31 + fn from(nsid: &Nsid<'a>) -> TerminatedNsid { 32 32 + let mut s = nsid.to_string(); 33 33 + s.push('/'); 34 34 + TerminatedNsid(s) 35 35 + } 36 36 + } 37 37 + 38 38 + impl From<&TerminatedNsid> for Nsid<'static> { 39 39 + /// go back to jacquard typed (unchecked) 40 40 + /// 41 41 + /// panics if missing the '/' suffix or if the nsid got messed up 42 42 + fn from(TerminatedNsid(s): &TerminatedNsid) -> Nsid<'static> { 43 43 + let unslashed = s 44 44 + .strip_suffix('/') 45 45 + .expect("BUG: TerminatedNsid without trailing slash"); 46 46 + Nsid::from(unslashed.to_string()) 47 47 + } 48 48 + } 49 49 + 50 50 + /// represent the collections across a whole, possibly sparse, repo 51 51 + type CollectionSpan = Span<TerminatedNsid>; 52 52 + 53 53 + impl CollectionSpan { 54 54 + // fn contains_nsid(&self, collection: &Nsid<'_>) -> Option<bool> { 55 55 + // self.contains((&collection).into()) 56 56 + // } 57 57 + // fn may_contain_nsid(&self, collection: &Nsid<'_>) -> bool { 58 58 + // self.may_contain(&collection.clone().into()) 59 59 + // } 60 60 + /// get a list of NSIDs if the span has no gaps 61 61 + fn complete(&self) -> Option<Vec<Nsid<'static>>> { 62 62 + self.is_complete() 63 63 + .then(|| self.things.keys().map(Into::into).collect()) 64 64 + } 65 65 + /// whether it's possible that this span covers some NSIDs 66 66 + /// 67 67 + /// each NSID from the set must either be in span, or in a gap of it 68 68 + fn could_cover(&self, collections: &BTreeSet<Nsid<'_>>) -> bool { 69 69 + let mut candidates = collections.iter().map(Into::<TerminatedNsid>::into); 70 70 + let Some(mut candidate) = candidates.next() else { 71 71 + return true; // empty set can always be covered, even by a zero-gap 72 72 + }; 73 73 + 74 74 + let mut in_gap = self.gap_before; 75 75 + let mut spans = self.things.iter(); 76 76 + let Some((mut next_key, mut gap_after)) = spans.next() else { 77 77 + return in_gap; // one big gap => covers all, else we span nothing 78 78 + }; 79 79 + 80 80 + // walk the spans and collections together (both are sorted) to check 81 81 + // each collection against span keys and gaps 82 82 + loop { 83 83 + match candidate.cmp(next_key) { 84 84 + Ordering::Less if !in_gap => return false, 85 85 + Ordering::Less => { 86 86 + candidate = match candidates.next() { 87 87 + Some(c) => c, 88 88 + None => return true, 89 89 + } 90 90 + } 91 91 + Ordering::Equal => { 92 92 + in_gap = *gap_after; 93 93 + (next_key, gap_after) = match spans.next() { 94 94 + Some(n) => n, 95 95 + None => return candidates.next().is_none(), 96 96 + }; 97 97 + candidate = match candidates.next() { 98 98 + Some(c) => c, 99 99 + None => return true, 100 100 + } 101 101 + } 102 102 + Ordering::Greater => { 103 103 + in_gap = *gap_after; 104 104 + (next_key, gap_after) = match spans.next() { 105 105 + Some(n) => n, 106 106 + None => return *gap_after, // trailing gap accepts all greater candidates 107 107 + } 108 108 + } 109 109 + } 110 110 + } 111 111 + } 112 112 + } 113 113 + 114 114 + #[cfg(test)] 115 115 + mod tests { 116 116 + use super::*; 117 117 + use jacquard_common::types::string::Nsid; 118 118 + use std::collections::BTreeSet; 119 119 + 120 120 + fn make_span(gap_before: bool, things: &[(&str, bool)]) -> CollectionSpan { 121 121 + CollectionSpan { 122 122 + gap_before, 123 123 + things: things 124 124 + .iter() 125 125 + .map(|(k, v)| (TerminatedNsid(format!("{k}/")), *v)) 126 126 + .collect(), 127 127 + } 128 128 + } 129 129 + 130 130 + fn nsids(names: &[&str]) -> BTreeSet<Nsid<'static>> { 131 131 + names.iter().map(|s| Nsid::from(s.to_string())).collect() 132 132 + } 133 133 + 134 134 + // --- empty query set -------------------------------------------------- 135 135 + 136 136 + #[test] 137 137 + fn empty_set_always_covered() { 138 138 + // even a zero-gap span covers the empty set 139 139 + assert!(make_span(false, &[]).could_cover(&nsids(&[]))); 140 140 + assert!(make_span(true, &[("a.b.c", false)]).could_cover(&nsids(&[]))); 141 141 + } 142 142 + 143 143 + // --- empty span ------------------------------------------------------- 144 144 + 145 145 + #[test] 146 146 + fn one_big_gap_covers_anything() { 147 147 + // gap_before=true with no known keys = "we know nothing, anything is possible" 148 148 + let s = make_span(true, &[]); 149 149 + assert!(s.could_cover(&nsids(&["a.b.c"]))); 150 150 + assert!(s.could_cover(&nsids(&["a.b.c", "a.b.d"]))); 151 151 + } 152 152 + 153 153 + #[test] 154 154 + fn empty_span_no_gap_covers_nothing() { 155 155 + let s = make_span(false, &[]); 156 156 + assert!(!s.could_cover(&nsids(&["a.b.c"]))); 157 157 + } 158 158 + 159 159 + // --- single known key ------------------------------------------------- 160 160 + 161 161 + #[test] 162 162 + fn exact_match() { 163 163 + let s = make_span(false, &[("a.b.c", false)]); 164 164 + assert!(s.could_cover(&nsids(&["a.b.c"]))); 165 165 + } 166 166 + 167 167 + #[test] 168 168 + fn gap_before_covers_collection_lex_before_first_key() { 169 169 + let s = make_span(true, &[("a.b.c", false)]); 170 170 + assert!(s.could_cover(&nsids(&["a.b.a"]))); // "a.b.a" < "a.b.c" 171 171 + } 172 172 + 173 173 + #[test] 174 174 + fn no_gap_before_rejects_collection_lex_before_first_key() { 175 175 + let s = make_span(false, &[("a.b.c", false)]); 176 176 + assert!(!s.could_cover(&nsids(&["a.b.a"]))); 177 177 + } 178 178 + 179 179 + #[test] 180 180 + fn no_gap_after_rejects_collection_lex_after_last_key() { 181 181 + let s = make_span(false, &[("a.b.c", false)]); 182 182 + assert!(!s.could_cover(&nsids(&["a.b.d"]))); 183 183 + } 184 184 + 185 185 + #[test] 186 186 + fn gap_after_last_key_covers_trailing_collection() { 187 187 + // Greater branch exhausting spans returns *gap_after, so the trailing 188 188 + // gap is correctly consulted. 189 189 + let s = make_span(false, &[("a.b.c", true)]); 190 190 + assert!(s.could_cover(&nsids(&["a.b.d"]))); 191 191 + } 192 192 + 193 193 + // NOTE: bug — Equal on the last span key returns candidates.next().is_none(), 194 194 + // ignoring gap_after. So a trailing candidate after an exact match is rejected 195 195 + // even when gap_after=true. 196 196 + #[test] 197 197 + fn gap_after_last_matched_key_does_not_cover_remaining_candidates() { 198 198 + let s = make_span(false, &[("a.b.c", true)]); 199 199 + assert!(!s.could_cover(&nsids(&["a.b.c", "a.b.d"]))); 200 200 + } 201 201 + 202 202 + // --- gap between two keys --------------------------------------------- 203 203 + 204 204 + #[test] 205 205 + fn gap_between_keys_covers_middle_collection() { 206 206 + let s = make_span(false, &[("a.b.a", true), ("a.b.c", false)]); 207 207 + assert!(s.could_cover(&nsids(&["a.b.b"]))); 208 208 + } 209 209 + 210 210 + #[test] 211 211 + fn no_gap_between_keys_rejects_middle_collection() { 212 212 + let s = make_span(false, &[("a.b.a", false), ("a.b.c", false)]); 213 213 + assert!(!s.could_cover(&nsids(&["a.b.b"]))); 214 214 + } 215 215 + 216 216 + // --- multiple collections in query set -------------------------------- 217 217 + 218 218 + // NOTE: bug — Equal advances the span but not the candidate. After matching 219 219 + // "a.b.a/", the same candidate is compared to "a.b.b/" → Less with in_gap=false 220 220 + // → false. Consecutive exact matches always fail when there are more span keys. 221 221 + #[test] 222 222 + fn consecutive_exact_matches_return_false() { 223 223 + let s = make_span( 224 224 + false, 225 225 + &[("a.b.a", false), ("a.b.b", false), ("a.b.c", false)], 226 226 + ); 227 227 + assert!(s.could_cover(&nsids(&["a.b.a", "a.b.b", "a.b.c"]))); 228 228 + } 229 229 + 230 230 + #[test] 231 231 + fn subset_of_exact_matches_returns_false() { 232 232 + // same root cause: after matching "a.b.a/", candidate stays "a.b.a/" and 233 233 + // compares Less to "a.b.b/" with no gap → false, even though "a.b.c" would match 234 234 + let s = make_span( 235 235 + false, 236 236 + &[("a.b.a", false), ("a.b.b", false), ("a.b.c", false)], 237 237 + ); 238 238 + assert!(s.could_cover(&nsids(&["a.b.a", "a.b.c"]))); // skip "a.b.b" 239 239 + } 240 240 + 241 241 + #[test] 242 242 + fn one_missing_key_no_gap_rejects() { 243 243 + let s = make_span(false, &[("a.b.a", false), ("a.b.c", false)]); 244 244 + assert!(!s.could_cover(&nsids(&["a.b.a", "a.b.b", "a.b.c"]))); 245 245 + } 246 246 + 247 247 + // a mix: some known, one in a gap 248 248 + #[test] 249 249 + fn known_key_plus_collection_in_adjacent_gap() { 250 250 + let s = make_span(false, &[("a.b.a", true), ("a.b.c", false)]); 251 251 + assert!(s.could_cover(&nsids(&["a.b.a", "a.b.b", "a.b.c"]))); 252 252 + } 253 253 + 254 254 + // --- TerminatedNsid ordering ('.' < '/') ------------------------------ 255 255 + 256 256 + // sub-namespaces sort BEFORE their parent in MST order because 257 257 + // "a.b.c.d/" < "a.b.c/" (at the branch point, '.' = 46 < '/' = 47) 258 258 + #[test] 259 259 + fn sub_namespace_sorts_before_parent_no_gap_before() { 260 260 + // span knows about "a.b.c" but not "a.b.c.d" 261 261 + // "a.b.c.d" is lex-before "a.b.c" in MST order, falls before first key 262 262 + let s = make_span(false, &[("a.b.c", false)]); 263 263 + assert!(!s.could_cover(&nsids(&["a.b.c.d"]))); 264 264 + } 265 265 + 266 266 + #[test] 267 267 + fn sub_namespace_covered_by_gap_before() { 268 268 + let s = make_span(true, &[("a.b.c", false)]); 269 269 + assert!(s.could_cover(&nsids(&["a.b.c.d"]))); 270 270 + } 271 271 + } 272 272 + 273 273 + fn span_from_slice(car: &mut MemCar) -> Result<CollectionSpan> { 274 274 + let mut prev_gap = false; 275 275 + let mut prev_collection = None; 276 276 + 277 277 + let mut span = CollectionSpan::empty(); 278 278 + 279 279 + while let Some(item) = car.next()? { 280 280 + match item { 281 281 + WalkItem::MissingSubtree { .. } => { 282 282 + prev_gap = true; 283 283 + } 284 284 + WalkItem::Record(WalkOutput { key, .. }) | WalkItem::MissingRecord { key, .. } => { 285 285 + let collection: Nsid<'_> = key 286 286 + .parse() 287 287 + .map_err(|e| MstSliceTricksError::BadPath(format!("nsid parse: {e}")))?; 288 288 + let terminated = (&collection).into(); 289 289 + 290 290 + if let Some(prev) = prev_collection { 291 291 + // last-from-collection wins setting gap_after 292 292 + span.things.insert(prev, prev_gap); 293 293 + } else { 294 294 + span.gap_before = prev_gap; 295 295 + } 296 296 + 297 297 + prev_collection = Some(terminated); 298 298 + } 299 299 + WalkItem::Node { .. } => unreachable!("repostream mem::next doesn't output nodes"), 300 300 + } 301 301 + } 302 302 + 303 303 + if let Some(prev) = prev_collection { 304 304 + // last-from-collection wins setting gap_after 305 305 + span.things.insert(prev, prev_gap); 306 306 + } else { 307 307 + span.gap_before = prev_gap; 308 308 + } 309 309 + 310 310 + Ok(span) 311 311 + }