dprint 0.9.1

Binary for dprint.
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

use std::path::PathBuf;
use std::sync::Mutex;
use std::sync::Arc;
use std::collections::HashMap;
use dprint_core::configuration::ConfigKeyMap;

use crate::plugins::pool::PluginPools;
use crate::environment::Environment;
use super::super::format_with_plugin_pool;

/// Use this when the plugins don't need to format via a plugin pool.
pub fn create_identity_import_object() -> wasmer_runtime::ImportObject {
    let host_clear_bytes = |_: u32| {};
    let host_read_buffer = |_: u32, _: u32| {};
    let host_write_buffer = |_: u32, _: u32, _: u32| {};
    let host_take_override_config = || {};
    let host_take_file_path = || {};
    let host_format = || -> u32 { 0 }; // no change
    let host_get_formatted_text = || -> u32 { 0 }; // zero length
    let host_get_error_text = || -> u32 { 0 }; // zero length

    wasmer_runtime::imports! {
        "dprint" => {
            "host_clear_bytes" => wasmer_runtime::func!(host_clear_bytes),
            "host_read_buffer" => wasmer_runtime::func!(host_read_buffer),
            "host_write_buffer" => wasmer_runtime::func!(host_write_buffer),
            "host_take_override_config" => wasmer_runtime::func!(host_take_override_config),
            "host_take_file_path" => wasmer_runtime::func!(host_take_file_path),
            "host_format" => wasmer_runtime::func!(host_format),
            "host_get_formatted_text" => wasmer_runtime::func!(host_get_formatted_text),
            "host_get_error_text" => wasmer_runtime::func!(host_get_error_text),
        }
    }
}

/// Create an import object that formats text using plugins from the plugin pool
pub fn create_pools_import_object<TEnvironment: Environment>(
    pools: Arc<PluginPools<TEnvironment>>,
    plugin_name: &str,
) -> wasmer_runtime::ImportObject {
    let parent_plugin_name = String::from(plugin_name);
    let override_config: Arc<Mutex<Option<ConfigKeyMap>>> = Arc::new(Mutex::new(None));
    let file_path: Arc<Mutex<Option<PathBuf>>> = Arc::new(Mutex::new(None));
    let shared_bytes: Arc<Mutex<Vec<u8>>> = Arc::new(Mutex::new(Vec::with_capacity(0)));
    let formatted_text_store: Arc<Mutex<String>> = Arc::new(Mutex::new(String::new()));
    let error_text_store: Arc<Mutex<String>> = Arc::new(Mutex::new(String::new()));

    let host_clear_bytes = {
        let shared_bytes = shared_bytes.clone();
        move |length: u32| {
            let mut shared_bytes = shared_bytes.lock().unwrap();
            *shared_bytes = Vec::with_capacity(length as usize);
        }
    };
    let host_read_buffer = {
        let shared_bytes = shared_bytes.clone();
        move |ctx: &mut wasmer_runtime::Ctx, buffer_pointer: u32, length: u32| {
            let buffer_pointer: wasmer_runtime::WasmPtr<u8, wasmer_runtime::Array> = wasmer_runtime::WasmPtr::new(buffer_pointer);
            let memory_reader = buffer_pointer
                .deref(ctx.memory(0), 0, length)
                .unwrap();
            let mut shared_bytes = shared_bytes.lock().unwrap();
            for i in 0..length as usize {
                shared_bytes.push(memory_reader[i].get());
            }
        }
    };
    let host_write_buffer = {
        let shared_bytes = shared_bytes.clone();
        move |ctx: &mut wasmer_runtime::Ctx, buffer_pointer: u32, offset: u32, length: u32| {
            let buffer_pointer: wasmer_runtime::WasmPtr<u8, wasmer_runtime::Array> = wasmer_runtime::WasmPtr::new(buffer_pointer);
            let memory_writer = buffer_pointer
                .deref(ctx.memory(0), 0, length)
                .unwrap();
            let offset = offset as usize;
            let length = length as usize;
            let shared_bytes = shared_bytes.lock().unwrap();
            let byte_slice = &shared_bytes[offset..offset + length];
            for i in 0..length as usize {
                memory_writer[i].set(byte_slice[i]);
            }
        }
    };
    let host_take_override_config = {
        let override_config = override_config.clone();
        let shared_bytes = shared_bytes.clone();
        move || {
            let bytes = {
                let mut shared_bytes = shared_bytes.lock().unwrap();
                std::mem::replace(&mut *shared_bytes, Vec::with_capacity(0))
            };
            let config_key_map: ConfigKeyMap = serde_json::from_slice(&bytes).unwrap_or(HashMap::new());
            let mut override_config = override_config.lock().unwrap();
            override_config.replace(config_key_map);
        }
    };
    let host_take_file_path = {
        let file_path = file_path.clone();
        let shared_bytes = shared_bytes.clone();
        move || {
            let bytes = {
                let mut shared_bytes = shared_bytes.lock().unwrap();
                std::mem::replace(&mut *shared_bytes, Vec::with_capacity(0))
            };
            let file_path_str = String::from_utf8(bytes).unwrap();
            let mut file_path = file_path.lock().unwrap();
            file_path.replace(PathBuf::from(file_path_str));
        }
    };
    let host_format = {
        let override_config = override_config.clone();
        let file_path = file_path.clone();
        let shared_bytes = shared_bytes.clone();
        let formatted_text_store = formatted_text_store.clone();
        let error_text_store = error_text_store.clone();
        move || {
            let override_config = override_config.lock().unwrap().take().unwrap_or(HashMap::new());
            let file_path = file_path.lock().unwrap().take().expect("Expected to have file path.");
            let bytes = {
                let mut shared_bytes = shared_bytes.lock().unwrap();
                std::mem::replace(&mut *shared_bytes, Vec::with_capacity(0))
            };
            let file_text = String::from_utf8(bytes).unwrap();

            match format_with_plugin_pool(&parent_plugin_name, &file_path, &file_text, &override_config, &pools) {
                Ok(Some(formatted_text)) => {
                    let mut formatted_text_store = formatted_text_store.lock().unwrap();
                    *formatted_text_store = formatted_text;
                    1 // change
                },
                Ok(None) => {
                    0 // no change
                }
                Err(err) => {
                    let mut error_text_store = error_text_store.lock().unwrap();
                    *error_text_store = err.to_string();
                    2 // error
                }
            }
        }
    };
    let host_get_formatted_text = {
        let shared_bytes = shared_bytes.clone();
        let formatted_text_store = formatted_text_store.clone();
        move || {
            let formatted_text = {
                let mut formatted_text_store = formatted_text_store.lock().unwrap();
                std::mem::replace(&mut *formatted_text_store, String::new())
            };
            let len = formatted_text.len();
            let mut shared_bytes = shared_bytes.lock().unwrap();
            *shared_bytes = formatted_text.into_bytes();
            len as u32
        }
    };
    let host_get_error_text = {
        // todo: reduce code duplication with above function
        let shared_bytes = shared_bytes.clone();
        let error_text_store = error_text_store.clone();
        move || {
            let error_text = {
                let mut error_text_store = error_text_store.lock().unwrap();
                std::mem::replace(&mut *error_text_store, String::new())
            };
            let len = error_text.len();
            let mut shared_bytes = shared_bytes.lock().unwrap();
            *shared_bytes = error_text.into_bytes();
            len as u32
        }
    };

    wasmer_runtime::imports! {
        "dprint" => {
            "host_clear_bytes" => wasmer_runtime::func!(host_clear_bytes),
            "host_read_buffer" => wasmer_runtime::func!(host_read_buffer),
            "host_write_buffer" => wasmer_runtime::func!(host_write_buffer),
            "host_take_override_config" => wasmer_runtime::func!(host_take_override_config),
            "host_take_file_path" => wasmer_runtime::func!(host_take_file_path),
            "host_format" => wasmer_runtime::func!(host_format),
            "host_get_formatted_text" => wasmer_runtime::func!(host_get_formatted_text),
            "host_get_error_text" => wasmer_runtime::func!(host_get_error_text),
        }
    }
}