murkdown 0.1.1

An experimental semantic markup language and static site generator for composing and decomposing hypertext documents
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

use std::{
    collections::{HashMap, HashSet},
    path::PathBuf,
    sync::{atomic::AtomicBool, Arc, Mutex, OnceLock},
};

use murkdown::compiler::Lang;
use murkdown::types::{AstMap, LocationMap};

#[cfg(test)]
use super::artifact::Artifact;
use super::{
    graph::OpGraph,
    op::{OpId, Operation},
    types::{AppError, AppErrorPathCtx, ArtifactMap, LangMap},
};

/// State container
#[derive(Debug, Clone)]
pub(crate) struct State {
    pub artifacts: Arc<Mutex<ArtifactMap>>,
    pub asts: Arc<Mutex<AstMap>>,
    pub locations: Arc<Mutex<LocationMap>>,
    pub languages: Arc<OnceLock<LangMap>>,
    pub operations: Arc<Mutex<OpGraph>>,
    pub operations_processed: Arc<Mutex<HashSet<OpId>>>,
    pub should_exit: Arc<AtomicBool>,
}

impl State {
    pub fn new() -> Self {
        Self {
            artifacts: Arc::new(Mutex::new(HashMap::new())),
            asts: Arc::new(Mutex::new(HashMap::new())),
            locations: Arc::new(Mutex::new(HashMap::new())),
            languages: Arc::new(OnceLock::new()),
            operations: Arc::new(Mutex::new(OpGraph::new())),
            operations_processed: Arc::new(Mutex::new(HashSet::new())),
            should_exit: Arc::new(AtomicBool::new(false)),
        }
    }

    #[cfg(test)]
    pub fn new_loaded(format: &str) -> Self {
        let ctx = Self::new();
        ctx.load_languages(format).expect("valid format");
        ctx
    }

    #[cfg(test)]
    pub fn insert_op(&self, op: Operation) -> OpId {
        let mut ops = self.operations.lock().expect("poisoned lock");
        ops.insert_node(op)
    }

    #[cfg(test)]
    pub fn insert_artifact(&self, uri: &str, art: Artifact) {
        let mut arts = self.artifacts.lock().expect("poisoned lock");
        arts.insert(uri.to_string(), art);
    }

    #[cfg(test)]
    pub fn insert_location(&self, path: &str, location: impl Into<murkdown::types::Location>) {
        let mut locs = self.locations.lock().expect("poisoned lock");
        locs.insert(path.to_string(), location.into());
    }

    pub fn insert_op_chain<I>(&self, new_ops: I)
    where
        I: IntoIterator<Item = Operation>,
    {
        let mut ops = self.operations.lock().expect("poisoned lock");
        ops.insert_node_chain(new_ops)
    }

    pub fn mark_op_processed(&self, id: OpId) {
        let mut processed = self.operations_processed.lock().expect("poisoned lock");
        processed.insert(id);
    }

    pub fn is_op_processed(&self, id: &OpId) -> bool {
        let processed = self.operations_processed.lock().expect("poisoned lock");
        processed.contains(id)
    }

    pub fn load_languages(&self, format: &str) -> Result<(), AppError> {
        if self.languages.get().is_none() {
            // builtin
            let markdown = include_str!("../lib/compiler/markdown.lang");
            let html = include_str!("../lib/compiler/html.lang");
            let plaintext = include_str!("../lib/compiler/plaintext.lang");

            let mut languages = HashMap::from([
                ("markdown".to_string(), Lang::new(markdown)?),
                ("html".to_string(), Lang::new(html)?),
                ("plaintext".to_string(), Lang::new(plaintext)?),
            ]);

            // custom
            if !languages.contains_key(format) {
                let path = PathBuf::from(format).with_extension("lang");
                let custom = std::fs::read_to_string(&path).with_ctx(path)?;
                languages.insert(format.to_string(), Lang::new(&custom)?);
            }

            self.languages.set(languages).expect("languages are loaded");
        }
        Ok(())
    }

    /// Clear state
    pub fn clear(&self) {
        self.asts.lock().expect("poisoned lock").clear();
        self.operations.lock().expect("poisoned lock").clear();
        self.operations_processed
            .lock()
            .expect("poisoned lock")
            .clear();
        self.locations.lock().expect("poisoned lock").clear();
        self.artifacts.lock().expect("poisoned lock").clear();
    }
}