Compare commits

...
Author SHA1 Message Date
Dylan M. Taylor 6ec4034b26 fix(xlsx): retain visible text in rejected Office Math boxes 2026-11-18 22:06:41 -05:00
Dylan M. Taylor 72f11bbacb fix(xlsx): preserve OMML fallback and bound conversion 2026-11-18 21:49:15 -05:00
Dylan M. Taylor 5cbe45d16e Cut over xlsx omml to craft-math (#4515)
* Cut over xlsx omml to craft-math (storytold/craft-libs#778)

* fix(omml): preserve opposite-side brace limit placement
2026-11-18 21:41:12 -05:00
5514a3a099 xlsx: fix main after the ODS cutover (clippy, empty first sheet, values, package checks) (#4518)
* xlsx: clear the two clippy errors the ODS cutover left on main

SheetNames::insert lost its only caller when the ODS reader moved to
craft-ods, and craft_ods::Value::Text already holds an Arc<str>.

* xlsx: ODS import keeps only the ODS tables, with unique valid names

The craft-ods cutover (#4513) built the workbook with Workbook::new(),
which already holds an empty Sheet1, and appended the ODS tables after
it. Opening an ODS file therefore showed an empty first sheet, and
ods_import_keeps_cached_values_and_reports_limits (plus the reader's
own sheets[0] tests) failed. It also stopped making sheet names unique
and valid, so two tables named Data and data became two sheets with
clashing names.

Clear the default sheet as the XLSX, XLS and XLSB readers do, and name
sheets through SheetNames again, as the reader did before the cutover.
That restores SheetNames::insert, which the previous commit removed
while it was unused.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* xlsx: ODS import keeps unreadable values as text and the exact mimetype check

Three more behaviours the craft-ods cutover (#4513) dropped, each
covered by an ods_tests case that has failed since:

- A cell whose typed value cannot be read (an unparsable number or
  date, a calcext error cache, a formula without a result) was skipped
  or marked unavailable. It keeps its displayed text again, else its
  raw value, with the same warning as before.
- Number formats are the old ones again: [h]:mm:ss.000 for durations
  and yyyy-mm-dd hh:mm:ss.000 for dates with a time. They are applied
  only when the typed value was read.
- read_ods checks the exact mimetype first, as sniff does; craft-ods
  alone accepted one with a trailing space.

The encryption case now writes its encryption-data inside the
content.xml file entry, where LibreOffice puts it and where craft-odf
looks for it. A bare one under the manifest root encrypts nothing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: FredApps <FredApps@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 09:10:52 +07:00
MaciekandMaciej Malinowski 42acfafcd3 Find and Replace: Undo and Redo reach the sheet while the dialog is open (#2140)
* Find and Replace: Undo and Redo reach the sheet while the dialog is open

Ctrl+Z after Replace All did nothing until the dialog was closed: the open
dialog kept the keyboard from the grid. The dialog now undoes and redoes
the workbook itself unless a text box has focus (there the shortcuts edit
the typed text).

* Find and Replace: Undo and Redo use the sheet's shortcut table

The dialog passed hard-coded keys to edit.undo and edit.redo. It now hands
Cmd/Ctrl+Z, Cmd/Ctrl+Shift+Z and Cmd/Ctrl+Y to ribbon::shortcut, the table
the grid uses, so the dialog and the sheet keep the same bindings. The test
also covers the Mac Redo shortcut (Cmd+Shift+Z).

* fix(find): allow workbook undo when a dialog button has focus

Reserve Undo/Redo for text editing only while a text edit has focus. The regression reproduces the failure with keyboard focus on Replace All, checks both Redo shortcuts, and verifies text-field Undo leaves the sheet unchanged. Regression failed before the fix and passes now. Validation: 1143 UI integration tests pass; only existing missing-glyph failures U+1E9E and U+1EBB remain. WASM, assets, layers and generators pass. Full CI reaches the unchanged Windows CLI clippy::only_used_in_recursion failure in apps/gridcraft-cli/src/check.rs.

* fix(find): block workbook shortcuts behind a modal message

Check app.message before dispatching workbook Undo/Redo. Regression uses an empty Replace All search to open the real error, covers all three shortcuts, and checks Redo after dismissal. Extend text-focus coverage to type and undo actual text. Modal regression fails before the guard and passes after it. Validation: 1144 integration tests pass; two existing missing-glyph failures remain. WASM, assets and layers pass. Full CI still stops at the unchanged Windows CLI clippy::only_used_in_recursion warning.

---------

Co-authored-by: Maciej Malinowski <231036771+webglobecontact-ui@users.noreply.github.com>
2026-11-19 08:37:18 +07:00
Dylan M. Taylor 83ab01678a Cut over gridcraft-xlsx ODS reader to craft-ods (#4513) 2026-11-18 17:22:18 -05:00
Michael Higgins 00e8f4fae0 Drag a selected chart's data outline to change its range (#4389, #4390) (#4391)
#4389, #4390: drag a selected chart's data outline to change its range

A selected chart now outlines its data as Excel does: series names in red,
category labels in purple and the values as one blue block. The values
block has a handle on each corner. Dragging one previews the new block,
and the release points the chart at it as one undo step. Esc cancels.

The new engine command chart.setValuesRange does the move. Each series
keeps its formatting, a wider block adds series and a narrower one drops
them, and names, category labels and bubble sizes that line up with the
block follow it. PivotCharts and series that are not one block are
refused.
#4389: chart data drag review fixes

- Category labels are compared as blocks, so a reference written with a
  leading = still counts as the same labels.
- A resize keeps the orientation the series were read in, so a chart
  shrunk to one cell per series stays resizable.
- The preview stays while edge scrolling moves the chart off screen.
- A values corner hidden under frozen panes is not a handle.
- The release takes the block from the pointer's last position, even when
  it moved in the release frame.
- Esc cancels the drag with Ctrl or Cmd held too.

Each fix has a test that fails without it.
#4389: read a corner drag from the grabbed corner's own cell

A values corner lies on a cell boundary, which belongs to the next row
and column, so a press on the bottom-right corner of A1:A5 read as B6:
releasing where the press was, or dragging straight down the edge of
column A, changed the other axis too. The drag now records the offset
from the press point to the centre of the corner's cell and reads the
pointer through it, so the press point stays in its cell and each whole
cell of movement moves the corner by one.
#4389: snap a dragged chart data edge to the nearest gridline

Reading the pointer from the middle of the grabbed corner's cell let the
grabbed row's height decide when the block moved: with a tall row 5 and
a short row 6, the pointer reached the bottom of row 6 while the block
stayed at A1:A5. Each edge the corner moves now snaps to the gridline
nearest the pointer, so every row and column changes over at its own
middle. A release where the press was still changes nothing, since the
corner lies on its own gridlines, and an edge dropped on its fixed edge
keeps one row or column.
#4389: drop a chart data drag when the chart's data changes under it

A command run between frames (the control channel, a macro) could change
the chart's values block while the button was held, and the release then
put the dragged block over that change. The drag now checks, from the
session, that the chart still plots the block it started from: a move
drops a stale drag, and the release skips it.
2026-11-18 21:53:00 +07:00
neilcawse f8af138f28 XLSX: read, evaluate and write Excel 2010 conditional formats (#717)
XLSX: read, evaluate and write Excel 2010 conditional formats

Excel 2010+ keeps conditional format rules whose formulas refer to
other sheets only in the worksheet's x14:conditionalFormattings
extension, with xm:f formulas and an inline x14:dxf in place of a
dxfId. GridCraft skipped the whole extension with a warning.

Read: x14 cellIs (every operator, one or two formulas), expression,
blanks, errors, duplicate/unique, top 10, above average and time
period rules become ordinary rules, with the inline differential
format (font, fill, border, number format) and priorities that
interleave with the main section's. A data bar's linked extension
(the x14:id of a main-section rule) adds no second rule. Other x14
kinds (data bar settings, x14 icon sets) are skipped with a warning
naming the kind.

Evaluate: cross-sheet references in rule formulas already resolve;
an engine test pins cellIs and expression rules against cells on
another sheet.

Write: a cell-value or formula rule referring to another sheet is
written in the x14 extension ({78C0D931-6437-407d-A8EE-F0AAD7539E65})
with an inline x14:dxf and a unique id; other rules stay in the main
section. The extension shares one extLst with the sparklines (CF
first). Inline number formats get ids styles.xml declares.

XLSX: say which x14 conditional format rules stay in the main section

Colour scale, data bar and icon set rules are always written in the main
section, even when their cfvo formulas refer to other sheets; the parity
docs now say so. (This commit first dropped the
reader's own x14:id linking; after the rebase onto main, main's data bar
linking from #550 is the one path, so only the docs part remains.)
XLSX: correct the x14 conditional format provenance and list skipped kinds

The file that motivated the x14 conditional format work
(watchdog-report.xlsx) was saved by LibreOffice 25.2, not Excel, so
nothing observed in Excel backs the earlier commit's statement that
Excel 2010+ keeps cross-sheet rules only in the extension. MS-XLSX
2.6.27 (CT_CfRule) allows single-sheet references in xm:f but says
nothing about where Excel places such rules; the comments and docs now
say the placement follows the LibreOffice-saved file and Excel's own
is unverified.

MS-XLSX 2.6.27 forbids sheet-range-reference (3-D spans) in xm:f, so a
rule with a 3-D span now stays in the main section.

The parity docs and gaps list name the x14 kinds read (cellIs,
expression, blanks, errors, duplicate/unique, top10, aboveAverage,
timePeriod) and those skipped with a warning and lost on save (data
bars, icon sets, colour scales, containsText, notContainsText,
beginsWith, endsWith).

Styles: differential formats keep their cell protection on save

dxf_xml, which writes both styles.xml dxfs and inline x14:dxf elements, wrote font, number format, fill, alignment and border but never protection, although read_dxf reads it. A rule whose format unlocked or hid cells lost that on save. It now writes protection after border, the order CT_Dxf requires.
XLSX: solid data bars are saved with negatives in the bar colour and no axis, as GridCraft draws them
docs: order parity revision history
docs: record verified x14 conditional format placement
docs: fold the Excel check into the PR's own changelog row instead of a new dated row
docs: the Excel check covered cross-sheet expression rules, not cell-value rules
Fix differential format serialization
Preserve default dxf protection
2026-11-18 21:13:46 +07:00
Harrison Booth aef4ceb10d RATE follows Excel's iteration (#2502)
fix(functions): RATE follows Excel's iteration

RATE used Newton with fallbacks and a bracketing search, so it found roots
Excel doesn't and missed the last iterate Excel returns. It now follows
Excel's solver as observed with synthetic inputs: a secant iteration from
the guess and the guess moved 0.001 toward a larger equation value, at most
200 steps, stopping when a step is under 1e-7 and the equation is within
1e-7 of zero (or as close as its terms allow), with the result more than
1e-7 above -100%. After 200 steps the last iterate is kept if it is within
a looser 1e-4. Subnormal steps flush to zero as in Excel.

RATE(5,0,-100,0) is now -0.999999409145182 like Excel (was #NUM!), and
RATE(4,0,-0.0001,100) is #NUM! like Excel (was 30.62). A guess at or below
-1 is #VALUE!. IRR and XIRR keep their solver.

RATE test: compare with a relative tolerance, not exact equality
ROADMAP: keep the progress log in descending date order
RATE: pin Excel's #NUM! for a fractional nper with a guess near -1
2026-11-18 20:39:57 +07:00
FredApps 8f8078c134 Fix main's build and tests after the recent merges (#4474)
- Import SheetApp in the pivot pane tests.
- Move the keyboard owner check out of keyboard() to stay within the complexity limit.
- Aim the title bar button helper at the button's own node.

Fixes #4473.

Signed-off-by: FredApps <153173854+FredApps@users.noreply.github.com>
2026-11-18 19:50:37 +07:00
FredApps c9d2883b86 Merge pull request #2028 from SoftwareBeesy/parity-crlf-windows
xtask: `parity --check` accepts a CRLF checkout of the checklist
2026-11-18 16:45:30 +07:00
Michael Higgins a3119f57c2 xlsx/csv: cap secondary reader allocations (#2159) (#2199)
* xlsx/csv: cap secondary reader allocations (#2159)
  
  - XML: at most 1M children per element, 16,384 per worksheet row (TooLarge).
  - Workbook-wide cap of 16M cell elements.
  - Array-formula ranges indexed by row (budgeted), not scanned per cell.
  - <cols> writes share a 4M budget.
  - At most 4096 sheets; duplicate names deduplicated with a HashSet.
  - Pivot: field lists capped, repeated fields used once, labels borrowed.
  - CSV: fields past MAX_COLS dropped while reading the record.
  - At most 4M shared strings.
  - Relationships looked up by id through a HashMap.

* xlsx: close the remaining secondary-reader cap gaps (#2159)
  
  - CSV: characters of a field past column 16,384 are not stored; quotes,
    delimiters and line ends in it are still followed.
  - Pivot: a field list cut at MAX_FIELDS is reported with a warning.
  - Sheet names: the prefix shortens once the (n) suffix passes (999), so
    deduplicated names stay within 31 characters.
  - Rows dropped for a bad row number still charge their <c> elements
    against MAX_CELLS.
  - Test Ctx helper gains the fields upstream added.

* #2159: describe MAX_CELLS as the reader's own cap
  
  calc::eval::MAX_CELLS has the same value but limits one array result,
  not a workbook.

* #2159: warn on capped pivot cache fields, dedupe pivot names through sets
  
  A cache cut at 16,384 fields is now reported, as the table field lists
  are. Axis filters and calculated fields are deduplicated through a set
  of lower-cased names instead of a scan per field, which was quadratic in
  the 16,384 fields allowed; the first of names equal but for case still
  wins.
2026-11-18 16:36:37 +07:00
NetterSilver 272ae54101 Delete separate rows or columns in one pass (#2385)
* Delete separate rows or columns in one pass
  
  Fixes #2287
2026-11-18 16:35:49 +07:00
NetterSilver bf48def687 Create new saved files without group/other write permission (#2567)
* Create new saved files without group/other write permission
  
  Fixes #2519
2026-11-18 16:35:20 +07:00
Michael Higgins dbf674ef48 links: spawn the Windows opener by absolute path (#2176) (#2204)
* links: spawn the Windows opener by absolute path (#2176)
  
  Explorer is now spawned as %SystemRoot%\explorer.exe (falling back to
  windir, then C:\Windows; only local drive paths are accepted), so an
  explorer.exe planted next to the app or in the CWD can't run. Space, ",
  comma and ^ are percent-encoded before Explorer parses its command line.
  macOS uses /usr/bin/open; a target starting with - or / is refused on
  every platform so it can never become an opener option.

* links: rename opener enum variant (clippy)
  
  `Os::MacOs` -> `Os::Mac` (clippy::enum_variant_names). Also give the
  desktop-theme watcher's non-Linux `Link` a non-unit type so
  clippy::let_unit_value stops firing on Windows/macOS.

* ui: leave desktop_theme Link alone (covered by #2141)

* #2176: say why the Explorer escape still encodes commas
2026-11-18 16:34:32 +07:00
FredApps 644861c132 Merge pull request #449 from neilcawse/fix/main-ci-csv-tests
CSV/text export: General numbers without exponents (integers below 1e16 exact); `&` switches to scientific past 21 characters
2026-11-18 16:34:02 +07:00
FredApps c8450fd1e5 Merge pull request #3784 from dotCooCoo/chore/craft-update-6e03f65
Updates: take craft-update from craft-libs main at e98299546
2026-11-18 16:28:11 +07:00
FredApps a492d8031a Merge pull request #3574 from SBaksa/intl-no-xlfn
XLSX: NETWORKDAYS.INTL and WORKDAY.INTL are saved without _xlfn. (fixes #3517)
2026-11-18 16:27:48 +07:00
FredApps 5b1d89f867 Merge pull request #3047 from quantforge-br/function-help-portuguese
UI: Brazilian Portuguese function help
2026-11-18 16:27:25 +07:00
FredApps 1f0d416f74 Merge pull request #3046 from quantforge-br/fix/spill-priority
Calc: a contested spill area stays with its array on full recalc and reopening (#964)
2026-11-18 16:27:02 +07:00
bmh129 82c97858df Linux: run on native Wayland again by default (revert #165) (#2789)
* Linux: run on native Wayland again by default (revert #165)
  
  winit 0.30.13 reported dropped files only on X11. The egui 0.37 migration
  (#2543) pins storytold/winit, whose patch W15 reports file drops through
  a per-seat Wayland data device (rust-windowing/winit#4729), so files
  dragged from the file manager open on native Wayland too. The XWayland
  default is no longer needed.
  
  It also costs a startup crash: winit's X11 backend loads
  libxkbcommon-x11, which the Linux packages don't depend on. Where it's
  missing (a Fedora toolbox, minimal installs), GridCraft panics before the
  window opens: "Library libxkbcommon-x11.so could not be loaded."
  
  Checked on GNOME (Wayland, Fedora 44) with a build of main plus other
  proposed changes, run with GRIDCRAFT_WAYLAND=1 (the path this revert
  makes the default): an .xlsx and a .csv dragged from Files each open as a
  workbook, and the app starts without libxkbcommon-x11 installed.
  
  This reverts commit 6f0e43c21c.
  
  Claude-Session: https://claude.ai/code/session_01Rvu8dWh26U2fsLQMSBQfH8
2026-11-18 16:26:39 +07:00
Zaxaerith 20c5742f79 fix(web): mark PDF exports in gridcraft:save (#2452) (#2535)
* fix(web): distinguish PDF exports in host save messages (#2452)
2026-11-18 16:26:01 +07:00
FredApps 21def4fa1a Merge pull request #2303 from MarekSpodBiedry/issue-2285
XLSX: write spilled text as cached strings, not shared strings (#2285)
2026-11-18 16:23:35 +07:00
FredApps 61ee368369 Merge pull request #2298 from dfendr/fix/table-style-looks
Tables: Give each style row its own look
2026-11-18 16:23:13 +07:00
FredApps d1a5c9671f Merge pull request #2293 from storytold/test/backfill-regression-tests
Regression tests for #223, #360 and #1485
2026-11-18 16:22:51 +07:00
Dominik Strebel 12dd9aea9b test: header AutoFit check measures the text as AutoFit did (#2273)
* test: header AutoFit check measures the text as AutoFit did
  
  table_filter_autofit_works_through_command_and_header_double_click
  compared the autofitted column with the engine's text-width estimate,
  but in the app AutoFit measures with the installed fonts
  (Session::text_width). Where those are narrower than the estimate (a
  Mac with Carlito, metric-compatible with Calibri), the estimate
  "overlapped" the filter button and the test failed on main. It now
  measures with the same function AutoFit used.

* test: the header AutoFit UI check measures with the app's fonts, which the app always installs
  
  The fallback to the engine's estimate never ran: SheetApp::logic installs the measure before
  AutoFit. AutoFit on the estimate is covered by the engine's autofit_filter_buttons tests.
2026-11-18 16:22:30 +07:00
FredApps 6980b00dac Merge pull request #2040 from alphazw/fix/ime-first-keystroke-bypasses-composition
IME: the first keystroke of a composition no longer lands in the cell
2026-11-18 16:22:08 +07:00
FredApps f36eaf3fbe Merge pull request #1960 from Hamza0101/checkbox-space
Space on a checkbox cell toggles it and nothing else
2026-11-18 16:21:31 +07:00
Vedran Doboš 12e1b5379b Keyboard: punctuation shortcuts follow the character the layout types (#1384) (#1385)
* Keyboard: punctuation shortcuts follow the character the layout types (#1384)
  
  On a Croatian or German keyboard Shift+, types `;`, so Excel inserts the
  date with Ctrl+Shift+,. GridCraft matched the key's US position and ran
  Decrease Font Size. Punctuation keys now go by the character typed
  (translated to the US key and Shift that type it), digits keep their
  position, and a character egui has no key for (č, ö) still falls back to
  the position. ribbon::shortcut reads the same key, so Ctrl+Shift+0
  typing `=` unhides columns instead of opening Insert, and Ctrl++ opens it.

* Keyboard: Cmd+Shift+; on a Mac doesn't insert today's date (review)
  
  ribbon::shortcut's Semicolon arm took Shift too, so the US-key mapping turned Cmd+Shift+; (and
  Cmd+Shift+. on a Croatian or German layout) into the date. Ctrl+Shift+; stays the time.

* Keyboard: tests for AZERTY and Czech, and for typing while a cell is edited (#1384)
  
  French AZERTY (`;` and `:` unshifted on the US `,` and `.` keys) and Czech (`;` on the US
  backtick key, `:` Shift+.) give the date and the time with Ctrl. The layout mapping runs only
  in the grid, which reads no shortcuts while a cell is edited; a test pins that: `;` and `:` typed
  as Shift+, and Shift+. on a Croatian or German keyboard go into the cell, and the font size stays.
2026-11-18 16:20:40 +07:00
bea2191b35 Fuzzer: undo checks follow the bounded undo history (#2332)
* Fuzzer: undo checks follow the bounded undo history

The undo history drops its oldest steps past 100 entries or 128 MB of snapshots (#1263). The
command-sequence fuzzer still compared "undo everything" with the episode's starting workbook,
so any episode whose snapshots passed the budget failed with "undoing all N steps doesn't give
back the starting workbook" although undo worked (seeds 104, 110 and 163 at 80 steps: a column
inserted next to whole-column borders, or rows deleted after filling whole columns, each made a
100 MB step).

The harness notices when an undoable command changed the workbook without the history growing,
and then compares with the state before the oldest step still in the history.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Fuzzer: undo and redo checks follow the reachable history boundary

Review of #2332. The harness now tracks the oldest state the undo history
can reach instead of a trimmed flag: whenever the history's oldest entry
changes without it emptying in between, the history dropped a step, and
undoing everything stops at the new oldest entry. That boundary is kept
when an edit.undo in the sequence uses up the retained history before the
episode ends, which used to fall back to the episode's start and report a
false undo mismatch.

The redo round trip no longer assumes n undos leave n redo entries: the
redo history is bounded too, so when it dropped the first step undone,
redo is expected to stop at the oldest entry it kept.

---------

Co-authored-by: nihilist-narwhal <240798405+nihilist-narwhal@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 22:36:17 -06:00
Neil Cawse 620174e069 Merge remote-tracking branch 'upstream/main' into fix/main-ci-csv-tests 2026-11-18 04:18:44 +00:00
Valentin KleinandClaude Opus 5.5 4c388df949 Flush a saved workbook to disk before replacing the old one (#3178)
* Flush a saved workbook to disk before the rename

write_file renamed the temporary file over the workbook without sync_all, so a power loss right after a save could leave an empty or truncated file under the workbook's name. Sync the file before the rename and, on unix, sync the folder after it (best effort).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Tolerate file systems that cannot flush when saving

On Apple targets std's sync_all asks for F_FULLFSYNC, which network mounts refuse with ENOTTY or ENOTSUP. Treat exactly those errors (and ErrorKind::Unsupported) from the temp file's sync as 'cannot flush here' and carry on with the rename, as before the flush was added. All other errors still fail the save.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Treat raw error 25 as unsupported-flush only on Unix

On Windows 25 is ERROR_SEEK, a real failure that must not be skipped.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Save: treat Apple's ENOTSUP from F_FULLFSYNC as unsupported flush

On Apple targets ENOTSUP is 45 and std leaves it uncategorized (only
EOPNOTSUPP, 102, and ENOSYS map to ErrorKind::Unsupported), so a volume
refusing F_FULLFSYNC with ENOTSUP failed the save and deleted the
temporary file. The raw code is now matched on Apple targets only;
elsewhere 45 is a different errno and stays a failed save. The check is
split into a platform-parameterised helper so each platform's codes are
tested on any host, plus an Apple-only test on the real helper.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-18 08:44:04 +07:00
Cheejyg 807cf23b02 Sort: Custom Sort dialog redesign (#1593)
* Sort: Custom Sort dialog redesign

* Sort: keep the dialog on its worksheet and open when sorting fails

* Improve custom sort dialog and localisation

Localise sort controls and adapt their layout to translations. Track worksheets by identity, restore selections across sheet changes, and allow additional levels to reuse columns.

* Fix sort dialog worksheet and input handling

Open Sort on the requested worksheet, reject invalid ranges, and close any open filter menu so Enter confirms the sort. Add regression tests for each case.
2026-11-18 08:43:41 +07:00
Neil Cawse 24f58a2ee4 Merge remote-tracking branch 'upstream/main' into fix/main-ci-csv-tests 2026-11-17 13:24:58 +00:00
Neil Cawse 319a3e4c2e Merge remote-tracking branch 'upstream/main' into fix/main-ci-csv-tests 2026-11-17 04:15:59 +00:00
Dylan M. Taylor d60709a173 pdf: follow up shared writer cutover with merged-library pin (#4407) 2026-11-16 22:44:24 -05:00
Dylan M. Taylor 0e5a82f084 ci: lock workflow actions through an actions.lock lockfile (#3879) 2026-11-16 21:58:36 -05:00
Dylan M. Taylor 4c943670cf pdf: move object and xref envelope writing to craft-pdf (#4398) 2026-11-16 21:58:31 -05:00
quantforge-br cf5e91ed5e Merge upstream/main into function-help-portuguese
# Conflicts:
#	docs/localization-parity.md
2026-11-16 23:13:57 -03:00
Dylan M. Taylor c8e69968c7 Merge pull request #4262 from vangel76/fix/ratex-parse-messages-i18n
Equation parse errors follow the interface language
2026-11-16 20:36:10 -05:00
Dylan M. Taylor 79742499b5 Merge pull request #3626 from vangel76/fix/i18n-hardcoded-strings
Status bar statistics, resize tips, sheet notes and macro toasts follow the interface language
2026-11-16 20:35:16 -05:00
Dylan M. Taylor d0f20a31da Merge pull request #4165 from vangel76/fix/4161-equation-fallback-font
Equation fallback text in xlsx is drawn at a normal font size
2026-11-16 20:32:51 -05:00
dotCooCoo 10506a1f1d Merge main into chore/craft-update-6e03f65 2026-11-16 17:09:15 -08:00
Dylan M. Taylor 7e4235c85b Merge pull request #4399 from storytold/dot/shared-xstring-20261117
xlsx: share SpreadsheetML string reader/writer codec (cutover stage 1)
2026-11-16 20:00:52 -05:00
Dylan M. Taylor ef87aaa590 test(xlsx): retain XML predicate for escaping oracle 2026-11-16 19:45:33 -05:00
Dylan M. Taylor 4ebc9a5127 Merge remote-tracking branch 'origin/main' into dot/shared-xstring-20261117 2026-11-16 19:44:21 -05:00
Dylan M. Taylor fc7698eb11 Merge pull request #4383 from Hamza0101/fix/table-hidden-total-row-keeps-calc
XLSX: a hidden Total Row keeps its calculations
2026-11-16 19:43:58 -05:00
Dylan M. Taylor 058ea183ec Merge pull request #4382 from Hamza0101/fix/xlsx-first-page-number
XLSX: keep Page Setup's first page number
2026-11-16 19:43:34 -05:00
Dylan M. Taylor faef1a06c8 xlsx: use shared SpreadsheetML string codec in reader and writer 2026-11-16 19:40:39 -05:00
vangel76 0c8e2f850e Merge fix/i18n-hardcoded-strings into fix/ratex-parse-messages-i18n 2026-11-16 21:55:34 +01:00
vangel76 54ebc232fb Merge upstream/main into fix/i18n-hardcoded-strings 2026-11-16 21:52:37 +01:00
Hamza 8d8716cdc0 XLSX: a hidden Total Row keeps its calculations
A table whose Total Row was turned off still holds each column's total:
Excel writes totalsRowFunction, totalsRowLabel and a custom
totalsRowFormula without totalsRowCount, and restores them when the row
is turned back on. The reader took them, but the writer wrote them only
while the row was shown, so a save lost a custom formula or an Average
and Excel brought back SUBTOTAL(109,...) instead. They are now written
whether the row is shown or not.

Fixes #4296
2026-11-16 20:10:00 +05:00
Hamza 496c13e7b4 XLSX: keep Page Setup's first page number
A sheet set to First page number 7 has pageSetup firstPageNumber="7"
useFirstPageNumber="1"; neither attribute was read, so a save reset it
to Automatic. PrintSettings now holds it (None for Automatic), the
reader takes the number when useFirstPageNumber is on, and the writer
writes both in the schema's order. A JSON workbook leaves it out when
Automatic, so existing files are written as before.

Fixes #4293
2026-11-16 20:04:07 +05:00
FredApps abcfc19153 Merge pull request #4364 from storytold/docs/shared-library-guidance
docs: prefer shared Craft libraries for reusable features
2026-11-16 13:51:45 +01:00
Dylan M. Taylor 3ca81a761b docs: prefer shared Craft libraries for reusable features 2026-11-16 06:27:17 -05:00
FredApps 1476d4e7ab Merge pull request #4184 from ZIDAN44/fix/3945-subtotal-grand-total-outline
engine: Subtotal groups every row under the grand total (#3945)
2026-11-16 10:25:43 +01:00
FredApps 91f153de5b Merge pull request #4247 from gmrmad1/docs/roadmap-2026-11-15
docs: bring ROADMAP.md and parity assessment current through 2026-11-15
2026-11-16 10:24:34 +01:00
FredApps 3443e06bfc Merge pull request #4183 from ZIDAN44/fix/3934-paste-row-down-narrow-selection
engine: paste repeats a copied row down a taller, narrower selection (#3934)
2026-11-16 10:24:21 +01:00
FredApps e1147239fc Merge pull request #4182 from ZIDAN44/fix/3949-custom-list-unlisted-sort
engine: custom-list sort puts unlisted values A to Z after the list (#3949)
2026-11-16 10:21:26 +01:00
Valentin KleinandClaude Opus 5.5 ef99f1e51f Functions: GETPIVOTDATA (#284) (#290)
* Functions: GETPIVOTDATA (#284)

The engine records each PivotTable report value cell (value field,
row/column items, value) on refresh and when a workbook is opened;
GETPIVOTDATA is an evaluator special form that looks the value up by
value field and field/item pairs, #REF! when the report doesn't show it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* GETPIVOTDATA: shared lazy index, report values, hash lookup (review of #290)

- PivotTable::data_index is an Arc-shared PivotLookup (serde-skipped), so the
  per-command workbook clone no longer copies the index; refresh sets it, clear resets it.
- No index work on open: the first GETPIVOTDATA on a pivot without one builds it from the
  source via the engine-registered PIVOT_INDEXER; a failure is #REF!, not an empty index.
- The result is the value the sheet shows at the cell's report position, so formula and
  report cell agree (test with a source edited after the last refresh).
- Lookup by a pre-lowercased hash key; numbers/booleans fall back to a scan on a miss.
- GETPIVOTDATA is no longer volatile: it depends on its pivot's whole report area.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* GETPIVOTDATA: keep the index of the stored report; collision-free keys; align estimates

The lookup index describes the report as last refreshed and is saved with
the pivot. A pivot loaded without one (XLSX) only builds it when the
recomputed layout matches the stored labels. Lookup keys are length-prefixed
and distinguish Boolean from text items. Function-parity estimates match.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* pivot: import PivotDataCell, PivotItemRef and PivotLookup explicitly after upstream dropped the glob import

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* pivot: add an ignored measurement of edits on a sheet with a large report

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* pivot: keep a failed lazy GETPIVOTDATA build retryable, never save an empty index

A failed lazy index build stored unwrap_or_default() into the shared,
first-set-wins PivotLookup, so a valid state coming later (undo, a
source fix, a reopen) could never rebuild it, and the empty list was
saved as a restored index. Cache only validated builds, treat an empty
list as no index in serialization, reject reports with more value
cells than the index cap instead of truncating, register the pivot
indexer in gridcraft-cli check, and add two regression tests.

* GETPIVOTDATA: move cached offsets with edits inside the report; exact numeric items first

Inserting or deleting rows or columns inside a report remapped the cells
and last_range but kept the cached value-cell offsets, so a lookup could
read another item's cell. shift_sheet_features now maps each indexed
cell through the edit into a new index (the shared one stays with the
undo snapshots); a value cell deleted with its line drops out (#REF!).

A numeric item was accepted on a formatted-label hash hit, so 0.6 and 1
both shown as "1" returned the first. A number now prefers the cell
whose item has exactly that value, before any label match.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Fix pivot chart test for the new Output.data field

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 08:59:28 +01:00
dotCooCoo 47b67127d5 Merge main into chore/craft-update-6e03f65 2026-11-15 17:56:30 -08:00
FredAppsandFredApps 19f07f3a25 Native JSON workbook: read and write through craft-gridcraft-format (#4320)
* Native JSON workbook: golden bytes before the move to craft-libs

A workbook with text, numbers, a formula, bold, a number format and a macro is
saved as native JSON. Its bytes, the bytes saved after a newer-format macro is
kept, and the error for a non-workbook file are golden files written by the
current code. Opening the golden file as .json and .scjson and saving it again
gives it back.

* Native JSON workbook: read and write through craft-gridcraft-format

The `.json`/`.scjson` extension check, the reader and its error text, and the
pretty writer with newer-format macros written back into `macros` now come from
craft-gridcraft-format (storytold/craft-libs#1749), pinned at its PR tip. The
Workbook model, the style-index and cell-band rebuilds after a read, and macro
reading and checks stay here.

The golden tests from the previous commit pass unchanged.

Part of storytold/craft-libs#778.

* Native JSON workbook: pin craft-gridcraft-format to the craft-libs merge commit 9a6d8942 (storytold/craft-libs#1749)

---------

Co-authored-by: FredApps <FredApps@users.noreply.github.com>
2026-11-16 02:14:28 +01:00
dotCooCoo 98bb5d6958 Merge main into chore/craft-update-6e03f65 2026-11-15 16:11:42 -08:00
Dylan M. Taylor 407e0e1fa9 Merge pull request #4314 from storytold/cutover/shared-pdf-runlength
pdf: use shared RunLength encoding for image streams
2026-11-15 17:36:23 -05:00
Dylan M. Taylor dbdec081e2 Merge pull request #4304 from storytold/extract/shared-xml-escaping
xlsx: reuse shared XML byte escaping
2026-11-15 17:19:16 -05:00
Dylan M. Taylor 24e40de94f Pin PDF RunLength dependency to merged shared fix 2026-11-15 17:02:36 -05:00
Dylan M. Taylor 44050e9447 Merge pull request #3023 from AxylumRust/fix/insert-modules-compiled
Engine: compile the insert submodules again (#2950)
2026-11-15 16:40:38 -05:00
Dylan M. Taylor d217e8272d Fix shared codec dependency for external GridCraft builds 2026-11-15 14:33:42 -05:00
Dylan M. Taylor f22b4ed9dd xlsx: import shared append escaping only for tests 2026-11-15 14:07:48 -05:00
Dylan M. Taylor 75c4b01db3 Use shared RunLength encoding for PDF image streams 2026-11-15 13:53:04 -05:00
quantforge-br 8a04139ef2 Calc: a spill keeps the cells it held when another array grows into them (#964)
#2483 lets a spill that already exists keep its cells, but when both
anchors held a spill, reading order decided: an array growing into a
neighbour's spill took its cells, in automatic calculation and after a
full recalculation. Excel keeps the cells the neighbour owns.

Standing now also remembers the area each anchor that held a spill
filled before the calculation. For each contested cell the anchor whose
spill held it keeps it; otherwise #2483's rules apply as before.

With the xlsx reader restoring each dynamic array's saved area, a
reopened workbook keeps its layout too, so both known limits documented
on Standing are gone. Tests now covered by #2483 are dropped, and its
grow-and-back test asserts the blocked grower.
2026-11-15 14:33:15 -03:00
quantforge-br e03780704e Merge upstream/main into fix/spill-priority 2026-11-15 14:33:09 -03:00
quantforge-br 5e692e0aba Merge upstream/main into function-help-portuguese
# Conflicts:
#	docs/localization-parity.md
2026-11-15 14:02:29 -03:00
Mouhand Kaddo 1d0b311b4a Preserve Arabic cell direction and RTL sheet layout in PDF exports (#955)
**Stacked on #940.** It contains all of #940 (Arabic shaping in PDF) and adds cell direction and right-to-left sheet geometry (`M12.AR5`). Review the [diff against #940's branch](https://github.com/Mouhand-Kaddo/gridcraft/compare/fix/arabic-pdf-text...fix/arabic-pdf-reading-direction); once #940 merges, this PR is up to date with it.

## Summary

PDF export now honors cell Context, Left-to-Right and Right-to-Left settings. Wrapped lines keep their paragraph direction. Right-to-left sheets place columns, repeated headings, merged cells and objects in the same order as the grid, and explicit Left and Right alignment stay on the side the grid shows them.

```diff
 PDF export
- infer each line separately; place every sheet left to right
+ preserve cell direction across lines; mirror RTL sheet positions
+ reject oversized text before appending an incomplete PDF block
```

Depends on #940 (Arabic PDF glyphs). The cell reading direction it reads landed with #947.

## Evidence

- **Before:** PDF ignored explicit reading order and RTL sheet layout. A public size-limit probe returned a PDF with an unmatched marked-content block.
  **After:** Direction, wrapped paragraphs, numeric brackets, RTL columns, headings, objects, clipping and sparklines have focused regressions. The same size-limit probe returns an error; its regression failed before the fix and passes afterward.
- At the current head, with Noto Sans Arabic installed and no `CRAFT_FONTS_DIR`: the `gridcraft-pdf` and `gridcraft-engine` tests, workspace clippy and fmt pass. The full `cargo xtask ci` with the craft-fonts bundle relies on the hosted gate.
- Poppler rendering inspected for LTR and RTL sheets. Bounding boxes confirm reversed column positions; logical Arabic strings remain searchable. No physical printer test.

## Merge Danger

**Door:** Two-way. Revert the commit to restore prior export behavior.

**Blast Radius:** PDF. Explicit cell direction is shared with XLSX persistence. Latin text retains the standard-font path, including forced RTL numeric text without an Arabic font.
2026-11-15 17:55:04 +01:00
Mouhand Kaddo 92ff21b9f2 Shape and preserve Arabic text in PDF exports (#940)
## Summary

Arabic text reached the PDF writer intact, then WinAnsi encoding replaced its characters with question marks. This fixes #923 through the shared PDF text path, including cells, headers and chart labels.

```diff
 PDF text
- encode Arabic through WinAnsi
+ shape with harfrust and Unicode bidi
+ embed licensed glyph outlines with matching weight coordinates
+ preserve logical source using ToUnicode and ActualText
+ fall back to the standard and CID fonts for characters the Arabic face lacks
```

Font binaries stay in the optional craft-fonts build input. Native unbundled builds can use installed Noto Sans Arabic. Explicit cell reading-direction integration follows separately.

**Web build:** shaped Arabic on web needs the bundled craft fonts. The current release workflow doesn't enable `web-craft-fonts`, so until a maintainer enables it, web sets Arabic in the CID font, as main does today, which has no Arabic glyphs, and shows a message that no Noto Sans Arabic face was found. The same applies to a desktop without Noto Sans Arabic, and to bold Arabic where only the regular face is installed.

## Evidence

- **Before:** Arabic exported as `?` (#923, v0.6.1); main now sets it in the CID font, which has no Arabic glyphs, so readers show blanks or boxes.
  **After:** native and bundled exports show joined letters, marks, Western/Arabic digits, bold/italic, wrapping, rotation and chart labels. Fresh `pdfinfo`, `pdffonts` and `pdftotext -bbox` checks accept the files; eight original Arabic strings match extracted logical text exactly.
- At the current head, with Noto Sans Arabic installed and no `CRAFT_FONTS_DIR`: the `gridcraft-pdf`, `gridcraft-engine` and `gridcraft-xlsx` tests, clippy, fmt, layers, assets, parity and the wasm check pass. The full `cargo xtask ci` with the craft-fonts bundle relies on the hosted gate.
- Characters the Arabic face lacks (emoji, Cyrillic) are set like non-Arabic text, and without an Arabic face for the text's weight Arabic takes the CID path main uses, with one message per export. Only a broken font or a size limit fails the export. Size limits cover text, glyph subsets, outlines and page content.

## Merge Danger

**Door:** two-way

**Blast Radius:** printing

`PdfDoc::finish` now returns a Result and every caller handles it. Latin-only rendering stays on its existing path. This is a glyph-outline PDF solution; platform printer and physical screen-reader behavior are not claimed.
2026-11-15 17:29:22 +01:00
Valentin Klein ee24d50ac8 Calc: overlapping spills resolve by anchor order, incremental matches full recalc (#2483)
## What

When two array formulas want the same cells, the one that already has its spill keeps them, whichever anchor comes first (this is what Excel does, measured on this PR by Harrison-Booth). The other formula shows `#SPILL!` until the winner is cleared, then it spills. When neither has a spill yet (a first calculation with no remembered layout), the anchor first in reading order (row, then column) wins, so the result never depends on evaluation order.

Before, an incremental recalculation let the existing spill keep its cells, while a full recalculation laid everything out from scratch and gave them to the earlier anchor. The two disagreed. A full recalculation now starts from the layout the sheet held, so both agree.

Also fixed: clearing a spilling formula did not unblock an array blocked by its old area when that array sat below or to the right of it.

## Why

Issue #2480: on the sales sample, `cell.set C14 =TRANSPOSE(B18:B24)` followed by `range.fill =D14:E18` over E13:F13 left F13 as `#SPILL!` in memory but `0` after a full recalc (the fuzzer, `command_sequence_fuzz` seed 0, hits this on #795). Now C14 keeps its cells, F13 is `#SPILL!`, and a full recalc gives the same.

Known limits: the xlsx reader does not restore spill layouts, so a workbook opened from a file is laid out by reading order only (Excel keeps the layout the file records); and when both anchors already held a spill and one grows into the other, reading order decides (Excel keeps the cells the other owns). The rule is documented on `Standing` in `crates/calc/src/recalc.rs`.

## Test

In `crates/engine/src/tests.rs`: the two-command sequence from the issue; both entry orders of an overlap, plus clearing the winner; and a no-history layout, where the earlier anchor wins in both entry orders. All compare cells with a full recalc.

## How verified

- `cargo fmt --check`, `cargo clippy -p gridcraft-calc -p gridcraft-engine --all-targets -- -D warnings`, `cargo test -p gridcraft-calc -p gridcraft-engine` (includes the fuzz test): all pass.

Fixes #2480
2026-11-15 17:27:51 +01:00
Dylan M. Taylor d593a8f99d Use existing craft-xml escaping for XLSX output 2026-11-15 10:19:11 -05:00
vangel76andClaude Opus 5.5 566eeef456 Equation parse errors from RaTeX follow the interface language
RaTeX reports parse errors only as finished English text. Its fixed
messages are now catalog keys, and its messages that carry a piece of the
source are read back into templates (i18n::unfill) and filled in again
after translating. A message of any other shape stays as RaTeX wrote it.
66 new keys in all 18 catalogs.

Fixes #4261

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 13:26:02 +01:00
skylar taylor-barrick 8bde636f27 Sandbox: test the socket owner ioctls with a real pointer (#4245)
The merged test asserts FIOSETOWN and FIOASYNC with the ioctl argument passed
by value, where the kernel reads the number as an address and fails with
EFAULT whether or not the filter refuses it, so the refusal alone is not the
reason the call came back. Passing a pointer, as a C caller does, the call
succeeds unconfined and is EPERM confined.

This covers FIOSETOWN and SIOCSPGRP that way on a socket the parent made and
the program inherited as a standard stream, after reading its socket name so a
pipe cannot pass for one. SIOCSPGRP is in the rules and in the filter's count
assertion but in no test until now.

Deleting either rule line fails this test at that ioctl's assertion; restored,
it passes. The test above is untouched.
2026-11-14 22:04:39 -06:00
Madhav Agarwal bfcb3a515a docs: bring ROADMAP.md current through 2026-11-15 2026-11-15 09:12:02 +05:30
skylar taylor-barrick 2f52ae5c7e Sandbox: refuse fcntl's asynchronous notification on Linux (#3846)
* Sandbox: refuse fcntl's asynchronous notification on Linux

* Sandbox: tests for fcntl's notification rules and the new probe

* Sandbox: the socket ioctls that notify another process, too
2026-11-14 21:12:49 -06:00
Dylan M. Taylor a62a532753 Merge pull request #4242 from storytold/ci/sonar-pinned-fonts
ci: provision pinned fonts for coverage tests
2026-11-14 20:53:30 -05:00
Dylan M. Taylor 69219c0d5c ci: provision pinned fonts for coverage tests 2026-11-14 20:38:23 -05:00
Zinadin Zidan da46633db7 Merge remote-tracking branch 'origin/main' into fix/3945-subtotal-grand-total-outline 2026-11-15 03:15:01 +06:00
Zinadin Zidan b01be008a0 Merge remote-tracking branch 'origin/main' into fix/3934-paste-row-down-narrow-selection 2026-11-15 03:14:59 +06:00
Zinadin Zidan 4ea6f081d7 Merge remote-tracking branch 'origin/main' into fix/3949-custom-list-unlisted-sort 2026-11-15 03:14:57 +06:00
Neil Cawse 027d5d1f43 Merge remote-tracking branch 'upstream/main' into fix/main-ci-csv-tests 2026-11-14 18:05:00 +00:00
FredApps f2044337c7 Merge pull request #4190 from storytold/fix/oversized-pivot-cache-warning-text
Tests: the oversized pivot cache warning names the part limit (main is red)
2026-11-14 18:29:41 +01:00
Cédric Legrand 569707e3f0 fix(engine): M8: compile insert submodules 2026-11-14 18:25:22 +01:00
FredApps 34ab393c72 Tests: the oversized pivot cache warning names the part limit
The package reader reports a part over the limit as "expands to more
than <limit> bytes"; the test added in #2491 expected the declared size
and failed on main.
2026-11-14 18:20:30 +01:00
Zinadin Zidan bece357298 engine: a blank goes last in a descending custom-list key (#3949)
In a descending custom-list key a blank tied with values not in the list,
which come first, while it still went after the listed values, so the order
depended on the input. It now goes last.
2026-11-14 22:53:00 +06:00
Zinadin Zidan de3576286e engine: leave a descending custom-list key as it was (#3949)
Comparing two values not in the list changed descending custom-list keys too:
they no longer tied, so a later key could not order them. Only an ascending
key sorts them now; with a descending one they tie, as before.
2026-11-14 22:36:26 +06:00
Zinadin Zidan dc9066cae0 engine: bound a row repeated down a narrow selection by the area it fills (#3934)
Repeating a copy down a selection narrower than it writes the copy's width on
every row, so the 4,000,000-cell limit on a tiled paste now counts that area
rather than the selection's. Past it the copy is pasted once, as a tiled
paste over too large a selection already is.
2026-11-14 22:35:11 +06:00
Zinadin Zidan d2c7c6ec58 engine: Subtotal groups every row under the grand total (#3945)
Data Subtotal grouped each group's detail rows at level 1 and left the
subtotal rows at level 0, so outline level 1 still showed every
subtotal. Excel adds an outer group over all data and subtotal rows,
summarised by the grand total: details at level 2, subtotals at
level 1, the grand total at level 0. Subtotal now adds that group after
writing the grand total.

Two tests that read the old levels now expect Excel's: the summary-row
test shows level 2 to keep the subtotal visible, and the sheet-prefix
test expects a detail row at level 2.
2026-11-14 22:16:13 +06:00
Zinadin Zidan 713a66e0d3 engine: paste repeats a copied row down a taller, narrower selection (#3934)
Paste tiled the copy only over a selection whose height and width were
both multiples of the copy's. A row copied into a narrower selection
several rows tall (A1:B1 into A3:A6) was pasted once. Excel repeats it
down every row of the selection at the copy's width. A selection
narrower than the copy now tiles down when its height is a multiple of
the copy's, and one shorter than the copy tiles across when its width
is a multiple.
2026-11-14 22:07:43 +06:00
Zinadin Zidan 07fcccd855 engine: custom-list sort puts unlisted values A to Z after the list (#3949)
A custom-list sort key compared only each value's position in the list.
Every value outside the list got the same position, so the stable sort
left them in their original order. Excel sorts them after the listed
values in the usual order. Two unlisted values now compare as a sort
without a list does (matchCase included).
2026-11-14 21:58:34 +06:00
c2aba7a3f4 perf: win back formula-entry and XLSX-save time lost since 23829d8c (#2654)
Measured with crates/engine/examples/bench.rs (perf/xtask-bench), 100k rows, M2 Pro:
enter.formulas 465 -> 420 ms (23829d8c: 375), xlsx.save 540 -> 488 ms (466).

- number_to_text: the round-up-to-1E+15 check (f29ac7d9e) formatted every number with
  exact {:.14e} and parsed it back; formula printing calls it once per literal. Run it
  only for magnitudes that can round up (>= 9.9999999999999e14). Same output; boundary
  tests added.
- Expr clone/map, xlsx prefix_params: a binary node whose left operand is not a chain
  no longer allocates a spine Vec (2aeb21d4d); map rewrites the operands in their boxes.
  Expr::walk reserves room for a typical formula up front.
- grow_autofilter checks the sheet has an AutoFilter before looking up the cell.
- retained_bytes_against looks up the newer band's row once per row, not per cell.
- The journal measures an entry's JSON size with a counting writer instead of building
  the text (a big paste's params are MBs).

The rest of the enter.formulas gap and all of edit.fanout's (~+12%) is Undo's byte
budget (72db972de, #1227): sizing each snapshot and freeing evicted ones, an intended
cost of bounded memory.

Co-authored-by: nihilist-narwhal <240798405+nihilist-narwhal@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 16:57:27 +01:00
Harrison BoothandClaude Opus 5.5 a8a51e3cf7 XLSX: warn when a pivot cache can't be read or is too large (#1039) (#2491)
read_cache turned every pivot cache error into absence with
optional_xml(part).ok().flatten(), so a cache over the part size limit
dropped its PivotTable with no warning, and a malformed or missing cache
only left a generic "skipped part" line. Each case now adds a warning that
the PivotTable was kept as plain cells, and the workbook keeps opening
(the oversized part is refused before it inflates).

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 16:56:12 +01:00
NetterSilverandClaude Haiku 5.5 45ee4eceed Keep mid-field quotes when splitting with Text to Columns (#2438)
Found while testing crates/engine/src/cmd/data.rs:992 (split_delimited, used by text_to_columns)

Co-authored-by: Claude Haiku 5.5 <noreply@anthropic.com>
2026-11-14 16:54:24 +01:00
Michael HigginsandClaude Opus 5.5 fdba683246 calc: linear dependency extraction for range-operator chains (#2183) (#2198)
* calc: linear dependency extraction for range-operator chains (#2183)

precedents() handled a range operator with non-reference operands by recursing into both operands and then letting Expr::walk descend into them again, so a left-associative chain of k operands cost 2^k (a 60-operand INDEX(...):INDEX(...) chain would hang on open). It is now a hand-written collector that visits every node once, growing the per-sheet bounding boxes of the enclosing range operator as it goes. Past a depth (4096) or node (1,000,000) bound it marks the formula dynamic (always recalculated) instead of recursing further.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* calc: drop wall-clock timing from precedents tests (clippy)

std::time::Instant::now is a disallowed method (clippy.toml: traps on wasm).
The regression test only needs to finish; the old 2^k walk would never return.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* calc: bound precedents to 100 ms and box plain-reference range chains (#2183)

- range_operator_chain_precedents_are_linear times the direct precedents
  call against the 100 ms bound in the issue.
- A Range node with two plain Ref operands (A1:B2:C3, which the parser
  can't fold) now collects its bounding box like any other range node, so
  an edit to C1 recalculates.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 16:53:03 +01:00
Mex 10849d5003 fix(functions): reject negative fractions in GCD and LCM (#2072)
* M0: reject negative fractional GCD and LCM arguments

Validate the original input before truncation. Add scalar and range regressions, including signed zero, positive fractions and zero-first LCM validation.

* M0: document negative-fraction GCD and LCM regression

Record tested edge-case behavior and update the parity revision history. Function counts and readiness estimates remain unchanged.

* M0: preserve GCD and LCM regression after math test extraction

Move the original negative-fraction regression into the existing extracted math tests. Scalar and range cases, zero-first validation, signed zero and positive truncation coverage are unchanged.
2026-11-14 16:51:29 +01:00
gyurix 494b830240 Linux: the title bar carries the window controls, as in Excel (#192) 2026-11-14 16:48:20 +01:00
Zinadin Zidan 40783ab184 functions: ACCRINTM accrues zero when issue equals settlement (#4096) (#4102)
ACCRINTM returned #NUM! whenever issue >= settlement. Excel rejects only
an issue date after settlement: when the two dates are equal after
truncation to whole days (including distinct times on the same day) it
returns 0 in every basis and both date systems. Relax the guard to
issue > settle; zero rate, zero par and an invalid basis stay #NUM!.
2026-11-14 15:22:59 +01:00
vangel76andClaude Sonnet 5.5 afd7303e48 Draw the equation plain-text stand-in at a normal size in xlsx
The text box that holds the LaTeX source (for an equation Office Math cannot
hold, and as the fallback of one it can) was written at the size the typeset
equation is drawn at, so the much wider source overflowed its frame in Excel.
It now uses 11 pt, or less when the frame itself is smaller.

Fixes #4161

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-14 12:56:37 +01:00
Neil Cawse 2c2699d87b Merge remote-tracking branch 'upstream/main' into fix/main-ci-csv-tests
# Conflicts:
#	crates/numfmt/src/render.rs
#	docs/function-parity.md
2026-11-13 19:44:29 +00:00
alphazw 87d2264d92 Route the first keystroke of an IME composition through the input method
When a cell wasn't in edit mode, `grid/keyboard.rs` consumed `Event::Text`
and seeded the in-cell editor with that keystroke. egui only delivers
composition events to a widget that publishes `PlatformOutput::ime` in that
frame, and only a focused `TextEdit` did so — which opens after the grid has
already handled the first key. A CJK IME therefore lost its first key: with
Wubi, typing `xta` wrote `x` into the cell and the input method only ever saw
`ta`.

The grid now publishes `IMEOutput` (egui 0.37's `IMEOutput::new`, anchored to
the active cell) on every frame it owns keyboard input, so the first key
reaches the input method. The editor is seeded from `ImeEvent::Commit`, never
from a `Preedit`; `Event::Text` still handles ASCII exactly as before. The
`context_generation` is kept in `Context` data and advances when the grid
gains IME focus. `PlatformOutput` is rebuilt each frame, so the editor's own
`TextEdit` keeps owning composition without any explicit disable.

A locked cell on a protected sheet gets no IME request: `begin_edit` refuses
those edits, so the grid applies the same merged-cell anchor and protection
check before publishing, avoiding a composition that would be discarded.
`IMEOutput` wants screen coordinates, so the cell and merged-range rectangles
are mirrored for right-to-left sheets and the caret follows the drawn cell.

Adds `tests/it/ime_composition.rs` (registered in `tests/it/main.rs`) with
eight kittest cases: the grid publishes `PlatformOutput::ime` before the first
keystroke, IME is withheld for a dialog and for locked cells but kept for
unlocked cells on a protected sheet, the right-to-left rect is mirrored, a
commit opens the editor with the committed text, a preedit alone does not, and
ASCII typing still seeds the editor. The harness allows tofu because the
suite's pinned font set has no Han face; the tests are about input routing.
2026-11-13 16:45:13 +08:00
vangel76andClaude Sonnet 5.5 c82673d9f0 Merge upstream/main into fix/i18n-hardcoded-strings
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-12 21:05:16 +01:00
FredApps c0ee120ac2 Merge pull request #1140 from vangel76/perf/chart-frame-cache
Charts: resolved data and rendering are cached between frames (#1139)
2026-11-12 19:55:40 +01:00
Codex bf76e6e63b test: keep ref-edit three-sheet check clippy-clean 2026-11-12 19:41:19 +01:00
Codex 467d36a9c8 Merge main after PDF cleanup; retain both roadmap entries 2026-11-12 19:30:40 +01:00
FredApps efc11acede Merge pull request #818 from vangel76/perf/pdf-writer-cleanup
PDF: writer cleanup, q nesting limit, image dedupe, style only on change (#816)
2026-11-12 18:59:02 +01:00
dotCooCoo f6a75ef153 Updates: take craft-update from craft-libs main at e98299546
craft-update, craft-window and the file-format crates (craft-cfb, craft-offcrypto, craft-opc, craft-csv, craft-xls) move from bb57d422d to craft-libs main at e98299546, which includes #923: the check of whether the copy can install itself now runs on the update-check thread instead of in Updater::tick on the UI thread.
2026-11-12 09:42:40 -08:00
quantforge-br 4656391c70 Merge upstream/main into fix/spill-priority 2026-11-12 14:35:09 -03:00
dotCooCoo cb58bed1cb Merge main into chore/craft-update-6e03f65 2026-11-12 09:23:03 -08:00
Codex 0c5436de76 Merge main into chart frame cache; preserve both roadmap entries 2026-11-12 18:13:44 +01:00
Codex ce0beb6900 Merge main into PDF writer cleanup; preserve both roadmap entries 2026-11-12 18:13:44 +01:00
FredApps a60db4f1c7 Merge pull request #3323 from vangel76/fix/linest-qr
LINEST, LOGEST, TREND, GROWTH: solve by Householder QR (#3322)
2026-11-12 17:59:31 +01:00
FredApps a3366cff65 Merge pull request #1135 from vangel76/fix/group-resize-on-release-1082
Grid: resizing several selected columns applies the width on release (#1082)
2026-11-12 17:58:46 +01:00
FredApps 591b8354f2 Merge pull request #3624 from vangel76/fix/3619-merged-shift-enter
Shift+arrows, Enter and Tab no longer get stuck on a merged cell
2026-11-12 17:57:39 +01:00
FredApps 0b31cebe5d Merge pull request #789 from vangel76/feat/wordart-784
Insert: WordArt (insert.wordArt) (#784)
2026-11-12 17:56:55 +01:00
Dylan M. Taylor 37941f0624 Merge pull request #3844 from storytold/switch-craft-libs-xls-dv
xlsx: .xls data validation from craft-xls
2026-11-12 01:43:22 -05:00
Dylan M. Taylor b1bd8d8b20 share legacy XLS test helpers 2026-11-12 06:29:50 +00:00
Dylan M. Taylor 794b65ecac fix XLS validation warnings 2026-11-12 06:13:59 +00:00
Dylan M. Taylor 6308fc9edb Merge pull request #3843 from storytold/switch-craft-libs-opc
xlsx: OPC packages through craft-opc; craft-libs at aa84415b
2026-11-12 01:10:14 -05:00
Dylan M. Taylor 48659c1668 Merge pull request #3842 from storytold/switch-craft-libs-offcrypto
xlsx: encrypted workbooks through craft-offcrypto and craft-cfb
2026-11-12 01:09:49 -05:00
Dylan M. Taylor e8845f648a Merge pull request #3841 from storytold/switch-craft-libs-csv
xlsx, engine: CSV and SYLK through craft-csv
2026-11-12 01:09:16 -05:00
Dylan M. Taylor 3858482465 Merge pull request #3840 from storytold/switch-craft-libs-xls
xlsx: read .xls through craft-xls
2026-11-12 01:00:41 -05:00
Dylan M. Taylor 73a18c4f4c Merge remote-tracking branch 'origin/switch-craft-libs-opc' into codex/reviewfix-3844 2026-11-12 05:41:20 +00:00
Dylan M. Taylor 0b4b36b865 Merge remote-tracking branch 'origin/switch-craft-libs-offcrypto' into codex/reviewfix-3843 2026-11-12 05:41:13 +00:00
Dylan M. Taylor 4251dad939 Merge remote-tracking branch 'origin/switch-craft-libs-csv' into codex/reviewfix-3842 2026-11-12 05:41:06 +00:00
Dylan M. Taylor 1b7e4f00dc Merge remote-tracking branch 'origin/switch-craft-libs-xls' into codex/reviewfix-3841 2026-11-12 05:40:59 +00:00
Dylan M. Taylor 4deedbb549 warn about dropped XLS rules 2026-11-12 05:40:53 +00:00
Dylan M. Taylor 8d4fb0b12e Merge remote-tracking branch 'origin/switch-craft-libs-opc' into codex/propagate-3844 2026-11-12 05:37:34 +00:00
Dylan M. Taylor 203872b4db Merge remote-tracking branch 'origin/switch-craft-libs-offcrypto' into codex/propagate-3843 2026-11-12 05:37:27 +00:00
Dylan M. Taylor d3954beacf Merge remote-tracking branch 'origin/switch-craft-libs-csv' into codex/propagate-3842 2026-11-12 05:37:21 +00:00
Dylan M. Taylor 26e7112e0f Merge remote-tracking branch 'origin/switch-craft-libs-xls' into codex/propagate-3840 2026-11-12 05:37:12 +00:00
Dylan M. Taylor 3d31729de3 test(xls): expect malformed encryption error 2026-11-12 05:36:34 +00:00
Dylan M. Taylor 3ba4945e72 GridCraft: use shared XLS validation operator type 2026-11-12 05:24:28 +00:00
Dylan M. Taylor 0752f3181b Merge current OPC switch into XLS validation switch 2026-11-12 05:20:25 +00:00
Dylan M. Taylor b24ec5df6d Merge current encrypted workbook switch into OPC switch 2026-11-12 05:19:49 +00:00
Dylan M. Taylor d0c567992e Merge current CSV switch into encrypted workbook switch 2026-11-12 05:18:19 +00:00
Dylan M. Taylor 1c84e32f58 GridCraft: update XLS validation switch to current shared crates 2026-11-12 05:16:38 +00:00
Dylan M. Taylor cf3b11c858 Merge remote-tracking branch 'origin/switch-craft-libs-opc' into codex/gridcraft-3844 2026-11-12 05:16:08 +00:00
Dylan M. Taylor 1e6c8b8b72 Merge remote-tracking branch 'origin/switch-craft-libs-opc' into codex/gridcraft-3843 2026-11-12 05:15:57 +00:00
Dylan M. Taylor 3e0f073e9a GridCraft: update OPC switch to current shared crates 2026-11-12 05:15:56 +00:00
Dylan M. Taylor eec5db66f0 Merge remote-tracking branch 'origin/switch-craft-libs-offcrypto' into codex/gridcraft-3843 2026-11-12 05:15:18 +00:00
Dylan M. Taylor a440cfac28 Merge remote-tracking branch 'origin/switch-craft-libs-offcrypto' into codex/gridcraft-3842 2026-11-12 05:14:54 +00:00
Dylan M. Taylor 92a79db048 GridCraft: update encrypted XLS switch to current shared crates 2026-11-12 05:14:47 +00:00
Dylan M. Taylor 652c08a89b Merge remote-tracking branch 'origin/switch-craft-libs-csv' into codex/gridcraft-3842 2026-11-12 05:14:07 +00:00
Dylan M. Taylor aeb3fb19ce Merge latest CSV branch updates 2026-11-12 05:13:54 +00:00
Dylan M. Taylor e4ec0d7ed1 GridCraft: update CSV switch to current shared crates 2026-11-12 05:13:10 +00:00
Dylan M. Taylor 23487b0cb5 Merge current XLS switch into CSV switch 2026-11-12 05:12:51 +00:00
Dylan M. Taylor 0407b63663 GridCraft: update XLS import to current shared crate 2026-11-12 05:11:53 +00:00
Dylan M. Taylor b45698d109 tests: give the xls fixture its compound-file byte order mark
craft-cfb refuses a header without the 0xFFFE mark at offset 28
([MS-CFB] 2.2), so craft-xls's sniff called the fixture LegacyBinary.
The old hand-written parser never read that field, which is why the test
only broke with the switch. The fixture is a real workbook otherwise:
sniff now says Xls and read_xls parses it.
2026-11-12 05:08:22 +00:00
Dylan M. Taylor c913bf6615 tests: give the xls fixture its compound-file byte order mark
craft-cfb refuses a header without the 0xFFFE mark at offset 28
([MS-CFB] 2.2), so craft-xls's sniff called the fixture LegacyBinary.
The old hand-written parser never read that field, which is why the test
only broke with the switch. The fixture is a real workbook otherwise:
sniff now says Xls and read_xls parses it.
2026-11-12 05:08:20 +00:00
Dylan M. Taylor 1bd4ca8946 Test xls import with a valid compound file header 2026-11-12 05:05:01 +00:00
Dylan M. Taylor 0431741359 tests: give the xls fixture its compound-file byte order mark
craft-cfb refuses a header without the 0xFFFE mark at offset 28
([MS-CFB] 2.2), so craft-xls's sniff called the fixture LegacyBinary.
The old hand-written parser never read that field, which is why the test
only broke with the switch. The fixture is a real workbook otherwise:
sniff now says Xls and read_xls parses it.
2026-11-12 04:37:07 +00:00
Dylan M. Taylorandkiwi4boy ae7fbd81b7 xlsx: .xls data validation from craft-xls
craft-xls reads Dv/DVal records (storytold/craft-libs#999, a port of #3636).
xls.rs maps each rule onto the model as the .xlsx reader maps a dataValidation:
a non-literal list source becomes =ref. The tests are #3636's, run through
read_xls; the cap test now expects craft-xls's skipped-rules warning.

Co-authored-by: kiwi4boy <kiwi4boy@gmail.com>
2026-11-12 02:47:52 +00:00
Dylan M. Taylor f800472b0a xlsx: OPC package access through craft-opc; craft-libs at aa84415b
package.rs keeps GridCraft's Package, Rel and ZipOut, now on craft_opc::LazyPackage
and craft_opc::ZipOut (on craft-zip). Limits stay GridCraft's (200,000 entries,
512 MB a part, 1 GB a package) and so do the budget rules, which craft-opc took
from GridCraft. The budget tests moved with them. normalize, resolve and
split_dir are craft-opc's (the same code).

Every craft-libs crate moves to aa84415b. craft-xls now reads data validation;
until GridCraft maps it, a sheet with rules still warns that .xls data validation
is not imported. ods.rs matches entity names through a slice, since the new
dependencies make the old as_ref() call ambiguous.
2026-11-12 02:37:30 +00:00
Dylan M. Taylor 9c87c22662 xlsx: encrypted workbooks and compound files through craft-offcrypto and craft-cfb
Decrypting password-protected workbooks ([MS-OFFCRYPTO], Agile and Standard) moved
to storytold/craft-libs as craft-offcrypto (#931), on craft-cfb. GridCraft keeps
its DecryptError and the engine's messages; crypto.rs maps the crate's errors onto
it. The private compound-file reader and its tests are gone: sniffing looks for
the encryption streams with craft_cfb::has_entry_named (with the same fallback for
a damaged directory), and the test builders encrypt with craft-offcrypto and write
compound files with craft-cfb.

One difference, as craft-offcrypto has it: the dataIntegrity HMAC key is used at
the length it decrypts to (up to the hash size); GridCraft accepted only a
salt-size or hash-size key. Both verify what Office writes.
2026-11-12 01:34:24 +00:00
Dylan M. Taylor c1adf9b239 xlsx, engine: CSV decoding, parsing and quoting, and SYLK, through craft-csv
Text decoding (byte order marks, UTF-8, Windows-1256/1252), delimiter sniffing,
the record parser and field quoting moved to storytold/craft-libs as craft-csv
(#889), with the SYLK reader as craft_csv::sylk. GridCraft keeps typed values,
date-order inference, the used-range limit and the sheet writer in csv.rs, and in
io/sylk.rs the workbook a SYLK file becomes: formulas parsed (an unparsable one
is skipped and counted, as before), error values, number-format styles and column
widths.
2026-11-12 01:17:21 +00:00
Dylan M. Taylor 21df49c636 xlsx: read .xls workbooks through craft-xls
The BIFF8 reader moved to storytold/craft-libs as craft-xls (#878). GridCraft
keeps the mapping onto its model in xls.rs: formulas parsed, Excel's implicit @
for legacy formulas, pixel widths and heights, styles interned per XF, sheet-name
checks, print areas and titles, calculation settings and GridCraft's warning text.

The workbook now opens on the sheet it was saved on when that sheet is visible,
else on the first visible sheet (from #3551 by @Morzilla, whose test is kept).
RString cells are read as text.

Every craft-libs crate moves to one revision, 119415f4.
2026-11-12 00:58:43 +00:00
FredApps 7e0d96d74b CI: nightly release dry run (#3820)
release.yml also runs nightly on main with craft-common-actions' dry-run: every release build
except macOS, with nothing signed, pushed or drafted. Breakage that only the release build hits
(riscv64, Flatpak, FreeBSD, packaging) then shows up the next morning instead of on release
day, as it did on 11 Nov 2026.
2026-11-11 23:04:17 +01:00
Dylan M. Taylor 572bec289b engine: work limits for Advanced Filter, Remove Duplicates, filters, AutoFit, macro footprints; range sizes saturate (#3295)
* engine: bound Advanced Filter, Remove Duplicates, AutoFilter, Circle Invalid Data; one-pass AutoFit; saturating range dimensions

* address review: AutoFit scans each run of adjacent selected columns separately

* address review: report a truncated circle-invalid scan, no spill scan for plain cells in Replace, one pass for many AutoFit runs

* address review: warn in the app when Circle Invalid Data stopped early; Replace test requires success

* address review: the scan note joins an open-time notice; say cell visits
2026-11-11 16:10:10 -05:00
Dylan M. Taylor 55eb394044 engine: index merges and bound the page in HTML export and clipboard HTML (#3266)
* engine: index merges and bound the page in HTML export and clipboard HTML

Save as Web Page and the clipboard's HTML scanned every merge of the
sheet for every cell, counted a merge's span over all the rows the file
gave it, placed each picture by summing every custom row before it, and
grew the page without a byte limit. Merges are now indexed once over
the exported rectangle (overlapping merges past a few visits per cell
are refused), spans use prefix counts clipped to the table, anchors use
LineIndex, and the page stops at 256 MiB with an error.

* address review: check the web page size after each chart and before returning it

* address review: bound the merge index, escape cell text within the page's room, size images before encoding

* address review: escape image attributes within the page's room
2026-11-11 16:09:43 -05:00
Dylan M. Taylor 9e9f13114f check, xtask stats: visited directories keyed by (dev, inode); stats reads only regular files (#3287)
* Directory walkers key visited directories by (dev, inode); stats skips non-regular or oversized .rs targets

* address review: record a walked directory only within the depth limit; stats skips symlinked sources and bounds the read

* address review: rescan a directory reached from a shallower path, skipping files already collected

* xtask stats: test the directory walk (links, identity, size limit)

* address review: create the test directories atomically and privately

* xtask stats tests: no unreachable! in the directory helper

* gridcraft check: unit-test that each workbook is listed once whatever path reaches it
2026-11-11 16:09:17 -05:00
Dylan M. Taylor 35e9815603 Security: one work budget across every call of a lifted function (#3197)
* functions: one work budget across every call of a lifted function

A function lifted over a computed array runs once per element, and only the
six lookups counted their repeated work against LIFTED_SCAN_BUDGET. Criteria
aggregates rescanned their ranges per criterion, CUMIPMT/CUMPRINC stepped
through up to 1e7 periods per element, and array-producing functions such as
MUNIT built a whole result per element before keeping its first cell.

The budget now covers all of it: COUNTIF/SUMIF/AVERAGEIF(S)/MAXIFS/MINIFS
charge their range cells per call, the period loops of every element are
added up before any runs, and array results charge their cells as they are
built. Past the budget the call is #NUM!, as lifted lookups already are.

* address review: charge numeric-text periods of lifted CUMIPMT/CUMPRINC to the work budget

* address review: charge only calls that reach the cumulative period loop

* address review: charge the numeric text a lifted period call parses

* address review: SUMIF/AVERAGEIF charge only the sum-range cells they read; weight cumulative period work
2026-11-11 16:08:50 -05:00
Dylan M. Taylor 6ea8d11522 print: bound the print area to the grid; render charts once and budget picture and chart output (#3314)
* print: hold the print area to the grid; render each chart once and budget picture and chart output across pages

* address review: budget chart path points and drop charts that do not fit the budget
2026-11-11 16:08:24 -05:00
Dylan M. Taylor 7c3af8a421 fix(formula): bound the wrappers stacked on one path of a parsed formula (#3813) 2026-11-11 16:07:58 -05:00
Dylan M. Taylor ca7ea0131e fix(mcp): send the control token only to a loopback address (#3814) 2026-11-11 16:07:32 -05:00
Dylan M. Taylor aa0347cc2e fix(engine): calculated pivot fields may not build arrays from scalars (#3812) 2026-11-11 16:07:06 -05:00
vangel76andClaude Sonnet 5.5 2ff6001d3d Merge upstream/main
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-11 21:54:23 +01:00
vangel76andClaude Sonnet 5.5 20917cfd01 Merge upstream/main
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-11 21:54:20 +01:00
vangel76andClaude Sonnet 5.5 4dd1c6cf6c Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-11 21:54:05 +01:00
Dylan M. Taylor 5cf52c5fbb chore: bump version to 0.19.1 for the Flatpak update fix (#3809) 2026-11-11 14:55:53 -05:00
Dylan M. Taylor 0c5b1e85e6 sonar: stop counting the locale table as duplicated code (#3805) 2026-11-11 14:33:16 -05:00
Dylan M. Taylor 7f6a79fd98 Fix Flatpak permissions for update checks and self-updates (#3803)
* fix(flatpak): allow release checks and self-update helpers

* test: keep Flatpak permission parsing within strict Clippy rules
2026-11-11 14:24:13 -05:00
Dylan M. Taylor 6dbfbc4058 Merge pull request #3795 from storytold/chore/craft-update-6e03f65
Updates: take craft-update from craft-libs main at 6e03f65bf
2026-11-11 12:44:31 -05:00
Dylan M. Taylor e258db5f19 Updates: take craft-update from craft-libs main at 6e03f65bf 2026-11-11 12:44:25 -05:00
Dylan M. Taylor 763816d27c ci: run Harden-Runner on every job (#3786)
Adds step-security/harden-runner (audit, pinned to v2.22.4 like
craft-common-actions) as the first step of each job that did not have it,
so every workflow in the org's public repos reports its egress to
StepSecurity. Audit, not block: block-mode allow lists come from each
job's observed traffic.
2026-11-11 12:11:59 -05:00
dotCooCoo 71ba34f061 Updates: take craft-update from craft-libs main at 6e03f65bf 2026-11-11 09:01:44 -08:00
quantforge-br a6cb00b6a7 Merge upstream/main into fix/spill-priority
#3298 recalculates every formula when sheet protection changes
(Ctx::recalc_all), on the line where a structural edit recalculates.
A structural edit still goes through recalc_after_structural_edit; a
protection change takes recalc_all, as on main.
2026-11-11 08:10:09 -03:00
vangel76andClaude Sonnet 5.5 60063b85cd Keep the Decorative Text ribbon button two lines wide
The one-line label widened the Insert tab enough to scroll the Equation button
out of view at 1400 px, which broke the equation editor tests in CI.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-10 23:20:06 +01:00
vangel76andClaude Sonnet 5.5 40c1afbe84 Use the Decorative Text label for the WordArt ribbon button
Upstream retires WordArt as a display name (display_names guard); the
button and its tooltip use the already translated Decorative Text key,
and the parity checklist is regenerated.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-10 22:17:09 +01:00
vangel76andClaude Sonnet 5.5 75c07a1a83 Merge upstream/main into feat/wordart-784
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-10 22:01:55 +01:00
vangel76andClaude Sonnet 5.5 433602250a Merge upstream/main into fix/i18n-hardcoded-strings
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-10 22:00:41 +01:00
quantforge-br c8e42061fa Merge upstream/main into function-help-portuguese
# Conflicts:
#	docs/localization-parity.md
2026-11-10 13:43:43 -03:00
quantforge-br 191c3b3ff7 Merge upstream/main into function-help-portuguese
# Conflicts:
#	docs/localization-parity.md
2026-11-10 12:41:42 -03:00
quantforge-br c47bdffcd6 Calc: preserve dynamic-array kind without discarding saved spill areas (#964) 2026-11-10 09:28:58 -03:00
quantforge-br d04914bca6 Merge upstream/main into fix/spill-priority 2026-11-10 09:22:24 -03:00
quantforge-br b00e592054 Merge upstream/main into function-help-portuguese
# Conflicts:
#	docs/localization-parity.md
2026-11-10 09:16:46 -03:00
vangel76 353908fca5 Merge remote-tracking branch 'upstream/main' into fix3624-wt 2026-11-09 23:30:34 +01:00
vangel76andClaude Opus 5.5 10545dc4e1 fix(selection): keep the old walk when the hidden axis has no direction
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 23:30:29 +01:00
vangel76andClaude Opus 5.5 f8070bbbd0 fix(selection): keep the Tab run's column when Enter skips hidden rows after a merged cell
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 23:21:03 +01:00
vangel76andClaude Opus 5.5 e3e03cb98e Merge upstream/main into fix/i18n-hardcoded-strings
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 23:07:44 +01:00
quantforge-br 3296878d87 Merge upstream/main into function-help-portuguese
# Conflicts:
#	docs/localization-parity.md
2026-11-09 12:28:18 -03:00
Neil Cawse 56a02dcc8c Merge origin/main into fix/main-ci-csv-tests 2026-11-09 01:11:15 +00:00
vangel76andClaude Opus 5.5 a0dc48547b fix(i18n): translate the equation checks' own error messages
The equation editor translated only its "Error at character" prefix;
the checks in crates/math (macro definitions, % with a link, nesting,
length, matrix-cell and size limits, layout failure) stayed English.
Add the seven messages to all 18 catalogs and test them from the real
checks, with the expected English built from the limits. RaTeX parser
errors are open-ended text from the external crate and stay English.
The localization doc now marks its counts as a snapshot and states the
current status.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 23:32:17 +01:00
vangel76andClaude Opus 5.5 5e5b5d082d fix(selection): Enter from a merged cell keeps the Tab run's column
Leaving a merged cell downwards kept the start column and dropped the
column offset Enter passes to return to the Tab run's start column, so
Tab A2 -> B2:C3, Enter landed on B4 instead of A4. Keep the computed
column (and the computed row when leaving to the right).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 23:22:22 +01:00
vangel76andClaude Opus 5.5 c16c5865b1 fix(i18n): translate status bar statistics, resize tips, sheet notes and macro toasts
Strings that were built with format! in English now translate their
template first and fill it in once (Language::tr_fill), so a value
holding `{...}` is never filled again: status bar statistics and the
circular reference note, the column width / row height drag tip, the
formula bar text for a picture in a cell, the Move or Copy and Unhide
notes, the Format Control title, the equation editor's error prefix,
and the Goal Seek and macro recorder/runner toasts. New keys go into
every catalog.

Fixes #3600, #3602, #3603, #3605, #3607, #3608, #3609, #3610, #3611

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 22:38:17 +01:00
vangel76andClaude Opus 5.5 2bc50341a0 fix(selection): Shift+arrows and Enter/Tab treat a merged cell as one cell (#3619)
Shift+Left/Up from a selected merged cell now widen the selection past
its edges, Shift+arrows shrink an area back over a merged cell, and
Enter/Tab leave a selected merged cell instead of walking the cells it
covers. Inside a larger selection Enter visits a merged cell once.

Fixes #3619

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 22:23:32 +01:00
vangel76andClaude Opus 5.5 7cd0a6cc72 Resize drag: spend Esc on the cancelled drag
Esc during a header-boundary resize was only peeked at, so the grid's
own Esc handling saw it as well and dropped a marked copy and Format
Painter. The cancel now removes the Esc presses from the frame's input,
with any modifiers, as before, cancelling the drag. The regression test
covers a pending copy and sticky Format Painter for rows and columns,
with the release in a later frame or the same frame, and Shift+Esc.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 13:01:31 +01:00
vangel76andClaude Opus 5.5 14aae7cee1 WordArt: keep ordinary shapes with textNoShape; print the text outline
textNoShape is the standard no-warp value, so it alone no longer makes a
shape WordArt: only a rectangle that is a text box (as the writer saves
WordArt) or has no fill and no outline reads as WordArt. A filled ellipse
with an explicit textNoShape now reads and saves as the same ellipse.

The PDF/print path drew WordArt text without its outline, so Mint
Outline (white text, green outline) printed as a blank page. The outline
is now drawn like on screen: the text in the outline colour, offset in
eight directions, under the filled text.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 12:54:30 +01:00
vangel76andClaude Opus 5.5 8605fb02f0 Charts: follow defined names when deciding a chart is volatile
A series like =FreshClock, where the workbook name FreshClock is NOW(),
was cached because only the literal series text was searched for
volatile calls. The check now also follows defined names the formulas
use (workbook or sheet scope, bare or sheet-qualified, LAMBDA names),
the way the evaluator looks them up. Nesting deeper than 8, cycles and
more than 64 lookups per chart count as volatile, so a chart whose
stability isn't established is not cached.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 12:52:00 +01:00
vangel76 032b280b04 Merge upstream/main into feat/wordart-784 2026-11-08 12:39:59 +01:00
vangel76andClaude Opus 5.5 40c3ada226 Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 12:28:15 +01:00
vangel76andClaude Opus 5.5 01fe67010d PDF: look up page images by hash instead of scanning every earlier image
Page::image_rgba compared each new picture with all earlier pictures on
the page, so N distinct pictures cost N(N-1)/2 comparisons. Keep a
page-local hash-to-index map (pixels still compared with ImageData::same)
and add a regression test with 3,000 distinct pictures.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 12:19:46 +01:00
vangel76andClaude Opus 5.5 86ed3d93b4 LINEST: treat only identical raw values as a constant predictor
The 64-ulp spread threshold still classified distinct representable
predictors such as [1e15, 1e15 + 1, 1e15 + 2] as constant and dropped
them. A column is now constant only when every raw value is the same
double; the 1e15 case is added to the offset regression test.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 12:19:34 +01:00
vangel76 ef320b988d Merge remote-tracking branch 'upstream/main' into HEAD 2026-11-08 12:18:59 +01:00
SBaksa e4e2c5292a XLSX: NETWORKDAYS.INTL and WORKDAY.INTL are saved without _xlfn. (#3517)
Both are in the file format's own function list, so a file stores them
unprefixed; LibreOffice gives #NAME? for the prefixed spelling. They are removed
from FUTURE_FUNCTIONS. A file with the prefix still reads (the parser strips it).
2026-11-08 11:24:12 +11:00
vangel76andClaude Sonnet 5.5 0144ffa51b Merge upstream/main into feat/wordart-784
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 18:39:57 +01:00
vangel76andClaude Sonnet 5.5 522120c34c Merge upstream/main into perf/pdf-writer-cleanup
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 18:39:27 +01:00
vangel76andClaude Sonnet 5.5 3e64ddbd80 Merge upstream/main into fix/group-resize-on-release-1082
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 18:39:12 +01:00
vangel76andClaude Sonnet 5.5 2cae4aa316 Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 18:38:57 +01:00
vangel76andClaude Sonnet 5.5 ed15db4101 Merge upstream/main into fix/linest-qr
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 18:37:48 +01:00
vangel76andClaude Sonnet 5.5 3d50413aff Resize drag: keep the last accepted preview and the redo history on Esc
A refused size no longer replaces the size the release applies to the
selection, and Esc puts back the redo stack the drag began with.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 17:34:38 +01:00
vangel76andClaude Sonnet 5.5 224d0e96d7 WordArt: refuse insertion on a protected sheet
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 17:32:14 +01:00
vangel76andClaude Sonnet 5.5 1baa723ae7 Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 17:28:55 +01:00
vangel76andClaude Sonnet 5.5 cca09cc8f4 PDF: track the first text run with a flag
text_rotated counted the Tf operators written so far on every run, which is
quadratic for text that alternates between WinAnsi and CID characters.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 17:19:10 +01:00
vangel76andClaude Sonnet 5.5 583c8a4819 LINEST: keep predictors that vary by little next to a large offset
A centred column was dropped when its length fell under 1e-12 of the raw
column, which also removed real variation such as [1e13, 1e13+1, 1e13+2].
Constant columns are now recognised on the raw values, within a few ulps.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 17:01:20 +01:00
vangel76andClaude Sonnet 5.5 8e3fba8a25 Chart cache: drop closed documents once per frame, skip volatile series
Move retain_docs out of the per-chart paint path into SheetApp::logic so closed
documents are forgotten even when no chart is painted. Charts whose series call
NOW, TODAY, RAND, RANDBETWEEN or RANDARRAY bypass the cache because their
resolved values change between evaluations.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 16:54:59 +01:00
vangel76andClaude Sonnet 5.5 dd5cd48b8f Regenerate parity checklist after merging main
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-05 04:29:48 +01:00
vangel76andClaude Sonnet 5.5 2a9a21d41c WordArt xlsx: only the textNoShape marker reads as WordArt, an empty WordArt keeps its body
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-05 04:25:50 +01:00
vangel76andClaude Sonnet 5.5 6a22a3b357 Merge upstream/main into feat/wordart-784
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-05 04:24:34 +01:00
vangel76andClaude Sonnet 5.5 38f48ad974 Merge upstream/main into fix/group-resize-on-release-1082
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-05 02:00:21 +01:00
vangel76andClaude Sonnet 5.5 ac0588dbaf Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-05 01:54:42 +01:00
vangel76andClaude Sonnet 5.5 a5c74edfec linest test: use f64::from directly (clippy)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-04 00:18:00 +01:00
vangel76andClaude Sonnet 5.5 d0b40c3b30 linest: drop a constant column that centres to rounding noise (review point)
CodeRabbit pointed out that the drop test used the centred column length, so a
constant column such as [0.1; 3] (centred to about -1.4e-17) was scaled to a unit
vector and kept, giving a meaningless coefficient and wrong df. A centred column
shorter than 1e-12 of its uncentred length is now treated as collinear with the
intercept. The suggested 1e-6 threshold was not used: it would also drop columns
that sit far from zero, such as 1e9 + i.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-04 00:05:38 +01:00
vangel76andClaude Sonnet 5.5 f74d95542f LINEST: solve by Householder QR instead of the normal equations (#3322)
The normal equations square the condition number, so a degree-5 polynomial on
x = 1..12 came back with errors up to 2.6e-6 and x, x^2 near 1e6 gave slope
2.99976 and intercept 251 for y = 3x + 7. LINEST, LOGEST, TREND and GROWTH now
factor the centred, column-scaled data with Householder QR. Collinear columns
are still dropped under the same relative tolerance.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-03 23:38:55 +01:00
vangel76andClaude Haiku 5.5 f3e24e2b68 Regenerate parity checklist after merging main
The parity CI step failed because docs/parity-checklist.md was stale
after merging upstream main. Regenerated with cargo xtask parity.
Counts now 278 / 292 (Insert: WordArt moved to implemented).

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
2026-11-02 20:58:00 +01:00
vangel76andClaude Sonnet 5.5 5b3b3bdc0e Keytip pending-sequence test: use NSC so it does not race the NJ go-live test
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-02 20:19:10 +01:00
quantforge-br 113e312809 Calc: index former spill areas by 64-cell squares, not by cell, on full recalc
A crafted XLSX may declare up to 16 million dynamic-range cells per sheet, and
opening it runs a full recalculation: the former-area cell set grew with every
cell (841 MB peak, 2.4 s for 16 one-million-cell areas). The index now lists the
areas over each 64 x 64 square they cover (12 MB, 13 ms for the same sheet).
2026-11-02 16:12:40 -03:00
vangel76andClaude Sonnet 5.5 f8a764f20c Fix merge: Shape::math for WordArt, fmt
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-02 20:07:54 +01:00
vangel76andClaude Sonnet 5.5 0d1296e532 Merge upstream/main into feat/wordart-784
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-02 20:03:35 +01:00
vangel76andClaude Sonnet 5.5 b396e6c0bd Merge upstream/main into perf/pdf-writer-cleanup
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-02 19:52:51 +01:00
vangel76andClaude Sonnet 5.5 9bd6fa1d75 Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-02 19:50:48 +01:00
quantforge-br 88310f3f4d Merge upstream/main into fix/spill-priority 2026-11-02 15:39:55 -03:00
Neil Cawse d95c11b370 Merge upstream main into fix/main-ci-csv-tests 2026-11-02 00:46:06 +00:00
quantforge-br 430f53df72 Calc: former spill areas are checked through their cells, not by scanning every area 2026-10-31 17:12:33 -03:00
quantforge-br f3546f25d9 Calc: a full recalc keeps former spill areas taken until their formulas are laid out again; a structural edit doesn't 2026-10-31 16:01:49 -03:00
quantforge-br 527b884429 pt function help: FILTER keeps each row or column whose own include value is TRUE 2026-10-31 14:41:03 -03:00
quantforge-br 6c2ba27110 Calc: an array that grew into another's spill area is laid out after it on full recalc 2026-10-31 14:41:02 -03:00
quantforge-br 0925c25666 Merge remote-tracking branch 'upstream/main' into repr-fix-spill-priority
# Conflicts:
#	crates/calc/src/recalc.rs
2026-10-31 13:15:24 -03:00
quantforge-br e54cfba348 Merge remote-tracking branch 'upstream/main' into repr-function-help-portuguese 2026-10-31 13:14:01 -03:00
Neil Cawse 50e01f7646 Merge main (981fad1) into the branch 2026-10-31 12:33:28 +00:00
Neil Cawse cb4ac4d554 Merge main (1f4c67e) into the branch 2026-10-31 02:07:05 +00:00
D. Fender 0c737637e5 Merge main into fix/table-style-looks 2026-10-30 10:51:44 -07:00
vangel76 e624f4d178 Merge remote-tracking branch 'upstream/main' into HEAD 2026-10-30 00:58:28 +01:00
vangel76andClaude Sonnet 5.5 96aece4e57 Keep Esc on a resize drag from undoing an earlier size edit
A resize drag shares its undo label with an earlier width/height edit, so
coalescing removed the drag's own entry and Esc undid the earlier edit too.
Track the workbook the drag started from and merge/cancel only entries from
there. Esc is also handled when egui has already ended the drag.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-30 00:58:28 +01:00
vangel76andClaude Sonnet 5.5 218aa884be Merge upstream/main into feat/wordart-784
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-29 23:17:05 +01:00
vangel76 4f372ff470 Name the test case type (clippy type_complexity) 2026-10-29 23:09:29 +01:00
vangel76andClaude Sonnet 5.5 5ca5e6b61e Merge upstream/main into perf/pdf-writer-cleanup
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-29 23:09:10 +01:00
vangel76andClaude Sonnet 5.5 5d440c82ac Merge upstream/main into fix/group-resize-on-release-1082
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-29 23:07:01 +01:00
vangel76 57e0eb5b0f Merge upstream/main into perf/chart-frame-cache 2026-10-29 23:06:07 +01:00
Hamza 09fcfb63a7 Space on a checkbox cell toggles it and nothing else (#1951)
A space on a checkbox cell toggles it, and the same key press also arrives as
text -- and typing text starts editing the cell. So the cell toggled *and*
opened an editor holding a space, which Enter then committed over the
checkbox: the value the space had just set was replaced by a space.

A space on a checkbox cell is no longer read as text to type.

Rebased onto main, 352 commits on: the grid's keyboard handling moved from
grid.rs to grid/keyboard.rs, which already imports `is_checkbox`, so the arm
sits in front of the general text arm there. Without it the test fails on
"no editor opened" -- that is, the editor still opens.
2026-10-28 20:18:15 +05:00
vangel76andClaude Sonnet 5.5 71469495bc Merge upstream/main into feat/wordart-784
Main moved shape text editing, PDF shape drawing, grid interaction and the Insert ribbon into submodules; the WordArt changes are re-applied there.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-27 20:16:35 +01:00
vangel76andClaude Sonnet 5.5 527abcfc7d Merge upstream/main into fix/group-resize-on-release-1082
grid.rs was split into grid/ modules on main; the resize-on-release changes are re-applied in grid.rs and grid/interact.rs.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-27 20:01:56 +01:00
vangel76andClaude Sonnet 5.5 37cf274a03 Merge upstream/main into perf/chart-frame-cache
SheetApp setup and font handling moved to app.rs and app/fonts.rs on main; the cache field and its clears are re-applied there. The cache tests use the ActiveSheet accessors.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-27 19:57:18 +01:00
D. Fender 4bc91dbc6a Tables: import what main's explicit imports now need; run table_style_looks in the it binary 2026-10-27 10:01:46 -07:00
D. Fender 2f0a986bad Merge main into fix/table-style-looks 2026-10-27 09:57:20 -07:00
Neil Cawse 65257b780c Merge main (45f5ab1) into the branch 2026-10-27 02:49:14 +00:00
vangel76andClaude Sonnet 5.5 f9bd1e7eca Fix WordArt for ActiveSheet API change after merge
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-26 20:52:27 +01:00
vangel76andClaude Sonnet 5.5 5a93bc3311 Merge upstream/main into feat/wordart-784
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-26 20:47:05 +01:00
vangel76andClaude Sonnet 5.5 f1d8d2e1e8 Merge upstream/main into feat/wordart-784
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-26 00:07:13 +01:00
vangel76andClaude Sonnet 5.5 3afaf39584 Merge upstream/main into perf/pdf-writer-cleanup
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-26 00:02:43 +01:00
vangel76andClaude Sonnet 5.5 4777381dec Merge upstream/main into fix/group-resize-on-release-1082
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-26 00:00:00 +01:00
vangel76andClaude Sonnet 5.5 97e43b84fa Chart cache test: set the MouseWheel source field added upstream
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 23:59:30 +01:00
vangel76andClaude Sonnet 5.5 6e2ec96c85 Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 23:55:51 +01:00
Neil Cawse c0bc784197 Merge main (ad10881) into the branch 2026-10-25 21:56:37 +00:00
quantmind-br 433ef8c85d Merge remote-tracking branch 'upstream/main' into function-help-portuguese
# Conflicts:
#	ROADMAP.md
2026-10-25 11:01:39 -03:00
vangel76andClaude Sonnet 5.5 e6b6d2d65f Merge upstream/main into perf/chart-frame-cache
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 10:22:23 +01:00
D. Fender f1ffb82737 Merge main into fix/table-style-looks
main (#456) moved the table style swatch's colours to theme tokens. Keep
this branch's cell-by-cell swatch, with its fallback colours taken from
the tokens (grid_bg for the background, cell_text for lines and dashes).
2026-10-24 23:01:09 -07:00
vangel76andClaude Opus 5.5 d59c51ba1f Merge upstream/main into feat/wordart-784
print.rs: main moved shape drawing into draw_shape; the WordArt shadow
pass now sits in its text loop. ja.rs: main's catalog and tests, plus
the two WordArt CORE labels.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-24 20:12:18 +02:00
vangel76andClaude Opus 5.5 bce01e7789 Merge upstream/main into fix/group-resize-on-release-1082
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-24 19:54:27 +02:00
quantmind-br 9d71a809e4 Merge upstream/main into fix/spill-priority 2026-10-24 07:44:03 -03:00
quantmind-br d183fdcb5a Merge upstream/main into fix/spill-priority 2026-10-24 07:17:46 -03:00
quantmind-br c3bd68f061 Merge upstream/main into fix/spill-priority 2026-10-24 06:53:44 -03:00
quantmind-br 8ceee8ef5a Merge remote-tracking branch 'upstream/main' into function-help-portuguese
# Conflicts:
#	docs/localization-parity.md
2026-10-23 16:47:41 -03:00
D. Fender ba0009a1c3 Tables: Centre the dashes in table style swatches
Excel's gallery thumbnails draw each cell's dash across about half the
cell, centred in the space inside the cell's lines. Ours ran nearly
edge to edge and centred on the whole cell, so the dashes in the
header and last row sat a pixel toward the table's frame.

Cell edges are now on whole pixels, and each dash covers about half
the cell, centred inside the cell's own lines. As in Excel, a spare
pixel goes below the dash.
2026-10-23 11:43:58 -07:00
skylar taylor-barrick 0ee8c0d15f Merge remote-tracking branch 'origin/main' into test/backfill-regression-tests 2026-10-23 11:03:45 -06:00
D. Fender c2457bdb8c Tables: Find a table's visible edges once per paint
The grid and print checked, for every painted table cell, whether all
rows and columns between it and the table's edge were hidden. On a big
filtered table that rescans the hidden rows for every cell.

shown_edges() now finds a table's first and last visible row and
column, and the per-paint CfCache keeps it for each table. Print now
always keeps a CfCache.
2026-10-22 19:09:38 -07:00
quantmind-br cbe10f0501 Recalc: clearing an array frees its whole spill area for a blocked array
Clearing (or overwriting) a dynamic array's anchor empties its whole former
spill area, but only arrays above and left of the anchor were re-evaluated,
so an array blocked further right (F13 against C14's C14:I14) stayed
#SPILL! until the next full recalculation. Reported by iluebbe on #964.
2026-10-22 22:17:38 -03:00
MarekSpodBiedry 6535174664 XLSX: write spilled text as cached strings, not shared strings (#2285) 2026-10-22 21:02:30 +02:00
D. Fender 74f09bc672 Tables: Give each style row its own look
Table styles reused three rough templates, so every row of a family in
the Format as Table gallery looked alike. The neutral band was white
darkened about 3%, which is invisible.

Each gallery row (Light 1-7, 8-14, 15-21; Medium 1-7, 8-14, 15-21,
22-28; Dark 1-7, 8, 9-11) now has its own fills, text colours and thin
lines: header rules, row lines, a vertical grid, an outer frame or
white tile gaps, as observed in Excel's gallery. The colours are our
own theme tints. Neutral bands are now visibly grey.

One function gives each cell's look, used by the grid, print, Convert
to Range and the gallery swatches, so the swatches match the tables.
The outer frame follows hidden or filtered edge rows and columns.
Explicit cell fills, fonts and borders still win over the table's.
2026-10-22 11:44:46 -07:00
vangel76andClaude Sonnet 5.5 4b75f3ea00 docs: regenerate parity checklist after merging main
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 20:26:34 +02:00
vangel76 a9069cb8f9 Merge remote-tracking branch 'upstream/main' into feat/wordart-784 2026-10-22 20:23:53 +02:00
skylar taylor-barrick bc0cd89225 #1485: test that the PivotTable field-list scrollbar sits at the pane edge
#1485 let the field list take the pane's width so its scrollbar sits at the pane edge, without a test. With 14 short field names the scrollbar otherwise sits beside them, about 250 px from the edge.
2026-10-22 11:50:34 -06:00
skylar taylor-barrick 524ce912e5 #360: test that Watch Window stays inside the Formulas ribbon
#360 (#342) moved Watch Window out of a three-row column it overflowed, without a test. The test checks Watch Window's painted label ends no lower than the ribbon's last label row; as the fourth small button it ends 15 px below.
2026-10-22 11:50:34 -06:00
skylar taylor-barrick ebc986fcc9 #223: test that the title bar's Save includes the cell being typed
#223 made the title bar's Save button (and the Save Changes dialog's) commit the cell edit before saving, without a test for the button. The test types into A1, clicks Save, and reads the saved file back; with the commit_edit call removed it fails because the file lacks the value.
2026-10-22 11:50:34 -06:00
vangel76 fb71f723fc Merge upstream/main into perf/pdf-writer-cleanup 2026-10-22 19:49:10 +02:00
vangel76 caf897daad Add WordArt labels to the catalogs added on main 2026-10-22 19:40:36 +02:00
vangel76 a9cc381332 Merge upstream/main into feat/wordart-784 2026-10-22 19:35:37 +02:00
vangel76 451debe5e8 Merge upstream/main into fix/group-resize-on-release-1082 2026-10-22 19:32:49 +02:00
vangel76 5f53afd72e Merge remote-tracking branch 'upstream/main' into perf/chart-frame-cache
# Conflicts:
#	ROADMAP.md
#	crates/ui-egui/src/chartview.rs
2026-10-22 19:30:01 +02:00
quantmind-br 66c82e0fd2 Merge remote-tracking branch 'upstream/main' into function-help-portuguese
# Conflicts:
#	ROADMAP.md
#	crates/ui-egui/src/i18n.rs
#	docs/localization-parity.md
2026-10-22 02:28:29 -03:00
quantmind-br c0db2ca597 Merge remote-tracking branch 'upstream/main' into fix/spill-priority
# Conflicts:
#	ROADMAP.md
#	crates/calc/src/tests.rs
2026-10-22 02:28:00 -03:00
Neil Cawse 77cfbda1bc docs: order parity revision history 2026-10-22 05:18:54 +00:00
Neil Cawse f8c4dac15b Merge main (06920de) into the branch 2026-10-22 05:11:38 +00:00
quantmind-br 9f3c04e9ca Merge remote-tracking branch 'origin/function-help' into function-help-portuguese 2026-10-20 08:34:15 -03:00
Cursor AgentandCRBBeesy d0033570df xtask: parity --check accepts a CRLF checkout of the checklist
On Windows with Git's default `core.autocrlf=true` (Git for Windows, GitHub's
`windows-latest` image), `docs/parity-checklist.md` is checked out with CRLF line
ends. `parity --check` compared it byte for byte with the generated text (LF), so
`cargo xtask ci` stopped at `parity` with "out of date" although the file was
current. Line ends are no longer a difference; any other change still is.

Co-authored-by: CRBBeesy <CRBBeesy@users.noreply.github.com>
2026-10-20 03:56:00 +00:00
Neil Cawse 3d19fa43f6 docs: restore the XLSX right-to-left text box row lost in the main merge 2026-10-20 03:14:18 +00:00
Neil Cawse 42d3e9adbb Merge main (23829d8) into the branch
# Conflicts:
#	docs/file-format-parity.md
2026-10-20 01:45:12 +00:00
vangel76andClaude Sonnet 5.5 c7e4d6a19c shape.setText: apply the WordArt length limit
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-20 01:35:46 +02:00
vangel76 30dfc3fbd8 PR789: merge main and preserve WordArt with RTL paragraph export 2026-10-20 00:57:39 +02:00
quantmind-br dd598ba705 Merge remote-tracking branch 'origin/function-help' into function-help-portuguese
# Conflicts:
#	docs/localization-parity.md
2026-10-19 14:06:20 -03:00
Neil Cawse b0c3d8eb3b Merge main (c30fa3f) into the branch 2026-10-18 03:22:52 +00:00
Neil Cawse f410a770c1 Merge main (19f4387) into the branch 2026-10-18 00:49:17 +00:00
Neil Cawse 44526f0d2b Merge main (f1894c6) into the branch 2026-10-17 01:23:08 +00:00
quantmind-br ffe73b3bd7 UI: Brazilian Portuguese function help
Português (Brasil) translates every worksheet function description (479)
and argument name (283) in i18n/pt_functions.rs, so the argument hint,
autocomplete and Insert Function read in Portuguese. The translation is
clean-room (not Excel's text) and still needs a native review.
2026-10-15 10:49:49 -03:00
Local contributor 9cbbaaeaed Docs: CSV export wording matches the code; inferred & boundaries marked
From 1E+15, CSV export writes the shortest round-trip digits, not &'s 15 digits.
'Every digit' now applies only to integers below 1e16.

The open/save round-trip claim is narrowed to files GridCraft wrote. The doc
now lists what a foreign CSV loses on its first save: 16-17-digit decimals are
cut to 15 digits, and scientific input is rounded to its 0.00E+00 format.

The 21-character switch is Excel-verified only for positive 15-digit
mantissas. Shorter mantissas from 1E-6 to 1E-9 and negatives are marked as
inferred, and the doc states the sign isn't counted. The function-parity
'was' value is corrected to main's 0.00000001.
2026-10-14 13:51:54 -04:00
Local contributor bf9b3cb9b1 CSV/text export: integers below 1e16 keep every digit; no exponents
The 2^53 cutoff turned exact 16-digit integers (9007199254740992, 9007199254740994) into
9.00719925474099E+15. A General number is now written with &'s 15 digits but never with an
exponent: reopening a CSV gives a scientific number a 0.00E+00 format that rounds it on the next
save. 1E+15 and up are written as the shortest round-trip digits (every integer below 1e16
exactly, main's output above), small numbers as their 15 digits in full.
2026-10-14 12:59:37 -04:00
Local contributor 6ff543ce76 Values: number text switches to scientific past 21 characters below 1, as Excel
Excel caches IMCSCH("13+5j") as 1.28233995888454E-06 and IMSECH("7+25j")'s imaginary part as
0.000241377759972715: below 1, a 15-digit decimal longer than 21 characters is written in
scientific notation. 9.99999999999999E-9&"" now gives 9.99999999999999E-09, not
0.00000000999999999999999. Affects every number-to-text conversion (&, CONCAT, TEXTJOIN, IM
functions, formula printing, labels).
2026-10-14 12:59:37 -04:00
Local contributor 4dd4ff9a93 CSV/text export: integers below 2^53 keep every digit
Writing every General number as & converts it rounded 16-digit integers such as card and order numbers to 1.23456789012346E+15, so opening a CSV and saving it again changed the data. Integers that f64 holds exactly (|x| < 2^53) are now written with all their digits, as before; larger integers and non-integers keep the 15-significant-digit & text.
2026-10-14 08:23:36 -04:00
Local contributor 9331dbb474 Values: number text rounds to 15 digits before choosing decimal or scientific
number_to_text picked the decimal branch for values in [999999999999999.5, 1e15) and then rounded them up to the 16-digit integer 1000000000000000. It now rounds to 15 significant digits first and chooses the notation from the rounded exponent, so those values read 1E+15 (and -1E+15).
2026-10-14 08:23:36 -04:00
vangel76andClaude Sonnet 5.5 8e30c095db Charts: resolved data and rendering are cached between frames (#1139)
Part of #1098. Charts were resolved and rendered on every frame. The
primitives are now cached per document/sheet/chart and checked against a
Weak<Workbook> (any write to the workbook moves or clones it), the zoom and
pixels-per-point; capped, LRU, closed documents dropped.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-13 20:26:01 +02:00
vangel76andClaude Sonnet 5.5 6090366562 Grid: resizing several selected columns applies the width on release (#1082)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-13 20:09:53 +02:00
neilcawse a6d70bcafb CSV/text export: every General number as & converts it (15 significant digits)
Main writes plain General with Rust's shortest round-trip (0.30000000000000004,
100000000000000000000) and still narrows coloured/sectioned General and numbers in
Text cells to the 11-character cell display (1.24412E+11). Export now formats through
numfmt's format_value_full, which writes General as number_to_text does, replacing
io.rs's plain-General special case. Docs: merge the duplicate CSV/text rows.
2026-10-13 13:14:06 -04:00
vangel76andClaude Sonnet 5.5 c59575b766 Merge main into #789
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-13 19:05:22 +02:00
vangel76andClaude Sonnet 5.5 30ef61982b Merge upstream/main into perf/pdf-writer-cleanup
Combine the writer cleanup with the PDF hardening (#812) and UTF-16BE info strings (#813): sanitised widths/dashes and finite/extent guards now feed the style tracking; tests adapted to emit-on-change.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-13 19:02:32 +02:00
quantmind-br 28a645ca13 Calc: a contested spill area stays with its array on full recalc and reopening (#964)
When two dynamic arrays want the same cells, the one already spilling there keeps them and
the newcomer is #SPILL!, as when the second is entered. recalc_all remembers the layout it
clears (formulas that spilled, formulas that were #SPILL!) and lays arrays out in that order,
then in reading order. The XLSX reader restores a dynamic array's saved `ref` as its spill
range, because the file can only cache #VALUE! for a blocked array.

Found by the command-sequence fuzz.
2026-10-13 08:00:40 -03:00
vangel76andClaude Sonnet 5.5 e04e559da3 PDF: writer cleanup, q nesting limit, image dedupe, style only on change (#816)
Direct object writing, image dedupe, per-page style tracking, 28-level q limit,
explicit joins, /ProcSet dropped. See the PR description.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-12 22:28:19 +02:00
vangel76andClaude Sonnet 5.5 3109f2a9e0 Keytips: NW runs insert.wordArt now that the command exists; pending-sequence test uses NJ (insert.object)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-12 21:47:39 +02:00
vangel76andClaude Sonnet 5.5 a39c6b8977 Calc: SUBTOTAL(10x) recalculates when Row Height, AutoFit Row Height or Ungroup reveal rows
home.rowHeight, home.autofitRowHeight and data.ungroup change row hidden
state without marking the edit structural, so SUBTOTAL(101-111) kept a stale
value. Found by the command-sequence fuzz (seed 3).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-12 21:09:41 +02:00
vangel76andClaude Sonnet 5.5 470968fcdc Insert: WordArt (insert.wordArt) (#784)
Floating decorative text built on the text-box shape path: ShapeKind::WordArt, ten original
styles, outline/shadow, wordArt.set, gallery in the ribbon, XLSX and print.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-12 20:38:11 +02:00
259 changed files with 20976 additions and 9157 deletions
+29
View File
@@ -0,0 +1,29 @@
# This file is machine-generated by `gh actions-lock`.
# Do not edit by hand; run `gh actions-lock` to update.
# Docs: https://gh.io/actions-lockfile
version: 'v0.0.3'
workflows:
'.github/workflows/ci.yml': []
'.github/workflows/freebsd.yml': []
'.github/workflows/house-rules.yml': []
'.github/workflows/lockfile.yml':
- 'actions/checkout@v7.0.1'
- 'step-security/harden-runner@v2.22.4'
'.github/workflows/nix.yml': []
'.github/workflows/packaging-lint.yml':
- 'actions/checkout@v7.0.1'
- 'step-security/harden-runner@v2.22.4'
'.github/workflows/release.yml': []
'.github/workflows/sonarcloud.yml': []
'.github/workflows/windows-arm64.yml': []
dependencies:
'actions/checkout@v7.0.1':
ref: 'v7.0.1'
commit: 'sha1-3d3c42e5aac5ba805825da76410c181273ba90b1'
owner_id: 44036562
repo_id: 197814629
'step-security/harden-runner@v2.22.4':
ref: 'v2.22.4'
commit: 'sha1-1d88384fd173af6ecb012dfd0264a306b711241a'
owner_id: 88700172
repo_id: 422287306
+34
View File
@@ -0,0 +1,34 @@
name: Lockfile
# Fails when .github/workflows/actions.lock is out of sync with the workflows, or when a locked pin
# no longer verifies upstream, so a moved tag cannot slip a different commit into a run.
# Docs: https://gh.io/actions-lockfile
on:
pull_request:
push:
branches: [main]
workflow_dispatch:
permissions:
contents: read
env:
GH_TOKEN: ${{ github.token }}
jobs:
lockfile:
name: Lockfile is in sync
runs-on: ubuntu-24.04
timeout-minutes: 10
steps:
- name: Harden runner
uses: step-security/harden-runner@v2.22.4
with:
egress-policy: audit
- uses: actions/checkout@v7.0.1
with:
persist-credentials: false
- name: Install gh-actions-lock
run: gh extension install github/gh-actions-lock --pin v0.4.1
- name: Verify the lockfile
run: gh actions-lock --verify
+5 -1
View File
@@ -27,7 +27,11 @@ jobs:
name: Windows installation policy (no app build)
runs-on: windows-latest
steps:
- uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
- name: Harden runner
uses: step-security/harden-runner@v2.22.4
with:
egress-policy: audit
- uses: actions/checkout@v7.0.1
with:
persist-credentials: false
- name: Install the pinned packaging toolchain
+5
View File
@@ -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
+3
View File
@@ -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
+4
View File
@@ -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
View File
@@ -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
+303 -35
View File
@@ -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,49 @@ dependencies = [
"libc",
]
[[package]]
name = "craft-cfb"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
[[package]]
name = "craft-csv"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-drawingml"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
dependencies = [
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)",
"kurbo",
"log",
"serde",
]
[[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 +981,81 @@ dependencies = [
"writeable",
]
[[package]]
name = "craft-math"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890#010702ee9b030844c852939095b1da0d0656a890"
dependencies = [
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890)",
"serde",
]
[[package]]
name = "craft-odf"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890#010702ee9b030844c852939095b1da0d0656a890"
dependencies = [
"aes",
"base64 0.23.1",
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890)",
"craft-zip 0.1.0 (git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890)",
"flate2",
"getrandom 0.3.4",
"hmac",
"sha1 0.11.0",
"sha2 0.11.1",
"thiserror 2.0.21",
"zeroize",
]
[[package]]
name = "craft-ods"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890#010702ee9b030844c852939095b1da0d0656a890"
dependencies = [
"craft-odf",
"craft-sheet 0.1.0 (git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890)",
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890)",
"thiserror 2.0.21",
]
[[package]]
name = "craft-offcrypto"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
dependencies = [
"aes",
"base64 0.23.1",
"craft-cfb",
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)",
"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=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
dependencies = [
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)",
"craft-zip 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)",
"log",
"thiserror 2.0.21",
]
[[package]]
name = "craft-pdf"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=ff142b3ad58aa7306676749428f4f2f9b277b5dd#ff142b3ad58aa7306676749428f4f2f9b277b5dd"
[[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 +1066,31 @@ dependencies = [
"winsafe",
]
[[package]]
name = "craft-sheet"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890#010702ee9b030844c852939095b1da0d0656a890"
[[package]]
name = "craft-sheet"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
[[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 +1110,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=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
dependencies = [
"chrono",
"dunce",
@@ -982,6 +1120,7 @@ dependencies = [
"image",
"log",
"plist",
"rustix 1.1.5",
"semver",
"serde",
"serde_json",
@@ -998,7 +1137,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 +1148,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 +1157,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=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
dependencies = [
"egui",
"objc2 0.6.5",
@@ -1034,6 +1173,70 @@ dependencies = [
"windows-sys 0.61.2",
]
[[package]]
name = "craft-xls"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
dependencies = [
"craft-cfb",
"craft-sheet 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)",
"md-5",
"miniz_oxide 0.9.1",
"sha1 0.10.7",
"thiserror 2.0.21",
]
[[package]]
name = "craft-xlsx"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
dependencies = [
"craft-drawingml",
"craft-opc",
"craft-sheet 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)",
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)",
"thiserror 2.0.21",
]
[[package]]
name = "craft-xml"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890#010702ee9b030844c852939095b1da0d0656a890"
dependencies = [
"quick-xml 0.41.0",
"serde",
"thiserror 2.0.21",
]
[[package]]
name = "craft-xml"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
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=010702ee9b030844c852939095b1da0d0656a890#010702ee9b030844c852939095b1da0d0656a890"
dependencies = [
"flate2",
"thiserror 2.0.21",
"zip 9.1.0",
]
[[package]]
name = "craft-zip"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
dependencies = [
"flate2",
"thiserror 2.0.21",
"zip 9.1.0",
]
[[package]]
name = "crc32fast"
version = "1.5.2"
@@ -1114,6 +1317,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 +1338,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 +1403,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 +2096,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]]
@@ -2022,7 +2238,7 @@ dependencies = [
[[package]]
name = "gridcraft"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"arboard",
"chrono",
@@ -2050,7 +2266,7 @@ dependencies = [
[[package]]
name = "gridcraft-calc"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"gridcraft-core",
"gridcraft-formula",
@@ -2062,7 +2278,7 @@ dependencies = [
[[package]]
name = "gridcraft-chart"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"gridcraft-calc",
"gridcraft-core",
@@ -2073,7 +2289,7 @@ dependencies = [
[[package]]
name = "gridcraft-cli"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"gridcraft-engine",
"gridcraft-mcp",
@@ -2086,7 +2302,7 @@ dependencies = [
[[package]]
name = "gridcraft-core"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"chrono",
"js-sys",
@@ -2097,8 +2313,10 @@ dependencies = [
[[package]]
name = "gridcraft-engine"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"craft-csv",
"craft-gridcraft-format",
"gridcraft-calc",
"gridcraft-chart",
"gridcraft-core",
@@ -2114,13 +2332,14 @@ dependencies = [
"serde",
"serde_json",
"thiserror 2.0.21",
"unicode-segmentation",
"web-time",
"zip 3.0.0",
]
[[package]]
name = "gridcraft-formula"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"gridcraft-core",
"serde",
@@ -2129,7 +2348,7 @@ dependencies = [
[[package]]
name = "gridcraft-functions"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"gridcraft-core",
"regex",
@@ -2137,7 +2356,7 @@ dependencies = [
[[package]]
name = "gridcraft-math"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"ratex-font",
"ratex-layout",
@@ -2147,7 +2366,7 @@ dependencies = [
[[package]]
name = "gridcraft-mcp"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"gridcraft-engine",
"log",
@@ -2156,7 +2375,7 @@ dependencies = [
[[package]]
name = "gridcraft-model"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"gridcraft-core",
"gridcraft-formula",
@@ -2169,18 +2388,26 @@ dependencies = [
[[package]]
name = "gridcraft-numfmt"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"gridcraft-core",
]
[[package]]
name = "gridcraft-pdf"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"craft-pdf",
"craft-stream-codecs",
"harfrust",
"sha2 0.11.1",
"skrifa",
"unicode-bidi",
]
[[package]]
name = "gridcraft-sandbox"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"landlock",
"libc",
@@ -2191,7 +2418,7 @@ dependencies = [
[[package]]
name = "gridcraft-ui-egui"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"craft-ui",
"craft-update",
@@ -2218,7 +2445,7 @@ dependencies = [
[[package]]
name = "gridcraft-web"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"craft-web-api",
"craft-web-host",
@@ -2237,16 +2464,23 @@ dependencies = [
[[package]]
name = "gridcraft-xlsx"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"aes",
"craft-cfb",
"craft-csv",
"craft-math",
"craft-ods",
"craft-offcrypto",
"craft-opc",
"craft-xls",
"craft-xlsx",
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)",
"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 +2567,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 +2599,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 +3248,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 +5070,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 +5144,7 @@ dependencies = [
"chrono",
"cmpv2",
"cms",
"const-oid",
"const-oid 0.9.6",
"der",
"hex",
"rand 0.10.3",
@@ -4916,7 +5183,7 @@ dependencies = [
"base64 0.22.1",
"chrono",
"cms",
"const-oid",
"const-oid 0.9.6",
"hex",
"pem",
"rustls-pki-types",
@@ -6519,7 +6786,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 +6801,7 @@ dependencies = [
"windows",
"windows-core",
"windows-implement",
"windows-numerics",
"xml",
]
@@ -6640,7 +6908,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",
@@ -6708,7 +6976,7 @@ checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7"
[[package]]
name = "xtask"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"gridcraft-engine",
"serde_json",
+26 -8
View File
@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
default-members = ["crates/*", "apps/gridcraft", "apps/gridcraft-cli", "xtask"]
[workspace.package]
version = "0.19.0"
version = "0.19.1"
edition = "2024"
license = "MIT OR Apache-2.0"
rust-version = "1.95"
@@ -26,10 +26,31 @@ 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 = "e98299546f5c5c3c22388d16507f8b5e61a5f280", version = "=0.1.0", features = ["egui"] }
# PDF RunLength encoding; this revision also fixes the vendored JBIG2 dependency for Git consumers.
craft-pdf = { git = "https://github.com/storytold/craft-libs", rev = "ff142b3ad58aa7306676749428f4f2f9b277b5dd", version = "0.1.0", default-features = false }
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 = "e98299546f5c5c3c22388d16507f8b5e61a5f280", version = "0.1.0" }
craft-offcrypto = { git = "https://github.com/storytold/craft-libs", rev = "e98299546f5c5c3c22388d16507f8b5e61a5f280", version = "0.1.0" }
craft-ods = { git = "https://github.com/storytold/craft-libs", rev = "010702ee9b030844c852939095b1da0d0656a890", 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 = "e98299546f5c5c3c22388d16507f8b5e61a5f280", 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 = "e98299546f5c5c3c22388d16507f8b5e61a5f280", version = "0.1.0" }
craft-math = { git = "https://github.com/storytold/craft-libs", rev = "010702ee9b030844c852939095b1da0d0656a890", 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.
# SpreadsheetML string encoding/decoding; workbook model mapping stays in gridcraft-xlsx.
craft-xlsx = { git = "https://github.com/storytold/craft-libs", rev = "e98299546f5c5c3c22388d16507f8b5e61a5f280", version = "0.1.0" }
craft-xml = { git = "https://github.com/storytold/craft-libs", rev = "e98299546f5c5c3c22388d16507f8b5e61a5f280", version = "0.1.0" }
craft-xls = { git = "https://github.com/storytold/craft-libs", rev = "e98299546f5c5c3c22388d16507f8b5e61a5f280", version = "0.1.0" }
# foundation
thiserror = "2"
@@ -44,9 +65,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 +90,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 = "e98299546f5c5c3c22388d16507f8b5e61a5f280", default-features = false, features = ["egui"] }
[workspace.lints.rust]
unsafe_code = "forbid"
+1 -1
View File
@@ -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,
+23 -2
View File
@@ -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-16 · **Change:** minor (a selected chart outlines its names, categories and values in Excel's colours, and dragging the values outline's corner changes the chart's data, #4389, #4390; earlier: 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) |
@@ -134,6 +135,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
| Date | What landed |
|---|---|
| 2026-11-16 | A selected chart outlines its data as Excel does (series names red, category labels purple, values one blue block), and dragging a corner of the values outline changes the cells the chart plots: series keep their formatting, a wider block adds series, aligned names and labels follow, one undo step, Esc cancels; `chart.setValuesRange` does the same for scripts, the CLI and MCP (#4389, #4390) |
| 2026-11-06 | A sheet keeps its own scroll position when sheets are inserted, deleted or moved before it: a new PivotTable or inserted sheet opens at the top instead of where its neighbour was scrolled; a closed window's positions are let go (#3485) |
| 2026-11-02 | Form controls: Insert › Controls places buttons, sliders (scroll bars) and spin buttons on the sheet. A slider or spin button holds a whole number from 0 to 30000 in a linked cell (a drag or a held arrow is one undo step, and editing the cell moves the control); a button runs a macro or one command through the macro policy, asking first in a workbook opened from a file; Assign Action and Format Control edit them, and XLSX files read and write them (control properties, `<controls>` and VML), alongside the form controls GridCraft keeps unchanged |
| 2026-11-02 | Dialogs take ranges by selection on the grid: reference boxes (RefEdit) with a collapse button that shrinks the dialog while the person selects, in Goal Seek, Solver (including the Model Range of Load/Save) and Data Analysis; while collapsed, the arrow keys move the selection and Shift+arrow extends it, and F4 cycles a reference's anchors |
@@ -149,6 +151,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 |
@@ -174,14 +178,17 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
| 2026-10-19 | Long flat operator chains (`=A1+A2+…`) up to Excel's 8,192-character limit (4,096 operands): entering, filling, inserting rows, undo, Evaluate Formula and XLSX save no longer overflow the stack; chains past 64 operands are saved as plain formulas, not dynamic arrays; Spanish formula entry accepts chains past 256 operands (#916) |
| 2026-10-19 | Linux: "Use system setting" for the theme keeps following the desktop when the XDG Desktop Portal stops answering: each read gives up after 2 s and the next poll reconnects, where one unanswered call stalled the watcher for the rest of the session |
| 2026-10-16 | Memory: undo steps share a sheet's picture bytes and the workbook's VBA project instead of copying them: 50 edits on a sheet with a 20 MB picture keep 22 MB instead of 992 MB |
| 2026-10-16 | Custom Sort dialog: header-named column dropdowns, smart Order labels, add/delete/copy/move levels, resizable window, selection follows the headers checkbox and returns on close; a selected block (such as a table's totals row) is sorted as selected |
| 2026-10-16 | Memory: floating pictures are decoded at about the size they are drawn, with limits, into a cache bounded by bytes and dropped with their workbook, instead of at full size into one that never let go; two open workbooks no longer show each other's picture. 12 large pictures scrolled through keep 40 MB of textures instead of 258 MB, and none once the workbook closes |
| 2026-10-16 | The web app keeps its preferences between visits (#1562): theme (dark mode), interface size, language, editing options and the rest of what the desktop app saves in `ui.json` and `prefs.json` are kept in the browser's `localStorage`, written as soon as they change |
| 2026-10-16 | Memory: the interface and script fallback fonts are read once per run and shared with egui instead of copied into it: an empty workbook settles at 158 MB instead of 258 MB on macOS |
| 2026-10-15 | Function help in Brazilian Portuguese: every description and argument name (479 and 283) |
| 2026-10-15 | File › Options › Formulas: Maximum Iterations and Maximum Change fields for iterative calculation, disabled while it is off, with Excel's limits (1 to 32767, 0 or more) |
| 2026-10-15 | Function help follows the interface language: argument hints, autocomplete, Insert Function (search and readable categories) and the Formulas-tab menus read per-language tables of descriptions and argument names; Spanish keeps its 10 functions in the new format |
| 2026-10-15 | Row auto-fit counts a cell's line breaks only when the cell wraps, as Excel does: a file whose unwrapped cells hold multi-line text no longer opens with tall rows (typing a break still turns wrap on and grows the row) |
| 2026-10-14 | Set precision as displayed is applied: with the option on, formula results, spills and numbers typed or reformatted are stored as their number format shows them and formulas calculate from those values; `formulas.calculationOptions` gains `precisionAsDisplayed` (turning it on rounds existing constants; locked constants on a protected sheet keep their value; numbers written to a new sheet are rounded too) (#1343) |
| 2026-10-14 | Lookups (MATCH, XMATCH, VLOOKUP, HLOOKUP, XLOOKUP, LOOKUP) compare numbers exactly like Excel, so a computed key such as `=0.1+0.2` no longer finds 0.3; `=` and COUNTIF/SUMIF keep their 15-digit comparison |
| 2026-10-14 | RATE matches Excel's solver: the same last iterate for slowly converging cases (about -100% when the future value is 0, instead of `#NUM!`) and `#NUM!` where Excel's iteration can't reach a very large rate |
| 2026-10-14 | Functions: EOMONTH, EDATE, WORKDAY, NETWORKDAYS, YEARFRAC, WEEKNUM, the bond and coupon functions, DISC, BIN2DEC, IM* and the other Analysis ToolPak functions give `#VALUE!` for a reference to more than one cell in a value argument, as Excel 365 does, instead of spilling; array constants and computed arrays still lift |
| 2026-10-14 | Protect Sheet on a protected sheet: Home › Format, its keytips (HOP, RPS) and the tab menu now read Unprotect Sheet… and unprotect (straight away without a password); a protected sheet that forbids selecting locked (or unlocked) cells is enforced for clicks, arrows and Go To, and the Protect Sheet dialog has the select options (#1346) |
| 2026-10-14 | `.xls` (Excel 97-2003) files open with their formatting: fonts, solid and pattern fills, borders (with diagonals), alignment (rotation, indent, wrap, shrink), locked and hidden cells, the workbook's custom colour palette, its Normal font and its user-defined cell styles |
@@ -198,9 +205,15 @@ 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 | Spills: an array that grows into cells another array's spill already holds is `#SPILL!`, in automatic calculation and after Calculate Now, as in Excel; a workbook reopened from XLSX keeps the spill layout it was saved with (#964, found by the command-sequence fuzz) |
| 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) |
@@ -266,6 +279,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
| Date | Change | Summary |
|---|---|---|
| 2026-11-16 | minor | Progress log: chart data outline in three colours, dragged from its corners (#4389, #4390) |
| 2026-11-06 | trivial | Progress log: scroll positions follow their sheet through sheet inserts, deletes and moves (#3485) |
| 2026-11-05 | minor | Reconcile upstream form-control progress with the CJK baseline update |
| 2026-11-02 | minor | Form controls; catalog 277 / 292 → 281 / 296 (Developer › Controls); progress log row |
@@ -281,6 +295,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 |
@@ -308,11 +324,16 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
| 2026-10-14 | minor | XLSX dynamic-array `cm` metadata kept on save; progress log row |
| 2026-10-14 | minor | Progress log: spill anchor reading its old spill area |
| 2026-10-14 | minor | Progress log: formulas reading an array that loses a spill conflict |
| 2026-10-14 | trivial | Progress log: RATE follows Excel's iteration |
| 2026-10-13 | trivial | Progress log: More Colors… and Recent Colors in the colour menus (#928) |
| 2026-10-13 | minor | Multi-level category axes (read, drawn, written); progress log row |
| 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 |
+40 -18
View File
@@ -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,
+43 -2
View File
@@ -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()
}
+38
View File
@@ -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).
+107 -1
View File
@@ -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`.
+2 -2
View File
@@ -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 }
+56 -26
View File
@@ -12,10 +12,10 @@
//! - `gridcraft:open` (from the host): `{ name, bytes }`. It opens like a workbook picked with
//! File › Open or dropped on the window; a file over [`MAX_OPEN_BYTES`] is refused before it is
//! copied.
//! - `gridcraft:save` (to the host): `{ name, saveAs, bytes }` for every file GridCraft would
//! otherwise download: Save and Save As (an .xlsx workbook) and Export as PDF. The host stores
//! it and reports failures itself. GridCraft doesn't tell the host which saves make a file the
//! document, so `saveAs` is always `false`.
//! - `gridcraft:save` (to the host): `{ name, saveAs, bytes, export }` for every file GridCraft
//! would otherwise download. With `export: false`, the host stores the XLSX workbook; with
//! `export: true`, it stores a separate file (such as a PDF) without replacing the workbook.
//! `saveAs` remains `false`; it does not distinguish Save from Save As here.
//! - `gridcraft:dirty` whenever unsaved changes appear or go away, `gridcraft:failed` when the
//! app couldn't start.
//!
@@ -27,16 +27,16 @@ use std::cell::RefCell;
use std::rc::Rc;
use craft_web_host::web::{FileData, Host, Message};
use craft_web_host::{Mode, Outgoing, file_name, message_type};
use gridcraft_ui_egui::{Inbox, Services, SheetApp};
use wasm_bindgen::JsValue;
use crate::host_save::{SaveMessage, sync_saved};
use crate::hostmode::open_name;
/// The app id in the host messages (`gridcraft:ready`).
const APP: &str = "gridcraft";
/// Saved files that count as a workbook: the document is then clean under the name it was saved as.
const WORKBOOK_EXTS: &[&str] = &["xlsx"];
/// The largest workbook taken from the host page, refused before it is copied.
const MAX_OPEN_BYTES: u64 = 512 << 20;
@@ -46,6 +46,7 @@ const MAX_AUTHOR_CHARS: usize = 200;
#[derive(Clone)]
pub struct Bridge {
host: Rc<Host>,
save_target: Rc<SaveTarget>,
/// Names of the files handed to the host since the last frame.
saved: Rc<RefCell<Vec<String>>>,
}
@@ -55,7 +56,19 @@ impl Bridge {
/// `data-host="page"` on the canvas, an unframed `?host=parent` page (it stays the normal app
/// with downloads), or a parent on another origin.
pub fn detect(canvas: &web_sys::HtmlCanvasElement) -> Option<Self> {
Some(Self { host: Rc::new(Host::connect(APP, canvas)?), saved: Rc::default() })
let host = Host::connect(APP, canvas)?;
let save_target = match host.mode() {
Mode::Parent => {
// Host::connect already admitted only a same-origin parent. Keep that origin
// as the postMessage target so later navigation can't receive workbook bytes.
let window = web_sys::window()?;
let parent = window.parent().ok().flatten()?;
let origin = window.location().origin().ok()?;
SaveTarget::Parent { parent, origin }
}
Mode::Page => SaveTarget::Page(canvas.clone()),
};
Some(Self { host: Rc::new(host), save_target: Rc::new(save_target), saved: Rc::default() })
}
/// Send saved and exported files to the host instead of downloading them, and hear files
@@ -91,20 +104,13 @@ impl Bridge {
/// crate does not repeat a state it already reported).
pub fn sync(&self, app: &mut SheetApp) {
let saved = std::mem::take(&mut *self.saved.borrow_mut());
if let Some(name) = saved.iter().rev().find(|name| is_workbook(name))
&& let Some(doc) = app.session.active_mut()
{
doc.saved = doc.wb.clone();
if doc.path.is_none() {
doc.title = name.clone();
}
}
sync_saved(&saved, app);
self.host.post_dirty(app.session.documents().iter().any(|d| d.is_dirty()));
}
fn post_save(&self, path: &str, bytes: &[u8]) -> Result<(), String> {
let name = file_name(path);
self.host.post_save(&name, bytes, None, false)?;
let name = file_name(Some(path), "document");
self.save_target.post(SaveMessage::new(&name, bytes)).map_err(|e| e.as_string().unwrap_or_else(|| format!("{e:?}")))?;
self.saved.borrow_mut().push(name);
Ok(())
}
@@ -118,6 +124,38 @@ impl Bridge {
}
}
/// A save-only adapter: the pinned host crate's `post_save` cannot add app-specific fields.
/// All other messages and transport detection still go through `Host`.
enum SaveTarget {
Parent { parent: web_sys::Window, origin: String },
Page(web_sys::HtmlCanvasElement),
}
impl SaveTarget {
fn post(&self, save: SaveMessage<'_>) -> Result<(), JsValue> {
let buffer = js_sys::Uint8Array::from(save.bytes).buffer();
let kind = message_type(APP, Outgoing::Save.kind());
let payload = js_sys::Object::new();
let set = |key, value: JsValue| js_sys::Reflect::set(&payload, &JsValue::from_str(key), &value);
set("name", save.name.into())?;
set("bytes", buffer.clone().into())?;
set("saveAs", JsValue::FALSE)?;
set("export", JsValue::from_bool(save.export))?;
match self {
Self::Parent { parent, origin } => {
set("type", kind.as_str().into())?;
parent.post_message_with_transfer(&payload, origin, &js_sys::Array::of1(&buffer))
}
Self::Page(canvas) => {
let init = web_sys::CustomEventInit::new();
init.set_detail(&payload.into());
let event = web_sys::CustomEvent::new_with_event_init_dict(&kind, &init)?;
canvas.dispatch_event(&event).map(|_| ())
}
}
}
}
/// The file an open message carries, pushed onto the inbox for the next frame, like a dropped
/// file. A host's file is untrusted input: an oversized one is refused before it is copied into
/// the app's memory (the data's own length, not the host's claim).
@@ -133,11 +171,3 @@ fn deliver_open(inbox: &Inbox, ctx: &egui::Context, name: &str, data: &FileData)
inbox.lock().unwrap_or_else(|e| e.into_inner()).push((open_name(name), array.to_vec()));
ctx.request_repaint();
}
fn is_workbook(name: &str) -> bool {
name.rsplit_once('.').is_some_and(|(_, ext)| WORKBOOK_EXTS.iter().any(|e| ext.eq_ignore_ascii_case(e)))
}
fn file_name(path: &str) -> String {
std::path::Path::new(path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| path.to_string())
}
+104
View File
@@ -0,0 +1,104 @@
//! Host save payloads and workbook receipts, shared with native regression tests.
use gridcraft_ui_egui::SheetApp;
/// Only these outputs replace the editable workbook in the host.
const WORKBOOK_EXTS: &[&str] = &["xlsx"];
pub struct SaveMessage<'a> {
pub name: &'a str,
pub bytes: &'a [u8],
pub export: bool,
}
impl<'a> SaveMessage<'a> {
pub fn new(name: &'a str, bytes: &'a [u8]) -> Self {
// All other outputs are exports, not necessarily PDFs.
Self { name, bytes, export: !is_workbook(name) }
}
}
fn is_workbook(name: &str) -> bool {
name.rsplit_once('.').is_some_and(|(_, ext)| WORKBOOK_EXTS.iter().any(|e| ext.eq_ignore_ascii_case(e)))
}
/// Preserve the bridge's existing rule: only a workbook receipt marks the document saved.
pub fn sync_saved(saved: &[String], app: &mut SheetApp) {
if let Some(name) = saved.iter().rev().find(|name| is_workbook(name))
&& let Some(doc) = app.session.active_mut()
{
doc.saved = doc.wb.clone();
if doc.path.is_none() {
doc.title = name.clone();
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use gridcraft_engine::Session;
use serde_json::json;
use std::sync::Arc;
#[test]
fn save_payload_marks_exports_and_preserves_name_and_bytes() {
let bytes = [0, 1, 127, 128, 255];
for (name, export) in [("finance.xlsx", false), ("finance.XLSX", false), ("finance.pdf", true), ("finance.PDF", true)] {
let message = SaveMessage::new(name, &bytes);
assert_eq!(message.export, export, "{name}");
assert_eq!(message.name, name);
assert_eq!(message.bytes, bytes.as_slice());
assert_eq!(message.bytes.as_ptr(), bytes.as_ptr(), "the payload borrows the original bytes");
}
}
#[test]
fn other_outputs_are_exports_not_workbook_saves() {
for name in ["finance.csv", "finance.bin", "finance", "finance.xlsx.pdf", "finance.xlsx.bak"] {
assert!(SaveMessage::new(name, &[]).export, "{name}");
}
assert!(!SaveMessage::new("finance.pdf.xlsx", &[]).export);
}
fn edited_app() -> Result<SheetApp, String> {
let mut session = Session::new();
session.new_workbook();
session.execute("cell.set", json!({"cell": "A1", "input": "42"})).map_err(|e| e.to_string())?;
Ok(SheetApp::new(session, Default::default()))
}
#[test]
fn pdf_receipts_leave_the_workbook_dirty_and_its_title_unchanged() -> Result<(), String> {
for name in ["finance.pdf", "finance.PDF"] {
let mut app = edited_app()?;
let doc = app.session.active().ok_or("no active document")?;
assert!(doc.is_dirty());
let title = doc.title.clone();
let saved = doc.saved.clone();
sync_saved(&[name.to_string()], &mut app);
let doc = app.session.active().ok_or("no active document")?;
assert!(doc.is_dirty(), "{name}");
assert!(Arc::ptr_eq(&saved, &doc.saved), "an export must not replace the saved snapshot");
assert_eq!(doc.title, title);
}
Ok(())
}
#[test]
fn workbook_receipts_mark_saved_and_later_exports_do_not_replace_them() -> Result<(), String> {
for name in ["finance.xlsx", "finance.XLSX"] {
let mut app = edited_app()?;
assert!(app.session.active().ok_or("no active document")?.is_dirty());
sync_saved(&[name.to_string(), "finance.pdf".to_string()], &mut app);
let doc = app.session.active().ok_or("no active document")?;
assert!(!doc.is_dirty());
assert!(Arc::ptr_eq(&doc.saved, &doc.wb));
assert_eq!(doc.title, name);
app.session.execute("cell.set", json!({"cell": "A1", "input": "43"})).map_err(|e| e.to_string())?;
sync_saved(&["finance.PDF".to_string()], &mut app);
assert!(app.session.active().ok_or("no active document")?.is_dirty(), "a subsequent export leaves new edits unsaved");
}
Ok(())
}
}
+2
View File
@@ -26,6 +26,8 @@ mod api;
#[cfg(target_arch = "wasm32")]
mod host;
#[cfg(any(target_arch = "wasm32", test))]
mod host_save;
#[cfg(any(target_arch = "wasm32", test))]
mod hostmode;
#[cfg(any(target_arch = "wasm32", test))]
mod prefs;
+1 -4
View File
@@ -25,9 +25,6 @@ chrono = { workspace = true }
# Icon + VERSIONINFO for gridcraft.exe; build.rs only uses it when the target is Windows.
winresource = "0.1"
[target.'cfg(all(unix, not(any(target_os = "macos", target_os = "linux"))))'.dependencies]
winit = { version = "0.30", default-features = false, features = ["x11"] }
[target.'cfg(target_os = "linux")'.dependencies]
# Retain X11 fallback; draw Wayland client-side controls without bundled title fonts.
winit = { version = "0.30", default-features = false, features = ["x11", "wayland-csd-adwaita-notitle"] }
@@ -35,7 +32,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"] }
+16 -21
View File
@@ -17,6 +17,7 @@ mod graphics;
mod logging;
#[cfg(target_os = "macos")]
mod native_menu;
mod opener;
mod print;
use std::cell::RefCell;
@@ -218,16 +219,16 @@ fn open_with_system(target: &str) {
log::warn!("refused to open {target:?}: only http, https and mailto links are opened");
return;
};
let target = target.as_str();
let cmd = if cfg!(target_os = "macos") {
"open"
} else if cfg!(windows) {
"explorer"
} else {
"xdg-open"
// By absolute path where the platform has one (#2176): a bare `explorer` would be looked up
// in the application's directory first.
let env = |key: &str| std::env::var(key).ok();
let (system_root, windir) = (env("SystemRoot"), env("windir"));
let Some((program, arg)) = opener::opener_command(opener::Os::current(), &target, system_root.as_deref(), windir.as_deref()) else {
log::warn!("refused to open {target:?}: it could be read as an option");
return;
};
if let Err(e) = std::process::Command::new(cmd).arg(target).spawn() {
log::warn!("{cmd} {target}: {e}");
if let Err(e) = std::process::Command::new(&program).arg(&arg).spawn() {
log::warn!("{} {arg}: {e}", program.display());
}
}
@@ -340,12 +341,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);
}
@@ -354,21 +359,11 @@ fn main() -> eframe::Result<()> {
}
let window_builder = viewport.clone();
let options = eframe::NativeOptions { viewport, ..Default::default() };
#[cfg(unix)]
#[cfg(target_os = "macos")]
let mut options = options;
// Intel Macs: Metal's compiler aborts on wgpu's indirect-validation shaders (see graphics.rs).
#[cfg(target_os = "macos")]
graphics::configure_indirect_validation(&mut options, graphics::skips_indirect_validation(true, cfg!(target_arch = "x86_64")));
// winit has no file drag-and-drop on Wayland (only on X11), so dropping files from the file
// manager showed a "no" cursor. Run through XWayland when it's there; GRIDCRAFT_WAYLAND=1
// keeps the native Wayland backend.
#[cfg(all(unix, not(target_os = "macos")))]
if std::env::var_os("DISPLAY").is_some_and(|d| !d.is_empty()) && std::env::var_os("GRIDCRAFT_WAYLAND").is_none() {
options.event_loop_builder = Some(Box::new(|b| {
use winit::platform::x11::EventLoopBuilderExtX11;
b.with_x11();
}));
}
// Before eframe creates the wgpu instance: Windows starts on DirectX 12, or OpenGL when
// DirectX 12 has no GPU driver, and never touches Vulkan unless asked (see graphics.rs).
#[cfg(target_os = "windows")]
+151
View File
@@ -0,0 +1,151 @@
//! How a link is handed to the operating system's opener (#2176).
//!
//! The opener is spawned by absolute path where the platform has a fixed one: a bare program name
//! on Windows is searched for in the application's own directory (and the current directory)
//! before System32 and the Windows directory, so an `explorer.exe` planted next to a portable
//! GridCraft would run with the user's session. The target never becomes an option of the opener,
//! and on Windows the characters Explorer's own command-line parser treats specially are
//! percent-encoded. Pure functions, so the tests run on every OS.
use std::path::PathBuf;
/// Whose opener to use.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Os {
Mac,
Windows,
/// Linux, the BSDs and other freedesktop systems: `xdg-open`.
Other,
}
impl Os {
pub fn current() -> Os {
if cfg!(target_os = "macos") {
Os::Mac
} else if cfg!(windows) {
Os::Windows
} else {
Os::Other
}
}
}
/// Used when neither `SystemRoot` nor `windir` holds a usable path.
const DEFAULT_WINDOWS_DIR: &str = "C:\\Windows";
/// The Windows directory: `SystemRoot`, else `windir`, else `C:\Windows`. A value is used only
/// when it is a local drive path (`X:\…`) without `..` segments; relative or network values
/// would bring back the search this exists to avoid.
pub fn windows_dir(system_root: Option<&str>, windir: Option<&str>) -> String {
[system_root, windir]
.into_iter()
.flatten()
.map(str::trim)
.find(|d| is_local_drive_path(d))
.map_or(DEFAULT_WINDOWS_DIR, |d| d.trim_end_matches(['\\', '/']))
.to_string()
}
/// `X:\…` or `X:/…` (not the drive-relative `X:` or `X:dir`), with no `..` segment and no quote.
fn is_local_drive_path(d: &str) -> bool {
let mut chars = d.chars();
let drive = chars.next().is_some_and(|c| c.is_ascii_alphabetic()) && chars.next() == Some(':');
let rest = chars.as_str();
let rooted = rest.starts_with(['\\', '/']);
drive && rooted && !d.contains('"') && !rest.split(['\\', '/']).any(|seg| seg == "..")
}
/// Percent-encodes the characters Explorer's command-line parser (comma-separated switches such
/// as `/select,`), the C runtime's quoting rules and `cmd` treat specially: space, `"`, `,` and
/// `^`. Space, `"` and `^` may not appear unencoded in a URL, so encoding them leaves the address
/// unchanged. A comma may, and RFC 3986 does not treat `%2C` as equivalent to it (a `mailto:`
/// recipient list is comma-separated); it is encoded anyway because Explorer's parser separates
/// switches at commas, and a handler that percent-decodes the address sees the comma again.
pub fn escape_for_explorer(target: &str) -> String {
let mut out = String::with_capacity(target.len());
for c in target.chars() {
match c {
' ' => out.push_str("%20"),
'"' => out.push_str("%22"),
',' => out.push_str("%2C"),
'^' => out.push_str("%5E"),
_ => out.push(c),
}
}
out
}
/// The program and its single argument that open `target` (already accepted by
/// `links::classify`) on `os`. `None` when the target could be read as an option: it starts with
/// `-` or `/`, or is empty. `xdg-open` takes no `--`, so refusing is the only safe answer.
pub fn opener_command(os: Os, target: &str, system_root: Option<&str>, windir: Option<&str>) -> Option<(PathBuf, String)> {
if target.is_empty() || target.starts_with(['-', '/']) {
return None;
}
Some(match os {
Os::Mac => (PathBuf::from("/usr/bin/open"), target.to_string()),
Os::Windows => {
let exe = format!("{}\\explorer.exe", windows_dir(system_root, windir));
(PathBuf::from(exe), escape_for_explorer(target))
}
// Found on PATH: its location differs between distributions and the BSDs.
Os::Other => (PathBuf::from("xdg-open"), target.to_string()),
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn windows_opener_is_explorer_in_the_windows_directory() {
let (exe, arg) = opener_command(Os::Windows, "https://a.example/x", Some("C:\\Windows"), None).unwrap_or_default();
assert_eq!(exe, PathBuf::from("C:\\Windows\\explorer.exe"));
assert_eq!(arg, "https://a.example/x");
// Never a bare name, whatever the environment says.
for (root, windir) in [(None, None), (Some(""), Some("")), (Some("Windows"), None), (Some(".\\"), Some("explorer"))] {
let (exe, _) = opener_command(Os::Windows, "https://a.example", root, windir).unwrap_or_default();
assert_eq!(exe, PathBuf::from("C:\\Windows\\explorer.exe"), "{root:?} {windir:?}");
}
}
#[test]
fn windows_dir_prefers_system_root_then_windir_then_default() {
assert_eq!(windows_dir(Some("D:\\WINNT\\"), Some("E:\\Win")), "D:\\WINNT");
assert_eq!(windows_dir(None, Some("E:\\Win")), "E:\\Win");
assert_eq!(windows_dir(Some("relative\\dir"), Some("e:/win/")), "e:/win");
assert_eq!(windows_dir(None, None), "C:\\Windows");
assert_eq!(windows_dir(Some("D:\\"), None), "D:");
for bad in ["\\\\host\\share", "//host/share", "C:", "C:Windows", "C:\\Windows\\..\\Users\\x", "C:\\\"x", "", " ", "1:\\x"] {
assert_eq!(windows_dir(Some(bad), None), "C:\\Windows", "{bad:?}");
}
}
#[test]
fn explorer_switch_characters_are_percent_encoded() {
let (_, arg) = opener_command(Os::Windows, "https://x/,/select,C:\\Windows\\a b\"^", None, None).unwrap_or_default();
assert_eq!(arg, "https://x/%2C/select%2CC:\\Windows\\a%20b%22%5E");
assert!(!arg.contains([' ', '"', ',', '^']));
assert_eq!(escape_for_explorer("mailto:a@b.example?subject=Hi there"), "mailto:a@b.example?subject=Hi%20there");
// Other platforms get the address as it is.
let (_, arg) = opener_command(Os::Other, "https://x/a,b", None, None).unwrap_or_default();
assert_eq!(arg, "https://x/a,b");
}
#[test]
fn mac_and_freedesktop_openers() {
let (exe, arg) = opener_command(Os::Mac, "https://a.example", None, None).unwrap_or_default();
assert_eq!((exe, arg.as_str()), (PathBuf::from("/usr/bin/open"), "https://a.example"));
let (exe, _) = opener_command(Os::Other, "mailto:a@b.example", None, None).unwrap_or_default();
assert_eq!(exe, PathBuf::from("xdg-open"));
}
#[test]
fn a_target_never_becomes_an_option() {
for os in [Os::Mac, Os::Windows, Os::Other] {
for bad in ["-a", "--help", "-e calc", "/select,C:\\x", "/root,C:\\", ""] {
assert_eq!(opener_command(os, bad, None, None), None, "{os:?} {bad:?}");
}
}
}
}
+5
View File
@@ -26,6 +26,11 @@ sync_github_name = false
[people.edurbs]
sync_github_name = true
[people.Cheejyg]
real_name = "Glenn Chee"
display_name = "Cheejyg"
sync_github_name = false
[people.arcanii]
real_name = "Bryan Mark"
display_name = "Arcanii"
+1
View File
@@ -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
View File
@@ -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",
+1
View File
@@ -4,6 +4,7 @@
#![forbid(unsafe_code)]
pub mod eval;
mod pivotdata;
mod precision;
pub mod recalc;
mod spill_index;
+149
View File
@@ -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))
}
}
+167 -4
View File
@@ -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,64 @@ 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, for
/// each cell both want:
///
/// 1. the anchor whose spill held that cell before this calculation keeps it, so an array that
/// grows into another's area is `#SPILL!` even when it held a spill of its own;
/// 2. otherwise an anchor that held a spill before this calculation outranks one that did not;
/// 3. otherwise the anchor first in reading order (row, then column) wins.
///
/// Rule 3 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, so it agrees with the incremental one; a workbook that is calculated for the first
/// time has no such layout (rule 3 only). The xlsx reader restores the area each dynamic array
/// was saved spilling over, so a workbook opened from a file keeps the layout it was saved with.
#[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>,
/// The area each anchor that held a spill filled before this calculation, for the anchors the
/// calculation lays out again (full: all of them; incremental: the formulas it recalculates).
/// Any other anchor still fills the area the sheet shows.
areas: HashMap<Key, RangeRef>,
}
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 and neither held them (rules 2, 3).
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),
}
}
/// Whether `k`'s spill held `cell` before this calculation; `now` is the area the sheet
/// shows for `k`.
fn held_cell(&self, k: Key, now: Option<RangeRef>, cell: CellRef) -> bool {
self.had_spill(k) && self.areas.get(&k).copied().or(now).is_some_and(|r| r.contains(cell))
}
/// Whether `a` takes `cell` from `b` when both want it (rule 1, then [`Self::outranks`]). Each
/// anchor comes with the area the sheet shows for it.
fn outranks_at(&self, (a, a_now): (Key, Option<RangeRef>), (b, b_now): (Key, Option<RangeRef>), cell: CellRef) -> bool {
match (self.held_cell(a, a_now, cell), self.held_cell(b, b_now, cell)) {
(true, false) => true,
(false, true) => false,
_ => self.outranks(a, b),
}
}
}
/// 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 +161,7 @@ impl Default for Calc {
fixed_now: None,
circular: vec![],
last_recalc_cells: 0,
standing: Standing::default(),
spill_errors: SpillErrors::default(),
}
}
@@ -269,6 +330,20 @@ 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 areas: HashMap<Key, RangeRef> = HashMap::default();
for i in 0..wb.sheets.len() {
if let Some(sh) = wb.sheet(i) {
areas.extend(
sh.spill_ranges
.iter()
.filter(|(a, _)| sh.cell(**a).is_some_and(|c| c.formula.is_some() || c.py.is_some()))
.map(|(a, r)| ((i, *a), *r)),
);
}
}
let held = areas.keys().copied().collect();
// 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 +355,9 @@ impl Calc {
}
}
let all: Vec<Key> = self.graph.nodes.keys().copied().collect();
self.standing = Standing { held: true, keys: held, areas };
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 +468,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 +556,29 @@ 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) {
match wb.sheet(k.0).and_then(|s| s.spill_ranges.get(&k.1)) {
Some(r) => {
self.standing.areas.insert(k, *r);
}
None => {
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 +596,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 +695,45 @@ 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 on every cell they share 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.intersection(&range).is_some_and(|shared| {
shared.iter().all(|cell| standing.outranks_at((*key, old), ((key.0, **o), Some(**r)), cell))
})
})
.map(|(o, r)| (*o, *r))
.collect()
} else {
Vec::new()
};
let blocked = spill_is_blocked(sheet, (*key, old), 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 +770,33 @@ 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` (with the area the sheet showed for it) 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, now): (Key, Option<RangeRef>),
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_at((anchor, now), ((anchor.0, *o), Some(*r)), cell))
};
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) {
+13 -3
View File
@@ -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 on
/// a cell they share (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_at(((sheet, *o), Some(*r)), ((sheet, anchor), own.copied()), c)
})
};
end.row >= gridcraft_core::MAX_ROWS
+243
View File
@@ -368,6 +368,24 @@ fn iterative_calculation_of_text_and_errors() {
assert_eq!(t.get("B1"), Value::Error(CellError::Div0));
}
/// `&`, CONCAT and TEXTJOIN turn a number into at most 15 significant digits, decimal unless that
/// would need 16 integer digits or more than 21 characters below 1.
#[test]
fn text_joins_convert_numbers_to_15_significant_digits() {
let mut t = T::new();
for (formula, text) in [
("=(1E15-0.5)&\"\"", "1E+15"),
("=(999999999999999)&\"\"", "999999999999999"),
("=1234567890123456&\"\"", "1.23456789012346E+15"),
("=(9.99999999999999E-9)&\"\"", "9.99999999999999E-09"),
("=CONCAT(1/3*1E-5)", "3.33333333333333E-06"),
("=TEXTJOIN(\",\",TRUE,1/3*1E-4,0.1+0.2)", "0.0000333333333333333,0.3"),
] {
t.set("A1", formula);
assert_eq!(t.get("A1"), Value::from(text), "{formula}");
}
}
#[test]
fn circular_references_without_iterative_calculation() {
let mut t = T::new();
@@ -706,6 +724,53 @@ fn spill_into_the_old_area_of_a_blocked_neighbour() {
assert_eq!([t.num("C8"), t.num("D8"), t.num("C9"), t.num("D9")], [1.0, 2.0, 3.0, 4.0]);
}
#[test]
fn a_full_recalc_keeps_a_spill_from_an_array_that_grew_into_it() {
// Both arrays spill; in manual calculation F13 then grows over F14:G14, which C14's array
// fills. A full recalculation gives what an automatic one would: C14 keeps its cells and F13
// is #SPILL!, although F13 comes first in reading order.
let mut t = T::new();
t.set("J1", "1");
t.set("C14", "=SEQUENCE(1,7)");
t.set("F13", "=SEQUENCE(J1,2)");
assert_eq!([t.num("F13"), t.num("G13")], [1.0, 2.0]);
t.wb.calc.mode = gridcraft_model::CalcMode::Manual;
t.set("J1", "5");
t.calc.recalc_all(&mut t.wb);
assert_eq!(t.get("F13"), Value::Error(CellError::Spill));
assert_eq!([t.num("C14"), t.num("F14"), t.num("G14"), t.num("I14")], [1.0, 4.0, 5.0, 7.0]);
}
#[test]
fn a_full_recalc_lays_out_arrays_as_an_automatic_one_when_one_shrinks_for_another() {
// C1 grows into C3, which A3's array fills, and A3 grows into E3, which E1's array leaves.
// Automatic recalculation lays them out in reading order with each former area still filled:
// C1 is #SPILL! and A3 takes A3:E3. A full recalculation after the same edit in manual
// calculation gives the same sheet.
let build = |manual: bool| {
let mut t = T::new();
t.set("J1", "2");
t.set("C1", "=SEQUENCE(J1)");
t.set("A3", "=SEQUENCE(1,J1+1)");
t.set("E1", "=SEQUENCE(5-J1)");
assert_eq!([t.num("C2"), t.num("C3"), t.num("E3")], [2.0, 3.0, 3.0]);
if manual {
t.wb.calc.mode = gridcraft_model::CalcMode::Manual;
}
t.set("J1", "4");
if manual {
t.calc.recalc_all(&mut t.wb);
}
t
};
let (automatic, full) = (build(false), build(true));
assert_eq!(automatic.get("C1"), Value::Error(CellError::Spill));
assert_eq!([automatic.num("A3"), automatic.num("C3"), automatic.num("E3")], [1.0, 3.0, 5.0]);
for cell in ["A1", "C1", "C2", "C3", "C4", "E1", "E2", "A3", "B3", "C3", "D3", "E3"] {
assert_eq!(full.get(cell), automatic.get(cell), "{cell}");
}
}
#[test]
fn formulas_reading_an_array_that_loses_a_spill_conflict_read_spill_errors() {
// Two arrays of one recalculation want the same empty cell: the one laid out second is
@@ -2331,6 +2396,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 +3025,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.
+1 -1
View File
@@ -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
View File
@@ -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,
+93
View File
@@ -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")));
}
+9 -2
View File
@@ -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"]);
+57 -6
View File
@@ -444,22 +444,35 @@ pub fn sort_compare(a: &Value, b: &Value) -> Ordering {
}
}
/// Number → text the way Excel converts in `&` and `TEXT(x,"General")`-free contexts: up to 15
/// significant digits, scientific for very large or very small magnitudes.
/// Number → text the way Excel converts in `&`, CONCAT and TEXTJOIN: at most 15 significant
/// digits, rounded first; scientific from 1E+15, below 1E-9, and wherever the decimal would be
/// longer than 21 characters, not counting the sign (`0.` plus 19 decimals). Excel-verified only
/// for positive 15-digit mantissas: `0.0000692361330972509` stays decimal and
/// `1.28233995888454E-06` does not, as Excel caches them. The limit for shorter mantissas from
/// 1E-6 to 1E-9 (e.g. `0.0000099999999999999` decimal) and for negatives (sign excluded) are
/// inferred.
pub fn number_to_text(n: f64) -> String {
if n == 0.0 || !n.is_finite() {
return "0".into();
}
// Round to 15 significant digits first, then pick decimal or scientific from the rounded
// magnitude, so 999999999999999.5 reads `1E+15`, never a 16-digit integer.
let a = n.abs();
if !(1e-9..1e15).contains(&a) && a.round() != a || a >= 1e15 {
let sci = format!("{:.14e}", n);
let (mant, exp) = sci.split_once('e').unwrap_or((&sci, "0"));
let mag: i32 = exp.parse().unwrap_or(0);
let sig = mant.bytes().filter(u8::is_ascii_digit).count() - mant.bytes().rev().take_while(|&b| b == b'0').count();
// Characters after `0.` for |n| < 1: the leading zeros, then the significant digits.
let decimals_below_one = -mag - 1 + sig as i32;
if !(-9..15).contains(&mag) || decimals_below_one > 19 {
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.
let mag = a.log10().floor() as i32;
let decimals = (14 - mag).clamp(0, 30) as usize;
let s = format!("{:.*}", decimals, n);
trim_decimal(&s)
@@ -498,14 +511,52 @@ mod tests {
assert_eq!(number_to_text(1234567890123456.0), "1.23456789012346E+15");
assert_eq!(number_to_text(0.0001), "0.0001");
assert_eq!(number_to_text(1e-10), "1E-10");
assert_eq!(number_to_text(1e15 - 0.5), "1E+15");
assert_eq!(number_to_text(1e15 - 0.1), "1E+15");
assert_eq!(number_to_text(-(1e15 - 0.5)), "-1E+15");
assert_eq!(number_to_text(999999999999999.0), "999999999999999");
assert_eq!(number_to_text(9.999999999999999e-10), "0.000000001");
assert_eq!(number_to_text(-9.999999999999999e-10), "-0.000000001");
assert_eq!(number_to_text(1.0 / 3.0), "0.333333333333333");
}
/// Excel switches to scientific when the 15-digit decimal would be longer than 21 characters
/// (`0.` plus 19 decimals). Excel-verified: IMTAN, IMSECH, IMCSCH and IMEXP results cached by
/// Excel for Mac in the `formulas` project's test.xlsx (ENGINEERING!S53, R47, S37, V37, V39).
#[test]
fn number_text_small_magnitudes() {
assert_eq!(number_to_text(6.92361330972509e-5), "0.0000692361330972509");
assert_eq!(number_to_text(2.41377759972715e-4), "0.000241377759972715");
assert_eq!(number_to_text(1.28233995888454e-6), "1.28233995888454E-06");
assert_eq!(number_to_text(-4.48088972789593e-6), "-4.48088972789593E-06");
assert_eq!(number_to_text(5.98317105631764e-7), "5.98317105631764E-07");
assert_eq!(number_to_text(-2.99158552811404e-7), "-2.99158552811404E-07");
// Just below powers of ten: the 21-character limit, and the rounded magnitude.
assert_eq!(number_to_text(9.99999999999999e-5), "0.0000999999999999999");
assert_eq!(number_to_text(9.99999999999999e-6), "9.99999999999999E-06");
assert_eq!(number_to_text(9.9999999999999e-6), "0.0000099999999999999");
assert_eq!(number_to_text(9.99999999999999e-9), "9.99999999999999E-09");
assert_eq!(number_to_text(-9.99999999999999e-9), "-9.99999999999999E-09");
assert_eq!(number_to_text(9.99999999999999e-10), "9.99999999999999E-10");
assert_eq!(number_to_text(9.999999999999999e-6), "0.00001");
assert_eq!(number_to_text(0.00001), "0.00001");
assert_eq!(number_to_text(0.000001), "0.000001");
assert_eq!(number_to_text(1.5e-9), "0.0000000015");
// Large side: 15 significant digits, scientific from 1E+15.
assert_eq!(number_to_text(99999999999999.9), "99999999999999.9");
assert_eq!(number_to_text(999999999999999.4), "999999999999999");
assert_eq!(number_to_text(9999999999999998.0), "1E+16");
assert_eq!(number_to_text(9.99999999999999e15), "9.99999999999999E+15");
}
#[test]
fn number_text_rounds_up_to_scientific_boundary() {
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]
+3
View File
@@ -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"] }
+48 -2
View File
@@ -4,7 +4,9 @@
use std::collections::{HashMap, HashSet};
use gridcraft_core::{CellRef, RangeRef, Value, compare};
use gridcraft_model::{CfOperator, CfRule, CfValueKind, Color, CondFormat, PatternType, Sheet, Style, Underline, Workbook, default_icon_thresholds};
use gridcraft_model::{
CfOperator, CfRule, CfValueKind, Color, CondFormat, PatternType, Sheet, Style, Table, Underline, Workbook, default_icon_thresholds,
};
/// The conditional look of one cell.
#[derive(Clone, Debug, Default, PartialEq)]
@@ -20,10 +22,12 @@ pub struct CfLook {
pub hide_value: bool,
}
/// Precomputed statistics per rule (min/max/percentiles/top-N thresholds/duplicates).
/// Precomputed statistics per rule (min/max/percentiles/top-N thresholds/duplicates), and each
/// table's visible edges. The grid and print keep one per paint.
#[derive(Default)]
pub struct CfCache {
stats: HashMap<usize, RuleStats>,
table_edges: HashMap<RangeRef, crate::tables::ShownEdges>,
}
#[derive(Default, Clone)]
@@ -275,6 +279,11 @@ impl CfCache {
Self::default()
}
/// [`crate::tables::shown_edges`] of `t`, found once per cache.
pub fn table_edges(&mut self, sh: &Sheet, t: &Table) -> crate::tables::ShownEdges {
*self.table_edges.entry(t.range).or_insert_with(|| crate::tables::shown_edges(sh, t))
}
/// Conditional look of `c`, or `None` when no rule applies.
pub fn look(&mut self, wb: &Workbook, sheet: usize, c: CellRef) -> Option<CfLook> {
let sh = wb.sheet(sheet)?;
@@ -728,6 +737,43 @@ mod tests {
assert_eq!([look("A1"), look("A2")], [true, false]);
}
#[test]
fn rules_compare_with_cells_on_other_sheets() {
let mut s = crate::Session::new();
s.new_workbook();
s.execute("range.setValues", json!({"range": "E1", "values": [["Suspended"], ["OK"], ["Terminated"], [7], [3]]})).unwrap();
let rule = |r: serde_json::Value| json!({"range": "E1:E5", "rule": r});
s.execute(
"home.conditionalFormat",
rule(json!({"type": "cellIs", "operator": "equal", "value": "='Vehicle Range'!$A$8", "preset": "redText"})),
)
.unwrap();
s.execute(
"home.conditionalFormat",
rule(json!({"type": "cellIs", "operator": "equal", "value": "='Vehicle Range'!$A$9", "preset": "redText"})),
)
.unwrap();
s.execute(
"home.conditionalFormat",
rule(json!({"type": "expression", "formula": "=AND(ISNUMBER(E1),E1>'Vehicle Range'!$B$1)", "preset": "yellowFill"})),
)
.unwrap();
s.execute("home.insertSheet", json!({"name": "Vehicle Range"})).unwrap();
s.execute("range.setValues", json!({"range": "'Vehicle Range'!A8", "values": [["Suspended"], ["Terminated"]]})).unwrap();
s.execute("range.setValues", json!({"range": "'Vehicle Range'!B1", "values": [[5]]})).unwrap();
let d = s.doc().unwrap();
let report = d.wb.sheets.iter().position(|sh| sh.name != "Vehicle Range").unwrap();
let mut cache = CfCache::new();
let mut look = |a: &str| cache.look(&d.wb, report, CellRef::parse(a).unwrap()).and_then(|l| l.style).unwrap_or_default();
let looks = ["E1", "E2", "E3", "E4", "E5"].map(&mut look);
// The cells equal to 'Vehicle Range'!A8 or A9 get the red text.
let red_text = looks[0].font.color;
assert_ne!(red_text, Color::Auto);
let red = |st: &Style| st.font.color == red_text;
let filled = |st: &Style| st.fill.pattern == PatternType::Solid;
assert_eq!(looks.each_ref().map(red), [true, false, true, false, false]);
assert_eq!(looks.each_ref().map(filled), [false, false, false, true, false]);
}
#[test]
fn text_rules_skip_error_values() {
let mut s = crate::Session::new();
+213
View File
@@ -0,0 +1,213 @@
//! Where a chart's data sits on a sheet, as the blocks a selected chart outlines: series names in
//! red, category labels in purple and values in blue (#4390). Dragging a corner of the values
//! block points the chart at other cells, and the names and categories follow it (#4389).
use gridcraft_core::{CellRef, RangeRef, col_to_letters};
use gridcraft_formula::{Expr, RefKind, SheetSel, parse, quote_sheet};
use gridcraft_model::{Chart, Series, Workbook};
/// Most series a chart takes from a dragged block (Excel's limit per chart).
pub const MAX_SERIES: u32 = 255;
/// Most cells a dragged values block may span, as for `chart.selectData`.
pub const MAX_CELLS: u64 = 1_000_000;
/// A chart's data as blocks of cells on one sheet.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ChartData {
/// The sheet the data is on.
pub sheet: usize,
/// Every series' values: one column per series (one row with `by_rows`), in series order.
pub values: RangeRef,
/// Series run across rows rather than down columns.
pub by_rows: bool,
/// The category labels every series shares, when they line up beside `values`.
pub categories: Option<RangeRef>,
/// One name cell per series, in the line beside `values`, when every series has one there.
pub names: Option<RangeRef>,
}
impl ChartData {
/// The blocks after the values move to `to`: category labels keep their column (row) and
/// span the new points, and names keep their row (column) and span the new series.
pub fn moved(&self, to: RangeRef) -> ChartData {
let (categories, names) = if self.by_rows {
(
self.categories.map(|c| RangeRef::new(CellRef::new(c.start.row, to.start.col), CellRef::new(c.start.row, to.end.col))),
self.names.map(|n| RangeRef::new(CellRef::new(to.start.row, n.start.col), CellRef::new(to.end.row, n.start.col))),
)
} else {
(
self.categories.map(|c| RangeRef::new(CellRef::new(to.start.row, c.start.col), CellRef::new(to.end.row, c.start.col))),
self.names.map(|n| RangeRef::new(CellRef::new(n.start.row, to.start.col), CellRef::new(n.start.row, to.end.col))),
)
};
ChartData { values: to, categories, names, ..*self }
}
/// The cells of series `i` within `values` (`None` past the last series).
fn line(&self, values: RangeRef, i: u32) -> Option<RangeRef> {
if self.by_rows {
let row = values.start.row.checked_add(i).filter(|r| *r <= values.end.row)?;
Some(RangeRef::new(CellRef::new(row, values.start.col), CellRef::new(row, values.end.col)))
} else {
let col = values.start.col.checked_add(i).filter(|c| *c <= values.end.col)?;
Some(RangeRef::new(CellRef::new(values.start.row, col), CellRef::new(values.end.row, col)))
}
}
/// How many series `values` holds.
fn count(&self, values: RangeRef) -> u32 {
if self.by_rows { values.height() } else { values.width() }
}
}
/// The sheet and cells a series reference names. `home` is the chart's own sheet, for an
/// unqualified reference. Literals, names, 3-D spans, other workbooks and whole rows or columns
/// are not blocks.
fn block(wb: &Workbook, home: usize, text: &str) -> Option<(usize, RangeRef)> {
let Ok(Expr::Ref(r)) = parse(text.trim().trim_start_matches('=')) else { return None };
let sheet = match &r.sheet {
SheetSel::Current => home,
SheetSel::Named(n) => wb.sheet_index(n)?,
SheetSel::Span(..) => return None,
};
matches!(r.kind, RefKind::Cell(_) | RefKind::Range(..)).then(|| (sheet, r.range()))
}
/// `chart`'s data on `home`'s workbook as blocks, when its series form one: every series' values
/// on one sheet, in adjacent columns (or rows) of the same extent, in series order. `None` for
/// any other layout, and for a PivotChart, whose series follow its PivotTable.
pub fn chart_data(wb: &Workbook, home: usize, chart: &Chart) -> Option<ChartData> {
if chart.pivot.is_some() {
return None;
}
let first = chart.series.first()?;
let (sheet, r0) = block(wb, home, &first.values)?;
let by_rows = match (r0.width(), r0.height()) {
(1, 1) => chart.by_rows,
(1, _) => false,
(_, 1) => true,
_ => return None,
};
let n = u32::try_from(chart.series.len()).ok()?;
let last = n.checked_sub(1)?;
let values = if by_rows {
RangeRef::new(r0.start, CellRef::new(r0.end.row.checked_add(last)?, r0.end.col))
} else {
RangeRef::new(r0.start, CellRef::new(r0.end.row, r0.end.col.checked_add(last)?))
};
let mut data = ChartData { sheet, values, by_rows, categories: None, names: None };
for (i, se) in (0..n).zip(&chart.series) {
if block(wb, home, &se.values) != Some((sheet, data.line(values, i)?)) {
return None;
}
}
// Category labels shared by every series, in one line beside the points. Compared as blocks,
// not text: `=Sheet1!$A$2:$A$4` and `Sheet1!$A$2:$A$4` are the same labels.
let cats = |se: &Series| se.categories.as_deref().and_then(|t| block(wb, home, t));
if let Some((s, c)) = cats(first)
&& s == sheet
&& chart.series.iter().all(|se| cats(se) == Some((s, c)))
{
let lines_up = if by_rows {
c.height() == 1
&& (c.start.col, c.end.col) == (values.start.col, values.end.col)
&& !(values.start.row..=values.end.row).contains(&c.start.row)
} else {
c.width() == 1
&& (c.start.row, c.end.row) == (values.start.row, values.end.row)
&& !(values.start.col..=values.end.col).contains(&c.start.col)
};
data.categories = lines_up.then_some(c);
}
// A name cell for every series, all in one line beside the values.
let names: Option<Vec<CellRef>> = chart
.series
.iter()
.map(|se| se.name.as_deref().and_then(|t| block(wb, home, t)).filter(|(s, r)| *s == sheet && r.is_single()).map(|(_, r)| r.start))
.collect();
if let Some(cells) = names
&& let (Some(a), Some(b)) = (cells.first(), cells.last())
{
let lines_up = (0..n).zip(&cells).all(|(i, c)| {
if by_rows {
c.col == a.col && Some(c.row) == values.start.row.checked_add(i) && !(values.start.col..=values.end.col).contains(&c.col)
} else {
c.row == a.row && Some(c.col) == values.start.col.checked_add(i) && !(values.start.row..=values.end.row).contains(&c.row)
}
});
data.names = lines_up.then(|| RangeRef::new(*a, *b));
}
Some(data)
}
/// Why [`with_values`] refused.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ValuesError {
/// The chart's series are not one block of cells ([`chart_data`] is `None`).
NotABlock,
/// The block is over [`MAX_CELLS`] cells or [`MAX_SERIES`] series.
TooLarge,
}
/// `chart` with its values moved to `to` on the data's own sheet, as dragging a corner of the
/// values outline does. Series `i` takes the `i`-th column (row) of `to` and keeps everything
/// else it had (colour, kind, axis, trendlines); a wider block adds series and a narrower one
/// drops the last ones. Category labels and names that line up follow the block; ones that don't
/// stay as they are. A data range kept for Switch Row/Column becomes the moved blocks.
pub fn with_values(wb: &Workbook, home: usize, chart: &Chart, to: RangeRef) -> Result<Chart, ValuesError> {
let data = chart_data(wb, home, chart).ok_or(ValuesError::NotABlock)?;
if to.count() > MAX_CELLS || data.count(to) > MAX_SERIES {
return Err(ValuesError::TooLarge);
}
let sheet = wb.sheet(data.sheet).ok_or(ValuesError::NotABlock)?;
let q = quote_sheet(&sheet.name);
let row = |r: u32| u64::from(r) + 1;
let range = |r: RangeRef| format!("{q}!${}${}:${}${}", col_to_letters(r.start.col), row(r.start.row), col_to_letters(r.end.col), row(r.end.row));
let cell = |c: CellRef| format!("{q}!${}${}", col_to_letters(c.col), row(c.row));
let moved = data.moved(to);
let shared_cats = chart.series.first().and_then(|se| se.categories.clone());
let mut out = chart.clone();
// Keep the orientation the series were read in: a block of one cell per series is read by
// `by_rows`, so a stale flag would make the moved series unreadable as a block.
out.by_rows = data.by_rows;
out.series = (0..data.count(to))
.filter_map(|i| {
let line = moved.line(to, i)?;
let old = chart.series.get(i as usize);
let mut se = old.cloned().unwrap_or_else(|| Series { categories: shared_cats.clone(), ..Series::default() });
se.values = range(line);
if let Some(c) = moved.categories {
se.categories = Some(range(c));
}
if let Some(n) = moved.names {
se.name =
Some(cell(if data.by_rows { CellRef::new(line.start.row, n.start.col) } else { CellRef::new(n.start.row, line.start.col) }));
}
// Bubble sizes in a line of their own beside the old points span the new ones.
if let (Some(old_line), Some(text)) = (data.line(data.values, i), se.bubble_sizes.clone())
&& let Some((s, b)) = block(wb, home, &text)
&& s == data.sheet
{
let follows = if data.by_rows {
b.height() == 1 && (b.start.col, b.end.col) == (old_line.start.col, old_line.end.col)
} else {
b.width() == 1 && (b.start.row, b.end.row) == (old_line.start.row, old_line.end.row)
};
if follows {
se.bubble_sizes = Some(range(if data.by_rows {
RangeRef::new(CellRef::new(b.start.row, to.start.col), CellRef::new(b.start.row, to.end.col))
} else {
RangeRef::new(CellRef::new(to.start.row, b.start.col), CellRef::new(to.end.row, b.start.col))
}));
}
}
Some(se)
})
.collect();
if out.source.is_some() {
let all = [moved.categories, moved.names].into_iter().flatten().fold(to, |a, r| a.union(&r));
out.source = Some(format!("{q}!{}", all.a1()));
}
Ok(out)
}
+2
View File
@@ -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());
+3 -2
View File
@@ -27,6 +27,7 @@ pub use filter::filter_values;
pub(crate) use filter::{apply_filter, grow_autofilter};
use filter::{clear_filter, filter_by, reapply, toggle_filter};
use grouping::{detail, group, outline_settings, show_levels, subtotal};
pub use sort::sort_context;
use sort::{quick_sort, sort};
#[cfg(test)]
use tools::split_delimited;
@@ -98,7 +99,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!(
@@ -212,7 +213,7 @@ fn data_target(s: &Session, p: &Json, cmd: &str) -> Result<(usize, RangeRef)> {
/// Excel's header guess: the first row is text over a column of numbers, or is bold.
fn guess_header(wb: &Workbook, sh: &Sheet, r: RangeRef) -> bool {
if let Some(t) = sh.table_at(r.start) {
return t.header_row;
return t.header_row && r.start.row == t.range.start.row;
}
if r.height() < 2 {
return false;
+6 -4
View File
@@ -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();
+3
View File
@@ -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}))
}
+37 -6
View File
@@ -28,6 +28,21 @@ fn sort_target(s: &Session, p: &Json) -> Result<(usize, RangeRef)> {
Ok((sheet, data_range(s, p)?))
}
/// The worksheet (index), range and header guess the Custom Sort dialog works on: the sheet named by
/// `sheet` or a `Sheet!` prefix on `range`, else the active one.
pub fn sort_context(s: &Session, p: &Json) -> Result<(usize, RangeRef, bool)> {
let (sheet, explicit) = sort_target(s, p)?;
let d = s.doc()?;
let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
let sel = d.selection.current();
// An explicit block wins over the table range, so a selected totals row can be sorted.
let r = match sh.used_range() {
Some(used) if p.get("range").is_none() && !sel.is_single() => sel.intersection(&used).unwrap_or(sel),
_ => explicit,
};
Ok((sheet, r, bool_param(p, "header").unwrap_or_else(|| guess_header(&d.wb, sh, r))))
}
pub(super) fn quick_sort(s: &mut Session, p: &Json, asc: bool) -> Result<Json> {
let (sheet, r) = sort_target(s, p)?;
let col = col_param(p.get("column"), r.start.col).unwrap_or(s.doc()?.selection.active.col).clamp(r.start.col, r.end.col);
@@ -68,7 +83,9 @@ pub(super) fn sort(s: &mut Session, p: &Json) -> Result<Json> {
});
}
if keys.is_empty() {
s.ui_requests.push(crate::UiRequest::Dialog("sort".into(), json!({"range": r.a1(), "header": header})));
let (sheet, r, header) = sort_context(s, p)?;
let name = s.doc()?.wb.sheet(sheet).map(|sh| sh.name.clone()).ok_or(EngineError::NoDocument)?;
s.ui_requests.push(crate::UiRequest::Dialog("sort".into(), json!({"range": r.a1(), "header": header, "sheet": name})));
return ok();
}
if keys.len() > 64 {
@@ -119,15 +136,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 };
+2 -2
View File
@@ -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");
+13 -1
View File
@@ -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(&quote) {
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);
+8 -2
View File
@@ -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}))
}
+1 -1
View File
@@ -35,7 +35,7 @@ use go_to::go_to_special;
#[cfg(test)]
use go_to::{GO_TO_MAX_AREAS, GO_TO_RECENT, reference_parts};
use paste_special::paste_special;
pub(crate) use paste_special::{rewrite_all_formulas, rewrite_cell_links, rewrite_python_refs};
pub(crate) use paste_special::{rewrite_all_formulas_many, rewrite_cell_links, rewrite_python_refs};
use selection::{select_all, select_col, select_region, select_row, selection_move, selection_next, selection_next_corner, selection_set};
pub fn specs() -> Vec<CommandSpec> {
+5 -1
View File
@@ -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;
+47 -16
View File
@@ -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) {
@@ -553,10 +566,15 @@ fn paste_validations(
/// Applies a reference adjustment to every cell formula and defined name in the workbook.
pub(crate) fn rewrite_all_formulas(wb: &mut gridcraft_model::Workbook, target: &str, e: &gridcraft_formula::adjust::Edit) -> Result<()> {
rewrite_all_formulas_many(wb, target, std::slice::from_ref(e))
}
/// [`rewrite_all_formulas`] for several edits applied in order, visiting each formula once.
pub(crate) fn rewrite_all_formulas_many(wb: &mut gridcraft_model::Workbook, target: &str, edits: &[gridcraft_formula::adjust::Edit]) -> Result<()> {
use gridcraft_formula::adjust::Edit;
// Rows and columns inserted or deleted on the target sheet move its legacy array ranges too
// (a cut moves its arrays itself).
let moves_arrays = matches!(e, Edit::Insert { .. } | Edit::Delete { .. } | Edit::InsertCells { .. } | Edit::DeleteCells { .. });
let moves_arrays = |e: &Edit| matches!(e, Edit::Insert { .. } | Edit::Delete { .. } | Edit::InsertCells { .. } | Edit::DeleteCells { .. });
for si in 0..wb.sheets.len() {
let host = wb.sheets.get(si).map(|s| s.name.clone()).unwrap_or_default();
let keys: Vec<(CellRef, std::sync::Arc<Formula>)> =
@@ -564,16 +582,29 @@ pub(crate) fn rewrite_all_formulas(wb: &mut gridcraft_model::Workbook, target: &
if keys.is_empty() {
continue;
}
let on_target = moves_arrays && host.eq_ignore_ascii_case(target);
let on_target = host.eq_ignore_ascii_case(target);
let Some(sheet) = wb.sheet_mut(si) else { continue };
for (c, f) in keys {
// Borrows the tree and copies and prints only the formulas the edit changes. A formula
// the edit leaves alone keeps its stored text, even if that text is not canonical.
let Some(new) = f.with_expr(|x| gridcraft_formula::adjust::adjust_if_changed(x, &host, target, e)) else { continue };
let array = match f.array {
Some(a) if on_target => crate::cmd::sheet::map_range(a, e),
a => a,
// Borrows the tree and copies and prints only the formulas the edits change. A formula
// the edits leave alone keeps its stored text, even if that text is not canonical.
let Some(new) = f.with_expr(|x| {
let mut cur: Option<gridcraft_formula::Expr> = None;
for e in edits {
if let Some(n) = gridcraft_formula::adjust::adjust_if_changed(cur.as_ref().unwrap_or(x), &host, target, e) {
cur = Some(n);
}
}
cur
}) else {
continue;
};
let mut array = f.array;
for e in edits {
array = match array {
Some(a) if on_target && moves_arrays(e) => crate::cmd::sheet::map_range(a, e),
a => a,
};
}
let nf = match new {
Some(new) => Formula { array, dynamic: f.dynamic, ..Formula::from_expr(new) },
None if array != f.array => Formula { array, ..(*f).clone() },
@@ -587,12 +618,12 @@ pub(crate) fn rewrite_all_formulas(wb: &mut gridcraft_model::Workbook, target: &
for n in wb.names.iter_mut() {
if let Ok(expr) = gridcraft_formula::parse_name(&n.formula) {
// Names are workbook-level: unqualified refs don't occur; qualified ones adjust.
let new = gridcraft_formula::adjust::adjust(expr, "\u{0}", target, e);
let new = edits.iter().fold(expr, |expr, e| gridcraft_formula::adjust::adjust(expr, "\u{0}", target, e));
n.formula = gridcraft_formula::print(&new);
}
}
rewrite_cell_links(wb, |host, expr| gridcraft_formula::adjust::adjust(expr, host, target, e));
rewrite_python_refs(wb, &|host, expr| gridcraft_formula::adjust::adjust(expr, host, target, e))
rewrite_cell_links(wb, |host, expr| edits.iter().fold(expr, |expr, e| gridcraft_formula::adjust::adjust(expr, host, target, e)));
rewrite_python_refs(wb, &|host, expr| edits.iter().fold(expr, |expr, e| gridcraft_formula::adjust::adjust(expr, host, target, e)))
}
/// Runs `f` over every reference a floating object holds (a chart's series values, categories,
+46 -10
View File
@@ -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()}))
}
+11 -1
View File
@@ -22,7 +22,7 @@ mod window;
pub(crate) use cells::is_checkbox_cell;
use cells::{background, checkbox, draw_border, new_cell_style, recently_used, theme_colors, theme_fonts, toggle_checkbox, use_in_formula};
use chart::{add_element, change_colors, format_series, move_chart, quick_layout, select_data};
use chart::{add_element, change_colors, format_series, move_chart, quick_layout, select_data, set_values_range};
use data::{from_csv, from_table_range, queries, table_resize};
use objects::{align, arrange, rotate, selection_pane, shape_fill, shape_outline};
pub(crate) use scripts::has_scripts;
@@ -61,6 +61,16 @@ pub fn specs() -> Vec<CommandSpec> {
has_doc,
select_data
),
// Dragging a corner of a selected chart's values outline on the sheet (#4389).
cmd!(
"chart.setValuesRange",
"Resize Chart Data",
[],
None,
"{chart?, range: \"B2:C9\" (the block every series' values come from, one column or row per series, on the data's sheet; names and category labels that line up follow it, series keep their formatting)}",
has_doc,
set_values_range
),
cmd!("chart.changeType", "Change Chart Type…", ["Chart Design", "Type"], None, "{chart?, type, subtype?}", has_doc, |s, p| s
.execute("chart.set", p.clone())),
cmd!(
+32
View File
@@ -233,6 +233,38 @@ pub(super) fn select_data(s: &mut Session, p: &Json) -> Result<Json> {
})
}
/// Points the chart's series at another block of cells on their sheet, keeping each series'
/// formatting, as dragging a corner of the selected chart's values outline does (#4389).
pub(super) fn set_values_range(s: &mut Session, p: &Json) -> Result<Json> {
use crate::chart_data::{ValuesError, chart_data, with_values};
let text = str_param(p, "range").ok_or_else(|| bad("chart.setValuesRange", "missing `range`"))?;
let (si, ci) = find_chart(s, p)?;
let d = s.doc()?;
let chart = d.wb.sheet(si).and_then(|sh| sh.charts.get(ci)).ok_or_else(|| bad("chart", "no such chart"))?;
let Some(data) = chart_data(&d.wb, si, chart) else {
return Err(bad("chart.setValuesRange", "the chart's series are not one block of cells"));
};
let (sheet_name, body) = split_sheet(text.trim().trim_start_matches('='));
if let Some(n) = sheet_name
&& d.wb.sheet_index(&n) != Some(data.sheet)
{
return Err(bad("chart.setValuesRange", "the range must be on the sheet the chart's data is on"));
}
let to = RangeRef::parse(body).ok_or_else(|| bad("chart.setValuesRange", "not a range"))?;
let new = with_values(&d.wb, si, chart, to).map_err(|e| match e {
ValuesError::NotABlock => bad("chart.setValuesRange", "the chart's series are not one block of cells"),
ValuesError::TooLarge => bad("chart.setValuesRange", "range too large for a chart"),
})?;
let values = format!("{}!{}", gridcraft_formula::quote_sheet(d.wb.sheet(data.sheet).map_or("", |sh| sh.name.as_str())), to.a1());
with_chart(s, p, move |c| {
c.series = new.series;
c.source = new.source;
c.by_rows = new.by_rows;
Ok(())
})
.map(|r| json!({"chart": r["chart"], "values": values}))
}
pub(super) fn move_chart(s: &mut Session, p: &Json) -> Result<Json> {
let (si, ci) = find_chart(s, p)?;
let target = match p.get("sheet").and_then(Json::as_str) {
+15
View File
@@ -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;
+31 -12
View File
@@ -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();
+6
View File
@@ -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 {
File diff suppressed because it is too large Load Diff
+70 -11
View File
@@ -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| {
+27 -2
View File
@@ -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() {
+17 -5
View File
@@ -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}))
}
+47 -43
View File
@@ -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)}))
})
+10 -2
View File
@@ -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 {
+334
View File
@@ -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,
+102 -14
View File
@@ -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,10 +174,10 @@ 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()) };
let mut cf = crate::cf::CfCache::new();
let k = lay.k();
let (aw, ah) = lay.avail();
for (pi, (ri, ci)) in lay.pages.iter().enumerate() {
@@ -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> {
+47 -27
View File
@@ -25,13 +25,16 @@ pub(super) struct Look {
pub(super) cf: Option<crate::cf::CfLook>,
}
fn cell_look(wb: &Workbook, si: usize, sh: &Sheet, c: CellRef, cf: &mut Option<crate::cf::CfCache>) -> Look {
fn cell_look(wb: &Workbook, si: usize, sh: &Sheet, c: CellRef, cf: &mut crate::cf::CfCache) -> Look {
let mut style = match sh.table_at(c) {
Some(t) => crate::tables::table_cell_style(wb, si, t, c),
Some(t) => crate::tables::table_cell_shown_style(wb, si, t, cf.table_edges(sh, t), c),
None => wb.styles.get(sh.style_id(c)).clone(),
};
let cfl = cf.as_mut().and_then(|cache| cache.look(wb, si, c));
let cfl = cf.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);
@@ -305,7 +319,7 @@ impl<'a> Covered<'a> {
}
/// Draws the cells of a block: fills, gridlines, data bars, borders and text.
pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Option<crate::cf::CfCache>) {
pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut crate::cf::CfCache) {
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);
if bw <= 0.0 || bh <= 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)]
+22
View File
@@ -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);
}
}
+51 -14
View File
@@ -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;
}
}
+290 -6
View File
@@ -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(&ltr, "/MediaBox [", 4)[2];
let (l, r) = (numbers_after(&ltr, "/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(&ltr, "/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(&ltr);
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(&ltr, "RIGHT") + right - exported_text_x(&ltr, "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(&ltr, 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(&ltr, "FIRST") < exported_text_x(&ltr, "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(&para, Font::Helvetica, 10.0, 1.0e9), vec![para.clone()]);
assert_eq!(wrapped_text(&para, 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)));
}
+185 -68
View File
@@ -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);
+47 -20
View File
@@ -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,22 +211,51 @@ 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;
}
}
}
}
/// Rewrites every formula reference (chart series included), sparkline source and PivotTable
/// source for a structural edit on `target`.
pub(super) fn rewrite(cx: &mut Ctx, target: &str, e: &Edit) -> Result<()> {
cx.edits.push((target.to_string(), e.clone()));
rewrite_many(cx, target, std::slice::from_ref(e))
}
/// [`rewrite`] for several edits applied in order, parsing each reference once.
fn rewrite_many(cx: &mut Ctx, target: &str, edits: &[Edit]) -> Result<()> {
cx.edits.extend(edits.iter().map(|e| (target.to_string(), e.clone())));
let wb = &mut cx.wb;
super::edit::rewrite_all_formulas(wb, target, e)?;
super::edit::rewrite_all_formulas_many(wb, target, edits)?;
for si in 0..wb.sheets.len() {
let host = wb.sheets.get(si).map(|s| s.name.clone()).unwrap_or_default();
let Some(sh) = wb.sheet_mut(si) else { continue };
let fix = |text: &str| -> String {
match gridcraft_formula::parse(text) {
Ok(expr) => gridcraft_formula::print(&gridcraft_formula::adjust::adjust(expr, &host, target, e)),
Ok(expr) => gridcraft_formula::print(&edits.iter().fold(expr, |expr, e| gridcraft_formula::adjust::adjust(expr, &host, target, e))),
Err(_) => text.to_string(),
}
};
@@ -239,7 +268,7 @@ pub(super) fn rewrite(cx: &mut Ctx, target: &str, e: &Edit) -> Result<()> {
let body = pt.source.trim().trim_start_matches('=');
if let Ok(expr) = gridcraft_formula::parse(body) {
let before = gridcraft_formula::print(&expr);
let after = gridcraft_formula::print(&gridcraft_formula::adjust::adjust(expr, &host, target, e));
let after = gridcraft_formula::print(&edits.iter().fold(expr, |expr, e| gridcraft_formula::adjust::adjust(expr, &host, target, e)));
if after != before {
pt.source = after;
}
@@ -354,23 +383,21 @@ fn delete_lines(s: &mut Session, p: &Json, axis: Axis) -> Result<Json> {
let out = edit(s, |cx| {
let name = cx.wb.sheet(sheet).map(|s| s.name.clone()).unwrap_or_default();
cx.protection_checked = true;
// Last area first, so the earlier ones keep their positions.
for (at, count) in areas {
{
let sh = cx.sheet_mut(sheet)?;
let block = match axis {
Axis::Rows => RangeRef::rows(at, (at + count - 1).min(MAX_ROWS - 1)),
Axis::Cols => RangeRef::cols(at, (at + count - 1).min(MAX_COLS - 1)),
};
sh.take_cells(block);
match axis {
Axis::Rows => sh.cells.shift_rows(at + count, -(count as i64)),
Axis::Cols => sh.cells.shift_cols(at + count, -(count as i64)),
}
{
let sh = cx.sheet_mut(sheet)?;
// Cells move once, past every deleted area above or left of them.
let ascending: Vec<(u32, u32)> = areas.iter().rev().copied().collect();
match axis {
Axis::Rows => sh.cells.delete_rows(&ascending),
Axis::Cols => sh.cells.delete_cols(&ascending),
}
// Last area first, so the earlier ones keep their positions.
for &(at, count) in &areas {
shift_sheet_features(sh, axis, at, count, false);
}
rewrite(cx, &name, &Edit::Delete { axis, at, count })?;
}
let edits: Vec<Edit> = areas.iter().map(|&(at, count)| Edit::Delete { axis, at, count }).collect();
rewrite_many(cx, &name, &edits)?;
cx.structural = true;
Ok(Json::Null)
})?;
@@ -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;
+9
View File
@@ -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]
+241
View File
@@ -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)
})
}
+23 -7
View File
@@ -5,7 +5,7 @@ use std::sync::Mutex;
use gridcraft_core::{CellRef, RangeRef, Value};
use gridcraft_model::{Sheet, Workbook};
use gridcraft_numfmt::{Formatted, NumberFormat, format_value};
use gridcraft_numfmt::{Formatted, NumberFormat, format_value, format_value_full};
/// Parsed number formats are cached by code.
pub(crate) fn parsed(code: &str) -> NumberFormat {
@@ -116,7 +116,8 @@ pub fn formula_hidden(wb: &Workbook, sheet: &Sheet, c: CellRef) -> bool {
wb.styles.get(sheet.style_id(at)).protection.hidden
}
/// The text a cell shows (full precision General; the grid narrows General to fit the column).
/// The text a cell shows (General up to the 11-character cell width; the grid narrows General
/// further to fit the column).
pub fn cell_text(wb: &Workbook, sheet: &Sheet, c: CellRef) -> String {
if sheet.show_formulas
&& let Some(f) = sheet.cell(c).and_then(|x| x.formula.as_ref())
@@ -124,20 +125,35 @@ pub fn cell_text(wb: &Workbook, sheet: &Sheet, c: CellRef) -> String {
{
return format!("={}", f.text);
}
value_text(wb, sheet, c)
shown_text(wb, sheet, c)
}
/// A cell's value with its number format applied, independent of column width: no `#####`
/// and no General narrowing (Save As CSV/Text writes this). Formulas give their result.
/// and no General narrowing (Save As CSV/Text writes this). Formulas give their result. A number
/// shown as General (also through a coloured or sectioned General, or a Text format) is written
/// as [`format_value_full`] writes it, never with an exponent: `&`'s 15 significant digits below
/// 1E+15 (`124412140710`, not `1.24412E+11`), the shortest round-trip digits from 1E+15 (every
/// integer below 1e16 exactly). Excel writes the cell display.
pub fn value_text(wb: &Workbook, sheet: &Sheet, c: CellRef) -> String {
let style = wb.styles.get(sheet.style_id(c));
with_fill_space(format_value_full(&sheet.value(c), &parsed(style.num_fmt.as_str()), wb.date_system))
}
/// A cell's value through its number format, General at the 11-character cell width.
fn shown_text(wb: &Workbook, sheet: &Sheet, c: CellRef) -> String {
let style = wb.styles.get(sheet.style_id(c));
value_text_as(wb, &sheet.value(c), style.num_fmt.as_str())
}
/// [`value_text`] for a value and a format code given apart from a cell (print takes the code
/// from the cell's effective look, which a conditional format can override).
/// A value through a format code given apart from a cell, as a cell shows it (General at the
/// 11-character cell width). Print takes the code from the cell's effective look, which a
/// conditional format can override.
pub fn value_text_as(wb: &Workbook, v: &Value, code: &str) -> String {
let f = format(v, code, wb);
with_fill_space(format(v, code, wb))
}
/// The formatted text with a single space where a `*x` repeat fill would expand.
fn with_fill_space(f: Formatted) -> String {
match f.fill {
Some((_, pos)) => {
let mut t = f.text;
+156 -38
View File
@@ -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.
@@ -558,20 +558,13 @@ pub fn source_path(path: &str) -> Option<std::path::PathBuf> {
/// Save As CSV/Text writes "the text and values as they are displayed in cells" with "all
/// characters in each cell" (Microsoft Support, *Excel formatting and features that are not
/// transferred to other file formats*): number formats applied, never column-width `#####`.
/// One intentional difference: a number shown as General is not narrowed to the cell width and
/// never gets an exponent (`gridcraft_numfmt::format_value_full`). Below 1E+15 it is written as
/// `&` converts it (15 significant digits); from 1E+15 as the shortest digits that read back as
/// the same value (every integer below 1e16 exactly, so long identifiers survive); small numbers
/// that `&` writes in scientific notation as their 15 digits in full.
fn csv(wb: &Workbook, sh: &Sheet, delimiter: u8) -> Result<Vec<u8>> {
gridcraft_xlsx::write_csv(sh, delimiter, |c| {
// General's grid-width formatting rounds large identifiers to scientific notation.
// Delimited files have no column width, so preserve the whole numeric value instead.
if wb.styles.get(sh.style_id(c)).num_fmt.as_str().eq_ignore_ascii_case("General")
&& let gridcraft_core::Value::Number(number) = sh.value(c)
&& number.is_finite()
{
number.to_string()
} else {
crate::display::value_text(wb, sh, c)
}
})
.map_err(|e| EngineError::Other(e.to_string()))
gridcraft_xlsx::write_csv(sh, delimiter, |c| crate::display::value_text(wb, sh, c)).map_err(|e| EngineError::Other(e.to_string()))
}
/// The active sheet as CSV of raw cell values, for automation: numbers at full precision, dates and
@@ -611,6 +604,24 @@ pub(crate) fn esc(s: &str) -> String {
s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;").replace('"', "&quot;")
}
/// [`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("&amp;"),
'<' => out.push_str("&lt;"),
'>' => out.push_str("&gt;"),
'"' => out.push_str("&quot;"),
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 +697,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 +729,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 +739,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 +802,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 +852,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 +888,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 +920,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)
}
@@ -977,6 +1055,12 @@ pub fn write_file(path: &str, bytes: &[u8]) -> Result<()> {
use std::os::unix::fs::OpenOptionsExt;
opts.mode(0o600);
}
// A brand-new file gets the restrictive default: no group/other write, whatever the umask.
#[cfg(unix)]
if prior.is_none() {
use std::os::unix::fs::OpenOptionsExt;
opts.mode(0o644);
}
let mut f = opts.open(&tmp).map_err(|e| {
let _ = std::fs::remove_file(&tmp);
EngineError::Other(format!("{path}: {e}"))
@@ -1000,16 +1084,50 @@ pub fn write_file(path: &str, bytes: &[u8]) -> Result<()> {
if let Some(p) = &prior {
let _ = f.set_permissions(p.clone());
}
f.write_all(bytes).and_then(|()| f.flush()).map_err(|e| {
// `sync_all` before the rename: without it a power loss right after the rename can leave
// the new name pointing at an empty or truncated file while the old workbook is gone.
// A file system that cannot flush at all (some network mounts; on Apple targets std asks
// for F_FULLFSYNC, which they refuse) keeps the old behaviour: skip the flush, still rename.
let synced = |f: &std::fs::File| f.sync_all().or_else(|e| if full_sync_unsupported(&e) { Ok(()) } else { Err(e) });
f.write_all(bytes).and_then(|()| f.flush()).and_then(|()| synced(&f)).map_err(|e| {
let _ = std::fs::remove_file(&tmp);
EngineError::Other(format!("{path}: {e}"))
})?;
drop(f);
std::fs::rename(&tmp, path).map_err(|e| {
// A write or rename that fails (full disk, the workbook locked by another app) leaves
// no temporary file beside the user's workbook.
let _ = std::fs::remove_file(&tmp);
EngineError::Other(format!("{path}: {e}"))
})
})?;
// Make the rename itself durable. Best effort: the workbook is already in place, so a
// directory that can't be opened or synced (some file systems) is not a failed save.
#[cfg(unix)]
{
let dir = std::path::Path::new(path).parent().filter(|d| !d.as_os_str().is_empty()).unwrap_or_else(|| std::path::Path::new("."));
if let Ok(d) = std::fs::File::open(dir) {
let _ = d.sync_all();
}
}
Ok(())
}
/// True when a flush failed only because the file system cannot do it: on Unix ENOTTY (25, what
/// `fcntl(F_FULLFSYNC)` returns on such volumes; on Windows 25 is ERROR_SEEK, a real failure), on
/// Apple targets ENOTSUP (45, which std leaves uncategorized there), or an unsupported-operation
/// error (EOPNOTSUPP/ENOSYS, and ENOTSUP where it equals EOPNOTSUPP). Any other error is a real
/// failure.
#[cfg(not(target_arch = "wasm32"))]
fn full_sync_unsupported(e: &std::io::Error) -> bool {
flush_unsupported_on(e, cfg!(unix), cfg!(target_vendor = "apple"))
}
/// [`full_sync_unsupported`] for a given platform, so each platform's raw codes can be tested
/// on any host.
#[cfg(not(target_arch = "wasm32"))]
fn flush_unsupported_on(e: &std::io::Error, unix: bool, apple: bool) -> bool {
let raw = e.raw_os_error();
(unix && raw == Some(25)) || (apple && raw == Some(45)) || e.kind() == std::io::ErrorKind::Unsupported
}
/// The mode a saved file gets from the file it replaces (`old`): all of it when its group was
+37 -301
View File
@@ -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))
}
+231 -2
View File
@@ -78,6 +78,34 @@ fn restored_mode_drops_the_group_and_special_bits_when_the_group_is_lost() {
assert_eq!(super::restored_mode(0o104_755, false), 0o705, "setuid is dropped");
}
#[cfg(not(target_arch = "wasm32"))]
#[cfg(unix)]
#[test]
fn fresh_save_drops_group_and_other_write_under_a_permissive_umask() {
use std::os::unix::fs::PermissionsExt;
if std::env::var_os("GRIDCRAFT_UMASK_CHILD").is_none() {
// Re-run this test in a child shell whose umask is 0002.
let exe = std::env::current_exe().unwrap();
let status = std::process::Command::new("sh")
.arg("-c")
.arg("umask 0002 && exec \"$0\" --exact io::tests::fresh_save_drops_group_and_other_write_under_a_permissive_umask")
.arg(exe)
.env("GRIDCRAFT_UMASK_CHILD", "1")
.status()
.unwrap();
assert!(status.success());
return;
}
let dir = std::env::temp_dir().join(format!("gridcraft-fs-safety-umask-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let fresh = dir.join("new.xlsx");
write_file(fresh.to_str().unwrap(), b"v").unwrap();
let mode = std::fs::metadata(&fresh).unwrap().permissions().mode() & 0o777;
let _ = std::fs::remove_dir_all(&dir);
assert!(mode & 0o022 == 0, "mode {mode:o}");
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn open_refuses_directories_and_unknowable_lengths() {
@@ -344,6 +372,65 @@ fn failed_save_leaves_no_temporary_file() {
let _ = std::fs::remove_dir_all(&dir);
}
/// A save replaces an existing workbook with exactly the new bytes, and a save into a folder
/// that doesn't exist fails without creating anything. The flush to disk before the rename is
/// not covered: a power loss can't be simulated in a unit test.
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn save_writes_exact_bytes_and_fails_cleanly_without_a_folder() {
let dir = std::env::temp_dir().join(format!("gridcraft-write-exact-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let dest = dir.join("Book.xlsx");
std::fs::write(&dest, b"old workbook that is longer than the new one").unwrap();
let bytes: Vec<u8> = (0..=255u8).cycle().take(100_000).collect();
write_file(dest.to_str().unwrap(), &bytes).unwrap();
assert_eq!(std::fs::read(&dest).unwrap(), bytes);
assert!(!dir.join("Book.xlsx.sctmp").exists());
let missing = dir.join("no-such-folder").join("Book.xlsx");
assert!(write_file(missing.to_str().unwrap(), b"x").is_err());
assert!(!dir.join("no-such-folder").exists());
assert_eq!(std::fs::read(&dest).unwrap(), bytes, "the existing workbook is untouched");
let _ = std::fs::remove_dir_all(&dir);
}
/// Only "this file system cannot flush" errors are tolerated when syncing a saved file.
/// The fallback on a real network mount is not tested.
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn full_sync_tolerates_only_unsupported_errors() {
use std::io::{Error, ErrorKind};
assert_eq!(full_sync_unsupported(&Error::from_raw_os_error(25)), cfg!(unix));
assert!(full_sync_unsupported(&Error::from(ErrorKind::Unsupported)));
assert!(!full_sync_unsupported(&Error::from(ErrorKind::PermissionDenied)));
assert!(!full_sync_unsupported(&Error::from(ErrorKind::StorageFull)));
assert!(!full_sync_unsupported(&Error::from_raw_os_error(28)), "ENOSPC on Linux");
assert!(!full_sync_unsupported(&Error::from_raw_os_error(5)), "EIO");
}
/// Apple's ENOTSUP is 45 (EOPNOTSUPP is 102), and std maps only the latter to
/// `ErrorKind::Unsupported`: F_FULLFSYNC refused with ENOTSUP must still save. Elsewhere 45 is
/// another error (EL2NSYNC on Linux) and stays a failed save.
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn full_sync_tolerates_apple_enotsup() {
use std::io::Error;
let enotsup = Error::from_raw_os_error(45);
assert!(flush_unsupported_on(&enotsup, true, true), "ENOTSUP on Apple");
assert!(!flush_unsupported_on(&enotsup, true, false), "45 on other Unix");
assert!(!flush_unsupported_on(&enotsup, false, false), "45 on Windows");
assert!(flush_unsupported_on(&Error::from_raw_os_error(25), true, true), "ENOTTY on Apple");
assert!(!flush_unsupported_on(&Error::from_raw_os_error(5), true, true), "EIO on Apple");
assert!(!flush_unsupported_on(&Error::from_raw_os_error(28), true, true), "ENOSPC on Apple");
}
/// The real helper on an Apple host: a raw ENOTSUP from F_FULLFSYNC is tolerated.
#[cfg(target_vendor = "apple")]
#[test]
fn full_sync_tolerates_raw_enotsup_on_apple() {
assert!(full_sync_unsupported(&std::io::Error::from_raw_os_error(45)));
}
/// While a script runs (#2178), file reads and writes are refused whatever command or
/// parameter asked for them; nesting and dropping the sandbox restore access.
#[cfg(not(target_arch = "wasm32"))]
@@ -527,9 +614,80 @@ fn delimited_exports_preserve_general_precision_and_explicit_number_formats() {
sheet.set_cell(CellRef::new(0, 0), Cell { value: Value::Number(124412140710.0), ..Default::default() });
sheet.set_cell(CellRef::new(0, 1), Cell { value: Value::Number(1.23456789012345), ..Default::default() });
sheet.set_cell(CellRef::new(0, 2), Cell { value: Value::Number(124412140710.0), style: scientific, ..Default::default() });
// Every integer below 1e16 that f64 holds (also 2^53 and the even integers above it) keeps
// every digit; larger numbers keep the shortest digits that read back as the same value,
// and a number `&` would write with an exponent is written out in full, so reopening the
// file can't give it a scientific format that then rounds it on the next save.
let cells = [
(1234567890123456.0, "1234567890123456"),
(-9007199254740991.0, "-9007199254740991"),
(9007199254740992.0, "9007199254740992"),
(9007199254740994.0, "9007199254740994"),
(9123456789012346.0, "9123456789012346"),
(-9999999999999998.0, "-9999999999999998"),
(12345678901234567.0, "12345678901234568"),
(1e20, "100000000000000000000"),
(1e15 - 0.5, "999999999999999.5"),
(1.0 / 3.0 * 1e-6, "0.000000333333333333333"),
(1.23456789012346e-10, "0.000000000123456789012346"),
];
for (col, (n, _)) in cells.iter().enumerate() {
sheet.set_cell(CellRef::new(0, col as u32 + 3), Cell { value: Value::Number(*n), ..Default::default() });
}
for (path, separator) in [("data.csv", ","), ("data.tsv", "\t")] {
let output = String::from_utf8(save_bytes(&workbook, path).unwrap()).unwrap();
assert_eq!(output, format!("124412140710{separator}1.23456789012345{separator}1.24E+11\r\n"));
let tail: Vec<&str> = cells.iter().map(|(_, text)| *text).collect();
assert_eq!(output, format!("124412140710{s}1.23456789012345{s}1.24E+11{s}{}\r\n", tail.join(separator), s = separator));
// Reopening the file and saving it again changes nothing.
let (reopened, _) = open_bytes(path, output.as_bytes()).unwrap();
assert_eq!(String::from_utf8(save_bytes(&reopened, path).unwrap()).unwrap(), output);
}
}
/// A number shown as General is written as `&` converts it (15 significant digits), whatever
/// colour, sections or literals the format adds, and in a Text cell. Excel writes the cell
/// display (`1.24412E+11`, `0.333333333`); GridCraft keeps the digits so part codes survive
/// (integers below 1e16 keep all their digits, and nothing gets an exponent; see the test above).
#[test]
fn delimited_exports_write_general_numbers_as_text_converts_them() {
use gridcraft_core::Value;
use gridcraft_model::{Cell, NumFmt, StyleId};
let mut wb = Workbook::new();
let mut styled = |code: &str| wb.styles.derive(StyleId::DEFAULT, |s| s.num_fmt = NumFmt::new(code));
let (blue, signed, red, text, unit) =
(styled("[Blue]General"), styled("General;-General"), styled("General;[Red]-General"), styled("@"), styled("General\" mm\""));
let code = 124412140710.0;
let sh = wb.sheet_mut(0).unwrap();
let cells = [
(Value::Number(1.0 / 3.0), StyleId::DEFAULT),
(Value::Number(0.1 + 0.2), StyleId::DEFAULT),
(Value::Number(1e20), StyleId::DEFAULT),
(Value::Number(code), blue),
(Value::Number(9007199254740994.0), blue),
(Value::Number(-1.0 / 3.0), blue),
(Value::Number(-code), signed),
(Value::Number(-code), red),
(Value::Number(code), text),
(Value::Number(code), unit),
];
for (col, (value, style)) in cells.into_iter().enumerate() {
sh.set_cell(CellRef::new(0, col as u32), Cell { value, formula: None, py: None, style });
}
for (path, sep) in [("out.csv", ","), ("out.txt", "\t")] {
let output = String::from_utf8(save_bytes(&wb, path).unwrap()).unwrap();
let expected = [
"0.333333333333333",
"0.3",
"100000000000000000000",
"124412140710",
"9007199254740994",
"-0.333333333333333",
"-124412140710",
"-124412140710",
"124412140710",
"124412140710 mm",
];
assert_eq!(output, format!("{}\r\n", expected.join(sep)));
}
}
@@ -763,7 +921,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 +968,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 `&amp;` are 15 bytes");
assert_eq!(esc_within("&&&", 15).as_deref(), Some("&amp;&amp;&amp;"));
}
#[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());
}
+20 -1
View File
@@ -8,6 +8,7 @@
pub mod catalog;
pub mod cf;
pub mod chart_data;
mod chart_svg;
mod clip_html;
pub mod cmd;
@@ -305,11 +306,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 +653,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();
+1 -11
View File
@@ -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.
+12 -3
View File
@@ -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 = [
+38 -2
View File
@@ -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;
+3 -1
View File
@@ -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);
}
+29 -3
View File
@@ -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 })
}
+4 -2
View File
@@ -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 {
+15
View File
@@ -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
View File
@@ -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());
+252 -86
View File
@@ -2,7 +2,7 @@
//! `TableStyleLight1…21 / Medium1…28 / Dark1…11` names so files round-trip).
use gridcraft_core::{CellRef, RangeRef};
use gridcraft_model::{BorderLine, BorderStyle, Cell, Color, Fill, Formula, PatternType, Style, Table, Workbook};
use gridcraft_model::{BorderLine, BorderStyle, Borders, Cell, Color, Fill, Formula, PatternType, Sheet, Style, Table, Workbook};
/// (family, number) from a style name, e.g. `TableStyleMedium2` → ("Medium", 2).
pub fn parse_style_name(name: &str) -> (&'static str, u32) {
@@ -22,113 +22,279 @@ fn accent_for(n: u32) -> Option<u8> {
if k == 0 { None } else { Some(3 + k as u8) }
}
/// Header/band/body colours for a table style.
/// Fills, text colours and thin lines of a table style, per part of the table (the recipes in
/// plan/excel/table-style-spec.json). Band 1 is the first data row; unbanded rows use band 2.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct TableLook {
pub header_fill: Option<Color>,
pub header_font: Color,
pub header_bold: bool,
pub band_fill: Option<Color>,
pub body_fill: Option<Color>,
pub line: Option<Color>,
pub total_top: Option<Color>,
pub band1: Option<Color>,
pub band2: Option<Color>,
pub body_font: Color,
pub top: Option<Color>,
pub header_bottom: Option<Color>,
pub inner_h: Option<Color>,
pub inner_v: Option<Color>,
pub sides: Option<Color>,
pub bottom: Option<Color>,
/// The totals row's double top rule (the gallery doesn't show totals).
pub total_top: Color,
}
pub fn look(style: &str) -> TableLook {
let (fam, n) = parse_style_name(style);
let acc = accent_for(n);
let base = |tint: i16| match acc {
Some(a) => Color::Theme(a, tint),
None => Color::Theme(1, if tint == 0 { 0 } else { tint.clamp(-1000, 1000) }),
// An accent tint, or the neutral column's colour.
let a = |tint: i16, neutral: Color| acc.map_or(neutral, |a| Color::Theme(a, tint));
let (black, white) = (Color::Theme(1, 0), Color::Theme(0, 0));
let (grey, mid_grey) = (Color::Theme(0, -150), Color::Theme(0, -350));
let main = a(0, black);
let plain = TableLook {
header_fill: None,
header_font: black,
band1: None,
band2: None,
body_font: black,
top: None,
header_bottom: None,
inner_h: None,
inner_v: None,
sides: None,
bottom: None,
total_top: main,
};
let neutral_light = |tint: i16| match acc {
Some(a) => Color::Theme(a, tint),
None => Color::Theme(0, -((1000 - tint).clamp(0, 1000) / 6)),
};
match fam {
"Light" => {
let group = (n - 1) / 7; // 0: lines only, 1: banded header line, 2: grid
match (fam, n.saturating_sub(1) / 7) {
("Light", 0) => {
let text = a(-250, black);
let line = Some(main);
TableLook { header_font: text, body_font: text, band1: Some(a(800, grey)), top: line, header_bottom: line, bottom: line, ..plain }
}
("Light", 1) => {
let line = Some(main);
TableLook { header_fill: line, header_font: white, top: line, inner_h: line, sides: line, bottom: line, ..plain }
}
("Light", _) => {
let line = Some(main);
TableLook { band1: Some(a(800, grey)), top: line, header_bottom: line, inner_v: line, sides: line, bottom: line, ..plain }
}
("Medium", 0) => {
let line = Some(a(400, black));
TableLook { header_fill: Some(main), header_font: white, band1: Some(a(800, grey)), top: line, sides: line, bottom: line, ..plain }
}
("Medium", 1) => TableLook {
header_fill: Some(main),
header_font: white,
band1: Some(a(600, mid_grey)),
band2: Some(a(800, grey)),
header_bottom: Some(white),
inner_v: Some(white),
..plain
},
("Medium", 2) => {
// Accent header over neutral grey bands and black rules; the neutral style adds a grid.
let line = Some(black);
let grid = if acc.is_none() { line } else { None };
let header_fill = Some(main);
TableLook {
header_fill: None,
header_font: if group == 0 { base(-250) } else { Color::Auto },
header_bold: true,
band_fill: Some(neutral_light(800)),
body_fill: None,
line: Some(base(0)),
total_top: Some(base(0)),
header_fill,
header_font: white,
band1: Some(grey),
top: line,
header_bottom: line,
inner_v: grid,
sides: grid,
bottom: line,
total_top: black,
..plain
}
}
"Dark" => TableLook {
header_fill: Some(Color::Theme(1, 0)),
header_font: Color::Theme(0, 0),
header_bold: true,
band_fill: Some(base(-250)),
body_fill: Some(base(0)),
line: None,
total_top: Some(Color::Theme(0, 0)),
},
_ => TableLook {
header_fill: Some(base(0)),
header_font: Color::Theme(0, 0),
header_bold: true,
band_fill: Some(neutral_light(800)),
body_fill: None,
line: if (n - 1) / 7 == 0 { None } else { Some(base(400)) },
total_top: Some(base(0)),
("Medium", _) => {
let line = Some(a(400, black));
let pale = Some(a(800, grey));
TableLook { header_fill: pale, band1: Some(a(600, mid_grey)), band2: pale, top: line, inner_v: line, sides: line, bottom: line, ..plain }
}
("Dark", 0) => TableLook {
header_fill: Some(black),
header_font: white,
band1: Some(a(-250, Color::Theme(1, 250))),
band2: Some(a(0, Color::Theme(1, 450))),
body_font: white,
header_bottom: Some(white),
total_top: white,
..plain
},
_ if n == 8 => TableLook { header_fill: Some(black), header_font: white, band1: Some(mid_grey), band2: Some(grey), ..plain },
_ => {
// Dark 9-11 pair accents 1+2, 3+4 and 5+6: the header takes the even one.
let k = n.clamp(9, 11) as u8 - 8;
let (head, body) = (Color::Theme(3 + 2 * k, 0), 2 + 2 * k);
let band1 = Some(Color::Theme(body, 600));
TableLook { header_fill: Some(head), header_font: white, band1, band2: Some(Color::Theme(body, 800)), total_top: head, ..plain }
}
}
}
/// The style a table gives a cell (merged over the cell's own style: explicit fills/fonts win).
/// Which parts of a table are on (the Table Style Options checkboxes).
#[derive(Clone, Copy, Debug)]
pub struct TableParts {
pub header_row: bool,
pub totals_row: bool,
pub banded_rows: bool,
pub banded_cols: bool,
pub first_col: bool,
pub last_col: bool,
}
impl TableParts {
pub fn of(t: &Table) -> TableParts {
TableParts {
header_row: t.header_row,
totals_row: t.totals_row,
banded_rows: t.banded_rows,
banded_cols: t.banded_cols,
first_col: t.first_col,
last_col: t.last_col,
}
}
}
/// What a table style paints on one cell of a `rows` x `cols` table (`row`, `col` from its
/// top-left). Each line has one owner: a horizontal line is a cell's bottom (top only on the
/// first row and the totals row), a vertical one a cell's right (left only on the first column).
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct CellLook {
pub fill: Option<Color>,
pub font: Color,
pub bold: bool,
pub borders: Borders,
}
pub fn cell_look(lk: &TableLook, p: TableParts, row: u32, col: u32, rows: u32, cols: u32) -> CellLook {
let last_row = rows.saturating_sub(1);
let last_col = cols.saturating_sub(1);
let is_header = p.header_row && row == 0;
let is_total = p.totals_row && row == last_row && !is_header;
let thin = |c: Option<Color>| c.map(|color| BorderLine { style: BorderStyle::Thin, color }).unwrap_or_default();
let mut b = Borders::default();
if row == 0 {
b.top = thin(lk.top);
}
b.bottom = thin(if row == last_row {
lk.bottom
} else if is_header {
lk.header_bottom
} else if p.totals_row && row.saturating_add(1) == last_row {
None // the totals row draws its own top rule
} else {
lk.inner_h
});
if col == 0 {
b.left = thin(lk.sides);
}
b.right = thin(if col == last_col { lk.sides } else { lk.inner_v });
let mut out = CellLook { borders: b, font: lk.body_font, ..Default::default() };
if is_header {
out.fill = lk.header_fill;
out.font = lk.header_font;
out.bold = true;
} else if is_total {
out.fill = lk.band2;
out.bold = true;
out.borders.top = BorderLine { style: BorderStyle::Double, color: lk.total_top };
} else {
let data_row = row.saturating_sub(p.header_row as u32);
let band1 = (p.banded_rows && data_row.is_multiple_of(2)) || (p.banded_cols && col.is_multiple_of(2));
out.fill = if band1 { lk.band1 } else { lk.band2 };
}
if (p.first_col && col == 0) || (p.last_col && col == last_col) {
out.bold = true;
}
out
}
/// The style a table gives a cell (merged over the cell's own style: explicit fills, fonts and
/// borders win).
pub fn table_cell_style(wb: &Workbook, sheet: usize, t: &Table, c: CellRef) -> Style {
let own = wb.sheet(sheet).map(|sh| wb.styles.get(sh.style_id(c)).clone()).unwrap_or_default();
let (start, end) = (t.range.start, t.range.end);
let rows = end.row.saturating_sub(start.row).saturating_add(1);
let cols = end.col.saturating_sub(start.col).saturating_add(1);
let lk = cell_look(&look(&t.style), TableParts::of(t), c.row.saturating_sub(start.row), c.col.saturating_sub(start.col), rows, cols);
let mut s = own.clone();
let lk = look(&t.style);
let is_header = t.header_row && c.row == t.range.start.row;
let is_total = t.totals_row && c.row == t.range.end.row;
let data_row = c.row.saturating_sub(t.range.start.row + t.header_row as u32);
let data_col = c.col - t.range.start.col;
let explicit_fill = own.fill.pattern != PatternType::None;
if is_header {
if let Some(f) = lk.header_fill
&& !explicit_fill
{
s.fill = Fill::solid(f);
}
if own.font.color == Color::Auto {
s.font.color = lk.header_font;
}
s.font.bold = s.font.bold || lk.header_bold;
if let Some(l) = lk.line {
s.borders.bottom = BorderLine { style: BorderStyle::Thin, color: l };
}
} else if is_total {
s.font.bold = true;
if let Some(l) = lk.total_top {
s.borders.top = BorderLine { style: BorderStyle::Double, color: l };
}
} else {
let band = (t.banded_rows && data_row.is_multiple_of(2)) || (t.banded_cols && data_col.is_multiple_of(2));
if !explicit_fill {
if band {
if let Some(f) = lk.band_fill {
s.fill = Fill::solid(f);
}
} else if let Some(f) = lk.body_fill {
s.fill = Fill::solid(f);
}
}
if let Some(l) = lk.line
&& t.style.contains("Light")
&& c.row == t.range.end.row
{
s.borders.bottom = BorderLine { style: BorderStyle::Thin, color: l };
if let Some(f) = lk.fill
&& own.fill.pattern == PatternType::None
{
s.fill = Fill::solid(f);
}
if own.font.color == Color::Auto {
s.font.color = lk.font;
}
s.font.bold = s.font.bold || lk.bold;
for (side, line) in [
(&mut s.borders.top, lk.borders.top),
(&mut s.borders.bottom, lk.borders.bottom),
(&mut s.borders.left, lk.borders.left),
(&mut s.borders.right, lk.borders.right),
] {
if side.is_none() {
*side = line;
}
}
if (t.first_col && c.col == t.range.start.col) || (t.last_col && c.col == t.range.end.col) {
s.font.bold = true;
s
}
/// A table's first and last visible row and column (hidden or filtered lines skipped).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ShownEdges {
pub top: u32,
pub bottom: u32,
pub left: u32,
pub right: u32,
}
/// Finds [`ShownEdges`]. It scans the hidden lines at each edge, so the grid and print call it
/// once per table per paint (through [`crate::cf::CfCache::table_edges`]), not once per cell.
pub fn shown_edges(sh: &Sheet, t: &Table) -> ShownEdges {
let (start, end) = (t.range.start, t.range.end);
let row_shown = |r: &u32| sh.row_height(*r) > 0.0;
let col_shown = |k: &u32| sh.col_width(*k) > 0.0;
// With every row (or column) hidden, each cell takes both edges' lines; nothing is drawn.
ShownEdges {
top: (start.row..=end.row).find(row_shown).unwrap_or(end.row),
bottom: (start.row..=end.row).rev().find(row_shown).unwrap_or(start.row),
left: (start.col..=end.col).find(col_shown).unwrap_or(end.col),
right: (start.col..=end.col).rev().find(col_shown).unwrap_or(start.col),
}
if t.style.starts_with("TableStyleDark") && !is_header && own.font.color == Color::Auto {
s.font.color = Color::Theme(0, 0);
}
/// The style the grid and print draw for a table cell. Like [`table_cell_style`], but the
/// table's outer frame follows hidden rows and columns: the last visible row takes the table's
/// bottom line, the last visible column its right side, and the first visible row and column its
/// top line and left side. (Each frame line is owned by the edge cell, which is never drawn while
/// it is hidden or filtered out.) Convert to Range uses [`table_cell_style`], the table as it is.
pub fn table_cell_shown_style(wb: &Workbook, sheet: usize, t: &Table, e: ShownEdges, c: CellRef) -> Style {
let mut s = table_cell_style(wb, sheet, t, c);
let Some(sh) = wb.sheet(sheet) else { return s };
let (start, end) = (t.range.start, t.range.end);
let below = c.row < end.row && c.row >= e.bottom;
let above = c.row > start.row && c.row <= e.top;
let right = c.col < end.col && c.col >= e.right;
let left = c.col > start.col && c.col <= e.left;
if !(below || above || right || left) {
return s;
}
let own = wb.styles.get(sh.style_id(c)).borders;
if below && own.bottom.is_none() {
s.borders.bottom = table_cell_style(wb, sheet, t, CellRef::new(end.row, c.col)).borders.bottom;
}
if above && own.top.is_none() {
s.borders.top = table_cell_style(wb, sheet, t, CellRef::new(start.row, c.col)).borders.top;
}
if right && own.right.is_none() {
s.borders.right = table_cell_style(wb, sheet, t, CellRef::new(c.row, end.col)).borders.right;
}
if left && own.left.is_none() {
s.borders.left = table_cell_style(wb, sheet, t, CellRef::new(c.row, start.col)).borders.left;
}
s
}
+494 -1
View File
@@ -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;
@@ -757,6 +869,65 @@ fn deleting_a_multi_area_row_selection_removes_every_area_and_undoes_once() {
assert_eq!((v(&s, "A1"), v(&s, "B1"), v(&s, "C1")), (Value::Number(2.0), Value::Number(4.0), Value::Empty));
}
#[test]
#[allow(clippy::disallowed_methods)] // native-only test: timing the two deletes
fn deleting_many_separate_rows_takes_about_as_long_as_one_block() {
// #2287: every 10th row of a 12,000-row sheet, as 1,200 single-row areas.
let (rows, step) = (12_000u32, 10u32);
let values: Vec<serde_json::Value> = (0..rows).map(|r| json!([r, r + 100_000, r + 200_000])).collect();
let deleted = |r: u32| r >= 1 && (r - 1).is_multiple_of(step);
let list = (0..rows).filter(|&r| deleted(r)).map(|r| format!("{0}:{0}", r + 1)).collect::<Vec<_>>().join(",");
let build = || {
let mut s = s();
s.execute("range.setValues", json!({"range": "A1", "values": values})).unwrap();
s.execute("cell.set", json!({"cell": "E1", "input": format!("=SUM(A1:A{rows})")})).unwrap();
s.execute("cell.set", json!({"cell": "E3", "input": "=B25"})).unwrap();
s
};
let mut block = build();
let t = std::time::Instant::now();
block.execute("home.deleteRows", json!({"rows": format!("2:{}", rows / step + 1)})).unwrap();
let block_time = t.elapsed();
let mut s = build();
let t = std::time::Instant::now();
s.execute("home.deleteRows", json!({"rows": list})).unwrap();
let separate_time = t.elapsed();
let kept: Vec<u32> = (0..rows).filter(|&r| !deleted(r)).collect();
let d = s.doc().unwrap();
let sh = d.wb.active().unwrap();
assert_eq!(sh.used_range().unwrap().end.row as usize, kept.len() - 1);
for (i, r) in kept.iter().enumerate() {
assert_eq!(sh.value(CellRef::new(i as u32, 0)), Value::Number(*r as f64));
assert_eq!(sh.value(CellRef::new(i as u32, 2)), Value::Number((*r + 200_000) as f64));
}
assert_eq!(s.execute("cell.get", json!({"cell": "E1"})).unwrap()["formula"], format!("=SUM(A1:A{})", kept.len()));
// B25 loses rows 2, 12 and 22 above it; the formula itself moves from E3 to E2.
assert_eq!(s.execute("cell.get", json!({"cell": "E2"})).unwrap()["formula"], "=B22");
assert!(
separate_time < block_time * 20 + std::time::Duration::from_millis(500),
"separate rows took {separate_time:?}, one block took {block_time:?}"
);
}
#[test]
fn deleting_many_separate_columns_matches_per_area_result() {
let mut s = s();
let values: Vec<serde_json::Value> = (0..50).map(|r| json!((0..40).map(|c| r * 100 + c).collect::<Vec<_>>())).collect();
s.execute("range.setValues", json!({"range": "A1", "values": values})).unwrap();
s.execute("cell.set", json!({"cell": "A60", "input": "=SUM(A1:AN1)+H2"})).unwrap();
// Columns B, E, H (refs) and F:G.
s.execute("home.deleteColumns", json!({"cols": "B:B,E:E,H:H,F:G"})).unwrap();
let kept: Vec<u32> = (0..40).filter(|c| ![1, 4, 5, 6, 7].contains(c)).collect();
for r in 0..50u32 {
for (i, c) in kept.iter().enumerate() {
assert_eq!(s.doc().unwrap().wb.active().unwrap().value(CellRef::new(r, i as u32)), Value::Number((r * 100 + c) as f64));
}
}
assert_eq!(s.execute("cell.get", json!({"cell": "A60"})).unwrap()["formula"], "=SUM(A1:AI1)+#REF!");
}
#[test]
fn move_columns_reorders_without_overwriting_and_undoes_once() {
let mut s = s();
@@ -1509,6 +1680,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 +1856,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 +1864,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 +2516,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 +3084,128 @@ 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, is
// #SPILL! because E10 holds those cells (as in Excel), shrinks back and spills 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: E10 holds F10, so it keeps it and F8 is blocked.
assert_eq!(v(&s, "F8"), Value::Error(Spill));
assert_eq!(v(&s, "F10"), Value::Number(20.0));
}
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, blocked again.
assert_eq!(v(&s, "F8"), Value::Error(Spill));
assert_eq!(v(&s, "F10"), Value::Number(20.0));
}
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
@@ -3037,6 +3415,21 @@ fn a_spill_that_goes_away_unblocks_another() {
assert_eq!((v(&s, "E10"), v(&s, "G10")), (Value::Number(1.0), Value::Number(3.0)));
}
#[test]
fn a_contested_spill_area_stays_with_its_array_after_reopening() {
// F13's array wants F14:G14, which C14's array already fills, so F13 is #SPILL!. The file
// can only cache #VALUE! for it; reopening (which recalculates) used to hand the area to F13
// for coming first in reading order.
let mut s = s();
s.execute("cell.set", json!({"cell": "C14", "input": "=SEQUENCE(1,7)"})).unwrap();
s.execute("cell.set", json!({"cell": "F13", "input": "=SEQUENCE(5,2)"})).unwrap();
assert_eq!(v(&s, "F13"), Value::Error(gridcraft_core::CellError::Spill));
let saved = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap();
s.execute("file.open", json!({"name": "contested.xlsx", "base64": saved["base64"]})).unwrap();
assert_eq!(v(&s, "F13"), Value::Error(gridcraft_core::CellError::Spill));
assert_eq!((v(&s, "C14"), v(&s, "G14"), v(&s, "I14")), (Value::Number(1.0), Value::Number(5.0), Value::Number(7.0)));
}
#[test]
fn an_array_reading_another_arrays_spill_is_updated() {
// G5 is evaluated before D11 in the same pass, so it first reads D11's old spill.
@@ -3061,6 +3454,19 @@ fn indirect_reads_a_spill_laid_out_in_the_same_pass() {
assert_eq!(v(&s, "E5"), Value::Number(9.0));
}
#[test]
fn inserting_rows_lays_out_spills_where_the_formulas_moved() {
// D1's array grows with the inserted rows to D1:D10 and C10's array moves down to C12:E14:
// the area C10:E12 it filled before the insertion blocks neither of them.
let mut s = s();
s.execute("cell.set", json!({"cell": "D1", "input": "=SEQUENCE(ROWS(A2:A9))"})).unwrap();
s.execute("cell.set", json!({"cell": "C8", "input": "=1"})).unwrap();
s.execute("cell.set", json!({"cell": "C10", "input": "=SEQUENCE(3,3)"})).unwrap();
s.execute("home.insertRows", json!({"rows": "3:4"})).unwrap();
assert_eq!((v(&s, "D1"), v(&s, "D10")), (Value::Number(1.0), Value::Number(10.0)));
assert_eq!((v(&s, "C12"), v(&s, "D12"), v(&s, "E14")), (Value::Number(1.0), Value::Number(2.0), Value::Number(9.0)));
}
#[test]
fn every_command_survives_empty_params() {
let mut s = Session::new();
@@ -3612,6 +4018,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 +5924,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.
@@ -6257,13 +6712,25 @@ fn a_script_cannot_switch_windows() {
assert_eq!(v(&s, "A1"), Value::number(2.0));
}
mod chart_data;
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 +6947,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 +7036,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();
+177
View File
@@ -0,0 +1,177 @@
//! A chart's data as blocks on the sheet, and `chart.setValuesRange`, which dragging a corner of a
//! selected chart's values outline runs (#4389, #4390).
use gridcraft_core::RangeRef;
use gridcraft_model::{Chart, Color};
use serde_json::json;
use super::s;
use crate::Session;
use crate::chart_data::{ChartData, chart_data};
fn r(a: &str) -> RangeRef {
RangeRef::parse(a).unwrap()
}
fn chart(s: &Session) -> Chart {
s.doc().unwrap().wb.active().unwrap().charts[0].clone()
}
fn data(s: &Session) -> Option<ChartData> {
chart_data(&s.doc().unwrap().wb, 0, &chart(s))
}
/// Points each plotted series has, as the chart resolves them.
fn points(s: &Session) -> Vec<usize> {
gridcraft_chart::resolve(&s.doc().unwrap().wb, 0, &chart(s)).series.iter().map(|se| se.values.len()).collect()
}
/// 10..80 down A1:A8, charted from A1:A5 only.
fn single_column() -> Session {
let mut s = s();
let values: Vec<_> = (1..=8).map(|i| json!([i * 10])).collect();
s.execute("range.setValues", json!({"range": "A1", "values": values})).unwrap();
s.execute("selection.set", json!({"range": "A1:A5"})).unwrap();
s.execute("insert.chart", json!({"type": "column"})).unwrap();
s
}
/// Region names across row 1, quarters down column A, charted from A1:C4.
fn table() -> Session {
let mut s = s();
s.execute(
"range.setValues",
json!({"range": "A1", "values": [
["", "North", "South", "East"],
["Q1", 10, 15, 12],
["Q2", 20, 25, 22],
["Q3", 30, 35, 32],
["Q4", 40, 45, 42],
["Q5", 50, 55, 52],
]}),
)
.unwrap();
s.execute("selection.set", json!({"range": "A1:C4"})).unwrap();
s.execute("insert.chart", json!({"type": "column"})).unwrap();
s
}
#[test]
fn a_plain_column_chart_is_one_values_block() {
let s = single_column();
assert_eq!(data(&s), Some(ChartData { sheet: 0, values: r("A1:A5"), by_rows: false, categories: None, names: None }));
}
#[test]
fn a_table_chart_has_names_categories_and_values_blocks() {
let s = table();
assert_eq!(data(&s), Some(ChartData { sheet: 0, values: r("B2:C4"), by_rows: false, categories: Some(r("A2:A4")), names: Some(r("B1:C1")) }));
}
#[test]
fn dragging_the_values_down_plots_the_new_rows_and_undo_puts_them_back() {
let mut s = single_column();
assert_eq!(points(&s), [5]);
let out = s.execute("chart.setValuesRange", json!({"range": "A1:A8"})).unwrap();
assert_eq!(out["values"], "Sheet1!A1:A8");
assert_eq!(chart(&s).series[0].values, "Sheet1!$A$1:$A$8");
assert_eq!(points(&s), [8]);
assert_eq!(data(&s).unwrap().values, r("A1:A8"));
s.execute("edit.undo", json!({})).unwrap();
assert_eq!(points(&s), [5]);
assert_eq!(chart(&s).series[0].values, "Sheet1!$A$1:$A$5");
}
#[test]
fn a_wider_block_adds_series_and_existing_series_keep_their_formatting() {
let mut s = table();
s.execute("chart.formatSelection", json!({"series": 1, "color": "#C00000"})).unwrap();
let south = chart(&s).series[1].color;
assert!(south.is_some());
s.execute("chart.setValuesRange", json!({"range": "B2:D6"})).unwrap();
let c = chart(&s);
assert_eq!(c.series.len(), 3);
assert_eq!(c.series[1].color, south, "South keeps its colour");
assert_eq!(c.series[2].color, None::<Color>, "the new series takes the automatic colour");
let names: Vec<_> = c.series.iter().map(|se| se.name.clone().unwrap()).collect();
assert_eq!(names, ["Sheet1!$B$1", "Sheet1!$C$1", "Sheet1!$D$1"], "names follow along the header row");
assert!(c.series.iter().all(|se| se.categories.as_deref() == Some("Sheet1!$A$2:$A$6")), "labels span the new points");
assert_eq!(c.series[2].values, "Sheet1!$D$2:$D$6");
assert_eq!(c.source.as_deref(), Some("Sheet1!A1:D6"), "Switch Row/Column sees the moved blocks");
assert_eq!(points(&s), [5, 5, 5]);
assert_eq!(data(&s), Some(ChartData { sheet: 0, values: r("B2:D6"), by_rows: false, categories: Some(r("A2:A6")), names: Some(r("B1:D1")) }));
// A narrower block drops the last series.
s.execute("chart.setValuesRange", json!({"range": "B2:B3"})).unwrap();
let c = chart(&s);
assert_eq!(c.series.len(), 1);
assert_eq!(c.series[0].categories.as_deref(), Some("Sheet1!$A$2:$A$3"));
s.execute("chart.switchRowColumn", json!({})).unwrap();
}
#[test]
fn series_in_rows_grow_across_the_columns() {
let mut s = s();
s.execute("range.setValues", json!({"range": "A1", "values": [[1, 2, 3, 4, 5, 6, 7], [7, 6, 5, 4, 3, 2, 1]]})).unwrap();
s.execute("selection.set", json!({"range": "A1:E2"})).unwrap();
s.execute("insert.chart", json!({"type": "line"})).unwrap();
assert_eq!(data(&s).map(|d| (d.values, d.by_rows)), Some((r("A1:E2"), true)));
s.execute("chart.setValuesRange", json!({"range": "A1:G2"})).unwrap();
assert_eq!(points(&s), [7, 7]);
assert_eq!(chart(&s).series[1].values, "Sheet1!$A$2:$G$2");
}
/// Changes the first chart on the first sheet in place, as a file can leave it.
fn edit_chart(s: &mut Session, f: impl FnOnce(&mut Chart)) {
let wb = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb);
f(&mut wb.sheet_mut(0).unwrap().charts[0]);
}
#[test]
fn category_labels_written_with_and_without_equals_are_one_block() {
let mut s = table();
edit_chart(&mut s, |c| c.series[1].categories = Some("=Sheet1!$A$2:$A$4".into()));
assert_eq!(data(&s).unwrap().categories, Some(r("A2:A4")));
s.execute("chart.setValuesRange", json!({"range": "B2:C6"})).unwrap();
assert!(chart(&s).series.iter().all(|se| se.categories.as_deref() == Some("Sheet1!$A$2:$A$6")), "both series' labels follow");
}
#[test]
fn series_read_in_rows_stay_resizable_after_shrinking_to_one_cell_each() {
let mut s = s();
s.execute("range.setValues", json!({"range": "A1", "values": [[1, 2, 3, 4, 5], [5, 4, 3, 2, 1]]})).unwrap();
s.execute("selection.set", json!({"range": "A1:E2"})).unwrap();
s.execute("insert.chart", json!({"type": "line"})).unwrap();
// A file can carry series in rows without saying so; the layout is read from the series.
edit_chart(&mut s, |c| c.by_rows = false);
assert_eq!(data(&s).map(|d| d.by_rows), Some(true));
s.execute("chart.setValuesRange", json!({"range": "A1:A2"})).unwrap();
assert!(chart(&s).by_rows);
assert_eq!(data(&s).map(|d| (d.values, d.by_rows)), Some((r("A1:A2"), true)), "still one block, still in rows");
s.execute("chart.setValuesRange", json!({"range": "A1:C2"})).unwrap();
assert_eq!(points(&s), [3, 3]);
}
#[test]
fn set_values_range_refuses_what_it_cannot_do() {
let mut s = table();
let before = chart(&s);
for (params, why) in [
(json!({}), "missing `range`"),
(json!({"range": "not a range"}), "not a range"),
(json!({"range": "A1:Z100000"}), "too large"),
(json!({"range": "A1:JA2"}), "too large"),
(json!({"range": "Sheet2!B2:C4"}), ""),
(json!({"chart": 999, "range": "B2:C4"}), "chart"),
] {
let err = s.execute("chart.setValuesRange", params.clone()).unwrap_err();
assert!(err.to_string().contains(why), "{params}: {err}");
assert_eq!(chart(&s), before, "{params} left the chart as it was");
}
// Series with a gap between them are not one block.
s.execute("selection.set", json!({"range": "A1:D4"})).unwrap();
s.execute("chart.selectData", json!({"range": "A1:D4"})).unwrap();
s.execute("chart.selectData", json!({"removeSeries": [1]})).unwrap();
assert_eq!(data(&s), None);
let err = s.execute("chart.setValuesRange", json!({"range": "B2:C4"})).unwrap_err();
assert!(err.to_string().contains("not one block"), "{err}");
}
+80
View File
@@ -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());
}
+15 -2
View File
@@ -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
+1
View File
@@ -0,0 +1 @@
not a GridCraft JSON workbook: invalid type: integer `7`, expected a sequence at line 1 column 12
+440
View File
@@ -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": []
}
]
}
+448
View File
@@ -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
}
@@ -35,7 +35,7 @@ use std::sync::Arc;
use gridcraft_core::{CellError, CellRef, MAX_COLS, MAX_ROWS, RangeRef, Value, col_to_letters};
use gridcraft_engine::calc::Calc;
use gridcraft_engine::model::{CalcMode, Formula, Sheet, SheetViewMode, Workbook};
use gridcraft_engine::{EngineError, Session, command_specs, find_command, io};
use gridcraft_engine::{EngineError, HistoryEntry, Session, command_specs, find_command, io};
use serde_json::{Value as Json, json};
const SAMPLES: [&str; 3] = ["sales", "budget", "grades"];
@@ -219,8 +219,24 @@ fn shrink(sample: &str, steps: &[Step], kind: &str) -> Vec<Step> {
struct Harness {
s: Session,
/// The workbook at the start of the current episode (what undoing everything gives back).
base: Arc<Workbook>,
/// What undoing everything gives back: the workbook at the start of the current episode or,
/// once the undo history has dropped its oldest steps (it is bounded by count and by the
/// memory its snapshots hold), the state before the oldest step it kept.
floor: Arc<Workbook>,
/// The workbook of the oldest undo step when the history was last looked at, to notice the
/// history dropping it.
oldest: Option<Arc<Workbook>>,
}
/// Where redoing the `n` steps just undone ends. The first of them went onto the redo history
/// with the final workbook `end`. The redo history is bounded like undo and drops its oldest
/// entries first, so when that entry is gone every older one is too, and redo stops after fewer
/// than `n` steps at the oldest entry it kept.
fn redo_target(end: &Arc<Workbook>, redo: &[HistoryEntry], n: usize) -> Arc<Workbook> {
if n == 0 || redo.iter().rev().take(n).any(|e| Arc::ptr_eq(&e.wb, end)) {
return end.clone();
}
redo.first().map_or_else(|| end.clone(), |e| e.wb.clone())
}
fn fail(step: usize, kind: &'static str, what: impl Into<String>) -> Failure {
@@ -243,8 +259,8 @@ impl Harness {
fn new(sample: &str) -> Harness {
let mut s = Session::new();
s.execute("file.new", json!({"sample": sample})).expect("sample opens");
let base = s.doc().expect("document").wb.clone();
Harness { s, base }
let floor = s.doc().expect("document").wb.clone();
Harness { s, floor, oldest: None }
}
fn wb(&self) -> Arc<Workbook> {
@@ -262,6 +278,7 @@ impl Harness {
return Err(fail(i, "documents", format!("`{id}` changed the number of open documents; exclude it in EXCLUDED")));
}
let after = self.wb();
self.track_history();
let spec = find_command(id).expect("generated ids are registered");
if !spec.undoable
&& !matches!(id, "edit.undo" | "edit.redo")
@@ -293,6 +310,7 @@ impl Harness {
/// and reload; the next episode starts from here with an empty history.
fn end_episode(&mut self, i: usize) -> Result<(), Failure> {
let end = self.wb();
self.track_history();
let mut n = 0;
while !self.s.doc().expect("document").undo.is_empty() {
if let Err(EngineError::Internal(_, msg)) = self.s.execute("edit.undo", json!({})) {
@@ -304,7 +322,7 @@ impl Harness {
}
}
let undone = self.wb();
if let Some(diff) = workbook_diff(&self.base, &undone) {
if let Some(diff) = workbook_diff(&self.floor, &undone) {
return Err(fail(i, "undo", format!("undoing all {n} steps doesn't give back the starting workbook: {diff}")));
}
if watch_list(&end) != watch_list(&undone) {
@@ -312,23 +330,39 @@ impl Harness {
}
self.check_state(i)?;
// Only the steps undone here: an `edit.undo {steps}` in the sequence may have left more.
let target = redo_target(&end, &self.s.doc().expect("document").redo, n);
for _ in 0..n {
if let Err(EngineError::Internal(_, msg)) = self.s.execute("edit.redo", json!({})) {
return Err(fail(i, "panic", format!("`edit.redo` panicked while redoing everything: {msg}")));
}
}
if let Some(diff) = workbook_diff(&end, &self.wb()) {
return Err(fail(i, "redo", format!("redoing all {n} steps doesn't give back the final workbook: {diff}")));
if let Some(diff) = workbook_diff(&target, &self.wb()) {
let what = if Arc::ptr_eq(&target, &end) { "the final workbook" } else { "the newest step the redo history kept" };
return Err(fail(i, "redo", format!("redoing all {n} steps doesn't give back {what}: {diff}")));
}
self.check_state(i)?;
guarded(i, "xlsx roundtrip", || roundtrip_diff(&end))?;
let d = self.s.active_mut().expect("document");
d.undo.clear();
d.redo.clear();
self.base = d.wb.clone();
self.floor = d.wb.clone();
self.oldest = None;
Ok(())
}
/// Notices the undo history dropping its oldest step: its oldest entry changed without the
/// history emptying in between. From then on undoing everything stops at the new oldest entry,
/// including after an `edit.undo` in the sequence has already used up what is left.
fn track_history(&mut self) {
let oldest = self.s.doc().expect("document").undo.first().map(|e| e.wb.clone());
if let (Some(was), Some(now)) = (&self.oldest, &oldest)
&& !Arc::ptr_eq(was, now)
{
self.floor = now.clone();
}
self.oldest = oldest;
}
fn finish(&mut self, steps: usize) -> Result<(), Failure> {
self.end_episode(steps)
}
@@ -1135,3 +1169,42 @@ fn view_mode_switch_is_not_an_undo_difference() {
assert!(failure.is_none(), "`{id}`: {failure:?}");
}
}
/// Review of #2332: once the undo history has dropped its oldest steps, an `edit.undo` in the
/// sequence can use up everything it kept before the episode ends. Undoing everything then has
/// nothing left to do, and the workbook is the state before the oldest step kept, not the
/// episode's start.
#[test]
fn a_trimmed_history_undone_in_the_sequence_stops_at_its_oldest_step() {
let mut h = Harness::new("sales");
// Past the engine's 100-step undo limit, so it drops the oldest 5 steps.
for i in 0..105 {
h.s.execute("cell.set", json!({"cell": format!("Z{}", i + 1), "input": i.to_string()})).expect("cell.set");
h.track_history();
}
assert_eq!(h.s.doc().expect("document").undo.len(), 100, "the history dropped its oldest steps");
if let Err(f) = h.step(0, "edit.undo", &json!({"steps": 100})) {
panic!("{f:?}");
}
assert!(h.s.doc().expect("document").undo.is_empty());
if let Err(f) = h.end_episode(0) {
panic!("{f:?}");
}
}
/// Review of #2332: the redo history is bounded too, so undoing `n` steps may leave fewer than
/// `n` to redo, and redo then stops at the oldest entry it kept rather than at the final workbook.
#[test]
fn redo_stops_at_the_oldest_step_its_history_kept() {
let h = Harness::new("sales");
let selection = h.s.doc().expect("document").selection.clone();
let entry = |wb: &Arc<Workbook>| HistoryEntry { label: String::new(), wb: wb.clone(), selection: selection.clone(), retained_bytes: 0 };
let end = Arc::new((*h.wb()).clone());
let kept = Arc::new((*h.wb()).clone());
// Both steps kept: the first one undone went onto the redo history with the final workbook.
assert!(Arc::ptr_eq(&redo_target(&end, &[entry(&end), entry(&kept)], 2), &end));
// Its entry dropped: redo stops at the oldest entry left.
assert!(Arc::ptr_eq(&redo_target(&end, &[entry(&kept)], 2), &kept));
// Nothing undone, so nothing to redo, whatever an earlier `edit.undo` left there.
assert!(Arc::ptr_eq(&redo_target(&end, &[entry(&kept)], 0), &end));
}
+2
View File
@@ -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;
@@ -31,6 +32,7 @@ mod sparse_clear_invalidation;
mod stored_list_shape;
mod structural_edit_rewrite;
mod table_resize_overlap;
mod table_style_looks;
mod table_total_row_last_row;
mod trace_error;
mod workbook_author;
@@ -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");
}
+243
View File
@@ -0,0 +1,243 @@
//! Table styles look like the Format as Table gallery: every row of the gallery (Light 1-7, 8-14,
//! 15-21, Medium 1-7, …) has its own fills and lines, as recorded in plan/excel/table-style-spec.json.
use gridcraft_core::CellRef;
use gridcraft_engine::Session;
use gridcraft_engine::model::*;
use gridcraft_engine::tables::{ShownEdges, shown_edges, table_cell_shown_style, table_cell_style};
use serde_json::json;
const ROWS: u32 = 6; // header + 5 data rows
const COLS: u32 = 5;
fn session() -> Session {
let mut s = Session::new();
s.new_workbook();
s.execute("range.setValues", json!({"range": "A1", "values": [["a", "b", "c", "d", "e"]]})).unwrap();
s.execute("insert.table", json!({"range": "A1:E6", "header": true})).unwrap();
s
}
/// The look of every cell of a 6x5 table (header on, banded rows) in `style`, row by row.
fn grid_with(s: &Session, style: &str, edit: impl Fn(&mut Table)) -> Vec<Vec<Style>> {
let wb = &s.doc().unwrap().wb;
let mut t = wb.sheet(0).unwrap().tables[0].clone();
t.style = format!("TableStyle{style}");
edit(&mut t);
(0..ROWS).map(|r| (0..COLS).map(|c| table_cell_style(wb, 0, &t, CellRef::new(r, c))).collect()).collect()
}
fn grid(style: &str) -> Vec<Vec<Style>> {
grid_with(&session(), style, |_| {})
}
fn thin(color: Color) -> BorderLine {
BorderLine { style: BorderStyle::Thin, color }
}
const NONE: BorderLine = BorderLine { style: BorderStyle::None, color: Color::Auto };
const BLACK: Color = Color::Theme(1, 0);
const WHITE: Color = Color::Theme(0, 0);
#[test]
fn each_row_of_the_gallery_has_its_own_look() {
// Same accent (or neutral) across the gallery's rows, so only the row-group differs.
for set in [
&["Light1", "Light8", "Light15", "Medium1", "Medium8", "Medium15", "Medium22", "Dark1", "Dark8"][..],
&["Light2", "Light9", "Light16", "Medium2", "Medium9", "Medium16", "Medium23", "Dark2", "Dark9"][..],
] {
let looks: Vec<_> = set.iter().map(|s| grid(s)).collect();
for (i, a) in looks.iter().enumerate() {
for (j, b) in looks.iter().enumerate().skip(i + 1) {
assert_ne!(a, b, "{} and {} look the same", set[i], set[j]);
}
}
}
}
#[test]
fn neutral_bands_are_visibly_grey() {
let theme = Theme::default();
let fill = |style: &str, row: usize| grid(style)[row][0].fill.fg.resolve(&theme).unwrap();
// lt1 -150 (about #D9D9D9) and lt1 -350 (about #A6A6A6).
for ch in fill("Light1", 1) {
assert!((210..=225).contains(&ch), "Light1 band {:?}", fill("Light1", 1));
}
for ch in fill("Medium8", 1) {
assert!((160..=172).contains(&ch), "Medium8 band1 {:?}", fill("Medium8", 1));
}
}
#[test]
fn light15_has_a_vertical_grid_and_no_row_lines() {
let g = grid("Light15");
assert_eq!(g[0][0].borders.top, thin(BLACK));
assert_eq!(g[0][2].borders.bottom, thin(BLACK), "header bottom");
assert_eq!(g[2][1].borders.right, thin(BLACK), "inner vertical");
assert_eq!(g[0][1].borders.right, thin(BLACK), "inner vertical in the header");
assert_eq!(g[2][0].borders.left, thin(BLACK), "left side");
assert_eq!(g[2][4].borders.right, thin(BLACK), "right side");
assert_eq!(g[5][2].borders.bottom, thin(BLACK), "bottom");
assert_eq!(g[2][1].borders.bottom, NONE, "no inner horizontal");
assert_eq!(g[2][1].borders.top, NONE, "no inner horizontal");
assert_eq!(g[1][0].fill.fg, Color::Theme(0, -150));
}
#[test]
fn medium2_has_a_pale_accent_frame_and_no_row_lines() {
let g = grid("Medium2");
let line = thin(Color::Theme(4, 400));
assert_eq!(g[0][0].fill.fg, Color::Theme(4, 0));
assert_eq!(g[0][0].font.color, WHITE);
assert_eq!(g[0][2].borders.top, line);
assert_eq!(g[0][0].borders.left, line, "the sides run down the header too");
assert_eq!(g[3][0].borders.left, line);
assert_eq!(g[3][4].borders.right, line);
assert_eq!(g[5][2].borders.bottom, line);
assert_eq!(g[0][2].borders.bottom, NONE, "no header bottom");
assert_eq!(g[2][2].borders.bottom, NONE, "no inner horizontal");
assert_eq!(g[2][2].borders.right, NONE, "no inner vertical");
assert_eq!(g[1][2].fill.fg, Color::Theme(4, 800));
assert_eq!(g[2][2].fill.pattern, PatternType::None);
}
#[test]
fn medium9_has_white_verticals_and_header_bottom() {
let g = grid("Medium9");
assert_eq!(g[0][1].borders.bottom, thin(WHITE));
assert_eq!(g[0][1].borders.right, thin(WHITE));
assert_eq!(g[3][1].borders.right, thin(WHITE));
assert_eq!(g[3][1].borders.bottom, NONE);
assert_eq!(g[3][0].borders.left, NONE, "no frame");
assert_eq!(g[5][4].borders.bottom, NONE, "no frame");
assert_eq!(g[1][0].fill.fg, Color::Theme(4, 600));
assert_eq!(g[2][0].fill.fg, Color::Theme(4, 800));
}
#[test]
fn dark2_bands_in_shaded_and_full_accent_under_a_black_header() {
let g = grid("Dark2");
assert_eq!(g[0][0].fill.fg, BLACK);
assert_eq!(g[0][0].borders.bottom, thin(WHITE));
assert_eq!(g[1][0].fill.fg, Color::Theme(4, -250));
assert_eq!(g[2][0].fill.fg, Color::Theme(4, 0));
assert_eq!(g[2][0].font.color, WHITE);
assert_eq!(g[2][0].borders, Borders::default());
}
#[test]
fn dark9_pairs_two_accents() {
let g = grid("Dark9");
assert_eq!(g[0][0].fill.fg, Color::Theme(5, 0));
assert_eq!(g[0][0].font.color, WHITE);
assert_eq!(g[1][0].fill.fg, Color::Theme(4, 600));
assert_eq!(g[2][0].fill.fg, Color::Theme(4, 800));
assert_eq!(g[2][0].font.color, BLACK);
let g = grid("Dark11");
assert_eq!(g[0][0].fill.fg, Color::Theme(9, 0));
assert_eq!(g[1][0].fill.fg, Color::Theme(8, 600));
}
#[test]
fn table_options_change_the_look() {
let s = session();
// Banded rows off: every data row looks like the second band.
let g = grid_with(&s, "Medium9", |t| t.banded_rows = false);
assert_eq!(g[1][0].fill.fg, Color::Theme(4, 800));
assert_eq!(g[2][0].fill.fg, Color::Theme(4, 800));
// Banded columns alternate by column.
let g = grid_with(&s, "Medium9", |t| {
t.banded_rows = false;
t.banded_cols = true;
});
assert_eq!(g[2][0].fill.fg, Color::Theme(4, 600));
assert_eq!(g[2][1].fill.fg, Color::Theme(4, 800));
// Header off: the top line moves to the first data row, and nothing is drawn as a header.
let g = grid_with(&s, "Light15", |t| t.header_row = false);
assert_eq!(g[0][2].borders.top, thin(BLACK));
assert_eq!(g[0][2].borders.bottom, NONE);
assert!(!g[0][2].font.bold);
// Totals row: bold, double top rule, no banding.
let g = grid_with(&s, "Medium2", |t| t.totals_row = true);
assert!(g[5][1].font.bold);
assert_eq!(g[5][1].borders.top, BorderLine { style: BorderStyle::Double, color: Color::Theme(4, 0) });
assert_eq!(g[5][1].borders.bottom, thin(Color::Theme(4, 400)));
// First and last column bold.
let g = grid_with(&s, "Medium2", |t| {
t.first_col = true;
t.last_col = true;
});
assert!(g[2][0].font.bold && g[2][4].font.bold && !g[2][2].font.bold);
}
#[test]
fn explicit_formatting_wins() {
let mut s = session();
s.execute("home.fillColor", json!({"range": "B3", "color": "#FF0000"})).unwrap();
s.execute("home.fontColor", json!({"range": "B3", "color": "#00FF00"})).unwrap();
s.execute("home.borders", json!({"range": "B3", "preset": "bottom"})).unwrap();
let g = grid_with(&s, "Dark2", |_| {});
assert_eq!(g[2][1].fill, Fill::solid(Color::Rgb(0xFF0000)));
assert_eq!(g[2][1].font.color, Color::Rgb(0x00FF00));
assert_eq!(g[2][1].borders.bottom.style, BorderStyle::Thin);
assert_eq!(g[2][1].borders.bottom.color, Color::Auto);
}
#[test]
fn every_style_name_is_safe() {
for name in ["Light0", "Light99", "Medium0", "Medium4000000000", "Dark0", "Dark12", "Dark99", "Bogus"] {
let _ = grid(name);
}
}
/// What the grid and print draw: like `grid_with`, but through the hidden-row/column aware
/// `table_cell_shown_style`.
fn shown_with(s: &Session, style: &str, edit: impl Fn(&mut Table)) -> Vec<Vec<Style>> {
let wb = &s.doc().unwrap().wb;
let mut t = wb.sheet(0).unwrap().tables[0].clone();
t.style = format!("TableStyle{style}");
edit(&mut t);
let e = shown_edges(wb.sheet(0).unwrap(), &t);
(0..ROWS).map(|r| (0..COLS).map(|c| table_cell_shown_style(wb, 0, &t, e, CellRef::new(r, c))).collect()).collect()
}
#[test]
fn frame_follows_the_last_visible_row_and_column() {
let frame = thin(Color::Theme(4, 400));
// Nothing hidden: the shown look is the table look.
let s = session();
assert_eq!(shown_with(&s, "Medium2", |_| {}), grid_with(&s, "Medium2", |_| {}));
// Last data row (and the one before it) and last column hidden: the frame moves in.
let mut s = session();
s.execute("home.hideRows", json!({"rows": "5:6"})).unwrap();
s.execute("home.hideColumns", json!({"cols": "E:E"})).unwrap();
let t = &s.doc().unwrap().wb.sheet(0).unwrap().tables[0];
assert_eq!(shown_edges(s.doc().unwrap().wb.sheet(0).unwrap(), t), ShownEdges { top: 0, bottom: 3, left: 0, right: 3 });
let g = shown_with(&s, "Medium2", |_| {});
for (c, cell) in g[3].iter().take(4).enumerate() {
assert_eq!(cell.borders.bottom, frame, "bottom frame on row 4, col {c}");
}
for (r, row) in g.iter().take(4).enumerate() {
assert_eq!(row[3].borders.right, frame, "right frame on col D, row {r}");
}
// Rows above the last visible one keep their inner look (Medium 2 has no row lines).
assert_eq!(g[2][1].borders.bottom, NONE);
// Convert to Range and friends still see the table as it is.
assert_eq!(grid_with(&s, "Medium2", |_| {})[3][1].borders.bottom, NONE);
// Header off and the first data row filtered out: the top line moves down.
let mut s = session();
s.execute("home.hideRows", json!({"rows": "1:1"})).unwrap();
s.execute("home.hideColumns", json!({"cols": "A:A"})).unwrap();
let g = shown_with(&s, "Light15", |t| t.header_row = false);
assert_eq!(g[1][2].borders.top, thin(BLACK));
assert_eq!(g[2][1].borders.left, thin(BLACK));
// Explicit borders still win.
let mut s = session();
s.execute("home.borders", json!({"range": "B5", "preset": "none"})).unwrap();
s.execute("home.fillColor", json!({"range": "B5", "color": "#FF0000"})).unwrap();
s.execute("home.borders", json!({"range": "C5", "preset": "bottom"})).unwrap();
s.execute("home.hideRows", json!({"rows": "6:6"})).unwrap();
let g = shown_with(&s, "Medium2", |_| {});
assert_eq!(g[4][1].borders.bottom, frame);
assert_eq!(g[4][2].borders.bottom.color, Color::Auto);
}
+22 -1
View File
@@ -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;
+24
View File
@@ -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(),

Some files were not shown because too many files have changed in this diff Show More