sinter-store 0.53.0

Embedded persistent graph store (redb), queryable without loading the world
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

//! The one place the per-node scope rule lives: a node's own override, else
//! its file node's override (generated banners), else the persisted file
//! scope, else conservative path classification.

use std::collections::HashMap;

use redb::ReadableTable;
use sinter_core::{CorpusScope, Node};

use crate::error::StoreError;
use crate::store::{FILE_SCOPE, NODE_SCOPE, Store};

pub(crate) fn resolve(
    node_scope: impl Fn(&str) -> Option<CorpusScope>,
    file_scope: Option<CorpusScope>,
    id: &str,
    file: &str,
) -> CorpusScope {
    node_scope(id)
        .or_else(|| node_scope(file))
        .or(file_scope)
        .unwrap_or_else(|| CorpusScope::classify_path(file))
}

/// Read-side scope lookup loaded once per command.
#[derive(Debug, Default, Clone)]
pub struct ScopeIndex {
    files: HashMap<String, CorpusScope>,
    nodes: HashMap<String, CorpusScope>,
}

impl ScopeIndex {
    pub fn scope_of(&self, node: &Node) -> CorpusScope {
        self.scope_of_id(node.id.as_str(), &node.file)
    }

    pub fn scope_of_id(&self, id: &str, file: &str) -> CorpusScope {
        resolve(
            |key| self.nodes.get(key).copied(),
            self.files.get(file).copied(),
            id,
            file,
        )
    }

    /// File-level scope only (path/override based); node overrides ignored.
    pub fn file_scope(&self, file: &str) -> CorpusScope {
        self.scope_of_id(file, file)
    }
}

impl Store {
    pub fn scope_index(&self) -> Result<ScopeIndex, StoreError> {
        let files = self.file_scopes()?;
        let txn = self.db.begin_read()?;
        let table = txn.open_table(NODE_SCOPE)?;
        let mut nodes = HashMap::new();
        for entry in table.iter()? {
            let (id, scope) = entry?;
            if let Some(scope) = CorpusScope::from_str_opt(scope.value()) {
                nodes.insert(id.value().to_string(), scope);
            }
        }
        Ok(ScopeIndex { files, nodes })
    }

    pub fn node_scope(&self, node: &Node) -> Result<CorpusScope, StoreError> {
        let txn = self.db.begin_read()?;
        let nodes = txn.open_table(NODE_SCOPE)?;
        let files = txn.open_table(FILE_SCOPE)?;
        let lookup = |key: &str| {
            nodes
                .get(key)
                .ok()
                .flatten()
                .and_then(|g| CorpusScope::from_str_opt(g.value()))
        };
        let file_scope = files
            .get(node.file.as_str())?
            .and_then(|g| CorpusScope::from_str_opt(g.value()));
        Ok(resolve(lookup, file_scope, node.id.as_str(), &node.file))
    }
}