sirtimbly/IronCalc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Nicolás Hatcher
2025-12-14 16:55:14 +01:00
parent ffe5d1a158
commit 96a5482e01
84 changed files with 308 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
base/src/actions.rs
View File

@@ -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)?;

2
base/src/arithmetic.rs
View File

@@ -22,7 +22,7 @@ fn to_f64(value: &ArrayNode) -> Result<f64, Error> {
}
}
impl Model {
impl<'a> Model<'a> {
/// Applies `op` element‐wise for arrays/numbers.
pub(crate) fn handle_arithmetic(
&mut self,

2
base/src/cast.rs
View File

@@ -14,7 +14,7 @@ pub(crate) enum NumberOrArray {
Array(Vec<Vec<ArrayNode>>),
}
impl Model {
impl<'a> Model<'a> {
pub(crate) fn cast_number(&self, s: &str) -> Option<f64> {
match s.trim().parse::<f64>() {
Ok(f) => Some(f),

27
base/src/expressions/lexer/mod.rs
View File

@@ -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<usize>,
len: usize,
chars: Vec<char>,
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<char> = 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`.

2
base/src/expressions/lexer/ranges.rs
View File

@@ -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

2
base/src/expressions/lexer/structured_references.rs
View File

@@ -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<Option<TableSpecifier>> {
if self.peek_char() == Some('#') {
// It's a specifier

6
base/src/expressions/lexer/test/test_common.rs
View File

@@ -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);
}

2
base/src/expressions/lexer/test/test_implicit_intersection.rs
View File

@@ -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)

6
base/src/expressions/lexer/test/test_language.rs
View File

@@ -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)
}

2
base/src/expressions/lexer/test/test_locale.rs
View File

@@ -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)

2
base/src/expressions/lexer/test/test_ranges.rs
View File

@@ -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)

2
base/src/expressions/lexer/test/test_tables.rs
View File

@@ -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)

40
base/src/expressions/parser/mod.rs
View File

@@ -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<String>,
defined_names: Vec<DefinedNameS>,
context: CellReferenceRC,
tables: HashMap<String, Table>,
locale: Locale,
language: Language,
locale: &'a Locale,
language: &'a Language,
}
pub fn new_parser_english(
pub fn new_parser_english<'a>(
worksheets: Vec<String>,
defined_names: Vec<DefinedNameS>,
tables: HashMap<String, Table>,
) -> 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<String>,
defined_names: Vec<DefinedNameS>,
tables: HashMap<String, Table>,
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);
}

6
base/src/expressions/parser/tests/test_languages.rs
View File

@@ -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<String>,
defined_names: Vec<DefinedNameS>,
tables: HashMap<String, Table>,
) -> Parser {
) -> Parser<'a> {
let locale = get_locale("en").unwrap();
let language = get_language("es").unwrap();
Parser::new(worksheets, defined_names, tables, locale, language)

10
base/src/expressions/parser/tests/test_move_formula.rs
View File

@@ -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]

20
base/src/expressions/parser/tests/utils.rs
View File

@@ -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<String>,
defined_names: Vec<DefinedNameS>,
tables: HashMap<String, Table>,
) -> 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)
}

2
base/src/functions/binary_search.rs
View File

@@ -137,7 +137,7 @@ pub(crate) fn binary_search_descending_or_greater<T: Ord>(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,

2
base/src/functions/database.rs
View File

@@ -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 {

2
base/src/functions/date_and_time.rs
View File

@@ -470,7 +470,7 @@ fn parse_datevalue_text(value: &str) -> Result<i32, String> {
}
}
impl Model {
impl<'a> Model<'a> {
fn get_date_serial(
&mut self,
node: &Node,

2
base/src/functions/engineering/bessel.rs
View File

@@ -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);

2
base/src/functions/engineering/bit_operations.rs
View File

@@ -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 {

2
base/src/functions/engineering/complex.rs
View File

@@ -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,

2
base/src/functions/engineering/convert.rs
View File

@@ -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 {

2
base/src/functions/engineering/misc.rs
View File

@@ -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();

2
base/src/functions/engineering/number_basis.rs
View File

@@ -31,7 +31,7 @@ fn from_binary_to_decimal(value: f64) -> Result<i64, String> {
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 {

2
base/src/functions/financial.rs
View File

@@ -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,

2
base/src/functions/information.rs
View File

@@ -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) {

2
base/src/functions/logical.rs
View File

@@ -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)

4
base/src/functions/lookup_and_reference.rs
View File

@@ -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),
);

2
base/src/functions/mathematical.rs
View File

@@ -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 {

2
base/src/functions/mathematical_sum.rs
View File

@@ -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) {

9
base/src/functions/mod.rs
View File

@@ -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,

2
base/src/functions/statistical/beta.rs
View File

@@ -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();

2
base/src/functions/statistical/binom.rs
View File

@@ -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);

2
base/src/functions/statistical/chisq.rs
View File

@@ -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 {

2
base/src/functions/statistical/correl.rs
View File

@@ -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) {

2
base/src/functions/statistical/count_and_average.rs
View File

@@ -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<F>(
&mut self,
args: &[Node],

2
base/src/functions/statistical/covariance.rs
View File

@@ -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],

2
base/src/functions/statistical/devsq.rs
View File

@@ -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() {

2
base/src/functions/statistical/exponential.rs
View File

@@ -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 {

2
base/src/functions/statistical/fisher.rs
View File

@@ -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 {

2
base/src/functions/statistical/gamma.rs
View File

@@ -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);

2
base/src/functions/statistical/gauss.rs
View File

@@ -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);

2
base/src/functions/statistical/geomean.rs
View File

@@ -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);

2
base/src/functions/statistical/hypegeom.rs
View File

@@ -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,

2
base/src/functions/statistical/if_ifs.rs
View File

@@ -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()];

2
base/src/functions/statistical/log_normal.rs
View File

@@ -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],

2
base/src/functions/statistical/normal.rs
View File

@@ -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 {

2
base/src/functions/statistical/pearson.rs
View File

@@ -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) {

2
base/src/functions/statistical/phi.rs
View File

@@ -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 {

2
base/src/functions/statistical/poisson.rs
View File

@@ -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,

2
base/src/functions/statistical/rank_eq_avg.rs
View File

@@ -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,

2
base/src/functions/statistical/standard_dev.rs
View File

@@ -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);

2
base/src/functions/statistical/standardize.rs
View File

@@ -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 {

2
base/src/functions/statistical/t_dist.rs
View File

@@ -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 {

2
base/src/functions/statistical/variance.rs
View File

@@ -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);

2
base/src/functions/statistical/weibull.rs
View File

@@ -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,

2
base/src/functions/statistical/z_test.rs
View File

@@ -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

2
base/src/functions/subtotal.rs
View File

@@ -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,

4
base/src/functions/text.rs
View File

@@ -50,7 +50,7 @@ fn search(search_for: &str, text: &str, start: usize) -> Option<i32> {
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,

2
base/src/functions/xlookup.rs
View File

@@ -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])

16
base/src/language/mod.rs
View File

@@ -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 {
pub fn get_default_language() -> &'static Language {
#[allow(clippy::unwrap_used)]
get_language("en").unwrap().clone()
}
get_language("en").unwrap()
}
static LANGUAGES: OnceLock<HashMap<String, Language>> = OnceLock::new();
@@ -398,7 +396,7 @@ fn get_languages() -> &'static HashMap<String, Language> {
})
}
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}'"))

26
base/src/locale/mod.rs
View File

@@ -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<String>,
pub day_names_short: Vec<String>,
@@ -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<String>,
@@ -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 {
pub fn get_default_locale() -> &'static Locale {
#[allow(clippy::unwrap_used)]
get_locale("en").unwrap().clone()
}
get_locale("en").unwrap()
}
static LOCALES: OnceLock<HashMap<String, Locale>> = OnceLock::new();
@@ -104,7 +102,7 @@ pub fn get_supported_locales() -> Vec<String> {
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}'"))

80
base/src/model.rs
View File

@@ -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<String, usize>,
/// 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<Model, String> {
pub fn from_bytes(s: &[u8], language_id: &'a str) -> Result<Model<'a>, 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<Model, String> {
pub fn from_workbook(workbook: Workbook, language_id: &str) -> Result<Model<'_>, 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(())
}

43
base/src/new_empty.rs
View File

@@ -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<Model, String> {
name: &'a str,
locale_id: &'a str,
timezone: &'a str,
language_id: &'a str,
) -> Result<Model<'a>, 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 {

2
base/src/styles.rs
View File

@@ -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,

2
base/src/test/test_fn_time.rs
View File

@@ -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);

2
base/src/test/test_language.rs
View File

@@ -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()
}

2
base/src/test/test_locale.rs
View File

@@ -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()
}

14
base/src/test/user_model/test_to_from_bytes.rs
View File

@@ -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()));
assert_eq!(
model.get_formatted_cell_value(0, 1, 2),
Ok("=SUM(1,2,3)".to_string())
);
}

4
base/src/test/user_model/util.rs
View File

@@ -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;

4
base/src/test/util.rs
View File

@@ -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()

2
base/src/units.rs
View File

@@ -88,7 +88,7 @@ fn get_units_from_format_string(num_fmt: &str) -> Option<Units> {
}
}
impl Model {
impl<'a> Model<'a> {
fn compute_cell_units(&self, cell_reference: &CellReferenceIndex) -> Option<Units> {
let cell_style_res = &self.get_style_for_cell(
cell_reference.sheet,

2
base/src/user_model/border.rs
View File

@@ -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,

22
base/src/user_model/common.rs
View File

@@ -218,20 +218,20 @@ fn update_style(old_value: &Style, style_path: &str, value: &str) -> Result<Styl
/// # Ok(())
/// # }
/// ```
pub struct UserModel {
pub(crate) model: Model,
pub struct UserModel<'a> {
pub(crate) model: Model<'a>,
history: History,
send_queue: Vec<QueueDiffs>,
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<UserModel, String> {
name: &'a str,
locale_id: &'a str,
timezone: &'a str,
language_id: &'a str,
) -> Result<UserModel<'a>, 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<UserModel, String> {
pub fn from_bytes(s: &[u8], language_id: &'a str) -> Result<UserModel<'a>, 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
}

2
base/src/user_model/ui.rs
View File

@@ -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) {

19
bindings/nodejs/src/model.rs
View File

@@ -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 })
}

16
bindings/nodejs/src/user_model.rs
View File

@@ -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 })
}

25
bindings/python/src/lib.rs
View File

@@ -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);

11
bindings/wasm/src/lib.rs
View File

@@ -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 })
}

2
webapp/IronCalc/src/components/SheetTabBar/SheetTabBar.tsx
View File

@@ -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[];

3
webapp/app.ironcalc.com/frontend/src/components/storage.ts
View File

@@ -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));
}
}

2
xlsx/src/export/test/test_export.rs
View File

@@ -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()
}

8
xlsx/src/import/mod.rs
View File

@@ -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<Model, XlsxError> {
language: &'a str,
) -> Result<Model<'a>, 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<Model, XlsxError> {
pub fn load_from_icalc<'a>(file_name: &str, language_id: &'a str) -> Result<Model<'a>, 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)