heddle-objects 0.15.0

An AI-native version control system
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

// SPDX-License-Identifier: Apache-2.0
use crate::{
    object::{Attribution, Blob, FileProvenance, Principal, State, StateId, Tree, TreeEntry},
    store::{InMemoryStore, ObjectStore},
};

pub(super) fn store() -> InMemoryStore {
    InMemoryStore::new()
}

pub(super) fn put_state_with_file(
    store: &InMemoryStore,
    file: &str,
    content: &[u8],
    parents: Vec<StateId>,
    principal_name: &str,
) -> State {
    let blob_hash = store.put_blob(&Blob::from_slice(content)).unwrap();
    let tree_hash = store
        .put_tree(&Tree::from_entries(vec![
            TreeEntry::file(file.to_string(), blob_hash, false).unwrap(),
        ]))
        .unwrap();
    let state = State::new(
        tree_hash,
        parents,
        Attribution::human(Principal::new(
            principal_name,
            format!("{principal_name}@example.com"),
        )),
    );
    store.put_state(&state).unwrap();
    state
}

pub(super) fn put_state_with_files(
    store: &InMemoryStore,
    files: &[(&str, &[u8])],
    parents: Vec<StateId>,
    principal_name: &str,
) -> State {
    let entries = files
        .iter()
        .map(|(name, content)| {
            let blob_hash = store.put_blob(&Blob::from_slice(content)).unwrap();
            TreeEntry::file((*name).to_string(), blob_hash, false).unwrap()
        })
        .collect();
    let tree_hash = store
        .put_tree(&Tree::from_entries(entries))
        .unwrap();
    let state = State::new(
        tree_hash,
        parents,
        Attribution::human(Principal::new(
            principal_name,
            format!("{principal_name}@example.com"),
        )),
    );
    store.put_state(&state).unwrap();
    state
}

pub(super) fn principals_at(provenance: &FileProvenance, line_idx: usize) -> Vec<String> {
    let line_origins = provenance.line_origin_set_indexes().unwrap();
    let set_idx = line_origins[line_idx];
    provenance.origin_sets[set_idx as usize]
        .origin_indexes
        .iter()
        .map(|index| {
            provenance.origins[*index as usize]
                .attribution
                .principal
                .name_lossy()
                .into_owned()
        })
        .collect()
}