moon_pdk 0.1.0

A plugin development kit for creating moon WASM plugins.
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

#[macro_export]
macro_rules! shared_config {
    ($container:ident, $model:ident) => {
        #[derive(Default)]
        pub struct $container {
            pub data: $model,
            pub dirty: Vec<String>,
            pub path: moon_pdk::VirtualPath,
        }

        impl std::ops::Deref for $container {
            type Target = $model;

            fn deref(&self) -> &Self::Target {
                &self.data
            }
        }

        impl std::ops::DerefMut for $container {
            fn deref_mut(&mut self) -> &mut Self::Target {
                &mut self.data
            }
        }

        impl $container {
            pub fn new(path: moon_pdk::VirtualPath) -> Self {
                Self {
                    data: Default::default(),
                    dirty: vec![],
                    path,
                }
            }

            pub fn is_dirty(&self) -> bool {
                !self.dirty.is_empty()
            }
        }
    };
}

#[macro_export]
macro_rules! json_config {
    ($container:ident, $model:ident) => {
        moon_pdk::shared_config!($container, $model);

        impl $container {
            pub fn load(path: moon_pdk::VirtualPath) -> AnyResult<Self> {
                Ok(Self {
                    data: starbase_utils::json::read_file(path.any_path())?,
                    dirty: vec![],
                    path,
                })
            }

            pub fn save(self) -> AnyResult<Option<moon_pdk::VirtualPath>> {
                if self.dirty.is_empty() {
                    return Ok(None);
                }

                use starbase_utils::json;

                let mut data: json::JsonValue = json::read_file(self.path.any_path())?;

                for field in &self.dirty {
                    match self.save_field(field, data.get(field))? {
                        Some(value) => {
                            data[field] = value;
                        }
                        None => {
                            if let Some(root) = data.as_object_mut() {
                                root.remove(field);
                            }
                        }
                    };
                }

                #[cfg(feature = "wasm")]
                {
                    host_log!(
                        "Saving <path>{}</path> with changed fields {}",
                        self.path.display(),
                        self.dirty
                            .into_iter()
                            .map(|dirty| format!("<property>{dirty}</property>"))
                            .collect::<Vec<_>>()
                            .join(", ")
                    );
                }

                json::write_file_with_config(self.path.any_path(), &data, true)?;

                Ok(Some(self.path))
            }

            pub fn save_model(self) -> AnyResult<moon_pdk::VirtualPath> {
                use starbase_utils::json;

                #[cfg(feature = "wasm")]
                {
                    host_log!("Saving <path>{}</path>", self.path.display());
                }

                json::write_file_with_config(self.path.any_path(), &self.data, true)?;

                Ok(self.path)
            }
        }
    };
}