dprint 0.13.1

Binary for dprint code formatter—a pluggable and configurable code formatting platform.
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
185
186
187
188
189
190
191
192
193

use std::path::PathBuf;
use std::sync::Arc;
use std::collections::HashMap;
use dprint_core::configuration::ConfigKeyMap;
use wasmer::{Function, Store, LazyInit, Instance, Memory, WasmerEnv, HostEnvInitError};
use parking_lot::Mutex;

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(store: &Store) -> wasmer::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::imports! {
        "dprint" => {
            "host_clear_bytes" => Function::new_native(&store, host_clear_bytes),
            "host_read_buffer" => Function::new_native(&store, host_read_buffer),
            "host_write_buffer" => Function::new_native(&store, host_write_buffer),
            "host_take_override_config" => Function::new_native(&store, host_take_override_config),
            "host_take_file_path" => Function::new_native(&store, host_take_file_path),
            "host_format" => Function::new_native(&store, host_format),
            "host_get_formatted_text" => Function::new_native(&store, host_get_formatted_text),
            "host_get_error_text" => Function::new_native(&store, host_get_error_text),
        }
    }
}

pub struct ImportObjectEnvironmentCellItems {
    override_config: Option<ConfigKeyMap>,
    file_path: Option<PathBuf>,
    shared_bytes: Vec<u8>,
    formatted_text_store: String,
    error_text_store: String,
}

#[derive(Clone)]
pub struct ImportObjectEnvironment<TEnvironment: Environment> {
    parent_plugin_name: String,
    memory: LazyInit<Memory>,
    pools: Arc<PluginPools<TEnvironment>>,
    cell: Arc<Mutex<ImportObjectEnvironmentCellItems>>,
}

impl<TEnvironment: Environment> WasmerEnv for ImportObjectEnvironment<TEnvironment> {
    fn init_with_instance(&mut self, instance: &Instance) -> Result<(), HostEnvInitError> {
        let memory = instance.exports.get_memory("memory").unwrap();
        self.memory.initialize(memory.clone());
        Ok(())
    }
}

impl<TEnvironment: Environment> ImportObjectEnvironment<TEnvironment> {
    pub fn new(plugin_name: &str, pools: Arc<PluginPools<TEnvironment>>) -> Self {
        ImportObjectEnvironment {
            parent_plugin_name: plugin_name.to_string(),
            pools,
            memory: LazyInit::new(),
            cell: Arc::new(Mutex::new(ImportObjectEnvironmentCellItems {
                override_config: None,
                file_path: None,
                shared_bytes: Vec::new(),
                formatted_text_store: String::new(),
                error_text_store: String::new(),
            }))
        }
    }
}

/// Create an import object that formats text using plugins from the plugin pool
pub fn create_pools_import_object<TEnvironment: Environment>(
    store: &Store,
    import_object_env: &ImportObjectEnvironment<TEnvironment>,
) -> wasmer::ImportObject {
    let host_clear_bytes = {
        |env: &ImportObjectEnvironment<TEnvironment>, length: u32| {
            env.cell.lock().shared_bytes = Vec::with_capacity(length as usize);
        }
    };
    let host_read_buffer = {
        |env: &ImportObjectEnvironment<TEnvironment>, buffer_pointer: u32, length: u32| {
            let buffer_pointer: wasmer::WasmPtr<u8, wasmer::Array> = wasmer::WasmPtr::new(buffer_pointer);
            let mut cell = env.cell.lock();
            let memory = env.memory.get_ref().unwrap();
            let memory_reader = buffer_pointer
                .deref(memory, 0, length)
                .unwrap();
            for i in 0..length as usize {
                cell.shared_bytes.push(memory_reader[i].get());
            }
        }
    };
    let host_write_buffer = {
        |env: &ImportObjectEnvironment<TEnvironment>, buffer_pointer: u32, offset: u32, length: u32| {
            let buffer_pointer: wasmer::WasmPtr<u8, wasmer::Array> = wasmer::WasmPtr::new(buffer_pointer);
            let cell = env.cell.lock();
            let memory = env.memory.get_ref().unwrap();
            let memory_writer = buffer_pointer
                .deref(memory, 0, length)
                .unwrap();
            let offset = offset as usize;
            let length = length as usize;
            let byte_slice = &cell.shared_bytes[offset..offset + length];
            for i in 0..length as usize {
                memory_writer[i].set(byte_slice[i]);
            }
        }
    };
    let host_take_override_config = {
        |env: &ImportObjectEnvironment<TEnvironment>| {
            let mut cell = env.cell.lock();
            let bytes = std::mem::replace(&mut cell.shared_bytes, Vec::new());
            let config_key_map: ConfigKeyMap = serde_json::from_slice(&bytes).unwrap_or(HashMap::new());
            cell.override_config.replace(config_key_map);
        }
    };
    let host_take_file_path = {
        |env: &ImportObjectEnvironment<TEnvironment>| {
            let mut cell = env.cell.lock();
            let bytes = std::mem::replace(&mut cell.shared_bytes, Vec::new());
            let file_path_str = String::from_utf8(bytes).unwrap();
            cell.file_path.replace(PathBuf::from(file_path_str));
        }
    };
    let host_format = {
        |env: &ImportObjectEnvironment<TEnvironment>| {
            let (override_config, file_path, file_text) = {
                let mut cell = env.cell.lock();
                let override_config = cell.override_config.take().unwrap_or(HashMap::new());
                let file_path = cell.file_path.take().expect("Expected to have file path.");
                let bytes = std::mem::replace(&mut cell.shared_bytes, Vec::new());
                let file_text = String::from_utf8(bytes).unwrap();
                (override_config, file_path, file_text)
            };

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

    wasmer::imports! {
        "dprint" => {
            "host_clear_bytes" => Function::new_native_with_env(&store, import_object_env.clone(), host_clear_bytes),
            "host_read_buffer" => Function::new_native_with_env(&store, import_object_env.clone(), host_read_buffer),
            "host_write_buffer" => Function::new_native_with_env(&store, import_object_env.clone(), host_write_buffer),
            "host_take_override_config" => Function::new_native_with_env(&store, import_object_env.clone(), host_take_override_config),
            "host_take_file_path" => Function::new_native_with_env(&store, import_object_env.clone(), host_take_file_path),
            "host_format" => Function::new_native_with_env(&store, import_object_env.clone(), host_format),
            "host_get_formatted_text" => Function::new_native_with_env(&store, import_object_env.clone(), host_get_formatted_text),
            "host_get_error_text" => Function::new_native_with_env(&store, import_object_env.clone(), host_get_error_text),
        }
    }
}