prikk-store 0.24.0

Prikk storage crate scaffold.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use prikk_object::{NodeId, text_span_hash};

use crate::node_lifecycle::NodeLifecycleState;
use crate::text_span;

use super::evidence_types::{
    ClassificationResult, Evidence, EvidenceError, EvidenceScope, PatchAlgebraEvidence,
};
use super::preimage::baseline_text_blob_for_mode;
use super::types::{Action, ConflictWitnessKind, OperationFacts, PairClass};
use super::witness::{conflict, conflict_with_span};

pub(super) fn classify_mode_and_text_edit<R: PatchAlgebraEvidence>(
    baseline: &NodeLifecycleState,
    text_resolver: &R,
    left: &OperationFacts,
    right: &OperationFacts,
    node_id: NodeId,
    old_mode: u32,
    edit: &Action,
) -> ClassificationResult {
    let Some(current_blob_id) = baseline_text_blob_for_mode(baseline, node_id, old_mode) else {
        return Ok(conflict(
            ConflictWitnessKind::LiveStateMismatch,
            left,
            right,
            Some(node_id),
            None,
        ));
    };
    let current_text = match text_resolver.baseline_text(
        EvidenceScope::SealedBaselineRequired,
        node_id,
        current_blob_id,
    ) {
        Evidence::Known(text) => text,
        other => return Err(evidence_error(other)),
    };
    match edit {
        Action::EditText {
            span_id,
            old_span_hash,
            left_anchor_hash,
            right_anchor_hash,
            old_span_text,
            ..
        } => {
            if text_span_hash(old_span_text) != *old_span_hash {
                return Ok(conflict_with_span(
                    ConflictWitnessKind::TextAnchorStale,
                    left,
                    right,
                    node_id,
                    *span_id,
                ));
            }
            match text_span::locate_text_span(
                &current_text,
                old_span_text,
                left_anchor_hash,
                right_anchor_hash,
                span_id,
                node_id,
                old_span_hash,
            ) {
                Ok(_) => Ok(PairClass::Independent),
                Err(_) => Ok(conflict_with_span(
                    ConflictWitnessKind::TextAnchorStale,
                    left,
                    right,
                    node_id,
                    *span_id,
                )),
            }
        }
        _ => unreachable!("caller passes only EditText actions"),
    }
}

fn evidence_error<T>(evidence: Evidence<T>) -> EvidenceError {
    evidence.into_error()
}