turtle-build 0.5.4

Ninja-compatible build system for high-level programming languages
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

use crate::{
    hash_type::HashType,
    infrastructure::{Database, DatabaseError},
    ir::BuildId,
};
use alloc::{collections::BTreeSet, sync::Arc};
use async_trait::async_trait;
use std::{collections::HashMap, sync::Mutex};

#[derive(Clone, Debug, Default)]
pub struct FakeDatabase {
    timestamp_hashes: Arc<Mutex<HashMap<BuildId, u64>>>,
    content_hashes: Arc<Mutex<HashMap<BuildId, u64>>>,
    header_dependencies: Arc<Mutex<HashMap<BuildId, Vec<String>>>>,
    header_dependency_requests: Arc<Mutex<Vec<BuildId>>>,
    outputs: Arc<Mutex<BTreeSet<String>>>,
    sources: Arc<Mutex<HashMap<String, String>>>,
}

impl FakeDatabase {
    pub fn header_dependency_requests(&self) -> Vec<BuildId> {
        self.header_dependency_requests.lock().unwrap().clone()
    }

    fn hashes(&self, r#type: HashType) -> &Mutex<HashMap<BuildId, u64>> {
        match r#type {
            HashType::Content => &self.content_hashes,
            HashType::Timestamp => &self.timestamp_hashes,
        }
    }
}

#[async_trait]
impl Database for FakeDatabase {
    fn get_hash(&self, r#type: HashType, id: BuildId) -> Result<Option<u64>, DatabaseError> {
        Ok(self.hashes(r#type).lock().unwrap().get(&id).copied())
    }

    fn set_hash(&self, r#type: HashType, id: BuildId, hash: u64) -> Result<(), DatabaseError> {
        self.hashes(r#type).lock().unwrap().insert(id, hash);

        Ok(())
    }

    fn get_header_dependencies(&self, id: BuildId) -> Result<Vec<String>, DatabaseError> {
        self.header_dependency_requests.lock().unwrap().push(id);

        Ok(self
            .header_dependencies
            .lock()
            .unwrap()
            .get(&id)
            .cloned()
            .unwrap_or_default())
    }

    fn set_header_dependencies(
        &self,
        id: BuildId,
        dependencies: &[String],
    ) -> Result<(), DatabaseError> {
        self.header_dependencies
            .lock()
            .unwrap()
            .insert(id, dependencies.to_vec());

        Ok(())
    }

    fn get_outputs(&self) -> Result<Vec<String>, DatabaseError> {
        Ok(self.outputs.lock().unwrap().iter().cloned().collect())
    }

    fn set_output(&self, path: &str) -> Result<(), DatabaseError> {
        self.outputs.lock().unwrap().insert(path.into());

        Ok(())
    }

    fn get_source(&self, output: &str) -> Result<Option<String>, DatabaseError> {
        Ok(self.sources.lock().unwrap().get(output).cloned())
    }

    fn set_source(&self, output: &str, source: &str) -> Result<(), DatabaseError> {
        self.sources
            .lock()
            .unwrap()
            .insert(output.into(), source.into());

        Ok(())
    }

    async fn flush(&self) -> Result<(), DatabaseError> {
        Ok(())
    }
}