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

FIX: Make clippy happy

Browse Source
This commit is contained in:
Nicolás Hatcher
2025-06-29 10:23:32 +02:00
committed by Nicolás Hatcher Andrés
parent 46ea92966f
commit 0be7d9b85a
39 changed files with 200 additions and 224 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
base/src/cast.rs
View File

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

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

@@ -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::<i32>().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::<f64>() {
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),
}

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

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

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

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

22
base/src/expressions/parser/move_formula.rs
View File

@@ -53,24 +53,24 @@ fn move_function(name: &str, args: &Vec<Node>, 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: _,

36
base/src/expressions/parser/stringify.rs
View File

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

6
base/src/formatter/dates.rs
View File

@@ -21,14 +21,12 @@ fn is_date_within_range(date: NaiveDate) -> bool {
pub fn from_excel_date(days: i64) -> Result<NaiveDate, String> {
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)]

54
base/src/formatter/format.rs
View File

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

6
base/src/formatter/lexer.rs
View File

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

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

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

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

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

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

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

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

@@ -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::<Vec<_>>();
let len = iter_list.len();

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

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

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

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

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

@@ -39,6 +39,6 @@ static LANGUAGES: Lazy<HashMap<String, Language>> = 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)
}

28
base/src/model.rs
View File

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

16
base/src/new_empty.rs
View File

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

2
base/src/number_format.rs
View File

@@ -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::<f64>().unwrap_or({
let value = format!("{base}e{exponent}").parse::<f64>().unwrap_or({
// TODO: do this in a way that does not require a possible error
0.0
});

2
base/src/styles.rs
View File

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

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

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

20
base/src/test/user_model/test_border.rs
View File

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

2
base/src/test/user_model/test_general.rs
View File

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

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

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

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

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

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

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

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

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