ragit 0.4.5

git-like rag pipeline
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

use super::Index;
use crate::constant::METADATA_FILE_NAME;
use crate::error::Error;
use ragit_fs::{
    WriteMode,
    exists,
    read_string,
    remove_file,
    write_bytes,
};
use ragit_pdl::JsonType;
use serde_json::Value;
use std::collections::HashMap;

pub type Path = String;

impl Index {
    pub fn get_meta_by_key(&self, key: String) -> Result<Option<String>, Error> {
        let meta_path = get_meta_path(&self.root_dir)?;

        if !exists(&meta_path) {
            return Ok(None);
        }

        let meta = load_meta(&meta_path)?;
        Ok(meta.get(&key).map(|v| v.to_string()))
    }

    pub fn get_all_meta(&self) -> Result<HashMap<String, String>, Error> {
        let meta_path = get_meta_path(&self.root_dir)?;

        if !exists(&meta_path) {
            return Ok(HashMap::new());
        }

        let meta = load_meta(&meta_path)?;
        Ok(meta)
    }

    pub fn set_meta_by_key(&mut self, key: String, value: String) -> Result<(), Error> {
        let meta_path = get_meta_path(&self.root_dir)?;

        if !exists(&meta_path) {
            save_meta(&meta_path, HashMap::new())?;
        }

        let mut meta = load_meta(&meta_path)?;
        meta.insert(key, value);
        self.reset_uid(true /* save_to_file */)?;
        save_meta(&meta_path, meta)
    }

    pub fn remove_meta_by_key(&mut self, key: String) -> Result<String, Error> {
        let meta_path = get_meta_path(&self.root_dir)?;

        if !exists(&meta_path) {
            return Err(Error::NoSuchMeta(key));
        }

        let mut meta = load_meta(&meta_path)?;

        match meta.remove(&key) {
            Some(v) => {
                let v = v.to_string();
                self.reset_uid(true /* save_to_file */)?;
                save_meta(&meta_path, meta)?;
                Ok(v)
            },
            None => Err(Error::NoSuchMeta(key)),
        }
    }

    pub fn remove_all_meta(&mut self) -> Result<(), Error> {
        let meta_path = get_meta_path(&self.root_dir)?;

        if exists(&meta_path) {
            remove_file(&meta_path)?;
        }

        self.reset_uid(true /* save_to_file */)?;
        Ok(())
    }
}

fn get_meta_path(root_dir: &Path) -> Result<Path, Error> {
    Index::get_rag_path(
        root_dir,
        &METADATA_FILE_NAME.to_string(),
    )
}

fn load_meta(path: &Path) -> Result<HashMap<String, String>, Error> {
    let content = read_string(path)?;
    let j = serde_json::from_str::<Value>(&content)?;
    let Value::Object(obj) = j else { return Err(Error::JsonTypeError {
        expected: JsonType::Object,
        got: (&j).into(),
    }) };
    let mut result = HashMap::with_capacity(obj.len());

    for (key, value) in obj.iter() {
        match value.as_str() {
            Some(value) => {
                result.insert(key.to_string(), value.to_string());
            },
            None => {
                return Err(Error::JsonTypeError {
                    expected: JsonType::Object,
                    got: value.into(),
                });
            },
        }
    }

    Ok(result)
}

fn save_meta(path: &Path, meta: HashMap<String, String>) -> Result<(), Error> {
    Ok(write_bytes(
        path,
        &serde_json::to_vec_pretty(&meta.into_iter().map(
            |(key, value)| (key, Value::String(value))
        ).collect::<Value>())?,
        WriteMode::CreateOrTruncate,
    )?)
}