From 96a5482e01b13e4e940cf4e1e7c3b7a8a081cf45 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nicol=C3=A1s=20Hatcher?= Date: Sun, 14 Dec 2025 16:55:14 +0100 Subject: [PATCH] FIX: Don not clone Locales and Languages, pass them by reference --- base/src/actions.rs | 10 +-- base/src/arithmetic.rs | 2 +- base/src/cast.rs | 2 +- base/src/expressions/lexer/mod.rs | 27 ++++--- base/src/expressions/lexer/ranges.rs | 2 +- .../lexer/structured_references.rs | 2 +- .../src/expressions/lexer/test/test_common.rs | 6 +- .../lexer/test/test_implicit_intersection.rs | 2 +- .../expressions/lexer/test/test_language.rs | 6 +- .../src/expressions/lexer/test/test_locale.rs | 2 +- .../src/expressions/lexer/test/test_ranges.rs | 2 +- .../src/expressions/lexer/test/test_tables.rs | 2 +- base/src/expressions/parser/mod.rs | 40 +++++----- .../parser/tests/test_languages.rs | 6 +- .../parser/tests/test_move_formula.rs | 10 +-- base/src/expressions/parser/tests/utils.rs | 20 ++--- base/src/functions/binary_search.rs | 2 +- base/src/functions/database.rs | 2 +- base/src/functions/date_and_time.rs | 2 +- base/src/functions/engineering/bessel.rs | 2 +- .../functions/engineering/bit_operations.rs | 2 +- base/src/functions/engineering/complex.rs | 2 +- base/src/functions/engineering/convert.rs | 2 +- base/src/functions/engineering/misc.rs | 2 +- .../src/functions/engineering/number_basis.rs | 2 +- base/src/functions/financial.rs | 2 +- base/src/functions/information.rs | 2 +- base/src/functions/logical.rs | 2 +- base/src/functions/lookup_and_reference.rs | 4 +- base/src/functions/mathematical.rs | 2 +- base/src/functions/mathematical_sum.rs | 2 +- base/src/functions/mod.rs | 9 +-- base/src/functions/statistical/beta.rs | 2 +- base/src/functions/statistical/binom.rs | 2 +- base/src/functions/statistical/chisq.rs | 2 +- base/src/functions/statistical/correl.rs | 2 +- .../statistical/count_and_average.rs | 2 +- base/src/functions/statistical/covariance.rs | 2 +- base/src/functions/statistical/devsq.rs | 2 +- base/src/functions/statistical/exponential.rs | 2 +- base/src/functions/statistical/fisher.rs | 2 +- base/src/functions/statistical/gamma.rs | 2 +- base/src/functions/statistical/gauss.rs | 2 +- base/src/functions/statistical/geomean.rs | 2 +- base/src/functions/statistical/hypegeom.rs | 2 +- base/src/functions/statistical/if_ifs.rs | 2 +- base/src/functions/statistical/log_normal.rs | 2 +- base/src/functions/statistical/normal.rs | 2 +- base/src/functions/statistical/pearson.rs | 2 +- base/src/functions/statistical/phi.rs | 2 +- base/src/functions/statistical/poisson.rs | 2 +- base/src/functions/statistical/rank_eq_avg.rs | 2 +- .../src/functions/statistical/standard_dev.rs | 2 +- base/src/functions/statistical/standardize.rs | 2 +- base/src/functions/statistical/t_dist.rs | 2 +- base/src/functions/statistical/variance.rs | 2 +- base/src/functions/statistical/weibull.rs | 2 +- base/src/functions/statistical/z_test.rs | 2 +- base/src/functions/subtotal.rs | 2 +- base/src/functions/text.rs | 4 +- base/src/functions/xlookup.rs | 2 +- base/src/language/mod.rs | 18 ++--- base/src/locale/mod.rs | 28 +++---- base/src/model.rs | 80 +++++++++---------- base/src/new_empty.rs | 43 +++++----- base/src/styles.rs | 2 +- base/src/test/test_fn_time.rs | 2 +- base/src/test/test_language.rs | 2 +- base/src/test/test_locale.rs | 2 +- .../src/test/user_model/test_to_from_bytes.rs | 16 +++- base/src/test/user_model/util.rs | 4 +- base/src/test/util.rs | 4 +- base/src/units.rs | 2 +- base/src/user_model/border.rs | 2 +- base/src/user_model/common.rs | 22 ++--- base/src/user_model/ui.rs | 2 +- bindings/nodejs/src/model.rs | 19 +++-- bindings/nodejs/src/user_model.rs | 16 +++- bindings/python/src/lib.rs | 25 +++++- bindings/wasm/src/lib.rs | 11 ++- .../components/SheetTabBar/SheetTabBar.tsx | 4 +- .../frontend/src/components/storage.ts | 3 +- xlsx/src/export/test/test_export.rs | 2 +- xlsx/src/import/mod.rs | 8 +- 84 files changed, 308 insertions(+), 251 deletions(-) diff --git a/base/src/actions.rs b/base/src/actions.rs index 7a9d356..c9bd5c8 100644 --- a/base/src/actions.rs +++ b/base/src/actions.rs @@ -10,7 +10,7 @@ use crate::model::Model; // In IronCalc, if one of the edges of the range is deleted will replace the edge with #REF! // I feel this is unimportant for now. -impl Model { +impl<'a> Model<'a> { fn shift_cell_formula( &mut self, sheet: u32, @@ -31,7 +31,7 @@ impl Model { column, }; // FIXME: This is not a very performant way if the formula has changed :S. - let formula = to_localized_string(node, &cell_reference, &self.locale, &self.language); + let formula = to_localized_string(node, &cell_reference, self.locale, self.language); let formula_displaced = to_string_displaced(node, &cell_reference, displace_data); if formula != formula_displaced { self.update_cell_with_formula(sheet, row, column, format!("={formula_displaced}"))?; @@ -111,7 +111,7 @@ impl Model { let formula_or_value = self .get_cell_formula(sheet, source_row, source_column)? .unwrap_or_else(|| { - source_cell.get_localized_text(&self.workbook.shared_strings, &self.language) + source_cell.get_localized_text(&self.workbook.shared_strings, self.language) }); self.set_user_input(sheet, target_row, target_column, formula_or_value)?; self.workbook @@ -497,7 +497,7 @@ impl Model { let formula_or_value = self.get_cell_formula(sheet, r.row, column)? .unwrap_or_else(|| { - cell.get_localized_text(&self.workbook.shared_strings, &self.language) + cell.get_localized_text(&self.workbook.shared_strings, self.language) }); original_cells.push((r.row, formula_or_value, style_idx)); self.cell_clear_all(sheet, r.row, column)?; @@ -584,7 +584,7 @@ impl Model { .ok_or("Expected Cell to exist")?; let style_idx = cell.get_style(); let formula_or_value = self.get_cell_formula(sheet, row, *c)?.unwrap_or_else(|| { - cell.get_localized_text(&self.workbook.shared_strings, &self.language) + cell.get_localized_text(&self.workbook.shared_strings, self.language) }); original_cells.push((*c, formula_or_value, style_idx)); self.cell_clear_all(sheet, row, *c)?; diff --git a/base/src/arithmetic.rs b/base/src/arithmetic.rs index 26f729d..b4e5bc7 100644 --- a/base/src/arithmetic.rs +++ b/base/src/arithmetic.rs @@ -22,7 +22,7 @@ fn to_f64(value: &ArrayNode) -> Result { } } -impl Model { +impl<'a> Model<'a> { /// Applies `op` element‐wise for arrays/numbers. pub(crate) fn handle_arithmetic( &mut self, diff --git a/base/src/cast.rs b/base/src/cast.rs index 53aa732..212b9a3 100644 --- a/base/src/cast.rs +++ b/base/src/cast.rs @@ -14,7 +14,7 @@ pub(crate) enum NumberOrArray { Array(Vec>), } -impl Model { +impl<'a> Model<'a> { pub(crate) fn cast_number(&self, s: &str) -> Option { match s.trim().parse::() { Ok(f) => Some(f), diff --git a/base/src/expressions/lexer/mod.rs b/base/src/expressions/lexer/mod.rs index 15257d1..d17f5d1 100644 --- a/base/src/expressions/lexer/mod.rs +++ b/base/src/expressions/lexer/mod.rs @@ -79,19 +79,24 @@ pub enum LexerMode { /// Tokenize an input #[derive(Clone)] -pub struct Lexer { +pub struct Lexer<'a> { position: usize, next_token_position: Option, len: usize, chars: Vec, mode: LexerMode, - locale: Locale, - language: Language, + locale: &'a Locale, + language: &'a Language, } -impl Lexer { +impl<'a> Lexer<'a> { /// Creates a new `Lexer` that returns the tokens of a formula. - pub fn new(formula: &str, mode: LexerMode, locale: &Locale, language: &Language) -> Lexer { + pub fn new( + formula: &str, + mode: LexerMode, + locale: &'a Locale, + language: &'a Language, + ) -> Lexer<'a> { let chars: Vec = formula.chars().collect(); let len = chars.len(); Lexer { @@ -100,8 +105,8 @@ impl Lexer { next_token_position: None, len, mode, - locale: locale.clone(), - language: language.clone(), + locale, + language, } } @@ -111,13 +116,13 @@ impl Lexer { } /// Sets the locale - pub fn set_locale(&mut self, locale: &Locale) { - self.locale = locale.clone(); + pub fn set_locale(&mut self, locale: &'a Locale) { + self.locale = locale; } /// Sets the language - pub fn set_language(&mut self, language: &Language) { - self.language = language.clone(); + pub fn set_language(&mut self, language: &'a Language) { + self.language = language; } // FIXME: I don't think we should have `is_a1_mode` and `get_formula`. diff --git a/base/src/expressions/lexer/ranges.rs b/base/src/expressions/lexer/ranges.rs index 63bf98b..d628232 100644 --- a/base/src/expressions/lexer/ranges.rs +++ b/base/src/expressions/lexer/ranges.rs @@ -4,7 +4,7 @@ use crate::expressions::{token::TokenType, utils::column_to_number}; use super::Lexer; use super::{ParsedRange, ParsedReference, Result}; -impl Lexer { +impl<'a> Lexer<'a> { /// Consumes a reference in A1 style like: /// AS23, $AS23, AS$23, $AS$23, R12 /// Or returns an error diff --git a/base/src/expressions/lexer/structured_references.rs b/base/src/expressions/lexer/structured_references.rs index a2f22d4..a697b5d 100644 --- a/base/src/expressions/lexer/structured_references.rs +++ b/base/src/expressions/lexer/structured_references.rs @@ -16,7 +16,7 @@ use crate::expressions::token::{TableReference, TableSpecifier}; use super::Result; use super::{Lexer, LexerError}; -impl Lexer { +impl<'a> Lexer<'a> { fn consume_table_specifier(&mut self) -> Result> { if self.peek_char() == Some('#') { // It's a specifier diff --git a/base/src/expressions/lexer/test/test_common.rs b/base/src/expressions/lexer/test/test_common.rs index 0ee6fbd..5825133 100644 --- a/base/src/expressions/lexer/test/test_common.rs +++ b/base/src/expressions/lexer/test/test_common.rs @@ -11,7 +11,7 @@ use crate::expressions::{ types::ParsedReference, }; -fn new_lexer(formula: &str, a1_mode: bool) -> Lexer { +fn new_lexer(formula: &str, a1_mode: bool) -> Lexer<'_> { let locale = get_locale("en").unwrap(); let language = get_language("en").unwrap(); let mode = if a1_mode { @@ -655,7 +655,9 @@ fn test_comma() { // Used for testing locales where the comma is the decimal separator let mut lx = new_lexer("12,34", false); - lx.locale.numbers.symbols.decimal = ",".to_string(); + let locale = get_locale("de").unwrap(); + lx.locale = locale; + assert_eq!(lx.next_token(), Number(12.34)); assert_eq!(lx.next_token(), EOF); } diff --git a/base/src/expressions/lexer/test/test_implicit_intersection.rs b/base/src/expressions/lexer/test/test_implicit_intersection.rs index d055850..3310b22 100644 --- a/base/src/expressions/lexer/test/test_implicit_intersection.rs +++ b/base/src/expressions/lexer/test/test_implicit_intersection.rs @@ -7,7 +7,7 @@ use crate::expressions::{ use crate::language::get_language; use crate::locale::get_locale; -fn new_lexer(formula: &str) -> Lexer { +fn new_lexer(formula: &str) -> Lexer<'_> { let locale = get_locale("en").unwrap(); let language = get_language("en").unwrap(); Lexer::new(formula, LexerMode::A1, locale, language) diff --git a/base/src/expressions/lexer/test/test_language.rs b/base/src/expressions/lexer/test/test_language.rs index 28b3125..9461904 100644 --- a/base/src/expressions/lexer/test/test_language.rs +++ b/base/src/expressions/lexer/test/test_language.rs @@ -6,11 +6,11 @@ use crate::{ token::{Error, TokenType}, }, language::get_language, - locale::get_locale, + locale::get_default_locale, }; -fn new_language_lexer(formula: &str, language: &str) -> Lexer { - let locale = get_locale("en").unwrap(); +fn new_language_lexer<'a>(formula: &str, language: &str) -> Lexer<'a> { + let locale = get_default_locale(); let language = get_language(language).unwrap(); Lexer::new(formula, LexerMode::A1, locale, language) } diff --git a/base/src/expressions/lexer/test/test_locale.rs b/base/src/expressions/lexer/test/test_locale.rs index 86c8887..a008632 100644 --- a/base/src/expressions/lexer/test/test_locale.rs +++ b/base/src/expressions/lexer/test/test_locale.rs @@ -9,7 +9,7 @@ use crate::{ locale::get_locale, }; -fn new_language_lexer(formula: &str, locale: &str, language: &str) -> Lexer { +fn new_language_lexer<'a>(formula: &str, locale: &str, language: &str) -> Lexer<'a> { let locale = get_locale(locale).unwrap(); let language = get_language(language).unwrap(); Lexer::new(formula, LexerMode::A1, locale, language) diff --git a/base/src/expressions/lexer/test/test_ranges.rs b/base/src/expressions/lexer/test/test_ranges.rs index df7b4c4..22f325d 100644 --- a/base/src/expressions/lexer/test/test_ranges.rs +++ b/base/src/expressions/lexer/test/test_ranges.rs @@ -10,7 +10,7 @@ use crate::expressions::{ use crate::language::get_language; use crate::locale::get_locale; -fn new_lexer(formula: &str) -> Lexer { +fn new_lexer(formula: &str) -> Lexer<'_> { let locale = get_locale("en").unwrap(); let language = get_language("en").unwrap(); Lexer::new(formula, LexerMode::A1, locale, language) diff --git a/base/src/expressions/lexer/test/test_tables.rs b/base/src/expressions/lexer/test/test_tables.rs index 9a2199d..d7c7a36 100644 --- a/base/src/expressions/lexer/test/test_tables.rs +++ b/base/src/expressions/lexer/test/test_tables.rs @@ -7,7 +7,7 @@ use crate::expressions::{ use crate::language::get_language; use crate::locale::get_locale; -fn new_lexer(formula: &str) -> Lexer { +fn new_lexer(formula: &str) -> Lexer<'_> { let locale = get_locale("en").unwrap(); let language = get_language("en").unwrap(); Lexer::new(formula, LexerMode::A1, locale, language) diff --git a/base/src/expressions/parser/mod.rs b/base/src/expressions/parser/mod.rs index 8007b06..ec22584 100644 --- a/base/src/expressions/parser/mod.rs +++ b/base/src/expressions/parser/mod.rs @@ -31,8 +31,10 @@ f_args => e (',' e)* use std::collections::HashMap; use crate::functions::Function; +use crate::language::get_default_language; use crate::language::get_language; use crate::language::Language; +use crate::locale::get_default_locale; use crate::locale::get_locale; use crate::locale::Locale; use crate::types::Table; @@ -204,34 +206,34 @@ pub enum Node { } #[derive(Clone)] -pub struct Parser { - lexer: lexer::Lexer, +pub struct Parser<'a> { + lexer: lexer::Lexer<'a>, worksheets: Vec, defined_names: Vec, context: CellReferenceRC, tables: HashMap, - locale: Locale, - language: Language, + locale: &'a Locale, + language: &'a Language, } -pub fn new_parser_english( +pub fn new_parser_english<'a>( worksheets: Vec, defined_names: Vec, tables: HashMap, -) -> Parser { - let locale = Locale::default(); - let language = Language::default(); - Parser::new(worksheets, defined_names, tables, &locale, &language) +) -> Parser<'a> { + let locale = get_default_locale(); + let language = get_default_language(); + Parser::new(worksheets, defined_names, tables, locale, language) } -impl Parser { +impl<'a> Parser<'a> { pub fn new( worksheets: Vec, defined_names: Vec, tables: HashMap, - locale: &Locale, - language: &Language, - ) -> Parser { + locale: &'a Locale, + language: &'a Language, + ) -> Parser<'a> { let lexer = lexer::Lexer::new("", lexer::LexerMode::A1, locale, language); let context = CellReferenceRC { sheet: worksheets.first().map_or("", |v| v).to_string(), @@ -244,21 +246,21 @@ impl Parser { defined_names, context, tables, - locale: locale.clone(), - language: language.clone(), + locale, + language, } } pub fn set_lexer_mode(&mut self, mode: lexer::LexerMode) { self.lexer.set_lexer_mode(mode) } - pub fn set_locale(&mut self, locale: &Locale) { - self.locale = locale.clone(); + pub fn set_locale(&mut self, locale: &'a Locale) { + self.locale = locale; self.lexer.set_locale(locale); } - pub fn set_language(&mut self, language: &Language) { - self.language = language.clone(); + pub fn set_language(&mut self, language: &'a Language) { + self.language = language; self.lexer.set_language(language); } diff --git a/base/src/expressions/parser/tests/test_languages.rs b/base/src/expressions/parser/tests/test_languages.rs index 0485c05..df4df5c 100644 --- a/base/src/expressions/parser/tests/test_languages.rs +++ b/base/src/expressions/parser/tests/test_languages.rs @@ -1,3 +1,5 @@ +#![allow(clippy::unwrap_used)] + use std::collections::HashMap; use crate::expressions::parser::{DefinedNameS, Node, Parser}; @@ -15,11 +17,11 @@ pub fn to_string(t: &Node, cell_reference: &CellReferenceRC) -> String { to_localized_string(t, cell_reference, locale, language) } -pub fn new_parser( +pub fn new_parser<'a>( worksheets: Vec, defined_names: Vec, tables: HashMap, -) -> Parser { +) -> Parser<'a> { let locale = get_locale("en").unwrap(); let language = get_language("es").unwrap(); Parser::new(worksheets, defined_names, tables, locale, language) diff --git a/base/src/expressions/parser/tests/test_move_formula.rs b/base/src/expressions/parser/tests/test_move_formula.rs index 1964ae1..fd420bf 100644 --- a/base/src/expressions/parser/tests/test_move_formula.rs +++ b/base/src/expressions/parser/tests/test_move_formula.rs @@ -4,13 +4,13 @@ use crate::expressions::parser::move_formula::{move_formula as mf, MoveContext}; use crate::expressions::parser::tests::utils::new_parser; use crate::expressions::parser::Node; use crate::expressions::types::{Area, CellReferenceRC}; -use crate::language::Language; -use crate::locale::Locale; +use crate::language::get_default_language; +use crate::locale::get_default_locale; fn move_formula(node: &Node, context: &MoveContext) -> String { - let locale = Locale::default(); - let language = Language::default(); - mf(node, context, &locale, &language) + let locale = get_default_locale(); + let language = get_default_language(); + mf(node, context, locale, language) } #[test] diff --git a/base/src/expressions/parser/tests/utils.rs b/base/src/expressions/parser/tests/utils.rs index 88d6024..5524fb1 100644 --- a/base/src/expressions/parser/tests/utils.rs +++ b/base/src/expressions/parser/tests/utils.rs @@ -5,25 +5,25 @@ use crate::{ parser::{DefinedNameS, Node, Parser}, types::CellReferenceRC, }, - language::Language, - locale::Locale, + language::get_default_language, + locale::get_default_locale, types::Table, }; use crate::expressions::parser::stringify::to_localized_string; pub fn to_english_localized_string(t: &Node, cell_reference: &CellReferenceRC) -> String { - let locale = Locale::default(); - let language = Language::default(); - to_localized_string(t, cell_reference, &locale, &language) + let locale = get_default_locale(); + let language = get_default_language(); + to_localized_string(t, cell_reference, locale, language) } -pub fn new_parser( +pub fn new_parser<'a>( worksheets: Vec, defined_names: Vec, tables: HashMap, -) -> Parser { - let locale = Locale::default(); - let language = Language::default(); - Parser::new(worksheets, defined_names, tables, &locale, &language) +) -> Parser<'a> { + let locale = get_default_locale(); + let language = get_default_language(); + Parser::new(worksheets, defined_names, tables, locale, language) } diff --git a/base/src/functions/binary_search.rs b/base/src/functions/binary_search.rs index 8708337..60fab1f 100644 --- a/base/src/functions/binary_search.rs +++ b/base/src/functions/binary_search.rs @@ -137,7 +137,7 @@ pub(crate) fn binary_search_descending_or_greater(target: &T, array: &[T Some((n - r - 1) as i32) } -impl Model { +impl<'a> Model<'a> { /// Returns an array with the list of cell values in the range pub(crate) fn prepare_array( &mut self, diff --git a/base/src/functions/database.rs b/base/src/functions/database.rs index 99596d0..55e65c5 100644 --- a/base/src/functions/database.rs +++ b/base/src/functions/database.rs @@ -9,7 +9,7 @@ use crate::{ use super::util::{compare_values, from_wildcard_to_regex, result_matches_regex}; -impl Model { +impl<'a> Model<'a> { // =DAVERAGE(database, field, criteria) pub(crate) fn fn_daverage(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() != 3 { diff --git a/base/src/functions/date_and_time.rs b/base/src/functions/date_and_time.rs index 742b0ff..3bd272c 100644 --- a/base/src/functions/date_and_time.rs +++ b/base/src/functions/date_and_time.rs @@ -470,7 +470,7 @@ fn parse_datevalue_text(value: &str) -> Result { } } -impl Model { +impl<'a> Model<'a> { fn get_date_serial( &mut self, node: &Node, diff --git a/base/src/functions/engineering/bessel.rs b/base/src/functions/engineering/bessel.rs index 18d4d53..6fa7b1d 100644 --- a/base/src/functions/engineering/bessel.rs +++ b/base/src/functions/engineering/bessel.rs @@ -12,7 +12,7 @@ use super::transcendental::{bessel_i, bessel_j, bessel_k, bessel_y}; // Notice that the parameters for Bessel functions in Excel and here have inverted order // EXCEL_BESSEL(x, n) => bessel(n, x) -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_besseli(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() != 2 { return CalcResult::new_args_number_error(cell); diff --git a/base/src/functions/engineering/bit_operations.rs b/base/src/functions/engineering/bit_operations.rs index 88cc16b..20b3f26 100644 --- a/base/src/functions/engineering/bit_operations.rs +++ b/base/src/functions/engineering/bit_operations.rs @@ -7,7 +7,7 @@ use crate::{ // 2^48-1 const MAX: f64 = 281474976710655.0; -impl Model { +impl<'a> Model<'a> { // BITAND( number1, number2) pub(crate) fn fn_bitand(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() != 2 { diff --git a/base/src/functions/engineering/complex.rs b/base/src/functions/engineering/complex.rs index 94321ee..51fe614 100644 --- a/base/src/functions/engineering/complex.rs +++ b/base/src/functions/engineering/complex.rs @@ -182,7 +182,7 @@ fn parse_complex_number(s: &str) -> Result<(f64, f64, Suffix), String> { } } -impl Model { +impl<'a> Model<'a> { fn get_complex_number( &mut self, node: &Node, diff --git a/base/src/functions/engineering/convert.rs b/base/src/functions/engineering/convert.rs index 9f031e4..37eb88e 100644 --- a/base/src/functions/engineering/convert.rs +++ b/base/src/functions/engineering/convert.rs @@ -41,7 +41,7 @@ fn convert_temperature( } } -impl Model { +impl<'a> Model<'a> { // CONVERT(number, from_unit, to_unit) pub(crate) fn fn_convert(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() != 3 { diff --git a/base/src/functions/engineering/misc.rs b/base/src/functions/engineering/misc.rs index 2612078..89ce299 100644 --- a/base/src/functions/engineering/misc.rs +++ b/base/src/functions/engineering/misc.rs @@ -5,7 +5,7 @@ use crate::{ number_format::to_precision, }; -impl Model { +impl<'a> Model<'a> { // DELTA(number1, [number2]) pub(crate) fn fn_delta(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { let arg_count = args.len(); diff --git a/base/src/functions/engineering/number_basis.rs b/base/src/functions/engineering/number_basis.rs index 78344a4..b24e464 100644 --- a/base/src/functions/engineering/number_basis.rs +++ b/base/src/functions/engineering/number_basis.rs @@ -31,7 +31,7 @@ fn from_binary_to_decimal(value: f64) -> Result { Ok(result) } -impl Model { +impl<'a> Model<'a> { // BIN2DEC(number) pub(crate) fn fn_bin2dec(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() != 1 { diff --git a/base/src/functions/financial.rs b/base/src/functions/financial.rs index 8e11ee4..ec1c986 100644 --- a/base/src/functions/financial.rs +++ b/base/src/functions/financial.rs @@ -191,7 +191,7 @@ fn compute_ppmt( // All, except for rate are easily solvable in terms of the others. // In these formulas the payment (pmt) is normally negative -impl Model { +impl<'a> Model<'a> { fn get_array_of_numbers_generic( &mut self, arg: &Node, diff --git a/base/src/functions/information.rs b/base/src/functions/information.rs index eb2f389..1515fec 100644 --- a/base/src/functions/information.rs +++ b/base/src/functions/information.rs @@ -4,7 +4,7 @@ use crate::{ model::{Model, ParsedDefinedName}, }; -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_isnumber(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() == 1 { match self.evaluate_node_in_context(&args[0], cell) { diff --git a/base/src/functions/logical.rs b/base/src/functions/logical.rs index 15a9128..6497dca 100644 --- a/base/src/functions/logical.rs +++ b/base/src/functions/logical.rs @@ -6,7 +6,7 @@ use crate::{ use super::util::compare_values; -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_true(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.is_empty() { CalcResult::Boolean(true) diff --git a/base/src/functions/lookup_and_reference.rs b/base/src/functions/lookup_and_reference.rs index 2b48823..539a726 100644 --- a/base/src/functions/lookup_and_reference.rs +++ b/base/src/functions/lookup_and_reference.rs @@ -7,7 +7,7 @@ use crate::{ use super::util::{compare_values, from_wildcard_to_regex, result_matches_regex, values_are_equal}; -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_index(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { let row_num; let col_num; @@ -698,7 +698,7 @@ impl Model { let parsed_reference = ParsedReference::parse_reference_formula( Some(cell.sheet), &s, - &self.locale, + self.locale, |name| self.get_sheet_index_by_name(name), ); diff --git a/base/src/functions/mathematical.rs b/base/src/functions/mathematical.rs index 4578ff1..cf45442 100644 --- a/base/src/functions/mathematical.rs +++ b/base/src/functions/mathematical.rs @@ -47,7 +47,7 @@ pub fn random() -> f64 { Math::random() } -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_min(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { let mut result = f64::NAN; for arg in args { diff --git a/base/src/functions/mathematical_sum.rs b/base/src/functions/mathematical_sum.rs index bc46497..1de3993 100644 --- a/base/src/functions/mathematical_sum.rs +++ b/base/src/functions/mathematical_sum.rs @@ -13,7 +13,7 @@ fn is_same_shape_or_1d(rows1: i32, cols1: i32, rows2: i32, cols2: i32) -> bool { || (rows2 == 1 && cols1 == 1 && cols2 == rows1) } -impl Model { +impl<'a> Model<'a> { // SUMX2MY2(array_x, array_y) - Returns the sum of the difference of squares pub(crate) fn fn_sumx2my2(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { let result = match self.fn_get_two_matrices(args, cell) { diff --git a/base/src/functions/mod.rs b/base/src/functions/mod.rs index f0e7dbb..2ea5246 100644 --- a/base/src/functions/mod.rs +++ b/base/src/functions/mod.rs @@ -3,8 +3,7 @@ use std::array::IntoIter; use crate::{ calc_result::CalcResult, expressions::{parser::Node, token::Error, types::CellReferenceIndex}, - language::Functions, - language::Language, + language::{get_default_language, Functions, Language}, model::Model, }; @@ -1642,8 +1641,8 @@ impl Function { Function::RankEq => "_xlfn.RANK.EQ".to_string(), _ => { - let language = Language::default(); - self.to_localized_name(&language) + let language = get_default_language(); + self.to_localized_name(language) } } } @@ -1653,7 +1652,7 @@ impl Function { } } -impl Model { +impl<'a> Model<'a> { pub(crate) fn evaluate_function( &mut self, kind: &Function, diff --git a/base/src/functions/statistical/beta.rs b/base/src/functions/statistical/beta.rs index a66ece8..9c1d347 100644 --- a/base/src/functions/statistical/beta.rs +++ b/base/src/functions/statistical/beta.rs @@ -5,7 +5,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { // BETA.DIST(x, alpha, beta, cumulative, [A], [B]) pub(crate) fn fn_beta_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { let arg_count = args.len(); diff --git a/base/src/functions/statistical/binom.rs b/base/src/functions/statistical/binom.rs index 1cca7b2..93111a8 100644 --- a/base/src/functions/statistical/binom.rs +++ b/base/src/functions/statistical/binom.rs @@ -5,7 +5,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_binom_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() != 4 { return CalcResult::new_args_number_error(cell); diff --git a/base/src/functions/statistical/chisq.rs b/base/src/functions/statistical/chisq.rs index fa9f16a..2e0e5c3 100644 --- a/base/src/functions/statistical/chisq.rs +++ b/base/src/functions/statistical/chisq.rs @@ -6,7 +6,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { // CHISQ.DIST(x, deg_freedom, cumulative) pub(crate) fn fn_chisq_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() != 3 { diff --git a/base/src/functions/statistical/correl.rs b/base/src/functions/statistical/correl.rs index 44aa456..f3b6074 100644 --- a/base/src/functions/statistical/correl.rs +++ b/base/src/functions/statistical/correl.rs @@ -3,7 +3,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { // CORREL(array1, array2) - Returns the correlation coefficient of two data sets pub(crate) fn fn_correl(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { let (_, _, values_left, values_right) = match self.fn_get_two_matrices(args, cell) { diff --git a/base/src/functions/statistical/count_and_average.rs b/base/src/functions/statistical/count_and_average.rs index 23298f3..46fd056 100644 --- a/base/src/functions/statistical/count_and_average.rs +++ b/base/src/functions/statistical/count_and_average.rs @@ -7,7 +7,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { fn for_each_value( &mut self, args: &[Node], diff --git a/base/src/functions/statistical/covariance.rs b/base/src/functions/statistical/covariance.rs index 61eccbb..8e58265 100644 --- a/base/src/functions/statistical/covariance.rs +++ b/base/src/functions/statistical/covariance.rs @@ -3,7 +3,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_covariance_p( &mut self, args: &[Node], diff --git a/base/src/functions/statistical/devsq.rs b/base/src/functions/statistical/devsq.rs index 13d666e..ee17879 100644 --- a/base/src/functions/statistical/devsq.rs +++ b/base/src/functions/statistical/devsq.rs @@ -5,7 +5,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { // DEVSQ(number1, [number2], ...) pub(crate) fn fn_devsq(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.is_empty() { diff --git a/base/src/functions/statistical/exponential.rs b/base/src/functions/statistical/exponential.rs index 4e33d3a..53cd103 100644 --- a/base/src/functions/statistical/exponential.rs +++ b/base/src/functions/statistical/exponential.rs @@ -3,7 +3,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_expon_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { // EXPON.DIST(x, lambda, cumulative) if args.len() != 3 { diff --git a/base/src/functions/statistical/fisher.rs b/base/src/functions/statistical/fisher.rs index cd7e698..a5f8f20 100644 --- a/base/src/functions/statistical/fisher.rs +++ b/base/src/functions/statistical/fisher.rs @@ -6,7 +6,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { // FISHER(x) = 0.5 * ln((1 + x) / (1 - x)) pub(crate) fn fn_fisher(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() != 1 { diff --git a/base/src/functions/statistical/gamma.rs b/base/src/functions/statistical/gamma.rs index 1180bd0..afe486a 100644 --- a/base/src/functions/statistical/gamma.rs +++ b/base/src/functions/statistical/gamma.rs @@ -6,7 +6,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_gamma(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() != 1 { return CalcResult::new_args_number_error(cell); diff --git a/base/src/functions/statistical/gauss.rs b/base/src/functions/statistical/gauss.rs index 0e4d89d..7230cba 100644 --- a/base/src/functions/statistical/gauss.rs +++ b/base/src/functions/statistical/gauss.rs @@ -4,7 +4,7 @@ use crate::expressions::token::Error; use crate::expressions::types::CellReferenceIndex; use crate::{calc_result::CalcResult, expressions::parser::Node, model::Model}; -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_gauss(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() != 1 { return CalcResult::new_args_number_error(cell); diff --git a/base/src/functions/statistical/geomean.rs b/base/src/functions/statistical/geomean.rs index b1ba362..55a67fd 100644 --- a/base/src/functions/statistical/geomean.rs +++ b/base/src/functions/statistical/geomean.rs @@ -3,7 +3,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_geomean(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.is_empty() { return CalcResult::new_args_number_error(cell); diff --git a/base/src/functions/statistical/hypegeom.rs b/base/src/functions/statistical/hypegeom.rs index 1b7027a..48e120a 100644 --- a/base/src/functions/statistical/hypegeom.rs +++ b/base/src/functions/statistical/hypegeom.rs @@ -5,7 +5,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { // =HYPGEOM.DIST(sample_s, number_sample, population_s, number_pop, cumulative) pub(crate) fn fn_hyp_geom_dist( &mut self, diff --git a/base/src/functions/statistical/if_ifs.rs b/base/src/functions/statistical/if_ifs.rs index 79bb89c..14be90e 100644 --- a/base/src/functions/statistical/if_ifs.rs +++ b/base/src/functions/statistical/if_ifs.rs @@ -8,7 +8,7 @@ use crate::{ model::Model, }; -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_countif(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() == 2 { let arguments = vec![args[0].clone(), args[1].clone()]; diff --git a/base/src/functions/statistical/log_normal.rs b/base/src/functions/statistical/log_normal.rs index 5a17e1e..5fe32b6 100644 --- a/base/src/functions/statistical/log_normal.rs +++ b/base/src/functions/statistical/log_normal.rs @@ -5,7 +5,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_log_norm_dist( &mut self, args: &[Node], diff --git a/base/src/functions/statistical/normal.rs b/base/src/functions/statistical/normal.rs index d49347c..645af17 100644 --- a/base/src/functions/statistical/normal.rs +++ b/base/src/functions/statistical/normal.rs @@ -5,7 +5,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { // NORM.DIST(x, mean, standard_dev, cumulative) pub(crate) fn fn_norm_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() != 4 { diff --git a/base/src/functions/statistical/pearson.rs b/base/src/functions/statistical/pearson.rs index fd523e0..f1e5086 100644 --- a/base/src/functions/statistical/pearson.rs +++ b/base/src/functions/statistical/pearson.rs @@ -3,7 +3,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { // PEARSON(array1, array2) pub(crate) fn fn_pearson(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { let (_, _, values_left, values_right) = match self.fn_get_two_matrices(args, cell) { diff --git a/base/src/functions/statistical/phi.rs b/base/src/functions/statistical/phi.rs index f4be299..4329675 100644 --- a/base/src/functions/statistical/phi.rs +++ b/base/src/functions/statistical/phi.rs @@ -1,7 +1,7 @@ use crate::expressions::types::CellReferenceIndex; use crate::{calc_result::CalcResult, expressions::parser::Node, model::Model}; -impl Model { +impl<'a> Model<'a> { // PHI(x) = standard normal PDF at x pub(crate) fn fn_phi(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() != 1 { diff --git a/base/src/functions/statistical/poisson.rs b/base/src/functions/statistical/poisson.rs index 9388dba..10d6975 100644 --- a/base/src/functions/statistical/poisson.rs +++ b/base/src/functions/statistical/poisson.rs @@ -5,7 +5,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { // =POISSON.DIST(x, mean, cumulative) pub(crate) fn fn_poisson_dist( &mut self, diff --git a/base/src/functions/statistical/rank_eq_avg.rs b/base/src/functions/statistical/rank_eq_avg.rs index c6ea771..1c99fca 100644 --- a/base/src/functions/statistical/rank_eq_avg.rs +++ b/base/src/functions/statistical/rank_eq_avg.rs @@ -3,7 +3,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { // Helper to collect numeric values from the 2nd argument of RANK.* fn collect_rank_values( &mut self, diff --git a/base/src/functions/statistical/standard_dev.rs b/base/src/functions/statistical/standard_dev.rs index 85a87cd..ba5edb3 100644 --- a/base/src/functions/statistical/standard_dev.rs +++ b/base/src/functions/statistical/standard_dev.rs @@ -5,7 +5,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_stdev_p(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.is_empty() { return CalcResult::new_args_number_error(cell); diff --git a/base/src/functions/statistical/standardize.rs b/base/src/functions/statistical/standardize.rs index 447a8bf..edf5a1a 100644 --- a/base/src/functions/statistical/standardize.rs +++ b/base/src/functions/statistical/standardize.rs @@ -3,7 +3,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_standardize(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { // STANDARDIZE(x, mean, standard_dev) if args.len() != 3 { diff --git a/base/src/functions/statistical/t_dist.rs b/base/src/functions/statistical/t_dist.rs index 6e64100..dda18b6 100644 --- a/base/src/functions/statistical/t_dist.rs +++ b/base/src/functions/statistical/t_dist.rs @@ -42,7 +42,7 @@ enum TTestTails { TwoTailed, } -impl Model { +impl<'a> Model<'a> { // T.DIST(x, deg_freedom, cumulative) pub(crate) fn fn_t_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() != 3 { diff --git a/base/src/functions/statistical/variance.rs b/base/src/functions/statistical/variance.rs index 564b9dc..efd224d 100644 --- a/base/src/functions/statistical/variance.rs +++ b/base/src/functions/statistical/variance.rs @@ -5,7 +5,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_var_p(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.is_empty() { return CalcResult::new_args_number_error(cell); diff --git a/base/src/functions/statistical/weibull.rs b/base/src/functions/statistical/weibull.rs index 95947ec..9d22033 100644 --- a/base/src/functions/statistical/weibull.rs +++ b/base/src/functions/statistical/weibull.rs @@ -5,7 +5,7 @@ use crate::{ calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model, }; -impl Model { +impl<'a> Model<'a> { // WEIBULL.DIST(x, alpha, beta, cumulative) pub(crate) fn fn_weibull_dist( &mut self, diff --git a/base/src/functions/statistical/z_test.rs b/base/src/functions/statistical/z_test.rs index c1c1f87..84741a0 100644 --- a/base/src/functions/statistical/z_test.rs +++ b/base/src/functions/statistical/z_test.rs @@ -4,7 +4,7 @@ use crate::expressions::token::Error; use crate::expressions::types::CellReferenceIndex; use crate::{calc_result::CalcResult, expressions::parser::Node, model::Model}; -impl Model { +impl<'a> Model<'a> { // Z.TEST(array, x, [sigma]) pub(crate) fn fn_z_test(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { // 2 or 3 arguments diff --git a/base/src/functions/subtotal.rs b/base/src/functions/subtotal.rs index cd3f49b..c9f1d74 100644 --- a/base/src/functions/subtotal.rs +++ b/base/src/functions/subtotal.rs @@ -32,7 +32,7 @@ pub enum CellTableStatus { Filtered, } -impl Model { +impl<'a> Model<'a> { fn get_table_for_cell(&self, sheet_index: u32, row: i32, column: i32) -> bool { let worksheet = match self.workbook.worksheet(sheet_index) { Ok(ws) => ws, diff --git a/base/src/functions/text.rs b/base/src/functions/text.rs index 5befef7..e51801f 100644 --- a/base/src/functions/text.rs +++ b/base/src/functions/text.rs @@ -50,7 +50,7 @@ fn search(search_for: &str, text: &str, start: usize) -> Option { None } -impl Model { +impl<'a> Model<'a> { pub(crate) fn fn_concat(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { let mut result = "".to_string(); for arg in args { @@ -149,7 +149,7 @@ impl Model { Ok(s) => s, Err(s) => return s, }; - let d = format_number(value, &format_code, &self.locale); + let d = format_number(value, &format_code, self.locale); if let Some(_e) = d.error { return CalcResult::Error { error: Error::VALUE, diff --git a/base/src/functions/xlookup.rs b/base/src/functions/xlookup.rs index ed90ae3..cb9f9ad 100644 --- a/base/src/functions/xlookup.rs +++ b/base/src/functions/xlookup.rs @@ -118,7 +118,7 @@ fn linear_search( None } -impl Model { +impl<'a> Model<'a> { /// The XLOOKUP function searches a range or an array, and then returns the item corresponding /// to the first match it finds. If no match exists, then XLOOKUP can return the closest (approximate) match. /// =XLOOKUP(lookup_value, lookup_array, return_array, [if_not_found], [match_mode], [search_mode]) diff --git a/base/src/language/mod.rs b/base/src/language/mod.rs index e070f72..06bd890 100644 --- a/base/src/language/mod.rs +++ b/base/src/language/mod.rs @@ -2,13 +2,13 @@ use std::{collections::HashMap, sync::OnceLock}; use bitcode::{Decode, Encode}; -#[derive(Encode, Decode, Clone)] +#[derive(Encode, Decode)] pub struct Booleans { pub r#true: String, pub r#false: String, } -#[derive(Encode, Decode, Clone)] +#[derive(Encode, Decode)] pub struct Errors { pub r#ref: String, pub name: String, @@ -24,7 +24,7 @@ pub struct Errors { pub null: String, } -#[derive(Encode, Decode, Clone)] +#[derive(Encode, Decode)] pub struct Functions { pub and: String, pub r#false: String, @@ -373,7 +373,7 @@ pub struct Functions { pub small: String, } -#[derive(Encode, Decode, Clone)] +#[derive(Encode, Decode)] pub struct Language { pub name: String, pub code: String, @@ -382,11 +382,9 @@ pub struct Language { pub functions: Functions, } -impl Default for Language { - fn default() -> Self { - #[allow(clippy::unwrap_used)] - get_language("en").unwrap().clone() - } +pub fn get_default_language() -> &'static Language { + #[allow(clippy::unwrap_used)] + get_language("en").unwrap() } static LANGUAGES: OnceLock> = OnceLock::new(); @@ -398,7 +396,7 @@ fn get_languages() -> &'static HashMap { }) } -pub fn get_language(id: &str) -> Result<&Language, String> { +pub fn get_language(id: &str) -> Result<&'static Language, String> { get_languages() .get(id) .ok_or_else(|| format!("Language is not supported: '{id}'")) diff --git a/base/src/locale/mod.rs b/base/src/locale/mod.rs index c53f654..86bc4dc 100644 --- a/base/src/locale/mod.rs +++ b/base/src/locale/mod.rs @@ -2,27 +2,27 @@ use std::{collections::HashMap, sync::OnceLock}; use bitcode::{Decode, Encode}; -#[derive(Encode, Decode, Clone)] +#[derive(Encode, Decode)] pub struct Locale { pub dates: Dates, pub numbers: NumbersProperties, pub currency: Currency, } -#[derive(Encode, Decode, Clone)] +#[derive(Encode, Decode)] pub struct Currency { pub iso: String, pub symbol: String, } -#[derive(Encode, Decode, Clone)] +#[derive(Encode, Decode)] pub struct NumbersProperties { pub symbols: NumbersSymbols, pub decimal_formats: DecimalFormats, pub currency_formats: CurrencyFormats, } -#[derive(Encode, Decode, Clone)] +#[derive(Encode, Decode)] pub struct Dates { pub day_names: Vec, pub day_names_short: Vec, @@ -34,7 +34,7 @@ pub struct Dates { pub date_time_formats: DateFormats, } -#[derive(Encode, Decode, Clone)] +#[derive(Encode, Decode)] pub struct NumbersSymbols { pub decimal: String, pub group: String, @@ -52,7 +52,7 @@ pub struct NumbersSymbols { } // See: https://cldr.unicode.org/translation/number-currency-formats/number-and-currency-patterns -#[derive(Encode, Decode, Clone)] +#[derive(Encode, Decode)] pub struct CurrencyFormats { pub standard: String, pub standard_alpha_next_to_number: Option, @@ -62,12 +62,12 @@ pub struct CurrencyFormats { pub accounting_no_currency: String, } -#[derive(Encode, Decode, Clone)] +#[derive(Encode, Decode)] pub struct DecimalFormats { pub standard: String, } -#[derive(Encode, Decode, Clone)] +#[derive(Encode, Decode)] pub struct DateFormats { pub full: String, pub long: String, @@ -75,7 +75,7 @@ pub struct DateFormats { pub short: String, } -#[derive(Encode, Decode, Clone)] +#[derive(Encode, Decode)] pub struct TimeFormats { pub full: String, pub long: String, @@ -83,11 +83,9 @@ pub struct TimeFormats { pub short: String, } -impl Default for Locale { - fn default() -> Self { - #[allow(clippy::unwrap_used)] - get_locale("en").unwrap().clone() - } +pub fn get_default_locale() -> &'static Locale { + #[allow(clippy::unwrap_used)] + get_locale("en").unwrap() } static LOCALES: OnceLock> = OnceLock::new(); @@ -104,7 +102,7 @@ pub fn get_supported_locales() -> Vec { get_locales().keys().cloned().collect() } -pub fn get_locale(id: &str) -> Result<&Locale, String> { +pub fn get_locale(id: &str) -> Result<&'static Locale, String> { get_locales() .get(id) .ok_or_else(|| format!("Invalid locale: '{id}'")) diff --git a/base/src/model.rs b/base/src/model.rs index 652fd5b..ed37bc9 100644 --- a/base/src/model.rs +++ b/base/src/model.rs @@ -24,7 +24,7 @@ use crate::{ }, functions::util::compare_values, implicit_intersection::implicit_intersection, - language::{get_language, Language}, + language::{get_default_language, get_language, Language}, locale::{get_locale, Locale}, types::*, utils as common, @@ -95,7 +95,7 @@ pub(crate) enum ParsedDefinedName { /// * A list of cells with its status (evaluating, evaluated, not evaluated) /// * A dictionary with the shared strings and their indices. /// This is an optimization for large files (~1 million rows) -pub struct Model { +pub struct Model<'a> { /// A Rust internal representation of an Excel workbook pub workbook: Workbook, /// A list of parsed formulas @@ -105,13 +105,13 @@ pub struct Model { /// An optimization to lookup strings faster pub(crate) shared_strings: HashMap, /// An instance of the parser - pub(crate) parser: Parser, + pub(crate) parser: Parser<'a>, /// The list of cells with formulas that are evaluated or being evaluated pub(crate) cells: HashMap<(u32, i32, i32), CellState>, /// The locale of the model - pub(crate) locale: Locale, + pub(crate) locale: &'a Locale, /// The language used - pub(crate) language: Language, + pub(crate) language: &'a Language, /// The timezone used to evaluate the model pub(crate) tz: Tz, /// The view id. A view consists of a selected sheet and ranges. @@ -129,7 +129,7 @@ pub struct CellIndex { pub column: i32, } -impl Model { +impl<'a> Model<'a> { pub(crate) fn evaluate_node_with_reference( &mut self, node: &Node, @@ -721,7 +721,7 @@ impl Model { BooleanCell { v, .. } => CalcResult::Boolean(*v), NumberCell { v, .. } => CalcResult::Number(*v), ErrorCell { ei, .. } => { - let message = ei.to_localized_error_string(&self.language); + let message = ei.to_localized_error_string(self.language); CalcResult::new_error(ei.clone(), cell_reference, message) } SharedString { si, .. } => { @@ -747,7 +747,7 @@ impl Model { CalcResult::Error { error: ei.clone(), origin: cell_reference, - message: ei.to_localized_error_string(&self.language), + message: ei.to_localized_error_string(self.language), } } } @@ -852,7 +852,7 @@ impl Model { /// /// See also: /// * [Model::to_bytes] - pub fn from_bytes(s: &[u8], language_id: &str) -> Result { + pub fn from_bytes(s: &[u8], language_id: &'a str) -> Result, String> { let workbook: Workbook = bitcode::decode(s).map_err(|e| format!("Error parsing workbook: {e}"))?; Model::from_workbook(workbook, language_id) @@ -876,7 +876,7 @@ impl Model { /// # Ok(()) /// # } /// ``` - pub fn from_workbook(workbook: Workbook, language_id: &str) -> Result { + pub fn from_workbook(workbook: Workbook, language_id: &str) -> Result, String> { let parsed_formulas = Vec::new(); let worksheets = &workbook.worksheets; @@ -894,9 +894,8 @@ impl Model { // } let cells = HashMap::new(); - let locale = get_locale(&workbook.settings.locale) - .map_err(|_| "Invalid locale".to_string())? - .clone(); + let locale = + get_locale(&workbook.settings.locale).map_err(|_| "Invalid locale".to_string())?; let tz: Tz = workbook .settings .tz @@ -904,15 +903,15 @@ impl Model { .map_err(|_| format!("Invalid timezone: {}", workbook.settings.tz))?; let language = match get_language(language_id) { - Ok(lang) => lang.clone(), + Ok(lang) => lang, Err(_) => return Err("Invalid language".to_string()), }; let parser = Parser::new( worksheet_names, defined_names, workbook.tables.clone(), - &locale, - &language, + locale, + language, ); let mut shared_strings = HashMap::new(); for (index, s) in workbook.shared_strings.iter().enumerate() { @@ -1068,8 +1067,8 @@ impl Model { row_delta: target.row - source.row, column_delta: target.column - source.column, }, - &self.locale, - &self.language, + self.locale, + self.language, ); Ok(format!("={formula_str}")) } else { @@ -1108,7 +1107,7 @@ impl Model { let cell = self.workbook.worksheet(sheet)?.cell(row, column); let result = match cell { Some(cell) => match cell.get_formula() { - None => cell.get_localized_text(&self.workbook.shared_strings, &self.language), + None => cell.get_localized_text(&self.workbook.shared_strings, self.language), Some(i) => { let formula = &self.parsed_formulas[sheet as usize][i as usize]; let cell_ref = CellReferenceRC { @@ -1118,7 +1117,7 @@ impl Model { }; format!( "={}", - to_localized_string(formula, &cell_ref, &self.locale, &self.language) + to_localized_string(formula, &cell_ref, self.locale, self.language) ) } }, @@ -1179,7 +1178,7 @@ impl Model { }; return Ok(format!( "={}", - to_localized_string(formula, &cell_reference, &self.locale, &self.language) + to_localized_string(formula, &cell_reference, self.locale, self.language) )); }; Ok(value.to_string()) @@ -1227,7 +1226,7 @@ impl Model { }; Ok(Some(format!( "={}", - to_localized_string(formula, &cell_ref, &self.locale, &self.language) + to_localized_string(formula, &cell_ref, self.locale, self.language) ))) } None => Ok(None), @@ -1261,10 +1260,10 @@ impl Model { row, column, }; - let language_en = Language::default(); + let language_en = get_default_language(); Ok(Some(format!( "={}", - to_localized_string(formula, &cell_ref, &self.locale, &language_en) + to_localized_string(formula, &cell_ref, self.locale, language_en) ))) } None => Ok(None), @@ -1306,7 +1305,7 @@ impl Model { ) -> Result<(), String> { let style_index = self.get_cell_style_index(sheet, row, column)?; let new_style_index; - if common::value_needs_quoting(value, &self.language) { + if common::value_needs_quoting(value, self.language) { new_style_index = self .workbook .styles @@ -1497,7 +1496,7 @@ impl Model { let style_index = self.get_cell_style_index(sheet, row, column)?; if let Some(new_value) = value.strip_prefix('\'') { // First check if it needs quoting - let new_style = if common::value_needs_quoting(new_value, &self.language) { + let new_style = if common::value_needs_quoting(new_value, self.language) { self.workbook .styles .get_style_with_quote_prefix(style_index)? @@ -1570,7 +1569,7 @@ impl Model { // Check is it is error value let upper = value.to_uppercase(); let worksheet = self.workbook.worksheet_mut(sheet)?; - match get_error_by_name(&upper, &self.language) { + match get_error_by_name(&upper, self.language) { Some(error) => { worksheet.set_cell_with_error(row, column, error, new_style_index)?; } @@ -1749,7 +1748,7 @@ impl Model { .cell(row, column) .cloned() .unwrap_or_default(); - let cell_value = cell.value(&self.workbook.shared_strings, &self.language); + let cell_value = cell.value(&self.workbook.shared_strings, self.language); Ok(cell_value) } @@ -1783,8 +1782,8 @@ impl Model { Some(cell) => { let format = self.get_style_for_cell(sheet_index, row, column)?.num_fmt; let formatted_value = - cell.formatted_value(&self.workbook.shared_strings, &self.language, |value| { - format_number(value, &format, &self.locale).text + cell.formatted_value(&self.workbook.shared_strings, self.language, |value| { + format_number(value, &format, self.locale).text }); Ok(formatted_value) } @@ -1825,10 +1824,10 @@ impl Model { }; Ok(format!( "={}", - to_localized_string(formula, &cell_ref, &self.locale, &self.language) + to_localized_string(formula, &cell_ref, self.locale, self.language) )) } - None => Ok(cell.get_localized_text(&self.workbook.shared_strings, &self.language)), + None => Ok(cell.get_localized_text(&self.workbook.shared_strings, self.language)), } } @@ -2156,12 +2155,9 @@ impl Model { } // Make sure the formula is valid - match common::ParsedReference::parse_reference_formula( - None, - formula, - &self.locale, - |name| self.get_sheet_index_by_name(name), - ) { + match common::ParsedReference::parse_reference_formula(None, formula, self.locale, |name| { + self.get_sheet_index_by_name(name) + }) { Ok(_) => {} Err(_) => { return Err("Formula: Invalid defined name formula".to_string()); @@ -2350,10 +2346,10 @@ impl Model { /// Sets the locale of the model pub fn set_locale(&mut self, locale_id: &str) -> Result<(), String> { let locale = match get_locale(locale_id) { - Ok(l) => l.clone(), + Ok(l) => l, Err(_) => return Err(format!("Invalid locale: {locale_id}")), }; - self.parser.set_locale(&locale); + self.parser.set_locale(locale); self.locale = locale; self.workbook.settings.locale = locale_id.to_string(); self.evaluate(); @@ -2375,10 +2371,10 @@ impl Model { /// Sets the language pub fn set_language(&mut self, language_id: &str) -> Result<(), String> { let language = match get_language(language_id) { - Ok(l) => l.clone(), + Ok(l) => l, Err(_) => return Err(format!("Invalid language: {language_id}")), }; - self.parser.set_language(&language); + self.parser.set_language(language); self.language = language; Ok(()) } diff --git a/base/src/new_empty.rs b/base/src/new_empty.rs index 474b476..1bc9cb7 100644 --- a/base/src/new_empty.rs +++ b/base/src/new_empty.rs @@ -8,13 +8,14 @@ use crate::{ expressions::{ lexer::LexerMode, parser::{ - Parser, stringify::{rename_sheet_in_node, to_localized_string, to_rc_format} + stringify::{rename_sheet_in_node, to_localized_string, to_rc_format}, + Parser, }, types::CellReferenceRC, }, - language::{Language, get_language}, - locale::{Locale, get_locale}, - model::{Model, ParsedDefinedName, get_milliseconds_since_epoch}, + language::{get_default_language, get_language}, + locale::{get_default_locale, get_locale}, + model::{get_milliseconds_since_epoch, Model, ParsedDefinedName}, types::{ DefinedName, Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet, WorksheetView, @@ -36,7 +37,7 @@ fn is_valid_sheet_name(name: &str) -> bool { !name.is_empty() && name.chars().count() <= 31 && !name.contains(&invalid[..]) } -impl Model { +impl<'a> Model<'a> { /// Creates a new worksheet. Note that it does not check if the name or the sheet_id exists fn new_empty_worksheet(name: &str, sheet_id: u32, view_ids: &[&u32]) -> Worksheet { let mut views = HashMap::new(); @@ -83,11 +84,11 @@ impl Model { // This function parses all the internal formulas in all the worksheets // (in the default language ("en") and locale ("en") and the RC format) pub(crate) fn parse_formulas(&mut self) { - let locale = self.locale.clone(); - let language = self.language.clone(); + let locale = self.locale; + let language = self.language; - self.parser.set_locale(&Locale::default()); - self.parser.set_language(&Language::default()); + self.parser.set_locale(get_default_locale()); + self.parser.set_language(get_default_language()); self.parser.set_lexer_mode(LexerMode::R1C1); let worksheets = &self.workbook.worksheets; for worksheet in worksheets { @@ -105,8 +106,8 @@ impl Model { self.parsed_formulas.push(parse_formula); } self.parser.set_lexer_mode(LexerMode::A1); - self.parser.set_locale(&locale); - self.parser.set_language(&language); + self.parser.set_locale(locale); + self.parser.set_language(language); } pub(crate) fn parse_defined_names(&mut self) { @@ -116,7 +117,7 @@ impl Model { ParsedReference::parse_reference_formula( None, &defined_name.formula, - &self.locale, + self.locale, |name| self.get_sheet_index_by_name(name), ) { match reference { @@ -298,7 +299,7 @@ impl Model { for defined_name in &mut self.workbook.defined_names { let mut t = self.parser.parse(&defined_name.formula, cell_reference); rename_sheet_in_node(&mut t, sheet_index, new_name); - let formula = to_localized_string(&t, cell_reference, &self.locale, &self.language); + let formula = to_localized_string(&t, cell_reference, self.locale, self.language); defined_names.push(DefinedName { name: defined_name.name.clone(), formula, @@ -364,21 +365,21 @@ impl Model { /// Creates a new workbook with one empty sheet pub fn new_empty( - name: &str, - locale_id: &str, - timezone: &str, - language_id: &str, - ) -> Result { + name: &'a str, + locale_id: &'a str, + timezone: &'a str, + language_id: &'a str, + ) -> Result, String> { let tz: Tz = match &timezone.parse() { Ok(tz) => *tz, Err(_) => return Err(format!("Invalid timezone: {}", &timezone)), }; let locale = match get_locale(locale_id) { - Ok(l) => l.clone(), + Ok(l) => l, Err(_) => return Err(format!("Invalid locale: {locale_id}")), }; let language = match get_language(language_id) { - Ok(l) => l.clone(), + Ok(l) => l, Err(_) => return Err(format!("Invalid language: {language_id}")), }; @@ -426,7 +427,7 @@ impl Model { let parsed_formulas = Vec::new(); let worksheets = &workbook.worksheets; let worksheet_names = worksheets.iter().map(|s| s.get_name()).collect(); - let parser = Parser::new(worksheet_names, vec![], HashMap::new(), &locale, &language); + let parser = Parser::new(worksheet_names, vec![], HashMap::new(), locale, language); let cells = HashMap::new(); let mut model = Model { diff --git a/base/src/styles.rs b/base/src/styles.rs index ca7b474..8daeedd 100644 --- a/base/src/styles.rs +++ b/base/src/styles.rs @@ -213,7 +213,7 @@ impl Styles { } // TODO: Try to find a better spot for styles setters -impl Model { +impl<'a> Model<'a> { pub fn set_cell_style( &mut self, sheet: u32, diff --git a/base/src/test/test_fn_time.rs b/base/src/test/test_fn_time.rs index 862aa0a..3b1184f 100644 --- a/base/src/test/test_fn_time.rs +++ b/base/src/test/test_fn_time.rs @@ -23,7 +23,7 @@ const TIME_2_AM: &str = "0.083333333"; // 2:00 AM = 2/24 ≈ 0.083333333 const TIME_00_00_01: &str = "0.000011574"; // 1 second = 1/86400 ≈ 0.000011574 /// Helper function to set up and evaluate a model with time expressions -fn test_time_expressions(expressions: &[(&str, &str)]) -> crate::model::Model { +fn test_time_expressions<'a>(expressions: &[(&str, &str)]) -> crate::model::Model<'a> { let mut model = new_empty_model(); for (cell, formula) in expressions { model._set(cell, formula); diff --git a/base/src/test/test_language.rs b/base/src/test/test_language.rs index 7da1ccc..d702acb 100644 --- a/base/src/test/test_language.rs +++ b/base/src/test/test_language.rs @@ -2,7 +2,7 @@ use crate::{test::util::new_empty_model, Model}; -pub fn new_german_empty_model() -> Model { +pub fn new_german_empty_model<'a>() -> Model<'a> { Model::new_empty("model", "en", "UTC", "de").unwrap() } diff --git a/base/src/test/test_locale.rs b/base/src/test/test_locale.rs index 61dd365..cce685e 100644 --- a/base/src/test/test_locale.rs +++ b/base/src/test/test_locale.rs @@ -2,7 +2,7 @@ use crate::Model; -pub fn new_empty_model() -> Model { +pub fn new_empty_model<'a>() -> Model<'a> { Model::new_empty("model", "de", "UTC", "de").unwrap() } diff --git a/base/src/test/user_model/test_to_from_bytes.rs b/base/src/test/user_model/test_to_from_bytes.rs index 0027332..f9a9a2f 100644 --- a/base/src/test/user_model/test_to_from_bytes.rs +++ b/base/src/test/user_model/test_to_from_bytes.rs @@ -33,7 +33,9 @@ fn errors() { fn language() { let mut model = UserModel::from_model(new_empty_model()); model.set_user_input(0, 1, 1, "=NOW()").unwrap(); - model.set_user_input(0, 1, 2, "=SUM(1.234, 3.4, T1:T3, {1,2.4,3})").unwrap(); + model + .set_user_input(0, 1, 2, "=SUM(1.234, 3.4, T1:T3, {1,2.4,3})") + .unwrap(); model.set_language("fr").unwrap(); model.set_locale("fr").unwrap(); let model_bytes = model.to_bytes(); @@ -41,7 +43,10 @@ fn language() { let model2 = UserModel::from_bytes(&model_bytes, "es").unwrap(); // Check that the formula has been localized to Spanish assert_eq!(model2.get_cell_content(0, 1, 1), Ok("=AHORA()".to_string())); - assert_eq!(model2.get_cell_content(0, 1, 2), Ok("=SUMA(1,234;3,4;T1:T3;{1;2,4;3})".to_string())); + assert_eq!( + model2.get_cell_content(0, 1, 2), + Ok("=SUMA(1,234;3,4;T1:T3;{1;2,4;3})".to_string()) + ); } #[test] @@ -52,5 +57,8 @@ fn formulatext_english() { model.set_language("de").unwrap(); - assert_eq!(model.get_formatted_cell_value(0, 1, 2), Ok("=SUM(1,2,3)".to_string())); -} \ No newline at end of file + assert_eq!( + model.get_formatted_cell_value(0, 1, 2), + Ok("=SUM(1,2,3)".to_string()) + ); +} diff --git a/base/src/test/user_model/util.rs b/base/src/test/user_model/util.rs index f1c6110..741957b 100644 --- a/base/src/test/user_model/util.rs +++ b/base/src/test/user_model/util.rs @@ -2,11 +2,11 @@ use crate::{expressions::types::Area, types::Border, BorderArea, UserModel}; -pub fn new_empty_user_model() -> UserModel { +pub fn new_empty_user_model<'a>() -> UserModel<'a> { UserModel::new_empty("model", "en", "UTC", "en").unwrap() } -impl UserModel { +impl<'a> UserModel<'a> { pub fn _set_cell_border(&mut self, cell: &str, color: &str) { let cell_reference = self.model._parse_reference(cell); let column = cell_reference.column; diff --git a/base/src/test/util.rs b/base/src/test/util.rs index 3ac4604..a672b9b 100644 --- a/base/src/test/util.rs +++ b/base/src/test/util.rs @@ -4,11 +4,11 @@ use crate::expressions::types::CellReferenceIndex; use crate::model::Model; use crate::types::Cell; -pub fn new_empty_model() -> Model { +pub fn new_empty_model<'a>() -> Model<'a> { Model::new_empty("model", "en", "UTC", "en").unwrap() } -impl Model { +impl<'a> Model<'a> { pub fn _parse_reference(&self, cell: &str) -> CellReferenceIndex { if cell.contains('!') { self.parse_reference(cell).unwrap() diff --git a/base/src/units.rs b/base/src/units.rs index 8ea49ee..304a38e 100644 --- a/base/src/units.rs +++ b/base/src/units.rs @@ -88,7 +88,7 @@ fn get_units_from_format_string(num_fmt: &str) -> Option { } } -impl Model { +impl<'a> Model<'a> { fn compute_cell_units(&self, cell_reference: &CellReferenceIndex) -> Option { let cell_style_res = &self.get_style_for_cell( cell_reference.sheet, diff --git a/base/src/user_model/border.rs b/base/src/user_model/border.rs index d3d057a..277355c 100644 --- a/base/src/user_model/border.rs +++ b/base/src/user_model/border.rs @@ -7,7 +7,7 @@ use super::{ border_utils::is_max_border, common::BorderType, history::Diff, BorderArea, UserModel, }; -impl UserModel { +impl<'a> UserModel<'a> { fn update_single_cell_border( &mut self, border_area: &BorderArea, diff --git a/base/src/user_model/common.rs b/base/src/user_model/common.rs index 6eec473..7b448be 100644 --- a/base/src/user_model/common.rs +++ b/base/src/user_model/common.rs @@ -218,20 +218,20 @@ fn update_style(old_value: &Style, style_path: &str, value: &str) -> Result { + pub(crate) model: Model<'a>, history: History, send_queue: Vec, pause_evaluation: bool, } -impl Debug for UserModel { +impl<'a> Debug for UserModel<'a> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_struct("UserModel").finish() } } -impl UserModel { +impl<'a> UserModel<'a> { /// Creates a user model from an existing model pub fn from_model(model: Model) -> UserModel { UserModel { @@ -247,11 +247,11 @@ impl UserModel { /// See also: /// * [Model::new_empty] pub fn new_empty( - name: &str, - locale_id: &str, - timezone: &str, - language_id: &str, - ) -> Result { + name: &'a str, + locale_id: &'a str, + timezone: &'a str, + language_id: &'a str, + ) -> Result, String> { let model = Model::new_empty(name, locale_id, timezone, language_id)?; Ok(UserModel { model, @@ -265,7 +265,7 @@ impl UserModel { /// /// See also: /// * [Model::from_bytes] - pub fn from_bytes(s: &[u8], language_id: &str) -> Result { + pub fn from_bytes(s: &[u8], language_id: &'a str) -> Result, String> { let model = Model::from_bytes(s, language_id)?; Ok(UserModel { model, @@ -284,7 +284,7 @@ impl UserModel { } /// Returns the internal model - pub fn get_model(&self) -> &Model { + pub fn get_model(&self) -> &Model<'_> { &self.model } diff --git a/base/src/user_model/ui.rs b/base/src/user_model/ui.rs index e947aa7..8bbb118 100644 --- a/base/src/user_model/ui.rs +++ b/base/src/user_model/ui.rs @@ -21,7 +21,7 @@ pub struct SelectedView { pub left_column: i32, } -impl UserModel { +impl<'a> UserModel<'a> { /// Returns the selected sheet index pub fn get_selected_sheet(&self) -> u32 { if let Some(view) = self.model.workbook.views.get(&self.model.view_id) { diff --git a/bindings/nodejs/src/model.rs b/bindings/nodejs/src/model.rs index 8041ab1..78fa130 100644 --- a/bindings/nodejs/src/model.rs +++ b/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 { - 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 { - 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 { - 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 }) } diff --git a/bindings/nodejs/src/user_model.rs b/bindings/nodejs/src/user_model.rs index c424b34..ef02ada 100644 --- a/bindings/nodejs/src/user_model.rs +++ b/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 { - 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 { - 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 }) } diff --git a/bindings/python/src/lib.rs b/bindings/python/src/lib.rs index a47a313..dc7fd12 100644 --- a/bindings/python/src/lib.rs +++ b/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 { + // 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 { + 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 pub fn load_from_bytes(bytes: &[u8], language_id: &str) -> PyResult { 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 { /// Creates an empty model in the raw API #[pyfunction] pub fn create(name: &str, locale: &str, tz: &str, language_id: &str) -> PyResult { + 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 { + 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 { + 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 { + 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 { 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); diff --git a/bindings/wasm/src/lib.rs b/bindings/wasm/src/lib.rs index 52a18c5..db0890d 100644 --- a/bindings/wasm/src/lib.rs +++ b/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 { + 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 { + let language_id = leak_str(language_id); let model = BaseModel::from_bytes(bytes, language_id).map_err(to_js_error)?; Ok(Model { model }) } diff --git a/webapp/IronCalc/src/components/SheetTabBar/SheetTabBar.tsx b/webapp/IronCalc/src/components/SheetTabBar/SheetTabBar.tsx index ececdf9..cfdc116 100644 --- a/webapp/IronCalc/src/components/SheetTabBar/SheetTabBar.tsx +++ b/webapp/IronCalc/src/components/SheetTabBar/SheetTabBar.tsx @@ -1,3 +1,4 @@ +import type { Model } from "@ironcalc/wasm"; import { styled, Tooltip } from "@mui/material"; import { EllipsisVertical, Menu, Plus } from "lucide-react"; import { useState } from "react"; @@ -11,7 +12,6 @@ import type { WorkbookState } from "../workbookState"; import SheetListMenu from "./SheetListMenu"; import SheetTab from "./SheetTab"; import type { SheetOptions } from "./types"; -import { Model } from "@ironcalc/wasm"; export interface SheetTabBarProps { sheets: SheetOptions[]; @@ -131,7 +131,7 @@ function SheetTabBar(props: SheetTabBarProps) { open={workbookSettingsOpen} onClose={() => setWorkbookSettingsOpen(false)} initialLocale={props.model.getLocale()} - initialTimezone={ props.model.getTimezone()} + initialTimezone={props.model.getTimezone()} initialLanguage={props.model.getLanguage()} onSave={(locale: string, timezone: string, language: string) => { props.onSettingsChange(locale, timezone, language); diff --git a/webapp/app.ironcalc.com/frontend/src/components/storage.ts b/webapp/app.ironcalc.com/frontend/src/components/storage.ts index 64abea1..f5985ba 100644 --- a/webapp/app.ironcalc.com/frontend/src/components/storage.ts +++ b/webapp/app.ironcalc.com/frontend/src/components/storage.ts @@ -139,8 +139,7 @@ export function saveSelectedModelInStorage(model: Model) { modelsJson = "{}"; } const models: ModelsMetadata = JSON.parse(modelsJson); - models[uuid].language = model.getLanguage(), - + models[uuid].language = model.getLanguage(); localStorage.setItem("models", JSON.stringify(models)); } } diff --git a/xlsx/src/export/test/test_export.rs b/xlsx/src/export/test/test_export.rs index 9f2aacd..5ee5efb 100644 --- a/xlsx/src/export/test/test_export.rs +++ b/xlsx/src/export/test/test_export.rs @@ -7,7 +7,7 @@ use crate::export::save_to_icalc; use crate::import::load_from_icalc; use crate::{export::save_to_xlsx, import::load_from_xlsx}; -pub fn new_empty_model() -> Model { +pub fn new_empty_model<'a>() -> Model<'a> { Model::new_empty("model", "en", "UTC", "en").unwrap() } diff --git a/xlsx/src/import/mod.rs b/xlsx/src/import/mod.rs index b46b728..0bdd706 100644 --- a/xlsx/src/import/mod.rs +++ b/xlsx/src/import/mod.rs @@ -140,18 +140,18 @@ pub fn load_from_xlsx_bytes( } /// Loads a [Model] from an xlsx file -pub fn load_from_xlsx( +pub fn load_from_xlsx<'a>( file_name: &str, locale: &str, tz: &str, - language: &str, -) -> Result { + language: &'a str, +) -> Result, XlsxError> { let workbook = load_from_excel(file_name, locale, tz)?; Model::from_workbook(workbook, language).map_err(XlsxError::Workbook) } /// Loads a [Model] from an `ic` file (a file in the IronCalc internal representation) -pub fn load_from_icalc(file_name: &str, language_id: &str) -> Result { +pub fn load_from_icalc<'a>(file_name: &str, language_id: &'a str) -> Result, XlsxError> { let contents = fs::read(file_name) .map_err(|e| XlsxError::IO(format!("Could not extract workbook name: {e}")))?; let workbook: Workbook = bitcode::decode(&contents)