Compare commits
1 Commits
feature/da
...
feature/ni
| Author | SHA1 | Date | |
|---|---|---|---|
|
ce3f0f33c2 |
26
.github/workflows/pypi.yml
vendored
26
.github/workflows/pypi.yml
vendored
@@ -32,9 +32,9 @@ jobs:
|
||||
manylinux: auto
|
||||
working-directory: bindings/python
|
||||
- name: Upload wheels
|
||||
uses: actions/upload-artifact@v4
|
||||
uses: actions/upload-artifact@v3
|
||||
with:
|
||||
name: wheels-${{ runner.os }}-${{ matrix.target }}
|
||||
name: wheels
|
||||
path: bindings/python/dist
|
||||
|
||||
windows:
|
||||
@@ -56,9 +56,9 @@ jobs:
|
||||
sccache: 'true'
|
||||
working-directory: bindings/python
|
||||
- name: Upload wheels
|
||||
uses: actions/upload-artifact@v4
|
||||
uses: actions/upload-artifact@v3
|
||||
with:
|
||||
name: wheels-${{ runner.os }}-${{ matrix.target }}
|
||||
name: wheels
|
||||
path: bindings/python/dist
|
||||
|
||||
macos:
|
||||
@@ -79,9 +79,9 @@ jobs:
|
||||
sccache: 'true'
|
||||
working-directory: bindings/python
|
||||
- name: Upload wheels
|
||||
uses: actions/upload-artifact@v4
|
||||
uses: actions/upload-artifact@v3
|
||||
with:
|
||||
name: wheels-${{ runner.os }}-${{ matrix.target }}
|
||||
name: wheels
|
||||
path: bindings/python/dist
|
||||
|
||||
sdist:
|
||||
@@ -95,9 +95,9 @@ jobs:
|
||||
args: --out dist
|
||||
working-directory: bindings/python
|
||||
- name: Upload sdist
|
||||
uses: actions/upload-artifact@v4
|
||||
uses: actions/upload-artifact@v3
|
||||
with:
|
||||
name: wheels-${{ runner.os }}-sdist
|
||||
name: wheels
|
||||
path: bindings/python/dist
|
||||
|
||||
publish-to-test-pypi:
|
||||
@@ -107,8 +107,9 @@ jobs:
|
||||
runs-on: ubuntu-latest
|
||||
needs: [linux, windows, macos, sdist]
|
||||
steps:
|
||||
- uses: actions/download-artifact@v4
|
||||
- uses: actions/download-artifact@v3
|
||||
with:
|
||||
name: wheels
|
||||
path: bindings/python/
|
||||
- name: Publish distribution 📦 to Test PyPI
|
||||
uses: PyO3/maturin-action@v1
|
||||
@@ -117,7 +118,7 @@ jobs:
|
||||
MATURIN_REPOSITORY_URL: "https://test.pypi.org/legacy/"
|
||||
with:
|
||||
command: upload
|
||||
args: "--skip-existing **/*.whl **/*.tar.gz"
|
||||
args: --skip-existing *
|
||||
working-directory: bindings/python
|
||||
|
||||
publish-pypi:
|
||||
@@ -127,8 +128,9 @@ jobs:
|
||||
runs-on: ubuntu-latest
|
||||
needs: [linux, windows, macos, sdist]
|
||||
steps:
|
||||
- uses: actions/download-artifact@v4
|
||||
- uses: actions/download-artifact@v3
|
||||
with:
|
||||
name: wheels
|
||||
path: bindings/python/
|
||||
- name: Publish distribution 📦 to PyPI
|
||||
uses: PyO3/maturin-action@v1
|
||||
@@ -137,5 +139,5 @@ jobs:
|
||||
MATURIN_REPOSITORY_URL: "https://upload.pypi.org/legacy/"
|
||||
with:
|
||||
command: upload
|
||||
args: "--skip-existing **/*.whl **/*.tar.gz"
|
||||
args: --skip-existing *
|
||||
working-directory: bindings/python
|
||||
|
||||
69
Cargo.lock
generated
69
Cargo.lock
generated
@@ -414,7 +414,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ironcalc"
|
||||
version = "0.5.0"
|
||||
version = "0.3.0"
|
||||
dependencies = [
|
||||
"bitcode",
|
||||
"chrono",
|
||||
@@ -430,13 +430,14 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ironcalc_base"
|
||||
version = "0.5.0"
|
||||
version = "0.3.0"
|
||||
dependencies = [
|
||||
"bitcode",
|
||||
"chrono",
|
||||
"chrono-tz",
|
||||
"csv",
|
||||
"js-sys",
|
||||
"once_cell",
|
||||
"rand",
|
||||
"regex",
|
||||
"regex-lite",
|
||||
@@ -447,7 +448,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ironcalc_nodejs"
|
||||
version = "0.5.0"
|
||||
version = "0.3.1"
|
||||
dependencies = [
|
||||
"ironcalc",
|
||||
"napi",
|
||||
@@ -720,10 +721,11 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyo3"
|
||||
version = "0.25.0"
|
||||
version = "0.23.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f239d656363bcee73afef85277f1b281e8ac6212a1d42aa90e55b90ed43c47a4"
|
||||
checksum = "57fe09249128b3173d092de9523eaa75136bf7ba85e0d69eca241c7939c933cc"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"indoc",
|
||||
"libc",
|
||||
"memoffset",
|
||||
@@ -737,9 +739,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyo3-build-config"
|
||||
version = "0.25.0"
|
||||
version = "0.23.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "755ea671a1c34044fa165247aaf6f419ca39caa6003aee791a0df2713d8f1b6d"
|
||||
checksum = "1cd3927b5a78757a0d71aa9dff669f903b1eb64b54142a9bd9f757f8fde65fd7"
|
||||
dependencies = [
|
||||
"once_cell",
|
||||
"target-lexicon",
|
||||
@@ -747,9 +749,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyo3-ffi"
|
||||
version = "0.25.0"
|
||||
version = "0.23.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fc95a2e67091e44791d4ea300ff744be5293f394f1bafd9f78c080814d35956e"
|
||||
checksum = "dab6bb2102bd8f991e7749f130a70d05dd557613e39ed2deeee8e9ca0c4d548d"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"pyo3-build-config",
|
||||
@@ -757,9 +759,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyo3-macros"
|
||||
version = "0.25.0"
|
||||
version = "0.23.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a179641d1b93920829a62f15e87c0ed791b6c8db2271ba0fd7c2686090510214"
|
||||
checksum = "91871864b353fd5ffcb3f91f2f703a22a9797c91b9ab497b1acac7b07ae509c7"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"pyo3-macros-backend",
|
||||
@@ -769,9 +771,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyo3-macros-backend"
|
||||
version = "0.25.0"
|
||||
version = "0.23.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9dff85ebcaab8c441b0e3f7ae40a6963ecea8a9f5e74f647e33fcf5ec9a1e89e"
|
||||
checksum = "43abc3b80bc20f3facd86cd3c60beed58c3e2aa26213f3cda368de39c60a27e4"
|
||||
dependencies = [
|
||||
"heck",
|
||||
"proc-macro2",
|
||||
@@ -782,9 +784,8 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyroncalc"
|
||||
version = "0.5.7"
|
||||
version = "0.3.0"
|
||||
dependencies = [
|
||||
"bitcode",
|
||||
"ironcalc",
|
||||
"pyo3",
|
||||
"serde",
|
||||
@@ -871,12 +872,6 @@ version = "0.19.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3cd14fd5e3b777a7422cca79358c57a8f6e3a703d9ac187448d0daf220c2407f"
|
||||
|
||||
[[package]]
|
||||
name = "rustversion"
|
||||
version = "1.0.21"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d"
|
||||
|
||||
[[package]]
|
||||
name = "ryu"
|
||||
version = "1.0.17"
|
||||
@@ -984,9 +979,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "target-lexicon"
|
||||
version = "0.13.2"
|
||||
version = "0.12.16"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
|
||||
checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
|
||||
|
||||
[[package]]
|
||||
name = "thiserror"
|
||||
@@ -1075,7 +1070,7 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
|
||||
|
||||
[[package]]
|
||||
name = "wasm"
|
||||
version = "0.5.0"
|
||||
version = "0.3.2"
|
||||
dependencies = [
|
||||
"ironcalc_base",
|
||||
"serde",
|
||||
@@ -1086,24 +1081,23 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen"
|
||||
version = "0.2.100"
|
||||
version = "0.2.92"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
|
||||
checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"once_cell",
|
||||
"rustversion",
|
||||
"wasm-bindgen-macro",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-backend"
|
||||
version = "0.2.100"
|
||||
version = "0.2.92"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
|
||||
checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
|
||||
dependencies = [
|
||||
"bumpalo",
|
||||
"log",
|
||||
"once_cell",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
@@ -1124,9 +1118,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-macro"
|
||||
version = "0.2.100"
|
||||
version = "0.2.92"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
|
||||
checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
|
||||
dependencies = [
|
||||
"quote",
|
||||
"wasm-bindgen-macro-support",
|
||||
@@ -1134,9 +1128,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-macro-support"
|
||||
version = "0.2.100"
|
||||
version = "0.2.92"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
|
||||
checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
@@ -1147,12 +1141,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-shared"
|
||||
version = "0.2.100"
|
||||
version = "0.2.92"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
|
||||
dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-test"
|
||||
|
||||
@@ -77,7 +77,7 @@ And visit <http://0.0.0.0:8000/ironcalc/>
|
||||
Add the dependency to `Cargo.toml`:
|
||||
```toml
|
||||
[dependencies]
|
||||
ironcalc = { git = "https://github.com/ironcalc/IronCalc", version = "0.5"}
|
||||
ironcalc = { git = "https://github.com/ironcalc/IronCalc", version = "0.1"}
|
||||
```
|
||||
|
||||
And then use this code in `main.rs`:
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
[package]
|
||||
name = "ironcalc_base"
|
||||
version = "0.5.0"
|
||||
version = "0.3.0"
|
||||
authors = ["Nicolás Hatcher <nicolas@theuniverse.today>"]
|
||||
edition = "2021"
|
||||
edition = "2024"
|
||||
homepage = "https://www.ironcalc.com"
|
||||
repository = "https://github.com/ironcalc/ironcalc/"
|
||||
description = "Open source spreadsheet engine"
|
||||
@@ -17,6 +17,7 @@ chrono = "0.4"
|
||||
chrono-tz = "0.10"
|
||||
regex = { version = "1.0", optional = true}
|
||||
regex-lite = { version = "0.1.6", optional = true}
|
||||
once_cell = "1.16.0"
|
||||
bitcode = "0.6.3"
|
||||
csv = "1.3.0"
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
use ironcalc_base::{types::CellType, Model};
|
||||
use ironcalc_base::{Model, types::CellType};
|
||||
|
||||
fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
let mut model = Model::new_empty("formulas-and-errors", "en", "UTC")?;
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
use ironcalc_base::{cell::CellValue, Model};
|
||||
use ironcalc_base::{Model, cell::CellValue};
|
||||
|
||||
fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
let mut model = Model::new_empty("hello-world", "en", "UTC")?;
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
use crate::constants::{LAST_COLUMN, LAST_ROW};
|
||||
use crate::expressions::parser::stringify::{to_string, to_string_displaced, DisplaceData};
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
use crate::expressions::parser::stringify::DisplaceData;
|
||||
use crate::model::Model;
|
||||
|
||||
// NOTE: There is a difference with Excel behaviour when deleting cells/rows/columns
|
||||
@@ -9,45 +8,16 @@ use crate::model::Model;
|
||||
// I feel this is unimportant for now.
|
||||
|
||||
impl Model {
|
||||
fn shift_cell_formula(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
column: i32,
|
||||
displace_data: &DisplaceData,
|
||||
) -> Result<(), String> {
|
||||
if let Some(f) = self
|
||||
.workbook
|
||||
.worksheet(sheet)?
|
||||
.cell(row, column)
|
||||
.and_then(|c| c.get_formula())
|
||||
{
|
||||
let node = &self.parsed_formulas[sheet as usize][f as usize].clone();
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: self.workbook.worksheets[sheet as usize].get_name(),
|
||||
row,
|
||||
column,
|
||||
};
|
||||
// FIXME: This is not a very performant way if the formula has changed :S.
|
||||
let formula = to_string(node, &cell_reference);
|
||||
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}"))?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
/// This function iterates over all cells in the model and shifts their formulas according to the displacement data.
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `displace_data` - A reference to `DisplaceData` describing the displacement's direction and magnitude.
|
||||
fn displace_cells(&mut self, displace_data: &DisplaceData) -> Result<(), String> {
|
||||
fn displace_cells(&mut self, displace_data: &DisplaceData) {
|
||||
let cells = self.get_all_cells();
|
||||
for cell in cells {
|
||||
self.shift_cell_formula(cell.index, cell.row, cell.column, displace_data)?;
|
||||
self.shift_cell_formula(cell.index, cell.row, cell.column, displace_data);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Retrieves the column indices for a specific row in a given sheet, sorted in ascending or descending order.
|
||||
@@ -164,7 +134,7 @@ impl Model {
|
||||
column,
|
||||
delta: column_count,
|
||||
}),
|
||||
)?;
|
||||
);
|
||||
|
||||
// In the list of columns:
|
||||
// * Keep all the columns to the left
|
||||
@@ -212,12 +182,6 @@ impl Model {
|
||||
if column_count <= 0 {
|
||||
return Err("Please use insert columns instead".to_string());
|
||||
}
|
||||
if !(1..=LAST_COLUMN).contains(&column) {
|
||||
return Err(format!("Column number '{column}' is not valid."));
|
||||
}
|
||||
if column + column_count - 1 > LAST_COLUMN {
|
||||
return Err("Cannot delete columns beyond the last column of the sheet".to_string());
|
||||
}
|
||||
|
||||
// first column being deleted
|
||||
let column_start = column;
|
||||
@@ -250,7 +214,7 @@ impl Model {
|
||||
column,
|
||||
delta: -column_count,
|
||||
}),
|
||||
)?;
|
||||
);
|
||||
let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
|
||||
|
||||
// deletes all the column styles
|
||||
@@ -374,7 +338,7 @@ impl Model {
|
||||
row,
|
||||
delta: row_count,
|
||||
}),
|
||||
)?;
|
||||
);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@@ -390,13 +354,6 @@ impl Model {
|
||||
if row_count <= 0 {
|
||||
return Err("Please use insert rows instead".to_string());
|
||||
}
|
||||
if !(1..=LAST_ROW).contains(&row) {
|
||||
return Err(format!("Row number '{row}' is not valid."));
|
||||
}
|
||||
if row + row_count - 1 > LAST_ROW {
|
||||
return Err("Cannot delete rows beyond the last row of the sheet".to_string());
|
||||
}
|
||||
|
||||
// Move cells
|
||||
let worksheet = &self.workbook.worksheet(sheet)?;
|
||||
let mut all_rows: Vec<i32> = worksheet.sheet_data.keys().copied().collect();
|
||||
@@ -442,7 +399,7 @@ impl Model {
|
||||
row,
|
||||
delta: -row_count,
|
||||
}),
|
||||
)?;
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -457,86 +414,23 @@ impl Model {
|
||||
/// * Column is one of the extremes of the range. The new extreme would be target_column.
|
||||
/// Range is then normalized
|
||||
/// * Any other case, range is left unchanged.
|
||||
/// NOTE: This moves the data and column styles along with the formulas
|
||||
/// NOTE: This does NOT move the data in the columns or move the colum styles
|
||||
pub fn move_column_action(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
delta: i32,
|
||||
) -> Result<(), String> {
|
||||
) -> Result<(), &'static str> {
|
||||
// Check boundaries
|
||||
let target_column = column + delta;
|
||||
if !(1..=LAST_COLUMN).contains(&target_column) {
|
||||
return Err("Target column out of boundaries".to_string());
|
||||
return Err("Target column out of boundaries");
|
||||
}
|
||||
if !(1..=LAST_COLUMN).contains(&column) {
|
||||
return Err("Initial column out of boundaries".to_string());
|
||||
return Err("Initial column out of boundaries");
|
||||
}
|
||||
|
||||
if delta == 0 {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Preserve cell contents, width and style of the column being moved
|
||||
let original_refs = self
|
||||
.workbook
|
||||
.worksheet(sheet)?
|
||||
.column_cell_references(column)?;
|
||||
let mut original_cells = Vec::new();
|
||||
for r in &original_refs {
|
||||
let cell = self
|
||||
.workbook
|
||||
.worksheet(sheet)?
|
||||
.cell(r.row, column)
|
||||
.ok_or("Expected Cell to exist")?;
|
||||
let style_idx = cell.get_style();
|
||||
let formula_or_value = self
|
||||
.get_cell_formula(sheet, r.row, column)?
|
||||
.unwrap_or_else(|| cell.get_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)?;
|
||||
}
|
||||
|
||||
let width = self.workbook.worksheet(sheet)?.get_column_width(column)?;
|
||||
let style = self.workbook.worksheet(sheet)?.get_column_style(column)?;
|
||||
|
||||
if delta > 0 {
|
||||
for c in column + 1..=target_column {
|
||||
let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
|
||||
for r in refs {
|
||||
self.move_cell(sheet, r.row, c, r.row, c - 1)?;
|
||||
}
|
||||
|
||||
let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
|
||||
let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_column_width_and_style(c - 1, w, s)?;
|
||||
}
|
||||
} else {
|
||||
for c in (target_column..=column - 1).rev() {
|
||||
let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
|
||||
for r in refs {
|
||||
self.move_cell(sheet, r.row, c, r.row, c + 1)?;
|
||||
}
|
||||
|
||||
let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
|
||||
let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_column_width_and_style(c + 1, w, s)?;
|
||||
}
|
||||
}
|
||||
|
||||
for (r, value, style_idx) in original_cells {
|
||||
self.set_user_input(sheet, r, target_column, value)?;
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_cell_style(r, target_column, style_idx)?;
|
||||
}
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_column_width_and_style(target_column, width, style)?;
|
||||
// TODO: Add the actual displacement of data and styles
|
||||
|
||||
// Update all formulas in the workbook
|
||||
self.displace_cells(
|
||||
@@ -545,91 +439,7 @@ impl Model {
|
||||
column,
|
||||
delta,
|
||||
}),
|
||||
)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Displaces cells due to a move row action
|
||||
/// from initial_row to target_row = initial_row + row_delta
|
||||
/// References will be updated following the same rules as move_column_action
|
||||
/// NOTE: This moves the data and row styles along with the formulas
|
||||
pub fn move_row_action(&mut self, sheet: u32, row: i32, delta: i32) -> Result<(), String> {
|
||||
// Check boundaries
|
||||
let target_row = row + delta;
|
||||
if !(1..=LAST_ROW).contains(&target_row) {
|
||||
return Err("Target row out of boundaries".to_string());
|
||||
}
|
||||
if !(1..=LAST_ROW).contains(&row) {
|
||||
return Err("Initial row out of boundaries".to_string());
|
||||
}
|
||||
|
||||
if delta == 0 {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let original_cols = self.get_columns_for_row(sheet, row, false)?;
|
||||
let mut original_cells = Vec::new();
|
||||
for c in &original_cols {
|
||||
let cell = self
|
||||
.workbook
|
||||
.worksheet(sheet)?
|
||||
.cell(row, *c)
|
||||
.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_text(&self.workbook.shared_strings, &self.language));
|
||||
original_cells.push((*c, formula_or_value, style_idx));
|
||||
self.cell_clear_all(sheet, row, *c)?;
|
||||
}
|
||||
|
||||
if delta > 0 {
|
||||
for r in row + 1..=target_row {
|
||||
let cols = self.get_columns_for_row(sheet, r, false)?;
|
||||
for c in cols {
|
||||
self.move_cell(sheet, r, c, r - 1, c)?;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for r in (target_row..=row - 1).rev() {
|
||||
let cols = self.get_columns_for_row(sheet, r, false)?;
|
||||
for c in cols {
|
||||
self.move_cell(sheet, r, c, r + 1, c)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (c, value, style_idx) in original_cells {
|
||||
self.set_user_input(sheet, target_row, c, value)?;
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_cell_style(target_row, c, style_idx)?;
|
||||
}
|
||||
|
||||
let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
|
||||
let mut new_rows = Vec::new();
|
||||
for r in worksheet.rows.iter() {
|
||||
if r.r == row {
|
||||
let mut nr = r.clone();
|
||||
nr.r = target_row;
|
||||
new_rows.push(nr);
|
||||
} else if delta > 0 && r.r > row && r.r <= target_row {
|
||||
let mut nr = r.clone();
|
||||
nr.r -= 1;
|
||||
new_rows.push(nr);
|
||||
} else if delta < 0 && r.r < row && r.r >= target_row {
|
||||
let mut nr = r.clone();
|
||||
nr.r += 1;
|
||||
new_rows.push(nr);
|
||||
} else {
|
||||
new_rows.push(r.clone());
|
||||
}
|
||||
}
|
||||
worksheet.rows = new_rows;
|
||||
|
||||
// Update all formulas in the workbook
|
||||
self.displace_cells(&(DisplaceData::RowMove { sheet, row, delta }))?;
|
||||
);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1,158 +0,0 @@
|
||||
use crate::{
|
||||
calc_result::CalcResult,
|
||||
cast::NumberOrArray,
|
||||
expressions::{
|
||||
parser::{ArrayNode, Node},
|
||||
token::Error,
|
||||
types::CellReferenceIndex,
|
||||
},
|
||||
model::Model,
|
||||
};
|
||||
|
||||
/// Unify how we map booleans/strings to f64
|
||||
fn to_f64(value: &ArrayNode) -> Result<f64, Error> {
|
||||
match value {
|
||||
ArrayNode::Number(f) => Ok(*f),
|
||||
ArrayNode::Boolean(b) => Ok(if *b { 1.0 } else { 0.0 }),
|
||||
ArrayNode::String(s) => match s.parse::<f64>() {
|
||||
Ok(f) => Ok(f),
|
||||
Err(_) => Err(Error::VALUE),
|
||||
},
|
||||
ArrayNode::Error(err) => Err(err.clone()),
|
||||
}
|
||||
}
|
||||
|
||||
impl Model {
|
||||
/// Applies `op` element‐wise for arrays/numbers.
|
||||
pub(crate) fn handle_arithmetic(
|
||||
&mut self,
|
||||
left: &Node,
|
||||
right: &Node,
|
||||
cell: CellReferenceIndex,
|
||||
op: &dyn Fn(f64, f64) -> Result<f64, Error>,
|
||||
) -> CalcResult {
|
||||
let l = match self.get_number_or_array(left, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
let r = match self.get_number_or_array(right, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
match (l, r) {
|
||||
// -----------------------------------------------------
|
||||
// Case 1: Both are numbers
|
||||
// -----------------------------------------------------
|
||||
(NumberOrArray::Number(f1), NumberOrArray::Number(f2)) => match op(f1, f2) {
|
||||
Ok(x) => CalcResult::Number(x),
|
||||
Err(Error::DIV) => CalcResult::Error {
|
||||
error: Error::DIV,
|
||||
origin: cell,
|
||||
message: "Divide by 0".to_string(),
|
||||
},
|
||||
Err(Error::VALUE) => CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Invalid number".to_string(),
|
||||
},
|
||||
Err(e) => CalcResult::Error {
|
||||
error: e,
|
||||
origin: cell,
|
||||
message: "Unknown error".to_string(),
|
||||
},
|
||||
},
|
||||
|
||||
// -----------------------------------------------------
|
||||
// Case 2: left is Number, right is Array
|
||||
// -----------------------------------------------------
|
||||
(NumberOrArray::Number(f1), NumberOrArray::Array(a2)) => {
|
||||
let mut array = Vec::new();
|
||||
for row in a2 {
|
||||
let mut data_row = Vec::new();
|
||||
for node in row {
|
||||
match to_f64(&node) {
|
||||
Ok(f2) => match op(f1, f2) {
|
||||
Ok(x) => data_row.push(ArrayNode::Number(x)),
|
||||
Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
|
||||
Err(Error::VALUE) => data_row.push(ArrayNode::Error(Error::VALUE)),
|
||||
Err(e) => data_row.push(ArrayNode::Error(e)),
|
||||
},
|
||||
Err(err) => data_row.push(ArrayNode::Error(err)),
|
||||
}
|
||||
}
|
||||
array.push(data_row);
|
||||
}
|
||||
CalcResult::Array(array)
|
||||
}
|
||||
|
||||
// -----------------------------------------------------
|
||||
// Case 3: left is Array, right is Number
|
||||
// -----------------------------------------------------
|
||||
(NumberOrArray::Array(a1), NumberOrArray::Number(f2)) => {
|
||||
let mut array = Vec::new();
|
||||
for row in a1 {
|
||||
let mut data_row = Vec::new();
|
||||
for node in row {
|
||||
match to_f64(&node) {
|
||||
Ok(f1) => match op(f1, f2) {
|
||||
Ok(x) => data_row.push(ArrayNode::Number(x)),
|
||||
Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
|
||||
Err(Error::VALUE) => data_row.push(ArrayNode::Error(Error::VALUE)),
|
||||
Err(e) => data_row.push(ArrayNode::Error(e)),
|
||||
},
|
||||
Err(err) => data_row.push(ArrayNode::Error(err)),
|
||||
}
|
||||
}
|
||||
array.push(data_row);
|
||||
}
|
||||
CalcResult::Array(array)
|
||||
}
|
||||
|
||||
// -----------------------------------------------------
|
||||
// Case 4: Both are arrays
|
||||
// -----------------------------------------------------
|
||||
(NumberOrArray::Array(a1), NumberOrArray::Array(a2)) => {
|
||||
let n1 = a1.len();
|
||||
let m1 = a1.first().map(|r| r.len()).unwrap_or(0);
|
||||
let n2 = a2.len();
|
||||
let m2 = a2.first().map(|r| r.len()).unwrap_or(0);
|
||||
let n = n1.max(n2);
|
||||
let m = m1.max(m2);
|
||||
|
||||
let mut array = Vec::new();
|
||||
for i in 0..n {
|
||||
let row1 = a1.get(i);
|
||||
let row2 = a2.get(i);
|
||||
|
||||
let mut data_row = Vec::new();
|
||||
for j in 0..m {
|
||||
let val1 = row1.and_then(|r| r.get(j));
|
||||
let val2 = row2.and_then(|r| r.get(j));
|
||||
|
||||
match (val1, val2) {
|
||||
(Some(v1), Some(v2)) => match (to_f64(v1), to_f64(v2)) {
|
||||
(Ok(f1), Ok(f2)) => match op(f1, f2) {
|
||||
Ok(x) => data_row.push(ArrayNode::Number(x)),
|
||||
Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
|
||||
Err(Error::VALUE) => {
|
||||
data_row.push(ArrayNode::Error(Error::VALUE))
|
||||
}
|
||||
Err(e) => data_row.push(ArrayNode::Error(e)),
|
||||
},
|
||||
(Err(e), _) | (_, Err(e)) => data_row.push(ArrayNode::Error(e)),
|
||||
},
|
||||
// Mismatched dimensions => #VALUE!
|
||||
_ => data_row.push(ArrayNode::Error(Error::VALUE)),
|
||||
}
|
||||
}
|
||||
array.push(data_row);
|
||||
}
|
||||
CalcResult::Array(array)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
use std::cmp::Ordering;
|
||||
|
||||
use crate::expressions::{parser::ArrayNode, token::Error, types::CellReferenceIndex};
|
||||
use crate::expressions::{token::Error, types::CellReferenceIndex};
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct Range {
|
||||
@@ -24,7 +24,6 @@ pub(crate) enum CalcResult {
|
||||
},
|
||||
EmptyCell,
|
||||
EmptyArg,
|
||||
Array(Vec<Vec<ArrayNode>>),
|
||||
}
|
||||
|
||||
impl CalcResult {
|
||||
|
||||
149
base/src/cast.rs
149
base/src/cast.rs
@@ -1,85 +1,11 @@
|
||||
use crate::{
|
||||
calc_result::{CalcResult, Range},
|
||||
expressions::{
|
||||
parser::{ArrayNode, Node},
|
||||
token::Error,
|
||||
types::CellReferenceIndex,
|
||||
},
|
||||
expressions::{parser::Node, token::Error, types::CellReferenceIndex},
|
||||
implicit_intersection::implicit_intersection,
|
||||
model::Model,
|
||||
};
|
||||
|
||||
pub(crate) enum NumberOrArray {
|
||||
Number(f64),
|
||||
Array(Vec<Vec<ArrayNode>>),
|
||||
}
|
||||
|
||||
impl Model {
|
||||
pub(crate) fn get_number_or_array(
|
||||
&mut self,
|
||||
node: &Node,
|
||||
cell: CellReferenceIndex,
|
||||
) -> Result<NumberOrArray, CalcResult> {
|
||||
match self.evaluate_node_in_context(node, cell) {
|
||||
CalcResult::Number(f) => Ok(NumberOrArray::Number(f)),
|
||||
CalcResult::String(s) => match s.parse::<f64>() {
|
||||
Ok(f) => Ok(NumberOrArray::Number(f)),
|
||||
_ => Err(CalcResult::new_error(
|
||||
Error::VALUE,
|
||||
cell,
|
||||
"Expecting number".to_string(),
|
||||
)),
|
||||
},
|
||||
CalcResult::Boolean(f) => {
|
||||
if f {
|
||||
Ok(NumberOrArray::Number(1.0))
|
||||
} else {
|
||||
Ok(NumberOrArray::Number(0.0))
|
||||
}
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(NumberOrArray::Number(0.0)),
|
||||
CalcResult::Range { left, right } => {
|
||||
let sheet = left.sheet;
|
||||
if sheet != right.sheet {
|
||||
return Err(CalcResult::Error {
|
||||
error: Error::ERROR,
|
||||
origin: cell,
|
||||
message: "3D ranges are not allowed".to_string(),
|
||||
});
|
||||
}
|
||||
// we need to convert the range into an array
|
||||
let mut array = Vec::new();
|
||||
for row in left.row..=right.row {
|
||||
let mut row_data = Vec::new();
|
||||
for column in left.column..=right.column {
|
||||
let value =
|
||||
match self.evaluate_cell(CellReferenceIndex { sheet, column, row }) {
|
||||
CalcResult::String(s) => ArrayNode::String(s),
|
||||
CalcResult::Number(f) => ArrayNode::Number(f),
|
||||
CalcResult::Boolean(b) => ArrayNode::Boolean(b),
|
||||
CalcResult::Error { error, .. } => ArrayNode::Error(error),
|
||||
CalcResult::Range { .. } => {
|
||||
// if we do things right this can never happen.
|
||||
// the evaluation of a cell should never return a range
|
||||
ArrayNode::Number(0.0)
|
||||
}
|
||||
CalcResult::EmptyCell => ArrayNode::Number(0.0),
|
||||
CalcResult::EmptyArg => ArrayNode::Number(0.0),
|
||||
CalcResult::Array(_) => {
|
||||
// if we do things right this can never happen.
|
||||
// the evaluation of a cell should never return an array
|
||||
ArrayNode::Number(0.0)
|
||||
}
|
||||
};
|
||||
row_data.push(value);
|
||||
}
|
||||
array.push(row_data);
|
||||
}
|
||||
Ok(NumberOrArray::Array(array))
|
||||
}
|
||||
CalcResult::Array(s) => Ok(NumberOrArray::Array(s)),
|
||||
error @ CalcResult::Error { .. } => Err(error),
|
||||
}
|
||||
}
|
||||
pub(crate) fn get_number(
|
||||
&mut self,
|
||||
node: &Node,
|
||||
@@ -113,16 +39,19 @@ impl Model {
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(0.0),
|
||||
error @ CalcResult::Error { .. } => Err(error),
|
||||
CalcResult::Range { .. } => Err(CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}),
|
||||
CalcResult::Array(_) => Err(CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}),
|
||||
CalcResult::Range { left, right } => {
|
||||
match implicit_intersection(&cell, &Range { left, right }) {
|
||||
Some(cell_reference) => {
|
||||
let result = self.evaluate_cell(cell_reference);
|
||||
self.cast_to_number(result, cell_reference)
|
||||
}
|
||||
None => Err(CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Invalid reference (number)".to_string(),
|
||||
}),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -159,7 +88,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 {
|
||||
@@ -170,16 +99,19 @@ impl Model {
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => Ok("".to_string()),
|
||||
error @ CalcResult::Error { .. } => Err(error),
|
||||
CalcResult::Range { .. } => Err(CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}),
|
||||
CalcResult::Array(_) => Err(CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}),
|
||||
CalcResult::Range { left, right } => {
|
||||
match implicit_intersection(&cell, &Range { left, right }) {
|
||||
Some(cell_reference) => {
|
||||
let result = self.evaluate_cell(cell_reference);
|
||||
self.cast_to_string(result, cell_reference)
|
||||
}
|
||||
None => Err(CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Invalid reference (string)".to_string(),
|
||||
}),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -219,16 +151,19 @@ impl Model {
|
||||
CalcResult::Boolean(b) => Ok(b),
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(false),
|
||||
error @ CalcResult::Error { .. } => Err(error),
|
||||
CalcResult::Range { .. } => Err(CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}),
|
||||
CalcResult::Array(_) => Err(CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}),
|
||||
CalcResult::Range { left, right } => {
|
||||
match implicit_intersection(&cell, &Range { left, right }) {
|
||||
Some(cell_reference) => {
|
||||
let result = self.evaluate_cell(cell_reference);
|
||||
self.cast_to_bool(result, cell_reference)
|
||||
}
|
||||
None => Err(CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Invalid reference (bool)".to_string(),
|
||||
}),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
138
base/src/diffs.rs
Normal file
138
base/src/diffs.rs
Normal file
@@ -0,0 +1,138 @@
|
||||
use crate::{
|
||||
expressions::{
|
||||
parser::{
|
||||
move_formula::ref_is_in_area,
|
||||
stringify::{DisplaceData, to_string, to_string_displaced},
|
||||
walk::forward_references,
|
||||
},
|
||||
types::{Area, CellReferenceIndex, CellReferenceRC},
|
||||
},
|
||||
model::Model,
|
||||
};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
|
||||
#[serde(untagged, deny_unknown_fields)]
|
||||
pub enum CellValue {
|
||||
Value(String),
|
||||
None,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
|
||||
pub struct SetCellValue {
|
||||
cell: CellReferenceIndex,
|
||||
new_value: CellValue,
|
||||
old_value: CellValue,
|
||||
}
|
||||
|
||||
impl Model {
|
||||
#[allow(clippy::expect_used)]
|
||||
pub(crate) fn shift_cell_formula(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
column: i32,
|
||||
displace_data: &DisplaceData,
|
||||
) {
|
||||
if let Some(f) = self
|
||||
.workbook
|
||||
.worksheet(sheet)
|
||||
.expect("Worksheet must exist")
|
||||
.cell(row, column)
|
||||
.expect("Cell must exist")
|
||||
.get_formula()
|
||||
{
|
||||
let node = &self.parsed_formulas[sheet as usize][f as usize].clone();
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: self.workbook.worksheets[sheet as usize].get_name(),
|
||||
row,
|
||||
column,
|
||||
};
|
||||
// FIXME: This is not a very performant way if the formula has changed :S.
|
||||
let formula = to_string(node, &cell_reference);
|
||||
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}"))
|
||||
.expect("Failed to shift cell formula");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::expect_used)]
|
||||
pub fn forward_references(
|
||||
&mut self,
|
||||
source_area: &Area,
|
||||
target: &CellReferenceIndex,
|
||||
) -> Result<Vec<SetCellValue>, String> {
|
||||
let mut diff_list: Vec<SetCellValue> = Vec::new();
|
||||
let target_area = &Area {
|
||||
sheet: target.sheet,
|
||||
row: target.row,
|
||||
column: target.column,
|
||||
width: source_area.width,
|
||||
height: source_area.height,
|
||||
};
|
||||
// Walk over every formula
|
||||
let cells = self.get_all_cells();
|
||||
for cell in cells {
|
||||
if let Some(f) = self
|
||||
.workbook
|
||||
.worksheet(cell.index)
|
||||
.expect("Worksheet must exist")
|
||||
.cell(cell.row, cell.column)
|
||||
.expect("Cell must exist")
|
||||
.get_formula()
|
||||
{
|
||||
let sheet = cell.index;
|
||||
let row = cell.row;
|
||||
let column = cell.column;
|
||||
|
||||
// If cell is in the source or target area, skip
|
||||
if ref_is_in_area(sheet, row, column, source_area)
|
||||
|| ref_is_in_area(sheet, row, column, target_area)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
// Get the formula
|
||||
// Get a copy of the AST
|
||||
let node = &mut self.parsed_formulas[sheet as usize][f as usize].clone();
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: self.workbook.worksheets[sheet as usize].get_name(),
|
||||
column: cell.column,
|
||||
row: cell.row,
|
||||
};
|
||||
let context = CellReferenceIndex { sheet, column, row };
|
||||
let formula = to_string(node, &cell_reference);
|
||||
let target_sheet_name = &self.workbook.worksheets[target.sheet as usize].name;
|
||||
forward_references(
|
||||
node,
|
||||
&context,
|
||||
source_area,
|
||||
target.sheet,
|
||||
target_sheet_name,
|
||||
target.row,
|
||||
target.column,
|
||||
);
|
||||
|
||||
// If the string representation of the formula has changed update the cell
|
||||
let updated_formula = to_string(node, &cell_reference);
|
||||
if formula != updated_formula {
|
||||
self.update_cell_with_formula(
|
||||
sheet,
|
||||
row,
|
||||
column,
|
||||
format!("={updated_formula}"),
|
||||
)?;
|
||||
// Update the diff list
|
||||
diff_list.push(SetCellValue {
|
||||
cell: CellReferenceIndex { sheet, column, row },
|
||||
new_value: CellValue::Value(format!("={}", updated_formula)),
|
||||
old_value: CellValue::Value(format!("={}", formula)),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(diff_list)
|
||||
}
|
||||
}
|
||||
@@ -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(())
|
||||
}
|
||||
@@ -187,7 +187,6 @@ impl Lexer {
|
||||
']' => TokenType::RightBracket,
|
||||
':' => TokenType::Colon,
|
||||
';' => TokenType::Semicolon,
|
||||
'@' => TokenType::At,
|
||||
',' => {
|
||||
if self.locale.numbers.symbols.decimal == "," {
|
||||
match self.consume_number(',') {
|
||||
@@ -314,9 +313,6 @@ impl Lexer {
|
||||
} else if name_upper == self.language.booleans.r#false {
|
||||
return TokenType::Boolean(false);
|
||||
}
|
||||
if self.peek_char() == Some('(') {
|
||||
return TokenType::Ident(name);
|
||||
}
|
||||
if self.mode == LexerMode::A1 {
|
||||
let parsed_reference = utils::parse_reference_a1(&name_upper);
|
||||
if parsed_reference.is_some()
|
||||
@@ -514,7 +510,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),
|
||||
})
|
||||
}
|
||||
|
||||
@@ -575,7 +571,9 @@ impl Lexer {
|
||||
}
|
||||
self.position = position;
|
||||
match chars.parse::<f64>() {
|
||||
Err(_) => Err(self.set_error(&format!("Failed to parse to double: {chars}"), position)),
|
||||
Err(_) => {
|
||||
Err(self.set_error(&format!("Failed to parse to double: {}", chars), position))
|
||||
}
|
||||
Ok(v) => Ok(v),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -148,16 +148,17 @@ impl Lexer {
|
||||
let row_left = match row_left.parse::<i32>() {
|
||||
Ok(n) => n,
|
||||
Err(_) => {
|
||||
return Err(
|
||||
self.set_error(&format!("Failed parsing row {row_left}"), position)
|
||||
)
|
||||
return Err(self
|
||||
.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))
|
||||
return Err(self.set_error(
|
||||
&format!("Failed parsing row {}", row_right),
|
||||
position,
|
||||
));
|
||||
}
|
||||
};
|
||||
if row_left > LAST_ROW {
|
||||
|
||||
@@ -23,19 +23,19 @@ impl Lexer {
|
||||
// TODO(TD): There are better ways of doing this :)
|
||||
let rest_of_formula: String = self.chars[self.position..self.len].iter().collect();
|
||||
let specifier = if rest_of_formula.starts_with("#This Row]") {
|
||||
self.position += "#This Row]".len();
|
||||
self.position += "#This Row]".bytes().len();
|
||||
TableSpecifier::ThisRow
|
||||
} else if rest_of_formula.starts_with("#All]") {
|
||||
self.position += "#All]".len();
|
||||
self.position += "#All]".bytes().len();
|
||||
TableSpecifier::All
|
||||
} else if rest_of_formula.starts_with("#Data]") {
|
||||
self.position += "#Data]".len();
|
||||
self.position += "#Data]".bytes().len();
|
||||
TableSpecifier::Data
|
||||
} else if rest_of_formula.starts_with("#Headers]") {
|
||||
self.position += "#Headers]".len();
|
||||
self.position += "#Headers]".bytes().len();
|
||||
TableSpecifier::Headers
|
||||
} else if rest_of_formula.starts_with("#Totals]") {
|
||||
self.position += "#Totals]".len();
|
||||
self.position += "#Totals]".bytes().len();
|
||||
TableSpecifier::Totals
|
||||
} else {
|
||||
return Err(LexerError {
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
mod test_common;
|
||||
mod test_implicit_intersection;
|
||||
mod test_language;
|
||||
mod test_locale;
|
||||
mod test_ranges;
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::expressions::utils::column_to_number;
|
||||
use crate::language::get_language;
|
||||
use crate::locale::get_locale;
|
||||
|
||||
@@ -686,29 +685,3 @@ fn test_comparisons() {
|
||||
assert_eq!(lx.next_token(), Number(7.0));
|
||||
assert_eq!(lx.next_token(), EOF);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_log10_is_cell_reference() {
|
||||
let mut lx = new_lexer("LOG10", true);
|
||||
assert_eq!(
|
||||
lx.next_token(),
|
||||
Reference {
|
||||
sheet: None,
|
||||
column: column_to_number("LOG").unwrap(),
|
||||
row: 10,
|
||||
absolute_column: false,
|
||||
absolute_row: false,
|
||||
}
|
||||
);
|
||||
assert_eq!(lx.next_token(), EOF);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_log10_is_function() {
|
||||
let mut lx = new_lexer("LOG10(100)", true);
|
||||
assert_eq!(lx.next_token(), Ident("LOG10".to_string()));
|
||||
assert_eq!(lx.next_token(), LeftParenthesis);
|
||||
assert_eq!(lx.next_token(), Number(100.0));
|
||||
assert_eq!(lx.next_token(), RightParenthesis);
|
||||
assert_eq!(lx.next_token(), EOF);
|
||||
}
|
||||
|
||||
@@ -1,25 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::expressions::{
|
||||
lexer::{Lexer, LexerMode},
|
||||
token::TokenType::*,
|
||||
};
|
||||
use crate::language::get_language;
|
||||
use crate::locale::get_locale;
|
||||
|
||||
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)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sum_implicit_intersection() {
|
||||
let mut lx = new_lexer("sum(@A1:A3)");
|
||||
assert_eq!(lx.next_token(), Ident("sum".to_string()));
|
||||
assert_eq!(lx.next_token(), LeftParenthesis);
|
||||
assert_eq!(lx.next_token(), At);
|
||||
assert!(matches!(lx.next_token(), Range { .. }));
|
||||
assert_eq!(lx.next_token(), RightParenthesis);
|
||||
assert_eq!(lx.next_token(), EOF);
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
/*!
|
||||
# GRAMMAR
|
||||
# GRAMAR
|
||||
|
||||
<pre class="rust">
|
||||
opComp => '=' | '<' | '>' | '<=' } '>=' | '<>'
|
||||
@@ -12,8 +12,7 @@ term => factor (opFactor factor)*
|
||||
factor => prod (opProd prod)*
|
||||
prod => power ('^' power)*
|
||||
power => (unaryOp)* range '%'*
|
||||
range => implicit (':' primary)?
|
||||
implicit=> '@' primary | primary
|
||||
range => primary (':' primary)?
|
||||
primary => '(' expr ')'
|
||||
=> number
|
||||
=> function '(' f_args ')'
|
||||
@@ -46,8 +45,8 @@ use super::utils::number_to_column;
|
||||
use token::OpCompare;
|
||||
|
||||
pub mod move_formula;
|
||||
pub mod static_analysis;
|
||||
pub mod stringify;
|
||||
pub mod walk;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -82,9 +81,6 @@ fn get_table_column_by_name(table_column_name: &str, table: &Table) -> Option<i3
|
||||
None
|
||||
}
|
||||
|
||||
// DefinedNameS is a tuple with the name of the defined name, the index of the sheet and the formula
|
||||
pub type DefinedNameS = (String, Option<u32>, String);
|
||||
|
||||
pub(crate) struct Reference<'a> {
|
||||
sheet_name: &'a Option<String>,
|
||||
sheet_index: u32,
|
||||
@@ -94,14 +90,6 @@ pub(crate) struct Reference<'a> {
|
||||
column: i32,
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Clone, Debug)]
|
||||
pub enum ArrayNode {
|
||||
Boolean(bool),
|
||||
Number(f64),
|
||||
String(String),
|
||||
Error(token::Error),
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Clone, Debug)]
|
||||
pub enum Node {
|
||||
BooleanKind(bool),
|
||||
@@ -175,14 +163,10 @@ pub enum Node {
|
||||
name: String,
|
||||
args: Vec<Node>,
|
||||
},
|
||||
ArrayKind(Vec<Vec<ArrayNode>>),
|
||||
DefinedNameKind(DefinedNameS),
|
||||
ArrayKind(Vec<Node>),
|
||||
DefinedNameKind((String, Option<u32>)),
|
||||
TableNameKind(String),
|
||||
WrongVariableKind(String),
|
||||
ImplicitIntersection {
|
||||
automatic: bool,
|
||||
child: Box<Node>,
|
||||
},
|
||||
CompareKind {
|
||||
kind: OpCompare,
|
||||
left: Box<Node>,
|
||||
@@ -205,7 +189,7 @@ pub enum Node {
|
||||
pub struct Parser {
|
||||
lexer: lexer::Lexer,
|
||||
worksheets: Vec<String>,
|
||||
defined_names: Vec<DefinedNameS>,
|
||||
defined_names: Vec<(String, Option<u32>)>,
|
||||
context: CellReferenceRC,
|
||||
tables: HashMap<String, Table>,
|
||||
}
|
||||
@@ -213,7 +197,7 @@ pub struct Parser {
|
||||
impl Parser {
|
||||
pub fn new(
|
||||
worksheets: Vec<String>,
|
||||
defined_names: Vec<DefinedNameS>,
|
||||
defined_names: Vec<(String, Option<u32>)>,
|
||||
tables: HashMap<String, Table>,
|
||||
) -> Parser {
|
||||
let lexer = lexer::Lexer::new(
|
||||
@@ -244,7 +228,7 @@ impl Parser {
|
||||
pub fn set_worksheets_and_names(
|
||||
&mut self,
|
||||
worksheets: Vec<String>,
|
||||
defined_names: Vec<DefinedNameS>,
|
||||
defined_names: Vec<(String, Option<u32>)>,
|
||||
) {
|
||||
self.worksheets = worksheets;
|
||||
self.defined_names = defined_names;
|
||||
@@ -268,17 +252,17 @@ impl Parser {
|
||||
|
||||
// Returns:
|
||||
// * None: If there is no defined name by that name
|
||||
// * Some((Some(index), formula)): If there is a defined name local to that sheet
|
||||
// * Some(Some(index)): If there is a defined name local to that sheet
|
||||
// * Some(None): If there is a global defined name
|
||||
fn get_defined_name(&self, name: &str, sheet: u32) -> Option<(Option<u32>, String)> {
|
||||
for (df_name, df_scope, df_formula) in &self.defined_names {
|
||||
fn get_defined_name(&self, name: &str, sheet: u32) -> Option<Option<u32>> {
|
||||
for (df_name, df_scope) in &self.defined_names {
|
||||
if name.to_lowercase() == df_name.to_lowercase() && df_scope == &Some(sheet) {
|
||||
return Some((*df_scope, df_formula.to_owned()));
|
||||
return Some(*df_scope);
|
||||
}
|
||||
}
|
||||
for (df_name, df_scope, df_formula) in &self.defined_names {
|
||||
for (df_name, df_scope) in &self.defined_names {
|
||||
if name.to_lowercase() == df_name.to_lowercase() && df_scope.is_none() {
|
||||
return Some((None, df_formula.to_owned()));
|
||||
return Some(None);
|
||||
}
|
||||
}
|
||||
None
|
||||
@@ -427,7 +411,7 @@ impl Parser {
|
||||
}
|
||||
|
||||
fn parse_range(&mut self) -> Node {
|
||||
let t = self.parse_implicit();
|
||||
let t = self.parse_primary();
|
||||
if let Node::ParseErrorKind { .. } = t {
|
||||
return t;
|
||||
}
|
||||
@@ -446,65 +430,6 @@ impl Parser {
|
||||
t
|
||||
}
|
||||
|
||||
fn parse_implicit(&mut self) -> Node {
|
||||
let next_token = self.lexer.peek_token();
|
||||
if next_token == TokenType::At {
|
||||
self.lexer.advance_token();
|
||||
let t = self.parse_primary();
|
||||
if let Node::ParseErrorKind { .. } = t {
|
||||
return t;
|
||||
}
|
||||
return Node::ImplicitIntersection {
|
||||
automatic: false,
|
||||
child: Box::new(t),
|
||||
};
|
||||
}
|
||||
self.parse_primary()
|
||||
}
|
||||
|
||||
fn parse_array_row(&mut self) -> Result<Vec<ArrayNode>, Node> {
|
||||
let mut row = Vec::new();
|
||||
// and array can only have numbers, string or booleans
|
||||
// otherwise it is a syntax error
|
||||
let first_element = match self.parse_expr() {
|
||||
Node::BooleanKind(s) => ArrayNode::Boolean(s),
|
||||
Node::NumberKind(s) => ArrayNode::Number(s),
|
||||
Node::StringKind(s) => ArrayNode::String(s),
|
||||
Node::ErrorKind(kind) => ArrayNode::Error(kind),
|
||||
error @ Node::ParseErrorKind { .. } => return Err(error),
|
||||
_ => {
|
||||
return Err(Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
message: "Invalid value in array".to_string(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
});
|
||||
}
|
||||
};
|
||||
row.push(first_element);
|
||||
let mut next_token = self.lexer.peek_token();
|
||||
// FIXME: this is not respecting the locale
|
||||
while next_token == TokenType::Comma {
|
||||
self.lexer.advance_token();
|
||||
let value = match self.parse_expr() {
|
||||
Node::BooleanKind(s) => ArrayNode::Boolean(s),
|
||||
Node::NumberKind(s) => ArrayNode::Number(s),
|
||||
Node::StringKind(s) => ArrayNode::String(s),
|
||||
Node::ErrorKind(kind) => ArrayNode::Error(kind),
|
||||
error @ Node::ParseErrorKind { .. } => return Err(error),
|
||||
_ => {
|
||||
return Err(Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
message: "Invalid value in array".to_string(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
});
|
||||
}
|
||||
};
|
||||
row.push(value);
|
||||
next_token = self.lexer.peek_token();
|
||||
}
|
||||
Ok(row)
|
||||
}
|
||||
|
||||
fn parse_primary(&mut self) -> Node {
|
||||
let next_token = self.lexer.next_token();
|
||||
match next_token {
|
||||
@@ -526,35 +451,21 @@ impl Parser {
|
||||
TokenType::Number(s) => Node::NumberKind(s),
|
||||
TokenType::String(s) => Node::StringKind(s),
|
||||
TokenType::LeftBrace => {
|
||||
// It's an array. It's a collection of rows all of the same dimension
|
||||
|
||||
let first_row = match self.parse_array_row() {
|
||||
Ok(s) => s,
|
||||
Err(error) => return error,
|
||||
};
|
||||
let length = first_row.len();
|
||||
|
||||
let mut matrix = Vec::new();
|
||||
matrix.push(first_row);
|
||||
// FIXME: this is not respecting the locale
|
||||
let t = self.parse_expr();
|
||||
if let Node::ParseErrorKind { .. } = t {
|
||||
return t;
|
||||
}
|
||||
let mut next_token = self.lexer.peek_token();
|
||||
let mut args: Vec<Node> = vec![t];
|
||||
while next_token == TokenType::Semicolon {
|
||||
self.lexer.advance_token();
|
||||
let row = match self.parse_array_row() {
|
||||
Ok(s) => s,
|
||||
Err(error) => return error,
|
||||
};
|
||||
next_token = self.lexer.peek_token();
|
||||
if row.len() != length {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
message: "All rows in an array should be the same length".to_string(),
|
||||
};
|
||||
let p = self.parse_expr();
|
||||
if let Node::ParseErrorKind { .. } = p {
|
||||
return p;
|
||||
}
|
||||
matrix.push(row);
|
||||
next_token = self.lexer.peek_token();
|
||||
args.push(p);
|
||||
}
|
||||
|
||||
if let Err(err) = self.lexer.expect(TokenType::RightBrace) {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
@@ -562,7 +473,7 @@ impl Parser {
|
||||
message: err.message,
|
||||
};
|
||||
}
|
||||
Node::ArrayKind(matrix)
|
||||
Node::ArrayKind(args)
|
||||
}
|
||||
TokenType::Reference {
|
||||
sheet,
|
||||
@@ -693,20 +604,6 @@ impl Parser {
|
||||
args,
|
||||
};
|
||||
}
|
||||
if &name == "_xlfn.SINGLE" {
|
||||
if args.len() != 1 {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
message: "Implicit Intersection requires just one argument"
|
||||
.to_string(),
|
||||
};
|
||||
}
|
||||
return Node::ImplicitIntersection {
|
||||
automatic: false,
|
||||
child: Box::new(args[0].clone()),
|
||||
};
|
||||
}
|
||||
return Node::InvalidFunctionKind { name, args };
|
||||
}
|
||||
let context = &self.context;
|
||||
@@ -717,14 +614,14 @@ impl Parser {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message: format!("sheet not found: {}", context.sheet),
|
||||
message: "sheet not found".to_string(),
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
// Could be a defined name or a table
|
||||
if let Some((scope, formula)) = self.get_defined_name(&name, context_sheet_index) {
|
||||
return Node::DefinedNameKind((name, scope, formula));
|
||||
if let Some(scope) = self.get_defined_name(&name, context_sheet_index) {
|
||||
return Node::DefinedNameKind((name, scope));
|
||||
}
|
||||
let name_lower = name.to_lowercase();
|
||||
for table_name in self.tables.keys() {
|
||||
@@ -809,14 +706,6 @@ impl Parser {
|
||||
message: "Unexpected token: 'POWER'".to_string(),
|
||||
}
|
||||
}
|
||||
TokenType::At => {
|
||||
// A primary Node cannot start with an operator
|
||||
Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message: "Unexpected token: '@'".to_string(),
|
||||
}
|
||||
}
|
||||
TokenType::RightParenthesis
|
||||
| TokenType::RightBracket
|
||||
| TokenType::Colon
|
||||
@@ -828,7 +717,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(),
|
||||
@@ -850,7 +739,7 @@ impl Parser {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message: format!("sheet not found: {}", context.sheet),
|
||||
message: "sheet not found".to_string(),
|
||||
};
|
||||
}
|
||||
};
|
||||
@@ -878,7 +767,7 @@ impl Parser {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message: format!("table sheet not found: {}", table.sheet_name),
|
||||
message: "sheet not found".to_string(),
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use super::{
|
||||
stringify::{stringify_reference, DisplaceData},
|
||||
ArrayNode, Node, Reference,
|
||||
Node, Reference,
|
||||
stringify::{DisplaceData, stringify_reference},
|
||||
};
|
||||
use crate::{
|
||||
constants::{LAST_COLUMN, LAST_ROW},
|
||||
@@ -53,24 +53,15 @@ fn move_function(name: &str, args: &Vec<Node>, move_context: &MoveContext) -> St
|
||||
arguments = to_string_moved(el, move_context);
|
||||
}
|
||||
}
|
||||
format!("{name}({arguments})")
|
||||
}
|
||||
|
||||
pub(crate) fn to_string_array_node(node: &ArrayNode) -> String {
|
||||
match node {
|
||||
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}"),
|
||||
}
|
||||
format!("{}({})", name, arguments)
|
||||
}
|
||||
|
||||
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 +232,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 +316,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 +349,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!(
|
||||
"{}^{}",
|
||||
@@ -371,41 +362,20 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
|
||||
move_function(name, args, move_context)
|
||||
}
|
||||
ArrayKind(args) => {
|
||||
let mut first_row = true;
|
||||
let mut matrix_string = String::new();
|
||||
|
||||
// Each element in `args` is assumed to be one "row" (itself a `Vec<T>`).
|
||||
for row in args {
|
||||
if !first_row {
|
||||
matrix_string.push(',');
|
||||
// This code is a placeholder. Arrays are not yet implemented
|
||||
let mut first = true;
|
||||
let mut arguments = "".to_string();
|
||||
for el in args {
|
||||
if !first {
|
||||
arguments = format!("{},{}", arguments, to_string_moved(el, move_context));
|
||||
} else {
|
||||
first_row = false;
|
||||
first = false;
|
||||
arguments = to_string_moved(el, move_context);
|
||||
}
|
||||
|
||||
// Build the string for the current row
|
||||
let mut first_col = true;
|
||||
let mut row_string = String::new();
|
||||
for el in row {
|
||||
if !first_col {
|
||||
row_string.push(',');
|
||||
} else {
|
||||
first_col = false;
|
||||
}
|
||||
|
||||
// Reuse your existing element-stringification function
|
||||
row_string.push_str(&to_string_array_node(el));
|
||||
}
|
||||
|
||||
// Enclose the row in braces
|
||||
matrix_string.push('{');
|
||||
matrix_string.push_str(&row_string);
|
||||
matrix_string.push('}');
|
||||
}
|
||||
|
||||
// Enclose the whole matrix in braces
|
||||
format!("{{{matrix_string}}}")
|
||||
format!("{{{}}}", arguments)
|
||||
}
|
||||
DefinedNameKind((name, ..)) => name.to_string(),
|
||||
DefinedNameKind((name, _)) => name.to_string(),
|
||||
TableNameKind(name) => name.to_string(),
|
||||
WrongVariableKind(name) => name.to_string(),
|
||||
CompareKind { kind, left, right } => format!(
|
||||
@@ -418,18 +388,12 @@ 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: _,
|
||||
position: _,
|
||||
} => formula.to_string(),
|
||||
EmptyArgKind => "".to_string(),
|
||||
ImplicitIntersection {
|
||||
automatic: _,
|
||||
child,
|
||||
} => {
|
||||
format!("@{}", to_string_moved(child, move_context))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,994 +0,0 @@
|
||||
use crate::functions::Function;
|
||||
|
||||
use super::Node;
|
||||
|
||||
use regex::Regex;
|
||||
use std::sync::OnceLock;
|
||||
|
||||
static RANGE_REFERENCE_REGEX: OnceLock<Regex> = OnceLock::new();
|
||||
|
||||
#[allow(clippy::expect_used)]
|
||||
fn get_re() -> &'static Regex {
|
||||
RANGE_REFERENCE_REGEX
|
||||
.get_or_init(|| Regex::new(r":[A-Z]*[0-9]*$").expect("Regex is known to be valid"))
|
||||
}
|
||||
|
||||
fn is_range_reference(s: &str) -> bool {
|
||||
get_re().is_match(s)
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
# NOTES on the Implicit Intersection operator: @
|
||||
|
||||
Sometimes we obtain a range where we expected a single argument. This can happen:
|
||||
|
||||
* As an argument of a function, eg: `SIN(A1:A5)`
|
||||
* As the result of a computation of a formula `=A1:A5`
|
||||
|
||||
In previous versions of the Friendly Giant the spreadsheet engine would perform an operation called _implicit intersection_
|
||||
that tries to find a single cell within the range. It works by picking a cell in the range that is the same row or the same column
|
||||
as the cell. If there is just one we return that otherwise we return the `#REF!` error.
|
||||
|
||||
Examples:
|
||||
|
||||
* Siting on `C3` the formula `=D1:D5` will return `D3`
|
||||
* Sitting on `C3` the formula `=D:D` will return `D3`
|
||||
* Sitting on `C3` the formula `=A1:A7` will return `A3`
|
||||
* Sitting on `C3` the formula `=A5:A8` will return `#REF!`
|
||||
* Sitting on `C3` the formula `D1:G7` will return `#REF!`
|
||||
|
||||
Today's version of the engine will result in a dynamic array spilling the result through several cells.
|
||||
To force the old behaviour we can use the _implicit intersection operator_: @
|
||||
|
||||
* `=@A1:A7` or `=SIN(@A1:A7)
|
||||
|
||||
When parsing formulas that come form old workbooks this is done automatically.
|
||||
We call this version of the II operator the _automatic_ II operator.
|
||||
|
||||
We can also insert the II operator in places where before was impossible:
|
||||
|
||||
* `=SUM(@A1:A7)`
|
||||
|
||||
This formulas will not be compatible with old versions of the engine. The FG will stringify this as `=SUM(_xlfn.SIMPLE(A1:A7))`.
|
||||
*/
|
||||
|
||||
/// Transverses the formula tree adding the implicit intersection operator in all arguments of functions that
|
||||
/// expect a scalar but get a range.
|
||||
/// * A:A => @A:A
|
||||
/// * SIN(A1:D1) => SIN(@A1:D1)
|
||||
///
|
||||
/// Assumes formula return a scalar
|
||||
pub fn add_implicit_intersection(node: &mut Node, add: bool) {
|
||||
match node {
|
||||
Node::BooleanKind(_)
|
||||
| Node::NumberKind(_)
|
||||
| Node::StringKind(_)
|
||||
| Node::ErrorKind(_)
|
||||
| Node::EmptyArgKind
|
||||
| Node::ParseErrorKind { .. }
|
||||
| Node::WrongReferenceKind { .. }
|
||||
| Node::WrongRangeKind { .. }
|
||||
| Node::InvalidFunctionKind { .. }
|
||||
| Node::ArrayKind(_)
|
||||
| Node::ReferenceKind { .. } => {}
|
||||
Node::ImplicitIntersection { child, .. } => {
|
||||
// We need to check wether the II can be automatic or not
|
||||
let mut new_node = child.as_ref().clone();
|
||||
add_implicit_intersection(&mut new_node, add);
|
||||
if matches!(&new_node, Node::ImplicitIntersection { .. }) {
|
||||
*node = new_node
|
||||
}
|
||||
}
|
||||
Node::RangeKind {
|
||||
row1,
|
||||
column1,
|
||||
row2,
|
||||
column2,
|
||||
sheet_name,
|
||||
sheet_index,
|
||||
absolute_row1,
|
||||
absolute_column1,
|
||||
absolute_row2,
|
||||
absolute_column2,
|
||||
} => {
|
||||
if add {
|
||||
*node = Node::ImplicitIntersection {
|
||||
automatic: true,
|
||||
child: Box::new(Node::RangeKind {
|
||||
sheet_name: sheet_name.clone(),
|
||||
sheet_index: *sheet_index,
|
||||
absolute_row1: *absolute_row1,
|
||||
absolute_column1: *absolute_column1,
|
||||
row1: *row1,
|
||||
column1: *column1,
|
||||
absolute_row2: *absolute_row2,
|
||||
absolute_column2: *absolute_column2,
|
||||
row2: *row2,
|
||||
column2: *column2,
|
||||
}),
|
||||
};
|
||||
}
|
||||
}
|
||||
Node::OpRangeKind { left, right } => {
|
||||
if add {
|
||||
*node = Node::ImplicitIntersection {
|
||||
automatic: true,
|
||||
child: Box::new(Node::OpRangeKind {
|
||||
left: left.clone(),
|
||||
right: right.clone(),
|
||||
}),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// operations
|
||||
Node::UnaryKind { right, .. } => add_implicit_intersection(right, add),
|
||||
Node::OpConcatenateKind { left, right }
|
||||
| Node::OpSumKind { left, right, .. }
|
||||
| Node::OpProductKind { left, right, .. }
|
||||
| Node::OpPowerKind { left, right, .. }
|
||||
| Node::CompareKind { left, right, .. } => {
|
||||
add_implicit_intersection(left, add);
|
||||
add_implicit_intersection(right, add);
|
||||
}
|
||||
|
||||
Node::DefinedNameKind(v) => {
|
||||
if add {
|
||||
// Not all defined names deserve the II operator
|
||||
// For instance =Sheet1!A1 doesn't need to be intersected
|
||||
if is_range_reference(&v.2) {
|
||||
*node = Node::ImplicitIntersection {
|
||||
automatic: true,
|
||||
child: Box::new(Node::DefinedNameKind(v.to_owned())),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Node::WrongVariableKind(v) => {
|
||||
if add {
|
||||
*node = Node::ImplicitIntersection {
|
||||
automatic: true,
|
||||
child: Box::new(Node::WrongVariableKind(v.to_owned())),
|
||||
}
|
||||
}
|
||||
}
|
||||
Node::TableNameKind(_) => {
|
||||
// noop for now
|
||||
}
|
||||
Node::FunctionKind { kind, args } => {
|
||||
let arg_count = args.len();
|
||||
let signature = get_function_args_signature(kind, arg_count);
|
||||
for index in 0..arg_count {
|
||||
if matches!(signature[index], Signature::Scalar)
|
||||
&& matches!(
|
||||
run_static_analysis_on_node(&args[index]),
|
||||
StaticResult::Range(_, _) | StaticResult::Unknown
|
||||
)
|
||||
{
|
||||
add_implicit_intersection(&mut args[index], true);
|
||||
} else {
|
||||
add_implicit_intersection(&mut args[index], false);
|
||||
}
|
||||
}
|
||||
if add
|
||||
&& matches!(
|
||||
run_static_analysis_on_node(node),
|
||||
StaticResult::Range(_, _) | StaticResult::Unknown
|
||||
)
|
||||
{
|
||||
*node = Node::ImplicitIntersection {
|
||||
automatic: true,
|
||||
child: Box::new(node.clone()),
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
pub(crate) enum StaticResult {
|
||||
Scalar,
|
||||
Array(i32, i32),
|
||||
Range(i32, i32),
|
||||
Unknown,
|
||||
// TODO: What if one of the dimensions is known?
|
||||
// what if the dimensions are unknown but bounded?
|
||||
}
|
||||
|
||||
fn static_analysis_op_nodes(left: &Node, right: &Node) -> StaticResult {
|
||||
let lhs = run_static_analysis_on_node(left);
|
||||
let rhs = run_static_analysis_on_node(right);
|
||||
match (lhs, rhs) {
|
||||
(StaticResult::Scalar, StaticResult::Scalar) => StaticResult::Scalar,
|
||||
(StaticResult::Scalar, StaticResult::Array(a, b) | StaticResult::Range(a, b)) => {
|
||||
StaticResult::Array(a, b)
|
||||
}
|
||||
|
||||
(StaticResult::Array(a, b) | StaticResult::Range(a, b), StaticResult::Scalar) => {
|
||||
StaticResult::Array(a, b)
|
||||
}
|
||||
(
|
||||
StaticResult::Array(a1, b1) | StaticResult::Range(a1, b1),
|
||||
StaticResult::Array(a2, b2) | StaticResult::Range(a2, b2),
|
||||
) => StaticResult::Array(a1.max(a2), b1.max(b2)),
|
||||
|
||||
(_, StaticResult::Unknown) => StaticResult::Unknown,
|
||||
(StaticResult::Unknown, _) => StaticResult::Unknown,
|
||||
}
|
||||
}
|
||||
|
||||
// Returns:
|
||||
// * Scalar if we can proof the result of the evaluation is a scalar
|
||||
// * Array(a, b) if we know it will be an a x b array.
|
||||
// * Range(a, b) if we know it will be a a x b range.
|
||||
// * Unknown if we cannot guaranty either
|
||||
fn run_static_analysis_on_node(node: &Node) -> StaticResult {
|
||||
match node {
|
||||
Node::BooleanKind(_)
|
||||
| Node::NumberKind(_)
|
||||
| Node::StringKind(_)
|
||||
| Node::ErrorKind(_)
|
||||
| Node::EmptyArgKind => StaticResult::Scalar,
|
||||
Node::UnaryKind { right, .. } => run_static_analysis_on_node(right),
|
||||
Node::ParseErrorKind { .. } => {
|
||||
// StaticResult::Unknown is also valid
|
||||
StaticResult::Scalar
|
||||
}
|
||||
Node::WrongReferenceKind { .. } => {
|
||||
// StaticResult::Unknown is also valid
|
||||
StaticResult::Scalar
|
||||
}
|
||||
Node::WrongRangeKind { .. } => {
|
||||
// StaticResult::Unknown or Array is also valid
|
||||
StaticResult::Scalar
|
||||
}
|
||||
Node::InvalidFunctionKind { .. } => {
|
||||
// StaticResult::Unknown is also valid
|
||||
StaticResult::Scalar
|
||||
}
|
||||
Node::ArrayKind(array) => {
|
||||
let n = array.len() as i32;
|
||||
// FIXME: This is a placeholder until we implement arrays
|
||||
StaticResult::Array(n, 1)
|
||||
}
|
||||
Node::RangeKind {
|
||||
row1,
|
||||
column1,
|
||||
row2,
|
||||
column2,
|
||||
..
|
||||
} => StaticResult::Range(row2 - row1, column2 - column1),
|
||||
Node::OpRangeKind { .. } => {
|
||||
// TODO: We could do a bit better here
|
||||
StaticResult::Unknown
|
||||
}
|
||||
Node::ReferenceKind { .. } => StaticResult::Scalar,
|
||||
|
||||
// binary operations
|
||||
Node::OpConcatenateKind { left, right } => static_analysis_op_nodes(left, right),
|
||||
Node::OpSumKind { left, right, .. } => static_analysis_op_nodes(left, right),
|
||||
Node::OpProductKind { left, right, .. } => static_analysis_op_nodes(left, right),
|
||||
Node::OpPowerKind { left, right, .. } => static_analysis_op_nodes(left, right),
|
||||
Node::CompareKind { left, right, .. } => static_analysis_op_nodes(left, right),
|
||||
|
||||
// defined names
|
||||
Node::DefinedNameKind(_) => StaticResult::Unknown,
|
||||
Node::WrongVariableKind(_) => StaticResult::Unknown,
|
||||
Node::TableNameKind(_) => StaticResult::Unknown,
|
||||
Node::FunctionKind { kind, args } => static_analysis_on_function(kind, args),
|
||||
Node::ImplicitIntersection { .. } => StaticResult::Scalar,
|
||||
}
|
||||
}
|
||||
|
||||
// If all the arguments are scalars the function will return a scalar
|
||||
// If any of the arguments is a range or an array it will return an array
|
||||
fn scalar_arguments(args: &[Node]) -> StaticResult {
|
||||
let mut n = 0;
|
||||
let mut m = 0;
|
||||
for arg in args {
|
||||
match run_static_analysis_on_node(arg) {
|
||||
StaticResult::Scalar => {
|
||||
// noop
|
||||
}
|
||||
StaticResult::Array(a, b) | StaticResult::Range(a, b) => {
|
||||
n = n.max(a);
|
||||
m = m.max(b);
|
||||
}
|
||||
StaticResult::Unknown => return StaticResult::Unknown,
|
||||
}
|
||||
}
|
||||
if n == 0 && m == 0 {
|
||||
return StaticResult::Scalar;
|
||||
}
|
||||
StaticResult::Array(n, m)
|
||||
}
|
||||
|
||||
// We only care if the function can return a range or not
|
||||
fn not_implemented(_args: &[Node]) -> StaticResult {
|
||||
StaticResult::Scalar
|
||||
}
|
||||
|
||||
fn static_analysis_offset(args: &[Node]) -> StaticResult {
|
||||
// If first argument is a single cell reference and there are no4th and 5th argument,
|
||||
// or they are 1, then it is a scalar
|
||||
let arg_count = args.len();
|
||||
if arg_count < 3 {
|
||||
// Actually an error
|
||||
return StaticResult::Scalar;
|
||||
}
|
||||
if !matches!(args[0], Node::ReferenceKind { .. }) {
|
||||
return StaticResult::Unknown;
|
||||
}
|
||||
if arg_count == 3 {
|
||||
return StaticResult::Scalar;
|
||||
}
|
||||
match args[3] {
|
||||
Node::NumberKind(f) => {
|
||||
if f != 1.0 {
|
||||
return StaticResult::Unknown;
|
||||
}
|
||||
}
|
||||
_ => return StaticResult::Unknown,
|
||||
};
|
||||
if arg_count == 4 {
|
||||
return StaticResult::Scalar;
|
||||
}
|
||||
match args[4] {
|
||||
Node::NumberKind(f) => {
|
||||
if f != 1.0 {
|
||||
return StaticResult::Unknown;
|
||||
}
|
||||
}
|
||||
_ => return StaticResult::Unknown,
|
||||
};
|
||||
StaticResult::Unknown
|
||||
}
|
||||
|
||||
// fn static_analysis_choose(_args: &[Node]) -> StaticResult {
|
||||
// // We will always insert the @ in CHOOSE, but technically it is only needed if one of the elements is a range
|
||||
// StaticResult::Unknown
|
||||
// }
|
||||
|
||||
fn static_analysis_indirect(_args: &[Node]) -> StaticResult {
|
||||
// We will always insert the @, but we don't need to do that in every scenario`
|
||||
StaticResult::Unknown
|
||||
}
|
||||
|
||||
fn static_analysis_index(_args: &[Node]) -> StaticResult {
|
||||
// INDEX has two forms, but they are indistinguishable at parse time.
|
||||
StaticResult::Unknown
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
enum Signature {
|
||||
Scalar,
|
||||
Vector,
|
||||
Error,
|
||||
}
|
||||
|
||||
fn args_signature_no_args(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count == 0 {
|
||||
vec![]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
|
||||
fn args_signature_scalars(
|
||||
arg_count: usize,
|
||||
required_count: usize,
|
||||
optional_count: usize,
|
||||
) -> Vec<Signature> {
|
||||
if arg_count >= required_count && arg_count <= required_count + optional_count {
|
||||
vec![Signature::Scalar; arg_count]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
|
||||
fn args_signature_one_vector(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count == 1 {
|
||||
vec![Signature::Vector]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
|
||||
fn args_signature_sumif(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count == 2 {
|
||||
vec![Signature::Vector, Signature::Scalar]
|
||||
} else if arg_count == 3 {
|
||||
vec![Signature::Vector, Signature::Scalar, Signature::Vector]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
|
||||
// 1 or none scalars
|
||||
fn args_signature_sheet(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count == 0 {
|
||||
vec![]
|
||||
} else if arg_count == 1 {
|
||||
vec![Signature::Scalar]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
|
||||
fn args_signature_hlookup(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count == 3 {
|
||||
vec![Signature::Vector, Signature::Vector, Signature::Scalar]
|
||||
} else if arg_count == 4 {
|
||||
vec![
|
||||
Signature::Vector,
|
||||
Signature::Vector,
|
||||
Signature::Scalar,
|
||||
Signature::Vector,
|
||||
]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
|
||||
fn args_signature_index(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count == 2 {
|
||||
vec![Signature::Vector, Signature::Scalar]
|
||||
} else if arg_count == 3 {
|
||||
vec![Signature::Vector, Signature::Scalar, Signature::Scalar]
|
||||
} else if arg_count == 4 {
|
||||
vec![
|
||||
Signature::Vector,
|
||||
Signature::Scalar,
|
||||
Signature::Scalar,
|
||||
Signature::Scalar,
|
||||
]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
|
||||
fn args_signature_lookup(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count == 2 {
|
||||
vec![Signature::Vector, Signature::Vector]
|
||||
} else if arg_count == 3 {
|
||||
vec![Signature::Vector, Signature::Vector, Signature::Vector]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
|
||||
fn args_signature_match(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count == 2 {
|
||||
vec![Signature::Vector, Signature::Vector]
|
||||
} else if arg_count == 3 {
|
||||
vec![Signature::Vector, Signature::Vector, Signature::Scalar]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
|
||||
fn args_signature_offset(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count == 3 {
|
||||
vec![Signature::Vector, Signature::Scalar, Signature::Scalar]
|
||||
} else if arg_count == 4 {
|
||||
vec![
|
||||
Signature::Vector,
|
||||
Signature::Scalar,
|
||||
Signature::Scalar,
|
||||
Signature::Scalar,
|
||||
]
|
||||
} else if arg_count == 5 {
|
||||
vec![
|
||||
Signature::Vector,
|
||||
Signature::Scalar,
|
||||
Signature::Scalar,
|
||||
Signature::Scalar,
|
||||
Signature::Scalar,
|
||||
]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
|
||||
fn args_signature_row(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count == 0 {
|
||||
vec![]
|
||||
} else if arg_count == 1 {
|
||||
vec![Signature::Vector]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
|
||||
fn args_signature_xlookup(arg_count: usize) -> Vec<Signature> {
|
||||
if !(3..=6).contains(&arg_count) {
|
||||
return vec![Signature::Error; arg_count];
|
||||
}
|
||||
let mut result = vec![Signature::Scalar; arg_count];
|
||||
result[0] = Signature::Vector;
|
||||
result[1] = Signature::Vector;
|
||||
result[2] = Signature::Vector;
|
||||
result
|
||||
}
|
||||
|
||||
fn args_signature_textafter(arg_count: usize) -> Vec<Signature> {
|
||||
if !(2..=6).contains(&arg_count) {
|
||||
vec![Signature::Scalar; arg_count]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
|
||||
fn args_signature_textjoin(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count >= 3 {
|
||||
let mut result = vec![Signature::Vector; arg_count];
|
||||
result[0] = Signature::Scalar;
|
||||
result[1] = Signature::Scalar;
|
||||
result
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
|
||||
fn args_signature_npv(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count < 2 {
|
||||
return vec![Signature::Error; arg_count];
|
||||
}
|
||||
let mut result = vec![Signature::Vector; arg_count];
|
||||
result[0] = Signature::Scalar;
|
||||
result
|
||||
}
|
||||
|
||||
fn args_signature_irr(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count > 2 {
|
||||
vec![Signature::Error; arg_count]
|
||||
} else if arg_count == 1 {
|
||||
vec![Signature::Vector]
|
||||
} else {
|
||||
vec![Signature::Vector, Signature::Scalar]
|
||||
}
|
||||
}
|
||||
|
||||
fn args_signature_xirr(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count == 2 {
|
||||
vec![Signature::Vector; arg_count]
|
||||
} else if arg_count == 3 {
|
||||
vec![Signature::Vector, Signature::Vector, Signature::Scalar]
|
||||
} else {
|
||||
vec![Signature::Error; arg_count]
|
||||
}
|
||||
}
|
||||
|
||||
fn args_signature_mirr(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count != 3 {
|
||||
vec![Signature::Error; arg_count]
|
||||
} else {
|
||||
vec![Signature::Vector, Signature::Scalar, Signature::Scalar]
|
||||
}
|
||||
}
|
||||
|
||||
fn args_signature_xnpv(arg_count: usize) -> Vec<Signature> {
|
||||
if arg_count != 3 {
|
||||
vec![Signature::Error; arg_count]
|
||||
} else {
|
||||
vec![Signature::Scalar, Signature::Vector, Signature::Vector]
|
||||
}
|
||||
}
|
||||
|
||||
// FIXME: This is terrible duplications of efforts. We use the signature in at least three different places:
|
||||
// 1. When computing the function
|
||||
// 2. Checking the arguments to see if we need to insert the implicit intersection operator
|
||||
// 3. Understanding the return value
|
||||
//
|
||||
// The signature of the functions should be defined only once
|
||||
|
||||
// Given a function and a number of arguments this returns the arguments at each position
|
||||
// are expected to be scalars or vectors (array/ranges).
|
||||
// Sets signature::Error to all arguments if the number of arguments is incorrect.
|
||||
fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signature> {
|
||||
match kind {
|
||||
Function::And => vec![Signature::Vector; arg_count],
|
||||
Function::False => args_signature_no_args(arg_count),
|
||||
Function::If => args_signature_scalars(arg_count, 2, 1),
|
||||
Function::Iferror => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Ifna => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Ifs => vec![Signature::Scalar; arg_count],
|
||||
Function::Not => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Or => vec![Signature::Vector; arg_count],
|
||||
Function::Switch => vec![Signature::Scalar; arg_count],
|
||||
Function::True => args_signature_no_args(arg_count),
|
||||
Function::Xor => vec![Signature::Vector; arg_count],
|
||||
Function::Abs => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Acos => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Acosh => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Asin => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Asinh => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Atan => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Atan2 => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Atanh => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Choose => vec![Signature::Scalar; arg_count],
|
||||
Function::Column => args_signature_row(arg_count),
|
||||
Function::Columns => args_signature_one_vector(arg_count),
|
||||
Function::Ln => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Log => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Log10 => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Cos => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Cosh => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Max => vec![Signature::Vector; arg_count],
|
||||
Function::Min => vec![Signature::Vector; arg_count],
|
||||
Function::Pi => args_signature_no_args(arg_count),
|
||||
Function::Power => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Product => vec![Signature::Vector; arg_count],
|
||||
Function::Round => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Rounddown => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Roundup => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Sin => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Sinh => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Sqrt => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Sqrtpi => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Sum => vec![Signature::Vector; arg_count],
|
||||
Function::Sumif => args_signature_sumif(arg_count),
|
||||
Function::Sumifs => vec![Signature::Vector; arg_count],
|
||||
Function::Tan => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Tanh => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::ErrorType => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Isblank => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Iserr => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Iserror => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Iseven => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Isformula => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Islogical => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Isna => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Isnontext => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Isnumber => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Isodd => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Isref => args_signature_one_vector(arg_count),
|
||||
Function::Istext => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Na => args_signature_no_args(arg_count),
|
||||
Function::Sheet => args_signature_sheet(arg_count),
|
||||
Function::Type => args_signature_one_vector(arg_count),
|
||||
Function::Hlookup => args_signature_hlookup(arg_count),
|
||||
Function::Index => args_signature_index(arg_count),
|
||||
Function::Indirect => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Lookup => args_signature_lookup(arg_count),
|
||||
Function::Match => args_signature_match(arg_count),
|
||||
Function::Offset => args_signature_offset(arg_count),
|
||||
Function::Row => args_signature_row(arg_count),
|
||||
Function::Rows => args_signature_one_vector(arg_count),
|
||||
Function::Vlookup => args_signature_hlookup(arg_count),
|
||||
Function::Xlookup => args_signature_xlookup(arg_count),
|
||||
Function::Concat => vec![Signature::Vector; arg_count],
|
||||
Function::Concatenate => vec![Signature::Scalar; arg_count],
|
||||
Function::Exact => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Find => args_signature_scalars(arg_count, 2, 1),
|
||||
Function::Left => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Len => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Lower => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Mid => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::Rept => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Right => args_signature_scalars(arg_count, 2, 1),
|
||||
Function::Search => args_signature_scalars(arg_count, 2, 1),
|
||||
Function::Substitute => args_signature_scalars(arg_count, 3, 1),
|
||||
Function::T => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Text => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Textafter => args_signature_textafter(arg_count),
|
||||
Function::Textbefore => args_signature_textafter(arg_count),
|
||||
Function::Textjoin => args_signature_textjoin(arg_count),
|
||||
Function::Trim => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Upper => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Value => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Valuetotext => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Average => vec![Signature::Vector; arg_count],
|
||||
Function::Averagea => vec![Signature::Vector; arg_count],
|
||||
Function::Averageif => args_signature_sumif(arg_count),
|
||||
Function::Averageifs => vec![Signature::Vector; arg_count],
|
||||
Function::Count => vec![Signature::Vector; arg_count],
|
||||
Function::Counta => vec![Signature::Vector; arg_count],
|
||||
Function::Countblank => vec![Signature::Vector; arg_count],
|
||||
Function::Countif => args_signature_sumif(arg_count),
|
||||
Function::Countifs => vec![Signature::Vector; arg_count],
|
||||
Function::Maxifs => vec![Signature::Vector; arg_count],
|
||||
Function::Minifs => vec![Signature::Vector; arg_count],
|
||||
Function::Date => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::Day => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Edate => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Eomonth => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Month => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Now => args_signature_no_args(arg_count),
|
||||
Function::Today => args_signature_no_args(arg_count),
|
||||
Function::Year => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Cumipmt => args_signature_scalars(arg_count, 6, 0),
|
||||
Function::Cumprinc => args_signature_scalars(arg_count, 6, 0),
|
||||
Function::Db => args_signature_scalars(arg_count, 4, 1),
|
||||
Function::Ddb => args_signature_scalars(arg_count, 4, 1),
|
||||
Function::Dollarde => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Dollarfr => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Effect => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Fv => args_signature_scalars(arg_count, 3, 2),
|
||||
Function::Ipmt => args_signature_scalars(arg_count, 4, 2),
|
||||
Function::Irr => args_signature_irr(arg_count),
|
||||
Function::Ispmt => args_signature_scalars(arg_count, 4, 0),
|
||||
Function::Mirr => args_signature_mirr(arg_count),
|
||||
Function::Nominal => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Nper => args_signature_scalars(arg_count, 3, 2),
|
||||
Function::Npv => args_signature_npv(arg_count),
|
||||
Function::Pduration => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::Pmt => args_signature_scalars(arg_count, 3, 2),
|
||||
Function::Ppmt => args_signature_scalars(arg_count, 4, 2),
|
||||
Function::Pv => args_signature_scalars(arg_count, 3, 2),
|
||||
Function::Rate => args_signature_scalars(arg_count, 3, 3),
|
||||
Function::Rri => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::Sln => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::Syd => args_signature_scalars(arg_count, 4, 0),
|
||||
Function::Tbilleq => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::Tbillprice => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::Tbillyield => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::Xirr => args_signature_xirr(arg_count),
|
||||
Function::Xnpv => args_signature_xnpv(arg_count),
|
||||
Function::Besseli => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Besselj => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Besselk => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Bessely => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Erf => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Erfc => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::ErfcPrecise => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::ErfPrecise => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Bin2dec => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Bin2hex => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Bin2oct => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Dec2Bin => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Dec2hex => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Dec2oct => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Hex2bin => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Hex2dec => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Hex2oct => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Oct2bin => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Oct2dec => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Oct2hex => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Bitand => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Bitlshift => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Bitor => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Bitrshift => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Bitxor => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Complex => args_signature_scalars(arg_count, 2, 1),
|
||||
Function::Imabs => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imaginary => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imargument => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imconjugate => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imcos => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imcosh => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imcot => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imcsc => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imcsch => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imdiv => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Imexp => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imln => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imlog10 => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imlog2 => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Impower => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Improduct => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Imreal => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imsec => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imsech => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imsin => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imsinh => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imsqrt => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Imsub => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Imsum => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Imtan => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Convert => args_signature_scalars(arg_count, 3, 0),
|
||||
Function::Delta => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Gestep => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Subtotal => args_signature_npv(arg_count),
|
||||
Function::Rand => args_signature_no_args(arg_count),
|
||||
Function::Randbetween => args_signature_scalars(arg_count, 2, 0),
|
||||
Function::Formulatext => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Unicode => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Geomean => vec![Signature::Vector; arg_count],
|
||||
}
|
||||
}
|
||||
|
||||
// Returns the type of the result (Scalar, Array or Range) depending on the arguments
|
||||
fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
|
||||
match kind {
|
||||
Function::And => StaticResult::Scalar,
|
||||
Function::False => StaticResult::Scalar,
|
||||
Function::If => scalar_arguments(args),
|
||||
Function::Iferror => scalar_arguments(args),
|
||||
Function::Ifna => scalar_arguments(args),
|
||||
Function::Ifs => not_implemented(args),
|
||||
Function::Not => StaticResult::Scalar,
|
||||
Function::Or => StaticResult::Scalar,
|
||||
Function::Switch => not_implemented(args),
|
||||
Function::True => StaticResult::Scalar,
|
||||
Function::Xor => StaticResult::Scalar,
|
||||
Function::Abs => scalar_arguments(args),
|
||||
Function::Acos => scalar_arguments(args),
|
||||
Function::Acosh => scalar_arguments(args),
|
||||
Function::Asin => scalar_arguments(args),
|
||||
Function::Asinh => scalar_arguments(args),
|
||||
Function::Atan => scalar_arguments(args),
|
||||
Function::Atan2 => scalar_arguments(args),
|
||||
Function::Atanh => scalar_arguments(args),
|
||||
Function::Choose => scalar_arguments(args), // static_analysis_choose(args, cell),
|
||||
Function::Column => not_implemented(args),
|
||||
Function::Columns => not_implemented(args),
|
||||
Function::Cos => scalar_arguments(args),
|
||||
Function::Cosh => scalar_arguments(args),
|
||||
Function::Max => StaticResult::Scalar,
|
||||
Function::Min => StaticResult::Scalar,
|
||||
Function::Pi => StaticResult::Scalar,
|
||||
Function::Power => scalar_arguments(args),
|
||||
Function::Product => not_implemented(args),
|
||||
Function::Round => scalar_arguments(args),
|
||||
Function::Rounddown => scalar_arguments(args),
|
||||
Function::Roundup => scalar_arguments(args),
|
||||
Function::Ln => scalar_arguments(args),
|
||||
Function::Log => scalar_arguments(args),
|
||||
Function::Log10 => scalar_arguments(args),
|
||||
Function::Sin => scalar_arguments(args),
|
||||
Function::Sinh => scalar_arguments(args),
|
||||
Function::Sqrt => scalar_arguments(args),
|
||||
Function::Sqrtpi => StaticResult::Scalar,
|
||||
Function::Sum => StaticResult::Scalar,
|
||||
Function::Sumif => not_implemented(args),
|
||||
Function::Sumifs => not_implemented(args),
|
||||
Function::Tan => scalar_arguments(args),
|
||||
Function::Tanh => scalar_arguments(args),
|
||||
Function::ErrorType => not_implemented(args),
|
||||
Function::Isblank => not_implemented(args),
|
||||
Function::Iserr => not_implemented(args),
|
||||
Function::Iserror => not_implemented(args),
|
||||
Function::Iseven => not_implemented(args),
|
||||
Function::Isformula => not_implemented(args),
|
||||
Function::Islogical => not_implemented(args),
|
||||
Function::Isna => not_implemented(args),
|
||||
Function::Isnontext => not_implemented(args),
|
||||
Function::Isnumber => not_implemented(args),
|
||||
Function::Isodd => not_implemented(args),
|
||||
Function::Isref => not_implemented(args),
|
||||
Function::Istext => not_implemented(args),
|
||||
Function::Na => StaticResult::Scalar,
|
||||
Function::Sheet => StaticResult::Scalar,
|
||||
Function::Type => not_implemented(args),
|
||||
Function::Hlookup => not_implemented(args),
|
||||
Function::Index => static_analysis_index(args),
|
||||
Function::Indirect => static_analysis_indirect(args),
|
||||
Function::Lookup => not_implemented(args),
|
||||
Function::Match => not_implemented(args),
|
||||
Function::Offset => static_analysis_offset(args),
|
||||
// FIXME: Row could return an array
|
||||
Function::Row => StaticResult::Scalar,
|
||||
Function::Rows => not_implemented(args),
|
||||
Function::Vlookup => not_implemented(args),
|
||||
Function::Xlookup => not_implemented(args),
|
||||
Function::Concat => not_implemented(args),
|
||||
Function::Concatenate => not_implemented(args),
|
||||
Function::Exact => not_implemented(args),
|
||||
Function::Find => not_implemented(args),
|
||||
Function::Left => not_implemented(args),
|
||||
Function::Len => not_implemented(args),
|
||||
Function::Lower => not_implemented(args),
|
||||
Function::Mid => not_implemented(args),
|
||||
Function::Rept => not_implemented(args),
|
||||
Function::Right => not_implemented(args),
|
||||
Function::Search => not_implemented(args),
|
||||
Function::Substitute => not_implemented(args),
|
||||
Function::T => not_implemented(args),
|
||||
Function::Text => not_implemented(args),
|
||||
Function::Textafter => not_implemented(args),
|
||||
Function::Textbefore => not_implemented(args),
|
||||
Function::Textjoin => not_implemented(args),
|
||||
Function::Trim => not_implemented(args),
|
||||
Function::Unicode => not_implemented(args),
|
||||
Function::Upper => not_implemented(args),
|
||||
Function::Value => not_implemented(args),
|
||||
Function::Valuetotext => not_implemented(args),
|
||||
Function::Average => not_implemented(args),
|
||||
Function::Averagea => not_implemented(args),
|
||||
Function::Averageif => not_implemented(args),
|
||||
Function::Averageifs => not_implemented(args),
|
||||
Function::Count => not_implemented(args),
|
||||
Function::Counta => not_implemented(args),
|
||||
Function::Countblank => not_implemented(args),
|
||||
Function::Countif => not_implemented(args),
|
||||
Function::Countifs => not_implemented(args),
|
||||
Function::Maxifs => not_implemented(args),
|
||||
Function::Minifs => not_implemented(args),
|
||||
Function::Date => not_implemented(args),
|
||||
Function::Day => not_implemented(args),
|
||||
Function::Edate => not_implemented(args),
|
||||
Function::Month => not_implemented(args),
|
||||
Function::Now => not_implemented(args),
|
||||
Function::Today => not_implemented(args),
|
||||
Function::Year => not_implemented(args),
|
||||
Function::Cumipmt => not_implemented(args),
|
||||
Function::Cumprinc => not_implemented(args),
|
||||
Function::Db => not_implemented(args),
|
||||
Function::Ddb => not_implemented(args),
|
||||
Function::Dollarde => not_implemented(args),
|
||||
Function::Dollarfr => not_implemented(args),
|
||||
Function::Effect => not_implemented(args),
|
||||
Function::Fv => not_implemented(args),
|
||||
Function::Ipmt => not_implemented(args),
|
||||
Function::Irr => not_implemented(args),
|
||||
Function::Ispmt => not_implemented(args),
|
||||
Function::Mirr => not_implemented(args),
|
||||
Function::Nominal => not_implemented(args),
|
||||
Function::Nper => not_implemented(args),
|
||||
Function::Npv => not_implemented(args),
|
||||
Function::Pduration => not_implemented(args),
|
||||
Function::Pmt => not_implemented(args),
|
||||
Function::Ppmt => not_implemented(args),
|
||||
Function::Pv => not_implemented(args),
|
||||
Function::Rate => not_implemented(args),
|
||||
Function::Rri => not_implemented(args),
|
||||
Function::Sln => not_implemented(args),
|
||||
Function::Syd => not_implemented(args),
|
||||
Function::Tbilleq => not_implemented(args),
|
||||
Function::Tbillprice => not_implemented(args),
|
||||
Function::Tbillyield => not_implemented(args),
|
||||
Function::Xirr => not_implemented(args),
|
||||
Function::Xnpv => not_implemented(args),
|
||||
Function::Besseli => scalar_arguments(args),
|
||||
Function::Besselj => scalar_arguments(args),
|
||||
Function::Besselk => scalar_arguments(args),
|
||||
Function::Bessely => scalar_arguments(args),
|
||||
Function::Erf => scalar_arguments(args),
|
||||
Function::Erfc => scalar_arguments(args),
|
||||
Function::ErfcPrecise => scalar_arguments(args),
|
||||
Function::ErfPrecise => scalar_arguments(args),
|
||||
Function::Bin2dec => scalar_arguments(args),
|
||||
Function::Bin2hex => scalar_arguments(args),
|
||||
Function::Bin2oct => scalar_arguments(args),
|
||||
Function::Dec2Bin => scalar_arguments(args),
|
||||
Function::Dec2hex => scalar_arguments(args),
|
||||
Function::Dec2oct => scalar_arguments(args),
|
||||
Function::Hex2bin => scalar_arguments(args),
|
||||
Function::Hex2dec => scalar_arguments(args),
|
||||
Function::Hex2oct => scalar_arguments(args),
|
||||
Function::Oct2bin => scalar_arguments(args),
|
||||
Function::Oct2dec => scalar_arguments(args),
|
||||
Function::Oct2hex => scalar_arguments(args),
|
||||
Function::Bitand => scalar_arguments(args),
|
||||
Function::Bitlshift => scalar_arguments(args),
|
||||
Function::Bitor => scalar_arguments(args),
|
||||
Function::Bitrshift => scalar_arguments(args),
|
||||
Function::Bitxor => scalar_arguments(args),
|
||||
Function::Complex => scalar_arguments(args),
|
||||
Function::Imabs => scalar_arguments(args),
|
||||
Function::Imaginary => scalar_arguments(args),
|
||||
Function::Imargument => scalar_arguments(args),
|
||||
Function::Imconjugate => scalar_arguments(args),
|
||||
Function::Imcos => scalar_arguments(args),
|
||||
Function::Imcosh => scalar_arguments(args),
|
||||
Function::Imcot => scalar_arguments(args),
|
||||
Function::Imcsc => scalar_arguments(args),
|
||||
Function::Imcsch => scalar_arguments(args),
|
||||
Function::Imdiv => scalar_arguments(args),
|
||||
Function::Imexp => scalar_arguments(args),
|
||||
Function::Imln => scalar_arguments(args),
|
||||
Function::Imlog10 => scalar_arguments(args),
|
||||
Function::Imlog2 => scalar_arguments(args),
|
||||
Function::Impower => scalar_arguments(args),
|
||||
Function::Improduct => scalar_arguments(args),
|
||||
Function::Imreal => scalar_arguments(args),
|
||||
Function::Imsec => scalar_arguments(args),
|
||||
Function::Imsech => scalar_arguments(args),
|
||||
Function::Imsin => scalar_arguments(args),
|
||||
Function::Imsinh => scalar_arguments(args),
|
||||
Function::Imsqrt => scalar_arguments(args),
|
||||
Function::Imsub => scalar_arguments(args),
|
||||
Function::Imsum => scalar_arguments(args),
|
||||
Function::Imtan => scalar_arguments(args),
|
||||
Function::Convert => not_implemented(args),
|
||||
Function::Delta => not_implemented(args),
|
||||
Function::Gestep => not_implemented(args),
|
||||
Function::Subtotal => not_implemented(args),
|
||||
Function::Rand => not_implemented(args),
|
||||
Function::Randbetween => scalar_arguments(args),
|
||||
Function::Eomonth => scalar_arguments(args),
|
||||
Function::Formulatext => not_implemented(args),
|
||||
Function::Geomean => not_implemented(args),
|
||||
}
|
||||
}
|
||||
@@ -1,8 +1,6 @@
|
||||
use super::{super::utils::quote_name, Node, Reference};
|
||||
use crate::constants::{LAST_COLUMN, LAST_ROW};
|
||||
use crate::expressions::parser::move_formula::to_string_array_node;
|
||||
use crate::expressions::parser::static_analysis::add_implicit_intersection;
|
||||
use crate::expressions::token::{OpSum, OpUnary};
|
||||
use crate::expressions::token::OpUnary;
|
||||
use crate::{expressions::types::CellReferenceRC, number_format::to_excel_precision_str};
|
||||
|
||||
pub enum DisplaceData {
|
||||
@@ -28,11 +26,6 @@ pub enum DisplaceData {
|
||||
column: i32,
|
||||
delta: i32,
|
||||
},
|
||||
RowMove {
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
delta: i32,
|
||||
},
|
||||
ColumnMove {
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
@@ -41,21 +34,10 @@ pub enum DisplaceData {
|
||||
None,
|
||||
}
|
||||
|
||||
/// This is the internal mode in IronCalc
|
||||
pub fn to_rc_format(node: &Node) -> String {
|
||||
stringify(node, None, &DisplaceData::None, false)
|
||||
}
|
||||
|
||||
/// This is the mode used to display the formula in the UI
|
||||
pub fn to_string(node: &Node, context: &CellReferenceRC) -> String {
|
||||
stringify(node, Some(context), &DisplaceData::None, false)
|
||||
}
|
||||
|
||||
/// This is the mode used to export the formula to Excel
|
||||
pub fn to_excel_string(node: &Node, context: &CellReferenceRC) -> String {
|
||||
stringify(node, Some(context), &DisplaceData::None, true)
|
||||
}
|
||||
|
||||
pub fn to_string_displaced(
|
||||
node: &Node,
|
||||
context: &CellReferenceRC,
|
||||
@@ -64,10 +46,18 @@ pub fn to_string_displaced(
|
||||
stringify(node, Some(context), displace_data, false)
|
||||
}
|
||||
|
||||
pub fn to_string(node: &Node, context: &CellReferenceRC) -> String {
|
||||
stringify(node, Some(context), &DisplaceData::None, false)
|
||||
}
|
||||
|
||||
pub fn to_excel_string(node: &Node, context: &CellReferenceRC) -> String {
|
||||
stringify(node, Some(context), &DisplaceData::None, true)
|
||||
}
|
||||
|
||||
/// Converts a local reference to a string applying some displacement if needed.
|
||||
/// It uses A1 style if context is not None. If context is None it uses R1C1 style
|
||||
/// If full_row is true then the row details will be omitted in the A1 case
|
||||
/// If full_column is true then column details will be omitted.
|
||||
/// If full_colum is true then column details will be omitted.
|
||||
pub(crate) fn stringify_reference(
|
||||
context: Option<&CellReferenceRC>,
|
||||
displace_data: &DisplaceData,
|
||||
@@ -164,29 +154,6 @@ pub(crate) fn stringify_reference(
|
||||
}
|
||||
}
|
||||
}
|
||||
DisplaceData::RowMove {
|
||||
sheet,
|
||||
row: move_row,
|
||||
delta,
|
||||
} => {
|
||||
if sheet_index == *sheet {
|
||||
if row == *move_row {
|
||||
row += *delta;
|
||||
} else if *delta > 0 {
|
||||
// Moving the row downwards
|
||||
if row > *move_row && row <= *move_row + *delta {
|
||||
// Intermediate rows move up by one position
|
||||
row -= 1;
|
||||
}
|
||||
} else if *delta < 0 {
|
||||
// Moving the row upwards
|
||||
if row < *move_row && row >= *move_row + *delta {
|
||||
// Intermediate rows move down by one position
|
||||
row += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
DisplaceData::ColumnMove {
|
||||
sheet,
|
||||
column: move_column,
|
||||
@@ -195,18 +162,14 @@ pub(crate) fn stringify_reference(
|
||||
if sheet_index == *sheet {
|
||||
if column == *move_column {
|
||||
column += *delta;
|
||||
} else if *delta > 0 {
|
||||
// Moving the column to the right
|
||||
if column > *move_column && column <= *move_column + *delta {
|
||||
// Intermediate columns move left by one position
|
||||
column -= 1;
|
||||
}
|
||||
} else if *delta < 0 {
|
||||
// Moving the column to the left
|
||||
if column < *move_column && column >= *move_column + *delta {
|
||||
// Intermediate columns move right by one position
|
||||
column += 1;
|
||||
}
|
||||
} else if (*delta > 0
|
||||
&& column > *move_column
|
||||
&& column <= *move_column + *delta)
|
||||
|| (*delta < 0
|
||||
&& column < *move_column
|
||||
&& column >= *move_column + *delta)
|
||||
{
|
||||
column -= *delta;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -216,16 +179,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
|
||||
};
|
||||
@@ -240,27 +203,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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -272,7 +235,7 @@ fn format_function(
|
||||
args: &Vec<Node>,
|
||||
context: Option<&CellReferenceRC>,
|
||||
displace_data: &DisplaceData,
|
||||
export_to_excel: bool,
|
||||
use_original_name: bool,
|
||||
) -> String {
|
||||
let mut first = true;
|
||||
let mut arguments = "".to_string();
|
||||
@@ -281,52 +244,27 @@ fn format_function(
|
||||
arguments = format!(
|
||||
"{},{}",
|
||||
arguments,
|
||||
stringify(el, context, displace_data, export_to_excel)
|
||||
stringify(el, context, displace_data, use_original_name)
|
||||
);
|
||||
} else {
|
||||
first = false;
|
||||
arguments = stringify(el, context, displace_data, export_to_excel);
|
||||
arguments = stringify(el, context, displace_data, use_original_name);
|
||||
}
|
||||
}
|
||||
format!("{name}({arguments})")
|
||||
format!("{}({})", name, arguments)
|
||||
}
|
||||
|
||||
// There is just one representation in the AST (Abstract Syntax Tree) of a formula.
|
||||
// But three different ways to convert it to a string.
|
||||
//
|
||||
// To stringify a formula we need a "context", that is in which cell are we doing the "stringifying"
|
||||
//
|
||||
// But there are three ways to stringify a formula:
|
||||
//
|
||||
// * To show it to the IronCalc user
|
||||
// * To store internally
|
||||
// * To export to Excel
|
||||
//
|
||||
// There are, of course correspondingly three "modes" when parsing a formula.
|
||||
//
|
||||
// The internal representation is the more different as references are stored in the RC representation.
|
||||
// The the AST of the formula is kept close to this representation we don't need a context
|
||||
//
|
||||
// In the export to Excel representation certain things are different:
|
||||
// * We add a _xlfn. in front of some (more modern) functions
|
||||
// * We remove the Implicit Intersection operator when it is automatic and add _xlfn.SINGLE when it is not
|
||||
//
|
||||
// Examples:
|
||||
// * =A1+B2
|
||||
// * =RC+R1C1
|
||||
// * =A1+B1
|
||||
|
||||
fn stringify(
|
||||
node: &Node,
|
||||
context: Option<&CellReferenceRC>,
|
||||
displace_data: &DisplaceData,
|
||||
export_to_excel: bool,
|
||||
use_original_name: bool,
|
||||
) -> 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,
|
||||
@@ -416,7 +354,7 @@ fn stringify(
|
||||
full_row,
|
||||
full_column,
|
||||
);
|
||||
format!("{s1}:{s2}")
|
||||
format!("{}:{}", s1, s2)
|
||||
}
|
||||
WrongRangeKind {
|
||||
sheet_name,
|
||||
@@ -465,56 +403,58 @@ fn stringify(
|
||||
full_row,
|
||||
full_column,
|
||||
);
|
||||
format!("{s1}:{s2}")
|
||||
format!("{}:{}", s1, s2)
|
||||
}
|
||||
OpRangeKind { left, right } => format!(
|
||||
"{}:{}",
|
||||
stringify(left, context, displace_data, export_to_excel),
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
stringify(left, context, displace_data, use_original_name),
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
OpConcatenateKind { left, right } => format!(
|
||||
"{}&{}",
|
||||
stringify(left, context, displace_data, export_to_excel),
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
stringify(left, context, displace_data, use_original_name),
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
CompareKind { kind, left, right } => format!(
|
||||
"{}{}{}",
|
||||
stringify(left, context, displace_data, export_to_excel),
|
||||
stringify(left, context, displace_data, use_original_name),
|
||||
kind,
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
OpSumKind { kind, left, right } => format!(
|
||||
"{}{}{}",
|
||||
stringify(left, context, displace_data, use_original_name),
|
||||
kind,
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
OpSumKind { kind, left, right } => {
|
||||
let left_str = stringify(left, context, displace_data, export_to_excel);
|
||||
// if kind is minus then we need parentheses in the right side if they are OpSumKind or CompareKind
|
||||
let right_str = if (matches!(kind, OpSum::Minus) && matches!(**right, OpSumKind { .. }))
|
||||
| matches!(**right, CompareKind { .. })
|
||||
{
|
||||
format!(
|
||||
"({})",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
)
|
||||
} else {
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
};
|
||||
|
||||
format!("{left_str}{kind}{right_str}")
|
||||
}
|
||||
OpProductKind { kind, left, right } => {
|
||||
let x = match **left {
|
||||
OpSumKind { .. } | CompareKind { .. } => format!(
|
||||
OpSumKind { .. } => format!(
|
||||
"({})",
|
||||
stringify(left, context, displace_data, export_to_excel)
|
||||
stringify(left, context, displace_data, use_original_name)
|
||||
),
|
||||
_ => stringify(left, context, displace_data, export_to_excel),
|
||||
CompareKind { .. } => format!(
|
||||
"({})",
|
||||
stringify(left, context, displace_data, use_original_name)
|
||||
),
|
||||
_ => stringify(left, context, displace_data, use_original_name),
|
||||
};
|
||||
let y = match **right {
|
||||
OpSumKind { .. } | CompareKind { .. } | OpProductKind { .. } => format!(
|
||||
OpSumKind { .. } => format!(
|
||||
"({})",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
_ => stringify(right, context, displace_data, export_to_excel),
|
||||
CompareKind { .. } => format!(
|
||||
"({})",
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
OpProductKind { .. } => format!(
|
||||
"({})",
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
_ => stringify(right, context, displace_data, use_original_name),
|
||||
};
|
||||
format!("{x}{kind}{y}")
|
||||
format!("{}{}{}", x, kind, y)
|
||||
}
|
||||
OpPowerKind { left, right } => {
|
||||
let x = match **left {
|
||||
@@ -527,7 +467,9 @@ fn stringify(
|
||||
| DefinedNameKind(_)
|
||||
| TableNameKind(_)
|
||||
| WrongVariableKind(_)
|
||||
| WrongRangeKind { .. } => stringify(left, context, displace_data, export_to_excel),
|
||||
| WrongRangeKind { .. } => {
|
||||
stringify(left, context, displace_data, use_original_name)
|
||||
}
|
||||
OpRangeKind { .. }
|
||||
| OpConcatenateKind { .. }
|
||||
| OpProductKind { .. }
|
||||
@@ -540,10 +482,9 @@ fn stringify(
|
||||
| ParseErrorKind { .. }
|
||||
| OpSumKind { .. }
|
||||
| CompareKind { .. }
|
||||
| ImplicitIntersection { .. }
|
||||
| EmptyArgKind => format!(
|
||||
"({})",
|
||||
stringify(left, context, displace_data, export_to_excel)
|
||||
stringify(left, context, displace_data, use_original_name)
|
||||
),
|
||||
};
|
||||
let y = match **right {
|
||||
@@ -557,7 +498,7 @@ fn stringify(
|
||||
| TableNameKind(_)
|
||||
| WrongVariableKind(_)
|
||||
| WrongRangeKind { .. } => {
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
}
|
||||
OpRangeKind { .. }
|
||||
| OpConcatenateKind { .. }
|
||||
@@ -571,129 +512,65 @@ fn stringify(
|
||||
| ParseErrorKind { .. }
|
||||
| OpSumKind { .. }
|
||||
| CompareKind { .. }
|
||||
| ImplicitIntersection { .. }
|
||||
| EmptyArgKind => format!(
|
||||
"({})",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
};
|
||||
format!("{x}^{y}")
|
||||
format!("{}^{}", x, y)
|
||||
}
|
||||
InvalidFunctionKind { name, args } => {
|
||||
format_function(name, args, context, displace_data, export_to_excel)
|
||||
format_function(name, args, context, displace_data, use_original_name)
|
||||
}
|
||||
FunctionKind { kind, args } => {
|
||||
let name = if export_to_excel {
|
||||
let name = if use_original_name {
|
||||
kind.to_xlsx_string()
|
||||
} else {
|
||||
kind.to_string()
|
||||
};
|
||||
format_function(&name, args, context, displace_data, export_to_excel)
|
||||
format_function(&name, args, context, displace_data, use_original_name)
|
||||
}
|
||||
ArrayKind(args) => {
|
||||
let mut first_row = true;
|
||||
let mut matrix_string = String::new();
|
||||
|
||||
for row in args {
|
||||
if !first_row {
|
||||
matrix_string.push(';');
|
||||
let mut first = true;
|
||||
let mut arguments = "".to_string();
|
||||
for el in args {
|
||||
if !first {
|
||||
arguments = format!(
|
||||
"{},{}",
|
||||
arguments,
|
||||
stringify(el, context, displace_data, use_original_name)
|
||||
);
|
||||
} else {
|
||||
first_row = false;
|
||||
first = false;
|
||||
arguments = stringify(el, context, displace_data, use_original_name);
|
||||
}
|
||||
let mut first_column = true;
|
||||
let mut row_string = String::new();
|
||||
for el in row {
|
||||
if !first_column {
|
||||
row_string.push(',');
|
||||
} else {
|
||||
first_column = false;
|
||||
}
|
||||
row_string.push_str(&to_string_array_node(el));
|
||||
}
|
||||
matrix_string.push_str(&row_string);
|
||||
}
|
||||
format!("{{{matrix_string}}}")
|
||||
format!("{{{}}}", arguments)
|
||||
}
|
||||
TableNameKind(value) => value.to_string(),
|
||||
DefinedNameKind((name, ..)) => name.to_string(),
|
||||
DefinedNameKind((name, _)) => name.to_string(),
|
||||
WrongVariableKind(name) => name.to_string(),
|
||||
UnaryKind { kind, right } => match kind {
|
||||
OpUnary::Minus => {
|
||||
let needs_parentheses = match **right {
|
||||
BooleanKind(_)
|
||||
| NumberKind(_)
|
||||
| StringKind(_)
|
||||
| ReferenceKind { .. }
|
||||
| RangeKind { .. }
|
||||
| WrongReferenceKind { .. }
|
||||
| WrongRangeKind { .. }
|
||||
| OpRangeKind { .. }
|
||||
| OpConcatenateKind { .. }
|
||||
| OpProductKind { .. }
|
||||
| OpPowerKind { .. }
|
||||
| FunctionKind { .. }
|
||||
| InvalidFunctionKind { .. }
|
||||
| ArrayKind(_)
|
||||
| DefinedNameKind(_)
|
||||
| TableNameKind(_)
|
||||
| WrongVariableKind(_)
|
||||
| ImplicitIntersection { .. }
|
||||
| CompareKind { .. }
|
||||
| ErrorKind(_)
|
||||
| ParseErrorKind { .. }
|
||||
| EmptyArgKind => false,
|
||||
|
||||
OpSumKind { .. } | UnaryKind { .. } => true,
|
||||
};
|
||||
if needs_parentheses {
|
||||
format!(
|
||||
"-({})",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
)
|
||||
} else {
|
||||
format!(
|
||||
"-{}",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
)
|
||||
}
|
||||
format!(
|
||||
"-{}",
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
)
|
||||
}
|
||||
OpUnary::Percentage => {
|
||||
format!(
|
||||
"{}%",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
)
|
||||
}
|
||||
},
|
||||
ErrorKind(kind) => format!("{kind}"),
|
||||
ErrorKind(kind) => format!("{}", kind),
|
||||
ParseErrorKind {
|
||||
formula,
|
||||
position: _,
|
||||
message: _,
|
||||
} => formula.to_string(),
|
||||
EmptyArgKind => "".to_string(),
|
||||
ImplicitIntersection {
|
||||
automatic: _,
|
||||
child,
|
||||
} => {
|
||||
if export_to_excel {
|
||||
// We need to check wether the II can be automatic or not
|
||||
let mut new_node = child.as_ref().clone();
|
||||
|
||||
add_implicit_intersection(&mut new_node, true);
|
||||
if matches!(&new_node, Node::ImplicitIntersection { .. }) {
|
||||
return stringify(child, context, displace_data, export_to_excel);
|
||||
}
|
||||
|
||||
return format!(
|
||||
"_xlfn.SINGLE({})",
|
||||
stringify(child, context, displace_data, export_to_excel)
|
||||
);
|
||||
}
|
||||
format!(
|
||||
"@{}",
|
||||
stringify(child, context, displace_data, export_to_excel)
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -781,12 +658,6 @@ pub(crate) fn rename_sheet_in_node(node: &mut Node, sheet_index: u32, new_name:
|
||||
Node::UnaryKind { kind: _, right } => {
|
||||
rename_sheet_in_node(right, sheet_index, new_name);
|
||||
}
|
||||
Node::ImplicitIntersection {
|
||||
automatic: _,
|
||||
child,
|
||||
} => {
|
||||
rename_sheet_in_node(child, sheet_index, new_name);
|
||||
}
|
||||
|
||||
// Do nothing
|
||||
Node::BooleanKind(_) => {}
|
||||
@@ -810,7 +681,7 @@ pub(crate) fn rename_defined_name_in_node(
|
||||
) {
|
||||
match node {
|
||||
// Rename
|
||||
Node::DefinedNameKind((n, s, _)) => {
|
||||
Node::DefinedNameKind((n, s)) => {
|
||||
if name.to_lowercase() == n.to_lowercase() && *s == scope {
|
||||
*n = new_name.to_string();
|
||||
}
|
||||
@@ -865,12 +736,6 @@ pub(crate) fn rename_defined_name_in_node(
|
||||
Node::UnaryKind { kind: _, right } => {
|
||||
rename_defined_name_in_node(right, name, scope, new_name);
|
||||
}
|
||||
Node::ImplicitIntersection {
|
||||
automatic: _,
|
||||
child,
|
||||
} => {
|
||||
rename_defined_name_in_node(child, name, scope, new_name);
|
||||
}
|
||||
|
||||
// Do nothing
|
||||
Node::BooleanKind(_) => {}
|
||||
|
||||
@@ -1,7 +1,4 @@
|
||||
mod test_add_implicit_intersection;
|
||||
mod test_arrays;
|
||||
mod test_general;
|
||||
mod test_implicit_intersection;
|
||||
mod test_issue_155;
|
||||
mod test_move_formula;
|
||||
mod test_ranges;
|
||||
|
||||
@@ -1,80 +0,0 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::{
|
||||
parser::{
|
||||
stringify::{to_excel_string, to_string},
|
||||
Parser,
|
||||
},
|
||||
types::CellReferenceRC,
|
||||
};
|
||||
|
||||
use crate::expressions::parser::static_analysis::add_implicit_intersection;
|
||||
|
||||
#[test]
|
||||
fn simple_test() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let cases = vec![
|
||||
("A1:A10*SUM(A1:A10)", "@A1:A10*SUM(A1:A10)"),
|
||||
("A1:A10", "@A1:A10"),
|
||||
// Math and trigonometry functions
|
||||
("SUM(A1:A10)", "SUM(A1:A10)"),
|
||||
("SIN(A1:A10)", "SIN(@A1:A10)"),
|
||||
("COS(A1:A10)", "COS(@A1:A10)"),
|
||||
("TAN(A1:A10)", "TAN(@A1:A10)"),
|
||||
("ASIN(A1:A10)", "ASIN(@A1:A10)"),
|
||||
("ACOS(A1:A10)", "ACOS(@A1:A10)"),
|
||||
("ATAN(A1:A10)", "ATAN(@A1:A10)"),
|
||||
("SINH(A1:A10)", "SINH(@A1:A10)"),
|
||||
("COSH(A1:A10)", "COSH(@A1:A10)"),
|
||||
("TANH(A1:A10)", "TANH(@A1:A10)"),
|
||||
("ASINH(A1:A10)", "ASINH(@A1:A10)"),
|
||||
("ACOSH(A1:A10)", "ACOSH(@A1:A10)"),
|
||||
("ATANH(A1:A10)", "ATANH(@A1:A10)"),
|
||||
("ATAN2(A1:A10,B1:B10)", "ATAN2(@A1:A10,@B1:B10)"),
|
||||
("ATAN2(A1:A10,A1)", "ATAN2(@A1:A10,A1)"),
|
||||
("SQRT(A1:A10)", "SQRT(@A1:A10)"),
|
||||
("SQRTPI(A1:A10)", "SQRTPI(@A1:A10)"),
|
||||
("POWER(A1:A10,A1)", "POWER(@A1:A10,A1)"),
|
||||
("POWER(A1:A10,B1:B10)", "POWER(@A1:A10,@B1:B10)"),
|
||||
("MAX(A1:A10)", "MAX(A1:A10)"),
|
||||
("MIN(A1:A10)", "MIN(A1:A10)"),
|
||||
("ABS(A1:A10)", "ABS(@A1:A10)"),
|
||||
("FALSE()", "FALSE()"),
|
||||
("TRUE()", "TRUE()"),
|
||||
// Defined names
|
||||
("BADNMAE", "@BADNMAE"),
|
||||
// Logical
|
||||
("AND(A1:A10)", "AND(A1:A10)"),
|
||||
("OR(A1:A10)", "OR(A1:A10)"),
|
||||
("NOT(A1:A10)", "NOT(@A1:A10)"),
|
||||
("IF(A1:A10,B1:B10,C1:C10)", "IF(@A1:A10,@B1:B10,@C1:C10)"),
|
||||
// Information
|
||||
// ("ISBLANK(A1:A10)", "ISBLANK(A1:A10)"),
|
||||
// ("ISERR(A1:A10)", "ISERR(A1:A10)"),
|
||||
// ("ISERROR(A1:A10)", "ISERROR(A1:A10)"),
|
||||
// ("ISEVEN(A1:A10)", "ISEVEN(A1:A10)"),
|
||||
// ("ISLOGICAL(A1:A10)", "ISLOGICAL(A1:A10)"),
|
||||
// ("ISNA(A1:A10)", "ISNA(A1:A10)"),
|
||||
// ("ISNONTEXT(A1:A10)", "ISNONTEXT(A1:A10)"),
|
||||
// ("ISNUMBER(A1:A10)", "ISNUMBER(A1:A10)"),
|
||||
// ("ISODD(A1:A10)", "ISODD(A1:A10)"),
|
||||
// ("ISREF(A1:A10)", "ISREF(A1:A10)"),
|
||||
// ("ISTEXT(A1:A10)", "ISTEXT(A1:A10)"),
|
||||
];
|
||||
for (formula, expected) in cases {
|
||||
let mut t = parser.parse(formula, &cell_reference);
|
||||
add_implicit_intersection(&mut t, true);
|
||||
let r = to_string(&t, &cell_reference);
|
||||
assert_eq!(r, expected);
|
||||
let excel_formula = to_excel_string(&t, &cell_reference);
|
||||
assert_eq!(excel_formula, formula);
|
||||
}
|
||||
}
|
||||
@@ -1,92 +0,0 @@
|
||||
#![allow(clippy::panic)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::parser::stringify::{to_rc_format, to_string};
|
||||
use crate::expressions::parser::{ArrayNode, Node, Parser};
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
|
||||
#[test]
|
||||
fn simple_horizontal() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let horizontal = parser.parse("{1, 2, 3}", &cell_reference);
|
||||
assert_eq!(
|
||||
horizontal,
|
||||
Node::ArrayKind(vec![vec![
|
||||
ArrayNode::Number(1.0),
|
||||
ArrayNode::Number(2.0),
|
||||
ArrayNode::Number(3.0)
|
||||
]])
|
||||
);
|
||||
|
||||
assert_eq!(to_rc_format(&horizontal), "{1,2,3}");
|
||||
assert_eq!(to_string(&horizontal, &cell_reference), "{1,2,3}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn simple_vertical() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let vertical = parser.parse("{1;2; 3}", &cell_reference);
|
||||
assert_eq!(
|
||||
vertical,
|
||||
Node::ArrayKind(vec![
|
||||
vec![ArrayNode::Number(1.0)],
|
||||
vec![ArrayNode::Number(2.0)],
|
||||
vec![ArrayNode::Number(3.0)]
|
||||
])
|
||||
);
|
||||
assert_eq!(to_rc_format(&vertical), "{1;2;3}");
|
||||
assert_eq!(to_string(&vertical, &cell_reference), "{1;2;3}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn simple_matrix() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let matrix = parser.parse("{1,2,3; 4, 5, 6; 7,8,9}", &cell_reference);
|
||||
assert_eq!(
|
||||
matrix,
|
||||
Node::ArrayKind(vec![
|
||||
vec![
|
||||
ArrayNode::Number(1.0),
|
||||
ArrayNode::Number(2.0),
|
||||
ArrayNode::Number(3.0)
|
||||
],
|
||||
vec![
|
||||
ArrayNode::Number(4.0),
|
||||
ArrayNode::Number(5.0),
|
||||
ArrayNode::Number(6.0)
|
||||
],
|
||||
vec![
|
||||
ArrayNode::Number(7.0),
|
||||
ArrayNode::Number(8.0),
|
||||
ArrayNode::Number(9.0)
|
||||
]
|
||||
])
|
||||
);
|
||||
assert_eq!(to_rc_format(&matrix), "{1,2,3;4,5,6;7,8,9}");
|
||||
assert_eq!(to_string(&matrix, &cell_reference), "{1,2,3;4,5,6;7,8,9}");
|
||||
}
|
||||
@@ -4,7 +4,7 @@ use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::lexer::LexerMode;
|
||||
use crate::expressions::parser::stringify::{
|
||||
to_rc_format, to_string, to_string_displaced, DisplaceData,
|
||||
DisplaceData, to_rc_format, to_string, to_string_displaced,
|
||||
};
|
||||
use crate::expressions::parser::{Node, Parser};
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
|
||||
@@ -1,75 +0,0 @@
|
||||
#![allow(clippy::panic)]
|
||||
|
||||
use crate::expressions::parser::{Node, Parser};
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
use std::collections::HashMap;
|
||||
|
||||
#[test]
|
||||
fn simple() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!B3
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 3,
|
||||
column: 2,
|
||||
};
|
||||
let t = parser.parse("@A1:A10", &cell_reference);
|
||||
let child = Node::RangeKind {
|
||||
sheet_name: None,
|
||||
sheet_index: 0,
|
||||
absolute_row1: false,
|
||||
absolute_column1: false,
|
||||
row1: -2,
|
||||
column1: -1,
|
||||
absolute_row2: false,
|
||||
absolute_column2: false,
|
||||
row2: 7,
|
||||
column2: -1,
|
||||
};
|
||||
assert_eq!(
|
||||
t,
|
||||
Node::ImplicitIntersection {
|
||||
automatic: false,
|
||||
child: Box::new(child)
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn simple_add() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!B3
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 3,
|
||||
column: 2,
|
||||
};
|
||||
let t = parser.parse("@A1:A10+12", &cell_reference);
|
||||
let child = Node::RangeKind {
|
||||
sheet_name: None,
|
||||
sheet_index: 0,
|
||||
absolute_row1: false,
|
||||
absolute_column1: false,
|
||||
row1: -2,
|
||||
column1: -1,
|
||||
absolute_row2: false,
|
||||
absolute_column2: false,
|
||||
row2: 7,
|
||||
column2: -1,
|
||||
};
|
||||
assert_eq!(
|
||||
t,
|
||||
Node::OpSumKind {
|
||||
kind: crate::expressions::token::OpSum::Add,
|
||||
left: Box::new(Node::ImplicitIntersection {
|
||||
automatic: false,
|
||||
child: Box::new(child)
|
||||
}),
|
||||
right: Box::new(Node::NumberKind(12.0))
|
||||
}
|
||||
)
|
||||
}
|
||||
@@ -2,8 +2,8 @@
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::parser::stringify::to_string;
|
||||
use crate::expressions::parser::Parser;
|
||||
use crate::expressions::parser::stringify::to_string;
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::parser::move_formula::{move_formula, MoveContext};
|
||||
use crate::expressions::parser::Parser;
|
||||
use crate::expressions::parser::move_formula::{MoveContext, move_formula};
|
||||
use crate::expressions::types::{Area, CellReferenceRC};
|
||||
|
||||
#[test]
|
||||
@@ -387,7 +387,7 @@ fn test_move_formula_misc() {
|
||||
width: 4,
|
||||
height: 5,
|
||||
};
|
||||
let node = parser.parse("X9^C2-F4*H2+SUM(F2:H4)+SUM(C2:F6)", context);
|
||||
let node = parser.parse("X9^C2-F4*H2", context);
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -400,7 +400,7 @@ fn test_move_formula_misc() {
|
||||
column_delta: 10,
|
||||
},
|
||||
);
|
||||
assert_eq!(t, "X9^M12-P14*H2+SUM(F2:H4)+SUM(M12:P16)");
|
||||
assert_eq!(t, "X9^M12-P14*H2");
|
||||
|
||||
let node = parser.parse("F5*(-D5)*SUM(A1, X9, $D$5)", context);
|
||||
let t = move_formula(
|
||||
@@ -475,77 +475,3 @@ fn test_move_formula_another_sheet() {
|
||||
"Sheet1!AB31*SUM(Sheet1!JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(M12:P16)"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn move_formula_implicit_intersetion() {
|
||||
// context is E4
|
||||
let row = 4;
|
||||
let column = 5;
|
||||
let context = &CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row,
|
||||
column,
|
||||
};
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Area is C2:F6
|
||||
let area = &Area {
|
||||
sheet: 0,
|
||||
row: 2,
|
||||
column: 3,
|
||||
width: 4,
|
||||
height: 5,
|
||||
};
|
||||
let node = parser.parse("SUM(@F2:H4)+SUM(@C2:F6)", context);
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
source_sheet_name: "Sheet1",
|
||||
row,
|
||||
column,
|
||||
area,
|
||||
target_sheet_name: "Sheet1",
|
||||
row_delta: 10,
|
||||
column_delta: 10,
|
||||
},
|
||||
);
|
||||
assert_eq!(t, "SUM(@F2:H4)+SUM(@M12:P16)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn move_formula_implicit_intersetion_with_ranges() {
|
||||
// context is E4
|
||||
let row = 4;
|
||||
let column = 5;
|
||||
let context = &CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row,
|
||||
column,
|
||||
};
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Area is C2:F6
|
||||
let area = &Area {
|
||||
sheet: 0,
|
||||
row: 2,
|
||||
column: 3,
|
||||
width: 4,
|
||||
height: 5,
|
||||
};
|
||||
let node = parser.parse("SUM(@F2:H4)+SUM(@C2:F6)+SUM(@A1, @X9, @$D$5)", context);
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
source_sheet_name: "Sheet1",
|
||||
row,
|
||||
column,
|
||||
area,
|
||||
target_sheet_name: "Sheet1",
|
||||
row_delta: 10,
|
||||
column_delta: 10,
|
||||
},
|
||||
);
|
||||
assert_eq!(t, "SUM(@F2:H4)+SUM(@M12:P16)+SUM(@A1,@X9,@$N$15)");
|
||||
}
|
||||
|
||||
@@ -2,8 +2,8 @@ use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::lexer::LexerMode;
|
||||
|
||||
use crate::expressions::parser::stringify::{to_rc_format, to_string};
|
||||
use crate::expressions::parser::Parser;
|
||||
use crate::expressions::parser::stringify::{to_rc_format, to_string};
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
|
||||
struct Formula<'a> {
|
||||
|
||||
@@ -2,8 +2,8 @@
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::parser::stringify::to_string;
|
||||
use crate::expressions::parser::Parser;
|
||||
use crate::expressions::parser::stringify::to_string;
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
|
||||
#[test]
|
||||
@@ -32,39 +32,3 @@ fn exp_order() {
|
||||
let t = parser.parse("(5)^(4)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "5^4");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn correct_parenthesis() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
|
||||
let t = parser.parse("-(1 + 1)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "-(1+1)");
|
||||
|
||||
let t = parser.parse("1 - (3 + 4)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "1-(3+4)");
|
||||
|
||||
let t = parser.parse("-(1.05*(0.0284 + 0.0046) - 0.0284)", &cell_reference);
|
||||
assert_eq!(
|
||||
to_string(&t, &cell_reference),
|
||||
"-(1.05*(0.0284+0.0046)-0.0284)"
|
||||
);
|
||||
|
||||
let t = parser.parse("1 + (3+5)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "1+3+5");
|
||||
|
||||
let t = parser.parse("1 - (3+5)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "1-(3+5)");
|
||||
|
||||
let t = parser.parse("(1 - 3) - (3+5)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "1-3-(3+5)");
|
||||
|
||||
let t = parser.parse("1 + (3<5)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "1+(3<5)");
|
||||
}
|
||||
|
||||
@@ -3,11 +3,12 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::parser::stringify::to_string;
|
||||
use crate::expressions::parser::Parser;
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
use crate::expressions::utils::{number_to_column, parse_reference_a1};
|
||||
use crate::types::{Table, TableColumn, TableStyleInfo};
|
||||
|
||||
use crate::expressions::parser::Parser;
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
|
||||
fn create_test_table(
|
||||
table_name: &str,
|
||||
column_names: &[&str],
|
||||
|
||||
278
base/src/expressions/parser/walk.rs
Normal file
278
base/src/expressions/parser/walk.rs
Normal file
@@ -0,0 +1,278 @@
|
||||
use super::{Node, move_formula::ref_is_in_area};
|
||||
|
||||
use crate::expressions::types::{Area, CellReferenceIndex};
|
||||
|
||||
pub(crate) fn forward_references(
|
||||
node: &mut Node,
|
||||
context: &CellReferenceIndex,
|
||||
source_area: &Area,
|
||||
target_sheet: u32,
|
||||
target_sheet_name: &str,
|
||||
target_row: i32,
|
||||
target_column: i32,
|
||||
) {
|
||||
match node {
|
||||
Node::ReferenceKind {
|
||||
sheet_name,
|
||||
sheet_index: reference_sheet,
|
||||
absolute_row,
|
||||
absolute_column,
|
||||
row: reference_row,
|
||||
column: reference_column,
|
||||
} => {
|
||||
let reference_row_absolute = if *absolute_row {
|
||||
*reference_row
|
||||
} else {
|
||||
*reference_row + context.row
|
||||
};
|
||||
let reference_column_absolute = if *absolute_column {
|
||||
*reference_column
|
||||
} else {
|
||||
*reference_column + context.column
|
||||
};
|
||||
if ref_is_in_area(
|
||||
*reference_sheet,
|
||||
reference_row_absolute,
|
||||
reference_column_absolute,
|
||||
source_area,
|
||||
) {
|
||||
if *reference_sheet != target_sheet {
|
||||
*sheet_name = Some(target_sheet_name.to_string());
|
||||
*reference_sheet = target_sheet;
|
||||
}
|
||||
*reference_row = target_row + *reference_row - source_area.row;
|
||||
*reference_column = target_column + *reference_column - source_area.column;
|
||||
}
|
||||
}
|
||||
Node::RangeKind {
|
||||
sheet_name,
|
||||
sheet_index,
|
||||
absolute_row1,
|
||||
absolute_column1,
|
||||
row1,
|
||||
column1,
|
||||
absolute_row2,
|
||||
absolute_column2,
|
||||
row2,
|
||||
column2,
|
||||
} => {
|
||||
let reference_row1 = if *absolute_row1 {
|
||||
*row1
|
||||
} else {
|
||||
*row1 + context.row
|
||||
};
|
||||
let reference_column1 = if *absolute_column1 {
|
||||
*column1
|
||||
} else {
|
||||
*column1 + context.column
|
||||
};
|
||||
|
||||
let reference_row2 = if *absolute_row2 {
|
||||
*row2
|
||||
} else {
|
||||
*row2 + context.row
|
||||
};
|
||||
let reference_column2 = if *absolute_column2 {
|
||||
*column2
|
||||
} else {
|
||||
*column2 + context.column
|
||||
};
|
||||
if ref_is_in_area(*sheet_index, reference_row1, reference_column1, source_area)
|
||||
&& ref_is_in_area(*sheet_index, reference_row2, reference_column2, source_area)
|
||||
{
|
||||
if *sheet_index != target_sheet {
|
||||
*sheet_index = target_sheet;
|
||||
*sheet_name = Some(target_sheet_name.to_string());
|
||||
}
|
||||
*row1 = target_row + *row1 - source_area.row;
|
||||
*column1 = target_column + *column1 - source_area.column;
|
||||
*row2 = target_row + *row2 - source_area.row;
|
||||
*column2 = target_column + *column2 - source_area.column;
|
||||
}
|
||||
}
|
||||
// Recurse
|
||||
Node::OpRangeKind { left, right } => {
|
||||
forward_references(
|
||||
left,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
forward_references(
|
||||
right,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
Node::OpConcatenateKind { left, right } => {
|
||||
forward_references(
|
||||
left,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
forward_references(
|
||||
right,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
Node::OpSumKind {
|
||||
kind: _,
|
||||
left,
|
||||
right,
|
||||
} => {
|
||||
forward_references(
|
||||
left,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
forward_references(
|
||||
right,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
Node::OpProductKind {
|
||||
kind: _,
|
||||
left,
|
||||
right,
|
||||
} => {
|
||||
forward_references(
|
||||
left,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
forward_references(
|
||||
right,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
Node::OpPowerKind { left, right } => {
|
||||
forward_references(
|
||||
left,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
forward_references(
|
||||
right,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
Node::FunctionKind { kind: _, args } => {
|
||||
for arg in args {
|
||||
forward_references(
|
||||
arg,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
}
|
||||
Node::InvalidFunctionKind { name: _, args } => {
|
||||
for arg in args {
|
||||
forward_references(
|
||||
arg,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
}
|
||||
Node::CompareKind {
|
||||
kind: _,
|
||||
left,
|
||||
right,
|
||||
} => {
|
||||
forward_references(
|
||||
left,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
forward_references(
|
||||
right,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
Node::UnaryKind { kind: _, right } => {
|
||||
forward_references(
|
||||
right,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
// TODO: Not implemented
|
||||
Node::ArrayKind(_) => {}
|
||||
// Do nothing. Note: we could do a blanket _ => {}
|
||||
Node::DefinedNameKind(_) => {}
|
||||
Node::TableNameKind(_) => {}
|
||||
Node::WrongVariableKind(_) => {}
|
||||
Node::ErrorKind(_) => {}
|
||||
Node::ParseErrorKind { .. } => {}
|
||||
Node::EmptyArgKind => {}
|
||||
Node::BooleanKind(_) => {}
|
||||
Node::NumberKind(_) => {}
|
||||
Node::StringKind(_) => {}
|
||||
Node::WrongReferenceKind { .. } => {}
|
||||
Node::WrongRangeKind { .. } => {}
|
||||
}
|
||||
}
|
||||
@@ -197,7 +197,7 @@ pub fn is_english_error_string(name: &str) -> bool {
|
||||
"#REF!", "#NAME?", "#VALUE!", "#DIV/0!", "#N/A", "#NUM!", "#ERROR!", "#N/IMPL!", "#SPILL!",
|
||||
"#CALC!", "#CIRC!", "#NULL!",
|
||||
];
|
||||
names.contains(&name)
|
||||
names.iter().any(|e| *e == name)
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
|
||||
@@ -240,7 +240,6 @@ pub enum TokenType {
|
||||
Bang, // !
|
||||
Percent, // %
|
||||
And, // &
|
||||
At, // @
|
||||
Reference {
|
||||
sheet: Option<String>,
|
||||
row: i32,
|
||||
|
||||
@@ -211,6 +211,4 @@ fn test_names() {
|
||||
assert!(!is_valid_identifier("test€"));
|
||||
assert!(!is_valid_identifier("truñe"));
|
||||
assert!(!is_valid_identifier("tr&ue"));
|
||||
|
||||
assert!(!is_valid_identifier("LOG10"));
|
||||
}
|
||||
|
||||
@@ -21,12 +21,14 @@ 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)]
|
||||
|
||||
@@ -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!("{value:.9}");
|
||||
let mut text = format!("{:.9}", value);
|
||||
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!("{value:.5}");
|
||||
let s = format!("{:.5}", value);
|
||||
Formatted {
|
||||
text: format!(
|
||||
"{}E{}{:02}",
|
||||
@@ -161,39 +161,39 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(e),
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
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!("{text}{day:02}");
|
||||
text = format!("{}{:02}", text, day);
|
||||
}
|
||||
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!("{text}{month:02}");
|
||||
text = format!("{}{:02}", text, month);
|
||||
}
|
||||
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,34 +373,30 @@ 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!("{text}0");
|
||||
text = format!("{}0", text);
|
||||
} 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!("{text}E-");
|
||||
text = format!("{}E-", text);
|
||||
} else {
|
||||
text = format!("{text}E+");
|
||||
text = format!("{}E+", text);
|
||||
}
|
||||
}
|
||||
let number_index = l_exp - (p.exponent_digit_count - index);
|
||||
if l_exp <= p.exponent_digit_count {
|
||||
if !(number_index < 0 && digit.kind == '#') {
|
||||
let c = if number_index < 0 {
|
||||
if digit.kind == '?' {
|
||||
' '
|
||||
} else {
|
||||
'0'
|
||||
}
|
||||
if digit.kind == '?' { ' ' } else { '0' }
|
||||
} else {
|
||||
exponent_part[number_index as usize]
|
||||
};
|
||||
|
||||
text = format!("{text}{c}");
|
||||
text = format!("{}{}", text, c);
|
||||
}
|
||||
} else {
|
||||
for i in 0..number_index + 1 {
|
||||
@@ -614,7 +610,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())));
|
||||
|
||||
@@ -178,7 +178,10 @@ impl Lexer {
|
||||
}
|
||||
}
|
||||
self.position = position;
|
||||
chars.parse::<f64>().ok()
|
||||
match chars.parse::<f64>() {
|
||||
Err(_) => None,
|
||||
Ok(v) => Some(v),
|
||||
}
|
||||
}
|
||||
|
||||
fn consume_condition(&mut self) -> Option<(Compare, f64)> {
|
||||
@@ -333,7 +336,7 @@ impl Lexer {
|
||||
} else if s == '-' {
|
||||
Token::ScientificMinus
|
||||
} else {
|
||||
self.set_error(&format!("Unexpected char: {s}. Expected + or -"));
|
||||
self.set_error(&format!("Unexpected char: {}. Expected + or -", s));
|
||||
Token::ILLEGAL
|
||||
}
|
||||
} else {
|
||||
@@ -385,14 +388,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
|
||||
}
|
||||
},
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
use crate::{
|
||||
formatter::format::format_number,
|
||||
locale::{get_locale, Locale},
|
||||
locale::{Locale, get_locale},
|
||||
};
|
||||
|
||||
fn get_default_locale() -> &'static Locale {
|
||||
|
||||
@@ -31,7 +31,7 @@ impl Model {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Out of range parameters for date".to_string(),
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
let day = date.day() as f64;
|
||||
@@ -54,7 +54,7 @@ impl Model {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Out of range parameters for date".to_string(),
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
let month = date.month() as f64;
|
||||
@@ -87,7 +87,7 @@ impl Model {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Out of range parameters for date".to_string(),
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
if serial_number > MAXIMUM_DATE_SERIAL_NUMBER as i64 {
|
||||
@@ -192,7 +192,7 @@ impl Model {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Out of range parameters for date".to_string(),
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
let year = date.year() as f64;
|
||||
@@ -216,7 +216,7 @@ impl Model {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Out of range parameters for date".to_string(),
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
@@ -266,7 +266,7 @@ impl Model {
|
||||
error: Error::ERROR,
|
||||
origin: cell,
|
||||
message: "Invalid date".to_string(),
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
// 693_594 is computed as:
|
||||
@@ -296,7 +296,7 @@ impl Model {
|
||||
error: Error::ERROR,
|
||||
origin: cell,
|
||||
message: "Invalid date".to_string(),
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
// 693_594 is computed as:
|
||||
|
||||
@@ -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!("{y:E}")
|
||||
format!("{:E}", y)
|
||||
} 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!("{x:E}")
|
||||
format!("{:E}", x)
|
||||
} else {
|
||||
format!("{x}")
|
||||
format!("{}", x)
|
||||
};
|
||||
if y == 0.0 && x == 0.0 {
|
||||
write!(f, "0")
|
||||
|
||||
@@ -76,7 +76,7 @@ impl Model {
|
||||
if value < 0 {
|
||||
CalcResult::String(format!("{:0width$X}", HEX_MAX + value, width = 9))
|
||||
} else {
|
||||
let result = format!("{value:X}");
|
||||
let result = format!("{:X}", value);
|
||||
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!("{value:o}");
|
||||
let result = format!("{:o}", value);
|
||||
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!("{value:b}");
|
||||
let result = format!("{:b}", value);
|
||||
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!("{value:X}");
|
||||
let result = format!("{:X}", value);
|
||||
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!("{value:o}");
|
||||
let result = format!("{:o}", value);
|
||||
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!("{value:b}");
|
||||
let result = format!("{:b}", value);
|
||||
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!("{value:o}");
|
||||
let result = format!("{:o}", value);
|
||||
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!("{value:b}");
|
||||
let result = format!("{:b}", value);
|
||||
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!("{value:X}");
|
||||
let result = format!("{:X}", value);
|
||||
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());
|
||||
|
||||
@@ -57,7 +57,7 @@
|
||||
|
||||
use std::f64::consts::FRAC_2_PI;
|
||||
|
||||
use super::bessel_util::{high_word, split_words, FRAC_2_SQRT_PI, HUGE};
|
||||
use super::bessel_util::{FRAC_2_SQRT_PI, HUGE, high_word, split_words};
|
||||
|
||||
// R0/S0 on [0, 2.00]
|
||||
const R02: f64 = 1.562_499_999_999_999_5e-2; // 0x3F8FFFFF, 0xFFFFFFFD
|
||||
|
||||
@@ -56,7 +56,7 @@
|
||||
|
||||
use std::f64::consts::FRAC_2_PI;
|
||||
|
||||
use super::bessel_util::{high_word, split_words, FRAC_2_SQRT_PI, HUGE};
|
||||
use super::bessel_util::{FRAC_2_SQRT_PI, HUGE, high_word, split_words};
|
||||
|
||||
// R0/S0 on [0,2]
|
||||
const R00: f64 = -6.25e-2; // 0xBFB00000, 0x00000000
|
||||
|
||||
@@ -40,7 +40,7 @@
|
||||
use super::{
|
||||
bessel_j0_y0::{j0, y0},
|
||||
bessel_j1_y1::{j1, y1},
|
||||
bessel_util::{split_words, FRAC_2_SQRT_PI},
|
||||
bessel_util::{FRAC_2_SQRT_PI, split_words},
|
||||
};
|
||||
|
||||
// Special cases are:
|
||||
@@ -232,11 +232,7 @@ pub(crate) fn jn(n: i32, x: f64) -> f64 {
|
||||
}
|
||||
}
|
||||
};
|
||||
if sign == 1 {
|
||||
-b
|
||||
} else {
|
||||
b
|
||||
}
|
||||
if sign == 1 { -b } else { b }
|
||||
}
|
||||
|
||||
// Yn returns the order-n Bessel function of the second kind.
|
||||
@@ -321,9 +317,5 @@ pub(crate) fn yn(n: i32, x: f64) -> f64 {
|
||||
}
|
||||
b
|
||||
};
|
||||
if sign > 0 {
|
||||
b
|
||||
} else {
|
||||
-b
|
||||
}
|
||||
if sign > 0 { b } else { -b }
|
||||
}
|
||||
|
||||
@@ -45,9 +45,5 @@ pub(crate) fn erf(x: f64) -> f64 {
|
||||
}
|
||||
|
||||
let res = t * f64::exp(-x_abs * x_abs + 0.5 * (cof[0] + ty * d) - dd);
|
||||
if x < 0.0 {
|
||||
res - 1.0
|
||||
} else {
|
||||
1.0 - res
|
||||
}
|
||||
if x < 0.0 { res - 1.0 } else { 1.0 - res }
|
||||
}
|
||||
|
||||
@@ -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()
|
||||
@@ -698,7 +698,7 @@ impl Model {
|
||||
error: error.0,
|
||||
origin: cell,
|
||||
message: error.1,
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
CalcResult::Number(ipmt)
|
||||
@@ -762,7 +762,7 @@ impl Model {
|
||||
error: error.0,
|
||||
origin: cell,
|
||||
message: error.1,
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
CalcResult::Number(ppmt)
|
||||
@@ -1075,7 +1075,7 @@ impl Model {
|
||||
error,
|
||||
origin: cell,
|
||||
message,
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -1096,7 +1096,7 @@ impl Model {
|
||||
error,
|
||||
origin: cell,
|
||||
message,
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -1634,7 +1634,7 @@ impl Model {
|
||||
error: error.0,
|
||||
origin: cell,
|
||||
message: error.1,
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1702,7 +1702,7 @@ impl Model {
|
||||
error: error.0,
|
||||
origin: cell,
|
||||
message: error.1,
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1750,11 +1750,7 @@ impl Model {
|
||||
rate = 1.0
|
||||
};
|
||||
let value = if rate == 1.0 {
|
||||
if period == 1.0 {
|
||||
cost
|
||||
} else {
|
||||
0.0
|
||||
}
|
||||
if period == 1.0 { cost } else { 0.0 }
|
||||
} else {
|
||||
cost * (1.0 - rate).powf(period - 1.0)
|
||||
};
|
||||
|
||||
@@ -235,11 +235,6 @@ impl Model {
|
||||
// This cannot happen
|
||||
CalcResult::Number(1.0)
|
||||
}
|
||||
CalcResult::Array(_) => CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
},
|
||||
}
|
||||
}
|
||||
pub(crate) fn fn_sheet(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
@@ -254,7 +249,7 @@ impl Model {
|
||||
// The arg could be a defined name or a table
|
||||
// let = &args[0];
|
||||
match &args[0] {
|
||||
Node::DefinedNameKind((name, scope, _)) => {
|
||||
Node::DefinedNameKind((name, scope)) => {
|
||||
// Let's see if it is a defined name
|
||||
if let Some(defined_name) = self
|
||||
.parsed_defined_names
|
||||
@@ -262,10 +257,10 @@ impl Model {
|
||||
{
|
||||
match defined_name {
|
||||
ParsedDefinedName::CellReference(reference) => {
|
||||
return CalcResult::Number(reference.sheet as f64 + 1.0)
|
||||
return CalcResult::Number(reference.sheet as f64 + 1.0);
|
||||
}
|
||||
ParsedDefinedName::RangeReference(range) => {
|
||||
return CalcResult::Number(range.left.sheet as f64 + 1.0)
|
||||
return CalcResult::Number(range.left.sheet as f64 + 1.0);
|
||||
}
|
||||
ParsedDefinedName::InvalidDefinedNameFormula => {
|
||||
return CalcResult::Error {
|
||||
@@ -301,7 +296,7 @@ impl Model {
|
||||
error: Error::NAME,
|
||||
origin: cell,
|
||||
message: format!("Name not found: {name}"),
|
||||
}
|
||||
};
|
||||
}
|
||||
arg => {
|
||||
// Now it should be the name of a sheet
|
||||
|
||||
@@ -161,13 +161,6 @@ impl Model {
|
||||
CalcResult::Range { .. }
|
||||
| CalcResult::String { .. }
|
||||
| CalcResult::EmptyCell => {}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
if let (Some(current_result), Some(short_circuit_value)) =
|
||||
(result, short_circuit_value)
|
||||
@@ -192,13 +185,6 @@ impl Model {
|
||||
}
|
||||
// References to empty cells are ignored. If all args are ignored the result is #VALUE!
|
||||
CalcResult::EmptyCell => {}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if let (Some(current_result), Some(short_circuit_value)) = (result, short_circuit_value)
|
||||
@@ -246,7 +232,7 @@ impl Model {
|
||||
}
|
||||
// None of the cases matched so we return the default
|
||||
// If there is an even number of args is the last one otherwise is #N/A
|
||||
if args_count.is_multiple_of(2) {
|
||||
if args_count % 2 == 0 {
|
||||
return self.evaluate_node_in_context(&args[args_count - 1], cell);
|
||||
}
|
||||
CalcResult::Error {
|
||||
@@ -262,7 +248,7 @@ impl Model {
|
||||
if args_count < 2 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
if !args_count.is_multiple_of(2) {
|
||||
if args_count % 2 != 0 {
|
||||
// Missing value for last condition
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
|
||||
@@ -855,7 +855,7 @@ impl Model {
|
||||
if left.row != right.row || left.column != right.column {
|
||||
// FIXME: Implicit intersection or dynamic arrays
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
error: Error::ERROR,
|
||||
origin: cell,
|
||||
message: "argument must be a reference to a single cell".to_string(),
|
||||
};
|
||||
|
||||
@@ -1,100 +0,0 @@
|
||||
#[macro_export]
|
||||
macro_rules! single_number_fn {
|
||||
// The macro takes:
|
||||
// 1) A function name to define (e.g. fn_sin)
|
||||
// 2) The operation to apply (e.g. f64::sin)
|
||||
($fn_name:ident, $op:expr) => {
|
||||
pub(crate) fn $fn_name(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
// 1) Check exactly one argument
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
// 2) Try to get a "NumberOrArray"
|
||||
match self.get_number_or_array(&args[0], cell) {
|
||||
// -----------------------------------------
|
||||
// Case A: It's a single number
|
||||
// -----------------------------------------
|
||||
Ok(NumberOrArray::Number(f)) => match $op(f) {
|
||||
Ok(x) => CalcResult::Number(x),
|
||||
Err(Error::DIV) => CalcResult::Error {
|
||||
error: Error::DIV,
|
||||
origin: cell,
|
||||
message: "Divide by 0".to_string(),
|
||||
},
|
||||
Err(Error::VALUE) => CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Invalid number".to_string(),
|
||||
},
|
||||
Err(e) => CalcResult::Error {
|
||||
error: e,
|
||||
origin: cell,
|
||||
message: "Unknown error".to_string(),
|
||||
},
|
||||
},
|
||||
|
||||
// -----------------------------------------
|
||||
// Case B: It's an array, so apply $op
|
||||
// element-by-element.
|
||||
// -----------------------------------------
|
||||
Ok(NumberOrArray::Array(a)) => {
|
||||
let mut array = Vec::new();
|
||||
for row in a {
|
||||
let mut data_row = Vec::with_capacity(row.len());
|
||||
for value in row {
|
||||
match value {
|
||||
// If Boolean, treat as 0.0 or 1.0
|
||||
ArrayNode::Boolean(b) => {
|
||||
let n = if b { 1.0 } else { 0.0 };
|
||||
match $op(n) {
|
||||
Ok(x) => data_row.push(ArrayNode::Number(x)),
|
||||
Err(Error::DIV) => {
|
||||
data_row.push(ArrayNode::Error(Error::DIV))
|
||||
}
|
||||
Err(Error::VALUE) => {
|
||||
data_row.push(ArrayNode::Error(Error::VALUE))
|
||||
}
|
||||
Err(e) => data_row.push(ArrayNode::Error(e)),
|
||||
}
|
||||
}
|
||||
// If Number, apply directly
|
||||
ArrayNode::Number(n) => match $op(n) {
|
||||
Ok(x) => data_row.push(ArrayNode::Number(x)),
|
||||
Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
|
||||
Err(Error::VALUE) => {
|
||||
data_row.push(ArrayNode::Error(Error::VALUE))
|
||||
}
|
||||
Err(e) => data_row.push(ArrayNode::Error(e)),
|
||||
},
|
||||
// If String, parse to f64 then apply or #VALUE! error
|
||||
ArrayNode::String(s) => {
|
||||
let node = match s.parse::<f64>() {
|
||||
Ok(f) => match $op(f) {
|
||||
Ok(x) => ArrayNode::Number(x),
|
||||
Err(Error::DIV) => ArrayNode::Error(Error::DIV),
|
||||
Err(Error::VALUE) => ArrayNode::Error(Error::VALUE),
|
||||
Err(e) => ArrayNode::Error(e),
|
||||
},
|
||||
Err(_) => ArrayNode::Error(Error::VALUE),
|
||||
};
|
||||
data_row.push(node);
|
||||
}
|
||||
// If Error, propagate the error
|
||||
e @ ArrayNode::Error(_) => {
|
||||
data_row.push(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
array.push(data_row);
|
||||
}
|
||||
CalcResult::Array(array)
|
||||
}
|
||||
|
||||
// -----------------------------------------
|
||||
// Case C: It's an Error => just return it
|
||||
// -----------------------------------------
|
||||
Err(err_result) => err_result,
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
@@ -1,9 +1,5 @@
|
||||
use crate::cast::NumberOrArray;
|
||||
use crate::constants::{LAST_COLUMN, LAST_ROW};
|
||||
use crate::expressions::parser::ArrayNode;
|
||||
use crate::expressions::types::CellReferenceIndex;
|
||||
use crate::number_format::to_precision;
|
||||
use crate::single_number_fn;
|
||||
use crate::{
|
||||
calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
|
||||
};
|
||||
@@ -173,27 +169,6 @@ impl Model {
|
||||
}
|
||||
}
|
||||
}
|
||||
CalcResult::Array(array) => {
|
||||
for row in array {
|
||||
for value in row {
|
||||
match value {
|
||||
ArrayNode::Number(value) => {
|
||||
result += value;
|
||||
}
|
||||
ArrayNode::Error(error) => {
|
||||
return CalcResult::Error {
|
||||
error,
|
||||
origin: cell,
|
||||
message: "Error in array".to_string(),
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
// We ignore booleans and strings
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
_ => {
|
||||
// We ignore booleans and strings
|
||||
@@ -312,7 +287,7 @@ impl Model {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => to_precision(f, 15),
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let number_of_digits = match self.get_number(&args[1], cell) {
|
||||
@@ -328,13 +303,12 @@ impl Model {
|
||||
let scale = 10.0_f64.powf(number_of_digits);
|
||||
CalcResult::Number((value * scale).round() / scale)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_roundup(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 2 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => to_precision(f, 15),
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let number_of_digits = match self.get_number(&args[1], cell) {
|
||||
@@ -354,13 +328,12 @@ impl Model {
|
||||
CalcResult::Number((value * scale).floor() / scale)
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn fn_rounddown(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 2 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => to_precision(f, 15),
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let number_of_digits = match self.get_number(&args[1], cell) {
|
||||
@@ -381,39 +354,187 @@ impl Model {
|
||||
}
|
||||
}
|
||||
|
||||
single_number_fn!(fn_log10, |f| if f <= 0.0 {
|
||||
Err(Error::NUM)
|
||||
} else {
|
||||
Ok(f64::log10(f))
|
||||
});
|
||||
single_number_fn!(fn_ln, |f| if f <= 0.0 {
|
||||
Err(Error::NUM)
|
||||
} else {
|
||||
Ok(f64::ln(f))
|
||||
});
|
||||
single_number_fn!(fn_sin, |f| Ok(f64::sin(f)));
|
||||
single_number_fn!(fn_cos, |f| Ok(f64::cos(f)));
|
||||
single_number_fn!(fn_tan, |f| Ok(f64::tan(f)));
|
||||
single_number_fn!(fn_sinh, |f| Ok(f64::sinh(f)));
|
||||
single_number_fn!(fn_cosh, |f| Ok(f64::cosh(f)));
|
||||
single_number_fn!(fn_tanh, |f| Ok(f64::tanh(f)));
|
||||
single_number_fn!(fn_asin, |f| Ok(f64::asin(f)));
|
||||
single_number_fn!(fn_acos, |f| Ok(f64::acos(f)));
|
||||
single_number_fn!(fn_atan, |f| Ok(f64::atan(f)));
|
||||
single_number_fn!(fn_asinh, |f| Ok(f64::asinh(f)));
|
||||
single_number_fn!(fn_acosh, |f| Ok(f64::acosh(f)));
|
||||
single_number_fn!(fn_atanh, |f| Ok(f64::atanh(f)));
|
||||
single_number_fn!(fn_abs, |f| Ok(f64::abs(f)));
|
||||
single_number_fn!(fn_sqrt, |f| if f < 0.0 {
|
||||
Err(Error::NUM)
|
||||
} else {
|
||||
Ok(f64::sqrt(f))
|
||||
});
|
||||
single_number_fn!(fn_sqrtpi, |f: f64| if f < 0.0 {
|
||||
Err(Error::NUM)
|
||||
} else {
|
||||
Ok((f * PI).sqrt())
|
||||
});
|
||||
pub(crate) fn fn_sin(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let result = value.sin();
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
pub(crate) fn fn_cos(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let result = value.cos();
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_tan(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let result = value.tan();
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_sinh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let result = value.sinh();
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
pub(crate) fn fn_cosh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let result = value.cosh();
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_tanh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let result = value.tanh();
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_asin(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let result = value.asin();
|
||||
if result.is_nan() || result.is_infinite() {
|
||||
return CalcResult::Error {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Invalid argument for ASIN".to_string(),
|
||||
};
|
||||
}
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
pub(crate) fn fn_acos(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let result = value.acos();
|
||||
if result.is_nan() || result.is_infinite() {
|
||||
return CalcResult::Error {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Invalid argument for COS".to_string(),
|
||||
};
|
||||
}
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_atan(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let result = value.atan();
|
||||
if result.is_nan() || result.is_infinite() {
|
||||
return CalcResult::Error {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Invalid argument for ATAN".to_string(),
|
||||
};
|
||||
}
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_asinh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let result = value.asinh();
|
||||
if result.is_nan() || result.is_infinite() {
|
||||
return CalcResult::Error {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Invalid argument for ASINH".to_string(),
|
||||
};
|
||||
}
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
pub(crate) fn fn_acosh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let result = value.acosh();
|
||||
if result.is_nan() || result.is_infinite() {
|
||||
return CalcResult::Error {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Invalid argument for ACOSH".to_string(),
|
||||
};
|
||||
}
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_atanh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let result = value.atanh();
|
||||
if result.is_nan() || result.is_infinite() {
|
||||
return CalcResult::Error {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Invalid argument for ATANH".to_string(),
|
||||
};
|
||||
}
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_pi(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if !args.is_empty() {
|
||||
@@ -422,6 +543,53 @@ impl Model {
|
||||
CalcResult::Number(PI)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_abs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
CalcResult::Number(value.abs())
|
||||
}
|
||||
|
||||
pub(crate) fn fn_sqrtpi(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
if value < 0.0 {
|
||||
return CalcResult::Error {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Argument of SQRTPI should be >= 0".to_string(),
|
||||
};
|
||||
}
|
||||
CalcResult::Number((value * PI).sqrt())
|
||||
}
|
||||
|
||||
pub(crate) fn fn_sqrt(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
if value < 0.0 {
|
||||
return CalcResult::Error {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Argument of SQRT should be >= 0".to_string(),
|
||||
};
|
||||
}
|
||||
CalcResult::Number(value.sqrt())
|
||||
}
|
||||
|
||||
pub(crate) fn fn_atan2(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 2 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
@@ -444,47 +612,6 @@ impl Model {
|
||||
CalcResult::Number(f64::atan2(y, x))
|
||||
}
|
||||
|
||||
pub(crate) fn fn_log(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
let n_args = args.len();
|
||||
if !(1..=2).contains(&n_args) {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let x = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let y = if n_args == 1 {
|
||||
10.0
|
||||
} else {
|
||||
match self.get_number(&args[1], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
}
|
||||
};
|
||||
if x <= 0.0 {
|
||||
return CalcResult::Error {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Number must be positive".to_string(),
|
||||
};
|
||||
}
|
||||
if y == 1.0 {
|
||||
return CalcResult::Error {
|
||||
error: Error::DIV,
|
||||
origin: cell,
|
||||
message: "Logarithm base cannot be 1".to_string(),
|
||||
};
|
||||
}
|
||||
if y <= 0.0 {
|
||||
return CalcResult::Error {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Logarithm base must be positive".to_string(),
|
||||
};
|
||||
}
|
||||
CalcResult::Number(f64::log(x, y))
|
||||
}
|
||||
|
||||
pub(crate) fn fn_power(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 2 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
|
||||
@@ -15,7 +15,6 @@ mod financial_util;
|
||||
mod information;
|
||||
mod logical;
|
||||
mod lookup_and_reference;
|
||||
mod macros;
|
||||
mod mathematical;
|
||||
mod statistical;
|
||||
mod subtotal;
|
||||
@@ -54,9 +53,6 @@ pub enum Function {
|
||||
Columns,
|
||||
Cos,
|
||||
Cosh,
|
||||
Log,
|
||||
Log10,
|
||||
Ln,
|
||||
Max,
|
||||
Min,
|
||||
Pi,
|
||||
@@ -253,7 +249,7 @@ pub enum Function {
|
||||
}
|
||||
|
||||
impl Function {
|
||||
pub fn into_iter() -> IntoIter<Function, 198> {
|
||||
pub fn into_iter() -> IntoIter<Function, 195> {
|
||||
[
|
||||
Function::And,
|
||||
Function::False,
|
||||
@@ -280,9 +276,6 @@ impl Function {
|
||||
Function::Atanh,
|
||||
Function::Abs,
|
||||
Function::Pi,
|
||||
Function::Ln,
|
||||
Function::Log,
|
||||
Function::Log10,
|
||||
Function::Sqrt,
|
||||
Function::Sqrtpi,
|
||||
Function::Atan2,
|
||||
@@ -540,10 +533,6 @@ impl Function {
|
||||
"POWER" => Some(Function::Power),
|
||||
"ATAN2" => Some(Function::Atan2),
|
||||
|
||||
"LN" => Some(Function::Ln),
|
||||
"LOG" => Some(Function::Log),
|
||||
"LOG10" => Some(Function::Log10),
|
||||
|
||||
"MAX" => Some(Function::Max),
|
||||
"MIN" => Some(Function::Min),
|
||||
"PRODUCT" => Some(Function::Product),
|
||||
@@ -744,9 +733,6 @@ impl fmt::Display for Function {
|
||||
Function::Switch => write!(f, "SWITCH"),
|
||||
Function::True => write!(f, "TRUE"),
|
||||
Function::Xor => write!(f, "XOR"),
|
||||
Function::Log => write!(f, "LOG"),
|
||||
Function::Log10 => write!(f, "LOG10"),
|
||||
Function::Ln => write!(f, "LN"),
|
||||
Function::Sin => write!(f, "SIN"),
|
||||
Function::Cos => write!(f, "COS"),
|
||||
Function::Tan => write!(f, "TAN"),
|
||||
@@ -974,9 +960,6 @@ impl Model {
|
||||
Function::True => self.fn_true(args, cell),
|
||||
Function::Xor => self.fn_xor(args, cell),
|
||||
// Math and trigonometry
|
||||
Function::Log => self.fn_log(args, cell),
|
||||
Function::Log10 => self.fn_log10(args, cell),
|
||||
Function::Ln => self.fn_ln(args, cell),
|
||||
Function::Sin => self.fn_sin(args, cell),
|
||||
Function::Cos => self.fn_cos(args, cell),
|
||||
Function::Tan => self.fn_tan(args, cell),
|
||||
@@ -1230,7 +1213,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();
|
||||
|
||||
@@ -134,13 +134,6 @@ impl Model {
|
||||
);
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => {}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -172,13 +165,6 @@ impl Model {
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => {}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
if count == 0.0 {
|
||||
@@ -350,7 +336,7 @@ impl Model {
|
||||
// FIXME: This function shares a lot of code with apply_ifs. Can we merge them?
|
||||
pub(crate) fn fn_countifs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
let args_count = args.len();
|
||||
if args_count < 2 || !args_count.is_multiple_of(2) {
|
||||
if args_count < 2 || args_count % 2 == 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
|
||||
@@ -402,7 +388,7 @@ impl Model {
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Invalid worksheet index: '{}'", first_range.left.sheet),
|
||||
)
|
||||
);
|
||||
}
|
||||
};
|
||||
let max_row = dimension.max_row;
|
||||
@@ -476,7 +462,7 @@ impl Model {
|
||||
F: FnMut(f64),
|
||||
{
|
||||
let args_count = args.len();
|
||||
if args_count < 3 || args_count.is_multiple_of(2) {
|
||||
if args_count < 3 || args_count % 2 == 0 {
|
||||
return Err(CalcResult::new_args_number_error(cell));
|
||||
}
|
||||
let arg_0 = self.evaluate_node_in_context(&args[0], cell);
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
use crate::{
|
||||
calc_result::CalcResult,
|
||||
expressions::{
|
||||
parser::{parse_range, Node},
|
||||
parser::{Node, parse_range},
|
||||
token::Error,
|
||||
types::CellReferenceIndex,
|
||||
},
|
||||
@@ -182,13 +182,6 @@ impl Model {
|
||||
}
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => result.push(0.0),
|
||||
CalcResult::Array(_) => {
|
||||
return Err(CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -433,13 +426,6 @@ impl Model {
|
||||
| CalcResult::Number(_)
|
||||
| CalcResult::Boolean(_)
|
||||
| CalcResult::Error { .. } => counta += 1,
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,7 +8,7 @@ use crate::{
|
||||
};
|
||||
|
||||
use super::{
|
||||
text_util::{substitute, text_after, text_before, Case},
|
||||
text_util::{Case, substitute, text_after, text_before},
|
||||
util::from_wildcard_to_regex,
|
||||
};
|
||||
|
||||
@@ -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!("{result}TRUE");
|
||||
result = format!("{}TRUE", result);
|
||||
} else {
|
||||
result = format!("{result}FALSE");
|
||||
result = format!("{}FALSE", result);
|
||||
}
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
@@ -82,37 +82,25 @@ impl Model {
|
||||
column,
|
||||
}) {
|
||||
CalcResult::String(value) => {
|
||||
result = format!("{result}{value}");
|
||||
result = format!("{}{}", result, value);
|
||||
}
|
||||
CalcResult::Number(value) => {
|
||||
result = format!("{}{}", result, value)
|
||||
}
|
||||
CalcResult::Number(value) => result = format!("{result}{value}"),
|
||||
CalcResult::Boolean(value) => {
|
||||
if value {
|
||||
result = format!("{result}TRUE");
|
||||
result = format!("{}TRUE", result);
|
||||
} else {
|
||||
result = format!("{result}FALSE");
|
||||
result = format!("{}FALSE", result);
|
||||
}
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => {}
|
||||
CalcResult::Range { .. } => {}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
CalcResult::String(result)
|
||||
@@ -137,13 +125,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => 0.0,
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
let format_code = match self.get_string(&args[1], cell) {
|
||||
Ok(s) => s,
|
||||
@@ -280,7 +261,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 {
|
||||
@@ -299,13 +280,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
return CalcResult::Number(s.chars().count() as f64);
|
||||
}
|
||||
@@ -315,7 +289,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 {
|
||||
@@ -334,13 +308,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
return CalcResult::String(s.trim().to_owned());
|
||||
}
|
||||
@@ -350,7 +317,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 {
|
||||
@@ -369,13 +336,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
return CalcResult::String(s.to_lowercase());
|
||||
}
|
||||
@@ -385,7 +345,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 {
|
||||
@@ -408,14 +368,7 @@ impl Model {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Empty cell".to_string(),
|
||||
}
|
||||
}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
@@ -439,7 +392,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 {
|
||||
@@ -458,13 +411,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
return CalcResult::String(s.to_uppercase());
|
||||
}
|
||||
@@ -476,7 +422,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 {
|
||||
@@ -495,13 +441,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
let num_chars = if args.len() == 2 {
|
||||
match self.evaluate_node_in_context(&args[1], cell) {
|
||||
@@ -532,13 +471,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => 0,
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
1
|
||||
@@ -558,7 +490,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 {
|
||||
@@ -577,13 +509,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
let num_chars = if args.len() == 2 {
|
||||
match self.evaluate_node_in_context(&args[1], cell) {
|
||||
@@ -614,13 +539,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => 0,
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
1
|
||||
@@ -640,7 +558,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 {
|
||||
@@ -659,13 +577,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
let start_num = match self.evaluate_node_in_context(&args[1], cell) {
|
||||
CalcResult::Number(v) => {
|
||||
@@ -718,7 +629,7 @@ impl Model {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Expecting number".to_string(),
|
||||
}
|
||||
};
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::Range { .. } => {
|
||||
@@ -730,13 +641,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => 0,
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
let mut result = "".to_string();
|
||||
let mut count: usize = 0;
|
||||
@@ -1079,13 +983,6 @@ impl Model {
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::EmptyArg | CalcResult::Range { .. } => {}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1105,13 +1002,6 @@ impl Model {
|
||||
}
|
||||
}
|
||||
CalcResult::EmptyArg => {}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
let result = values.join(&delimiter);
|
||||
@@ -1235,11 +1125,6 @@ impl Model {
|
||||
}
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => CalcResult::Number(0.0),
|
||||
CalcResult::Array(_) => CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
@@ -393,8 +393,10 @@ pub(crate) fn build_criteria<'a>(value: &'a CalcResult) -> Box<dyn Fn(&CalcResul
|
||||
// An error will match an error (never a string that is an error)
|
||||
Box::new(move |x| result_is_equal_to_error(x, &error.to_string()))
|
||||
}
|
||||
CalcResult::Range { left: _, right: _ } => Box::new(move |_x| false),
|
||||
CalcResult::Array(_) => Box::new(move |_x| false),
|
||||
CalcResult::Range { left: _, right: _ } => {
|
||||
// TODO: Implicit Intersection
|
||||
Box::new(move |_x| false)
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => Box::new(result_is_equal_to_empty),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -141,9 +141,9 @@ impl Model {
|
||||
/// * 1 - Perform a search starting at the first item. This is the default.
|
||||
/// * -1 - Perform a reverse search starting at the last item.
|
||||
/// * 2 - Perform a binary search that relies on lookup_array being sorted
|
||||
/// in ascending order. If not sorted, invalid results will be returned.
|
||||
/// in ascending order. If not sorted, invalid results will be returned.
|
||||
/// * -2 - Perform a binary search that relies on lookup_array being sorted
|
||||
/// in descending order. If not sorted, invalid results will be returned.
|
||||
/// in descending order. If not sorted, invalid results will be returned.
|
||||
pub(crate) fn fn_xlookup(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() < 3 || args.len() > 6 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
use std::{collections::HashMap, sync::OnceLock};
|
||||
use std::collections::HashMap;
|
||||
|
||||
use bitcode::{Decode, Encode};
|
||||
use once_cell::sync::Lazy;
|
||||
|
||||
#[derive(Encode, Decode, Clone)]
|
||||
pub struct Booleans {
|
||||
@@ -30,17 +31,14 @@ pub struct Language {
|
||||
pub errors: Errors,
|
||||
}
|
||||
|
||||
static LANGUAGES: OnceLock<HashMap<String, Language>> = OnceLock::new();
|
||||
|
||||
#[allow(clippy::expect_used)]
|
||||
fn get_languages() -> &'static HashMap<String, Language> {
|
||||
LANGUAGES.get_or_init(|| {
|
||||
bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
|
||||
})
|
||||
}
|
||||
static LANGUAGES: Lazy<HashMap<String, Language>> = Lazy::new(|| {
|
||||
bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
|
||||
});
|
||||
|
||||
pub fn get_language(id: &str) -> Result<&Language, String> {
|
||||
get_languages()
|
||||
let language = LANGUAGES
|
||||
.get(id)
|
||||
.ok_or_else(|| format!("Language is not supported: '{id}'"))
|
||||
.ok_or(format!("Language is not supported: '{}'", id))?;
|
||||
Ok(language)
|
||||
}
|
||||
|
||||
@@ -39,9 +39,9 @@ pub mod types;
|
||||
pub mod worksheet;
|
||||
|
||||
mod actions;
|
||||
mod arithmetic;
|
||||
mod cast;
|
||||
mod constants;
|
||||
mod diffs;
|
||||
mod functions;
|
||||
mod implicit_intersection;
|
||||
mod model;
|
||||
@@ -57,8 +57,8 @@ mod test;
|
||||
#[cfg(test)]
|
||||
pub mod mock_time;
|
||||
|
||||
pub use model::get_milliseconds_since_epoch;
|
||||
pub use model::Model;
|
||||
pub use model::get_milliseconds_since_epoch;
|
||||
pub use user_model::BorderArea;
|
||||
pub use user_model::ClipboardData;
|
||||
pub use user_model::UserModel;
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
use std::{collections::HashMap, sync::OnceLock};
|
||||
|
||||
use bitcode::{Decode, Encode};
|
||||
use once_cell::sync::Lazy;
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
#[derive(Encode, Decode, Clone)]
|
||||
pub struct Locale {
|
||||
@@ -64,17 +65,12 @@ pub struct DecimalFormats {
|
||||
pub standard: String,
|
||||
}
|
||||
|
||||
static LOCALES: OnceLock<HashMap<String, Locale>> = OnceLock::new();
|
||||
|
||||
#[allow(clippy::expect_used)]
|
||||
fn get_locales() -> &'static HashMap<String, Locale> {
|
||||
LOCALES.get_or_init(|| {
|
||||
bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale")
|
||||
})
|
||||
}
|
||||
static LOCALES: Lazy<HashMap<String, Locale>> =
|
||||
Lazy::new(|| bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale"));
|
||||
|
||||
pub fn get_locale(id: &str) -> Result<&Locale, String> {
|
||||
get_locales()
|
||||
.get(id)
|
||||
.ok_or_else(|| format!("Invalid locale: '{id}'"))
|
||||
// TODO: pass the locale once we implement locales in Rust
|
||||
let locale = LOCALES.get(id).ok_or("Invalid locale")?;
|
||||
Ok(locale)
|
||||
}
|
||||
|
||||
@@ -10,11 +10,11 @@ use crate::{
|
||||
expressions::{
|
||||
lexer::LexerMode,
|
||||
parser::{
|
||||
move_formula::{move_formula, MoveContext},
|
||||
stringify::{rename_defined_name_in_node, to_rc_format, to_string},
|
||||
Node, Parser,
|
||||
move_formula::{MoveContext, move_formula},
|
||||
stringify::{rename_defined_name_in_node, to_rc_format, to_string},
|
||||
},
|
||||
token::{get_error_by_name, Error, OpCompare, OpProduct, OpSum, OpUnary},
|
||||
token::{Error, OpCompare, OpProduct, OpSum, OpUnary, get_error_by_name},
|
||||
types::*,
|
||||
utils::{self, is_valid_column_number, is_valid_identifier, is_valid_row},
|
||||
},
|
||||
@@ -24,8 +24,8 @@ use crate::{
|
||||
},
|
||||
functions::util::compare_values,
|
||||
implicit_intersection::implicit_intersection,
|
||||
language::{get_language, Language},
|
||||
locale::{get_locale, Currency, Locale},
|
||||
language::{Language, get_language},
|
||||
locale::{Currency, Locale, get_locale},
|
||||
types::*,
|
||||
utils as common,
|
||||
};
|
||||
@@ -106,15 +106,15 @@ pub struct Model {
|
||||
pub(crate) shared_strings: HashMap<String, usize>,
|
||||
/// An instance of the parser
|
||||
pub(crate) parser: Parser,
|
||||
/// The list of cells with formulas that are evaluated or being evaluated
|
||||
/// The list of cells with formulas that are evaluated of being evaluated
|
||||
pub(crate) cells: HashMap<(u32, i32, i32), CellState>,
|
||||
/// The locale of the model
|
||||
pub(crate) locale: Locale,
|
||||
/// The language used
|
||||
/// Tha language used
|
||||
pub(crate) language: Language,
|
||||
/// The timezone used to evaluate the model
|
||||
pub(crate) tz: Tz,
|
||||
/// The view id. A view consists of a selected sheet and ranges.
|
||||
/// The view id. A view consist of a selected sheet and ranges.
|
||||
pub(crate) view_id: u32,
|
||||
}
|
||||
|
||||
@@ -207,17 +207,6 @@ impl Model {
|
||||
},
|
||||
}
|
||||
}
|
||||
Node::ImplicitIntersection {
|
||||
automatic: _,
|
||||
child,
|
||||
} => match self.evaluate_node_with_reference(child, cell) {
|
||||
CalcResult::Range { left, right } => CalcResult::Range { left, right },
|
||||
_ => CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Error with Implicit Intersection in cell {cell:?}"),
|
||||
),
|
||||
},
|
||||
_ => self.evaluate_node_in_context(node, cell),
|
||||
}
|
||||
}
|
||||
@@ -267,10 +256,27 @@ impl Model {
|
||||
) -> CalcResult {
|
||||
use Node::*;
|
||||
match node {
|
||||
OpSumKind { kind, left, right } => match kind {
|
||||
OpSum::Add => self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1 + f2)),
|
||||
OpSum::Minus => self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1 - f2)),
|
||||
},
|
||||
OpSumKind { kind, left, right } => {
|
||||
// In the future once the feature try trait stabilizes we could use the '?' operator for this :)
|
||||
// See: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=236044e8321a1450988e6ffe5a27dab5
|
||||
let l = match self.get_number(left, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
let r = match self.get_number(right, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
let result = match kind {
|
||||
OpSum::Add => l + r,
|
||||
OpSum::Minus => l - r,
|
||||
};
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
NumberKind(value) => CalcResult::Number(*value),
|
||||
StringKind(value) => CalcResult::String(value.replace(r#""""#, r#"""#)),
|
||||
BooleanKind(value) => CalcResult::Boolean(*value),
|
||||
@@ -355,30 +361,62 @@ impl Model {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
let result = format!("{l}{r}");
|
||||
let result = format!("{}{}", l, r);
|
||||
CalcResult::String(result)
|
||||
}
|
||||
OpProductKind { kind, left, right } => match kind {
|
||||
OpProduct::Times => {
|
||||
self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1 * f2))
|
||||
}
|
||||
OpProduct::Divide => self.handle_arithmetic(left, right, cell, &|f1, f2| {
|
||||
if f2 == 0.0 {
|
||||
Err(Error::DIV)
|
||||
} else {
|
||||
Ok(f1 / f2)
|
||||
OpProductKind { kind, left, right } => {
|
||||
let l = match self.get_number(left, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
}),
|
||||
},
|
||||
};
|
||||
let r = match self.get_number(right, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
let result = match kind {
|
||||
OpProduct::Times => l * r,
|
||||
OpProduct::Divide => {
|
||||
if r == 0.0 {
|
||||
return CalcResult::new_error(
|
||||
Error::DIV,
|
||||
cell,
|
||||
"Divide by Zero".to_string(),
|
||||
);
|
||||
}
|
||||
l / r
|
||||
}
|
||||
};
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
OpPowerKind { left, right } => {
|
||||
self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1.powf(f2)))
|
||||
let l = match self.get_number(left, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
let r = match self.get_number(right, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
// Deal with errors properly
|
||||
CalcResult::Number(l.powf(r))
|
||||
}
|
||||
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, _)) => {
|
||||
ArrayKind(_) => {
|
||||
// TODO: NOT IMPLEMENTED
|
||||
CalcResult::new_error(Error::NIMPL, cell, "Arrays not implemented".to_string())
|
||||
}
|
||||
DefinedNameKind((name, scope)) => {
|
||||
if let Ok(Some(parsed_defined_name)) = self.get_parsed_defined_name(name, *scope) {
|
||||
match parsed_defined_name {
|
||||
ParsedDefinedName::CellReference(reference) => {
|
||||
@@ -391,26 +429,26 @@ impl Model {
|
||||
ParsedDefinedName::InvalidDefinedNameFormula => CalcResult::new_error(
|
||||
Error::NAME,
|
||||
cell,
|
||||
format!("Defined name \"{name}\" is not a reference."),
|
||||
format!("Defined name \"{}\" is not a reference.", name),
|
||||
),
|
||||
}
|
||||
} else {
|
||||
CalcResult::new_error(
|
||||
Error::NAME,
|
||||
cell,
|
||||
format!("Defined name \"{name}\" not found."),
|
||||
format!("Defined name \"{}\" not found.", name),
|
||||
)
|
||||
}
|
||||
}
|
||||
TableNameKind(s) => CalcResult::new_error(
|
||||
Error::NAME,
|
||||
cell,
|
||||
format!("table name \"{s}\" not supported."),
|
||||
format!("table name \"{}\" not supported.", s),
|
||||
),
|
||||
WrongVariableKind(s) => CalcResult::new_error(
|
||||
Error::NAME,
|
||||
cell,
|
||||
format!("Variable name \"{s}\" not found."),
|
||||
format!("Variable name \"{}\" not found.", s),
|
||||
),
|
||||
CompareKind { kind, left, right } => {
|
||||
let l = self.evaluate_node_in_context(left, cell);
|
||||
@@ -487,25 +525,9 @@ impl Model {
|
||||
} => CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Error parsing {formula}: {message}"),
|
||||
format!("Error parsing {}: {}", formula, message),
|
||||
),
|
||||
EmptyArgKind => CalcResult::EmptyArg,
|
||||
ImplicitIntersection {
|
||||
automatic: _,
|
||||
child,
|
||||
} => match self.evaluate_node_with_reference(child, cell) {
|
||||
CalcResult::Range { left, right } => {
|
||||
match implicit_intersection(&cell, &Range { left, right }) {
|
||||
Some(cell_reference) => self.evaluate_cell(cell_reference),
|
||||
None => CalcResult::new_error(
|
||||
Error::VALUE,
|
||||
cell,
|
||||
format!("Error with Implicit Intersection in cell {cell:?}"),
|
||||
),
|
||||
}
|
||||
}
|
||||
_ => self.evaluate_node_in_context(child, cell),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
@@ -595,15 +617,12 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::Range { left, right } => {
|
||||
if left.sheet == right.sheet
|
||||
&& left.row == right.row
|
||||
&& left.column == right.column
|
||||
let range = Range {
|
||||
left: *left,
|
||||
right: *right,
|
||||
};
|
||||
if let Some(intersection_cell) = implicit_intersection(&cell_reference, &range)
|
||||
{
|
||||
let intersection_cell = CellReferenceIndex {
|
||||
sheet: left.sheet,
|
||||
column: left.column,
|
||||
row: left.row,
|
||||
};
|
||||
let v = self.evaluate_cell(intersection_cell);
|
||||
self.set_cell_value(cell_reference, &v);
|
||||
} else {
|
||||
@@ -620,32 +639,10 @@ impl Model {
|
||||
f,
|
||||
s,
|
||||
o,
|
||||
m: "Implicit Intersection not implemented".to_string(),
|
||||
ei: Error::NIMPL,
|
||||
m: "Invalid reference".to_string(),
|
||||
ei: Error::VALUE,
|
||||
};
|
||||
}
|
||||
// if let Some(intersection_cell) = implicit_intersection(&cell_reference, &range)
|
||||
// {
|
||||
// let v = self.evaluate_cell(intersection_cell);
|
||||
// self.set_cell_value(cell_reference, &v);
|
||||
// } else {
|
||||
// let o = match self.cell_reference_to_string(&cell_reference) {
|
||||
// Ok(s) => s,
|
||||
// Err(_) => "".to_string(),
|
||||
// };
|
||||
// *self.workbook.worksheets[sheet as usize]
|
||||
// .sheet_data
|
||||
// .get_mut(&row)
|
||||
// .expect("expected a row")
|
||||
// .get_mut(&column)
|
||||
// .expect("expected a column") = Cell::CellFormulaError {
|
||||
// f,
|
||||
// s,
|
||||
// o,
|
||||
// m: "Invalid reference".to_string(),
|
||||
// ei: Error::VALUE,
|
||||
// };
|
||||
// }
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => {
|
||||
*self.workbook.worksheets[sheet as usize]
|
||||
@@ -655,20 +652,6 @@ impl Model {
|
||||
.get_mut(&column)
|
||||
.expect("expected a column") = Cell::CellFormulaNumber { f, s, v: 0.0 };
|
||||
}
|
||||
CalcResult::Array(_) => {
|
||||
*self.workbook.worksheets[sheet as usize]
|
||||
.sheet_data
|
||||
.get_mut(&row)
|
||||
.expect("expected a row")
|
||||
.get_mut(&column)
|
||||
.expect("expected a column") = Cell::CellFormulaError {
|
||||
f,
|
||||
s,
|
||||
o: "".to_string(),
|
||||
m: "Arrays not supported yet".to_string(),
|
||||
ei: Error::NIMPL,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -697,7 +680,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
|
||||
@@ -882,7 +865,11 @@ impl Model {
|
||||
|
||||
let worksheet_names = worksheets.iter().map(|s| s.get_name()).collect();
|
||||
|
||||
let defined_names = workbook.get_defined_names_with_scope();
|
||||
let defined_names = workbook
|
||||
.get_defined_names_with_scope()
|
||||
.iter()
|
||||
.map(|s| (s.0.to_owned(), s.1))
|
||||
.collect();
|
||||
// add all tables
|
||||
// let mut tables = Vec::new();
|
||||
// for worksheet in worksheets {
|
||||
@@ -1027,7 +1014,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 +1028,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 +1048,7 @@ impl Model {
|
||||
column_delta: target.column - source.column,
|
||||
},
|
||||
);
|
||||
Ok(format!("={formula_str}"))
|
||||
Ok(format!("={}", formula_str))
|
||||
} else {
|
||||
Ok(value.to_string())
|
||||
}
|
||||
@@ -1538,7 +1525,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,
|
||||
|
||||
@@ -8,17 +8,16 @@ use crate::{
|
||||
expressions::{
|
||||
lexer::LexerMode,
|
||||
parser::{
|
||||
stringify::{rename_sheet_in_node, to_rc_format, to_string},
|
||||
Parser,
|
||||
stringify::{rename_sheet_in_node, to_rc_format},
|
||||
},
|
||||
types::CellReferenceRC,
|
||||
},
|
||||
language::get_language,
|
||||
locale::get_locale,
|
||||
model::{get_milliseconds_since_epoch, Model, ParsedDefinedName},
|
||||
model::{Model, ParsedDefinedName, get_milliseconds_since_epoch},
|
||||
types::{
|
||||
DefinedName, Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet,
|
||||
WorksheetView,
|
||||
Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet, WorksheetView,
|
||||
},
|
||||
utils::ParsedReference,
|
||||
};
|
||||
@@ -145,7 +144,12 @@ impl Model {
|
||||
|
||||
/// Reparses all formulas and defined names
|
||||
pub(crate) fn reset_parsed_structures(&mut self) {
|
||||
let defined_names = self.workbook.get_defined_names_with_scope();
|
||||
let defined_names = self
|
||||
.workbook
|
||||
.get_defined_names_with_scope()
|
||||
.iter()
|
||||
.map(|s| (s.0.to_owned(), s.1))
|
||||
.collect();
|
||||
self.parser
|
||||
.set_worksheets_and_names(self.workbook.get_worksheet_names(), defined_names);
|
||||
self.parsed_formulas = vec![];
|
||||
@@ -168,11 +172,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 +196,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,12 +238,12 @@ 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.
|
||||
/// It can fail if:
|
||||
/// * The original index is out of bounds
|
||||
/// * The original index is too large
|
||||
/// * The target sheet name already exists
|
||||
/// * The target sheet name is invalid
|
||||
pub fn rename_sheet_by_index(
|
||||
@@ -248,20 +252,22 @@ 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));
|
||||
}
|
||||
let worksheets = &self.workbook.worksheets;
|
||||
let sheet_count = worksheets.len() as u32;
|
||||
if sheet_index >= sheet_count {
|
||||
return Err("Sheet index out of bounds".to_string());
|
||||
}
|
||||
// Gets the new name and checks that a sheet with that index exists
|
||||
let old_name = self.workbook.worksheet(sheet_index)?.get_name();
|
||||
|
||||
// Parse all formulas with the old name
|
||||
// All internal formulas are R1C1
|
||||
self.parser.set_lexer_mode(LexerMode::R1C1);
|
||||
|
||||
for worksheet in &mut self.workbook.worksheets {
|
||||
// R1C1 formulas are not tied to a cell (but are tied to a cell)
|
||||
// We use iter because the default would be a mut_iter and we don't need a mutable reference
|
||||
let worksheets = &mut self.workbook.worksheets;
|
||||
for worksheet in worksheets {
|
||||
let cell_reference = &CellReferenceRC {
|
||||
sheet: worksheet.get_name(),
|
||||
row: 1,
|
||||
@@ -275,32 +281,11 @@ impl Model {
|
||||
}
|
||||
worksheet.shared_formulas = formulas;
|
||||
}
|
||||
|
||||
// Set the mode back to A1
|
||||
// Se the mode back to A1
|
||||
self.parser.set_lexer_mode(LexerMode::A1);
|
||||
|
||||
// We reparse all the defined names formulas
|
||||
let mut defined_names = Vec::new();
|
||||
// Defined names do not have a context, we can use anything
|
||||
let cell_reference = &CellReferenceRC {
|
||||
sheet: old_name.clone(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
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_string(&t, cell_reference);
|
||||
defined_names.push(DefinedName {
|
||||
name: defined_name.name.clone(),
|
||||
formula,
|
||||
sheet_id: defined_name.sheet_id,
|
||||
});
|
||||
}
|
||||
self.workbook.defined_names = defined_names;
|
||||
|
||||
// Update the name of the worksheet
|
||||
self.workbook.worksheet_mut(sheet_index)?.set_name(new_name);
|
||||
let worksheets = &mut self.workbook.worksheets;
|
||||
worksheets[sheet_index as usize].set_name(new_name);
|
||||
self.reset_parsed_structures();
|
||||
Ok(())
|
||||
}
|
||||
@@ -362,14 +347,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();
|
||||
|
||||
@@ -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!("{base}e{exponent}").parse::<f64>().unwrap_or({
|
||||
let value = format!("{}e{}", base, exponent).parse::<f64>().unwrap_or({
|
||||
// TODO: do this in a way that does not require a possible error
|
||||
0.0
|
||||
});
|
||||
@@ -150,7 +150,7 @@ pub fn format_number(value: f64, format_code: &str, locale: &str) -> Formatted {
|
||||
text: "#ERROR!".to_owned(),
|
||||
color: None,
|
||||
error: Some("Invalid locale".to_string()),
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
formatter::format::format_number(value, format_code, locale)
|
||||
|
||||
@@ -154,7 +154,7 @@ impl Styles {
|
||||
return Ok(cell_style.xf_id);
|
||||
}
|
||||
}
|
||||
Err(format!("Style '{style_name}' not found"))
|
||||
Err(format!("Style '{}' not found", style_name))
|
||||
}
|
||||
|
||||
pub fn create_named_style(&mut self, style_name: &str, style: &Style) -> Result<(), String> {
|
||||
|
||||
@@ -28,6 +28,7 @@ mod test_fn_sumifs;
|
||||
mod test_fn_textbefore;
|
||||
mod test_fn_textjoin;
|
||||
mod test_fn_unicode;
|
||||
mod test_forward_references;
|
||||
mod test_frozen_rows_columns;
|
||||
mod test_general;
|
||||
mod test_math;
|
||||
@@ -51,20 +52,14 @@ mod engineering;
|
||||
mod test_fn_offset;
|
||||
mod test_number_format;
|
||||
|
||||
mod test_arrays;
|
||||
mod test_escape_quotes;
|
||||
mod test_extend;
|
||||
mod test_fn_fv;
|
||||
mod test_fn_round;
|
||||
mod test_fn_type;
|
||||
mod test_frozen_rows_and_columns;
|
||||
mod test_geomean;
|
||||
mod test_get_cell_content;
|
||||
mod test_implicit_intersection;
|
||||
mod test_issue_155;
|
||||
mod test_ln;
|
||||
mod test_log;
|
||||
mod test_log10;
|
||||
mod test_percentage;
|
||||
mod test_set_functions_error_handling;
|
||||
mod test_today;
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN, LAST_ROW};
|
||||
use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN};
|
||||
use crate::model::Model;
|
||||
use crate::test::util::new_empty_model;
|
||||
use crate::types::Col;
|
||||
@@ -206,9 +206,11 @@ fn test_delete_column_width() {
|
||||
let (sheet, column) = (0, 5);
|
||||
let normal_width = model.get_column_width(sheet, column).unwrap();
|
||||
// Set the width of one column to 5 times the normal width
|
||||
assert!(model
|
||||
.set_column_width(sheet, column, normal_width * 5.0)
|
||||
.is_ok());
|
||||
assert!(
|
||||
model
|
||||
.set_column_width(sheet, column, normal_width * 5.0)
|
||||
.is_ok()
|
||||
);
|
||||
|
||||
// delete it
|
||||
assert!(model.delete_columns(sheet, column, 1).is_ok());
|
||||
@@ -508,10 +510,6 @@ fn test_move_column_right() {
|
||||
assert_eq!(model._get_formula("E5"), "=SUM(H3:J7)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM(H3:H7)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM(G3:G7)");
|
||||
|
||||
// Data moved as well
|
||||
assert_eq!(model._get_text("G1"), "1");
|
||||
assert_eq!(model._get_text("H1"), "3");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -536,249 +534,5 @@ fn tets_move_column_error() {
|
||||
assert!(result.is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_down() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Formulas referencing rows 3 and 4
|
||||
model._set("E3", "=G3");
|
||||
model._set("E4", "=G4");
|
||||
model._set("E5", "=SUM(G3:J3)");
|
||||
model._set("E6", "=SUM(G3:G3)");
|
||||
model._set("E7", "=SUM(G4:G4)");
|
||||
model.evaluate();
|
||||
|
||||
// Move row 3 down by one position
|
||||
let result = model.move_row_action(0, 3, 1);
|
||||
assert!(result.is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E3"), "=G3");
|
||||
assert_eq!(model._get_formula("E4"), "=G4");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM(G4:J4)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM(G4:G4)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM(G3:G3)");
|
||||
|
||||
// Data moved as well
|
||||
assert_eq!(model._get_text("G4"), "-2");
|
||||
assert_eq!(model._get_text("G3"), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_up() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Formulas referencing rows 4 and 5
|
||||
model._set("E4", "=G4");
|
||||
model._set("E5", "=G5");
|
||||
model._set("E6", "=SUM(G4:J4)");
|
||||
model._set("E7", "=SUM(G4:G4)");
|
||||
model._set("E8", "=SUM(G5:G5)");
|
||||
model.evaluate();
|
||||
|
||||
// Move row 5 up by one position
|
||||
let result = model.move_row_action(0, 5, -1);
|
||||
assert!(result.is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E4"), "=G4");
|
||||
assert_eq!(model._get_formula("E5"), "=G5");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM(G5:J5)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM(G5:G5)");
|
||||
assert_eq!(model._get_formula("E8"), "=SUM(G4:G4)");
|
||||
|
||||
// Data moved as well
|
||||
assert_eq!(model._get_text("G4"), "");
|
||||
assert_eq!(model._get_text("G5"), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_error() {
|
||||
let mut model = new_empty_model();
|
||||
model.evaluate();
|
||||
|
||||
let result = model.move_row_action(0, 7, -10);
|
||||
assert!(result.is_err());
|
||||
|
||||
let result = model.move_row_action(0, -7, 20);
|
||||
assert!(result.is_err());
|
||||
|
||||
let result = model.move_row_action(0, LAST_ROW, 1);
|
||||
assert!(result.is_err());
|
||||
|
||||
let result = model.move_row_action(0, LAST_ROW + 1, -10);
|
||||
assert!(result.is_err());
|
||||
|
||||
// This works
|
||||
let result = model.move_row_action(0, LAST_ROW, -1);
|
||||
assert!(result.is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_down_absolute_refs() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Absolute references
|
||||
model._set("E3", "=$G$3");
|
||||
model._set("E4", "=$G$4");
|
||||
model._set("E5", "=SUM($G$3:$J$3)");
|
||||
model._set("E6", "=SUM($G$3:$G$3)");
|
||||
model._set("E7", "=SUM($G$4:$G$4)");
|
||||
model.evaluate();
|
||||
|
||||
assert!(model.move_row_action(0, 3, 1).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E3"), "=$G$3");
|
||||
assert_eq!(model._get_formula("E4"), "=$G$4");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM($G$4:$J$4)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM($G$4:$G$4)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM($G$3:$G$3)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_column_right_absolute_refs() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Absolute references
|
||||
model._set("E3", "=$G$3");
|
||||
model._set("E4", "=$H$3");
|
||||
model._set("E5", "=SUM($G$3:$J$7)");
|
||||
model._set("E6", "=SUM($G$3:$G$7)");
|
||||
model._set("E7", "=SUM($H$3:$H$7)");
|
||||
model.evaluate();
|
||||
|
||||
assert!(model.move_column_action(0, 7, 1).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E3"), "=$H$3");
|
||||
assert_eq!(model._get_formula("E4"), "=$G$3");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM($H$3:$J$7)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM($H$3:$H$7)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM($G$3:$G$7)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_down_mixed_refs() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
model._set("E3", "=$G3"); // absolute col, relative row
|
||||
model._set("E4", "=$G4");
|
||||
model._set("E5", "=SUM($G3:$J3)");
|
||||
model._set("E6", "=SUM($G3:$G3)");
|
||||
model._set("E7", "=SUM($G4:$G4)");
|
||||
model._set("F3", "=H$3"); // relative col, absolute row
|
||||
model._set("F4", "=G$3");
|
||||
model.evaluate();
|
||||
|
||||
assert!(model.move_row_action(0, 3, 1).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E3"), "=$G3");
|
||||
assert_eq!(model._get_formula("E4"), "=$G4");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM($G4:$J4)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM($G4:$G4)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM($G3:$G3)");
|
||||
assert_eq!(model._get_formula("F3"), "=G$4");
|
||||
assert_eq!(model._get_formula("F4"), "=H$4");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_column_right_mixed_refs() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
model._set("E3", "=$G3");
|
||||
model._set("E4", "=$H3");
|
||||
model._set("E5", "=SUM($G3:$J7)");
|
||||
model._set("E6", "=SUM($G3:$G7)");
|
||||
model._set("E7", "=SUM($H3:$H7)");
|
||||
model._set("F3", "=H$3");
|
||||
model._set("F4", "=H$3");
|
||||
model.evaluate();
|
||||
|
||||
assert!(model.move_column_action(0, 7, 1).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E3"), "=$H3");
|
||||
assert_eq!(model._get_formula("E4"), "=$G3");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM($H3:$J7)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM($H3:$H7)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM($G3:$G7)");
|
||||
assert_eq!(model._get_formula("F3"), "=G$3");
|
||||
assert_eq!(model._get_formula("F4"), "=G$3");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_height() {
|
||||
let mut model = new_empty_model();
|
||||
let sheet = 0;
|
||||
let custom_height = DEFAULT_ROW_HEIGHT * 2.0;
|
||||
// Set a custom height for row 3
|
||||
model
|
||||
.workbook
|
||||
.worksheet_mut(sheet)
|
||||
.unwrap()
|
||||
.set_row_height(3, custom_height)
|
||||
.unwrap();
|
||||
|
||||
// Record the original height of row 4 (should be the default)
|
||||
let original_row4_height = model.get_row_height(sheet, 4).unwrap();
|
||||
|
||||
// Move row 3 down by one position
|
||||
assert!(model.move_row_action(sheet, 3, 1).is_ok());
|
||||
|
||||
// The custom height should now be on row 4
|
||||
assert_eq!(model.get_row_height(sheet, 4), Ok(custom_height));
|
||||
|
||||
// Row 3 should now have the previous height of row 4
|
||||
assert_eq!(model.get_row_height(sheet, 3), Ok(original_row4_height));
|
||||
}
|
||||
|
||||
/// Moving a row down by two positions should shift formulas on intermediate
|
||||
/// rows by only one (the row that gets skipped), not by the full delta ‒ this
|
||||
/// guards against the regression fixed in the RowMove displacement logic.
|
||||
#[test]
|
||||
fn test_row_move_down_two_updates_intermediate_refs_by_one() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Set up formulas to verify intermediate rows shift by 1 (not full delta).
|
||||
model._set("E3", "=G3"); // target row
|
||||
model._set("E4", "=G4"); // intermediate row
|
||||
model._set("E5", "=SUM(G3:J3)");
|
||||
model.evaluate();
|
||||
|
||||
// Move row 3 down by two positions (row 3 -> row 5)
|
||||
assert!(model.move_row_action(0, 3, 2).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
// Assert that references for the moved row and intermediate row are correct.
|
||||
assert_eq!(model._get_formula("E3"), "=G3");
|
||||
assert_eq!(model._get_formula("E5"), "=G5");
|
||||
assert_eq!(model._get_formula("E4"), "=SUM(G5:J5)");
|
||||
}
|
||||
|
||||
/// Moving a column right by two positions should shift formulas on
|
||||
/// intermediate columns by only one, ensuring the ColumnMove displacement
|
||||
/// logic handles multi-position moves correctly.
|
||||
#[test]
|
||||
fn test_column_move_right_two_updates_intermediate_refs_by_one() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Set up formulas to verify intermediate columns shift by 1 (not full delta).
|
||||
model._set("E3", "=$G3"); // target column
|
||||
model._set("E4", "=$H3"); // intermediate column
|
||||
model._set("E5", "=SUM($G3:$J7)");
|
||||
model.evaluate();
|
||||
|
||||
// Move column G (7) right by two positions (G -> I)
|
||||
assert!(model.move_column_action(0, 7, 2).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
// Assert that references for moved and intermediate columns are correct.
|
||||
assert_eq!(model._get_formula("E3"), "=$I3");
|
||||
assert_eq!(model._get_formula("E4"), "=$G3");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM($I3:$J7)");
|
||||
}
|
||||
|
||||
// A B C D E F G H I J K L M N O P Q R
|
||||
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
|
||||
|
||||
@@ -1,13 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn sum_arrays() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=SUM({1,2,3}+{3,4,5})");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"18");
|
||||
}
|
||||
@@ -22,14 +22,13 @@ fn fn_concatenate() {
|
||||
model._set("B1", r#"=CONCATENATE(A1, A2, A3, "!")"#);
|
||||
// This will break once we implement the implicit intersection operator
|
||||
// It should be:
|
||||
model._set("C2", r#"=CONCATENATE(@A1:A3, "!")"#);
|
||||
// model._set("B2", r#"=CONCATENATE(@A1:A3, "!")"#);
|
||||
model._set("B2", r#"=CONCATENATE(A1:A3, "!")"#);
|
||||
model._set("B3", r#"=CONCAT(A1:A3, "!")"#);
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"Hello my World!");
|
||||
assert_eq!(model._get_text("B2"), *"#N/IMPL!");
|
||||
assert_eq!(model._get_text("B2"), *" my !");
|
||||
assert_eq!(model._get_text("B3"), *"Hello my World!");
|
||||
assert_eq!(model._get_text("C2"), *" my !");
|
||||
}
|
||||
|
||||
@@ -30,18 +30,8 @@ fn implicit_intersection() {
|
||||
model._set("A2", "=FORMULATEXT(D1:E1)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#N/IMPL!");
|
||||
assert_eq!(model._get_text("A2"), *"#N/IMPL!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn implicit_intersection_operator() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=1 + 2");
|
||||
model._set("B1", "=FORMULATEXT(@A:A)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#N/IMPL!");
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -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!");
|
||||
}
|
||||
|
||||
@@ -1,15 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn fn_round_approximation() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=ROUND(1.05*(0.0284+0.0046)-0.0284,4)");
|
||||
model._set("A2", "=ROUNDDOWN(1.05*(0.0284+0.0046)-0.0284,5)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.0063");
|
||||
assert_eq!(model._get_text("A2"), *"0.00625");
|
||||
}
|
||||
@@ -17,19 +17,3 @@ fn test_fn_sum_arguments() {
|
||||
assert_eq!(model._get_text("A3"), *"1");
|
||||
assert_eq!(model._get_text("A4"), *"4");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arrays() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=SUM({1, 2, 3})");
|
||||
model._set("A2", "=SUM({1; 2; 3})");
|
||||
model._set("A3", "=SUM({1, 2; 3, 4})");
|
||||
model._set("A4", "=SUM({1, 2; 3, 4; 5, 6})");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"6");
|
||||
assert_eq!(model._get_text("A2"), *"6");
|
||||
assert_eq!(model._get_text("A3"), *"10");
|
||||
assert_eq!(model._get_text("A4"), *"21");
|
||||
}
|
||||
|
||||
121
base/src/test/test_forward_references.rs
Normal file
121
base/src/test/test_forward_references.rs
Normal file
@@ -0,0 +1,121 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::expressions::types::{Area, CellReferenceIndex};
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_forward_references() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// test single ref changed nd not changed
|
||||
model._set("H8", "=F6*G9");
|
||||
// tests areas
|
||||
model._set("H9", "=SUM(D4:F6)");
|
||||
// absolute coordinates
|
||||
model._set("H10", "=$F$6");
|
||||
// area larger than the source area
|
||||
model._set("H11", "=SUM(D3:F6)");
|
||||
// Test arguments and concat
|
||||
model._set("H12", "=SUM(F6, D4:F6) & D4");
|
||||
// Test range operator. This is syntax error for now.
|
||||
// model._set("H13", "=SUM(D4:INDEX(D4:F5,4,2))");
|
||||
// Test operations
|
||||
model._set("H14", "=-D4+D5*F6/F5");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Source Area is D4:F6
|
||||
let source_area = &Area {
|
||||
sheet: 0,
|
||||
row: 4,
|
||||
column: 4,
|
||||
width: 3,
|
||||
height: 3,
|
||||
};
|
||||
|
||||
// We paste in B10
|
||||
let target_row = 10;
|
||||
let target_column = 2;
|
||||
let result = model.forward_references(
|
||||
source_area,
|
||||
&CellReferenceIndex {
|
||||
sheet: 0,
|
||||
row: target_row,
|
||||
column: target_column,
|
||||
},
|
||||
);
|
||||
assert!(result.is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("H8"), "=D12*G9");
|
||||
assert_eq!(model._get_formula("H9"), "=SUM(B10:D12)");
|
||||
assert_eq!(model._get_formula("H10"), "=$D$12");
|
||||
|
||||
assert_eq!(model._get_formula("H11"), "=SUM(D3:F6)");
|
||||
assert_eq!(model._get_formula("H12"), "=SUM(D12,B10:D12)&B10");
|
||||
// assert_eq!(model._get_formula("H13"), "=SUM(B10:INDEX(B10:D11,4,2))");
|
||||
assert_eq!(model._get_formula("H14"), "=-B10+B11*D12/D11");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_different_sheet() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// test single ref changed not changed
|
||||
model._set("H8", "=F6*G9");
|
||||
// tests areas
|
||||
model._set("H9", "=SUM(D4:F6)");
|
||||
// absolute coordinates
|
||||
model._set("H10", "=$F$6");
|
||||
// area larger than the source area
|
||||
model._set("H11", "=SUM(D3:F6)");
|
||||
// Test arguments and concat
|
||||
model._set("H12", "=SUM(F6, D4:F6) & D4");
|
||||
// Test range operator. This is syntax error for now.
|
||||
// model._set("H13", "=SUM(D4:INDEX(D4:F5,4,2))");
|
||||
// Test operations
|
||||
model._set("H14", "=-D4+D5*F6/F5");
|
||||
|
||||
// Adds a new sheet
|
||||
assert!(model.add_sheet("Sheet2").is_ok());
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Source Area is D4:F6
|
||||
let source_area = &Area {
|
||||
sheet: 0,
|
||||
row: 4,
|
||||
column: 4,
|
||||
width: 3,
|
||||
height: 3,
|
||||
};
|
||||
|
||||
// We paste in Sheet2!B10
|
||||
let target_row = 10;
|
||||
let target_column = 2;
|
||||
let result = model.forward_references(
|
||||
source_area,
|
||||
&CellReferenceIndex {
|
||||
sheet: 1,
|
||||
row: target_row,
|
||||
column: target_column,
|
||||
},
|
||||
);
|
||||
assert!(result.is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("H8"), "=Sheet2!D12*G9");
|
||||
assert_eq!(model._get_formula("H9"), "=SUM(Sheet2!B10:D12)");
|
||||
assert_eq!(model._get_formula("H10"), "=Sheet2!$D$12");
|
||||
|
||||
assert_eq!(model._get_formula("H11"), "=SUM(D3:F6)");
|
||||
assert_eq!(
|
||||
model._get_formula("H12"),
|
||||
"=SUM(Sheet2!D12,Sheet2!B10:D12)&Sheet2!B10"
|
||||
);
|
||||
// assert_eq!(model._get_formula("H13"), "=SUM(B10:INDEX(B10:D11,4,2))");
|
||||
assert_eq!(
|
||||
model._get_formula("H14"),
|
||||
"=-Sheet2!B10+Sheet2!B11*Sheet2!D12/Sheet2!D11"
|
||||
);
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn simple_colum() {
|
||||
let mut model = new_empty_model();
|
||||
// We populate cells A1 to A3
|
||||
model._set("A1", "1");
|
||||
model._set("A2", "2");
|
||||
model._set("A3", "3");
|
||||
|
||||
model._set("C2", "=@A1:A3");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("C2"), "2".to_string());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn return_of_array_is_n_impl() {
|
||||
let mut model = new_empty_model();
|
||||
// We populate cells A1 to A3
|
||||
model._set("A1", "1");
|
||||
model._set("A2", "2");
|
||||
model._set("A3", "3");
|
||||
|
||||
model._set("C2", "=A1:A3");
|
||||
model._set("D2", "=SUM(SIN(A:A)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("C2"), "#N/IMPL!".to_string());
|
||||
assert_eq!(model._get_text("D2"), "1.89188842".to_string());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn concat() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=CONCAT(@B1:B3)");
|
||||
model._set("A2", "=CONCAT(B1:B3)");
|
||||
model._set("B1", "Hello");
|
||||
model._set("B2", " ");
|
||||
model._set("B3", "world!");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"Hello");
|
||||
assert_eq!(model._get_text("A2"), *"Hello world!");
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=LN(100)");
|
||||
model._set("A2", "=LN()");
|
||||
model._set("A3", "=LN(100, 10)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"4.605170186");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=LOG(100)");
|
||||
model._set("A2", "=LOG()");
|
||||
model._set("A3", "=LOG(10000, 10)");
|
||||
model._set("A4", "=LOG(100, 10, 1)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"2");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"4");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=LOG10(100)");
|
||||
model._set("A2", "=LOG10()");
|
||||
model._set("A3", "=LOG10(100, 10)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"2");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cell_and_function() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=LOG10");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// This is the cell LOG10
|
||||
assert_eq!(model._get_text("A1"), *"0");
|
||||
|
||||
model._set("LOG10", "1000");
|
||||
model._set("A2", "=LOG10(LOG10)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"1000");
|
||||
assert_eq!(model._get_text("A2"), *"3");
|
||||
}
|
||||
@@ -179,52 +179,60 @@ fn test_move_formula_rectangle() {
|
||||
width: 2,
|
||||
height: 20,
|
||||
};
|
||||
assert!(model
|
||||
.move_cell_value_to_area(
|
||||
value,
|
||||
&CellReferenceIndex {
|
||||
sheet: 0,
|
||||
column: 3,
|
||||
row: 1,
|
||||
},
|
||||
target,
|
||||
area
|
||||
)
|
||||
.is_err());
|
||||
assert!(model
|
||||
.move_cell_value_to_area(
|
||||
value,
|
||||
&CellReferenceIndex {
|
||||
sheet: 0,
|
||||
column: 2,
|
||||
row: 1,
|
||||
},
|
||||
target,
|
||||
area
|
||||
)
|
||||
.is_ok());
|
||||
assert!(model
|
||||
.move_cell_value_to_area(
|
||||
value,
|
||||
&CellReferenceIndex {
|
||||
sheet: 0,
|
||||
column: 1,
|
||||
row: 20,
|
||||
},
|
||||
target,
|
||||
area
|
||||
)
|
||||
.is_ok());
|
||||
assert!(model
|
||||
.move_cell_value_to_area(
|
||||
value,
|
||||
&CellReferenceIndex {
|
||||
sheet: 0,
|
||||
column: 1,
|
||||
row: 21,
|
||||
},
|
||||
target,
|
||||
area
|
||||
)
|
||||
.is_err());
|
||||
assert!(
|
||||
model
|
||||
.move_cell_value_to_area(
|
||||
value,
|
||||
&CellReferenceIndex {
|
||||
sheet: 0,
|
||||
column: 3,
|
||||
row: 1,
|
||||
},
|
||||
target,
|
||||
area
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
assert!(
|
||||
model
|
||||
.move_cell_value_to_area(
|
||||
value,
|
||||
&CellReferenceIndex {
|
||||
sheet: 0,
|
||||
column: 2,
|
||||
row: 1,
|
||||
},
|
||||
target,
|
||||
area
|
||||
)
|
||||
.is_ok()
|
||||
);
|
||||
assert!(
|
||||
model
|
||||
.move_cell_value_to_area(
|
||||
value,
|
||||
&CellReferenceIndex {
|
||||
sheet: 0,
|
||||
column: 1,
|
||||
row: 20,
|
||||
},
|
||||
target,
|
||||
area
|
||||
)
|
||||
.is_ok()
|
||||
);
|
||||
assert!(
|
||||
model
|
||||
.move_cell_value_to_area(
|
||||
value,
|
||||
&CellReferenceIndex {
|
||||
sheet: 0,
|
||||
column: 1,
|
||||
row: 21,
|
||||
},
|
||||
target,
|
||||
area
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
|
||||
@@ -62,17 +62,3 @@ fn test_create_named_style() {
|
||||
let style = model.get_style_for_cell(0, 1, 1).unwrap();
|
||||
assert!(style.font.b);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn empty_models_have_two_fills() {
|
||||
let model = new_empty_model();
|
||||
assert_eq!(model.workbook.styles.fills.len(), 2);
|
||||
assert_eq!(
|
||||
model.workbook.styles.fills[0].pattern_type,
|
||||
"none".to_string()
|
||||
);
|
||||
assert_eq!(
|
||||
model.workbook.styles.fills[1].pattern_type,
|
||||
"gray125".to_string()
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
mod test_add_delete_sheets;
|
||||
mod test_autofill_columns;
|
||||
mod test_autofill_rows;
|
||||
mod test_batch_row_column_diff;
|
||||
mod test_border;
|
||||
mod test_clear_cells;
|
||||
mod test_column_style;
|
||||
@@ -12,8 +11,6 @@ mod test_evaluation;
|
||||
mod test_general;
|
||||
mod test_grid_lines;
|
||||
mod test_keyboard_navigation;
|
||||
mod test_last_empty_cell;
|
||||
mod test_multi_row_column;
|
||||
mod test_on_area_selection;
|
||||
mod test_on_expand_selected_range;
|
||||
mod test_on_paste_styles;
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{constants::DEFAULT_COLUMN_WIDTH, UserModel};
|
||||
use crate::{UserModel, constants::DEFAULT_COLUMN_WIDTH};
|
||||
|
||||
#[test]
|
||||
fn add_undo_redo() {
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::UserModel;
|
||||
use crate::constants::{LAST_COLUMN, LAST_ROW};
|
||||
use crate::expressions::types::Area;
|
||||
use crate::test::util::new_empty_model;
|
||||
use crate::UserModel;
|
||||
|
||||
#[test]
|
||||
fn basic_tests() {
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::UserModel;
|
||||
use crate::constants::{LAST_COLUMN, LAST_ROW};
|
||||
use crate::expressions::types::Area;
|
||||
use crate::test::util::new_empty_model;
|
||||
use crate::UserModel;
|
||||
|
||||
#[test]
|
||||
fn basic_tests() {
|
||||
|
||||
@@ -1,675 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
#![allow(clippy::panic)]
|
||||
|
||||
use bitcode::decode;
|
||||
|
||||
use crate::{
|
||||
constants::{LAST_COLUMN, LAST_ROW},
|
||||
test::util::new_empty_model,
|
||||
user_model::history::{Diff, QueueDiffs},
|
||||
UserModel,
|
||||
};
|
||||
|
||||
fn last_diff_list(model: &mut UserModel) -> Vec<Diff> {
|
||||
let bytes = model.flush_send_queue();
|
||||
let queue: Vec<QueueDiffs> = decode(&bytes).unwrap();
|
||||
// Get the last operation's diff list
|
||||
queue.last().unwrap().list.clone()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn diff_invariant_insert_rows() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
assert!(model.insert_rows(0, 5, 3).is_ok());
|
||||
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
assert!(matches!(
|
||||
&list[0],
|
||||
Diff::InsertRows {
|
||||
sheet: 0,
|
||||
row: 5,
|
||||
count: 3
|
||||
}
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn diff_invariant_insert_columns() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
assert!(model.insert_columns(0, 2, 4).is_ok());
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
assert!(matches!(
|
||||
&list[0],
|
||||
Diff::InsertColumns {
|
||||
sheet: 0,
|
||||
column: 2,
|
||||
count: 4
|
||||
}
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn undo_redo_after_batch_delete() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Place values that will shift.
|
||||
model.set_user_input(0, 20, 1, "A").unwrap();
|
||||
model.set_user_input(0, 1, 20, "B").unwrap();
|
||||
|
||||
// Fill some of the rows we are about to delete for testing
|
||||
for r in 10..15 {
|
||||
model.set_user_input(0, r, 1, "tmp").unwrap();
|
||||
}
|
||||
|
||||
// Delete rows 10..14 and columns 5..8
|
||||
assert!(model.delete_rows(0, 10, 5).is_ok());
|
||||
assert!(model.delete_columns(0, 5, 4).is_ok());
|
||||
|
||||
// Verify shift
|
||||
assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "A");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 16).unwrap(), "B");
|
||||
|
||||
// Undo
|
||||
model.undo().unwrap(); // columns
|
||||
model.undo().unwrap(); // rows
|
||||
assert_eq!(model.get_formatted_cell_value(0, 20, 1).unwrap(), "A");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 20).unwrap(), "B");
|
||||
|
||||
// Redo
|
||||
model.redo().unwrap(); // rows
|
||||
model.redo().unwrap(); // columns
|
||||
assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "A");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 16).unwrap(), "B");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn diff_order_delete_rows() {
|
||||
// Verifies that delete diffs are generated with all data preserved
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Populate rows to delete
|
||||
for r in 5..10 {
|
||||
model.set_user_input(0, r, 1, &r.to_string()).unwrap();
|
||||
}
|
||||
|
||||
assert!(model.delete_rows(0, 5, 5).is_ok());
|
||||
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
|
||||
// Should have one bulk diff with all the row data
|
||||
match &list[0] {
|
||||
Diff::DeleteRows {
|
||||
sheet,
|
||||
row,
|
||||
count,
|
||||
old_data,
|
||||
} => {
|
||||
assert_eq!(*sheet, 0);
|
||||
assert_eq!(*row, 5);
|
||||
assert_eq!(*count, 5);
|
||||
assert_eq!(old_data.len(), 5);
|
||||
// Verify the data was collected for each row
|
||||
for (i, row_data) in old_data.iter().enumerate() {
|
||||
let _expected_value = (5 + i).to_string();
|
||||
assert!(row_data.data.contains_key(&1));
|
||||
}
|
||||
}
|
||||
_ => panic!("Unexpected diff variant"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn batch_operations_with_formulas() {
|
||||
// Verifies formulas update correctly after batch ops
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
model.set_user_input(0, 1, 1, "10").unwrap();
|
||||
model.set_user_input(0, 5, 1, "=A1*2").unwrap(); // Will become A3 after insert
|
||||
|
||||
assert!(model.insert_rows(0, 2, 2).is_ok());
|
||||
|
||||
// Formula should now reference A1 (unchanged) but be in row 7
|
||||
assert_eq!(model.get_formatted_cell_value(0, 7, 1).unwrap(), "20");
|
||||
assert_eq!(model.get_cell_content(0, 7, 1).unwrap(), "=A1*2");
|
||||
|
||||
// Undo and verify formula is back at original position
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "20");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn edge_case_single_operation() {
|
||||
// Single row/column operations should still work correctly
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
assert!(model.insert_rows(0, 1, 1).is_ok());
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
|
||||
assert!(model.insert_columns(0, 1, 1).is_ok());
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delete_empty_rows() {
|
||||
// Delete multiple empty rows and verify behavior
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Set data in rows 1 and 10, leaving rows 5-8 empty
|
||||
model.set_user_input(0, 1, 1, "Before").unwrap();
|
||||
model.set_user_input(0, 10, 1, "After").unwrap();
|
||||
|
||||
// Delete empty rows 5-8
|
||||
assert!(model.delete_rows(0, 5, 4).is_ok());
|
||||
|
||||
// Verify shift
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "Before");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "After");
|
||||
|
||||
// Verify diffs now use bulk operation
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
match &list[0] {
|
||||
Diff::DeleteRows {
|
||||
sheet,
|
||||
row,
|
||||
count,
|
||||
old_data,
|
||||
} => {
|
||||
assert_eq!(*sheet, 0);
|
||||
assert_eq!(*row, 5);
|
||||
assert_eq!(*count, 4);
|
||||
assert_eq!(old_data.len(), 4);
|
||||
// All rows should be empty
|
||||
for row_data in old_data {
|
||||
assert!(row_data.data.is_empty());
|
||||
}
|
||||
}
|
||||
_ => panic!("Unexpected diff variant"),
|
||||
}
|
||||
|
||||
// Undo/redo
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "After");
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "After");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delete_mixed_empty_and_filled_rows() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Alternating filled and empty rows
|
||||
model.set_user_input(0, 5, 1, "Row5").unwrap();
|
||||
model.set_user_input(0, 7, 1, "Row7").unwrap();
|
||||
model.set_user_input(0, 9, 1, "Row9").unwrap();
|
||||
model.set_user_input(0, 10, 1, "After").unwrap();
|
||||
|
||||
assert!(model.delete_rows(0, 5, 5).is_ok());
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "After");
|
||||
|
||||
// Verify mix of empty and filled row diffs
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
match &list[0] {
|
||||
Diff::DeleteRows {
|
||||
sheet,
|
||||
row,
|
||||
count,
|
||||
old_data,
|
||||
} => {
|
||||
assert_eq!(*sheet, 0);
|
||||
assert_eq!(*row, 5);
|
||||
assert_eq!(*count, 5);
|
||||
assert_eq!(old_data.len(), 5);
|
||||
|
||||
// Count filled rows (should be 3: rows 5, 7, 9)
|
||||
let filled_count = old_data
|
||||
.iter()
|
||||
.filter(|row_data| !row_data.data.is_empty())
|
||||
.count();
|
||||
assert_eq!(filled_count, 3);
|
||||
}
|
||||
_ => panic!("Unexpected diff variant"),
|
||||
}
|
||||
|
||||
// Undo
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "Row5");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 7, 1).unwrap(), "Row7");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 9, 1).unwrap(), "Row9");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "After");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_insert_rows_undo_redo() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Set up initial data
|
||||
model.set_user_input(0, 1, 1, "A1").unwrap();
|
||||
model.set_user_input(0, 2, 1, "A2").unwrap();
|
||||
model.set_user_input(0, 5, 1, "A5").unwrap();
|
||||
|
||||
// Insert 3 rows at position 3
|
||||
assert!(model.insert_rows(0, 3, 3).is_ok());
|
||||
|
||||
// Verify data has shifted
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 2, 1).unwrap(), "A2");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 8, 1).unwrap(), "A5"); // A5 moved to A8
|
||||
|
||||
// Check diff structure
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
assert!(matches!(
|
||||
&list[0],
|
||||
Diff::InsertRows {
|
||||
sheet: 0,
|
||||
row: 3,
|
||||
count: 3
|
||||
}
|
||||
));
|
||||
|
||||
// Undo
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "A5"); // Back to original position
|
||||
|
||||
// Redo
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 8, 1).unwrap(), "A5"); // Shifted again
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_insert_columns_undo_redo() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Set up initial data
|
||||
model.set_user_input(0, 1, 1, "A1").unwrap();
|
||||
model.set_user_input(0, 1, 2, "B1").unwrap();
|
||||
model.set_user_input(0, 1, 5, "E1").unwrap();
|
||||
|
||||
// Insert 3 columns at position 3
|
||||
assert!(model.insert_columns(0, 3, 3).is_ok());
|
||||
|
||||
// Verify data has shifted
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 2).unwrap(), "B1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 8).unwrap(), "E1"); // E1 moved to H1
|
||||
|
||||
// Check diff structure
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
assert!(matches!(
|
||||
&list[0],
|
||||
Diff::InsertColumns {
|
||||
sheet: 0,
|
||||
column: 3,
|
||||
count: 3
|
||||
}
|
||||
));
|
||||
|
||||
// Undo
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 5).unwrap(), "E1"); // Back to original position
|
||||
|
||||
// Redo
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 8).unwrap(), "E1"); // Shifted again
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_delete_rows_round_trip() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Set up data with styles
|
||||
model.set_user_input(0, 3, 1, "Row3").unwrap();
|
||||
model.set_user_input(0, 4, 1, "Row4").unwrap();
|
||||
model.set_user_input(0, 5, 1, "Row5").unwrap();
|
||||
model.set_user_input(0, 6, 1, "Row6").unwrap();
|
||||
model.set_user_input(0, 7, 1, "After").unwrap();
|
||||
|
||||
// Set some row heights to verify they're preserved
|
||||
model.set_rows_height(0, 4, 4, 30.0).unwrap();
|
||||
model.set_rows_height(0, 5, 5, 40.0).unwrap();
|
||||
|
||||
// Delete rows 3-6
|
||||
assert!(model.delete_rows(0, 3, 4).is_ok());
|
||||
|
||||
// Verify deletion
|
||||
assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "After");
|
||||
|
||||
// Check diff structure
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
match &list[0] {
|
||||
Diff::DeleteRows {
|
||||
sheet,
|
||||
row,
|
||||
count,
|
||||
old_data,
|
||||
} => {
|
||||
assert_eq!(*sheet, 0);
|
||||
assert_eq!(*row, 3);
|
||||
assert_eq!(*count, 4);
|
||||
assert_eq!(old_data.len(), 4);
|
||||
// Verify data was preserved
|
||||
assert!(old_data[0].data.contains_key(&1)); // Row3
|
||||
assert!(old_data[1].data.contains_key(&1)); // Row4
|
||||
assert!(old_data[2].data.contains_key(&1)); // Row5
|
||||
assert!(old_data[3].data.contains_key(&1)); // Row6
|
||||
}
|
||||
_ => panic!("Expected DeleteRows diff"),
|
||||
}
|
||||
|
||||
// Undo - should restore all data and row heights
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "Row3");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 4, 1).unwrap(), "Row4");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "Row5");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "Row6");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 7, 1).unwrap(), "After");
|
||||
assert_eq!(model.get_row_height(0, 4).unwrap(), 30.0);
|
||||
assert_eq!(model.get_row_height(0, 5).unwrap(), 40.0);
|
||||
|
||||
// Redo - should delete again
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "After");
|
||||
|
||||
// Final undo to verify round-trip
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "Row3");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 4, 1).unwrap(), "Row4");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "Row5");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "Row6");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_delete_columns_round_trip() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Set up data with styles
|
||||
model.set_user_input(0, 1, 3, "C1").unwrap();
|
||||
model.set_user_input(0, 1, 4, "D1").unwrap();
|
||||
model.set_user_input(0, 1, 5, "E1").unwrap();
|
||||
model.set_user_input(0, 1, 6, "F1").unwrap();
|
||||
model.set_user_input(0, 1, 7, "After").unwrap();
|
||||
|
||||
// Set some column widths to verify they're preserved
|
||||
model.set_columns_width(0, 4, 4, 100.0).unwrap();
|
||||
model.set_columns_width(0, 5, 5, 120.0).unwrap();
|
||||
|
||||
// Delete columns 3-6
|
||||
assert!(model.delete_columns(0, 3, 4).is_ok());
|
||||
|
||||
// Verify deletion
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "After");
|
||||
|
||||
// Check diff structure
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
match &list[0] {
|
||||
Diff::DeleteColumns {
|
||||
sheet,
|
||||
column,
|
||||
count,
|
||||
old_data,
|
||||
} => {
|
||||
assert_eq!(*sheet, 0);
|
||||
assert_eq!(*column, 3);
|
||||
assert_eq!(*count, 4);
|
||||
assert_eq!(old_data.len(), 4);
|
||||
// Verify data was preserved
|
||||
assert!(old_data[0].data.contains_key(&1)); // C1
|
||||
assert!(old_data[1].data.contains_key(&1)); // D1
|
||||
assert!(old_data[2].data.contains_key(&1)); // E1
|
||||
assert!(old_data[3].data.contains_key(&1)); // F1
|
||||
}
|
||||
_ => panic!("Expected DeleteColumns diff"),
|
||||
}
|
||||
|
||||
// Undo - should restore all data and column widths
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "C1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 4).unwrap(), "D1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 5).unwrap(), "E1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 6).unwrap(), "F1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 7).unwrap(), "After");
|
||||
assert_eq!(model.get_column_width(0, 4).unwrap(), 100.0);
|
||||
assert_eq!(model.get_column_width(0, 5).unwrap(), 120.0);
|
||||
|
||||
// Redo - should delete again
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "After");
|
||||
|
||||
// Final undo to verify round-trip
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "C1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 4).unwrap(), "D1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 5).unwrap(), "E1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 6).unwrap(), "F1");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn complex_bulk_operations_sequence() {
|
||||
// Test a complex sequence of bulk operations
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Initial setup
|
||||
model.set_user_input(0, 1, 1, "A1").unwrap();
|
||||
model.set_user_input(0, 2, 2, "B2").unwrap();
|
||||
model.set_user_input(0, 3, 3, "C3").unwrap();
|
||||
|
||||
// Operation 1: Insert 2 rows at position 2
|
||||
model.insert_rows(0, 2, 2).unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 4, 2).unwrap(), "B2"); // B2 moved down
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 3).unwrap(), "C3"); // C3 moved down
|
||||
|
||||
// Operation 2: Insert 2 columns at position 2
|
||||
model.insert_columns(0, 2, 2).unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 4, 4).unwrap(), "B2"); // B2 moved right
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 5).unwrap(), "C3"); // C3 moved right
|
||||
|
||||
// Operation 3: Delete the inserted rows
|
||||
model.delete_rows(0, 2, 2).unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 2, 4).unwrap(), "B2");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 3, 5).unwrap(), "C3");
|
||||
|
||||
// Undo all operations
|
||||
model.undo().unwrap(); // Undo delete rows
|
||||
assert_eq!(model.get_formatted_cell_value(0, 4, 4).unwrap(), "B2");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 5).unwrap(), "C3");
|
||||
|
||||
model.undo().unwrap(); // Undo insert columns
|
||||
assert_eq!(model.get_formatted_cell_value(0, 4, 2).unwrap(), "B2");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 3).unwrap(), "C3");
|
||||
|
||||
model.undo().unwrap(); // Undo insert rows
|
||||
assert_eq!(model.get_formatted_cell_value(0, 2, 2).unwrap(), "B2");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 3, 3).unwrap(), "C3");
|
||||
|
||||
// Redo all operations
|
||||
model.redo().unwrap(); // Redo insert rows
|
||||
model.redo().unwrap(); // Redo insert columns
|
||||
model.redo().unwrap(); // Redo delete rows
|
||||
assert_eq!(model.get_formatted_cell_value(0, 2, 4).unwrap(), "B2");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 3, 5).unwrap(), "C3");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_operations_with_formulas_update() {
|
||||
// Test that formulas update correctly with bulk operations
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Set up data and formulas
|
||||
model.set_user_input(0, 1, 1, "10").unwrap();
|
||||
model.set_user_input(0, 5, 1, "20").unwrap();
|
||||
model.set_user_input(0, 10, 1, "=A1+A5").unwrap(); // Formula referencing A1 and A5
|
||||
|
||||
// Insert 3 rows at position 3
|
||||
model.insert_rows(0, 3, 3).unwrap();
|
||||
|
||||
// Formula should update to reference the shifted cells
|
||||
assert_eq!(model.get_formatted_cell_value(0, 13, 1).unwrap(), "30"); // Formula moved down
|
||||
assert_eq!(model.get_cell_content(0, 13, 1).unwrap(), "=A1+A8"); // A5 became A8
|
||||
|
||||
// Undo
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "30");
|
||||
assert_eq!(model.get_cell_content(0, 10, 1).unwrap(), "=A1+A5");
|
||||
|
||||
// Now test column insertion
|
||||
model.set_user_input(0, 1, 5, "20").unwrap(); // Add value in E1
|
||||
model.set_user_input(0, 1, 10, "=A1+E1").unwrap();
|
||||
model.insert_columns(0, 3, 2).unwrap();
|
||||
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 12).unwrap(), "30"); // Formula moved right
|
||||
assert_eq!(model.get_cell_content(0, 1, 12).unwrap(), "=A1+G1"); // E1 became G1
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_delete_with_styles() {
|
||||
// Test that cell and row/column styles are preserved
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Set up data with various styles
|
||||
for r in 5..10 {
|
||||
model.set_user_input(0, r, 1, &format!("Row{r}")).unwrap();
|
||||
model.set_rows_height(0, r, r, (r * 10) as f64).unwrap();
|
||||
}
|
||||
|
||||
// Delete and verify style preservation
|
||||
model.delete_rows(0, 5, 5).unwrap();
|
||||
|
||||
// Undo should restore all styles
|
||||
model.undo().unwrap();
|
||||
for r in 5..10 {
|
||||
assert_eq!(
|
||||
model.get_formatted_cell_value(0, r, 1).unwrap(),
|
||||
format!("Row{r}")
|
||||
);
|
||||
assert_eq!(model.get_row_height(0, r).unwrap(), (r * 10) as f64);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_operations_large_count() {
|
||||
// Test operations with large counts
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Insert a large number of rows
|
||||
model.set_user_input(0, 1, 1, "Before").unwrap();
|
||||
model.set_user_input(0, 100, 1, "After").unwrap();
|
||||
|
||||
assert!(model.insert_rows(0, 50, 100).is_ok());
|
||||
|
||||
// Verify shift
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "Before");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 200, 1).unwrap(), "After"); // Moved by 100
|
||||
|
||||
// Check diff
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
assert!(matches!(
|
||||
&list[0],
|
||||
Diff::InsertRows {
|
||||
sheet: 0,
|
||||
row: 50,
|
||||
count: 100
|
||||
}
|
||||
));
|
||||
|
||||
// Undo and redo
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 100, 1).unwrap(), "After");
|
||||
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 200, 1).unwrap(), "After");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_operations_error_cases() {
|
||||
// Test error conditions
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Negative count should fail
|
||||
assert!(model.insert_rows(0, 1, -5).is_err());
|
||||
assert!(model.insert_columns(0, 1, -5).is_err());
|
||||
assert!(model.delete_rows(0, 1, -5).is_err());
|
||||
assert!(model.delete_columns(0, 1, -5).is_err());
|
||||
|
||||
// Zero count should fail
|
||||
assert!(model.insert_rows(0, 1, 0).is_err());
|
||||
assert!(model.insert_columns(0, 1, 0).is_err());
|
||||
assert!(model.delete_rows(0, 1, 0).is_err());
|
||||
assert!(model.delete_columns(0, 1, 0).is_err());
|
||||
|
||||
// Out of bounds operations should fail
|
||||
assert!(model.delete_rows(0, LAST_ROW - 5, 10).is_err());
|
||||
assert!(model.delete_columns(0, LAST_COLUMN - 5, 10).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_diff_serialization() {
|
||||
// Test that bulk diffs can be serialized/deserialized correctly
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Create some data
|
||||
model.set_user_input(0, 1, 1, "Test").unwrap();
|
||||
model.insert_rows(0, 2, 3).unwrap();
|
||||
|
||||
// Flush and get the serialized diffs
|
||||
let bytes = model.flush_send_queue();
|
||||
|
||||
// Create a new model and apply the diffs
|
||||
let base2 = new_empty_model();
|
||||
let mut model2 = UserModel::from_model(base2);
|
||||
|
||||
assert!(model2.apply_external_diffs(&bytes).is_ok());
|
||||
|
||||
// Verify the state matches
|
||||
assert_eq!(model2.get_formatted_cell_value(0, 1, 1).unwrap(), "Test");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boundary_validation() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Test deleting rows beyond valid range
|
||||
assert!(model.delete_rows(0, LAST_ROW, 2).is_err());
|
||||
assert!(model.delete_rows(0, LAST_ROW + 1, 1).is_err());
|
||||
|
||||
// Test deleting columns beyond valid range
|
||||
assert!(model.delete_columns(0, LAST_COLUMN, 2).is_err());
|
||||
assert!(model.delete_columns(0, LAST_COLUMN + 1, 1).is_err());
|
||||
|
||||
// Test valid boundary deletions (should work with our empty row fix)
|
||||
assert!(model.delete_rows(0, LAST_ROW, 1).is_ok());
|
||||
assert!(model.delete_columns(0, LAST_COLUMN, 1).is_ok());
|
||||
}
|
||||
@@ -1,10 +1,10 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{
|
||||
BorderArea, UserModel,
|
||||
constants::{LAST_COLUMN, LAST_ROW},
|
||||
expressions::{types::Area, utils::number_to_column},
|
||||
types::{Border, BorderItem, BorderStyle},
|
||||
BorderArea, UserModel,
|
||||
};
|
||||
|
||||
// checks there are no borders in the sheet
|
||||
@@ -50,7 +50,10 @@ fn check_borders(model: &UserModel) {
|
||||
assert_eq!(
|
||||
Some(top_border),
|
||||
top_cell_style.border.bottom,
|
||||
"(Top). Sheet: {sheet}, row: {row}, column: {column}"
|
||||
"(Top). Sheet: {}, row: {}, column: {}",
|
||||
sheet,
|
||||
row,
|
||||
column
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -62,7 +65,10 @@ fn check_borders(model: &UserModel) {
|
||||
assert_eq!(
|
||||
Some(right_border),
|
||||
right_cell_style.border.left,
|
||||
"(Right). Sheet: {sheet}, row: {row}, column: {column}"
|
||||
"(Right). Sheet: {}, row: {}, column: {}",
|
||||
sheet,
|
||||
row,
|
||||
column
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -74,7 +80,10 @@ fn check_borders(model: &UserModel) {
|
||||
assert_eq!(
|
||||
Some(bottom_border),
|
||||
bottom_cell_style.border.top,
|
||||
"(Bottom). Sheet: {sheet}, row: {row}, column: {column}"
|
||||
"(Bottom). Sheet: {}, row: {}, column: {}",
|
||||
sheet,
|
||||
row,
|
||||
column
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -85,7 +94,10 @@ fn check_borders(model: &UserModel) {
|
||||
assert_eq!(
|
||||
Some(left_border),
|
||||
left_cell_style.border.right,
|
||||
"(Left). Sheet: {sheet}, row: {row}, column: {column}"
|
||||
"(Left). Sheet: {}, row: {}, column: {}",
|
||||
sheet,
|
||||
row,
|
||||
column
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{expressions::types::Area, UserModel};
|
||||
use crate::{UserModel, expressions::types::Area};
|
||||
|
||||
#[test]
|
||||
fn basic() {
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::UserModel;
|
||||
use crate::constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT, LAST_COLUMN, LAST_ROW};
|
||||
use crate::expressions::types::Area;
|
||||
use crate::UserModel;
|
||||
|
||||
#[test]
|
||||
fn column_width() {
|
||||
|
||||
@@ -423,30 +423,3 @@ fn change_scope_to_first_sheet() {
|
||||
Ok("#NAME?".to_string())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rename_sheet() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
model.new_sheet().unwrap();
|
||||
model.set_user_input(0, 1, 1, "Hello").unwrap();
|
||||
|
||||
model
|
||||
.new_defined_name("myName", None, "Sheet1!$A$1")
|
||||
.unwrap();
|
||||
|
||||
model
|
||||
.set_user_input(0, 2, 1, r#"=CONCATENATE(MyName, " world!")"#)
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(
|
||||
model.get_formatted_cell_value(0, 2, 1),
|
||||
Ok("Hello world!".to_string())
|
||||
);
|
||||
|
||||
model.rename_sheet(0, "AnotherName").unwrap();
|
||||
|
||||
assert_eq!(
|
||||
model.get_formatted_cell_value(0, 2, 1),
|
||||
Ok("Hello world!".to_string())
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{
|
||||
UserModel,
|
||||
constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT, LAST_COLUMN, LAST_ROW},
|
||||
expressions::types::Area,
|
||||
UserModel,
|
||||
};
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{
|
||||
UserModel,
|
||||
constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT},
|
||||
test::util::new_empty_model,
|
||||
UserModel,
|
||||
};
|
||||
|
||||
#[test]
|
||||
@@ -65,8 +65,8 @@ fn queue_undo_redo_multiple() {
|
||||
model1.set_user_input(0, row, 17, "=ROW()").unwrap();
|
||||
}
|
||||
|
||||
model1.insert_rows(0, 3, 1).unwrap();
|
||||
model1.insert_rows(0, 3, 1).unwrap();
|
||||
model1.insert_row(0, 3).unwrap();
|
||||
model1.insert_row(0, 3).unwrap();
|
||||
|
||||
// undo al of them
|
||||
while model1.can_undo() {
|
||||
@@ -157,7 +157,9 @@ fn new_sheet() {
|
||||
#[test]
|
||||
fn wrong_diffs_handled() {
|
||||
let mut model = UserModel::from_model(new_empty_model());
|
||||
assert!(model
|
||||
.apply_external_diffs("Hello world".as_bytes())
|
||||
.is_err());
|
||||
assert!(
|
||||
model
|
||||
.apply_external_diffs("Hello world".as_bytes())
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::UserModel;
|
||||
use crate::constants::{LAST_COLUMN, LAST_ROW};
|
||||
use crate::test::util::new_empty_model;
|
||||
use crate::types::CellType;
|
||||
use crate::UserModel;
|
||||
|
||||
#[test]
|
||||
fn set_user_input_errors() {
|
||||
@@ -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");
|
||||
}
|
||||
|
||||
@@ -62,7 +62,7 @@ fn insert_remove_rows() {
|
||||
assert!(model.set_rows_height(0, 5, 5, 3.0 * height).is_ok());
|
||||
|
||||
// remove the row
|
||||
assert!(model.delete_rows(0, 5, 1).is_ok());
|
||||
assert!(model.delete_row(0, 5).is_ok());
|
||||
// Row 5 has now the normal height
|
||||
assert_eq!(model.get_row_height(0, 5), Ok(height));
|
||||
// There is no value in A5
|
||||
@@ -99,7 +99,7 @@ fn insert_remove_columns() {
|
||||
assert_eq!(model.get_column_width(0, 5).unwrap(), 3.0 * column_width);
|
||||
|
||||
// remove the column
|
||||
assert!(model.delete_columns(0, 5, 1).is_ok());
|
||||
assert!(model.delete_column(0, 5).is_ok());
|
||||
// Column 5 has now the normal width
|
||||
assert_eq!(model.get_column_width(0, 5), Ok(column_width));
|
||||
// There is no value in E5
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
use crate::UserModel;
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn basic_tests() {
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{
|
||||
UserModel,
|
||||
constants::{
|
||||
DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT, DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH,
|
||||
LAST_COLUMN,
|
||||
},
|
||||
test::util::new_empty_model,
|
||||
UserModel,
|
||||
};
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -1,55 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::constants::LAST_ROW;
|
||||
use crate::expressions::types::Area;
|
||||
use crate::test::util::new_empty_model;
|
||||
use crate::UserModel;
|
||||
|
||||
#[test]
|
||||
fn basic_tests() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
// This is the first row, column 5
|
||||
model.set_user_input(0, 3, 5, "todo").unwrap();
|
||||
|
||||
// Row 3 before column 5 should be empty
|
||||
assert_eq!(
|
||||
model
|
||||
.get_last_non_empty_in_row_before_column(0, 3, 4)
|
||||
.unwrap(),
|
||||
None
|
||||
);
|
||||
// Row 3 before column 5 should be 5
|
||||
assert_eq!(
|
||||
model
|
||||
.get_last_non_empty_in_row_before_column(0, 3, 7)
|
||||
.unwrap(),
|
||||
Some(5)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_last_empty_cell() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
|
||||
let column_g_range = Area {
|
||||
sheet: 0,
|
||||
row: 1,
|
||||
column: 7,
|
||||
width: 1,
|
||||
height: LAST_ROW,
|
||||
};
|
||||
|
||||
model
|
||||
.update_range_style(&column_g_range, "fill.bg_color", "#333444")
|
||||
.unwrap();
|
||||
|
||||
// Column 7 has a style but it is empty
|
||||
assert_eq!(
|
||||
model
|
||||
.get_last_non_empty_in_row_before_column(0, 3, 14)
|
||||
.unwrap(),
|
||||
None
|
||||
);
|
||||
}
|
||||
@@ -1,173 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{
|
||||
constants::{LAST_COLUMN, LAST_ROW},
|
||||
test::util::new_empty_model,
|
||||
UserModel,
|
||||
};
|
||||
|
||||
#[test]
|
||||
fn insert_multiple_rows_shifts_cells() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
// Place a value below the insertion point.
|
||||
model.set_user_input(0, 10, 1, "42").unwrap();
|
||||
|
||||
// Insert 3 rows starting at row 5.
|
||||
assert!(model.insert_rows(0, 5, 3).is_ok());
|
||||
|
||||
// The original value should have moved down by 3 rows.
|
||||
assert_eq!(model.get_formatted_cell_value(0, 13, 1).unwrap(), "42");
|
||||
|
||||
// Undo / redo cycle should restore the same behaviour.
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "42");
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 13, 1).unwrap(), "42");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn insert_rows_errors() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
|
||||
// Negative or zero counts are rejected.
|
||||
assert_eq!(
|
||||
model.insert_rows(0, 1, -2),
|
||||
Err("Cannot add a negative number of cells :)".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
model.insert_rows(0, 1, 0),
|
||||
Err("Cannot add a negative number of cells :)".to_string())
|
||||
);
|
||||
|
||||
// Inserting too many rows so that the sheet would overflow.
|
||||
let too_many = LAST_ROW; // This guarantees max_row + too_many > LAST_ROW.
|
||||
assert_eq!(
|
||||
model.insert_rows(0, 1, too_many),
|
||||
Err(
|
||||
"Cannot shift cells because that would delete cells at the end of a column".to_string()
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn insert_multiple_columns_shifts_cells() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
// Place a value to the right of the insertion point.
|
||||
model.set_user_input(0, 1, 10, "99").unwrap();
|
||||
|
||||
// Insert 3 columns starting at column 5.
|
||||
assert!(model.insert_columns(0, 5, 3).is_ok());
|
||||
|
||||
// The original value should have moved right by 3 columns.
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 13).unwrap(), "99");
|
||||
|
||||
// Undo / redo cycle.
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 10).unwrap(), "99");
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 13).unwrap(), "99");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn insert_columns_errors() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
|
||||
// Negative or zero counts are rejected.
|
||||
assert_eq!(
|
||||
model.insert_columns(0, 1, -2),
|
||||
Err("Cannot add a negative number of cells :)".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
model.insert_columns(0, 1, 0),
|
||||
Err("Cannot add a negative number of cells :)".to_string())
|
||||
);
|
||||
|
||||
// Overflow to the right.
|
||||
let too_many = LAST_COLUMN; // Ensures max_column + too_many > LAST_COLUMN
|
||||
assert_eq!(
|
||||
model.insert_columns(0, 1, too_many),
|
||||
Err("Cannot shift cells because that would delete cells at the end of a row".to_string())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delete_multiple_rows_shifts_cells_upwards() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
|
||||
// Populate rows 10..14 (to be deleted) so that the diff builder does not fail.
|
||||
for r in 10..15 {
|
||||
model.set_user_input(0, r, 1, "del").unwrap();
|
||||
}
|
||||
// Place a value below the deletion range.
|
||||
model.set_user_input(0, 20, 1, "keep").unwrap();
|
||||
|
||||
// Delete 5 rows starting at row 10.
|
||||
assert!(model.delete_rows(0, 10, 5).is_ok());
|
||||
|
||||
// The value originally at row 20 should now be at row 15.
|
||||
assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "keep");
|
||||
|
||||
// Undo / redo cycle.
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 20, 1).unwrap(), "keep");
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "keep");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delete_rows_errors() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
|
||||
// Negative or zero counts are rejected.
|
||||
assert_eq!(
|
||||
model.delete_rows(0, 1, -3),
|
||||
Err("Please use insert rows instead".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
model.delete_rows(0, 1, 0),
|
||||
Err("Please use insert rows instead".to_string())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delete_multiple_columns_shifts_cells_left() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
|
||||
// Place a value to the right of the deletion range.
|
||||
model.set_user_input(0, 1, 15, "88").unwrap();
|
||||
|
||||
// Delete 4 columns starting at column 5.
|
||||
assert!(model.delete_columns(0, 5, 4).is_ok());
|
||||
|
||||
// The value originally at column 15 should now be at column 11.
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 11).unwrap(), "88");
|
||||
|
||||
// Undo / redo cycle.
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 15).unwrap(), "88");
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 11).unwrap(), "88");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delete_columns_errors() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
|
||||
// Negative or zero counts are rejected.
|
||||
assert_eq!(
|
||||
model.delete_columns(0, 1, -4),
|
||||
Err("Please use insert columns instead".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
model.delete_columns(0, 1, 0),
|
||||
Err("Please use insert columns instead".to_string())
|
||||
);
|
||||
}
|
||||
@@ -1,9 +1,9 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{
|
||||
UserModel,
|
||||
constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_WINDOW_WIDTH},
|
||||
test::util::new_empty_model,
|
||||
UserModel,
|
||||
};
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{
|
||||
UserModel,
|
||||
constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_WINDOW_WIDTH, LAST_COLUMN},
|
||||
test::util::new_empty_model,
|
||||
UserModel,
|
||||
};
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::UserModel;
|
||||
use crate::test::util::new_empty_model;
|
||||
use crate::types::Fill;
|
||||
use crate::UserModel;
|
||||
|
||||
#[test]
|
||||
fn simple_pasting() {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{expressions::types::Area, UserModel};
|
||||
use crate::{UserModel, expressions::types::Area};
|
||||
|
||||
#[test]
|
||||
fn csv_paste() {
|
||||
@@ -24,7 +24,6 @@ fn csv_paste() {
|
||||
model.get_formatted_cell_value(0, 7, 7),
|
||||
Ok("21".to_string())
|
||||
);
|
||||
assert_eq!([4, 2, 5, 4], model.get_selected_view().range);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -46,7 +45,6 @@ fn csv_paste_formula() {
|
||||
model.get_formatted_cell_value(0, 1, 1),
|
||||
Ok("2022".to_string())
|
||||
);
|
||||
assert_eq!([1, 1, 1, 1], model.get_selected_view().range);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -71,7 +69,6 @@ fn tsv_crlf_paste() {
|
||||
model.get_formatted_cell_value(0, 7, 7),
|
||||
Ok("21".to_string())
|
||||
);
|
||||
assert_eq!([4, 2, 5, 4], model.get_selected_view().range);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -167,7 +164,7 @@ fn copy_paste_internal() {
|
||||
let copy = model.copy_to_clipboard().unwrap();
|
||||
assert_eq!(
|
||||
copy.csv,
|
||||
"42\t127\n\"A season of faith\t \"\"perfection\"\"\""
|
||||
"42\t127\n\"A season of faith\t \"\"perfection\"\"\"\t\n"
|
||||
);
|
||||
assert_eq!(copy.range, (1, 1, 2, 2));
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{
|
||||
constants::LAST_ROW, expressions::types::Area, test::util::new_empty_model, UserModel,
|
||||
UserModel, constants::LAST_ROW, expressions::types::Area, test::util::new_empty_model,
|
||||
};
|
||||
|
||||
#[test]
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user