From 0be7d9b85acac7e3ea7ca4ffae5abad13f688703 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nicol=C3=A1s=20Hatcher?= Date: Sun, 29 Jun 2025 10:23:32 +0200 Subject: [PATCH] FIX: Make clippy happy --- base/src/cast.rs | 2 +- base/src/expressions/lexer/mod.rs | 6 +-- base/src/expressions/lexer/ranges.rs | 4 +- base/src/expressions/parser/mod.rs | 2 +- base/src/expressions/parser/move_formula.rs | 22 ++++---- base/src/expressions/parser/stringify.rs | 36 ++++++------- base/src/formatter/dates.rs | 6 +-- base/src/formatter/format.rs | 54 +++++++++---------- base/src/formatter/lexer.rs | 6 +-- base/src/functions/engineering/complex.rs | 8 +-- .../src/functions/engineering/number_basis.rs | 18 +++---- base/src/functions/financial.rs | 4 +- base/src/functions/mod.rs | 2 +- base/src/functions/text.rs | 32 +++++------ base/src/functions/util.rs | 2 +- base/src/language/mod.rs | 2 +- base/src/model.rs | 28 +++++----- base/src/new_empty.rs | 16 +++--- base/src/number_format.rs | 2 +- base/src/styles.rs | 2 +- base/src/test/test_fn_or_xor.rs | 2 +- base/src/test/user_model/test_border.rs | 20 ++----- base/src/test/user_model/test_general.rs | 2 +- base/src/test/user_model/util.rs | 12 ++--- base/src/test/util.rs | 2 +- base/src/user_model/common.rs | 14 ++--- base/src/user_model/ui.rs | 14 +++-- xlsx/examples/hello_calc.rs | 4 +- xlsx/src/bin/test.rs | 2 +- xlsx/src/compare.rs | 2 +- xlsx/src/export/doc_props.rs | 21 ++++---- xlsx/src/export/mod.rs | 4 +- xlsx/src/export/worksheets.rs | 2 +- xlsx/src/import/mod.rs | 4 +- xlsx/src/import/styles.rs | 2 +- xlsx/src/import/util.rs | 4 +- xlsx/src/import/workbook.rs | 2 +- xlsx/src/import/worksheets.rs | 41 +++++++------- xlsx/tests/test.rs | 16 +++--- 39 files changed, 200 insertions(+), 224 deletions(-) diff --git a/base/src/cast.rs b/base/src/cast.rs index 0ff8db5..06cb2c9 100644 --- a/base/src/cast.rs +++ b/base/src/cast.rs @@ -159,7 +159,7 @@ impl Model { // FIXME: I think when casting a number we should convert it to_precision(x, 15) // See function Exact match result { - CalcResult::Number(f) => Ok(format!("{}", f)), + CalcResult::Number(f) => Ok(format!("{f}")), CalcResult::String(s) => Ok(s), CalcResult::Boolean(f) => { if f { diff --git a/base/src/expressions/lexer/mod.rs b/base/src/expressions/lexer/mod.rs index d629d0d..4ebfd90 100644 --- a/base/src/expressions/lexer/mod.rs +++ b/base/src/expressions/lexer/mod.rs @@ -142,7 +142,7 @@ impl Lexer { pub fn expect(&mut self, tk: TokenType) -> Result<()> { let nt = self.next_token(); if mem::discriminant(&nt) != mem::discriminant(&tk) { - return Err(self.set_error(&format!("Error, expected {:?}", tk), self.position)); + return Err(self.set_error(&format!("Error, expected {tk:?}"), self.position)); } Ok(()) } @@ -511,7 +511,7 @@ impl Lexer { self.position = position; chars.parse::().map_err(|_| LexerError { position, - message: format!("Failed to parse to int: {}", chars), + message: format!("Failed to parse to int: {chars}"), }) } @@ -573,7 +573,7 @@ impl Lexer { self.position = position; match chars.parse::() { Err(_) => { - Err(self.set_error(&format!("Failed to parse to double: {}", chars), position)) + Err(self.set_error(&format!("Failed to parse to double: {chars}"), position)) } Ok(v) => Ok(v), } diff --git a/base/src/expressions/lexer/ranges.rs b/base/src/expressions/lexer/ranges.rs index b0f5788..a574942 100644 --- a/base/src/expressions/lexer/ranges.rs +++ b/base/src/expressions/lexer/ranges.rs @@ -149,14 +149,14 @@ impl Lexer { Ok(n) => n, Err(_) => { return Err(self - .set_error(&format!("Failed parsing row {}", row_left), position)) + .set_error(&format!("Failed parsing row {row_left}"), position)) } }; let row_right = match row_right.parse::() { Ok(n) => n, Err(_) => { return Err(self - .set_error(&format!("Failed parsing row {}", row_right), position)) + .set_error(&format!("Failed parsing row {row_right}"), position)) } }; if row_left > LAST_ROW { diff --git a/base/src/expressions/parser/mod.rs b/base/src/expressions/parser/mod.rs index 4d655e3..8281cf5 100644 --- a/base/src/expressions/parser/mod.rs +++ b/base/src/expressions/parser/mod.rs @@ -828,7 +828,7 @@ impl Parser { | TokenType::Percent => Node::ParseErrorKind { formula: self.lexer.get_formula(), position: 0, - message: format!("Unexpected token: '{:?}'", next_token), + message: format!("Unexpected token: '{next_token:?}'"), }, TokenType::LeftBracket => Node::ParseErrorKind { formula: self.lexer.get_formula(), diff --git a/base/src/expressions/parser/move_formula.rs b/base/src/expressions/parser/move_formula.rs index 956f742..89954d1 100644 --- a/base/src/expressions/parser/move_formula.rs +++ b/base/src/expressions/parser/move_formula.rs @@ -53,24 +53,24 @@ fn move_function(name: &str, args: &Vec, move_context: &MoveContext) -> St arguments = to_string_moved(el, move_context); } } - format!("{}({})", name, arguments) + format!("{name}({arguments})") } pub(crate) fn to_string_array_node(node: &ArrayNode) -> String { match node { - ArrayNode::Boolean(value) => format!("{}", value).to_ascii_uppercase(), + ArrayNode::Boolean(value) => format!("{value}").to_ascii_uppercase(), ArrayNode::Number(number) => to_excel_precision_str(*number), - ArrayNode::String(value) => format!("\"{}\"", value), - ArrayNode::Error(kind) => format!("{}", kind), + ArrayNode::String(value) => format!("\"{value}\""), + ArrayNode::Error(kind) => format!("{kind}"), } } fn to_string_moved(node: &Node, move_context: &MoveContext) -> String { use self::Node::*; match node { - BooleanKind(value) => format!("{}", value).to_ascii_uppercase(), + BooleanKind(value) => format!("{value}").to_ascii_uppercase(), NumberKind(number) => to_excel_precision_str(*number), - StringKind(value) => format!("\"{}\"", value), + StringKind(value) => format!("\"{value}\""), ReferenceKind { sheet_name, sheet_index, @@ -241,7 +241,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String { full_row, full_column, ); - format!("{}:{}", s1, s2) + format!("{s1}:{s2}") } WrongReferenceKind { sheet_name, @@ -325,7 +325,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String { full_row, full_column, ); - format!("{}:{}", s1, s2) + format!("{s1}:{s2}") } OpRangeKind { left, right } => format!( "{}:{}", @@ -358,7 +358,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String { } _ => to_string_moved(right, move_context), }; - format!("{}{}{}", x, kind, y) + format!("{x}{kind}{y}") } OpPowerKind { left, right } => format!( "{}^{}", @@ -403,7 +403,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String { } // Enclose the whole matrix in braces - format!("{{{}}}", matrix_string) + format!("{{{matrix_string}}}") } DefinedNameKind((name, ..)) => name.to_string(), TableNameKind(name) => name.to_string(), @@ -418,7 +418,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String { OpUnary::Minus => format!("-{}", to_string_moved(right, move_context)), OpUnary::Percentage => format!("{}%", to_string_moved(right, move_context)), }, - ErrorKind(kind) => format!("{}", kind), + ErrorKind(kind) => format!("{kind}"), ParseErrorKind { formula, message: _, diff --git a/base/src/expressions/parser/stringify.rs b/base/src/expressions/parser/stringify.rs index b2b7958..f4bda5d 100644 --- a/base/src/expressions/parser/stringify.rs +++ b/base/src/expressions/parser/stringify.rs @@ -184,16 +184,16 @@ pub(crate) fn stringify_reference( return "#REF!".to_string(); } let mut row_abs = if absolute_row { - format!("${}", row) + format!("${row}") } else { - format!("{}", row) + format!("{row}") }; let column = match crate::expressions::utils::number_to_column(column) { Some(s) => s, None => return "#REF!".to_string(), }; let mut col_abs = if absolute_column { - format!("${}", column) + format!("${column}") } else { column }; @@ -208,27 +208,27 @@ pub(crate) fn stringify_reference( format!("{}!{}{}", quote_name(name), col_abs, row_abs) } None => { - format!("{}{}", col_abs, row_abs) + format!("{col_abs}{row_abs}") } } } None => { let row_abs = if absolute_row { - format!("R{}", row) + format!("R{row}") } else { - format!("R[{}]", row) + format!("R[{row}]") }; let col_abs = if absolute_column { - format!("C{}", column) + format!("C{column}") } else { - format!("C[{}]", column) + format!("C[{column}]") }; match &sheet_name { Some(name) => { format!("{}!{}{}", quote_name(name), row_abs, col_abs) } None => { - format!("{}{}", row_abs, col_abs) + format!("{row_abs}{col_abs}") } } } @@ -256,7 +256,7 @@ fn format_function( arguments = stringify(el, context, displace_data, export_to_excel); } } - format!("{}({})", name, arguments) + format!("{name}({arguments})") } // There is just one representation in the AST (Abstract Syntax Tree) of a formula. @@ -292,9 +292,9 @@ fn stringify( ) -> String { use self::Node::*; match node { - BooleanKind(value) => format!("{}", value).to_ascii_uppercase(), + BooleanKind(value) => format!("{value}").to_ascii_uppercase(), NumberKind(number) => to_excel_precision_str(*number), - StringKind(value) => format!("\"{}\"", value), + StringKind(value) => format!("\"{value}\""), WrongReferenceKind { sheet_name, column, @@ -384,7 +384,7 @@ fn stringify( full_row, full_column, ); - format!("{}:{}", s1, s2) + format!("{s1}:{s2}") } WrongRangeKind { sheet_name, @@ -433,7 +433,7 @@ fn stringify( full_row, full_column, ); - format!("{}:{}", s1, s2) + format!("{s1}:{s2}") } OpRangeKind { left, right } => format!( "{}:{}", @@ -484,7 +484,7 @@ fn stringify( ), _ => stringify(right, context, displace_data, export_to_excel), }; - format!("{}{}{}", x, kind, y) + format!("{x}{kind}{y}") } OpPowerKind { left, right } => { let x = match **left { @@ -547,7 +547,7 @@ fn stringify( stringify(right, context, displace_data, export_to_excel) ), }; - format!("{}^{}", x, y) + format!("{x}^{y}") } InvalidFunctionKind { name, args } => { format_function(name, args, context, displace_data, export_to_excel) @@ -582,7 +582,7 @@ fn stringify( } matrix_string.push_str(&row_string); } - format!("{{{}}}", matrix_string) + format!("{{{matrix_string}}}") } TableNameKind(value) => value.to_string(), DefinedNameKind((name, ..)) => name.to_string(), @@ -601,7 +601,7 @@ fn stringify( ) } }, - ErrorKind(kind) => format!("{}", kind), + ErrorKind(kind) => format!("{kind}"), ParseErrorKind { formula, position: _, diff --git a/base/src/formatter/dates.rs b/base/src/formatter/dates.rs index 0959f06..336ac14 100644 --- a/base/src/formatter/dates.rs +++ b/base/src/formatter/dates.rs @@ -21,14 +21,12 @@ fn is_date_within_range(date: NaiveDate) -> bool { pub fn from_excel_date(days: i64) -> Result { if days < MINIMUM_DATE_SERIAL_NUMBER as i64 { return Err(format!( - "Excel date must be greater than {}", - MINIMUM_DATE_SERIAL_NUMBER + "Excel date must be greater than {MINIMUM_DATE_SERIAL_NUMBER}" )); }; if days > MAXIMUM_DATE_SERIAL_NUMBER as i64 { return Err(format!( - "Excel date must be less than {}", - MAXIMUM_DATE_SERIAL_NUMBER + "Excel date must be less than {MAXIMUM_DATE_SERIAL_NUMBER}" )); }; #[allow(clippy::expect_used)] diff --git a/base/src/formatter/format.rs b/base/src/formatter/format.rs index 6cbf495..582f1f7 100644 --- a/base/src/formatter/format.rs +++ b/base/src/formatter/format.rs @@ -120,7 +120,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form // We should have different codepaths for general formatting and errors let value_abs = value.abs(); if (1.0e-8..1.0e+11).contains(&value_abs) { - let mut text = format!("{:.9}", value); + let mut text = format!("{value:.9}"); text = text.trim_end_matches('0').trim_end_matches('.').to_string(); Formatted { text, @@ -138,7 +138,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form let exponent = value_abs.log10().floor(); value /= 10.0_f64.powf(exponent); let sign = if exponent < 0.0 { '-' } else { '+' }; - let s = format!("{:.5}", value); + let s = format!("{value:.5}"); Formatted { text: format!( "{}E{}{:02}", @@ -167,33 +167,33 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form for token in tokens { match token { TextToken::Literal(c) => { - text = format!("{}{}", text, c); + text = format!("{text}{c}"); } TextToken::Text(t) => { - text = format!("{}{}", text, t); + text = format!("{text}{t}"); } TextToken::Ghost(_) => { // we just leave a whitespace // This is what the TEXT function does - text = format!("{} ", text); + text = format!("{text} "); } TextToken::Spacer(_) => { // we just leave a whitespace // This is what the TEXT function does - text = format!("{} ", text); + text = format!("{text} "); } TextToken::Raw => { - text = format!("{}{}", text, value); + text = format!("{text}{value}"); } TextToken::Digit(_) => {} TextToken::Period => {} TextToken::Day => { let day = date.day() as usize; - text = format!("{}{}", text, day); + text = format!("{text}{day}"); } TextToken::DayPadded => { let day = date.day() as usize; - text = format!("{}{:02}", text, day); + text = format!("{text}{day:02}"); } TextToken::DayNameShort => { let mut day = date.weekday().number_from_monday() as usize; @@ -211,11 +211,11 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form } TextToken::Month => { let month = date.month() as usize; - text = format!("{}{}", text, month); + text = format!("{text}{month}"); } TextToken::MonthPadded => { let month = date.month() as usize; - text = format!("{}{:02}", text, month); + text = format!("{text}{month:02}"); } TextToken::MonthNameShort => { let month = date.month() as usize; @@ -228,7 +228,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form TextToken::MonthLetter => { let month = date.month() as usize; let months_letter = &locale.dates.months_letter[month - 1]; - text = format!("{}{}", text, months_letter); + text = format!("{text}{months_letter}"); } TextToken::YearShort => { text = format!("{}{}", text, date.format("%y")); @@ -247,7 +247,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form ParsePart::Number(p) => { let mut text = "".to_string(); if let Some(c) = p.currency { - text = format!("{}", c); + text = format!("{c}"); } let tokens = &p.tokens; value = value * 100.0_f64.powi(p.percent) / (1000.0_f64.powi(p.comma)); @@ -295,26 +295,26 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form for token in tokens { match token { TextToken::Literal(c) => { - text = format!("{}{}", text, c); + text = format!("{text}{c}"); } TextToken::Text(t) => { - text = format!("{}{}", text, t); + text = format!("{text}{t}"); } TextToken::Ghost(_) => { // we just leave a whitespace // This is what the TEXT function does - text = format!("{} ", text); + text = format!("{text} "); } TextToken::Spacer(_) => { // we just leave a whitespace // This is what the TEXT function does - text = format!("{} ", text); + text = format!("{text} "); } TextToken::Raw => { - text = format!("{}{}", text, value); + text = format!("{text}{value}"); } TextToken::Period => { - text = format!("{}{}", text, decimal_separator); + text = format!("{text}{decimal_separator}"); } TextToken::Digit(digit) => { if digit.number == 'i' { @@ -322,7 +322,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form let index = digit.index; let number_index = ln - digit_count + index; if index == 0 && is_negative { - text = format!("-{}", text); + text = format!("-{text}"); } if ln <= digit_count { // The number of digits is less or equal than the number of digit tokens @@ -347,7 +347,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form } else { "" }; - text = format!("{}{}{}", text, c, sep); + text = format!("{text}{c}{sep}"); } digit_index += 1; } else { @@ -373,18 +373,18 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form if index < fract_part.len() { text = format!("{}{}", text, fract_part[index]); } else if digit.kind == '0' { - text = format!("{}0", text); + text = format!("{text}0"); } else if digit.kind == '?' { - text = format!("{} ", text); + text = format!("{text} "); } } else if digit.number == 'e' { // 3. Exponent part let index = digit.index; if index == 0 { if exponent_is_negative { - text = format!("{}E-", text); + text = format!("{text}E-"); } else { - text = format!("{}E+", text); + text = format!("{text}E+"); } } let number_index = l_exp - (p.exponent_digit_count - index); @@ -400,7 +400,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form exponent_part[number_index as usize] }; - text = format!("{}{}", text, c); + text = format!("{text}{c}"); } } else { for i in 0..number_index + 1 { @@ -614,7 +614,7 @@ pub(crate) fn parse_formatted_number( // check if it is a currency in currencies for currency in currencies { - if let Some(p) = value.strip_prefix(&format!("-{}", currency)) { + if let Some(p) = value.strip_prefix(&format!("-{currency}")) { let (f, options) = parse_number(p.trim())?; if options.is_scientific { return Ok((f, Some(scientific_format.to_string()))); diff --git a/base/src/formatter/lexer.rs b/base/src/formatter/lexer.rs index b99eff4..2cddd22 100644 --- a/base/src/formatter/lexer.rs +++ b/base/src/formatter/lexer.rs @@ -333,7 +333,7 @@ impl Lexer { } else if s == '-' { Token::ScientificMinus } else { - self.set_error(&format!("Unexpected char: {}. Expected + or -", s)); + self.set_error(&format!("Unexpected char: {s}. Expected + or -")); Token::ILLEGAL } } else { @@ -385,14 +385,14 @@ impl Lexer { for c in "eneral".chars() { let cc = self.read_next_char(); if Some(c) != cc { - self.set_error(&format!("Unexpected character: {}", x)); + self.set_error(&format!("Unexpected character: {x}")); return Token::ILLEGAL; } } Token::General } _ => { - self.set_error(&format!("Unexpected character: {}", x)); + self.set_error(&format!("Unexpected character: {x}")); Token::ILLEGAL } }, diff --git a/base/src/functions/engineering/complex.rs b/base/src/functions/engineering/complex.rs index 2ec6015..94321ee 100644 --- a/base/src/functions/engineering/complex.rs +++ b/base/src/functions/engineering/complex.rs @@ -46,18 +46,18 @@ impl fmt::Display for Complex { // it is a bit weird what Excel does but it seems it uses general notation for // numbers > 1e-20 and scientific notation for the rest let y_str = if y.abs() <= 9e-20 { - format!("{:E}", y) + format!("{y:E}") } else if y == 1.0 { "".to_string() } else if y == -1.0 { "-".to_string() } else { - format!("{}", y) + format!("{y}") }; let x_str = if x.abs() <= 9e-20 { - format!("{:E}", x) + format!("{x:E}") } else { - format!("{}", x) + format!("{x}") }; if y == 0.0 && x == 0.0 { write!(f, "0") diff --git a/base/src/functions/engineering/number_basis.rs b/base/src/functions/engineering/number_basis.rs index a2537c3..78344a4 100644 --- a/base/src/functions/engineering/number_basis.rs +++ b/base/src/functions/engineering/number_basis.rs @@ -76,7 +76,7 @@ impl Model { if value < 0 { CalcResult::String(format!("{:0width$X}", HEX_MAX + value, width = 9)) } else { - let result = format!("{:X}", value); + let result = format!("{value:X}"); if let Some(places) = places { if places < result.len() as i32 { return CalcResult::new_error( @@ -120,7 +120,7 @@ impl Model { if value < 0 { CalcResult::String(format!("{:0width$o}", OCT_MAX + value, width = 9)) } else { - let result = format!("{:o}", value); + let result = format!("{value:o}"); if let Some(places) = places { if places < result.len() as i32 { return CalcResult::new_error( @@ -163,7 +163,7 @@ impl Model { if value < 0 { value += 1024; } - let result = format!("{:b}", value); + let result = format!("{value:b}"); if let Some(places) = places { if value_raw > 0.0 && places < result.len() as i32 { return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string()); @@ -202,7 +202,7 @@ impl Model { if value < 0 { value += HEX_MAX; } - let result = format!("{:X}", value); + let result = format!("{value:X}"); if let Some(places) = places { if value_raw > 0.0 && places < result.len() as i32 { return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string()); @@ -242,7 +242,7 @@ impl Model { if value < 0 { value += OCT_MAX; } - let result = format!("{:o}", value); + let result = format!("{value:o}"); if let Some(places) = places { if value_raw > 0.0 && places < result.len() as i32 { return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string()); @@ -301,7 +301,7 @@ impl Model { if value < 0 { value += 1024; } - let result = format!("{:b}", value); + let result = format!("{value:b}"); if let Some(places) = places { if places <= 0 || (value > 0 && places < result.len() as i32) { return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string()); @@ -391,7 +391,7 @@ impl Model { if value < 0 { value += OCT_MAX; } - let result = format!("{:o}", value); + let result = format!("{value:o}"); if let Some(places) = places { if places <= 0 || (value > 0 && places < result.len() as i32) { return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string()); @@ -446,7 +446,7 @@ impl Model { if value < 0 { value += 1024; } - let result = format!("{:b}", value); + let result = format!("{value:b}"); if let Some(places) = places { if value < 512 && places < result.len() as i32 { return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string()); @@ -532,7 +532,7 @@ impl Model { if value < 0 { value += HEX_MAX; } - let result = format!("{:X}", value); + let result = format!("{value:X}"); if let Some(places) = places { if value < HEX_MAX_HALF && places < result.len() as i32 { return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string()); diff --git a/base/src/functions/financial.rs b/base/src/functions/financial.rs index 50f2fb9..8e11ee4 100644 --- a/base/src/functions/financial.rs +++ b/base/src/functions/financial.rs @@ -231,7 +231,7 @@ impl Model { CalcResult::new_error( Error::ERROR, *cell, - format!("Invalid worksheet index: '{}'", sheet), + format!("Invalid worksheet index: '{sheet}'"), ) })? .dimension() @@ -245,7 +245,7 @@ impl Model { CalcResult::new_error( Error::ERROR, *cell, - format!("Invalid worksheet index: '{}'", sheet), + format!("Invalid worksheet index: '{sheet}'"), ) })? .dimension() diff --git a/base/src/functions/mod.rs b/base/src/functions/mod.rs index fa25560..45da025 100644 --- a/base/src/functions/mod.rs +++ b/base/src/functions/mod.rs @@ -1214,7 +1214,7 @@ mod tests { } // We make a list with their functions names, but we escape ".": ERROR.TYPE => ERRORTYPE let iter_list = Function::into_iter() - .map(|f| format!("{}", f).replace('.', "")) + .map(|f| format!("{f}").replace('.', "")) .collect::>(); let len = iter_list.len(); diff --git a/base/src/functions/text.rs b/base/src/functions/text.rs index d85db6f..d681a68 100644 --- a/base/src/functions/text.rs +++ b/base/src/functions/text.rs @@ -55,14 +55,14 @@ impl Model { let mut result = "".to_string(); for arg in args { match self.evaluate_node_in_context(arg, cell) { - CalcResult::String(value) => result = format!("{}{}", result, value), - CalcResult::Number(value) => result = format!("{}{}", result, value), + CalcResult::String(value) => result = format!("{result}{value}"), + CalcResult::Number(value) => result = format!("{result}{value}"), CalcResult::EmptyCell | CalcResult::EmptyArg => {} CalcResult::Boolean(value) => { if value { - result = format!("{}TRUE", result); + result = format!("{result}TRUE"); } else { - result = format!("{}FALSE", result); + result = format!("{result}FALSE"); } } error @ CalcResult::Error { .. } => return error, @@ -82,16 +82,16 @@ impl Model { column, }) { CalcResult::String(value) => { - result = format!("{}{}", result, value); + result = format!("{result}{value}"); } CalcResult::Number(value) => { - result = format!("{}{}", result, value) + result = format!("{result}{value}") } CalcResult::Boolean(value) => { if value { - result = format!("{}TRUE", result); + result = format!("{result}TRUE"); } else { - result = format!("{}FALSE", result); + result = format!("{result}FALSE"); } } error @ CalcResult::Error { .. } => return error, @@ -282,7 +282,7 @@ impl Model { pub(crate) fn fn_len(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() == 1 { let s = match self.evaluate_node_in_context(&args[0], cell) { - CalcResult::Number(v) => format!("{}", v), + CalcResult::Number(v) => format!("{v}"), CalcResult::String(v) => v, CalcResult::Boolean(b) => { if b { @@ -317,7 +317,7 @@ impl Model { pub(crate) fn fn_trim(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() == 1 { let s = match self.evaluate_node_in_context(&args[0], cell) { - CalcResult::Number(v) => format!("{}", v), + CalcResult::Number(v) => format!("{v}"), CalcResult::String(v) => v, CalcResult::Boolean(b) => { if b { @@ -352,7 +352,7 @@ impl Model { pub(crate) fn fn_lower(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() == 1 { let s = match self.evaluate_node_in_context(&args[0], cell) { - CalcResult::Number(v) => format!("{}", v), + CalcResult::Number(v) => format!("{v}"), CalcResult::String(v) => v, CalcResult::Boolean(b) => { if b { @@ -387,7 +387,7 @@ impl Model { pub(crate) fn fn_unicode(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() == 1 { let s = match self.evaluate_node_in_context(&args[0], cell) { - CalcResult::Number(v) => format!("{}", v), + CalcResult::Number(v) => format!("{v}"), CalcResult::String(v) => v, CalcResult::Boolean(b) => { if b { @@ -441,7 +441,7 @@ impl Model { pub(crate) fn fn_upper(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult { if args.len() == 1 { let s = match self.evaluate_node_in_context(&args[0], cell) { - CalcResult::Number(v) => format!("{}", v), + CalcResult::Number(v) => format!("{v}"), CalcResult::String(v) => v, CalcResult::Boolean(b) => { if b { @@ -478,7 +478,7 @@ impl Model { return CalcResult::new_args_number_error(cell); } let s = match self.evaluate_node_in_context(&args[0], cell) { - CalcResult::Number(v) => format!("{}", v), + CalcResult::Number(v) => format!("{v}"), CalcResult::String(v) => v, CalcResult::Boolean(b) => { if b { @@ -560,7 +560,7 @@ impl Model { return CalcResult::new_args_number_error(cell); } let s = match self.evaluate_node_in_context(&args[0], cell) { - CalcResult::Number(v) => format!("{}", v), + CalcResult::Number(v) => format!("{v}"), CalcResult::String(v) => v, CalcResult::Boolean(b) => { if b { @@ -642,7 +642,7 @@ impl Model { return CalcResult::new_args_number_error(cell); } let s = match self.evaluate_node_in_context(&args[0], cell) { - CalcResult::Number(v) => format!("{}", v), + CalcResult::Number(v) => format!("{v}"), CalcResult::String(v) => v, CalcResult::Boolean(b) => { if b { diff --git a/base/src/functions/util.rs b/base/src/functions/util.rs index fb04a40..dea96e8 100644 --- a/base/src/functions/util.rs +++ b/base/src/functions/util.rs @@ -110,7 +110,7 @@ pub(crate) fn from_wildcard_to_regex( // And we have a valid Perl regex! (As Kim Kardashian said before me: "I know, right?") if exact { - return regex::Regex::new(&format!("^{}$", reg)); + return regex::Regex::new(&format!("^{reg}$")); } regex::Regex::new(reg) } diff --git a/base/src/language/mod.rs b/base/src/language/mod.rs index ef362c4..40fe49e 100644 --- a/base/src/language/mod.rs +++ b/base/src/language/mod.rs @@ -39,6 +39,6 @@ static LANGUAGES: Lazy> = Lazy::new(|| { pub fn get_language(id: &str) -> Result<&Language, String> { let language = LANGUAGES .get(id) - .ok_or(format!("Language is not supported: '{}'", id))?; + .ok_or(format!("Language is not supported: '{id}'"))?; Ok(language) } diff --git a/base/src/model.rs b/base/src/model.rs index f2879cb..d55e95a 100644 --- a/base/src/model.rs +++ b/base/src/model.rs @@ -215,7 +215,7 @@ impl Model { _ => CalcResult::new_error( Error::ERROR, cell, - format!("Error with Implicit Intersection in cell {:?}", cell), + format!("Error with Implicit Intersection in cell {cell:?}"), ), }, _ => self.evaluate_node_in_context(node, cell), @@ -355,7 +355,7 @@ impl Model { return s; } }; - let result = format!("{}{}", l, r); + let result = format!("{l}{r}"); CalcResult::String(result) } OpProductKind { kind, left, right } => match kind { @@ -375,7 +375,7 @@ impl Model { } FunctionKind { kind, args } => self.evaluate_function(kind, args, cell), InvalidFunctionKind { name, args: _ } => { - CalcResult::new_error(Error::ERROR, cell, format!("Invalid function: {}", name)) + CalcResult::new_error(Error::ERROR, cell, format!("Invalid function: {name}")) } ArrayKind(s) => CalcResult::Array(s.to_owned()), DefinedNameKind((name, scope, _)) => { @@ -391,26 +391,26 @@ impl Model { ParsedDefinedName::InvalidDefinedNameFormula => CalcResult::new_error( Error::NAME, cell, - format!("Defined name \"{}\" is not a reference.", name), + format!("Defined name \"{name}\" is not a reference."), ), } } else { CalcResult::new_error( Error::NAME, cell, - format!("Defined name \"{}\" not found.", name), + format!("Defined name \"{name}\" not found."), ) } } TableNameKind(s) => CalcResult::new_error( Error::NAME, cell, - format!("table name \"{}\" not supported.", s), + format!("table name \"{s}\" not supported."), ), WrongVariableKind(s) => CalcResult::new_error( Error::NAME, cell, - format!("Variable name \"{}\" not found.", s), + format!("Variable name \"{s}\" not found."), ), CompareKind { kind, left, right } => { let l = self.evaluate_node_in_context(left, cell); @@ -487,7 +487,7 @@ impl Model { } => CalcResult::new_error( Error::ERROR, cell, - format!("Error parsing {}: {}", formula, message), + format!("Error parsing {formula}: {message}"), ), EmptyArgKind => CalcResult::EmptyArg, ImplicitIntersection { @@ -500,7 +500,7 @@ impl Model { None => CalcResult::new_error( Error::VALUE, cell, - format!("Error with Implicit Intersection in cell {:?}", cell), + format!("Error with Implicit Intersection in cell {cell:?}"), ), } } @@ -697,7 +697,7 @@ impl Model { worksheet.color = Some(color.to_string()); return Ok(()); } - Err(format!("Invalid color: {}", color)) + Err(format!("Invalid color: {color}")) } /// Changes the visibility of a sheet @@ -1027,7 +1027,7 @@ impl Model { let source_sheet_name = self .workbook .worksheet(source.sheet) - .map_err(|e| format!("Could not find source worksheet: {}", e))? + .map_err(|e| format!("Could not find source worksheet: {e}"))? .get_name(); if source.sheet != area.sheet { return Err("Source and area are in different sheets".to_string()); @@ -1041,7 +1041,7 @@ impl Model { let target_sheet_name = self .workbook .worksheet(target.sheet) - .map_err(|e| format!("Could not find target worksheet: {}", e))? + .map_err(|e| format!("Could not find target worksheet: {e}"))? .get_name(); if let Some(formula) = value.strip_prefix('=') { let cell_reference = CellReferenceRC { @@ -1061,7 +1061,7 @@ impl Model { column_delta: target.column - source.column, }, ); - Ok(format!("={}", formula_str)) + Ok(format!("={formula_str}")) } else { Ok(value.to_string()) } @@ -1538,7 +1538,7 @@ impl Model { // If the formula fails to parse try adding a parenthesis // SUM(A1:A3 => SUM(A1:A3) if let Node::ParseErrorKind { .. } = parsed_formula { - let new_parsed_formula = self.parser.parse(&format!("{})", formula), &cell_reference); + let new_parsed_formula = self.parser.parse(&format!("{formula})"), &cell_reference); match new_parsed_formula { Node::ParseErrorKind { .. } => {} _ => parsed_formula = new_parsed_formula, diff --git a/base/src/new_empty.rs b/base/src/new_empty.rs index a07b30e..f861914 100644 --- a/base/src/new_empty.rs +++ b/base/src/new_empty.rs @@ -168,11 +168,11 @@ impl Model { .get_worksheet_names() .iter() .map(|s| s.to_uppercase()) - .any(|x| x == format!("{}{}", base_name_uppercase, index)) + .any(|x| x == format!("{base_name_uppercase}{index}")) { index += 1; } - let sheet_name = format!("{}{}", base_name, index); + let sheet_name = format!("{base_name}{index}"); // Now we need a sheet_id let sheet_id = self.get_new_sheet_id(); let view_ids: Vec<&u32> = self.workbook.views.keys().collect(); @@ -192,7 +192,7 @@ impl Model { sheet_id: Option, ) -> Result<(), String> { if !is_valid_sheet_name(sheet_name) { - return Err(format!("Invalid name for a sheet: '{}'", sheet_name)); + return Err(format!("Invalid name for a sheet: '{sheet_name}'")); } if self .workbook @@ -234,7 +234,7 @@ impl Model { if let Some(sheet_index) = self.get_sheet_index_by_name(old_name) { return self.rename_sheet_by_index(sheet_index, new_name); } - Err(format!("Could not find sheet {}", old_name)) + Err(format!("Could not find sheet {old_name}")) } /// Renames a sheet and updates all existing references to that sheet. @@ -248,10 +248,10 @@ impl Model { new_name: &str, ) -> Result<(), String> { if !is_valid_sheet_name(new_name) { - return Err(format!("Invalid name for a sheet: '{}'.", new_name)); + return Err(format!("Invalid name for a sheet: '{new_name}'.")); } if self.get_sheet_index_by_name(new_name).is_some() { - return Err(format!("Sheet already exists: '{}'.", new_name)); + return Err(format!("Sheet already exists: '{new_name}'.")); } // Gets the new name and checks that a sheet with that index exists let old_name = self.workbook.worksheet(sheet_index)?.get_name(); @@ -362,14 +362,14 @@ impl Model { }; let locale = match get_locale(locale_id) { Ok(l) => l.clone(), - Err(_) => return Err(format!("Invalid locale: {}", locale_id)), + Err(_) => return Err(format!("Invalid locale: {locale_id}")), }; let milliseconds = get_milliseconds_since_epoch(); let seconds = milliseconds / 1000; let dt = match DateTime::from_timestamp(seconds, 0) { Some(s) => s, - None => return Err(format!("Invalid timestamp: {}", milliseconds)), + None => return Err(format!("Invalid timestamp: {milliseconds}")), }; // "2020-08-06T21:20:53Z let now = dt.format("%Y-%m-%dT%H:%M:%SZ").to_string(); diff --git a/base/src/number_format.rs b/base/src/number_format.rs index 6fcf295..73376ae 100644 --- a/base/src/number_format.rs +++ b/base/src/number_format.rs @@ -126,7 +126,7 @@ pub fn to_precision_str(value: f64, precision: usize) -> String { let exponent = value.abs().log10().floor(); let base = value / 10.0_f64.powf(exponent); let base = format!("{0:.1$}", base, precision - 1); - let value = format!("{}e{}", base, exponent).parse::().unwrap_or({ + let value = format!("{base}e{exponent}").parse::().unwrap_or({ // TODO: do this in a way that does not require a possible error 0.0 }); diff --git a/base/src/styles.rs b/base/src/styles.rs index dd95aeb..ca7b474 100644 --- a/base/src/styles.rs +++ b/base/src/styles.rs @@ -154,7 +154,7 @@ impl Styles { return Ok(cell_style.xf_id); } } - Err(format!("Style '{}' not found", style_name)) + Err(format!("Style '{style_name}' not found")) } pub fn create_named_style(&mut self, style_name: &str, style: &Style) -> Result<(), String> { diff --git a/base/src/test/test_fn_or_xor.rs b/base/src/test/test_fn_or_xor.rs index 9630a63..b4338c3 100644 --- a/base/src/test/test_fn_or_xor.rs +++ b/base/src/test/test_fn_or_xor.rs @@ -174,7 +174,7 @@ fn fn_or_xor_no_arguments() { println!("Testing function: {func}"); let mut model = new_empty_model(); - model._set("A1", &format!("={}()", func)); + model._set("A1", &format!("={func}()")); model.evaluate(); assert_eq!(model._get_text("A1"), *"#ERROR!"); } diff --git a/base/src/test/user_model/test_border.rs b/base/src/test/user_model/test_border.rs index a37ff0a..7e8aeab 100644 --- a/base/src/test/user_model/test_border.rs +++ b/base/src/test/user_model/test_border.rs @@ -50,10 +50,7 @@ fn check_borders(model: &UserModel) { assert_eq!( Some(top_border), top_cell_style.border.bottom, - "(Top). Sheet: {}, row: {}, column: {}", - sheet, - row, - column + "(Top). Sheet: {sheet}, row: {row}, column: {column}" ); } } @@ -65,10 +62,7 @@ fn check_borders(model: &UserModel) { assert_eq!( Some(right_border), right_cell_style.border.left, - "(Right). Sheet: {}, row: {}, column: {}", - sheet, - row, - column + "(Right). Sheet: {sheet}, row: {row}, column: {column}" ); } } @@ -80,10 +74,7 @@ fn check_borders(model: &UserModel) { assert_eq!( Some(bottom_border), bottom_cell_style.border.top, - "(Bottom). Sheet: {}, row: {}, column: {}", - sheet, - row, - column + "(Bottom). Sheet: {sheet}, row: {row}, column: {column}" ); } } @@ -94,10 +85,7 @@ fn check_borders(model: &UserModel) { assert_eq!( Some(left_border), left_cell_style.border.right, - "(Left). Sheet: {}, row: {}, column: {}", - sheet, - row, - column + "(Left). Sheet: {sheet}, row: {row}, column: {column}" ); } } diff --git a/base/src/test/user_model/test_general.rs b/base/src/test/user_model/test_general.rs index dc4e60b..d54b0ef 100644 --- a/base/src/test/user_model/test_general.rs +++ b/base/src/test/user_model/test_general.rs @@ -26,7 +26,7 @@ fn set_user_input_errors() { #[test] fn user_model_debug_message() { let model = UserModel::new_empty("model", "en", "UTC").unwrap(); - let s = &format!("{:?}", model); + let s = &format!("{model:?}"); assert_eq!(s, "UserModel"); } diff --git a/base/src/test/user_model/util.rs b/base/src/test/user_model/util.rs index 877e7e6..cafbe64 100644 --- a/base/src/test/user_model/util.rs +++ b/base/src/test/user_model/util.rs @@ -11,11 +11,10 @@ impl UserModel { r##"{{ "item": {{ "style": "thin", - "color": "{}" + "color": "{color}" }}, "type": "All" - }}"##, - color + }}"## )) .unwrap(); let range = &Area { @@ -40,11 +39,10 @@ impl UserModel { r##"{{ "item": {{ "style": "thin", - "color": "{}" + "color": "{color}" }}, - "type": "{}" - }}"##, - color, kind + "type": "{kind}" + }}"## )) .unwrap(); let range = &Area { diff --git a/base/src/test/util.rs b/base/src/test/util.rs index 737798a..e50e347 100644 --- a/base/src/test/util.rs +++ b/base/src/test/util.rs @@ -13,7 +13,7 @@ impl Model { if cell.contains('!') { self.parse_reference(cell).unwrap() } else { - self.parse_reference(&format!("Sheet1!{}", cell)).unwrap() + self.parse_reference(&format!("Sheet1!{cell}")).unwrap() } } pub fn _set(&mut self, cell: &str, value: &str) { diff --git a/base/src/user_model/common.rs b/base/src/user_model/common.rs index 0b4b172..d89428a 100644 --- a/base/src/user_model/common.rs +++ b/base/src/user_model/common.rs @@ -1487,10 +1487,10 @@ impl UserModel { return Err(format!("Invalid row: '{first_row}'")); } if !is_valid_column_number(last_column) { - return Err(format!("Invalid column: '{}'", last_column)); + return Err(format!("Invalid column: '{last_column}'")); } if !is_valid_row(last_row) { - return Err(format!("Invalid row: '{}'", last_row)); + return Err(format!("Invalid row: '{last_row}'")); } if !is_valid_row(to_column) { @@ -1623,15 +1623,15 @@ impl UserModel { text_row.push(text); } wtr.write_record(text_row) - .map_err(|e| format!("Error while processing csv: {}", e))?; + .map_err(|e| format!("Error while processing csv: {e}"))?; data.insert(row, data_row); } let csv = String::from_utf8( wtr.into_inner() - .map_err(|e| format!("Processing error: '{}'", e))?, + .map_err(|e| format!("Processing error: '{e}'"))?, ) - .map_err(|e| format!("Error converting from utf8: '{}'", e))?; + .map_err(|e| format!("Error converting from utf8: '{e}'"))?; Ok(Clipboard { csv, @@ -2391,7 +2391,7 @@ mod tests { VerticalAlignment::Top, ]; for a in all { - assert_eq!(vertical(&format!("{}", a)), Ok(a)); + assert_eq!(vertical(&format!("{a}")), Ok(a)); } } @@ -2408,7 +2408,7 @@ mod tests { HorizontalAlignment::Right, ]; for a in all { - assert_eq!(horizontal(&format!("{}", a)), Ok(a)); + assert_eq!(horizontal(&format!("{a}")), Ok(a)); } } } diff --git a/base/src/user_model/ui.rs b/base/src/user_model/ui.rs index b217b1b..bfb3509 100644 --- a/base/src/user_model/ui.rs +++ b/base/src/user_model/ui.rs @@ -76,7 +76,7 @@ impl UserModel { /// Sets the the selected sheet pub fn set_selected_sheet(&mut self, sheet: u32) -> Result<(), String> { if self.model.workbook.worksheet(sheet).is_err() { - return Err(format!("Invalid worksheet index {}", sheet)); + return Err(format!("Invalid worksheet index {sheet}")); } if let Some(view) = self.model.workbook.views.get_mut(&0) { view.sheet = sheet; @@ -98,7 +98,7 @@ impl UserModel { return Err(format!("Invalid row: '{row}'")); } if self.model.workbook.worksheet(sheet).is_err() { - return Err(format!("Invalid worksheet index {}", sheet)); + return Err(format!("Invalid worksheet index {sheet}")); } if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) { if let Some(view) = worksheet.views.get_mut(&0) { @@ -138,7 +138,7 @@ impl UserModel { return Err(format!("Invalid row: '{end_row}'")); } if self.model.workbook.worksheet(sheet).is_err() { - return Err(format!("Invalid worksheet index {}", sheet)); + return Err(format!("Invalid worksheet index {sheet}")); } if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) { if let Some(view) = worksheet.views.get_mut(&0) { @@ -147,14 +147,12 @@ impl UserModel { // The selected cells must be on one of the corners of the selected range: if selected_row != start_row && selected_row != end_row { return Err(format!( - "The selected cells is not in one of the corners. Row: '{}' and row range '({}, {})'", - selected_row, start_row, end_row + "The selected cells is not in one of the corners. Row: '{selected_row}' and row range '({start_row}, {end_row})'" )); } if selected_column != start_column && selected_column != end_column { return Err(format!( - "The selected cells is not in one of the corners. Column '{}' and column range '({}, {})'", - selected_column, start_column, end_column + "The selected cells is not in one of the corners. Column '{selected_column}' and column range '({start_column}, {end_column})'" )); } view.range = [start_row, start_column, end_row, end_column]; @@ -307,7 +305,7 @@ impl UserModel { return Err(format!("Invalid row: '{top_row}'")); } if self.model.workbook.worksheet(sheet).is_err() { - return Err(format!("Invalid worksheet index {}", sheet)); + return Err(format!("Invalid worksheet index {sheet}")); } if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) { if let Some(view) = worksheet.views.get_mut(&0) { diff --git a/xlsx/examples/hello_calc.rs b/xlsx/examples/hello_calc.rs index 085d2c8..f3478d2 100644 --- a/xlsx/examples/hello_calc.rs +++ b/xlsx/examples/hello_calc.rs @@ -9,14 +9,14 @@ fn main() -> Result<(), Box> { for row in 1..100 { for column in 1..100 { let value = row * column; - model.set_user_input(0, row, column, format!("{}", value))?; + model.set_user_input(0, row, column, format!("{value}"))?; } } // Adds a new sheet model.add_sheet("Calculation")?; // column 100 is CV let last_column = number_to_column(100).ok_or("Invalid column number")?; - let formula = format!("=SUM(Sheet1!A1:{}100)", last_column); + let formula = format!("=SUM(Sheet1!A1:{last_column}100)"); model.set_user_input(1, 1, 1, formula)?; // evaluates diff --git a/xlsx/src/bin/test.rs b/xlsx/src/bin/test.rs index 3dc2ef5..b35e7e2 100644 --- a/xlsx/src/bin/test.rs +++ b/xlsx/src/bin/test.rs @@ -22,7 +22,7 @@ fn main() { let file_name = &args[1]; println!("Testing file: {file_name}"); if let Err(message) = test_file(file_name) { - println!("{}", message); + println!("{message}"); panic!("Model was evaluated inconsistently with XLSX data.") } diff --git a/xlsx/src/compare.rs b/xlsx/src/compare.rs index 09798a1..4a99930 100644 --- a/xlsx/src/compare.rs +++ b/xlsx/src/compare.rs @@ -176,7 +176,7 @@ pub(crate) fn compare_models(m1: &Model, m2: &Model) -> Result<(), String> { diff.reason ); } - Err(format!("Models are different: {}", message)) + Err(format!("Models are different: {message}")) } } Err(r) => Err(format!("Models are different: {}", r.message)), diff --git a/xlsx/src/export/doc_props.rs b/xlsx/src/export/doc_props.rs index ad6f2f5..2c885d2 100644 --- a/xlsx/src/export/doc_props.rs +++ b/xlsx/src/export/doc_props.rs @@ -19,10 +19,9 @@ pub(crate) fn get_app_xml(_: &Workbook) -> String { " \ - {}\ - {}\ -", - APPLICATION, APP_VERSION + {APPLICATION}\ + {APP_VERSION}\ +" ) } @@ -40,8 +39,7 @@ pub(crate) fn get_core_xml(workbook: &Workbook, milliseconds: i64) -> Result s, None => { return Err(XlsxError::Xml(format!( - "Invalid timestamp: {}", - milliseconds + "Invalid timestamp: {milliseconds}" ))) } }; @@ -54,16 +52,15 @@ pub(crate) fn get_core_xml(workbook: &Workbook, milliseconds: i64) -> Result \ \ -{}\ +{creator}\ \ \ -{}\ +{last_modified_by}\ \ -{}\ -{}\ +{created}\ +{last_modified}\ \ \ -", - creator, last_modified_by, created, last_modified +" )) } diff --git a/xlsx/src/export/mod.rs b/xlsx/src/export/mod.rs index 00c3ba4..cda06a7 100644 --- a/xlsx/src/export/mod.rs +++ b/xlsx/src/export/mod.rs @@ -59,7 +59,7 @@ fn get_content_types_xml(workbook: &Workbook) -> String { pub fn save_to_xlsx(model: &Model, file_name: &str) -> Result<(), XlsxError> { let file_path = std::path::Path::new(&file_name); if file_path.exists() { - return Err(XlsxError::IO(format!("file {} already exists", file_name))); + return Err(XlsxError::IO(format!("file {file_name} already exists"))); } let file = fs::File::create(file_path).unwrap(); let writer = BufWriter::new(file); @@ -140,7 +140,7 @@ pub fn save_xlsx_to_writer(model: &Model, writer: W) -> Result< pub fn save_to_icalc(model: &Model, file_name: &str) -> Result<(), XlsxError> { let file_path = std::path::Path::new(&file_name); if file_path.exists() { - return Err(XlsxError::IO(format!("file {} already exists", file_name))); + return Err(XlsxError::IO(format!("file {file_name} already exists"))); } let s = bitcode::encode(&model.workbook); let mut file = fs::File::create(file_path)?; diff --git a/xlsx/src/export/worksheets.rs b/xlsx/src/export/worksheets.rs index 7bf6fbe..01eabe5 100644 --- a/xlsx/src/export/worksheets.rs +++ b/xlsx/src/export/worksheets.rs @@ -35,7 +35,7 @@ fn get_cell_style_attribute(s: i32) -> String { if s == 0 { "".to_string() } else { - format!(" s=\"{}\"", s) + format!(" s=\"{s}\"") } } diff --git a/xlsx/src/import/mod.rs b/xlsx/src/import/mod.rs index 7ca509e..c1065fc 100644 --- a/xlsx/src/import/mod.rs +++ b/xlsx/src/import/mod.rs @@ -148,8 +148,8 @@ pub fn load_from_xlsx(file_name: &str, locale: &str, tz: &str) -> Result Result { let contents = fs::read(file_name) - .map_err(|e| XlsxError::IO(format!("Could not extract workbook name: {}", e)))?; + .map_err(|e| XlsxError::IO(format!("Could not extract workbook name: {e}")))?; let workbook: Workbook = bitcode::decode(&contents) - .map_err(|e| XlsxError::IO(format!("Failed to decode file: {}", e)))?; + .map_err(|e| XlsxError::IO(format!("Failed to decode file: {e}")))?; Model::from_workbook(workbook).map_err(XlsxError::Workbook) } diff --git a/xlsx/src/import/styles.rs b/xlsx/src/import/styles.rs index f682dc8..70cf0bb 100644 --- a/xlsx/src/import/styles.rs +++ b/xlsx/src/import/styles.rs @@ -142,7 +142,7 @@ pub(super) fn load_styles( } "charset" => {} _ => { - println!("Unexpected feature {:?}", feature); + println!("Unexpected feature {feature:?}"); } } } diff --git a/xlsx/src/import/util.rs b/xlsx/src/import/util.rs index c9626e4..98c3615 100644 --- a/xlsx/src/import/util.rs +++ b/xlsx/src/import/util.rs @@ -21,7 +21,7 @@ where { let attr_name = attr_name.into(); node.attribute(attr_name) - .ok_or_else(|| XlsxError::Xml(format!("Missing \"{:?}\" XML attribute", attr_name))) + .ok_or_else(|| XlsxError::Xml(format!("Missing \"{attr_name:?}\" XML attribute"))) } pub(super) fn get_value_or_default(node: &Node, tag_name: &str, default: &str) -> String { @@ -64,7 +64,7 @@ pub(super) fn get_color(node: Node) -> Result, XlsxError> { // A boolean value indicating the color is automatic and system color dependent. Ok(None) } else { - println!("Unexpected color node {:?}", node); + println!("Unexpected color node {node:?}"); Ok(None) } } diff --git a/xlsx/src/import/workbook.rs b/xlsx/src/import/workbook.rs index 490ab28..3a4267f 100644 --- a/xlsx/src/import/workbook.rs +++ b/xlsx/src/import/workbook.rs @@ -40,7 +40,7 @@ pub(super) fn load_workbook( Some("visible") | None => SheetState::Visible, Some("hidden") => SheetState::Hidden, Some("veryHidden") => SheetState::VeryHidden, - Some(state) => return Err(XlsxError::Xml(format!("Unknown sheet state: {}", state))), + Some(state) => return Err(XlsxError::Xml(format!("Unknown sheet state: {state}"))), }; sheets.push(Sheet { name, diff --git a/xlsx/src/import/worksheets.rs b/xlsx/src/import/worksheets.rs index 322c9dc..de7a048 100644 --- a/xlsx/src/import/worksheets.rs +++ b/xlsx/src/import/worksheets.rs @@ -81,7 +81,7 @@ fn parse_cell_reference(cell: &str) -> Result<(i32, i32), String> { if let Some(r) = parse_reference_a1(cell) { Ok((r.row, r.column)) } else { - Err(format!("Invalid cell reference: '{}'", cell)) + Err(format!("Invalid cell reference: '{cell}'")) } } @@ -91,17 +91,17 @@ fn parse_range(range: &str) -> Result<(i32, i32, i32, i32), String> { if let Some(r) = parse_reference_a1(parts[0]) { Ok((r.row, r.column, r.row, r.column)) } else { - Err(format!("Invalid range: '{}'", range)) + Err(format!("Invalid range: '{range}'")) } } else if parts.len() == 2 { match (parse_reference_a1(parts[0]), parse_reference_a1(parts[1])) { (Some(left), Some(right)) => { return Ok((left.row, left.column, right.row, right.column)); } - _ => return Err(format!("Invalid range: '{}'", range)), + _ => return Err(format!("Invalid range: '{range}'")), } } else { - return Err(format!("Invalid range: '{}'", range)); + return Err(format!("Invalid range: '{range}'")); } } @@ -390,7 +390,7 @@ fn get_cell_from_excel( } "d" => { // Not implemented - println!("Invalid type (d) in {}!{}", sheet_name, cell_ref); + println!("Invalid type (d) in {sheet_name}!{cell_ref}"); Cell::ErrorCell { ei: Error::NIMPL, s: cell_style, @@ -398,7 +398,7 @@ fn get_cell_from_excel( } "inlineStr" => { // Not implemented - println!("Invalid type (inlineStr) in {}!{}", sheet_name, cell_ref); + println!("Invalid type (inlineStr) in {sheet_name}!{cell_ref}"); Cell::ErrorCell { ei: Error::NIMPL, s: cell_style, @@ -408,8 +408,7 @@ fn get_cell_from_excel( _ => { // error println!( - "Unexpected type ({}) in {}!{}", - cell_type, sheet_name, cell_ref + "Unexpected type ({cell_type}) in {sheet_name}!{cell_ref}" ); Cell::ErrorCell { ei: Error::ERROR, @@ -444,15 +443,15 @@ fn get_cell_from_excel( f: formula_index, ei: get_error_by_english_name(error_name).unwrap_or(Error::ERROR), s: cell_style, - o: format!("{}!{}", sheet_name, cell_ref), + o: format!("{sheet_name}!{cell_ref}"), m: cell_value.unwrap_or("#ERROR!").to_string(), } } "s" => { // Not implemented - let o = format!("{}!{}", sheet_name, cell_ref); + let o = format!("{sheet_name}!{cell_ref}"); let m = Error::NIMPL.to_string(); - println!("Invalid type (s) in {}!{}", sheet_name, cell_ref); + println!("Invalid type (s) in {sheet_name}!{cell_ref}"); Cell::CellFormulaError { f: formula_index, ei: Error::NIMPL, @@ -471,8 +470,8 @@ fn get_cell_from_excel( } "d" => { // Not implemented - println!("Invalid type (d) in {}!{}", sheet_name, cell_ref); - let o = format!("{}!{}", sheet_name, cell_ref); + println!("Invalid type (d) in {sheet_name}!{cell_ref}"); + let o = format!("{sheet_name}!{cell_ref}"); let m = Error::NIMPL.to_string(); Cell::CellFormulaError { f: formula_index, @@ -484,9 +483,9 @@ fn get_cell_from_excel( } "inlineStr" => { // Not implemented - let o = format!("{}!{}", sheet_name, cell_ref); + let o = format!("{sheet_name}!{cell_ref}"); let m = Error::NIMPL.to_string(); - println!("Invalid type (inlineStr) in {}!{}", sheet_name, cell_ref); + println!("Invalid type (inlineStr) in {sheet_name}!{cell_ref}"); Cell::CellFormulaError { f: formula_index, ei: Error::NIMPL, @@ -498,10 +497,9 @@ fn get_cell_from_excel( _ => { // error println!( - "Unexpected type ({}) in {}!{}", - cell_type, sheet_name, cell_ref + "Unexpected type ({cell_type}) in {sheet_name}!{cell_ref}" ); - let o = format!("{}!{}", sheet_name, cell_ref); + let o = format!("{sheet_name}!{cell_ref}"); let m = Error::ERROR.to_string(); Cell::CellFormulaError { f: formula_index, @@ -886,7 +884,7 @@ pub(super) fn load_sheet( Some(_) => { // It's the mother cell. We do not use the ref attribute in IronCalc let formula = fs[0].text().unwrap_or("").to_string(); - let context = format!("{}!{}", sheet_name, cell_ref); + let context = format!("{sheet_name}!{cell_ref}"); let formula = from_a1_to_rc( formula, worksheets, @@ -949,7 +947,7 @@ pub(super) fn load_sheet( } // Its a cell with a simple formula let formula = fs[0].text().unwrap_or("").to_string(); - let context = format!("{}!{}", sheet_name, cell_ref); + let context = format!("{sheet_name}!{cell_ref}"); let formula = from_a1_to_rc( formula, worksheets, @@ -968,8 +966,7 @@ pub(super) fn load_sheet( } _ => { return Err(XlsxError::Xml(format!( - "Invalid formula type {:?}.", - formula_type, + "Invalid formula type {formula_type:?}.", ))); } } diff --git a/xlsx/tests/test.rs b/xlsx/tests/test.rs index 0845da5..f86ec91 100644 --- a/xlsx/tests/test.rs +++ b/xlsx/tests/test.rs @@ -350,11 +350,11 @@ fn test_xlsx() { for file_path in entries { let file_name_str = file_path.file_name().unwrap().to_str().unwrap(); let file_path_str = file_path.to_str().unwrap(); - println!("Testing file: {}", file_path_str); + println!("Testing file: {file_path_str}"); if file_name_str.ends_with(".xlsx") && !file_name_str.starts_with('~') { if let Err(message) = test_file(file_path_str) { println!("Error with file: '{file_path_str}'"); - println!("{}", message); + println!("{message}"); is_error = true; } let t = test_load_and_saving(file_path_str, &dir); @@ -389,11 +389,11 @@ fn no_export() { for file_path in entries { let file_name_str = file_path.file_name().unwrap().to_str().unwrap(); let file_path_str = file_path.to_str().unwrap(); - println!("Testing file: {}", file_path_str); + println!("Testing file: {file_path_str}"); if file_name_str.ends_with(".xlsx") && !file_name_str.starts_with('~') { if let Err(message) = test_file(file_path_str) { println!("Error with file: '{file_path_str}'"); - println!("{}", message); + println!("{message}"); is_error = true; } } else { @@ -485,7 +485,7 @@ fn test_documentation_xlsx() { // Numerically unstable skip.push("TAN.xlsx"); let skip: Vec = skip.iter().map(|s| format!("tests/docs/{s}")).collect(); - println!("{:?}", skip); + println!("{skip:?}"); // dumb counter to make sure we are actually testing the files assert!(entries.len() > 7); let temp_folder = env::temp_dir(); @@ -497,13 +497,13 @@ fn test_documentation_xlsx() { let file_name_str = file_path.file_name().unwrap().to_str().unwrap(); let file_path_str = file_path.to_str().unwrap(); if skip.contains(&file_path_str.to_string()) { - println!("Skipping file: {}", file_path_str); + println!("Skipping file: {file_path_str}"); continue; } - println!("Testing file: {}", file_path_str); + println!("Testing file: {file_path_str}"); if file_name_str.ends_with(".xlsx") && !file_name_str.starts_with('~') { if let Err(message) = test_file(file_path_str) { - println!("{}", message); + println!("{message}"); is_error = true; } assert!(test_load_and_saving(file_path_str, &dir).is_ok());