FIX: Don not clone Locales and Languages, pass them by reference

bindings/nodejs/src/model.rs

@@ -28,17 +28,24 @@ fn to_node_error(error: XlsxError) -> Error {
   Error::new(Status::Unknown, error.to_string())
 }
 
+fn leak_str(s: &str) -> &'static str {
+  Box::leak(s.to_owned().into_boxed_str())
+}
+
 #[napi]
 pub struct Model {
-  model: BaseModel,
+  model: BaseModel<'static>,
 }
 
 #[napi]
 impl Model {
   #[napi(constructor)]
   pub fn new(name: String, locale: String, timezone: String, language_id: String) -> Result<Self> {
-    let model =
-      BaseModel::new_empty(&name, &locale, &timezone, &language_id).map_err(to_js_error)?;
+    let name = leak_str(&name);
+    let locale = leak_str(&locale);
+    let timezone = leak_str(&timezone);
+    let language_id = leak_str(&language_id);
+    let model = BaseModel::new_empty(name, locale, timezone, language_id).map_err(to_js_error)?;
     Ok(Self { model })
   }
 
@@ -49,14 +56,16 @@ impl Model {
     tz: String,
     language_id: String,
   ) -> Result<Model> {
-    let model = load_from_xlsx(&file_path, &locale, &tz, &language_id)
+    let language_id = leak_str(&language_id);
+    let model = load_from_xlsx(&file_path, &locale, &tz, language_id)
       .map_err(|error| Error::new(Status::Unknown, error.to_string()))?;
     Ok(Self { model })
   }
 
   #[napi(factory)]
   pub fn from_icalc(file_name: String, language_id: String) -> Result<Model> {
-    let model = load_from_icalc(&file_name, &language_id)
+    let language_id = leak_str(&language_id);
+    let model = load_from_icalc(&file_name, language_id)
       .map_err(|error| Error::new(Status::Unknown, error.to_string()))?;
     Ok(Self { model })
   }

bindings/nodejs/src/user_model.rs

@@ -21,23 +21,31 @@ fn to_js_error(error: String) -> Error {
   Error::new(Status::Unknown, error)
 }
 
+fn leak_str(s: &str) -> &'static str {
+  Box::leak(s.to_owned().into_boxed_str())
+}
+
 #[napi]
 pub struct UserModel {
-  model: BaseModel,
+  model: BaseModel<'static>,
 }
 
 #[napi]
 impl UserModel {
   #[napi(constructor)]
   pub fn new(name: String, locale: String, timezone: String, language_id: String) -> Result<Self> {
-    let model =
-      BaseModel::new_empty(&name, &locale, &timezone, &language_id).map_err(to_js_error)?;
+    let name = leak_str(&name);
+    let locale = leak_str(&locale);
+    let timezone = leak_str(&timezone);
+    let language_id = leak_str(&language_id);
+    let model = BaseModel::new_empty(name, locale, timezone, language_id).map_err(to_js_error)?;
     Ok(Self { model })
   }
 
   #[napi(factory)]
   pub fn from_bytes(bytes: &[u8], language_id: String) -> Result<UserModel> {
-    let model = BaseModel::from_bytes(bytes, &language_id).map_err(to_js_error)?;
+    let language_id = leak_str(&language_id);
+    let model = BaseModel::from_bytes(bytes, language_id).map_err(to_js_error)?;
     Ok(UserModel { model })
   }
 

bindings/python/src/lib.rs

@@ -12,10 +12,14 @@ mod types;
 
 create_exception!(_ironcalc, WorkbookError, PyException);
 
+fn leak_str(s: &str) -> &'static str {
+    Box::leak(s.to_owned().into_boxed_str())
+}
+
 #[pyclass]
 pub struct PyUserModel {
     /// The user model, which is a wrapper around the Model
-    pub model: UserModel,
+    pub model: UserModel<'static>,
 }
 
 #[pymethods]
@@ -87,7 +91,7 @@ impl PyUserModel {
 /// This is a model implementing the 'raw' API
 #[pyclass]
 pub struct PyModel {
-    model: Model,
+    model: Model<'static>,
 }
 
 #[pymethods]
@@ -335,6 +339,10 @@ pub fn load_from_xlsx(
     tz: &str,
     language_id: &str,
 ) -> PyResult<PyModel> {
+    // let locale = leak_str(locale);
+    // let tz = leak_str(tz);
+    let language_id = leak_str(language_id);
+
     let model = import::load_from_xlsx(file_path, locale, tz, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     Ok(PyModel { model })
@@ -343,6 +351,7 @@ pub fn load_from_xlsx(
 /// Loads a function from icalc binary representation
 #[pyfunction]
 pub fn load_from_icalc(file_name: &str, language_id: &str) -> PyResult<PyModel> {
+    let language_id = leak_str(language_id);
     let model = import::load_from_icalc(file_name, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     Ok(PyModel { model })
@@ -355,6 +364,7 @@ pub fn load_from_icalc(file_name: &str, language_id: &str) -> PyResult<PyModel>
 pub fn load_from_bytes(bytes: &[u8], language_id: &str) -> PyResult<PyModel> {
     let workbook: Workbook =
         bitcode::decode(bytes).map_err(|e| WorkbookError::new_err(e.to_string()))?;
+    let language_id = leak_str(language_id);
     let model = Model::from_workbook(workbook, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     Ok(PyModel { model })
@@ -363,6 +373,10 @@ pub fn load_from_bytes(bytes: &[u8], language_id: &str) -> PyResult<PyModel> {
 /// Creates an empty model in the raw API
 #[pyfunction]
 pub fn create(name: &str, locale: &str, tz: &str, language_id: &str) -> PyResult<PyModel> {
+    let name = leak_str(name);
+    let locale = leak_str(locale);
+    let tz = leak_str(tz);
+    let language_id = leak_str(language_id);
     let model = Model::new_empty(name, locale, tz, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     Ok(PyModel { model })
@@ -376,6 +390,10 @@ pub fn create_user_model(
     tz: &str,
     language_id: &str,
 ) -> PyResult<PyUserModel> {
+    let name = leak_str(name);
+    let locale = leak_str(locale);
+    let tz = leak_str(tz);
+    let language_id = leak_str(language_id);
     let model = UserModel::new_empty(name, locale, tz, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     Ok(PyUserModel { model })
@@ -389,6 +407,7 @@ pub fn create_user_model_from_xlsx(
     tz: &str,
     language_id: &str,
 ) -> PyResult<PyUserModel> {
+    let language_id = leak_str(language_id);
     let model = import::load_from_xlsx(file_path, locale, tz, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     let model = UserModel::from_model(model);
@@ -398,6 +417,7 @@ pub fn create_user_model_from_xlsx(
 /// Creates a user model from an icalc file
 #[pyfunction]
 pub fn create_user_model_from_icalc(file_name: &str, language_id: &str) -> PyResult<PyUserModel> {
+    let language_id = leak_str(language_id);
     let model = import::load_from_icalc(file_name, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     let model = UserModel::from_model(model);
@@ -411,6 +431,7 @@ pub fn create_user_model_from_icalc(file_name: &str, language_id: &str) -> PyRes
 pub fn create_user_model_from_bytes(bytes: &[u8], language_id: &str) -> PyResult<PyUserModel> {
     let workbook: Workbook =
         bitcode::decode(bytes).map_err(|e| WorkbookError::new_err(e.to_string()))?;
+    let language_id = leak_str(language_id);
     let model = Model::from_workbook(workbook, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     let user_model = UserModel::from_model(model);

bindings/wasm/src/lib.rs

@@ -59,9 +59,13 @@ struct DefinedName {
     formula: String,
 }
 
+fn leak_str(s: &str) -> &'static str {
+    Box::leak(s.to_owned().into_boxed_str())
+}
+
 #[wasm_bindgen]
 pub struct Model {
-    model: BaseModel,
+    model: BaseModel<'static>,
 }
 
 #[wasm_bindgen]
@@ -73,12 +77,17 @@ impl Model {
         timezone: &str,
         language_id: &str,
     ) -> Result<Model, JsError> {
+        let name = leak_str(name);
+        let locale = leak_str(locale);
+        let timezone = leak_str(timezone);
+        let language_id = leak_str(language_id);
         let model =
             BaseModel::new_empty(name, locale, timezone, language_id).map_err(to_js_error)?;
         Ok(Model { model })
     }
 
     pub fn from_bytes(bytes: &[u8], language_id: &str) -> Result<Model, JsError> {
+        let language_id = leak_str(language_id);
         let model = BaseModel::from_bytes(bytes, language_id).map_err(to_js_error)?;
         Ok(Model { model })
     }