Compare commits
55 Commits
v0.2.0
...
varum-chan
| Author | SHA1 | Date | |
|---|---|---|---|
|
e7858f7aa9 | ||
|
|
3270d587ac | ||
|
|
e065477b5a | ||
|
|
1f5f575e7a | ||
|
|
472740f296 | ||
|
|
430b420435 | ||
|
|
48fd51fc8a | ||
|
|
614d71b61c | ||
|
|
38e21b9639 | ||
|
|
d6a462dbe3 | ||
|
|
c1df2cec0b | ||
|
|
283a44e109 | ||
|
|
f7dac8b015 | ||
|
|
df0aa51d14 | ||
|
|
411c5de59b | ||
|
|
0df132d5c2 | ||
|
|
8cdb3b8c60 | ||
|
|
d08fe32f97 | ||
|
|
47acd0d600 | ||
|
|
d70ab85396 | ||
|
|
65b959cb1c | ||
|
|
726fc1399d | ||
|
|
8ed0ab25f6 | ||
|
|
949eafc97f | ||
|
|
1f1fd24334 | ||
|
|
2b0c24de55 | ||
|
|
1aa9b6a220 | ||
|
|
94ebf33656 | ||
|
|
b3d4c479f6 | ||
|
|
67aaa85a9a | ||
|
|
5d2953b894 | ||
|
|
b84aeb8bb9 | ||
|
|
c5576af81b | ||
|
|
cb38eff899 | ||
|
|
16212b1518 | ||
|
|
8243e231ab | ||
|
|
48afb45eb9 | ||
|
|
97846041e5 | ||
|
|
c1be1e47cb | ||
|
|
7efdbede3c | ||
|
|
be6819fec3 | ||
|
|
e130f784fd | ||
|
|
c2a2983937 | ||
|
|
3c49f9a606 | ||
|
|
63817e2d50 | ||
|
|
028ae1ce98 | ||
|
|
a4a40c6fd0 | ||
|
|
0ed2984358 | ||
|
|
0b1199056f | ||
|
|
726bf677ed | ||
|
|
d681f63b25 | ||
|
|
ba5869420b | ||
|
|
420ea9829c | ||
|
|
49ae2d8915 | ||
|
|
bdd2c8fe04 |
18
.github/workflows/publish-wiki.yml
vendored
18
.github/workflows/publish-wiki.yml
vendored
@@ -1,18 +0,0 @@
|
||||
name: Publish wiki
|
||||
on:
|
||||
push:
|
||||
branches: [main]
|
||||
paths:
|
||||
- wiki/**
|
||||
- .github/workflows/publish-wiki.yml
|
||||
concurrency:
|
||||
group: publish-wiki
|
||||
cancel-in-progress: true
|
||||
permissions:
|
||||
contents: write
|
||||
jobs:
|
||||
publish-wiki:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: Andrew-Chen-Wang/github-wiki-action@v4
|
||||
6
.github/workflows/test-coverage.yaml
vendored
6
.github/workflows/test-coverage.yaml
vendored
@@ -1,6 +1,10 @@
|
||||
name: Coverage
|
||||
|
||||
on: [pull_request]
|
||||
on:
|
||||
pull_request:
|
||||
push:
|
||||
branches:
|
||||
- main
|
||||
|
||||
jobs:
|
||||
coverage:
|
||||
|
||||
13
CHANGELOG.md
13
CHANGELOG.md
@@ -1,6 +1,17 @@
|
||||
# CHANGELOG
|
||||
|
||||
## [Unreleased]
|
||||
## Unreleased
|
||||
|
||||
### Added
|
||||
|
||||
- New function UNICODE ([#128](https://github.com/ironcalc/IronCalc/pull/128))
|
||||
- New document server (Thanks Dani!)
|
||||
- New function FORMULATEXT
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fixed several issues with pasting content
|
||||
- Fixed several issues with borders
|
||||
|
||||
## [0.2.0] - 2024-11-06 (The HN release)
|
||||
|
||||
|
||||
73
CONTRIBUTING.md
Normal file
73
CONTRIBUTING.md
Normal file
@@ -0,0 +1,73 @@
|
||||
# Contributing to IronCalc
|
||||
|
||||
Whether you are a seasoned developer or a rookie, welcome to IronCalc!
|
||||
|
||||
🎉 We appreciate your interest in contributing to our project.
|
||||
|
||||
Before starting any work it is best if you get in touch to make sure your work is relevant.
|
||||
|
||||
Please be patient, I am only one and this is a side project.
|
||||
|
||||
---
|
||||
|
||||
## 🛠 Changes to the main repo
|
||||
|
||||
If are comfortable working with GitHub and Git, the following steps should be straightforward. For more general information visit [GitHub Docs](https://docs.github.com/en) and [Git Documentation](https://git-scm.com/doc).
|
||||
|
||||
1. **Fork the repository**
|
||||
Start by forking the repository to your own GitHub account. You can do this by clicking the "Fork" button on the top right of the repository page.
|
||||
|
||||
2. **Clone the original repository**
|
||||
Clone the original repository to your local machine:
|
||||
```bash
|
||||
git clone https://github.com/ironcalc/IronCalc.git
|
||||
cd IronCalc
|
||||
```
|
||||
|
||||
|
||||
3. **Add your fork as a remote**
|
||||
Add your forked repository as a remote named fork:
|
||||
|
||||
```bash
|
||||
git remote add fork https://github.com/<your-username>/IronCalc.git
|
||||
```
|
||||
4. **Create a new branch**
|
||||
Always create a new branch for your changes to keep your work isolated:
|
||||
|
||||
```bash
|
||||
git checkout -b your-feature-name
|
||||
```
|
||||
5. **Make changes**
|
||||
Implement your changes, improvements, or bug fixes. Make sure to follow any coding style or project-specific guidelines.
|
||||
|
||||
6. **Commit your changes**
|
||||
Write clear and concise commit messages:
|
||||
|
||||
```bash
|
||||
git add .
|
||||
git commit -m "Brief description of your changes"
|
||||
```
|
||||
7. **Push to your fork**
|
||||
Push your branch to your forked repository:
|
||||
```bash
|
||||
git push fork your-feature-name
|
||||
````
|
||||
|
||||
8. **Create a Pull Request (PR)**
|
||||
Follow the steps on the terminal or go to the orig IronCalc repository, and click on "New Pull Request."
|
||||
Ensure your PR has a clear title and description explaining the purpose of your changes.
|
||||
|
||||
Always start from the main branch in a clean state. `git pull` will generally get the lastest changes form the original repo.
|
||||
|
||||
You should make sure that your changes are properly tested.
|
||||
|
||||
# 🤝 Community and Support
|
||||
|
||||
Feel free to reach out if you have questions or need help. Via GitHub, email, our discord server or bluesky.
|
||||
|
||||
* Open an issue to report a bug or discuss a feature before implementing it.
|
||||
* Engage with the community to share ideas or seek guidance.
|
||||
|
||||
Note that not all contributors need to be coding. To contribute testing, bug reports, typos, ideas of all kinds, you can just send us an email.
|
||||
|
||||
Thank you for your contributions! 💪 Together, we can make IronCalc even better.
|
||||
133
Cargo.lock
generated
133
Cargo.lock
generated
@@ -1,6 +1,6 @@
|
||||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
version = 3
|
||||
version = 4
|
||||
|
||||
[[package]]
|
||||
name = "adler"
|
||||
@@ -19,15 +19,6 @@ dependencies = [
|
||||
"cpufeatures",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "aho-corasick"
|
||||
version = "0.6.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "81ce3d38065e618af2d7b77e10c5ad9a069859b4be3c2250f674af3840d9c8a5"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "aho-corasick"
|
||||
version = "1.1.3"
|
||||
@@ -52,6 +43,12 @@ dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "arrayvec"
|
||||
version = "0.7.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
|
||||
|
||||
[[package]]
|
||||
name = "autocfg"
|
||||
version = "1.2.0"
|
||||
@@ -66,31 +63,28 @@ checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
|
||||
|
||||
[[package]]
|
||||
name = "bitcode"
|
||||
version = "0.6.0"
|
||||
version = "0.6.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "48bc1c27654127a24c476d40198746860ef56475f41a601bfa5c4d0f832968f0"
|
||||
checksum = "ee1bce7608560cd4bf0296a4262d0dbf13e6bcec5ff2105724c8ab88cc7fc784"
|
||||
dependencies = [
|
||||
"arrayvec",
|
||||
"bitcode_derive",
|
||||
"bytemuck",
|
||||
"glam",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bitcode_derive"
|
||||
version = "0.6.0"
|
||||
version = "0.6.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2966755a19aad59ee2aae91e2d48842c667a99d818ec72168efdab07200701cc"
|
||||
checksum = "a539389a13af092cd345a2b47ae7dec12deb306d660b2223d25cd3419b253ebe"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bitflags"
|
||||
version = "1.3.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
|
||||
|
||||
[[package]]
|
||||
name = "block-buffer"
|
||||
version = "0.10.4"
|
||||
@@ -157,9 +151,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
|
||||
|
||||
[[package]]
|
||||
name = "chrono"
|
||||
version = "0.4.37"
|
||||
version = "0.4.38"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e"
|
||||
checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
|
||||
dependencies = [
|
||||
"android-tzdata",
|
||||
"iana-time-zone",
|
||||
@@ -171,9 +165,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "chrono-tz"
|
||||
version = "0.9.0"
|
||||
version = "0.10.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "93698b29de5e97ad0ae26447b344c482a7284c737d9ddc5f9e52b74a336671bb"
|
||||
checksum = "cd6dd8046d00723a59a2f8c5f295c515b9bb9a331ee4f8f3d4dd49e428acd3b6"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"chrono-tz-build",
|
||||
@@ -182,12 +176,11 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "chrono-tz-build"
|
||||
version = "0.3.0"
|
||||
version = "0.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0c088aee841df9c3041febbb73934cfc39708749bf96dc827e3359cd39ef11b1"
|
||||
checksum = "e94fea34d77a245229e7746bd2beb786cd2a896f306ff491fb8cecb3074b10a7"
|
||||
dependencies = [
|
||||
"parse-zoneinfo",
|
||||
"phf",
|
||||
"phf_codegen",
|
||||
]
|
||||
|
||||
@@ -278,19 +271,6 @@ dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "csv-sniffer"
|
||||
version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7b8e952164bb270a505d6cb6136624174c34cfb9abd16e0011f5e53058317f39"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"csv",
|
||||
"csv-core",
|
||||
"memchr",
|
||||
"regex 0.2.11",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "deranged"
|
||||
version = "0.3.11"
|
||||
@@ -348,6 +328,12 @@ dependencies = [
|
||||
"wasi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "glam"
|
||||
version = "0.29.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "dc46dd3ec48fdd8e693a98d2b8bafae273a2d54c1de02a2a7e3d57d501f39677"
|
||||
|
||||
[[package]]
|
||||
name = "heck"
|
||||
version = "0.5.0"
|
||||
@@ -425,11 +411,11 @@ dependencies = [
|
||||
"chrono",
|
||||
"chrono-tz",
|
||||
"csv",
|
||||
"csv-sniffer",
|
||||
"js-sys",
|
||||
"once_cell",
|
||||
"rand",
|
||||
"regex 1.10.4",
|
||||
"regex",
|
||||
"regex-lite",
|
||||
"ryu",
|
||||
"serde",
|
||||
"serde_json",
|
||||
@@ -468,12 +454,6 @@ dependencies = [
|
||||
"wasm-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "lazy_static"
|
||||
version = "1.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
|
||||
|
||||
[[package]]
|
||||
name = "libc"
|
||||
version = "0.2.153"
|
||||
@@ -533,11 +513,11 @@ checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
|
||||
|
||||
[[package]]
|
||||
name = "parse-zoneinfo"
|
||||
version = "0.3.0"
|
||||
version = "0.3.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c705f256449c60da65e11ff6626e0c16a0a0b96aaa348de61376b249bc340f41"
|
||||
checksum = "1f2a05b18d44e2957b88f96ba460715e295bc1d7510468a2f3d3b44535d26c24"
|
||||
dependencies = [
|
||||
"regex 1.10.4",
|
||||
"regex",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -746,29 +726,16 @@ dependencies = [
|
||||
"getrandom",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex"
|
||||
version = "0.2.11"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9329abc99e39129fcceabd24cf5d85b4671ef7c29c50e972bc5afe32438ec384"
|
||||
dependencies = [
|
||||
"aho-corasick 0.6.10",
|
||||
"memchr",
|
||||
"regex-syntax 0.5.6",
|
||||
"thread_local",
|
||||
"utf8-ranges",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex"
|
||||
version = "1.10.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
|
||||
dependencies = [
|
||||
"aho-corasick 1.1.3",
|
||||
"aho-corasick",
|
||||
"memchr",
|
||||
"regex-automata",
|
||||
"regex-syntax 0.8.3",
|
||||
"regex-syntax",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -777,19 +744,16 @@ version = "0.4.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
|
||||
dependencies = [
|
||||
"aho-corasick 1.1.3",
|
||||
"aho-corasick",
|
||||
"memchr",
|
||||
"regex-syntax 0.8.3",
|
||||
"regex-syntax",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex-syntax"
|
||||
version = "0.5.6"
|
||||
name = "regex-lite"
|
||||
version = "0.1.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7d707a4fa2637f2dca2ef9fd02225ec7661fe01a53623c1e6515b6916511f7a7"
|
||||
dependencies = [
|
||||
"ucd-util",
|
||||
]
|
||||
checksum = "53a49587ad06b26609c52e423de037e7f57f20d53535d66e08c695f347df952a"
|
||||
|
||||
[[package]]
|
||||
name = "regex-syntax"
|
||||
@@ -928,15 +892,6 @@ dependencies = [
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "thread_local"
|
||||
version = "0.3.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b"
|
||||
dependencies = [
|
||||
"lazy_static",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "time"
|
||||
version = "0.3.34"
|
||||
@@ -962,12 +917,6 @@ version = "1.17.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
|
||||
|
||||
[[package]]
|
||||
name = "ucd-util"
|
||||
version = "0.1.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "abd2fc5d32b590614af8b0a20d837f32eca055edd0bbead59a9cfe80858be003"
|
||||
|
||||
[[package]]
|
||||
name = "unicode-ident"
|
||||
version = "1.0.12"
|
||||
@@ -980,12 +929,6 @@ version = "0.2.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"
|
||||
|
||||
[[package]]
|
||||
name = "utf8-ranges"
|
||||
version = "1.0.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7fcfc827f90e53a02eaef5e535ee14266c1d569214c6aa70133a624d8a3164ba"
|
||||
|
||||
[[package]]
|
||||
name = "uuid"
|
||||
version = "1.8.0"
|
||||
|
||||
11
Makefile
11
Makefile
@@ -1,7 +1,7 @@
|
||||
.PHONY: lint
|
||||
lint:
|
||||
cargo fmt -- --check
|
||||
cargo clippy --all-targets --all-features
|
||||
cargo clippy --all-targets --all-features -- -W clippy::unwrap_used -W clippy::expect_used -W clippy::panic -D warnings
|
||||
cd webapp && npm install && npm run check
|
||||
|
||||
.PHONY: format
|
||||
@@ -10,9 +10,6 @@ format:
|
||||
|
||||
.PHONY: tests
|
||||
tests: lint
|
||||
cargo test
|
||||
./target/debug/documentation
|
||||
cmp functions.md wiki/functions.md || exit 1
|
||||
make remove-artifacts
|
||||
# Regretabbly we need to build the wasm twice, once for the nodejs tests
|
||||
# and a second one for the vitest.
|
||||
@@ -25,7 +22,6 @@ remove-artifacts:
|
||||
rm -f xlsx/hello-calc.xlsx
|
||||
rm -f xlsx/hello-styles.xlsx
|
||||
rm -f xlsx/widths-and-heights.xlsx
|
||||
rm -f functions.md
|
||||
|
||||
.PHONY: clean
|
||||
clean: remove-artifacts
|
||||
@@ -43,11 +39,6 @@ coverage:
|
||||
CARGO_INCREMENTAL=0 RUSTFLAGS='-C instrument-coverage' LLVM_PROFILE_FILE='cargo-test-%p-%m.profraw' cargo test
|
||||
grcov . --binary-path ./target/debug/deps/ -s . -t html --branch --ignore-not-existing --ignore '../*' --ignore "/*" -o target/coverage/html
|
||||
|
||||
.PHONY: update-docs
|
||||
update-docs:
|
||||
cargo build
|
||||
./target/debug/documentation -o wiki/functions.md
|
||||
|
||||
.PHONY: docs
|
||||
docs:
|
||||
cargo doc --no-deps
|
||||
|
||||
@@ -14,12 +14,17 @@ readme = "README.md"
|
||||
serde = { version = "1.0", features = ["derive"] }
|
||||
ryu = "1.0"
|
||||
chrono = "0.4"
|
||||
chrono-tz = "0.9"
|
||||
regex = "1.0"
|
||||
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.0"
|
||||
bitcode = "0.6.3"
|
||||
csv = "1.3.0"
|
||||
csv-sniffer = "0.1"
|
||||
|
||||
[features]
|
||||
default = ["use_regex_full"]
|
||||
use_regex_full = ["regex"]
|
||||
use_regex_lite = ["regex-lite"]
|
||||
|
||||
[dev-dependencies]
|
||||
serde_json = "1.0"
|
||||
|
||||
@@ -176,3 +176,18 @@ impl Cell {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Implementing methods for MergedCells struct
|
||||
|
||||
impl MergedCells {
|
||||
pub fn is_cell_part_of_merged_cells(&self, row: i32, col: i32) -> bool {
|
||||
// This is merge Mother cell so do not include this cell as part of Merged Cells
|
||||
if row == self.0 && col == self.1 {
|
||||
return false;
|
||||
}
|
||||
|
||||
let result: bool = (row >= self.0 && row <= self.2) && (col >= self.1 && col <= self.3);
|
||||
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
@@ -26,6 +26,7 @@ pub struct SetCellValue {
|
||||
}
|
||||
|
||||
impl Model {
|
||||
#[allow(clippy::expect_used)]
|
||||
pub(crate) fn shift_cell_formula(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
@@ -57,6 +58,7 @@ impl Model {
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::expect_used)]
|
||||
pub fn forward_references(
|
||||
&mut self,
|
||||
source_area: &Area,
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
#![allow(clippy::expect_used)]
|
||||
|
||||
use crate::expressions::{
|
||||
lexer::util::get_tokens,
|
||||
token::{OpCompare, OpSum, TokenType},
|
||||
|
||||
@@ -52,7 +52,9 @@ pub fn get_tokens(formula: &str) -> Vec<MarkedToken> {
|
||||
let mut lexer = Lexer::new(
|
||||
formula,
|
||||
LexerMode::A1,
|
||||
#[allow(clippy::expect_used)]
|
||||
get_locale("en").expect(""),
|
||||
#[allow(clippy::expect_used)]
|
||||
get_language("en").expect(""),
|
||||
);
|
||||
let mut start = lexer.get_position();
|
||||
|
||||
@@ -63,7 +63,9 @@ pub(crate) fn parse_range(formula: &str) -> Result<(i32, i32, i32, i32), String>
|
||||
let mut lexer = lexer::Lexer::new(
|
||||
formula,
|
||||
lexer::LexerMode::A1,
|
||||
#[allow(clippy::expect_used)]
|
||||
get_locale("en").expect(""),
|
||||
#[allow(clippy::expect_used)]
|
||||
get_language("en").expect(""),
|
||||
);
|
||||
if let TokenType::Range {
|
||||
@@ -202,7 +204,9 @@ impl Parser {
|
||||
let lexer = lexer::Lexer::new(
|
||||
"",
|
||||
lexer::LexerMode::A1,
|
||||
#[allow(clippy::expect_used)]
|
||||
get_locale("en").expect(""),
|
||||
#[allow(clippy::expect_used)]
|
||||
get_language("en").expect(""),
|
||||
);
|
||||
Parser {
|
||||
@@ -675,14 +679,23 @@ impl Parser {
|
||||
}
|
||||
};
|
||||
// table-name => table
|
||||
let table = self.tables.get(&table_name).unwrap_or_else(|| {
|
||||
panic!(
|
||||
let table = match self.tables.get(&table_name) {
|
||||
Some(t) => t,
|
||||
None => {
|
||||
let message = format!(
|
||||
"Table not found: '{table_name}' at '{}!{}{}'",
|
||||
context.sheet,
|
||||
number_to_column(context.column).expect(""),
|
||||
number_to_column(context.column)
|
||||
.unwrap_or(format!("{}", context.column)),
|
||||
context.row
|
||||
)
|
||||
});
|
||||
);
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message,
|
||||
};
|
||||
}
|
||||
};
|
||||
let table_sheet_index = match self.get_sheet_index_by_name(&table.sheet_name) {
|
||||
Some(i) => i,
|
||||
None => {
|
||||
@@ -701,6 +714,7 @@ impl Parser {
|
||||
};
|
||||
|
||||
// context must be with tables.reference
|
||||
#[allow(clippy::expect_used)]
|
||||
let (column_start, mut row_start, column_end, mut row_end) =
|
||||
parse_range(&table.reference).expect("Failed parsing range");
|
||||
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
#![allow(clippy::panic)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::lexer::LexerMode;
|
||||
|
||||
@@ -5,6 +5,7 @@ use chrono::NaiveDate;
|
||||
use crate::constants::EXCEL_DATE_BASE;
|
||||
|
||||
pub fn from_excel_date(days: i64) -> NaiveDate {
|
||||
#[allow(clippy::expect_used)]
|
||||
let dt = NaiveDate::from_ymd_opt(1900, 1, 1).expect("problem with chrono::NaiveDate");
|
||||
dt + Duration::days(days - 2)
|
||||
}
|
||||
|
||||
@@ -12,7 +12,7 @@ const EPS_LOW: f64 = 1e-6;
|
||||
|
||||
// Known values computed with Arb via Nemo.jl in Julia
|
||||
// You can also use Mathematica
|
||||
/// But please do not use Excel or any other software without arbitrary precision
|
||||
// But please do not use Excel or any other software without arbitrary precision
|
||||
|
||||
fn numbers_are_close(a: f64, b: f64) -> bool {
|
||||
if a == b {
|
||||
|
||||
@@ -194,16 +194,24 @@ fn compute_ppmt(
|
||||
// In these formulas the payment (pmt) is normally negative
|
||||
|
||||
impl Model {
|
||||
// FIXME: These three functions (get_array_of_numbers..) need to be refactored
|
||||
// They are really similar expect for small issues
|
||||
fn get_array_of_numbers(
|
||||
fn get_array_of_numbers_generic(
|
||||
&mut self,
|
||||
arg: &Node,
|
||||
cell: &CellReferenceIndex,
|
||||
accept_number_node: bool,
|
||||
handle_empty_cell: impl Fn() -> Result<Option<f64>, CalcResult>,
|
||||
handle_non_number_cell: impl Fn() -> Result<Option<f64>, CalcResult>,
|
||||
) -> Result<Vec<f64>, CalcResult> {
|
||||
let mut values = Vec::new();
|
||||
match self.evaluate_node_in_context(arg, *cell) {
|
||||
CalcResult::Number(value) => values.push(value),
|
||||
CalcResult::Number(value) if accept_number_node => values.push(value),
|
||||
CalcResult::Number(_) => {
|
||||
return Err(CalcResult::new_error(
|
||||
Error::VALUE,
|
||||
*cell,
|
||||
"Expected range of numbers".to_string(),
|
||||
));
|
||||
}
|
||||
CalcResult::Range { left, right } => {
|
||||
if left.sheet != right.sheet {
|
||||
return Err(CalcResult::new_error(
|
||||
@@ -212,6 +220,7 @@ impl Model {
|
||||
"Ranges are in different sheets".to_string(),
|
||||
));
|
||||
}
|
||||
let sheet = left.sheet;
|
||||
let row1 = left.row;
|
||||
let mut row2 = right.row;
|
||||
let column1 = left.column;
|
||||
@@ -219,32 +228,46 @@ impl Model {
|
||||
if row1 == 1 && row2 == LAST_ROW {
|
||||
row2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.worksheet(sheet)
|
||||
.map_err(|_| {
|
||||
CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
*cell,
|
||||
format!("Invalid worksheet index: '{}'", sheet),
|
||||
)
|
||||
})?
|
||||
.dimension()
|
||||
.max_row;
|
||||
}
|
||||
if column1 == 1 && column2 == LAST_COLUMN {
|
||||
column2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.worksheet(sheet)
|
||||
.map_err(|_| {
|
||||
CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
*cell,
|
||||
format!("Invalid worksheet index: '{}'", sheet),
|
||||
)
|
||||
})?
|
||||
.dimension()
|
||||
.max_column;
|
||||
}
|
||||
for row in row1..row2 + 1 {
|
||||
for column in column1..(column2 + 1) {
|
||||
match self.evaluate_cell(CellReferenceIndex {
|
||||
sheet: left.sheet,
|
||||
row,
|
||||
column,
|
||||
}) {
|
||||
CalcResult::Number(value) => {
|
||||
for row in row1..=row2 {
|
||||
for column in column1..=column2 {
|
||||
let cell_ref = CellReferenceIndex { sheet, row, column };
|
||||
match self.evaluate_cell(cell_ref) {
|
||||
CalcResult::Number(value) => values.push(value),
|
||||
error @ CalcResult::Error { .. } => return Err(error),
|
||||
CalcResult::EmptyCell => {
|
||||
if let Some(value) = handle_empty_cell()? {
|
||||
values.push(value);
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return Err(error),
|
||||
}
|
||||
_ => {
|
||||
// We ignore booleans and strings
|
||||
if let Some(value) = handle_non_number_cell()? {
|
||||
values.push(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -252,88 +275,51 @@ impl Model {
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return Err(error),
|
||||
_ => {
|
||||
// We ignore booleans and strings
|
||||
handle_non_number_cell()?;
|
||||
}
|
||||
}
|
||||
};
|
||||
Ok(values)
|
||||
}
|
||||
|
||||
fn get_array_of_numbers(
|
||||
&mut self,
|
||||
arg: &Node,
|
||||
cell: &CellReferenceIndex,
|
||||
) -> Result<Vec<f64>, CalcResult> {
|
||||
self.get_array_of_numbers_generic(
|
||||
arg,
|
||||
cell,
|
||||
true, // accept_number_node
|
||||
|| Ok(None), // Ignore empty cells
|
||||
|| Ok(None), // Ignore non-number cells
|
||||
)
|
||||
}
|
||||
|
||||
fn get_array_of_numbers_xpnv(
|
||||
&mut self,
|
||||
arg: &Node,
|
||||
cell: &CellReferenceIndex,
|
||||
error: Error,
|
||||
) -> Result<Vec<f64>, CalcResult> {
|
||||
let mut values = Vec::new();
|
||||
match self.evaluate_node_in_context(arg, *cell) {
|
||||
CalcResult::Number(value) => values.push(value),
|
||||
CalcResult::Range { left, right } => {
|
||||
if left.sheet != right.sheet {
|
||||
return Err(CalcResult::new_error(
|
||||
Error::VALUE,
|
||||
*cell,
|
||||
"Ranges are in different sheets".to_string(),
|
||||
));
|
||||
}
|
||||
let row1 = left.row;
|
||||
let mut row2 = right.row;
|
||||
let column1 = left.column;
|
||||
let mut column2 = right.column;
|
||||
if row1 == 1 && row2 == LAST_ROW {
|
||||
row2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_row;
|
||||
}
|
||||
if column1 == 1 && column2 == LAST_COLUMN {
|
||||
column2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_column;
|
||||
}
|
||||
for row in row1..row2 + 1 {
|
||||
for column in column1..(column2 + 1) {
|
||||
match self.evaluate_cell(CellReferenceIndex {
|
||||
sheet: left.sheet,
|
||||
row,
|
||||
column,
|
||||
}) {
|
||||
CalcResult::Number(value) => {
|
||||
values.push(value);
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return Err(error),
|
||||
CalcResult::EmptyCell => {
|
||||
return Err(CalcResult::new_error(
|
||||
self.get_array_of_numbers_generic(
|
||||
arg,
|
||||
cell,
|
||||
true, // accept_number_node
|
||||
|| {
|
||||
Err(CalcResult::new_error(
|
||||
Error::NUM,
|
||||
*cell,
|
||||
"Expected number".to_string(),
|
||||
));
|
||||
}
|
||||
_ => {
|
||||
return Err(CalcResult::new_error(
|
||||
error,
|
||||
))
|
||||
},
|
||||
|| {
|
||||
Err(CalcResult::new_error(
|
||||
error.clone(),
|
||||
*cell,
|
||||
"Expected number".to_string(),
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return Err(error),
|
||||
_ => {
|
||||
return Err(CalcResult::new_error(
|
||||
error,
|
||||
*cell,
|
||||
"Expected number".to_string(),
|
||||
));
|
||||
}
|
||||
};
|
||||
Ok(values)
|
||||
))
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
fn get_array_of_numbers_xirr(
|
||||
@@ -341,69 +327,19 @@ impl Model {
|
||||
arg: &Node,
|
||||
cell: &CellReferenceIndex,
|
||||
) -> Result<Vec<f64>, CalcResult> {
|
||||
let mut values = Vec::new();
|
||||
match self.evaluate_node_in_context(arg, *cell) {
|
||||
CalcResult::Range { left, right } => {
|
||||
if left.sheet != right.sheet {
|
||||
return Err(CalcResult::new_error(
|
||||
Error::VALUE,
|
||||
*cell,
|
||||
"Ranges are in different sheets".to_string(),
|
||||
));
|
||||
}
|
||||
let row1 = left.row;
|
||||
let mut row2 = right.row;
|
||||
let column1 = left.column;
|
||||
let mut column2 = right.column;
|
||||
if row1 == 1 && row2 == LAST_ROW {
|
||||
row2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_row;
|
||||
}
|
||||
if column1 == 1 && column2 == LAST_COLUMN {
|
||||
column2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_column;
|
||||
}
|
||||
for row in row1..row2 + 1 {
|
||||
for column in column1..(column2 + 1) {
|
||||
match self.evaluate_cell(CellReferenceIndex {
|
||||
sheet: left.sheet,
|
||||
row,
|
||||
column,
|
||||
}) {
|
||||
CalcResult::Number(value) => {
|
||||
values.push(value);
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return Err(error),
|
||||
CalcResult::EmptyCell => values.push(0.0),
|
||||
_ => {
|
||||
return Err(CalcResult::new_error(
|
||||
self.get_array_of_numbers_generic(
|
||||
arg,
|
||||
cell,
|
||||
false, // Do not accept a single number node
|
||||
|| Ok(Some(0.0)), // Treat empty cells as zero
|
||||
|| {
|
||||
Err(CalcResult::new_error(
|
||||
Error::VALUE,
|
||||
*cell,
|
||||
"Expected number".to_string(),
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return Err(error),
|
||||
_ => {
|
||||
return Err(CalcResult::new_error(
|
||||
Error::VALUE,
|
||||
*cell,
|
||||
"Expected number".to_string(),
|
||||
));
|
||||
}
|
||||
};
|
||||
Ok(values)
|
||||
))
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
/// PMT(rate, nper, pv, [fv], [type])
|
||||
@@ -862,20 +798,28 @@ impl Model {
|
||||
let column1 = left.column;
|
||||
let mut column2 = right.column;
|
||||
if row1 == 1 && row2 == LAST_ROW {
|
||||
row2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_row;
|
||||
row2 = match self.workbook.worksheet(left.sheet) {
|
||||
Ok(s) => s.dimension().max_row,
|
||||
Err(_) => {
|
||||
return CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Invalid worksheet index: '{}'", left.sheet),
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
if column1 == 1 && column2 == LAST_COLUMN {
|
||||
column2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_column;
|
||||
column2 = match self.workbook.worksheet(left.sheet) {
|
||||
Ok(s) => s.dimension().max_column,
|
||||
Err(_) => {
|
||||
return CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Invalid worksheet index: '{}'", left.sheet),
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
for row in row1..row2 + 1 {
|
||||
for column in column1..(column2 + 1) {
|
||||
@@ -1393,21 +1337,21 @@ impl Model {
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
|
||||
/// This next three functions deal with Treasure Bills or T-Bills for short
|
||||
/// They are zero-coupon that mature in one year or less.
|
||||
/// Definitions:
|
||||
/// $r$ be the discount rate
|
||||
/// $v$ the face value of the Bill
|
||||
/// $p$ the price of the Bill
|
||||
/// $d_m$ is the number of days from the settlement to maturity
|
||||
/// Then:
|
||||
/// $$ p = v \times\left(1-\frac{d_m}{r}\right) $$
|
||||
/// If d_m is less than 183 days the he Bond Equivalent Yield (BEY, here $y$) is given by:
|
||||
/// $$ y = \frac{F - B}{M}\times \frac{365}{d_m} = \frac{365\times r}{360-r\times d_m}
|
||||
/// If d_m>= 183 days things are a bit more complicated.
|
||||
/// Let $d_e = d_m - 365/2$ if $d_m <= 365$ or $d_e = 183$ if $d_m = 366$.
|
||||
/// $$ v = p\times \left(1+\frac{y}{2}\right)\left(1+d_e\times\frac{y}{365}\right) $$
|
||||
/// Together with the previous relation of $p$ and $v$ gives us a quadratic equation for $y$.
|
||||
// This next three functions deal with Treasure Bills or T-Bills for short
|
||||
// They are zero-coupon that mature in one year or less.
|
||||
// Definitions:
|
||||
// $r$ be the discount rate
|
||||
// $v$ the face value of the Bill
|
||||
// $p$ the price of the Bill
|
||||
// $d_m$ is the number of days from the settlement to maturity
|
||||
// Then:
|
||||
// $$ p = v \times\left(1-\frac{d_m}{r}\right) $$
|
||||
// If d_m is less than 183 days the he Bond Equivalent Yield (BEY, here $y$) is given by:
|
||||
// $$ y = \frac{F - B}{M}\times \frac{365}{d_m} = \frac{365\times r}{360-r\times d_m}
|
||||
// If d_m>= 183 days things are a bit more complicated.
|
||||
// Let $d_e = d_m - 365/2$ if $d_m <= 365$ or $d_e = 183$ if $d_m = 366$.
|
||||
// $$ v = p\times \left(1+\frac{y}{2}\right)\left(1+d_e\times\frac{y}{365}\right) $$
|
||||
// Together with the previous relation of $p$ and $v$ gives us a quadratic equation for $y$.
|
||||
|
||||
// TBILLEQ(settlement, maturity, discount)
|
||||
pub(crate) fn fn_tbilleq(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
|
||||
@@ -838,4 +838,43 @@ impl Model {
|
||||
};
|
||||
CalcResult::Range { left, right }
|
||||
}
|
||||
|
||||
pub(crate) fn fn_formulatext(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
if let CalcResult::Range { left, right } = self.evaluate_node_with_reference(&args[0], cell)
|
||||
{
|
||||
if left.sheet != right.sheet {
|
||||
return CalcResult::Error {
|
||||
error: Error::ERROR,
|
||||
origin: cell,
|
||||
message: "3D ranges not supported".to_string(),
|
||||
};
|
||||
}
|
||||
if left.row != right.row || left.column != right.column {
|
||||
// FIXME: Implicit intersection or dynamic arrays
|
||||
return CalcResult::Error {
|
||||
error: Error::ERROR,
|
||||
origin: cell,
|
||||
message: "argument must be a reference to a single cell".to_string(),
|
||||
};
|
||||
}
|
||||
if let Ok(Some(f)) = self.get_cell_formula(left.sheet, left.row, left.column) {
|
||||
CalcResult::String(f)
|
||||
} else {
|
||||
CalcResult::Error {
|
||||
error: Error::NA,
|
||||
origin: cell,
|
||||
message: "Reference does not have a formula".to_string(),
|
||||
}
|
||||
}
|
||||
} else {
|
||||
CalcResult::Error {
|
||||
error: Error::ERROR,
|
||||
origin: cell,
|
||||
message: "Argument must be a reference".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -128,20 +128,28 @@ impl Model {
|
||||
let column1 = left.column;
|
||||
let mut column2 = right.column;
|
||||
if row1 == 1 && row2 == LAST_ROW {
|
||||
row2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_row;
|
||||
row2 = match self.workbook.worksheet(left.sheet) {
|
||||
Ok(s) => s.dimension().max_row,
|
||||
Err(_) => {
|
||||
return CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Invalid worksheet index: '{}'", left.sheet),
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
if column1 == 1 && column2 == LAST_COLUMN {
|
||||
column2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_column;
|
||||
column2 = match self.workbook.worksheet(left.sheet) {
|
||||
Ok(s) => s.dimension().max_column,
|
||||
Err(_) => {
|
||||
return CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Invalid worksheet index: '{}'", left.sheet),
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
for row in row1..row2 + 1 {
|
||||
for column in column1..(column2 + 1) {
|
||||
@@ -195,20 +203,28 @@ impl Model {
|
||||
let column1 = left.column;
|
||||
let mut column2 = right.column;
|
||||
if row1 == 1 && row2 == LAST_ROW {
|
||||
row2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_row;
|
||||
row2 = match self.workbook.worksheet(left.sheet) {
|
||||
Ok(s) => s.dimension().max_row,
|
||||
Err(_) => {
|
||||
return CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Invalid worksheet index: '{}'", left.sheet),
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
if column1 == 1 && column2 == LAST_COLUMN {
|
||||
column2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_column;
|
||||
column2 = match self.workbook.worksheet(left.sheet) {
|
||||
Ok(s) => s.dimension().max_column,
|
||||
Err(_) => {
|
||||
return CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Invalid worksheet index: '{}'", left.sheet),
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
for row in row1..row2 + 1 {
|
||||
for column in column1..(column2 + 1) {
|
||||
|
||||
@@ -75,6 +75,7 @@ pub enum Function {
|
||||
|
||||
// Information
|
||||
ErrorType,
|
||||
Formulatext,
|
||||
Isblank,
|
||||
Iserr,
|
||||
Iserror,
|
||||
@@ -122,6 +123,7 @@ pub enum Function {
|
||||
Textbefore,
|
||||
Textjoin,
|
||||
Trim,
|
||||
Unicode,
|
||||
Upper,
|
||||
Value,
|
||||
Valuetotext,
|
||||
@@ -246,7 +248,7 @@ pub enum Function {
|
||||
}
|
||||
|
||||
impl Function {
|
||||
pub fn into_iter() -> IntoIter<Function, 192> {
|
||||
pub fn into_iter() -> IntoIter<Function, 194> {
|
||||
[
|
||||
Function::And,
|
||||
Function::False,
|
||||
@@ -316,6 +318,7 @@ impl Function {
|
||||
Function::Search,
|
||||
Function::Text,
|
||||
Function::Trim,
|
||||
Function::Unicode,
|
||||
Function::Upper,
|
||||
Function::Isnumber,
|
||||
Function::Isnontext,
|
||||
@@ -330,6 +333,7 @@ impl Function {
|
||||
Function::Isodd,
|
||||
Function::Iseven,
|
||||
Function::ErrorType,
|
||||
Function::Formulatext,
|
||||
Function::Isformula,
|
||||
Function::Type,
|
||||
Function::Sheet,
|
||||
@@ -460,6 +464,7 @@ impl Function {
|
||||
Function::Textbefore => "_xlfn.TEXTBEFORE".to_string(),
|
||||
Function::Textafter => "_xlfn.TEXTAFTER".to_string(),
|
||||
Function::Textjoin => "_xlfn.TEXTJOIN".to_string(),
|
||||
Function::Unicode => "_xlfn.UNICODE".to_string(),
|
||||
Function::Rri => "_xlfn.RRI".to_string(),
|
||||
Function::Pduration => "_xlfn.PDURATION".to_string(),
|
||||
Function::Bitand => "_xlfn.BITAND".to_string(),
|
||||
@@ -479,6 +484,7 @@ impl Function {
|
||||
Function::Valuetotext => "_xlfn.VALUETOTEXT".to_string(),
|
||||
Function::Isformula => "_xlfn.ISFORMULA".to_string(),
|
||||
Function::Sheet => "_xlfn.SHEET".to_string(),
|
||||
Function::Formulatext => "_xlfn.FORMULATEXT".to_string(),
|
||||
_ => self.to_string(),
|
||||
}
|
||||
}
|
||||
@@ -567,6 +573,7 @@ impl Function {
|
||||
"SEARCH" => Some(Function::Search),
|
||||
"TEXT" => Some(Function::Text),
|
||||
"TRIM" => Some(Function::Trim),
|
||||
"UNICODE" | "_XLFN.UNICODE" => Some(Function::Unicode),
|
||||
"UPPER" => Some(Function::Upper),
|
||||
|
||||
"REPT" => Some(Function::Rept),
|
||||
@@ -588,6 +595,7 @@ impl Function {
|
||||
"ISODD" => Some(Function::Isodd),
|
||||
"ISEVEN" => Some(Function::Iseven),
|
||||
"ERROR.TYPE" => Some(Function::ErrorType),
|
||||
"FORMULATEXT" | "_XLFN.FORMULATEXT" => Some(Function::Formulatext),
|
||||
"ISFORMULA" | "_XLFN.ISFORMULA" => Some(Function::Isformula),
|
||||
"TYPE" => Some(Function::Type),
|
||||
"SHEET" | "_XLFN.SHEET" => Some(Function::Sheet),
|
||||
@@ -779,6 +787,7 @@ impl fmt::Display for Function {
|
||||
Function::Search => write!(f, "SEARCH"),
|
||||
Function::Text => write!(f, "TEXT"),
|
||||
Function::Trim => write!(f, "TRIM"),
|
||||
Function::Unicode => write!(f, "UNICODE"),
|
||||
Function::Upper => write!(f, "UPPER"),
|
||||
Function::Isnumber => write!(f, "ISNUMBER"),
|
||||
Function::Isnontext => write!(f, "ISNONTEXT"),
|
||||
@@ -793,6 +802,7 @@ impl fmt::Display for Function {
|
||||
Function::Isodd => write!(f, "ISODD"),
|
||||
Function::Iseven => write!(f, "ISEVEN"),
|
||||
Function::ErrorType => write!(f, "ERROR.TYPE"),
|
||||
Function::Formulatext => write!(f, "FORMULATEXT"),
|
||||
Function::Isformula => write!(f, "ISFORMULA"),
|
||||
Function::Type => write!(f, "TYPE"),
|
||||
Function::Sheet => write!(f, "SHEET"),
|
||||
@@ -1012,6 +1022,7 @@ impl Model {
|
||||
Function::Search => self.fn_search(args, cell),
|
||||
Function::Text => self.fn_text(args, cell),
|
||||
Function::Trim => self.fn_trim(args, cell),
|
||||
Function::Unicode => self.fn_unicode(args, cell),
|
||||
Function::Upper => self.fn_upper(args, cell),
|
||||
// Information
|
||||
Function::Isnumber => self.fn_isnumber(args, cell),
|
||||
@@ -1027,6 +1038,7 @@ impl Model {
|
||||
Function::Isodd => self.fn_isodd(args, cell),
|
||||
Function::Iseven => self.fn_iseven(args, cell),
|
||||
Function::ErrorType => self.fn_errortype(args, cell),
|
||||
Function::Formulatext => self.fn_formulatext(args, cell),
|
||||
Function::Isformula => self.fn_isformula(args, cell),
|
||||
Function::Type => self.fn_type(args, cell),
|
||||
Function::Sheet => self.fn_sheet(args, cell),
|
||||
@@ -1148,6 +1160,7 @@ impl Model {
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#![allow(clippy::unwrap_used)]
|
||||
use std::{
|
||||
fs::File,
|
||||
io::{BufRead, BufReader},
|
||||
|
||||
@@ -381,11 +381,16 @@ impl Model {
|
||||
let right_row = first_range.right.row;
|
||||
let right_column = first_range.right.column;
|
||||
|
||||
let dimension = self
|
||||
.workbook
|
||||
.worksheet(first_range.left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension();
|
||||
let dimension = match self.workbook.worksheet(first_range.left.sheet) {
|
||||
Ok(s) => s.dimension(),
|
||||
Err(_) => {
|
||||
return CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Invalid worksheet index: '{}'", first_range.left.sheet),
|
||||
)
|
||||
}
|
||||
};
|
||||
let max_row = dimension.max_row;
|
||||
let max_column = dimension.max_column;
|
||||
|
||||
@@ -526,20 +531,28 @@ impl Model {
|
||||
let mut right_column = sum_range.right.column;
|
||||
|
||||
if left_row == 1 && right_row == LAST_ROW {
|
||||
right_row = self
|
||||
.workbook
|
||||
.worksheet(sum_range.left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_row;
|
||||
right_row = match self.workbook.worksheet(sum_range.left.sheet) {
|
||||
Ok(s) => s.dimension().max_row,
|
||||
Err(_) => {
|
||||
return Err(CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
|
||||
));
|
||||
}
|
||||
};
|
||||
}
|
||||
if left_column == 1 && right_column == LAST_COLUMN {
|
||||
right_column = self
|
||||
.workbook
|
||||
.worksheet(sum_range.left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_column;
|
||||
right_column = match self.workbook.worksheet(sum_range.left.sheet) {
|
||||
Ok(s) => s.dimension().max_column,
|
||||
Err(_) => {
|
||||
return Err(CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
|
||||
));
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
for row in left_row..right_row + 1 {
|
||||
|
||||
@@ -53,8 +53,13 @@ impl Model {
|
||||
false
|
||||
}
|
||||
|
||||
fn cell_hidden_status(&self, sheet_index: u32, row: i32, column: i32) -> CellTableStatus {
|
||||
let worksheet = self.workbook.worksheet(sheet_index).expect("");
|
||||
fn cell_hidden_status(
|
||||
&self,
|
||||
sheet_index: u32,
|
||||
row: i32,
|
||||
column: i32,
|
||||
) -> Result<CellTableStatus, String> {
|
||||
let worksheet = self.workbook.worksheet(sheet_index)?;
|
||||
let mut hidden = false;
|
||||
for row_style in &worksheet.rows {
|
||||
if row_style.r == row {
|
||||
@@ -63,13 +68,13 @@ impl Model {
|
||||
}
|
||||
}
|
||||
if !hidden {
|
||||
return CellTableStatus::Normal;
|
||||
return Ok(CellTableStatus::Normal);
|
||||
}
|
||||
// The row is hidden we need to know if the table has filters
|
||||
if self.get_table_for_cell(sheet_index, row, column) {
|
||||
CellTableStatus::Filtered
|
||||
Ok(CellTableStatus::Filtered)
|
||||
} else {
|
||||
CellTableStatus::Hidden
|
||||
Ok(CellTableStatus::Hidden)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -143,7 +148,11 @@ impl Model {
|
||||
let column2 = right.column;
|
||||
|
||||
for row in row1..=row2 {
|
||||
let cell_status = self.cell_hidden_status(left.sheet, row, column1);
|
||||
let cell_status = self
|
||||
.cell_hidden_status(left.sheet, row, column1)
|
||||
.map_err(|message| {
|
||||
CalcResult::new_error(Error::ERROR, cell, message)
|
||||
})?;
|
||||
if cell_status == CellTableStatus::Filtered {
|
||||
continue;
|
||||
}
|
||||
@@ -380,7 +389,14 @@ impl Model {
|
||||
let column2 = right.column;
|
||||
|
||||
for row in row1..=row2 {
|
||||
let cell_status = self.cell_hidden_status(left.sheet, row, column1);
|
||||
let cell_status = match self
|
||||
.cell_hidden_status(left.sheet, row, column1)
|
||||
{
|
||||
Ok(s) => s,
|
||||
Err(message) => {
|
||||
return CalcResult::new_error(Error::ERROR, cell, message);
|
||||
}
|
||||
};
|
||||
if cell_status == CellTableStatus::Filtered {
|
||||
continue;
|
||||
}
|
||||
@@ -449,7 +465,14 @@ impl Model {
|
||||
let column2 = right.column;
|
||||
|
||||
for row in row1..=row2 {
|
||||
let cell_status = self.cell_hidden_status(left.sheet, row, column1);
|
||||
let cell_status = match self
|
||||
.cell_hidden_status(left.sheet, row, column1)
|
||||
{
|
||||
Ok(s) => s,
|
||||
Err(message) => {
|
||||
return CalcResult::new_error(Error::ERROR, cell, message);
|
||||
}
|
||||
};
|
||||
if cell_status == CellTableStatus::Filtered {
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -342,6 +342,53 @@ impl Model {
|
||||
CalcResult::new_args_number_error(cell)
|
||||
}
|
||||
|
||||
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::String(v) => v,
|
||||
CalcResult::Boolean(b) => {
|
||||
if b {
|
||||
"TRUE".to_string()
|
||||
} else {
|
||||
"FALSE".to_string()
|
||||
}
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::Range { .. } => {
|
||||
// Implicit Intersection not implemented
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Implicit Intersection not implemented".to_string(),
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => {
|
||||
return CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Empty cell".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
match s.chars().next() {
|
||||
Some(c) => {
|
||||
let unicode_number = c as u32;
|
||||
return CalcResult::Number(unicode_number as f64);
|
||||
}
|
||||
None => {
|
||||
return CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Empty cell".to_string(),
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
CalcResult::new_args_number_error(cell)
|
||||
}
|
||||
|
||||
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) {
|
||||
@@ -503,7 +550,7 @@ impl Model {
|
||||
}
|
||||
result.push(ch);
|
||||
}
|
||||
return CalcResult::String(result.chars().rev().collect::<String>());
|
||||
CalcResult::String(result.chars().rev().collect::<String>())
|
||||
}
|
||||
|
||||
pub(crate) fn fn_mid(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
@@ -888,20 +935,28 @@ impl Model {
|
||||
let column1 = left.column;
|
||||
let mut column2 = right.column;
|
||||
if row1 == 1 && row2 == LAST_ROW {
|
||||
row2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_row;
|
||||
row2 = match self.workbook.worksheet(left.sheet) {
|
||||
Ok(s) => s.dimension().max_row,
|
||||
Err(_) => {
|
||||
return CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Invalid worksheet index: '{}'", left.sheet),
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
if column1 == 1 && column2 == LAST_COLUMN {
|
||||
column2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_column;
|
||||
column2 = match self.workbook.worksheet(left.sheet) {
|
||||
Ok(s) => s.dimension().max_column,
|
||||
Err(_) => {
|
||||
return CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Invalid worksheet index: '{}'", left.sheet),
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
for row in row1..row2 + 1 {
|
||||
for column in column1..(column2 + 1) {
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
use regex::{escape, Regex};
|
||||
#[cfg(feature = "use_regex_lite")]
|
||||
use regex_lite as regex;
|
||||
|
||||
use crate::{calc_result::CalcResult, expressions::token::is_english_error_string};
|
||||
|
||||
@@ -25,9 +26,9 @@ pub(crate) fn values_are_equal(left: &CalcResult, right: &CalcResult) -> bool {
|
||||
}
|
||||
}
|
||||
|
||||
/// In Excel there are two ways of comparing cell values.
|
||||
/// The old school comparison valid in formulas like D3 < D4 or HLOOKUP,... cast empty cells into empty strings or 0
|
||||
/// For the new formulas like XLOOKUP or SORT an empty cell is always larger than anything else.
|
||||
// In Excel there are two ways of comparing cell values.
|
||||
// The old school comparison valid in formulas like D3 < D4 or HLOOKUP,... cast empty cells into empty strings or 0
|
||||
// For the new formulas like XLOOKUP or SORT an empty cell is always larger than anything else.
|
||||
|
||||
// ..., -2, -1, 0, 1, 2, ..., A-Z, FALSE, TRUE;
|
||||
pub(crate) fn compare_values(left: &CalcResult, right: &CalcResult) -> i32 {
|
||||
@@ -86,7 +87,7 @@ pub(crate) fn from_wildcard_to_regex(
|
||||
exact: bool,
|
||||
) -> Result<regex::Regex, regex::Error> {
|
||||
// 1. Escape all
|
||||
let reg = &escape(wildcard);
|
||||
let reg = ®ex::escape(wildcard);
|
||||
|
||||
// 2. We convert the escaped '?' into '.' (matches a single character)
|
||||
let reg = ®.replace("\\?", ".");
|
||||
@@ -109,13 +110,13 @@ 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::new(&format!("^{}$", reg));
|
||||
return regex::Regex::new(&format!("^{}$", reg));
|
||||
}
|
||||
Regex::new(reg)
|
||||
regex::Regex::new(reg)
|
||||
}
|
||||
|
||||
/// NUMBERS ///
|
||||
///*********///
|
||||
// NUMBERS ///
|
||||
//*********///
|
||||
|
||||
// It could be either the number or a string representation of the number
|
||||
// In the rest of the cases calc_result needs to be a number (cannot be the string "23", for instance)
|
||||
@@ -180,8 +181,8 @@ fn result_is_not_equal_to_number(calc_result: &CalcResult, target: f64) -> bool
|
||||
}
|
||||
}
|
||||
|
||||
/// BOOLEANS ///
|
||||
///**********///
|
||||
// BOOLEANS ///
|
||||
//**********///
|
||||
|
||||
// Booleans have to be "exactly" equal
|
||||
fn result_is_equal_to_bool(calc_result: &CalcResult, target: bool) -> bool {
|
||||
@@ -198,12 +199,12 @@ fn result_is_not_equal_to_bool(calc_result: &CalcResult, target: bool) -> bool {
|
||||
}
|
||||
}
|
||||
|
||||
/// STRINGS ///
|
||||
///*********///
|
||||
// STRINGS ///
|
||||
//*********///
|
||||
|
||||
/// Note that strings are case insensitive. `target` must always be lower case.
|
||||
// Note that strings are case insensitive. `target` must always be lower case.
|
||||
|
||||
pub(crate) fn result_matches_regex(calc_result: &CalcResult, reg: &Regex) -> bool {
|
||||
pub(crate) fn result_matches_regex(calc_result: &CalcResult, reg: ®ex::Regex) -> bool {
|
||||
match calc_result {
|
||||
CalcResult::String(s) => reg.is_match(&s.to_lowercase()),
|
||||
_ => false,
|
||||
@@ -269,8 +270,8 @@ fn result_is_greater_or_equal_than_string(calc_result: &CalcResult, target: &str
|
||||
}
|
||||
}
|
||||
|
||||
/// ERRORS ///
|
||||
///********///
|
||||
// ERRORS ///
|
||||
//********///
|
||||
|
||||
fn result_is_equal_to_error(calc_result: &CalcResult, target: &str) -> bool {
|
||||
match calc_result {
|
||||
@@ -286,8 +287,8 @@ fn result_is_not_equal_to_error(calc_result: &CalcResult, target: &str) -> bool
|
||||
}
|
||||
}
|
||||
|
||||
/// EMPTY ///
|
||||
///*******///
|
||||
// EMPTY ///
|
||||
//*******///
|
||||
|
||||
// Note that these two are not inverse of each other.
|
||||
// In particular, you can never match an empty cell.
|
||||
|
||||
@@ -251,20 +251,28 @@ impl Model {
|
||||
let column1 = left.column;
|
||||
|
||||
if row1 == 1 && row2 == LAST_ROW {
|
||||
row2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_row;
|
||||
row2 = match self.workbook.worksheet(left.sheet) {
|
||||
Ok(s) => s.dimension().max_row,
|
||||
Err(_) => {
|
||||
return CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Invalid worksheet index: '{}'", left.sheet),
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
if column1 == 1 && column2 == LAST_COLUMN {
|
||||
column2 = self
|
||||
.workbook
|
||||
.worksheet(left.sheet)
|
||||
.expect("Sheet expected during evaluation.")
|
||||
.dimension()
|
||||
.max_column;
|
||||
column2 = match self.workbook.worksheet(left.sheet) {
|
||||
Ok(s) => s.dimension().max_column,
|
||||
Err(_) => {
|
||||
return CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Invalid worksheet index: '{}'", left.sheet),
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
let left = CellReferenceIndex {
|
||||
sheet: left.sheet,
|
||||
|
||||
@@ -31,6 +31,7 @@ pub struct Language {
|
||||
pub errors: Errors,
|
||||
}
|
||||
|
||||
#[allow(clippy::expect_used)]
|
||||
static LANGUAGES: Lazy<HashMap<String, Language>> = Lazy::new(|| {
|
||||
bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
|
||||
});
|
||||
|
||||
@@ -65,6 +65,7 @@ pub struct DecimalFormats {
|
||||
pub standard: String,
|
||||
}
|
||||
|
||||
#[allow(clippy::expect_used)]
|
||||
static LOCALES: Lazy<HashMap<String, Locale>> =
|
||||
Lazy::new(|| bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale"));
|
||||
|
||||
|
||||
@@ -15,7 +15,7 @@ use crate::{
|
||||
},
|
||||
token::{get_error_by_name, Error, OpCompare, OpProduct, OpSum, OpUnary},
|
||||
types::*,
|
||||
utils::{self, is_valid_column_number, is_valid_row},
|
||||
utils::{self, is_valid_column_number, is_valid_row, parse_reference_a1},
|
||||
},
|
||||
formatter::{
|
||||
format::{format_number, parse_formatted_number},
|
||||
@@ -41,6 +41,7 @@ pub use crate::mock_time::get_milliseconds_since_epoch;
|
||||
/// * Or mocked for tests
|
||||
#[cfg(not(test))]
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
#[allow(clippy::expect_used)]
|
||||
pub fn get_milliseconds_since_epoch() -> i64 {
|
||||
use std::time::{SystemTime, UNIX_EPOCH};
|
||||
SystemTime::now()
|
||||
@@ -529,6 +530,7 @@ impl Model {
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::expect_used)]
|
||||
fn cell_reference_to_string(
|
||||
&self,
|
||||
cell_reference: &CellReferenceIndex,
|
||||
@@ -544,6 +546,7 @@ impl Model {
|
||||
/// Sets `result` in the cell given by `sheet` sheet index, row and column
|
||||
/// Note that will panic if the cell does not exist
|
||||
/// It will do nothing if the cell does not have a formula
|
||||
#[allow(clippy::expect_used)]
|
||||
fn set_cell_value(&mut self, cell_reference: CellReferenceIndex, result: &CalcResult) {
|
||||
let CellReferenceIndex { sheet, column, row } = cell_reference;
|
||||
let cell = &self.workbook.worksheets[sheet as usize].sheet_data[&row][&column];
|
||||
@@ -744,6 +747,29 @@ impl Model {
|
||||
self.workbook.worksheet(sheet)?.is_empty_cell(row, column)
|
||||
}
|
||||
|
||||
/// Returns 'true' if the cell belongs to any Merged cells
|
||||
/// # Examples
|
||||
///
|
||||
/// ```rust
|
||||
/// # use ironcalc_base::Model;
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// let mut model = Model::new_empty("model", "en", "UTC")?;
|
||||
/// model.merge_cells(0, "A1:D5");
|
||||
/// assert_eq!(model.is_part_of_merged_cells(0, 1, 2)?, true);
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn is_part_of_merged_cells(
|
||||
&self,
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
column: i32,
|
||||
) -> Result<bool, String> {
|
||||
self.workbook
|
||||
.worksheet(sheet)?
|
||||
.is_part_of_merged_cells(row, column)
|
||||
}
|
||||
|
||||
pub(crate) fn evaluate_cell(&mut self, cell_reference: CellReferenceIndex) -> CalcResult {
|
||||
let row_data = match self.workbook.worksheets[cell_reference.sheet as usize]
|
||||
.sheet_data
|
||||
@@ -875,6 +901,7 @@ impl Model {
|
||||
.map_err(|_| format!("Invalid timezone: {}", workbook.settings.tz))?;
|
||||
|
||||
// FIXME: Add support for display languages
|
||||
#[allow(clippy::expect_used)]
|
||||
let language = get_language("en").expect("").clone();
|
||||
let mut shared_strings = HashMap::new();
|
||||
for (index, s) in workbook.shared_strings.iter().enumerate() {
|
||||
@@ -1221,6 +1248,14 @@ impl Model {
|
||||
column: i32,
|
||||
value: &str,
|
||||
) -> Result<(), String> {
|
||||
// Checking first whether cell we are updating is part of Merged cells
|
||||
// if so returning with Err
|
||||
if self.is_part_of_merged_cells(sheet, row, column)? {
|
||||
return Err(format!(
|
||||
"Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
|
||||
row, column
|
||||
));
|
||||
}
|
||||
let style_index = self.get_cell_style_index(sheet, row, column)?;
|
||||
let new_style_index;
|
||||
if common::value_needs_quoting(value, &self.language) {
|
||||
@@ -1271,6 +1306,15 @@ impl Model {
|
||||
column: i32,
|
||||
value: bool,
|
||||
) -> Result<(), String> {
|
||||
// Checking first whether cell we are updating is part of Merged cells
|
||||
// if so returning with Err
|
||||
if self.is_part_of_merged_cells(sheet, row, column)? {
|
||||
return Err(format!(
|
||||
"Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
|
||||
row, column
|
||||
));
|
||||
}
|
||||
|
||||
let style_index = self.get_cell_style_index(sheet, row, column)?;
|
||||
let new_style_index = if self.workbook.styles.style_is_quote_prefix(style_index) {
|
||||
self.workbook
|
||||
@@ -1313,6 +1357,14 @@ impl Model {
|
||||
column: i32,
|
||||
value: f64,
|
||||
) -> Result<(), String> {
|
||||
// Checking first whether cell we are updating is part of Merged cells
|
||||
// if so returning with Err
|
||||
if self.is_part_of_merged_cells(sheet, row, column)? {
|
||||
return Err(format!(
|
||||
"Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
|
||||
row, column
|
||||
));
|
||||
}
|
||||
let style_index = self.get_cell_style_index(sheet, row, column)?;
|
||||
let new_style_index = if self.workbook.styles.style_is_quote_prefix(style_index) {
|
||||
self.workbook
|
||||
@@ -1358,6 +1410,12 @@ impl Model {
|
||||
column: i32,
|
||||
formula: String,
|
||||
) -> Result<(), String> {
|
||||
if self.is_part_of_merged_cells(sheet, row, column)? {
|
||||
return Err(format!(
|
||||
"Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
|
||||
row, column
|
||||
));
|
||||
}
|
||||
let mut style_index = self.get_cell_style_index(sheet, row, column)?;
|
||||
if self.workbook.styles.style_is_quote_prefix(style_index) {
|
||||
style_index = self
|
||||
@@ -1410,6 +1468,14 @@ impl Model {
|
||||
column: i32,
|
||||
value: String,
|
||||
) -> Result<(), String> {
|
||||
// Checking first whether cell we are updating is part of Merged cells
|
||||
// if so returning with Err
|
||||
if self.is_part_of_merged_cells(sheet, row, column)? {
|
||||
return Err(format!(
|
||||
"Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
|
||||
row, column
|
||||
));
|
||||
}
|
||||
// If value starts with "'" then we force the style to be quote_prefix
|
||||
let style_index = self.get_cell_style_index(sheet, row, column)?;
|
||||
if let Some(new_value) = value.strip_prefix('\'') {
|
||||
@@ -1924,6 +1990,7 @@ impl Model {
|
||||
/// Sets the number of frozen rows to `frozen_rows` in the workbook.
|
||||
/// Fails if `frozen`_rows` is either too small (<0) or too large (>LAST_ROW)`
|
||||
pub fn set_frozen_rows(&mut self, sheet: u32, frozen_rows: i32) -> Result<(), String> {
|
||||
// TODO: What is frozen rows and do we need to take of this if row we are frozing is part of merge cells ?
|
||||
if let Some(worksheet) = self.workbook.worksheets.get_mut(sheet as usize) {
|
||||
if frozen_rows < 0 {
|
||||
return Err("Frozen rows cannot be negative".to_string());
|
||||
@@ -1941,6 +2008,7 @@ impl Model {
|
||||
/// Sets the number of frozen columns to `frozen_column` in the workbook.
|
||||
/// Fails if `frozen`_columns` is either too small (<0) or too large (>LAST_COLUMN)`
|
||||
pub fn set_frozen_columns(&mut self, sheet: u32, frozen_columns: i32) -> Result<(), String> {
|
||||
// TODO: What is frozen columns and do we need to take of this if column we are frozing is part of merge cells ?
|
||||
if let Some(worksheet) = self.workbook.worksheets.get_mut(sheet as usize) {
|
||||
if frozen_columns < 0 {
|
||||
return Err("Frozen columns cannot be negative".to_string());
|
||||
@@ -1982,10 +2050,169 @@ impl Model {
|
||||
.worksheet_mut(sheet)?
|
||||
.set_row_height(column, height)
|
||||
}
|
||||
|
||||
fn parse_merged_range(&mut self, range: &str) -> Result<(i32, i32, i32, i32), String> {
|
||||
let parts: Vec<&str> = range.split(':').collect();
|
||||
if parts.len() == 1 {
|
||||
Err(format!("Invalid range: '{}'", range))
|
||||
} else if parts.len() == 2 {
|
||||
match (parse_reference_a1(parts[0]), parse_reference_a1(parts[1])) {
|
||||
(Some(left), Some(right)) => {
|
||||
return Ok((left.row, left.column, right.row, right.column));
|
||||
}
|
||||
_ => return Err(format!("Invalid range: '{}'", range)),
|
||||
}
|
||||
} else {
|
||||
return Err(format!("Invalid range: '{}'", range));
|
||||
}
|
||||
}
|
||||
|
||||
// Implementing public APIS related to Merge cells handling
|
||||
|
||||
/// Merges given selected cells
|
||||
/// If no overlap, it will create that merged cells with left most top cell value representing the whole merged cells
|
||||
/// If new merge cells creation overlaps with any of the existing merged cells, Overlapped merged cells gets unmerged
|
||||
/// and new merge cells gets added
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```rust
|
||||
/// # use ironcalc_base::Model;
|
||||
/// # use ironcalc_base::cell::CellValue;
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// let mut model = Model::new_empty("model", "en", "UTC")?;
|
||||
/// model.merge_cells(0, "D4:F6").unwrap();
|
||||
/// model.merge_cells(0, "A1:B4").unwrap();
|
||||
/// assert_eq!(model.workbook.worksheet(0).unwrap().merged_cells_list.len(), 2);
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// See also:
|
||||
/// * [Model::update_cell_with_formula()]
|
||||
/// * [Model::update_cell_with_number()]
|
||||
/// * [Model::update_cell_with_bool()]
|
||||
/// * [Model::update_cell_with_text()]
|
||||
pub fn merge_cells(&mut self, sheet: u32, range_ref: &str) -> Result<(), String> {
|
||||
match self.parse_merged_range(range_ref) {
|
||||
Ok(parsed_merge_cell_range) => {
|
||||
// ATTENTION 2: Below thing we can support here but keeping it simple
|
||||
// Web or different client needs to keep this in mind
|
||||
// User can give errored parse ranges like C3:A1
|
||||
// Where col_start and row_start and is greated then col_end and row_end
|
||||
// Return error in these scenario
|
||||
if parsed_merge_cell_range.0 > parsed_merge_cell_range.2
|
||||
|| parsed_merge_cell_range.1 > parsed_merge_cell_range.3
|
||||
{
|
||||
return Err(
|
||||
"Invalid parse range. Merge Mother cell always be top left cell"
|
||||
.to_string(),
|
||||
);
|
||||
}
|
||||
|
||||
let mut merged_cells_overlaped_list: Vec<bool> = Vec::new();
|
||||
// checking whether our new range overlaps with any of the already existing merged cells
|
||||
// if so, need to unmerge those and create this new one
|
||||
{
|
||||
let worksheet = self.workbook.worksheet(sheet)?;
|
||||
let merged_cells = worksheet.get_merged_cells_list();
|
||||
|
||||
for merge_node in merged_cells {
|
||||
// checking whether any overlapping exist with this merge cell
|
||||
if !(parsed_merge_cell_range.1 > merge_node.3
|
||||
|| parsed_merge_cell_range.3 < merge_node.1
|
||||
|| parsed_merge_cell_range.0 > merge_node.2
|
||||
|| parsed_merge_cell_range.2 < merge_node.0)
|
||||
{
|
||||
// overlap has happened
|
||||
merged_cells_overlaped_list.push(true);
|
||||
} else {
|
||||
merged_cells_overlaped_list.push(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if !merged_cells_overlaped_list.is_empty() {
|
||||
// Lets take Mutable ref to Merge cell and deletes all those nodes which has overlapped
|
||||
let worksheet = self.workbook.worksheet_mut(sheet)?;
|
||||
let merged_cells_list_mut = worksheet.get_merged_cells_list_mut();
|
||||
let mut merged_cells_overlaped_list_iter = merged_cells_overlaped_list.iter();
|
||||
merged_cells_list_mut
|
||||
.retain(|_| !(*merged_cells_overlaped_list_iter.next().unwrap()))
|
||||
}
|
||||
|
||||
// Now need to update (n*m - 1) cells with empty cell ( except the Mother cell )
|
||||
for row_index in parsed_merge_cell_range.0..=parsed_merge_cell_range.2 {
|
||||
for col_index in parsed_merge_cell_range.1..=parsed_merge_cell_range.3 {
|
||||
// skip Mother cell
|
||||
if row_index == parsed_merge_cell_range.0
|
||||
&& col_index == parsed_merge_cell_range.2
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
//update the node with empty cell
|
||||
{
|
||||
self.workbook.worksheet_mut(sheet)?.update_cell(
|
||||
row_index,
|
||||
col_index,
|
||||
Cell::EmptyCell { s: 0 },
|
||||
)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let new_merged_cells = MergedCells::new(parsed_merge_cell_range);
|
||||
{
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.merged_cells_list
|
||||
.push(new_merged_cells);
|
||||
}
|
||||
}
|
||||
Err(err) => {
|
||||
return Err(err);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Unmerges a given/selected merged cells
|
||||
/// Once unmerged, only top most left corner value gets retained and all the others will have empty cell
|
||||
/// # Examples
|
||||
///
|
||||
/// ```rust
|
||||
/// # use ironcalc_base::Model;
|
||||
/// # use ironcalc_base::cell::CellValue;
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// let mut model = Model::new_empty("model", "en", "UTC")?;
|
||||
/// model.merge_cells(0, "D4:F6");
|
||||
/// model.unmerge_cells(0, "D4:F6");
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn unmerge_cells(&mut self, sheet: u32, range_ref: &str) -> Result<(), String> {
|
||||
let worksheet = self.workbook.worksheet(sheet)?;
|
||||
let merged_cells = worksheet.get_merged_cells_list();
|
||||
for (index, merge_node) in merged_cells.iter().enumerate() {
|
||||
let merge_block_range_ref = merge_node.get_merged_cells_str_ref()?;
|
||||
// finding the merge cell node to be deleted
|
||||
if merge_block_range_ref.as_str() == range_ref {
|
||||
// Merge cell to be deleted is found
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.merged_cells_list
|
||||
.remove(index);
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
Err("Invalid merge_cell_ref, Merged cells to be deleted is not found".to_string())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#![allow(clippy::expect_used)]
|
||||
use super::CellReferenceIndex as CellReference;
|
||||
use crate::{test::util::new_empty_model, types::Cell};
|
||||
|
||||
|
||||
@@ -57,7 +57,7 @@ impl Model {
|
||||
rows: vec![],
|
||||
comments: vec![],
|
||||
dimension: "A1".to_string(),
|
||||
merge_cells: vec![],
|
||||
merged_cells_list: vec![],
|
||||
name: name.to_string(),
|
||||
shared_formulas: vec![],
|
||||
sheet_data: Default::default(),
|
||||
@@ -392,6 +392,7 @@ impl Model {
|
||||
let cells = HashMap::new();
|
||||
|
||||
// FIXME: Add support for display languages
|
||||
#[allow(clippy::expect_used)]
|
||||
let language = get_language("en").expect("").clone();
|
||||
|
||||
let mut model = Model {
|
||||
|
||||
@@ -223,6 +223,14 @@ impl Model {
|
||||
column: i32,
|
||||
style: &Style,
|
||||
) -> Result<(), String> {
|
||||
// Checking first whether cell we are updating is part of Merged cells
|
||||
// if so returning with Err
|
||||
if self.is_part_of_merged_cells(sheet, row, column)? {
|
||||
return Err(format!(
|
||||
"Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
|
||||
row, column
|
||||
));
|
||||
}
|
||||
let style_index = self.workbook.styles.get_style_index_or_create(style);
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
@@ -252,6 +260,14 @@ impl Model {
|
||||
column: i32,
|
||||
style_name: &str,
|
||||
) -> Result<(), String> {
|
||||
// Checking first whether cell we are updating is part of Merged cells
|
||||
// if so returning with Err
|
||||
if self.is_part_of_merged_cells(sheet, row, column)? {
|
||||
return Err(format!(
|
||||
"Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
|
||||
row, column
|
||||
));
|
||||
}
|
||||
let style_index = self.workbook.styles.get_style_index_by_name(style_name)?;
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
|
||||
@@ -15,6 +15,7 @@ mod test_fn_concatenate;
|
||||
mod test_fn_count;
|
||||
mod test_fn_exact;
|
||||
mod test_fn_financial;
|
||||
mod test_fn_formulatext;
|
||||
mod test_fn_if;
|
||||
mod test_fn_maxifs;
|
||||
mod test_fn_minifs;
|
||||
@@ -24,6 +25,7 @@ mod test_fn_sum;
|
||||
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;
|
||||
@@ -51,6 +53,7 @@ mod test_extend;
|
||||
mod test_fn_type;
|
||||
mod test_frozen_rows_and_columns;
|
||||
mod test_get_cell_content;
|
||||
mod test_model_merge_cell_fns;
|
||||
mod test_percentage;
|
||||
mod test_set_functions_error_handling;
|
||||
mod test_today;
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
#![allow(clippy::panic)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
use crate::types::Cell;
|
||||
|
||||
47
base/src/test/test_fn_formulatext.rs
Normal file
47
base/src/test/test_fn_formulatext.rs
Normal file
@@ -0,0 +1,47 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn simple_cases() {}
|
||||
|
||||
#[test]
|
||||
fn wrong_number_of_arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=FORMULATEXT()");
|
||||
model._set("A2", "=FORMULATEXT(\"B\",\"A\")");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn multi_sheet_ref() {
|
||||
let mut model = new_empty_model();
|
||||
model.new_sheet();
|
||||
model._set("A1", "=FORMULATEXT(Sheet1!A1:Sheet2!A1)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn implicit_intersection() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=FORMULATEXT(C1:C2)");
|
||||
model._set("A2", "=FORMULATEXT(D1:E1)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn non_reference() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=FORMULATEXT(42)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
}
|
||||
63
base/src/test/test_fn_unicode.rs
Normal file
63
base/src/test/test_fn_unicode.rs
Normal file
@@ -0,0 +1,63 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn simple_cases() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=UNICODE(\"1,00\")");
|
||||
model._set("A2", "=UNICODE(\"1\")");
|
||||
model._set("A3", "=UNICODE(1)");
|
||||
model._set("A4", "=UNICODE(\"T\")");
|
||||
model._set("A5", "=UNICODE(\"TRUE\")");
|
||||
model._set("A6", "=UNICODE(TRUE)");
|
||||
model._set("A7", "=UNICODE(FALSE)");
|
||||
model._set("A8", "=UNICODE(\"の\")");
|
||||
model._set("A9", "=UNICODE(\" \")");
|
||||
|
||||
model._set("A10", "=_xlfn.UNICODE(\"T\")");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"49");
|
||||
assert_eq!(model._get_text("A2"), *"49");
|
||||
assert_eq!(model._get_text("A3"), *"49");
|
||||
assert_eq!(model._get_text("A4"), *"84");
|
||||
assert_eq!(model._get_text("A5"), *"84");
|
||||
assert_eq!(model._get_text("A6"), *"84");
|
||||
assert_eq!(model._get_text("A7"), *"70");
|
||||
assert_eq!(model._get_text("A8"), *"12398");
|
||||
assert_eq!(model._get_text("A9"), *"32");
|
||||
assert_eq!(model._get_text("A10"), *"84");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_error_cases() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=UNICODE(\"\")");
|
||||
model._set("A2", "=UNICODE(#CALC!)");
|
||||
model._set("A3", "=UNICODE(#NAME?)");
|
||||
model._set("A4", "=UNICODE(#VALUE!)");
|
||||
model._set("A5", "=UNICODE(#REF!)");
|
||||
model._set("A6", "=UNICODE(#DIV/0!)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#VALUE!");
|
||||
assert_eq!(model._get_text("A2"), *"#CALC!");
|
||||
assert_eq!(model._get_text("A3"), *"#NAME?");
|
||||
assert_eq!(model._get_text("A4"), *"#VALUE!");
|
||||
assert_eq!(model._get_text("A5"), *"#REF!");
|
||||
assert_eq!(model._get_text("A6"), *"#DIV/0!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrong_number_of_arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=UNICODE()");
|
||||
model._set("A2", "=UNICODE(\"B\",\"A\")");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
}
|
||||
@@ -1,3 +1,5 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
|
||||
155
base/src/test/test_model_merge_cell_fns.rs
Normal file
155
base/src/test/test_model_merge_cell_fns.rs
Normal file
@@ -0,0 +1,155 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{test::util::new_empty_model, types::CellType};
|
||||
|
||||
#[test]
|
||||
fn test_model_set_fns_related_to_merge_cells() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// creating a merge cell of D1:F2
|
||||
model.merge_cells(0, "D1:F2").unwrap();
|
||||
|
||||
// Updating the mother cell of Merge cells and expecting the update to go through
|
||||
model.set_user_input(0, 1, 4, "Hello".to_string()).unwrap();
|
||||
assert_eq!(model.get_cell_content(0, 1, 4).unwrap(), "Hello");
|
||||
assert_eq!(model.get_cell_type(0, 1, 4).unwrap(), CellType::Text);
|
||||
|
||||
// Updating cell which is not in Merge cell block
|
||||
assert_eq!(model.set_user_input(0, 1, 3, "Hello".to_string()), Ok(()));
|
||||
assert_eq!(model.get_cell_content(0, 1, 3), Ok("Hello".to_string()));
|
||||
assert_eq!(model.get_cell_type(0, 1, 3), Ok(CellType::Text));
|
||||
|
||||
// 1: testing with set_user_input()
|
||||
assert_eq!(
|
||||
model
|
||||
.set_user_input(0, 1, 5, "Hello".to_string()),
|
||||
Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
|
||||
);
|
||||
assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
|
||||
assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
|
||||
|
||||
// 2: testing with update_cell_with_bool()
|
||||
assert_eq!(
|
||||
model
|
||||
.update_cell_with_bool(0, 1, 5, true),
|
||||
Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
|
||||
);
|
||||
assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
|
||||
assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
|
||||
|
||||
// 3: testing with update_cell_with_formula()
|
||||
assert_eq!(
|
||||
model
|
||||
.update_cell_with_formula(0, 1, 5, "=SUM(A1+A2)".to_string()),
|
||||
Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
|
||||
);
|
||||
assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
|
||||
|
||||
// 4: testing with update_cell_with_number()
|
||||
assert_eq!(
|
||||
model
|
||||
.update_cell_with_number(0, 1, 5, 10.0),
|
||||
Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
|
||||
);
|
||||
assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
|
||||
assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
|
||||
|
||||
// 5: testing with update_cell_with_text()
|
||||
assert_eq!(
|
||||
model
|
||||
.update_cell_with_text(0, 1, 5, "new text"),
|
||||
Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
|
||||
);
|
||||
assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
|
||||
assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_model_merge_cells_crud_api() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// creating a merge cell of D4:F6
|
||||
model.merge_cells(0, "D4:F6").unwrap();
|
||||
model
|
||||
.set_user_input(0, 4, 4, "Merge Block".to_string())
|
||||
.unwrap();
|
||||
// CRUD APIS testing on Merge Cells
|
||||
|
||||
// Case1: Creating a new merge cell without overlapping
|
||||
// Newly created Merge block is left to D4:F6
|
||||
assert_eq!(model.merge_cells(0, "A1:B4"), Ok(()));
|
||||
assert_eq!(
|
||||
model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
|
||||
2
|
||||
);
|
||||
model.set_user_input(0, 1, 1, "left".to_string()).unwrap();
|
||||
|
||||
// Newly created Merge block is right to D4:F6
|
||||
assert_eq!(model.merge_cells(0, "G1:H7"), Ok(()));
|
||||
assert_eq!(
|
||||
model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
|
||||
3
|
||||
);
|
||||
model.set_user_input(0, 1, 7, "right".to_string()).unwrap();
|
||||
|
||||
// Newly created Merge block is above to D4:F6
|
||||
assert_eq!(model.merge_cells(0, "C1:D3"), Ok(()));
|
||||
assert_eq!(
|
||||
model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
|
||||
4
|
||||
);
|
||||
model.set_user_input(0, 1, 3, "top".to_string()).unwrap();
|
||||
|
||||
// Newly created Merge block is down to D4:F6
|
||||
assert_eq!(model.merge_cells(0, "D8:E9"), Ok(()));
|
||||
assert_eq!(
|
||||
model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
|
||||
5
|
||||
);
|
||||
model.set_user_input(0, 8, 4, "down".to_string()).unwrap();
|
||||
|
||||
// Case2: Creating a new merge cell with overlapping with other 3 merged cell
|
||||
assert_eq!(model.merge_cells(0, "C1:G4"), Ok(()));
|
||||
assert_eq!(
|
||||
model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
|
||||
3
|
||||
);
|
||||
model
|
||||
.set_user_input(0, 1, 3, "overlapped_new_merge_block".to_string())
|
||||
.unwrap();
|
||||
|
||||
// Case3: Giving wrong parsing range
|
||||
assert_eq!(
|
||||
model.merge_cells(0, "C3:A1"),
|
||||
Err("Invalid parse range. Merge Mother cell always be top left cell".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
model.merge_cells(0, "CA:A1"),
|
||||
Err("Invalid range: 'CA:A1'".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
model.merge_cells(0, "C0:A1"),
|
||||
Err("Invalid range: 'C0:A1'".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
model.merge_cells(0, "C1:A0"),
|
||||
Err("Invalid range: 'C1:A0'".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
model.merge_cells(0, "C1"),
|
||||
Err("Invalid range: 'C1'".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
model.merge_cells(0, "C1:A1:B1"),
|
||||
Err("Invalid range: 'C1:A1:B1'".to_string())
|
||||
);
|
||||
|
||||
// Case3: Giving wrong merge_ref, which would resulting in error (Merge cell to be deleted is not found)
|
||||
assert_eq!(
|
||||
model.unmerge_cells(0, "C1:E1"),
|
||||
Err("Invalid merge_cell_ref, Merged cells to be deleted is not found".to_string())
|
||||
);
|
||||
|
||||
// Case4: unmerge scenario
|
||||
assert_eq!(model.unmerge_cells(0, "C1:G4"), Ok(()));
|
||||
}
|
||||
@@ -1,3 +1,5 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{expressions::token, test::util::new_empty_model, types::Cell};
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -62,3 +62,45 @@ fn test_create_named_style() {
|
||||
let style = model.get_style_for_cell(0, 1, 1).unwrap();
|
||||
assert!(style.font.b);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_model_style_set_fns_in_merge_cell_context() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// creating a merge cell of D1:F2
|
||||
model.merge_cells(0, "D1:F2").unwrap();
|
||||
model.set_user_input(0, 1, 4, "Hello".to_string()).unwrap();
|
||||
|
||||
let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
|
||||
assert!(!style.font.b);
|
||||
style.font.b = true;
|
||||
|
||||
// Updating the mother cell of Merge cells and expecting the update to go through
|
||||
// This should make the text "Hello" in bold format
|
||||
assert_eq!(model.set_cell_style(0, 1, 4, &style), Ok(()));
|
||||
|
||||
// 1: testing with set_cell_style()
|
||||
let original_style: Style = model.get_style_for_cell(0, 1, 5).unwrap();
|
||||
assert_eq!(
|
||||
model
|
||||
.set_cell_style(0, 1, 5, &style),
|
||||
Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
|
||||
);
|
||||
assert_eq!(model.get_style_for_cell(0, 1, 5), Ok(original_style));
|
||||
|
||||
// 2: testing with set_cell_style_by_name
|
||||
let mut style = model.get_style_for_cell(0, 1, 4).unwrap();
|
||||
style.font.b = true;
|
||||
assert_eq!(
|
||||
model.workbook.styles.create_named_style("bold", &style),
|
||||
Ok(())
|
||||
);
|
||||
|
||||
let original_style: Style = model.get_style_for_cell(0, 1, 5).unwrap();
|
||||
assert_eq!(
|
||||
model
|
||||
.set_cell_style_by_name(0, 1, 5, "bold"),
|
||||
Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
|
||||
);
|
||||
assert_eq!(model.get_style_for_cell(0, 1, 5), Ok(original_style));
|
||||
}
|
||||
|
||||
@@ -283,3 +283,87 @@ fn test_worksheet_navigate_to_edge_in_direction() {
|
||||
assert_eq!(navigate(8, 3, NavigationDirection::Up), (6, 3));
|
||||
assert_eq!(navigate(9, 3, NavigationDirection::Up), (6, 3));
|
||||
}
|
||||
|
||||
// Tests Merge cells related functions of worksheet
|
||||
|
||||
#[test]
|
||||
fn test_merge_cell_fns_worksheet() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Adding one Merge cell
|
||||
model.merge_cells(0, "D1:E3").unwrap();
|
||||
|
||||
// Lets check whether D1 (Mother Merge cell) is part of Merge block or not
|
||||
// It should not be considered as part of Merge cell
|
||||
assert!(!model
|
||||
.workbook
|
||||
.worksheet(0)
|
||||
.unwrap()
|
||||
.is_part_of_merged_cells(1, 4)
|
||||
.unwrap(),);
|
||||
|
||||
// Lets give cell which is actually part of Merge block and expect true from fn
|
||||
assert!(model
|
||||
.workbook
|
||||
.worksheet(0)
|
||||
.unwrap()
|
||||
.is_part_of_merged_cells(2, 4)
|
||||
.unwrap());
|
||||
|
||||
// Lets give cell which is not a part of Merge block and expect false from fn
|
||||
assert!(!model
|
||||
.workbook
|
||||
.worksheet(0)
|
||||
.unwrap()
|
||||
.is_part_of_merged_cells(2, 6)
|
||||
.unwrap());
|
||||
|
||||
// Lets give an Invalid row
|
||||
assert_eq!(
|
||||
model
|
||||
.workbook
|
||||
.worksheet(0)
|
||||
.unwrap()
|
||||
.is_part_of_merged_cells(0, 1),
|
||||
Err("Incorrect row or column".to_string())
|
||||
);
|
||||
|
||||
//Lets give Invalid column
|
||||
assert_eq!(
|
||||
model
|
||||
.workbook
|
||||
.worksheet(0)
|
||||
.unwrap()
|
||||
.is_part_of_merged_cells(1, 0),
|
||||
Err("Incorrect row or column".to_string())
|
||||
);
|
||||
|
||||
// Verifying get fns of worksheet
|
||||
assert_eq!(
|
||||
model
|
||||
.workbook
|
||||
.worksheet(0)
|
||||
.unwrap()
|
||||
.get_merged_cells_list()
|
||||
.len(),
|
||||
1
|
||||
);
|
||||
{
|
||||
let merge_cell_vec = model
|
||||
.workbook
|
||||
.worksheet_mut(0)
|
||||
.unwrap()
|
||||
.get_merged_cells_list_mut();
|
||||
merge_cell_vec.remove(0);
|
||||
|
||||
assert_eq!(
|
||||
model
|
||||
.workbook
|
||||
.worksheet(0)
|
||||
.unwrap()
|
||||
.get_merged_cells_list()
|
||||
.len(),
|
||||
0
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -19,3 +19,4 @@ mod test_to_from_bytes;
|
||||
mod test_undo_redo;
|
||||
mod test_view;
|
||||
mod test_window_size;
|
||||
mod util;
|
||||
|
||||
@@ -1,11 +1,111 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{
|
||||
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
|
||||
#[track_caller]
|
||||
fn check_no_borders(model: &UserModel) {
|
||||
let workbook = &model.model.workbook;
|
||||
for ws in &workbook.worksheets {
|
||||
for data_row in ws.sheet_data.values() {
|
||||
for cell in data_row.values() {
|
||||
let style_index = cell.get_style();
|
||||
let style = workbook.styles.get_style(style_index).unwrap();
|
||||
assert_eq!(
|
||||
style.border,
|
||||
Border {
|
||||
diagonal_up: false,
|
||||
diagonal_down: false,
|
||||
left: None,
|
||||
right: None,
|
||||
top: None,
|
||||
bottom: None,
|
||||
diagonal: None
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// checks that all the borders are consistent
|
||||
#[track_caller]
|
||||
fn check_borders(model: &UserModel) {
|
||||
let workbook = &model.model.workbook;
|
||||
for (sheet_index, ws) in workbook.worksheets.iter().enumerate() {
|
||||
let sheet = sheet_index as u32;
|
||||
for (&row, data_row) in &ws.sheet_data {
|
||||
for (&column, cell) in data_row {
|
||||
let style_index = cell.get_style();
|
||||
let style = workbook.styles.get_style(style_index).unwrap();
|
||||
// Top border:
|
||||
if let Some(top_border) = style.border.top {
|
||||
if row > 1 {
|
||||
let top_cell_style = model.get_cell_style(sheet, row - 1, column).unwrap();
|
||||
assert_eq!(
|
||||
Some(top_border),
|
||||
top_cell_style.border.bottom,
|
||||
"(Top). Sheet: {}, row: {}, column: {}",
|
||||
sheet,
|
||||
row,
|
||||
column
|
||||
);
|
||||
}
|
||||
}
|
||||
// Border to the right
|
||||
if let Some(right_border) = style.border.right {
|
||||
if column < LAST_COLUMN {
|
||||
let right_cell_style =
|
||||
model.get_cell_style(sheet, row, column + 1).unwrap();
|
||||
assert_eq!(
|
||||
Some(right_border),
|
||||
right_cell_style.border.left,
|
||||
"(Right). Sheet: {}, row: {}, column: {}",
|
||||
sheet,
|
||||
row,
|
||||
column
|
||||
);
|
||||
}
|
||||
}
|
||||
// Bottom border:
|
||||
if let Some(bottom_border) = style.border.bottom {
|
||||
if row < LAST_ROW {
|
||||
let bottom_cell_style =
|
||||
model.get_cell_style(sheet, row + 1, column).unwrap();
|
||||
assert_eq!(
|
||||
Some(bottom_border),
|
||||
bottom_cell_style.border.top,
|
||||
"(Bottom). Sheet: {}, row: {}, column: {}",
|
||||
sheet,
|
||||
row,
|
||||
column
|
||||
);
|
||||
}
|
||||
}
|
||||
// Left Border
|
||||
if let Some(left_border) = style.border.left {
|
||||
if column > 1 {
|
||||
let left_cell_style = model.get_cell_style(sheet, row, column - 1).unwrap();
|
||||
assert_eq!(
|
||||
Some(left_border),
|
||||
left_cell_style.border.right,
|
||||
"(Left). Sheet: {}, row: {}, column: {}",
|
||||
sheet,
|
||||
row,
|
||||
column
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn borders_all() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
@@ -129,6 +229,8 @@ fn borders_all() {
|
||||
}
|
||||
}
|
||||
|
||||
check_borders(&model);
|
||||
|
||||
// Lets remove all of them:
|
||||
let border_area: BorderArea = serde_json::from_str(
|
||||
r##"{
|
||||
@@ -156,11 +258,14 @@ fn borders_all() {
|
||||
assert_eq!(style.border, expected_border);
|
||||
}
|
||||
}
|
||||
|
||||
check_borders(&model);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn borders_inner() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
check_borders(&model);
|
||||
// We set an outer border in cells F5:H9
|
||||
let range = &Area {
|
||||
sheet: 0,
|
||||
@@ -183,6 +288,7 @@ fn borders_inner() {
|
||||
)
|
||||
.unwrap();
|
||||
model.set_area_with_border(range, &border_area).unwrap();
|
||||
check_borders(&model);
|
||||
// The inner part all have borders
|
||||
for row in 6..8 {
|
||||
for column in 7..8 {
|
||||
@@ -269,6 +375,7 @@ fn borders_outer() {
|
||||
)
|
||||
.unwrap();
|
||||
model.set_area_with_border(range, &border_area).unwrap();
|
||||
check_borders(&model);
|
||||
{
|
||||
// We check the border on F5
|
||||
let style = model.get_cell_style(0, 5, 6).unwrap();
|
||||
@@ -412,6 +519,7 @@ fn borders_top() {
|
||||
)
|
||||
.unwrap();
|
||||
model.set_area_with_border(range, &border_area).unwrap();
|
||||
check_borders(&model);
|
||||
for row in 5..9 {
|
||||
for column in 6..9 {
|
||||
let style = model.get_cell_style(0, row, column).unwrap();
|
||||
@@ -419,13 +527,18 @@ fn borders_top() {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#FF5566".to_string()),
|
||||
};
|
||||
let bottom = if row == 8 {
|
||||
None
|
||||
} else {
|
||||
Some(border_item.clone())
|
||||
};
|
||||
let expected_border = Border {
|
||||
diagonal_up: false,
|
||||
diagonal_down: false,
|
||||
left: None,
|
||||
right: None,
|
||||
top: Some(border_item.clone()),
|
||||
bottom: None,
|
||||
bottom,
|
||||
diagonal: None,
|
||||
};
|
||||
assert_eq!(style.border, expected_border);
|
||||
@@ -497,6 +610,8 @@ fn borders_top() {
|
||||
assert_eq!(style.border, expected_border);
|
||||
}
|
||||
}
|
||||
assert!(model.undo().is_ok());
|
||||
check_no_borders(&model);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -524,18 +639,29 @@ fn borders_right() {
|
||||
)
|
||||
.unwrap();
|
||||
model.set_area_with_border(range, &border_area).unwrap();
|
||||
|
||||
for row in 5..9 {
|
||||
for column in 6..9 {
|
||||
for column in 6..10 {
|
||||
let style = model.get_cell_style(0, row, column).unwrap();
|
||||
let border_item = BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#FF5566".to_string()),
|
||||
};
|
||||
let left = if column == 6 {
|
||||
None
|
||||
} else {
|
||||
Some(border_item.clone())
|
||||
};
|
||||
let right = if column == 9 {
|
||||
None
|
||||
} else {
|
||||
Some(border_item.clone())
|
||||
};
|
||||
let expected_border = Border {
|
||||
diagonal_up: false,
|
||||
diagonal_down: false,
|
||||
left: None,
|
||||
right: Some(border_item.clone()),
|
||||
left,
|
||||
right,
|
||||
top: None,
|
||||
bottom: None,
|
||||
diagonal: None,
|
||||
@@ -570,6 +696,7 @@ fn borders_bottom() {
|
||||
)
|
||||
.unwrap();
|
||||
model.set_area_with_border(range, &border_area).unwrap();
|
||||
check_borders(&model);
|
||||
for row in 5..9 {
|
||||
for column in 6..9 {
|
||||
let style = model.get_cell_style(0, row, column).unwrap();
|
||||
@@ -577,12 +704,18 @@ fn borders_bottom() {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#FF5566".to_string()),
|
||||
};
|
||||
// The top will also have a value for all but the first one
|
||||
let top = if row == 5 {
|
||||
None
|
||||
} else {
|
||||
Some(border_item.clone())
|
||||
};
|
||||
let expected_border = Border {
|
||||
diagonal_up: false,
|
||||
diagonal_down: false,
|
||||
left: None,
|
||||
right: None,
|
||||
top: None,
|
||||
top,
|
||||
bottom: Some(border_item.clone()),
|
||||
diagonal: None,
|
||||
};
|
||||
@@ -616,18 +749,29 @@ fn borders_left() {
|
||||
)
|
||||
.unwrap();
|
||||
model.set_area_with_border(range, &border_area).unwrap();
|
||||
|
||||
for row in 5..9 {
|
||||
for column in 6..9 {
|
||||
for column in 5..9 {
|
||||
let style = model.get_cell_style(0, row, column).unwrap();
|
||||
let border_item = BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#FF5566".to_string()),
|
||||
};
|
||||
let left = if column == 5 {
|
||||
None
|
||||
} else {
|
||||
Some(border_item.clone())
|
||||
};
|
||||
let right = if column == 8 {
|
||||
None
|
||||
} else {
|
||||
Some(border_item.clone())
|
||||
};
|
||||
let expected_border = Border {
|
||||
diagonal_up: false,
|
||||
diagonal_down: false,
|
||||
left: Some(border_item.clone()),
|
||||
right: None,
|
||||
left,
|
||||
right,
|
||||
top: None,
|
||||
bottom: None,
|
||||
diagonal: None,
|
||||
@@ -636,3 +780,255 @@ fn borders_left() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn none_borders_get_neighbour() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
// We set an outer border in cells F5:
|
||||
let range = &Area {
|
||||
sheet: 0,
|
||||
row: 5,
|
||||
column: 6,
|
||||
width: 1,
|
||||
height: 1,
|
||||
};
|
||||
let border_area: BorderArea = serde_json::from_str(
|
||||
r##"{
|
||||
"item": {
|
||||
"style": "thin",
|
||||
"color": "#FF5566"
|
||||
},
|
||||
"type": "All"
|
||||
}"##,
|
||||
)
|
||||
.unwrap();
|
||||
model.set_area_with_border(range, &border_area).unwrap();
|
||||
|
||||
// Get adjacent cells
|
||||
{
|
||||
// F4
|
||||
let style = model.get_cell_style(0, 4, 6).unwrap();
|
||||
let border_item = BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#FF5566".to_string()),
|
||||
};
|
||||
|
||||
let expected_border = Border {
|
||||
diagonal_up: false,
|
||||
diagonal_down: false,
|
||||
left: None,
|
||||
right: None,
|
||||
top: None,
|
||||
bottom: Some(border_item),
|
||||
diagonal: None,
|
||||
};
|
||||
assert_eq!(style.border, expected_border);
|
||||
}
|
||||
{
|
||||
// G5
|
||||
let style = model.get_cell_style(0, 5, 7).unwrap();
|
||||
let border_item = BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#FF5566".to_string()),
|
||||
};
|
||||
|
||||
let expected_border = Border {
|
||||
diagonal_up: false,
|
||||
diagonal_down: false,
|
||||
left: Some(border_item),
|
||||
right: None,
|
||||
top: None,
|
||||
bottom: None,
|
||||
diagonal: None,
|
||||
};
|
||||
assert_eq!(style.border, expected_border);
|
||||
}
|
||||
{
|
||||
// F6
|
||||
let style = model.get_cell_style(0, 6, 6).unwrap();
|
||||
let border_item = BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#FF5566".to_string()),
|
||||
};
|
||||
|
||||
let expected_border = Border {
|
||||
diagonal_up: false,
|
||||
diagonal_down: false,
|
||||
left: None,
|
||||
right: None,
|
||||
top: Some(border_item),
|
||||
bottom: None,
|
||||
diagonal: None,
|
||||
};
|
||||
assert_eq!(style.border, expected_border);
|
||||
}
|
||||
{
|
||||
// E5
|
||||
let style = model.get_cell_style(0, 5, 5).unwrap();
|
||||
let border_item = BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#FF5566".to_string()),
|
||||
};
|
||||
|
||||
let expected_border = Border {
|
||||
diagonal_up: false,
|
||||
diagonal_down: false,
|
||||
left: None,
|
||||
right: Some(border_item),
|
||||
top: None,
|
||||
bottom: None,
|
||||
diagonal: None,
|
||||
};
|
||||
assert_eq!(style.border, expected_border);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn heavier_borders() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
|
||||
model._set_cell_border("F5", "#F2F2F2");
|
||||
|
||||
// We set an outer border in F4:
|
||||
model._set_cell_border("F4", "#000000");
|
||||
|
||||
// We check the border between F4 and F5
|
||||
let border_item = BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#000000".to_string()),
|
||||
};
|
||||
assert_eq!(model._get_cell_border("F5").top, Some(border_item.clone()));
|
||||
|
||||
// But the border is actually NOT changed (because it is lighter)
|
||||
let border_item2 = BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#F2F2F2".to_string()),
|
||||
};
|
||||
assert_eq!(model._get_cell_actual_border("F5").top, Some(border_item2));
|
||||
|
||||
model._set_cell_border("F6", "#000000");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lighter_borders() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
|
||||
model._set_cell_border("F5", "#000000");
|
||||
|
||||
// We set an outer border all around that is "lighter":
|
||||
model._set_cell_border("F4", "#F2F2F2");
|
||||
model._set_cell_border("G5", "#F2F2F2");
|
||||
model._set_cell_border("F6", "#F2F2F2");
|
||||
model._set_cell_border("E5", "#F2F2F2");
|
||||
|
||||
// We check the border around F5
|
||||
let border_item = BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#F2F2F2".to_string()),
|
||||
};
|
||||
let border = model._get_cell_border("F5");
|
||||
assert_eq!(border.top, Some(border_item.clone()));
|
||||
assert_eq!(border.right, Some(border_item.clone()));
|
||||
assert_eq!(border.bottom, Some(border_item.clone()));
|
||||
assert_eq!(border.left, Some(border_item.clone()));
|
||||
|
||||
// The border is actually changed (because it is heavier)
|
||||
let actual_border = model._get_cell_actual_border("F5");
|
||||
assert_eq!(actual_border.top, Some(border_item.clone()));
|
||||
assert_eq!(actual_border.right, Some(border_item.clone()));
|
||||
assert_eq!(actual_border.bottom, Some(border_item.clone()));
|
||||
assert_eq!(actual_border.left, Some(border_item));
|
||||
|
||||
model.undo().unwrap();
|
||||
model.undo().unwrap();
|
||||
model.undo().unwrap();
|
||||
model.undo().unwrap();
|
||||
|
||||
// after undoing the border is what it was
|
||||
let border_item = BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#000000".to_string()),
|
||||
};
|
||||
let border = model._get_cell_border("F5");
|
||||
assert_eq!(border.top, Some(border_item.clone()));
|
||||
assert_eq!(border.right, Some(border_item.clone()));
|
||||
assert_eq!(border.bottom, Some(border_item.clone()));
|
||||
assert_eq!(border.left, Some(border_item.clone()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn autofill() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
|
||||
model._set_area_border("C4:F6", "#F4F4F4", "All");
|
||||
|
||||
// Set a border in D2
|
||||
model._set_cell_border("D2", "#000000");
|
||||
// now we extend to D8
|
||||
model
|
||||
.auto_fill_rows(
|
||||
&Area {
|
||||
sheet: 0,
|
||||
row: 2,
|
||||
column: 4,
|
||||
width: 1,
|
||||
height: 1,
|
||||
},
|
||||
8,
|
||||
)
|
||||
.unwrap();
|
||||
// auto filling does not change the borders
|
||||
let border_item = BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#000000".to_string()),
|
||||
};
|
||||
let border = model._get_cell_border("D4");
|
||||
assert_eq!(border.top, Some(border_item.clone()));
|
||||
assert_eq!(border.right, Some(border_item.clone()));
|
||||
assert_eq!(border.bottom, Some(border_item.clone()));
|
||||
assert_eq!(border.left, Some(border_item.clone()));
|
||||
|
||||
// E5
|
||||
let border_e5 = model._get_cell_border("E5");
|
||||
assert_eq!(border_e5.left, Some(border_item.clone()));
|
||||
|
||||
// but it hasn't really changed
|
||||
let border_item = BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#F4F4F4".to_string()),
|
||||
};
|
||||
let border_e5_actual = model._get_cell_actual_border("E5");
|
||||
assert_eq!(border_e5_actual.left, Some(border_item.clone()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn border_top() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
|
||||
model._set_area_border("C4:F6", "#000000", "All");
|
||||
|
||||
// We set all with a lighter color in the top
|
||||
model._set_area_border("C4:F6", "#F2F2F2", "Top");
|
||||
|
||||
// C3 doesn't have a border in the bottom
|
||||
assert_eq!(model._get_cell_actual_border("C3").bottom, None);
|
||||
|
||||
// But C4 was changed
|
||||
let border_item = BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#F2F2F2".to_string()),
|
||||
};
|
||||
assert_eq!(
|
||||
model._get_cell_actual_border("C4").bottom,
|
||||
Some(border_item)
|
||||
);
|
||||
|
||||
model.undo().unwrap();
|
||||
|
||||
// This tests that diff lists go in the right order
|
||||
let border_item = BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#000000".to_string()),
|
||||
};
|
||||
assert_eq!(model._get_cell_actual_border("C4").top, Some(border_item));
|
||||
}
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{
|
||||
constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT},
|
||||
test::util::new_empty_model,
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{expressions::types::Area, UserModel};
|
||||
|
||||
#[test]
|
||||
@@ -7,7 +9,7 @@ fn csv_paste() {
|
||||
assert_eq!(model.get_formatted_cell_value(0, 7, 7), Ok("0".to_string()));
|
||||
|
||||
// paste some numbers in B4:C7
|
||||
let csv = "1,2,3\n4,5,6";
|
||||
let csv = "1\t2\t3\n4\t5\t6";
|
||||
let area = Area {
|
||||
sheet: 0,
|
||||
row: 4,
|
||||
@@ -24,6 +26,27 @@ fn csv_paste() {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn csv_paste_formula() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
|
||||
let csv = "=YEAR(TODAY())";
|
||||
let area = Area {
|
||||
sheet: 0,
|
||||
row: 1,
|
||||
column: 1,
|
||||
width: 1,
|
||||
height: 1,
|
||||
};
|
||||
model.set_selected_cell(1, 1).unwrap();
|
||||
model.paste_csv_string(&area, csv).unwrap();
|
||||
|
||||
assert_eq!(
|
||||
model.get_formatted_cell_value(0, 1, 1),
|
||||
Ok("2022".to_string())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tsv_crlf_paste() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
@@ -65,7 +88,7 @@ fn cut_paste() {
|
||||
model.update_range_style(&range, "font.b", "true").unwrap();
|
||||
|
||||
model
|
||||
.set_user_input(0, 2, 1, "A season of faith, \"perfection\"")
|
||||
.set_user_input(0, 2, 1, "A season of faith\t \"perfection\"")
|
||||
.unwrap();
|
||||
|
||||
// Select A1:B2 and copy
|
||||
@@ -113,7 +136,7 @@ fn copy_paste_internal() {
|
||||
model.update_range_style(&range, "font.b", "true").unwrap();
|
||||
|
||||
model
|
||||
.set_user_input(0, 2, 1, "A season of faith, \"perfection\"")
|
||||
.set_user_input(0, 2, 1, "A season of faith\t \"perfection\"")
|
||||
.unwrap();
|
||||
|
||||
// Select A1:B2 and copy
|
||||
@@ -121,7 +144,7 @@ fn copy_paste_internal() {
|
||||
let copy = model.copy_to_clipboard().unwrap();
|
||||
assert_eq!(
|
||||
copy.csv,
|
||||
"42,127\n\"A season of faith, \"\"perfection\"\"\",\n"
|
||||
"42\t127\n\"A season of faith\t \"\"perfection\"\"\"\t\n"
|
||||
);
|
||||
assert_eq!(copy.range, (1, 1, 2, 2));
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
use crate::{
|
||||
expressions::types::Area,
|
||||
types::{Alignment, BorderItem, BorderStyle, HorizontalAlignment, VerticalAlignment},
|
||||
types::{Alignment, HorizontalAlignment, VerticalAlignment},
|
||||
UserModel,
|
||||
};
|
||||
|
||||
@@ -229,157 +229,6 @@ fn basic_format() {
|
||||
assert_eq!(style.num_fmt, "$#,##0.0000");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn basic_borders() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
let range = Area {
|
||||
sheet: 0,
|
||||
row: 1,
|
||||
column: 1,
|
||||
width: 1,
|
||||
height: 1,
|
||||
};
|
||||
|
||||
model
|
||||
.update_range_style(&range, "border.left", "thin,#F1F1F1")
|
||||
.unwrap();
|
||||
let style = model.get_cell_style(0, 1, 1).unwrap();
|
||||
assert_eq!(
|
||||
style.border.left,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#F1F1F1".to_owned()),
|
||||
})
|
||||
);
|
||||
|
||||
model
|
||||
.update_range_style(&range, "border.left", "thin,")
|
||||
.unwrap();
|
||||
let style = model.get_cell_style(0, 1, 1).unwrap();
|
||||
assert_eq!(
|
||||
style.border.left,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: None,
|
||||
})
|
||||
);
|
||||
|
||||
model
|
||||
.update_range_style(&range, "border.right", "dotted,#F1F1F2")
|
||||
.unwrap();
|
||||
let style = model.get_cell_style(0, 1, 1).unwrap();
|
||||
assert_eq!(
|
||||
style.border.right,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::Dotted,
|
||||
color: Some("#F1F1F2".to_owned()),
|
||||
})
|
||||
);
|
||||
|
||||
model
|
||||
.update_range_style(&range, "border.top", "double,#F1F1F3")
|
||||
.unwrap();
|
||||
let style = model.get_cell_style(0, 1, 1).unwrap();
|
||||
assert_eq!(
|
||||
style.border.top,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::Double,
|
||||
color: Some("#F1F1F3".to_owned()),
|
||||
})
|
||||
);
|
||||
|
||||
model
|
||||
.update_range_style(&range, "border.bottom", "medium,#F1F1F4")
|
||||
.unwrap();
|
||||
let style = model.get_cell_style(0, 1, 1).unwrap();
|
||||
assert_eq!(
|
||||
style.border.bottom,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::Medium,
|
||||
color: Some("#F1F1F4".to_owned()),
|
||||
})
|
||||
);
|
||||
|
||||
while model.can_undo() {
|
||||
model.undo().unwrap();
|
||||
}
|
||||
|
||||
let style = model.get_cell_style(0, 1, 1).unwrap();
|
||||
assert_eq!(style.border.left, None);
|
||||
assert_eq!(style.border.top, None);
|
||||
assert_eq!(style.border.right, None);
|
||||
assert_eq!(style.border.bottom, None);
|
||||
|
||||
while model.can_redo() {
|
||||
model.redo().unwrap();
|
||||
}
|
||||
|
||||
let style = model.get_cell_style(0, 1, 1).unwrap();
|
||||
assert_eq!(
|
||||
style.border.left,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: None,
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
style.border.right,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::Dotted,
|
||||
color: Some("#F1F1F2".to_owned()),
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
style.border.top,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::Double,
|
||||
color: Some("#F1F1F3".to_owned()),
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
style.border.bottom,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::Medium,
|
||||
color: Some("#F1F1F4".to_owned()),
|
||||
})
|
||||
);
|
||||
|
||||
let send_queue = model.flush_send_queue();
|
||||
|
||||
let mut model2 = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
model2.apply_external_diffs(&send_queue).unwrap();
|
||||
|
||||
let style = model2.get_cell_style(0, 1, 1).unwrap();
|
||||
assert_eq!(
|
||||
style.border.left,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: None,
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
style.border.right,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::Dotted,
|
||||
color: Some("#F1F1F2".to_owned()),
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
style.border.top,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::Double,
|
||||
color: Some("#F1F1F3".to_owned()),
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
style.border.bottom,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::Medium,
|
||||
color: Some("#F1F1F4".to_owned()),
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn basic_alignment() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
@@ -567,142 +416,6 @@ fn basic_wrap_text() {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn more_basic_borders() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
let range = Area {
|
||||
sheet: 0,
|
||||
row: 1,
|
||||
column: 1,
|
||||
width: 1,
|
||||
height: 1,
|
||||
};
|
||||
|
||||
model
|
||||
.update_range_style(&range, "border.left", "thick,#F1F1F1")
|
||||
.unwrap();
|
||||
let style = model.get_cell_style(0, 1, 1).unwrap();
|
||||
assert_eq!(
|
||||
style.border.left,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::Thick,
|
||||
color: Some("#F1F1F1".to_owned()),
|
||||
})
|
||||
);
|
||||
|
||||
model
|
||||
.update_range_style(&range, "border.left", "slantDashDot,#F1F1F1")
|
||||
.unwrap();
|
||||
let style = model.get_cell_style(0, 1, 1).unwrap();
|
||||
assert_eq!(
|
||||
style.border.left,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::SlantDashDot,
|
||||
color: Some("#F1F1F1".to_owned()),
|
||||
})
|
||||
);
|
||||
|
||||
model
|
||||
.update_range_style(&range, "border.left", "mediumDashDot,#F1F1F1")
|
||||
.unwrap();
|
||||
let style = model.get_cell_style(0, 1, 1).unwrap();
|
||||
assert_eq!(
|
||||
style.border.left,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::MediumDashDot,
|
||||
color: Some("#F1F1F1".to_owned()),
|
||||
})
|
||||
);
|
||||
|
||||
model
|
||||
.update_range_style(&range, "border.left", "mediumDashDotDot,#F1F1F1")
|
||||
.unwrap();
|
||||
let style = model.get_cell_style(0, 1, 1).unwrap();
|
||||
assert_eq!(
|
||||
style.border.left,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::MediumDashDotDot,
|
||||
color: Some("#F1F1F1".to_owned()),
|
||||
})
|
||||
);
|
||||
|
||||
model
|
||||
.update_range_style(&range, "border.left", "mediumDashed,#F1F1F1")
|
||||
.unwrap();
|
||||
let style = model.get_cell_style(0, 1, 1).unwrap();
|
||||
assert_eq!(
|
||||
style.border.left,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::MediumDashed,
|
||||
color: Some("#F1F1F1".to_owned()),
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn border_errors() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
let range = Area {
|
||||
sheet: 0,
|
||||
row: 1,
|
||||
column: 1,
|
||||
width: 1,
|
||||
height: 1,
|
||||
};
|
||||
|
||||
assert_eq!(
|
||||
model.update_range_style(&range, "border.lef", "thick,#F1F1F1"),
|
||||
Err("Invalid style path: 'border.lef'.".to_string())
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
model.update_range_style(&range, "border.left", "thic,#F1F1F1"),
|
||||
Err("Invalid border style: 'thic'.".to_string())
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
model.update_range_style(&range, "border.left", "thick,#F1F1F"),
|
||||
Err("Invalid color: '#F1F1F'.".to_string())
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
model.update_range_style(&range, "border.left", " "),
|
||||
Err("Invalid border value: ' '.".to_string())
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
model.update_range_style(&range, "border.left", "thick,#F1F1F1,thin"),
|
||||
Err("Invalid border value: 'thick,#F1F1F1,thin'.".to_string())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn empty_removes_border() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
let range = Area {
|
||||
sheet: 0,
|
||||
row: 1,
|
||||
column: 1,
|
||||
width: 1,
|
||||
height: 1,
|
||||
};
|
||||
model
|
||||
.update_range_style(&range, "border.left", "mediumDashDotDot,#F1F1F1")
|
||||
.unwrap();
|
||||
let style = model.get_cell_style(0, 1, 1).unwrap();
|
||||
assert_eq!(
|
||||
style.border.left,
|
||||
Some(BorderItem {
|
||||
style: BorderStyle::MediumDashDotDot,
|
||||
color: Some("#F1F1F1".to_owned()),
|
||||
})
|
||||
);
|
||||
|
||||
model.update_range_style(&range, "border.left", "").unwrap();
|
||||
let style = model.get_cell_style(0, 1, 1).unwrap();
|
||||
assert_eq!(style.border.left, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn false_removes_value() {
|
||||
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
|
||||
|
||||
75
base/src/test/user_model/util.rs
Normal file
75
base/src/test/user_model/util.rs
Normal file
@@ -0,0 +1,75 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{expressions::types::Area, types::Border, BorderArea, UserModel};
|
||||
|
||||
impl UserModel {
|
||||
pub fn _set_cell_border(&mut self, cell: &str, color: &str) {
|
||||
let cell_reference = self.model._parse_reference(cell);
|
||||
let column = cell_reference.column;
|
||||
let row = cell_reference.row;
|
||||
let border_area: BorderArea = serde_json::from_str(&format!(
|
||||
r##"{{
|
||||
"item": {{
|
||||
"style": "thin",
|
||||
"color": "{}"
|
||||
}},
|
||||
"type": "All"
|
||||
}}"##,
|
||||
color
|
||||
))
|
||||
.unwrap();
|
||||
let range = &Area {
|
||||
sheet: 0,
|
||||
row,
|
||||
column,
|
||||
width: 1,
|
||||
height: 1,
|
||||
};
|
||||
self.set_area_with_border(range, &border_area).unwrap();
|
||||
}
|
||||
|
||||
pub fn _set_area_border(&mut self, range: &str, color: &str, kind: &str) {
|
||||
let s: Vec<&str> = range.split(':').collect();
|
||||
let left = self.model._parse_reference(s[0]);
|
||||
let right = self.model._parse_reference(s[1]);
|
||||
let column = left.column;
|
||||
let row = left.row;
|
||||
let width = right.column - column + 1;
|
||||
let height = right.row - row + 1;
|
||||
let border_area: BorderArea = serde_json::from_str(&format!(
|
||||
r##"{{
|
||||
"item": {{
|
||||
"style": "thin",
|
||||
"color": "{}"
|
||||
}},
|
||||
"type": "{}"
|
||||
}}"##,
|
||||
color, kind
|
||||
))
|
||||
.unwrap();
|
||||
let range = &Area {
|
||||
sheet: 0,
|
||||
row,
|
||||
column,
|
||||
width,
|
||||
height,
|
||||
};
|
||||
self.set_area_with_border(range, &border_area).unwrap();
|
||||
}
|
||||
|
||||
pub fn _get_cell_border(&self, cell: &str) -> Border {
|
||||
let cell_reference = self.model._parse_reference(cell);
|
||||
let column = cell_reference.column;
|
||||
let row = cell_reference.row;
|
||||
let style = self.get_cell_style(0, row, column).unwrap();
|
||||
style.border
|
||||
}
|
||||
|
||||
pub fn _get_cell_actual_border(&self, cell: &str) -> Border {
|
||||
let cell_reference = self.model._parse_reference(cell);
|
||||
let column = cell_reference.column;
|
||||
let row = cell_reference.row;
|
||||
let style = self.model.get_style_for_cell(0, row, column).unwrap();
|
||||
style.border
|
||||
}
|
||||
}
|
||||
@@ -9,7 +9,7 @@ pub fn new_empty_model() -> Model {
|
||||
}
|
||||
|
||||
impl Model {
|
||||
fn _parse_reference(&self, cell: &str) -> CellReferenceIndex {
|
||||
pub fn _parse_reference(&self, cell: &str) -> CellReferenceIndex {
|
||||
if cell.contains('!') {
|
||||
self.parse_reference(cell).unwrap()
|
||||
} else {
|
||||
|
||||
@@ -3,6 +3,7 @@ use serde::{Deserialize, Serialize};
|
||||
use std::{collections::HashMap, fmt::Display};
|
||||
|
||||
use crate::expressions::token::Error;
|
||||
use crate::expressions::utils::number_to_column;
|
||||
|
||||
fn default_as_false() -> bool {
|
||||
false
|
||||
@@ -110,7 +111,7 @@ pub struct Worksheet {
|
||||
pub sheet_id: u32,
|
||||
pub state: SheetState,
|
||||
pub color: Option<String>,
|
||||
pub merge_cells: Vec<String>,
|
||||
pub merged_cells_list: Vec<MergedCells>,
|
||||
pub comments: Vec<Comment>,
|
||||
pub frozen_rows: i32,
|
||||
pub frozen_columns: i32,
|
||||
@@ -351,6 +352,43 @@ pub enum FontScheme {
|
||||
None,
|
||||
}
|
||||
|
||||
// MergedCells type
|
||||
// There will be one MergedCells struct maintained for every Merged cells that we load
|
||||
// merge_cell_range : Its tuple having [row_start, column_start, row_end, column_end]
|
||||
#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
|
||||
pub struct MergedCells(pub i32, pub i32, pub i32, pub i32);
|
||||
|
||||
// implementing accessor function
|
||||
impl MergedCells {
|
||||
// Method which returns range_ref from the tuple
|
||||
// ex : (3,1,4,2) is interpreted as A3:B4
|
||||
pub fn get_merged_cells_str_ref(&self) -> Result<String, String> {
|
||||
let start_column = number_to_column(self.1).ok_or(format!(
|
||||
"Error while converting column start {} number to column string ref",
|
||||
self.1
|
||||
))?;
|
||||
let end_column = number_to_column(self.3).ok_or(format!(
|
||||
"Error while converting column end {} number to column string ref",
|
||||
self.3
|
||||
))?;
|
||||
return Ok(start_column
|
||||
+ &self.0.to_string()
|
||||
+ &":".to_string()
|
||||
+ &end_column
|
||||
+ &self.2.to_string());
|
||||
}
|
||||
|
||||
// Only Public function where Merge cell can be created
|
||||
pub fn new(merge_cell_parsed_range: (i32, i32, i32, i32)) -> Self {
|
||||
Self(
|
||||
merge_cell_parsed_range.0,
|
||||
merge_cell_parsed_range.1,
|
||||
merge_cell_parsed_range.2,
|
||||
merge_cell_parsed_range.3,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl Display for FontScheme {
|
||||
fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
|
||||
match self {
|
||||
@@ -578,7 +616,7 @@ impl Default for CellStyles {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
|
||||
#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, PartialOrd, Clone)]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
pub enum BorderStyle {
|
||||
Thin,
|
||||
|
||||
137
base/src/user_model/border_utils.rs
Normal file
137
base/src/user_model/border_utils.rs
Normal file
@@ -0,0 +1,137 @@
|
||||
use crate::types::BorderItem;
|
||||
|
||||
fn parse_color(s: &str) -> Option<(u8, u8, u8)> {
|
||||
let s = s.trim_start_matches('#');
|
||||
match s.len() {
|
||||
6 => {
|
||||
let r = u8::from_str_radix(&s[0..2], 16).ok()?;
|
||||
let g = u8::from_str_radix(&s[2..4], 16).ok()?;
|
||||
let b = u8::from_str_radix(&s[4..6], 16).ok()?;
|
||||
Some((r, g, b))
|
||||
}
|
||||
3 => {
|
||||
let r = u8::from_str_radix(&s[0..1], 16).ok()?;
|
||||
let g = u8::from_str_radix(&s[1..2], 16).ok()?;
|
||||
let b = u8::from_str_radix(&s[2..3], 16).ok()?;
|
||||
// Expand single hex digits to full bytes
|
||||
Some((r * 17, g * 17, b * 17))
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn compute_luminance(r: u8, g: u8, b: u8) -> f64 {
|
||||
// Normalize RGB values to [0, 1]
|
||||
let r = r as f64 / 255.0;
|
||||
let g = g as f64 / 255.0;
|
||||
let b = b as f64 / 255.0;
|
||||
// Calculate luminance using the Rec. 601 formula
|
||||
0.299 * r + 0.587 * g + 0.114 * b
|
||||
}
|
||||
|
||||
fn is_max_color(a: &str, b: &str) -> bool {
|
||||
let (ar, ag, ab) = match parse_color(a) {
|
||||
Some(rgb) => rgb,
|
||||
None => return false, // Invalid color format for 'a'
|
||||
};
|
||||
|
||||
let (br, bg, bb) = match parse_color(b) {
|
||||
Some(rgb) => rgb,
|
||||
None => return false, // Invalid color format for 'b'
|
||||
};
|
||||
|
||||
let luminance_a = compute_luminance(ar, ag, ab);
|
||||
let luminance_b = compute_luminance(br, bg, bb);
|
||||
|
||||
// 'b' is heavier if its luminance is less than 'a's luminance
|
||||
luminance_b < luminance_a
|
||||
}
|
||||
|
||||
/// Is border b "heavier" than a?
|
||||
pub(crate) fn is_max_border(a: Option<&BorderItem>, b: Option<&BorderItem>) -> bool {
|
||||
match (a, b) {
|
||||
(_, None) => false,
|
||||
(None, Some(_)) => true,
|
||||
(Some(item_a), Some(item_b)) => {
|
||||
if item_a.style < item_b.style {
|
||||
return true;
|
||||
} else if item_a.style > item_b.style {
|
||||
return false;
|
||||
}
|
||||
match (&item_a.color, &item_b.color) {
|
||||
(_, None) => false,
|
||||
(None, Some(_)) => true,
|
||||
(Some(color_a), Some(color_b)) => is_max_color(color_a, color_b),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::types::BorderStyle;
|
||||
|
||||
#[test]
|
||||
fn compare_borders() {
|
||||
let b = BorderItem {
|
||||
style: BorderStyle::Thin,
|
||||
color: Some("#FFF".to_string()),
|
||||
};
|
||||
// Some border *always* beats no border
|
||||
assert!(is_max_border(None, Some(&b)));
|
||||
|
||||
// No border is beaten by some border
|
||||
assert!(!is_max_border(Some(&b), None));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn basic_colors() {
|
||||
// Black vs White
|
||||
assert!(is_max_color("#FFFFFF", "#000000"));
|
||||
assert!(!is_max_color("#000000", "#FFFFFF"));
|
||||
|
||||
// Red vs Dark Red
|
||||
assert!(is_max_color("#FF0000", "#800000"));
|
||||
assert!(!is_max_color("#800000", "#FF0000"));
|
||||
|
||||
// Green vs Dark Green
|
||||
assert!(is_max_color("#00FF00", "#008000"));
|
||||
assert!(!is_max_color("#008000", "#00FF00"));
|
||||
|
||||
// Blue vs Dark Blue
|
||||
assert!(is_max_color("#0000FF", "#000080"));
|
||||
assert!(!is_max_color("#000080", "#0000FF"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn same_color() {
|
||||
// Comparing the same color should return false
|
||||
assert!(!is_max_color("#123456", "#123456"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn edge_cases() {
|
||||
// Colors with minimal luminance difference
|
||||
assert!(!is_max_color("#000000", "#010101"));
|
||||
assert!(!is_max_color("#FEFEFE", "#FFFFFF"));
|
||||
assert!(!is_max_color("#7F7F7F", "#808080"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn luminance_ordering() {
|
||||
// Colors with known luminance differences
|
||||
assert!(is_max_color("#CCCCCC", "#333333")); // Light gray vs Day
|
||||
assert!(is_max_color("#FFFF00", "#808000")); // Yellow ve
|
||||
assert!(is_max_color("#FF00FF", "#800080")); // Magenta vle
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn borderline_cases() {
|
||||
// Testing colors with equal luminance
|
||||
assert!(!is_max_color("#777777", "#777777"));
|
||||
|
||||
// Testing black against near-black
|
||||
assert!(!is_max_color("#000000", "#010000"));
|
||||
}
|
||||
}
|
||||
@@ -3,7 +3,6 @@
|
||||
use std::{collections::HashMap, fmt::Debug, io::Cursor};
|
||||
|
||||
use csv::{ReaderBuilder, WriterBuilder};
|
||||
use csv_sniffer::Sniffer;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::{
|
||||
@@ -14,8 +13,8 @@ use crate::{
|
||||
},
|
||||
model::Model,
|
||||
types::{
|
||||
Alignment, BorderItem, BorderStyle, CellType, Col, HorizontalAlignment, SheetProperties,
|
||||
Style, VerticalAlignment,
|
||||
Alignment, BorderItem, CellType, Col, HorizontalAlignment, SheetProperties, Style,
|
||||
VerticalAlignment,
|
||||
},
|
||||
utils::is_valid_hex_color,
|
||||
};
|
||||
@@ -23,6 +22,8 @@ use crate::{
|
||||
use crate::user_model::history::{
|
||||
ColumnData, Diff, DiffList, DiffType, History, QueueDiffs, RowData,
|
||||
};
|
||||
|
||||
use super::border_utils::is_max_border;
|
||||
/// Data for the clipboard
|
||||
pub type ClipboardData = HashMap<i32, HashMap<i32, ClipboardCell>>;
|
||||
|
||||
@@ -80,37 +81,6 @@ fn color(value: &str) -> Result<Option<String>, String> {
|
||||
Ok(Some(value.to_owned()))
|
||||
}
|
||||
|
||||
fn border(value: &str) -> Result<Option<BorderItem>, String> {
|
||||
if value.is_empty() {
|
||||
return Ok(None);
|
||||
}
|
||||
let parts = value.split(',');
|
||||
let values = parts.collect::<Vec<&str>>();
|
||||
match values[..] {
|
||||
[border_style, color_str] => {
|
||||
let style = match border_style {
|
||||
"thin" => BorderStyle::Thin,
|
||||
"medium" => BorderStyle::Medium,
|
||||
"thick" => BorderStyle::Thick,
|
||||
"double" => BorderStyle::Double,
|
||||
"dotted" => BorderStyle::Dotted,
|
||||
"slantDashDot" => BorderStyle::SlantDashDot,
|
||||
"mediumDashed" => BorderStyle::MediumDashed,
|
||||
"mediumDashDotDot" => BorderStyle::MediumDashDotDot,
|
||||
"mediumDashDot" => BorderStyle::MediumDashDot,
|
||||
_ => {
|
||||
return Err(format!("Invalid border style: '{border_style}'."));
|
||||
}
|
||||
};
|
||||
Ok(Some(BorderItem {
|
||||
style,
|
||||
color: color(color_str)?,
|
||||
}))
|
||||
}
|
||||
_ => Err(format!("Invalid border value: '{value}'.")),
|
||||
}
|
||||
}
|
||||
|
||||
fn horizontal(value: &str) -> Result<HorizontalAlignment, String> {
|
||||
match value {
|
||||
"center" => Ok(HorizontalAlignment::Center),
|
||||
@@ -571,7 +541,10 @@ impl UserModel {
|
||||
break;
|
||||
}
|
||||
}
|
||||
let data = worksheet.sheet_data.get(&row).unwrap().clone();
|
||||
let data = match worksheet.sheet_data.get(&row) {
|
||||
Some(s) => s.clone(),
|
||||
None => return Err(format!("Row number '{row}' is not valid.")),
|
||||
};
|
||||
let old_data = Box::new(RowData {
|
||||
row: row_data,
|
||||
data,
|
||||
@@ -790,7 +763,9 @@ impl UserModel {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Sets the border
|
||||
/// Sets the border in an area of cells.
|
||||
/// When setting the border we need to check if the adjacent cells have a "heavier" border
|
||||
/// If that is the case we need to change it
|
||||
pub fn set_area_with_border(
|
||||
&mut self,
|
||||
range: &Area,
|
||||
@@ -803,94 +778,218 @@ impl UserModel {
|
||||
for row in range.row..=last_row {
|
||||
for column in range.column..=last_column {
|
||||
let old_value = self.model.get_style_for_cell(sheet, row, column)?;
|
||||
let mut style = old_value.clone();
|
||||
let mut new_value = old_value.clone();
|
||||
|
||||
match border_area.r#type {
|
||||
BorderType::All => {
|
||||
style.border.top = Some(border_area.item.clone());
|
||||
style.border.right = Some(border_area.item.clone());
|
||||
style.border.bottom = Some(border_area.item.clone());
|
||||
style.border.left = Some(border_area.item.clone());
|
||||
new_value.border.top = Some(border_area.item.clone());
|
||||
new_value.border.right = Some(border_area.item.clone());
|
||||
new_value.border.bottom = Some(border_area.item.clone());
|
||||
new_value.border.left = Some(border_area.item.clone());
|
||||
}
|
||||
BorderType::Inner => {
|
||||
if row != range.row {
|
||||
style.border.top = Some(border_area.item.clone());
|
||||
new_value.border.top = Some(border_area.item.clone());
|
||||
}
|
||||
if row != last_row {
|
||||
style.border.bottom = Some(border_area.item.clone());
|
||||
new_value.border.bottom = Some(border_area.item.clone());
|
||||
}
|
||||
if column != range.column {
|
||||
style.border.left = Some(border_area.item.clone());
|
||||
new_value.border.left = Some(border_area.item.clone());
|
||||
}
|
||||
if column != last_column {
|
||||
style.border.right = Some(border_area.item.clone());
|
||||
new_value.border.right = Some(border_area.item.clone());
|
||||
}
|
||||
}
|
||||
BorderType::Outer => {
|
||||
if row == range.row {
|
||||
style.border.top = Some(border_area.item.clone());
|
||||
new_value.border.top = Some(border_area.item.clone());
|
||||
}
|
||||
if row == last_row {
|
||||
style.border.bottom = Some(border_area.item.clone());
|
||||
new_value.border.bottom = Some(border_area.item.clone());
|
||||
}
|
||||
if column == range.column {
|
||||
style.border.left = Some(border_area.item.clone());
|
||||
new_value.border.left = Some(border_area.item.clone());
|
||||
}
|
||||
if column == last_column {
|
||||
style.border.right = Some(border_area.item.clone());
|
||||
new_value.border.right = Some(border_area.item.clone());
|
||||
}
|
||||
}
|
||||
BorderType::Top => {
|
||||
new_value.border.top = Some(border_area.item.clone());
|
||||
// Check if the cell above has a "heavier" bottom border
|
||||
if row > 1 {
|
||||
let old_value_cell_above =
|
||||
self.model.get_style_for_cell(sheet, row - 1, column)?;
|
||||
if is_max_border(
|
||||
Some(&border_area.item),
|
||||
old_value_cell_above.border.bottom.as_ref(),
|
||||
) {
|
||||
let mut new_value_cell_above = old_value_cell_above.clone();
|
||||
if border_area.r#type == BorderType::None {
|
||||
new_value_cell_above.border.bottom = None;
|
||||
} else {
|
||||
new_value_cell_above.border.bottom =
|
||||
Some(border_area.item.clone());
|
||||
}
|
||||
self.model.set_cell_style(
|
||||
sheet,
|
||||
row - 1,
|
||||
column,
|
||||
&new_value_cell_above,
|
||||
)?;
|
||||
diff_list.push(Diff::SetCellStyle {
|
||||
sheet,
|
||||
row: row - 1,
|
||||
column,
|
||||
old_value: Box::new(old_value_cell_above),
|
||||
new_value: Box::new(new_value_cell_above),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
BorderType::Right => {
|
||||
new_value.border.right = Some(border_area.item.clone());
|
||||
// Check if the cell to the right has a "heavier" left border
|
||||
if column < LAST_COLUMN {
|
||||
let old_value_cell_right =
|
||||
self.model.get_style_for_cell(sheet, row, column + 1)?;
|
||||
if is_max_border(
|
||||
Some(&border_area.item),
|
||||
old_value_cell_right.border.left.as_ref(),
|
||||
) {
|
||||
let mut new_value_cell_right = old_value_cell_right.clone();
|
||||
if border_area.r#type == BorderType::None {
|
||||
new_value_cell_right.border.left = None;
|
||||
} else {
|
||||
new_value_cell_right.border.left =
|
||||
Some(border_area.item.clone());
|
||||
}
|
||||
self.model.set_cell_style(
|
||||
sheet,
|
||||
row,
|
||||
column + 1,
|
||||
&new_value_cell_right,
|
||||
)?;
|
||||
diff_list.push(Diff::SetCellStyle {
|
||||
sheet,
|
||||
row,
|
||||
column: column + 1,
|
||||
old_value: Box::new(old_value_cell_right),
|
||||
new_value: Box::new(new_value_cell_right),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
BorderType::Bottom => {
|
||||
new_value.border.bottom = Some(border_area.item.clone());
|
||||
// Check if the cell bellow has a "heavier" top border
|
||||
if row < LAST_ROW {
|
||||
let old_value_cell_below =
|
||||
self.model.get_style_for_cell(sheet, row + 1, column)?;
|
||||
if is_max_border(
|
||||
Some(&border_area.item),
|
||||
old_value_cell_below.border.top.as_ref(),
|
||||
) {
|
||||
let mut new_value_cell_below = old_value_cell_below.clone();
|
||||
if border_area.r#type == BorderType::None {
|
||||
new_value_cell_below.border.top = None;
|
||||
} else {
|
||||
new_value_cell_below.border.top =
|
||||
Some(border_area.item.clone());
|
||||
}
|
||||
self.model.set_cell_style(
|
||||
sheet,
|
||||
row + 1,
|
||||
column,
|
||||
&new_value_cell_below,
|
||||
)?;
|
||||
diff_list.push(Diff::SetCellStyle {
|
||||
sheet,
|
||||
row: row + 1,
|
||||
column,
|
||||
old_value: Box::new(old_value_cell_below),
|
||||
new_value: Box::new(new_value_cell_below),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
BorderType::Left => {
|
||||
new_value.border.left = Some(border_area.item.clone());
|
||||
// Check if the cell to the left has a "heavier" right border
|
||||
if column > 1 {
|
||||
let old_value_cell_left =
|
||||
self.model.get_style_for_cell(sheet, row, column - 1)?;
|
||||
if is_max_border(
|
||||
Some(&border_area.item),
|
||||
old_value_cell_left.border.right.as_ref(),
|
||||
) {
|
||||
let mut new_value_cell_left = old_value_cell_left.clone();
|
||||
if border_area.r#type == BorderType::None {
|
||||
new_value_cell_left.border.right = None;
|
||||
} else {
|
||||
new_value_cell_left.border.right =
|
||||
Some(border_area.item.clone());
|
||||
}
|
||||
self.model.set_cell_style(
|
||||
sheet,
|
||||
row,
|
||||
column - 1,
|
||||
&new_value_cell_left,
|
||||
)?;
|
||||
diff_list.push(Diff::SetCellStyle {
|
||||
sheet,
|
||||
row,
|
||||
column: column - 1,
|
||||
old_value: Box::new(old_value_cell_left),
|
||||
new_value: Box::new(new_value_cell_left),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
BorderType::Top => style.border.top = Some(border_area.item.clone()),
|
||||
BorderType::Right => style.border.right = Some(border_area.item.clone()),
|
||||
BorderType::Bottom => style.border.bottom = Some(border_area.item.clone()),
|
||||
BorderType::Left => style.border.left = Some(border_area.item.clone()),
|
||||
BorderType::CenterH => {
|
||||
if row != range.row {
|
||||
style.border.top = Some(border_area.item.clone());
|
||||
new_value.border.top = Some(border_area.item.clone());
|
||||
}
|
||||
if row != last_row {
|
||||
style.border.bottom = Some(border_area.item.clone());
|
||||
new_value.border.bottom = Some(border_area.item.clone());
|
||||
}
|
||||
}
|
||||
BorderType::CenterV => {
|
||||
if column != range.column {
|
||||
style.border.left = Some(border_area.item.clone());
|
||||
new_value.border.left = Some(border_area.item.clone());
|
||||
}
|
||||
if column != last_column {
|
||||
style.border.right = Some(border_area.item.clone());
|
||||
new_value.border.right = Some(border_area.item.clone());
|
||||
}
|
||||
}
|
||||
BorderType::None => {
|
||||
style.border.top = None;
|
||||
style.border.right = None;
|
||||
style.border.bottom = None;
|
||||
style.border.left = None;
|
||||
new_value.border.top = None;
|
||||
new_value.border.right = None;
|
||||
new_value.border.bottom = None;
|
||||
new_value.border.left = None;
|
||||
}
|
||||
}
|
||||
|
||||
self.model.set_cell_style(sheet, row, column, &style)?;
|
||||
self.model.set_cell_style(sheet, row, column, &new_value)?;
|
||||
diff_list.push(Diff::SetCellStyle {
|
||||
sheet,
|
||||
row,
|
||||
column,
|
||||
old_value: Box::new(old_value),
|
||||
new_value: Box::new(style),
|
||||
new_value: Box::new(new_value),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// bottom of the cells above the first
|
||||
if range.row > 1
|
||||
&& [
|
||||
BorderType::Top,
|
||||
BorderType::All,
|
||||
BorderType::None,
|
||||
BorderType::Outer,
|
||||
]
|
||||
.contains(&border_area.r#type)
|
||||
&& [BorderType::All, BorderType::None, BorderType::Outer].contains(&border_area.r#type)
|
||||
{
|
||||
let row = range.row - 1;
|
||||
for column in range.column..=last_column {
|
||||
let old_value = self.model.get_style_for_cell(sheet, row, column)?;
|
||||
if is_max_border(Some(&border_area.item), old_value.border.bottom.as_ref()) {
|
||||
let mut style = old_value.clone();
|
||||
if border_area.r#type == BorderType::None {
|
||||
style.border.bottom = None;
|
||||
@@ -907,19 +1006,16 @@ impl UserModel {
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
// Cells to the right
|
||||
if last_column < LAST_COLUMN
|
||||
&& [
|
||||
BorderType::Right,
|
||||
BorderType::All,
|
||||
BorderType::None,
|
||||
BorderType::Outer,
|
||||
]
|
||||
.contains(&border_area.r#type)
|
||||
&& [BorderType::All, BorderType::None, BorderType::Outer].contains(&border_area.r#type)
|
||||
{
|
||||
let column = last_column + 1;
|
||||
for row in range.row..=last_row {
|
||||
let old_value = self.model.get_style_for_cell(sheet, row, column)?;
|
||||
// If the border in the adjacent cell is "heavier" we change it
|
||||
if is_max_border(Some(&border_area.item), old_value.border.left.as_ref()) {
|
||||
let mut style = old_value.clone();
|
||||
if border_area.r#type == BorderType::None {
|
||||
style.border.left = None;
|
||||
@@ -936,19 +1032,15 @@ impl UserModel {
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
// Cells bellow
|
||||
if last_row < LAST_ROW
|
||||
&& [
|
||||
BorderType::Bottom,
|
||||
BorderType::All,
|
||||
BorderType::None,
|
||||
BorderType::Outer,
|
||||
]
|
||||
.contains(&border_area.r#type)
|
||||
&& [BorderType::All, BorderType::None, BorderType::Outer].contains(&border_area.r#type)
|
||||
{
|
||||
let row = last_row + 1;
|
||||
for column in range.column..=last_column {
|
||||
let old_value = self.model.get_style_for_cell(sheet, row, column)?;
|
||||
if is_max_border(Some(&border_area.item), old_value.border.top.as_ref()) {
|
||||
let mut style = old_value.clone();
|
||||
if border_area.r#type == BorderType::None {
|
||||
style.border.top = None;
|
||||
@@ -965,19 +1057,15 @@ impl UserModel {
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
// Cells to the left
|
||||
if range.column > 1
|
||||
&& [
|
||||
BorderType::Left,
|
||||
BorderType::All,
|
||||
BorderType::None,
|
||||
BorderType::Outer,
|
||||
]
|
||||
.contains(&border_area.r#type)
|
||||
&& [BorderType::All, BorderType::None, BorderType::Outer].contains(&border_area.r#type)
|
||||
{
|
||||
let column = range.column - 1;
|
||||
for row in range.row..=last_row {
|
||||
let old_value = self.model.get_style_for_cell(sheet, row, column)?;
|
||||
if is_max_border(Some(&border_area.item), old_value.border.right.as_ref()) {
|
||||
let mut style = old_value.clone();
|
||||
if border_area.r#type == BorderType::None {
|
||||
style.border.right = None;
|
||||
@@ -994,6 +1082,7 @@ impl UserModel {
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
self.push_diff_list(diff_list);
|
||||
Ok(())
|
||||
@@ -1041,18 +1130,6 @@ impl UserModel {
|
||||
"num_fmt" => {
|
||||
value.clone_into(&mut style.num_fmt);
|
||||
}
|
||||
"border.left" => {
|
||||
style.border.left = border(value)?;
|
||||
}
|
||||
"border.right" => {
|
||||
style.border.right = border(value)?;
|
||||
}
|
||||
"border.top" => {
|
||||
style.border.top = border(value)?;
|
||||
}
|
||||
"border.bottom" => {
|
||||
style.border.bottom = border(value)?;
|
||||
}
|
||||
"alignment" => {
|
||||
if !value.is_empty() {
|
||||
return Err(format!("Alignment must be empty, but found: '{value}'."));
|
||||
@@ -1109,11 +1186,69 @@ impl UserModel {
|
||||
|
||||
/// Returns the style for a cell
|
||||
///
|
||||
/// Cells share a border, so the left border of B1 is the right border of A1
|
||||
/// In the object structure the borders of the cells might be difference,
|
||||
/// We always pick the "heaviest" border.
|
||||
///
|
||||
/// See also:
|
||||
/// * [Model::get_style_for_cell]
|
||||
#[inline]
|
||||
pub fn get_cell_style(&self, sheet: u32, row: i32, column: i32) -> Result<Style, String> {
|
||||
self.model.get_style_for_cell(sheet, row, column)
|
||||
let mut style = self.model.get_style_for_cell(sheet, row, column)?;
|
||||
|
||||
// We need to check if the adjacent cells have a "heavier" border
|
||||
let border_top = if row > 1 {
|
||||
self.model
|
||||
.get_style_for_cell(sheet, row - 1, column)?
|
||||
.border
|
||||
.bottom
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let border_right = if column < LAST_COLUMN {
|
||||
self.model
|
||||
.get_style_for_cell(sheet, row, column + 1)?
|
||||
.border
|
||||
.left
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let border_bottom = if row < LAST_ROW {
|
||||
self.model
|
||||
.get_style_for_cell(sheet, row + 1, column)?
|
||||
.border
|
||||
.top
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let border_left = if column > 1 {
|
||||
self.model
|
||||
.get_style_for_cell(sheet, row, column - 1)?
|
||||
.border
|
||||
.right
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
if is_max_border(style.border.top.as_ref(), border_top.as_ref()) {
|
||||
style.border.top = border_top;
|
||||
}
|
||||
|
||||
if is_max_border(style.border.right.as_ref(), border_right.as_ref()) {
|
||||
style.border.right = border_right;
|
||||
}
|
||||
|
||||
if is_max_border(style.border.bottom.as_ref(), border_bottom.as_ref()) {
|
||||
style.border.bottom = border_bottom;
|
||||
}
|
||||
|
||||
if is_max_border(style.border.left.as_ref(), border_left.as_ref()) {
|
||||
style.border.left = border_left;
|
||||
}
|
||||
|
||||
Ok(style)
|
||||
}
|
||||
|
||||
/// Fills the cells from `source_area` until `to_row`.
|
||||
@@ -1222,27 +1357,27 @@ impl UserModel {
|
||||
pub fn auto_fill_columns(&mut self, source_area: &Area, to_column: i32) -> Result<(), String> {
|
||||
let mut diff_list = Vec::new();
|
||||
let sheet = source_area.sheet;
|
||||
let row1 = source_area.row;
|
||||
let column1 = source_area.column;
|
||||
let width1 = source_area.width;
|
||||
let height1 = source_area.height;
|
||||
let first_row = source_area.row;
|
||||
let first_column = source_area.column;
|
||||
let last_column = first_column + source_area.width - 1;
|
||||
let last_row = first_row + source_area.height - 1;
|
||||
|
||||
// Check first all parameters are valid
|
||||
if self.model.workbook.worksheet(sheet).is_err() {
|
||||
return Err(format!("Invalid worksheet index: '{sheet}'"));
|
||||
}
|
||||
|
||||
if !is_valid_column_number(column1) {
|
||||
return Err(format!("Invalid column: '{column1}'"));
|
||||
if !is_valid_column_number(first_column) {
|
||||
return Err(format!("Invalid column: '{first_column}'"));
|
||||
}
|
||||
if !is_valid_row(row1) {
|
||||
return Err(format!("Invalid row: '{row1}'"));
|
||||
if !is_valid_row(first_row) {
|
||||
return Err(format!("Invalid row: '{first_row}'"));
|
||||
}
|
||||
if !is_valid_column_number(column1 + width1 - 1) {
|
||||
return Err(format!("Invalid column: '{}'", column1 + width1 - 1));
|
||||
if !is_valid_column_number(last_column) {
|
||||
return Err(format!("Invalid column: '{}'", last_column));
|
||||
}
|
||||
if !is_valid_row(row1 + height1 - 1) {
|
||||
return Err(format!("Invalid row: '{}'", row1 + height1 - 1));
|
||||
if !is_valid_row(last_row) {
|
||||
return Err(format!("Invalid row: '{}'", last_row));
|
||||
}
|
||||
|
||||
if !is_valid_row(to_column) {
|
||||
@@ -1255,21 +1390,21 @@ impl UserModel {
|
||||
// this is the range of columns we are going to fill
|
||||
let column_range: Vec<i32>;
|
||||
|
||||
if to_column >= column1 + width1 {
|
||||
if to_column > last_column {
|
||||
// we go right, we start from `1 + width` to `to_column`,
|
||||
anchor_column = column1;
|
||||
anchor_column = first_column;
|
||||
sign = 1;
|
||||
column_range = (column1 + width1..to_column + 1).collect();
|
||||
} else if to_column < column1 {
|
||||
column_range = (last_column + 1..to_column + 1).collect();
|
||||
} else if to_column < first_column {
|
||||
// we go left, starting from `column1 - `` all the way to `to_column`
|
||||
anchor_column = column1 + width1 - 1;
|
||||
anchor_column = last_column;
|
||||
sign = -1;
|
||||
column_range = (to_column..column1).rev().collect();
|
||||
column_range = (to_column..first_column).rev().collect();
|
||||
} else {
|
||||
return Err("Invalid parameters for autofill".to_string());
|
||||
}
|
||||
|
||||
for row in row1..row1 + height1 {
|
||||
for row in first_row..=last_row {
|
||||
let mut index = 0;
|
||||
for column_ref in &column_range {
|
||||
let column = *column_ref;
|
||||
@@ -1290,8 +1425,9 @@ impl UserModel {
|
||||
self.model
|
||||
.set_user_input(sheet, row, column, target_value.to_string())?;
|
||||
|
||||
// Compute the new style and set it
|
||||
let new_style = self.model.get_style_for_cell(sheet, row, source_column)?;
|
||||
// Compute the new style and set it
|
||||
|
||||
self.model.set_cell_style(sheet, row, column, &new_style)?;
|
||||
|
||||
// Add the diffs
|
||||
@@ -1302,6 +1438,7 @@ impl UserModel {
|
||||
old_value: Box::new(old_style),
|
||||
new_value: Box::new(new_style),
|
||||
});
|
||||
|
||||
diff_list.push(Diff::SetCellValue {
|
||||
sheet,
|
||||
row,
|
||||
@@ -1310,7 +1447,7 @@ impl UserModel {
|
||||
old_value: Box::new(old_value),
|
||||
});
|
||||
|
||||
index = (index + sign) % width1;
|
||||
index = (index + sign) % source_area.width;
|
||||
}
|
||||
}
|
||||
self.push_diff_list(diff_list);
|
||||
@@ -1349,7 +1486,7 @@ impl UserModel {
|
||||
pub fn copy_to_clipboard(&self) -> Result<Clipboard, String> {
|
||||
let selected_area = self.get_selected_view();
|
||||
let sheet = selected_area.sheet;
|
||||
let mut wtr = WriterBuilder::new().from_writer(vec![]);
|
||||
let mut wtr = WriterBuilder::new().delimiter(b'\t').from_writer(vec![]);
|
||||
|
||||
let mut data = HashMap::new();
|
||||
let [row_start, column_start, row_end, column_end] = selected_area.range;
|
||||
@@ -1359,7 +1496,7 @@ impl UserModel {
|
||||
for column in column_start..=column_end {
|
||||
let text = self.get_formatted_cell_value(sheet, row, column)?;
|
||||
let content = self.get_cell_content(sheet, row, column)?;
|
||||
let style = self.get_cell_style(sheet, row, column)?;
|
||||
let style = self.model.get_style_for_cell(sheet, row, column)?;
|
||||
data_row.insert(
|
||||
column,
|
||||
ClipboardCell {
|
||||
@@ -1369,11 +1506,16 @@ impl UserModel {
|
||||
);
|
||||
text_row.push(text);
|
||||
}
|
||||
wtr.write_record(text_row).unwrap();
|
||||
wtr.write_record(text_row)
|
||||
.map_err(|e| format!("Error while processing csv: {}", e))?;
|
||||
data.insert(row, data_row);
|
||||
}
|
||||
|
||||
let csv = String::from_utf8(wtr.into_inner().unwrap()).unwrap();
|
||||
let csv = String::from_utf8(
|
||||
wtr.into_inner()
|
||||
.map_err(|e| format!("Processing error: '{}'", e))?,
|
||||
)
|
||||
.map_err(|e| format!("Error converting from utf8: '{}'", e))?;
|
||||
|
||||
Ok(Clipboard {
|
||||
csv,
|
||||
@@ -1478,6 +1620,7 @@ impl UserModel {
|
||||
.worksheet(sheet)?
|
||||
.cell(row, column)
|
||||
.cloned();
|
||||
|
||||
diff_list.push(Diff::CellClearContents {
|
||||
sheet,
|
||||
row,
|
||||
@@ -1501,18 +1644,10 @@ impl UserModel {
|
||||
let sheet = area.sheet;
|
||||
let mut row = area.row;
|
||||
let mut column = area.column;
|
||||
// Create a sniffer with default settings
|
||||
let mut sniffer = Sniffer::new();
|
||||
let mut csv_reader = Cursor::new(csv);
|
||||
|
||||
// Sniff the CSV metadata
|
||||
let metadata = sniffer
|
||||
.sniff_reader(&mut csv_reader)
|
||||
.map_err(|_| "Failed")?;
|
||||
// Reset the cursor to the beginning after sniffing
|
||||
csv_reader.set_position(0);
|
||||
let mut reader = ReaderBuilder::new()
|
||||
.delimiter(metadata.dialect.delimiter)
|
||||
.delimiter(b'\t')
|
||||
.has_headers(false)
|
||||
.from_reader(csv_reader);
|
||||
for record in reader.records() {
|
||||
@@ -1572,7 +1707,7 @@ impl UserModel {
|
||||
|
||||
fn apply_undo_diff_list(&mut self, diff_list: &DiffList) -> Result<(), String> {
|
||||
let mut needs_evaluation = false;
|
||||
for diff in diff_list {
|
||||
for diff in diff_list.iter().rev() {
|
||||
match diff {
|
||||
Diff::SetCellValue {
|
||||
sheet,
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
#![deny(missing_docs)]
|
||||
|
||||
mod border_utils;
|
||||
mod common;
|
||||
mod history;
|
||||
mod ui;
|
||||
|
||||
@@ -34,6 +34,7 @@ impl ParsedReference {
|
||||
locale: &Locale,
|
||||
get_sheet_index_by_name: F,
|
||||
) -> Result<ParsedReference, String> {
|
||||
#[allow(clippy::expect_used)]
|
||||
let language = get_language("en").expect("");
|
||||
let mut lexer = Lexer::new(reference, LexerMode::A1, locale, language);
|
||||
|
||||
@@ -151,6 +152,8 @@ pub(crate) fn is_valid_hex_color(color: &str) -> bool {
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#![allow(clippy::expect_used)]
|
||||
|
||||
use super::*;
|
||||
use crate::language::get_language;
|
||||
use crate::locale::{get_locale, Locale};
|
||||
|
||||
@@ -254,6 +254,7 @@ impl Worksheet {
|
||||
/// Changes the height of a row.
|
||||
/// * If the row does not a have a style we add it.
|
||||
/// * If it has we modify the height and make sure it is applied.
|
||||
///
|
||||
/// Fails if column index is outside allowed range.
|
||||
pub fn set_row_height(&mut self, row: i32, height: f64) -> Result<(), String> {
|
||||
if !is_valid_row(row) {
|
||||
@@ -282,6 +283,7 @@ impl Worksheet {
|
||||
/// Changes the width of a column.
|
||||
/// * If the column does not a have a width we simply add it
|
||||
/// * If it has, it might be part of a range and we ned to split the range.
|
||||
///
|
||||
/// Fails if column index is outside allowed range.
|
||||
pub fn set_column_width(&mut self, column: i32, width: f64) -> Result<(), String> {
|
||||
self.set_column_width_and_style(column, width, None)
|
||||
@@ -522,6 +524,23 @@ impl Worksheet {
|
||||
Ok(is_empty)
|
||||
}
|
||||
|
||||
/// Returns true if cell part of Merged Cells.
|
||||
/// First cell of Merged cells block is not considered as part of Merged cells
|
||||
/// Ex : if Merged cells were A1-C3, A1 is not considered as part of Merged cells block
|
||||
pub fn is_part_of_merged_cells(&self, row: i32, column: i32) -> Result<bool, String> {
|
||||
if !is_valid_column_number(column) || !is_valid_row(row) {
|
||||
return Err("Incorrect row or column".to_string());
|
||||
}
|
||||
|
||||
// traverse through Vector of Merged Cells and return (linear search)
|
||||
for merged_cells in &self.merged_cells_list {
|
||||
if merged_cells.is_cell_part_of_merged_cells(row, column) {
|
||||
return Ok(true);
|
||||
}
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
/// It provides convenient method for user navigation in the spreadsheet by jumping to edges.
|
||||
/// Spreadsheet engines usually allow this method of navigation by using CTRL+arrows.
|
||||
/// Behaviour summary:
|
||||
@@ -575,6 +594,16 @@ impl Worksheet {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns mutable reference to Vector of Merged cells list
|
||||
pub fn get_merged_cells_list_mut(&mut self) -> &mut Vec<MergedCells> {
|
||||
&mut self.merged_cells_list
|
||||
}
|
||||
|
||||
/// Returns reference to Vector of Merged cells list
|
||||
pub fn get_merged_cells_list(&self) -> &Vec<MergedCells> {
|
||||
&self.merged_cells_list
|
||||
}
|
||||
}
|
||||
|
||||
struct WalkFoundCells {
|
||||
|
||||
@@ -19,6 +19,3 @@ pyo3 = { version = "0.22.3", features = ["extension-module"] }
|
||||
[features]
|
||||
extension-module = ["pyo3/extension-module"]
|
||||
default = ["extension-module"]
|
||||
|
||||
[tool.maturin]
|
||||
features = ["pyo3/extension-module"]
|
||||
@@ -9,6 +9,14 @@ if [ ! -d "$EXAMPLES_DIR" ]; then
|
||||
exit 1
|
||||
fi
|
||||
|
||||
python -m venv venv
|
||||
source venv/bin/activate
|
||||
# not sure why this is needed
|
||||
pip install patchelf
|
||||
pip install maturin
|
||||
pip install pytest
|
||||
maturin develop
|
||||
|
||||
# Iterate over all Python files in the examples directory
|
||||
for file in "$EXAMPLES_DIR"/*.py; do
|
||||
# Check if there are any Python files
|
||||
|
||||
@@ -208,12 +208,13 @@ impl PyModel {
|
||||
.map_err(|e| WorkbookError::new_err(e.to_string()))
|
||||
}
|
||||
|
||||
#[allow(clippy::panic)]
|
||||
pub fn test_panic(&self) -> PyResult<()> {
|
||||
panic!("This function panics for testing panic handling");
|
||||
}
|
||||
}
|
||||
|
||||
/// Create methods
|
||||
// Create methods
|
||||
|
||||
/// Loads a function from an xlsx file
|
||||
#[pyfunction]
|
||||
@@ -240,6 +241,7 @@ pub fn create(name: &str, locale: &str, tz: &str) -> PyResult<PyModel> {
|
||||
}
|
||||
|
||||
#[pyfunction]
|
||||
#[allow(clippy::panic)]
|
||||
pub fn test_panic() {
|
||||
panic!("This function panics for testing panic handling");
|
||||
}
|
||||
|
||||
@@ -14,7 +14,7 @@ crate-type = ["cdylib"]
|
||||
# Uses `../ironcalc/base` when used locally, and uses
|
||||
# the inicated version from crates.io when published.
|
||||
# https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#multiple-locations
|
||||
ironcalc_base = { path = "../../base", version = "0.2" }
|
||||
ironcalc_base = { path = "../../base", version = "0.2", features = ["use_regex_lite"] }
|
||||
serde = { version = "1.0", features = ["derive"] }
|
||||
wasm-bindgen = "0.2.92"
|
||||
serde-wasm-bindgen = "0.4"
|
||||
|
||||
@@ -274,15 +274,18 @@ impl Model {
|
||||
row: i32,
|
||||
column: i32,
|
||||
) -> Result<JsValue, JsError> {
|
||||
self.model
|
||||
let style = self
|
||||
.model
|
||||
.get_cell_style(sheet, row, column)
|
||||
.map_err(to_js_error)
|
||||
.map(|x| serde_wasm_bindgen::to_value(&x).unwrap())
|
||||
.map_err(to_js_error)?;
|
||||
|
||||
serde_wasm_bindgen::to_value(&style).map_err(|e| to_js_error(e.to_string()))
|
||||
}
|
||||
|
||||
#[wasm_bindgen(js_name = "onPasteStyles")]
|
||||
pub fn on_paste_styles(&mut self, styles: JsValue) -> Result<(), JsError> {
|
||||
let styles: &Vec<Vec<Style>> = &serde_wasm_bindgen::from_value(styles).unwrap();
|
||||
let styles: &Vec<Vec<Style>> =
|
||||
&serde_wasm_bindgen::from_value(styles).map_err(|e| to_js_error(e.to_string()))?;
|
||||
self.model.on_paste_styles(styles).map_err(to_js_error)
|
||||
}
|
||||
|
||||
@@ -304,7 +307,10 @@ impl Model {
|
||||
)
|
||||
}
|
||||
|
||||
// I don't _think_ serializing to JsValue can't fail
|
||||
// FIXME: Remove this clippy directive
|
||||
#[wasm_bindgen(js_name = "getWorksheetsProperties")]
|
||||
#[allow(clippy::unwrap_used)]
|
||||
pub fn get_worksheets_properties(&self) -> JsValue {
|
||||
serde_wasm_bindgen::to_value(&self.model.get_worksheets_properties()).unwrap()
|
||||
}
|
||||
@@ -320,7 +326,10 @@ impl Model {
|
||||
vec![sheet as i32, row, column]
|
||||
}
|
||||
|
||||
// I don't _think_ serializing to JsValue can't fail
|
||||
// FIXME: Remove this clippy directive
|
||||
#[wasm_bindgen(js_name = "getSelectedView")]
|
||||
#[allow(clippy::unwrap_used)]
|
||||
pub fn get_selected_view(&self) -> JsValue {
|
||||
serde_wasm_bindgen::to_value(&self.model.get_selected_view()).unwrap()
|
||||
}
|
||||
@@ -503,8 +512,9 @@ impl Model {
|
||||
let data = self
|
||||
.model
|
||||
.copy_to_clipboard()
|
||||
.map_err(|e| to_js_error(e.to_string()));
|
||||
data.map(|x| serde_wasm_bindgen::to_value(&x).unwrap())
|
||||
.map_err(|e| to_js_error(e.to_string()))?;
|
||||
|
||||
serde_wasm_bindgen::to_value(&data).map_err(|e| to_js_error(e.to_string()))
|
||||
}
|
||||
|
||||
#[wasm_bindgen(js_name = "pasteFromClipboard")]
|
||||
|
||||
@@ -143,10 +143,12 @@ export enum BorderStyle {
|
||||
Thin = "thin",
|
||||
Medium = "medium",
|
||||
Thick = "thick",
|
||||
Dashed = "dashed",
|
||||
Dotted = "dotted",
|
||||
Double = "double",
|
||||
None = "none",
|
||||
Dotted = "dotted",
|
||||
SlantDashDot = "slantdashdot",
|
||||
MediumDashed = "mediumdashed",
|
||||
MediumDashDotDot = "mediumdashdotdot",
|
||||
MediumDashDot = "mediumdashdot",
|
||||
}
|
||||
|
||||
interface BorderItem {
|
||||
|
||||
3
docs/.gitignore
vendored
Normal file
3
docs/.gitignore
vendored
Normal file
@@ -0,0 +1,3 @@
|
||||
src/.vitepress/cache/*
|
||||
src/.vitepress/dist/*
|
||||
node_modules/*
|
||||
40
docs/README.md
Normal file
40
docs/README.md
Normal file
@@ -0,0 +1,40 @@
|
||||
# IronCalc Docs
|
||||
|
||||
This repository contains IronCalc's end-user documentation. Here, you can explore supported features, functions, and more.
|
||||
|
||||
## Prerequisites
|
||||
|
||||
To manage the documentation, we use [VitePress](https://vitepress.dev/guide/what-is-vitepress), a Static Site Generator (SSG).
|
||||
|
||||
First, ensure you have [nodejs](https://nodejs.org/) installed in your system.
|
||||
|
||||
## Installation
|
||||
|
||||
Start installing the required dependencies by changing directory to the _docs_ folder of the IronCalc repository and running the following command in your terminal:
|
||||
|
||||
```bash
|
||||
npm install
|
||||
```
|
||||
|
||||
## Running the Project
|
||||
|
||||
Start a development instance of the documentation server with:
|
||||
|
||||
```bash
|
||||
npm run dev
|
||||
```
|
||||
|
||||
After running the command, you can view the documentation in your browser at http://localhost:5173 if the port is available.
|
||||
Making changes to the Markdown will automatically reload your browser.
|
||||
|
||||
|
||||
## Build the Project
|
||||
|
||||
To deploy the project:
|
||||
|
||||
```bash
|
||||
npm run build
|
||||
```
|
||||
|
||||
The project will be build in `src/.vitepress/dist`
|
||||
|
||||
2719
docs/package-lock.json
generated
Normal file
2719
docs/package-lock.json
generated
Normal file
File diff suppressed because it is too large
Load Diff
12
docs/package.json
Normal file
12
docs/package.json
Normal file
@@ -0,0 +1,12 @@
|
||||
{
|
||||
"scripts": {
|
||||
"dev": "vitepress dev src",
|
||||
"build": "vitepress build src",
|
||||
"preview": "vitepress preview src"
|
||||
},
|
||||
"devDependencies": {
|
||||
"markdown-it-mathjax3": "^4.3.2",
|
||||
"vitepress": "^1.5.0",
|
||||
"vue": "^3.5.12"
|
||||
}
|
||||
}
|
||||
2042
docs/src/.vitepress/config.mts
Normal file
2042
docs/src/.vitepress/config.mts
Normal file
File diff suppressed because it is too large
Load Diff
18
docs/src/.vitepress/theme/index.ts
Normal file
18
docs/src/.vitepress/theme/index.ts
Normal file
@@ -0,0 +1,18 @@
|
||||
// https://vitepress.dev/guide/custom-theme
|
||||
import { h } from "vue";
|
||||
import type { Theme } from "vitepress";
|
||||
import DefaultTheme from "vitepress/theme";
|
||||
import "./style.css";
|
||||
import "./vars.css";
|
||||
|
||||
export default {
|
||||
extends: DefaultTheme,
|
||||
Layout: () => {
|
||||
return h(DefaultTheme.Layout, null, {
|
||||
// https://vitepress.dev/guide/extending-default-theme#layout-slots
|
||||
});
|
||||
},
|
||||
enhanceApp({ app, router, siteData }) {
|
||||
// ...
|
||||
},
|
||||
} satisfies Theme;
|
||||
209
docs/src/.vitepress/theme/style.css
Normal file
209
docs/src/.vitepress/theme/style.css
Normal file
@@ -0,0 +1,209 @@
|
||||
/**
|
||||
* Customize default theme styling by overriding CSS variables:
|
||||
* https://github.com/vuejs/vitepress/blob/main/src/client/theme-default/styles/vars.css
|
||||
*/
|
||||
|
||||
/**
|
||||
* Colors
|
||||
*
|
||||
* Each colors have exact same color scale system with 3 levels of solid
|
||||
* colors with different brightness, and 1 soft color.
|
||||
*
|
||||
* - `XXX-1`: The most solid color used mainly for colored text. It must
|
||||
* satisfy the contrast ratio against when used on top of `XXX-soft`.
|
||||
*
|
||||
* - `XXX-2`: The color used mainly for hover state of the button.
|
||||
*
|
||||
* - `XXX-3`: The color for solid background, such as bg color of the button.
|
||||
* It must satisfy the contrast ratio with pure white (#ffffff) text on
|
||||
* top of it.
|
||||
*
|
||||
* - `XXX-soft`: The color used for subtle background such as custom container
|
||||
* or badges. It must satisfy the contrast ratio when putting `XXX-1` colors
|
||||
* on top of it.
|
||||
*
|
||||
* The soft color must be semi transparent alpha channel. This is crucial
|
||||
* because it allows adding multiple "soft" colors on top of each other
|
||||
* to create a accent, such as when having inline code block inside
|
||||
* custom containers.
|
||||
*
|
||||
* - `default`: The color used purely for subtle indication without any
|
||||
* special meanings attached to it such as bg color for menu hover state.
|
||||
*
|
||||
* - `brand`: Used for primary brand colors, such as link text, button with
|
||||
* brand theme, etc.
|
||||
*
|
||||
* - `tip`: Used to indicate useful information. The default theme uses the
|
||||
* brand color for this by default.
|
||||
*
|
||||
* - `warning`: Used to indicate warning to the users. Used in custom
|
||||
* container, badges, etc.
|
||||
*
|
||||
* - `danger`: Used to show error, or dangerous message to the users. Used
|
||||
* in custom container, badges, etc.
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-c-default-1: #9e9e9e;
|
||||
--vp-c-default-2: red;
|
||||
--vp-c-default-3: yellow;
|
||||
--vp-c-default-soft: var(--vp-c-gray-soft);
|
||||
|
||||
--vp-c-brand-1: #f2994a;
|
||||
--vp-c-brand-2: #efaa6d;
|
||||
--vp-c-brand-3: #d68742;
|
||||
--vp-c-brand-soft: var(--vp-c-indigo-soft);
|
||||
|
||||
--vp-c-tip-1: var(--vp-c-brand-1);
|
||||
--vp-c-tip-2: var(--vp-c-brand-2);
|
||||
--vp-c-tip-3: var(--vp-c-brand-3);
|
||||
--vp-c-tip-soft: var(--vp-c-brand-soft);
|
||||
|
||||
--vp-c-warning-1: var(--vp-c-yellow-1);
|
||||
--vp-c-warning-2: var(--vp-c-yellow-2);
|
||||
--vp-c-warning-3: var(--vp-c-yellow-3);
|
||||
--vp-c-warning-soft: var(--vp-c-yellow-soft);
|
||||
|
||||
--vp-c-danger-1: var(--vp-c-red-1);
|
||||
--vp-c-danger-2: var(--vp-c-red-2);
|
||||
--vp-c-danger-3: var(--vp-c-red-3);
|
||||
--vp-c-danger-soft: var(--vp-c-red-soft);
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Button
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-button-brand-border: transparent;
|
||||
--vp-button-brand-text: var(--vp-c-white);
|
||||
--vp-button-brand-bg: var(--vp-c-brand-3);
|
||||
--vp-button-brand-hover-border: transparent;
|
||||
--vp-button-brand-hover-text: var(--vp-c-white);
|
||||
--vp-button-brand-hover-bg: var(--vp-c-brand-2);
|
||||
--vp-button-brand-active-border: transparent;
|
||||
--vp-button-brand-active-text: var(--vp-c-white);
|
||||
--vp-button-brand-active-bg: var(--vp-c-brand-1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Home
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-home-hero-name-color: transparent;
|
||||
--vp-home-hero-name-background: -webkit-linear-gradient(
|
||||
120deg,
|
||||
#bd34fe 30%,
|
||||
#41d1ff
|
||||
);
|
||||
|
||||
--vp-home-hero-image-background-image: linear-gradient(
|
||||
-45deg,
|
||||
#bd34fe 50%,
|
||||
#47caff 50%
|
||||
);
|
||||
--vp-home-hero-image-filter: blur(44px);
|
||||
}
|
||||
|
||||
@media (min-width: 640px) {
|
||||
:root {
|
||||
--vp-home-hero-image-filter: blur(56px);
|
||||
}
|
||||
}
|
||||
|
||||
@media (min-width: 960px) {
|
||||
:root {
|
||||
--vp-home-hero-image-filter: blur(68px);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Custom Block
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-custom-block-tip-border: transparent;
|
||||
--vp-custom-block-tip-text: var(--vp-c-text-1);
|
||||
--vp-custom-block-tip-bg: var(--vp-c-brand-soft);
|
||||
--vp-custom-block-tip-code-bg: var(--vp-c-brand-soft);
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Algolia
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
.DocSearch {
|
||||
--docsearch-primary-color: var(--vp-c-brand-1) !important;
|
||||
}
|
||||
|
||||
/* IronCalc Docs custom css */
|
||||
|
||||
.content p {
|
||||
font-size: 14px;
|
||||
}
|
||||
|
||||
.VPSidebar {
|
||||
border-right: 1px solid var(--vp-c-divider);
|
||||
padding-bottom: 32px !important;
|
||||
}
|
||||
|
||||
/* .curtain {
|
||||
background-color: white !important;
|
||||
} */
|
||||
|
||||
.edit-info {
|
||||
border-top: 1px solid var(--vp-c-divider);
|
||||
padding-top: 14px;
|
||||
}
|
||||
|
||||
li::marker {
|
||||
color: var(--vp-c-brand-1);
|
||||
}
|
||||
|
||||
.DocSearch-Button-Placeholder {
|
||||
min-width: 200px;
|
||||
text-align: left;
|
||||
}
|
||||
|
||||
.vp-doc h2 {
|
||||
margin: 36px 0 16px;
|
||||
padding-top: 36px;
|
||||
}
|
||||
|
||||
.vp-doc h2 .header-anchor {
|
||||
top: 36px;
|
||||
}
|
||||
|
||||
.VPSwitch {
|
||||
background-color: var(--vp-c-bg-alt) !important;
|
||||
}
|
||||
|
||||
.VPDocFooter {
|
||||
margin-top: 36px !important;
|
||||
}
|
||||
|
||||
table {
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
.VPSidebarItem.level-0 {
|
||||
padding-bottom: 10px !important;
|
||||
}
|
||||
|
||||
.VPBadge.info {
|
||||
background-color: var(--vp-c-gray-3);
|
||||
}
|
||||
|
||||
.custom-block {
|
||||
padding: 8px 16px;
|
||||
}
|
||||
|
||||
.vp-doc ul,
|
||||
.vp-doc ol {
|
||||
font-size: 14px;
|
||||
}
|
||||
|
||||
.vp-doc h2 > .VPBadge {
|
||||
vertical-align: middle;
|
||||
}
|
||||
598
docs/src/.vitepress/theme/vars.css
Normal file
598
docs/src/.vitepress/theme/vars.css
Normal file
@@ -0,0 +1,598 @@
|
||||
/**
|
||||
* Colors: Solid
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-c-white: #ffffff;
|
||||
--vp-c-black: #000000;
|
||||
|
||||
--vp-c-neutral: var(--vp-c-black);
|
||||
--vp-c-neutral-inverse: var(--vp-c-white);
|
||||
}
|
||||
|
||||
.dark {
|
||||
--vp-c-neutral: var(--vp-c-white);
|
||||
--vp-c-neutral-inverse: var(--vp-c-black);
|
||||
}
|
||||
|
||||
/**
|
||||
* Colors: Palette
|
||||
*
|
||||
* The primitive colors used for accent colors. These colors are referenced
|
||||
* by functional colors such as "Text", "Background", or "Brand".
|
||||
*
|
||||
* Each colors have exact same color scale system with 3 levels of solid
|
||||
* colors with different brightness, and 1 soft color.
|
||||
*
|
||||
* - `XXX-1`: The most solid color used mainly for colored text. It must
|
||||
* satisfy the contrast ratio against when used on top of `XXX-soft`.
|
||||
*
|
||||
* - `XXX-2`: The color used mainly for hover state of the button.
|
||||
*
|
||||
* - `XXX-3`: The color for solid background, such as bg color of the button.
|
||||
* It must satisfy the contrast ratio with pure white (#ffffff) text on
|
||||
* top of it.
|
||||
*
|
||||
* - `XXX-soft`: The color used for subtle background such as custom container
|
||||
* or badges. It must satisfy the contrast ratio when putting `XXX-1` colors
|
||||
* on top of it.
|
||||
*
|
||||
* The soft color must be semi transparent alpha channel. This is crucial
|
||||
* because it allows adding multiple "soft" colors on top of each other
|
||||
* to create a accent, such as when having inline code block inside
|
||||
* custom containers.
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-c-gray-1: #dddde3;
|
||||
--vp-c-gray-2: #e4e4e9;
|
||||
--vp-c-gray-3: #ebebef;
|
||||
--vp-c-gray-soft: rgba(242, 150, 170, 0.14);
|
||||
|
||||
--vp-c-indigo-1: #f2994a;
|
||||
--vp-c-indigo-2: #efaa6d;
|
||||
--vp-c-indigo-3: #d68742;
|
||||
--vp-c-indigo-soft: rgba(242, 153, 74, 0.14);
|
||||
|
||||
--vp-c-purple-1: #6f42c1;
|
||||
--vp-c-purple-2: #7e4cc9;
|
||||
--vp-c-purple-3: #8e5cd9;
|
||||
--vp-c-purple-soft: rgba(159, 122, 234, 0.14);
|
||||
|
||||
--vp-c-green-1: #18794e;
|
||||
--vp-c-green-2: #299764;
|
||||
--vp-c-green-3: #30a46c;
|
||||
--vp-c-green-soft: rgba(16, 185, 129, 0.14);
|
||||
|
||||
--vp-c-yellow-1: #915930;
|
||||
--vp-c-yellow-2: #946300;
|
||||
--vp-c-yellow-3: #9f6a00;
|
||||
--vp-c-yellow-soft: rgba(234, 179, 8, 0.14);
|
||||
|
||||
--vp-c-red-1: #b8272c;
|
||||
--vp-c-red-2: #d5393e;
|
||||
--vp-c-red-3: #e0575b;
|
||||
--vp-c-red-soft: rgba(244, 63, 94, 0.14);
|
||||
|
||||
--vp-c-sponsor: #db2777;
|
||||
|
||||
/* ironcalc colors */
|
||||
|
||||
--primary-main: #f2994a;
|
||||
--primary-light: #efaa6d;
|
||||
--primary-dark: #d68742;
|
||||
--primary-contrastText: #ffffff;
|
||||
|
||||
--secondary-main: #2f80ed;
|
||||
--secondary-light: #4e92ec;
|
||||
--secondary-dark: #2b6ec8;
|
||||
--secondary-contrastText: #ffffff;
|
||||
|
||||
--info-main: #9e9e9e;
|
||||
--info-light: #e0e0e0;
|
||||
--info-dark: #757575;
|
||||
--info-contrastText: #ffffff;
|
||||
|
||||
--grey-50: #f2f2f2;
|
||||
--grey-100: #f5f5f5;
|
||||
--grey-200: #eeeeee;
|
||||
--grey-300: #e0e0e0;
|
||||
--grey-400: #bdbdbd;
|
||||
--grey-500: #9e9e9e;
|
||||
--grey-600: #757575;
|
||||
--grey-700: #616161;
|
||||
--grey-800: #424242;
|
||||
--grey-900: #333333;
|
||||
|
||||
--dark: #272525;
|
||||
--background-color: #fcfcfc;
|
||||
}
|
||||
|
||||
.dark {
|
||||
--vp-c-gray-1: #515c67;
|
||||
--vp-c-gray-2: #414853;
|
||||
--vp-c-gray-3: #32363f;
|
||||
--vp-c-gray-soft: rgba(101, 117, 133, 0.16);
|
||||
|
||||
--vp-c-indigo-1: #f2994a;
|
||||
--vp-c-indigo-2: #efaa6d;
|
||||
--vp-c-indigo-3: #d68742;
|
||||
--vp-c-indigo-soft: rgba(242, 153, 74, 0.14);
|
||||
|
||||
--vp-c-purple-1: #c8abfa;
|
||||
--vp-c-purple-2: #a879e6;
|
||||
--vp-c-purple-3: #8e5cd9;
|
||||
--vp-c-purple-soft: rgba(159, 122, 234, 0.16);
|
||||
|
||||
--vp-c-green-1: #3dd68c;
|
||||
--vp-c-green-2: #30a46c;
|
||||
--vp-c-green-3: #298459;
|
||||
--vp-c-green-soft: rgba(16, 185, 129, 0.16);
|
||||
|
||||
--vp-c-yellow-1: #f9b44e;
|
||||
--vp-c-yellow-2: #da8b17;
|
||||
--vp-c-yellow-3: #a46a0a;
|
||||
--vp-c-yellow-soft: rgba(234, 179, 8, 0.16);
|
||||
|
||||
--vp-c-red-1: #f66f81;
|
||||
--vp-c-red-2: #f14158;
|
||||
--vp-c-red-3: #b62a3c;
|
||||
--vp-c-red-soft: rgba(244, 63, 94, 0.16);
|
||||
}
|
||||
|
||||
/**
|
||||
* Colors: Background
|
||||
*
|
||||
* - `bg`: The bg color used for main screen.
|
||||
*
|
||||
* - `bg-alt`: The alternative bg color used in places such as "sidebar",
|
||||
* or "code block".
|
||||
*
|
||||
* - `bg-elv`: The elevated bg color. This is used at parts where it "floats",
|
||||
* such as "dialog".
|
||||
*
|
||||
* - `bg-soft`: The bg color to slightly distinguish some components from
|
||||
* the page. Used for things like "carbon ads" or "table".
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-c-bg: #ffffff;
|
||||
--vp-c-bg-alt: #f6f6f7;
|
||||
--vp-c-bg-elv: #ffffff;
|
||||
--vp-c-bg-soft: #f6f6f7;
|
||||
}
|
||||
|
||||
.dark {
|
||||
--vp-c-bg: #1b1b1f;
|
||||
--vp-c-bg-alt: #161618;
|
||||
--vp-c-bg-elv: #202127;
|
||||
--vp-c-bg-soft: #202127;
|
||||
}
|
||||
|
||||
/**
|
||||
* Colors: Borders
|
||||
*
|
||||
* - `divider`: This is used for separators. This is used to divide sections
|
||||
* within the same components, such as having separator on "h2" heading.
|
||||
*
|
||||
* - `border`: This is designed for borders on interactive components.
|
||||
* For example this should be used for a button outline.
|
||||
*
|
||||
* - `gutter`: This is used to divide components in the page. For example
|
||||
* the header and the lest of the page.
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-c-border: #c2c2c4;
|
||||
--vp-c-divider: #e2e2e3;
|
||||
--vp-c-gutter: #e2e2e3;
|
||||
}
|
||||
|
||||
.dark {
|
||||
--vp-c-border: #3c3f44;
|
||||
--vp-c-divider: #2e2e32;
|
||||
--vp-c-gutter: #000000;
|
||||
}
|
||||
|
||||
/**
|
||||
* Colors: Text
|
||||
*
|
||||
* - `text-1`: Used for primary text.
|
||||
*
|
||||
* - `text-2`: Used for muted texts, such as "inactive menu" or "info texts".
|
||||
*
|
||||
* - `text-3`: Used for subtle texts, such as "placeholders" or "caret icon".
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-c-text-1: rgba(60, 60, 67);
|
||||
--vp-c-text-2: rgba(60, 60, 67, 0.78);
|
||||
--vp-c-text-3: rgba(60, 60, 67, 0.56);
|
||||
}
|
||||
|
||||
.dark {
|
||||
--vp-c-text-1: rgba(255, 255, 245, 0.86);
|
||||
--vp-c-text-2: rgba(235, 235, 245, 0.6);
|
||||
--vp-c-text-3: rgba(235, 235, 245, 0.38);
|
||||
}
|
||||
|
||||
/**
|
||||
* Colors: Function
|
||||
*
|
||||
* - `default`: The color used purely for subtle indication without any
|
||||
* special meanings attached to it such as bg color for menu hover state.
|
||||
*
|
||||
* - `brand`: Used for primary brand colors, such as link text, button with
|
||||
* brand theme, etc.
|
||||
*
|
||||
* - `tip`: Used to indicate useful information. The default theme uses the
|
||||
* brand color for this by default.
|
||||
*
|
||||
* - `warning`: Used to indicate warning to the users. Used in custom
|
||||
* container, badges, etc.
|
||||
*
|
||||
* - `danger`: Used to show error, or dangerous message to the users. Used
|
||||
* in custom container, badges, etc.
|
||||
*
|
||||
* To understand the scaling system, refer to "Colors: Palette" section.
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-c-default-1: var(--vp-c-gray-1);
|
||||
--vp-c-default-2: var(--vp-c-gray-2);
|
||||
--vp-c-default-3: var(--vp-c-gray-3);
|
||||
--vp-c-default-soft: var(--vp-c-gray-soft);
|
||||
|
||||
--vp-c-brand-1: var(--vp-c-indigo-1);
|
||||
--vp-c-brand-2: var(--vp-c-indigo-2);
|
||||
--vp-c-brand-3: var(--vp-c-indigo-3);
|
||||
--vp-c-brand-soft: var(--vp-c-indigo-soft);
|
||||
|
||||
/* DEPRECATED: Use `--vp-c-brand-1` instead. */
|
||||
--vp-c-brand: var(--vp-c-brand-1);
|
||||
|
||||
--vp-c-tip-1: var(--vp-c-brand-1);
|
||||
--vp-c-tip-2: var(--vp-c-brand-2);
|
||||
--vp-c-tip-3: var(--vp-c-brand-3);
|
||||
--vp-c-tip-soft: var(--vp-c-brand-soft);
|
||||
|
||||
--vp-c-note-1: var(--vp-c-brand-1);
|
||||
--vp-c-note-2: var(--vp-c-brand-2);
|
||||
--vp-c-note-3: var(--vp-c-brand-3);
|
||||
--vp-c-note-soft: var(--vp-c-brand-soft);
|
||||
|
||||
--vp-c-success-1: var(--vp-c-green-1);
|
||||
--vp-c-success-2: var(--vp-c-green-2);
|
||||
--vp-c-success-3: var(--vp-c-green-3);
|
||||
--vp-c-success-soft: var(--vp-c-green-soft);
|
||||
|
||||
--vp-c-important-1: var(--vp-c-purple-1);
|
||||
--vp-c-important-2: var(--vp-c-purple-2);
|
||||
--vp-c-important-3: var(--vp-c-purple-3);
|
||||
--vp-c-important-soft: var(--vp-c-purple-soft);
|
||||
|
||||
--vp-c-warning-1: var(--vp-c-yellow-1);
|
||||
--vp-c-warning-2: var(--vp-c-yellow-2);
|
||||
--vp-c-warning-3: var(--vp-c-yellow-3);
|
||||
--vp-c-warning-soft: var(--vp-c-yellow-soft);
|
||||
|
||||
--vp-c-danger-1: var(--vp-c-red-1);
|
||||
--vp-c-danger-2: var(--vp-c-red-2);
|
||||
--vp-c-danger-3: var(--vp-c-red-3);
|
||||
--vp-c-danger-soft: var(--vp-c-red-soft);
|
||||
|
||||
--vp-c-caution-1: var(--vp-c-red-1);
|
||||
--vp-c-caution-2: var(--vp-c-red-2);
|
||||
--vp-c-caution-3: var(--vp-c-red-3);
|
||||
--vp-c-caution-soft: var(--vp-c-red-soft);
|
||||
}
|
||||
|
||||
/**
|
||||
* Typography
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-font-family-base: "Inter", ui-sans-serif, system-ui, sans-serif,
|
||||
"Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
|
||||
--vp-font-family-mono: ui-monospace, "Menlo", "Monaco", "Consolas",
|
||||
"Liberation Mono", "Courier New", monospace;
|
||||
font-optical-sizing: auto;
|
||||
}
|
||||
|
||||
:root:where(:lang(zh)) {
|
||||
--vp-font-family-base: "Punctuation SC", "Inter", ui-sans-serif, system-ui,
|
||||
sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol",
|
||||
"Noto Color Emoji";
|
||||
}
|
||||
|
||||
/**
|
||||
* Shadows
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-shadow-1: 0 1px 2px rgba(0, 0, 0, 0.04), 0 1px 2px rgba(0, 0, 0, 0.06);
|
||||
--vp-shadow-2: 0 3px 12px rgba(0, 0, 0, 0.07), 0 1px 4px rgba(0, 0, 0, 0.07);
|
||||
--vp-shadow-3: 0 12px 32px rgba(0, 0, 0, 0.1), 0 2px 6px rgba(0, 0, 0, 0.08);
|
||||
--vp-shadow-4: 0 14px 44px rgba(0, 0, 0, 0.12), 0 3px 9px rgba(0, 0, 0, 0.12);
|
||||
--vp-shadow-5: 0 18px 56px rgba(0, 0, 0, 0.16), 0 4px 12px rgba(0, 0, 0, 0.16);
|
||||
}
|
||||
|
||||
/**
|
||||
* Z-indexes
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-z-index-footer: 10;
|
||||
--vp-z-index-local-nav: 20;
|
||||
--vp-z-index-nav: 30;
|
||||
--vp-z-index-layout-top: 40;
|
||||
--vp-z-index-backdrop: 50;
|
||||
--vp-z-index-sidebar: 60;
|
||||
}
|
||||
|
||||
@media (min-width: 960px) {
|
||||
:root {
|
||||
--vp-z-index-sidebar: 25;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Layouts
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-layout-max-width: 1440px;
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Header Anchor
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-header-anchor-symbol: "#";
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Code
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-code-line-height: 1.7;
|
||||
--vp-code-font-size: 0.875em;
|
||||
--vp-code-color: var(--vp-c-brand-1);
|
||||
--vp-code-link-color: var(--vp-c-brand-1);
|
||||
--vp-code-link-hover-color: var(--vp-c-brand-2);
|
||||
--vp-code-bg: var(--vp-c-gray-3);
|
||||
|
||||
--vp-code-block-color: var(--vp-c-text-2);
|
||||
--vp-code-block-bg: var(--vp-c-bg-alt);
|
||||
--vp-code-block-divider-color: var(--vp-c-gutter);
|
||||
|
||||
--vp-code-lang-color: var(--vp-c-text-3);
|
||||
|
||||
--vp-code-line-highlight-color: var(--vp-c-default-soft);
|
||||
--vp-code-line-number-color: var(--vp-c-text-3);
|
||||
|
||||
--vp-code-line-diff-add-color: var(--vp-c-success-soft);
|
||||
--vp-code-line-diff-add-symbol-color: var(--vp-c-success-1);
|
||||
|
||||
--vp-code-line-diff-remove-color: var(--vp-c-danger-soft);
|
||||
--vp-code-line-diff-remove-symbol-color: var(--vp-c-danger-1);
|
||||
|
||||
--vp-code-line-warning-color: var(--vp-c-warning-soft);
|
||||
--vp-code-line-error-color: var(--vp-c-danger-soft);
|
||||
|
||||
--vp-code-copy-code-border-color: var(--vp-c-divider);
|
||||
--vp-code-copy-code-bg: var(--vp-c-bg-soft);
|
||||
--vp-code-copy-code-hover-border-color: var(--vp-c-divider);
|
||||
--vp-code-copy-code-hover-bg: var(--vp-c-bg);
|
||||
--vp-code-copy-code-active-text: var(--vp-c-text-2);
|
||||
--vp-code-copy-copied-text-content: "Copied";
|
||||
|
||||
--vp-code-tab-divider: var(--vp-code-block-divider-color);
|
||||
--vp-code-tab-text-color: var(--vp-c-text-2);
|
||||
--vp-code-tab-bg: var(--vp-code-block-bg);
|
||||
--vp-code-tab-hover-text-color: var(--vp-c-text-1);
|
||||
--vp-code-tab-active-text-color: var(--vp-c-text-1);
|
||||
--vp-code-tab-active-bar-color: var(--vp-c-brand-1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Button
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-button-brand-border: transparent;
|
||||
--vp-button-brand-text: var(--vp-c-white);
|
||||
--vp-button-brand-bg: var(--vp-c-brand-3);
|
||||
--vp-button-brand-hover-border: transparent;
|
||||
--vp-button-brand-hover-text: var(--vp-c-white);
|
||||
--vp-button-brand-hover-bg: var(--vp-c-brand-2);
|
||||
--vp-button-brand-active-border: transparent;
|
||||
--vp-button-brand-active-text: var(--vp-c-white);
|
||||
--vp-button-brand-active-bg: var(--vp-c-brand-1);
|
||||
|
||||
--vp-button-alt-border: transparent;
|
||||
--vp-button-alt-text: var(--vp-c-text-1);
|
||||
--vp-button-alt-bg: var(--vp-c-default-3);
|
||||
--vp-button-alt-hover-border: transparent;
|
||||
--vp-button-alt-hover-text: var(--vp-c-text-1);
|
||||
--vp-button-alt-hover-bg: var(--vp-c-default-2);
|
||||
--vp-button-alt-active-border: transparent;
|
||||
--vp-button-alt-active-text: var(--vp-c-text-1);
|
||||
--vp-button-alt-active-bg: var(--vp-c-default-1);
|
||||
|
||||
--vp-button-sponsor-border: var(--vp-c-text-2);
|
||||
--vp-button-sponsor-text: var(--vp-c-text-2);
|
||||
--vp-button-sponsor-bg: transparent;
|
||||
--vp-button-sponsor-hover-border: var(--vp-c-sponsor);
|
||||
--vp-button-sponsor-hover-text: var(--vp-c-sponsor);
|
||||
--vp-button-sponsor-hover-bg: transparent;
|
||||
--vp-button-sponsor-active-border: var(--vp-c-sponsor);
|
||||
--vp-button-sponsor-active-text: var(--vp-c-sponsor);
|
||||
--vp-button-sponsor-active-bg: transparent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Custom Block
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-custom-block-font-size: 14px;
|
||||
--vp-custom-block-code-font-size: 13px;
|
||||
|
||||
--vp-custom-block-info-border: transparent;
|
||||
--vp-custom-block-info-text: var(--vp-c-text-1);
|
||||
--vp-custom-block-info-bg: var(--vp-c-gray-3);
|
||||
--vp-custom-block-info-code-bg: var(--vp-c-default-soft);
|
||||
|
||||
--vp-custom-block-note-border: transparent;
|
||||
--vp-custom-block-note-text: var(--vp-c-text-1);
|
||||
--vp-custom-block-note-bg: var(--vp-c-default-soft);
|
||||
--vp-custom-block-note-code-bg: var(--vp-c-default-soft);
|
||||
|
||||
--vp-custom-block-tip-border: transparent;
|
||||
--vp-custom-block-tip-text: var(--vp-c-text-1);
|
||||
--vp-custom-block-tip-bg: var(--vp-c-tip-soft);
|
||||
--vp-custom-block-tip-code-bg: var(--vp-c-tip-soft);
|
||||
|
||||
--vp-custom-block-important-border: transparent;
|
||||
--vp-custom-block-important-text: var(--vp-c-text-1);
|
||||
--vp-custom-block-important-bg: var(--vp-c-important-soft);
|
||||
--vp-custom-block-important-code-bg: var(--vp-c-important-soft);
|
||||
|
||||
--vp-custom-block-warning-border: transparent;
|
||||
--vp-custom-block-warning-text: var(--vp-c-text-1);
|
||||
--vp-custom-block-warning-bg: var(--vp-c-warning-soft);
|
||||
--vp-custom-block-warning-code-bg: var(--vp-c-warning-soft);
|
||||
|
||||
--vp-custom-block-danger-border: transparent;
|
||||
--vp-custom-block-danger-text: var(--vp-c-text-1);
|
||||
--vp-custom-block-danger-bg: var(--vp-c-danger-soft);
|
||||
--vp-custom-block-danger-code-bg: var(--vp-c-danger-soft);
|
||||
|
||||
--vp-custom-block-caution-border: transparent;
|
||||
--vp-custom-block-caution-text: var(--vp-c-text-1);
|
||||
--vp-custom-block-caution-bg: var(--vp-c-caution-soft);
|
||||
--vp-custom-block-caution-code-bg: var(--vp-c-caution-soft);
|
||||
|
||||
--vp-custom-block-details-border: var(--vp-custom-block-info-border);
|
||||
--vp-custom-block-details-text: var(--vp-custom-block-info-text);
|
||||
--vp-custom-block-details-bg: var(--vp-custom-block-info-bg);
|
||||
--vp-custom-block-details-code-bg: var(--vp-custom-block-info-code-bg);
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Input
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-input-border-color: var(--vp-c-border);
|
||||
--vp-input-bg-color: var(--vp-c-bg-alt);
|
||||
|
||||
--vp-input-switch-bg-color: var(--vp-c-default-soft);
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Nav
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-nav-height: 64px;
|
||||
--vp-nav-bg-color: var(--vp-c-bg);
|
||||
--vp-nav-screen-bg-color: var(--vp-c-bg);
|
||||
--vp-nav-logo-height: 24px;
|
||||
}
|
||||
|
||||
.hide-nav {
|
||||
--vp-nav-height: 0px;
|
||||
}
|
||||
|
||||
.hide-nav .VPSidebar {
|
||||
--vp-nav-height: 22px;
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Local Nav
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-local-nav-bg-color: var(--vp-c-bg);
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Sidebar
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-sidebar-width: 272px;
|
||||
--vp-sidebar-bg-color: var(--vp-c-bg-alt);
|
||||
}
|
||||
|
||||
/**
|
||||
* Colors Backdrop
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-backdrop-bg-color: rgba(0, 0, 0, 0.6);
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Home
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-home-hero-name-color: var(--vp-c-brand-1);
|
||||
--vp-home-hero-name-background: transparent;
|
||||
|
||||
--vp-home-hero-image-background-image: none;
|
||||
--vp-home-hero-image-filter: none;
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Badge
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-badge-info-border: transparent;
|
||||
--vp-badge-info-text: var(--vp-c-text-2);
|
||||
--vp-badge-info-bg: var(--vp-c-default-soft);
|
||||
|
||||
--vp-badge-tip-border: transparent;
|
||||
--vp-badge-tip-text: var(--vp-c-tip-1);
|
||||
--vp-badge-tip-bg: var(--vp-c-tip-soft);
|
||||
|
||||
--vp-badge-warning-border: transparent;
|
||||
--vp-badge-warning-text: var(--vp-c-warning-1);
|
||||
--vp-badge-warning-bg: var(--vp-c-warning-soft);
|
||||
|
||||
--vp-badge-danger-border: transparent;
|
||||
--vp-badge-danger-text: var(--vp-c-danger-1);
|
||||
--vp-badge-danger-bg: var(--vp-c-danger-soft);
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Carbon Ads
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-carbon-ads-text-color: var(--vp-c-text-1);
|
||||
--vp-carbon-ads-poweredby-color: var(--vp-c-text-2);
|
||||
--vp-carbon-ads-bg-color: var(--vp-c-bg-soft);
|
||||
--vp-carbon-ads-hover-text-color: var(--vp-c-brand-1);
|
||||
--vp-carbon-ads-hover-poweredby-color: var(--vp-c-text-1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Component: Local Search
|
||||
* -------------------------------------------------------------------------- */
|
||||
|
||||
:root {
|
||||
--vp-local-search-bg: var(--vp-c-bg);
|
||||
--vp-local-search-result-bg: var(--vp-c-bg);
|
||||
--vp-local-search-result-border: var(--vp-c-divider);
|
||||
--vp-local-search-result-selected-bg: var(--vp-c-bg);
|
||||
--vp-local-search-result-selected-border: var(--vp-c-brand-1);
|
||||
--vp-local-search-highlight-bg: var(--vp-c-brand-1);
|
||||
--vp-local-search-highlight-text: var(--vp-c-neutral-inverse);
|
||||
}
|
||||
9
docs/src/contributing/how-to-contribute.md
Normal file
9
docs/src/contributing/how-to-contribute.md
Normal file
@@ -0,0 +1,9 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# How to Contribute
|
||||
|
||||
If you want to give us a hand, take a look at our [GitHub repository](https://github.com/ironcalc/IronCalc?tab=readme-ov-file#collaborators-needed-call-to-action), join our [Discord Channel](https://discord.gg/sjaefMWE) or send us an email to [hello@ironcalc.com](mailto:hello@ironcalc.com).
|
||||
12
docs/src/desktop/about.md
Normal file
12
docs/src/desktop/about.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# The desktop application
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/issues/57)
|
||||
:::
|
||||
BIN
docs/src/favicon-32x32.png
Normal file
BIN
docs/src/favicon-32x32.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 729 B |
79
docs/src/features/error-types.md
Normal file
79
docs/src/features/error-types.md
Normal file
@@ -0,0 +1,79 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# Error Types
|
||||
|
||||
::: warning
|
||||
**Note:** This page is in construction 🚧
|
||||
:::
|
||||
|
||||
When working with formulas, you may encounter these common errors:
|
||||
|
||||
---
|
||||
|
||||
### **`#ERROR!`**
|
||||
|
||||
**Cause:** General formula issue, like syntax errors or invalid references.
|
||||
**Fix:** Check the formula for mistakes or invalid cell references.
|
||||
|
||||
---
|
||||
|
||||
### **`#VALUE!`**
|
||||
|
||||
**Cause:** Mismatched data types (e.g., text used where numbers are expected).
|
||||
**Fix:** Ensure input types are correct; convert text to numbers if needed.
|
||||
|
||||
---
|
||||
|
||||
### **`#DIV/0!`**
|
||||
|
||||
**Cause:** Division by zero or an empty cell.
|
||||
**Fix:** Ensure the denominator isn’t zero or blank. Use `IF` to handle such cases:
|
||||
|
||||
```
|
||||
=IF(B1=0, "N/A", A1/B1)
|
||||
```
|
||||
|
||||
### **`#NAME?`**
|
||||
|
||||
**Cause:** Unrecognized text in the formula (e.g., misspelled function names or undefined named ranges).
|
||||
**Fix:** Correct spelling or define the missing name.
|
||||
|
||||
### **`#REF!`**
|
||||
|
||||
**Cause:** Invalid cell reference, often from deleting cells used in a formula.
|
||||
**Fix:** Update the formula with correct references.
|
||||
|
||||
### **`#NUM!`**
|
||||
|
||||
**Cause:** Invalid numeric operation (e.g., calculating a square root of a negative number).
|
||||
**Fix:** Adjust the formula to ensure valid numeric operations.
|
||||
|
||||
### **`#N/A`**
|
||||
|
||||
**Cause:** A value is not available, often in lookup functions like VLOOKUP.
|
||||
**Fix:** Ensure the lookup value exists or use IFNA() to handle missing values:
|
||||
|
||||
```
|
||||
=IFNA(VLOOKUP(A1, B1:C10, 2, FALSE), "Not Found")
|
||||
```
|
||||
|
||||
### **`#NULL!`**
|
||||
|
||||
**Cause:** Incorrect range operator in a formula (e.g., missing a colon between cell references).
|
||||
**Fix:** Use correct range operators (e.g., A1:A10).
|
||||
|
||||
|
||||
### **`#CIRC!`**
|
||||
|
||||
**Cause:** Circular reference.
|
||||
**Fix:** Remove the circular reference.
|
||||
|
||||
|
||||
### **`#####`**
|
||||
|
||||
**Cause:** The column isn’t wide enough to display the value.
|
||||
**Fix:** Resize the column width to fit the content.
|
||||
42
docs/src/features/formatting-values.md
Normal file
42
docs/src/features/formatting-values.md
Normal file
@@ -0,0 +1,42 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# Formatting Values
|
||||
|
||||
You can format numbers in **scientific notation**, as **currencies**, **percentages**, or **dates**.
|
||||
|
||||
## How to Format Values
|
||||
|
||||
To change the format of the values:
|
||||
|
||||
- Click on the **€** or **%** buttons in the toolbox for quick access.
|
||||
- Alternatively, click on the **123 dropdown** to select one of the predefined formats:
|
||||
- Number
|
||||
- Percentage
|
||||
- Euro (€)
|
||||
- Dollar ($)
|
||||
- British Pound (£)
|
||||
- Short Date
|
||||
- Long Date
|
||||
|
||||
You can also **create a custom format** directly from the dropdown.
|
||||
|
||||
## Creating Custom Formats
|
||||
|
||||
To create a custom format, you need to use a specific formatting string. Here's an example:
|
||||
|
||||
- **`"$"#,##0.00`**
|
||||
- **`$`**: Displays the dollar symbol. You can replace this with another currency symbol like **€** or **£**.
|
||||
- **`#,##0`**: Formats numbers with a thousands separator (`,`).
|
||||
- **`.00`**: Ensures two decimal places are always displayed.
|
||||
|
||||
### Common Custom Format Examples
|
||||
|
||||
- **`"€"#,##0.00`**: Formats numbers as Euros with two decimal places.
|
||||
- **`0.00%`**: Formats numbers as percentages with two decimal places.
|
||||
- **`yyyy-mm-dd`**: Displays dates in the year-month-day format.
|
||||
|
||||
For more advanced options, refer to standard number formatting guides.
|
||||
28
docs/src/features/keyboard-shortcuts.md
Normal file
28
docs/src/features/keyboard-shortcuts.md
Normal file
@@ -0,0 +1,28 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# Keyboard Shortcuts
|
||||
|
||||
From within your keyboard you can navigate and interact with the spreadsheet. This is a fairly interesting feature for power users.
|
||||
|
||||
## Common Actions
|
||||
|
||||
| Action | Windows | Mac |
|
||||
| ------ | -------- | ----- |
|
||||
| Copy | ctrl + c | ⌘ + c |
|
||||
| Paste | ctrl + v | ⌘ + v |
|
||||
| Cut | ctrl + x | ⌘ + x |
|
||||
| Undo | ctrl + z | ⌘ + z |
|
||||
| Redo | ctrl + y | ⌘ + y |
|
||||
|
||||
## Navigation
|
||||
|
||||
| <div style="width:200px">Action</div> | <div style="width:80px">Windows</div> | <div style="width:80px">Mac</div> |
|
||||
| ------------------------------------- | ------------------------------------- | --------------------------------- |
|
||||
| Move to beginning of row | ??? | Fn + Left Arrow |
|
||||
| Move to end of row | ??? | Fn + Right Arrow |
|
||||
| Move to previous sheet | Option + Arrow Up | Option + Arrow Up |
|
||||
| Move to next sheet | Option + Arrow Down | Option + Arrow Down |
|
||||
29
docs/src/features/unsupported-features.md
Normal file
29
docs/src/features/unsupported-features.md
Normal file
@@ -0,0 +1,29 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# Important Unsupported Features
|
||||
|
||||
Although IronCalc is ready for use, it’s important to understand its current limitations. Below, we list the most significant missing features of a modern spreadsheet engine. If you can live without these features for now, IronCalc might be the product you’re looking for.
|
||||
|
||||
## **Arrays and Array Formulas** <Badge type="info" text="Planned" />
|
||||
|
||||
IronCalc currently does not implement arrays or array formulas. These are planned and are coming very soon, as they are the highest priority on the engine side.
|
||||
|
||||
## **Name Manager** <Badge type="info" text="Planned" />
|
||||
|
||||
While IronCalc supports importing and exporting defined names, it does not yet allow you to create, delete, or update them in the UI. This feature is expected to be implemented shortly.
|
||||
|
||||
## **Only English Supported**
|
||||
|
||||
The MVP version of IronCalc supports only the English language. However, version 1.0 will include support for three languages: **English**, **German**, and **Spanish**.
|
||||
|
||||
## **No Autocomplete**
|
||||
|
||||
Spreadsheet users are accustomed to autocompleting sequences (e.g., filling in `4, 5, 6` after `1, 2, 3`). This feature is not yet available in IronCalc but is on the roadmap for future updates.
|
||||
|
||||
## **Charts** <Badge type="info" text="Not Planned for v1" />
|
||||
|
||||
Although charts are an essential feature for any serious spreadsheet program, they are not planned for version 1.0. Adding chart support will become a high priority after the release of version 1.0.
|
||||
28
docs/src/features/using-styles.md
Normal file
28
docs/src/features/using-styles.md
Normal file
@@ -0,0 +1,28 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# Using Styles
|
||||
|
||||
In IronCalc you can aldo customize the appearance of your data with a variety of style options:
|
||||
|
||||
- **Background Colors**: Apply colors to cell backgrounds.
|
||||
- **Text Colors**: Change the color of the text within cells.
|
||||
- **Borders**: Add or modify borders around cells, including **border color** and **line thickness** (thin, medium or thick).
|
||||
- **Font Styles**: Use **bold**, _italics_, _underlined_, or **strikethrough** text for emphasis.
|
||||
- **Alignment**: Align text both **horizontally** and **vertically**, with options to **align middle** for both axes for perfect centering.
|
||||
|
||||
You can also **show or hide grid lines** for a cleaner layout.
|
||||
|
||||
## Adjusting Row and Column Dimensions
|
||||
|
||||
You can also customize the layout by modifying:
|
||||
|
||||
- **Row Heights**: Adjust the height of rows to fit your content.
|
||||
- **Column Widths**: Resize columns for optimal visibility of data.
|
||||
|
||||
## Copying and Pasting Styles
|
||||
|
||||
Styles can be easily **copied and pasted** from one cell or cell range to another. Simply copy the cell with the desired style and paste it into another cell or range to apply the same formatting.
|
||||
19
docs/src/functions/cube.md
Normal file
19
docs/src/functions/cube.md
Normal file
@@ -0,0 +1,19 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# Cube functions
|
||||
|
||||
At the moment IronCalc does not support any function in this section. All are planned.
|
||||
You can track the progress in this [GitHub issue](https://github.com/ironcalc/IronCalc/issues/58).
|
||||
|
||||
| Function | Status | Documentation |
|
||||
| ------------------ | ---------------------------------------------- | ------------- |
|
||||
| CUBEKPIMEMBER | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| CUBEMEMBERPROPERTY | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| CUBERANKEDMEMBER | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| CUBESET | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| CUBESETCOUNT | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| CUBEVALUE | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
12
docs/src/functions/cube/cubekpimember.md
Normal file
12
docs/src/functions/cube/cubekpimember.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# CUBEKPIMEMBER
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/cube/cubemember.md
Normal file
12
docs/src/functions/cube/cubemember.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# CUBEMEMBER
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/cube/cubememberproperty.md
Normal file
12
docs/src/functions/cube/cubememberproperty.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# CUBEMEMBERPROPERTY
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/cube/cuberankedmember.md
Normal file
12
docs/src/functions/cube/cuberankedmember.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# CUBERANKEDMEMBER
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/cube/cubeset.md
Normal file
12
docs/src/functions/cube/cubeset.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# CUBESET
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/cube/cubesetcount.md
Normal file
12
docs/src/functions/cube/cubesetcount.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# CUBESETCOUNT
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/cube/cubevalue.md
Normal file
12
docs/src/functions/cube/cubevalue.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# CUBEVALUE
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
25
docs/src/functions/database.md
Normal file
25
docs/src/functions/database.md
Normal file
@@ -0,0 +1,25 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# Database functions
|
||||
|
||||
At the moment IronCalc does not support any function in this section. All are planned.
|
||||
You can track the progress in this [GitHub issue](https://github.com/ironcalc/IronCalc/issues/47).
|
||||
|
||||
| Function | Status | Documentation |
|
||||
| -------- | ---------------------------------------------- | ------------- |
|
||||
| DAVERAGE | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DCOUNT | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DCOUNTA | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DGET | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DMAX | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DMIN | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DPRODUCT | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DSTDEV | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DSTDEVP | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DSUM | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DVAR | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DVARP | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
12
docs/src/functions/database/daverage.md
Normal file
12
docs/src/functions/database/daverage.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DAVERAGE
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/database/dcount.md
Normal file
12
docs/src/functions/database/dcount.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DCOUNT
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/database/dcounta.md
Normal file
12
docs/src/functions/database/dcounta.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DCOUNTA
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/database/dget.md
Normal file
12
docs/src/functions/database/dget.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DGET
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/database/dmax.md
Normal file
12
docs/src/functions/database/dmax.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DMAX
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/database/dmin.md
Normal file
12
docs/src/functions/database/dmin.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DMIN
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/database/dproduct.md
Normal file
12
docs/src/functions/database/dproduct.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DPRODUCT
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/database/dstdev.md
Normal file
12
docs/src/functions/database/dstdev.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DSTDEV
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/database/dstdevp.md
Normal file
12
docs/src/functions/database/dstdevp.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DSTDEVP
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/database/dsum.md
Normal file
12
docs/src/functions/database/dsum.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DSUM
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/database/dvar.md
Normal file
12
docs/src/functions/database/dvar.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DVAR
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/database/dvarp.md
Normal file
12
docs/src/functions/database/dvarp.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DVARP
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
38
docs/src/functions/date-and-time.md
Normal file
38
docs/src/functions/date-and-time.md
Normal file
@@ -0,0 +1,38 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# Date and Time functions
|
||||
|
||||
At the moment IronCalc only supports a few function in this section.
|
||||
You can track the progress in this [GitHub issue](https://github.com/ironcalc/IronCalc/issues/48).
|
||||
|
||||
| Function | Status | Documentation |
|
||||
| ---------------- | ---------------------------------------------- | ------------- |
|
||||
| DATE | <Badge type="tip" text="Available" /> | – |
|
||||
| DATEDIF | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DATEVALUE | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DAY | <Badge type="tip" text="Available" /> | – |
|
||||
| DAYS | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| DAYS360 | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| EDATE | <Badge type="tip" text="Available" /> | – |
|
||||
| EOMONTH | <Badge type="tip" text="Available" /> | – |
|
||||
| HOUR | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| ISOWEEKNUM | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| MINUTE | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| MONTH | <Badge type="tip" text="Available" /> | – |
|
||||
| NETWORKDAYS | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| NETWORKDAYS.INTL | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| NOW | <Badge type="tip" text="Available" /> | – |
|
||||
| SECOND | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| TIME | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| TIMEVALUE | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| TODAY | <Badge type="tip" text="Available" /> | – |
|
||||
| WEEKDAY | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| WEEKNUM | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| WORKDAY | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| WORKDAY.INTL | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| YEAR | <Badge type="tip" text="Available" /> | – |
|
||||
| YEARFRAC | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
11
docs/src/functions/date_and_time/date.md
Normal file
11
docs/src/functions/date_and_time/date.md
Normal file
@@ -0,0 +1,11 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DATE
|
||||
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
:::
|
||||
12
docs/src/functions/date_and_time/datedif.md
Normal file
12
docs/src/functions/date_and_time/datedif.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DATEDIF
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
12
docs/src/functions/date_and_time/datevalue.md
Normal file
12
docs/src/functions/date_and_time/datevalue.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DATEVALUE
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
11
docs/src/functions/date_and_time/day.md
Normal file
11
docs/src/functions/date_and_time/day.md
Normal file
@@ -0,0 +1,11 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DAY
|
||||
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
:::
|
||||
12
docs/src/functions/date_and_time/days.md
Normal file
12
docs/src/functions/date_and_time/days.md
Normal file
@@ -0,0 +1,12 @@
|
||||
---
|
||||
layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# DAYS
|
||||
|
||||
::: warning
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user