notegraf 0.1.1

Core library for building a graph-oriented notebook
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::collections::HashSet;

pub static NOTE_METADATA_CURRENT_SCHEMA_VERSION: u64 = 0;

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct NoteMetadata {
    pub schema_version: u64,
    pub created_at: DateTime<Utc>,
    pub modified_at: DateTime<Utc>,
    pub tags: HashSet<String>,
    pub custom_metadata: serde_json::Value,
}

impl Default for NoteMetadata {
    fn default() -> Self {
        let now = Utc::now();
        NoteMetadata {
            schema_version: NOTE_METADATA_CURRENT_SCHEMA_VERSION,
            created_at: now,
            modified_at: now,
            tags: HashSet::new(),
            custom_metadata: serde_json::json!({}),
        }
    }
}

impl NoteMetadata {
    pub(crate) fn on_update_note(&self) -> Self {
        // We cannot update the metadata if it's based on a newer schema
        assert!(NOTE_METADATA_CURRENT_SCHEMA_VERSION >= self.schema_version);
        NoteMetadata {
            schema_version: NOTE_METADATA_CURRENT_SCHEMA_VERSION,
            created_at: self.created_at,
            modified_at: Utc::now(),
            tags: self.tags.clone(),
            custom_metadata: self.custom_metadata.clone(),
        }
    }

    pub fn from_editable(m: NoteMetadataEditable) -> Self {
        let mut nm = NoteMetadata::default();
        m.apply(&mut nm);
        nm
    }

    pub fn apply_editable(mut self, m: NoteMetadataEditable) -> Self {
        m.apply(&mut self);
        self
    }
}

#[derive(Serialize, Deserialize, Clone)]
pub struct NoteMetadataEditable {
    pub tags: Option<HashSet<String>>,
    pub custom_metadata: Option<serde_json::Value>,
}

impl NoteMetadataEditable {
    pub fn apply(self, n: &mut NoteMetadata) {
        if let Some(t) = self.tags {
            n.tags = t;
        }
        if let Some(c) = self.custom_metadata {
            n.custom_metadata = c;
        }
    }

    pub fn unchanged() -> Self {
        NoteMetadataEditable {
            tags: None,
            custom_metadata: None,
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::notemetadata::NoteMetadataEditable;
    use crate::{InMemoryStore, NoteStore, PlainNote};
    use std::option::Option::None;

    #[tokio::test]
    async fn update_note_tags() {
        let store: InMemoryStore<PlainNote> = InMemoryStore::new();
        let loc1 = store
            .new_note(
                "".to_owned(),
                PlainNote::new("Foo".into()),
                NoteMetadataEditable::unchanged(),
            )
            .await
            .unwrap();
        let rev1 = loc1.get_revision().unwrap();
        let metadata1 = store
            .get_note(&loc1.current())
            .await
            .unwrap()
            .get_metadata();
        let mut tags = metadata1.tags.clone();
        tags.insert("my_tag".to_owned());
        let new_metadata = NoteMetadataEditable {
            tags: Some(tags),
            custom_metadata: None,
        };
        let loc2 = store
            .update_note(&loc1, None, None, new_metadata)
            .await
            .unwrap();
        let rev2 = loc2.get_revision().unwrap();
        assert_ne!(rev1, rev2);
        assert!(!store
            .get_note(&loc1)
            .await
            .unwrap()
            .get_metadata()
            .tags
            .contains("my_tag"));
        assert!(store
            .get_note(&loc1.at_revision(rev2))
            .await
            .unwrap()
            .get_metadata()
            .tags
            .contains("my_tag"));
        assert!(store
            .get_note(&loc1.current())
            .await
            .unwrap()
            .get_metadata()
            .tags
            .contains("my_tag"));
    }
}