1use crate::error::TabnasError;
4use crate::options::Options;
5use crate::rule::{Rule, RuleSnapshot};
6use crate::token::Token;
7use crate::value::unwrap_arc;
8use crate::value::Value;
9use indexmap::IndexMap;
10use std::cell::RefCell;
11use std::collections::VecDeque;
12use std::fmt;
13use std::rc::Rc;
14use std::sync::Arc;
15
16#[derive(Debug, Clone, PartialEq, Eq)]
17pub struct ActionError {
18 pub code: String,
19 pub detail: String,
20}
21
22impl ActionError {
23 pub fn new(code: impl Into<String>, detail: impl Into<String>) -> Self {
24 Self {
25 code: code.into(),
26 detail: detail.into(),
27 }
28 }
29}
30
31impl fmt::Display for ActionError {
32 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
33 formatter.write_str(&self.detail)
34 }
35}
36
37impl std::error::Error for ActionError {}
38
39#[derive(Debug, Clone, Default, PartialEq, Eq)]
43pub struct InstanceInfo {
44 pub id: String,
45 pub parent_id: Option<String>,
46 pub tag: String,
47 pub plugins: Vec<String>,
48 pub rule_names: Vec<String>,
49}
50
51#[derive(Debug, Clone, Default, PartialEq)]
55pub struct ContextSeed {
56 pub meta: Option<Value>,
57 pub u: IndexMap<String, Value>,
58}
59
60impl From<ActionError> for TabnasError {
61 fn from(action_error: ActionError) -> Self {
62 let mut error = TabnasError::new(action_error.code, "", "", 0, 1, 1);
63 error.detail = action_error.detail;
64 error
65 }
66}
67
68fn follow_stack(frames: &mut Vec<Rc<RuleSnapshot>>, stack: &[Rule]) {
70 frames.truncate(stack.len());
71 for rule in &stack[frames.len()..] {
72 frames.push(rule.snapshot());
73 }
74}
75
76#[cfg(debug_assertions)]
86fn same_rule(snapshot: &crate::RuleSnapshot, rule: &Rule) -> bool {
87 snapshot.i == rule.i
88 && snapshot.d == rule.d
89 && snapshot.name == rule.name
92 && snapshot.state == rule.state
93 && snapshot.need == rule.need
94 && snapshot.bo == rule.bo
95 && snapshot.ao == rule.ao
96 && snapshot.bc == rule.bc
97 && snapshot.ac == rule.ac
98 && snapshot.next_rule_name == rule.next_rule_name
99 && snapshot.n == rule.n
100 && same_values(&snapshot.u, &rule.u)
101 && same_values(&snapshot.k, &rule.k)
102 && same_tokens(&snapshot.o, &rule.o)
103 && same_tokens(&snapshot.c, &rule.c)
104 && same_link(&snapshot.parent_rule, &rule.parent_rule)
105 && same_link(&snapshot.child_rule, &rule.child_rule)
106 && same_link(&snapshot.prev_rule, &rule.prev_rule)
107 && same_link(&snapshot.next_rule, &rule.next_rule)
108}
109
110#[cfg(debug_assertions)]
111fn same_values(
112 left: &std::collections::HashMap<String, Value>,
113 right: &std::collections::HashMap<String, Value>,
114) -> bool {
115 left.len() == right.len()
116 && left
117 .iter()
118 .all(|(key, value)| right.get(key).is_some_and(|other| value.deep_equal(other)))
119}
120
121#[cfg(debug_assertions)]
125fn same_tokens(left: &[Token], right: &[Token]) -> bool {
126 left.len() == right.len()
127 && left.iter().zip(right).all(|(left, right)| {
128 left.name == right.name
129 && left.tin == right.tin
130 && left.src == right.src
131 && left.len == right.len
132 && left.site == right.site
133 && left.err == right.err
134 && left.why == right.why
135 && left.val.deep_equal(&right.val)
136 && same_values(left.use_data(), right.use_data())
137 })
138}
139
140#[cfg(debug_assertions)]
144fn same_link(
145 snapshot: &Option<std::rc::Rc<crate::RuleSnapshot>>,
146 rule: &Option<std::rc::Rc<crate::RuleSnapshot>>,
147) -> bool {
148 match (snapshot, rule) {
149 (None, None) => true,
150 (Some(left), Some(right)) => std::rc::Rc::ptr_eq(left, right),
151 _ => false,
152 }
153}
154
155#[derive(Debug)]
162pub struct Context {
163 pub iteration: usize,
165 pub source: String,
167 pub meta: Value,
169 pub u: IndexMap<String, Value>,
171 pub errs: Vec<TabnasError>,
173 pub options: Arc<Options>,
179 pub instance: InstanceInfo,
181 pub rule: Option<Rc<RuleSnapshot>>,
184 pub rule_stack: Vec<Rc<RuleSnapshot>>,
185 #[cfg(debug_assertions)]
189 rule_stack_shadow: Vec<Rc<RuleSnapshot>>,
190 pub v: VecDeque<Token>,
197 pub v_abs: usize,
199 pub t: Vec<Token>,
201 replay: VecDeque<Token>,
202 history_limit: Option<usize>,
203 root: Option<Rc<RefCell<Value>>>,
204 pub(crate) recover_at: Option<usize>,
205 pub(crate) recover_si: Option<usize>,
206 pub(crate) bad_to: Option<usize>,
207 pub(crate) bad_error: Option<usize>,
208 probe_owners: Vec<usize>,
213 probe_pass: bool,
216}
217
218impl Context {
219 pub(crate) fn new(
220 history_limit: Option<usize>,
221 source: impl Into<String>,
222 meta: Value,
223 options: Arc<Options>,
224 instance: InstanceInfo,
225 ) -> Self {
226 Self {
227 iteration: 0,
228 source: source.into(),
229 meta,
230 u: IndexMap::new(),
231 errs: Vec::new(),
232 options,
233 instance,
234 rule: None,
235 rule_stack: Vec::new(),
236 #[cfg(debug_assertions)]
237 rule_stack_shadow: Vec::new(),
238 v: VecDeque::new(),
239 v_abs: 0,
240 t: Vec::with_capacity(8),
241 replay: VecDeque::new(),
242 history_limit,
243 root: None,
244 recover_at: None,
245 recover_si: None,
246 bad_to: None,
247 bad_error: None,
248 probe_owners: Vec::new(),
249 probe_pass: false,
250 }
251 }
252
253 pub fn probe_open(&mut self, rule: &RuleSnapshot) {
263 self.probe_owners.push(rule.d);
264 self.probe_pass = true;
265 }
266
267 pub fn probe_close(&mut self) {
271 self.probe_owners.pop();
272 self.probe_pass = true;
273 }
274
275 pub fn probe_depth(&self) -> usize {
277 self.probe_owners.len()
278 }
279
280 pub fn probe_abandon(&mut self, rule: &RuleSnapshot) -> bool {
286 let probe = !self.probe_owners.is_empty();
287 while self
288 .probe_owners
289 .last()
290 .is_some_and(|depth| rule.d <= *depth)
291 {
292 self.probe_owners.pop();
293 }
294 probe
295 }
296
297 pub fn probe_take(&mut self) -> bool {
304 let probe = !self.probe_owners.is_empty() || self.probe_pass;
305 self.probe_pass = false;
306 probe
307 }
308
309 pub fn mark(&self) -> usize {
311 self.v_abs
312 }
313
314 pub fn v1(&self) -> Option<&Token> {
316 self.v.back()
317 }
318
319 pub fn v2(&self) -> Option<&Token> {
321 self.v.get(self.v.len().wrapping_sub(2))
322 }
323
324 pub fn t0(&self) -> Option<&Token> {
325 self.t.first()
326 }
327
328 pub fn t1(&self) -> Option<&Token> {
329 self.t.get(1)
330 }
331
332 pub fn set_t0(&mut self, token: Token) {
333 if self.t.is_empty() {
334 self.t.push(token);
335 } else {
336 self.t[0] = token;
337 }
338 }
339
340 pub fn set_t1(&mut self, token: Token) {
341 while self.t.len() < 2 {
342 self.t.push(Token::no_token());
343 }
344 self.t[1] = token;
345 }
346
347 pub fn set_v1(&mut self, token: Token) {
348 if let Some(last) = self.v.back_mut() {
349 *last = token;
350 } else {
351 self.v.push_back(token);
352 }
353 }
354
355 pub fn set_v2(&mut self, token: Token) {
356 match self.v.len() {
357 0 => self.v.push_back(token),
358 1 => self.v.push_front(token),
359 length => self.v[length - 2] = token,
360 }
361 }
362
363 pub fn root(&self) -> Option<Value> {
364 self.root.as_ref().map(|root| root.borrow().clone())
365 }
366
367 pub(crate) fn set_root(&mut self, root: Rc<RefCell<Value>>) {
368 self.root = Some(root);
369 }
370
371 pub(crate) fn set_active(&mut self, rule: &Rule, stack: &[Rule]) {
372 self.set_rule(rule);
373 self.sync_rule_stack(stack);
374 }
375
376 fn sync_rule_stack(&mut self, stack: &[Rule]) {
410 follow_stack(&mut self.rule_stack, stack);
411 #[cfg(debug_assertions)]
412 {
413 follow_stack(&mut self.rule_stack_shadow, stack);
414 debug_assert!(
415 self.rule_stack_shadow
416 .iter()
417 .zip(stack)
418 .all(|(snapshot, rule)| same_rule(snapshot, rule)),
419 "the incremental rule stack drifted from the live parse stack"
420 );
421 }
422 }
423
424 pub(crate) fn set_rule(&mut self, rule: &Rule) {
425 self.rule = Some(rule.snapshot());
426 }
427
428 pub(crate) fn apply_seed(&mut self, seed: &ContextSeed) {
429 if let Some(meta) = &seed.meta {
430 self.meta = merge_seed_value(self.meta.clone(), meta.clone());
431 }
432 for (key, value) in &seed.u {
433 let previous = self.u.shift_remove(key).unwrap_or(Value::Undefined);
434 self.u
435 .insert(key.clone(), merge_seed_value(previous, value.clone()));
436 }
437 self.errs.clear();
438 }
439
440 pub fn rewind(&mut self, mark: usize) -> Result<(), ActionError> {
447 let Some(count) = self.v_abs.checked_sub(mark) else {
448 return Ok(());
449 };
450 if count == 0 {
451 return Ok(());
452 }
453 if count > self.v.len() {
454 return Err(ActionError::new(
455 "internal",
456 format!(
457 "tabnas: ctx.rewind target {mark} is outside the retained history window \
458 (oldest mark available is {}, current is {}); increase \
459 options.rewind.history",
460 self.v_abs - self.v.len(),
461 self.v_abs,
462 ),
463 ));
464 }
465
466 let retained_at = self.v.len() - count;
467 let rewound = self.v.split_off(retained_at);
468 let lookahead = std::mem::take(&mut self.t);
469 let pending = std::mem::take(&mut self.replay);
470 self.replay = rewound
471 .into_iter()
472 .chain(lookahead)
473 .chain(pending)
474 .collect();
475 self.v_abs -= count;
476 Ok(())
477 }
478
479 pub(crate) fn record_consumed(&mut self, count: usize) {
480 if count == 0 {
481 return;
482 }
483 let count = count.min(self.t.len());
484 self.v.extend(self.t.drain(0..count));
485 self.v_abs += count;
486
487 if let Some(limit) = self.history_limit {
488 if self.v.len() > 2 * limit {
489 let remove = self.v.len() - limit;
490 self.v.drain(0..remove);
491 }
492 }
493 }
494
495 pub(crate) fn oldest_held(&self) -> Option<usize> {
500 self.t
501 .iter()
502 .chain(self.replay.iter())
503 .chain(self.v.iter())
504 .map(|token| token.site.pos)
505 .min()
506 }
507
508 pub(crate) fn next_replay(&mut self) -> Option<Token> {
509 self.replay.pop_front()
510 }
511
512 pub(crate) fn take_replay(&mut self) -> VecDeque<Token> {
513 std::mem::take(&mut self.replay)
514 }
515
516 pub(crate) fn restore_replay(&mut self, replay: VecDeque<Token>) {
517 self.replay = replay;
518 }
519}
520
521fn merge_seed_value(base: Value, overlay: Value) -> Value {
522 match (base, overlay) {
523 (base, Value::Undefined) => base,
524 (Value::Object(base), Value::Object(overlay)) => {
525 let mut base = unwrap_arc(base);
526 for (key, value) in unwrap_arc(overlay) {
527 let previous = base.shift_remove(&key).unwrap_or(Value::Undefined);
528 base.insert(key, merge_seed_value(previous, value));
529 }
530 Value::object(base)
531 }
532 (_, overlay) => overlay,
533 }
534}
535
536#[cfg(test)]
537mod probe_tests {
538 use super::*;
539
540 fn context() -> Context {
541 let options = Arc::new(Options::default());
542 Context::new(
543 options.rewind.history,
544 "",
545 Value::Undefined,
546 Arc::clone(&options),
547 InstanceInfo::default(),
548 )
549 }
550
551 fn rule_at(d: usize) -> crate::Rule {
552 let mut rule = crate::Rule::new("r", Value::Undefined);
553 rule.d = d;
554 rule
555 }
556
557 #[test]
561 fn probes_nest_and_flag_the_passes_that_open_and_close_them() {
562 let mut ctx = context();
563 assert!(!ctx.probe_take());
564 ctx.probe_open(&rule_at(2));
565 assert!(ctx.probe_take(), "the pass that opens a probe");
566 ctx.probe_open(&rule_at(4));
567 ctx.probe_close();
568 assert!(ctx.probe_take(), "still inside the outer probe");
569 ctx.probe_close();
570 assert_eq!(ctx.probe_depth(), 0);
571 assert!(ctx.probe_take(), "the pass that closes the outer probe");
572 assert!(!ctx.probe_take(), "the next pass is the document again");
573 ctx.probe_close();
574 assert_eq!(
575 ctx.probe_depth(),
576 0,
577 "an unmatched close does not underflow"
578 );
579 }
580
581 #[test]
584 fn abandoning_a_rule_closes_its_probes_and_only_those() {
585 let mut ctx = context();
586 ctx.probe_open(&rule_at(2));
587 ctx.probe_open(&rule_at(4));
588 ctx.probe_take();
589 for (d, probe, depth) in [(5, true, 2), (4, true, 1), (3, true, 1), (2, true, 0)] {
591 assert_eq!(ctx.probe_abandon(&rule_at(d)), probe, "abandon d={d}");
592 assert_eq!(ctx.probe_depth(), depth, "abandon d={d}");
593 }
594 assert!(!ctx.probe_take(), "the next pass is the document again");
595 assert!(!ctx.probe_abandon(&rule_at(1)), "outside every probe");
596 }
597}