mirror of
https://github.com/storytold/gridcraft.git
synced 2026-11-16 11:00:21 -06:00
Compare commits
190
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
3ca81a761b | ||
|
|
1476d4e7ab | ||
|
|
91f153de5b | ||
|
|
3443e06bfc | ||
|
|
e1147239fc | ||
|
|
ef99f1e51f | ||
|
|
19f07f3a25 | ||
|
|
407e0e1fa9 | ||
|
|
dbdec081e2 | ||
|
|
24e40de94f | ||
|
|
44050e9447 | ||
|
|
d217e8272d | ||
|
|
f22b4ed9dd | ||
|
|
75c4b01db3 | ||
|
|
1d0b311b4a | ||
|
|
92ff21b9f2 | ||
|
|
ee24d50ac8 | ||
|
|
d593a8f99d | ||
|
|
8bde636f27 | ||
|
|
bfcb3a515a | ||
|
|
2f52ae5c7e | ||
|
|
a62a532753 | ||
|
|
69219c0d5c | ||
|
|
da46633db7 | ||
|
|
b01be008a0 | ||
|
|
4ea6f081d7 | ||
|
|
f2044337c7 | ||
|
|
569707e3f0 | ||
|
|
34ab393c72 | ||
|
|
bece357298 | ||
|
|
de3576286e | ||
|
|
dc9066cae0 | ||
|
|
d2c7c6ec58 | ||
|
|
713a66e0d3 | ||
|
|
07fcccd855 | ||
|
|
c2aba7a3f4 | ||
|
|
a8a51e3cf7 | ||
|
|
45ee4eceed | ||
|
|
fdba683246 | ||
|
|
10849d5003 | ||
|
|
494b830240 | ||
|
|
40783ab184 | ||
|
|
c0ee120ac2 | ||
|
|
bf76e6e63b | ||
|
|
467d36a9c8 | ||
|
|
efc11acede | ||
|
|
0c5436de76 | ||
|
|
ce0beb6900 | ||
|
|
a60db4f1c7 | ||
|
|
a3366cff65 | ||
|
|
591b8354f2 | ||
|
|
0b31cebe5d | ||
|
|
37941f0624 | ||
|
|
b1bd8d8b20 | ||
|
|
794b65ecac | ||
|
|
6308fc9edb | ||
|
|
48659c1668 | ||
|
|
e8845f648a | ||
|
|
3858482465 | ||
|
|
73a18c4f4c | ||
|
|
0b4b36b865 | ||
|
|
4251dad939 | ||
|
|
1b7e4f00dc | ||
|
|
4deedbb549 | ||
|
|
8d4fb0b12e | ||
|
|
203872b4db | ||
|
|
d3954beacf | ||
|
|
26e7112e0f | ||
|
|
3d31729de3 | ||
|
|
3ba4945e72 | ||
|
|
0752f3181b | ||
|
|
b24ec5df6d | ||
|
|
d0c567992e | ||
|
|
1c84e32f58 | ||
|
|
cf3b11c858 | ||
|
|
1e6c8b8b72 | ||
|
|
3e0f073e9a | ||
|
|
eec5db66f0 | ||
|
|
a440cfac28 | ||
|
|
92a79db048 | ||
|
|
652c08a89b | ||
|
|
aeb3fb19ce | ||
|
|
e4ec0d7ed1 | ||
|
|
23487b0cb5 | ||
|
|
0407b63663 | ||
|
|
b45698d109 | ||
|
|
c913bf6615 | ||
|
|
1bd4ca8946 | ||
|
|
0431741359 | ||
|
|
ae7fbd81b7 | ||
|
|
f800472b0a | ||
|
|
9c87c22662 | ||
|
|
c1adf9b239 | ||
|
|
21df49c636 | ||
|
|
7e0d96d74b | ||
|
|
572bec289b | ||
|
|
55eb394044 | ||
|
|
9e9f13114f | ||
|
|
35e9815603 | ||
|
|
6ea8d11522 | ||
|
|
7c3af8a421 | ||
|
|
ca7ea0131e | ||
|
|
aa0347cc2e | ||
|
|
2ff6001d3d | ||
|
|
20917cfd01 | ||
|
|
4dd1c6cf6c | ||
|
|
5cf52c5fbb | ||
|
|
0c5b1e85e6 | ||
|
|
7f6a79fd98 | ||
|
|
6dbfbc4058 | ||
|
|
e258db5f19 | ||
|
|
763816d27c | ||
|
|
60063b85cd | ||
|
|
40c1afbe84 | ||
|
|
75c07a1a83 | ||
|
|
353908fca5 | ||
|
|
10545dc4e1 | ||
|
|
f8070bbbd0 | ||
|
|
5e5b5d082d | ||
|
|
2bc50341a0 | ||
|
|
7cd0a6cc72 | ||
|
|
14aae7cee1 | ||
|
|
8605fb02f0 | ||
|
|
032b280b04 | ||
|
|
40c3ada226 | ||
|
|
01fe67010d | ||
|
|
86ed3d93b4 | ||
|
|
ef320b988d | ||
|
|
0144ffa51b | ||
|
|
522120c34c | ||
|
|
3e64ddbd80 | ||
|
|
2cae4aa316 | ||
|
|
ed15db4101 | ||
|
|
3d50413aff | ||
|
|
224d0e96d7 | ||
|
|
1baa723ae7 | ||
|
|
cca09cc8f4 | ||
|
|
583c8a4819 | ||
|
|
8e3fba8a25 | ||
|
|
dd5cd48b8f | ||
|
|
2a9a21d41c | ||
|
|
6a22a3b357 | ||
|
|
38f48ad974 | ||
|
|
ac0588dbaf | ||
|
|
a5c74edfec | ||
|
|
d0b40c3b30 | ||
|
|
f74d95542f | ||
|
|
f3e24e2b68 | ||
|
|
5b3b3bdc0e | ||
|
|
f8a764f20c | ||
|
|
0d1296e532 | ||
|
|
b396e6c0bd | ||
|
|
9bd6fa1d75 | ||
|
|
e624f4d178 | ||
|
|
96aece4e57 | ||
|
|
218aa884be | ||
|
|
4f372ff470 | ||
|
|
5ca5e6b61e | ||
|
|
5d440c82ac | ||
|
|
57e0eb5b0f | ||
|
|
71469495bc | ||
|
|
527abcfc7d | ||
|
|
37cf274a03 | ||
|
|
f9bd1e7eca | ||
|
|
5a93bc3311 | ||
|
|
f1d8d2e1e8 | ||
|
|
3afaf39584 | ||
|
|
4777381dec | ||
|
|
97e43b84fa | ||
|
|
6e2ec96c85 | ||
|
|
e6b6d2d65f | ||
|
|
d59c51ba1f | ||
|
|
bce01e7789 | ||
|
|
4b75f3ea00 | ||
|
|
a9069cb8f9 | ||
|
|
fb71f723fc | ||
|
|
caf897daad | ||
|
|
a9cc381332 | ||
|
|
451debe5e8 | ||
|
|
5f53afd72e | ||
|
|
c7e4d6a19c | ||
|
|
30dfc3fbd8 | ||
|
|
8e30c095db | ||
|
|
6090366562 | ||
|
|
c59575b766 | ||
|
|
30ef61982b | ||
|
|
e04e559da3 | ||
|
|
3109f2a9e0 | ||
|
|
a39c6b8977 | ||
|
|
470968fcdc |
@@ -27,6 +27,10 @@ jobs:
|
||||
name: Windows installation policy (no app build)
|
||||
runs-on: windows-latest
|
||||
steps:
|
||||
- name: Harden runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
with:
|
||||
egress-policy: audit
|
||||
- uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
|
||||
with:
|
||||
persist-credentials: false
|
||||
|
||||
@@ -1,6 +1,10 @@
|
||||
name: Release
|
||||
|
||||
on:
|
||||
# A nightly dry run on main: every release build except macOS, nothing signed or released
|
||||
# (craft-common-actions release.yml `dry-run`). Finds release-only breakage before release day.
|
||||
schedule:
|
||||
- cron: "56 1 * * *"
|
||||
push:
|
||||
branches: [release]
|
||||
workflow_dispatch:
|
||||
@@ -23,6 +27,7 @@ jobs:
|
||||
# Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
|
||||
uses: storytold/craft-common-actions/.github/workflows/release.yml@main
|
||||
with:
|
||||
dry-run: ${{ github.event_name == 'schedule' }}
|
||||
app-name: gridcraft
|
||||
app-title: GridCraft
|
||||
craft-fonts-ref: b076417b5880bd4154bd22f00695b1d28c6bea83
|
||||
|
||||
@@ -18,4 +18,7 @@ jobs:
|
||||
sonarcloud:
|
||||
# Tracked at @main so org-wide CI improvements propagate without PR churn.
|
||||
uses: storytold/craft-common-actions/.github/workflows/sonarcloud.yml@main
|
||||
with:
|
||||
# Match the main CI gate so coverage exercises every glyph-sensitive UI case.
|
||||
fonts-ref: b076417b5880bd4154bd22f00695b1d28c6bea83
|
||||
secrets: inherit
|
||||
|
||||
@@ -121,3 +121,7 @@ People trust GridCraft with their numbers; a crash loses their work. **This outr
|
||||
- Some workflow files here still run their own jobs. Don't add to them. Moving a job into craft-common-actions is its own task, never part of another PR, and the job stays here until a shared workflow runs it.
|
||||
|
||||
New workspace crates include `workspace = true` under `[lints]` in `Cargo.toml`. Production crate roots declare the crate-level lint attributes before modules; crate-level `//!` documentation may precede them.
|
||||
|
||||
## Shared libraries
|
||||
|
||||
Before adding or changing file-format, codec, protocol, or reusable UI code, check `storytold/craft-libs` and its open PRs first; reuse or extend the shared library rather than duplicating it locally, keep app-specific policy and model mapping in the app, and preserve behavior, security/resource limits, attribution, and regression coverage during cutovers.
|
||||
|
||||
+3
-1
@@ -47,5 +47,7 @@ Generated-in-code art is original and has no file to list: the UI icon set (`cra
|
||||
| `docs/images/pivot.png` | GridCraft contributors | screenshot of GridCraft rendered offscreen (`crates/ui-egui/examples/snapshot.rs`) showing an original sample workbook | MIT OR Apache-2.0 | README screenshot; no third-party content |
|
||||
| `docs/images/format-chart.png` | GridCraft contributors | screenshot of GridCraft rendered offscreen (`crates/ui-egui/examples/snapshot.rs`) showing an original sample workbook | MIT OR Apache-2.0 | README screenshot; no third-party content |
|
||||
| `docs/images/page-break.png` | GridCraft contributors | screenshot of GridCraft rendered offscreen (`crates/ui-egui/examples/snapshot.rs`) showing an original sample workbook | MIT OR Apache-2.0 | README screenshot; no third-party content |
|
||||
| Core 14 AFM metric numbers in `crates/pdf/src/symbol.rs` (Symbol: character codes and advance widths) and `crates/pdf/src/metrics.rs` (Helvetica, Times and Courier advance widths); no font file | Adobe Systems Incorporated | Adobe's Core 14 AFM font metrics files (`Symbol.afm` 001.008 and the Helvetica, Times and Courier AFMs) | Adobe's Core 14 metrics notice: the files may be used, copied and distributed for any purpose and without charge, provided the notice is kept (quoted in `crates/pdf/src/metrics.rs`) | Numbers only, typed in from the public metrics. PDF export embeds no font: Symbol and the Times faces are base-14 fonts every PDF reader supplies, and text outside WinAnsiEncoding is set in a predefined, non-embedded Adobe-GB1 CID font |
|
||||
| Core 14 AFM metric numbers in `crates/pdf/src/symbol.rs` (Symbol: character codes and advance widths) and `crates/pdf/src/metrics.rs` (Helvetica, Times and Courier advance widths); no font file | Adobe Systems Incorporated | Adobe's Core 14 AFM font metrics files (`Symbol.afm` 001.008 and the Helvetica, Times and Courier AFMs) | Adobe's Core 14 metrics notice: the files may be used, copied and distributed for any purpose and without charge, provided the notice is kept (quoted in `crates/pdf/src/metrics.rs`) | Numbers only, typed in from the public metrics. PDF export embeds none of these fonts: Symbol and the Times faces are base-14 fonts every PDF reader supplies, and non-Arabic text outside WinAnsiEncoding is set in a predefined, non-embedded Adobe-GB1 CID font |
|
||||
| Unicode values of the Symbol encoding in `crates/pdf/src/symbol.rs` (the code-to-character map; numbers only, no file copied) | Unicode, Inc. | `symbol.txt`, "Adobe Symbol Encoding to Unicode", table version 1.0 (2011-07-12), at unicode.org/Public/MAPPINGS/VENDORS/ADOBE/ | Unicode, Inc.'s notice in the file: "Unicode, Inc. hereby grants the right to freely use the information supplied in this file in the creation of products supporting the Unicode Standard, and to make copies of this file in any form for internal or external distribution as long as this notice remains attached." The file is provided as-is, without warranties | Separate from Adobe's Core 14 notice (previous row), which covers the character codes and widths; the Unicode values come from this table |
|
||||
|
||||
Arabic PDF text uses Noto Sans Arabic from the optional [craft-fonts build input](https://github.com/storytold/craft-fonts), pinned by the release workflow. Author: The Noto Project Authors. Licence: SIL Open Font License 1.1. Native unbundled export uses an installed Noto Sans Arabic face. No new asset file is committed.
|
||||
|
||||
Generated
+190
-17
@@ -739,6 +739,12 @@ dependencies = [
|
||||
"cc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cmov"
|
||||
version = "0.5.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0c9ea0ac24bc397ab3c98583a3c9ba74fa56b09a4449bbe172b9b1ddb016027a"
|
||||
|
||||
[[package]]
|
||||
name = "cmpv2"
|
||||
version = "0.2.0"
|
||||
@@ -757,7 +763,7 @@ version = "0.2.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7b77c319abfd5219629c45c34c89ba945ed3c5e49fcde9d16b6c3885f118a730"
|
||||
dependencies = [
|
||||
"const-oid",
|
||||
"const-oid 0.9.6",
|
||||
"der",
|
||||
"spki",
|
||||
"x509-cert",
|
||||
@@ -827,6 +833,12 @@ version = "0.9.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
|
||||
|
||||
[[package]]
|
||||
name = "const-oid"
|
||||
version = "0.10.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "be95d4a884358a21a199689323c29e9256b4a1b315e22f183d155422041d3a9a"
|
||||
|
||||
[[package]]
|
||||
name = "core-foundation"
|
||||
version = "0.9.4"
|
||||
@@ -907,15 +919,38 @@ dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-cfb"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=bb57d422d0bc842cbde430955825553ab7b976f4#bb57d422d0bc842cbde430955825553ab7b976f4"
|
||||
|
||||
[[package]]
|
||||
name = "craft-csv"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=bb57d422d0bc842cbde430955825553ab7b976f4#bb57d422d0bc842cbde430955825553ab7b976f4"
|
||||
dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-fonts-build"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=aa84415bae3b765fef6b7ef42404f66ad1cff9d9#aa84415bae3b765fef6b7ef42404f66ad1cff9d9"
|
||||
|
||||
[[package]]
|
||||
name = "craft-gridcraft-format"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=9a6d894200221fcfedc274870c30394d404f859d#9a6d894200221fcfedc274870c30394d404f859d"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"serde_json",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-i18n"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=aa84415bae3b765fef6b7ef42404f66ad1cff9d9#aa84415bae3b765fef6b7ef42404f66ad1cff9d9"
|
||||
dependencies = [
|
||||
"fixed_decimal",
|
||||
"icu_decimal",
|
||||
@@ -935,10 +970,38 @@ dependencies = [
|
||||
"writeable",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-offcrypto"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=bb57d422d0bc842cbde430955825553ab7b976f4#bb57d422d0bc842cbde430955825553ab7b976f4"
|
||||
dependencies = [
|
||||
"aes",
|
||||
"base64 0.23.1",
|
||||
"craft-cfb",
|
||||
"craft-xml",
|
||||
"getrandom 0.3.4",
|
||||
"hmac",
|
||||
"sha1 0.11.0",
|
||||
"sha2 0.11.1",
|
||||
"thiserror 2.0.21",
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-opc"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=bb57d422d0bc842cbde430955825553ab7b976f4#bb57d422d0bc842cbde430955825553ab7b976f4"
|
||||
dependencies = [
|
||||
"craft-xml",
|
||||
"craft-zip",
|
||||
"log",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-print"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=aa84415bae3b765fef6b7ef42404f66ad1cff9d9#aa84415bae3b765fef6b7ef42404f66ad1cff9d9"
|
||||
dependencies = [
|
||||
"craft-winprint-gdi",
|
||||
"log",
|
||||
@@ -949,10 +1012,26 @@ dependencies = [
|
||||
"winsafe",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-sheet"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=bb57d422d0bc842cbde430955825553ab7b976f4#bb57d422d0bc842cbde430955825553ab7b976f4"
|
||||
|
||||
[[package]]
|
||||
name = "craft-stream-codecs"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=f7e0d7fd5577e102b4634bcbe062e649eb68165f#f7e0d7fd5577e102b4634bcbe062e649eb68165f"
|
||||
dependencies = [
|
||||
"fax",
|
||||
"hayro-ccitt",
|
||||
"hayro-jbig2",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-ui"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=aa84415bae3b765fef6b7ef42404f66ad1cff9d9#aa84415bae3b765fef6b7ef42404f66ad1cff9d9"
|
||||
dependencies = [
|
||||
"craft-fonts-build",
|
||||
"craft-i18n",
|
||||
@@ -972,7 +1051,7 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "craft-update"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=bb57d422d0bc842cbde430955825553ab7b976f4#bb57d422d0bc842cbde430955825553ab7b976f4"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"dunce",
|
||||
@@ -982,6 +1061,7 @@ dependencies = [
|
||||
"image",
|
||||
"log",
|
||||
"plist",
|
||||
"rustix 1.1.5",
|
||||
"semver",
|
||||
"serde",
|
||||
"serde_json",
|
||||
@@ -998,7 +1078,7 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "craft-web-api"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=fd5e2feff6ea25bed371a99cc732b3968d621505#fd5e2feff6ea25bed371a99cc732b3968d621505"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=aa84415bae3b765fef6b7ef42404f66ad1cff9d9#aa84415bae3b765fef6b7ef42404f66ad1cff9d9"
|
||||
dependencies = [
|
||||
"js-sys",
|
||||
"serde_json",
|
||||
@@ -1009,7 +1089,7 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "craft-web-host"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=fd5e2feff6ea25bed371a99cc732b3968d621505#fd5e2feff6ea25bed371a99cc732b3968d621505"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=aa84415bae3b765fef6b7ef42404f66ad1cff9d9#aa84415bae3b765fef6b7ef42404f66ad1cff9d9"
|
||||
dependencies = [
|
||||
"wasm-bindgen",
|
||||
"web-sys",
|
||||
@@ -1018,7 +1098,7 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "craft-window"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=bb57d422d0bc842cbde430955825553ab7b976f4#bb57d422d0bc842cbde430955825553ab7b976f4"
|
||||
dependencies = [
|
||||
"egui",
|
||||
"objc2 0.6.5",
|
||||
@@ -1034,6 +1114,38 @@ dependencies = [
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-xls"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=bb57d422d0bc842cbde430955825553ab7b976f4#bb57d422d0bc842cbde430955825553ab7b976f4"
|
||||
dependencies = [
|
||||
"craft-cfb",
|
||||
"craft-sheet",
|
||||
"md-5",
|
||||
"miniz_oxide 0.9.1",
|
||||
"sha1 0.10.7",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-xml"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=bb57d422d0bc842cbde430955825553ab7b976f4#bb57d422d0bc842cbde430955825553ab7b976f4"
|
||||
dependencies = [
|
||||
"quick-xml 0.41.0",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-zip"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=bb57d422d0bc842cbde430955825553ab7b976f4#bb57d422d0bc842cbde430955825553ab7b976f4"
|
||||
dependencies = [
|
||||
"flate2",
|
||||
"thiserror 2.0.21",
|
||||
"zip 9.1.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crc32fast"
|
||||
version = "1.5.2"
|
||||
@@ -1114,6 +1226,15 @@ dependencies = [
|
||||
"hybrid-array",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ctutils"
|
||||
version = "0.4.8"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "261af4dc7a06ea8a527a8717d8cbba3417530d6ea14e1edb3de6b67806be474f"
|
||||
dependencies = [
|
||||
"cmov",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cursor-icon"
|
||||
version = "1.2.0"
|
||||
@@ -1126,7 +1247,7 @@ version = "0.7.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
|
||||
dependencies = [
|
||||
"const-oid",
|
||||
"const-oid 0.9.6",
|
||||
"der_derive",
|
||||
"flagset",
|
||||
"pem-rfc7468",
|
||||
@@ -1191,7 +1312,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
|
||||
dependencies = [
|
||||
"block-buffer 0.12.1",
|
||||
"const-oid 0.10.3",
|
||||
"crypto-common 0.2.2",
|
||||
"ctutils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -1882,9 +2005,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"js-sys",
|
||||
"libc",
|
||||
"r-efi 5.3.0",
|
||||
"wasip2",
|
||||
"wasm-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -2099,6 +2224,8 @@ dependencies = [
|
||||
name = "gridcraft-engine"
|
||||
version = "0.19.1"
|
||||
dependencies = [
|
||||
"craft-csv",
|
||||
"craft-gridcraft-format",
|
||||
"gridcraft-calc",
|
||||
"gridcraft-chart",
|
||||
"gridcraft-core",
|
||||
@@ -2114,6 +2241,7 @@ dependencies = [
|
||||
"serde",
|
||||
"serde_json",
|
||||
"thiserror 2.0.21",
|
||||
"unicode-segmentation",
|
||||
"web-time",
|
||||
"zip 3.0.0",
|
||||
]
|
||||
@@ -2177,6 +2305,13 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "gridcraft-pdf"
|
||||
version = "0.19.1"
|
||||
dependencies = [
|
||||
"craft-stream-codecs",
|
||||
"harfrust",
|
||||
"sha2 0.11.1",
|
||||
"skrifa",
|
||||
"unicode-bidi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "gridcraft-sandbox"
|
||||
@@ -2239,14 +2374,18 @@ dependencies = [
|
||||
name = "gridcraft-xlsx"
|
||||
version = "0.19.1"
|
||||
dependencies = [
|
||||
"aes",
|
||||
"craft-cfb",
|
||||
"craft-csv",
|
||||
"craft-offcrypto",
|
||||
"craft-opc",
|
||||
"craft-xls",
|
||||
"craft-xml",
|
||||
"gridcraft-core",
|
||||
"gridcraft-formula",
|
||||
"gridcraft-functions",
|
||||
"gridcraft-math",
|
||||
"gridcraft-model",
|
||||
"quick-xml 0.41.0",
|
||||
"sha1 0.11.0",
|
||||
"sha2 0.11.1",
|
||||
"thiserror 2.0.21",
|
||||
"zip 3.0.0",
|
||||
@@ -2333,6 +2472,20 @@ dependencies = [
|
||||
"foldhash 0.2.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "hayro-ccitt"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9f4d0e94ddd48749f06bbe4e5389fb9799a0c45bcaf00495042076ef05e3241a"
|
||||
|
||||
[[package]]
|
||||
name = "hayro-jbig2"
|
||||
version = "0.3.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=f7e0d7fd5577e102b4634bcbe062e649eb68165f#f7e0d7fd5577e102b4634bcbe062e649eb68165f"
|
||||
dependencies = [
|
||||
"hayro-ccitt",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "heck"
|
||||
version = "0.5.0"
|
||||
@@ -2351,6 +2504,15 @@ version = "0.4.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
|
||||
|
||||
[[package]]
|
||||
name = "hmac"
|
||||
version = "0.13.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6303bc9732ae41b04cb554b844a762b4115a61bfaa81e3e83050991eeb56863f"
|
||||
dependencies = [
|
||||
"digest 0.11.3",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "http"
|
||||
version = "1.5.0"
|
||||
@@ -2991,6 +3153,16 @@ version = "0.1.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4050469837a6ff301cd14c1f8f24f88549e6d548f24f64e2148eb0f72cebc51f"
|
||||
|
||||
[[package]]
|
||||
name = "md-5"
|
||||
version = "0.10.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"digest 0.10.7",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "memchr"
|
||||
version = "2.8.3"
|
||||
@@ -4803,7 +4975,7 @@ checksum = "da90c3d9af638898a5fdc347479b18f950bb0dde11ecf2244f94cd28135da53b"
|
||||
dependencies = [
|
||||
"aws-lc-rs",
|
||||
"base64 0.22.1",
|
||||
"const-oid",
|
||||
"const-oid 0.9.6",
|
||||
"der",
|
||||
"digest 0.10.7",
|
||||
"pem",
|
||||
@@ -4877,7 +5049,7 @@ dependencies = [
|
||||
"chrono",
|
||||
"cmpv2",
|
||||
"cms",
|
||||
"const-oid",
|
||||
"const-oid 0.9.6",
|
||||
"der",
|
||||
"hex",
|
||||
"rand 0.10.3",
|
||||
@@ -4916,7 +5088,7 @@ dependencies = [
|
||||
"base64 0.22.1",
|
||||
"chrono",
|
||||
"cms",
|
||||
"const-oid",
|
||||
"const-oid 0.9.6",
|
||||
"hex",
|
||||
"pem",
|
||||
"rustls-pki-types",
|
||||
@@ -6519,7 +6691,7 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "winprint"
|
||||
version = "0.2.1"
|
||||
source = "git+https://github.com/storytold/winprint.rs?rev=51934db382f225454cf152a8657eb03789be63c4#51934db382f225454cf152a8657eb03789be63c4"
|
||||
source = "git+https://github.com/storytold/winprint.rs?rev=bc06a7c48b768eb27a828c7986f6d2868b245ee0#bc06a7c48b768eb27a828c7986f6d2868b245ee0"
|
||||
dependencies = [
|
||||
"flate2",
|
||||
"fmt-derive",
|
||||
@@ -6534,6 +6706,7 @@ dependencies = [
|
||||
"windows",
|
||||
"windows-core",
|
||||
"windows-implement",
|
||||
"windows-numerics",
|
||||
"xml",
|
||||
]
|
||||
|
||||
@@ -6640,7 +6813,7 @@ version = "0.2.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1301e935010a701ae5f8655edc0ad17c44bad3ac5ce8c39185f75453b720ae94"
|
||||
dependencies = [
|
||||
"const-oid",
|
||||
"const-oid 0.9.6",
|
||||
"der",
|
||||
"sha1 0.10.7",
|
||||
"signature",
|
||||
|
||||
+20
-7
@@ -26,10 +26,26 @@ gridcraft-ui-egui = { path = "crates/ui-egui" }
|
||||
gridcraft-mcp = { path = "crates/mcp" }
|
||||
gridcraft-pdf = { path = "crates/pdf" }
|
||||
gridcraft-math = { path = "crates/math" }
|
||||
# Every craft-libs crate (craft-update and craft-window here, craft-ui in ui-egui, craft-print in
|
||||
# the app) comes from one craft-libs revision.
|
||||
# Every craft-libs crate (craft-update, craft-window and the file-format crates here, craft-ui in
|
||||
# ui-egui, craft-print in the app, craft-web-api and craft-web-host in the web app) comes from one
|
||||
# craft-libs revision.
|
||||
# craft-update: app-specific pretend versions apply to startup and manual checks.
|
||||
craft-update = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", version = "=0.1.0", features = ["egui"] }
|
||||
craft-update = { git = "https://github.com/storytold/craft-libs", rev = "bb57d422d0bc842cbde430955825553ab7b976f4", version = "=0.1.0", features = ["egui"] }
|
||||
# PDF RunLength encoding; this revision also fixes the vendored JBIG2 dependency for Git consumers.
|
||||
craft-stream-codecs = { git = "https://github.com/storytold/craft-libs", rev = "f7e0d7fd5577e102b4634bcbe062e649eb68165f", version = "0.1.0" }
|
||||
# Compound files ([MS-CFB]) and password-encrypted OOXML packages ([MS-OFFCRYPTO]).
|
||||
craft-cfb = { git = "https://github.com/storytold/craft-libs", rev = "bb57d422d0bc842cbde430955825553ab7b976f4", version = "0.1.0" }
|
||||
craft-offcrypto = { git = "https://github.com/storytold/craft-libs", rev = "bb57d422d0bc842cbde430955825553ab7b976f4", version = "0.1.0" }
|
||||
# OPC zip packages (parts, relationships, the zip writer) under `crates/xlsx/src/package.rs`.
|
||||
craft-opc = { git = "https://github.com/storytold/craft-libs", rev = "bb57d422d0bc842cbde430955825553ab7b976f4", version = "0.1.0" }
|
||||
# Delimited text (CSV, TSV) and SYLK; `crates/xlsx/src/csv.rs` and `crates/engine/src/io/sylk.rs`
|
||||
# turn them into workbooks.
|
||||
craft-csv = { git = "https://github.com/storytold/craft-libs", rev = "bb57d422d0bc842cbde430955825553ab7b976f4", version = "0.1.0" }
|
||||
# The native JSON workbook (`.json`, `.scjson`): read, written, and kept newer macros written back.
|
||||
craft-gridcraft-format = { git = "https://github.com/storytold/craft-libs", rev = "9a6d894200221fcfedc274870c30394d404f859d", version = "0.1.0" }
|
||||
# Excel 97-2003 (.xls, BIFF8) workbooks; `crates/xlsx/src/xls.rs` maps them onto the model.
|
||||
craft-xml = { git = "https://github.com/storytold/craft-libs", rev = "bb57d422d0bc842cbde430955825553ab7b976f4", version = "0.1.0" }
|
||||
craft-xls = { git = "https://github.com/storytold/craft-libs", rev = "bb57d422d0bc842cbde430955825553ab7b976f4", version = "0.1.0" }
|
||||
|
||||
# foundation
|
||||
thiserror = "2"
|
||||
@@ -44,9 +60,6 @@ regex = { version = "1", default-features = false, features = ["std", "unicode",
|
||||
quick-xml = "0.41"
|
||||
zip = { version = "3", default-features = false, features = ["deflate"] }
|
||||
sha2 = { version = "0.11", default-features = false }
|
||||
# Decrypting password-protected workbooks ([MS-OFFCRYPTO]): AES and SHA-1, pure Rust (wasm-safe).
|
||||
aes = { version = "0.9", default-features = false }
|
||||
sha1 = { version = "0.11", default-features = false }
|
||||
image = { version = "0.25", default-features = false, features = ["png", "jpeg"] }
|
||||
|
||||
# equations: RaTeX (MIT) lays LaTeX out as positioned glyphs, rules and paths. Exact pins: it is
|
||||
@@ -72,7 +85,7 @@ skrifa = { version = "0.44", default-features = false, features = ["std"] }
|
||||
epaint_default_fonts = "0.37"
|
||||
# One native window per workbook: the window list, Window menu titles and the immediate-viewport
|
||||
# driver. Same craft-libs revision as craft-update above.
|
||||
craft-window = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", default-features = false, features = ["egui"] }
|
||||
craft-window = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "bb57d422d0bc842cbde430955825553ab7b976f4", default-features = false, features = ["egui"] }
|
||||
|
||||
[workspace.lints.rust]
|
||||
unsafe_code = "forbid"
|
||||
|
||||
@@ -205,7 +205,7 @@ egui frontend is a separate crate, so the UI can be swapped without touching the
|
||||
|
||||
GridCraft is in **alpha**: the core workflow works end to end, but depth, fidelity and file
|
||||
compatibility are still rough. It covers 89% of standard ribbon commands in our catalog
|
||||
([`docs/parity-checklist.md`](docs/parity-checklist.md)) and 513 standard worksheet functions
|
||||
([`docs/parity-checklist.md`](docs/parity-checklist.md)) and 514 standard worksheet functions
|
||||
([`docs/function-parity.md`](docs/function-parity.md)); this is a parity inventory, not a count of working implementations. Weighted by what spreadsheet users rely on, we
|
||||
estimate it is about 50% ready for real work. Next up: XLSX fidelity on real-world files, very large
|
||||
workbooks and multi-threaded recalc, chart depth, text in every script, and `.xls` import. Stage,
|
||||
|
||||
+16
-2
@@ -2,6 +2,7 @@
|
||||
|
||||
**Stage: alpha** · next: beta, ~25 points of "ready for real work" and ~160–240 h away
|
||||
|
||||
> **Last reviewed:** 2026-11-15 · **Last updated:** 2026-11-15 · **Change:** minor (performance: formula entry and XLSX save win back time lost since 23829d8c (#2654), 465 → 420 ms and 540 → 488 ms on the 100k-row benchmark; Sandbox refuses fcntl's asynchronous notification and the socket ioctls that notify another process on Linux (#3846); CI provisions pinned fonts for coverage tests; the oversized pivot-cache warning's test names the part limit; readiness estimates unchanged) · **Target:** Microsoft Excel (Microsoft 365)
|
||||
> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-05 · **Change:** minor (CJK fallback text shares the Latin baseline; earlier: form controls: buttons, sliders and spin buttons; earlier: RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis take ranges by selection on the grid; earlier: Python mode in the formula bar; earlier: Python cells stored and kept in files; earlier: equations: Insert › Equation, editor, gridcraft-math; earlier: What-if and analysis: Solver Sensitivity report for Simplex LP and GRG Nonlinear; earlier: floating objects: one selection, eight resize handles, keyboard delete; earlier: Chart data tables: live source values beneath column, bar, line, area and compatible combo charts; legend keys and borders; XLSX round-trip and print/PDF; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and Insert Function categories; XLSX workbook-view selection, bounded tab ratios and sheet-edit regressions; readiness estimates unchanged; earlier: CSV and text open detects each column's date order, so day-first dates are not silently swapped) · **Target:** Microsoft Excel (Microsoft 365)
|
||||
|
||||
GridCraft aims at full Microsoft Excel parity, and at being better in places: faster, open (XLSX
|
||||
@@ -22,7 +23,7 @@ This page is the summary. The detail is in:
|
||||
| Number | Value | Kind |
|
||||
|---|---|---|
|
||||
| 2026-10-14 | Editing a cell with text that would read back as a number, boolean, date or formula (entered with a leading apostrophe) shows the apostrophe in the editor and formula bar, so Enter unchanged keeps it text (#1362) |
|
||||
| **Feature breadth** (weighted) | **~75%** | estimated, anchored on two measurements: ribbon catalog 281 / 296 (94.9%), worksheet functions 513 / 523 (98.1%; 504 working, 96.4%) |
|
||||
| **Feature breadth** (weighted) | **~75%** | estimated, anchored on two measurements: ribbon catalog 281 / 296 (94.9%), worksheet functions 514 / 523 (98.3%; 505 working, 96.6%) |
|
||||
| **Ready for real work** | **~50%** | estimated from written weights (51.6); [target-app-parity.md](docs/target-app-parity.md) |
|
||||
| **Mainstream practitioner** | **~50%** | estimated: typical analyst/finance user, weekly features, × 0.90 interaction × 0.92 stability × 0.88 file exchange; [method](docs/target-app-parity.md#mainstream-practitioner) |
|
||||
| **Essentials user** | **~63%** | estimated: core features only, × 0.92 launch/stability × 0.95 clarity × 0.90 opening sent files; [method](docs/target-app-parity.md#essentials-user) |
|
||||
@@ -74,7 +75,7 @@ collaboration, mobile, AI).
|
||||
| Area | Breadth | Ready | Hours | Doc |
|
||||
|---|---|---|---|---|
|
||||
| Formula language and calculation | ~92% | ~72% | 20–30 | [target-app-parity.md](docs/target-app-parity.md#feature-areas) |
|
||||
| Worksheet functions | 96.6% measured | ~82% | 16–26 | [function-parity.md](docs/function-parity.md) |
|
||||
| Worksheet functions | 96.6% measured | ~82% | 15–25 | [function-parity.md](docs/function-parity.md) |
|
||||
| Editing, navigation, clipboard, fill | ~90% | ~70% | 15–25 | [ui-parity.md](docs/ui-parity.md) |
|
||||
| Cell formatting, styles, conditional formatting | ~95% | ~80% | 8–14 | [target-app-parity.md](docs/target-app-parity.md#feature-areas) |
|
||||
| Sort, filter, tables, validation, outline | ~82% | ~70% | 10–16 | [target-app-parity.md](docs/target-app-parity.md#feature-areas) |
|
||||
@@ -149,6 +150,8 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
|
||||
| 2026-10-31 | Recently Used lists the functions most recently entered in a formula from any source (ribbon, control channel, MCP, scripts), kept with the preferences and returned by `formulas.recentlyUsed`; the Insert Function dialog takes Excel's title and a working category list (Most Recently Used, All, each category) |
|
||||
| 2026-10-31 | Formulas › Function Library as a big Insert Function button, the AutoSum split button and three columns of labelled small buttons, each category book in its own colour; category menus end with Insert Function… on that category; More Functions cascades into the remaining categories; Home › Editing shares the AutoSum menu; the MR key tip opens Recently Used |
|
||||
| 2026-10-31 | System and embedded CJK fallback text shares the Latin baseline in cells, editors and window titles (#1265, #2621). Symbol and emoji alignment, manual row heights and clipping are unchanged |
|
||||
| 2026-10-26 | PDF preserves Context/LTR/RTL reading direction through wrapping and drawing; RTL sheet cells, borders, headings, objects and sparklines mirror consistently |
|
||||
| 2026-10-26 | Arabic PDF export shapes licensed glyph outlines and preserves searchable logical text; characters the font lacks, or a missing Arabic font, fall back to the standard fonts instead of failing the export |
|
||||
| 2026-10-26 | Arabic bidi display/editing preserve logical source text; per-cell reading direction is editable and survives undo, XLSX and conditional-format priority |
|
||||
| 2026-10-26 | Arabic text shows in cells and the interface through a system, fontconfig or craft-fonts Arabic face; workbook fonts keep their script fallbacks |
|
||||
| 2026-10-25 | AutoSum over a selection does what Excel does: a selected row gets one total to its right (in its last cell if that is empty), not a one-cell total under each cell; a block whose last column is empty gets each row's total there, one whose last row is empty each column's, and with both the corner gets the total of the block; otherwise totals go under each column as before |
|
||||
@@ -198,9 +201,14 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
|
||||
| 2026-10-13 | XLSX export writes a picture used on several sheets once, as one `xl/media` part every drawing points to (it wrote a copy per drawing: a 16-sheet workbook with one 112 KB logo grew from 0.4 to 1.9 MB) (#985) |
|
||||
| 2026-10-13 | XLSX: `[Content_Types].xml`, `_rels/.rels`, the workbook rels and `xl/workbook.xml` are the first zip entries (document properties last), so libmagic and PHP `finfo` detect the file type even with large properties (#1090) |
|
||||
| 2026-10-13 | Conditional formatting: a rule gathers range statistics only when it reads them (top/bottom, above average, duplicates, scales, bars, icons) and borrows them instead of copying them per cell, so the per-frame lookup of an expression or cell-value rule no longer visits its whole range (#1098, part 1) |
|
||||
| 2026-10-13 | Grid: resizing several selected columns or rows previews on the dragged one and applies the size to all on release; Esc cancels (#1082) |
|
||||
| 2026-10-12 | Next/previous sheet navigation stops at the first/last visible worksheet instead of activating a hidden boundary sheet; the current selection is retained |
|
||||
| 2026-10-12 | GETPIVOTDATA reads PivotTable values by field and items (#284) |
|
||||
| 2026-10-12 | PDF writer: objects are written straight to the output, identical pictures are stored once, style operators are emitted only when they change, `q` nesting is limited to 28 and polyline joins no longer leak into later strokes (#816) |
|
||||
| 2026-10-12 | Insert › Text › WordArt (`insert.wordArt`, `wordArt.set`): floating decorative text with 10 original styles, outline and shadow, in-place editing, XLSX and print (#784) |
|
||||
| 2026-10-12 | Number formatting: one table of built-in formats (xlsx); numbers, dates and General render with one scratch buffer instead of per-token strings; output unchanged, checked against digests recorded from the old code (#817) |
|
||||
| 2026-10-21 | Macro engine ([macros.md](docs/macros.md)): typed, declarative macros saved in the workbook (a JSON field; hidden names in xlsx); declared inputs checked with messages that name the cells; tokens (`Input.col(2)`, `Row`, `Output`, `Name:Total`, `{{…}}` in formulas); one undo step with full rollback; a footprint dry run with ask, fail, overwrite, shift down or shift right; a policy that keeps macros away from files and the app, with approval for macros in opened files; Repeat, If and Stop steps; a debugger; a relative recorder; `macro.*` commands beside the unchanged Automate scripts |
|
||||
| 2026-10-13 | Performance: a chart is resolved and rendered once per change of its workbook, zoom or fonts instead of on every frame; idle frames, hovering and scrolling reuse it (#1139, part of #1098) |
|
||||
| 2026-10-13 | Charts: work and memory are bounded by series x points (2,000,000 per chart: every series keeps its first points; 16 trendlines per chart), hairline columns and bars are merged per pixel column, series ranges are clipped before they are evaluated, the moving average is linear and rendering clean data no longer copies it (#1147) |
|
||||
| 2026-10-13 | Charts: one combo plot-kind rule for resolving and drawing; ticks of a scale off the step grid keep their own values (#1146) |
|
||||
| 2026-10-12 | Security: the `--control` server requires an auth token (random, kept in a 0600 file or chosen with `GRIDCRAFT_CONTROL_TOKEN`) on each connection's first line and closes bad connections (#777) |
|
||||
@@ -281,6 +289,8 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
|
||||
| 2026-10-31 | minor | Progress log: Recently Used and Insert Function categories |
|
||||
| 2026-10-31 | minor | Progress log: Function Library |
|
||||
| 2026-10-31 | minor | Progress log: shared CJK/Latin baselines in cells, editors and window titles |
|
||||
| 2026-10-26 | minor | Progress log: PDF reading direction and RTL sheets |
|
||||
| 2026-10-26 | minor | Progress log: Arabic PDF text |
|
||||
| 2026-10-26 | minor | Progress log: Arabic bidi display and editing |
|
||||
| 2026-10-26 | minor | Progress log: Arabic font fallback |
|
||||
| 2026-10-25 | minor | Progress log: AutoSum over a selected row, and a selection's empty last row and column |
|
||||
@@ -313,6 +323,10 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
|
||||
| 2026-10-13 | trivial | Progress log: shared pictures written once on XLSX export (#985) |
|
||||
| 2026-10-13 | minor | Progress log: conditional-format lookups no longer scan the range for rules without statistics (#1098) |
|
||||
| 2026-10-12 | minor | Progress log: hidden-sheet navigation at workbook boundaries |
|
||||
| 2026-10-12 | minor | Worksheet functions 514 / 523 (GETPIVOTDATA); progress log row |
|
||||
| 2026-10-13 | trivial | Progress log: charts cached between frames (#1139) |
|
||||
| 2026-10-12 | minor | Progress log: PDF writer cleanup (#816) |
|
||||
| 2026-10-12 | minor | Catalog 276 → 277 / 292: Insert › WordArt (#784) |
|
||||
| 2026-10-12 | minor | Numfmt cleanup: one built-in format table (gridcraft-xlsx), fewer allocations rendering numbers, dates and General, equality test against the previous output (#817); progress log row |
|
||||
| 2026-10-12 | minor | The control server requires an auth token and closes bad connections (#777); progress log row |
|
||||
| 2026-10-12 | minor | Rows auto-fit oversized fonts on open and whole-row/column formatting (#833); progress log row |
|
||||
|
||||
@@ -214,7 +214,7 @@ pub fn main(args: &[String]) -> ExitCode {
|
||||
Err(_) => return usage(format!("--max-report needs a whole number, not `{n}`")),
|
||||
}
|
||||
}
|
||||
let Discovery { files, failures: mut reports } = collect_inputs(&a.positional);
|
||||
let Discovery { files, failures: mut reports, .. } = collect_inputs(&a.positional);
|
||||
reports.extend(files.iter().map(|p| {
|
||||
let path = p.to_string_lossy().into_owned();
|
||||
match gridcraft_engine::io::read_file(&path) {
|
||||
@@ -233,6 +233,9 @@ pub fn main(args: &[String]) -> ExitCode {
|
||||
#[derive(Default)]
|
||||
struct Discovery {
|
||||
files: Vec<PathBuf>,
|
||||
/// Identity (dev+inode) of each collected file, so a rescan reached by a shallower path doesn't add it twice.
|
||||
#[cfg(unix)]
|
||||
file_ids: std::collections::HashSet<(u64, u64)>,
|
||||
failures: Vec<FileReport>,
|
||||
}
|
||||
|
||||
@@ -257,11 +260,11 @@ impl Discovery {
|
||||
/// (`~$…`) are skipped.
|
||||
fn collect_inputs(inputs: &[String]) -> Discovery {
|
||||
let mut out = Discovery::default();
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
let mut seen = std::collections::HashMap::new();
|
||||
for i in inputs {
|
||||
let p = PathBuf::from(i);
|
||||
if p.is_dir() {
|
||||
if !walk(&p, 0, &mut out, &mut seen) {
|
||||
if !walk(&p, 0, false, &mut out, &mut seen) {
|
||||
break;
|
||||
}
|
||||
} else if !out.add_file(p) {
|
||||
@@ -277,19 +280,29 @@ fn collect_inputs(inputs: &[String]) -> Discovery {
|
||||
out
|
||||
}
|
||||
|
||||
/// Returns false only when the global file budget stops traversal.
|
||||
fn walk(dir: &Path, depth: usize, out: &mut Discovery, seen: &mut std::collections::HashSet<u64>) -> bool {
|
||||
// A directory is visited once by identity (dev+inode on unix): several links to the same
|
||||
// directory are aliases, not exponential branches of the scan. Other platforms keep the
|
||||
// depth cap only.
|
||||
/// Returns false only when the global file budget stops traversal. `seen` holds the shallowest
|
||||
/// depth each directory was scanned from; `rescan` is set below a directory reached again from a
|
||||
/// shallower path (its depth-limited subtree may now fit), where already collected files are skipped.
|
||||
#[cfg_attr(not(unix), allow(unused_mut))]
|
||||
fn walk(dir: &Path, depth: usize, mut rescan: bool, out: &mut Discovery, seen: &mut std::collections::HashMap<(u64, u64), usize>) -> bool {
|
||||
// A directory is visited once by identity (dev+inode on unix) unless reached from a shallower
|
||||
// path: several links to the same directory are aliases, not exponential branches of the scan
|
||||
// (each directory is scanned at most MAX_DEPTH + 1 times). Other platforms keep the depth cap only.
|
||||
#[cfg(unix)]
|
||||
{
|
||||
use std::os::unix::fs::MetadataExt as _;
|
||||
if let Ok(m) = std::fs::metadata(dir)
|
||||
&& let Some(id) = m.dev().checked_mul(1 << 60).and_then(|d| d.checked_add(m.ino()))
|
||||
&& !seen.insert(id)
|
||||
{
|
||||
return true;
|
||||
if let Ok(m) = std::fs::metadata(dir) {
|
||||
let identity = (m.dev(), m.ino());
|
||||
// A directory past the depth limit is not scanned, so it is not recorded: asked for
|
||||
// by name later, it is walked from depth 0.
|
||||
match seen.get(&identity) {
|
||||
Some(&shallowest) if shallowest <= depth => return true,
|
||||
Some(_) => rescan = true,
|
||||
None => {}
|
||||
}
|
||||
if depth <= MAX_DEPTH {
|
||||
seen.insert(identity, depth);
|
||||
}
|
||||
}
|
||||
}
|
||||
if depth > MAX_DEPTH {
|
||||
@@ -324,13 +337,20 @@ fn walk(dir: &Path, depth: usize, out: &mut Discovery, seen: &mut std::collectio
|
||||
}
|
||||
};
|
||||
if metadata.is_dir() {
|
||||
if !walk(&p, depth + 1, out, seen) {
|
||||
if !walk(&p, depth + 1, rescan, out, seen) {
|
||||
return false;
|
||||
}
|
||||
} else if p.extension().and_then(std::ffi::OsStr::to_str).is_some_and(|e| e.eq_ignore_ascii_case("xlsx") || e.eq_ignore_ascii_case("xlsm")) {
|
||||
#[cfg(unix)]
|
||||
{
|
||||
use std::os::unix::fs::MetadataExt as _;
|
||||
if !out.file_ids.insert((metadata.dev(), metadata.ino())) && rescan {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if !out.add_file(p) {
|
||||
return false;
|
||||
}
|
||||
} else if p.extension().and_then(std::ffi::OsStr::to_str).is_some_and(|e| e.eq_ignore_ascii_case("xlsx") || e.eq_ignore_ascii_case("xlsm"))
|
||||
&& !out.add_file(p)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
true
|
||||
@@ -348,6 +368,8 @@ pub fn check_bytes(path: &str, bytes: &[u8], opts: &Options) -> FileReport {
|
||||
}
|
||||
|
||||
fn check_inner(path: &str, bytes: &[u8], opts: &Options) -> FileReport {
|
||||
// GETPIVOTDATA needs the engine's pivot indexer; without it every such cell reads #REF!.
|
||||
let _ = gridcraft_engine::model::PIVOT_INDEXER.set(gridcraft_engine::pivot::index_cells);
|
||||
let mut report = FileReport { path: path.to_string(), ..Default::default() };
|
||||
let (cached, warnings) = match gridcraft_engine::io::open_bytes(path, bytes) {
|
||||
Ok(x) => x,
|
||||
|
||||
@@ -11,8 +11,8 @@ fn discovery_reports_a_directory_read_error() {
|
||||
let path = std::env::temp_dir().join(format!("gridcraft-check-not-a-directory-{}", std::process::id()));
|
||||
std::fs::write(&path, "not a directory").unwrap();
|
||||
let mut discovery = Discovery::default();
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
assert!(walk(&path, 0, &mut discovery, &mut seen));
|
||||
let mut seen = std::collections::HashMap::new();
|
||||
assert!(walk(&path, 0, false, &mut discovery, &mut seen));
|
||||
assert!(discovery.files.is_empty());
|
||||
assert_eq!(discovery.failures.len(), 1);
|
||||
assert_eq!(discovery.failures[0].path, path.to_string_lossy());
|
||||
@@ -31,6 +31,47 @@ fn discovery_reports_omissions_only_after_the_file_limit() {
|
||||
assert!(discovery.failures[0].error.as_ref().unwrap().contains("file limit"));
|
||||
}
|
||||
|
||||
/// A new directory under the temp dir: `create_dir` fails on a name somebody else made first.
|
||||
#[cfg(unix)]
|
||||
fn fresh_dir(tag: &str) -> PathBuf {
|
||||
let mut n = 0u32;
|
||||
loop {
|
||||
let dir = std::env::temp_dir().join(format!("gridcraft-check-{tag}-{}-{n}", std::process::id()));
|
||||
match std::fs::create_dir(&dir) {
|
||||
Ok(()) => return dir,
|
||||
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
|
||||
Err(e) => panic!("{e}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A directory named again by a deeper path, or by a link back to a parent, lists each workbook once.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn discovery_lists_each_workbook_once_whatever_path_reaches_it() {
|
||||
let dir = fresh_dir("once");
|
||||
let sub = dir.join("sub");
|
||||
std::fs::create_dir(&sub).unwrap();
|
||||
std::fs::write(dir.join("a.xlsx"), b"x").unwrap();
|
||||
std::fs::write(sub.join("b.xlsx"), b"x").unwrap();
|
||||
std::os::unix::fs::symlink(&dir, sub.join("loop")).unwrap();
|
||||
let names = |d: &Discovery| {
|
||||
let mut v: Vec<String> = d.files.iter().map(|p| p.file_name().unwrap().to_string_lossy().into_owned()).collect();
|
||||
v.sort();
|
||||
v
|
||||
};
|
||||
// The link back to the top is one directory, not another branch of the scan.
|
||||
let found = collect_inputs(&[dir.to_string_lossy().into_owned()]);
|
||||
assert_eq!(names(&found), ["a.xlsx", "b.xlsx"]);
|
||||
// `sub` named after its parent is reached from a shallower depth: scanned again, nothing listed twice.
|
||||
let found = collect_inputs(&[dir.to_string_lossy().into_owned(), sub.to_string_lossy().into_owned()]);
|
||||
assert_eq!(names(&found), ["a.xlsx", "b.xlsx"]);
|
||||
// Named first, the same `sub` is the shallowest path and the parent's scan skips it.
|
||||
let found = collect_inputs(&[sub.to_string_lossy().into_owned(), dir.to_string_lossy().into_owned()]);
|
||||
assert_eq!(names(&found), ["a.xlsx", "b.xlsx"]);
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
fn at(a1: &str) -> CellRef {
|
||||
CellRef::parse(a1).unwrap()
|
||||
}
|
||||
|
||||
@@ -205,6 +205,44 @@ fn check_reports_a_depth_limited_scan_while_checking_readable_files() {
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_directory_past_the_depth_limit_is_still_scanned_when_named_as_an_input() {
|
||||
let dir = tmpdir("check-depth-named");
|
||||
// The first folder past the limit (33 levels down): the scan from the top reports it unreached.
|
||||
let mut deep = dir.clone();
|
||||
for _ in 0..33 {
|
||||
deep.push("d");
|
||||
}
|
||||
std::fs::create_dir_all(&deep).unwrap();
|
||||
ok(&["run", "--out", deep.join("deep.xlsx").to_str().unwrap(), "--quiet"]);
|
||||
let out = run(&["check", dir.to_str().unwrap(), deep.to_str().unwrap(), "--json"]);
|
||||
let report: serde_json::Value = serde_json::from_slice(&out.stdout).unwrap();
|
||||
// The first scan reports the subtree it could not reach; the named directory is checked.
|
||||
assert_eq!(report["totals"]["opened"], 1, "{report}");
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_directory_first_reached_at_the_depth_limit_is_completed_when_named_as_an_input() {
|
||||
let dir = tmpdir("check-depth-shallower");
|
||||
// The 32nd folder is scanned from the top, but its child (and the workbook in it) is past the limit.
|
||||
let mut limit = dir.clone();
|
||||
for _ in 0..32 {
|
||||
limit.push("d");
|
||||
}
|
||||
let child = limit.join("c");
|
||||
std::fs::create_dir_all(&child).unwrap();
|
||||
ok(&["run", "--out", limit.join("at_limit.xlsx").to_str().unwrap(), "--quiet"]);
|
||||
ok(&["run", "--out", child.join("below.xlsx").to_str().unwrap(), "--quiet"]);
|
||||
let out = run(&["check", dir.to_str().unwrap(), limit.to_str().unwrap(), "--json"]);
|
||||
let report: serde_json::Value = serde_json::from_slice(&out.stdout).unwrap();
|
||||
// Named from depth 0 the subtree is read: the workbook below the limit is checked, the one at it only once.
|
||||
assert_eq!(report["totals"]["opened"], 2, "{report}");
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
/// A script line whose parameters are under a key `run` does not read used to run the command
|
||||
/// with no parameters at all, and the run still exited 0: three mistaken lines made Sheet2,
|
||||
/// Sheet3 and Sheet4 instead of the named sheets, and nothing said so (#2256).
|
||||
|
||||
@@ -78,6 +78,8 @@ fn the_self_test_finds_every_denial() {
|
||||
] {
|
||||
assert!(out.contains(line), "missing `{line}` in:\n{out}");
|
||||
}
|
||||
#[cfg(target_os = "linux")]
|
||||
assert!(out.contains("denied: switch a descriptor's notifications on"), "missing the notification switch in:\n{out}");
|
||||
std::fs::remove_dir_all(home).unwrap();
|
||||
}
|
||||
|
||||
@@ -181,7 +183,9 @@ fn system_python() -> Option<(String, String)> {
|
||||
/// Confined, a program can't signal another process (this test, signal 0 delivering nothing), but can
|
||||
/// still signal itself and its own threads. On Linux, where the filter names them, it also can't
|
||||
/// change another process's limits or priority, or type into a terminal: no call here reaches a real
|
||||
/// terminal, since its standard input isn't one.
|
||||
/// terminal, since its standard input isn't one. Linux also refuses the `fcntl` commands that would
|
||||
/// have the kernel signal a process for it: naming the owner, choosing the signal, or switching the
|
||||
/// notification on.
|
||||
#[test]
|
||||
fn a_confined_program_leaves_other_processes_alone() {
|
||||
if !confines() {
|
||||
@@ -226,6 +230,13 @@ if sys.platform == "linux":
|
||||
assert refused(os.setpriority, os.PRIO_USER, 0, 0), "every process's priority"
|
||||
assert refused(os.sched_setaffinity, other, {0}), "another process's processors"
|
||||
assert refused(os.pidfd_open, other), "a handle on another process"
|
||||
read, write = os.pipe()
|
||||
assert refused(fcntl.fcntl, write, fcntl.F_SETOWN, other), "giving a descriptor's notifications to another process"
|
||||
# 15 is F_SETOWN_EX and 10 is F_SETSIG, which Python's fcntl doesn't name; the filter refuses
|
||||
# them whatever owner or signal they name, so the argument doesn't matter.
|
||||
assert refused(fcntl.fcntl, write, 15), "naming a descriptor's owner the extended way"
|
||||
assert refused(fcntl.fcntl, write, 10), "choosing a descriptor's notification signal"
|
||||
assert refused(fcntl.fcntl, write, fcntl.F_SETFL, fcntl.fcntl(write, fcntl.F_GETFL) | os.O_ASYNC), "switching a descriptor's notifications on"
|
||||
resource.prlimit(0, resource.RLIMIT_NOFILE)
|
||||
resource.prlimit(os.getpid(), resource.RLIMIT_NOFILE)
|
||||
os.setpriority(os.PRIO_PROCESS, 0, os.getpriority(os.PRIO_PROCESS, 0))
|
||||
@@ -240,6 +251,101 @@ print("left alone")
|
||||
assert!(String::from_utf8_lossy(&o.stdout).contains("left alone"), "{}", text(&o));
|
||||
}
|
||||
|
||||
/// A socket the parent made, which the program inherited as a standard stream, can't be pointed at
|
||||
/// another process through the ioctls that do what `fcntl`'s notification commands do: `FIOSETOWN`
|
||||
/// (0x8901) and `FIOASYNC` (0x5452), which Python's `fcntl` passes straight through. Linux only:
|
||||
/// macOS's profile has no rule for them, and its standard streams here are pipes.
|
||||
#[cfg(target_os = "linux")]
|
||||
#[test]
|
||||
fn a_confined_program_cant_point_an_inherited_socket_at_another_process() {
|
||||
if !confines() {
|
||||
return;
|
||||
}
|
||||
let Some((python, prefix)) = system_python() else {
|
||||
return;
|
||||
};
|
||||
let code = r#"
|
||||
import fcntl, sys
|
||||
other = int(sys.argv[1])
|
||||
def refused(call, *args):
|
||||
try:
|
||||
call(*args)
|
||||
except PermissionError:
|
||||
return True
|
||||
except OSError as e:
|
||||
print("other error", e)
|
||||
return False
|
||||
assert refused(fcntl.ioctl, 0, 0x8901, other), "giving a socket's notifications to another process"
|
||||
assert refused(fcntl.ioctl, 0, 0x5452, 1), "switching a socket's notifications on"
|
||||
print("socket quiet")
|
||||
"#;
|
||||
let (mine, _) = std::os::unix::net::UnixStream::pair().unwrap();
|
||||
let socket: std::os::fd::OwnedFd = mine.into();
|
||||
let me = std::process::id().to_string();
|
||||
let o = Command::new(env!("CARGO_BIN_EXE_gridcraft-cli"))
|
||||
.args(["sandbox-check", "--read", &prefix, "--", &python, "-I", "-c", code, &me])
|
||||
.stdin(std::process::Stdio::from(socket))
|
||||
.output()
|
||||
.unwrap();
|
||||
let out = text(&o);
|
||||
assert!(o.status.success(), "{out}");
|
||||
assert!(String::from_utf8_lossy(&o.stdout).contains("socket quiet"), "{out}");
|
||||
}
|
||||
|
||||
/// The same inherited socket, by both ioctls that name the process to notify, `FIOSETOWN` (0x8901)
|
||||
/// and `SIOCSPGRP` (0x8902), with the argument a real pointer. Named by value the kernel reads the
|
||||
/// number as an address and fails with `EFAULT` whether or not the filter refuses it, so that form
|
||||
/// shows only that a rule matched a request number; by pointer each call succeeds unconfined and is
|
||||
/// `EPERM` confined, which is the transition the page claims. Kept apart from the test above so a
|
||||
/// rule dropped for one request number fails for that request, not behind another. Linux only, as
|
||||
/// those rules are: macOS's profile has none, and its standard streams here are pipes.
|
||||
#[cfg(target_os = "linux")]
|
||||
#[test]
|
||||
fn a_confined_program_cant_point_an_inherited_socket_at_another_process_by_pointer() {
|
||||
if !confines() {
|
||||
return;
|
||||
}
|
||||
let Some((python, prefix)) = system_python() else {
|
||||
return;
|
||||
};
|
||||
let code = r#"
|
||||
import fcntl, socket, struct, sys
|
||||
other = int(sys.argv[1])
|
||||
def refused(call, *args):
|
||||
try:
|
||||
call(*args)
|
||||
except PermissionError:
|
||||
return True
|
||||
except OSError as e:
|
||||
print("other error", e)
|
||||
return False
|
||||
# Read first, so a standard stream that is not a socket can't pass for one: a pipe has no socket name.
|
||||
# Detached, not dropped: a socket object closes the descriptor it wrapped when it is collected, and then
|
||||
# the refusals below would be read off an invalid descriptor.
|
||||
wrapped = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM, fileno=0)
|
||||
name = wrapped.getsockname()
|
||||
wrapped.detach()
|
||||
assert name == ""
|
||||
# The process group is a pointer, as a C caller passes it; naming it by value has the kernel read the
|
||||
# number as an address and fail with EFAULT, which would leave the refusal unexplained by the filter.
|
||||
group = bytearray(struct.pack("i", other))
|
||||
assert refused(fcntl.ioctl, 0, 0x8901, group), "giving a socket's notifications to another process"
|
||||
assert refused(fcntl.ioctl, 0, 0x8902, group), "giving a socket's notifications to another process's group"
|
||||
print("socket owner quiet")
|
||||
"#;
|
||||
let (mine, _) = std::os::unix::net::UnixStream::pair().unwrap();
|
||||
let socket: std::os::fd::OwnedFd = mine.into();
|
||||
let me = std::process::id().to_string();
|
||||
let o = Command::new(env!("CARGO_BIN_EXE_gridcraft-cli"))
|
||||
.args(["sandbox-check", "--read", &prefix, "--", &python, "-I", "-c", code, &me])
|
||||
.stdin(std::process::Stdio::from(socket))
|
||||
.output()
|
||||
.unwrap();
|
||||
let out = text(&o);
|
||||
assert!(o.status.success(), "{out}");
|
||||
assert!(String::from_utf8_lossy(&o.stdout).contains("socket owner quiet"), "{out}");
|
||||
}
|
||||
|
||||
/// Confined, a program changes no file, whether the policy lets it read that file or not, by path or
|
||||
/// by a descriptor: not its contents, permissions, owner, extended attributes, times or flags.
|
||||
/// Skipped when there is no `python3`.
|
||||
|
||||
@@ -18,8 +18,8 @@ gridcraft-engine = { workspace = true }
|
||||
gridcraft-ui-egui = { workspace = true }
|
||||
# The host messages (storytold/craft-libs): one contract and one bridge for the web builds.
|
||||
# The page command API (storytold/craft-libs#413): window.gridcraft over the control channel.
|
||||
craft-web-api = { git = "https://github.com/storytold/craft-libs", rev = "fd5e2feff6ea25bed371a99cc732b3968d621505", version = "0.1.0" }
|
||||
craft-web-host = { git = "https://github.com/storytold/craft-libs", rev = "fd5e2feff6ea25bed371a99cc732b3968d621505", version = "0.1.0" }
|
||||
craft-web-api = { git = "https://github.com/storytold/craft-libs", rev = "aa84415bae3b765fef6b7ef42404f66ad1cff9d9", version = "0.1.0" }
|
||||
craft-web-host = { git = "https://github.com/storytold/craft-libs", rev = "aa84415bae3b765fef6b7ef42404f66ad1cff9d9", version = "0.1.0" }
|
||||
egui = { workspace = true }
|
||||
log = { workspace = true }
|
||||
serde_json = { workspace = true }
|
||||
|
||||
@@ -35,7 +35,7 @@ winit = { version = "0.30", default-features = false, features = ["x11", "waylan
|
||||
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
|
||||
# Same craft-libs revision as the workspace's craft-update and craft-window (see the root
|
||||
# Cargo.toml).
|
||||
craft-print = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d" }
|
||||
craft-print = { git = "https://github.com/storytold/craft-libs", rev = "aa84415bae3b765fef6b7ef42404f66ad1cff9d9" }
|
||||
craft-update = { workspace = true }
|
||||
rfd = { workspace = true }
|
||||
arboard = { workspace = true, features = ["image-data"] }
|
||||
|
||||
@@ -340,12 +340,16 @@ fn main() -> eframe::Result<()> {
|
||||
for f in &files {
|
||||
app.open_path(f);
|
||||
}
|
||||
// Linux/BSD: Excel's layout — no window-manager title bar above ours; our title bar carries the
|
||||
// window controls. `GRIDCRAFT_SYSTEM_TITLEBAR=1` keeps the system frame.
|
||||
app.window_controls = cfg!(not(any(target_os = "macos", target_os = "windows"))) && std::env::var_os("GRIDCRAFT_SYSTEM_TITLEBAR").is_none();
|
||||
let mut viewport = egui::ViewportBuilder::default()
|
||||
.with_title("GridCraft")
|
||||
.with_inner_size([1440.0, 900.0])
|
||||
.with_min_inner_size([640.0, 420.0])
|
||||
.with_app_id("ai.storyteller.gridcraft")
|
||||
.with_drag_and_drop(true);
|
||||
.with_drag_and_drop(true)
|
||||
.with_decorations(!app.window_controls);
|
||||
if cfg!(target_os = "macos") {
|
||||
viewport = viewport.with_fullsize_content_view(true).with_titlebar_shown(false).with_title_shown(false);
|
||||
}
|
||||
|
||||
@@ -72,6 +72,7 @@ impl<'h> Evaluator<'h> {
|
||||
"XLOOKUP" => self.xlookup(args),
|
||||
"CELL" => self.cell_info(args),
|
||||
"TRIMRANGE" => self.trimrange(args),
|
||||
"GETPIVOTDATA" => self.getpivotdata(args),
|
||||
"SUBTOTAL" | "AGGREGATE" => self.subtotal(name, args),
|
||||
"TEXT" => {
|
||||
if args.len() != 2 {
|
||||
|
||||
+158
-46
@@ -27,62 +27,172 @@ pub fn resized_sum_range(sum: RangeRef, height: u32, width: u32) -> RangeRef {
|
||||
RangeRef::new(sum.start, CellRef::new(row, col))
|
||||
}
|
||||
|
||||
/// Most expression nodes [`precedents`] visits before giving up and marking the formula dynamic.
|
||||
const MAX_PRECEDENT_NODES: usize = 1_000_000;
|
||||
|
||||
/// Collects the static references of an expression with their sheets resolved; `dynamic` is
|
||||
/// set when the formula uses INDIRECT/OFFSET/names/tables whose targets can change.
|
||||
///
|
||||
/// Every node is visited once (#2183: range-operator chains used to re-walk shared operands,
|
||||
/// costing 2^k for k operands), with an explicit stack, so a flat chain as long as Excel allows
|
||||
/// (`1+1+…`, about 4,000 levels deep) never recurses. Past [`MAX_PRECEDENT_NODES`] the result
|
||||
/// is conservative: `dynamic` is set so the formula recalculates every time.
|
||||
pub fn precedents(wb: &Workbook, sheet: usize, e: &Expr) -> (Vec<Area>, bool) {
|
||||
let mut out = Vec::new();
|
||||
let mut dynamic = false;
|
||||
let push = |out: &mut Vec<Area>, r: &Reference, range: RangeRef| match &r.sheet {
|
||||
SheetSel::Current => out.push(Area { sheet, range }),
|
||||
SheetSel::Named(n) => {
|
||||
if let Some(i) = wb.sheet_index(n) {
|
||||
out.push(Area { sheet: i, range });
|
||||
}
|
||||
let mut c = Precedents { wb, sheet, out: Vec::new(), dynamic: false, boxes: Vec::new() };
|
||||
c.collect(e);
|
||||
(c.out, c.dynamic)
|
||||
}
|
||||
|
||||
/// Grows the per-sheet bounding box in `boxes` to cover `area`.
|
||||
fn union_box(boxes: &mut Vec<Area>, area: Area) {
|
||||
match boxes.iter_mut().find(|x| x.sheet == area.sheet) {
|
||||
Some(x) => x.range = x.range.union(&area.range),
|
||||
None => boxes.push(area),
|
||||
}
|
||||
}
|
||||
|
||||
/// One entry of [`Precedents::collect`]'s explicit stack. `boxes` indexes
|
||||
/// [`Precedents::boxes`]: the bounding boxes of the innermost enclosing range operator, if any.
|
||||
enum PrecedentStep<'e> {
|
||||
/// Visit an expression and queue its children.
|
||||
Visit(&'e Expr, Option<usize>),
|
||||
/// Both operands of a range operator have been visited: record the bounding boxes they
|
||||
/// collected in `inner`, growing the `outer` operator's boxes too.
|
||||
Close { inner: usize, outer: Option<usize> },
|
||||
}
|
||||
|
||||
struct Precedents<'w> {
|
||||
wb: &'w Workbook,
|
||||
sheet: usize,
|
||||
out: Vec<Area>,
|
||||
dynamic: bool,
|
||||
/// Per-sheet bounding boxes, one list per range operator (`A1:INDEX(…)`) met so far.
|
||||
boxes: Vec<Vec<Area>>,
|
||||
}
|
||||
|
||||
impl Precedents<'_> {
|
||||
/// Records `area`, also growing the bounding boxes of the enclosing range operator, if any.
|
||||
fn add(&mut self, area: Area, boxes: Option<usize>) {
|
||||
if let Some(b) = boxes.and_then(|i| self.boxes.get_mut(i)) {
|
||||
union_box(b, area);
|
||||
}
|
||||
SheetSel::Span(a, b) => {
|
||||
if let (Some(i), Some(j)) = (wb.sheet_index(a), wb.sheet_index(b)) {
|
||||
for s in i.min(j)..=i.max(j) {
|
||||
out.push(Area { sheet: s, range });
|
||||
self.out.push(area);
|
||||
}
|
||||
|
||||
fn push(&mut self, r: &Reference, range: RangeRef, boxes: Option<usize>) {
|
||||
match &r.sheet {
|
||||
SheetSel::Current => self.add(Area { sheet: self.sheet, range }, boxes),
|
||||
SheetSel::Named(n) => {
|
||||
if let Some(i) = self.wb.sheet_index(n) {
|
||||
self.add(Area { sheet: i, range }, boxes);
|
||||
}
|
||||
}
|
||||
SheetSel::Span(a, b) => {
|
||||
if let (Some(i), Some(j)) = (self.wb.sheet_index(a), self.wb.sheet_index(b)) {
|
||||
for s in i.min(j)..=i.max(j) {
|
||||
self.add(Area { sheet: s, range }, boxes);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
e.walk(&mut |x| match x {
|
||||
Expr::Ref(r) => push(&mut out, r, r.range()),
|
||||
// The cells SUMIF/AVERAGEIF really read from the sum range (see `resized_sum_range`); when
|
||||
// the criteria range's size isn't known statically, recalculate the formula every time.
|
||||
Expr::Call(n, args) if resizes_sum_range(n, args.len()) => match (args.first(), args.get(2)) {
|
||||
(Some(Expr::Ref(c)), Some(Expr::Ref(s))) => {
|
||||
let (crit, sum) = (c.range(), s.range());
|
||||
push(&mut out, s, resized_sum_range(sum, crit.height(), crit.width()));
|
||||
}
|
||||
(_, Some(Expr::Number(_) | Expr::Text(_) | Expr::Bool(_) | Expr::Error(_) | Expr::Array(_) | Expr::Missing)) => {}
|
||||
_ => dynamic = true,
|
||||
},
|
||||
Expr::Call(n, _)
|
||||
if matches!(n.as_str(), "INDIRECT" | "OFFSET" | "NOW" | "TODAY" | "RAND" | "RANDBETWEEN" | "RANDARRAY" | "CELL" | "INFO") =>
|
||||
{
|
||||
dynamic = true
|
||||
}
|
||||
Expr::Name(_) | Expr::Struct(_) => dynamic = true,
|
||||
Expr::Call(n, _) if gridcraft_functions::lookup(n).is_none() && !is_special(n) => dynamic = true,
|
||||
// A range ending in a function's result (`A1:INDEX(B1:B9,n)`) covers the cells between
|
||||
// the references inside it, not only those references.
|
||||
Expr::Binary(BinOp::Range, a, b) if !matches!((&**a, &**b), (Expr::Ref(_), Expr::Ref(_))) => {
|
||||
let mut inner = precedents(wb, sheet, a).0;
|
||||
inner.extend(precedents(wb, sheet, b).0);
|
||||
let mut boxes: Vec<Area> = Vec::new();
|
||||
for area in inner {
|
||||
match boxes.iter_mut().find(|x| x.sheet == area.sheet) {
|
||||
Some(x) => x.range = x.range.union(&area.range),
|
||||
None => boxes.push(area),
|
||||
}
|
||||
|
||||
/// Visits every node of `root` once, parents before children, left to right. Areas found
|
||||
/// inside a range operator (`A1:INDEX(…)`) also grow that operator's per-sheet bounding boxes.
|
||||
fn collect(&mut self, root: &Expr) {
|
||||
let mut pending = vec![PrecedentStep::Visit(root, None)];
|
||||
let mut nodes = 0usize;
|
||||
while let Some(step) = pending.pop() {
|
||||
let (x, boxes) = match step {
|
||||
PrecedentStep::Visit(x, boxes) => (x, boxes),
|
||||
PrecedentStep::Close { inner, outer } => {
|
||||
let areas = self.boxes.get_mut(inner).map(std::mem::take).unwrap_or_default();
|
||||
for area in areas {
|
||||
self.add(area, outer);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
};
|
||||
nodes = nodes.saturating_add(1);
|
||||
if nodes > MAX_PRECEDENT_NODES {
|
||||
self.dynamic = true;
|
||||
return;
|
||||
}
|
||||
out.extend(boxes);
|
||||
self.visit(x, boxes, &mut pending);
|
||||
}
|
||||
_ => {}
|
||||
});
|
||||
(out, dynamic)
|
||||
}
|
||||
|
||||
/// Handles one node for [`Precedents::collect`], queueing the children still to visit.
|
||||
fn visit<'e>(&mut self, x: &'e Expr, boxes: Option<usize>, pending: &mut Vec<PrecedentStep<'e>>) {
|
||||
match x {
|
||||
Expr::Ref(r) => self.push(r, r.range(), boxes),
|
||||
// The cells SUMIF/AVERAGEIF really read from the sum range (see `resized_sum_range`); when
|
||||
// the criteria range's size isn't known statically, recalculate the formula every time.
|
||||
Expr::Call(n, args) if resizes_sum_range(n, args.len()) => match (args.first(), args.get(2)) {
|
||||
(Some(Expr::Ref(c)), Some(Expr::Ref(s))) => {
|
||||
let (crit, sum) = (c.range(), s.range());
|
||||
self.push(s, resized_sum_range(sum, crit.height(), crit.width()), boxes);
|
||||
}
|
||||
(_, Some(Expr::Number(_) | Expr::Text(_) | Expr::Bool(_) | Expr::Error(_) | Expr::Array(_) | Expr::Missing)) => {}
|
||||
_ => self.dynamic = true,
|
||||
},
|
||||
// GETPIVOTDATA reads the report cells, so it depends on the whole report its reference
|
||||
// points into (pivot commands recalculate everything). Any other reference is dynamic.
|
||||
Expr::Call(n, args) if n == "GETPIVOTDATA" => match args.get(1) {
|
||||
Some(Expr::Ref(r)) => {
|
||||
let si = match &r.sheet {
|
||||
SheetSel::Current => Some(self.sheet),
|
||||
SheetSel::Named(name) => self.wb.sheet_index(name),
|
||||
SheetSel::Span(..) => None,
|
||||
};
|
||||
let report = si
|
||||
.and_then(|i| self.wb.sheet(i))
|
||||
.and_then(|sh| sh.pivots.iter().find_map(|p| p.last_range.filter(|lr| lr.intersects(&r.range()))));
|
||||
match report {
|
||||
Some(lr) => self.push(r, lr, boxes),
|
||||
None => self.dynamic = true,
|
||||
}
|
||||
}
|
||||
_ => self.dynamic = true,
|
||||
},
|
||||
Expr::Call(n, _)
|
||||
if matches!(n.as_str(), "INDIRECT" | "OFFSET" | "NOW" | "TODAY" | "RAND" | "RANDBETWEEN" | "RANDARRAY" | "CELL" | "INFO") =>
|
||||
{
|
||||
self.dynamic = true
|
||||
}
|
||||
Expr::Name(_) | Expr::Struct(_) => self.dynamic = true,
|
||||
Expr::Call(n, _) if gridcraft_functions::lookup(n).is_none() && !is_special(n) => self.dynamic = true,
|
||||
// A range ending in a function's result (`A1:INDEX(B1:B9,n)`), or a chain of plain
|
||||
// references the parser can't fold into one (`A1:B2:C3`), covers the cells between the
|
||||
// references inside it, not only those references. Both operands are visited once,
|
||||
// collecting their bounding boxes on the way, which `Close` then records.
|
||||
Expr::Binary(BinOp::Range, a, b) => {
|
||||
let inner = self.boxes.len();
|
||||
self.boxes.push(Vec::new());
|
||||
pending.push(PrecedentStep::Close { inner, outer: boxes });
|
||||
pending.push(PrecedentStep::Visit(b, Some(inner)));
|
||||
pending.push(PrecedentStep::Visit(a, Some(inner)));
|
||||
return;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
// Children are pushed in reverse so they pop left to right.
|
||||
let visit = |e: &'e Expr| PrecedentStep::Visit(e, boxes);
|
||||
match x {
|
||||
Expr::Array(rows) => pending.extend(rows.iter().flatten().rev().map(visit)),
|
||||
Expr::Unary(_, e) | Expr::Paren(e) => pending.push(visit(e)),
|
||||
Expr::Binary(_, a, b) => {
|
||||
pending.push(visit(b));
|
||||
pending.push(visit(a));
|
||||
}
|
||||
Expr::Call(_, args) => pending.extend(args.iter().rev().map(visit)),
|
||||
Expr::Invoke(c, args) => {
|
||||
pending.extend(args.iter().rev().map(visit));
|
||||
pending.push(visit(c));
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn is_special(n: &str) -> bool {
|
||||
@@ -108,6 +218,7 @@ fn is_special(n: &str) -> bool {
|
||||
| "INDEX"
|
||||
| "CELL"
|
||||
| "TRIMRANGE"
|
||||
| "GETPIVOTDATA"
|
||||
| "SUBTOTAL"
|
||||
| "AGGREGATE"
|
||||
| "TEXT"
|
||||
@@ -146,6 +257,7 @@ pub const SPECIAL_FUNCTIONS: &[&str] = &[
|
||||
"INDEX",
|
||||
"CELL",
|
||||
"TRIMRANGE",
|
||||
"GETPIVOTDATA",
|
||||
"SUBTOTAL",
|
||||
"AGGREGATE",
|
||||
"TEXT",
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
#![forbid(unsafe_code)]
|
||||
|
||||
pub mod eval;
|
||||
mod pivotdata;
|
||||
mod precision;
|
||||
pub mod recalc;
|
||||
mod spill_index;
|
||||
|
||||
@@ -0,0 +1,149 @@
|
||||
//! GETPIVOTDATA: a value from a PivotTable report, found by its value field and the row and
|
||||
//! column items that locate it (Excel's documented semantics). Each PivotTable's value cells are
|
||||
//! indexed in `PivotTable::data_index` (set on refresh and saved with the report; built on first
|
||||
//! use only for a pivot loaded without one, and only when it matches the stored report); the
|
||||
//! result is read from the report cell the sheet shows.
|
||||
|
||||
use gridcraft_core::{CellError, CellRef, Value};
|
||||
use gridcraft_formula::Expr;
|
||||
use gridcraft_model::{PIVOT_INDEXER, PivotDataCell, PivotItemRef, PivotLookup, PivotTable};
|
||||
|
||||
use crate::eval::{Ev, Evaluator};
|
||||
|
||||
/// Excel allows 126 field/item pairs.
|
||||
const MAX_PAIRS: usize = 126;
|
||||
|
||||
fn same_text(a: &str, b: &str) -> bool {
|
||||
a.trim().to_lowercase() == b.trim().to_lowercase()
|
||||
}
|
||||
|
||||
/// A number matches an item with that value (dates as serials) or with that label; anything
|
||||
/// else matches the label as text. With `exact`, a number matches only an item of that value.
|
||||
fn item_matches(item: &PivotItemRef, v: &Value, exact: bool) -> bool {
|
||||
if let Value::Number(n) = v {
|
||||
if let Value::Number(x) = &item.value
|
||||
&& n == x
|
||||
{
|
||||
return true;
|
||||
}
|
||||
if exact {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if let Value::Bool(b) = v {
|
||||
return item.value == Value::Bool(*b);
|
||||
}
|
||||
v.to_text().is_ok_and(|t| same_text(&t, &item.label))
|
||||
}
|
||||
|
||||
/// Whether `cell` is the value field asked for with exactly these items.
|
||||
fn cell_matches(cell: &PivotDataCell, data_field: &str, pairs: &[(String, Value)], exact: bool) -> bool {
|
||||
(same_text(&cell.data_field, data_field) || same_text(&cell.source_col, data_field))
|
||||
&& cell.items.len() == pairs.len()
|
||||
&& pairs.iter().all(|(f, v)| cell.items.iter().any(|it| same_text(&it.field, f) && item_matches(it, v, exact)))
|
||||
}
|
||||
|
||||
fn is_axis_field(pt: &PivotTable, field: &str) -> bool {
|
||||
pt.rows.iter().chain(pt.columns.iter()).any(|f| same_text(&f.source_col, field))
|
||||
}
|
||||
|
||||
/// The value cell whose value field and items are exactly those asked for. Text items hit the
|
||||
/// hash index; numbers and booleans also match by value, which a miss falls back to scanning for.
|
||||
/// A number prefers the item of that value: two numeric items can show the same label (0.6 and 1
|
||||
/// formatted as `0`), so a label hit counts only when no item has the exact value.
|
||||
fn find<'a>(cells: &'a PivotLookup, data_field: &str, pairs: &[(String, Value)]) -> Option<&'a PivotDataCell> {
|
||||
let labels: Option<Vec<(&str, String, bool)>> =
|
||||
pairs.iter().map(|(f, v)| v.to_text().ok().map(|t| (f.as_str(), t, matches!(v, Value::Bool(_))))).collect();
|
||||
let hit = labels.as_ref().and_then(|labels| {
|
||||
let refs: Vec<(&str, &str, bool)> = labels.iter().map(|(f, t, b)| (*f, t.as_str(), *b)).collect();
|
||||
cells.find(data_field, &refs)
|
||||
});
|
||||
if pairs.iter().all(|(_, v)| matches!(v, Value::Text(_))) {
|
||||
return hit;
|
||||
}
|
||||
if let Some(c) = hit.filter(|c| cell_matches(c, data_field, pairs, true)) {
|
||||
return Some(c);
|
||||
}
|
||||
let all = cells.cells()?;
|
||||
all.iter()
|
||||
.find(|cell| cell_matches(cell, data_field, pairs, true))
|
||||
.or(hit)
|
||||
.or_else(|| all.iter().find(|cell| cell_matches(cell, data_field, pairs, false)))
|
||||
}
|
||||
|
||||
impl Evaluator<'_> {
|
||||
pub(crate) fn getpivotdata(&mut self, args: &[Expr]) -> Ev {
|
||||
match self.pivot_value(args) {
|
||||
Ok(v) => Ev::V(v),
|
||||
Err(e) => Ev::V(Value::Error(e)),
|
||||
}
|
||||
}
|
||||
|
||||
fn scalar_arg(&mut self, e: &Expr) -> Result<Value, CellError> {
|
||||
match self.value(e).scalar() {
|
||||
Value::Error(e) => Err(e),
|
||||
v => Ok(v),
|
||||
}
|
||||
}
|
||||
|
||||
fn pivot_value(&mut self, args: &[Expr]) -> Result<Value, CellError> {
|
||||
let (Some(field_expr), Some(table_expr)) = (args.first(), args.get(1)) else { return Err(CellError::Value) };
|
||||
let rest = args.get(2..).unwrap_or_default();
|
||||
if rest.len() % 2 != 0 || rest.len() / 2 > MAX_PAIRS {
|
||||
return Err(CellError::Ref);
|
||||
}
|
||||
let data_field = self.scalar_arg(field_expr)?.to_text()?;
|
||||
let area = match self.eval(table_expr) {
|
||||
Ev::R(areas) => areas.first().copied().ok_or(CellError::Ref)?,
|
||||
Ev::V(Value::Error(e)) => return Err(e),
|
||||
_ => return Err(CellError::Ref),
|
||||
};
|
||||
let mut pairs: Vec<(String, Value)> = Vec::with_capacity(rest.len() / 2);
|
||||
for pair in rest.chunks(2) {
|
||||
let (Some(f), Some(i)) = (pair.first(), pair.get(1)) else { return Err(CellError::Ref) };
|
||||
let field = self.scalar_arg(f)?.to_text()?;
|
||||
let item = self.scalar_arg(i)?;
|
||||
if pairs.iter().any(|(g, _)| same_text(g, &field)) {
|
||||
return Err(CellError::Ref);
|
||||
}
|
||||
pairs.push((field, item));
|
||||
}
|
||||
let wb = self.host.workbook();
|
||||
let sheet = wb.sheet(area.sheet).ok_or(CellError::Ref)?;
|
||||
let pt = sheet.pivots.iter().find(|p| p.last_range.is_some_and(|r| r.intersects(&area.range))).ok_or(CellError::Ref)?;
|
||||
// A report filter field may be named when the report shows exactly that one item.
|
||||
let mut axis_pairs = Vec::with_capacity(pairs.len());
|
||||
for (field, item) in pairs {
|
||||
if is_axis_field(pt, &field) {
|
||||
axis_pairs.push((field, item));
|
||||
continue;
|
||||
}
|
||||
let filter = pt.filters.iter().find(|f| same_text(&f.source_col, &field)).ok_or(CellError::Ref)?;
|
||||
let shown = match filter.selected.as_deref() {
|
||||
Some([one]) => item.to_text().is_ok_and(|t| same_text(&t, one)),
|
||||
_ => false,
|
||||
};
|
||||
if !shown {
|
||||
return Err(CellError::Ref);
|
||||
}
|
||||
}
|
||||
// The report's value cells. A pivot loaded without them builds them once; a stored report
|
||||
// that no longer matches its source gets no index at all, so the lookup is #REF! until a
|
||||
// refresh — never an index cached from a failed build, because the shared lookup keeps
|
||||
// the first one set and undo or reopen could then never rebuild it.
|
||||
if pt.data_index.cells().is_none() {
|
||||
let build = PIVOT_INDEXER.get().ok_or(CellError::Ref)?;
|
||||
if let Ok(cells) = build(wb, area.sheet, pt) {
|
||||
pt.data_index.set_cells(cells);
|
||||
}
|
||||
}
|
||||
let cell = find(&pt.data_index, &data_field, &axis_pairs).ok_or(CellError::Ref)?;
|
||||
// The value is the one the sheet shows, so the formula and the report cell always agree.
|
||||
let report = pt.last_range.ok_or(CellError::Ref)?;
|
||||
let at = CellRef::new(report.start.row.saturating_add(cell.row), report.start.col.saturating_add(cell.col));
|
||||
if !report.contains(at) {
|
||||
return Err(CellError::Ref);
|
||||
}
|
||||
Ok(sheet.value(at))
|
||||
}
|
||||
}
|
||||
+119
-4
@@ -48,6 +48,8 @@ pub struct Calc {
|
||||
/// Cells whose formulas have errors from cycles.
|
||||
pub circular: Vec<Key>,
|
||||
pub last_recalc_cells: usize,
|
||||
/// Which anchors held a spill when the current calculation started (see [`Standing`]).
|
||||
standing: Standing,
|
||||
/// The cells whose value is `#SPILL!`, kept so that finding the formulas an emptied cell or a
|
||||
/// freed spill area may unblock doesn't walk every formula or window of cells. Filled in
|
||||
/// `rebuild`, kept up to date by `cells_changed` and by the write-back of a run; an entry is
|
||||
@@ -55,6 +57,45 @@ pub struct Calc {
|
||||
spill_errors: SpillErrors,
|
||||
}
|
||||
|
||||
/// Who gets the cells when two arrays want the same ones. Excel (measured by a reviewer on
|
||||
/// PR #2483) lets the spill that already exists keep its cells, whichever anchor comes first;
|
||||
/// the other formula shows `#SPILL!`, and clearing the winner lets it spill. The rule here:
|
||||
///
|
||||
/// 1. an anchor that held a spill before this calculation outranks one that did not;
|
||||
/// 2. otherwise the anchor first in reading order (row, then column) wins.
|
||||
///
|
||||
/// Rule 2 alone decides when nothing is remembered, so the result never depends on hash order
|
||||
/// or evaluation order. A full recalculation remembers the layout the sheet held before it
|
||||
/// started (rule 1), so it agrees with the incremental one; a workbook that is calculated for
|
||||
/// the first time has no such layout (rule 2 only).
|
||||
///
|
||||
/// Known limits: (a) the xlsx reader does not restore spill layouts, so a workbook opened from a
|
||||
/// file is laid out by rule 2 alone, although Excel keeps the layout the file records; (b) when
|
||||
/// both anchors held a spill and one grows into the other, rule 2 decides, where Excel keeps
|
||||
/// the cells the other already owns.
|
||||
#[derive(Clone, Debug, Default)]
|
||||
struct Standing {
|
||||
/// `true`: `keys` are the anchors that held a spill (full recalculation, which lays every
|
||||
/// spill out afresh). `false`: `keys` are the formulas that held none (incremental).
|
||||
held: bool,
|
||||
keys: HashSet<Key>,
|
||||
}
|
||||
|
||||
impl Standing {
|
||||
fn had_spill(&self, k: Key) -> bool {
|
||||
self.keys.contains(&k) == self.held
|
||||
}
|
||||
|
||||
/// Whether `a` takes cells from `b` when both want them.
|
||||
fn outranks(&self, a: Key, b: Key) -> bool {
|
||||
match (self.had_spill(a), self.had_spill(b)) {
|
||||
(true, false) => true,
|
||||
(false, true) => false,
|
||||
_ => (a.1.row, a.1.col) < (b.1.row, b.1.col),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A set of cells by row, each row's columns in their own set: a window of rows and columns is
|
||||
/// found by one column range per row that has an entry, so the cost follows the cells in the
|
||||
/// window, not those to the side of it in the same rows.
|
||||
@@ -101,6 +142,7 @@ impl Default for Calc {
|
||||
fixed_now: None,
|
||||
circular: vec![],
|
||||
last_recalc_cells: 0,
|
||||
standing: Standing::default(),
|
||||
spill_errors: SpillErrors::default(),
|
||||
}
|
||||
}
|
||||
@@ -269,6 +311,14 @@ impl Calc {
|
||||
/// Recalculates every formula (F9 / Ctrl+Alt+F9, and after loading).
|
||||
pub fn recalc_all(&mut self, wb: &mut Workbook) {
|
||||
self.rebuild(wb);
|
||||
// The layout the sheets hold now decides who keeps cells two arrays both want.
|
||||
// (A Python cell that holds a spill counts too, as it does in the incremental pass.)
|
||||
let mut held = HashSet::default();
|
||||
for i in 0..wb.sheets.len() {
|
||||
if let Some(sh) = wb.sheet(i) {
|
||||
held.extend(sh.spill_ranges.keys().filter(|a| sh.cell(**a).is_some_and(|c| c.formula.is_some() || c.py.is_some())).map(|a| (i, *a)));
|
||||
}
|
||||
}
|
||||
// Spills are laid out again from the formulas where they are now (a structural edit moves
|
||||
// or deletes the formulas, not the values they spilled).
|
||||
for i in 0..wb.sheets.len() {
|
||||
@@ -280,7 +330,9 @@ impl Calc {
|
||||
}
|
||||
}
|
||||
let all: Vec<Key> = self.graph.nodes.keys().copied().collect();
|
||||
self.standing = Standing { held: true, keys: held };
|
||||
self.run(wb, all, true);
|
||||
self.standing = Standing::default();
|
||||
}
|
||||
|
||||
/// Updates the graph for cells whose content changed and recalculates what depends on them.
|
||||
@@ -391,6 +443,13 @@ impl Calc {
|
||||
}
|
||||
}
|
||||
}
|
||||
// So can the area a removed formula spilled over.
|
||||
for (si, r) in &cleared {
|
||||
match emptied.iter_mut().find(|x| x.0 == *si) {
|
||||
Some(x) => x.1 = CellRef::new(x.1.row.max(r.end.row), x.1.col.max(r.end.col)),
|
||||
None => emptied.push((*si, r.end)),
|
||||
}
|
||||
}
|
||||
// An emptied cell can unblock an anchor any distance above or to the left of it.
|
||||
for (si, end) in emptied {
|
||||
seeds.extend(self.unblock_candidates(wb, si, end));
|
||||
@@ -472,10 +531,22 @@ impl Calc {
|
||||
fn run(&mut self, wb: &mut Workbook, mut dirty: Vec<Key>, full: bool) {
|
||||
let mut dynamic_again = !self.graph.dynamic.is_empty();
|
||||
self.last_recalc_cells = 0;
|
||||
let mut seen: HashSet<Key> = HashSet::default();
|
||||
if !full {
|
||||
self.standing = Standing::default();
|
||||
}
|
||||
for _round in 0..8 {
|
||||
if dirty.is_empty() {
|
||||
break;
|
||||
}
|
||||
if !full {
|
||||
// What each formula held before this calculation touched it.
|
||||
for &k in &dirty {
|
||||
if seen.insert(k) && wb.sheet(k.0).is_some_and(|s| !s.spill_ranges.contains_key(&k.1)) {
|
||||
self.standing.keys.insert(k);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Row-major order is a good topological guess; on-demand evaluation fixes the rest.
|
||||
dirty.sort_by_key(|(s, c)| (*s, c.row, c.col));
|
||||
let mut exprs: HashMap<Key, std::sync::Arc<Expr>> = HashMap::with_capacity_and_hasher(dirty.len(), Default::default());
|
||||
@@ -493,6 +564,7 @@ impl Calc {
|
||||
let tp = prof_now();
|
||||
let (results, spills, cycles) = {
|
||||
let mut host = PassHost::new(wb, &exprs, &mut rng, now).with_python(python);
|
||||
host.standing = Some(&self.standing);
|
||||
host.iterate = wb.calc.iterative;
|
||||
for k in &dirty {
|
||||
host.calculate(*k);
|
||||
@@ -591,7 +663,40 @@ impl Calc {
|
||||
if let Some(array) = new {
|
||||
let end = CellRef::new(key.1.row.saturating_add(array.rows as u32 - 1), key.1.col.saturating_add(array.cols as u32 - 1));
|
||||
let range = RangeRef::new(key.1, end);
|
||||
let blocked = spill_is_blocked(sheet, key.1, range, end);
|
||||
// Two arrays that want the same cells (see [`Standing`]): a spill already laid out
|
||||
// that this anchor outranks is taken over, and recalculated.
|
||||
let standing = &self.standing;
|
||||
// A spill can only be in the way where it has cells besides its anchor, and an
|
||||
// anchor itself blocks the array. When no spilled cell lies in the range, the owners
|
||||
// are not scanned: a full recalculation of many disjoint spills stays linear.
|
||||
let outranked: Vec<(CellRef, RangeRef)> = if range.iter().any(|cell| cell != key.1 && sheet.spill.contains_key(&cell)) {
|
||||
#[cfg(test)]
|
||||
OWNER_SCANS.with(|n| n.set(n.get() + 1));
|
||||
sheet
|
||||
.spill_ranges
|
||||
.iter()
|
||||
.filter(|(o, r)| **o != key.1 && r.intersects(&range) && standing.outranks(*key, (key.0, **o)))
|
||||
.map(|(o, r)| (*o, *r))
|
||||
.collect()
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
let blocked = spill_is_blocked(sheet, *key, range, end, standing);
|
||||
if !blocked {
|
||||
for (o, r) in outranked {
|
||||
for c in r.iter() {
|
||||
sheet.spill.remove(&c);
|
||||
}
|
||||
sheet.spill_ranges.remove(&o);
|
||||
if let Some(cell) = sheet.cells.get_mut(o) {
|
||||
cell.value = Value::Error(CellError::Spill);
|
||||
self.spill_errors.insert((key.0, o));
|
||||
}
|
||||
spill_changes.push((key.0, o));
|
||||
self.graph.dependents_of_range(key.0, r, &mut spill_changes);
|
||||
freed.push((key.0, r));
|
||||
}
|
||||
}
|
||||
if blocked {
|
||||
if let Some(cell) = sheet.cells.get_mut(key.1) {
|
||||
cell.value = Value::Error(CellError::Spill);
|
||||
@@ -628,12 +733,22 @@ impl Calc {
|
||||
}
|
||||
}
|
||||
|
||||
fn spill_is_blocked(sheet: &gridcraft_model::Sheet, anchor: CellRef, range: RangeRef, end: CellRef) -> bool {
|
||||
// Owner scans done by `write_back`, to check that disjoint spills never walk every owner.
|
||||
#[cfg(test)]
|
||||
thread_local! {
|
||||
pub(crate) static OWNER_SCANS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
|
||||
}
|
||||
|
||||
/// Whether the array at `anchor` can't be laid out over `range`. A spill already laid out that
|
||||
/// `anchor` outranks does not block it: it is taken over when written back.
|
||||
fn spill_is_blocked(sheet: &gridcraft_model::Sheet, anchor: Key, range: RangeRef, end: CellRef, standing: &Standing) -> bool {
|
||||
let outranked =
|
||||
|cell: CellRef| sheet.spill_ranges.iter().any(|(o, r)| *o != anchor.1 && r.contains(cell) && standing.outranks(anchor, (anchor.0, *o)));
|
||||
end.row >= gridcraft_core::MAX_ROWS
|
||||
|| end.col >= gridcraft_core::MAX_COLS
|
||||
|| range.iter().any(|cell| cell != anchor && (sheet.cells.has(cell) || sheet.spill.contains_key(&cell)))
|
||||
|| range.iter().any(|cell| cell != anchor.1 && (sheet.cells.has(cell) || (sheet.spill.contains_key(&cell) && !outranked(cell))))
|
||||
|| sheet.merges.iter().any(|merge| merge.intersects(&range))
|
||||
|| sheet.tables.iter().any(|table| table.range.contains(anchor))
|
||||
|| sheet.tables.iter().any(|table| table.range.contains(anchor.1))
|
||||
}
|
||||
|
||||
fn fill_spill(sheet: &mut gridcraft_model::Sheet, anchor: CellRef, range: RangeRef, array: &Array) {
|
||||
|
||||
@@ -31,6 +31,8 @@ pub(super) struct PassHost<'a> {
|
||||
/// every row, so once per sheet rather than once per range read.
|
||||
used: HashMap<usize, Option<RangeRef>>,
|
||||
rng: &'a mut u64,
|
||||
/// Who held a spill before the calculation; unset: every formula did (reading order decides).
|
||||
pub(super) standing: Option<&'a super::Standing>,
|
||||
now: f64,
|
||||
cycle: bool,
|
||||
pub(super) cycles: Vec<Key>,
|
||||
@@ -99,6 +101,7 @@ impl<'a> PassHost<'a> {
|
||||
spill_index: SpillIndex::default(),
|
||||
used: HashMap::default(),
|
||||
rng,
|
||||
standing: None,
|
||||
now,
|
||||
cycle: false,
|
||||
cycles: vec![],
|
||||
@@ -160,19 +163,26 @@ fn spill_hits_overlap(index: &SpillIndex, sheet: usize, hits: &[CellRef], range:
|
||||
}
|
||||
|
||||
/// Whether an array result at `k` can't spill: it is in a table, or its area runs off the sheet,
|
||||
/// overlaps merged cells, holds other cells, or another formula's spill (unless that formula is
|
||||
/// recalculated in this pass, and so may spill elsewhere now).
|
||||
/// overlaps merged cells, holds other cells, or the spill of another formula that outranks it
|
||||
/// (see `Standing`; unless that formula is recalculated in this pass, and so may spill elsewhere
|
||||
/// now). A spill it outranks gives way to it when written back.
|
||||
fn spill_blocked(host: &PassHost<'_>, (sheet, anchor): Key, a: &Array) -> bool {
|
||||
let Some(sh) = host.wb.sheet(sheet) else { return false };
|
||||
let end =
|
||||
CellRef::new(anchor.row.saturating_add((a.rows as u32).saturating_sub(1)), anchor.col.saturating_add((a.cols as u32).saturating_sub(1)));
|
||||
let range = RangeRef::new(anchor, end);
|
||||
let own = sh.spill_ranges.get(&anchor);
|
||||
let default = super::Standing::default();
|
||||
let standing = host.standing.unwrap_or(&default);
|
||||
let spilled_over = |c: CellRef| {
|
||||
!own.is_some_and(|o| o.contains(c))
|
||||
&& sh.spill_ranges.iter().any(|(o, r)| {
|
||||
// A formula or Python cell recalculated in this pass lays its array out again.
|
||||
*o != anchor && r.contains(c) && !host.exprs.contains_key(&(sheet, *o)) && !host.python.contains_key(&(sheet, *o))
|
||||
*o != anchor
|
||||
&& r.contains(c)
|
||||
&& !host.exprs.contains_key(&(sheet, *o))
|
||||
&& !host.python.contains_key(&(sheet, *o))
|
||||
&& standing.outranks((sheet, *o), (sheet, anchor))
|
||||
})
|
||||
};
|
||||
end.row >= gridcraft_core::MAX_ROWS
|
||||
|
||||
@@ -2331,6 +2331,85 @@ fn median_large_values_recalculate_dependents() {
|
||||
}
|
||||
}
|
||||
|
||||
/// #2183: `INDEX(…):INDEX(…):…` used to re-walk each operand of the left-associative range chain,
|
||||
/// costing 2^k for k operands (28 took 40 s; 60 would take millennia), on open and on every edit.
|
||||
#[test]
|
||||
fn range_operator_chain_precedents_are_linear() {
|
||||
let operands: Vec<String> = (1..=60).map(|i| format!("INDEX(A{i},1)")).collect();
|
||||
let src = format!("=SUM({})", operands.join(":"));
|
||||
let e = gridcraft_formula::parse(&src).unwrap();
|
||||
let wb = Workbook::new();
|
||||
// With the old 2^k walk this call would never return; #2183 asks for under 100 ms.
|
||||
#[allow(clippy::disallowed_methods)] // a native test: the clock is there
|
||||
let t0 = std::time::Instant::now();
|
||||
let (areas, dynamic) = crate::eval::precedents(&wb, 0, &e);
|
||||
let took = t0.elapsed();
|
||||
assert!(took < std::time::Duration::from_millis(100), "precedents took {took:?}");
|
||||
assert!(!dynamic);
|
||||
// The chain covers A1:A60, not only the 60 cells named in it.
|
||||
let whole = gridcraft_core::RangeRef::new(c("A1"), c("A60"));
|
||||
assert!(areas.iter().any(|a| a.sheet == 0 && a.range == whole), "{areas:?}");
|
||||
// Each node is visited once: 60 references plus one box per range operator.
|
||||
assert!(areas.len() < 200, "{} areas", areas.len());
|
||||
|
||||
// Through the recalculation engine: setting it finishes and editing a cell in the box recalculates.
|
||||
let mut t = T::new();
|
||||
for i in 1..=60 {
|
||||
t.set(&format!("A{i}"), "1");
|
||||
}
|
||||
t.set("B1", &src);
|
||||
assert_eq!(t.num("B1"), 60.0);
|
||||
t.set("A30", "5");
|
||||
assert_eq!(t.num("B1"), 64.0);
|
||||
}
|
||||
|
||||
/// A chained range of plain references (`A1:B2:C3`, which the parser can't fold into one
|
||||
/// reference) covers their bounding box, as the evaluator expands it: an edit inside the box but
|
||||
/// outside each operand still recalculates.
|
||||
#[test]
|
||||
fn chained_plain_range_precedents_cover_the_bounding_box() {
|
||||
let e = gridcraft_formula::parse("=SUM(A1:B2:C3)").unwrap();
|
||||
let (areas, dynamic) = crate::eval::precedents(&Workbook::new(), 0, &e);
|
||||
assert!(!dynamic);
|
||||
let whole = gridcraft_core::RangeRef::new(c("A1"), c("C3"));
|
||||
assert!(areas.iter().any(|a| a.sheet == 0 && a.range == whole), "{areas:?}");
|
||||
|
||||
let mut t = T::new();
|
||||
t.set("A1", "1");
|
||||
t.set("E1", "=SUM(A1:B2:C3)");
|
||||
assert_eq!(t.num("E1"), 1.0);
|
||||
t.set("C1", "4");
|
||||
assert_eq!(t.num("E1"), 5.0);
|
||||
}
|
||||
|
||||
/// `precedents` walks with an explicit stack: an expression nested deeper than any formula
|
||||
/// within the length limit can build still finds its references, on a small stack.
|
||||
#[test]
|
||||
fn precedents_of_deep_nesting_do_not_recurse() {
|
||||
let (areas, dynamic) = std::thread::Builder::new()
|
||||
.stack_size(256 * 1024)
|
||||
.spawn(|| {
|
||||
let mut e = gridcraft_formula::parse("=A1").unwrap();
|
||||
for _ in 0..10_000 {
|
||||
e = gridcraft_formula::Expr::Paren(Box::new(e));
|
||||
}
|
||||
let found = crate::eval::precedents(&Workbook::new(), 0, &e);
|
||||
// Dropping the deep tree recurses; leak it so only `precedents` is under test.
|
||||
std::mem::forget(e);
|
||||
found
|
||||
})
|
||||
.unwrap()
|
||||
.join()
|
||||
.unwrap();
|
||||
assert!(!dynamic);
|
||||
assert_eq!(areas.len(), 1);
|
||||
// Shallow nesting stays static.
|
||||
let e = gridcraft_formula::parse("=((((A1))))").unwrap();
|
||||
let (areas, dynamic) = crate::eval::precedents(&Workbook::new(), 0, &e);
|
||||
assert!(!dynamic);
|
||||
assert_eq!(areas.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cell_filename_names_the_workbook_file() {
|
||||
// Excel returns `<folder>/[<file>]<sheet>`, and the classic sheet-name formula splits it on
|
||||
@@ -2881,6 +2960,105 @@ fn formulas_read_a_dirty_python_cell_after_it_is_laid_out() {
|
||||
assert_eq!((t.num("A1"), t.num("A2"), t.num("A3")), (5.0, 100.0, 111.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn disjoint_spills_do_not_scan_every_spill_owner() {
|
||||
// Many independent two-cell arrays: write-back must not walk all earlier owners for each one.
|
||||
let mut t = T::new();
|
||||
for i in 1..=2000 {
|
||||
t.wb.sheet_mut(0).unwrap().cells.set(c(&format!("A{}", i * 2 - 1)), Cell::formula(Formula::new("=SEQUENCE(2)")));
|
||||
}
|
||||
crate::recalc::OWNER_SCANS.with(|n| n.set(0));
|
||||
t.calc.recalc_all(&mut t.wb);
|
||||
assert_eq!((t.num("A2"), t.num("A4000")), (2.0, 2.0));
|
||||
let scans = crate::recalc::OWNER_SCANS.with(|n| n.get());
|
||||
assert!(scans < 10, "{scans} owner scans for 2000 disjoint spills");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn overlapping_spill_edit_sequences_match_a_full_recalc() {
|
||||
// Random short edit sequences on a small grid of arrays that run into each other (sizes from
|
||||
// shared cells, so one edit resizes several at once), with constants and clears in their way.
|
||||
// After every edit the incremental result must equal a full recalc of the same workbook.
|
||||
let seeds: u64 = std::env::var("GRIDCRAFT_SPILL_SEEDS").ok().and_then(|v| v.parse().ok()).unwrap_or(200);
|
||||
let steps: usize = std::env::var("GRIDCRAFT_SPILL_STEPS").ok().and_then(|v| v.parse().ok()).unwrap_or(20);
|
||||
let only: Option<u64> = std::env::var("GRIDCRAFT_SPILL_SEED").ok().and_then(|v| v.parse().ok());
|
||||
let next = |state: &mut u64| {
|
||||
*state = state.wrapping_add(0x9E37_79B9_7F4A_7C15);
|
||||
let mut z = *state;
|
||||
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
|
||||
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
|
||||
z ^ (z >> 31)
|
||||
};
|
||||
let seeds: Vec<u64> = match only {
|
||||
Some(s) => vec![s],
|
||||
None => (0..seeds).collect(),
|
||||
};
|
||||
for seed in seeds {
|
||||
let mut state = seed;
|
||||
let mut t = T::new();
|
||||
// Sizes in J1:J4.
|
||||
for (i, n) in [2, 3, 1, 4].iter().enumerate() {
|
||||
t.set(&format!("J{}", i + 1), &n.to_string());
|
||||
}
|
||||
let mut log: Vec<(String, String)> = Vec::new();
|
||||
for step in 0..steps {
|
||||
let r = next(&mut state);
|
||||
let at = format!("{}{}", (b'A' + (r % 6) as u8) as char, 1 + (r >> 8) % 6);
|
||||
let kind = (r >> 16) % 14;
|
||||
let (at, input) = match kind {
|
||||
0..=3 => {
|
||||
let a = 1 + (r >> 24) % 4;
|
||||
let b = 1 + (r >> 28) % 4;
|
||||
(at, format!("=SEQUENCE($J${a},$J${b})"))
|
||||
}
|
||||
4 => (at, format!("=SEQUENCE({},{})", 1 + (r >> 24) % 3, 1 + (r >> 28) % 3)),
|
||||
5 => (format!("J{}", 1 + (r >> 24) % 4), (1 + (r >> 28) % 4).to_string()),
|
||||
6 => (at, "x".to_string()),
|
||||
7 | 8 => (at, String::new()),
|
||||
9 => (format!("K{}", 1 + (r >> 24) % 6), "=SUM(A1:F6)".to_string()),
|
||||
10 => {
|
||||
// An earlier edit again (often putting back what a cell held before, as undo does).
|
||||
match log.len() {
|
||||
0 => (at, String::new()),
|
||||
n => log[(r >> 24) as usize % n].clone(),
|
||||
}
|
||||
}
|
||||
11 => (format!("{}{}", (b'A' + ((r >> 24) % 6) as u8) as char, 1 + (r >> 32) % 6), (1 + (r >> 40) % 3).to_string()),
|
||||
// Several cells in one edit (a fill, or clearing a range): a 2x2 block from `at`.
|
||||
12 => (format!("{at}+"), String::new()),
|
||||
_ => (format!("{at}+"), format!("=SEQUENCE($J${},$J${})", 1 + (r >> 24) % 4, 1 + (r >> 28) % 4)),
|
||||
};
|
||||
log.push((at.clone(), input.clone()));
|
||||
if let Some(from) = at.strip_suffix('+') {
|
||||
let from = c(from);
|
||||
let keys: Vec<(usize, CellRef)> =
|
||||
(0..2).flat_map(|dr| (0..2).map(move |dc| (0, CellRef { row: from.row + dr, col: from.col + dc }))).collect();
|
||||
for k in &keys {
|
||||
let cell = if input.is_empty() { Cell::value(Value::Empty) } else { Cell::formula(Formula::new(&input)) };
|
||||
t.wb.sheet_mut(0).unwrap().cells.set(k.1, cell);
|
||||
}
|
||||
t.calc.cells_changed(&mut t.wb, &keys);
|
||||
} else {
|
||||
t.set(&at, &input);
|
||||
}
|
||||
let mut fresh = t.wb.clone();
|
||||
Calc::new().recalc_all(&mut fresh);
|
||||
let (a, b) = (t.wb.sheet(0).unwrap(), fresh.sheet(0).unwrap());
|
||||
for row in 0..12 {
|
||||
for col in 0..12 {
|
||||
let cell = CellRef { row, col };
|
||||
assert_eq!(a.value(cell), b.value(cell), "seed {seed} step {step}: {cell} incremental vs full recalc after {log:?}");
|
||||
}
|
||||
}
|
||||
let mut ka: Vec<_> = a.spill_ranges.iter().map(|(k, v)| (*k, *v)).collect();
|
||||
let mut kb: Vec<_> = b.spill_ranges.iter().map(|(k, v)| (*k, *v)).collect();
|
||||
ka.sort_by_key(|(k, _)| (k.row, k.col));
|
||||
kb.sort_by_key(|(k, _)| (k.row, k.col));
|
||||
assert_eq!(ka, kb, "seed {seed} step {step}: spill layout after {log:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A computed criterion whose formula runs a database function over the same criteria counts as
|
||||
/// not met inside itself: before, each record's check ran the function again for every record, at
|
||||
/// every level, so the work grew exponentially with the nesting allowed.
|
||||
|
||||
@@ -26,7 +26,7 @@ use serde::{Deserialize, Serialize};
|
||||
pub use axis::{Scale, format_number, nice_scale};
|
||||
pub use raster::rasterize;
|
||||
pub use render::{Swatch, legend_entries, render, supports_trendline};
|
||||
pub use resolve::{default_palette, resolve, series_color, series_plot_kind};
|
||||
pub use resolve::{default_palette, has_volatile_series, resolve, series_color, series_plot_kind};
|
||||
pub use sparkline::render_sparkline;
|
||||
|
||||
/// Straight (non-premultiplied) RGBA colour.
|
||||
|
||||
+126
-5
@@ -155,6 +155,131 @@ fn eval_list_in(wb: &Workbook, sheet: usize, formula: &str, limit: usize, depth:
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether a series formula of `ch` (chart of `sheet`) calls a function whose result changes
|
||||
/// between evaluations (`NOW`, `TODAY`, `RAND`, `RANDBETWEEN`, `RANDARRAY`), so a result resolved
|
||||
/// earlier is stale. Defined names the formulas use (`=FreshClock`, `Sheet1!Rates`, a LAMBDA name)
|
||||
/// are followed into their own formulas, the way the evaluator looks them up; each name once per
|
||||
/// chart, so a cycle ends. Names nested deeper than [`MAX_NAME_DEPTH`], or more than
|
||||
/// [`MAX_NAMES_FOLLOWED`] distinct names, count as volatile: a chart whose stability isn't
|
||||
/// established is not cached.
|
||||
pub fn has_volatile_series(wb: &Workbook, sheet: usize, ch: &Chart) -> bool {
|
||||
let mut seen = Seen::new();
|
||||
ch.series.iter().any(|s| {
|
||||
[s.name.as_deref(), s.categories.as_deref(), Some(s.values.as_str()), s.bubble_sizes.as_deref()]
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.any(|f| formula_volatile(wb, sheet, f, 0, &mut seen))
|
||||
})
|
||||
}
|
||||
|
||||
/// Names followed inside names before a formula counts as volatile.
|
||||
const MAX_NAME_DEPTH: u32 = 8;
|
||||
/// Distinct defined names followed per chart before the chart counts as volatile.
|
||||
const MAX_NAMES_FOLLOWED: usize = 64;
|
||||
|
||||
/// Defined names already followed for one chart, each with the sheet its formula is read on.
|
||||
type Seen<'a> = Vec<(&'a gridcraft_model::DefinedName, usize)>;
|
||||
|
||||
fn formula_volatile<'a>(wb: &'a Workbook, sheet: usize, f: &str, depth: u32, seen: &mut Seen<'a>) -> bool {
|
||||
if calls_volatile(f) {
|
||||
return true;
|
||||
}
|
||||
name_tokens(f).into_iter().any(|t| {
|
||||
let Some((n, at)) = defined_name(wb, sheet, t) else { return false };
|
||||
// Followed already, or being followed (a cycle): a volatile call in it is found there.
|
||||
if seen.iter().any(|&(m, s)| std::ptr::eq(m, n) && s == at) {
|
||||
return false;
|
||||
}
|
||||
if depth >= MAX_NAME_DEPTH || seen.len() >= MAX_NAMES_FOLLOWED {
|
||||
return true;
|
||||
}
|
||||
seen.push((n, at));
|
||||
formula_volatile(wb, at, &n.formula, depth + 1, seen)
|
||||
})
|
||||
}
|
||||
|
||||
/// Whether formula text `f` calls one of the volatile functions by name.
|
||||
fn calls_volatile(f: &str) -> bool {
|
||||
const VOLATILE: [&str; 5] = ["NOW", "TODAY", "RAND", "RANDBETWEEN", "RANDARRAY"];
|
||||
// Formulas read from a file may carry the `_xlfn.` prefix of newer functions.
|
||||
let up = f.to_ascii_uppercase().replace("_XLFN.", "");
|
||||
VOLATILE.iter().any(|name| {
|
||||
up.match_indices(name).any(|(i, _)| {
|
||||
let before = up[..i].chars().next_back();
|
||||
let after = up[i + name.len()..].trim_start();
|
||||
before.is_none_or(|c| !(c.is_alphanumeric() || c == '_' || c == '.')) && after.starts_with('(')
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
fn is_ident_char(c: char) -> bool {
|
||||
c.is_alphanumeric() || c == '_' || c == '.' || c == '\\'
|
||||
}
|
||||
|
||||
/// End of the identifier starting at byte `from` of `f`.
|
||||
fn ident_end(f: &str, from: usize) -> usize {
|
||||
f[from..].char_indices().find(|&(_, c)| !is_ident_char(c)).map_or(f.len(), |(j, _)| from + j)
|
||||
}
|
||||
|
||||
/// End (past the closing quote) of the `q`-quoted text opening at byte `from`; a doubled quote
|
||||
/// is an escaped one. `None` when it is not closed.
|
||||
fn quoted_end(f: &str, from: usize, q: char) -> Option<usize> {
|
||||
let mut i = from + q.len_utf8();
|
||||
loop {
|
||||
let j = i + f[i..].find(q)?;
|
||||
if f[j + q.len_utf8()..].starts_with(q) {
|
||||
i = j + 2 * q.len_utf8();
|
||||
} else {
|
||||
return Some(j + q.len_utf8());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The words of formula text `f` that may be defined names: `Name`, `Sheet1!Name`,
|
||||
/// `'Bob''s'!Name`. String literals and numbers are skipped; function names, column letters and
|
||||
/// the like come along too and simply aren't found as names.
|
||||
fn name_tokens(f: &str) -> Vec<&str> {
|
||||
let mut out = Vec::new();
|
||||
let mut i = 0;
|
||||
while let Some(c) = f[i..].chars().next() {
|
||||
let start = i;
|
||||
let end = match c {
|
||||
'"' => {
|
||||
i = quoted_end(f, i, '"').unwrap_or(f.len());
|
||||
continue;
|
||||
}
|
||||
'\'' => quoted_end(f, i, '\'').unwrap_or(f.len()),
|
||||
c if is_ident_char(c) => ident_end(f, i),
|
||||
c => {
|
||||
i += c.len_utf8();
|
||||
continue;
|
||||
}
|
||||
};
|
||||
i = end;
|
||||
if f[end..].starts_with('!') {
|
||||
let e = ident_end(f, end + 1);
|
||||
if e > end + 1 {
|
||||
out.push(&f[start..e]);
|
||||
}
|
||||
i = e;
|
||||
} else if c != '\'' && !c.is_ascii_digit() {
|
||||
out.push(&f[start..end]);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The defined name `t` (`Name` or `Sheet1!Name`) seen from `sheet`, and the sheet its own
|
||||
/// formula is read on.
|
||||
fn defined_name<'a>(wb: &'a Workbook, sheet: usize, t: &str) -> Option<(&'a gridcraft_model::DefinedName, usize)> {
|
||||
// `'Bob''s'!Name`: the sheet is unquoted as everywhere else (#2012).
|
||||
let (at, bare) = match gridcraft_core::split_sheet(t) {
|
||||
(Some(s), bare) => (wb.sheet_index(&s)?, bare),
|
||||
(None, bare) => (sheet, bare),
|
||||
};
|
||||
wb.name(bare, at).map(|n| (n, n.scope.unwrap_or(at)))
|
||||
}
|
||||
|
||||
fn to_num(v: &Value) -> Option<f64> {
|
||||
match v {
|
||||
Value::Number(n) if n.is_finite() => Some(*n),
|
||||
@@ -305,11 +430,7 @@ fn category_table(wb: &Workbook, sheet: usize, formula: &str, values: &str, limi
|
||||
/// Whether `t` names a defined name seen from `sheet` (`Name`, or `Sheet1!Name` looked up on
|
||||
/// that sheet), the way the evaluator looks names up.
|
||||
fn is_defined_name(wb: &Workbook, sheet: usize, t: &str) -> bool {
|
||||
// `'Bob''s'!Name`: the sheet is unquoted as everywhere else (#2012).
|
||||
match gridcraft_core::split_sheet(t) {
|
||||
(Some(s), bare) => wb.sheet_index(&s).is_some_and(|i| wb.name(bare, i).is_some()),
|
||||
(None, _) => wb.name(t, sheet).is_some(),
|
||||
}
|
||||
defined_name(wb, sheet, t).is_some()
|
||||
}
|
||||
|
||||
/// A series name: a reference/formula or a defined name (`[0]!Title` in a file) is evaluated,
|
||||
|
||||
@@ -1680,3 +1680,96 @@ fn a_series_named_by_a_name_on_a_sheet_with_a_bang_resolves() {
|
||||
let d = resolve(&wb, 0, &c);
|
||||
assert_eq!(d.series.first().map(|s| s.name.as_str()), Some("Takings"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn volatile_series_formulas_are_detected() {
|
||||
let wb = Workbook::new();
|
||||
let with = |values: &str, name: Option<&str>| {
|
||||
let mut c = chart(ChartKind::Line);
|
||||
c.series.push(Series {
|
||||
name: name.map(Into::into),
|
||||
categories: None,
|
||||
values: values.into(),
|
||||
bubble_sizes: None,
|
||||
color: None,
|
||||
secondary: false,
|
||||
kind: None,
|
||||
smooth: false,
|
||||
quartiles: Default::default(),
|
||||
trendlines: vec![],
|
||||
});
|
||||
c
|
||||
};
|
||||
assert!(has_volatile_series(&wb, 0, &with("=NOW()", None)));
|
||||
assert!(has_volatile_series(&wb, 0, &with("=SUM(A1:A3)*rand ()", None)));
|
||||
assert!(has_volatile_series(&wb, 0, &with("Sheet1!$B$2:$B$9", Some("=TODAY()"))));
|
||||
assert!(has_volatile_series(&wb, 0, &with("=RANDARRAY(5)", None)));
|
||||
assert!(has_volatile_series(&wb, 0, &with("=_xlfn.RANDARRAY(5)", None)));
|
||||
assert!(!has_volatile_series(&wb, 0, &with("Sheet1!$B$2:$B$9", Some("Sheet1!$B$1"))));
|
||||
assert!(!has_volatile_series(&wb, 0, &with("=MYRAND(A1)", None)));
|
||||
assert!(!has_volatile_series(&wb, 0, &with("=Sheet1!$NOW", None)));
|
||||
assert!(!has_volatile_series(&wb, 0, &chart(ChartKind::Line)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn volatile_defined_names_are_followed() {
|
||||
let with = |values: &str| {
|
||||
let mut c = chart(ChartKind::Line);
|
||||
c.series.push(Series {
|
||||
name: None,
|
||||
categories: None,
|
||||
values: values.into(),
|
||||
bubble_sizes: None,
|
||||
color: None,
|
||||
secondary: false,
|
||||
kind: None,
|
||||
smooth: false,
|
||||
quartiles: Default::default(),
|
||||
trendlines: vec![],
|
||||
});
|
||||
c
|
||||
};
|
||||
let name = |name: &str, scope: Option<usize>, formula: &str| gridcraft_model::DefinedName {
|
||||
name: name.into(),
|
||||
scope,
|
||||
formula: formula.into(),
|
||||
comment: String::new(),
|
||||
hidden: false,
|
||||
};
|
||||
let mut wb = Workbook::new();
|
||||
wb.sheet_mut(0).unwrap().name = "Bob's".into();
|
||||
wb.names.push(name("FreshClock", None, "NOW()"));
|
||||
wb.names.push(name("Later", None, "FreshClock+1"));
|
||||
wb.names.push(name("Dice", Some(0), "RANDBETWEEN(1,6)"));
|
||||
wb.names.push(name("Rates", None, "'Bob''s'!$A$1:$A$3"));
|
||||
wb.names.push(name("Loop", None, "Loop+1"));
|
||||
wb.names.push(name("Spin", None, "Spin+NOW()"));
|
||||
wb.names.push(name("Roll", None, "LAMBDA(n,n*RAND())"));
|
||||
// A workbook-scoped name, a name used inside another, and a sheet-scoped one, bare or qualified.
|
||||
assert!(has_volatile_series(&wb, 0, &with("=FreshClock")));
|
||||
assert!(has_volatile_series(&wb, 0, &with("=SUM(Later, 1)")));
|
||||
assert!(has_volatile_series(&wb, 0, &with("=Dice*2")));
|
||||
assert!(has_volatile_series(&wb, 0, &with("='Bob''s'!Dice")));
|
||||
assert!(has_volatile_series(&wb, 0, &with("=Roll(3)")));
|
||||
// A self-referencing name ends (it evaluates to an error, not a changing value); one that
|
||||
// also calls NOW is volatile.
|
||||
assert!(!has_volatile_series(&wb, 0, &with("=Loop")));
|
||||
assert!(has_volatile_series(&wb, 0, &with("=Spin")));
|
||||
// Many series over the same stable name stay cacheable: each name is followed once.
|
||||
let mut many = with("=Rates");
|
||||
let first = many.series[0].clone();
|
||||
many.series.extend(std::iter::repeat_n(first, 100));
|
||||
assert!(!has_volatile_series(&wb, 0, &many));
|
||||
// Names nested deeper than the limit are not known to be stable.
|
||||
for i in 0..10 {
|
||||
wb.names.push(name(&format!("Deep{i}"), None, &format!("Deep{}", i + 1)));
|
||||
}
|
||||
assert!(has_volatile_series(&wb, 0, &with("=Deep0")));
|
||||
// A name that refers to cells, a name inside a string and a name of another scope are stable.
|
||||
assert!(!has_volatile_series(&wb, 0, &with("=Rates")));
|
||||
assert!(!has_volatile_series(&wb, 0, &with("=\"FreshClock\"")));
|
||||
// Dice belongs to sheet 0: seen from another sheet it isn't defined.
|
||||
wb.sheets.push(Arc::new(gridcraft_model::Sheet::new("Other")));
|
||||
assert!(!has_volatile_series(&wb, 1, &with("=Dice")));
|
||||
assert!(has_volatile_series(&wb, 1, &with("=FreshClock")));
|
||||
}
|
||||
|
||||
@@ -147,10 +147,10 @@ impl RangeRef {
|
||||
RangeRef::new(CellRef::new(0, 0), CellRef::new(MAX_ROWS - 1, MAX_COLS - 1))
|
||||
}
|
||||
pub fn height(&self) -> u32 {
|
||||
self.end.row - self.start.row + 1
|
||||
self.end.row.saturating_sub(self.start.row).saturating_add(1)
|
||||
}
|
||||
pub fn width(&self) -> u32 {
|
||||
self.end.col - self.start.col + 1
|
||||
self.end.col.saturating_sub(self.start.col).saturating_add(1)
|
||||
}
|
||||
pub fn count(&self) -> u64 {
|
||||
self.height() as u64 * self.width() as u64
|
||||
@@ -321,6 +321,13 @@ pub fn split_areas(reference: &str) -> Vec<&str> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn hostile_range_dimensions_saturate_instead_of_wrapping() {
|
||||
let r = RangeRef { start: CellRef::new(0, 0), end: CellRef::new(u32::MAX, u32::MAX) };
|
||||
assert_eq!((r.height(), r.width()), (u32::MAX, u32::MAX));
|
||||
assert_eq!(r.count(), u64::from(u32::MAX) * u64::from(u32::MAX));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn areas_split_only_at_commas_outside_quoted_sheet_names() {
|
||||
assert_eq!(split_areas("B2:B4,D1"), ["B2:B4", "D1"]);
|
||||
|
||||
@@ -454,8 +454,9 @@ pub fn number_to_text(n: f64) -> String {
|
||||
if !(1e-9..1e15).contains(&a) && a.round() != a || a >= 1e15 {
|
||||
return sci_text(n, 15);
|
||||
}
|
||||
// A value just below 1e15 can round up to 1e15 at 15 significant digits.
|
||||
if format!("{:.14e}", a).parse::<f64>().is_ok_and(|r| r >= 1e15) {
|
||||
// A value just below 1e15 can round up to 1e15 at 15 significant digits. Only that narrow
|
||||
// band pays for the exact formatting: it runs for every number literal a formula prints.
|
||||
if a >= 9.999_999_999_999_9e14 && format!("{:.14e}", a).parse::<f64>().is_ok_and(|r| r >= 1e15) {
|
||||
return sci_text(n, 15);
|
||||
}
|
||||
// 15 significant digits, trailing zeros trimmed.
|
||||
@@ -506,6 +507,9 @@ mod tests {
|
||||
assert_eq!(number_to_text(999999999999999.9), "1E+15");
|
||||
assert_eq!(number_to_text(-999999999999999.9), "-1E+15");
|
||||
assert_eq!(number_to_text(999999999999999.0), "999999999999999");
|
||||
assert_eq!(number_to_text(999999999999999.5), "1E+15");
|
||||
assert_eq!(number_to_text(999999999999999.4), "999999999999999");
|
||||
assert_eq!(number_to_text(999999999999989.9), "999999999999990");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -21,10 +21,13 @@ web-time = { workspace = true }
|
||||
thiserror = { workspace = true }
|
||||
log = { workspace = true }
|
||||
gridcraft-xlsx = { workspace = true }
|
||||
craft-csv = { workspace = true }
|
||||
craft-gridcraft-format = { workspace = true }
|
||||
gridcraft-chart = { workspace = true }
|
||||
gridcraft-pdf = { workspace = true }
|
||||
gridcraft-math = { workspace = true }
|
||||
image = { workspace = true }
|
||||
unicode-segmentation = "=1.13.3"
|
||||
|
||||
[dev-dependencies]
|
||||
gridcraft-xlsx = { workspace = true, features = ["test-support"] }
|
||||
|
||||
@@ -26,6 +26,7 @@ pub mod spelling;
|
||||
pub mod stash;
|
||||
pub mod view;
|
||||
pub mod whatif;
|
||||
pub mod wordart;
|
||||
|
||||
use gridcraft_calc::Key;
|
||||
use gridcraft_core::{CellRef, RangeRef};
|
||||
@@ -176,6 +177,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
|
||||
v.extend(extra::specs());
|
||||
v.extend(macros::specs());
|
||||
v.extend(draw::specs());
|
||||
v.extend(wordart::specs());
|
||||
v.extend(spelling::specs());
|
||||
v.extend(solver::specs());
|
||||
v.extend(pivot::specs());
|
||||
|
||||
@@ -98,7 +98,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
validation
|
||||
),
|
||||
cmd!(query "data.validate", "Check Value Against Validation", [], None, "{cell?, input} → {ok, message?}", has_doc, validate_cmd),
|
||||
cmd!(noundo "data.circleInvalid", "Circle Invalid Data", ["Data", "Data Tools", "Data Validation"], None, "{} → invalid cells", has_doc, circle_invalid),
|
||||
cmd!(noundo "data.circleInvalid", "Circle Invalid Data", ["Data", "Data Tools", "Data Validation"], None, "{} → {invalid: [cell], truncated: bool (true when the 100,000-cell scan allowance ended before every range was checked)}", has_doc, circle_invalid),
|
||||
CommandSpec {
|
||||
shortcut_mac: Some("Cmd+Shift+K"),
|
||||
..cmd!(
|
||||
|
||||
@@ -166,14 +166,15 @@ fn filter_blank(v: &Value) -> bool {
|
||||
/// A table's own filter is left to the table, and a row typed after a blank row does not count.
|
||||
/// A formula counts before it is calculated: this runs inside the edit, ahead of the recalc.
|
||||
pub(crate) fn grow_autofilter(sh: &mut Sheet, at: CellRef) {
|
||||
if !sh.cells.get(at).is_some_and(|c| !filter_blank(&c.value) || c.formula.is_some()) {
|
||||
return;
|
||||
}
|
||||
// The AutoFilter checks come first: they are cheap, and most sheets have none.
|
||||
let Some(af) = sh.autofilter.as_ref() else { return };
|
||||
let r = af.range;
|
||||
if r.end.row.checked_add(1) != Some(at.row) || at.col < r.start.col || at.col > r.end.col || sh.tables.iter().any(|t| t.range == r) {
|
||||
return;
|
||||
}
|
||||
if !sh.cells.get(at).is_some_and(|c| !filter_blank(&c.value) || c.formula.is_some()) {
|
||||
return;
|
||||
}
|
||||
let grown = RangeRef::new(r.start, CellRef::new(at.row, r.end.col));
|
||||
if let Some(af) = sh.autofilter.as_mut() {
|
||||
af.range = grown;
|
||||
@@ -184,7 +185,8 @@ pub(crate) fn grow_autofilter(sh: &mut Sheet, at: CellRef) {
|
||||
pub(crate) fn apply_filter(wb: &mut Workbook, sheet: usize) {
|
||||
let Some(sh) = wb.sheet(sheet) else { return };
|
||||
let Some(af) = sh.autofilter.clone() else { return };
|
||||
let r = af.range;
|
||||
// An imported range can name rows past the grid; none of those exist to hide.
|
||||
let r = RangeRef::new(af.range.start, CellRef::new(af.range.end.row.min(gridcraft_core::MAX_ROWS - 1), af.range.end.col));
|
||||
let mut hide = Vec::new();
|
||||
// Precompute per-criterion top10 threshold and average once, not per row.
|
||||
let mut col_stats: std::collections::HashMap<usize, (Option<f64>, f64)> = std::collections::HashMap::new();
|
||||
|
||||
@@ -283,5 +283,8 @@ pub(super) fn subtotal(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let range = RangeRef::new(CellRef::new(first, *c), CellRef::new(last - 1, *c)).a1();
|
||||
s.execute("cell.set", json!({"sheet": sheet, "cell": CellRef::new(last, *c).a1(), "input": format!("=SUBTOTAL({code},{range})")}))?;
|
||||
}
|
||||
// One outer group over every data and subtotal row, summarised by the grand total, as in
|
||||
// Excel: outline level 1 then shows only the grand total, and level 2 the subtotals.
|
||||
s.execute("data.group", json!({"sheet": sheet, "rows": format!("{}:{}", first + 1, last)}))?;
|
||||
Ok(json!({"groups": inserted}))
|
||||
}
|
||||
|
||||
@@ -119,15 +119,29 @@ fn do_sort(s: &mut Session, sheet: usize, r: RangeRef, header: bool, keys: Vec<S
|
||||
for (ki, k) in keys.iter().enumerate() {
|
||||
let (va, ca) = &keyed[a as usize][ki];
|
||||
let (vb, cb) = &keyed[b as usize][ki];
|
||||
let plain = || {
|
||||
if case && va.is_text() && vb.is_text() {
|
||||
sort_compare(va, vb).then_with(|| case_order(va.as_text().unwrap_or(""), vb.as_text().unwrap_or("")))
|
||||
} else {
|
||||
sort_compare(va, vb)
|
||||
}
|
||||
};
|
||||
let o = if k.by != "values" {
|
||||
ca.cmp(cb)
|
||||
} else if let Some(list) = &k.list {
|
||||
let pos = |v: &Value| v.as_text().and_then(|t| list.iter().position(|x| x.eq_ignore_ascii_case(t))).unwrap_or(usize::MAX);
|
||||
pos(va).cmp(&pos(vb))
|
||||
} else if case && va.is_text() && vb.is_text() {
|
||||
sort_compare(va, vb).then_with(|| case_order(va.as_text().unwrap_or(""), vb.as_text().unwrap_or("")))
|
||||
let pos = |v: &Value| v.as_text().and_then(|t| list.iter().position(|x| x.eq_ignore_ascii_case(t)));
|
||||
match (pos(va), pos(vb)) {
|
||||
(Some(a), Some(b)) => a.cmp(&b),
|
||||
(Some(_), None) => Ordering::Less,
|
||||
(None, Some(_)) => Ordering::Greater,
|
||||
// Values not in the list follow the listed ones in the usual order, as in Excel.
|
||||
// A descending key is left as it was: they tie, so the next key decides.
|
||||
// A blank has no place in the list either, but still goes last.
|
||||
(None, None) if k.desc => va.is_empty().cmp(&vb.is_empty()),
|
||||
(None, None) => plain(),
|
||||
}
|
||||
} else {
|
||||
sort_compare(va, vb)
|
||||
plain()
|
||||
};
|
||||
// Blanks always sort last, whatever the order.
|
||||
let o = if k.desc && !(va.is_empty() || vb.is_empty()) { o.reverse() } else { o };
|
||||
|
||||
@@ -40,8 +40,8 @@ fn subtotal_puts_summary_rows_below_their_detail() {
|
||||
s.execute("data.subtotal", json!({"range": "A1:B4", "groupBy": "A", "columns": ["B"]})).unwrap();
|
||||
let sh = s.doc().unwrap().wb.active().unwrap().clone();
|
||||
assert!(sh.summary_below, "the totals sit below their groups");
|
||||
// East's detail is rows 2–3 and its total row 4: collapsing level 1 keeps the total showing.
|
||||
s.execute("data.showLevels", json!({"rows": 1})).unwrap();
|
||||
// East's detail is rows 2–3 and its total row 4: showing level 2 keeps the total showing.
|
||||
s.execute("data.showLevels", json!({"rows": 2})).unwrap();
|
||||
let hidden = |s: &Session, row: u32| s.doc().unwrap().wb.active().unwrap().is_row_hidden(row);
|
||||
assert!(hidden(&s, 1) && hidden(&s, 2), "East's detail rows are hidden");
|
||||
assert!(!hidden(&s, 3), "East Total stays visible");
|
||||
|
||||
@@ -5,6 +5,9 @@ use super::{
|
||||
|
||||
// ---------------------------------------------------------------- tools
|
||||
|
||||
/// Most cells (rows times compared columns) one Remove Duplicates call reads.
|
||||
const MAX_COMPARED_CELLS: u64 = 50_000_000;
|
||||
|
||||
pub(super) fn remove_duplicates(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let (sheet, r) = data_target(s, p, "data.removeDuplicates")?;
|
||||
let d = s.doc()?;
|
||||
@@ -24,6 +27,10 @@ pub(super) fn remove_duplicates(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
if cols.is_empty() || cols.iter().any(|c| !(r.start.col..=r.end.col).contains(c)) {
|
||||
return Err(bad("data.removeDuplicates", "`columns` must name at least one column of the range"));
|
||||
}
|
||||
// Rows are compared one by one, so a sparse sheet's enclosing rectangle is bounded like a list.
|
||||
if r.count() > MAX_COMPARED_CELLS {
|
||||
return Err(bad("data.removeDuplicates", "the range is too large"));
|
||||
}
|
||||
let start = r.start.row + header as u32;
|
||||
let mut removed = 0;
|
||||
edit(s, |cx| {
|
||||
@@ -176,8 +183,11 @@ pub(super) fn split_delimited(text: &str, delims: &[char], consecutive: bool, qu
|
||||
let mut in_q = false;
|
||||
let mut last_delim = false;
|
||||
let mut chars = text.chars().peekable();
|
||||
let mut at_start = true;
|
||||
while let Some(c) = chars.next() {
|
||||
if c == quote {
|
||||
if c == quote && (in_q || at_start) {
|
||||
at_start = false;
|
||||
last_delim = false;
|
||||
if in_q && chars.peek() == Some("e) {
|
||||
cur.push(quote);
|
||||
chars.next();
|
||||
@@ -192,9 +202,11 @@ pub(super) fn split_delimited(text: &str, delims: &[char], consecutive: bool, qu
|
||||
}
|
||||
out.push(std::mem::take(&mut cur));
|
||||
last_delim = true;
|
||||
at_start = true;
|
||||
continue;
|
||||
}
|
||||
last_delim = false;
|
||||
at_start = false;
|
||||
cur.push(c);
|
||||
}
|
||||
out.push(cur);
|
||||
|
||||
@@ -337,11 +337,17 @@ pub(super) fn circle_invalid(s: &mut Session, _: &Json) -> Result<Json> {
|
||||
let sheet = d.wb.active_sheet();
|
||||
let Some(sh) = d.wb.sheet(sheet) else { return Err(EngineError::NoDocument) };
|
||||
let mut bad_cells = Vec::new();
|
||||
// One scan allowance for the whole command: duplicate or overlapping ranges don't multiply it.
|
||||
let mut budget = 100_000usize;
|
||||
// Cells were left unchecked because the allowance ran out: said in the result.
|
||||
let mut truncated = false;
|
||||
for dv in &sh.validations {
|
||||
for r in &dv.ranges {
|
||||
let r = sh.used_range().and_then(|u| r.intersection(&u));
|
||||
let Some(r) = r else { continue };
|
||||
for c in r.iter().take(100_000) {
|
||||
truncated |= r.count() > budget as u64;
|
||||
for c in r.iter().take(budget) {
|
||||
budget -= 1;
|
||||
let text = sh.input_text(c);
|
||||
if !text.is_empty() && check_validation(&d.wb, sheet, c, &text).is_some() {
|
||||
bad_cells.push(c.a1());
|
||||
@@ -349,5 +355,5 @@ pub(super) fn circle_invalid(s: &mut Session, _: &Json) -> Result<Json> {
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(json!({"invalid": bad_cells}))
|
||||
Ok(json!({"invalid": bad_cells, "truncated": truncated}))
|
||||
}
|
||||
|
||||
@@ -199,7 +199,11 @@ pub(super) fn replace(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let mut total = 0usize;
|
||||
for si in sheets {
|
||||
let cells: Vec<(CellRef, String)> =
|
||||
cx.wb.sheet(si).map(|sh| sh.cells.iter().map(|(c, _)| (c, sh.input_text(c))).collect()).unwrap_or_default();
|
||||
// A hidden formula's source is not searched: a count or error would reveal its text.
|
||||
cx.wb
|
||||
.sheet(si)
|
||||
.map(|sh| sh.cells.iter().filter(|(c, cell)| cell.formula.is_none() && cell.py.is_none() || !crate::display::formula_hidden(&cx.wb, sh, *c)).map(|(c, _)| (c, sh.input_text(c))).collect())
|
||||
.unwrap_or_default();
|
||||
for (c, text) in cells {
|
||||
if (!all && c != active) || selection.as_ref().is_some_and(|sel| !sel.contains(c)) {
|
||||
continue;
|
||||
|
||||
@@ -36,15 +36,28 @@ pub(super) fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let whole = clip.areas.is_empty() && (clip.selected.is_full_cols() || clip.selected.is_full_rows()) && clip.selected.contains_range(&clip.range);
|
||||
let src = if whole { clip.selected } else { clip.range };
|
||||
let (h, w) = if transpose { (src.width(), src.height()) } else { (src.height(), src.width()) };
|
||||
// Tile the copy over a larger destination that is a multiple of its size.
|
||||
let tile = sel.height() % h == 0
|
||||
&& sel.width() % w == 0
|
||||
// Tile the copy over a larger destination that is a multiple of its size. A selection
|
||||
// narrower than the copy but a multiple of its height takes it down every row, at the copy's
|
||||
// width (and a shorter one a multiple of its width across), as in Excel.
|
||||
let multiple = sel.height() % h == 0 && sel.width() % w == 0;
|
||||
let down = sel.width() < w && sel.height() > h && sel.height() % h == 0;
|
||||
let across = sel.height() < h && sel.width() > w && sel.width() % w == 0;
|
||||
// The cells the tiles cover: the selection itself, or for `down`/`across` the selection at the
|
||||
// copy's width/height, which can be much larger than what was selected.
|
||||
let area = if down {
|
||||
u64::from(sel.height()) * u64::from(w)
|
||||
} else if across {
|
||||
u64::from(h) * u64::from(sel.width())
|
||||
} else {
|
||||
sel.count()
|
||||
};
|
||||
let tile = (multiple || down || across)
|
||||
&& !sel.is_single()
|
||||
&& cell_param_on(s, p, "at", dest_sheet)?.is_none()
|
||||
&& !sel.is_full_cols()
|
||||
&& !sel.is_full_rows()
|
||||
&& sel.count() <= 4_000_000;
|
||||
let (tiles_r, tiles_c) = if tile { (sel.height() / h, sel.width() / w) } else { (1, 1) };
|
||||
&& area <= 4_000_000;
|
||||
let (tiles_r, tiles_c) = if tile { ((sel.height() / h).max(1), (sel.width() / w).max(1)) } else { (1, 1) };
|
||||
// A single cell or row repeated down a filtered selection skips the rows the filter hides; a
|
||||
// taller block is pasted straight down, hidden rows included, as in Excel.
|
||||
let skip_rows = match s.doc()?.wb.sheet(dest_sheet) {
|
||||
|
||||
@@ -63,6 +63,11 @@ pub(super) fn selection_move(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let d = s.doc_mut()?;
|
||||
let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) };
|
||||
let sel = &mut d.selection;
|
||||
if extend && !jmp {
|
||||
// Shift+arrows move the edge the anchor doesn't hold, keeping merged cells whole.
|
||||
sel.extend_by(sheet, dr, dc);
|
||||
return Ok(json!({"selection": sel.a1(), "active": sel.active.a1()}));
|
||||
}
|
||||
// Extension moves the far corner, not the active cell.
|
||||
let from = if extend { sel.moving_end() } else { sel.active };
|
||||
// Skip hidden rows/columns and step over merged areas.
|
||||
@@ -77,23 +82,32 @@ pub(super) fn selection_move(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
jump(sheet, from, dr.signum(), dc.signum())
|
||||
} else {
|
||||
let mut t = from.offset_clamped(dr, dc);
|
||||
if !extend && let Some(m) = sheet.merge_at(from) {
|
||||
// Leaving a merged cell moves from its edge.
|
||||
if dr > 0 {
|
||||
t = CellRef::new(m.end.offset_clamped(dr, 0).row, t.col);
|
||||
} else if dc > 0 {
|
||||
t = CellRef::new(t.row, m.end.offset_clamped(0, dc).col);
|
||||
}
|
||||
}
|
||||
let mut guard = 0;
|
||||
while (sheet.is_row_hidden(t.row) || sheet.is_col_hidden(t.col)) && guard < 100_000 {
|
||||
let n = t.offset_clamped(dr.signum(), dc.signum());
|
||||
// Step each hidden axis along its own direction, so a diagonal exit from a merge
|
||||
// (Tab-run return column) keeps its column while skipping hidden rows.
|
||||
let mut n = CellRef::new(
|
||||
if sheet.is_row_hidden(t.row) { t.offset_clamped(dr.signum(), 0).row } else { t.row },
|
||||
if sheet.is_col_hidden(t.col) { t.offset_clamped(0, dc.signum()).col } else { t.col },
|
||||
);
|
||||
if n == t {
|
||||
// The hidden axis has no direction (a move along the other axis): walk as before.
|
||||
n = t.offset_clamped(dr.signum(), dc.signum());
|
||||
}
|
||||
if n == t {
|
||||
break;
|
||||
}
|
||||
t = n;
|
||||
guard += 1;
|
||||
}
|
||||
if !extend && let Some(m) = sheet.merge_at(from) {
|
||||
// Leaving a merged cell moves from its edge.
|
||||
if dr > 0 {
|
||||
t = CellRef::new(m.end.offset_clamped(dr, 0).row, from.col);
|
||||
} else if dc > 0 {
|
||||
t = CellRef::new(from.row, m.end.offset_clamped(0, dc).col);
|
||||
}
|
||||
}
|
||||
t
|
||||
};
|
||||
if let Some(m) = sheet.merge_at(to)
|
||||
@@ -140,7 +154,29 @@ pub(super) fn selection_next(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let fwd = bool_param(p, "forward").unwrap_or(true);
|
||||
let by_row = bool_param(p, "byRow").unwrap_or(false);
|
||||
let d = s.doc_mut()?;
|
||||
d.selection.cycle(fwd, by_row);
|
||||
let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) };
|
||||
let sel = &d.selection;
|
||||
if sel.is_one_merged_cell(sheet) {
|
||||
// A selection that is just one merged cell is one cell, as in Excel: Enter and Tab leave
|
||||
// it for the next cell instead of walking the cells it covers.
|
||||
let step = if fwd { 1 } else { -1 };
|
||||
let (dr, dc) = if by_row { (0, step) } else { (step, 0) };
|
||||
selection_move(s, &json!({"dr": dr, "dc": dc}))?;
|
||||
return Ok(json!({"active": s.doc()?.selection.active.a1()}));
|
||||
}
|
||||
// Inside a larger selection the cells a merged cell covers are skipped: it is visited once,
|
||||
// at its top-left cell.
|
||||
let area = sel.current();
|
||||
let cells =
|
||||
(u64::from(area.end.row.saturating_sub(area.start.row)) + 1).saturating_mul(u64::from(area.end.col.saturating_sub(area.start.col)) + 1);
|
||||
let mut next = sel.clone();
|
||||
for _ in 0..cells.min(1 << 20) {
|
||||
next.cycle(fwd, by_row);
|
||||
if sheet.merge_at(next.active).is_none_or(|m| m.start == next.active) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
d.selection = next;
|
||||
Ok(json!({"active": d.selection.active.a1()}))
|
||||
}
|
||||
|
||||
|
||||
@@ -891,6 +891,21 @@ mod tests {
|
||||
assert!((0.75..=1.15).contains(&ratio), "Arabic {} vs Latin {}", width(0), width(1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn autofit_of_many_separate_columns_fits_only_the_selected_ones() {
|
||||
let mut s = crate::Session::new();
|
||||
s.new_workbook();
|
||||
let long = "a much longer text than the others";
|
||||
// Columns A, C, E, G, I, K are selected (six runs), the ones between hold long text too.
|
||||
let row: Vec<_> = (0..11).map(|c| if c % 2 == 0 { json!("x") } else { json!(long) }).collect();
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": [row]})).unwrap();
|
||||
s.execute("home.autofitColumnWidth", json!({"cols": "A:A,C:C,E:E,G:G,I:I,K:K"})).unwrap();
|
||||
let doc = s.doc().unwrap();
|
||||
let size = |c: u32| doc.wb.active().and_then(|sh| sh.cols.get(&c)).and_then(|e| e.size);
|
||||
assert!([0, 2, 4, 6, 8, 10].iter().all(|&c| size(c).is_some()));
|
||||
assert!([1, 3, 5, 7, 9].iter().all(|&c| size(c).is_none()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arabic_word_ligatures_are_wider_than_letters() {
|
||||
let em = |t: &str| approx_text_width(t, 72.0, false) / 96.0;
|
||||
|
||||
@@ -194,16 +194,35 @@ pub(super) fn autofit_cols(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let measure = s.text_width.clone();
|
||||
edit(s, |cx| {
|
||||
let Some(sh) = cx.wb.sheet(si) else { return Ok(Json::Null) };
|
||||
let mut widths = Vec::new();
|
||||
let mut measured: std::collections::HashMap<StyleId, std::collections::HashMap<String, f32>> = Default::default();
|
||||
let mut distinct = 0usize;
|
||||
let used = sh.used_range();
|
||||
for (a, b) in lines {
|
||||
for c in a..=b.min(a + 16383) {
|
||||
let Some(u) = used else { continue };
|
||||
let col = RangeRef::new(CellRef::new(u.start.row, c), CellRef::new(u.end.row, c));
|
||||
let mut max: f32 = 0.0;
|
||||
for (cell, _) in sh.cells.iter_range(col) {
|
||||
// Selected columns, then one pass over the populated cells (the store is row-oriented, so a
|
||||
// scan per column would revisit every row for each selected column, empty or not).
|
||||
let cols: std::collections::BTreeSet<u32> = lines.iter().flat_map(|&(a, b)| a..=b.min(a + 16383)).collect();
|
||||
let mut maxes: std::collections::BTreeMap<u32, f32> = Default::default();
|
||||
if let Some(u) = sh.used_range() {
|
||||
// One pass per run of adjacent selected columns, so columns between distant selections
|
||||
// (A and XFD) are never visited.
|
||||
let mut runs: Vec<(u32, u32)> = Vec::new();
|
||||
for &c in &cols {
|
||||
match runs.last_mut() {
|
||||
Some((_, end)) if *end + 1 == c => *end = c,
|
||||
_ => runs.push((c, c)),
|
||||
}
|
||||
}
|
||||
// Every run is a pass over all the stored rows: many runs (alternating columns) are one
|
||||
// pass over their whole span instead, the unselected columns skipped.
|
||||
if runs.len() > 4
|
||||
&& let (Some(&(first, _)), Some(&(_, last))) = (runs.first(), runs.last())
|
||||
{
|
||||
runs = vec![(first, last)];
|
||||
}
|
||||
for (first, last) in runs {
|
||||
let span = RangeRef::new(CellRef::new(u.start.row, first), CellRef::new(u.end.row, last));
|
||||
for (cell, _) in sh.cells.iter_range(span) {
|
||||
if !cols.contains(&cell.col) {
|
||||
continue;
|
||||
}
|
||||
if sh.merge_at(cell).is_some_and(|m| !m.is_single()) {
|
||||
continue;
|
||||
}
|
||||
@@ -226,14 +245,14 @@ pub(super) fn autofit_cols(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
}
|
||||
None => approx_text_width(line, st.font.size, st.font.bold),
|
||||
};
|
||||
max = max.max(w + 6.0 + st.align.indent as f32 * 9.0 + sh.filter_button_space(cell));
|
||||
let w = w + 6.0 + st.align.indent as f32 * 9.0 + sh.filter_button_space(cell);
|
||||
let max = maxes.entry(cell.col).or_insert(0.0);
|
||||
*max = max.max(w);
|
||||
}
|
||||
}
|
||||
if max > 0.0 {
|
||||
widths.push((c, max.clamp(8.0, 1785.0)));
|
||||
}
|
||||
}
|
||||
}
|
||||
let widths: Vec<(u32, f32)> = maxes.into_iter().filter(|&(_, m)| m > 0.0).map(|(c, m)| (c, m.clamp(8.0, 1785.0))).collect();
|
||||
let sh = cx.sheet_mut(si)?;
|
||||
for (c, w) in widths {
|
||||
let e = sh.cols.entry(c).or_default();
|
||||
|
||||
@@ -290,6 +290,12 @@ pub fn function_list() -> Vec<Json> {
|
||||
("SHEETS", "Information", "SHEETS([reference])", "Number of sheets."),
|
||||
("AREAS", "Lookup", "AREAS(reference)", "Number of areas in a reference."),
|
||||
("TRIMRANGE", "Lookup", "TRIMRANGE(range, [trim_rows], [trim_cols])", "A range or array without its blank outer rows and columns."),
|
||||
(
|
||||
"GETPIVOTDATA",
|
||||
"Lookup",
|
||||
"GETPIVOTDATA(data_field, pivot_table, [field1, item1], ...)",
|
||||
"A value from a PivotTable report, by value field and items.",
|
||||
),
|
||||
("ISOMITTED", "Information", "ISOMITTED(argument)", "TRUE when a LAMBDA argument was left out."),
|
||||
];
|
||||
for (n, c, sig, d) in specials {
|
||||
|
||||
+21
-1580
File diff suppressed because it is too large
Load Diff
@@ -1,17 +1,38 @@
|
||||
use super::{
|
||||
Anchor, CellRef, Chart, ChartKind, EngineError, Json, LegendPos, RangeRef, Result, Series, Session, Sheet, anchor_mode_param, bad, block,
|
||||
bool_param, cell_param_on, edit, f64_param, json, split_sheet, str_param, target_ranges, target_sheet, u32_param,
|
||||
Anchor, CellRef, Chart, ChartKind, EngineError, Json, LegendPos, MAX_COLS, MAX_ROWS, RangeRef, Result, Series, Session, Sheet, anchor_mode_param,
|
||||
bad, block, bool_param, cell_param_on, edit, f64_param, json, size_cap, split_sheet, str_param, target_ranges, target_sheet, u32_param,
|
||||
};
|
||||
|
||||
#[cfg(test)]
|
||||
pub(super) fn compiled() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn chart_areas(s: &Session, p: &Json) -> Result<Vec<RangeRef>> {
|
||||
if p.get("range").is_some() {
|
||||
return target_ranges(s, p);
|
||||
let mut areas = if p.get("range").is_some() {
|
||||
target_ranges(s, p)?
|
||||
} else if s.doc()?.selection.ranges.len() > 1 {
|
||||
s.doc()?.selection.ranges.clone()
|
||||
} else {
|
||||
vec![block(s, p)?]
|
||||
};
|
||||
// Whole columns/rows span a million cells: clip their far edges to the cells in use, so only
|
||||
// a block that really is too large gets refused. Bounded areas keep their extent as given.
|
||||
let sheet = target_sheet(s, p)?;
|
||||
if let Some(used) = s.doc()?.wb.sheet(sheet).and_then(|sh| sh.used_range()) {
|
||||
// Areas that start outside the used range keep their extent as given.
|
||||
for r in &mut areas {
|
||||
let whole_cols = r.start.row == 0 && r.end.row >= MAX_ROWS - 1;
|
||||
let whole_rows = r.start.col == 0 && r.end.col >= MAX_COLS - 1;
|
||||
if whole_cols && r.start.row <= used.end.row {
|
||||
r.end.row = r.end.row.min(used.end.row);
|
||||
}
|
||||
if whole_rows && r.start.col <= used.end.col {
|
||||
r.end.col = r.end.col.min(used.end.col);
|
||||
}
|
||||
}
|
||||
}
|
||||
let d = s.doc()?;
|
||||
if d.selection.ranges.len() > 1 {
|
||||
return Ok(d.selection.ranges.clone());
|
||||
}
|
||||
Ok(vec![block(s, p)?])
|
||||
Ok(areas)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- charts
|
||||
@@ -263,6 +284,8 @@ pub fn build_chart(s: &Session, p: &Json) -> Result<(usize, Chart)> {
|
||||
data_table: None,
|
||||
gridlines: !matches!(kind, ChartKind::Pie | ChartKind::Doughnut | ChartKind::Treemap | ChartKind::Sunburst | ChartKind::Funnel),
|
||||
style: 1,
|
||||
hole_size: 75,
|
||||
first_slice_angle: 0,
|
||||
x_title: None,
|
||||
y_title: None,
|
||||
source: (areas.len() == 1).then(|| format!("{}!{}", gridcraft_formula::quote_sheet(&sh.name), bounds.a1())),
|
||||
@@ -308,7 +331,11 @@ pub(super) fn chart_set(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let Some(c) = sh.charts.get_mut(ci) else { return Ok(Json::Null) };
|
||||
if let Some(t) = str_param(p, "type") {
|
||||
c.kind = chart_kind(t, str_param(p, "subtype").unwrap_or(""));
|
||||
if !c.supports_data_table() {
|
||||
c.data_table = None;
|
||||
}
|
||||
}
|
||||
update_data_table(c, p, bool_param(p, "dataTable"))?;
|
||||
if let Some(method) = quartiles {
|
||||
for series in &mut c.series {
|
||||
series.quartiles = method;
|
||||
@@ -335,6 +362,12 @@ pub(super) fn chart_set(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
if let Some(v) = u32_param(p, "style") {
|
||||
c.style = v.clamp(1, 16);
|
||||
}
|
||||
if let Some(v) = u32_param(p, "holeSize") {
|
||||
c.hole_size = v.clamp(10, 90) as u8;
|
||||
}
|
||||
if let Some(v) = u32_param(p, "firstSliceAngle") {
|
||||
c.first_slice_angle = (v % 360) as u16;
|
||||
}
|
||||
if let Some(t) = p.get("xTitle") {
|
||||
c.x_title = t.as_str().map(str::to_string);
|
||||
}
|
||||
@@ -345,10 +378,10 @@ pub(super) fn chart_set(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
c.anchor.cell = at;
|
||||
}
|
||||
if let Some(w) = f64_param(p, "width") {
|
||||
c.anchor.width = w.clamp(20.0, 10000.0) as f32;
|
||||
c.anchor.width = w.clamp(20.0, size_cap(c.anchor.width)) as f32;
|
||||
}
|
||||
if let Some(h) = f64_param(p, "height") {
|
||||
c.anchor.height = h.clamp(20.0, 10000.0) as f32;
|
||||
c.anchor.height = h.clamp(20.0, size_cap(c.anchor.height)) as f32;
|
||||
}
|
||||
if let Some(v) = f64_param(p, "dx") {
|
||||
c.anchor.dx = v as f32;
|
||||
@@ -360,6 +393,32 @@ pub(super) fn chart_set(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
})
|
||||
}
|
||||
|
||||
/// Shared by Chart Properties and Add Chart Element; no separate UI state.
|
||||
pub(crate) fn update_data_table(c: &mut Chart, p: &Json, on: Option<bool>) -> Result<()> {
|
||||
if p.get("dataTable").is_some_and(|v| !v.is_boolean()) {
|
||||
return Err(bad("chart", "`dataTable` must be a boolean"));
|
||||
}
|
||||
if on == Some(false) {
|
||||
c.data_table = None;
|
||||
return Ok(());
|
||||
}
|
||||
let fields = ["dataTableKeys", "dataTableHorizontalBorder", "dataTableVerticalBorder", "dataTableOutline"];
|
||||
if on == Some(true) || fields.iter().any(|k| p.get(k).is_some()) {
|
||||
if !c.supports_data_table() {
|
||||
return Err(bad("chart", "data tables need a column, bar, line, area or compatible combo chart"));
|
||||
}
|
||||
let table = c.data_table.get_or_insert_with(Default::default);
|
||||
for (key, value) in
|
||||
fields.into_iter().zip([&mut table.show_keys, &mut table.horizontal_border, &mut table.vertical_border, &mut table.outline])
|
||||
{
|
||||
if let Some(v) = p.get(key) {
|
||||
*value = v.as_bool().ok_or_else(|| bad("chart", format!("`{key}` must be a boolean")))?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) fn chart_switch(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let (si, ci) = find_chart(s, p)?;
|
||||
edit(s, |cx| {
|
||||
|
||||
@@ -1,8 +1,14 @@
|
||||
use super::{
|
||||
Anchor, BorderLine, BorderStyle, Borders, CfOperator, CfRule, CfValueKind, Color, CondFormat, EngineError, Fill, Json, Result, Session, Shape,
|
||||
ShapeKind, Style, anchor_mode_param, bad, bool_param, cell_param, edit, f64_param, json, ok, str_param, target_ranges, target_sheet, u32_param,
|
||||
Anchor, BorderLine, BorderStyle, Borders, CellRef, CfOperator, CfRule, CfValueKind, Color, CondFormat, EngineError, Fill, Json, RangeRef, Result,
|
||||
Session, Shape, ShapeKind, Style, anchor_mode_param, bad, bool_param, cell_param, edit, f64_param, json, ok, str_param, target_ranges,
|
||||
target_sheet, u32_param,
|
||||
};
|
||||
|
||||
#[cfg(test)]
|
||||
pub(super) fn compiled() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- conditional formatting
|
||||
|
||||
fn preset_style(name: &str) -> Style {
|
||||
@@ -271,7 +277,13 @@ pub(super) fn clear_cf(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
sh.cond_formats.clear();
|
||||
} else {
|
||||
for cf in sh.cond_formats.iter_mut() {
|
||||
let before = RangeRef::top_left(&cf.ranges);
|
||||
cf.ranges.retain(|r| !ranges.iter().any(|x| x.intersects(r)));
|
||||
// The relative formulas are written for the top-left cell: when it goes, they're
|
||||
// rewritten for the new one, so the areas left keep reading the same cells.
|
||||
if let (Some(from), Some(to)) = (before, RangeRef::top_left(&cf.ranges)) {
|
||||
rebase_cf_formulas(&mut cf.rule, from, to);
|
||||
}
|
||||
}
|
||||
sh.cond_formats.retain(|c| !c.ranges.is_empty());
|
||||
}
|
||||
@@ -279,6 +291,19 @@ pub(super) fn clear_cf(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
})
|
||||
}
|
||||
|
||||
/// Moves the relative references of a rule's per-cell formulas written for `from` to `to`.
|
||||
fn rebase_cf_formulas(rule: &mut CfRule, from: CellRef, to: CellRef) {
|
||||
let mv = |f: &str| crate::cmd::data::move_rule_formula(f, from, to);
|
||||
match rule {
|
||||
CfRule::CellIs { a, b, .. } => {
|
||||
*a = mv(a);
|
||||
*b = b.as_deref().map(mv);
|
||||
}
|
||||
CfRule::Expression { formula, .. } => *formula = mv(formula),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn manage_cf(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let sheet = target_sheet(s, p)?;
|
||||
if p.get("delete").is_none() && p.get("moveUp").is_none() && p.get("moveDown").is_none() {
|
||||
|
||||
@@ -3,6 +3,11 @@ use super::{
|
||||
split_sheet, str_param, target_ranges, target_sheet,
|
||||
};
|
||||
|
||||
#[cfg(test)]
|
||||
pub(super) fn compiled() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- links & comments
|
||||
|
||||
pub(super) fn insert_link(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
@@ -27,8 +32,10 @@ pub(super) fn insert_link(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
st.font.underline = Underline::Single;
|
||||
});
|
||||
let sh = cx.sheet_mut(sheet)?;
|
||||
if let Some(t) = text.clone().or_else(|| sh.value(at).is_empty().then(|| target.clone())) {
|
||||
sh.set_cell(at, Cell { value: gridcraft_core::Value::text(t.as_str()), formula: None, style: link_style });
|
||||
if let Some(t) = text.clone().or_else(|| {
|
||||
(sh.spill_anchor(at).is_none() && sh.value(at).is_empty() && sh.cell(at).is_none_or(|cell| !cell.has_content())).then(|| target.clone())
|
||||
}) {
|
||||
sh.set_cell(at, Cell { value: gridcraft_core::Value::text(t.as_str()), formula: None, style: link_style, py: None });
|
||||
} else {
|
||||
sh.set_style(at, link_style);
|
||||
}
|
||||
@@ -38,9 +45,11 @@ pub(super) fn insert_link(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
})
|
||||
}
|
||||
|
||||
/// Follows a link: a reference selects it, an `http`/`https`/`mailto` address is handed to the
|
||||
/// host (`UiRequest::OpenUrl`); anything else is refused ([`crate::links::classify`]). Opens no
|
||||
/// dialog; the interactive click asks for confirmation first, in the UI.
|
||||
/// Follows a link: a reference selects it; anything else is refused ([`crate::links::classify`]).
|
||||
/// An `http`/`https`/`mailto` address is refused too unless the host set
|
||||
/// [`crate::links::LinkPolicy::Allow`]: every caller of a command may be a script or an agent, so
|
||||
/// the user opens such links by clicking and confirming, and the UI then calls
|
||||
/// [`Session::open_confirmed_link`] (#2181). Opens no dialog.
|
||||
pub(super) fn open_link(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let target = match str_param(p, "url").or_else(|| str_param(p, "target")) {
|
||||
Some(t) => t.to_string(),
|
||||
@@ -56,6 +65,9 @@ pub(super) fn open_link(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
match crate::links::classify(&target) {
|
||||
crate::links::LinkKind::Internal(r) => crate::cmd::edit::go_to(s, &json!({"reference": r.trim_start_matches('#')})),
|
||||
crate::links::LinkKind::External(u) => {
|
||||
if s.link_policy != crate::links::LinkPolicy::Allow {
|
||||
return Err(EngineError::Other(crate::links::NEEDS_CONFIRMATION.into()));
|
||||
}
|
||||
s.ui_requests.push(crate::UiRequest::OpenUrl(u.clone()));
|
||||
Ok(json!({"opened": u}))
|
||||
}
|
||||
|
||||
@@ -1,8 +1,14 @@
|
||||
use super::{
|
||||
Anchor, CellPicture, CellRef, Color, EngineError, Image, Json, PROTECTED, Result, Session, Shape, ShapeKind, Sparkline, SparklineKind,
|
||||
anchor_mode_name, anchor_mode_param, bad, bool_param, cell_param, edit, f64_param, json, locked_cell_error, ok, str_param, u32_param,
|
||||
Anchor, CellPicture, CellRef, Color, EngineError, Image, Json, MAX_OBJECT_OFFSET, ObjKind, ObjRef, PROTECTED, Result, Session, Shape, ShapeKind,
|
||||
Sparkline, SparklineKind, anchor_mode_name, anchor_mode_param, bad, bool_param, cell_param, edit, f64_param, json, locked_cell_error, ok,
|
||||
size_cap, str_param, u32_param,
|
||||
};
|
||||
|
||||
#[cfg(test)]
|
||||
pub(super) fn compiled() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
pub(super) fn insert_sparkline(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let src = str_param(p, "range").ok_or_else(|| bad("insert.sparkline", "missing `range`"))?.to_string();
|
||||
let loc = cell_param(s, p, "location")?.ok_or_else(|| bad("insert.sparkline", "missing `location`"))?;
|
||||
@@ -63,6 +69,10 @@ pub(super) fn insert_picture(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
.unwrap_or_else(|| if data.starts_with(&[0x89, b'P', b'N', b'G']) { "image/png".into() } else { "image/jpeg".into() });
|
||||
let (w, h) = crate::io::image_size(&data).unwrap_or((320, 240));
|
||||
let d = s.doc()?;
|
||||
// Sheet protection locks drawing objects, as for a text box's text.
|
||||
if d.wb.active().is_some_and(|sh| sh.is_protected()) {
|
||||
return Err(EngineError::Other(PROTECTED.into()));
|
||||
}
|
||||
let id = d.wb.next_object_id();
|
||||
let at = cell_param(s, p, "at")?.unwrap_or(d.selection.active);
|
||||
let scale = (640.0 / w.max(1) as f32).min(1.0);
|
||||
@@ -176,9 +186,15 @@ pub(super) fn shape_set_text(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let sheet = d.wb.active_sheet();
|
||||
let sh = d.wb.active().ok_or_else(|| bad("shape.setText", "no such text box"))?;
|
||||
let shape = sh.shapes.iter().find(|shape| shape.id == id).ok_or_else(|| bad("shape.setText", "no such text box"))?;
|
||||
if shape.kind != ShapeKind::TextBox {
|
||||
if !matches!(shape.kind, ShapeKind::TextBox | ShapeKind::WordArt) {
|
||||
return Err(bad("shape.setText", "the shape is not a text box"));
|
||||
}
|
||||
if shape.kind == ShapeKind::WordArt && text.is_empty() {
|
||||
return Err(bad("shape.setText", "WordArt text must not be empty"));
|
||||
}
|
||||
if shape.kind == ShapeKind::WordArt && text.chars().nth(crate::cmd::wordart::MAX_CHARS).is_some() {
|
||||
return Err(bad("shape.setText", format!("`text` is longer than {} characters", crate::cmd::wordart::MAX_CHARS)));
|
||||
}
|
||||
// Sheet protection locks drawing objects (there is no "edit objects" allowance yet).
|
||||
if sh.is_protected() {
|
||||
return Err(EngineError::Other(PROTECTED.into()));
|
||||
@@ -193,51 +209,50 @@ pub(super) fn shape_set_text(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
})
|
||||
}
|
||||
|
||||
/// The floating object a `{kind, id}` command names on the active sheet. Unknown kinds and
|
||||
/// objects are errors, so a stale id never succeeds silently.
|
||||
fn object_param(s: &Session, p: &Json, cmd: &str) -> Result<(usize, ObjRef)> {
|
||||
let id = u32_param(p, "id").ok_or_else(|| bad(cmd, "missing `id`"))?;
|
||||
let kind =
|
||||
str_param(p, "kind").and_then(ObjKind::parse).ok_or_else(|| bad(cmd, "kind must be chart, image, shape, slicer, equation or control"))?;
|
||||
let d = s.doc()?;
|
||||
let sheet = d.wb.active_sheet();
|
||||
let o = ObjRef::new(kind, id);
|
||||
if !d.wb.sheet(sheet).is_some_and(|sh| sh.has_object(o)) {
|
||||
return Err(bad(cmd, "no such object"));
|
||||
}
|
||||
// A locked form control on a protected sheet stays as it is.
|
||||
crate::cmd::controls::check_objects_unlocked(s, sheet, kind, &[id])?;
|
||||
Ok((sheet, o))
|
||||
}
|
||||
|
||||
pub(super) fn delete_object(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let id = u32_param(p, "id").ok_or_else(|| bad("object.delete", "missing `id`"))?;
|
||||
let kind = str_param(p, "kind").unwrap_or("").to_string();
|
||||
let sheet = s.doc()?.wb.active_sheet();
|
||||
let (sheet, o) = object_param(s, p, "object.delete")?;
|
||||
edit(s, |cx| {
|
||||
let sh = cx.sheet_mut(sheet)?;
|
||||
match kind.as_str() {
|
||||
"chart" => sh.charts.retain(|c| c.id != id),
|
||||
"image" => sh.images.retain(|c| c.id != id),
|
||||
"slicer" => sh.slicers.retain(|c| c.id != id),
|
||||
_ => sh.shapes.retain(|c| c.id != id),
|
||||
}
|
||||
Ok(Json::Null)
|
||||
cx.sheet_mut(sheet)?.remove_object(o);
|
||||
Ok(json!({"deleted": o}))
|
||||
})
|
||||
}
|
||||
|
||||
pub(super) fn move_object(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let id = u32_param(p, "id").ok_or_else(|| bad("object.move", "missing `id`"))?;
|
||||
let kind = str_param(p, "kind").unwrap_or("").to_string();
|
||||
let sheet = s.doc()?.wb.active_sheet();
|
||||
let (sheet, o) = object_param(s, p, "object.move")?;
|
||||
let at = cell_param(s, p, "at")?;
|
||||
edit(s, |cx| {
|
||||
let sh = cx.sheet_mut(sheet)?;
|
||||
let anchor = match kind.as_str() {
|
||||
"chart" => sh.charts.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
|
||||
"image" => sh.images.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
|
||||
"slicer" => sh.slicers.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
|
||||
"shape" => sh.shapes.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
|
||||
_ => None,
|
||||
};
|
||||
let Some(a) = anchor else { return Err(bad("object.move", "no such object")) };
|
||||
let Some(a) = cx.sheet_mut(sheet)?.object_anchor_mut(o) else { return Err(bad("object.move", "no such object")) };
|
||||
if let Some(at) = at {
|
||||
a.cell = at;
|
||||
}
|
||||
if let Some(v) = f64_param(p, "dx") {
|
||||
a.dx = v as f32;
|
||||
a.dx = v.clamp(-MAX_OBJECT_OFFSET, MAX_OBJECT_OFFSET) as f32;
|
||||
}
|
||||
if let Some(v) = f64_param(p, "dy") {
|
||||
a.dy = v as f32;
|
||||
a.dy = v.clamp(-MAX_OBJECT_OFFSET, MAX_OBJECT_OFFSET) as f32;
|
||||
}
|
||||
if let Some(v) = f64_param(p, "width") {
|
||||
a.width = v.clamp(1.0, 10000.0) as f32;
|
||||
a.width = v.clamp(1.0, size_cap(a.width)) as f32;
|
||||
}
|
||||
if let Some(v) = f64_param(p, "height") {
|
||||
a.height = v.clamp(0.0, 10000.0) as f32;
|
||||
a.height = v.clamp(0.0, size_cap(a.height)) as f32;
|
||||
}
|
||||
Ok(Json::Null)
|
||||
})
|
||||
@@ -247,21 +262,10 @@ pub(super) fn move_object(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
/// cells" / "Don't move or size with cells"), so it follows — or ignores — its rows and columns
|
||||
/// when the sheet is sorted or edited structurally.
|
||||
pub(super) fn set_anchor_mode(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let id = u32_param(p, "id").ok_or_else(|| bad("object.setAnchorMode", "missing `id`"))?;
|
||||
let kind = str_param(p, "kind").unwrap_or("").to_string();
|
||||
if !matches!(kind.as_str(), "chart" | "image" | "shape") {
|
||||
return Err(bad("object.setAnchorMode", "kind must be chart, image or shape"));
|
||||
}
|
||||
let (sheet, o) = object_param(s, p, "object.setAnchorMode")?;
|
||||
let mode = anchor_mode_param(p).ok_or_else(|| bad("object.setAnchorMode", "mode must be moveAndSize, moveOnly or absolute"))?;
|
||||
let sheet = s.doc()?.wb.active_sheet();
|
||||
edit(s, |cx| {
|
||||
let sh = cx.sheet_mut(sheet)?;
|
||||
let anchor = match kind.as_str() {
|
||||
"chart" => sh.charts.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
|
||||
"image" => sh.images.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
|
||||
_ => sh.shapes.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
|
||||
};
|
||||
let Some(a) = anchor else { return Err(bad("object.setAnchorMode", "no such object")) };
|
||||
let Some(a) = cx.sheet_mut(sheet)?.object_anchor_mut(o) else { return Err(bad("object.setAnchorMode", "no such object")) };
|
||||
a.mode = mode;
|
||||
Ok(json!({"mode": anchor_mode_name(mode)}))
|
||||
})
|
||||
|
||||
@@ -3,6 +3,11 @@ use super::{
|
||||
block, bool_param, edit, json, rewrite, shift_cell_features, str_param, target_range, target_sheet, with,
|
||||
};
|
||||
|
||||
#[cfg(test)]
|
||||
pub(super) fn compiled() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- tables
|
||||
|
||||
pub(super) fn insert_table(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
@@ -51,7 +56,7 @@ pub(super) fn insert_table(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let sh = cx.sheet_mut(sheet)?;
|
||||
// The header row pushes the data down one row: never off the end of the sheet.
|
||||
let last = RangeRef::new(CellRef::new(MAX_ROWS - 1, r.start.col), CellRef::new(MAX_ROWS - 1, r.end.col));
|
||||
if sh.cells.iter_range(last).any(|(_, x)| x.formula.is_some() || !x.value.is_empty()) {
|
||||
if sh.cells.iter_range(last).any(|(_, x)| x.has_content()) {
|
||||
return Err(EngineError::Other("To prevent possible loss of data, cells can't be pushed off the end of the worksheet.".into()));
|
||||
}
|
||||
sh.cells.shift_rows_in_cols(r.start.col, r.end.col, r.start.row, 1);
|
||||
@@ -211,7 +216,10 @@ fn write_totals(sh: &mut Sheet, ti: usize) {
|
||||
let c = CellRef::new(row, t.range.start.col + i as u32);
|
||||
if let Some(code) = col.totals.subtotal_code() {
|
||||
let f = format!("=SUBTOTAL({code},{}[{}])", t.name, col.name);
|
||||
sh.set_cell(c, Cell { formula: Some(std::sync::Arc::new(Formula::new(&f))), value: gridcraft_core::Value::Empty, style: sh.style_id(c) });
|
||||
sh.set_cell(
|
||||
c,
|
||||
Cell { formula: Some(std::sync::Arc::new(Formula::new(&f))), value: gridcraft_core::Value::Empty, style: sh.style_id(c), py: None },
|
||||
);
|
||||
} else if let Some(l) = &col.totals_label {
|
||||
sh.set_value(c, gridcraft_core::Value::text(l.as_str()));
|
||||
} else {
|
||||
|
||||
@@ -628,6 +628,312 @@ fn calculated_field_errors() {
|
||||
assert!(matches!(s.ui_requests.last(), Some(crate::UiRequest::Dialog(n, _)) if n == "pivotCalculatedField"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn getpivotdata_reads_the_report() {
|
||||
let mut s = sales();
|
||||
s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
|
||||
assert_eq!(pt(&s).last_range.unwrap().a1(), "A3:E8");
|
||||
let gp = |s: &mut Session, cell: &str, f: &str| {
|
||||
s.execute("cell.set", json!({"cell": cell, "input": f})).unwrap();
|
||||
val(s, cell)
|
||||
};
|
||||
// Item cell, row subtotal by any cell of the report, grand total; names and items ignore case.
|
||||
assert_eq!(gp(&mut s, "G1", r#"=GETPIVOTDATA("Sales",$A$3,"Region","East","Product","Apples")"#), Value::Number(160.0));
|
||||
assert_eq!(gp(&mut s, "G2", r#"=GETPIVOTDATA("sales",C6,"region","east")"#), Value::Number(415.0));
|
||||
assert_eq!(gp(&mut s, "G3", r#"=GETPIVOTDATA("Sum of Sales",A3)"#), Value::Number(TOTAL));
|
||||
assert_eq!(gp(&mut s, "G4", r#"=GETPIVOTDATA("Sales",A3,"Product","Pears")"#), Value::Number(270.0));
|
||||
// Not in the report: unknown item, value field, field, unpaired field, not a pivot cell.
|
||||
for (cell, f) in [
|
||||
("H1", r#"=GETPIVOTDATA("Sales",A3,"Region","South")"#),
|
||||
("H2", r#"=GETPIVOTDATA("Units",A3)"#),
|
||||
("H3", r#"=GETPIVOTDATA("Sales",A3,"Date","East")"#),
|
||||
("H4", r#"=GETPIVOTDATA("Sales",A3,"Region")"#),
|
||||
("H5", r#"=GETPIVOTDATA("Sales",Z99)"#),
|
||||
("H6", r#"=GETPIVOTDATA("Sales",A3,"Region","East","Region","East")"#),
|
||||
] {
|
||||
assert_eq!(gp(&mut s, cell, f), Value::Error(CellError::Ref), "{f}");
|
||||
}
|
||||
assert_eq!(gp(&mut s, "H7", r#"=GETPIVOTDATA("Sales",A3,"Region",NA())"#), Value::Error(CellError::NA));
|
||||
// A refresh after a source edit updates the result.
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "E2", "input": "1100"})).unwrap();
|
||||
s.execute("data.refreshAll", json!({})).unwrap();
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet2"})).unwrap();
|
||||
assert_eq!(val(&s, "G1"), Value::Number(1160.0));
|
||||
// Opening a saved workbook starts without an index (files don't carry it); the first
|
||||
// GETPIVOTDATA builds it.
|
||||
let wb = (*s.doc().unwrap().wb).clone();
|
||||
let (back, _) = gridcraft_xlsx::read_xlsx(&gridcraft_xlsx::write_xlsx(&wb).unwrap()).unwrap();
|
||||
s.add_document(crate::DocState::new(back, None, "Reopened".into(), crate::Trust::FromFile));
|
||||
let d = s.doc().unwrap();
|
||||
let sh = d.wb.sheet(d.wb.sheet_index("Sheet2").unwrap()).unwrap();
|
||||
assert!(sh.pivots.first().unwrap().data_index.cells().is_some());
|
||||
assert_eq!(sh.value(CellRef::parse("G1").unwrap()), Value::Number(1160.0));
|
||||
assert_eq!(sh.value(CellRef::parse("G3").unwrap()), Value::Number(TOTAL + 1000.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn getpivotdata_reads_the_displayed_report() {
|
||||
let mut s = sales();
|
||||
s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
|
||||
// The source changes after the last refresh, then the workbook is saved and reopened:
|
||||
// the report still shows the old numbers, and the formula agrees with the cell.
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "E2", "input": "1100"})).unwrap();
|
||||
let wb = (*s.doc().unwrap().wb).clone();
|
||||
let (back, _) = gridcraft_xlsx::read_xlsx(&gridcraft_xlsx::write_xlsx(&wb).unwrap()).unwrap();
|
||||
s.add_document(crate::DocState::new(back, None, "Reopened".into(), crate::Trust::FromFile));
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet2"})).unwrap();
|
||||
let r = pt(&s).last_range.unwrap();
|
||||
let at = r.start.a1();
|
||||
s.execute("cell.set", json!({"cell": "K1", "input": format!(r#"=GETPIVOTDATA("Sales",{at},"Region","East")"#)})).unwrap();
|
||||
let d = s.doc().unwrap();
|
||||
let sh = d.wb.sheet(d.wb.sheet_index("Sheet2").unwrap()).unwrap();
|
||||
let east = (r.start.row..=r.end.row).find(|row| sh.value(CellRef::new(*row, r.start.col)) == Value::Text("East".into())).unwrap();
|
||||
let shown = sh.value(CellRef::new(east, r.start.col + 1));
|
||||
assert_eq!(shown, Value::Number(415.0));
|
||||
assert_eq!(val(&s, "K1"), shown);
|
||||
}
|
||||
|
||||
/// `=GETPIVOTDATA("Sales", <report>, "Region", <region>)` evaluated in K1 of the active sheet.
|
||||
fn region_sales(s: &mut Session, region: &str) -> Value {
|
||||
let at = pt(s).last_range.unwrap().start.a1();
|
||||
s.execute("cell.set", json!({"cell": "K1", "input": format!(r#"=GETPIVOTDATA("Sales",{at},"Region","{region}")"#)})).unwrap();
|
||||
val(s, "K1")
|
||||
}
|
||||
|
||||
fn reopen(s: &mut Session) {
|
||||
let wb = (*s.doc().unwrap().wb).clone();
|
||||
let (back, _) = gridcraft_xlsx::read_xlsx(&gridcraft_xlsx::write_xlsx(&wb).unwrap()).unwrap();
|
||||
s.add_document(crate::DocState::new(back, None, "Reopened".into(), crate::Trust::FromFile));
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet2"})).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn getpivotdata_retries_after_a_lazy_build_fails() {
|
||||
let mut s = sales();
|
||||
s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
|
||||
// A pivot read from a file carries no index, so the first lookup builds one.
|
||||
reopen(&mut s);
|
||||
assert!(pt(&s).data_index.cells().is_none());
|
||||
// The source changes, so the stored report is stale and the build finds nothing to trust.
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "A2", "input": "Alpha"})).unwrap();
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet2"})).unwrap();
|
||||
assert_eq!(region_sales(&mut s, "West"), Value::Error(CellError::Ref));
|
||||
assert!(pt(&s).data_index.cells().is_none(), "the failed build caches nothing");
|
||||
// The lookup is shared, so caching a failure as an empty index would leave every state that
|
||||
// shares it #REF! for good. Restoring the source lets the lookup build the index.
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "A2", "input": "East"})).unwrap();
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet2"})).unwrap();
|
||||
assert_eq!(region_sales(&mut s, "West"), Value::Number(285.0));
|
||||
assert!(pt(&s).data_index.cells().is_some(), "the lookup rebuilt after the failure");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn getpivotdata_saves_no_index_when_the_lazy_build_fails() {
|
||||
let mut s = sales();
|
||||
s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
|
||||
// A pivot read from a file carries no index; a source change makes the stored report stale,
|
||||
// so the lazy build fails and the lookup is #REF!.
|
||||
reopen(&mut s);
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "A2", "input": "Alpha"})).unwrap();
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet2"})).unwrap();
|
||||
assert_eq!(region_sales(&mut s, "West"), Value::Error(CellError::Ref));
|
||||
// Saving the pivot must save no index at all, not an empty one: restoring an empty index
|
||||
// would count as an index and lock the reopened pivot against the lazy rebuild.
|
||||
let json = serde_json::to_string(&pt(&s)).unwrap();
|
||||
let back: gridcraft_model::PivotTable = serde_json::from_str(&json).unwrap();
|
||||
assert!(json.contains(r#""data_index":null"#), "a failed build saves no index, not an empty one: {json}");
|
||||
assert!(back.data_index.cells().is_none());
|
||||
// Reopened with the source restored, the lookup builds the index.
|
||||
reopen(&mut s);
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "A2", "input": "East"})).unwrap();
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet2"})).unwrap();
|
||||
assert_eq!(region_sales(&mut s, "West"), Value::Number(285.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn getpivotdata_keeps_the_refreshed_report_when_an_item_is_inserted() {
|
||||
let mut s = sales();
|
||||
s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
|
||||
assert_eq!(region_sales(&mut s, "West"), Value::Number(285.0));
|
||||
// A new first item in the source shifts every item of a fresh report down one row.
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "A2", "input": "Alpha"})).unwrap();
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet2"})).unwrap();
|
||||
// Before the refresh the report still shows the old items, and the lookup reads that report.
|
||||
assert_eq!(region_sales(&mut s, "West"), Value::Number(285.0));
|
||||
assert_eq!(region_sales(&mut s, "Alpha"), Value::Error(CellError::Ref));
|
||||
// Saved and reopened unrefreshed: the stored report no longer matches the source, so there
|
||||
// is no index to trust (never the shifted cell of a different item).
|
||||
reopen(&mut s);
|
||||
assert_eq!(region_sales(&mut s, "West"), Value::Error(CellError::Ref));
|
||||
assert_eq!(region_sales(&mut s, "Alpha"), Value::Error(CellError::Ref));
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
|
||||
s.execute("data.refreshAll", json!({})).unwrap();
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet2"})).unwrap();
|
||||
assert_eq!(region_sales(&mut s, "Alpha"), Value::Number(100.0));
|
||||
assert_eq!(region_sales(&mut s, "West"), Value::Number(285.0));
|
||||
assert_eq!(region_sales(&mut s, "East"), Value::Number(315.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn getpivotdata_keeps_the_refreshed_report_when_an_item_is_removed() {
|
||||
let mut s = sales();
|
||||
s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
|
||||
assert_eq!(region_sales(&mut s, "North"), Value::Number(135.0));
|
||||
// Every North row becomes East: North leaves the report and West moves up.
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
|
||||
for a in ["A5", "A8", "A11"] {
|
||||
s.execute("cell.set", json!({"cell": a, "input": "East"})).unwrap();
|
||||
}
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet2"})).unwrap();
|
||||
assert_eq!(region_sales(&mut s, "North"), Value::Number(135.0));
|
||||
assert_eq!(region_sales(&mut s, "West"), Value::Number(285.0));
|
||||
reopen(&mut s);
|
||||
assert_eq!(region_sales(&mut s, "North"), Value::Error(CellError::Ref));
|
||||
assert_eq!(region_sales(&mut s, "West"), Value::Error(CellError::Ref));
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
|
||||
s.execute("data.refreshAll", json!({})).unwrap();
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet2"})).unwrap();
|
||||
assert_eq!(region_sales(&mut s, "North"), Value::Error(CellError::Ref));
|
||||
assert_eq!(region_sales(&mut s, "West"), Value::Number(285.0));
|
||||
assert_eq!(region_sales(&mut s, "East"), Value::Number(550.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn getpivotdata_index_is_saved_with_an_unrefreshed_pivot() {
|
||||
let mut s = sales();
|
||||
s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "A2", "input": "Alpha"})).unwrap();
|
||||
s.execute("sheet.activate", json!({"sheet": "Sheet2"})).unwrap();
|
||||
// The pivot as saved by the native format: the index of the stored report comes back with
|
||||
// it even though the source has since changed.
|
||||
let back: gridcraft_model::PivotTable = serde_json::from_str(&serde_json::to_string(&pt(&s)).unwrap()).unwrap();
|
||||
let cells = back.data_index.cells().expect("index saved");
|
||||
assert_eq!(cells, pt(&s).data_index.cells().unwrap());
|
||||
let west = back.data_index.find("Sales", &[("Region", "West", false)]).unwrap();
|
||||
assert_eq!((west.row, west.col), (3, 1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn getpivotdata_calculated_field() {
|
||||
let mut s = sales();
|
||||
s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
|
||||
s.execute("pivot.calculatedField", json!({"name": "Double", "formula": "=Sales*2"})).unwrap();
|
||||
let at = pt(&s).last_range.unwrap().start.a1();
|
||||
s.execute("cell.set", json!({"cell": "K1", "input": format!(r#"=GETPIVOTDATA("Double",{at},"Region","East")"#)})).unwrap();
|
||||
assert_eq!(val(&s, "K1"), Value::Number(830.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn getpivotdata_report_filter() {
|
||||
let mut s = sales();
|
||||
s.execute("insert.pivotTable", json!({"rows": ["Product"], "values": ["Sales"], "filters": ["Region"]})).unwrap();
|
||||
let at = pt(&s).last_range.unwrap().start.a1();
|
||||
let f = |region: &str| format!(r#"=GETPIVOTDATA("Sales",{at},"Region","{region}","Product","Apples")"#);
|
||||
// With every item shown, naming the filter field is #REF!.
|
||||
s.execute("cell.set", json!({"cell": "H1", "input": f("East")})).unwrap();
|
||||
assert_eq!(val(&s, "H1"), Value::Error(CellError::Ref));
|
||||
// Filtered to East: East matches, West doesn't.
|
||||
s.execute("pivot.filter", json!({"field": "Region", "selected": ["East"]})).unwrap();
|
||||
assert_eq!(val(&s, "H1"), Value::Number(160.0));
|
||||
s.execute("cell.set", json!({"cell": "H2", "input": f("West")})).unwrap();
|
||||
assert_eq!(val(&s, "H2"), Value::Error(CellError::Ref));
|
||||
}
|
||||
|
||||
/// A workbook whose Sheet1 holds `rows` under a two-column header, with a PivotTable of the first
|
||||
/// column (rows) and the second (sum) on a new sheet; the report sheet is active.
|
||||
fn two_column_pivot(header: [&str; 2], rows: Json, key_format: Option<&str>) -> Session {
|
||||
let mut s = Session::new();
|
||||
s.new_workbook();
|
||||
let n = rows.as_array().map_or(0, Vec::len);
|
||||
let mut all = vec![json!(header)];
|
||||
all.extend(rows.as_array().cloned().unwrap_or_default());
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": all})).unwrap();
|
||||
if let Some(code) = key_format {
|
||||
s.execute("home.numberFormat", json!({"range": format!("A2:A{}", n + 1), "code": code})).unwrap();
|
||||
}
|
||||
s.execute("selection.set", json!({"range": "A1"})).unwrap();
|
||||
s.execute("insert.pivotTable", json!({"rows": [header[0]], "values": [header[1]]})).unwrap();
|
||||
s
|
||||
}
|
||||
|
||||
/// The value the report shows for the row item `label` (one value field: the report's last column).
|
||||
fn shown(s: &Session, label: &str) -> Value {
|
||||
let r = pt(s).last_range.unwrap();
|
||||
let row = find_row(s, label).unwrap_or_else(|| panic!("{label} is not in the report"));
|
||||
val(s, &CellRef::new(row, r.end.col).a1())
|
||||
}
|
||||
|
||||
/// Inserting or deleting rows or columns inside a report keeps GETPIVOTDATA on the requested
|
||||
/// item's cell (the stored offsets move with the cells), and undo restores the old positions.
|
||||
#[test]
|
||||
fn getpivotdata_follows_rows_and_columns_edited_inside_the_report() {
|
||||
let mut s = two_column_pivot(["Region", "Sales"], json!([["East", 10], ["North", 30], ["West", 20]]), None);
|
||||
assert_eq!(pt(&s).last_range.unwrap().start.a1(), "A3");
|
||||
s.execute("cell.set", json!({"cell": "K1", "input": r#"=GETPIVOTDATA("Sales",A3,"Region","West")"#})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "K2", "input": r#"=GETPIVOTDATA("Sales",A3,"Region","North")"#})).unwrap();
|
||||
assert_eq!(val(&s, "K1"), Value::Number(20.0));
|
||||
// Row 4 splits the header from the items; column B splits the labels from the values (and
|
||||
// moves the formulas from K to L).
|
||||
for (cmd, lines, west, north) in
|
||||
[("home.insertRows", json!({"rows": "4:4"}), "K1", "K2"), ("home.insertColumns", json!({"cols": "B:B"}), "L1", "L2")]
|
||||
{
|
||||
s.execute(cmd, lines).unwrap();
|
||||
assert_eq!(shown(&s, "West"), Value::Number(20.0), "{cmd}");
|
||||
assert_eq!(val(&s, west), shown(&s, "West"), "{cmd}");
|
||||
assert_eq!(val(&s, north), shown(&s, "North"), "{cmd}");
|
||||
}
|
||||
s.execute("edit.undo", json!({})).unwrap();
|
||||
s.execute("edit.undo", json!({})).unwrap();
|
||||
assert_eq!(pt(&s).last_range.unwrap().start.a1(), "A3");
|
||||
s.execute("cell.set", json!({"cell": "K3", "input": r#"=GETPIVOTDATA("Sales",A3,"Region","West")"#})).unwrap();
|
||||
assert_eq!(val(&s, "K3"), Value::Number(20.0), "undo restores the report and its offsets");
|
||||
// Deleting North's row moves West up; North itself is gone from the report.
|
||||
let north = find_row(&s, "North").unwrap() + 1;
|
||||
s.execute("home.deleteRows", json!({"rows": format!("{north}:{north}")})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "K1", "input": r#"=GETPIVOTDATA("Sales",A3,"Region","West")"#})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "K2", "input": r#"=GETPIVOTDATA("Sales",A3,"Region","North")"#})).unwrap();
|
||||
assert_eq!(val(&s, "K1"), Value::Number(20.0));
|
||||
assert_eq!(val(&s, "K1"), shown(&s, "West"));
|
||||
assert_eq!(val(&s, "K2"), Value::Error(CellError::Ref), "a deleted value cell is not read from its old place");
|
||||
// Lines inserted at the report's first line move the whole report, and lines right after it
|
||||
// leave it alone; either way the offsets stay what they were.
|
||||
for rows in ["3:3", "9:9"] {
|
||||
s.execute("home.insertRows", json!({"rows": rows})).unwrap();
|
||||
let at = pt(&s).last_range.unwrap().start.a1();
|
||||
s.execute("cell.set", json!({"cell": "K1", "input": format!(r#"=GETPIVOTDATA("Sales",{at},"Region","West")"#)})).unwrap();
|
||||
assert_eq!(val(&s, "K1"), Value::Number(20.0), "insert {rows}");
|
||||
assert_eq!(val(&s, "K1"), shown(&s, "West"), "insert {rows}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Numeric items whose formatted labels collide are told apart by value: an exact numeric item
|
||||
/// wins over another item that only displays the same label.
|
||||
#[test]
|
||||
fn getpivotdata_matches_numeric_items_by_value_before_label() {
|
||||
let mut s = two_column_pivot(["Key", "Sales"], json!([[0.6, 10], [1, 20]]), Some("0"));
|
||||
let p = pt(&s);
|
||||
let labels: Vec<&str> = p.data_index.cells().unwrap().iter().flat_map(|c| c.items.iter().map(|i| i.label.as_str())).collect();
|
||||
assert_eq!(labels, ["1", "1"], "both items display as 1");
|
||||
s.execute("cell.set", json!({"cell": "K1", "input": r#"=GETPIVOTDATA("Sales",A3,"Key",1)"#})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "K2", "input": r#"=GETPIVOTDATA("Sales",A3,"Key",0.6)"#})).unwrap();
|
||||
assert_eq!(val(&s, "K1"), Value::Number(20.0));
|
||||
assert_eq!(val(&s, "K2"), Value::Number(10.0));
|
||||
// Dates: two times on one day show the same date label; each serial finds its own item.
|
||||
let mut s = two_column_pivot(["Day", "Sales"], json!([[45000, 10], [45000.25, 20]]), Some("m/d/yyyy"));
|
||||
s.execute("cell.set", json!({"cell": "K1", "input": r#"=GETPIVOTDATA("Sales",A3,"Day",45000.25)"#})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "K2", "input": r#"=GETPIVOTDATA("Sales",A3,"Day",45000)"#})).unwrap();
|
||||
assert_eq!(val(&s, "K1"), Value::Number(20.0));
|
||||
assert_eq!(val(&s, "K2"), Value::Number(10.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn replace_protection() {
|
||||
let mut s = sales();
|
||||
@@ -1062,6 +1368,34 @@ fn detail_cells_are_the_cells_show_details_takes() {
|
||||
assert!(crate::pivot::detail_cells(&d.wb, pt, d.wb.active_sheet()).unwrap_err().contains("out of date"));
|
||||
}
|
||||
|
||||
/// Measurement, not a check: `perf stat -e instructions:u` of this test with `PIVOT_BENCH_EDITS=0`
|
||||
/// and `=20` (and `PIVOT_BENCH_REOPEN=0/1`) gives the cost of edits on the report's sheet and of
|
||||
/// opening a saved workbook, with the setup subtracted. `PIVOT_BENCH_ROWS` is the source size.
|
||||
#[test]
|
||||
#[ignore = "measurement only"]
|
||||
fn bench_edit_on_sheet_with_large_report() {
|
||||
let env = |k: &str, d: usize| std::env::var(k).ok().and_then(|v| v.parse().ok()).unwrap_or(d);
|
||||
let (n, edits) = (env("PIVOT_BENCH_ROWS", 100_000), env("PIVOT_BENCH_EDITS", 0));
|
||||
let mut s = Session::new();
|
||||
s.new_workbook();
|
||||
let mut rows = vec![json!(["Id", "Product", "Sales"])];
|
||||
rows.extend((0..n).map(|i| {
|
||||
let (id, product) = (format!("id{i:07}"), ["Apples", "Pears", "Plums"][i % 3]);
|
||||
json!([id, product, i])
|
||||
}));
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
|
||||
s.execute("selection.set", json!({"range": "A1"})).unwrap();
|
||||
s.execute("insert.pivotTable", json!({"rows": ["Id"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
|
||||
for i in 0..edits {
|
||||
s.execute("cell.set", json!({"cell": "K1", "input": i.to_string()})).unwrap();
|
||||
}
|
||||
if env("PIVOT_BENCH_REOPEN", 0) == 1 {
|
||||
let wb = (*s.doc().unwrap().wb).clone();
|
||||
let (back, _) = gridcraft_xlsx::read_xlsx(&gridcraft_xlsx::write_xlsx(&wb).unwrap()).unwrap();
|
||||
s.add_document(crate::DocState::new(back, None, "Reopened".into(), crate::Trust::FromFile));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rank_ties_are_dense_and_count_numbers_is_captioned_count_of() {
|
||||
// #1448 items 10 and 12: Excel ranks 5, 4, 3, 3, 4 as 1, 2, 3, 3, 2 (GridCraft gave 1, 2, 4,
|
||||
|
||||
+101
-13
@@ -13,13 +13,15 @@ use gridcraft_core::{CellRef, MAX_COLS, MAX_ROWS, RangeRef, Value};
|
||||
#[cfg(test)]
|
||||
use gridcraft_model::{Alignment, Image, SheetViewMode};
|
||||
use gridcraft_model::{
|
||||
Anchor, BorderLine, BorderStyle, Borders, Color, HAlign, Orientation, PageOrder, PatternType, PrintSettings, ShapeKind, Sheet, Style, StyleId,
|
||||
StyleTable, Underline, VAlign, Visibility, Workbook,
|
||||
Anchor, BorderLine, BorderStyle, Borders, Color, HAlign, Orientation, PageOrder, PatternType, PrintSettings, ReadingOrder, ShapeKind, Sheet,
|
||||
Style, StyleId, StyleTable, Underline, VAlign, Visibility, Workbook,
|
||||
};
|
||||
use gridcraft_pdf::{Font, Page, PdfDoc, Point, Rect, Rgb};
|
||||
use gridcraft_pdf::{Baseline, Font, Page, PdfDoc, Point, Rect, Rgb, TextDirection};
|
||||
use serde_json::{Value as Json, json};
|
||||
|
||||
use super::{CommandSpec, Result, Session, bad, bool_param, cmd, edit, f64_param, has_doc, split_sheet, str_param, target_sheet, u32_param};
|
||||
use super::{
|
||||
CommandSpec, EngineError, Result, Session, bad, bool_param, cmd, edit, f64_param, has_doc, split_sheet, str_param, target_sheet, u32_param,
|
||||
};
|
||||
|
||||
mod draw;
|
||||
mod header_footer;
|
||||
@@ -32,8 +34,69 @@ use header_footer::draw_header_footer;
|
||||
pub use header_footer::{
|
||||
HF_FIELDS, HfContext, HfSection, codes_to_fields, expand_header_footer, fields_to_codes, hf_date_time, join_header_footer, split_header_footer,
|
||||
};
|
||||
/// Decoded pictures (bytes, width, height) keyed by (sheet, picture); `None` = undecodable.
|
||||
type PicCache = std::collections::HashMap<(usize, usize), Option<(Vec<u8>, u32, u32)>>;
|
||||
type DecodedPicture = (Vec<u8>, u32, u32);
|
||||
|
||||
/// What one PDF render shares across the pages an object spans.
|
||||
#[derive(Default)]
|
||||
struct PicCache {
|
||||
/// Decoded pictures (bytes, width, height) keyed by (sheet, picture); `None` = undecodable.
|
||||
decoded: std::collections::HashMap<(usize, usize), Option<DecodedPicture>>,
|
||||
/// Laid-out charts (with their [`chart_cost`]) keyed by (sheet, chart), rendered once however
|
||||
/// many pages they touch. Only charts that can still be drawn are kept.
|
||||
charts: std::collections::HashMap<(usize, usize), (Vec<gridcraft_chart::Prim>, usize)>,
|
||||
/// Charts too big for what was left of the budget: never drawn, so not rendered again.
|
||||
rejected_charts: std::collections::HashSet<(usize, usize)>,
|
||||
/// Bytes of picture pixels embedded so far, and chart cost units emitted so far. Each page an
|
||||
/// object touches gets its own copy in the PDF, so a workbook-controlled anchor over thousands
|
||||
/// of pages would multiply them without bound.
|
||||
image_bytes: usize,
|
||||
chart_prims: usize,
|
||||
}
|
||||
|
||||
impl PicCache {
|
||||
/// The chart's primitives for one more page, or `None` once they no longer fit
|
||||
/// [`MAX_CHART_PRIMS`]. `render` runs at most once per chart; a chart that doesn't fit is
|
||||
/// dropped at once and remembered, so its vectors are never retained.
|
||||
fn chart(&mut self, key: (usize, usize), render: impl FnOnce() -> Vec<gridcraft_chart::Prim>) -> Option<&[gridcraft_chart::Prim]> {
|
||||
if self.rejected_charts.contains(&key) {
|
||||
return None;
|
||||
}
|
||||
let (prims, cost) = match self.charts.remove(&key) {
|
||||
Some(cached) => cached,
|
||||
None => {
|
||||
let prims = render();
|
||||
let cost = chart_cost(&prims);
|
||||
(prims, cost)
|
||||
}
|
||||
};
|
||||
if self.chart_prims.saturating_add(cost) > MAX_CHART_PRIMS {
|
||||
self.rejected_charts.insert(key);
|
||||
return None;
|
||||
}
|
||||
self.chart_prims += cost;
|
||||
Some(&self.charts.entry(key).or_insert((prims, cost)).0)
|
||||
}
|
||||
}
|
||||
|
||||
/// What a chart's drawing costs in the PDF: one unit per primitive plus one per path point (a
|
||||
/// smoothed line holds thousands of points, each written out) and per point of a wedge's outline.
|
||||
fn chart_cost(prims: &[gridcraft_chart::Prim]) -> usize {
|
||||
use gridcraft_chart::Prim;
|
||||
prims
|
||||
.iter()
|
||||
.map(|p| match p {
|
||||
Prim::Line { pts, .. } | Prim::Polygon { pts, .. } => pts.len().saturating_add(1),
|
||||
// At most 400 steps along each of the outer and inner arcs (see `draw_prims`).
|
||||
Prim::Wedge { .. } => 803,
|
||||
_ => 1,
|
||||
})
|
||||
.fold(0, usize::saturating_add)
|
||||
}
|
||||
|
||||
/// Most picture pixel bytes (RGBA, before PDF packing) one render embeds across all pages.
|
||||
const MAX_EMBEDDED_IMAGE_BYTES: usize = 512 * 1024 * 1024;
|
||||
/// Most chart cost units (primitives and path points, see [`chart_cost`]) one render draws across all pages.
|
||||
const MAX_CHART_PRIMS: usize = 4_000_000;
|
||||
|
||||
#[cfg(test)]
|
||||
use layout::bands;
|
||||
@@ -90,8 +153,17 @@ pub(crate) const PX_TO_PT: f32 = 0.75;
|
||||
/// Most pages one export produces.
|
||||
pub const MAX_PAGES: usize = 2000;
|
||||
|
||||
/// A rendered PDF and whether some of its Arabic text was set without an Arabic face.
|
||||
pub struct RenderedPdf {
|
||||
pub bytes: Vec<u8>,
|
||||
pub pages: usize,
|
||||
pub missing_arabic_font: bool,
|
||||
}
|
||||
|
||||
const MISSING_ARABIC_FONT: &str = "Some Arabic text could not be drawn in this PDF because no Noto Sans Arabic face was found for it.";
|
||||
|
||||
/// Renders laid-out sheets to a PDF.
|
||||
pub fn render_pdf(wb: &Workbook, layouts: &[SheetLayout], file: &str, path: &str) -> (Vec<u8>, usize) {
|
||||
pub fn render_pdf(wb: &Workbook, layouts: &[SheetLayout], file: &str, path: &str) -> Result<RenderedPdf> {
|
||||
let mut doc = PdfDoc::new();
|
||||
doc.info.title = if wb.props.title.is_empty() { file.to_string() } else { wb.props.title.clone() };
|
||||
doc.info.author = wb.props.author.clone();
|
||||
@@ -102,7 +174,7 @@ pub fn render_pdf(wb: &Workbook, layouts: &[SheetLayout], file: &str, path: &str
|
||||
let mut printed_blocks = Vec::new();
|
||||
// Decoded pictures are reused across the pages their anchor covers: a floating picture
|
||||
// spanning 40 pages was decoded (and pushed into the PDF) 40 times (#2389).
|
||||
let mut pics = PicCache::new();
|
||||
let mut pics = PicCache::default();
|
||||
for lay in layouts {
|
||||
let Some(sh) = wb.sheet(lay.sheet) else { continue };
|
||||
let mut cf = if sh.cond_formats.is_empty() { None } else { Some(crate::cf::CfCache::new()) };
|
||||
@@ -127,7 +199,16 @@ pub fn render_pdf(wb: &Workbook, layouts: &[SheetLayout], file: &str, path: &str
|
||||
let b = make_block(wb, lay.sheet, sh, *rs, *cs, (x, y), lay);
|
||||
draw_block(pg, &b, lay.settings.gridlines, &mut cf);
|
||||
draw_block_links(pg, &b, page_index, &mut pending_links);
|
||||
printed_blocks.push(PrintedBlock { page: page_index, sheet: lay.sheet, rows: *rs, cols: *cs, x, y, k });
|
||||
printed_blocks.push(PrintedBlock {
|
||||
page: page_index,
|
||||
sheet: lay.sheet,
|
||||
rows: *rs,
|
||||
cols: *cs,
|
||||
x,
|
||||
y,
|
||||
k,
|
||||
mirror_axis: sh.right_to_left.then_some(b.mirror_axis),
|
||||
});
|
||||
if lay.settings.headings {
|
||||
draw_headings(pg, &b, rsi == 0, csi == 0, (ox, oy), (lay.heading_w * k, lay.heading_h * k));
|
||||
}
|
||||
@@ -143,6 +224,7 @@ pub fn render_pdf(wb: &Workbook, layouts: &[SheetLayout], file: &str, path: &str
|
||||
}
|
||||
if lay.settings.headings {
|
||||
let fill = [0xF2, 0xF2, 0xF2];
|
||||
let ox = if sh.right_to_left { lay.page_w - ox - lay.heading_w * k } else { ox };
|
||||
pg.fill_rect(ox, oy, lay.heading_w * k, lay.heading_h * k, fill);
|
||||
pg.rect_stroke(ox, oy, lay.heading_w * k, lay.heading_h * k, 0.3, [0xA0, 0xA0, 0xA0]);
|
||||
}
|
||||
@@ -166,18 +248,24 @@ pub fn render_pdf(wb: &Workbook, layouts: &[SheetLayout], file: &str, path: &str
|
||||
page.link_page(Rect::new(lx, ly, w, h), target_page, Point::new(x, y));
|
||||
}
|
||||
}
|
||||
let n = doc.page_count();
|
||||
(doc.finish(), n)
|
||||
let pages = doc.page_count();
|
||||
let missing_arabic_font = doc.missing_arabic_font();
|
||||
let bytes = doc.finish().map_err(|error| EngineError::Other(error.to_string()))?;
|
||||
Ok(RenderedPdf { bytes, pages, missing_arabic_font })
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- commands
|
||||
|
||||
fn build_pdf(s: &Session, p: &Json, cmd: &str) -> Result<(Vec<u8>, usize)> {
|
||||
fn build_pdf(s: &mut Session, p: &Json, cmd: &str) -> Result<(Vec<u8>, usize)> {
|
||||
let opts = PrintOptions::from_params(p, cmd)?;
|
||||
let d = s.doc()?;
|
||||
let lays = layouts(&d.wb, &opts);
|
||||
let path = d.path.clone().unwrap_or_default();
|
||||
Ok(render_pdf(&d.wb, &lays, &d.display_title(), &path))
|
||||
let pdf = render_pdf(&d.wb, &lays, &d.display_title(), &path)?;
|
||||
if pdf.missing_arabic_font {
|
||||
s.ui_requests.push(crate::UiRequest::Message(MISSING_ARABIC_FONT.into()));
|
||||
}
|
||||
Ok((pdf.bytes, pdf.pages))
|
||||
}
|
||||
|
||||
pub(crate) fn export_pdf(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
|
||||
@@ -32,6 +32,9 @@ fn cell_look(wb: &Workbook, si: usize, sh: &Sheet, c: CellRef, cf: &mut Option<c
|
||||
};
|
||||
let cfl = cf.as_mut().and_then(|cache| cache.look(wb, si, c));
|
||||
if let Some(st) = cfl.as_ref().and_then(|l| l.style.as_ref()) {
|
||||
if st.align.reading_order.is_some() {
|
||||
style.align.reading_order = st.align.reading_order;
|
||||
}
|
||||
if st.fill.pattern != PatternType::None {
|
||||
style.fill = st.fill;
|
||||
}
|
||||
@@ -172,9 +175,20 @@ pub(super) struct Block<'a> {
|
||||
pub(super) ys: Vec<f32>,
|
||||
pub(super) k: f32,
|
||||
pub(super) scale: f32,
|
||||
pub(super) mirror_axis: f32,
|
||||
}
|
||||
|
||||
impl Block<'_> {
|
||||
fn point_x(&self, x: f32) -> f32 {
|
||||
if self.sh.right_to_left { self.mirror_axis - x } else { x }
|
||||
}
|
||||
pub(super) fn text_x(&self, x: f32, width: f32) -> f32 {
|
||||
if self.sh.right_to_left { self.mirror_axis - x - width } else { x }
|
||||
}
|
||||
pub(super) fn drawn_rect(&self, r: RangeRef) -> (f32, f32, f32, f32) {
|
||||
let (x, y, w, h) = self.rect(r);
|
||||
(self.text_x(x, w), y, w, h)
|
||||
}
|
||||
fn x(&self, col: u32) -> f32 {
|
||||
if col >= self.cols.0 && col <= self.cols.1 + 1 {
|
||||
return self.xs.get((col - self.cols.0) as usize).copied().unwrap_or(0.0);
|
||||
@@ -328,15 +342,15 @@ pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Opt
|
||||
set
|
||||
};
|
||||
pg.save();
|
||||
pg.clip_rect(bx, by, bw, bh);
|
||||
pg.clip_rect(b.text_x(bx, bw), by, bw, bh);
|
||||
if gridlines {
|
||||
let grey = [0xB0, 0xB0, 0xB0];
|
||||
let lw = (0.35 * b.scale).clamp(0.1, 0.5);
|
||||
for x in &b.xs {
|
||||
pg.stroke_line(*x, by, *x, by + bh, lw, grey);
|
||||
pg.stroke_line(b.point_x(*x), by, b.point_x(*x), by + bh, lw, grey);
|
||||
}
|
||||
for y in &b.ys {
|
||||
pg.stroke_line(bx, *y, bx + bw, *y, lw, grey);
|
||||
pg.stroke_line(b.point_x(bx), *y, b.point_x(bx + bw), *y, lw, grey);
|
||||
}
|
||||
}
|
||||
// Cheap pre-filter: blank, unstyled cells outside tables and conditional formats draw nothing.
|
||||
@@ -379,17 +393,17 @@ pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Opt
|
||||
continue;
|
||||
}
|
||||
if let Some(f) = l.fill {
|
||||
pg.fill_rect(x, y, w, h, f);
|
||||
pg.fill_rect(b.text_x(x, w), y, w, h, f);
|
||||
} else if merged && gridlines {
|
||||
pg.fill_rect(x, y, w, h, [255, 255, 255]);
|
||||
pg.fill_rect(b.text_x(x, w), y, w, h, [255, 255, 255]);
|
||||
}
|
||||
if merged && gridlines {
|
||||
pg.rect_stroke(x, y, w, h, (0.35 * b.scale).clamp(0.1, 0.5), [0xB0, 0xB0, 0xB0]);
|
||||
pg.rect_stroke(b.text_x(x, w), y, w, h, (0.35 * b.scale).clamp(0.1, 0.5), [0xB0, 0xB0, 0xB0]);
|
||||
}
|
||||
if let Some((frac, rgb, _)) = l.cf.as_ref().and_then(|cf| cf.bar) {
|
||||
let pad = 1.5 * b.k;
|
||||
let bwid = ((w - 2.0 * pad) * frac.clamp(0.0, 1.0)).max(0.0);
|
||||
pg.fill_rect(x + pad, y + pad, bwid, (h - 2.0 * pad).max(0.0), rgb);
|
||||
pg.fill_rect(b.text_x(x + pad, bwid), y + pad, bwid, (h - 2.0 * pad).max(0.0), rgb);
|
||||
}
|
||||
}
|
||||
// Borders.
|
||||
@@ -406,12 +420,12 @@ pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Opt
|
||||
),
|
||||
None => (bd.right, bd.bottom),
|
||||
};
|
||||
draw_border(pg, &bd.top, b.wb, Point::new(x, y), Point::new(x + w, y), b.k);
|
||||
draw_border(pg, &bottom, b.wb, Point::new(x, y + h), Point::new(x + w, y + h), b.k);
|
||||
draw_border(pg, &bd.left, b.wb, Point::new(x, y), Point::new(x, y + h), b.k);
|
||||
draw_border(pg, &right, b.wb, Point::new(x + w, y), Point::new(x + w, y + h), b.k);
|
||||
draw_border(pg, &bd.diag_down, b.wb, Point::new(x, y), Point::new(x + w, y + h), b.k);
|
||||
draw_border(pg, &bd.diag_up, b.wb, Point::new(x, y + h), Point::new(x + w, y), b.k);
|
||||
draw_border(pg, &bd.top, b.wb, Point::new(b.point_x(x), y), Point::new(b.point_x(x + w), y), b.k);
|
||||
draw_border(pg, &bottom, b.wb, Point::new(b.point_x(x), y + h), Point::new(b.point_x(x + w), y + h), b.k);
|
||||
draw_border(pg, &bd.left, b.wb, Point::new(b.point_x(x), y), Point::new(b.point_x(x), y + h), b.k);
|
||||
draw_border(pg, &right, b.wb, Point::new(b.point_x(x + w), y), Point::new(b.point_x(x + w), y + h), b.k);
|
||||
draw_border(pg, &bd.diag_down, b.wb, Point::new(b.point_x(x), y), Point::new(b.point_x(x + w), y + h), b.k);
|
||||
draw_border(pg, &bd.diag_up, b.wb, Point::new(b.point_x(x), y + h), Point::new(b.point_x(x + w), y), b.k);
|
||||
}
|
||||
// Text.
|
||||
for (c, l) in &looks {
|
||||
@@ -420,9 +434,9 @@ pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Opt
|
||||
continue;
|
||||
}
|
||||
if let Some(picture) = sh.cell_pictures.get(c) {
|
||||
draw_cell_picture(pg, &picture.data, (x, y, w, h), b.k);
|
||||
draw_cell_picture(pg, &picture.data, (b.text_x(x, w), y, w, h), b.k);
|
||||
} else if let Some(on) = checkbox_state(l, &sh.value(*c)) {
|
||||
draw_checkbox(pg, (x, y, w, h), b.k, on);
|
||||
draw_checkbox(pg, (b.text_x(x, w), y, w, h), b.k, on);
|
||||
} else {
|
||||
draw_text(pg, b, TextPlacement { cell: *c, look: l, rect: (x, y, w, h), merged, merges: &merges, limits: (bx, bx + bw) });
|
||||
}
|
||||
@@ -476,6 +490,8 @@ pub(super) struct PrintedBlock {
|
||||
pub(super) x: f32,
|
||||
pub(super) y: f32,
|
||||
pub(super) k: f32,
|
||||
/// The page x that right-to-left sheets are mirrored about; `None` for left-to-right sheets.
|
||||
pub(super) mirror_axis: Option<f32>,
|
||||
}
|
||||
|
||||
/// PDF annotations are not affected by graphics clipping, so intersect each cell with its page
|
||||
@@ -495,7 +511,7 @@ pub(super) fn draw_block_links(pg: &mut Page, b: &Block, page: usize, pending: &
|
||||
if x1 <= x0 || y1 <= y0 {
|
||||
continue;
|
||||
}
|
||||
let rect = (x0, y0, x1 - x0, y1 - y0);
|
||||
let rect = (b.text_x(x0, x1 - x0), y0, x1 - x0, y1 - y0);
|
||||
match crate::links::classify(&link.target) {
|
||||
crate::links::LinkKind::External(uri) => pg.link_uri(rect.0, rect.1, rect.2, rect.3, &uri),
|
||||
crate::links::LinkKind::Internal(target) if !link.external => {
|
||||
@@ -514,6 +530,10 @@ pub(super) fn printed_target(wb: &Workbook, blocks: &[PrintedBlock], source_shee
|
||||
let sh = wb.sheet(sheet)?;
|
||||
let block = blocks.iter().find(|b| b.sheet == sheet && (b.rows.0..=b.rows.1).contains(&cell.row) && (b.cols.0..=b.cols.1).contains(&cell.col))?;
|
||||
let x = block.x + (sh.col_left(cell.col) - sh.col_left(block.cols.0)) as f32 * block.k;
|
||||
let x = match block.mirror_axis {
|
||||
Some(axis) => axis - x - (sh.col_left(cell.col.saturating_add(1)) - sh.col_left(cell.col)) as f32 * block.k,
|
||||
None => x,
|
||||
};
|
||||
let y = block.y + (sh.row_top(cell.row) - sh.row_top(block.rows.0)) as f32 * block.k;
|
||||
Some((block.page, x, y))
|
||||
}
|
||||
@@ -530,11 +550,11 @@ pub(super) fn draw_headings(pg: &mut Page, b: &Block, col_heads: bool, row_heads
|
||||
if x1 - x0 <= 0.0 {
|
||||
continue;
|
||||
}
|
||||
pg.fill_rect(x0, y, x1 - x0, size.1, fill);
|
||||
pg.rect_stroke(x0, y, x1 - x0, size.1, lw, line);
|
||||
pg.fill_rect(b.text_x(x0, x1 - x0), y, x1 - x0, size.1, fill);
|
||||
pg.rect_stroke(b.text_x(x0, x1 - x0), y, x1 - x0, size.1, lw, line);
|
||||
let t = gridcraft_core::col_to_letters(col);
|
||||
let tw = gridcraft_pdf::text_width(Font::Helvetica, fsize, &t);
|
||||
pg.text(x0 + (x1 - x0 - tw) / 2.0, y + size.1 / 2.0 + fsize * 0.35, fsize, Font::Helvetica, [0x40, 0x40, 0x40], &t);
|
||||
pg.text(b.text_x(x0 + (x1 - x0 - tw) / 2.0, tw), y + size.1 / 2.0 + fsize * 0.35, fsize, Font::Helvetica, [0x40, 0x40, 0x40], &t);
|
||||
}
|
||||
}
|
||||
if row_heads {
|
||||
@@ -544,11 +564,11 @@ pub(super) fn draw_headings(pg: &mut Page, b: &Block, col_heads: bool, row_heads
|
||||
if y1 - y0 <= 0.0 {
|
||||
continue;
|
||||
}
|
||||
pg.fill_rect(x, y0, size.0, y1 - y0, fill);
|
||||
pg.rect_stroke(x, y0, size.0, y1 - y0, lw, line);
|
||||
pg.fill_rect(b.text_x(x, size.0), y0, size.0, y1 - y0, fill);
|
||||
pg.rect_stroke(b.text_x(x, size.0), y0, size.0, y1 - y0, lw, line);
|
||||
let t = (row + 1).to_string();
|
||||
let tw = gridcraft_pdf::text_width(Font::Helvetica, fsize, &t);
|
||||
pg.text(x + (size.0 - tw) / 2.0, y0 + (y1 - y0) / 2.0 + fsize * 0.35, fsize, Font::Helvetica, [0x40, 0x40, 0x40], &t);
|
||||
pg.text(b.text_x(x + (size.0 - tw) / 2.0, tw), y0 + (y1 - y0) / 2.0 + fsize * 0.35, fsize, Font::Helvetica, [0x40, 0x40, 0x40], &t);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -579,7 +599,7 @@ pub(super) fn make_block<'a>(
|
||||
acc += sh.row_height(r) * k;
|
||||
ys.push(acc);
|
||||
}
|
||||
Block { wb, si, sh, rows, cols, xs, ys, k, scale: lay.scale }
|
||||
Block { wb, si, sh, rows, cols, xs, ys, k, scale: lay.scale, mirror_axis: lay.page_w }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -224,6 +224,12 @@ pub fn layout_sheet(wb: &Workbook, si: usize, opts: &PrintOptions, range_overrid
|
||||
Some(r) => trim_full(sh, r),
|
||||
None => print_range(sh).unwrap_or(RangeRef::cell(CellRef::new(0, 0))),
|
||||
};
|
||||
// A print area from a file or JSON can name coordinates past the grid; pagination walks every
|
||||
// line of the area (zero-height rows never fill a band), so it is held to the grid first.
|
||||
let area = RangeRef::new(
|
||||
CellRef::new(area.start.row.min(MAX_ROWS - 1), area.start.col.min(MAX_COLS - 1)),
|
||||
CellRef::new(area.end.row.min(MAX_ROWS - 1), area.end.col.min(MAX_COLS - 1)),
|
||||
);
|
||||
let title_rows = title_span(st.title_rows, MAX_ROWS);
|
||||
let title_cols = title_span(st.title_cols, MAX_COLS);
|
||||
let digits = format!("{}", area.end.row + 1).len() as f32;
|
||||
@@ -379,3 +385,19 @@ pub(super) fn segments(titles: Option<(u32, u32)>, band: (u32, u32)) -> Vec<(u32
|
||||
pub(super) fn seg_size(sh: &Sheet, seg: (u32, u32), rows: bool) -> f32 {
|
||||
if rows { (seg.0..=seg.1).map(|r| sh.row_height(r)).sum() } else { (seg.0..=seg.1).map(|c| sh.col_width(c)).sum() }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn a_print_area_past_the_grid_is_held_to_the_grid() {
|
||||
let mut wb = Workbook::new();
|
||||
let sh = wb.sheet_mut(0).unwrap();
|
||||
sh.default_row_height = 0.0;
|
||||
sh.print.print_area = Some(RangeRef { start: CellRef::new(0, 0), end: CellRef::new(u32::MAX, u32::MAX) });
|
||||
let lay = layout_sheet(&wb, 0, &PrintOptions::default(), None).unwrap();
|
||||
assert_eq!((lay.area.end.row, lay.area.end.col), (MAX_ROWS - 1, MAX_COLS - 1));
|
||||
assert!(lay.pages.len() <= MAX_PAGES);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use super::draw::{Block, PdfMeasure, Xf, draw_prims, rgb_of};
|
||||
use super::text::wrap_lines;
|
||||
use super::{Anchor, Font, Page, RangeRef, Rect, ShapeKind, Sheet, Value, Workbook};
|
||||
use super::{Anchor, Font, Page, Point, RangeRef, Rect, ShapeKind, Sheet, TextDirection, Value, Workbook};
|
||||
|
||||
/// Cell pictures fit the current cell (or merged-cell) rectangle without changing aspect ratio.
|
||||
pub(super) fn draw_cell_picture(pg: &mut Page, data: &[u8], rect: (f32, f32, f32, f32), k: f32) {
|
||||
@@ -76,9 +76,11 @@ pub(super) fn draw_objects(pg: &mut Page, wb: &Workbook, si: usize, sh: &Sheet,
|
||||
let (bx, by) = (b.xs.first().copied().unwrap_or(0.0), b.ys.first().copied().unwrap_or(0.0));
|
||||
let (bw, bh) = (b.xs.last().copied().unwrap_or(bx) - bx, b.ys.last().copied().unwrap_or(by) - by);
|
||||
let visible = |r: (f64, f64, f64, f64)| r.2 > 0.0 && r.3 > 0.0 && r.0 < sx1 && r.0 + r.2 > sx0 && r.1 < sy1 && r.1 + r.3 > sy0;
|
||||
let place = |r: (f64, f64, f64, f64)| (bx + ((r.0 - sx0) as f32) * b.k, by + ((r.1 - sy0) as f32) * b.k, r.2 as f32 * b.k, r.3 as f32 * b.k);
|
||||
let place = |r: (f64, f64, f64, f64)| {
|
||||
(b.text_x(bx + ((r.0 - sx0) as f32) * b.k, r.2 as f32 * b.k), by + ((r.1 - sy0) as f32) * b.k, r.2 as f32 * b.k, r.3 as f32 * b.k)
|
||||
};
|
||||
pg.save();
|
||||
pg.clip_rect(bx, by, bw, bh);
|
||||
pg.clip_rect(b.text_x(bx, bw), by, bw, bh);
|
||||
draw_sparklines(pg, wb, si, sh, b, block);
|
||||
for (imi, im) in sh.images.iter().enumerate() {
|
||||
let r = anchor_rect(sh, &im.anchor);
|
||||
@@ -88,9 +90,14 @@ pub(super) fn draw_objects(pg: &mut Page, wb: &Workbook, si: usize, sh: &Sheet,
|
||||
let (x, y, w, h) = place(r);
|
||||
// About 150 dpi is plenty for print.
|
||||
let (mw, mh) = (((w / 72.0) * 150.0).ceil().clamp(1.0, 4000.0) as u32, ((h / 72.0) * 150.0).ceil().clamp(1.0, 4000.0) as u32);
|
||||
let decoded = pics.entry((si, imi)).or_insert_with(|| decode_image(&im.data, mw, mh));
|
||||
let decoded = pics.decoded.entry((si, imi)).or_insert_with(|| decode_image(&im.data, mw, mh));
|
||||
if let Some((px, pw, ph)) = decoded.as_ref() {
|
||||
pg.image_rgba(Rect::new(x, y, w, h), px, [*pw, *ph]);
|
||||
// Every page the picture touches embeds its own copy: past the budget it is left out.
|
||||
let bytes = px.len();
|
||||
if pics.image_bytes.saturating_add(bytes) <= super::MAX_EMBEDDED_IMAGE_BYTES {
|
||||
pics.image_bytes += bytes;
|
||||
pg.image_rgba(Rect::new(x, y, w, h), px, [*pw, *ph]);
|
||||
}
|
||||
}
|
||||
}
|
||||
for shp in &sh.shapes {
|
||||
@@ -120,15 +127,20 @@ pub(super) fn draw_objects(pg: &mut Page, wb: &Workbook, si: usize, sh: &Sheet,
|
||||
}
|
||||
draw_shape(pg, wb, shp, b, (x, y, w, h));
|
||||
}
|
||||
for ch in &sh.charts {
|
||||
for (chi, ch) in sh.charts.iter().enumerate() {
|
||||
let r = anchor_rect(sh, &ch.anchor);
|
||||
if !visible(r) {
|
||||
continue;
|
||||
}
|
||||
let (x, y, _, _) = place(r);
|
||||
let data = gridcraft_chart::resolve(wb, si, ch);
|
||||
let prims = gridcraft_chart::render(ch, &data, r.2 as f32, r.3 as f32, &PdfMeasure);
|
||||
draw_prims(pg, &prims, Xf { ox: x, oy: y, k: b.k });
|
||||
// As for pictures, each page gets its own copy of the drawing commands.
|
||||
let prims = pics.chart((si, chi), || {
|
||||
let data = gridcraft_chart::resolve(wb, si, ch);
|
||||
gridcraft_chart::render(ch, &data, r.2 as f32, r.3 as f32, &PdfMeasure)
|
||||
});
|
||||
if let Some(prims) = prims {
|
||||
draw_prims(pg, prims, Xf { ox: x, oy: y, k: b.k });
|
||||
}
|
||||
}
|
||||
pg.restore();
|
||||
}
|
||||
@@ -143,9 +155,19 @@ fn draw_sparklines(pg: &mut Page, wb: &Workbook, si: usize, sh: &Sheet, b: &Bloc
|
||||
v => vec![v.as_f64()],
|
||||
};
|
||||
let color = rgb_of(sp.color, wb).unwrap_or([0x15, 0x60, 0x82]);
|
||||
let (x, y, w, h) = b.rect(RangeRef::cell(sp.cell));
|
||||
let (x, y, w, h) = b.drawn_rect(RangeRef::cell(sp.cell));
|
||||
let (wpx, hpx) = (w / b.k, h / b.k);
|
||||
let prims = gridcraft_chart::render_sparkline(sp.kind, &vals, [color[0], color[1], color[2], 255], sp.markers, wpx, hpx);
|
||||
let mut prims = gridcraft_chart::render_sparkline(sp.kind, &vals, [color[0], color[1], color[2], 255], sp.markers, wpx, hpx);
|
||||
if sh.right_to_left {
|
||||
for prim in &mut prims {
|
||||
match prim {
|
||||
gridcraft_chart::Prim::Rect { x, w, .. } => *x = wpx - *x - *w,
|
||||
gridcraft_chart::Prim::Line { pts, .. } => pts.iter_mut().for_each(|p| p[0] = wpx - p[0]),
|
||||
gridcraft_chart::Prim::Circle { cx, .. } => *cx = wpx - *cx,
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
draw_prims(pg, &prims, Xf { ox: x, oy: y, k: b.k });
|
||||
}
|
||||
}
|
||||
@@ -189,7 +211,7 @@ fn draw_shape(pg: &mut Page, wb: &Workbook, shp: &gridcraft_model::Shape, b: &Bl
|
||||
let color = fm.text_color.and_then(|c| rgb_of(c, wb)).unwrap_or([0, 0, 0]);
|
||||
let align = fm.align.unwrap_or(if text_box { ShapeTextAlign::Left } else { ShapeTextAlign::Center });
|
||||
let anchor = fm.anchor.unwrap_or(if text_box { ShapeTextAnchor::Top } else { ShapeTextAnchor::Middle });
|
||||
let lines = wrap_lines(&shp.text, font, size, (w - 4.0 * b.k).max(size));
|
||||
let lines = wrap_lines(&shp.text, font, size, (w - 4.0 * b.k).max(size), TextDirection::Auto);
|
||||
let block_h = lines.len().min(500) as f32 * size * 1.2;
|
||||
let mut yy = match anchor {
|
||||
ShapeTextAnchor::Top => y + 2.0 * b.k,
|
||||
@@ -197,13 +219,28 @@ fn draw_shape(pg: &mut Page, wb: &Workbook, shp: &gridcraft_model::Shape, b: &Bl
|
||||
ShapeTextAnchor::Bottom => y + h - 2.0 * b.k - block_h,
|
||||
} + size * 0.8;
|
||||
for l in lines.iter().take(500) {
|
||||
let lw = gridcraft_pdf::text_width(font, size, l);
|
||||
let lw = gridcraft_pdf::text_width_with_direction(font, size, &l.text, l.direction);
|
||||
let lx = match align {
|
||||
ShapeTextAlign::Left => x + 2.0 * b.k,
|
||||
ShapeTextAlign::Center => x + (w - lw) / 2.0,
|
||||
ShapeTextAlign::Right => x + w - 2.0 * b.k - lw,
|
||||
};
|
||||
pg.text(lx, yy, size, font, color, l);
|
||||
// WordArt's drop shadow: the line again, offset, in the shadow colour (under the text).
|
||||
if let Some(sc) = fm.text_shadow.and_then(|c| rgb_of(c, wb)) {
|
||||
let off = (size * 0.06).max(0.5);
|
||||
pg.text_with_direction(Point::new(lx + off, yy + off), size, font, sc, &l.text, l.direction);
|
||||
}
|
||||
// WordArt's text outline, as on screen: the line in the outline colour, offset in eight
|
||||
// directions by half the outline width, under the filled text.
|
||||
if let Some((c, ow)) = fm.text_outline
|
||||
&& let Some(oc) = rgb_of(c, wb)
|
||||
{
|
||||
let d = (ow * b.scale / 2.0).clamp(0.25, 20.0);
|
||||
for (dx, dy) in [(-1.0, -1.0), (0.0, -1.0), (1.0, -1.0), (-1.0, 0.0), (1.0, 0.0), (-1.0, 1.0), (0.0, 1.0), (1.0, 1.0)] {
|
||||
pg.text_with_direction(Point::new(lx + dx * d, yy + dy * d), size, font, oc, &l.text, l.direction);
|
||||
}
|
||||
}
|
||||
pg.text_with_direction(Point::new(lx, yy), size, font, color, &l.text, l.direction);
|
||||
yy += size * 1.2;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
use gridcraft_model::{Sparkline, SparklineKind};
|
||||
use serde_json::json;
|
||||
|
||||
use super::*;
|
||||
@@ -15,6 +16,35 @@ fn pdf_of(s: &mut Session, p: Json) -> (Vec<u8>, u64) {
|
||||
fn contains(hay: &[u8], needle: &str) -> bool {
|
||||
hay.windows(needle.len()).any(|w| w == needle.as_bytes())
|
||||
}
|
||||
fn arabic_face_available() -> bool {
|
||||
let mut doc = gridcraft_pdf::PdfDoc::new();
|
||||
doc.add_page(100.0, 100.0).text(0.0, 50.0, 10.0, Font::Helvetica, [0, 0, 0], "مرحبا");
|
||||
!doc.missing_arabic_font()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn right_to_left_sheets_mirror_link_rectangles_and_targets() {
|
||||
fn numbers_after(pdf: &[u8], key: &str, n: usize) -> Vec<f32> {
|
||||
let text = String::from_utf8_lossy(pdf);
|
||||
let at = text.find(key).unwrap() + key.len();
|
||||
text[at..].split([' ', ']']).filter_map(|t| t.parse().ok()).take(n).collect()
|
||||
}
|
||||
let mut s = s();
|
||||
s.execute("insert.link", json!({"cell": "A1", "target": "https://example.org/report"})).unwrap();
|
||||
s.execute("insert.link", json!({"cell": "A2", "target": "Sheet1!B60"})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "B60", "input": "Destination"})).unwrap();
|
||||
let (ltr, _) = pdf_of(&mut s, json!({}));
|
||||
s.execute("view.rightToLeft", json!({"on": true})).unwrap();
|
||||
let (rtl, _) = pdf_of(&mut s, json!({}));
|
||||
let axis = numbers_after(<r, "/MediaBox [", 4)[2];
|
||||
let (l, r) = (numbers_after(<r, "/Rect [", 4), numbers_after(&rtl, "/Rect [", 4));
|
||||
assert!((r[0] - (axis - l[2])).abs() < 0.01 && (r[2] - (axis - l[0])).abs() < 0.01, "{l:?} mirrors to {r:?}");
|
||||
assert_eq!(r[1], l[1]);
|
||||
let b_width = s.doc().unwrap().wb.active().unwrap().col_width(1);
|
||||
let (lx, rx) = (numbers_after(<r, "/XYZ ", 1)[0], numbers_after(&rtl, "/XYZ ", 1)[0]);
|
||||
let k = (l[2] - l[0]) / s.doc().unwrap().wb.active().unwrap().col_width(0);
|
||||
assert!((rx - (axis - lx - b_width * k)).abs() < 0.01, "target {lx} mirrors to {rx}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chart_data_table_prints_formatted_values_and_follows_recalculation() {
|
||||
@@ -58,6 +88,199 @@ fn pdf_export_keeps_safe_links_on_their_printed_pages() {
|
||||
assert!(!cropped.contains("/Dest ["));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arabic_with_characters_its_font_lacks_still_exports() {
|
||||
let mut s = s();
|
||||
s.execute("cell.set", json!({"cell": "A1", "input": "مرحبا 😀"})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "A2", "input": "مرحبا Привет"})).unwrap();
|
||||
let out = s.execute("file.exportPdf", json!({})).unwrap();
|
||||
assert_eq!(out["pages"], 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrapping_keeps_combining_marks_with_their_letters() {
|
||||
let word = "a\u{301}a\u{301}a\u{301}a\u{301}";
|
||||
let lines = wrap_lines(word, Font::Helvetica, 10.0, 7.0, TextDirection::Auto);
|
||||
assert_eq!(lines.iter().map(|line| line.text.as_str()).collect::<String>(), word);
|
||||
assert!(lines.iter().all(|line| line.text == "a\u{301}"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arabic_cells_headers_and_charts_export_searchable_shaped_text() {
|
||||
if !arabic_face_available() && std::env::var_os("CRAFT_FONTS_REQUIRED").is_none() {
|
||||
return;
|
||||
}
|
||||
let mut s = s();
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": [["مَرْحَبًا 123 (ABC)", "القيمة"], ["تفاح", 3], ["كمثرى", 5], ["العَرَبِيَّة العَرَبِيَّة العَرَبِيَّة العَرَبِيَّة العَرَبِيَّة", null], ["تقرير ١٢٣ (ABC)", null], ["مرحبا", null]]})).unwrap();
|
||||
s.execute("home.columnWidth", json!({"cols": "A:B", "chars": 32})).unwrap();
|
||||
s.execute("home.rowHeight", json!({"rows": "1:6", "height": 50})).unwrap();
|
||||
s.execute("home.fontSize", json!({"range": "A1:B6", "size": 20})).unwrap();
|
||||
s.execute("home.rowHeight", json!({"rows": "4:4", "height": 90})).unwrap();
|
||||
s.execute("home.bold", json!({"range": "A2"})).unwrap();
|
||||
s.execute("home.italic", json!({"range": "A3"})).unwrap();
|
||||
s.execute("home.wrapText", json!({"range": "A4"})).unwrap();
|
||||
s.execute("home.orientation", json!({"range": "A6", "angle": 30})).unwrap();
|
||||
s.execute("pageLayout.pageSetup", json!({"header": "&Cتقرير المبيعات 2026", "gridlines": true})).unwrap();
|
||||
s.execute("insert.chart", json!({"range": "A1:B3", "type": "column"})).unwrap();
|
||||
{
|
||||
let d = s.doc_mut().unwrap();
|
||||
let wb = std::sync::Arc::make_mut(&mut d.wb);
|
||||
for chart in &mut wb.sheet_mut(0).unwrap().charts {
|
||||
chart.anchor.cell = CellRef::new(8, 0);
|
||||
chart.anchor.width = 500.0;
|
||||
chart.anchor.height = 280.0;
|
||||
}
|
||||
}
|
||||
let (pdf, pages) = pdf_of(&mut s, json!({"fitToPage": true}));
|
||||
assert_eq!(pages, 1);
|
||||
assert!(contains(&pdf, "/Subtype /Type3"));
|
||||
for text in ["مَرْحَبًا 123 (ABC)", "تقرير المبيعات 2026", "القيمة", "تفاح", "كمثرى"] {
|
||||
let utf16 = text.encode_utf16().map(|unit| format!("{unit:04X}")).collect::<String>();
|
||||
assert!(contains(&pdf, &format!("/ActualText <FEFF{utf16}>")), "missing text {text}");
|
||||
}
|
||||
let lines = wrap_lines("العَرَبِيَّةالعَرَبِيَّة", Font::Helvetica, 20.0, 40.0, TextDirection::Auto);
|
||||
assert_eq!(lines.iter().map(|line| line.text.as_str()).collect::<String>(), "العَرَبِيَّةالعَرَبِيَّة");
|
||||
assert!(lines.iter().all(|line| !line.text.starts_with(['َ', 'ِ', 'ُ', 'ّ', 'ْ'])));
|
||||
assert!(lines.iter().all(|line| gridcraft_pdf::text_width_with_direction(Font::Helvetica, 20.0, &line.text, line.direction) <= 40.0));
|
||||
let path = std::env::temp_dir().join(format!("gridcraft-arabic-export-{}.pdf", std::process::id()));
|
||||
std::fs::write(&path, &pdf).unwrap();
|
||||
eprintln!("Arabic PDF artifact: {}", path.display());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arabic_reading_order_export_artifact() {
|
||||
if !arabic_face_available() && std::env::var_os("CRAFT_FONTS_REQUIRED").is_none() {
|
||||
return;
|
||||
}
|
||||
let mut s = s();
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": [["Context", "LeftToRight", "RightToLeft"], ["مرحبا ABC !", "مرحبا ABC !", "مرحبا ABC !"], ["123 مرحبا ABC", "123 مرحبا ABC", "123 مرحبا ABC"], ["(مرحبا) ABC", "(مرحبا) ABC", "(مرحبا) ABC"], ["مرحبا ABC ! DEF ? مرحبا", "مرحبا ABC ! DEF ? مرحبا", "مرحبا ABC ! DEF ? مرحبا"]]})).unwrap();
|
||||
s.execute("home.columnWidth", json!({"cols": "A:C", "chars": 24})).unwrap();
|
||||
s.execute("home.rowHeight", json!({"rows": "1:5", "height": 60})).unwrap();
|
||||
s.execute("home.fontSize", json!({"range": "A2:C5", "size": 18})).unwrap();
|
||||
for (range, order) in [("A2:A5", "Context"), ("B2:B5", "LeftToRight"), ("C2:C5", "RightToLeft")] {
|
||||
s.execute("home.formatCells", json!({"range": range, "style": {"align": {"reading_order": order}}})).unwrap();
|
||||
}
|
||||
s.execute("home.wrapText", json!({"range": "A5:C5"})).unwrap();
|
||||
s.execute("pageLayout.pageSetup", json!({"gridlines": true, "header": "&CArabic cell reading order"})).unwrap();
|
||||
let (pdf, _) = pdf_of(&mut s, json!({}));
|
||||
for text in ["مرحبا ABC !", "123 مرحبا ABC", "(مرحبا) ABC"] {
|
||||
let utf16 = text.encode_utf16().map(|unit| format!("{unit:04X}")).collect::<String>();
|
||||
assert!(contains(&pdf, &format!("/ActualText <FEFF{utf16}>")));
|
||||
}
|
||||
let path = std::env::temp_dir().join(format!("gridcraft-arabic-reading-order-{}.pdf", std::process::id()));
|
||||
std::fs::write(&path, &pdf).unwrap();
|
||||
eprintln!("Arabic reading-order PDF artifact: {}", path.display());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrapped_lines_keep_the_paragraph_direction() {
|
||||
let lines = wrap_lines("مرحبا ABC ! DEF ?\nLatin مرحبا !", Font::Helvetica, 10.0, 30.0, TextDirection::Auto);
|
||||
let split = lines.iter().position(|l| l.text.starts_with("Latin")).unwrap();
|
||||
assert!(split > 0);
|
||||
assert!(lines[..split].iter().all(|l| l.direction == TextDirection::RightToLeft));
|
||||
assert!(lines[split..].iter().all(|l| l.direction == TextDirection::LeftToRight));
|
||||
let lines = wrap_lines("123 مرحبا ABC !", Font::Helvetica, 10.0, 30.0, TextDirection::Context.resolve("123 مرحبا ABC !"));
|
||||
assert!(lines.iter().all(|l| l.direction == TextDirection::LeftToRight));
|
||||
}
|
||||
|
||||
fn exported_text_x(pdf: &[u8], text: &str) -> f32 {
|
||||
let pdf = String::from_utf8_lossy(pdf);
|
||||
let marker = format!("({text}) Tj");
|
||||
let before = &pdf[..pdf.find(&marker).unwrap()];
|
||||
let matrix = before.lines().rev().find(|line| line.ends_with(" Tm")).unwrap();
|
||||
matrix.split_whitespace().nth(4).unwrap().parse().unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cell_reading_order_and_conditional_context_reach_pdf() {
|
||||
let mut s = s();
|
||||
s.execute("cell.set", json!({"cell": "A1", "input": "ABC !"})).unwrap();
|
||||
s.execute("home.formatCells", json!({"range": "A1", "style": {"align": {"reading_order": "RightToLeft"}}})).unwrap();
|
||||
let (rtl, _) = pdf_of(&mut s, json!({}));
|
||||
assert!(contains(&rtl, "(! ABC) Tj"));
|
||||
assert!(!contains(&rtl, "/Subtype /Type3"));
|
||||
s.execute("home.conditionalFormat", json!({"range": "A1", "rule": {"type": "noBlanks", "style": {"align": {"reading_order": "Context"}}}}))
|
||||
.unwrap();
|
||||
let (context, _) = pdf_of(&mut s, json!({}));
|
||||
assert!(contains(&context, "(ABC !) Tj"));
|
||||
assert!(!contains(&context, "(! ABC) Tj"));
|
||||
assert!(exported_text_x(&rtl, "! ABC") > exported_text_x(&context, "ABC !"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rtl_sheet_sparkline_reflects_with_cell_geometry() {
|
||||
let mut wb = Workbook::new();
|
||||
let sh = wb.sheet_mut(0).unwrap();
|
||||
sh.set_value(CellRef::new(0, 0), Value::Number(1.0));
|
||||
sh.set_value(CellRef::new(1, 0), Value::Number(3.0));
|
||||
sh.sparklines.push(Sparkline {
|
||||
cell: CellRef::new(0, 1),
|
||||
source: "A1:A2".into(),
|
||||
kind: SparklineKind::Line,
|
||||
color: Color::rgb(255, 0, 0),
|
||||
markers: false,
|
||||
});
|
||||
let options = PrintOptions { range: RangeRef::parse("A1:B2"), ..PrintOptions::default() };
|
||||
let ltr = render_pdf(&wb, &layouts(&wb, &options), "", "").unwrap().bytes;
|
||||
wb.sheet_mut(0).unwrap().right_to_left = true;
|
||||
let rtl = render_pdf(&wb, &layouts(&wb, &options), "", "").unwrap().bytes;
|
||||
let points = |pdf: &[u8]| {
|
||||
let pdf = String::from_utf8_lossy(pdf);
|
||||
let after = pdf.split("1 0 0 RG\n").nth(1).unwrap();
|
||||
let line = after.lines().find(|line| line.ends_with(" l S")).unwrap();
|
||||
let values: Vec<_> = line.split_whitespace().collect();
|
||||
(values[0].parse::<f32>().unwrap(), values[3].parse::<f32>().unwrap())
|
||||
};
|
||||
let (left0, left1) = points(<r);
|
||||
let (right0, right1) = points(&rtl);
|
||||
assert!(left0 < left1 && right0 > right1);
|
||||
assert!((left0 + right0 - 612.0).abs() < 0.001);
|
||||
assert!((left1 + right1 - 612.0).abs() < 0.001);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_left_and_right_keep_their_side_on_a_right_to_left_sheet() {
|
||||
let mut s = s();
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": [["LEFT"], ["RIGHT"]]})).unwrap();
|
||||
s.execute("home.alignLeft", json!({"range": "A1"})).unwrap();
|
||||
s.execute("home.alignRight", json!({"range": "A2"})).unwrap();
|
||||
let (ltr, _) = pdf_of(&mut s, json!({}));
|
||||
s.execute("view.rightToLeft", json!({"on": true})).unwrap();
|
||||
let (rtl, _) = pdf_of(&mut s, json!({}));
|
||||
let width = |label| gridcraft_pdf::text_width(Font::Helvetica, 11.0, label);
|
||||
let (left, right) = (width("LEFT"), width("RIGHT"));
|
||||
let ltr_gap = exported_text_x(<r, "RIGHT") + right - exported_text_x(<r, "LEFT");
|
||||
let rtl_gap = exported_text_x(&rtl, "RIGHT") + right - exported_text_x(&rtl, "LEFT");
|
||||
assert!((ltr_gap - rtl_gap).abs() < 0.01, "Left stays left of Right in the cell: {ltr_gap}, {rtl_gap}");
|
||||
assert!(exported_text_x(&rtl, "LEFT") + left < exported_text_x(&rtl, "RIGHT") + right);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rtl_sheet_pdf_mirrors_cells_merges_headings_and_object_anchors() {
|
||||
let mut s = s();
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": [["FIRST", "SECOND"], [null, "MERGED"]]})).unwrap();
|
||||
s.execute("home.mergeCenter", json!({"range": "B2:C2"})).unwrap();
|
||||
s.execute("pageLayout.pageSetup", json!({"printArea": "A1:D5", "headings": true, "gridlines": true, "left": 0.8, "right": 0.4})).unwrap();
|
||||
s.execute("insert.shape", json!({"kind": "rectangle", "at": "B4", "width": 128, "height": 30, "text": "OBJECT"})).unwrap();
|
||||
let (ltr, _) = pdf_of(&mut s, json!({}));
|
||||
s.execute("view.rightToLeft", json!({"on": true})).unwrap();
|
||||
let (rtl, _) = pdf_of(&mut s, json!({}));
|
||||
for label in ["FIRST", "SECOND", "MERGED", "A", "B", "C", "D", "1", "2", "OBJECT"] {
|
||||
let left = exported_text_x(<r, label);
|
||||
let right = exported_text_x(&rtl, label);
|
||||
let font_size = if ["A", "B", "C", "D", "1", "2"].contains(&label) { 9.0 } else { 11.0 };
|
||||
let width = gridcraft_pdf::text_width(Font::Helvetica, font_size, label);
|
||||
assert!((left + right + width - 612.0).abs() < 0.01, "{label}: {left}, {right}, {width}");
|
||||
}
|
||||
assert!(exported_text_x(<r, "FIRST") < exported_text_x(<r, "SECOND"));
|
||||
assert!(exported_text_x(&rtl, "FIRST") > exported_text_x(&rtl, "SECOND"));
|
||||
for (name, pdf) in [("ltr", ltr), ("rtl", rtl)] {
|
||||
let path = std::env::temp_dir().join(format!("gridcraft-print-direction-{name}-{}.pdf", std::process::id()));
|
||||
std::fs::write(&path, pdf).unwrap();
|
||||
eprintln!("Print direction PDF artifact: {}", path.display());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn header_sections_split_join_and_field_names() {
|
||||
let spec = "&L&\"Arial,Bold\"Sales &&Co&CPage &P of &N&R&D";
|
||||
@@ -694,11 +917,32 @@ fn bands_unit() {
|
||||
let b = bands(0, 2, |r| if r == 1 { 100.0 } else { 10.0 }, |_| 35.0, &[], 100);
|
||||
assert_eq!(b, vec![(0, 0), (1, 1), (2, 2)]);
|
||||
assert_eq!(bands(0, 1_000_000, |_| 10.0, |_| 5.0, &[], 3).len(), 3);
|
||||
let w = wrap_lines("the quick brown fox jumps", Font::Helvetica, 10.0, 50.0);
|
||||
let w = wrap_lines("the quick brown fox jumps", Font::Helvetica, 10.0, 50.0, TextDirection::Auto);
|
||||
assert!(w.len() >= 2);
|
||||
assert!(w.iter().all(|l| gridcraft_pdf::text_width(Font::Helvetica, 10.0, l) <= 50.0 || !l.contains(' ')));
|
||||
let w = wrap_lines("Supercalifragilistic", Font::Helvetica, 10.0, 20.0);
|
||||
assert!(w.iter().all(|l| gridcraft_pdf::text_width_with_direction(Font::Helvetica, 10.0, &l.text, l.direction) <= 50.0 || !l.text.contains(' ')));
|
||||
let w = wrap_lines("Supercalifragilistic", Font::Helvetica, 10.0, 20.0, TextDirection::Auto);
|
||||
assert!(w.len() > 2);
|
||||
let long = "abcdefghij".repeat(300);
|
||||
let w = wrap_lines(&long, Font::Helvetica, 10.0, 50.0, TextDirection::Auto);
|
||||
assert_eq!(w.iter().map(|l| l.text.as_str()).collect::<String>(), long);
|
||||
assert!(w.iter().all(|l| gridcraft_pdf::text_width_with_direction(Font::Helvetica, 10.0, &l.text, l.direction) <= 50.0));
|
||||
let mut at = 0;
|
||||
for l in &w[..w.len() - 1] {
|
||||
let one_more = &long[at..at + l.text.len() + 1];
|
||||
assert!(gridcraft_pdf::text_width_with_direction(Font::Helvetica, 10.0, one_more, l.direction) > 50.0, "each split is as long as fits");
|
||||
at += l.text.len();
|
||||
}
|
||||
}
|
||||
|
||||
fn wrapped_text(text: &str, font: Font, size: f32, width: f32) -> Vec<String> {
|
||||
wrap_lines(text, font, size, width, TextDirection::Auto).into_iter().map(|line| line.text).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrapping_ignores_the_width_of_undrawn_bidi_marks() {
|
||||
let word = "i\u{200e}".repeat(20);
|
||||
assert!(gridcraft_pdf::text_width(Font::Helvetica, 10.0, &word) <= 50.0);
|
||||
assert_eq!(wrapped_text(&word, Font::Helvetica, 10.0, 50.0), vec![word.clone()]);
|
||||
}
|
||||
|
||||
/// The wrapper `wrap_lines` replaced, re-measuring strings, as the reference for its lines.
|
||||
@@ -755,7 +999,11 @@ fn wrap_lines_matches_the_remeasuring_wrapper() {
|
||||
for text in texts {
|
||||
for font in [Font::Helvetica, Font::HelveticaBold, Font::Courier] {
|
||||
for (size, width) in [(10.0, 50.0), (10.0, 20.0), (11.0, 1.0), (8.0, 300.0), (12.0, 0.0)] {
|
||||
assert_eq!(wrap_lines(text, font, size, width), wrap_lines_remeasuring(text, font, size, width), "{text:?} {font:?} {size} {width}");
|
||||
assert_eq!(
|
||||
wrapped_text(text, font, size, width),
|
||||
wrap_lines_remeasuring(text, font, size, width),
|
||||
"{text:?} {font:?} {size} {width}"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -766,12 +1014,24 @@ fn wrapping_a_long_word_in_a_narrow_box_stops_at_the_line_limit() {
|
||||
// One character per line: the old wrapper re-measured and copied the rest of the word for
|
||||
// each of the 100,000 lines before checking the limit.
|
||||
let word = "w".repeat(100_000);
|
||||
let lines = wrap_lines(&word, Font::Helvetica, 10.0, 1.0);
|
||||
let lines = wrapped_text(&word, Font::Helvetica, 10.0, 1.0);
|
||||
assert!(lines.len() <= 2002, "{}", lines.len());
|
||||
assert!(lines.iter().all(|l| l == "w"));
|
||||
// A long paragraph in a very wide box is one line.
|
||||
let para = vec!["word"; 50_000].join(" ");
|
||||
assert_eq!(wrap_lines(¶, Font::Helvetica, 10.0, 1.0e9), vec![para.clone()]);
|
||||
assert_eq!(wrapped_text(¶, Font::Helvetica, 10.0, 1.0e9), vec![para.clone()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrapping_a_long_arabic_word_measures_pieces_not_the_rest_of_the_word() {
|
||||
let word = "مرحبا".repeat(10_000);
|
||||
if !arabic_face_available() {
|
||||
return;
|
||||
}
|
||||
let lines = wrapped_text(&word, Font::Helvetica, 10.0, 20.0);
|
||||
assert!(lines.len() > 2000 && lines.len() <= 2002, "{}", lines.len());
|
||||
assert!(lines.iter().take(2000).all(|line| gridcraft_pdf::text_width(Font::Helvetica, 10.0, line) <= 20.0));
|
||||
assert!(word.starts_with(&lines.concat()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -938,3 +1198,27 @@ fn equations_print_with_the_symbol_font() {
|
||||
// A glyph no standard font has is a [?] box.
|
||||
assert!(contains(&pdf, "(?) Tj"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chart_budget_counts_path_points_and_drops_charts_that_do_not_fit() {
|
||||
use gridcraft_chart::Prim;
|
||||
let line = |n: usize| Prim::Line { pts: vec![[0.0, 0.0]; n], color: [0, 0, 0, 255], width: 1.0, dash: false };
|
||||
// A smoothed line is its points, not one unit.
|
||||
assert_eq!(chart_cost(&[line(4000), Prim::Circle { cx: 0.0, cy: 0.0, r: 1.0, fill: None, stroke: None }]), 4002);
|
||||
// Room for exactly two copies of a 1,000-point chart.
|
||||
let mut pics = PicCache { chart_prims: MAX_CHART_PRIMS - 2002, ..Default::default() };
|
||||
let mut renders = 0;
|
||||
for expect in [true, true, false, false] {
|
||||
let got = pics.chart((0, 0), || {
|
||||
renders += 1;
|
||||
vec![line(1000)]
|
||||
});
|
||||
assert_eq!(got.is_some(), expect);
|
||||
}
|
||||
assert_eq!(renders, 1, "a rejected chart is not rendered again");
|
||||
assert!(pics.charts.is_empty(), "and its primitives are not kept");
|
||||
// A chart too big for what is left is dropped without being cached at all.
|
||||
let mut pics = PicCache { chart_prims: MAX_CHART_PRIMS - 10, ..Default::default() };
|
||||
assert!(pics.chart((0, 1), || vec![line(1000)]).is_none());
|
||||
assert!(pics.charts.is_empty() && pics.rejected_charts.contains(&(0, 1)));
|
||||
}
|
||||
|
||||
@@ -1,78 +1,176 @@
|
||||
use super::draw::{Block, Look, rgb_of};
|
||||
use super::{CellRef, Color, Font, HAlign, MAX_COLS, Page, Point, RangeRef, Sheet, Style, StyleTable, Underline, VAlign, Value};
|
||||
use super::{
|
||||
Baseline, CellRef, Color, Font, HAlign, MAX_COLS, Page, Point, RangeRef, ReadingOrder, Sheet, Style, StyleTable, TextDirection, Underline,
|
||||
VAlign, Value,
|
||||
};
|
||||
use unicode_segmentation::UnicodeSegmentation;
|
||||
|
||||
const PAD_PX: f32 = 2.0;
|
||||
|
||||
/// Most lines [`wrap_lines`] returns (it may return one more, the rest of a paragraph).
|
||||
const MAX_WRAP_LINES: usize = 2000;
|
||||
|
||||
/// Word-wraps `text` to `width` points.
|
||||
pub(super) struct TextLine {
|
||||
pub(super) text: String,
|
||||
pub(super) direction: TextDirection,
|
||||
}
|
||||
|
||||
/// Word-wraps `text` to `width` points, keeping each paragraph's base direction on every
|
||||
/// continuation line.
|
||||
///
|
||||
/// Widths are kept as running sums of glyph widths (the sum `text_width` makes), so each
|
||||
/// character is measured once: re-measuring the line for every word, or the rest of an
|
||||
/// over-long word for every piece cut from it, made a long paragraph or word quadratic.
|
||||
pub(super) fn wrap_lines(text: &str, font: Font, size: f32, width: f32) -> Vec<String> {
|
||||
/// A paragraph whose width is not that sum is measured as drawn by [`wrap_measured_paragraph`].
|
||||
pub(super) fn wrap_lines(text: &str, font: Font, size: f32, width: f32, direction: TextDirection) -> Vec<TextLine> {
|
||||
let mut out = Vec::new();
|
||||
for para in text.split('\n') {
|
||||
let direction = direction.resolve(para);
|
||||
if gridcraft_pdf::width_is_char_sum(font, para, direction) {
|
||||
wrap_summed_paragraph(para, font, size, width, direction, &mut out);
|
||||
} else {
|
||||
let fits = |s: &str| gridcraft_pdf::text_width_with_direction(font, size, s, direction) <= width;
|
||||
wrap_measured_paragraph(para, &fits, direction, &mut out);
|
||||
}
|
||||
if out.len() > MAX_WRAP_LINES {
|
||||
return out;
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn wrap_summed_paragraph(para: &str, font: Font, size: f32, width: f32, direction: TextDirection, out: &mut Vec<TextLine>) {
|
||||
let units_of = |s: &str| -> u64 { s.chars().map(|c| u64::from(font.char_width(c))).sum() };
|
||||
let fits = |units: u64| units as f32 * size / 1000.0 <= width;
|
||||
let space = units_of(" ");
|
||||
let mut out = Vec::new();
|
||||
for para in text.split('\n') {
|
||||
let mut line = String::new();
|
||||
let mut line_units: u64 = 0;
|
||||
for word in para.split(' ') {
|
||||
let word_units = units_of(word);
|
||||
if line.is_empty() {
|
||||
line.push_str(word);
|
||||
line_units = word_units;
|
||||
} else if fits(line_units + space + word_units) {
|
||||
line.push(' ');
|
||||
line.push_str(word);
|
||||
line_units += space + word_units;
|
||||
} else {
|
||||
out.push(std::mem::take(&mut line));
|
||||
line.push_str(word);
|
||||
line_units = word_units;
|
||||
}
|
||||
// Break a single over-long word by characters: each piece is the longest that fits
|
||||
// (at least one character).
|
||||
if !fits(line_units) && line.chars().nth(1).is_some() {
|
||||
let mut piece = String::new();
|
||||
let mut units: u64 = 0;
|
||||
for c in line.chars() {
|
||||
let w = u64::from(font.char_width(c));
|
||||
if !piece.is_empty() && !fits(units + w) {
|
||||
out.push(std::mem::take(&mut piece));
|
||||
units = 0;
|
||||
if out.len() > MAX_WRAP_LINES {
|
||||
return out;
|
||||
}
|
||||
let mut line = String::new();
|
||||
let mut line_units: u64 = 0;
|
||||
for word in para.split(' ') {
|
||||
let word_units = units_of(word);
|
||||
if line.is_empty() {
|
||||
line.push_str(word);
|
||||
line_units = word_units;
|
||||
} else if fits(line_units + space + word_units) {
|
||||
line.push(' ');
|
||||
line.push_str(word);
|
||||
line_units += space + word_units;
|
||||
} else {
|
||||
out.push(TextLine { text: std::mem::take(&mut line), direction });
|
||||
line.push_str(word);
|
||||
line_units = word_units;
|
||||
}
|
||||
if !fits(line_units) && line.graphemes(true).nth(1).is_some() {
|
||||
let mut piece = String::new();
|
||||
let mut units: u64 = 0;
|
||||
for g in line.graphemes(true) {
|
||||
let w = units_of(g);
|
||||
if !piece.is_empty() && !fits(units + w) {
|
||||
out.push(TextLine { text: std::mem::take(&mut piece), direction });
|
||||
units = 0;
|
||||
if out.len() > MAX_WRAP_LINES {
|
||||
return;
|
||||
}
|
||||
piece.push(c);
|
||||
units += w;
|
||||
}
|
||||
line = piece;
|
||||
line_units = units;
|
||||
piece.push_str(g);
|
||||
units += w;
|
||||
}
|
||||
if out.len() > MAX_WRAP_LINES {
|
||||
return out;
|
||||
line = piece;
|
||||
line_units = units;
|
||||
}
|
||||
if out.len() > MAX_WRAP_LINES {
|
||||
return;
|
||||
}
|
||||
}
|
||||
out.push(TextLine { text: line, direction });
|
||||
}
|
||||
|
||||
/// One paragraph of [`wrap_lines`] whose width is not a sum of character widths (shaped Arabic,
|
||||
/// right-to-left reordering or bidi controls), measuring each candidate line as drawn.
|
||||
fn wrap_measured_paragraph(para: &str, fits: &impl Fn(&str) -> bool, direction: TextDirection, out: &mut Vec<TextLine>) {
|
||||
let mut line = String::new();
|
||||
for word in para.split(' ') {
|
||||
if !line.is_empty() {
|
||||
let candidate = format!("{line} {word}");
|
||||
if fits(&candidate) {
|
||||
line = candidate;
|
||||
continue;
|
||||
}
|
||||
out.push(TextLine { text: std::mem::take(&mut line), direction });
|
||||
}
|
||||
line = if fits(word) { word.to_string() } else { break_measured_word(word, fits, direction, out) };
|
||||
if out.len() > MAX_WRAP_LINES {
|
||||
return;
|
||||
}
|
||||
}
|
||||
out.push(TextLine { text: line, direction });
|
||||
}
|
||||
|
||||
/// Cuts `word` into the longest grapheme prefixes that fit (at least one grapheme each), pushes
|
||||
/// all but the last to `out` and returns the last. Each cut gallops from one grapheme, so it
|
||||
/// measures prefixes about as long as the piece rather than the rest of the word.
|
||||
fn break_measured_word(word: &str, fits: &impl Fn(&str) -> bool, direction: TextDirection, out: &mut Vec<TextLine>) -> String {
|
||||
let ends: Vec<usize> = word.grapheme_indices(true).map(|(i, g)| i + g.len()).collect();
|
||||
let (mut start, mut first) = (0, 0);
|
||||
loop {
|
||||
let len = ends.len().saturating_sub(first);
|
||||
let end = |count: usize| ends.get(first + count.saturating_sub(1)).copied().unwrap_or(word.len());
|
||||
let fits_prefix = |count: usize| fits(word.get(start..end(count)).unwrap_or_default());
|
||||
let (mut fit, mut over, mut probe) = (1, len + 1, 2);
|
||||
while fit < len {
|
||||
let count = probe.min(len);
|
||||
if fits_prefix(count) {
|
||||
fit = count;
|
||||
probe = count.saturating_mul(2);
|
||||
} else {
|
||||
over = count;
|
||||
break;
|
||||
}
|
||||
}
|
||||
out.push(line);
|
||||
if fit >= len {
|
||||
return word.get(start..).unwrap_or_default().to_string();
|
||||
}
|
||||
while over - fit > 1 {
|
||||
let mid = fit + (over - fit) / 2;
|
||||
if fits_prefix(mid) {
|
||||
fit = mid;
|
||||
} else {
|
||||
over = mid;
|
||||
}
|
||||
}
|
||||
let cut = end(fit);
|
||||
out.push(TextLine { text: word.get(start..cut).unwrap_or_default().to_string(), direction });
|
||||
start = cut;
|
||||
first += fit;
|
||||
if out.len() > MAX_WRAP_LINES {
|
||||
return word.get(start..).unwrap_or_default().to_string();
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn font_for(style: &Style) -> Font {
|
||||
Font::styled(Font::family_for(&style.font.name), style.font.bold, style.font.italic)
|
||||
}
|
||||
|
||||
fn text_align(align: HAlign, value: &Value) -> HAlign {
|
||||
fn text_direction(order: ReadingOrder) -> TextDirection {
|
||||
match order {
|
||||
ReadingOrder::Context => TextDirection::Context,
|
||||
ReadingOrder::LeftToRight => TextDirection::LeftToRight,
|
||||
ReadingOrder::RightToLeft => TextDirection::RightToLeft,
|
||||
}
|
||||
}
|
||||
|
||||
/// The alignment a cell is laid out with before a right-to-left sheet is mirrored. Explicit Left
|
||||
/// and Right are swapped there, as in the grid, so they print on the side the user chose.
|
||||
fn text_align(align: HAlign, value: &Value, direction: TextDirection, right_to_left_sheet: bool) -> HAlign {
|
||||
match align {
|
||||
HAlign::General => match value {
|
||||
Value::Number(_) => HAlign::Right,
|
||||
Value::Bool(_) | Value::Error(_) => HAlign::Center,
|
||||
_ if direction == TextDirection::RightToLeft && !right_to_left_sheet => HAlign::Right,
|
||||
_ => HAlign::Left,
|
||||
},
|
||||
HAlign::Left if right_to_left_sheet => HAlign::Right,
|
||||
HAlign::Right if right_to_left_sheet => HAlign::Left,
|
||||
HAlign::CenterAcross | HAlign::Distributed => HAlign::Center,
|
||||
HAlign::Justify | HAlign::Fill => HAlign::Left,
|
||||
other => other,
|
||||
@@ -183,32 +281,46 @@ pub(super) fn draw_text(pg: &mut Page, b: &Block, placement: TextPlacement<'_>)
|
||||
if text.is_empty() {
|
||||
return;
|
||||
}
|
||||
let mut tw = gridcraft_pdf::text_width(font, size, &text);
|
||||
let direction = text_direction(st.align.reading_order.unwrap_or_default()).resolve(&text);
|
||||
let mut tw = gridcraft_pdf::text_width_with_direction(font, size, &text, direction);
|
||||
if st.align.shrink && !wrap && tw > avail && tw > 0.0 {
|
||||
size = (size * avail / tw).max(1.0);
|
||||
tw = gridcraft_pdf::text_width(font, size, &text);
|
||||
tw = gridcraft_pdf::text_width_with_direction(font, size, &text, direction);
|
||||
}
|
||||
if is_num && !wrap && tw > avail + 0.01 && !sh.show_formulas {
|
||||
let hash = gridcraft_pdf::text_width(font, size, "#").max(0.1);
|
||||
text = "#".repeat(((avail / hash).floor().max(1.0) as usize).min(255));
|
||||
tw = gridcraft_pdf::text_width(font, size, &text);
|
||||
tw = gridcraft_pdf::text_width_with_direction(font, size, &text, direction);
|
||||
}
|
||||
let h_align = text_align(st.align.h, &v);
|
||||
let h_align = text_align(st.align.h, &v, direction, sh.right_to_left);
|
||||
let rot = st.align.rotation;
|
||||
let rotated = rot != 0 && rot != 255;
|
||||
// Rotated text wraps along its own direction: upright (±90°) text to the row height.
|
||||
let lines: Vec<String> = match (wrap, rotated) {
|
||||
(true, false) => wrap_lines(&text, font, size, avail.max(size)),
|
||||
(true, true) if rot.abs() == 90 => wrap_lines(&text, font, size, (h - 2.0 * pad).max(size)),
|
||||
(true, true) => vec![text.lines().next().unwrap_or_default().to_string()],
|
||||
(false, _) => vec![text],
|
||||
let lines: Vec<TextLine> = match (wrap, rotated) {
|
||||
(true, false) => wrap_lines(&text, font, size, avail.max(size), direction),
|
||||
(true, true) if rot.abs() == 90 => wrap_lines(&text, font, size, (h - 2.0 * pad).max(size), direction),
|
||||
(true, true) => vec![TextLine { text: text.lines().next().unwrap_or_default().to_string(), direction }],
|
||||
(false, _) => vec![TextLine { text, direction }],
|
||||
};
|
||||
let line_h = size * 1.2;
|
||||
let extents = lines
|
||||
.iter()
|
||||
.filter_map(|line| pg.text_vertical_extents_with_direction(font, size, &line.text, line.direction))
|
||||
.reduce(|a, b| (a.0.max(b.0), a.1.max(b.1)))
|
||||
.map(|(ascent, descent)| (ascent.max(size * 0.8), descent.max(size * 0.22)));
|
||||
let line_h = extents.map_or(size * 1.2, |(ascent, descent)| (ascent + descent + size * 0.2).max(size * 1.2));
|
||||
let n = lines.len().max(1) as f32;
|
||||
let first_baseline = match st.align.v {
|
||||
VAlign::Top => y + pad + size * 0.8,
|
||||
VAlign::Center | VAlign::Justify | VAlign::Distributed => y + (h - n * line_h) / 2.0 + line_h * 0.5 + size * 0.33,
|
||||
VAlign::Bottom => y + h - pad - size * 0.22 - (n - 1.0) * line_h,
|
||||
let first_baseline = if let Some((ascent, descent)) = extents {
|
||||
match st.align.v {
|
||||
VAlign::Top => y + pad + ascent,
|
||||
VAlign::Center | VAlign::Justify | VAlign::Distributed => y + (h - (n - 1.0) * line_h - ascent - descent) / 2.0 + ascent,
|
||||
VAlign::Bottom => y + h - pad - descent - (n - 1.0) * line_h,
|
||||
}
|
||||
} else {
|
||||
match st.align.v {
|
||||
VAlign::Top => y + pad + size * 0.8,
|
||||
VAlign::Center | VAlign::Justify | VAlign::Distributed => y + (h - n * line_h) / 2.0 + line_h * 0.5 + size * 0.33,
|
||||
VAlign::Bottom => y + h - pad - size * 0.22 - (n - 1.0) * line_h,
|
||||
}
|
||||
};
|
||||
// Overflow into empty neighbours (single-line text, not merged).
|
||||
// Center Across Selection spans the empty Center Across cells to its right; the text stays within that run.
|
||||
@@ -222,7 +334,7 @@ pub(super) fn draw_text(pg: &mut Page, b: &Block, placement: TextPlacement<'_>)
|
||||
let clip_l = clip_l.max(limits.0);
|
||||
let clip_r = clip_r.min(limits.1);
|
||||
pg.save();
|
||||
pg.clip_rect(clip_l, y, (clip_r - clip_l).max(0.0), h);
|
||||
pg.clip_rect(b.text_x(clip_l, clip_r - clip_l), y, (clip_r - clip_l).max(0.0), h);
|
||||
if rotated {
|
||||
// Rotated text: anchored at the bottom-left (upward) or top-left (downward) of the cell.
|
||||
// Wrapped lines stack rightward for upward text and leftward for downward text, so
|
||||
@@ -233,23 +345,27 @@ pub(super) fn draw_text(pg: &mut Page, b: &Block, placement: TextPlacement<'_>)
|
||||
for (i, t) in lines.iter().enumerate() {
|
||||
let i = i as f32;
|
||||
let (ox, oy) = if deg > 0.0 {
|
||||
(x + pad + size * 0.8 * deg.to_radians().sin() + i * line_h, y + h - pad)
|
||||
(x + pad + extents.map_or(size * 0.8, |e| e.0) * deg.to_radians().sin() + i * line_h, y + h - pad)
|
||||
} else {
|
||||
(x + pad + (last - i) * line_h, y + pad + size * 0.8)
|
||||
(x + pad + (last - i) * line_h, y + pad + extents.map_or(size * 0.8, |e| e.0))
|
||||
};
|
||||
pg.text_rotated(Point::new(ox, oy), size, font, color, t, angle);
|
||||
let tw = gridcraft_pdf::text_width_with_direction(font, size, &t.text, t.direction);
|
||||
let (sn, cs) = angle.sin_cos();
|
||||
let (ascent, descent) = extents.unwrap_or((size * 0.8, size * 0.22));
|
||||
let ox = if sh.right_to_left { b.mirror_axis - ox - tw * cs - (ascent - descent) * sn } else { ox };
|
||||
pg.text_rotated_with_direction(Baseline { origin: Point::new(ox, oy), angle }, size, font, color, &t.text, t.direction);
|
||||
}
|
||||
pg.restore();
|
||||
return;
|
||||
}
|
||||
if rot == 255 {
|
||||
// Vertical stacked text.
|
||||
let chars: Vec<char> = lines.concat().chars().take(500).collect();
|
||||
let mut yy = y + pad + size * 0.8;
|
||||
let stacked: String = lines.iter().map(|line| line.text.as_str()).collect();
|
||||
let chars: Vec<&str> = stacked.graphemes(true).take(500).collect();
|
||||
let mut yy = y + pad + extents.map_or(size * 0.8, |e| e.0);
|
||||
for ch in chars {
|
||||
let s = ch.to_string();
|
||||
let cw = gridcraft_pdf::text_width(font, size, &s);
|
||||
pg.text(x + (w - cw) / 2.0, yy, size, font, color, &s);
|
||||
let cw = gridcraft_pdf::text_width(font, size, ch);
|
||||
pg.text_with_direction(Point::new(b.text_x(x + (w - cw) / 2.0, cw), yy), size, font, color, ch, direction);
|
||||
yy += line_h;
|
||||
if yy > y + h + line_h {
|
||||
break;
|
||||
@@ -259,7 +375,7 @@ pub(super) fn draw_text(pg: &mut Page, b: &Block, placement: TextPlacement<'_>)
|
||||
return;
|
||||
}
|
||||
for (i, line) in lines.iter().enumerate() {
|
||||
let lw = gridcraft_pdf::text_width(font, size, line);
|
||||
let lw = gridcraft_pdf::text_width_with_direction(font, size, &line.text, line.direction);
|
||||
let lx = match h_align {
|
||||
HAlign::Right => x + w - pad - lw - indent,
|
||||
HAlign::Center => x + (w + across - lw) / 2.0,
|
||||
@@ -269,7 +385,8 @@ pub(super) fn draw_text(pg: &mut Page, b: &Block, placement: TextPlacement<'_>)
|
||||
if ly - size > y + h || ly < y - line_h {
|
||||
continue;
|
||||
}
|
||||
pg.text(lx, ly, size, font, color, line);
|
||||
let lx = b.text_x(lx, lw);
|
||||
pg.text_with_direction(Point::new(lx, ly), size, font, color, &line.text, line.direction);
|
||||
if st.font.underline != Underline::None {
|
||||
let uw = (size * 0.06).max(0.2);
|
||||
pg.stroke_line(lx, ly + size * 0.12, lx + lw, ly + size * 0.12, uw, color);
|
||||
|
||||
@@ -4,7 +4,7 @@ use std::sync::Arc;
|
||||
|
||||
use gridcraft_core::{CellRef, MAX_COLS, MAX_ROWS, RangeRef};
|
||||
use gridcraft_formula::adjust::{Axis, Edit};
|
||||
use gridcraft_model::{Anchor, AnchorMode, Sheet, Visibility};
|
||||
use gridcraft_model::{Anchor, AnchorMode, PivotDataCell, PivotLookup, Sheet, Visibility};
|
||||
use serde_json::{Value as Json, json};
|
||||
|
||||
use super::{
|
||||
@@ -211,7 +211,31 @@ fn shift_sheet_features(sh: &mut Sheet, axis: Axis, at: u32, count: u32, insert:
|
||||
Axis::Rows => CellRef::new(at, pt.anchor.col),
|
||||
Axis::Cols => CellRef::new(pt.anchor.row, at),
|
||||
});
|
||||
pt.last_range = pt.last_range.and_then(map_range);
|
||||
let old = pt.last_range;
|
||||
pt.last_range = old.and_then(map_range);
|
||||
// GETPIVOTDATA's value cells are stored as offsets from the report's top-left cell, so
|
||||
// lines inserted or deleted inside the report move them as well. The moved cells go into
|
||||
// a new index (the shared one stays with the undo snapshots); a value cell deleted with
|
||||
// its line drops out, so it is #REF! rather than read from whatever took its place.
|
||||
let index = pt.data_index.clone();
|
||||
if let (Some(o), Some(n), Some(cells)) = (old, pt.last_range, index.cells()) {
|
||||
let (lo, hi) = if axis == Axis::Rows { (o.start.row, o.end.row) } else { (o.start.col, o.end.col) };
|
||||
let inside = at <= hi && if insert { at > lo } else { at.saturating_add(count) > lo };
|
||||
if inside {
|
||||
let moved: Vec<PivotDataCell> = cells
|
||||
.iter()
|
||||
.filter_map(|c| {
|
||||
let to = map_cell(CellRef::new(o.start.row.checked_add(c.row)?, o.start.col.checked_add(c.col)?))?;
|
||||
Some(PivotDataCell { row: to.row.checked_sub(n.start.row)?, col: to.col.checked_sub(n.start.col)?, ..c.clone() })
|
||||
})
|
||||
.collect();
|
||||
let lookup = PivotLookup::default();
|
||||
if !moved.is_empty() {
|
||||
lookup.set_cells(moved);
|
||||
}
|
||||
pt.data_index = lookup;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -83,6 +83,9 @@ pub(crate) fn criterion_matches(v: &Value, text: &str, crit: &Value) -> bool {
|
||||
}
|
||||
}
|
||||
|
||||
/// Most (list row, criteria row) pairs one Advanced Filter tests.
|
||||
const MAX_FILTER_TESTS: u64 = 50_000_000;
|
||||
|
||||
pub(super) fn advanced_filter(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
const CMD: &str = "data.advancedFilter";
|
||||
let d = s.doc()?;
|
||||
@@ -133,6 +136,10 @@ pub(super) fn advanced_filter(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
rows.push(conds);
|
||||
}
|
||||
}
|
||||
// Each list row is tried against every criteria row, so bound their product too.
|
||||
if u64::from(list.height()) * rows.len() as u64 > MAX_FILTER_TESTS {
|
||||
return Err(bad(CMD, "the list and criteria ranges together are too large"));
|
||||
}
|
||||
let matches_row = |row: u32| -> bool {
|
||||
if rows.is_empty() {
|
||||
return true;
|
||||
|
||||
@@ -298,6 +298,15 @@ fn consolidate_by_position_and_label() {
|
||||
assert!(s.execute("data.consolidate", json!({"sources": ["A1"], "function": "median"})).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn advanced_filter_refuses_a_list_times_criteria_product_over_the_work_limit() {
|
||||
let mut s = s();
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": [["Name"], ["A"]]})).unwrap();
|
||||
s.execute("range.setValues", json!({"range": "H1", "values": [["Name"], ["A"]]})).unwrap();
|
||||
// A sparse million-row list against 9,999 blank criteria rows would be ~10 billion tests.
|
||||
assert!(s.execute("data.advancedFilter", json!({"range": "A2:A1048576", "criteria": "H1:H10000"})).is_err());
|
||||
}
|
||||
|
||||
/// A hundred thousand positional rows take one key lookup each; a tall source and a wide one
|
||||
/// whose keys would meet in a table of 160 million cells are refused before it is built.
|
||||
#[test]
|
||||
|
||||
@@ -0,0 +1,241 @@
|
||||
//! Insert › Text › WordArt: decorative text as a floating shape (`ShapeKind::WordArt`) built on
|
||||
//! the text-box machinery (anchor, move/resize/delete, undo, XLSX shape text body, printing).
|
||||
//! The style palette below is original to GridCraft.
|
||||
|
||||
use gridcraft_model::{Anchor, Color, Shape, ShapeFormat, ShapeKind, ShapeTextAlign, ShapeTextAnchor};
|
||||
use serde_json::{Value as Json, json};
|
||||
|
||||
use super::{
|
||||
CommandSpec, EngineError, PROTECTED, Result, Session, anchor_mode_param, bad, bool_param, cell_param, cmd, edit, f64_param, has_doc, ok,
|
||||
u32_param,
|
||||
};
|
||||
|
||||
/// One entry of the style gallery.
|
||||
pub struct WordArtStyle {
|
||||
pub name: &'static str,
|
||||
pub fill: Color,
|
||||
pub outline: Option<(Color, f32)>,
|
||||
pub shadow: Option<Color>,
|
||||
pub bold: bool,
|
||||
pub italic: bool,
|
||||
/// Font size in points.
|
||||
pub size: f32,
|
||||
}
|
||||
|
||||
const fn rgb(v: u32) -> Color {
|
||||
Color::Rgb(v)
|
||||
}
|
||||
|
||||
/// GridCraft's own WordArt presets. Theme colours where it makes sense (they follow the theme),
|
||||
/// fixed colours for the rest.
|
||||
pub const STYLES: [WordArtStyle; 10] = [
|
||||
WordArtStyle { name: "Classic", fill: Color::Theme(4, 0), outline: None, shadow: None, bold: true, italic: false, size: 36.0 },
|
||||
WordArtStyle { name: "Midnight", fill: rgb(0x1B2A49), outline: None, shadow: Some(rgb(0x8A94A6)), bold: true, italic: false, size: 40.0 },
|
||||
WordArtStyle { name: "Sunrise", fill: rgb(0xF2A33A), outline: Some((rgb(0xB5451B), 1.5)), shadow: None, bold: true, italic: false, size: 40.0 },
|
||||
WordArtStyle {
|
||||
name: "Lagoon",
|
||||
fill: rgb(0x1F9E9A),
|
||||
outline: Some((rgb(0x0B4F5C), 1.0)),
|
||||
shadow: Some(rgb(0x9CC9C7)),
|
||||
bold: true,
|
||||
italic: true,
|
||||
size: 36.0,
|
||||
},
|
||||
WordArtStyle { name: "Ember", fill: rgb(0xD64527), outline: None, shadow: Some(rgb(0x5A1A0E)), bold: true, italic: false, size: 44.0 },
|
||||
WordArtStyle {
|
||||
name: "Mint Outline",
|
||||
fill: rgb(0xFFFFFF),
|
||||
outline: Some((rgb(0x2E9B6A), 2.0)),
|
||||
shadow: None,
|
||||
bold: true,
|
||||
italic: false,
|
||||
size: 40.0,
|
||||
},
|
||||
WordArtStyle { name: "Ink Stamp", fill: rgb(0x2F3A8F), outline: Some((rgb(0x2F3A8F), 0.5)), shadow: None, bold: true, italic: false, size: 32.0 },
|
||||
WordArtStyle { name: "Orchid", fill: rgb(0x8E4FB5), outline: None, shadow: Some(rgb(0xD9C2E8)), bold: false, italic: true, size: 40.0 },
|
||||
WordArtStyle {
|
||||
name: "Graphite",
|
||||
fill: rgb(0x4A4F57),
|
||||
outline: Some((rgb(0xFFFFFF), 1.0)),
|
||||
shadow: Some(rgb(0x9AA0A8)),
|
||||
bold: true,
|
||||
italic: false,
|
||||
size: 36.0,
|
||||
},
|
||||
WordArtStyle {
|
||||
name: "Lime Pop",
|
||||
fill: rgb(0xA6D61C),
|
||||
outline: Some((rgb(0x3F5A00), 1.5)),
|
||||
shadow: Some(rgb(0x6E8B2C)),
|
||||
bold: true,
|
||||
italic: true,
|
||||
size: 40.0,
|
||||
},
|
||||
];
|
||||
|
||||
/// The text of a WordArt inserted without `text`.
|
||||
pub const DEFAULT_TEXT: &str = "Your text here";
|
||||
/// Longest WordArt text (characters).
|
||||
pub const MAX_CHARS: usize = 1000;
|
||||
const MAX_POINTS: f64 = 400.0;
|
||||
const MAX_SIDE: f64 = 4000.0;
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
vec![
|
||||
cmd!(
|
||||
"insert.wordArt",
|
||||
"WordArt",
|
||||
["Insert", "Text"],
|
||||
None,
|
||||
"{style?: preset name or 0-based index (Classic, Midnight, Sunrise, Lagoon, Ember, Mint Outline, Ink Stamp, Orchid, Graphite, Lime Pop), text?, at?, width?, height?, fontSize?, bold?, italic?, fill?: hex, outline?: hex|false, outlineWidth?, shadow?: hex|bool}",
|
||||
has_doc,
|
||||
insert_word_art
|
||||
),
|
||||
cmd!(
|
||||
"wordArt.set",
|
||||
"Format WordArt",
|
||||
[],
|
||||
None,
|
||||
"{id: WordArt id, style?, text?, fontSize?, bold?, italic?, fill?: hex, outline?: hex|false, outlineWidth?, shadow?: hex|bool}",
|
||||
has_doc,
|
||||
set_word_art
|
||||
),
|
||||
]
|
||||
}
|
||||
|
||||
fn style_param(command: &str, p: &Json) -> Result<Option<&'static WordArtStyle>> {
|
||||
match p.get("style") {
|
||||
None | Some(Json::Null) => Ok(None),
|
||||
Some(Json::Number(n)) => n
|
||||
.as_u64()
|
||||
.and_then(|i| STYLES.get(usize::try_from(i).ok()?))
|
||||
.map(Some)
|
||||
.ok_or_else(|| bad(command, format!("`style` index must be 0..{}", STYLES.len() - 1))),
|
||||
Some(Json::String(name)) => STYLES
|
||||
.iter()
|
||||
.find(|s| s.name.eq_ignore_ascii_case(name.trim()))
|
||||
.map(Some)
|
||||
.ok_or_else(|| bad(command, format!("unknown WordArt style `{name}`"))),
|
||||
Some(_) => Err(bad(command, "`style` must be a preset name or index")),
|
||||
}
|
||||
}
|
||||
|
||||
fn text_param(command: &str, p: &Json) -> Result<Option<String>> {
|
||||
match p.get("text") {
|
||||
None | Some(Json::Null) => Ok(None),
|
||||
Some(Json::String(t)) if t.is_empty() => Err(bad(command, "`text` must not be empty")),
|
||||
Some(Json::String(t)) if t.chars().nth(MAX_CHARS).is_some() => Err(bad(command, format!("`text` is longer than {MAX_CHARS} characters"))),
|
||||
Some(Json::String(t)) => Ok(Some(t.clone())),
|
||||
Some(_) => Err(bad(command, "`text` must be a string")),
|
||||
}
|
||||
}
|
||||
|
||||
/// Applies a preset, then explicit overrides, to a shape's format and fill.
|
||||
fn apply(command: &str, shape: &mut Shape, style: Option<&WordArtStyle>, p: &Json) -> Result<()> {
|
||||
if let Some(st) = style {
|
||||
shape.format.text_color = Some(st.fill);
|
||||
shape.format.text_outline = st.outline;
|
||||
shape.format.text_shadow = st.shadow;
|
||||
shape.format.bold = st.bold;
|
||||
shape.format.italic = st.italic;
|
||||
shape.format.font_size = Some(st.size);
|
||||
}
|
||||
let f = &mut shape.format;
|
||||
if let Some(c) = p.get("fill").filter(|v| !v.is_null()) {
|
||||
f.text_color = Some(super::format::color_param(Some(c)).ok_or_else(|| bad(command, "`fill` must be a hex colour"))?);
|
||||
}
|
||||
match p.get("outline") {
|
||||
None | Some(Json::Null) => {}
|
||||
Some(Json::Bool(false)) => f.text_outline = None,
|
||||
Some(v) => {
|
||||
let c = super::format::color_param(Some(v)).ok_or_else(|| bad(command, "`outline` must be a hex colour or false"))?;
|
||||
let w = f64_param(p, "outlineWidth").map_or(f.text_outline.map_or(1.5, |o| o.1), |w| w.clamp(0.25, 20.0) as f32);
|
||||
f.text_outline = Some((c, w));
|
||||
}
|
||||
}
|
||||
if let (Some(w), Some((c, _))) = (f64_param(p, "outlineWidth"), f.text_outline) {
|
||||
f.text_outline = Some((c, w.clamp(0.25, 20.0) as f32));
|
||||
}
|
||||
match p.get("shadow") {
|
||||
None | Some(Json::Null) => {}
|
||||
Some(Json::Bool(false)) => f.text_shadow = None,
|
||||
Some(Json::Bool(true)) => f.text_shadow = Some(f.text_shadow.unwrap_or(rgb(0x808080))),
|
||||
Some(v) => {
|
||||
f.text_shadow = Some(super::format::color_param(Some(v)).ok_or_else(|| bad(command, "`shadow` must be a hex colour or a boolean"))?)
|
||||
}
|
||||
}
|
||||
if let Some(b) = bool_param(p, "bold") {
|
||||
f.bold = b;
|
||||
}
|
||||
if let Some(b) = bool_param(p, "italic") {
|
||||
f.italic = b;
|
||||
}
|
||||
if let Some(sz) = f64_param(p, "fontSize") {
|
||||
f.font_size = Some(sz.clamp(1.0, MAX_POINTS) as f32);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn insert_word_art(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let style = style_param("insert.wordArt", p)?.unwrap_or(&STYLES[0]);
|
||||
let text = text_param("insert.wordArt", p)?.unwrap_or_else(|| DEFAULT_TEXT.to_string());
|
||||
let d = s.doc()?;
|
||||
if d.wb.active().is_some_and(|sh| sh.is_protected()) {
|
||||
return Err(EngineError::Other(PROTECTED.into()));
|
||||
}
|
||||
let id = d.wb.next_object_id();
|
||||
let at = cell_param(s, p, "at")?.unwrap_or(d.selection.active);
|
||||
let mut shape = Shape {
|
||||
id,
|
||||
kind: ShapeKind::WordArt,
|
||||
anchor: Anchor { cell: at, dx: 0.0, dy: 0.0, width: 0.0, height: 0.0, mode: anchor_mode_param(p).unwrap_or_default() },
|
||||
fill: Color::Auto,
|
||||
line: Color::Auto,
|
||||
text: text.clone(),
|
||||
format: ShapeFormat { no_line: true, align: Some(ShapeTextAlign::Center), anchor: Some(ShapeTextAnchor::Middle), ..Default::default() },
|
||||
math: Default::default(),
|
||||
};
|
||||
apply("insert.wordArt", &mut shape, Some(style), p)?;
|
||||
// Default box: the longest line at the font size (about 0.62 em per character) plus padding.
|
||||
let pt = f64::from(shape.format.font_size.unwrap_or(36.0));
|
||||
let longest = text.split('\n').map(|l| l.chars().count()).max().unwrap_or(1) as f64;
|
||||
let lines = text.split('\n').count() as f64;
|
||||
let width = f64_param(p, "width").unwrap_or(longest * pt * 0.62 * 96.0 / 72.0 + 24.0).clamp(8.0, MAX_SIDE);
|
||||
let height = f64_param(p, "height").unwrap_or(lines * pt * 1.35 * 96.0 / 72.0 + 12.0).clamp(8.0, MAX_SIDE);
|
||||
shape.anchor.width = width as f32;
|
||||
shape.anchor.height = height as f32;
|
||||
let sheet = d.wb.active_sheet();
|
||||
edit(s, |cx| {
|
||||
cx.sheet_mut(sheet)?.shapes.push(shape);
|
||||
Ok(json!({"shape": id}))
|
||||
})
|
||||
}
|
||||
|
||||
fn set_word_art(s: &mut Session, p: &Json) -> Result<Json> {
|
||||
let id = u32_param(p, "id").ok_or_else(|| bad("wordArt.set", "`id` must be a WordArt id"))?;
|
||||
let style = style_param("wordArt.set", p)?;
|
||||
let text = text_param("wordArt.set", p)?;
|
||||
let d = s.doc()?;
|
||||
let sheet = d.wb.active_sheet();
|
||||
let sh = d.wb.active().ok_or_else(|| bad("wordArt.set", "no such WordArt"))?;
|
||||
let current = sh.shapes.iter().find(|x| x.id == id).ok_or_else(|| bad("wordArt.set", "no such WordArt"))?;
|
||||
if current.kind != ShapeKind::WordArt {
|
||||
return Err(bad("wordArt.set", "the shape is not WordArt"));
|
||||
}
|
||||
if sh.is_protected() {
|
||||
return Err(EngineError::Other(PROTECTED.into()));
|
||||
}
|
||||
let mut updated = current.clone();
|
||||
apply("wordArt.set", &mut updated, style, p)?;
|
||||
if let Some(t) = text {
|
||||
updated.text = t;
|
||||
}
|
||||
if &updated == current {
|
||||
return ok();
|
||||
}
|
||||
edit(s, |cx| {
|
||||
let shape = cx.sheet_mut(sheet)?.shapes.iter_mut().find(|x| x.id == id).ok_or_else(|| bad("wordArt.set", "no such WordArt"))?;
|
||||
*shape = updated;
|
||||
Ok(Json::Null)
|
||||
})
|
||||
}
|
||||
+108
-23
@@ -3,7 +3,7 @@
|
||||
use std::fmt::Write as _;
|
||||
|
||||
use gridcraft_core::{CellRef, RangeRef};
|
||||
use gridcraft_model::{Sheet, Workbook};
|
||||
use gridcraft_model::{LineIndex, Sheet, Workbook};
|
||||
|
||||
use crate::{EngineError, Result};
|
||||
|
||||
@@ -42,7 +42,7 @@ impl FileKind {
|
||||
"ods" => FileKind::Ods,
|
||||
"csv" => FileKind::Csv,
|
||||
"tsv" | "tab" | "txt" => FileKind::Tsv,
|
||||
"json" | "scjson" => FileKind::Json,
|
||||
ext if craft_gridcraft_format::is_extension(ext) => FileKind::Json,
|
||||
"html" | "htm" => FileKind::Html,
|
||||
"slk" => FileKind::Sylk,
|
||||
_ => return None,
|
||||
@@ -316,7 +316,7 @@ fn read_plain(name: &str, bytes: &[u8], csv_as_text: bool) -> Result<(Workbook,
|
||||
}
|
||||
match kind {
|
||||
Some(FileKind::Json) => {
|
||||
let mut wb: Workbook = serde_json::from_slice(bytes).map_err(|e| EngineError::Other(format!("not a GridCraft JSON workbook: {e}")))?;
|
||||
let mut wb: Workbook = craft_gridcraft_format::read(bytes).map_err(|e| EngineError::Other(e.to_string()))?;
|
||||
wb.styles.rebuild_index();
|
||||
if wb.sheets.is_empty() {
|
||||
// The file's macros are read after this (`macros::load`), so they come along.
|
||||
@@ -611,6 +611,24 @@ pub(crate) fn esc(s: &str) -> String {
|
||||
s.replace('&', "&").replace('<', "<").replace('>', ">").replace('"', """)
|
||||
}
|
||||
|
||||
/// [`esc`], or `None` once the escaped text would pass `limit` bytes (nothing larger is built).
|
||||
fn esc_within(s: &str, limit: usize) -> Option<String> {
|
||||
let mut out = String::with_capacity(s.len().min(limit));
|
||||
for c in s.chars() {
|
||||
match c {
|
||||
'&' => out.push_str("&"),
|
||||
'<' => out.push_str("<"),
|
||||
'>' => out.push_str(">"),
|
||||
'"' => out.push_str("""),
|
||||
c => out.push(c),
|
||||
}
|
||||
if out.len() > limit {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
Some(out)
|
||||
}
|
||||
|
||||
fn html_cell_css(wb: &Workbook, sh: &Sheet, c: CellRef, dir: CellDir) -> String {
|
||||
let st = wb.styles.get(sh.style_id(c));
|
||||
let mut css = String::new();
|
||||
@@ -686,6 +704,30 @@ fn table_dir(sh: &Sheet) -> &'static str {
|
||||
const CLIPBOARD_HTML_MAX_BYTES: usize = 4 * 1024 * 1024;
|
||||
const CLIPBOARD_HTML_MAX_CELLS: u64 = 10_000;
|
||||
|
||||
/// Most cells the merge index holds: one entry per merged cell inside the exported range.
|
||||
const MERGE_INDEX_MAX_ENTRIES: usize = 1_000_000;
|
||||
|
||||
/// The merge covering each cell of `rect`, as `Sheet::merge_at` would find it (the first in the
|
||||
/// sheet's list), built once so a table lookup is one probe instead of a scan of every merge.
|
||||
/// `None` when overlapping merges would cost more than a few visits per cell of `rect`, or merged
|
||||
/// cells fill more than [`MERGE_INDEX_MAX_ENTRIES`]: a hostile file's merge list can't multiply the
|
||||
/// work or the memory of a bounded export.
|
||||
fn merge_index(sh: &Sheet, rect: RangeRef) -> Option<std::collections::HashMap<CellRef, RangeRef>> {
|
||||
let mut map = std::collections::HashMap::new();
|
||||
let mut left = rect.count().saturating_mul(4);
|
||||
for m in &sh.merges {
|
||||
let Some(part) = m.intersection(&rect) else { continue };
|
||||
left = left.checked_sub(part.count())?;
|
||||
for c in part.iter() {
|
||||
map.entry(c).or_insert(*m);
|
||||
}
|
||||
if map.len() > MERGE_INDEX_MAX_ENTRIES {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
Some(map)
|
||||
}
|
||||
|
||||
/// An HTML fragment for the same range as `plain_text`, previously produced by
|
||||
/// `display::range_text`. Large copies keep plain text only; never return a partial table.
|
||||
pub(crate) fn range_html(wb: &Workbook, sheet: usize, r: RangeRef, plain_text: &str) -> Option<String> {
|
||||
@@ -694,6 +736,7 @@ pub(crate) fn range_html(wb: &Workbook, sheet: usize, r: RangeRef, plain_text: &
|
||||
return None;
|
||||
}
|
||||
let sh = wb.sheet(sheet)?;
|
||||
let merges = merge_index(sh, r)?;
|
||||
let mut out = ClipboardHtml(String::new());
|
||||
write!(out, "<table{} style=\"border-collapse:collapse;font-family:Calibri,Carlito,Arial,sans-serif;font-size:11pt\">", table_dir(sh)).ok()?;
|
||||
for row in r.start.row..=r.end.row {
|
||||
@@ -703,7 +746,7 @@ pub(crate) fn range_html(wb: &Workbook, sheet: usize, r: RangeRef, plain_text: &
|
||||
out.write_str("<tr>").ok()?;
|
||||
for col in r.start.col..=r.end.col {
|
||||
let c = CellRef::new(row, col);
|
||||
let span = if let Some(merged) = sh.merges.iter().find(|m| m.contains(c)).and_then(|m| m.intersection(&r)) {
|
||||
let span = if let Some(merged) = merges.get(&c).and_then(|m| m.intersection(&r)) {
|
||||
let first_row = (merged.start.row..=merged.end.row).find(|&row| !sh.is_row_hidden(row))?;
|
||||
if c != CellRef::new(first_row, merged.start.col) {
|
||||
continue;
|
||||
@@ -766,6 +809,14 @@ const HTML_EXPORT_MAX_ROWS: u32 = 100_001;
|
||||
/// tall, wide one) would otherwise be gigabytes of `<td></td>` before finishing (#2387).
|
||||
const HTML_EXPORT_MAX_CELLS: u64 = 4_000_000;
|
||||
|
||||
/// Most bytes of one web page. Every cell may hold long text (shared across many cells in the
|
||||
/// file), so the cell count alone doesn't bound the page; past this the export fails instead.
|
||||
const HTML_EXPORT_MAX_BYTES: usize = 256 * 1024 * 1024;
|
||||
|
||||
fn html_too_big() -> EngineError {
|
||||
EngineError::Other(format!("the web page would be over {} MiB. Save as .xlsx or CSV instead.", HTML_EXPORT_MAX_BYTES / (1024 * 1024)))
|
||||
}
|
||||
|
||||
/// A sheet as a standalone HTML table (Save as Web Page). A sheet with pictures gets the sheet's
|
||||
/// own column widths and row heights so each picture and chart (inline SVG) can sit at its anchor.
|
||||
pub fn to_html(wb: &Workbook, sheet: usize) -> Result<String> {
|
||||
@@ -808,6 +859,24 @@ pub fn to_html(wb: &Workbook, sheet: usize) -> Result<String> {
|
||||
r.width()
|
||||
)));
|
||||
}
|
||||
let merges = merge_index(sh, r)
|
||||
.ok_or_else(|| EngineError::Other("the sheet's merged cells overlap too much, or cover too many cells, for a web page.".into()))?;
|
||||
// Visible rows and columns of the table before each line, so a merge's span is counted
|
||||
// in constant time whatever the file says its size is.
|
||||
let visible_before = |hidden: &dyn Fn(u32) -> bool, from: u32, to: u32| {
|
||||
let mut v = Vec::with_capacity((to - from) as usize + 2);
|
||||
v.push(0u32);
|
||||
for line in from..=to {
|
||||
v.push(v.last().copied().unwrap_or(0) + u32::from(!hidden(line)));
|
||||
}
|
||||
v
|
||||
};
|
||||
let rows_before = visible_before(&|y| sh.is_row_hidden(y), r.start.row, r.end.row);
|
||||
let cols_before = visible_before(&|x| sh.is_col_hidden(x), r.start.col, r.end.col);
|
||||
let visible = |before: &[u32], from: u32, a: u32, b: u32| {
|
||||
let at = |line: u32| before.get((line - from) as usize).copied().unwrap_or(0);
|
||||
at(b + 1) - at(a)
|
||||
};
|
||||
if fixed {
|
||||
out.push_str("<colgroup>");
|
||||
for col in (r.start.col..=r.end.col).filter(|&c| !sh.is_col_hidden(c)) {
|
||||
@@ -826,27 +895,31 @@ pub fn to_html(wb: &Workbook, sheet: usize) -> Result<String> {
|
||||
}
|
||||
for col in r.start.col..=r.end.col {
|
||||
let c = CellRef::new(row, col);
|
||||
if sh.merges.iter().any(|m| m.contains(c) && m.start != c) || (fixed && sh.is_col_hidden(col)) {
|
||||
let merge = merges.get(&c);
|
||||
if merge.is_some_and(|m| m.start != c) || (fixed && sh.is_col_hidden(col)) {
|
||||
continue;
|
||||
}
|
||||
let text = crate::display::cell_text(wb, sh, c);
|
||||
let dir = CellDir::of(sh, c, &text);
|
||||
let css = html_cell_css(wb, sh, c, dir);
|
||||
let span = sh
|
||||
.merges
|
||||
.iter()
|
||||
.find(|m| m.start == c)
|
||||
let span = merge
|
||||
.map(|m| {
|
||||
if fixed {
|
||||
let rows = (m.start.row..=m.end.row).filter(|&y| !sh.is_row_hidden(y)).count();
|
||||
let cols = (m.start.col..=m.end.col).filter(|&x| !sh.is_col_hidden(x)).count();
|
||||
// Spans count the table's visible lines: the merge is clipped to the table.
|
||||
let rows = visible(&rows_before, r.start.row, m.start.row, m.end.row.min(r.end.row));
|
||||
let cols = visible(&cols_before, r.start.col, m.start.col, m.end.col.min(r.end.col));
|
||||
format!(" rowspan=\"{rows}\" colspan=\"{cols}\"")
|
||||
} else {
|
||||
format!(" rowspan=\"{}\" colspan=\"{}\"", m.height(), m.width())
|
||||
}
|
||||
})
|
||||
.unwrap_or_default();
|
||||
let _ = write!(out, "<td style=\"{css}\"{}{span}>{}</td>", dir.attr(), esc(&text));
|
||||
// The text is escaped only as far as the page still has room for it.
|
||||
let Some(escaped) = esc_within(&text, HTML_EXPORT_MAX_BYTES.saturating_sub(out.len())) else { return Err(html_too_big()) };
|
||||
let _ = write!(out, "<td style=\"{css}\"{}{span}>{escaped}</td>", dir.attr());
|
||||
if out.len() > HTML_EXPORT_MAX_BYTES {
|
||||
return Err(html_too_big());
|
||||
}
|
||||
}
|
||||
out.push_str("</tr>");
|
||||
}
|
||||
@@ -854,36 +927,48 @@ pub fn to_html(wb: &Workbook, sheet: usize) -> Result<String> {
|
||||
out.push_str("</table>");
|
||||
if fixed {
|
||||
// Sheet units are CSS pixels; the table starts at the used range, not at A1.
|
||||
let (left, top) = used.map_or((0.0, 0.0), |r| (sh.col_left(r.start.col), sh.row_top(r.start.row)));
|
||||
// Indexed positions: each anchor would otherwise sum every custom row and column before it.
|
||||
let ri = LineIndex::new(&sh.rows, sh.default_row_height, gridcraft_core::MAX_ROWS);
|
||||
let ci = LineIndex::new(&sh.cols, sh.default_col_width, gridcraft_core::MAX_COLS);
|
||||
let (left, top) = used.map_or((0.0, 0.0), |r| (ci.start(r.start.col), ri.start(r.start.row)));
|
||||
let place = |a: &gridcraft_model::Anchor| {
|
||||
format!(
|
||||
"position:absolute;left:{}px;top:{}px;width:{}px;height:{}px",
|
||||
sh.col_left(a.cell.col) - left + f64::from(a.dx),
|
||||
sh.row_top(a.cell.row) - top + f64::from(a.dy),
|
||||
ci.start(a.cell.col) - left + f64::from(a.dx),
|
||||
ri.start(a.cell.row) - top + f64::from(a.dy),
|
||||
a.width.max(0.0),
|
||||
a.height.max(0.0)
|
||||
)
|
||||
};
|
||||
for im in &sh.images {
|
||||
let _ = write!(
|
||||
out,
|
||||
"<img src=\"data:{};base64,{}\" alt=\"{}\" style=\"{}\">",
|
||||
esc(&im.mime),
|
||||
base64_encode(&im.data),
|
||||
esc(&im.alt),
|
||||
place(&im.anchor)
|
||||
);
|
||||
// The base64 text is a third longer than the picture: refused before it is built.
|
||||
if out.len().saturating_add(im.data.len().div_ceil(3).saturating_mul(4)) > HTML_EXPORT_MAX_BYTES {
|
||||
return Err(html_too_big());
|
||||
}
|
||||
// The attributes are escaped only as far as the page has room for them.
|
||||
let room = HTML_EXPORT_MAX_BYTES.saturating_sub(out.len());
|
||||
let (Some(mime), Some(alt)) = (esc_within(&im.mime, room), esc_within(&im.alt, room)) else { return Err(html_too_big()) };
|
||||
let _ = write!(out, "<img src=\"data:{mime};base64,{}\" alt=\"{alt}\" style=\"{}\">", base64_encode(&im.data), place(&im.anchor));
|
||||
if out.len() > HTML_EXPORT_MAX_BYTES {
|
||||
return Err(html_too_big());
|
||||
}
|
||||
}
|
||||
let mut svg_budget = crate::chart_svg::MAX_PAGE_SVG_BYTES;
|
||||
for ch in &sh.charts {
|
||||
if let Some(svg) = crate::chart_svg::chart_svg(wb, sheet, ch, &place(&ch.anchor), svg_budget)? {
|
||||
svg_budget -= svg.len();
|
||||
out.push_str(&svg);
|
||||
if out.len() > HTML_EXPORT_MAX_BYTES {
|
||||
return Err(html_too_big());
|
||||
}
|
||||
}
|
||||
}
|
||||
out.push_str("</div>");
|
||||
}
|
||||
out.push_str("</body></html>");
|
||||
if out.len() > HTML_EXPORT_MAX_BYTES {
|
||||
return Err(html_too_big());
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
|
||||
+37
-301
@@ -1,156 +1,57 @@
|
||||
//! SYLK (`.slk`) import: the symbolic link text format older spreadsheets and some legacy systems
|
||||
//! export. One record per line, fields separated by `;` (`;;` is a literal semicolon):
|
||||
//!
|
||||
//! - `ID` starts the file; `E` ends it.
|
||||
//! - `C;Y<row>;X<col>;K<value>;E<formula>` is a cell. `Y` and `X` may be left out to stay on the
|
||||
//! current row or column. `K` is a number, `"text"`, `TRUE`/`FALSE` or an error; `E` is a
|
||||
//! formula in R1C1 notation; `S;R<row>;C<col>` shares the formula of another cell.
|
||||
//! - `P;P<code>` adds a number format to the file's list; `F;P<n>;Y<row>;X<col>` gives a cell the
|
||||
//! n-th format (0-based), and `F;W<first> <last> <width>` sets column widths in characters.
|
||||
//!
|
||||
//! Other records (fonts, options, window settings) are skipped. Formulas are converted to A1 with
|
||||
//! the same relative and absolute references, as Excel does when it opens the file.
|
||||
//! SYLK (`.slk`) import. `craft_csv::sylk` reads the file (values, formulas rewritten from R1C1 to
|
||||
//! A1, number formats, column widths); this module makes it a one-sheet workbook: formulas parsed
|
||||
//! (a formula GridCraft can't parse is skipped and counted), error values recognised, formats
|
||||
//! interned as styles and widths converted from characters.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::sync::Arc;
|
||||
|
||||
use gridcraft_core::{CellError, CellRef, MAX_COLS, MAX_ROWS, Value, col_to_letters};
|
||||
use craft_csv::sylk;
|
||||
use gridcraft_core::{CellError, CellRef, Value};
|
||||
use gridcraft_model::{Cell, Formula, NumFmt, Sheet, Style, Workbook};
|
||||
|
||||
use crate::{EngineError, Result};
|
||||
|
||||
/// The largest SYLK file read, as for other text imports: past it the file is refused.
|
||||
const MAX_BYTES: usize = 512 << 20;
|
||||
/// Column-width records kept from one file; each can cover every column.
|
||||
const MAX_WIDTH_RECORDS: usize = 1024;
|
||||
|
||||
/// Reads a SYLK file into a one-sheet workbook. Returns the workbook and its warnings.
|
||||
pub fn read(name: &str, bytes: &[u8]) -> Result<(Workbook, Vec<String>)> {
|
||||
if bytes.len() > MAX_BYTES {
|
||||
return Err(EngineError::Other(format!("We can't open '{name}': the SYLK file is larger than {} MB.", MAX_BYTES >> 20)));
|
||||
}
|
||||
let text = match std::str::from_utf8(bytes) {
|
||||
Ok(s) => s.to_string(),
|
||||
// Older exports are in a single-byte code page: keep each byte as its Latin-1 character.
|
||||
Err(_) => bytes.iter().map(|&b| char::from(b)).collect(),
|
||||
};
|
||||
let text = text.strip_prefix('\u{feff}').unwrap_or(&text);
|
||||
if !text.starts_with("ID") {
|
||||
return Err(EngineError::Other(format!("We can't open '{name}': it isn't a SYLK file (it doesn't start with an ID record).")));
|
||||
}
|
||||
let file = sylk::read(bytes).map_err(|e| match e {
|
||||
sylk::Error::TooLarge => EngineError::Other(format!("We can't open '{name}': the SYLK file is larger than {} MB.", sylk::MAX_BYTES >> 20)),
|
||||
_ => EngineError::Other(format!("We can't open '{name}': it isn't a SYLK file (it doesn't start with an ID record).")),
|
||||
})?;
|
||||
let mut wb = Workbook::new();
|
||||
let mut sheet = Sheet::new("Sheet1");
|
||||
let mut formats: Vec<String> = Vec::new();
|
||||
// Cells' number formats by index into `formats`, applied once every format is known.
|
||||
let mut cell_formats: Vec<(CellRef, usize)> = Vec::new();
|
||||
let mut formulas: HashMap<CellRef, String> = HashMap::new();
|
||||
let mut widths: Vec<(u32, u32, f64)> = Vec::new();
|
||||
let (mut row, mut col) = (0u32, 0u32);
|
||||
let mut skipped = 0usize;
|
||||
for line in text.lines() {
|
||||
let fields = split_fields(line);
|
||||
let Some((kind, rest)) = fields.split_first() else { continue };
|
||||
match kind.as_str() {
|
||||
"C" => {
|
||||
let (mut value, mut formula, mut shared) = (None, None, None::<(Option<u32>, Option<u32>)>);
|
||||
let mut bad = false;
|
||||
for f in rest {
|
||||
let (tag, arg) = f.split_at(f.chars().next().map_or(0, char::len_utf8));
|
||||
match tag {
|
||||
"Y" => match position(arg, MAX_ROWS) {
|
||||
Some(r) => row = r,
|
||||
None => bad = true,
|
||||
},
|
||||
"X" => match position(arg, MAX_COLS) {
|
||||
Some(c) => col = c,
|
||||
None => bad = true,
|
||||
},
|
||||
"K" => value = Some(parse_value(arg)),
|
||||
"E" => formula = Some(arg.to_string()),
|
||||
"S" => shared = Some((None, None)),
|
||||
// In a shared-formula cell, R and C name the cell whose formula it shares.
|
||||
"R" if shared.is_some() => shared = shared.map(|(_, c)| (position(arg, MAX_ROWS), c)),
|
||||
"C" if shared.is_some() => shared = shared.map(|(r, _)| (r, position(arg, MAX_COLS))),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
if bad {
|
||||
skipped += 1;
|
||||
continue;
|
||||
}
|
||||
let at = CellRef::new(row, col);
|
||||
if let Some((Some(r), Some(c))) = shared {
|
||||
formula = formulas.get(&CellRef::new(r, c)).cloned();
|
||||
}
|
||||
let mut cell = sheet.cell(at).cloned().unwrap_or_else(|| Cell::value(Value::Empty));
|
||||
if let Some(v) = value {
|
||||
cell.value = v;
|
||||
}
|
||||
if let Some(r1c1) = formula {
|
||||
let a1 = r1c1_formula_to_a1(&r1c1, at);
|
||||
let f = Formula::new(&a1);
|
||||
if f.expr.is_some() {
|
||||
cell.formula = Some(Arc::new(f));
|
||||
formulas.insert(at, r1c1);
|
||||
} else {
|
||||
skipped += 1;
|
||||
}
|
||||
}
|
||||
sheet.set_cell(at, cell);
|
||||
let mut skipped = file.skipped;
|
||||
let mut styles = HashMap::new();
|
||||
for (&(row, col), c) in &file.cells {
|
||||
let value = match &c.value {
|
||||
sylk::Value::Number(n) => Value::Number(*n),
|
||||
sylk::Value::Text(s) => Value::Text(Arc::from(s.as_str())),
|
||||
sylk::Value::Bool(b) => Value::Bool(*b),
|
||||
sylk::Value::Error(s) => CellError::parse(s).map_or_else(|| Value::Text(Arc::from(s.as_str())), Value::Error),
|
||||
_ => Value::Empty,
|
||||
};
|
||||
let mut cell = Cell::value(value);
|
||||
if let Some(a1) = &c.formula {
|
||||
let f = Formula::new(a1);
|
||||
if f.expr.is_some() {
|
||||
cell.formula = Some(Arc::new(f));
|
||||
} else {
|
||||
skipped += 1;
|
||||
}
|
||||
"F" => {
|
||||
let mut format = None;
|
||||
for f in rest {
|
||||
let (tag, arg) = f.split_at(f.chars().next().map_or(0, char::len_utf8));
|
||||
match tag {
|
||||
"Y" => row = position(arg, MAX_ROWS).unwrap_or(row),
|
||||
"X" => col = position(arg, MAX_COLS).unwrap_or(col),
|
||||
"P" => format = arg.parse::<usize>().ok(),
|
||||
"W" => {
|
||||
let mut parts = arg.split_whitespace();
|
||||
if let (Some(first), Some(last), Some(width)) = (parts.next(), parts.next(), parts.next())
|
||||
&& let (Some(first), Some(last), Ok(width)) =
|
||||
(position(first, MAX_COLS), position(last, MAX_COLS), width.parse::<f64>())
|
||||
&& first <= last
|
||||
&& (0.0..=255.0).contains(&width)
|
||||
// A file of width records can't make the import loop over every column
|
||||
// again and again.
|
||||
&& widths.len() < MAX_WIDTH_RECORDS
|
||||
{
|
||||
widths.push((first, last, width));
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
if let Some(format) = format {
|
||||
cell_formats.push((CellRef::new(row, col), format));
|
||||
}
|
||||
}
|
||||
// Number formats only: `P;F…` and `P;E…` are fonts.
|
||||
"P" => {
|
||||
if let Some(code) = rest.first().and_then(|f| f.strip_prefix('P')) {
|
||||
formats.push(code.to_string());
|
||||
}
|
||||
}
|
||||
"E" => break,
|
||||
_ => {}
|
||||
}
|
||||
if let Some(code) = &c.format {
|
||||
cell.style = *styles
|
||||
.entry(code.as_str())
|
||||
.or_insert_with(|| wb.styles.intern(Style { num_fmt: NumFmt(Arc::from(code.as_str())), ..Style::default() }));
|
||||
}
|
||||
sheet.set_cell(CellRef::new(row, col), cell);
|
||||
}
|
||||
for (first, last, width) in widths {
|
||||
let size = crate::cmd::format::chars_to_points(width) as f32;
|
||||
for c in first..=last {
|
||||
for w in &file.column_widths {
|
||||
let size = crate::cmd::format::chars_to_points(w.width) as f32;
|
||||
for c in w.first..=w.last {
|
||||
sheet.cols.entry(c).or_default().size = Some(size);
|
||||
}
|
||||
}
|
||||
let mut wb = Workbook::new();
|
||||
let mut styles = HashMap::new();
|
||||
for (at, index) in cell_formats {
|
||||
let Some(code) = formats.get(index).filter(|code| !code.is_empty() && *code != "General") else { continue };
|
||||
let style = *styles.entry(index).or_insert_with(|| wb.styles.intern(Style { num_fmt: NumFmt(Arc::from(code.as_str())), ..Style::default() }));
|
||||
let mut cell = sheet.cell(at).cloned().unwrap_or_else(|| Cell::value(Value::Empty));
|
||||
cell.style = style;
|
||||
sheet.set_cell(at, cell);
|
||||
}
|
||||
if let Some(first) = wb.sheet_mut(0) {
|
||||
sheet.name = std::mem::take(&mut first.name);
|
||||
*first = sheet;
|
||||
@@ -161,168 +62,3 @@ pub fn read(name: &str, bytes: &[u8]) -> Result<(Workbook, Vec<String>)> {
|
||||
}
|
||||
Ok((wb, warnings))
|
||||
}
|
||||
|
||||
/// A record's fields: `;` separates them and `;;` is a literal semicolon.
|
||||
fn split_fields(line: &str) -> Vec<String> {
|
||||
let mut fields = vec![String::new()];
|
||||
let mut chars = line.trim_end_matches('\r').chars().peekable();
|
||||
while let Some(c) = chars.next() {
|
||||
if c == ';' {
|
||||
if chars.peek() == Some(&';') {
|
||||
chars.next();
|
||||
if let Some(f) = fields.last_mut() {
|
||||
f.push(';');
|
||||
}
|
||||
} else {
|
||||
fields.push(String::new());
|
||||
}
|
||||
} else if let Some(f) = fields.last_mut() {
|
||||
f.push(c);
|
||||
}
|
||||
}
|
||||
fields
|
||||
}
|
||||
|
||||
/// A 1-based row or column number → 0-based, within `max`.
|
||||
fn position(arg: &str, max: u32) -> Option<u32> {
|
||||
arg.trim().parse::<u32>().ok().filter(|n| (1..=max).contains(n)).map(|n| n - 1)
|
||||
}
|
||||
|
||||
/// A `K` value: `"text"` (everything between the first and the last quote, as written), a
|
||||
/// boolean, an error or a number.
|
||||
fn parse_value(arg: &str) -> Value {
|
||||
if let Some(text) = arg.strip_prefix('"') {
|
||||
let text = text.strip_suffix('"').unwrap_or(text);
|
||||
return Value::Text(Arc::from(text));
|
||||
}
|
||||
if arg.eq_ignore_ascii_case("TRUE") || arg.eq_ignore_ascii_case("FALSE") {
|
||||
return Value::Bool(arg.eq_ignore_ascii_case("TRUE"));
|
||||
}
|
||||
if let Some(e) = CellError::parse(arg) {
|
||||
return Value::Error(e);
|
||||
}
|
||||
match arg.trim().parse::<f64>() {
|
||||
Ok(n) if n.is_finite() => Value::Number(n),
|
||||
_ => Value::Text(Arc::from(arg)),
|
||||
}
|
||||
}
|
||||
|
||||
/// One part of an R1C1 reference: `R`/`C` followed by an absolute number, a bracketed offset or
|
||||
/// nothing (the cell's own row or column).
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
enum Part {
|
||||
Absolute(u32),
|
||||
Relative(i64),
|
||||
}
|
||||
|
||||
impl Part {
|
||||
/// The 0-based index and whether it is absolute, or `None` when it falls off the sheet.
|
||||
fn resolve(self, base: u32, max: u32) -> Option<(u32, bool)> {
|
||||
match self {
|
||||
Part::Absolute(n) => (1..=max).contains(&n).then(|| (n - 1, true)),
|
||||
Part::Relative(k) => i64::from(base).checked_add(k).and_then(|v| u32::try_from(v).ok()).filter(|v| *v < max).map(|v| (v, false)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Parses the number after `R` or `C` at `i`: digits, `[offset]` or nothing. Returns the part and
|
||||
/// the index after it, or `None` when the text isn't a reference part.
|
||||
fn parse_part(chars: &[char], i: usize) -> Option<(Part, usize)> {
|
||||
match chars.get(i) {
|
||||
Some('[') => {
|
||||
let close = chars[i..].iter().position(|&c| c == ']')? + i;
|
||||
let inner: String = chars[i + 1..close].iter().collect();
|
||||
Some((Part::Relative(inner.parse().ok()?), close + 1))
|
||||
}
|
||||
Some(c) if c.is_ascii_digit() => {
|
||||
let end = chars[i..].iter().position(|c| !c.is_ascii_digit()).map_or(chars.len(), |p| p + i);
|
||||
let n: String = chars[i..end].iter().collect();
|
||||
Some((Part::Absolute(n.parse().unwrap_or(u32::MAX)), end))
|
||||
}
|
||||
_ => Some((Part::Relative(0), i)),
|
||||
}
|
||||
}
|
||||
|
||||
fn is_word_char(c: char) -> bool {
|
||||
c.is_alphanumeric() || matches!(c, '_' | '.' | '\\' | '?' | '$')
|
||||
}
|
||||
|
||||
/// Rewrites the R1C1 references in a SYLK formula as A1 references for the cell at `at`:
|
||||
/// `RC[-1]` → `B2`, `R1C1` → `$A$1`, `R[-2]C:R[-1]C` → `D2:D3`, a whole column `C4` → `$D:$D` and
|
||||
/// a whole row `R3` → `$3:$3`. Text in quotes and quoted sheet names are left alone; a reference
|
||||
/// off the sheet becomes `#REF!`.
|
||||
pub(crate) fn r1c1_formula_to_a1(formula: &str, at: CellRef) -> String {
|
||||
let chars: Vec<char> = formula.chars().collect();
|
||||
let mut out = String::with_capacity(formula.len());
|
||||
let mut i = 0;
|
||||
while i < chars.len() {
|
||||
let c = chars[i];
|
||||
if c == '"' || c == '\'' {
|
||||
// Copy the quoted run as it is; a doubled quote stays inside it.
|
||||
let mut j = i + 1;
|
||||
while j < chars.len() && !(chars[j] == c && chars.get(j + 1) != Some(&c)) {
|
||||
j += if chars[j] == c { 2 } else { 1 };
|
||||
}
|
||||
let stop = (j + 1).min(chars.len());
|
||||
out.extend(&chars[i..stop]);
|
||||
i = stop;
|
||||
continue;
|
||||
}
|
||||
let starts_word = i == 0 || !is_word_char(chars[i - 1]);
|
||||
if starts_word
|
||||
&& matches!(c, 'R' | 'r' | 'C' | 'c')
|
||||
&& let Some((text, next)) = reference_at(&chars, i, at)
|
||||
{
|
||||
out.push_str(&text);
|
||||
i = next;
|
||||
continue;
|
||||
}
|
||||
// Copy the rest of a word as it is, so `ROUND` or `Sheet2` isn't read as a reference.
|
||||
if is_word_char(c) {
|
||||
let end = (i..chars.len()).find(|&j| !is_word_char(chars[j])).unwrap_or(chars.len());
|
||||
out.extend(&chars[i..end]);
|
||||
i = end;
|
||||
} else {
|
||||
out.push(c);
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The A1 text of the R1C1 reference starting at `i`, and the index after it, or `None` when the
|
||||
/// word there isn't a reference (a function or a name).
|
||||
fn reference_at(chars: &[char], i: usize, at: CellRef) -> Option<(String, usize)> {
|
||||
let mut j = i;
|
||||
let mut row = None;
|
||||
let mut col = None;
|
||||
if matches!(chars.get(j), Some('R' | 'r')) {
|
||||
let (part, next) = parse_part(chars, j + 1)?;
|
||||
row = Some(part);
|
||||
j = next;
|
||||
}
|
||||
if matches!(chars.get(j), Some('C' | 'c')) {
|
||||
let (part, next) = parse_part(chars, j + 1)?;
|
||||
col = Some(part);
|
||||
j = next;
|
||||
}
|
||||
if row.is_none() && col.is_none() {
|
||||
return None;
|
||||
}
|
||||
// A reference ends the word: `ROUND(`, `RATE` or `R2D2` are names.
|
||||
if chars.get(j).is_some_and(|&c| is_word_char(c) || c == '(' || c == '[' || c == '!') {
|
||||
return None;
|
||||
}
|
||||
let row_text = |p: Part| p.resolve(at.row, MAX_ROWS).map(|(r, abs)| format!("{}{}", if abs { "$" } else { "" }, r + 1));
|
||||
let col_text = |p: Part| p.resolve(at.col, MAX_COLS).map(|(c, abs)| format!("{}{}", if abs { "$" } else { "" }, col_to_letters(c)));
|
||||
// One side of a range (`R2:R4`, `C1:C3`) is written alone; a lone row or column is the whole of it.
|
||||
let prev = chars[..i].iter().rev().find(|c| !c.is_whitespace());
|
||||
let in_range = prev == Some(&':') || chars[j..].iter().find(|c| !c.is_whitespace()) == Some(&':');
|
||||
let text = match (row, col) {
|
||||
(Some(r), Some(c)) => row_text(r).zip(col_text(c)).map(|(r, c)| format!("{c}{r}")),
|
||||
(Some(r), None) => row_text(r).map(|r| if in_range { r } else { format!("{r}:{r}") }),
|
||||
(None, Some(c)) => col_text(c).map(|c| if in_range { c } else { format!("{c}:{c}") }),
|
||||
(None, None) => None,
|
||||
};
|
||||
Some((text.unwrap_or_else(|| "#REF!".into()), j))
|
||||
}
|
||||
|
||||
@@ -763,7 +763,7 @@ fn sylk_r1c1_formulas_become_a1() {
|
||||
("R[-5]C", "#REF!"),
|
||||
("\"RC\"&R1C1", "\"RC\"&$A$1"),
|
||||
] {
|
||||
assert_eq!(sylk::r1c1_formula_to_a1(r1c1, b2), a1, "{r1c1}");
|
||||
assert_eq!(craft_csv::sylk::r1c1_formula_to_a1(r1c1, (b2.row, b2.col)), a1, "{r1c1}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -810,3 +810,74 @@ fn reading_a_fifo_is_refused_without_blocking() {
|
||||
assert!(err.contains("only regular files"), "{err}");
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
/// Merges far from what is copied or exported, in a hostile number, are indexed once instead of
|
||||
/// being scanned for every cell; a merge running past the table is clipped to it.
|
||||
#[test]
|
||||
fn html_merge_lookups_and_spans_stay_bounded() {
|
||||
let mut wb = book_with_picture("A1", (0, 0));
|
||||
let sh = wb.sheet_mut(0).unwrap();
|
||||
for i in 0..200_000u32 {
|
||||
sh.merges.push(RangeRef::new(CellRef::new(500_000 + i * 2, 5), CellRef::new(500_000 + i * 2, 6)));
|
||||
}
|
||||
sh.merges.push(RangeRef::new(CellRef::new(0, 0), CellRef::new(gridcraft_core::MAX_ROWS - 1, 1)));
|
||||
sh.set_value(CellRef::new(2, 1), gridcraft_core::Value::Number(2.0));
|
||||
let html = copied(&wb, "A1:C50");
|
||||
assert!(html.contains("rowspan=\"50\" colspan=\"2\""), "{html}");
|
||||
let page = to_html(&wb, 0).unwrap();
|
||||
// The table is A1:B3 (the used range): the whole-height merge spans its three rows only.
|
||||
assert!(page.contains("rowspan=\"3\" colspan=\"2\""), "{page}");
|
||||
// Merges stacked over one another past a few per cell are refused, not walked.
|
||||
let sh = wb.sheet_mut(0).unwrap();
|
||||
sh.merges = vec![RangeRef::new(CellRef::new(0, 0), CellRef::new(2, 1)); 100];
|
||||
assert!(to_html(&wb, 0).is_err());
|
||||
assert!(range_html(&wb, 0, RangeRef::parse("A1:B3").unwrap(), "").is_none());
|
||||
}
|
||||
|
||||
/// Thousands of pictures over thousands of custom rows: each is placed through a row index.
|
||||
#[test]
|
||||
fn html_export_places_many_pictures_over_many_custom_rows() {
|
||||
let mut wb = book_with_picture("A1", (0, 0));
|
||||
let sh = wb.sheet_mut(0).unwrap();
|
||||
for row in 0..50_000 {
|
||||
sh.rows.insert(row, gridcraft_model::LineInfo { size: Some(30.0), ..Default::default() });
|
||||
}
|
||||
let image = sh.images[0].clone();
|
||||
for i in 0..5_000u32 {
|
||||
let mut im = image.clone();
|
||||
im.anchor.cell = CellRef::new(40_000 + i, 0);
|
||||
sh.images.push(im);
|
||||
}
|
||||
let page = to_html(&wb, 0).unwrap();
|
||||
assert!(page.contains(&format!("top:{}px", 30 * 44_999)), "last picture placed by the index");
|
||||
}
|
||||
|
||||
/// One long text shown by many cells: the page fails at its byte limit instead of growing on.
|
||||
#[test]
|
||||
fn html_export_refuses_a_page_past_its_byte_limit() {
|
||||
let mut wb = Workbook::new();
|
||||
let sh = wb.sheet_mut(0).unwrap();
|
||||
let text = gridcraft_core::Value::text("x".repeat(32_000));
|
||||
for row in 0..10_000 {
|
||||
sh.set_value(CellRef::new(row, 0), text.clone());
|
||||
}
|
||||
let err = to_html(&wb, 0).unwrap_err();
|
||||
assert!(err.to_string().contains("MiB"), "{err}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn escaping_stops_at_the_room_left() {
|
||||
assert_eq!(esc_within("a&b<c>\"d", 100).as_deref(), Some(esc("a&b<c>\"d").as_str()));
|
||||
assert_eq!(esc_within("&&&", 14), None, "three `&` are 15 bytes");
|
||||
assert_eq!(esc_within("&&&", 15).as_deref(), Some("&&&"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_merge_index_holds_a_bounded_number_of_cells() {
|
||||
let mut sh = Sheet::new("S");
|
||||
let rect = RangeRef::new(CellRef::new(0, 0), CellRef::new(1_100_000, 0));
|
||||
sh.merges.push(RangeRef::new(CellRef::new(0, 0), CellRef::new(999_999, 0)));
|
||||
assert_eq!(merge_index(&sh, rect).map(|m| m.len()), Some(1_000_000));
|
||||
sh.merges = vec![RangeRef::new(CellRef::new(0, 0), CellRef::new(1_000_000, 0))];
|
||||
assert!(merge_index(&sh, rect).is_none());
|
||||
}
|
||||
|
||||
@@ -305,11 +305,25 @@ fn trim_to_budget(history: &mut Vec<HistoryEntry>, byte_budget: usize) {
|
||||
}
|
||||
}
|
||||
|
||||
/// A writer that only counts the bytes written to it.
|
||||
struct ByteCounter(usize);
|
||||
|
||||
impl std::io::Write for ByteCounter {
|
||||
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
|
||||
self.0 = self.0.saturating_add(buf.len());
|
||||
Ok(buf.len())
|
||||
}
|
||||
fn flush(&mut self) -> std::io::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl DocState {
|
||||
/// A document for `wb`, which came from where `trust` says: [`Trust::FromFile`] for anything
|
||||
/// read from bytes (a file, a download, a recovery copy), [`Trust::Local`] only for a workbook
|
||||
/// made in this session.
|
||||
pub fn new(mut wb: Workbook, path: Option<String>, title: String, trust: Trust) -> DocState {
|
||||
let _ = gridcraft_model::PIVOT_INDEXER.set(pivot::index_cells);
|
||||
let mut calc = Calc::new();
|
||||
calc.recalc_all(&mut wb);
|
||||
Self::with_calc(wb, calc, path, title, trust)
|
||||
@@ -638,7 +652,11 @@ impl Session {
|
||||
/// Journals a command, then trims the oldest entries past either cap. A recording in progress
|
||||
/// keeps pointing at the same entry (the steps the trim dropped are lost).
|
||||
fn push_journal(&mut self, id: &str, params: Json) {
|
||||
let size = |e: &(String, Json)| serde_json::to_vec(e).map_or(0, |v| v.len());
|
||||
// Counted as it is written, without building the text: a paste's params can be MBs.
|
||||
let size = |e: &(String, Json)| {
|
||||
let mut counter = ByteCounter(0);
|
||||
serde_json::to_writer(&mut counter, e).map_or(0, |()| counter.0)
|
||||
};
|
||||
// `journal` is public: if it was changed from outside, measure it again.
|
||||
if self.journal_sizes.len() != self.journal.len() {
|
||||
self.journal_sizes = self.journal.iter().map(size).collect();
|
||||
|
||||
@@ -213,17 +213,7 @@ pub fn json_bytes(wb: &Workbook) -> crate::Result<Vec<u8>> {
|
||||
for m in &wb.macros {
|
||||
check(m).map_err(crate::EngineError::Other)?;
|
||||
}
|
||||
let bytes = if wb.macros_unread.is_empty() {
|
||||
serde_json::to_vec_pretty(wb)
|
||||
} else {
|
||||
serde_json::to_value(wb).and_then(|mut v| {
|
||||
if let Some(list) = v.as_object_mut().map(|o| o.entry("macros").or_insert_with(|| Json::Array(vec![]))).and_then(Json::as_array_mut) {
|
||||
list.extend(wb.macros_unread.iter().cloned());
|
||||
}
|
||||
serde_json::to_vec_pretty(&v)
|
||||
})
|
||||
};
|
||||
bytes.map_err(|e| crate::EngineError::Other(e.to_string()))
|
||||
craft_gridcraft_format::write_with_kept(wb, "macros", &wb.macros_unread).map_err(|e| crate::EngineError::Other(e.to_string()))
|
||||
}
|
||||
|
||||
/// Whether `v` is a macro in a newer format than this build reads.
|
||||
|
||||
@@ -1281,9 +1281,18 @@ fn content_differs(b: Option<&Cell>, a: Option<&Cell>) -> bool {
|
||||
/// Objects added, changed and removed between two versions of a sheet.
|
||||
fn objects(b: &Sheet, a: &Sheet) -> (usize, usize, usize) {
|
||||
fn count<T: PartialEq>(b: &[T], a: &[T], id: impl Fn(&T) -> u32) -> (usize, usize, usize) {
|
||||
let added = a.iter().filter(|x| !b.iter().any(|y| id(y) == id(x))).count();
|
||||
let removed = b.iter().filter(|x| !a.iter().any(|y| id(y) == id(x))).count();
|
||||
let changed = b.iter().filter(|x| a.iter().any(|y| id(y) == id(x) && y != *x)).count();
|
||||
// Objects grouped by id, so each lookup is a map probe instead of a scan of the list.
|
||||
fn group<'a, T>(v: &'a [T], id: &impl Fn(&T) -> u32) -> std::collections::HashMap<u32, Vec<&'a T>> {
|
||||
let mut m: std::collections::HashMap<u32, Vec<&T>> = std::collections::HashMap::new();
|
||||
for x in v {
|
||||
m.entry(id(x)).or_default().push(x);
|
||||
}
|
||||
m
|
||||
}
|
||||
let (gb, ga) = (group(b, &id), group(a, &id));
|
||||
let added = a.iter().filter(|x| !gb.contains_key(&id(x))).count();
|
||||
let removed = b.iter().filter(|x| !ga.contains_key(&id(x))).count();
|
||||
let changed = b.iter().filter(|x| ga.get(&id(x)).is_some_and(|ys| ys.iter().any(|y| *y != *x))).count();
|
||||
(added, changed, removed)
|
||||
}
|
||||
let parts = [
|
||||
|
||||
@@ -12,8 +12,8 @@ use gridcraft_core::date::datetime_from_serial;
|
||||
pub use gridcraft_core::quote_sheet;
|
||||
use gridcraft_core::{CellError, CellRef, MAX_COLS, MAX_ROWS, RangeRef, Value, split_sheet};
|
||||
use gridcraft_model::{
|
||||
BorderLine, BorderStyle, Cell, Chart, Color, Fill, HAlign, NumFmt, PivotDateGroup, PivotField, PivotFilter, PivotFunc, PivotLayout, PivotShowAs,
|
||||
PivotSort, PivotTable, PivotValue, Series, Style, StyleId, Workbook,
|
||||
BorderLine, BorderStyle, Cell, Chart, Color, Fill, HAlign, NumFmt, PivotDataCell, PivotDateGroup, PivotField, PivotFilter, PivotFunc,
|
||||
PivotItemRef, PivotLayout, PivotLookup, PivotShowAs, PivotSort, PivotTable, PivotValue, Series, Style, StyleId, Workbook,
|
||||
};
|
||||
|
||||
use crate::pivot_calc::CalcSet;
|
||||
@@ -41,6 +41,9 @@ pub const MAX_OUTPUT_CELLS: u64 = 2_000_000;
|
||||
pub const MAX_AXIS_FIELDS: usize = 32;
|
||||
/// Most fields in the Values area.
|
||||
pub const MAX_VALUE_FIELDS: usize = 256;
|
||||
/// Most report value cells a report may have (every one is indexed for GETPIVOTDATA; bigger
|
||||
/// reports are rejected).
|
||||
pub const MAX_INDEXED_CELLS: usize = 1_000_000;
|
||||
|
||||
const MONTHS: [&str; 12] = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
|
||||
|
||||
@@ -314,9 +317,42 @@ pub fn refresh(wb: &mut Workbook, sheet: usize, idx: usize, replace: bool) -> Re
|
||||
}
|
||||
let sheet_name = shm.name.clone();
|
||||
rebind_charts(wb, &sheet_name, &pt.name, origin, &out);
|
||||
// The index of the new report; its lookup hash is built on the first GETPIVOTDATA.
|
||||
if let Some(p) = wb.sheet_mut(sheet).and_then(|s| s.pivots.get_mut(idx)) {
|
||||
let index = PivotLookup::default();
|
||||
index.set_cells(out.data);
|
||||
p.data_index = index;
|
||||
}
|
||||
Ok(area)
|
||||
}
|
||||
|
||||
/// The value cells of a PivotTable's report, for GETPIVOTDATA when a refresh did not set the
|
||||
/// index (a workbook just opened from XLSX). The positions must describe the report as it is
|
||||
/// stored on the sheet, not as the current source would render it: the source is recomputed only
|
||||
/// to learn the layout, and the result is accepted when every label and header cell of that
|
||||
/// layout equals the stored cell at the same place. A source changed since the last refresh gives
|
||||
/// a different layout, so there is no trustworthy index and the lookup fails until a refresh.
|
||||
pub fn index_cells(wb: &Workbook, sheet: usize, pt: &PivotTable) -> Result<Vec<PivotDataCell>, String> {
|
||||
const STALE: &str = "The stored report no longer matches the source. Refresh the PivotTable.";
|
||||
let report = pt.last_range.ok_or("The PivotTable has no report.")?;
|
||||
let out = compute(wb, pt, sheet)?;
|
||||
let sh = wb.sheet(sheet).ok_or("There's no such sheet.")?;
|
||||
let rows = u64::from(report.end.row) - u64::from(report.start.row) + 1;
|
||||
let cols = u64::from(report.end.col) - u64::from(report.start.col) + 1;
|
||||
if rows != u64::from(out.height().max(1)) || cols != u64::from(out.width.max(1)) {
|
||||
return Err(STALE.into());
|
||||
}
|
||||
let labels = [CellKind::Header, CellKind::RowLabel, CellKind::ColLabel, CellKind::Filter];
|
||||
for (r, row) in out.grid.iter().enumerate() {
|
||||
for (c, oc) in row.iter().enumerate() {
|
||||
if labels.contains(&oc.kind) && sh.value(CellRef::new(report.start.row + r as u32, report.start.col + c as u32)) != oc.value {
|
||||
return Err(STALE.into());
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(out.data)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod fit_tests {
|
||||
use super::data_cols_exceed_sheet;
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use super::output::Output;
|
||||
use super::{CellRef, Chart, Series, Workbook, quote_sheet};
|
||||
use super::{CellRef, Chart, PivotLookup, Series, Workbook, quote_sheet};
|
||||
|
||||
// ---------------------------------------------------------------- PivotCharts
|
||||
|
||||
@@ -109,6 +109,7 @@ pub fn clear_output(wb: &mut Workbook, sheet: usize, idx: usize) {
|
||||
shm.take_cells(r);
|
||||
if let Some(p) = shm.pivots.get_mut(idx) {
|
||||
p.last_range = None;
|
||||
p.data_index = PivotLookup::default();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -126,6 +127,7 @@ mod tests {
|
||||
chart_rows: vec![1, 2, 3],
|
||||
chart_cols: (1..1000).map(|c| (c, format!("S{c}"))).collect(),
|
||||
label_col: Some(0),
|
||||
data: vec![],
|
||||
};
|
||||
assert_eq!(chart_series("Sheet1", CellRef::new(0, 0), &out).len(), MAX_CHART_SERIES);
|
||||
}
|
||||
|
||||
@@ -3,8 +3,8 @@ use super::output::{
|
||||
AggMap, CellKind, ColKind, ColSpec, Ctx, Grid, Line, LineKind, Output, RowKind, ValSrc, caption, data_cols_exceed_sheet, flatten_cols,
|
||||
};
|
||||
use super::{
|
||||
CalcSet, CellError, CellRef, HashMap, HashSet, MAX_AXIS_FIELDS, MAX_COLS, MAX_VALUE_FIELDS, PivotDateGroup, PivotField, PivotFilter, PivotFunc,
|
||||
PivotLayout, PivotShowAs, PivotTable, PivotValue, Source, Value, Workbook, read_source,
|
||||
CalcSet, CellError, CellRef, HashMap, HashSet, MAX_AXIS_FIELDS, MAX_COLS, MAX_INDEXED_CELLS, MAX_VALUE_FIELDS, PivotDataCell, PivotDateGroup,
|
||||
PivotField, PivotFilter, PivotFunc, PivotItemRef, PivotLayout, PivotShowAs, PivotTable, PivotValue, Source, Value, Workbook, read_source,
|
||||
};
|
||||
|
||||
/// Why Show Details turns a cell down when it isn't a value cell of a PivotTable (the front end
|
||||
@@ -653,6 +653,7 @@ pub(super) fn compute_from(wb: &Workbook, pt: &PivotTable, src: &Source, mut pro
|
||||
chart_rows: vec![],
|
||||
chart_cols: vec![],
|
||||
label_col: None,
|
||||
data: vec![],
|
||||
});
|
||||
}
|
||||
|
||||
@@ -728,6 +729,16 @@ pub(super) fn compute_from(wb: &Workbook, pt: &PivotTable, src: &Source, mut pro
|
||||
} else {
|
||||
Some(row_levels.saturating_sub(1) as u32)
|
||||
};
|
||||
let item_refs = |fields: &[&PivotField], items: &[FieldItems], path: &[u32]| -> Vec<PivotItemRef> {
|
||||
path.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(d, it)| {
|
||||
let (f, item) = (fields.get(d)?, items.get(d)?.get(*it)?);
|
||||
Some(PivotItemRef { field: f.source_col.clone(), label: item.label.clone(), value: item.value.clone() })
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
let mut data: Vec<PivotDataCell> = Vec::new();
|
||||
for line in &lines {
|
||||
let rk = match line.kind {
|
||||
LineKind::Item(b) => RowKind::Item(b),
|
||||
@@ -758,6 +769,21 @@ pub(super) fn compute_from(wb: &Workbook, pt: &PivotTable, src: &Source, mut pro
|
||||
let Some(raw) = lookup.get(rp, cp, *vi) else { continue };
|
||||
let context = ShowContext { row_path: rp, col_path: cp, value_index: *vi, level0: &level0, siblings: &siblings, cache: &show_cache };
|
||||
let shown = show_value(vdef, raw, &lookup, &context);
|
||||
// Every value cell of the report is indexed, so a report that needs more cells than
|
||||
// the index cap is rejected outright — never written with a truncated index that
|
||||
// would answer #REF! for the values the sheet shows.
|
||||
if data.len() >= MAX_INDEXED_CELLS {
|
||||
return Err(format!("A PivotTable report can have at most {MAX_INDEXED_CELLS} value cells."));
|
||||
}
|
||||
let mut items = item_refs(&ctx.rows, &ctx.row_items, rp);
|
||||
items.extend(item_refs(&col_fields, &col_items, cp));
|
||||
data.push(PivotDataCell {
|
||||
data_field: vdef.name.clone(),
|
||||
source_col: vdef.source_col.clone(),
|
||||
items,
|
||||
row: u32::try_from(r).unwrap_or(u32::MAX),
|
||||
col: u32::try_from(l + j).unwrap_or(u32::MAX),
|
||||
});
|
||||
if let Some(pr) = probe.as_deref_mut() {
|
||||
if pr.at == Some((r, l + j)) {
|
||||
pr.hit = Some((rp.to_vec(), cp.to_vec()));
|
||||
@@ -769,5 +795,5 @@ pub(super) fn compute_from(wb: &Workbook, pt: &PivotTable, src: &Source, mut pro
|
||||
g.set(r, l + j, shown, ck.1, 0, data_fmt.get(*vi).cloned().flatten());
|
||||
}
|
||||
}
|
||||
Ok(Output { width: g.width as u32, grid: g.rows, row_kinds: g.kinds, body_offset, chart_rows, chart_cols, label_col })
|
||||
Ok(Output { width: g.width as u32, grid: g.rows, row_kinds: g.kinds, body_offset, chart_rows, chart_cols, label_col, data })
|
||||
}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
use super::items::{Acc, FieldItems, Node, is_collapsed};
|
||||
use super::{
|
||||
BorderLine, BorderStyle, Color, Fill, HAlign, HashMap, MAX_COLS, MAX_OUTPUT_CELLS, MAX_ROWS, NumFmt, PivotField, PivotLayout, PivotTable, Style,
|
||||
Value,
|
||||
BorderLine, BorderStyle, Color, Fill, HAlign, HashMap, MAX_COLS, MAX_OUTPUT_CELLS, MAX_ROWS, NumFmt, PivotDataCell, PivotField, PivotLayout,
|
||||
PivotTable, Style, Value,
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------- output
|
||||
@@ -61,6 +61,8 @@ pub struct Output {
|
||||
pub chart_cols: Vec<(u32, String)>,
|
||||
/// Grid column holding the innermost row labels (`None` without row fields).
|
||||
pub label_col: Option<u32>,
|
||||
/// Every value cell with the items that locate it (for GETPIVOTDATA).
|
||||
pub data: Vec<PivotDataCell>,
|
||||
}
|
||||
|
||||
impl Output {
|
||||
|
||||
@@ -153,6 +153,11 @@ pub fn compile(formula: &str, field: &dyn Fn(&str) -> Option<String>) -> Result<
|
||||
Expr::Name(n) if n.starts_with(PREFIX) => {}
|
||||
Expr::Name(n) => problem = Some(format!("There's no field named '{n}'.")),
|
||||
Expr::Ref(_) | Expr::Struct(_) => problem = Some("A calculated field can't refer to cells or tables; use field names.".into()),
|
||||
// Evaluated once per group and per report, with only the first value kept: Excel does not
|
||||
// allow functions that need arrays in a calculated field, and these build one from scalars.
|
||||
Expr::Call(f, _) if matches!(f.as_str(), "SEQUENCE" | "RANDARRAY" | "MAKEARRAY" | "EXPAND" | "MUNIT") => {
|
||||
problem = Some(format!("A calculated field can't use {f}: it builds an array."))
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
});
|
||||
@@ -332,6 +337,16 @@ mod tests {
|
||||
assert!(compile(&format!("={}", "1+".repeat(MAX_FORMULA_LEN)), &fields).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_calculated_field_cannot_build_arrays_from_scalars() {
|
||||
for f in
|
||||
["=SEQUENCE(5000,1000)", "=SUM(RANDARRAY(1000,1000))", "=MAKEARRAY(9,9,LAMBDA(r,c,r*c))+Sales", "=expand(Sales,1000,1000)", "=MUNIT(500)"]
|
||||
{
|
||||
assert!(compile(f, &fields).unwrap_err().contains("builds an array"), "{f}");
|
||||
}
|
||||
assert!(compile("=SUM({1,2,3})*Sales", &fields).is_ok(), "an array constant is bounded by the formula's own length");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deep_and_cyclic_chains_are_bounded() {
|
||||
// 300 calculated fields, each using the previous one, and a two-field cycle.
|
||||
|
||||
+141
-17
@@ -43,6 +43,10 @@ impl Selection {
|
||||
pub fn is_single_cell(&self) -> bool {
|
||||
self.ranges.len() == 1 && self.current().is_single()
|
||||
}
|
||||
/// Whether the selection is exactly one merged cell, which Enter and Tab treat as one cell.
|
||||
pub fn is_one_merged_cell(&self, sheet: &Sheet) -> bool {
|
||||
self.ranges.len() == 1 && sheet.merge_at(self.active).is_some_and(|m| m == self.current())
|
||||
}
|
||||
/// The corner of the current area opposite the anchor: the end that Shift+arrows move.
|
||||
pub fn moving_end(&self) -> CellRef {
|
||||
let r = self.current();
|
||||
@@ -67,23 +71,28 @@ impl Selection {
|
||||
/// they are: clicking column B's header selects just B even when B1:C1 is merged, as in Excel.
|
||||
pub fn expand_merges(&mut self, sheet: &Sheet) {
|
||||
for r in self.ranges.iter_mut() {
|
||||
if r.is_full_cols() || r.is_full_rows() {
|
||||
continue;
|
||||
}
|
||||
let mut cur = *r;
|
||||
loop {
|
||||
let mut grown = cur;
|
||||
for m in &sheet.merges {
|
||||
if m.intersects(&grown) {
|
||||
grown = grown.union(m);
|
||||
}
|
||||
}
|
||||
if grown == cur {
|
||||
break;
|
||||
}
|
||||
cur = grown;
|
||||
}
|
||||
*r = cur;
|
||||
*r = with_merges(sheet, *r);
|
||||
}
|
||||
}
|
||||
/// Shift+arrows: moves the edge of the current area that the anchor doesn't hold by `dr`
|
||||
/// rows and `dc` columns, keeping merged cells whole, as Excel does. The anchor is the whole
|
||||
/// merged cell it is in, so from a selected merged cell Shift+Left and Shift+Up widen the
|
||||
/// selection past its left and top edges. A step that would shrink the area onto the inside
|
||||
/// of a merged cell (where keeping it whole would undo the step) goes on to the next line
|
||||
/// that does shrink it, and when the area can't shrink any more it grows in that direction.
|
||||
pub fn extend_by(&mut self, sheet: &Sheet, dr: i64, dc: i64) {
|
||||
let anchor = sheet.merge_at(self.anchor).unwrap_or(RangeRef::cell(self.anchor));
|
||||
let mut r = self.current();
|
||||
if dc != 0 {
|
||||
r = step_edge(sheet, r, anchor, dc, true);
|
||||
}
|
||||
if dr != 0 {
|
||||
r = step_edge(sheet, r, anchor, dr, false);
|
||||
}
|
||||
if let Some(last) = self.ranges.last_mut() {
|
||||
*last = r;
|
||||
} else {
|
||||
self.ranges.push(r);
|
||||
}
|
||||
}
|
||||
/// Moves the active cell within the selection (Enter/Tab inside a multi-cell selection).
|
||||
@@ -128,6 +137,91 @@ impl Selection {
|
||||
}
|
||||
}
|
||||
|
||||
/// `r` grown until every merged cell it touches is inside it. Whole columns and whole rows stay
|
||||
/// as they are.
|
||||
fn with_merges(sheet: &Sheet, r: RangeRef) -> RangeRef {
|
||||
if r.is_full_cols() || r.is_full_rows() {
|
||||
return r;
|
||||
}
|
||||
let mut cur = r;
|
||||
loop {
|
||||
let mut grown = cur;
|
||||
for m in &sheet.merges {
|
||||
if m.intersects(&grown) {
|
||||
grown = grown.union(m);
|
||||
}
|
||||
}
|
||||
if grown == cur {
|
||||
return cur;
|
||||
}
|
||||
cur = grown;
|
||||
}
|
||||
}
|
||||
|
||||
/// One Shift+arrow step of [`Selection::extend_by`] along one axis (`cols`: columns, else rows).
|
||||
fn step_edge(sheet: &Sheet, r: RangeRef, anchor: RangeRef, d: i64, cols: bool) -> RangeRef {
|
||||
let max = i64::from(if cols { MAX_COLS } else { MAX_ROWS }) - 1;
|
||||
let hidden = |i: i64| if cols { sheet.is_col_hidden(i as u32) } else { sheet.is_row_hidden(i as u32) };
|
||||
// `from` moved by `by`, then on past hidden lines in the same direction (not off the sheet).
|
||||
let land = |from: i64, by: i64| {
|
||||
let mut t = from.saturating_add(by).clamp(0, max);
|
||||
// Bounded like the arrow keys' walk over hidden lines.
|
||||
for _ in 0..100_000 {
|
||||
if !hidden(t) {
|
||||
break;
|
||||
}
|
||||
let n = (t + by.signum()).clamp(0, max);
|
||||
if n == t {
|
||||
break;
|
||||
}
|
||||
t = n;
|
||||
}
|
||||
t
|
||||
};
|
||||
let span = |x: &RangeRef| {
|
||||
if cols { (i64::from(x.start.col), i64::from(x.end.col)) } else { (i64::from(x.start.row), i64::from(x.end.row)) }
|
||||
};
|
||||
let with = |lo: i64, hi: i64| {
|
||||
let (lo, hi) = (lo.clamp(0, max) as u32, hi.clamp(0, max) as u32);
|
||||
let (s, e) = if cols {
|
||||
(CellRef::new(r.start.row, lo), CellRef::new(r.end.row, hi))
|
||||
} else {
|
||||
(CellRef::new(lo, r.start.col), CellRef::new(hi, r.end.col))
|
||||
};
|
||||
with_merges(sheet, RangeRef::new(s, e))
|
||||
};
|
||||
let (lo, hi) = span(&r);
|
||||
let (alo, ahi) = span(&anchor);
|
||||
// The anchor holds the low edge unless the area reaches past it on that side.
|
||||
let moving_hi = lo >= alo;
|
||||
let shrinking = if moving_hi { d < 0 && hi > ahi } else { d > 0 && lo < alo };
|
||||
if shrinking {
|
||||
let mut t = if moving_hi { hi } else { lo };
|
||||
let mut by = d;
|
||||
loop {
|
||||
t = if moving_hi { land(t, by).max(ahi) } else { land(t, by).min(alo) };
|
||||
let cand = if moving_hi { with(lo, t) } else { with(t, hi) };
|
||||
if cand != r {
|
||||
return cand;
|
||||
}
|
||||
if t == if moving_hi { ahi } else { alo } {
|
||||
break;
|
||||
}
|
||||
// The step was undone because a merged cell crosses the new edge, and so is every
|
||||
// edge up to where that merged cell starts (ends, for the low edge): go on from there
|
||||
// so a tall or wide merged cell costs one step, not one per line it covers.
|
||||
let across = sheet.merges.iter().filter(|m| m.intersects(&r)).filter_map(|m| {
|
||||
let (ms, me) = span(m);
|
||||
if moving_hi { (ms <= t && me > t).then_some(ms) } else { (ms < t && me >= t).then_some(me) }
|
||||
});
|
||||
t = if moving_hi { across.min().map_or(t, |ms| ms.min(t)) } else { across.max().map_or(t, |me| me.max(t)) };
|
||||
by = d.signum();
|
||||
}
|
||||
}
|
||||
// Grow the area on the side the arrow points to.
|
||||
if d > 0 { with(lo, land(hi, d)) } else { with(land(lo, d), hi) }
|
||||
}
|
||||
|
||||
impl Selection {
|
||||
/// Ctrl+. (Next Corner of Selection): the active cell moves clockwise to the next corner of
|
||||
/// the current area (top-left, top-right, bottom-right, bottom-left) and becomes the anchor,
|
||||
@@ -287,6 +381,36 @@ mod tests {
|
||||
assert_eq!(current_region(&s, CellRef::new(5, 0)).a1(), "A1:B20000");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shift_arrows_from_a_merged_cell() {
|
||||
let mut s = Sheet::new("S");
|
||||
s.merges.push(RangeRef::parse("B2:C3").unwrap());
|
||||
let at = |s: &Sheet, a1: &str| {
|
||||
let mut sel = Selection::at(CellRef::parse(a1).unwrap());
|
||||
sel.expand_merges(s);
|
||||
sel
|
||||
};
|
||||
for ((dr, dc), want) in [((0, -1), "A2:C3"), ((-1, 0), "B1:C3"), ((0, 1), "B2:D3"), ((1, 0), "B2:C4")] {
|
||||
let mut sel = at(&s, "B2");
|
||||
sel.extend_by(&s, dr, dc);
|
||||
assert_eq!(sel.a1(), want);
|
||||
}
|
||||
// Shrinking onto the inside of the merged cell goes on past it.
|
||||
let mut sel = at(&s, "A1");
|
||||
sel.extend_by(&s, 1, 1);
|
||||
assert_eq!(sel.a1(), "A1:C3");
|
||||
sel.extend_by(&s, 0, -1);
|
||||
assert_eq!(sel.a1(), "A1:A3");
|
||||
// A hidden column is stepped over, and the sheet edge stops the area.
|
||||
s.cols.entry(3).or_default().hidden = true;
|
||||
let mut sel = at(&s, "B2");
|
||||
sel.extend_by(&s, 0, 1);
|
||||
assert_eq!(sel.a1(), "B2:E3");
|
||||
let mut sel = at(&s, "A1");
|
||||
sel.extend_by(&s, -1, -1);
|
||||
assert_eq!(sel.a1(), "A1");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cycling() {
|
||||
let mut sel = Selection::range(RangeRef::parse("A1:B2").unwrap());
|
||||
|
||||
+405
-1
@@ -532,6 +532,118 @@ fn shape_text_edit_survives_xlsx_roundtrip() {
|
||||
assert_eq!(shape.text, text);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn word_art_insert_respects_sheet_protection() {
|
||||
let mut s = s();
|
||||
s.execute("review.protectSheet", json!({})).unwrap();
|
||||
let before = s.doc().unwrap().wb.clone();
|
||||
let undo_len = s.doc().unwrap().undo.len();
|
||||
assert!(s.execute("insert.wordArt", json!({})).is_err());
|
||||
assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().wb, &before));
|
||||
assert_eq!(s.doc().unwrap().undo.len(), undo_len);
|
||||
s.execute("review.unprotectSheet", json!({})).unwrap();
|
||||
s.execute("insert.wordArt", json!({})).unwrap();
|
||||
assert_eq!(s.doc().unwrap().wb.active().unwrap().shapes.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn word_art_inserts_with_defaults_and_undoes() {
|
||||
use gridcraft_model::ShapeKind;
|
||||
let mut s = s();
|
||||
// Empty params: default style and text, no dialog.
|
||||
let r = s.execute("insert.wordArt", json!({})).unwrap();
|
||||
assert!(s.take_ui_requests().is_empty());
|
||||
let shape = s.doc().unwrap().wb.active().unwrap().shapes[0].clone();
|
||||
assert_eq!(shape.id, r["shape"].as_u64().unwrap() as u32);
|
||||
assert_eq!(shape.kind, ShapeKind::WordArt);
|
||||
assert_eq!(shape.text, crate::cmd::wordart::DEFAULT_TEXT);
|
||||
assert!(shape.anchor.width > 8.0 && shape.format.text_color.is_some());
|
||||
// Named style plus overrides; restyle and edit the text through wordArt.set.
|
||||
s.execute("insert.wordArt", json!({"style": "ember", "text": "Q3", "fontSize": 60, "shadow": false, "outline": "#112233", "outlineWidth": 3}))
|
||||
.unwrap();
|
||||
let ember = s.doc().unwrap().wb.active().unwrap().shapes[1].clone();
|
||||
assert_eq!(ember.format.font_size, Some(60.0));
|
||||
assert_eq!((ember.format.text_shadow, ember.format.text_outline.map(|o| o.1)), (None, Some(3.0)));
|
||||
s.execute("wordArt.set", json!({"id": ember.id, "style": 3, "text": "Q4"})).unwrap();
|
||||
let styled = s.doc().unwrap().wb.active().unwrap().shapes[1].clone();
|
||||
assert_eq!((styled.text.as_str(), styled.format.italic), ("Q4", true));
|
||||
s.execute("shape.setText", json!({"id": ember.id, "text": "Q5"})).unwrap();
|
||||
s.execute("edit.undo", json!({})).unwrap();
|
||||
s.execute("edit.undo", json!({})).unwrap();
|
||||
assert_eq!(s.doc().unwrap().wb.active().unwrap().shapes[1], ember);
|
||||
s.execute("edit.redo", json!({})).unwrap();
|
||||
assert_eq!(s.doc().unwrap().wb.active().unwrap().shapes[1].text, "Q4");
|
||||
// Moves and deletes like any floating shape.
|
||||
s.execute("object.move", json!({"kind": "shape", "id": ember.id, "at": "D4"})).unwrap();
|
||||
s.execute("object.delete", json!({"kind": "shape", "id": ember.id})).unwrap();
|
||||
assert_eq!(s.doc().unwrap().wb.active().unwrap().shapes.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn word_art_rejects_hostile_params() {
|
||||
let mut s = s();
|
||||
let id = s.execute("insert.wordArt", json!({})).unwrap()["shape"].clone();
|
||||
let rectangle = s.execute("insert.shape", json!({"kind": "rectangle"})).unwrap()["shape"].clone();
|
||||
let before = s.doc().unwrap().wb.clone();
|
||||
for (cmd, params) in [
|
||||
("insert.wordArt", json!({"style": "No Such Style"})),
|
||||
("insert.wordArt", json!({"style": 99})),
|
||||
("insert.wordArt", json!({"style": -1})),
|
||||
("insert.wordArt", json!({"text": 5})),
|
||||
("insert.wordArt", json!({"text": ""})),
|
||||
("insert.wordArt", json!({"text": "x".repeat(crate::cmd::wordart::MAX_CHARS + 1)})),
|
||||
("insert.wordArt", json!({"fill": "not a colour"})),
|
||||
("wordArt.set", json!({})),
|
||||
("wordArt.set", json!({"id": 999})),
|
||||
("wordArt.set", json!({"id": rectangle})),
|
||||
("shape.setText", json!({"id": id, "text": ""})),
|
||||
] {
|
||||
assert!(matches!(s.execute(cmd, params), Err(crate::EngineError::BadParams { .. })), "{cmd}");
|
||||
assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().wb, &before));
|
||||
}
|
||||
// Absurd sizes are clamped, not trusted.
|
||||
s.execute("insert.wordArt", json!({"fontSize": 1e12, "width": 1e300, "height": -5})).unwrap();
|
||||
let big = &s.doc().unwrap().wb.active().unwrap().shapes[2];
|
||||
assert!(big.anchor.width <= 4000.0 && big.anchor.height >= 8.0 && big.format.font_size == Some(400.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn word_art_survives_xlsx_roundtrip() {
|
||||
use gridcraft_model::ShapeKind;
|
||||
let mut s = s();
|
||||
s.execute("insert.wordArt", json!({"style": "Lagoon", "text": "Sales <2026>\nOutlook & more"})).unwrap();
|
||||
let before = s.doc().unwrap().wb.active().unwrap().shapes[0].clone();
|
||||
let saved = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap();
|
||||
s.execute("file.open", json!({"name": "wordart.xlsx", "base64": saved["base64"]})).unwrap();
|
||||
let after = &s.doc().unwrap().wb.active().unwrap().shapes[0];
|
||||
assert_eq!(after.kind, ShapeKind::WordArt);
|
||||
assert_eq!(after.text, before.text);
|
||||
assert_eq!(after.format.text_color, before.format.text_color);
|
||||
assert_eq!(after.format.text_outline, before.format.text_outline);
|
||||
assert_eq!(after.format.text_shadow, before.format.text_shadow);
|
||||
assert_eq!((after.format.bold, after.format.italic, after.format.font_size), (true, true, before.format.font_size));
|
||||
assert!(after.format.no_line);
|
||||
}
|
||||
|
||||
/// White text with a green outline (Mint Outline) prints its outline, so it is not invisible on a
|
||||
/// white page.
|
||||
#[test]
|
||||
fn word_art_outline_prints() {
|
||||
let mut s = s();
|
||||
s.execute("insert.wordArt", json!({"style": "Mint Outline", "text": "VISIBLE", "at": "A1"})).unwrap();
|
||||
let pdf = s.execute("file.exportPdf", json!({"range": "A1:G10"})).unwrap();
|
||||
let data = crate::io::base64_decode(pdf["base64"].as_str().unwrap()).unwrap();
|
||||
let text = String::from_utf8_lossy(&data);
|
||||
let outline = text.matches("0.18 0.608 0.416 rg").count();
|
||||
assert!(outline >= 1, "the outline colour (2E9B6A) is drawn");
|
||||
assert_eq!(text.matches("(VISIBLE) Tj").count(), 9, "eight outline copies under the white text");
|
||||
assert!(text.contains("1 1 1 rg"), "the white fill is drawn on top");
|
||||
// The last copy drawn is the filled text, in white; every outline copy comes before it.
|
||||
let before_fill = &text[..text.rfind("(VISIBLE) Tj").unwrap()];
|
||||
assert!(before_fill.rfind("1 1 1 rg") > before_fill.rfind("0.18 0.608 0.416 rg"), "the white fill is drawn last");
|
||||
assert_eq!(before_fill.matches("(VISIBLE) Tj").count(), 8);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_border_clears_only_shared_edges_and_undo_restores_them() {
|
||||
use gridcraft_core::RangeRef;
|
||||
@@ -1509,6 +1621,44 @@ fn case_sensitive_sort_puts_lowercase_first() {
|
||||
assert_eq!(col, ["a", "A", "aB", "Ab", "b", "B"].map(Value::from));
|
||||
}
|
||||
|
||||
/// #3949: Excel sorts values that are not in the custom list A to Z after the listed ones.
|
||||
#[test]
|
||||
fn custom_list_sort_puts_unlisted_values_after_the_list_in_order() {
|
||||
let mut s = s();
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": [["Priority"], ["Zulu"], ["Alpha"], ["Low"], ["High"], ["Medium"]]})).unwrap();
|
||||
let key = json!({"column": "A", "order": "asc", "customList": ["High", "Medium", "Low"]});
|
||||
s.execute("data.sort", json!({"range": "A1:A6", "header": true, "keys": [key]})).unwrap();
|
||||
let col: Vec<Value> = (1..=6).map(|r| v(&s, &format!("A{r}"))).collect();
|
||||
assert_eq!(col, ["Priority", "High", "Medium", "Low", "Alpha", "Zulu"].map(Value::from));
|
||||
}
|
||||
|
||||
/// #3949 changes only an ascending custom-list key: with a descending one, two values not in the
|
||||
/// list still tie, so the next key orders them.
|
||||
#[test]
|
||||
fn descending_custom_list_sort_leaves_unlisted_values_to_the_next_key() {
|
||||
let mut s = s();
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": [["Name", "N"], ["Zulu", 2], ["Alpha", 1], ["High", 3]]})).unwrap();
|
||||
let keys = json!([
|
||||
{"column": "A", "order": "desc", "customList": ["High", "Medium", "Low"]},
|
||||
{"column": "B", "order": "asc"}
|
||||
]);
|
||||
s.execute("data.sort", json!({"range": "A1:B4", "header": true, "keys": keys})).unwrap();
|
||||
let col: Vec<Value> = (2..=4).map(|r| v(&s, &format!("A{r}"))).collect();
|
||||
assert_eq!(col, ["Alpha", "Zulu", "High"].map(Value::from));
|
||||
}
|
||||
|
||||
/// A blank in a descending custom-list key goes last, after the list, rather than tying with the
|
||||
/// values that are not in the list (which come first), so the order is the same whatever the input.
|
||||
#[test]
|
||||
fn descending_custom_list_sort_puts_blanks_last() {
|
||||
let mut s = s();
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": [["Name"], [null], ["High"], ["Zulu"]]})).unwrap();
|
||||
let key = json!({"column": "A", "order": "desc", "customList": ["High", "Medium", "Low"]});
|
||||
s.execute("data.sort", json!({"range": "A1:A4", "header": true, "keys": [key]})).unwrap();
|
||||
let col: Vec<Value> = (2..=4).map(|r| v(&s, &format!("A{r}"))).collect();
|
||||
assert_eq!(col, [Value::from("Zulu"), Value::from("High"), Value::Empty]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn data_sort_orders_vowelled_arabic_by_letters() {
|
||||
let mut s = s();
|
||||
@@ -1647,7 +1797,7 @@ fn subtotal_with_a_sheet_prefix_works_on_the_named_sheet() {
|
||||
assert_eq!(col(prices, 0), ["Item", "a", "a", "a Total", "b", "b Total", "Grand Total"].map(Value::from));
|
||||
assert_eq!(col(prices, 1)[1..], [1.0, 2.0, 3.0, 4.0, 4.0, 7.0].map(Value::from));
|
||||
assert!(wb.styles.get(prices.style_id(CellRef::new(3, 0))).font.bold);
|
||||
assert_eq!(prices.rows.get(&1).map(|l| l.outline), Some(1));
|
||||
assert_eq!(prices.rows.get(&1).map(|l| l.outline), Some(2));
|
||||
let sheet1 = wb.sheet(wb.sheet_index("Sheet1").unwrap()).unwrap();
|
||||
assert_eq!(col(sheet1, 0)[..4], ["Name", "x", "x", "y"].map(Value::from));
|
||||
assert!(sheet1.value(CellRef::new(4, 0)).is_empty());
|
||||
@@ -1655,6 +1805,24 @@ fn subtotal_with_a_sheet_prefix_works_on_the_named_sheet() {
|
||||
assert!(s.execute("data.group", json!({"sheet": "Prices"})).is_err());
|
||||
}
|
||||
|
||||
/// #3945: Excel groups every data and subtotal row under the grand total, so the details are at
|
||||
/// level 2, the subtotals at level 1, and showing level 1 leaves only the grand total.
|
||||
#[test]
|
||||
fn subtotal_groups_everything_under_the_grand_total() {
|
||||
let mut s = s();
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": [["Group", "Amount"], ["A", 10], ["A", 20], ["B", 30]]})).unwrap();
|
||||
s.execute("data.subtotal", json!({"range": "A1:B4", "groupBy": "A", "columns": ["B"], "function": "sum"})).unwrap();
|
||||
let sh = s.doc().unwrap().wb.active().unwrap();
|
||||
let levels: Vec<u8> = (0..7).map(|r| sh.rows.get(&r).map_or(0, |l| l.outline)).collect();
|
||||
assert_eq!(levels, [0, 2, 2, 1, 2, 1, 0]);
|
||||
let shown = |s: &Session| -> Vec<u32> { (0..7).filter(|&r| !s.doc().unwrap().wb.active().unwrap().is_row_hidden(r)).map(|r| r + 1).collect() };
|
||||
s.execute("data.showLevels", json!({"rows": 1})).unwrap();
|
||||
assert_eq!(shown(&s), [1, 7]);
|
||||
s.execute("data.showLevels", json!({"rows": 2})).unwrap();
|
||||
assert_eq!(shown(&s), [1, 4, 6, 7]);
|
||||
assert_eq!(v(&s, "B7"), Value::Number(60.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn formatting_and_styles() {
|
||||
let mut s = s();
|
||||
@@ -2289,6 +2457,35 @@ fn merging_over_a_spill_blocks_it_and_unmerging_unblocks_it() {
|
||||
assert_eq!(v(&s, "A3"), Value::Number(3.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn inserting_a_link_without_text_preserves_a_spill_child() {
|
||||
let mut s = s();
|
||||
s.execute("cell.set", json!({"cell": "A1", "input": "=SEQUENCE(3)"})).unwrap();
|
||||
assert_eq!(v(&s, "A2"), Value::Number(2.0));
|
||||
s.execute("insert.link", json!({"cell": "A2", "target": "https://example.org"})).unwrap();
|
||||
assert_eq!(v(&s, "A1"), Value::Number(1.0));
|
||||
assert_eq!(v(&s, "A2"), Value::Number(2.0));
|
||||
let d = s.doc().unwrap();
|
||||
let at = CellRef::parse("A2").unwrap();
|
||||
assert_eq!(d.wb.active().unwrap().hyperlinks.get(&at).map(|link| link.target.as_str()), Some("https://example.org"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn inserting_a_link_without_text_preserves_an_empty_spill_child() {
|
||||
let mut s = s();
|
||||
s.execute("range.setValues", json!({"range": "A1:C3", "values": [["a", "x", 1], ["b", "x", 2], ["a", "y", 3]]})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "K1", "input": "=PIVOTBY(A1:A3,B1:B3,C1:C3,LAMBDA(x,SUM(x)))"})).unwrap();
|
||||
assert_eq!(v(&s, "K1"), Value::Empty);
|
||||
let at = CellRef::parse("M3").unwrap();
|
||||
assert_eq!(v(&s, "M3"), Value::Empty);
|
||||
assert_eq!(s.doc().unwrap().wb.active().unwrap().spill_anchor(at), Some(CellRef::parse("K1").unwrap()));
|
||||
s.execute("insert.link", json!({"cell": "M3", "target": "https://example.org"})).unwrap();
|
||||
assert_eq!(v(&s, "K1"), Value::Empty);
|
||||
assert_eq!(v(&s, "M3"), Value::Empty);
|
||||
let d = s.doc().unwrap();
|
||||
assert_eq!(d.wb.active().unwrap().hyperlinks.get(&at).map(|link| link.target.as_str()), Some("https://example.org"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn multi_cell_array_formulas_and_tables_dont_overlap() {
|
||||
// Found by the command-sequence fuzzer: an array over a table header lost its value to the
|
||||
@@ -2828,6 +3025,127 @@ fn validation_formulas_are_relative_and_see_the_new_value() {
|
||||
assert!(!ok(&mut s, "C1", "50"));
|
||||
}
|
||||
|
||||
/// Every value of the active sheet as the incremental recalculation left it must equal a full one.
|
||||
fn assert_matches_full_recalc(s: &Session) {
|
||||
let wb = &s.doc().unwrap().wb;
|
||||
let mut fresh = (**wb).clone();
|
||||
gridcraft_calc::Calc::new().recalc_all(&mut fresh);
|
||||
let (a, b) = (wb.active().unwrap(), fresh.active().unwrap());
|
||||
for row in 0..30 {
|
||||
for col in 0..12 {
|
||||
let cell = CellRef { row, col };
|
||||
assert_eq!(a.value(cell), b.value(cell), "{cell} in memory vs after a full recalc");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn filling_a_formula_next_to_a_spill_matches_a_full_recalc() {
|
||||
// Found by the command-sequence fuzzer: C14 spills along row 14; filling `=D14:E18` over
|
||||
// E13:F13 puts two array formulas whose areas run into that spill and into each other. The
|
||||
// incremental pass left F13 as #SPILL! while a full recalc gave F13 its array and C14
|
||||
// #SPILL!. The spill that already exists keeps its cells (as in Excel), in both.
|
||||
let mut s = s();
|
||||
s.execute("range.setValues", json!({"range": "B18", "values": [[1], [2], [3], [4], [5], [6], [7]]})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "C14", "input": "=TRANSPOSE(B18:B24)"})).unwrap();
|
||||
s.execute("selection.set", json!({"range": "E13"})).unwrap();
|
||||
s.execute("range.fill", json!({"range": "E13:F13", "input": "=D14:E18"})).unwrap();
|
||||
assert_eq!(v(&s, "C14"), Value::Number(1.0));
|
||||
assert_eq!(v(&s, "I14"), Value::Number(7.0));
|
||||
assert_eq!(v(&s, "F13"), Value::Error(gridcraft_core::CellError::Spill));
|
||||
assert_matches_full_recalc(&s);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn overlapping_spills_keep_the_one_that_exists_whichever_anchor_is_first() {
|
||||
use gridcraft_core::CellError::Spill;
|
||||
// E10 spills along row 10, F8 down over F10: F8 is first in reading order, E10 may be first
|
||||
// to spill. Excel keeps whichever spilled first.
|
||||
for (first, second) in [(("E10", "=SEQUENCE(1,3)"), ("F8", "=SEQUENCE(5)")), (("F8", "=SEQUENCE(5)"), ("E10", "=SEQUENCE(1,3)"))] {
|
||||
let mut s = s();
|
||||
s.execute("cell.set", json!({"cell": first.0, "input": first.1})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": second.0, "input": second.1})).unwrap();
|
||||
assert_ne!(v(&s, first.0), Value::Error(Spill), "{} keeps its cells", first.0);
|
||||
assert_eq!(v(&s, second.0), Value::Error(Spill), "{} is blocked", second.0);
|
||||
assert_matches_full_recalc(&s);
|
||||
// Clearing the winner lets the other one spill.
|
||||
s.execute("edit.clearContents", json!({"range": first.0})).unwrap();
|
||||
assert_ne!(v(&s, second.0), Value::Error(Spill), "{} spills once {} is cleared", second.0, first.0);
|
||||
assert_matches_full_recalc(&s);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_spill_growing_into_another_and_back_matches_a_full_recalc_at_every_step() {
|
||||
use gridcraft_core::CellError::Spill;
|
||||
// Both arrays already spill; F8 (first in reading order) grows down over E10's spill, takes
|
||||
// its cells, shrinks back and lets it spill again, then the steps are undone, redone, edited
|
||||
// inside the contested area and cleared. Every state must match a full recalc.
|
||||
let mut s = s();
|
||||
s.execute("cell.set", json!({"cell": "H1", "input": "1"})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "F8", "input": "=SEQUENCE(H1)"})).unwrap();
|
||||
s.execute("cell.set", json!({"cell": "E10", "input": "=SEQUENCE(1,3)*10"})).unwrap();
|
||||
assert_eq!(v(&s, "G10"), Value::Number(30.0));
|
||||
assert_matches_full_recalc(&s);
|
||||
let steps: [(&str, serde_json::Value); 9] = [
|
||||
("cell.set", json!({"cell": "H1", "input": "5"})),
|
||||
("cell.set", json!({"cell": "E10", "input": "=SEQUENCE(1,2)*10"})),
|
||||
("cell.set", json!({"cell": "H1", "input": "1"})),
|
||||
("edit.undo", json!({})),
|
||||
("edit.undo", json!({})),
|
||||
("edit.redo", json!({})),
|
||||
("cell.set", json!({"cell": "F11", "input": "x"})),
|
||||
("cell.set", json!({"cell": "H1", "input": "2"})),
|
||||
("edit.clearContents", json!({"range": "E8:F10"})),
|
||||
];
|
||||
for (i, (id, params)) in steps.iter().enumerate() {
|
||||
s.execute(id, params.clone()).unwrap();
|
||||
assert_matches_full_recalc(&s);
|
||||
if i == 0 {
|
||||
// Both held a spill: reading order gives F8 the cells.
|
||||
assert_eq!(v(&s, "F12"), Value::Number(5.0));
|
||||
assert_eq!(v(&s, "E10"), Value::Error(Spill));
|
||||
}
|
||||
if i == 2 {
|
||||
assert_eq!(v(&s, "E10"), Value::Number(10.0));
|
||||
assert_eq!(v(&s, "F10"), Value::Number(20.0));
|
||||
}
|
||||
if i == 3 {
|
||||
// Undone back to the grown F8.
|
||||
assert_eq!(v(&s, "F12"), Value::Number(5.0));
|
||||
assert_eq!(v(&s, "E10"), Value::Error(Spill));
|
||||
}
|
||||
if i == 8 {
|
||||
assert_eq!((v(&s, "F8"), v(&s, "E10"), v(&s, "F9")), (Value::Empty, Value::Empty, Value::Empty));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn overlapping_spills_with_no_history_go_to_the_earlier_anchor() {
|
||||
use gridcraft_core::CellError::Spill;
|
||||
// A workbook calculated for the first time (a file that carries no layout) has no entry
|
||||
// order: the anchor first in reading order wins, whatever order the formulas were set in.
|
||||
for order in [["E10", "F8"], ["F8", "E10"]] {
|
||||
let mut s = s();
|
||||
for a in order {
|
||||
let input = if a == "E10" { "=SEQUENCE(1,3)" } else { "=SEQUENCE(5)" };
|
||||
s.execute("cell.set", json!({"cell": a, "input": input})).unwrap();
|
||||
}
|
||||
let mut fresh = (*s.doc().unwrap().wb).clone();
|
||||
for i in 0..fresh.sheets.len() {
|
||||
let sh = fresh.sheet_mut(i).unwrap();
|
||||
sh.spill.clear();
|
||||
sh.spill_ranges.clear();
|
||||
}
|
||||
gridcraft_calc::Calc::new().recalc_all(&mut fresh);
|
||||
let a = fresh.active().unwrap();
|
||||
let cell = |r: &str| a.value(CellRef::parse(r).unwrap());
|
||||
assert_ne!(cell("F8"), Value::Error(Spill), "order {order:?}");
|
||||
assert_eq!(cell("E10"), Value::Error(Spill), "order {order:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn multi_area_rule_formulas_are_relative_to_the_top_left_cell_of_all_areas() {
|
||||
// Issue #3152: Excel writes the formula for the top-left cell of all the areas (H26), whatever
|
||||
@@ -3612,6 +3930,8 @@ fn xls_fixture() -> Vec<u8> {
|
||||
let mut put = |at: usize, v: &[u8]| b[at..at + v.len()].copy_from_slice(v);
|
||||
put(0, &[0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1]);
|
||||
put(26, &3u16.to_le_bytes());
|
||||
// The byte order mark [MS-CFB] 2.2 requires; craft-cfb refuses a header without it.
|
||||
put(28, &0xFFFEu16.to_le_bytes());
|
||||
put(30, &9u16.to_le_bytes());
|
||||
put(32, &6u16.to_le_bytes());
|
||||
put(44, &1u32.to_le_bytes());
|
||||
@@ -5516,6 +5836,53 @@ fn tiled_paste_clears_destination_cells_under_blank_source_cells() {
|
||||
assert_eq!(v(&s, "C4"), Value::Empty);
|
||||
}
|
||||
|
||||
/// #3934: a row copied into a taller, narrower selection repeats down every selected row at the
|
||||
/// copy's width, as in Excel; a column copied into a wider, shorter one repeats across.
|
||||
#[test]
|
||||
fn paste_into_a_narrower_selection_repeats_the_copy_down_its_rows() {
|
||||
for dest in ["A3:A6", "A3:B6"] {
|
||||
let mut s = s();
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": [[1, 2]]})).unwrap();
|
||||
s.execute("edit.copy", json!({"range": "A1:B1"})).unwrap();
|
||||
s.execute("selection.set", json!({"range": dest})).unwrap();
|
||||
let r = s.execute("edit.paste", json!({})).unwrap();
|
||||
assert_eq!(r["pasted"], json!("A3:B6"), "{dest}");
|
||||
for row in 3..=6 {
|
||||
assert_eq!(v(&s, &format!("A{row}")), Value::Number(1.0), "{dest} row {row}");
|
||||
assert_eq!(v(&s, &format!("B{row}")), Value::Number(2.0), "{dest} row {row}");
|
||||
}
|
||||
assert_eq!(v(&s, "A2"), Value::Empty);
|
||||
assert_eq!(v(&s, "A7"), Value::Empty);
|
||||
}
|
||||
let mut s = s();
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": [[1], [2]]})).unwrap();
|
||||
s.execute("edit.copy", json!({"range": "A1:A2"})).unwrap();
|
||||
s.execute("selection.set", json!({"range": "C1:F1"})).unwrap();
|
||||
let r = s.execute("edit.paste", json!({})).unwrap();
|
||||
assert_eq!(r["pasted"], json!("C1:F2"));
|
||||
for col in ["C", "D", "E", "F"] {
|
||||
assert_eq!(v(&s, &format!("{col}1")), Value::Number(1.0), "{col}1");
|
||||
assert_eq!(v(&s, &format!("{col}2")), Value::Number(2.0), "{col}2");
|
||||
}
|
||||
}
|
||||
|
||||
/// #3934: repeating a wide copy down a narrow selection writes the copy's width on every row, so
|
||||
/// the 4,000,000-cell limit on a tiled paste counts that area, not the selection's. Past it the
|
||||
/// copy is pasted once, as a tiled paste over too large a selection already is.
|
||||
#[test]
|
||||
fn a_row_repeated_down_a_narrow_selection_is_bounded_by_the_area_it_fills() {
|
||||
let mut s = s();
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": [[1]]})).unwrap();
|
||||
s.execute("range.setValues", json!({"range": "P1", "values": [[2]]})).unwrap();
|
||||
s.execute("edit.copy", json!({"range": "A1:P1"})).unwrap();
|
||||
// 300,000 rows selected, 4,800,000 cells once the copy's 16 columns are repeated down them.
|
||||
s.execute("selection.set", json!({"range": "A3:A300002"})).unwrap();
|
||||
let r = s.execute("edit.paste", json!({})).unwrap();
|
||||
assert_eq!(r["pasted"], json!("A3:P3"));
|
||||
assert_eq!(v(&s, "P3"), Value::Number(2.0));
|
||||
assert_eq!(v(&s, "A4"), Value::Empty);
|
||||
}
|
||||
|
||||
/// Excel refuses a paste that would run off the sheet rather than pasting part of it: whole
|
||||
/// columns below row 1, whole rows right of column A, a whole column transposed, or a block at
|
||||
/// the last row or column.
|
||||
@@ -6259,11 +6626,22 @@ fn a_script_cannot_switch_windows() {
|
||||
|
||||
mod controls;
|
||||
mod equation;
|
||||
mod json_golden;
|
||||
mod macros;
|
||||
mod objects;
|
||||
mod python_cells;
|
||||
mod python_commands;
|
||||
mod python_files;
|
||||
|
||||
#[test]
|
||||
fn text_to_columns_keeps_a_mid_field_quote() {
|
||||
let mut s = s();
|
||||
s.execute("cell.set", json!({"cell": "A1", "input": "'5\" pipe,abc"})).unwrap();
|
||||
s.execute("data.textToColumns", json!({"range": "A1", "delimiters": [","]})).unwrap();
|
||||
assert_eq!(v(&s, "A1"), Value::text("5\" pipe"));
|
||||
assert_eq!(v(&s, "B1"), Value::text("abc"));
|
||||
}
|
||||
|
||||
mod seams;
|
||||
|
||||
#[test]
|
||||
@@ -6480,6 +6858,19 @@ fn clearing_links_and_notes_keeps_allow_edit_ranges() {
|
||||
assert!(sh.hyperlinks.is_empty() && sh.comments.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn replace_does_not_search_hidden_formula_source() {
|
||||
let mut s = s();
|
||||
s.execute("cell.set", json!({"cell": "A1", "input": "=SEQUENCE(3)*7"})).unwrap();
|
||||
s.execute("home.formatCells", json!({"range": "A1", "style": {"protection": {"locked": true, "hidden": true}}})).unwrap();
|
||||
s.execute("review.protectSheet", json!({})).unwrap();
|
||||
// Both give the same answer, and it is not an error: a hidden formula's source is not searched.
|
||||
let hit = s.execute("edit.replace", json!({"what": "SEQUENCE", "with": "X"})).unwrap();
|
||||
let miss = s.execute("edit.replace", json!({"what": "NOSUCHTEXT", "with": "X"})).unwrap();
|
||||
assert_eq!(hit, miss);
|
||||
assert_eq!(hit["replaced"], json!(0), "{hit}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn formulatext_does_not_reveal_a_hidden_formula() {
|
||||
let mut s = s();
|
||||
@@ -6556,6 +6947,19 @@ fn pivot_new_sheet_destination_respects_workbook_structure_protection() {
|
||||
assert!(s.execute("insert.pivotTable", json!({"source": "A1:B3", "location": "New"})).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn circle_invalid_says_when_its_scan_allowance_ended_early() {
|
||||
let mut s = s();
|
||||
s.execute("range.setValues", json!({"range": "A1", "values": [[-1]]})).unwrap();
|
||||
s.execute("range.setValues", json!({"range": "A200000", "values": [[-1]]})).unwrap();
|
||||
s.execute("data.validation", json!({"range": "A1:A5", "type": "whole", "operator": "greater", "formula1": "0"})).unwrap();
|
||||
let out = s.execute("data.circleInvalid", json!({})).unwrap();
|
||||
assert_eq!((out["invalid"].as_array().map(Vec::len), out["truncated"].as_bool()), (Some(1), Some(false)), "{out}");
|
||||
s.execute("data.validation", json!({"range": "A1:A200000", "type": "whole", "operator": "greater", "formula1": "0"})).unwrap();
|
||||
let out = s.execute("data.circleInvalid", json!({})).unwrap();
|
||||
assert_eq!(out["truncated"].as_bool(), Some(true), "{out}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_charges_a_changed_sheets_comment_text() {
|
||||
let mut s = s();
|
||||
|
||||
@@ -0,0 +1,80 @@
|
||||
//! Byte-for-byte checks on the native JSON workbook (`.json`, `.scjson`). The files in
|
||||
//! `crates/engine/tests/golden` were written before the format moved to `craft-gridcraft-format`
|
||||
//! (storytold/craft-libs). Saving the same workbook must give the same bytes, and opening a
|
||||
//! golden file and saving it again must give it back.
|
||||
//! `GRIDCRAFT_BLESS_GOLDEN=1` rewrites them. Only do that for a deliberate format change.
|
||||
|
||||
use std::path::PathBuf;
|
||||
|
||||
use serde_json::json;
|
||||
|
||||
use super::s;
|
||||
use crate::Session;
|
||||
|
||||
fn golden(name: &str) -> PathBuf {
|
||||
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests").join("golden").join(name)
|
||||
}
|
||||
|
||||
fn check(name: &str, actual: &[u8]) {
|
||||
let path = golden(name);
|
||||
if std::env::var_os("GRIDCRAFT_BLESS_GOLDEN").is_some() {
|
||||
std::fs::write(&path, actual).unwrap_or_else(|e| panic!("{}: {e}", path.display()));
|
||||
return;
|
||||
}
|
||||
let expected = std::fs::read(&path).unwrap_or_else(|e| panic!("{}: {e}", path.display()));
|
||||
assert!(expected == actual, "{name} changed ({} bytes, golden has {})", actual.len(), expected.len());
|
||||
}
|
||||
|
||||
fn save(s: &mut Session) -> Vec<u8> {
|
||||
let r = s.execute("file.saveBytes", json!({"format": "json"})).unwrap();
|
||||
crate::io::base64_decode(r["base64"].as_str().unwrap()).unwrap()
|
||||
}
|
||||
|
||||
fn open(s: &mut Session, name: &str, bytes: &[u8]) {
|
||||
s.execute("file.open", json!({"name": name, "base64": crate::io::base64_encode(bytes)})).unwrap();
|
||||
}
|
||||
|
||||
/// A workbook with text, numbers, a formula, a style, a number format, a second sheet and a macro.
|
||||
fn book() -> Session {
|
||||
let mut s = s();
|
||||
for (cell, input) in [("A1", "Item"), ("B1", "Qty"), ("A2", "Äpfel ✓"), ("B2", "3.5"), ("A3", "Pears"), ("B3", "2"), ("B4", "=SUM(B2:B3)")] {
|
||||
s.execute("cell.set", json!({"cell": cell, "input": input})).unwrap();
|
||||
}
|
||||
s.execute("home.bold", json!({"range": "A1:B1"})).unwrap();
|
||||
s.execute("home.numberFormat", json!({"range": "B2:B4", "format": "0.00"})).unwrap();
|
||||
s.execute("macro.save", json!({"name": "Fill", "steps": [{"command": "cell.set", "params": {"cell": "C1", "input": "x"}}]})).unwrap();
|
||||
s
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_save_writes_the_golden_workbook_bytes() {
|
||||
let mut s = book();
|
||||
check("book.json", &save(&mut s));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_golden_workbook_opens_and_saves_back_unchanged() {
|
||||
let bytes = std::fs::read(golden("book.json")).unwrap();
|
||||
for name in ["book.json", "book.scjson"] {
|
||||
let mut s = s();
|
||||
open(&mut s, name, &bytes);
|
||||
assert_eq!(super::v(&s, "B4"), gridcraft_core::Value::Number(5.5), "{name}");
|
||||
assert!(save(&mut s) == bytes, "{name} saved back differently");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn macros_in_a_newer_format_are_written_back_as_the_file_held_them() {
|
||||
// The save that splices kept macros back into `macros` goes through a JSON value.
|
||||
let mut v: serde_json::Value = serde_json::from_slice(&std::fs::read(golden("book.json")).unwrap()).unwrap();
|
||||
v["macros"].as_array_mut().unwrap().push(json!({"name": "Future", "v": gridcraft_model::MACRO_VERSION + 1, "extra": [1, 2]}));
|
||||
let mut s = s();
|
||||
open(&mut s, "kept.json", &serde_json::to_vec_pretty(&v).unwrap());
|
||||
check("kept.json", &save(&mut s));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn what_is_not_a_json_workbook_says_so() {
|
||||
let err = crate::io::open_bytes("bad.json", b"{\"sheets\": 7}").unwrap_err().to_string();
|
||||
check("bad.error.txt", err.as_bytes());
|
||||
}
|
||||
@@ -175,8 +175,8 @@ fn text_to_columns_keeps_a_py_piece_as_text() {
|
||||
s.execute("cell.set", json!({"cell": "A1", "input": "'=PY(\"x\");7"})).unwrap();
|
||||
assert_eq!(super::v(&s, "A1"), Value::text("=PY(\"x\");7"));
|
||||
s.execute("data.textToColumns", json!({"range": "A1", "delimiters": [";"]})).unwrap();
|
||||
// The default text qualifier takes the quotes away, as in Excel.
|
||||
assert_eq!(super::v(&s, "A1"), Value::text("=PY(x)"), "the piece is kept, not cleared");
|
||||
// A quote in the middle of a field is kept, as in Excel.
|
||||
assert_eq!(super::v(&s, "A1"), Value::text("=PY(\"x\")"), "the piece is kept, not cleared");
|
||||
assert_eq!(code(&s, 0, "A1"), None, "and it is not a Python cell");
|
||||
assert_eq!(super::v(&s, "B1"), Value::Number(7.0));
|
||||
}
|
||||
@@ -530,3 +530,16 @@ fn python_code_with_an_empty_value_counts_as_content() {
|
||||
s.execute("edit.copy", json!({"range": "T1"})).unwrap();
|
||||
assert!(s.execute("edit.paste", json!({"at": "R2"})).is_err_and(|e| e.to_string().contains("part of an array")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn inserting_a_link_without_text_preserves_an_empty_python_cell() {
|
||||
let mut s = s();
|
||||
plant_empty(&mut s, "A1");
|
||||
s.execute("insert.link", json!({"cell": "A1", "target": "https://example.org"})).unwrap();
|
||||
assert_eq!(code(&s, 0, "A1"), Some("x = 1".into()));
|
||||
let d = s.doc().unwrap();
|
||||
let sh = d.wb.sheet(0).unwrap();
|
||||
let at = CellRef::parse("A1").unwrap();
|
||||
assert_eq!(sh.value(at), Value::Empty);
|
||||
assert_eq!(sh.hyperlinks.get(&at).map(|link| link.target.as_str()), Some("https://example.org"));
|
||||
}
|
||||
|
||||
@@ -0,0 +1,2 @@
|
||||
# Golden files are compared byte for byte: no line-ending conversion on checkout.
|
||||
* -text
|
||||
@@ -0,0 +1 @@
|
||||
not a GridCraft JSON workbook: invalid type: integer `7`, expected a sequence at line 1 column 12
|
||||
@@ -0,0 +1,440 @@
|
||||
{
|
||||
"sheets": [
|
||||
{
|
||||
"name": "Sheet1",
|
||||
"cells": {
|
||||
"bands": {
|
||||
"0": {
|
||||
"rows": {
|
||||
"0": {
|
||||
"0": {
|
||||
"value": {
|
||||
"t": "Text",
|
||||
"v": "Item"
|
||||
},
|
||||
"formula": null,
|
||||
"style": 1
|
||||
},
|
||||
"1": {
|
||||
"value": {
|
||||
"t": "Text",
|
||||
"v": "Qty"
|
||||
},
|
||||
"formula": null,
|
||||
"style": 1
|
||||
}
|
||||
},
|
||||
"1": {
|
||||
"0": {
|
||||
"value": {
|
||||
"t": "Text",
|
||||
"v": "Äpfel ✓"
|
||||
},
|
||||
"formula": null,
|
||||
"style": 0
|
||||
},
|
||||
"1": {
|
||||
"value": {
|
||||
"t": "Number",
|
||||
"v": 3.5
|
||||
},
|
||||
"formula": null,
|
||||
"style": 2
|
||||
}
|
||||
},
|
||||
"2": {
|
||||
"0": {
|
||||
"value": {
|
||||
"t": "Text",
|
||||
"v": "Pears"
|
||||
},
|
||||
"formula": null,
|
||||
"style": 0
|
||||
},
|
||||
"1": {
|
||||
"value": {
|
||||
"t": "Number",
|
||||
"v": 2.0
|
||||
},
|
||||
"formula": null,
|
||||
"style": 2
|
||||
}
|
||||
},
|
||||
"3": {
|
||||
"1": {
|
||||
"value": {
|
||||
"t": "Number",
|
||||
"v": 5.5
|
||||
},
|
||||
"formula": {
|
||||
"text": "SUM(B2:B3)",
|
||||
"array": null
|
||||
},
|
||||
"style": 2
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"len": 7
|
||||
},
|
||||
"cols": {},
|
||||
"rows": {},
|
||||
"default_col_width": 64.0,
|
||||
"default_row_height": 20.0,
|
||||
"merges": [],
|
||||
"freeze": null,
|
||||
"tab_color": null,
|
||||
"visibility": "Visible",
|
||||
"show_gridlines": true,
|
||||
"show_headings": true,
|
||||
"show_formulas": false,
|
||||
"show_zeros": true,
|
||||
"show_outline_symbols": true,
|
||||
"summary_below": true,
|
||||
"summary_right": true,
|
||||
"right_to_left": false,
|
||||
"zoom": 100,
|
||||
"cond_formats": [],
|
||||
"validations": [],
|
||||
"tables": [],
|
||||
"autofilter": null,
|
||||
"comments": {},
|
||||
"hyperlinks": {},
|
||||
"charts": [],
|
||||
"images": [],
|
||||
"shapes": [],
|
||||
"sparklines": [],
|
||||
"slicers": [],
|
||||
"pivots": [],
|
||||
"protection": null,
|
||||
"print": {
|
||||
"orientation": "Portrait",
|
||||
"paper": "Letter",
|
||||
"margins": [
|
||||
0.7,
|
||||
0.7,
|
||||
0.75,
|
||||
0.75,
|
||||
0.3,
|
||||
0.3
|
||||
],
|
||||
"print_area": null,
|
||||
"title_rows": null,
|
||||
"title_cols": null,
|
||||
"scale": 100,
|
||||
"fit_to": null,
|
||||
"gridlines": false,
|
||||
"headings": false,
|
||||
"center_h": false,
|
||||
"center_v": false,
|
||||
"header": "",
|
||||
"footer": "",
|
||||
"row_breaks": [],
|
||||
"col_breaks": [],
|
||||
"different_first": false,
|
||||
"different_odd_even": false,
|
||||
"first_header": "",
|
||||
"first_footer": "",
|
||||
"even_header": "",
|
||||
"even_footer": "",
|
||||
"hf_scale_with_doc": true,
|
||||
"hf_align_with_margins": true,
|
||||
"page_order": "downThenOver"
|
||||
},
|
||||
"view_active": {
|
||||
"row": 0,
|
||||
"col": 0
|
||||
},
|
||||
"view_top_left": {
|
||||
"row": 0,
|
||||
"col": 0
|
||||
},
|
||||
"view": "normal"
|
||||
}
|
||||
],
|
||||
"names": [],
|
||||
"styles": {
|
||||
"styles": [
|
||||
{
|
||||
"font": {
|
||||
"name": "Calibri",
|
||||
"size": 11.0,
|
||||
"bold": false,
|
||||
"italic": false,
|
||||
"underline": "None",
|
||||
"strike": false,
|
||||
"color": "Auto",
|
||||
"vert": "Baseline",
|
||||
"charset": null,
|
||||
"family": null,
|
||||
"minor": true
|
||||
},
|
||||
"fill": {
|
||||
"pattern": "None",
|
||||
"fg": "Auto",
|
||||
"bg": "Auto"
|
||||
},
|
||||
"borders": {
|
||||
"left": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
},
|
||||
"right": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
},
|
||||
"top": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
},
|
||||
"bottom": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
},
|
||||
"diag_down": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
},
|
||||
"diag_up": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
}
|
||||
},
|
||||
"align": {
|
||||
"h": "General",
|
||||
"v": "Bottom",
|
||||
"wrap": false,
|
||||
"shrink": false,
|
||||
"indent": 0,
|
||||
"rotation": 0,
|
||||
"reading_order": null
|
||||
},
|
||||
"num_fmt": "General",
|
||||
"protection": {
|
||||
"locked": true,
|
||||
"hidden": false
|
||||
},
|
||||
"dxf_stated": {
|
||||
"bold": false,
|
||||
"italic": false,
|
||||
"strike": false,
|
||||
"underline": false,
|
||||
"size": false,
|
||||
"name": false,
|
||||
"scheme": null,
|
||||
"protection": false
|
||||
}
|
||||
},
|
||||
{
|
||||
"font": {
|
||||
"name": "Calibri",
|
||||
"size": 11.0,
|
||||
"bold": true,
|
||||
"italic": false,
|
||||
"underline": "None",
|
||||
"strike": false,
|
||||
"color": "Auto",
|
||||
"vert": "Baseline",
|
||||
"charset": null,
|
||||
"family": null,
|
||||
"minor": true
|
||||
},
|
||||
"fill": {
|
||||
"pattern": "None",
|
||||
"fg": "Auto",
|
||||
"bg": "Auto"
|
||||
},
|
||||
"borders": {
|
||||
"left": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
},
|
||||
"right": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
},
|
||||
"top": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
},
|
||||
"bottom": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
},
|
||||
"diag_down": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
},
|
||||
"diag_up": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
}
|
||||
},
|
||||
"align": {
|
||||
"h": "General",
|
||||
"v": "Bottom",
|
||||
"wrap": false,
|
||||
"shrink": false,
|
||||
"indent": 0,
|
||||
"rotation": 0,
|
||||
"reading_order": null
|
||||
},
|
||||
"num_fmt": "General",
|
||||
"protection": {
|
||||
"locked": true,
|
||||
"hidden": false
|
||||
},
|
||||
"dxf_stated": {
|
||||
"bold": false,
|
||||
"italic": false,
|
||||
"strike": false,
|
||||
"underline": false,
|
||||
"size": false,
|
||||
"name": false,
|
||||
"scheme": null,
|
||||
"protection": false
|
||||
}
|
||||
},
|
||||
{
|
||||
"font": {
|
||||
"name": "Calibri",
|
||||
"size": 11.0,
|
||||
"bold": false,
|
||||
"italic": false,
|
||||
"underline": "None",
|
||||
"strike": false,
|
||||
"color": "Auto",
|
||||
"vert": "Baseline",
|
||||
"charset": null,
|
||||
"family": null,
|
||||
"minor": true
|
||||
},
|
||||
"fill": {
|
||||
"pattern": "None",
|
||||
"fg": "Auto",
|
||||
"bg": "Auto"
|
||||
},
|
||||
"borders": {
|
||||
"left": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
},
|
||||
"right": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
},
|
||||
"top": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
},
|
||||
"bottom": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
},
|
||||
"diag_down": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
},
|
||||
"diag_up": {
|
||||
"style": "None",
|
||||
"color": "Auto"
|
||||
}
|
||||
},
|
||||
"align": {
|
||||
"h": "General",
|
||||
"v": "Bottom",
|
||||
"wrap": false,
|
||||
"shrink": false,
|
||||
"indent": 0,
|
||||
"rotation": 0,
|
||||
"reading_order": null
|
||||
},
|
||||
"num_fmt": "0.00",
|
||||
"protection": {
|
||||
"locked": true,
|
||||
"hidden": false
|
||||
},
|
||||
"dxf_stated": {
|
||||
"bold": false,
|
||||
"italic": false,
|
||||
"strike": false,
|
||||
"underline": false,
|
||||
"size": false,
|
||||
"name": false,
|
||||
"scheme": null,
|
||||
"protection": false
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"theme": {
|
||||
"name": "Craft",
|
||||
"colors": [
|
||||
16777215,
|
||||
0,
|
||||
15263976,
|
||||
927809,
|
||||
1400962,
|
||||
15298866,
|
||||
1665828,
|
||||
1023701,
|
||||
10496915,
|
||||
5154606,
|
||||
4618374,
|
||||
9855101
|
||||
],
|
||||
"major_font": "Calibri",
|
||||
"minor_font": "Calibri",
|
||||
"major_font_ea": "",
|
||||
"minor_font_ea": "",
|
||||
"major_font_cs": "",
|
||||
"minor_font_cs": "",
|
||||
"major_font_scripts": [],
|
||||
"minor_font_scripts": []
|
||||
},
|
||||
"date_system": "D1900",
|
||||
"calc": {
|
||||
"mode": "Automatic",
|
||||
"iterative": false,
|
||||
"max_iterations": 100,
|
||||
"max_change": 0.001,
|
||||
"precision_as_displayed": false,
|
||||
"r1c1": false
|
||||
},
|
||||
"active_sheet": 0,
|
||||
"props": {
|
||||
"title": "",
|
||||
"subject": "",
|
||||
"author": "GridCraft User",
|
||||
"company": "",
|
||||
"keywords": "",
|
||||
"description": ""
|
||||
},
|
||||
"protected_structure": false,
|
||||
"custom_lists": [],
|
||||
"cell_styles": [],
|
||||
"vba_project": null,
|
||||
"macros": [
|
||||
{
|
||||
"v": 1,
|
||||
"name": "Fill",
|
||||
"description": "",
|
||||
"inputs": [],
|
||||
"steps": [
|
||||
{
|
||||
"type": "command",
|
||||
"id": "cell.set",
|
||||
"params": {
|
||||
"cell": "C1",
|
||||
"input": "x"
|
||||
}
|
||||
}
|
||||
],
|
||||
"output": {
|
||||
"onConflict": "ask"
|
||||
},
|
||||
"permissions": []
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,448 @@
|
||||
{
|
||||
"active_sheet": 0,
|
||||
"calc": {
|
||||
"iterative": false,
|
||||
"max_change": 0.001,
|
||||
"max_iterations": 100,
|
||||
"mode": "Automatic",
|
||||
"precision_as_displayed": false,
|
||||
"r1c1": false
|
||||
},
|
||||
"cell_styles": [],
|
||||
"custom_lists": [],
|
||||
"date_system": "D1900",
|
||||
"macros": [
|
||||
{
|
||||
"description": "",
|
||||
"inputs": [],
|
||||
"name": "Fill",
|
||||
"output": {
|
||||
"onConflict": "ask"
|
||||
},
|
||||
"permissions": [],
|
||||
"steps": [
|
||||
{
|
||||
"id": "cell.set",
|
||||
"params": {
|
||||
"cell": "C1",
|
||||
"input": "x"
|
||||
},
|
||||
"type": "command"
|
||||
}
|
||||
],
|
||||
"v": 1
|
||||
},
|
||||
{
|
||||
"extra": [
|
||||
1,
|
||||
2
|
||||
],
|
||||
"name": "Future",
|
||||
"v": 2
|
||||
}
|
||||
],
|
||||
"names": [],
|
||||
"props": {
|
||||
"author": "GridCraft User",
|
||||
"company": "",
|
||||
"description": "",
|
||||
"keywords": "",
|
||||
"subject": "",
|
||||
"title": ""
|
||||
},
|
||||
"protected_structure": false,
|
||||
"sheets": [
|
||||
{
|
||||
"autofilter": null,
|
||||
"cells": {
|
||||
"bands": {
|
||||
"0": {
|
||||
"rows": {
|
||||
"0": {
|
||||
"0": {
|
||||
"formula": null,
|
||||
"style": 1,
|
||||
"value": {
|
||||
"t": "Text",
|
||||
"v": "Item"
|
||||
}
|
||||
},
|
||||
"1": {
|
||||
"formula": null,
|
||||
"style": 1,
|
||||
"value": {
|
||||
"t": "Text",
|
||||
"v": "Qty"
|
||||
}
|
||||
}
|
||||
},
|
||||
"1": {
|
||||
"0": {
|
||||
"formula": null,
|
||||
"style": 0,
|
||||
"value": {
|
||||
"t": "Text",
|
||||
"v": "Äpfel ✓"
|
||||
}
|
||||
},
|
||||
"1": {
|
||||
"formula": null,
|
||||
"style": 2,
|
||||
"value": {
|
||||
"t": "Number",
|
||||
"v": 3.5
|
||||
}
|
||||
}
|
||||
},
|
||||
"2": {
|
||||
"0": {
|
||||
"formula": null,
|
||||
"style": 0,
|
||||
"value": {
|
||||
"t": "Text",
|
||||
"v": "Pears"
|
||||
}
|
||||
},
|
||||
"1": {
|
||||
"formula": null,
|
||||
"style": 2,
|
||||
"value": {
|
||||
"t": "Number",
|
||||
"v": 2.0
|
||||
}
|
||||
}
|
||||
},
|
||||
"3": {
|
||||
"1": {
|
||||
"formula": {
|
||||
"array": null,
|
||||
"text": "SUM(B2:B3)"
|
||||
},
|
||||
"style": 2,
|
||||
"value": {
|
||||
"t": "Number",
|
||||
"v": 5.5
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"len": 7
|
||||
},
|
||||
"charts": [],
|
||||
"cols": {},
|
||||
"comments": {},
|
||||
"cond_formats": [],
|
||||
"default_col_width": 64.0,
|
||||
"default_row_height": 20.0,
|
||||
"freeze": null,
|
||||
"hyperlinks": {},
|
||||
"images": [],
|
||||
"merges": [],
|
||||
"name": "Sheet1",
|
||||
"pivots": [],
|
||||
"print": {
|
||||
"center_h": false,
|
||||
"center_v": false,
|
||||
"col_breaks": [],
|
||||
"different_first": false,
|
||||
"different_odd_even": false,
|
||||
"even_footer": "",
|
||||
"even_header": "",
|
||||
"first_footer": "",
|
||||
"first_header": "",
|
||||
"fit_to": null,
|
||||
"footer": "",
|
||||
"gridlines": false,
|
||||
"header": "",
|
||||
"headings": false,
|
||||
"hf_align_with_margins": true,
|
||||
"hf_scale_with_doc": true,
|
||||
"margins": [
|
||||
0.699999988079071,
|
||||
0.699999988079071,
|
||||
0.75,
|
||||
0.75,
|
||||
0.30000001192092896,
|
||||
0.30000001192092896
|
||||
],
|
||||
"orientation": "Portrait",
|
||||
"page_order": "downThenOver",
|
||||
"paper": "Letter",
|
||||
"print_area": null,
|
||||
"row_breaks": [],
|
||||
"scale": 100,
|
||||
"title_cols": null,
|
||||
"title_rows": null
|
||||
},
|
||||
"protection": null,
|
||||
"right_to_left": false,
|
||||
"rows": {},
|
||||
"shapes": [],
|
||||
"show_formulas": false,
|
||||
"show_gridlines": true,
|
||||
"show_headings": true,
|
||||
"show_outline_symbols": true,
|
||||
"show_zeros": true,
|
||||
"slicers": [],
|
||||
"sparklines": [],
|
||||
"summary_below": true,
|
||||
"summary_right": true,
|
||||
"tab_color": null,
|
||||
"tables": [],
|
||||
"validations": [],
|
||||
"view": "normal",
|
||||
"view_active": {
|
||||
"col": 0,
|
||||
"row": 0
|
||||
},
|
||||
"view_top_left": {
|
||||
"col": 0,
|
||||
"row": 0
|
||||
},
|
||||
"visibility": "Visible",
|
||||
"zoom": 100
|
||||
}
|
||||
],
|
||||
"styles": {
|
||||
"styles": [
|
||||
{
|
||||
"align": {
|
||||
"h": "General",
|
||||
"indent": 0,
|
||||
"reading_order": null,
|
||||
"rotation": 0,
|
||||
"shrink": false,
|
||||
"v": "Bottom",
|
||||
"wrap": false
|
||||
},
|
||||
"borders": {
|
||||
"bottom": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
},
|
||||
"diag_down": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
},
|
||||
"diag_up": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
},
|
||||
"left": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
},
|
||||
"right": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
},
|
||||
"top": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
}
|
||||
},
|
||||
"dxf_stated": {
|
||||
"bold": false,
|
||||
"italic": false,
|
||||
"name": false,
|
||||
"protection": false,
|
||||
"scheme": null,
|
||||
"size": false,
|
||||
"strike": false,
|
||||
"underline": false
|
||||
},
|
||||
"fill": {
|
||||
"bg": "Auto",
|
||||
"fg": "Auto",
|
||||
"pattern": "None"
|
||||
},
|
||||
"font": {
|
||||
"bold": false,
|
||||
"charset": null,
|
||||
"color": "Auto",
|
||||
"family": null,
|
||||
"italic": false,
|
||||
"minor": true,
|
||||
"name": "Calibri",
|
||||
"size": 11.0,
|
||||
"strike": false,
|
||||
"underline": "None",
|
||||
"vert": "Baseline"
|
||||
},
|
||||
"num_fmt": "General",
|
||||
"protection": {
|
||||
"hidden": false,
|
||||
"locked": true
|
||||
}
|
||||
},
|
||||
{
|
||||
"align": {
|
||||
"h": "General",
|
||||
"indent": 0,
|
||||
"reading_order": null,
|
||||
"rotation": 0,
|
||||
"shrink": false,
|
||||
"v": "Bottom",
|
||||
"wrap": false
|
||||
},
|
||||
"borders": {
|
||||
"bottom": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
},
|
||||
"diag_down": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
},
|
||||
"diag_up": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
},
|
||||
"left": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
},
|
||||
"right": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
},
|
||||
"top": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
}
|
||||
},
|
||||
"dxf_stated": {
|
||||
"bold": false,
|
||||
"italic": false,
|
||||
"name": false,
|
||||
"protection": false,
|
||||
"scheme": null,
|
||||
"size": false,
|
||||
"strike": false,
|
||||
"underline": false
|
||||
},
|
||||
"fill": {
|
||||
"bg": "Auto",
|
||||
"fg": "Auto",
|
||||
"pattern": "None"
|
||||
},
|
||||
"font": {
|
||||
"bold": true,
|
||||
"charset": null,
|
||||
"color": "Auto",
|
||||
"family": null,
|
||||
"italic": false,
|
||||
"minor": true,
|
||||
"name": "Calibri",
|
||||
"size": 11.0,
|
||||
"strike": false,
|
||||
"underline": "None",
|
||||
"vert": "Baseline"
|
||||
},
|
||||
"num_fmt": "General",
|
||||
"protection": {
|
||||
"hidden": false,
|
||||
"locked": true
|
||||
}
|
||||
},
|
||||
{
|
||||
"align": {
|
||||
"h": "General",
|
||||
"indent": 0,
|
||||
"reading_order": null,
|
||||
"rotation": 0,
|
||||
"shrink": false,
|
||||
"v": "Bottom",
|
||||
"wrap": false
|
||||
},
|
||||
"borders": {
|
||||
"bottom": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
},
|
||||
"diag_down": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
},
|
||||
"diag_up": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
},
|
||||
"left": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
},
|
||||
"right": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
},
|
||||
"top": {
|
||||
"color": "Auto",
|
||||
"style": "None"
|
||||
}
|
||||
},
|
||||
"dxf_stated": {
|
||||
"bold": false,
|
||||
"italic": false,
|
||||
"name": false,
|
||||
"protection": false,
|
||||
"scheme": null,
|
||||
"size": false,
|
||||
"strike": false,
|
||||
"underline": false
|
||||
},
|
||||
"fill": {
|
||||
"bg": "Auto",
|
||||
"fg": "Auto",
|
||||
"pattern": "None"
|
||||
},
|
||||
"font": {
|
||||
"bold": false,
|
||||
"charset": null,
|
||||
"color": "Auto",
|
||||
"family": null,
|
||||
"italic": false,
|
||||
"minor": true,
|
||||
"name": "Calibri",
|
||||
"size": 11.0,
|
||||
"strike": false,
|
||||
"underline": "None",
|
||||
"vert": "Baseline"
|
||||
},
|
||||
"num_fmt": "0.00",
|
||||
"protection": {
|
||||
"hidden": false,
|
||||
"locked": true
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"theme": {
|
||||
"colors": [
|
||||
16777215,
|
||||
0,
|
||||
15263976,
|
||||
927809,
|
||||
1400962,
|
||||
15298866,
|
||||
1665828,
|
||||
1023701,
|
||||
10496915,
|
||||
5154606,
|
||||
4618374,
|
||||
9855101
|
||||
],
|
||||
"major_font": "Calibri",
|
||||
"major_font_cs": "",
|
||||
"major_font_ea": "",
|
||||
"major_font_scripts": [],
|
||||
"minor_font": "Calibri",
|
||||
"minor_font_cs": "",
|
||||
"minor_font_ea": "",
|
||||
"minor_font_scripts": [],
|
||||
"name": "Craft"
|
||||
},
|
||||
"vba_project": null
|
||||
}
|
||||
@@ -18,6 +18,7 @@ mod hidden_sheet_navigation;
|
||||
mod ink_roundtrip;
|
||||
mod line_count_overflow;
|
||||
mod long_operator_chains;
|
||||
mod merged_selection_keys;
|
||||
mod offset_overflow;
|
||||
mod percent_entry;
|
||||
mod pivot_unknown_func;
|
||||
|
||||
@@ -0,0 +1,162 @@
|
||||
//! Shift+arrows and Enter/Tab on merged cells, as Excel does them.
|
||||
|
||||
use gridcraft_engine::Session;
|
||||
use serde_json::json;
|
||||
|
||||
/// A new workbook with B2:C3 merged and nothing selected but A1.
|
||||
fn merged_book() -> Session {
|
||||
let mut s = Session::new();
|
||||
s.new_workbook();
|
||||
s.execute("selection.set", json!({"range": "B2:C3"})).unwrap();
|
||||
s.execute("home.mergeCells", json!({})).unwrap();
|
||||
s.execute("selection.set", json!({"cell": "A1"})).unwrap();
|
||||
s
|
||||
}
|
||||
|
||||
fn shift(s: &mut Session, dr: i64, dc: i64) -> String {
|
||||
s.execute("selection.move", json!({"dr": dr, "dc": dc, "extend": true})).unwrap();
|
||||
s.doc().unwrap().selection.a1()
|
||||
}
|
||||
|
||||
fn enter(s: &mut Session, forward: bool, by_row: bool) -> (String, String) {
|
||||
s.execute("selection.next", json!({"forward": forward, "byRow": by_row})).unwrap();
|
||||
let sel = &s.doc().unwrap().selection;
|
||||
(sel.active.a1(), sel.a1())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shift_arrows_from_a_merged_cell_widen_past_each_edge() {
|
||||
let mut s = merged_book();
|
||||
for ((dr, dc), want) in [((0, -1), "A2:C3"), ((-1, 0), "B1:C3"), ((0, 1), "B2:D3"), ((1, 0), "B2:C4")] {
|
||||
s.execute("selection.set", json!({"cell": "B2"})).unwrap();
|
||||
assert_eq!(s.doc().unwrap().selection.a1(), "B2:C3");
|
||||
assert_eq!(shift(&mut s, dr, dc), want, "Shift+({dr},{dc}) from the merged cell B2:C3");
|
||||
assert_eq!(s.doc().unwrap().selection.active.a1(), "B2", "the active cell stays");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shift_arrows_keep_going_and_come_back_to_the_merged_cell() {
|
||||
let mut s = merged_book();
|
||||
s.execute("selection.set", json!({"cell": "B2"})).unwrap();
|
||||
assert_eq!(shift(&mut s, 1, 0), "B2:C4");
|
||||
assert_eq!(shift(&mut s, 1, 0), "B2:C5");
|
||||
assert_eq!(shift(&mut s, 1, 0), "B2:C6");
|
||||
assert_eq!(shift(&mut s, -1, 0), "B2:C5");
|
||||
s.execute("selection.set", json!({"cell": "B2"})).unwrap();
|
||||
assert_eq!(shift(&mut s, 0, -1), "A2:C3");
|
||||
assert_eq!(shift(&mut s, 0, 1), "B2:C3", "back to just the merged cell");
|
||||
assert_eq!(shift(&mut s, 0, 1), "B2:D3");
|
||||
assert_eq!(shift(&mut s, -1, 0), "B1:D3");
|
||||
assert_eq!(shift(&mut s, 1, 0), "B2:D3");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shift_arrows_shrink_past_a_merged_cell_they_pulled_in() {
|
||||
let mut s = merged_book();
|
||||
assert_eq!(shift(&mut s, 0, 1), "A1:B1");
|
||||
assert_eq!(shift(&mut s, 1, 0), "A1:C3", "B2 pulls in the whole merged cell");
|
||||
assert_eq!(shift(&mut s, 0, -1), "A1:A3", "one step back leaves the merged cell out");
|
||||
assert_eq!(shift(&mut s, 0, 1), "A1:C3");
|
||||
assert_eq!(shift(&mut s, -1, 0), "A1:C1");
|
||||
assert_eq!(shift(&mut s, 1, 0), "A1:C3");
|
||||
assert_eq!(shift(&mut s, 1, 0), "A1:C4");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn enter_and_tab_leave_a_selected_merged_cell() {
|
||||
let mut s = merged_book();
|
||||
for (forward, by_row, want) in [(true, false, "B4"), (false, false, "B1"), (true, true, "D2"), (false, true, "A2")] {
|
||||
s.execute("selection.set", json!({"cell": "B2"})).unwrap();
|
||||
assert_eq!(enter(&mut s, forward, by_row), (want.to_string(), want.to_string()), "forward {forward} byRow {by_row}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn enter_and_tab_out_of_a_merged_cell_step_over_hidden_lines() {
|
||||
let mut s = merged_book();
|
||||
s.execute("selection.set", json!({"range": "A4"})).unwrap();
|
||||
s.execute("home.hideRows", json!({})).unwrap();
|
||||
s.execute("selection.set", json!({"range": "D1"})).unwrap();
|
||||
s.execute("home.hideColumns", json!({})).unwrap();
|
||||
s.execute("selection.set", json!({"cell": "B2"})).unwrap();
|
||||
assert_eq!(enter(&mut s, true, false).0, "B5", "row 4 is hidden");
|
||||
s.execute("selection.set", json!({"cell": "B2"})).unwrap();
|
||||
assert_eq!(enter(&mut s, true, true).0, "E2", "column D is hidden");
|
||||
s.execute("selection.set", json!({"cell": "B2"})).unwrap();
|
||||
s.execute("selection.move", json!({"dr": 1})).unwrap();
|
||||
assert_eq!(s.doc().unwrap().selection.a1(), "B5", "the Down arrow too");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn enter_inside_a_selection_visits_a_merged_cell_once() {
|
||||
let mut s = merged_book();
|
||||
s.execute("selection.set", json!({"range": "A1:C3", "active": "A1"})).unwrap();
|
||||
let seen: Vec<String> = (0..6).map(|_| enter(&mut s, true, false).0).collect();
|
||||
assert_eq!(seen, ["A2", "A3", "B1", "B2", "C1", "A1"]);
|
||||
assert_eq!(s.doc().unwrap().selection.a1(), "A1:C3", "the selection stays");
|
||||
let back: Vec<String> = (0..2).map(|_| enter(&mut s, false, false).0).collect();
|
||||
assert_eq!(back, ["C1", "B2"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shift_arrow_that_cannot_shrink_the_area_grows_it() {
|
||||
// A2:B3 merged, anchor B1: Shift+Down pulls the area out to column A, past the anchor.
|
||||
// Shift+Right can't shrink it from the left (the merged cell would come back), so it grows.
|
||||
let mut s = Session::new();
|
||||
s.new_workbook();
|
||||
s.execute("selection.set", json!({"range": "A2:B3"})).unwrap();
|
||||
s.execute("home.mergeCells", json!({})).unwrap();
|
||||
s.execute("selection.set", json!({"cell": "B1"})).unwrap();
|
||||
assert_eq!(shift(&mut s, 1, 0), "A1:B3");
|
||||
assert_eq!(shift(&mut s, 0, 1), "A1:C3");
|
||||
assert_eq!(s.doc().unwrap().selection.active.a1(), "B1");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shift_left_shrinks_past_a_chain_of_merged_cells_in_one_step() {
|
||||
// B2:C3 and D3:E4 are both inside A1:E4. Shift+Left from E can't stop in column D (D3:E4
|
||||
// would come back) and stops in C, where B2:C3 is whole.
|
||||
let mut s = merged_book();
|
||||
s.execute("selection.set", json!({"range": "D3:E4"})).unwrap();
|
||||
s.execute("home.mergeCells", json!({})).unwrap();
|
||||
s.execute("selection.set", json!({"cell": "A1"})).unwrap();
|
||||
assert_eq!(shift(&mut s, 3, 4), "A1:E4");
|
||||
assert_eq!(shift(&mut s, 0, -1), "A1:C4");
|
||||
assert_eq!(shift(&mut s, -1, 0), "A1:C3", "row 4 holds nothing merged once column D is out");
|
||||
assert_eq!(shift(&mut s, 0, -1), "A1:A3", "C can't stop inside B2:C3");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shift_up_over_a_tall_merged_cell_takes_one_step() {
|
||||
let mut s = Session::new();
|
||||
s.new_workbook();
|
||||
s.execute("selection.set", json!({"range": "B2:C500000"})).unwrap();
|
||||
s.execute("home.mergeCells", json!({})).unwrap();
|
||||
s.execute("selection.set", json!({"cell": "A1"})).unwrap();
|
||||
assert_eq!(shift(&mut s, 0, 1), "A1:B1");
|
||||
assert_eq!(shift(&mut s, 1, 0), "A1:C500000");
|
||||
assert_eq!(shift(&mut s, -1, 0), "A1:C1", "row 1 is the last row above the merged cell");
|
||||
assert_eq!(shift(&mut s, 1, 0), "A1:C500000");
|
||||
assert_eq!(shift(&mut s, 0, -1), "A1:A500000");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shift_arrows_change_only_the_last_area() {
|
||||
let mut s = merged_book();
|
||||
s.execute("selection.set", json!({"range": "E5:F6,B2"})).unwrap();
|
||||
assert_eq!(s.doc().unwrap().selection.a1(), "E5:F6,B2:C3");
|
||||
assert_eq!(shift(&mut s, 0, -1), "E5:F6,A2:C3");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn enter_skips_a_merged_cell_whose_start_is_outside_the_selection() {
|
||||
// A whole column isn't widened to the merged cells it touches. B1 is covered by A1:B1, whose
|
||||
// top-left cell is outside column B, so Enter skips it.
|
||||
let mut s = Session::new();
|
||||
s.new_workbook();
|
||||
s.execute("selection.set", json!({"range": "A1:B1"})).unwrap();
|
||||
s.execute("home.mergeCells", json!({})).unwrap();
|
||||
s.execute("selection.set", json!({"range": "B:B", "active": "B2"})).unwrap();
|
||||
assert_eq!(enter(&mut s, false, false).0, "B1048576", "B1 is skipped, going up wraps to the bottom");
|
||||
}
|
||||
@@ -215,7 +215,9 @@ impl Expr {
|
||||
/// Visits every node depth-first, parents before children, left to right.
|
||||
pub fn walk<'a>(&'a self, f: &mut dyn FnMut(&'a Expr)) {
|
||||
// An explicit stack: a long operator chain must not recurse once per operand.
|
||||
let mut pending = vec![self];
|
||||
// Room for a typical formula up front, so walking one costs one allocation, not several.
|
||||
let mut pending = Vec::with_capacity(8);
|
||||
pending.push(self);
|
||||
while let Some(e) = pending.pop() {
|
||||
f(e);
|
||||
match e {
|
||||
@@ -236,6 +238,19 @@ impl Expr {
|
||||
}
|
||||
/// Rewrites every node bottom-up, children left to right before their parent.
|
||||
pub fn map(self, f: &mut dyn FnMut(Expr) -> Expr) -> Expr {
|
||||
// One operator on a non-chain operand (`A1*2`), the common case, needs no spine: rewrite
|
||||
// the operands in their boxes.
|
||||
if let Expr::Binary(op, mut a, mut b) = self {
|
||||
if !matches!(*a, Expr::Binary(..)) {
|
||||
*a = std::mem::replace(&mut *a, Expr::Missing).map(f);
|
||||
*b = std::mem::replace(&mut *b, Expr::Missing).map(f);
|
||||
return f(Expr::Binary(op, a, b));
|
||||
}
|
||||
return Expr::Binary(op, a, b).map_chain(f);
|
||||
}
|
||||
self.map_chain(f)
|
||||
}
|
||||
fn map_chain(self, f: &mut dyn FnMut(Expr) -> Expr) -> Expr {
|
||||
// Unwind the left spine of a long operator chain into a list, then rebuild it from the
|
||||
// innermost operand outwards, in the order a recursive rewrite would visit the nodes.
|
||||
let mut spine = Vec::new();
|
||||
@@ -283,6 +298,12 @@ impl Expr {
|
||||
|
||||
impl Clone for Expr {
|
||||
fn clone(&self) -> Self {
|
||||
// One operator on a non-chain operand needs no spine.
|
||||
if let Expr::Binary(op, a, b) = self
|
||||
&& !matches!(**a, Expr::Binary(..))
|
||||
{
|
||||
return Expr::Binary(*op, a.clone(), b.clone());
|
||||
}
|
||||
// Copy the left spine of an operator chain in a loop (see [`Expr`]).
|
||||
let mut spine = Vec::new();
|
||||
let mut node = self;
|
||||
|
||||
@@ -69,11 +69,35 @@ fn parse_top(src: &str, locale: crate::FormulaLocale, allow_union: bool) -> Resu
|
||||
let mut p = Parser { toks, i: 0, depth: 0, input: locale == crate::FormulaLocale::Es };
|
||||
let e = p.expr(0, allow_union)?;
|
||||
match p.peek() {
|
||||
Tok::Eof if wrapper_height(&e) > MAX_DEPTH => Err(ParseError { msg: "formula is nested too deeply".into(), pos: 0 }),
|
||||
Tok::Eof => Ok(e),
|
||||
t => Err(p.err(format!("unexpected {}", describe(t)))),
|
||||
}
|
||||
}
|
||||
|
||||
/// The most unary operators, parentheses and invocations on one path of `e`. The parser bounds
|
||||
/// each level's postfix wrappers by its own depth, so levels inside levels can still stack them
|
||||
/// far past [`MAX_DEPTH`]; code that maps over the tree recurses once per wrapper.
|
||||
fn wrapper_height(e: &Expr) -> usize {
|
||||
let mut most = 0;
|
||||
let mut pending = vec![(e, 0usize)];
|
||||
while let Some((e, h)) = pending.pop() {
|
||||
most = most.max(h);
|
||||
match e {
|
||||
Expr::Unary(_, a) | Expr::Paren(a) => pending.push((a, h + 1)),
|
||||
Expr::Invoke(callee, args) => {
|
||||
pending.push((callee, h + 1));
|
||||
pending.extend(args.iter().map(|a| (a, h + 1)));
|
||||
}
|
||||
Expr::Binary(_, a, b) => pending.extend([(&**a, h), (&**b, h)]),
|
||||
Expr::Call(_, args) => pending.extend(args.iter().map(|a| (a, h))),
|
||||
Expr::Array(rows) => pending.extend(rows.iter().flatten().map(|a| (a, h))),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
most
|
||||
}
|
||||
|
||||
fn describe(t: &Tok) -> String {
|
||||
match t {
|
||||
Tok::RParen => "`)`".into(),
|
||||
|
||||
@@ -576,3 +576,19 @@ fn column_starting_with_at_round_trips() {
|
||||
assert_eq!(parse(&text).ok(), Some(Expr::Struct(s)), "printed as {text}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrappers_stacked_across_levels_are_bounded_as_a_whole() {
|
||||
// Each level adds 40 percents inside the parser's per-level bound, so no level is too deep alone.
|
||||
let stacked = |levels: usize| {
|
||||
let mut f = "1".to_string();
|
||||
for _ in 0..levels {
|
||||
f = format!("({f}){}", "%".repeat(40));
|
||||
}
|
||||
f
|
||||
};
|
||||
assert!(parse(&stacked(5)).is_ok());
|
||||
assert!(parse(&stacked(7)).is_err(), "7 x 41 wrappers on one path");
|
||||
assert!(parse(&format!("{}1{}", "(".repeat(200), ")".repeat(200))).is_ok());
|
||||
assert!(parse(&format!("={}", vec!["A1%"; 100].join("+"))).is_ok(), "siblings are not stacked");
|
||||
}
|
||||
|
||||
@@ -13,6 +13,7 @@ mod day_count;
|
||||
mod depreciation;
|
||||
mod securities;
|
||||
mod tvm;
|
||||
pub(crate) use tvm::cumulative_args;
|
||||
|
||||
use day_count::{coupdaybs, coupdays, coupdaysnc, coupncd, coupnum, couppcd};
|
||||
use depreciation::{amordegrc, amorlinc, db, ddb, sln, syd, vdb};
|
||||
|
||||
@@ -71,7 +71,8 @@ pub(super) fn accrintm(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
|
||||
let (issue, settle, rate) = (date(a, 0)?, date(a, 1)?, num(a, 2)?);
|
||||
let par = if has(a, 3) { num(a, 3)? } else { 1000.0 };
|
||||
let basis = basis_arg(a, 4)?;
|
||||
if issue >= settle || rate <= 0.0 || par <= 0.0 {
|
||||
// Excel accepts equal (whole-day) dates and accrues nothing; only issue after settlement is #NUM!.
|
||||
if issue > settle || rate <= 0.0 || par <= 0.0 {
|
||||
return Err(CellError::Num);
|
||||
}
|
||||
num_val(par * rate * year_frac(c.date_system(), issue, settle, basis)?)
|
||||
|
||||
@@ -317,3 +317,28 @@ fn securities_read_dates_in_the_1904_system() {
|
||||
let odd = vec![d4(2008, 11, 11), d4(2021, 3, 1), d4(2008, 10, 15), d4(2009, 3, 1), n(0.0785), n(0.0625), n(100.0), n(2.0), n(1.0)];
|
||||
close_tol(ev4("ODDFPRICE", odd), 113.597717474079, 1e-9);
|
||||
}
|
||||
|
||||
/// Excel truncates ACCRINTM's dates to whole days and accrues nothing when issue equals
|
||||
/// settlement, in every basis and both date systems; only issue after settlement is #NUM! (#4096).
|
||||
#[test]
|
||||
fn accrintm_equal_dates_accrue_zero() {
|
||||
let day = serial_from_ymd(DateSystem::D1900, 2025, 1, 15).unwrap();
|
||||
for basis in 0..=4 {
|
||||
close(ev("ACCRINTM", vec![n(day), n(day), n(0.05), n(1000.0), n(f64::from(basis))]), 0.0);
|
||||
}
|
||||
// Distinct times on the same day truncate to equal dates.
|
||||
close(ev("ACCRINTM", vec![n(day + 0.1), n(day + 0.9), n(0.05), n(1000.0), n(2.0)]), 0.0);
|
||||
close_tol(ev("ACCRINTM", vec![n(day), n(day + 1.0), n(0.05), n(1000.0), n(2.0)]), 0.1388888888888889, 1e-15);
|
||||
is_err(ev("ACCRINTM", vec![n(day + 1.0), n(day), n(0.05), n(1000.0), n(2.0)]), CellError::Num);
|
||||
// Equal dates do not excuse a zero rate or par, or an invalid basis.
|
||||
is_err(ev("ACCRINTM", vec![n(day), n(day), n(0.0), n(1000.0), n(2.0)]), CellError::Num);
|
||||
is_err(ev("ACCRINTM", vec![n(day), n(day), n(0.05), n(0.0), n(2.0)]), CellError::Num);
|
||||
is_err(ev("ACCRINTM", vec![n(day), n(day), n(0.05), n(1000.0), n(5.0)]), CellError::Num);
|
||||
|
||||
let day4 = serial_from_ymd(DateSystem::D1904, 2025, 1, 15).unwrap();
|
||||
for basis in 0..=4 {
|
||||
let mut ctx = TestCtx { sys: DateSystem::D1904, ..TestCtx::default() };
|
||||
let args = vec![n(day4), n(day4), n(0.05), n(1000.0), n(f64::from(basis))];
|
||||
close(crate::call(crate::lookup("ACCRINTM").unwrap(), &args, &mut ctx), 0.0);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -116,7 +116,9 @@ pub(super) fn ppmt(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
|
||||
num_val(pmt_calc(rate, np, pv, fv, typ) - ipmt_calc(rate, per, np, pv, fv, typ))
|
||||
}
|
||||
|
||||
fn cumulative(a: &[Arg], principal: bool) -> R<Value> {
|
||||
/// The validated (rate, periods, pv, start, end, type) of CUMIPMT/CUMPRINC: every check that
|
||||
/// refuses a call before its period loop, shared with the lifted-call work preflight.
|
||||
pub(crate) fn cumulative_args(a: &[Arg]) -> R<(f64, f64, f64, f64, f64, f64)> {
|
||||
let (rate, np, pv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
|
||||
let (start, end, typ) = (num(a, 3)?.trunc(), num(a, 4)?.trunc(), num(a, 5)?);
|
||||
let np_i = np.trunc();
|
||||
@@ -126,6 +128,11 @@ fn cumulative(a: &[Arg], principal: bool) -> R<Value> {
|
||||
if end - start > 1e7 || np_i > 1e15 {
|
||||
return Err(CellError::Num);
|
||||
}
|
||||
Ok((rate, np_i, pv, start, end, typ))
|
||||
}
|
||||
|
||||
fn cumulative(a: &[Arg], principal: bool) -> R<Value> {
|
||||
let (rate, np_i, pv, start, end, typ) = cumulative_args(a)?;
|
||||
let p = pmt_calc(rate, np_i, pv, 0.0, typ);
|
||||
let mut sum = 0.0;
|
||||
let mut per = start;
|
||||
|
||||
+195
-26
@@ -63,26 +63,86 @@ const SCANS: &[&str] = &["VLOOKUP", "HLOOKUP", "LOOKUP", "MATCH", "XLOOKUP", "XM
|
||||
/// `XMATCH(SEQUENCE(1048576), -SEQUENCE(1048576))` runs for hours and hangs opening the file.
|
||||
/// Past the budget the call is `#NUM!`, as MMULT is past 2e9 multiply-adds. 5e8 keeps the worst
|
||||
/// case to a few seconds and still admits 5,000 needles over a 100,000-row table.
|
||||
///
|
||||
/// The same budget covers all the work of a lifted call added up across its elements: criteria
|
||||
/// aggregates rescanning their ranges, period loops, and array results built per element.
|
||||
const LIFTED_SCAN_BUDGET: usize = 500_000_000;
|
||||
|
||||
/// The length of the longest vector a lifted call of `spec` searches per needle: 0 unless `spec`
|
||||
/// is one of the [`SCANS`] lookups and a non-lifted argument is an array.
|
||||
/// Criteria aggregates: every call tests each cell of its ranges against its criteria, so a call
|
||||
/// lifted over `n` criteria does `n` x (range cells) work, like the [`SCANS`] lookups.
|
||||
const CRITERIA: &[&str] = &["COUNTIF", "COUNTIFS", "SUMIF", "SUMIFS", "AVERAGEIF", "AVERAGEIFS", "MAXIFS", "MINIFS"];
|
||||
|
||||
/// Cumulative TVM functions that step through every period from `start_period` (argument 3) to
|
||||
/// `end_period` (argument 4) on each call.
|
||||
const PERIOD_LOOPS: &[&str] = &["CUMIPMT", "CUMPRINC"];
|
||||
|
||||
/// Budget units one period of a [`PERIOD_LOOPS`] call costs: each period computes a payment and a
|
||||
/// balance with powers, many times a scanned cell.
|
||||
const PERIOD_COST: usize = 16;
|
||||
|
||||
/// The work every lifted call of `spec` repeats over its non-lifted arguments: the longest vector
|
||||
/// a [`SCANS`] lookup searches, or every cell a [`CRITERIA`] aggregate tests. 0 for other
|
||||
/// functions.
|
||||
fn scan_len(spec: &FnSpec, args: &[Arg]) -> usize {
|
||||
if !SCANS.contains(&spec.name) {
|
||||
let scans = SCANS.contains(&spec.name);
|
||||
if !scans && !CRITERIA.contains(&spec.name) {
|
||||
return 0;
|
||||
}
|
||||
args.iter()
|
||||
.enumerate()
|
||||
.filter(|(i, _)| !spec.is_scalar_arg(*i))
|
||||
.filter_map(|(_, a)| match &a.value {
|
||||
Value::Array(arr) => Some(arr.rows.max(arr.cols)),
|
||||
_ => None,
|
||||
})
|
||||
.max()
|
||||
.unwrap_or(0)
|
||||
// SUMIF and AVERAGEIF read the optional third range only at the coordinates of the first.
|
||||
let first = args.first().and_then(|a| if let Value::Array(arr) = &a.value { Some(arr.data.len()) } else { None });
|
||||
let lens = args.iter().enumerate().filter(|(i, _)| !spec.is_scalar_arg(*i)).filter_map(|(i, a)| match &a.value {
|
||||
Value::Array(arr) if scans => Some(arr.rows.max(arr.cols)),
|
||||
Value::Array(arr) if i == 2 && matches!(spec.name, "SUMIF" | "AVERAGEIF") => Some(arr.data.len().min(first.unwrap_or(usize::MAX))),
|
||||
Value::Array(arr) => Some(arr.data.len()),
|
||||
_ => None,
|
||||
});
|
||||
if scans { lens.max().unwrap_or(0) } else { lens.fold(0, usize::saturating_add) }
|
||||
}
|
||||
|
||||
/// The work of one lifted call that depends on its own (lifted) scalar arguments: the number of
|
||||
/// periods a [`PERIOD_LOOPS`] function steps through. 0 for other functions.
|
||||
fn call_cost(spec: &FnSpec, cell_args: &[Arg]) -> usize {
|
||||
if !PERIOD_LOOPS.contains(&spec.name) {
|
||||
return 0;
|
||||
}
|
||||
// Coercing numeric text reads all of it, even in a call the function then refuses, so each
|
||||
// character is charged as well: of the arguments it coerces in order, up to the first that fails.
|
||||
let mut parse = 0usize;
|
||||
for (i, a) in cell_args.iter().enumerate().take(6) {
|
||||
if let Value::Text(t) = &a.value {
|
||||
parse = parse.saturating_add(t.len());
|
||||
}
|
||||
if crate::util::num(cell_args, i).is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// The function's own validation and coercion (text like "10000000" counts), so a call it
|
||||
// refuses before its loop costs nothing and no loop goes uncharged.
|
||||
let periods = crate::financial::cumulative_args(cell_args).map_or(0, |(.., start, end, _)| (end - start + 1.0) as usize);
|
||||
parse.saturating_add(periods.saturating_mul(PERIOD_COST))
|
||||
}
|
||||
|
||||
pub(crate) fn call_lifted(spec: &FnSpec, args: &[Arg], ctx: &mut dyn Ctx) -> Value {
|
||||
call_lifted_within(spec, args, ctx, LIFTED_SCAN_BUDGET)
|
||||
}
|
||||
|
||||
/// Sets the lifted arguments of `cell_args` to their elements at (`r`, `c`).
|
||||
fn element_args(spec: &FnSpec, args: &[Arg], r: usize, c: usize, cell_args: &mut [Arg]) {
|
||||
for (i, a) in args.iter().enumerate() {
|
||||
if spec.is_scalar_arg(i)
|
||||
&& let Value::Array(arr) = &a.value
|
||||
&& let Some(slot) = cell_args.get_mut(i)
|
||||
{
|
||||
let v = arr.get_broadcast(r, c);
|
||||
slot.value = if let Value::Array(inner) = &v { inner.data.first().cloned().unwrap_or(Value::Empty) } else { v };
|
||||
// A blank element of a written array argument is given, as a scalar blank is.
|
||||
slot.blank_value = !slot.from_ref && matches!(slot.value, Value::Empty);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// [`call_lifted`] with every call's work added up against `budget` (see [`LIFTED_SCAN_BUDGET`]).
|
||||
fn call_lifted_within(spec: &FnSpec, args: &[Arg], ctx: &mut dyn Ctx, budget: usize) -> Value {
|
||||
let rejected = if spec.value_args.is_empty() { None } else { reject_multi_cell_refs(spec, args) };
|
||||
let args = rejected.as_deref().unwrap_or(args);
|
||||
let mut rows = 0usize;
|
||||
@@ -101,27 +161,42 @@ pub(crate) fn call_lifted(spec: &FnSpec, args: &[Arg], ctx: &mut dyn Ctx) -> Val
|
||||
return (spec.imp)(args, ctx);
|
||||
}
|
||||
let needles = rows.saturating_mul(cols);
|
||||
if needles > MAX_CELLS || needles.saturating_mul(scan_len(spec, args)) > LIFTED_SCAN_BUDGET {
|
||||
// Every call is charged its repeated scan (at least 1), its own period loop, and the cells of
|
||||
// an array result (built in full, though only its first cell is kept), so lifting a scalar
|
||||
// argument can't multiply what one call may do into hours of work:
|
||||
// `COUNTIF(big_range, SEQUENCE(1e4))`, `CUMIPMT(0.1, 1e7, 1, 1, SEQUENCE(1e4,,1e7,0), 0)`,
|
||||
// `MUNIT(SEQUENCE(1e4,,3000,0))`.
|
||||
let per_call = scan_len(spec, args).max(1);
|
||||
let mut cell_args: Vec<Arg> = args.to_vec();
|
||||
let mut spent = needles.saturating_mul(per_call);
|
||||
if needles > MAX_CELLS || spent > budget {
|
||||
return Value::Error(CellError::Num);
|
||||
}
|
||||
let mut cell_args: Vec<Arg> = args.to_vec();
|
||||
// Period loops are known before any call runs, so a call over budget does none of them.
|
||||
if PERIOD_LOOPS.contains(&spec.name) {
|
||||
for r in 0..rows {
|
||||
for c in 0..cols {
|
||||
element_args(spec, args, r, c, &mut cell_args);
|
||||
spent = spent.saturating_add(call_cost(spec, &cell_args));
|
||||
if spent > budget {
|
||||
return Value::Error(CellError::Num);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut data = Vec::with_capacity(rows * cols);
|
||||
for r in 0..rows {
|
||||
for c in 0..cols {
|
||||
for (i, a) in args.iter().enumerate() {
|
||||
if spec.is_scalar_arg(i)
|
||||
&& let Value::Array(arr) = &a.value
|
||||
&& let Some(slot) = cell_args.get_mut(i)
|
||||
{
|
||||
let v = arr.get_broadcast(r, c);
|
||||
slot.value = if let Value::Array(inner) = &v { inner.data.first().cloned().unwrap_or(Value::Empty) } else { v };
|
||||
// A blank element of a written array argument is given, as a scalar blank is.
|
||||
slot.blank_value = !slot.from_ref && matches!(slot.value, Value::Empty);
|
||||
}
|
||||
}
|
||||
element_args(spec, args, r, c, &mut cell_args);
|
||||
let out = (spec.imp)(&cell_args, ctx);
|
||||
data.push(match out {
|
||||
Value::Array(a) => a.data.first().cloned().unwrap_or(Value::Empty),
|
||||
Value::Array(a) => {
|
||||
spent = spent.saturating_add(a.data.len());
|
||||
if spent > budget {
|
||||
return Value::Error(CellError::Num);
|
||||
}
|
||||
a.data.first().cloned().unwrap_or(Value::Empty)
|
||||
}
|
||||
v => v,
|
||||
});
|
||||
}
|
||||
@@ -206,6 +281,100 @@ mod tests {
|
||||
assert_eq!(rows_of(&out), vec![vec![nv(-1.0)]; 1000]);
|
||||
}
|
||||
|
||||
/// Security: lifting a criteria aggregate rescans its range for every criterion, so criteria
|
||||
/// x range cells past the budget is `#NUM!` before any scan runs.
|
||||
#[test]
|
||||
fn lifted_criteria_aggregates_stop_past_their_work_budget() {
|
||||
use gridcraft_core::Array;
|
||||
let tall = |n: usize| av(Array::filled(n, 1, nv(-1.0)).into());
|
||||
is_err(ev("COUNTIF", vec![tall(1_000_000), tall(501)]), CellError::Num);
|
||||
is_err(ev("SUMIF", vec![tall(1_000_000), tall(501)]), CellError::Num);
|
||||
is_err(ev("COUNTIFS", vec![tall(1_000_000), tall(501)]), CellError::Num);
|
||||
// Two ranges of 250,000 cells each count together.
|
||||
is_err(ev("SUMIFS", vec![tall(250_000), tall(250_000), tall(1001)]), CellError::Num);
|
||||
// SUMIF reads its sum range only where the criteria range has cells: a one-cell range over a
|
||||
// million-cell sum range is one cell of work per criterion.
|
||||
let one = av(Array::filled(1, 1, nv(-1.0)).into());
|
||||
assert_eq!(rows_of(&ev("SUMIF", vec![one, tall(501), tall(1_000_000)])).len(), 501);
|
||||
let counts = ev("COUNTIF", vec![av(col(&[1.0, 2.0, 2.0])), av(col(&[2.0, 1.0, 5.0]))]);
|
||||
assert_eq!(rows_of(&counts), vec![vec![nv(2.0)], vec![nv(1.0)], vec![nv(0.0)]]);
|
||||
for name in super::CRITERIA.iter().chain(super::PERIOD_LOOPS) {
|
||||
assert!(crate::lookup(name).is_some(), "{name} isn't registered");
|
||||
}
|
||||
}
|
||||
|
||||
/// Security: CUMIPMT and CUMPRINC loop over their periods once per lifted element; the
|
||||
/// periods of all elements are added up first, so an over-budget call runs none of them.
|
||||
#[test]
|
||||
fn lifted_period_loops_stop_past_their_work_budget() {
|
||||
use gridcraft_core::Array;
|
||||
let ends = |len: usize, end: f64| av(Array::filled(len, 1, nv(end)).into());
|
||||
let args = |len: usize, end: f64| vec![n(0.01), n(1e7), n(1000.0), n(1.0), ends(len, end), n(0.0)];
|
||||
// 51 elements of 1e7 periods each is past 5e8.
|
||||
is_err(ev("CUMIPMT", args(51, 1e7)), CellError::Num);
|
||||
is_err(ev("CUMPRINC", args(51, 1e7)), CellError::Num);
|
||||
// A period costs more than a scanned cell, so fewer elements are enough.
|
||||
is_err(ev("CUMIPMT", args(49, 1e7)), CellError::Num);
|
||||
// Numeric text is coerced by the function, so its periods are charged the same.
|
||||
let text_ends = av(Array::filled(51, 1, Value::text("10000000")).into());
|
||||
is_err(ev("CUMIPMT", vec![n(0.01), n(1e7), n(1000.0), n(1.0), text_ends, n(0.0)]), CellError::Num);
|
||||
let out = ev("CUMIPMT", args(2, 12.0));
|
||||
assert_eq!(rows_of(&out).len(), 2);
|
||||
assert!(matches!(rows_of(&out).first().and_then(|r| r.first()), Some(Value::Number(x)) if *x < 0.0));
|
||||
}
|
||||
|
||||
/// Security: numeric text is parsed once per lifted element even when the call is refused; the
|
||||
/// characters read are charged, so a long text repeated down a column can't cost gigabytes of parsing.
|
||||
#[test]
|
||||
fn lifted_period_loops_charge_the_text_they_parse() {
|
||||
use gridcraft_core::Array;
|
||||
// 20,000 elements x 32,000 characters is past 5e8 though no call reaches its loop (rate is negative).
|
||||
let long = Value::text(format!("{}5", "0".repeat(32_000)));
|
||||
let ends = av(Array::filled(20_000, 1, long).into());
|
||||
is_err(ev("CUMIPMT", vec![n(-0.01), n(10.0), n(1000.0), n(1.0), ends, n(0.0)]), CellError::Num);
|
||||
// A short text period costs next to nothing.
|
||||
let ends = av(Array::filled(3, 1, Value::text("12")).into());
|
||||
assert_eq!(rows_of(&ev("CUMIPMT", vec![n(0.01), n(20.0), n(1000.0), n(1.0), ends, n(0.0)])).len(), 3);
|
||||
}
|
||||
|
||||
/// Text after the first argument that fails to coerce is never read, so it is not charged: the
|
||||
/// elements keep their own errors instead of one budget `#NUM!`.
|
||||
#[test]
|
||||
fn lifted_period_loops_charge_only_the_text_they_reach() {
|
||||
use gridcraft_core::Array;
|
||||
let rates = av(Array::filled(20_000, 1, Value::text("x")).into());
|
||||
let long = Value::text(format!("{}5", "0".repeat(32_000)));
|
||||
let out = ev("CUMIPMT", vec![rates, n(10.0), n(1000.0), n(1.0), av(long), n(0.0)]);
|
||||
assert!(rows_of(&out).iter().all(|r| r.first() == Some(&Value::Error(CellError::Value))));
|
||||
}
|
||||
|
||||
/// A call the function refuses before its loop (here: end period past the period count) is
|
||||
/// not charged, so rejected elements can't push a valid one over the budget.
|
||||
#[test]
|
||||
fn lifted_period_loops_do_not_charge_rejected_calls() {
|
||||
use gridcraft_core::Array;
|
||||
let mut ends = vec![nv(1e7 + 1.0); 60];
|
||||
ends.push(nv(12.0));
|
||||
let ends = av(Array::new(ends.len(), 1, ends).unwrap_or_else(|| panic!("shape")).into());
|
||||
let out = ev("CUMIPMT", vec![n(0.01), n(1e7), n(1000.0), n(1.0), ends, n(0.0)]);
|
||||
let rows = rows_of(&out);
|
||||
assert_eq!(rows.len(), 61);
|
||||
assert!(matches!(rows.last().and_then(|r| r.first()), Some(Value::Number(x)) if *x < 0.0));
|
||||
}
|
||||
|
||||
/// Security: an array-producing function lifted over a computed array builds each element's
|
||||
/// whole result before keeping one cell; their cells count against the budget.
|
||||
#[test]
|
||||
fn lifted_array_results_count_against_the_budget() {
|
||||
use gridcraft_core::Array;
|
||||
let spec = crate::lookup("MUNIT").unwrap_or_else(|| panic!("MUNIT isn't registered"));
|
||||
let dims = |n: usize| [av(Array::filled(n, 1, nv(10.0)).into())];
|
||||
// Ten 10x10 identity matrices are 1,000 cells.
|
||||
let out = super::call_lifted_within(spec, &dims(10), &mut TestCtx::default(), 1_010);
|
||||
assert_eq!(rows_of(&out), vec![vec![nv(1.0)]; 10]);
|
||||
is_err(super::call_lifted_within(spec, &dims(11), &mut TestCtx::default(), 1_010), CellError::Num);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn value_params_reject_multi_cell_references() {
|
||||
let s = FnSpec { value_args: &[true, false], ..spec() };
|
||||
|
||||
@@ -520,7 +520,7 @@ fn integer_args(a: &[Arg]) -> R<Vec<u64>> {
|
||||
v.iter()
|
||||
.map(|x| {
|
||||
let t = x.trunc();
|
||||
if !(0.0..9.007_199_254_740_992e15).contains(&t) { Err(CellError::Num) } else { Ok(t as u64) }
|
||||
if !(0.0..9.007_199_254_740_992e15).contains(x) { Err(CellError::Num) } else { Ok(t as u64) }
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
@@ -229,6 +229,20 @@ fn combinatorics() {
|
||||
is_err(ev("MULTINOMIAL", vec![n(-1.0), n(2.0)]), Num);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn gcd_and_lcm_reject_negative_fractions_before_truncation() {
|
||||
for name in ["GCD", "LCM"] {
|
||||
for x in [-0.1, -0.5, -0.999] {
|
||||
is_err(ev2(name, x, 2.0), Num);
|
||||
is_err(ev(name, vec![rf(row(&[2.0, x]))]), Num);
|
||||
// A zero elsewhere must not hide an invalid negative argument.
|
||||
is_err(ev2(name, 0.0, x), Num);
|
||||
}
|
||||
close(ev2(name, -0.0, 2.0), if name == "GCD" { 2.0 } else { 0.0 });
|
||||
close(ev2(name, 12.9, 18.9), if name == "GCD" { 6.0 } else { 36.0 });
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trig() {
|
||||
close(ev1("SIN", PI / 2.0), 1.0);
|
||||
|
||||
@@ -55,12 +55,12 @@ fn strict_num(v: &Value) -> R<f64> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Most predictor columns LINEST, LOGEST, TREND and GROWTH accept. The normal equations are a
|
||||
/// k×k matrix inverted in O(k³), so an unbounded k (one `SEQUENCE(1,16384)` argument) allocated
|
||||
/// Most predictor columns LINEST, LOGEST, TREND and GROWTH accept. The fit works on a k×k
|
||||
/// triangle in O(k³), so an unbounded k (one `SEQUENCE(1,16384)` argument) allocated
|
||||
/// gigabytes and could abort the process.
|
||||
pub(super) const MAX_REGRESSORS: usize = 255;
|
||||
|
||||
/// Most multiply-adds (rows × k²) a regression may spend building its normal equations.
|
||||
/// Most multiply-adds (rows × k²) a regression may spend on its factorisation.
|
||||
const MAX_REGRESSION_WORK: usize = 1_000_000_000;
|
||||
|
||||
/// Rejects regressions too large to fit: more than [`MAX_REGRESSORS`] predictors is `#VALUE!`,
|
||||
@@ -121,59 +121,136 @@ struct Fit {
|
||||
ssresid: f64,
|
||||
}
|
||||
|
||||
/// Inverts a symmetric positive semi-definite matrix by Gauss–Jordan on the diagonal, dropping
|
||||
/// (zeroing) collinear variables. Returns the inverse and the dropped flags.
|
||||
fn sym_inverse(m: &[Vec<f64>]) -> (Vec<Vec<f64>>, Vec<bool>) {
|
||||
let p = m.len();
|
||||
let mut a: Vec<Vec<f64>> = m.to_vec();
|
||||
let mut inv: Vec<Vec<f64>> = (0..p).map(|i| (0..p).map(|j| if i == j { 1.0 } else { 0.0 }).collect()).collect();
|
||||
let mut dropped = vec![false; p];
|
||||
let diag: Vec<f64> = (0..p).map(|i| m.get(i).and_then(|r| r.get(i)).copied().unwrap_or(0.0).abs()).collect();
|
||||
for j in 0..p {
|
||||
let piv = a.get(j).and_then(|r| r.get(j)).copied().unwrap_or(0.0);
|
||||
let scale = diag.get(j).copied().unwrap_or(0.0);
|
||||
if piv.abs() <= 1e-12 * scale || piv.abs() < 1e-300 {
|
||||
if let Some(d) = dropped.get_mut(j) {
|
||||
*d = true;
|
||||
}
|
||||
for row in a.iter_mut() {
|
||||
if let Some(v) = row.get_mut(j) {
|
||||
*v = 0.0;
|
||||
}
|
||||
}
|
||||
if let Some(r) = a.get_mut(j) {
|
||||
r.iter_mut().for_each(|v| *v = 0.0);
|
||||
}
|
||||
if let Some(r) = inv.get_mut(j) {
|
||||
r.iter_mut().for_each(|v| *v = 0.0);
|
||||
}
|
||||
/// Euclidean norm without intermediate overflow or underflow.
|
||||
fn norm2(v: &[f64]) -> f64 {
|
||||
let m = v.iter().fold(0.0f64, |m, x| m.max(x.abs()));
|
||||
if m == 0.0 || !m.is_finite() {
|
||||
return m;
|
||||
}
|
||||
m * v.iter().map(|x| (x / m) * (x / m)).sum::<f64>().sqrt()
|
||||
}
|
||||
|
||||
/// Result of [`qr_solve`]: the least-squares solution on the kept columns, in the caller's
|
||||
/// column scale, and what the standard errors need.
|
||||
struct QrFit {
|
||||
coef: Vec<f64>,
|
||||
dropped: Vec<bool>,
|
||||
/// Residual sum of squares of the fit.
|
||||
ssresid: f64,
|
||||
/// Diagonal of `(X'X)^-1` over the kept columns (0 for dropped ones).
|
||||
diag: Vec<f64>,
|
||||
/// `xm' (X'X)^-1 xm` over the kept columns.
|
||||
quad: f64,
|
||||
}
|
||||
|
||||
/// Least squares by Householder QR on unit-norm columns, instead of the normal equations, whose
|
||||
/// condition number is the square of the data's. Columns are taken left to right; one whose part
|
||||
/// outside the span of the kept columns is under 1e-6 of its own length (the 1e-12 relative
|
||||
/// pivot of the earlier normal-equation solver, on squares) is collinear: it is dropped, with
|
||||
/// coefficient and standard error 0, as Excel does.
|
||||
///
|
||||
/// `constant[j]` says column `j` was constant before centring. Centring it leaves rounding
|
||||
/// residue, not 0 (`[0.1; 3]` centres to about -1.4e-17): it is collinear with the intercept, so
|
||||
/// it is dropped instead of being scaled up to unit length. Whether a column is constant is
|
||||
/// decided on its raw values, not by comparing the centred length with the offset: a predictor
|
||||
/// like `[1e13, 1e13 + 1, 1e13 + 2]` is far smaller than its offset and still varies.
|
||||
fn qr_solve(mut cols: Vec<Vec<f64>>, mut y: Vec<f64>, xm: &[f64], constant: &[bool]) -> QrFit {
|
||||
let n = y.len();
|
||||
let k = cols.len();
|
||||
let mut scale = vec![1.0; k];
|
||||
let mut dropped = vec![false; k];
|
||||
// Householder vectors (unit norm, acting on rows `at..n`) and the columns of R.
|
||||
let mut refl: Vec<(usize, Vec<f64>)> = Vec::new();
|
||||
let mut r_cols: Vec<Vec<f64>> = Vec::new();
|
||||
let mut kept: Vec<usize> = Vec::new();
|
||||
for (j, col) in cols.iter_mut().enumerate() {
|
||||
let len = norm2(col);
|
||||
if constant.get(j).copied().unwrap_or(false) || !(len > 1e-300 && len.is_finite()) {
|
||||
dropped[j] = true;
|
||||
continue;
|
||||
}
|
||||
let arow: Vec<f64> = a.get(j).map(|r| r.iter().map(|v| v / piv).collect()).unwrap_or_default();
|
||||
let irow: Vec<f64> = inv.get(j).map(|r| r.iter().map(|v| v / piv).collect()).unwrap_or_default();
|
||||
for i in 0..p {
|
||||
if i == j {
|
||||
continue;
|
||||
}
|
||||
let f = a.get(i).and_then(|r| r.get(j)).copied().unwrap_or(0.0);
|
||||
if f == 0.0 {
|
||||
continue;
|
||||
}
|
||||
if let Some(r) = a.get_mut(i) {
|
||||
r.iter_mut().zip(&arow).for_each(|(v, w)| *v -= f * w);
|
||||
}
|
||||
if let Some(r) = inv.get_mut(i) {
|
||||
r.iter_mut().zip(&irow).for_each(|(v, w)| *v -= f * w);
|
||||
}
|
||||
col.iter_mut().for_each(|v| *v /= len);
|
||||
scale[j] = len;
|
||||
for (at, v) in &refl {
|
||||
apply_reflector(*at, v, col);
|
||||
}
|
||||
if let Some(r) = a.get_mut(j) {
|
||||
*r = arow;
|
||||
let at = refl.len();
|
||||
let tail = col.get(at..).unwrap_or(&[]);
|
||||
let alpha = norm2(tail);
|
||||
if alpha * alpha <= 1e-12 {
|
||||
dropped[j] = true;
|
||||
continue;
|
||||
}
|
||||
if let Some(r) = inv.get_mut(j) {
|
||||
*r = irow;
|
||||
let sign = if tail.first().is_some_and(|t| *t < 0.0) { -1.0 } else { 1.0 };
|
||||
let mut v: Vec<f64> = tail.to_vec();
|
||||
if let Some(h) = v.first_mut() {
|
||||
*h += sign * alpha;
|
||||
}
|
||||
let vn = norm2(&v);
|
||||
v.iter_mut().for_each(|x| *x /= vn);
|
||||
let mut rc: Vec<f64> = col.get(..at).unwrap_or(&[]).to_vec();
|
||||
rc.push(-sign * alpha);
|
||||
r_cols.push(rc);
|
||||
refl.push((at, v));
|
||||
kept.push(j);
|
||||
}
|
||||
for (at, v) in &refl {
|
||||
apply_reflector(*at, v, &mut y);
|
||||
}
|
||||
let r = kept.len();
|
||||
// Back substitution R c = (Q'y)[..r], then undo the column scaling.
|
||||
let mut c = vec![0.0; r];
|
||||
for i in (0..r).rev() {
|
||||
let mut t = y.get(i).copied().unwrap_or(0.0);
|
||||
for jj in i + 1..r {
|
||||
t -= r_cols.get(jj).and_then(|rc| rc.get(i)).copied().unwrap_or(0.0) * c.get(jj).copied().unwrap_or(0.0);
|
||||
}
|
||||
if let Some(ci) = c.get_mut(i) {
|
||||
*ci = t / r_cols.get(i).and_then(|rc| rc.get(i)).copied().unwrap_or(f64::NAN);
|
||||
}
|
||||
}
|
||||
(inv, dropped)
|
||||
let ssresid = y.get(r..n).unwrap_or(&[]).iter().map(|v| v * v).sum::<f64>();
|
||||
// R^-1 (upper triangular), row i of the inverse at rinv[i].
|
||||
let rij = |i: usize, j: usize| r_cols.get(j).and_then(|rc| rc.get(i)).copied().unwrap_or(0.0);
|
||||
let mut rinv = vec![vec![0.0; r]; r];
|
||||
for t in 0..r {
|
||||
for i in (0..=t).rev() {
|
||||
let mut v = if i == t { 1.0 } else { 0.0 };
|
||||
for jj in i + 1..=t {
|
||||
v -= rij(i, jj) * rinv.get(jj).and_then(|row| row.get(t)).copied().unwrap_or(0.0);
|
||||
}
|
||||
if let Some(cell) = rinv.get_mut(i).and_then(|row| row.get_mut(t)) {
|
||||
*cell = v / rij(i, i);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut coef = vec![0.0; k];
|
||||
let mut diag = vec![0.0; k];
|
||||
for (i, &j) in kept.iter().enumerate() {
|
||||
let s = scale.get(j).copied().unwrap_or(1.0);
|
||||
if let Some(v) = coef.get_mut(j) {
|
||||
*v = c.get(i).copied().unwrap_or(0.0) / s;
|
||||
}
|
||||
let row = rinv.get(i);
|
||||
if let Some(v) = diag.get_mut(j) {
|
||||
*v = row.map_or(0.0, |rw| rw.iter().map(|x| x * x).sum::<f64>()) / (s * s);
|
||||
}
|
||||
}
|
||||
// xm' (S R'R S)^-1 xm = |R^-T S^-1 xm|².
|
||||
let w: Vec<f64> = kept.iter().map(|&j| xm.get(j).copied().unwrap_or(0.0) / scale.get(j).copied().unwrap_or(1.0)).collect();
|
||||
let quad = (0..r)
|
||||
.map(|t| {
|
||||
(0..=t).map(|i| rinv.get(i).and_then(|row| row.get(t)).copied().unwrap_or(0.0) * w.get(i).copied().unwrap_or(0.0)).sum::<f64>().powi(2)
|
||||
})
|
||||
.sum::<f64>();
|
||||
QrFit { coef, dropped, ssresid, diag, quad }
|
||||
}
|
||||
|
||||
/// Applies the Householder reflection `I - 2vv'` on rows `at..` of `x`.
|
||||
fn apply_reflector(at: usize, v: &[f64], x: &mut [f64]) {
|
||||
let Some(tail) = x.get_mut(at..) else { return };
|
||||
let dot: f64 = v.iter().zip(tail.iter()).map(|(a, b)| a * b).sum();
|
||||
tail.iter_mut().zip(v).for_each(|(t, a)| *t -= 2.0 * dot * a);
|
||||
}
|
||||
|
||||
fn regress(y: &[f64], x: &[Vec<f64>], k: usize, constant: bool) -> R<Fit> {
|
||||
@@ -189,35 +266,22 @@ fn regress(y: &[f64], x: &[Vec<f64>], k: usize, constant: bool) -> R<Fit> {
|
||||
} else {
|
||||
(vec![0.0; k], 0.0)
|
||||
};
|
||||
// Normal equations on (centred) data.
|
||||
let mut xtx = vec![vec![0.0; k]; k];
|
||||
let mut xty = vec![0.0; k];
|
||||
for (row, yv) in x.iter().zip(y) {
|
||||
let d: Vec<f64> = (0..k).map(|j| row.get(j).copied().unwrap_or(0.0) - xm.get(j).copied().unwrap_or(0.0)).collect();
|
||||
let yd = yv - ym;
|
||||
for (i, di) in d.iter().enumerate() {
|
||||
if let Some(t) = xty.get_mut(i) {
|
||||
*t += di * yd;
|
||||
}
|
||||
if let Some(r) = xtx.get_mut(i) {
|
||||
for (j, dj) in d.iter().enumerate() {
|
||||
if let Some(v) = r.get_mut(j) {
|
||||
*v += di * dj;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let (inv, dropped) = sym_inverse(&xtx);
|
||||
let coef: Vec<f64> = (0..k).map(|i| inv.get(i).map(|r| r.iter().zip(&xty).map(|(a, b)| a * b).sum()).unwrap_or(0.0)).collect();
|
||||
// (Centred) predictor columns and response.
|
||||
let cols: Vec<Vec<f64>> =
|
||||
(0..k).map(|j| x.iter().map(|r| r.get(j).copied().unwrap_or(0.0) - xm.get(j).copied().unwrap_or(0.0)).collect()).collect();
|
||||
let yc: Vec<f64> = y.iter().map(|v| v - ym).collect();
|
||||
let sstot: f64 = if constant { yc.iter().map(|v| v * v).sum() } else { y.iter().map(|v| v * v).sum() };
|
||||
// Only centring leaves rounding residue behind; without an intercept a constant column is data.
|
||||
// Constant means every raw value is the same double: distinct values, however close, vary.
|
||||
let constant_cols: Vec<bool> = (0..k)
|
||||
.map(|j| {
|
||||
let mut col = x.iter().map(|r| r.get(j).copied().unwrap_or(0.0));
|
||||
let first = col.next();
|
||||
constant && first.is_some_and(|f| col.all(|v| v == f))
|
||||
})
|
||||
.collect();
|
||||
let QrFit { coef, dropped, ssresid, diag, quad } = qr_solve(cols, yc, &xm, &constant_cols);
|
||||
let b = if constant { ym - coef.iter().zip(&xm).map(|(c, m)| c * m).sum::<f64>() } else { 0.0 };
|
||||
let mut ssresid = 0.0;
|
||||
let mut sstot = 0.0;
|
||||
for (row, yv) in x.iter().zip(y) {
|
||||
let pred = b + coef.iter().zip(row).map(|(c, v)| c * v).sum::<f64>();
|
||||
ssresid += (yv - pred).powi(2);
|
||||
sstot += if constant { (yv - ym).powi(2) } else { yv * yv };
|
||||
}
|
||||
let used = dropped.iter().filter(|d| !**d).count() + usize::from(constant);
|
||||
let df = nf - used as f64;
|
||||
let ssreg = sstot - ssresid;
|
||||
@@ -230,20 +294,9 @@ fn regress(y: &[f64], x: &[Vec<f64>], k: usize, constant: bool) -> R<Fit> {
|
||||
_ => Err(CellError::Num),
|
||||
};
|
||||
let s2 = sey2.unwrap_or(f64::NAN);
|
||||
let se: Vec<f64> = (0..k)
|
||||
.map(|i| if dropped.get(i).copied().unwrap_or(true) { 0.0 } else { (inv.get(i).and_then(|r| r.get(i)).copied().unwrap_or(0.0) * s2).sqrt() })
|
||||
.collect();
|
||||
let se_b = if constant {
|
||||
let mut q = 0.0;
|
||||
for (i, mi) in xm.iter().enumerate() {
|
||||
for (j, mj) in xm.iter().enumerate() {
|
||||
q += mi * mj * inv.get(i).and_then(|r| r.get(j)).copied().unwrap_or(0.0);
|
||||
}
|
||||
}
|
||||
Some((s2 * (1.0 / nf + q)).sqrt())
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let se: Vec<f64> =
|
||||
(0..k).map(|i| if dropped.get(i).copied().unwrap_or(true) { 0.0 } else { (diag.get(i).copied().unwrap_or(0.0) * s2).sqrt() }).collect();
|
||||
let se_b = if constant { Some((s2 * (1.0 / nf + quad)).sqrt()) } else { None };
|
||||
Ok(Fit { coef, b, se, se_b, r2, sey, f, df, ssreg, ssresid })
|
||||
}
|
||||
|
||||
|
||||
@@ -433,6 +433,185 @@ fn linest_family() {
|
||||
is_err(ev("LINEST", vec![c(&[1.0, 2.0]), c(&[1.0, 2.0, 3.0])]), CellError::Ref);
|
||||
}
|
||||
|
||||
/// LINEST on columns of predictors, `stats` on, as rows of numbers (`None` for an error cell).
|
||||
fn linest_rows(y: &[f64], xs: &[Vec<f64>], constant: bool) -> Vec<Vec<Option<f64>>> {
|
||||
let x = arr((0..y.len()).map(|i| xs.iter().map(|col| nv(col[i])).collect()).collect());
|
||||
let r = rows_of(&ev("LINEST", vec![c(y), av(x), b(constant), b(true)]));
|
||||
r.iter().map(|row| row.iter().map(Value::as_f64).collect()).collect()
|
||||
}
|
||||
|
||||
fn rel_close(got: Option<f64>, want: f64, tol: f64, what: &str) {
|
||||
let got = got.unwrap_or(f64::NAN);
|
||||
assert!((got - want).abs() <= tol * want.abs().max(1e-300), "{what}: got {got:e}, want {want:e}, rel tol {tol:e}");
|
||||
}
|
||||
|
||||
// B2: LINEST solved the normal equations, whose condition number is the square of the data's.
|
||||
// Expected values below come from exact rational arithmetic: the normal equations solved with
|
||||
// Python `fractions.Fraction` (no rounding at all), rounded once to f64 (script in the PR text).
|
||||
#[test]
|
||||
fn linest_ill_conditioned_polynomial_is_exact() {
|
||||
// y = 1 + x + x² + x³ + x⁴ + x⁵ on x = 1..12: every coefficient is exactly 1. The normal
|
||||
// equations were off by up to 2.6e-6.
|
||||
let xs: Vec<f64> = (1..=12).map(f64::from).collect();
|
||||
let ys: Vec<f64> = xs.iter().map(|x| (0..=5).map(|j| x.powi(j)).sum()).collect();
|
||||
let cols: Vec<Vec<f64>> = (1..=5).map(|j| xs.iter().map(|x| x.powi(j)).collect()).collect();
|
||||
let r = linest_rows(&ys, &cols, true);
|
||||
for (i, v) in r[0].iter().enumerate() {
|
||||
rel_close(*v, 1.0, 1e-9, &format!("coefficient {i}"));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn linest_large_offset_regressors_recover_the_line() {
|
||||
// y = 3x + 7 exactly with x = 1e6 + i and regressors [x, x²]: the true fit has x² coefficient
|
||||
// 0, x coefficient 3, intercept 7. The normal equations returned 2.99976 and 251.14.
|
||||
let xs: Vec<f64> = (0..12).map(|i| 1_000_000.0 + f64::from(i)).collect();
|
||||
let ys: Vec<f64> = xs.iter().map(|x| 3.0 * x + 7.0).collect();
|
||||
let r = linest_rows(&ys, &[xs.clone(), xs.iter().map(|x| x * x).collect()], true);
|
||||
assert!(r[0][0].unwrap().abs() < 1e-12, "x² coefficient {:?}", r[0][0]);
|
||||
rel_close(r[0][1], 3.0, 1e-9, "x coefficient");
|
||||
// The intercept subtracts 3e6 from 3e6 + 7 and carries the x² coefficient times 1e12, so
|
||||
// it is good to about 1e-4 in absolute terms, not better.
|
||||
assert!((r[0][2].unwrap() - 7.0).abs() < 1e-3, "intercept {:?}", r[0][2]);
|
||||
// One regressor: exact.
|
||||
let one = linest_rows(&ys, std::slice::from_ref(&xs), true);
|
||||
rel_close(one[0][0], 3.0, 1e-12, "slope");
|
||||
rel_close(one[0][1], 7.0, 1e-9, "intercept");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn linest_noisy_fits_match_exact_rational_least_squares() {
|
||||
// Two predictors with noise, constant fitted. Order of each row: x2, x1, intercept.
|
||||
let x1 = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
|
||||
let x2 = [2.0, 1.0, 4.0, 3.0, 7.0, 5.0, 9.0, 6.0];
|
||||
let y = [5.0, 6.0, 11.0, 12.0, 20.0, 19.0, 30.0, 28.0];
|
||||
let r = linest_rows(&y, &[x1.to_vec(), x2.to_vec()], true);
|
||||
let (coef, se) = ([1.4270152505446623, 2.452069716775599, -1.2592592592592593], [0.3376442444771937, 0.3679392851360571, 1.0847489958915801]);
|
||||
for i in 0..3 {
|
||||
rel_close(r[0][i], coef[i], 1e-12, "coef");
|
||||
rel_close(r[1][i], se[i], 1e-12, "se");
|
||||
}
|
||||
rel_close(r[2][0], 0.985070139277778, 1e-12, "r2");
|
||||
rel_close(r[2][1], 1.367057173604725, 1e-12, "sey");
|
||||
rel_close(r[3][0], 164.94965318256004, 1e-11, "F");
|
||||
assert_eq!(r[3][1], Some(5.0));
|
||||
rel_close(r[4][0], 616.5307734204792, 1e-12, "ssreg");
|
||||
rel_close(r[4][1], 9.344226579520697, 1e-11, "ssresid");
|
||||
assert_eq!(r[2][2], None);
|
||||
// const = FALSE: through the origin, R² and F from the uncentred sums.
|
||||
let r = linest_rows(&y, &[x1.to_vec(), x2.to_vec()], false);
|
||||
rel_close(r[0][0], 1.3529411764705883, 1e-12, "coef");
|
||||
rel_close(r[0][1], 2.303921568627451, 1e-12, "coef");
|
||||
assert_eq!(r[0][2], Some(0.0));
|
||||
rel_close(r[1][0], 0.34102994374364876, 1e-12, "se");
|
||||
rel_close(r[1][1], 0.35495521934550084, 1e-12, "se");
|
||||
assert_eq!(r[1][2], None);
|
||||
rel_close(r[2][0], 0.995718966041848, 1e-12, "r2");
|
||||
rel_close(r[2][1], 1.4061024795535124, 1e-12, "sey");
|
||||
rel_close(r[3][0], 697.7652892561983, 1e-11, "F");
|
||||
assert_eq!(r[3][1], Some(6.0));
|
||||
rel_close(r[4][0], 2759.1372549019607, 1e-12, "ssreg");
|
||||
rel_close(r[4][1], 11.862745098039216, 1e-11, "ssresid");
|
||||
// Cubic and quintic with noise on x = 1..12; order x^k .. x, intercept.
|
||||
let xs: Vec<f64> = (1..=12).map(f64::from).collect();
|
||||
let noise = [3.0, -2.0, 4.0, -1.0, 2.0, -3.0, 1.0, -4.0, 2.0, 3.0, -2.0, 1.0];
|
||||
let cub: Vec<f64> = xs.iter().zip(noise).map(|(x, e)| 1.0 + x + x * x + x.powi(3) + e).collect();
|
||||
let r = linest_rows(&cub, &(1..=3).map(|j| xs.iter().map(|x| x.powi(j)).collect()).collect::<Vec<Vec<f64>>>(), true);
|
||||
let coef = [0.9955969955969955, 1.1452991452991452, -0.33514633514633513, 4.373737373737374];
|
||||
let se = [0.02755463331301788, 0.5434124199147191, 3.102549978874372, 4.851885058051787];
|
||||
for i in 0..4 {
|
||||
rel_close(r[0][i], coef[i], 1e-11, "cubic coef");
|
||||
rel_close(r[1][i], se[i], 1e-10, "cubic se");
|
||||
}
|
||||
rel_close(r[2][0], 0.9999837292113533, 1e-12, "cubic r2");
|
||||
rel_close(r[4][1], 70.35586635586635, 1e-9, "cubic ssresid");
|
||||
let quint: Vec<f64> = xs.iter().zip(noise).map(|(x, e)| (0..=5).map(|j| x.powi(j)).sum::<f64>() + 50.0 * e).collect();
|
||||
let r = linest_rows(&quint, &(1..=5).map(|j| xs.iter().map(|x| x.powi(j)).collect()).collect::<Vec<Vec<f64>>>(), true);
|
||||
let coef = [0.9330693815987934, 3.022273070067188, -20.97398190045249, 108.20489681886741, -250.24940010969422, 271.45454545454544];
|
||||
let se = [0.20046539191103213, 6.538253746916523, 78.39635356777087, 421.2608646012634, 976.3504976093745, 736.5866411764556];
|
||||
for i in 0..6 {
|
||||
rel_close(r[0][i], coef[i], 1e-8, "quintic coef");
|
||||
rel_close(r[1][i], se[i], 1e-8, "quintic se");
|
||||
}
|
||||
rel_close(r[2][1], 168.58174051770763, 1e-9, "quintic sey");
|
||||
rel_close(r[4][1], 170518.81941587824, 1e-7, "quintic ssresid");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn linest_drops_collinear_columns() {
|
||||
// x2 = 2·x1: the later column is dropped (coefficient and standard error 0), the fit is the
|
||||
// one on x1 alone, and the degrees of freedom count only the kept column.
|
||||
let x1 = [1.0, 2.0, 3.0, 4.0, 5.0];
|
||||
let y = [2.0, 4.0, 5.0, 4.0, 5.0];
|
||||
let x2: Vec<f64> = x1.iter().map(|v| 2.0 * v).collect();
|
||||
let r = linest_rows(&y, &[x1.to_vec(), x2], true);
|
||||
// Exact: slope 0.6, intercept 2.2, ssresid 2.4, ssreg 3.6, df 3 (Fraction arithmetic).
|
||||
assert_eq!(r[0][0], Some(0.0));
|
||||
rel_close(r[0][1], 0.6, 1e-12, "slope");
|
||||
rel_close(r[0][2], 2.2, 1e-12, "intercept");
|
||||
assert_eq!(r[1][0], Some(0.0));
|
||||
rel_close(r[1][1], (0.8f64 / 10.0).sqrt(), 1e-12, "se slope");
|
||||
assert_eq!(r[3][1], Some(3.0));
|
||||
rel_close(r[4][0], 3.6, 1e-12, "ssreg");
|
||||
rel_close(r[4][1], 2.4, 1e-12, "ssresid");
|
||||
// A constant column is collinear with the intercept and dropped as well.
|
||||
let r = linest_rows(&y, &[vec![7.0; 5], x1.to_vec()], true);
|
||||
assert_eq!(r[0][1], Some(0.0));
|
||||
assert_eq!(r[1][1], Some(0.0));
|
||||
rel_close(r[0][0], 0.6, 1e-12, "slope");
|
||||
rel_close(r[0][2], 2.2, 1e-12, "intercept");
|
||||
// A constant column whose mean does not centre to exactly 0 (the mean of three 0.1 is
|
||||
// 0.10000000000000002) is just as collinear with the intercept: dropped, not scaled up to a
|
||||
// unit vector. Some length hits a rounding mean for each constant.
|
||||
for c in [0.1, 1.1, 1e6 + 0.3] {
|
||||
for n in 3..=12 {
|
||||
let xs: Vec<f64> = (1..=n).map(f64::from).collect();
|
||||
let ys: Vec<f64> = (1..=n).map(|i| f64::from(i * i % 7) + 0.5 * f64::from(i)).collect();
|
||||
let r = linest_rows(&ys, &[vec![c; n as usize], xs], true);
|
||||
assert_eq!(r[0][1], Some(0.0), "coefficient of the constant {c}, n={n}");
|
||||
assert_eq!(r[1][1], Some(0.0), "standard error of the constant {c}, n={n}");
|
||||
assert_eq!(r[3][1], Some(f64::from(n) - 2.0), "df with the constant {c}, n={n}");
|
||||
}
|
||||
}
|
||||
// A column that merely sits far from zero is not noise and is kept.
|
||||
let off: Vec<f64> = x1.iter().map(|v| 1e9 + v).collect();
|
||||
let r = linest_rows(&y, &[off], true);
|
||||
rel_close(r[0][0], 0.6, 1e-6, "slope on an offset column");
|
||||
assert_eq!(r[3][1], Some(3.0));
|
||||
// Distinct values far from zero, whose spread is below 1e-12 of the offset, still vary.
|
||||
let r = linest_rows(&[0.0, 1.0, 2.0], &[vec![1e13, 1e13 + 1.0, 1e13 + 2.0]], true);
|
||||
rel_close(r[0][0], 1.0, 1e-9, "slope on a predictor with a 1e13 offset");
|
||||
assert_eq!(r[3][1], Some(1.0), "df: the predictor is kept");
|
||||
// Same at 1e15, where the spread is only a few ulps of the offset: still distinct doubles.
|
||||
let x15 = [1e15, 1e15 + 1.0, 1e15 + 2.0];
|
||||
let r = linest_rows(&[0.0, 1.0, 2.0], &[x15.to_vec()], true);
|
||||
rel_close(r[0][0], 1.0, 1e-9, "slope on a predictor with a 1e15 offset");
|
||||
rel_close(r[0][1], -1e15, 1e-9, "intercept on a predictor with a 1e15 offset");
|
||||
assert_eq!(r[3][1], Some(1.0), "df: the 1e15 predictor is kept");
|
||||
assert!(r[4][1].is_some_and(|v| v.abs() < 1e-9), "ssresid: the 1e15 line is exact, got {:?}", r[4][1]);
|
||||
let fitted = rows_of(&ev("TREND", vec![c(&[0.0, 1.0, 2.0]), c(&x15)]));
|
||||
close(fitted[2][0].clone(), 2.0);
|
||||
// More predictors than observations: the surplus columns drop, no panic.
|
||||
let r = linest_rows(&[1.0, 2.0], &[vec![1.0, 2.0], vec![2.0, 1.0], vec![0.0, 5.0]], true);
|
||||
assert_eq!(r[0].len(), 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn logest_is_linest_of_ln_y() {
|
||||
// y = 5·2^x: m = 2, b = 5.
|
||||
let x = [0.0, 1.0, 2.0, 3.0, 4.0];
|
||||
let y: Vec<f64> = x.iter().map(|v| 5.0 * 2f64.powf(*v)).collect();
|
||||
let l = rows_of(&ev("LOGEST", vec![c(&y), c(&x)]));
|
||||
close_tol(l[0][0].clone(), 2.0, 1e-12);
|
||||
close_tol(l[0][1].clone(), 5.0, 1e-12);
|
||||
// The statistics are those of the fit on ln y, untransformed.
|
||||
let ln: Vec<f64> = y.iter().map(|v| v.ln()).collect();
|
||||
let ls = rows_of(&ev("LOGEST", vec![c(&y), c(&x), b(true), b(true)]));
|
||||
let ns = rows_of(&ev("LINEST", vec![c(&ln), c(&x), b(true), b(true)]));
|
||||
assert_eq!(ls[1..], ns[1..]);
|
||||
close_tol(ls[0][0].clone(), ns[0][0].as_f64().unwrap().exp(), 1e-14);
|
||||
}
|
||||
|
||||
// #2177: one predictor row of 16,384 columns built three 16,384² matrices (6 GB) and an O(k³)
|
||||
// inversion; a wider TOROW aborted the process. It is now refused before allocating.
|
||||
#[test]
|
||||
|
||||
@@ -53,6 +53,15 @@ impl Remote {
|
||||
self.conn = None;
|
||||
let mut last = std::io::Error::new(std::io::ErrorKind::NotFound, format!("cannot resolve {}", self.addr));
|
||||
for sa in self.addr.to_socket_addrs()? {
|
||||
// The token goes over plain TCP, so only to this machine: a network peer could read it,
|
||||
// and the app's control port listens on loopback only.
|
||||
if !sa.ip().is_loopback() {
|
||||
last = std::io::Error::new(
|
||||
std::io::ErrorKind::PermissionDenied,
|
||||
format!("{sa} is not a loopback address: the control token is sent only to 127.0.0.1 or ::1"),
|
||||
);
|
||||
continue;
|
||||
}
|
||||
match TcpStream::connect_timeout(&sa, Duration::from_secs(2)) {
|
||||
Ok(s) => {
|
||||
s.set_nodelay(true).ok();
|
||||
|
||||
@@ -482,6 +482,9 @@ fn remote_backend_over_tcp() {
|
||||
drop(s);
|
||||
handle.join().unwrap();
|
||||
assert!(Remote::connect_with_token("127.0.0.1:1", "x".into()).is_err());
|
||||
// A network address is refused before anything, the token included, is sent.
|
||||
let err = Remote::connect_with_token("192.0.2.1:7979", "x".into()).err().unwrap();
|
||||
assert_eq!(err.kind(), std::io::ErrorKind::PermissionDenied, "{err}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -9,7 +9,10 @@ use crate::style::{Color, Style};
|
||||
mod pivot;
|
||||
mod print;
|
||||
|
||||
pub use pivot::{PivotCalcField, PivotDateGroup, PivotField, PivotFilter, PivotFunc, PivotLayout, PivotShowAs, PivotSort, PivotTable, PivotValue};
|
||||
pub use pivot::{
|
||||
PIVOT_INDEXER, PivotCalcField, PivotDataCell, PivotDateGroup, PivotField, PivotFilter, PivotFunc, PivotIndexer, PivotItemRef, PivotLayout,
|
||||
PivotLookup, PivotShowAs, PivotSort, PivotTable, PivotValue, pivot_key,
|
||||
};
|
||||
pub use print::{EditRange, HfPage, LineInfo, Orientation, PageOrder, PrintSettings, SheetProtection, password_hash};
|
||||
|
||||
// ---------------------------------------------------------------- tables
|
||||
@@ -668,6 +671,9 @@ pub enum ShapeKind {
|
||||
/// A freehand ink stroke; `Shape::text` holds the points as `x,y;x,y;…` relative to the
|
||||
/// anchor (sheet points), `Shape::line` the ink colour and `fill` unused.
|
||||
Ink,
|
||||
/// Decorative text (`insert.wordArt`): a transparent shape whose `Shape::text` is drawn with
|
||||
/// the large, filled/outlined/shadowed text properties of `Shape::format`.
|
||||
WordArt,
|
||||
/// An equation: `Shape::text` holds its LaTeX source, `Shape::line` its ink colour
|
||||
/// (`Color::Auto` for the sheet's text colour) and `Shape::math` its cached layout.
|
||||
Equation,
|
||||
@@ -1026,6 +1032,8 @@ pub struct ShapeFormat {
|
||||
pub text_color: Option<Color>,
|
||||
/// Text outline (`a:rPr/a:ln`): colour and width in points.
|
||||
pub text_outline: Option<(Color, f32)>,
|
||||
/// Text drop shadow colour (`a:rPr/a:effectLst/a:outerShdw`); `None` is no shadow.
|
||||
pub text_shadow: Option<Color>,
|
||||
/// `None`: the shape's default (left for text boxes, centred for other shapes).
|
||||
pub align: Option<ShapeTextAlign>,
|
||||
/// `None`: the shape's default (top for text boxes, middle for other shapes).
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
use gridcraft_core::Value;
|
||||
|
||||
use super::{CellRef, RangeRef};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
@@ -131,6 +133,11 @@ pub struct PivotTable {
|
||||
pub last_range: Option<RangeRef>,
|
||||
/// Calculated fields, usable in the Values area by name.
|
||||
pub calculated_fields: Vec<PivotCalcField>,
|
||||
/// Where GETPIVOTDATA finds the report's value cells, as of the last refresh. Shared between
|
||||
/// workbook clones (so editing the pivot's sheet doesn't copy it), set on refresh and saved
|
||||
/// with the report, so a reopened unrefreshed pivot still reads the report it stored. Only a
|
||||
/// pivot loaded without one (XLSX) builds it on first use, checked against the stored report.
|
||||
pub data_index: PivotLookup,
|
||||
/// The Σ Values pseudo-field (it exists with two or more value fields) sits in Rows rather
|
||||
/// than Columns (Excel's "values on rows").
|
||||
pub values_on_rows: bool,
|
||||
@@ -149,6 +156,143 @@ pub struct PivotCalcField {
|
||||
pub formula: String,
|
||||
}
|
||||
|
||||
/// One value cell of a computed PivotTable report: the value field, the row and column items
|
||||
/// that locate it (fewer for subtotals, none for the grand total) and where the report shows it.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
|
||||
pub struct PivotDataCell {
|
||||
/// The value field's caption ("Sum of Sales").
|
||||
pub data_field: String,
|
||||
/// The value field's source column ("Sales").
|
||||
pub source_col: String,
|
||||
pub items: Vec<PivotItemRef>,
|
||||
/// Row and column of the cell, counted from the report's top-left cell.
|
||||
pub row: u32,
|
||||
pub col: u32,
|
||||
}
|
||||
|
||||
/// Builds a PivotTable's value cells from its source (`sheet` is the pivot's sheet). The engine
|
||||
/// sets it; the model can't compute reports.
|
||||
pub type PivotIndexer = fn(&crate::Workbook, usize, &PivotTable) -> Result<Vec<PivotDataCell>, String>;
|
||||
pub static PIVOT_INDEXER: std::sync::OnceLock<PivotIndexer> = std::sync::OnceLock::new();
|
||||
|
||||
fn norm(s: &str) -> String {
|
||||
s.trim().to_lowercase()
|
||||
}
|
||||
|
||||
/// One part of a lookup key: length-prefixed, so no label text can imitate a separator.
|
||||
fn key_part(out: &mut String, s: &str) {
|
||||
out.push_str(&s.len().to_string());
|
||||
out.push(':');
|
||||
out.push_str(s);
|
||||
}
|
||||
|
||||
/// The lookup key of a value field with field/item labels (names ignore case and outer blanks).
|
||||
/// Each item is `(field, label, is_bool)`: a Boolean item and a text item with the same label
|
||||
/// are different items.
|
||||
pub fn pivot_key(data_field: &str, items: &[(&str, &str, bool)]) -> String {
|
||||
let mut parts: Vec<String> = items
|
||||
.iter()
|
||||
.map(|(f, l, b)| {
|
||||
let mut p = String::new();
|
||||
key_part(&mut p, &norm(f));
|
||||
key_part(&mut p, &norm(l));
|
||||
p.push(if *b { 'b' } else { 't' });
|
||||
p
|
||||
})
|
||||
.collect();
|
||||
parts.sort_unstable();
|
||||
let mut key = String::new();
|
||||
key_part(&mut key, &norm(data_field));
|
||||
key.push_str(&parts.len().to_string());
|
||||
key.push('|');
|
||||
for p in parts {
|
||||
key.push_str(&p);
|
||||
}
|
||||
key
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct LookupInner {
|
||||
cells: std::sync::OnceLock<Vec<PivotDataCell>>,
|
||||
keys: std::sync::OnceLock<std::collections::HashMap<String, usize>>,
|
||||
}
|
||||
|
||||
/// A PivotTable's GETPIVOTDATA index. Clones share it, so `Workbook` clones per command stay
|
||||
/// cheap however large the report is. The cells are set on refresh or on first use; the hash of
|
||||
/// them is built on the first lookup.
|
||||
#[derive(Clone, Default)]
|
||||
pub struct PivotLookup(std::sync::Arc<LookupInner>);
|
||||
|
||||
impl PivotLookup {
|
||||
/// The value cells, if they were set.
|
||||
pub fn cells(&self) -> Option<&[PivotDataCell]> {
|
||||
self.0.cells.get().map(Vec::as_slice)
|
||||
}
|
||||
|
||||
/// Sets the value cells (the first set wins) and returns them.
|
||||
pub fn set_cells(&self, cells: Vec<PivotDataCell>) -> &[PivotDataCell] {
|
||||
self.0.cells.get_or_init(|| cells)
|
||||
}
|
||||
|
||||
/// The cell with this value field and exactly these items, by hash.
|
||||
pub fn find(&self, data_field: &str, items: &[(&str, &str, bool)]) -> Option<&PivotDataCell> {
|
||||
let cells = self.0.cells.get()?;
|
||||
let keys = self.0.keys.get_or_init(|| {
|
||||
let mut m = std::collections::HashMap::with_capacity(cells.len());
|
||||
for (i, c) in cells.iter().enumerate() {
|
||||
let items: Vec<(&str, &str, bool)> =
|
||||
c.items.iter().map(|it| (it.field.as_str(), it.label.as_str(), matches!(it.value, Value::Bool(_)))).collect();
|
||||
m.entry(pivot_key(&c.data_field, &items)).or_insert(i);
|
||||
m.entry(pivot_key(&c.source_col, &items)).or_insert(i);
|
||||
}
|
||||
m
|
||||
});
|
||||
keys.get(&pivot_key(data_field, items)).and_then(|i| cells.get(*i))
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for PivotLookup {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
write!(f, "PivotLookup({} cells)", self.cells().map_or(0, <[PivotDataCell]>::len))
|
||||
}
|
||||
}
|
||||
|
||||
/// Saved as the list of value cells (or nothing before the first refresh); the hash is rebuilt.
|
||||
/// An empty list is never saved: it is no index, and restoring one would lock the shared lookup
|
||||
/// against the lazy rebuild that a reopened workbook needs.
|
||||
impl Serialize for PivotLookup {
|
||||
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
|
||||
self.cells().filter(|cells| !cells.is_empty()).serialize(s)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'de> Deserialize<'de> for PivotLookup {
|
||||
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
|
||||
let l = PivotLookup::default();
|
||||
if let Some(cells) = Option::<Vec<PivotDataCell>>::deserialize(d)?
|
||||
&& !cells.is_empty()
|
||||
{
|
||||
l.set_cells(cells);
|
||||
}
|
||||
Ok(l)
|
||||
}
|
||||
}
|
||||
|
||||
/// The index is a cache, not part of a PivotTable's identity.
|
||||
impl PartialEq for PivotLookup {
|
||||
fn eq(&self, _: &Self) -> bool {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
/// A row or column field item: the field's source column, the item's label and its value.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
|
||||
pub struct PivotItemRef {
|
||||
pub field: String,
|
||||
pub label: String,
|
||||
pub value: Value,
|
||||
}
|
||||
|
||||
impl Default for PivotTable {
|
||||
fn default() -> Self {
|
||||
PivotTable {
|
||||
@@ -170,8 +314,65 @@ impl Default for PivotTable {
|
||||
show_headers: true,
|
||||
last_range: None,
|
||||
calculated_fields: vec![],
|
||||
data_index: PivotLookup::default(),
|
||||
values_on_rows: false,
|
||||
values_position: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod pivot_lookup_tests {
|
||||
use super::*;
|
||||
|
||||
fn cell(field: &str, label: &str, value: Value, row: u32) -> PivotDataCell {
|
||||
PivotDataCell {
|
||||
data_field: "Sum of Sales".into(),
|
||||
source_col: "Sales".into(),
|
||||
items: vec![PivotItemRef { field: field.into(), label: label.into(), value }],
|
||||
row,
|
||||
col: 1,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn labels_with_separator_characters_do_not_collide() {
|
||||
let l = PivotLookup::default();
|
||||
// Two different (field, label) pairs that a separator-joined key would make identical.
|
||||
l.set_cells(vec![cell("A\u{2}B", "C", Value::Text("C".into()), 1), cell("A", "B\u{2}C", Value::Text("B\u{2}C".into()), 2)]);
|
||||
assert_eq!(l.find("Sales", &[("A\u{2}B", "C", false)]).unwrap().row, 1);
|
||||
assert_eq!(l.find("Sales", &[("A", "B\u{2}C", false)]).unwrap().row, 2);
|
||||
// A label carrying the old pair separator cannot stand for two items.
|
||||
assert!(l.find("Sales", &[("A", "B", false), ("C", "D", false)]).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boolean_and_text_items_with_one_label_are_different_items() {
|
||||
let l = PivotLookup::default();
|
||||
l.set_cells(vec![cell("Flag", "TRUE", Value::Text("TRUE".into()), 1), cell("Flag", "TRUE", Value::Bool(true), 2)]);
|
||||
assert_eq!(l.find("Sales", &[("Flag", "TRUE", true)]).unwrap().row, 2);
|
||||
assert_eq!(l.find("Sales", &[("Flag", "TRUE", false)]).unwrap().row, 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn index_round_trips_through_serde() {
|
||||
let l = PivotLookup::default();
|
||||
l.set_cells(vec![cell("Region", "East", Value::Text("East".into()), 1)]);
|
||||
let back: PivotLookup = serde_json::from_str(&serde_json::to_string(&l).unwrap()).unwrap();
|
||||
assert_eq!(back.find("Sales", &[("Region", "East", false)]).unwrap().row, 1);
|
||||
let none: PivotLookup = serde_json::from_str(&serde_json::to_string(&PivotLookup::default()).unwrap()).unwrap();
|
||||
assert!(none.cells().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_empty_lookup_is_saved_as_no_index() {
|
||||
// An empty cell list is no index, so it must not be saved as an empty one: restoring an
|
||||
// empty index counts as an initialized lookup, which blocks the lazy rebuild.
|
||||
let l = PivotLookup::default();
|
||||
l.set_cells(vec![]);
|
||||
let saved = serde_json::to_string(&l).unwrap();
|
||||
assert_eq!(saved, "null", "an empty lookup saves no index: {saved}");
|
||||
let back: PivotLookup = serde_json::from_str("[]").unwrap();
|
||||
assert!(back.cells().is_none(), "an empty saved list restores no index");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -235,11 +235,12 @@ impl CellStore {
|
||||
bytes = bytes.saturating_add(size_of::<Band>());
|
||||
for (row, cols) in &band.rows {
|
||||
bytes = bytes.saturating_add(size_of::<u32>() + 3 * size_of::<usize>());
|
||||
let next_row = next.and_then(|b| b.rows.get(row));
|
||||
for (col, cell) in cols {
|
||||
// Cells and BTreeMap nodes are duplicated with a cloned band even when
|
||||
// their formula/value Arcs are still shared with the next snapshot.
|
||||
bytes = bytes.saturating_add(size_of::<u32>() + size_of::<Cell>() + 3 * size_of::<usize>());
|
||||
let next_cell = next.and_then(|b| b.rows.get(row)).and_then(|r| r.get(col));
|
||||
let next_cell = next_row.and_then(|r| r.get(col));
|
||||
if let Some(formula) = &cell.formula
|
||||
&& !next_cell.and_then(|c| c.formula.as_ref()).is_some_and(|f| Arc::ptr_eq(f, formula))
|
||||
{
|
||||
|
||||
@@ -3,10 +3,18 @@ name = "gridcraft-pdf"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
description = "GridCraft's tiny self-contained PDF 1.7 writer (standard 14 fonts, vector drawing, RGBA images)"
|
||||
description = "GridCraft PDF 1.7 writer with shaped Arabic text, vector drawing and RGBA images"
|
||||
readme = "README.md"
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
|
||||
[dependencies]
|
||||
craft-stream-codecs.workspace = true
|
||||
harfrust = "=0.12.0"
|
||||
skrifa = { workspace = true }
|
||||
unicode-bidi = "=0.3.18"
|
||||
|
||||
[build-dependencies]
|
||||
sha2 = { workspace = true }
|
||||
skrifa = { workspace = true }
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# gridcraft-pdf
|
||||
|
||||
A small, dependency-free PDF 1.7 writer for vector drawing and RGBA images.
|
||||
A small PDF 1.7 writer for shaped Arabic text, vector drawing and RGBA images.
|
||||
|
||||
## API migration
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user