nmp-threading 1.0.0-rc.1

Reply-convention-agnostic timeline grouping algorithm. Owns ThreadPointer / ParentResolver / ModulePolicy / TimelineBlock / Grouper, consumed by per-NIP wrapper view modules (NIP-10 in nmp-nip01). No app nouns, no kind semantics.
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Shared fixtures for the grouper integration tests: a fake resolver that
//! decodes convention-agnostic tags (`e_parent`, `e_root`, `a_root`,
//! `i_root`, `e_supersedes`), event builders on top of it, and the
//! `block_ids` layout helper used across every behavior-area submodule.

use nmp_core::substrate::KernelEvent;
use nmp_threading::{Grouper, ModulePolicy, ParentResolver, ThreadPointer, TimelineBlock};

pub(crate) struct FakeResolver;

pub(crate) fn tag(key: &str, val: &str) -> Vec<String> {
    vec![key.into(), val.into()]
}

pub(crate) fn event_with_tags(id: &str, created_at: u64, tags: Vec<Vec<String>>) -> KernelEvent {
    KernelEvent {
        id: id.into(),
        author: "auth".into(),
        kind: 1,
        created_at,
        tags,
        content: id.into(),
        relay_provenance: Vec::new(),
    }
}

pub(crate) fn parent_tags(parent: Option<&str>) -> Vec<Vec<String>> {
    let mut tags = Vec::new();
    if let Some(p) = parent {
        tags.push(tag("e_parent", p));
    }
    tags
}

pub(crate) fn ev(
    id: &str,
    created_at: u64,
    parent: Option<&str>,
    root: Option<&str>,
) -> KernelEvent {
    let mut tags = parent_tags(parent);
    if let Some(r) = root {
        tags.push(tag("e_root", r));
    }
    event_with_tags(id, created_at, tags)
}

pub(crate) fn ev_addr_root(
    id: &str,
    created_at: u64,
    parent: Option<&str>,
    coord: &str,
) -> KernelEvent {
    let mut tags = parent_tags(parent);
    tags.push(tag("a_root", coord));
    event_with_tags(id, created_at, tags)
}

pub(crate) fn ev_uri_root(
    id: &str,
    created_at: u64,
    parent: Option<&str>,
    uri: &str,
) -> KernelEvent {
    let mut tags = parent_tags(parent);
    tags.push(tag("i_root", uri));
    event_with_tags(id, created_at, tags)
}

impl ParentResolver for FakeResolver {
    fn parent(&self, event: &KernelEvent) -> Option<ThreadPointer> {
        event.tags.iter().find_map(|t| match (t.first(), t.get(1)) {
            (Some(k), Some(v)) if k == "e_parent" => Some(ThreadPointer::Event {
                id: v.clone(),
                relay: None,
                kind: None,
            }),
            _ => None,
        })
    }
    fn root(&self, event: &KernelEvent) -> Option<ThreadPointer> {
        event.tags.iter().find_map(|t| match (t.first(), t.get(1)) {
            (Some(k), Some(v)) if k == "e_root" => Some(ThreadPointer::Event {
                id: v.clone(),
                relay: None,
                kind: None,
            }),
            (Some(k), Some(v)) if k == "a_root" => Some(ThreadPointer::Address {
                coord: v.clone(),
                relay: None,
                kind: None,
            }),
            (Some(k), Some(v)) if k == "i_root" => Some(ThreadPointer::External { uri: v.clone() }),
            _ => None,
        })
    }
    fn parent_author(&self, _event: &KernelEvent) -> Option<String> {
        None
    }
    fn supersedes(&self, event: &KernelEvent) -> Option<String> {
        event.tags.iter().find_map(|t| match (t.first(), t.get(1)) {
            (Some(k), Some(v)) if k == "e_supersedes" => Some(v.clone()),
            _ => None,
        })
    }
}

pub(crate) fn ev_supersedes(id: &str, created_at: u64, target: &str) -> KernelEvent {
    event_with_tags(id, created_at, vec![tag("e_supersedes", target)])
}

pub(crate) fn fresh() -> Grouper<FakeResolver> {
    Grouper::new(FakeResolver, ModulePolicy::default())
}

pub(crate) fn block_ids(b: &TimelineBlock) -> Vec<&str> {
    match b {
        TimelineBlock::Standalone { id, .. } => vec![id.as_str()],
        TimelineBlock::Module { events, .. } => events.iter().map(|s| s.as_str()).collect(),
    }
}