Compare commits
1 Commits
feature/br
...
varum-chan
| Author | SHA1 | Date | |
|---|---|---|---|
|
e7858f7aa9 |
446
.github/workflows/npm.yml
vendored
446
.github/workflows/npm.yml
vendored
@@ -1,446 +0,0 @@
|
||||
name: nodejs
|
||||
env:
|
||||
DEBUG: napi:*
|
||||
APP_NAME: nodejs
|
||||
MACOSX_DEPLOYMENT_TARGET: '10.13'
|
||||
permissions:
|
||||
contents: write
|
||||
id-token: write
|
||||
'on':
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
publish:
|
||||
description: "Publish to npm"
|
||||
required: true
|
||||
type: boolean
|
||||
defaults:
|
||||
run:
|
||||
working-directory: ./bindings/nodejs
|
||||
jobs:
|
||||
build:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
settings:
|
||||
- host: macos-latest
|
||||
target: x86_64-apple-darwin
|
||||
build: yarn build --target x86_64-apple-darwin
|
||||
- host: windows-latest
|
||||
build: yarn build --target x86_64-pc-windows-msvc
|
||||
target: x86_64-pc-windows-msvc
|
||||
- host: ubuntu-latest
|
||||
target: x86_64-unknown-linux-gnu
|
||||
docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian
|
||||
build: yarn build --target x86_64-unknown-linux-gnu
|
||||
- host: ubuntu-latest
|
||||
target: x86_64-unknown-linux-musl
|
||||
docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine
|
||||
build: yarn build --target x86_64-unknown-linux-musl
|
||||
- host: macos-latest
|
||||
target: aarch64-apple-darwin
|
||||
build: yarn build --target aarch64-apple-darwin
|
||||
- host: ubuntu-latest
|
||||
target: aarch64-unknown-linux-gnu
|
||||
docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian-aarch64
|
||||
build: yarn build --target aarch64-unknown-linux-gnu
|
||||
- host: ubuntu-latest
|
||||
target: armv7-unknown-linux-gnueabihf
|
||||
setup: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install gcc-arm-linux-gnueabihf -y
|
||||
build: yarn build --target armv7-unknown-linux-gnueabihf
|
||||
- host: ubuntu-latest
|
||||
target: armv7-unknown-linux-musleabihf
|
||||
build: yarn build --target armv7-unknown-linux-musleabihf
|
||||
- host: ubuntu-latest
|
||||
target: aarch64-linux-android
|
||||
build: yarn build --target aarch64-linux-android
|
||||
- host: ubuntu-latest
|
||||
target: armv7-linux-androideabi
|
||||
build: yarn build --target armv7-linux-androideabi
|
||||
- host: ubuntu-latest
|
||||
target: aarch64-unknown-linux-musl
|
||||
docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine
|
||||
build: |-
|
||||
set -e &&
|
||||
rustup target add aarch64-unknown-linux-musl &&
|
||||
yarn build --target aarch64-unknown-linux-musl
|
||||
- host: windows-latest
|
||||
target: aarch64-pc-windows-msvc
|
||||
build: yarn build --target aarch64-pc-windows-msvc
|
||||
- host: ubuntu-latest
|
||||
target: riscv64gc-unknown-linux-gnu
|
||||
setup: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install gcc-riscv64-linux-gnu -y
|
||||
build: yarn build --target riscv64gc-unknown-linux-gnu
|
||||
name: stable - ${{ matrix.settings.target }} - node@20
|
||||
runs-on: ${{ matrix.settings.host }}
|
||||
defaults:
|
||||
run:
|
||||
working-directory: ./bindings/nodejs
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Setup node
|
||||
uses: actions/setup-node@v4
|
||||
if: ${{ !matrix.settings.docker }}
|
||||
with:
|
||||
node-version: 20
|
||||
cache: yarn
|
||||
cache-dependency-path: "bindings/nodejs"
|
||||
- name: Install
|
||||
uses: dtolnay/rust-toolchain@stable
|
||||
if: ${{ !matrix.settings.docker }}
|
||||
with:
|
||||
toolchain: stable
|
||||
targets: ${{ matrix.settings.target }}
|
||||
- name: Cache cargo
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: |
|
||||
~/.cargo/registry/index/
|
||||
~/.cargo/registry/cache/
|
||||
~/.cargo/git/db/
|
||||
.cargo-cache
|
||||
target/
|
||||
key: ${{ matrix.settings.target }}-cargo-${{ matrix.settings.host }}
|
||||
- uses: goto-bus-stop/setup-zig@v2
|
||||
if: ${{ matrix.settings.target == 'armv7-unknown-linux-gnueabihf' || matrix.settings.target == 'armv7-unknown-linux-musleabihf' }}
|
||||
with:
|
||||
version: 0.13.0
|
||||
- name: Setup toolchain
|
||||
run: ${{ matrix.settings.setup }}
|
||||
if: ${{ matrix.settings.setup }}
|
||||
shell: bash
|
||||
- name: Install dependencies
|
||||
run: yarn install
|
||||
- name: Build in docker
|
||||
uses: addnab/docker-run-action@v3
|
||||
if: ${{ matrix.settings.docker }}
|
||||
with:
|
||||
image: ${{ matrix.settings.docker }}
|
||||
options: '--user 0:0 -v ${{ github.workspace }}/.cargo-cache/git/db:/usr/local/cargo/git/db -v ${{ github.workspace }}/.cargo/registry/cache:/usr/local/cargo/registry/cache -v ${{ github.workspace }}/.cargo/registry/index:/usr/local/cargo/registry/index -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
|
||||
run: ${{ matrix.settings.build }}
|
||||
- name: Build
|
||||
run: ${{ matrix.settings.build }}
|
||||
if: ${{ !matrix.settings.docker }}
|
||||
shell: bash
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: bindings-${{ matrix.settings.target }}
|
||||
path: bindings/nodejs/${{ env.APP_NAME }}.*.node
|
||||
if-no-files-found: error
|
||||
test-macOS-windows-binding:
|
||||
name: Test bindings on ${{ matrix.settings.target }} - node@${{ matrix.node }}
|
||||
needs:
|
||||
- build
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
settings:
|
||||
- host: macos-latest
|
||||
target: x86_64-apple-darwin
|
||||
- host: windows-latest
|
||||
target: x86_64-pc-windows-msvc
|
||||
node:
|
||||
- '18'
|
||||
- '20'
|
||||
runs-on: ${{ matrix.settings.host }}
|
||||
defaults:
|
||||
run:
|
||||
working-directory: ./bindings/nodejs
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Setup node
|
||||
uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: ${{ matrix.node }}
|
||||
cache: yarn
|
||||
cache-dependency-path: "bindings/nodejs"
|
||||
architecture: x64
|
||||
- name: Install dependencies
|
||||
run: yarn install
|
||||
- name: Download artifacts
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: bindings-${{ matrix.settings.target }}
|
||||
path: bindings/nodejs/
|
||||
- name: List packages
|
||||
run: ls -R .
|
||||
shell: bash
|
||||
- name: Test bindings
|
||||
run: yarn test
|
||||
test-linux-x64-gnu-binding:
|
||||
name: Test bindings on Linux-x64-gnu - node@${{ matrix.node }}
|
||||
needs:
|
||||
- build
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
node:
|
||||
- '18'
|
||||
- '20'
|
||||
runs-on: ubuntu-latest
|
||||
defaults:
|
||||
run:
|
||||
working-directory: ./bindings/nodejs
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Setup node
|
||||
uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: ${{ matrix.node }}
|
||||
cache: yarn
|
||||
cache-dependency-path: "bindings/nodejs"
|
||||
- name: Install dependencies
|
||||
run: yarn install
|
||||
- name: Download artifacts
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: bindings-x86_64-unknown-linux-gnu
|
||||
path: bindings/nodejs/
|
||||
- name: List packages
|
||||
run: ls -R .
|
||||
shell: bash
|
||||
- name: Test bindings
|
||||
run: docker run --rm -v $(pwd):/build -w /build/bindings/nodejs node:${{ matrix.node }}-slim yarn test
|
||||
test-linux-x64-musl-binding:
|
||||
name: Test bindings on x86_64-unknown-linux-musl - node@${{ matrix.node }}
|
||||
needs:
|
||||
- build
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
node:
|
||||
- '18'
|
||||
- '20'
|
||||
runs-on: ubuntu-latest
|
||||
defaults:
|
||||
run:
|
||||
working-directory: ./bindings/nodejs
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Setup node
|
||||
uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: ${{ matrix.node }}
|
||||
cache: yarn
|
||||
cache-dependency-path: "bindings/nodejs"
|
||||
- name: Install dependencies
|
||||
run: |
|
||||
yarn config set supportedArchitectures.libc "musl"
|
||||
yarn install
|
||||
- name: Download artifacts
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: bindings-x86_64-unknown-linux-musl
|
||||
path: bindings/nodejs/
|
||||
- name: List packages
|
||||
run: ls -R .
|
||||
shell: bash
|
||||
- name: Test bindings
|
||||
run: docker run --rm -v $(pwd):/build -w /build/bindings/nodejs node:${{ matrix.node }}-alpine yarn test
|
||||
test-linux-aarch64-gnu-binding:
|
||||
name: Test bindings on aarch64-unknown-linux-gnu - node@${{ matrix.node }}
|
||||
needs:
|
||||
- build
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
node:
|
||||
- '18'
|
||||
- '20'
|
||||
runs-on: ubuntu-latest
|
||||
defaults:
|
||||
run:
|
||||
working-directory: ./bindings/nodejs
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Download artifacts
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: bindings-aarch64-unknown-linux-gnu
|
||||
path: bindings/nodejs/
|
||||
- name: List packages
|
||||
run: ls -R .
|
||||
shell: bash
|
||||
- name: Install dependencies
|
||||
run: |
|
||||
yarn config set supportedArchitectures.cpu "arm64"
|
||||
yarn config set supportedArchitectures.libc "glibc"
|
||||
yarn install
|
||||
- name: Set up QEMU
|
||||
uses: docker/setup-qemu-action@v3
|
||||
with:
|
||||
platforms: arm64
|
||||
- run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
|
||||
- name: Setup and run tests
|
||||
uses: addnab/docker-run-action@v3
|
||||
with:
|
||||
image: node:${{ matrix.node }}-slim
|
||||
options: '--platform linux/arm64 -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
|
||||
run: |
|
||||
set -e
|
||||
yarn test
|
||||
ls -la
|
||||
test-linux-aarch64-musl-binding:
|
||||
name: Test bindings on aarch64-unknown-linux-musl - node@${{ matrix.node }}
|
||||
needs:
|
||||
- build
|
||||
runs-on: ubuntu-latest
|
||||
defaults:
|
||||
run:
|
||||
working-directory: ./bindings/nodejs
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Download artifacts
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: bindings-aarch64-unknown-linux-musl
|
||||
path: bindings/nodejs/
|
||||
- name: List packages
|
||||
run: ls -R .
|
||||
shell: bash
|
||||
- name: Install dependencies
|
||||
run: |
|
||||
yarn config set supportedArchitectures.cpu "arm64"
|
||||
yarn config set supportedArchitectures.libc "musl"
|
||||
yarn install
|
||||
- name: Set up QEMU
|
||||
uses: docker/setup-qemu-action@v3
|
||||
with:
|
||||
platforms: arm64
|
||||
- run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
|
||||
- name: Setup and run tests
|
||||
uses: addnab/docker-run-action@v3
|
||||
with:
|
||||
image: node:lts-alpine
|
||||
options: '--platform linux/arm64 -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
|
||||
run: |
|
||||
set -e
|
||||
yarn test
|
||||
test-linux-arm-gnueabihf-binding:
|
||||
name: Test bindings on armv7-unknown-linux-gnueabihf - node@${{ matrix.node }}
|
||||
needs:
|
||||
- build
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
node:
|
||||
- '18'
|
||||
- '20'
|
||||
runs-on: ubuntu-latest
|
||||
defaults:
|
||||
run:
|
||||
working-directory: ./bindings/nodejs
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Download artifacts
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: bindings-armv7-unknown-linux-gnueabihf
|
||||
path: bindings/nodejs/
|
||||
- name: List packages
|
||||
run: ls -R .
|
||||
shell: bash
|
||||
- name: Install dependencies
|
||||
run: |
|
||||
yarn config set supportedArchitectures.cpu "arm"
|
||||
yarn install
|
||||
- name: Set up QEMU
|
||||
uses: docker/setup-qemu-action@v3
|
||||
with:
|
||||
platforms: arm
|
||||
- run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
|
||||
- name: Setup and run tests
|
||||
uses: addnab/docker-run-action@v3
|
||||
with:
|
||||
image: node:${{ matrix.node }}-bullseye-slim
|
||||
options: '--platform linux/arm/v7 -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
|
||||
run: |
|
||||
set -e
|
||||
yarn test
|
||||
ls -la
|
||||
universal-macOS:
|
||||
name: Build universal macOS binary
|
||||
needs:
|
||||
- build
|
||||
runs-on: macos-latest
|
||||
defaults:
|
||||
run:
|
||||
working-directory: ./bindings/nodejs
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Setup node
|
||||
uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: 20
|
||||
cache: yarn
|
||||
cache-dependency-path: "bindings/nodejs"
|
||||
- name: Install dependencies
|
||||
run: yarn install
|
||||
- name: Download macOS x64 artifact
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: bindings-x86_64-apple-darwin
|
||||
path: bindings/nodejs/artifacts
|
||||
- name: Download macOS arm64 artifact
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: bindings-aarch64-apple-darwin
|
||||
path: bindings/nodejs/artifacts
|
||||
- name: Combine binaries
|
||||
run: yarn universal
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: bindings-universal-apple-darwin
|
||||
path: bindings/nodejs/${{ env.APP_NAME }}.*.node
|
||||
if-no-files-found: error
|
||||
publish:
|
||||
name: Publish
|
||||
runs-on: ubuntu-latest
|
||||
defaults:
|
||||
run:
|
||||
working-directory: ./bindings/nodejs
|
||||
needs:
|
||||
- test-macOS-windows-binding
|
||||
- test-linux-x64-gnu-binding
|
||||
- test-linux-x64-musl-binding
|
||||
- test-linux-aarch64-gnu-binding
|
||||
- test-linux-aarch64-musl-binding
|
||||
- test-linux-arm-gnueabihf-binding
|
||||
- universal-macOS
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Setup node
|
||||
uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: 20
|
||||
cache: yarn
|
||||
cache-dependency-path: "bindings/nodejs"
|
||||
- name: Install dependencies
|
||||
run: yarn install
|
||||
- name: Download all artifacts
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
path: bindings/nodejs/artifacts
|
||||
- name: Move artifacts
|
||||
run: yarn artifacts
|
||||
- name: List packages
|
||||
run: ls -R ./npm
|
||||
shell: bash
|
||||
- name: Publish
|
||||
run: |
|
||||
echo "${{ github.event.inputs.publish }}"
|
||||
if [ "${{ github.event.inputs.publish }}" = "true" ]; then
|
||||
echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" >> ~/.npmrc
|
||||
npm publish --access public
|
||||
echo "Published to npm"
|
||||
else
|
||||
echo "Not a release, skipping publish"
|
||||
fi
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
|
||||
141
.github/workflows/pypi.yml
vendored
141
.github/workflows/pypi.yml
vendored
@@ -1,141 +0,0 @@
|
||||
name: Upload component to Python Package Index
|
||||
|
||||
on:
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
release:
|
||||
type: boolean
|
||||
default: false
|
||||
required: false
|
||||
description: "Release? If false, publish to test.pypi.org, if true, publish to pypi.org"
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
linux:
|
||||
runs-on: ubuntu-latest
|
||||
strategy:
|
||||
matrix:
|
||||
target: [x86_64, x86, aarch64, armv7, s390x, ppc64le]
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- uses: actions/setup-python@v4
|
||||
with:
|
||||
python-version: '3.10'
|
||||
- name: Build wheels
|
||||
uses: PyO3/maturin-action@v1
|
||||
with:
|
||||
target: ${{ matrix.target }}
|
||||
args: --release --out dist --find-interpreter
|
||||
sccache: 'true'
|
||||
manylinux: auto
|
||||
working-directory: bindings/python
|
||||
- name: Upload wheels
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: wheels-${{ runner.os }}-${{ matrix.target }}
|
||||
path: bindings/python/dist
|
||||
|
||||
windows:
|
||||
runs-on: windows-latest
|
||||
strategy:
|
||||
matrix:
|
||||
target: [x64, x86]
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- uses: actions/setup-python@v4
|
||||
with:
|
||||
python-version: '3.10'
|
||||
architecture: ${{ matrix.target }}
|
||||
- name: Build wheels
|
||||
uses: PyO3/maturin-action@v1
|
||||
with:
|
||||
target: ${{ matrix.target }}
|
||||
args: --release --out dist --find-interpreter
|
||||
sccache: 'true'
|
||||
working-directory: bindings/python
|
||||
- name: Upload wheels
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: wheels-${{ runner.os }}-${{ matrix.target }}
|
||||
path: bindings/python/dist
|
||||
|
||||
macos:
|
||||
runs-on: macos-latest
|
||||
strategy:
|
||||
matrix:
|
||||
target: [x86_64, aarch64]
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- uses: actions/setup-python@v4
|
||||
with:
|
||||
python-version: '3.10'
|
||||
- name: Build wheels
|
||||
uses: PyO3/maturin-action@v1
|
||||
with:
|
||||
target: ${{ matrix.target }}
|
||||
args: --release --out dist --find-interpreter
|
||||
sccache: 'true'
|
||||
working-directory: bindings/python
|
||||
- name: Upload wheels
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: wheels-${{ runner.os }}-${{ matrix.target }}
|
||||
path: bindings/python/dist
|
||||
|
||||
sdist:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- name: Build sdist
|
||||
uses: PyO3/maturin-action@v1
|
||||
with:
|
||||
command: sdist
|
||||
args: --out dist
|
||||
working-directory: bindings/python
|
||||
- name: Upload sdist
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: wheels-${{ runner.os }}-sdist
|
||||
path: bindings/python/dist
|
||||
|
||||
publish-to-test-pypi:
|
||||
if: ${{ github.event.inputs.release != 'true' }}
|
||||
name: >-
|
||||
Publish Python 🐍 distribution 📦 to Test PyPI
|
||||
runs-on: ubuntu-latest
|
||||
needs: [linux, windows, macos, sdist]
|
||||
steps:
|
||||
- uses: actions/download-artifact@v4
|
||||
with:
|
||||
path: bindings/python/
|
||||
- name: Publish distribution 📦 to Test PyPI
|
||||
uses: PyO3/maturin-action@v1
|
||||
env:
|
||||
MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_TEST_API_TOKEN }}
|
||||
MATURIN_REPOSITORY_URL: "https://test.pypi.org/legacy/"
|
||||
with:
|
||||
command: upload
|
||||
args: "--skip-existing **/*.whl **/*.tar.gz"
|
||||
working-directory: bindings/python
|
||||
|
||||
publish-pypi:
|
||||
if: ${{ github.event.inputs.release == 'true' }}
|
||||
name: >-
|
||||
Publish Python 🐍 distribution 📦 to PyPI
|
||||
runs-on: ubuntu-latest
|
||||
needs: [linux, windows, macos, sdist]
|
||||
steps:
|
||||
- uses: actions/download-artifact@v4
|
||||
with:
|
||||
path: bindings/python/
|
||||
- name: Publish distribution 📦 to PyPI
|
||||
uses: PyO3/maturin-action@v1
|
||||
env:
|
||||
MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
|
||||
MATURIN_REPOSITORY_URL: "https://upload.pypi.org/legacy/"
|
||||
with:
|
||||
command: upload
|
||||
args: "--skip-existing **/*.whl **/*.tar.gz"
|
||||
working-directory: bindings/python
|
||||
10
.github/workflows/test-coverage.yaml
vendored
10
.github/workflows/test-coverage.yaml
vendored
@@ -1,7 +1,10 @@
|
||||
name: Coverage
|
||||
|
||||
on:
|
||||
workflow_dispatch:
|
||||
pull_request:
|
||||
push:
|
||||
branches:
|
||||
- main
|
||||
|
||||
jobs:
|
||||
coverage:
|
||||
@@ -17,9 +20,8 @@ jobs:
|
||||
- name: Generate code coverage
|
||||
run: cargo llvm-cov --all-features --workspace --exclude pyroncalc --exclude wasm --lcov --output-path lcov.info
|
||||
- name: Upload coverage to Codecov
|
||||
uses: codecov/codecov-action@v5
|
||||
env:
|
||||
CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
|
||||
uses: codecov/codecov-action@v3
|
||||
with:
|
||||
token: ${{ secrets.CODECOV_TOKEN }}
|
||||
files: lcov.info
|
||||
fail_ci_if_error: true
|
||||
|
||||
3
.gitignore
vendored
3
.gitignore
vendored
@@ -1,3 +1,2 @@
|
||||
target/*
|
||||
**/node_modules/**
|
||||
.DS_Store
|
||||
.DS_Store
|
||||
10
CHANGELOG.md
10
CHANGELOG.md
@@ -7,21 +7,11 @@
|
||||
- New function UNICODE ([#128](https://github.com/ironcalc/IronCalc/pull/128))
|
||||
- New document server (Thanks Dani!)
|
||||
- New function FORMULATEXT
|
||||
- Name Manager ([#212](https://github.com/ironcalc/IronCalc/pull/212) [#220](https://github.com/ironcalc/IronCalc/pull/220))
|
||||
- Add context menu. We can now insert rows and columns. Freeze and unfreeze rows and columns. Delete rows and columns [#271]
|
||||
- Add nodejs bindings [#254]
|
||||
- Add python bindings for all platforms
|
||||
- Add is split into the product and widget
|
||||
- Add Python documentation [#260]
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fixed several issues with pasting content
|
||||
- Fixed several issues with borders
|
||||
- Fixed bug where columns and rows could be resized to negative width and height, respectively
|
||||
- Undo/redo when add/delete sheet now works [#270]
|
||||
- Numerous small fixes
|
||||
- Multiple fixes to the documentation
|
||||
|
||||
## [0.2.0] - 2024-11-06 (The HN release)
|
||||
|
||||
|
||||
184
Cargo.lock
generated
184
Cargo.lock
generated
@@ -85,12 +85,6 @@ dependencies = [
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bitflags"
|
||||
version = "2.8.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8f68f53c83ab957f72c32642f3868eec03eb974d1fb82e453128456482613d36"
|
||||
|
||||
[[package]]
|
||||
name = "block-buffer"
|
||||
version = "0.10.4"
|
||||
@@ -216,15 +210,6 @@ version = "0.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
|
||||
|
||||
[[package]]
|
||||
name = "convert_case"
|
||||
version = "0.6.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
|
||||
dependencies = [
|
||||
"unicode-segmentation",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "core-foundation-sys"
|
||||
version = "0.8.6"
|
||||
@@ -286,16 +271,6 @@ dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ctor"
|
||||
version = "0.2.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "32a2785755761f3ddc1492979ce1e48d2c00d09311c39e4466429188f3dd6501"
|
||||
dependencies = [
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "deranged"
|
||||
version = "0.3.11"
|
||||
@@ -414,7 +389,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ironcalc"
|
||||
version = "0.6.0"
|
||||
version = "0.2.0"
|
||||
dependencies = [
|
||||
"bitcode",
|
||||
"chrono",
|
||||
@@ -430,13 +405,14 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ironcalc_base"
|
||||
version = "0.6.0"
|
||||
version = "0.2.0"
|
||||
dependencies = [
|
||||
"bitcode",
|
||||
"chrono",
|
||||
"chrono-tz",
|
||||
"csv",
|
||||
"js-sys",
|
||||
"once_cell",
|
||||
"rand",
|
||||
"regex",
|
||||
"regex-lite",
|
||||
@@ -445,17 +421,6 @@ dependencies = [
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ironcalc_nodejs"
|
||||
version = "0.6.0"
|
||||
dependencies = [
|
||||
"ironcalc",
|
||||
"napi",
|
||||
"napi-build",
|
||||
"napi-derive",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itertools"
|
||||
version = "0.12.1"
|
||||
@@ -495,16 +460,6 @@ version = "0.2.153"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
|
||||
|
||||
[[package]]
|
||||
name = "libloading"
|
||||
version = "0.8.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"windows-targets",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "log"
|
||||
version = "0.4.21"
|
||||
@@ -535,65 +490,6 @@ dependencies = [
|
||||
"adler",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "napi"
|
||||
version = "2.16.13"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "214f07a80874bb96a8433b3cdfc84980d56c7b02e1a0d7ba4ba0db5cef785e2b"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"ctor",
|
||||
"napi-derive",
|
||||
"napi-sys",
|
||||
"once_cell",
|
||||
"serde",
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "napi-build"
|
||||
version = "2.1.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "db836caddef23662b94e16bf1f26c40eceb09d6aee5d5b06a7ac199320b69b19"
|
||||
|
||||
[[package]]
|
||||
name = "napi-derive"
|
||||
version = "2.16.13"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7cbe2585d8ac223f7d34f13701434b9d5f4eb9c332cccce8dee57ea18ab8ab0c"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"convert_case",
|
||||
"napi-derive-backend",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "napi-derive-backend"
|
||||
version = "1.0.75"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1639aaa9eeb76e91c6ae66da8ce3e89e921cd3885e99ec85f4abacae72fc91bf"
|
||||
dependencies = [
|
||||
"convert_case",
|
||||
"once_cell",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"regex",
|
||||
"semver",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "napi-sys"
|
||||
version = "2.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "427802e8ec3a734331fec1035594a210ce1ff4dc5bc1950530920ab717964ea3"
|
||||
dependencies = [
|
||||
"libloading",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-conv"
|
||||
version = "0.1.0"
|
||||
@@ -720,10 +616,11 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyo3"
|
||||
version = "0.25.0"
|
||||
version = "0.22.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f239d656363bcee73afef85277f1b281e8ac6212a1d42aa90e55b90ed43c47a4"
|
||||
checksum = "15ee168e30649f7f234c3d49ef5a7a6cbf5134289bc46c29ff3155fa3221c225"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"indoc",
|
||||
"libc",
|
||||
"memoffset",
|
||||
@@ -737,9 +634,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyo3-build-config"
|
||||
version = "0.25.0"
|
||||
version = "0.22.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "755ea671a1c34044fa165247aaf6f419ca39caa6003aee791a0df2713d8f1b6d"
|
||||
checksum = "e61cef80755fe9e46bb8a0b8f20752ca7676dcc07a5277d8b7768c6172e529b3"
|
||||
dependencies = [
|
||||
"once_cell",
|
||||
"target-lexicon",
|
||||
@@ -747,9 +644,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyo3-ffi"
|
||||
version = "0.25.0"
|
||||
version = "0.22.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fc95a2e67091e44791d4ea300ff744be5293f394f1bafd9f78c080814d35956e"
|
||||
checksum = "67ce096073ec5405f5ee2b8b31f03a68e02aa10d5d4f565eca04acc41931fa1c"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"pyo3-build-config",
|
||||
@@ -757,9 +654,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyo3-macros"
|
||||
version = "0.25.0"
|
||||
version = "0.22.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a179641d1b93920829a62f15e87c0ed791b6c8db2271ba0fd7c2686090510214"
|
||||
checksum = "2440c6d12bc8f3ae39f1e775266fa5122fd0c8891ce7520fa6048e683ad3de28"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"pyo3-macros-backend",
|
||||
@@ -769,9 +666,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyo3-macros-backend"
|
||||
version = "0.25.0"
|
||||
version = "0.22.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9dff85ebcaab8c441b0e3f7ae40a6963ecea8a9f5e74f647e33fcf5ec9a1e89e"
|
||||
checksum = "1be962f0e06da8f8465729ea2cb71a416d2257dff56cbe40a70d3e62a93ae5d1"
|
||||
dependencies = [
|
||||
"heck",
|
||||
"proc-macro2",
|
||||
@@ -782,9 +679,8 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyroncalc"
|
||||
version = "0.6.0"
|
||||
version = "0.1.2"
|
||||
dependencies = [
|
||||
"bitcode",
|
||||
"ironcalc",
|
||||
"pyo3",
|
||||
"serde",
|
||||
@@ -871,12 +767,6 @@ version = "0.19.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3cd14fd5e3b777a7422cca79358c57a8f6e3a703d9ac187448d0daf220c2407f"
|
||||
|
||||
[[package]]
|
||||
name = "rustversion"
|
||||
version = "1.0.21"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d"
|
||||
|
||||
[[package]]
|
||||
name = "ryu"
|
||||
version = "1.0.17"
|
||||
@@ -889,12 +779,6 @@ version = "1.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
|
||||
|
||||
[[package]]
|
||||
name = "semver"
|
||||
version = "1.0.25"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f79dfe2d285b0488816f30e700a7438c5a73d816b5b7d3ac72fbc48b0d185e03"
|
||||
|
||||
[[package]]
|
||||
name = "serde"
|
||||
version = "1.0.197"
|
||||
@@ -984,9 +868,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "target-lexicon"
|
||||
version = "0.13.2"
|
||||
version = "0.12.16"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
|
||||
checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
|
||||
|
||||
[[package]]
|
||||
name = "thiserror"
|
||||
@@ -1039,12 +923,6 @@ version = "1.0.12"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
|
||||
|
||||
[[package]]
|
||||
name = "unicode-segmentation"
|
||||
version = "1.12.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
|
||||
|
||||
[[package]]
|
||||
name = "unindent"
|
||||
version = "0.2.3"
|
||||
@@ -1075,7 +953,7 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
|
||||
|
||||
[[package]]
|
||||
name = "wasm"
|
||||
version = "0.6.0"
|
||||
version = "0.1.3"
|
||||
dependencies = [
|
||||
"ironcalc_base",
|
||||
"serde",
|
||||
@@ -1086,24 +964,23 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen"
|
||||
version = "0.2.100"
|
||||
version = "0.2.92"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
|
||||
checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"once_cell",
|
||||
"rustversion",
|
||||
"wasm-bindgen-macro",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-backend"
|
||||
version = "0.2.100"
|
||||
version = "0.2.92"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
|
||||
checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
|
||||
dependencies = [
|
||||
"bumpalo",
|
||||
"log",
|
||||
"once_cell",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
@@ -1124,9 +1001,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-macro"
|
||||
version = "0.2.100"
|
||||
version = "0.2.92"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
|
||||
checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
|
||||
dependencies = [
|
||||
"quote",
|
||||
"wasm-bindgen-macro-support",
|
||||
@@ -1134,9 +1011,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-macro-support"
|
||||
version = "0.2.100"
|
||||
version = "0.2.92"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
|
||||
checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
@@ -1147,12 +1024,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-shared"
|
||||
version = "0.2.100"
|
||||
version = "0.2.92"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
|
||||
dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-test"
|
||||
|
||||
@@ -6,12 +6,10 @@ members = [
|
||||
"xlsx",
|
||||
"bindings/wasm",
|
||||
"bindings/python",
|
||||
"bindings/nodejs",
|
||||
]
|
||||
|
||||
exclude = [
|
||||
"generate_locale",
|
||||
"webapp/app.ironcalc.com/server",
|
||||
]
|
||||
|
||||
[profile.release]
|
||||
|
||||
93
Dockerfile
93
Dockerfile
@@ -1,93 +0,0 @@
|
||||
FROM rust:latest AS builder
|
||||
|
||||
WORKDIR /app
|
||||
COPY . .
|
||||
|
||||
# Tools + wasm toolchain + Node via nvm
|
||||
RUN apt-get update && apt-get install -y --no-install-recommends \
|
||||
bash curl ca-certificates make \
|
||||
&& rustup target add wasm32-unknown-unknown \
|
||||
&& cargo install wasm-pack \
|
||||
&& bash -lc "curl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash -" \
|
||||
&& bash -lc '\
|
||||
export NVM_DIR="$HOME/.nvm" && \
|
||||
source "$NVM_DIR/nvm.sh" && \
|
||||
nvm install 22 && nvm alias default 22 && \
|
||||
nroot="$NVM_DIR/versions/node/$(nvm version default)/bin" && \
|
||||
ln -sf "$nroot/node" /usr/local/bin/node && \
|
||||
ln -sf "$nroot/npm" /usr/local/bin/npm && \
|
||||
ln -sf "$nroot/npx" /usr/local/bin/npx \
|
||||
' \
|
||||
&& npm install typescript \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
|
||||
# build the server
|
||||
RUN cargo build --release --manifest-path webapp/app.ironcalc.com/server/Cargo.toml
|
||||
|
||||
# build the wasm
|
||||
RUN make -C bindings/wasm
|
||||
|
||||
# build the widget
|
||||
WORKDIR /app/webapp/IronCalc
|
||||
RUN npm install && npm run build
|
||||
|
||||
# build the frontend app
|
||||
WORKDIR /app/webapp/app.ironcalc.com/frontend
|
||||
RUN npm install && npm run build
|
||||
|
||||
# build the xlsx_2_icalc binary (we don't need the release version here)
|
||||
WORKDIR /app/xlsx
|
||||
RUN cargo build
|
||||
|
||||
WORKDIR /app
|
||||
# copy the artifacts to a dist/ directory
|
||||
RUN mkdir dist
|
||||
RUN mkdir dist/frontend
|
||||
RUN cp -r webapp/app.ironcalc.com/frontend/dist/* dist/frontend/
|
||||
RUN mkdir dist/server
|
||||
RUN cp webapp/app.ironcalc.com/server/target/release/ironcalc_server dist/server/
|
||||
RUN cp webapp/app.ironcalc.com/server/Rocket.toml dist/server/
|
||||
RUN cp webapp/app.ironcalc.com/server/ironcalc.sqlite dist/server/
|
||||
|
||||
# Create ic files in docs
|
||||
RUN mkdir -p dist/frontend/models
|
||||
|
||||
# Loop over all xlsx files in xlsx/tests/docs & templates and convert them to .ic
|
||||
RUN bash -lc 'set -euo pipefail; \
|
||||
mkdir -p dist/frontend/models; \
|
||||
shopt -s nullglob; \
|
||||
for xlsx_file in xlsx/tests/docs/*.xlsx; do \
|
||||
base_name="${xlsx_file##*/}"; base_name="${base_name%.xlsx}"; \
|
||||
./target/debug/xlsx_2_icalc "$xlsx_file" "dist/frontend/models/${base_name}.ic"; \
|
||||
done; \
|
||||
for xlsx_file in xlsx/tests/templates/*.xlsx; do \
|
||||
base_name="${xlsx_file##*/}"; base_name="${base_name%.xlsx}"; \
|
||||
./target/debug/xlsx_2_icalc "$xlsx_file" "dist/frontend/models/${base_name}.ic"; \
|
||||
done'
|
||||
|
||||
# ---------- server runtime ----------
|
||||
FROM debian:bookworm-slim AS server-runtime
|
||||
RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates && \
|
||||
rm -rf /var/lib/apt/lists/*
|
||||
WORKDIR /app
|
||||
# Copy EVERYTHING you put in dist/server (binary + Rocket.toml + DB)
|
||||
COPY --from=builder /app/dist/server/ ./
|
||||
# Make sure Rocket binds to the container IP; explicitly point to the config file
|
||||
ENV ROCKET_ADDRESS=0.0.0.0 \
|
||||
ROCKET_PORT=8000 \
|
||||
ROCKET_CONFIG=/app/Rocket.toml
|
||||
EXPOSE 8000
|
||||
# Run from /app so relative paths in Rocket.toml/DB work
|
||||
CMD ["./ironcalc_server"]
|
||||
|
||||
# ---------- caddy runtime (serves frontend + reverse-proxy /api) ----------
|
||||
FROM caddy:latest AS caddy-runtime
|
||||
|
||||
WORKDIR /srv
|
||||
|
||||
# Copy the frontend build output to /srv
|
||||
COPY --from=builder /app/dist/frontend/ /srv/
|
||||
|
||||
# Copy the Caddyfile
|
||||
COPY --from=builder /app/webapp/app.ironcalc.com/Caddyfile.compose /etc/caddy/Caddyfile
|
||||
|
||||
6
Makefile
6
Makefile
@@ -2,8 +2,7 @@
|
||||
lint:
|
||||
cargo fmt -- --check
|
||||
cargo clippy --all-targets --all-features -- -W clippy::unwrap_used -W clippy::expect_used -W clippy::panic -D warnings
|
||||
cd webapp/IronCalc/ && npm install && npm run check
|
||||
cd webapp/app.ironcalc.com/frontend/ && npm install && npm run check
|
||||
cd webapp && npm install && npm run check
|
||||
|
||||
.PHONY: format
|
||||
format:
|
||||
@@ -11,12 +10,11 @@ format:
|
||||
|
||||
.PHONY: tests
|
||||
tests: lint
|
||||
cargo test
|
||||
make remove-artifacts
|
||||
# Regretabbly we need to build the wasm twice, once for the nodejs tests
|
||||
# and a second one for the vitest.
|
||||
cd bindings/wasm/ && wasm-pack build --target nodejs && node tests/test.mjs && make
|
||||
cd webapp/IronCalc/ && npm run test
|
||||
cd webapp && npm run test
|
||||
cd bindings/python && ./run_tests.sh && ./run_examples.sh
|
||||
|
||||
.PHONY: remove-artifacts
|
||||
|
||||
16
README.md
16
README.md
@@ -31,17 +31,7 @@ This repository contains the main engine and the xlsx reader and writer.
|
||||
|
||||
Programmed in Rust, you will be able to use it from a variety of programming languages like Python, JavaScript (wasm), nodejs and possibly R, Julia or Go.
|
||||
|
||||
We will build different _skins_: in the terminal, as a desktop application or use it in your own web application.
|
||||
|
||||
# Docker
|
||||
|
||||
If you have docker installed just run:
|
||||
|
||||
```bash
|
||||
docker compose up --build
|
||||
```
|
||||
|
||||
head over to <http://localhost:2080> to test the application.
|
||||
We will build different _skins_: in the terminal, as a desktop application or use it in you own web application.
|
||||
|
||||
# Building
|
||||
|
||||
@@ -87,14 +77,14 @@ And visit <http://0.0.0.0:8000/ironcalc/>
|
||||
Add the dependency to `Cargo.toml`:
|
||||
```toml
|
||||
[dependencies]
|
||||
ironcalc = { git = "https://github.com/ironcalc/IronCalc", version = "0.5"}
|
||||
ironcalc = { git = "https://github.com/ironcalc/IronCalc", version = "0.1"}
|
||||
```
|
||||
|
||||
And then use this code in `main.rs`:
|
||||
|
||||
```rust
|
||||
use ironcalc::{
|
||||
base::{expressions::utils::number_to_column, Model},
|
||||
base::{expressions::utils::number_to_column, model::Model},
|
||||
export::save_to_xlsx,
|
||||
};
|
||||
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 8.1 KiB After Width: | Height: | Size: 5.1 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 18 KiB After Width: | Height: | Size: 15 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 7.4 KiB After Width: | Height: | Size: 4.7 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 538 B After Width: | Height: | Size: 441 B |
Binary file not shown.
|
Before Width: | Height: | Size: 1019 B After Width: | Height: | Size: 729 B |
Binary file not shown.
|
Before Width: | Height: | Size: 15 KiB After Width: | Height: | Size: 15 KiB |
BIN
assets/logo.png
BIN
assets/logo.png
Binary file not shown.
|
Before Width: | Height: | Size: 18 KiB After Width: | Height: | Size: 33 KiB |
@@ -1,11 +1,11 @@
|
||||
[package]
|
||||
name = "ironcalc_base"
|
||||
version = "0.6.0"
|
||||
version = "0.2.0"
|
||||
authors = ["Nicolás Hatcher <nicolas@theuniverse.today>"]
|
||||
edition = "2021"
|
||||
homepage = "https://www.ironcalc.com"
|
||||
repository = "https://github.com/ironcalc/ironcalc/"
|
||||
description = "Open source spreadsheet engine"
|
||||
description = "The democratization of spreadsheets"
|
||||
license = "MIT OR Apache-2.0"
|
||||
readme = "README.md"
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
@@ -17,6 +17,7 @@ chrono = "0.4"
|
||||
chrono-tz = "0.10"
|
||||
regex = { version = "1.0", optional = true}
|
||||
regex-lite = { version = "0.1.6", optional = true}
|
||||
once_cell = "1.16.0"
|
||||
bitcode = "0.6.3"
|
||||
csv = "1.3.0"
|
||||
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
use crate::constants::{LAST_COLUMN, LAST_ROW};
|
||||
use crate::expressions::parser::stringify::{to_string, to_string_displaced, DisplaceData};
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
use crate::expressions::parser::stringify::DisplaceData;
|
||||
use crate::model::Model;
|
||||
|
||||
// NOTE: There is a difference with Excel behaviour when deleting cells/rows/columns
|
||||
@@ -9,45 +8,16 @@ use crate::model::Model;
|
||||
// I feel this is unimportant for now.
|
||||
|
||||
impl Model {
|
||||
fn shift_cell_formula(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
column: i32,
|
||||
displace_data: &DisplaceData,
|
||||
) -> Result<(), String> {
|
||||
if let Some(f) = self
|
||||
.workbook
|
||||
.worksheet(sheet)?
|
||||
.cell(row, column)
|
||||
.and_then(|c| c.get_formula())
|
||||
{
|
||||
let node = &self.parsed_formulas[sheet as usize][f as usize].clone();
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: self.workbook.worksheets[sheet as usize].get_name(),
|
||||
row,
|
||||
column,
|
||||
};
|
||||
// FIXME: This is not a very performant way if the formula has changed :S.
|
||||
let formula = to_string(node, &cell_reference);
|
||||
let formula_displaced = to_string_displaced(node, &cell_reference, displace_data);
|
||||
if formula != formula_displaced {
|
||||
self.update_cell_with_formula(sheet, row, column, format!("={formula_displaced}"))?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
/// This function iterates over all cells in the model and shifts their formulas according to the displacement data.
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `displace_data` - A reference to `DisplaceData` describing the displacement's direction and magnitude.
|
||||
fn displace_cells(&mut self, displace_data: &DisplaceData) -> Result<(), String> {
|
||||
fn displace_cells(&mut self, displace_data: &DisplaceData) {
|
||||
let cells = self.get_all_cells();
|
||||
for cell in cells {
|
||||
self.shift_cell_formula(cell.index, cell.row, cell.column, displace_data)?;
|
||||
self.shift_cell_formula(cell.index, cell.row, cell.column, displace_data);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Retrieves the column indices for a specific row in a given sheet, sorted in ascending or descending order.
|
||||
@@ -164,34 +134,7 @@ impl Model {
|
||||
column,
|
||||
delta: column_count,
|
||||
}),
|
||||
)?;
|
||||
|
||||
// In the list of columns:
|
||||
// * Keep all the columns to the left
|
||||
// * Displace all the columns to the right
|
||||
|
||||
let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
|
||||
|
||||
let mut new_columns = Vec::new();
|
||||
for col in worksheet.cols.iter_mut() {
|
||||
// range under study
|
||||
let min = col.min;
|
||||
let max = col.max;
|
||||
if column > max {
|
||||
// If the range under study is to our left, this is a noop
|
||||
} else if column <= min {
|
||||
// If the range under study is to our right, we displace it
|
||||
col.min = min + column_count;
|
||||
col.max = max + column_count;
|
||||
} else {
|
||||
// If the range under study is in the middle we augment it
|
||||
col.max = max + column_count;
|
||||
}
|
||||
new_columns.push(col.clone());
|
||||
}
|
||||
// TODO: If in a row the cell to the right and left have the same style we should copy it
|
||||
|
||||
worksheet.cols = new_columns;
|
||||
);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@@ -212,12 +155,6 @@ impl Model {
|
||||
if column_count <= 0 {
|
||||
return Err("Please use insert columns instead".to_string());
|
||||
}
|
||||
if !(1..=LAST_COLUMN).contains(&column) {
|
||||
return Err(format!("Column number '{column}' is not valid."));
|
||||
}
|
||||
if column + column_count - 1 > LAST_COLUMN {
|
||||
return Err("Cannot delete columns beyond the last column of the sheet".to_string());
|
||||
}
|
||||
|
||||
// first column being deleted
|
||||
let column_start = column;
|
||||
@@ -250,7 +187,7 @@ impl Model {
|
||||
column,
|
||||
delta: -column_count,
|
||||
}),
|
||||
)?;
|
||||
);
|
||||
let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
|
||||
|
||||
// deletes all the column styles
|
||||
@@ -374,7 +311,7 @@ impl Model {
|
||||
row,
|
||||
delta: row_count,
|
||||
}),
|
||||
)?;
|
||||
);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@@ -390,13 +327,6 @@ impl Model {
|
||||
if row_count <= 0 {
|
||||
return Err("Please use insert rows instead".to_string());
|
||||
}
|
||||
if !(1..=LAST_ROW).contains(&row) {
|
||||
return Err(format!("Row number '{row}' is not valid."));
|
||||
}
|
||||
if row + row_count - 1 > LAST_ROW {
|
||||
return Err("Cannot delete rows beyond the last row of the sheet".to_string());
|
||||
}
|
||||
|
||||
// Move cells
|
||||
let worksheet = &self.workbook.worksheet(sheet)?;
|
||||
let mut all_rows: Vec<i32> = worksheet.sheet_data.keys().copied().collect();
|
||||
@@ -442,7 +372,7 @@ impl Model {
|
||||
row,
|
||||
delta: -row_count,
|
||||
}),
|
||||
)?;
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -457,86 +387,23 @@ impl Model {
|
||||
/// * Column is one of the extremes of the range. The new extreme would be target_column.
|
||||
/// Range is then normalized
|
||||
/// * Any other case, range is left unchanged.
|
||||
/// NOTE: This moves the data and column styles along with the formulas
|
||||
/// NOTE: This does NOT move the data in the columns or move the colum styles
|
||||
pub fn move_column_action(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
delta: i32,
|
||||
) -> Result<(), String> {
|
||||
) -> Result<(), &'static str> {
|
||||
// Check boundaries
|
||||
let target_column = column + delta;
|
||||
if !(1..=LAST_COLUMN).contains(&target_column) {
|
||||
return Err("Target column out of boundaries".to_string());
|
||||
return Err("Target column out of boundaries");
|
||||
}
|
||||
if !(1..=LAST_COLUMN).contains(&column) {
|
||||
return Err("Initial column out of boundaries".to_string());
|
||||
return Err("Initial column out of boundaries");
|
||||
}
|
||||
|
||||
if delta == 0 {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Preserve cell contents, width and style of the column being moved
|
||||
let original_refs = self
|
||||
.workbook
|
||||
.worksheet(sheet)?
|
||||
.column_cell_references(column)?;
|
||||
let mut original_cells = Vec::new();
|
||||
for r in &original_refs {
|
||||
let cell = self
|
||||
.workbook
|
||||
.worksheet(sheet)?
|
||||
.cell(r.row, column)
|
||||
.ok_or("Expected Cell to exist")?;
|
||||
let style_idx = cell.get_style();
|
||||
let formula_or_value = self
|
||||
.get_cell_formula(sheet, r.row, column)?
|
||||
.unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
|
||||
original_cells.push((r.row, formula_or_value, style_idx));
|
||||
self.cell_clear_all(sheet, r.row, column)?;
|
||||
}
|
||||
|
||||
let width = self.workbook.worksheet(sheet)?.get_column_width(column)?;
|
||||
let style = self.workbook.worksheet(sheet)?.get_column_style(column)?;
|
||||
|
||||
if delta > 0 {
|
||||
for c in column + 1..=target_column {
|
||||
let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
|
||||
for r in refs {
|
||||
self.move_cell(sheet, r.row, c, r.row, c - 1)?;
|
||||
}
|
||||
|
||||
let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
|
||||
let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_column_width_and_style(c - 1, w, s)?;
|
||||
}
|
||||
} else {
|
||||
for c in (target_column..=column - 1).rev() {
|
||||
let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
|
||||
for r in refs {
|
||||
self.move_cell(sheet, r.row, c, r.row, c + 1)?;
|
||||
}
|
||||
|
||||
let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
|
||||
let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_column_width_and_style(c + 1, w, s)?;
|
||||
}
|
||||
}
|
||||
|
||||
for (r, value, style_idx) in original_cells {
|
||||
self.set_user_input(sheet, r, target_column, value)?;
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_cell_style(r, target_column, style_idx)?;
|
||||
}
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_column_width_and_style(target_column, width, style)?;
|
||||
// TODO: Add the actual displacement of data and styles
|
||||
|
||||
// Update all formulas in the workbook
|
||||
self.displace_cells(
|
||||
@@ -545,91 +412,7 @@ impl Model {
|
||||
column,
|
||||
delta,
|
||||
}),
|
||||
)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Displaces cells due to a move row action
|
||||
/// from initial_row to target_row = initial_row + row_delta
|
||||
/// References will be updated following the same rules as move_column_action
|
||||
/// NOTE: This moves the data and row styles along with the formulas
|
||||
pub fn move_row_action(&mut self, sheet: u32, row: i32, delta: i32) -> Result<(), String> {
|
||||
// Check boundaries
|
||||
let target_row = row + delta;
|
||||
if !(1..=LAST_ROW).contains(&target_row) {
|
||||
return Err("Target row out of boundaries".to_string());
|
||||
}
|
||||
if !(1..=LAST_ROW).contains(&row) {
|
||||
return Err("Initial row out of boundaries".to_string());
|
||||
}
|
||||
|
||||
if delta == 0 {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let original_cols = self.get_columns_for_row(sheet, row, false)?;
|
||||
let mut original_cells = Vec::new();
|
||||
for c in &original_cols {
|
||||
let cell = self
|
||||
.workbook
|
||||
.worksheet(sheet)?
|
||||
.cell(row, *c)
|
||||
.ok_or("Expected Cell to exist")?;
|
||||
let style_idx = cell.get_style();
|
||||
let formula_or_value = self
|
||||
.get_cell_formula(sheet, row, *c)?
|
||||
.unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
|
||||
original_cells.push((*c, formula_or_value, style_idx));
|
||||
self.cell_clear_all(sheet, row, *c)?;
|
||||
}
|
||||
|
||||
if delta > 0 {
|
||||
for r in row + 1..=target_row {
|
||||
let cols = self.get_columns_for_row(sheet, r, false)?;
|
||||
for c in cols {
|
||||
self.move_cell(sheet, r, c, r - 1, c)?;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for r in (target_row..=row - 1).rev() {
|
||||
let cols = self.get_columns_for_row(sheet, r, false)?;
|
||||
for c in cols {
|
||||
self.move_cell(sheet, r, c, r + 1, c)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (c, value, style_idx) in original_cells {
|
||||
self.set_user_input(sheet, target_row, c, value)?;
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_cell_style(target_row, c, style_idx)?;
|
||||
}
|
||||
|
||||
let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
|
||||
let mut new_rows = Vec::new();
|
||||
for r in worksheet.rows.iter() {
|
||||
if r.r == row {
|
||||
let mut nr = r.clone();
|
||||
nr.r = target_row;
|
||||
new_rows.push(nr);
|
||||
} else if delta > 0 && r.r > row && r.r <= target_row {
|
||||
let mut nr = r.clone();
|
||||
nr.r -= 1;
|
||||
new_rows.push(nr);
|
||||
} else if delta < 0 && r.r < row && r.r >= target_row {
|
||||
let mut nr = r.clone();
|
||||
nr.r += 1;
|
||||
new_rows.push(nr);
|
||||
} else {
|
||||
new_rows.push(r.clone());
|
||||
}
|
||||
}
|
||||
worksheet.rows = new_rows;
|
||||
|
||||
// Update all formulas in the workbook
|
||||
self.displace_cells(&(DisplaceData::RowMove { sheet, row, delta }))?;
|
||||
);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1,158 +0,0 @@
|
||||
use crate::{
|
||||
calc_result::CalcResult,
|
||||
cast::NumberOrArray,
|
||||
expressions::{
|
||||
parser::{ArrayNode, Node},
|
||||
token::Error,
|
||||
types::CellReferenceIndex,
|
||||
},
|
||||
model::Model,
|
||||
};
|
||||
|
||||
/// Unify how we map booleans/strings to f64
|
||||
fn to_f64(value: &ArrayNode) -> Result<f64, Error> {
|
||||
match value {
|
||||
ArrayNode::Number(f) => Ok(*f),
|
||||
ArrayNode::Boolean(b) => Ok(if *b { 1.0 } else { 0.0 }),
|
||||
ArrayNode::String(s) => match s.parse::<f64>() {
|
||||
Ok(f) => Ok(f),
|
||||
Err(_) => Err(Error::VALUE),
|
||||
},
|
||||
ArrayNode::Error(err) => Err(err.clone()),
|
||||
}
|
||||
}
|
||||
|
||||
impl Model {
|
||||
/// Applies `op` element‐wise for arrays/numbers.
|
||||
pub(crate) fn handle_arithmetic(
|
||||
&mut self,
|
||||
left: &Node,
|
||||
right: &Node,
|
||||
cell: CellReferenceIndex,
|
||||
op: &dyn Fn(f64, f64) -> Result<f64, Error>,
|
||||
) -> CalcResult {
|
||||
let l = match self.get_number_or_array(left, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
let r = match self.get_number_or_array(right, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
match (l, r) {
|
||||
// -----------------------------------------------------
|
||||
// Case 1: Both are numbers
|
||||
// -----------------------------------------------------
|
||||
(NumberOrArray::Number(f1), NumberOrArray::Number(f2)) => match op(f1, f2) {
|
||||
Ok(x) => CalcResult::Number(x),
|
||||
Err(Error::DIV) => CalcResult::Error {
|
||||
error: Error::DIV,
|
||||
origin: cell,
|
||||
message: "Divide by 0".to_string(),
|
||||
},
|
||||
Err(Error::VALUE) => CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Invalid number".to_string(),
|
||||
},
|
||||
Err(e) => CalcResult::Error {
|
||||
error: e,
|
||||
origin: cell,
|
||||
message: "Unknown error".to_string(),
|
||||
},
|
||||
},
|
||||
|
||||
// -----------------------------------------------------
|
||||
// Case 2: left is Number, right is Array
|
||||
// -----------------------------------------------------
|
||||
(NumberOrArray::Number(f1), NumberOrArray::Array(a2)) => {
|
||||
let mut array = Vec::new();
|
||||
for row in a2 {
|
||||
let mut data_row = Vec::new();
|
||||
for node in row {
|
||||
match to_f64(&node) {
|
||||
Ok(f2) => match op(f1, f2) {
|
||||
Ok(x) => data_row.push(ArrayNode::Number(x)),
|
||||
Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
|
||||
Err(Error::VALUE) => data_row.push(ArrayNode::Error(Error::VALUE)),
|
||||
Err(e) => data_row.push(ArrayNode::Error(e)),
|
||||
},
|
||||
Err(err) => data_row.push(ArrayNode::Error(err)),
|
||||
}
|
||||
}
|
||||
array.push(data_row);
|
||||
}
|
||||
CalcResult::Array(array)
|
||||
}
|
||||
|
||||
// -----------------------------------------------------
|
||||
// Case 3: left is Array, right is Number
|
||||
// -----------------------------------------------------
|
||||
(NumberOrArray::Array(a1), NumberOrArray::Number(f2)) => {
|
||||
let mut array = Vec::new();
|
||||
for row in a1 {
|
||||
let mut data_row = Vec::new();
|
||||
for node in row {
|
||||
match to_f64(&node) {
|
||||
Ok(f1) => match op(f1, f2) {
|
||||
Ok(x) => data_row.push(ArrayNode::Number(x)),
|
||||
Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
|
||||
Err(Error::VALUE) => data_row.push(ArrayNode::Error(Error::VALUE)),
|
||||
Err(e) => data_row.push(ArrayNode::Error(e)),
|
||||
},
|
||||
Err(err) => data_row.push(ArrayNode::Error(err)),
|
||||
}
|
||||
}
|
||||
array.push(data_row);
|
||||
}
|
||||
CalcResult::Array(array)
|
||||
}
|
||||
|
||||
// -----------------------------------------------------
|
||||
// Case 4: Both are arrays
|
||||
// -----------------------------------------------------
|
||||
(NumberOrArray::Array(a1), NumberOrArray::Array(a2)) => {
|
||||
let n1 = a1.len();
|
||||
let m1 = a1.first().map(|r| r.len()).unwrap_or(0);
|
||||
let n2 = a2.len();
|
||||
let m2 = a2.first().map(|r| r.len()).unwrap_or(0);
|
||||
let n = n1.max(n2);
|
||||
let m = m1.max(m2);
|
||||
|
||||
let mut array = Vec::new();
|
||||
for i in 0..n {
|
||||
let row1 = a1.get(i);
|
||||
let row2 = a2.get(i);
|
||||
|
||||
let mut data_row = Vec::new();
|
||||
for j in 0..m {
|
||||
let val1 = row1.and_then(|r| r.get(j));
|
||||
let val2 = row2.and_then(|r| r.get(j));
|
||||
|
||||
match (val1, val2) {
|
||||
(Some(v1), Some(v2)) => match (to_f64(v1), to_f64(v2)) {
|
||||
(Ok(f1), Ok(f2)) => match op(f1, f2) {
|
||||
Ok(x) => data_row.push(ArrayNode::Number(x)),
|
||||
Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
|
||||
Err(Error::VALUE) => {
|
||||
data_row.push(ArrayNode::Error(Error::VALUE))
|
||||
}
|
||||
Err(e) => data_row.push(ArrayNode::Error(e)),
|
||||
},
|
||||
(Err(e), _) | (_, Err(e)) => data_row.push(ArrayNode::Error(e)),
|
||||
},
|
||||
// Mismatched dimensions => #VALUE!
|
||||
_ => data_row.push(ArrayNode::Error(Error::VALUE)),
|
||||
}
|
||||
}
|
||||
array.push(data_row);
|
||||
}
|
||||
CalcResult::Array(array)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,8 +1,7 @@
|
||||
use std::cmp::Ordering;
|
||||
|
||||
use crate::expressions::{parser::ArrayNode, token::Error, types::CellReferenceIndex};
|
||||
use crate::expressions::{token::Error, types::CellReferenceIndex};
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct Range {
|
||||
pub left: CellReferenceIndex,
|
||||
pub right: CellReferenceIndex,
|
||||
@@ -24,7 +23,6 @@ pub(crate) enum CalcResult {
|
||||
},
|
||||
EmptyCell,
|
||||
EmptyArg,
|
||||
Array(Vec<Vec<ArrayNode>>),
|
||||
}
|
||||
|
||||
impl CalcResult {
|
||||
|
||||
149
base/src/cast.rs
149
base/src/cast.rs
@@ -1,85 +1,11 @@
|
||||
use crate::{
|
||||
calc_result::{CalcResult, Range},
|
||||
expressions::{
|
||||
parser::{ArrayNode, Node},
|
||||
token::Error,
|
||||
types::CellReferenceIndex,
|
||||
},
|
||||
expressions::{parser::Node, token::Error, types::CellReferenceIndex},
|
||||
implicit_intersection::implicit_intersection,
|
||||
model::Model,
|
||||
};
|
||||
|
||||
pub(crate) enum NumberOrArray {
|
||||
Number(f64),
|
||||
Array(Vec<Vec<ArrayNode>>),
|
||||
}
|
||||
|
||||
impl Model {
|
||||
pub(crate) fn get_number_or_array(
|
||||
&mut self,
|
||||
node: &Node,
|
||||
cell: CellReferenceIndex,
|
||||
) -> Result<NumberOrArray, CalcResult> {
|
||||
match self.evaluate_node_in_context(node, cell) {
|
||||
CalcResult::Number(f) => Ok(NumberOrArray::Number(f)),
|
||||
CalcResult::String(s) => match s.parse::<f64>() {
|
||||
Ok(f) => Ok(NumberOrArray::Number(f)),
|
||||
_ => Err(CalcResult::new_error(
|
||||
Error::VALUE,
|
||||
cell,
|
||||
"Expecting number".to_string(),
|
||||
)),
|
||||
},
|
||||
CalcResult::Boolean(f) => {
|
||||
if f {
|
||||
Ok(NumberOrArray::Number(1.0))
|
||||
} else {
|
||||
Ok(NumberOrArray::Number(0.0))
|
||||
}
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(NumberOrArray::Number(0.0)),
|
||||
CalcResult::Range { left, right } => {
|
||||
let sheet = left.sheet;
|
||||
if sheet != right.sheet {
|
||||
return Err(CalcResult::Error {
|
||||
error: Error::ERROR,
|
||||
origin: cell,
|
||||
message: "3D ranges are not allowed".to_string(),
|
||||
});
|
||||
}
|
||||
// we need to convert the range into an array
|
||||
let mut array = Vec::new();
|
||||
for row in left.row..=right.row {
|
||||
let mut row_data = Vec::new();
|
||||
for column in left.column..=right.column {
|
||||
let value =
|
||||
match self.evaluate_cell(CellReferenceIndex { sheet, column, row }) {
|
||||
CalcResult::String(s) => ArrayNode::String(s),
|
||||
CalcResult::Number(f) => ArrayNode::Number(f),
|
||||
CalcResult::Boolean(b) => ArrayNode::Boolean(b),
|
||||
CalcResult::Error { error, .. } => ArrayNode::Error(error),
|
||||
CalcResult::Range { .. } => {
|
||||
// if we do things right this can never happen.
|
||||
// the evaluation of a cell should never return a range
|
||||
ArrayNode::Number(0.0)
|
||||
}
|
||||
CalcResult::EmptyCell => ArrayNode::Number(0.0),
|
||||
CalcResult::EmptyArg => ArrayNode::Number(0.0),
|
||||
CalcResult::Array(_) => {
|
||||
// if we do things right this can never happen.
|
||||
// the evaluation of a cell should never return an array
|
||||
ArrayNode::Number(0.0)
|
||||
}
|
||||
};
|
||||
row_data.push(value);
|
||||
}
|
||||
array.push(row_data);
|
||||
}
|
||||
Ok(NumberOrArray::Array(array))
|
||||
}
|
||||
CalcResult::Array(s) => Ok(NumberOrArray::Array(s)),
|
||||
error @ CalcResult::Error { .. } => Err(error),
|
||||
}
|
||||
}
|
||||
pub(crate) fn get_number(
|
||||
&mut self,
|
||||
node: &Node,
|
||||
@@ -113,16 +39,19 @@ impl Model {
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(0.0),
|
||||
error @ CalcResult::Error { .. } => Err(error),
|
||||
CalcResult::Range { .. } => Err(CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}),
|
||||
CalcResult::Array(_) => Err(CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}),
|
||||
CalcResult::Range { left, right } => {
|
||||
match implicit_intersection(&cell, &Range { left, right }) {
|
||||
Some(cell_reference) => {
|
||||
let result = self.evaluate_cell(cell_reference);
|
||||
self.cast_to_number(result, cell_reference)
|
||||
}
|
||||
None => Err(CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Invalid reference (number)".to_string(),
|
||||
}),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -159,7 +88,7 @@ impl Model {
|
||||
// FIXME: I think when casting a number we should convert it to_precision(x, 15)
|
||||
// See function Exact
|
||||
match result {
|
||||
CalcResult::Number(f) => Ok(format!("{f}")),
|
||||
CalcResult::Number(f) => Ok(format!("{}", f)),
|
||||
CalcResult::String(s) => Ok(s),
|
||||
CalcResult::Boolean(f) => {
|
||||
if f {
|
||||
@@ -170,16 +99,19 @@ impl Model {
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => Ok("".to_string()),
|
||||
error @ CalcResult::Error { .. } => Err(error),
|
||||
CalcResult::Range { .. } => Err(CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}),
|
||||
CalcResult::Array(_) => Err(CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}),
|
||||
CalcResult::Range { left, right } => {
|
||||
match implicit_intersection(&cell, &Range { left, right }) {
|
||||
Some(cell_reference) => {
|
||||
let result = self.evaluate_cell(cell_reference);
|
||||
self.cast_to_string(result, cell_reference)
|
||||
}
|
||||
None => Err(CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Invalid reference (string)".to_string(),
|
||||
}),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -219,16 +151,19 @@ impl Model {
|
||||
CalcResult::Boolean(b) => Ok(b),
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(false),
|
||||
error @ CalcResult::Error { .. } => Err(error),
|
||||
CalcResult::Range { .. } => Err(CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}),
|
||||
CalcResult::Array(_) => Err(CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}),
|
||||
CalcResult::Range { left, right } => {
|
||||
match implicit_intersection(&cell, &Range { left, right }) {
|
||||
Some(cell_reference) => {
|
||||
let result = self.evaluate_cell(cell_reference);
|
||||
self.cast_to_bool(result, cell_reference)
|
||||
}
|
||||
None => Err(CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Invalid reference (bool)".to_string(),
|
||||
}),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -176,3 +176,18 @@ impl Cell {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Implementing methods for MergedCells struct
|
||||
|
||||
impl MergedCells {
|
||||
pub fn is_cell_part_of_merged_cells(&self, row: i32, col: i32) -> bool {
|
||||
// This is merge Mother cell so do not include this cell as part of Merged Cells
|
||||
if row == self.0 && col == self.1 {
|
||||
return false;
|
||||
}
|
||||
|
||||
let result: bool = (row >= self.0 && row <= self.2) && (col >= self.1 && col <= self.3);
|
||||
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,7 +6,7 @@ pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 125.0;
|
||||
pub(crate) const DEFAULT_ROW_HEIGHT: f64 = 28.0;
|
||||
pub(crate) const COLUMN_WIDTH_FACTOR: f64 = 12.0;
|
||||
pub(crate) const ROW_HEIGHT_FACTOR: f64 = 2.0;
|
||||
pub(crate) const DEFAULT_WINDOW_HEIGHT: i64 = 600;
|
||||
pub(crate) const DEFAULT_WINDOW_HEIGH: i64 = 600;
|
||||
pub(crate) const DEFAULT_WINDOW_WIDTH: i64 = 800;
|
||||
|
||||
pub(crate) const LAST_COLUMN: i32 = 16_384;
|
||||
@@ -16,10 +16,3 @@ pub(crate) const LAST_ROW: i32 = 1_048_576;
|
||||
// NaiveDate::from_ymd(1900, 1, 1).num_days_from_ce() - 2
|
||||
// The 2 days offset is because of Excel 1900 bug
|
||||
pub(crate) const EXCEL_DATE_BASE: i32 = 693_594;
|
||||
|
||||
// We do not support dates before 1899-12-31.
|
||||
pub(crate) const MINIMUM_DATE_SERIAL_NUMBER: i32 = 1;
|
||||
|
||||
// Excel can handle dates until the year 9999-12-31
|
||||
// 2958465 is the number of days from 1900-01-01 to 9999-12-31
|
||||
pub(crate) const MAXIMUM_DATE_SERIAL_NUMBER: i32 = 2_958_465;
|
||||
|
||||
138
base/src/diffs.rs
Normal file
138
base/src/diffs.rs
Normal file
@@ -0,0 +1,138 @@
|
||||
use crate::{
|
||||
expressions::{
|
||||
parser::{
|
||||
move_formula::ref_is_in_area,
|
||||
stringify::{to_string, to_string_displaced, DisplaceData},
|
||||
walk::forward_references,
|
||||
},
|
||||
types::{Area, CellReferenceIndex, CellReferenceRC},
|
||||
},
|
||||
model::Model,
|
||||
};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
|
||||
#[serde(untagged, deny_unknown_fields)]
|
||||
pub enum CellValue {
|
||||
Value(String),
|
||||
None,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
|
||||
pub struct SetCellValue {
|
||||
cell: CellReferenceIndex,
|
||||
new_value: CellValue,
|
||||
old_value: CellValue,
|
||||
}
|
||||
|
||||
impl Model {
|
||||
#[allow(clippy::expect_used)]
|
||||
pub(crate) fn shift_cell_formula(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
column: i32,
|
||||
displace_data: &DisplaceData,
|
||||
) {
|
||||
if let Some(f) = self
|
||||
.workbook
|
||||
.worksheet(sheet)
|
||||
.expect("Worksheet must exist")
|
||||
.cell(row, column)
|
||||
.expect("Cell must exist")
|
||||
.get_formula()
|
||||
{
|
||||
let node = &self.parsed_formulas[sheet as usize][f as usize].clone();
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: self.workbook.worksheets[sheet as usize].get_name(),
|
||||
row,
|
||||
column,
|
||||
};
|
||||
// FIXME: This is not a very performant way if the formula has changed :S.
|
||||
let formula = to_string(node, &cell_reference);
|
||||
let formula_displaced = to_string_displaced(node, &cell_reference, displace_data);
|
||||
if formula != formula_displaced {
|
||||
self.update_cell_with_formula(sheet, row, column, format!("={formula_displaced}"))
|
||||
.expect("Failed to shift cell formula");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::expect_used)]
|
||||
pub fn forward_references(
|
||||
&mut self,
|
||||
source_area: &Area,
|
||||
target: &CellReferenceIndex,
|
||||
) -> Result<Vec<SetCellValue>, String> {
|
||||
let mut diff_list: Vec<SetCellValue> = Vec::new();
|
||||
let target_area = &Area {
|
||||
sheet: target.sheet,
|
||||
row: target.row,
|
||||
column: target.column,
|
||||
width: source_area.width,
|
||||
height: source_area.height,
|
||||
};
|
||||
// Walk over every formula
|
||||
let cells = self.get_all_cells();
|
||||
for cell in cells {
|
||||
if let Some(f) = self
|
||||
.workbook
|
||||
.worksheet(cell.index)
|
||||
.expect("Worksheet must exist")
|
||||
.cell(cell.row, cell.column)
|
||||
.expect("Cell must exist")
|
||||
.get_formula()
|
||||
{
|
||||
let sheet = cell.index;
|
||||
let row = cell.row;
|
||||
let column = cell.column;
|
||||
|
||||
// If cell is in the source or target area, skip
|
||||
if ref_is_in_area(sheet, row, column, source_area)
|
||||
|| ref_is_in_area(sheet, row, column, target_area)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
// Get the formula
|
||||
// Get a copy of the AST
|
||||
let node = &mut self.parsed_formulas[sheet as usize][f as usize].clone();
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: self.workbook.worksheets[sheet as usize].get_name(),
|
||||
column: cell.column,
|
||||
row: cell.row,
|
||||
};
|
||||
let context = CellReferenceIndex { sheet, column, row };
|
||||
let formula = to_string(node, &cell_reference);
|
||||
let target_sheet_name = &self.workbook.worksheets[target.sheet as usize].name;
|
||||
forward_references(
|
||||
node,
|
||||
&context,
|
||||
source_area,
|
||||
target.sheet,
|
||||
target_sheet_name,
|
||||
target.row,
|
||||
target.column,
|
||||
);
|
||||
|
||||
// If the string representation of the formula has changed update the cell
|
||||
let updated_formula = to_string(node, &cell_reference);
|
||||
if formula != updated_formula {
|
||||
self.update_cell_with_formula(
|
||||
sheet,
|
||||
row,
|
||||
column,
|
||||
format!("={updated_formula}"),
|
||||
)?;
|
||||
// Update the diff list
|
||||
diff_list.push(SetCellValue {
|
||||
cell: CellReferenceIndex { sheet, column, row },
|
||||
new_value: CellValue::Value(format!("={}", updated_formula)),
|
||||
old_value: CellValue::Value(format!("={}", formula)),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(diff_list)
|
||||
}
|
||||
}
|
||||
@@ -142,7 +142,7 @@ impl Lexer {
|
||||
pub fn expect(&mut self, tk: TokenType) -> Result<()> {
|
||||
let nt = self.next_token();
|
||||
if mem::discriminant(&nt) != mem::discriminant(&tk) {
|
||||
return Err(self.set_error(&format!("Error, expected {tk:?}"), self.position));
|
||||
return Err(self.set_error(&format!("Error, expected {:?}", tk), self.position));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -187,7 +187,6 @@ impl Lexer {
|
||||
']' => TokenType::RightBracket,
|
||||
':' => TokenType::Colon,
|
||||
';' => TokenType::Semicolon,
|
||||
'@' => TokenType::At,
|
||||
',' => {
|
||||
if self.locale.numbers.symbols.decimal == "," {
|
||||
match self.consume_number(',') {
|
||||
@@ -314,9 +313,6 @@ impl Lexer {
|
||||
} else if name_upper == self.language.booleans.r#false {
|
||||
return TokenType::Boolean(false);
|
||||
}
|
||||
if self.peek_char() == Some('(') {
|
||||
return TokenType::Ident(name);
|
||||
}
|
||||
if self.mode == LexerMode::A1 {
|
||||
let parsed_reference = utils::parse_reference_a1(&name_upper);
|
||||
if parsed_reference.is_some()
|
||||
@@ -514,7 +510,7 @@ impl Lexer {
|
||||
self.position = position;
|
||||
chars.parse::<i32>().map_err(|_| LexerError {
|
||||
position,
|
||||
message: format!("Failed to parse to int: {chars}"),
|
||||
message: format!("Failed to parse to int: {}", chars),
|
||||
})
|
||||
}
|
||||
|
||||
@@ -575,7 +571,9 @@ impl Lexer {
|
||||
}
|
||||
self.position = position;
|
||||
match chars.parse::<f64>() {
|
||||
Err(_) => Err(self.set_error(&format!("Failed to parse to double: {chars}"), position)),
|
||||
Err(_) => {
|
||||
Err(self.set_error(&format!("Failed to parse to double: {}", chars), position))
|
||||
}
|
||||
Ok(v) => Ok(v),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -148,16 +148,15 @@ impl Lexer {
|
||||
let row_left = match row_left.parse::<i32>() {
|
||||
Ok(n) => n,
|
||||
Err(_) => {
|
||||
return Err(
|
||||
self.set_error(&format!("Failed parsing row {row_left}"), position)
|
||||
)
|
||||
return Err(self
|
||||
.set_error(&format!("Failed parsing row {}", row_left), position))
|
||||
}
|
||||
};
|
||||
let row_right = match row_right.parse::<i32>() {
|
||||
Ok(n) => n,
|
||||
Err(_) => {
|
||||
return Err(self
|
||||
.set_error(&format!("Failed parsing row {row_right}"), position))
|
||||
.set_error(&format!("Failed parsing row {}", row_right), position))
|
||||
}
|
||||
};
|
||||
if row_left > LAST_ROW {
|
||||
|
||||
@@ -23,19 +23,19 @@ impl Lexer {
|
||||
// TODO(TD): There are better ways of doing this :)
|
||||
let rest_of_formula: String = self.chars[self.position..self.len].iter().collect();
|
||||
let specifier = if rest_of_formula.starts_with("#This Row]") {
|
||||
self.position += "#This Row]".len();
|
||||
self.position += "#This Row]".bytes().len();
|
||||
TableSpecifier::ThisRow
|
||||
} else if rest_of_formula.starts_with("#All]") {
|
||||
self.position += "#All]".len();
|
||||
self.position += "#All]".bytes().len();
|
||||
TableSpecifier::All
|
||||
} else if rest_of_formula.starts_with("#Data]") {
|
||||
self.position += "#Data]".len();
|
||||
self.position += "#Data]".bytes().len();
|
||||
TableSpecifier::Data
|
||||
} else if rest_of_formula.starts_with("#Headers]") {
|
||||
self.position += "#Headers]".len();
|
||||
self.position += "#Headers]".bytes().len();
|
||||
TableSpecifier::Headers
|
||||
} else if rest_of_formula.starts_with("#Totals]") {
|
||||
self.position += "#Totals]".len();
|
||||
self.position += "#Totals]".bytes().len();
|
||||
TableSpecifier::Totals
|
||||
} else {
|
||||
return Err(LexerError {
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
mod test_common;
|
||||
mod test_implicit_intersection;
|
||||
mod test_language;
|
||||
mod test_locale;
|
||||
mod test_ranges;
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::expressions::utils::column_to_number;
|
||||
use crate::language::get_language;
|
||||
use crate::locale::get_locale;
|
||||
|
||||
@@ -686,29 +685,3 @@ fn test_comparisons() {
|
||||
assert_eq!(lx.next_token(), Number(7.0));
|
||||
assert_eq!(lx.next_token(), EOF);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_log10_is_cell_reference() {
|
||||
let mut lx = new_lexer("LOG10", true);
|
||||
assert_eq!(
|
||||
lx.next_token(),
|
||||
Reference {
|
||||
sheet: None,
|
||||
column: column_to_number("LOG").unwrap(),
|
||||
row: 10,
|
||||
absolute_column: false,
|
||||
absolute_row: false,
|
||||
}
|
||||
);
|
||||
assert_eq!(lx.next_token(), EOF);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_log10_is_function() {
|
||||
let mut lx = new_lexer("LOG10(100)", true);
|
||||
assert_eq!(lx.next_token(), Ident("LOG10".to_string()));
|
||||
assert_eq!(lx.next_token(), LeftParenthesis);
|
||||
assert_eq!(lx.next_token(), Number(100.0));
|
||||
assert_eq!(lx.next_token(), RightParenthesis);
|
||||
assert_eq!(lx.next_token(), EOF);
|
||||
}
|
||||
|
||||
@@ -1,25 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::expressions::{
|
||||
lexer::{Lexer, LexerMode},
|
||||
token::TokenType::*,
|
||||
};
|
||||
use crate::language::get_language;
|
||||
use crate::locale::get_locale;
|
||||
|
||||
fn new_lexer(formula: &str) -> Lexer {
|
||||
let locale = get_locale("en").unwrap();
|
||||
let language = get_language("en").unwrap();
|
||||
Lexer::new(formula, LexerMode::A1, locale, language)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sum_implicit_intersection() {
|
||||
let mut lx = new_lexer("sum(@A1:A3)");
|
||||
assert_eq!(lx.next_token(), Ident("sum".to_string()));
|
||||
assert_eq!(lx.next_token(), LeftParenthesis);
|
||||
assert_eq!(lx.next_token(), At);
|
||||
assert!(matches!(lx.next_token(), Range { .. }));
|
||||
assert_eq!(lx.next_token(), RightParenthesis);
|
||||
assert_eq!(lx.next_token(), EOF);
|
||||
}
|
||||
@@ -24,25 +24,6 @@ fn test_get_tokens() {
|
||||
assert_eq!(l.end, 10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn get_tokens_unicode() {
|
||||
let formula = "'🇵🇭 Philippines'!A1";
|
||||
let t = get_tokens(formula);
|
||||
assert_eq!(t.len(), 1);
|
||||
|
||||
let expected = TokenType::Reference {
|
||||
sheet: Some("🇵🇭 Philippines".to_string()),
|
||||
row: 1,
|
||||
column: 1,
|
||||
absolute_column: false,
|
||||
absolute_row: false,
|
||||
};
|
||||
let l = t.first().expect("expected token");
|
||||
assert_eq!(l.token, expected);
|
||||
assert_eq!(l.start, 0);
|
||||
assert_eq!(l.end, 19);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_simple_tokens() {
|
||||
assert_eq!(
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*!
|
||||
# GRAMMAR
|
||||
# GRAMAR
|
||||
|
||||
<pre class="rust">
|
||||
opComp => '=' | '<' | '>' | '<=' } '>=' | '<>'
|
||||
@@ -12,8 +12,7 @@ term => factor (opFactor factor)*
|
||||
factor => prod (opProd prod)*
|
||||
prod => power ('^' power)*
|
||||
power => (unaryOp)* range '%'*
|
||||
range => implicit (':' primary)?
|
||||
implicit=> '@' primary | primary
|
||||
range => primary (':' primary)?
|
||||
primary => '(' expr ')'
|
||||
=> number
|
||||
=> function '(' f_args ')'
|
||||
@@ -46,11 +45,19 @@ use super::utils::number_to_column;
|
||||
use token::OpCompare;
|
||||
|
||||
pub mod move_formula;
|
||||
pub mod static_analysis;
|
||||
pub mod stringify;
|
||||
pub mod walk;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
mod test;
|
||||
|
||||
#[cfg(test)]
|
||||
mod test_ranges;
|
||||
|
||||
#[cfg(test)]
|
||||
mod test_move_formula;
|
||||
#[cfg(test)]
|
||||
mod test_tables;
|
||||
|
||||
pub(crate) fn parse_range(formula: &str) -> Result<(i32, i32, i32, i32), String> {
|
||||
let mut lexer = lexer::Lexer::new(
|
||||
@@ -82,9 +89,6 @@ fn get_table_column_by_name(table_column_name: &str, table: &Table) -> Option<i3
|
||||
None
|
||||
}
|
||||
|
||||
// DefinedNameS is a tuple with the name of the defined name, the index of the sheet and the formula
|
||||
pub type DefinedNameS = (String, Option<u32>, String);
|
||||
|
||||
pub(crate) struct Reference<'a> {
|
||||
sheet_name: &'a Option<String>,
|
||||
sheet_index: u32,
|
||||
@@ -94,14 +98,6 @@ pub(crate) struct Reference<'a> {
|
||||
column: i32,
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Clone, Debug)]
|
||||
pub enum ArrayNode {
|
||||
Boolean(bool),
|
||||
Number(f64),
|
||||
String(String),
|
||||
Error(token::Error),
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Clone, Debug)]
|
||||
pub enum Node {
|
||||
BooleanKind(bool),
|
||||
@@ -175,14 +171,8 @@ pub enum Node {
|
||||
name: String,
|
||||
args: Vec<Node>,
|
||||
},
|
||||
ArrayKind(Vec<Vec<ArrayNode>>),
|
||||
DefinedNameKind(DefinedNameS),
|
||||
TableNameKind(String),
|
||||
WrongVariableKind(String),
|
||||
ImplicitIntersection {
|
||||
automatic: bool,
|
||||
child: Box<Node>,
|
||||
},
|
||||
ArrayKind(Vec<Node>),
|
||||
VariableKind(String),
|
||||
CompareKind {
|
||||
kind: OpCompare,
|
||||
left: Box<Node>,
|
||||
@@ -205,17 +195,12 @@ pub enum Node {
|
||||
pub struct Parser {
|
||||
lexer: lexer::Lexer,
|
||||
worksheets: Vec<String>,
|
||||
defined_names: Vec<DefinedNameS>,
|
||||
context: CellReferenceRC,
|
||||
context: Option<CellReferenceRC>,
|
||||
tables: HashMap<String, Table>,
|
||||
}
|
||||
|
||||
impl Parser {
|
||||
pub fn new(
|
||||
worksheets: Vec<String>,
|
||||
defined_names: Vec<DefinedNameS>,
|
||||
tables: HashMap<String, Table>,
|
||||
) -> Parser {
|
||||
pub fn new(worksheets: Vec<String>, tables: HashMap<String, Table>) -> Parser {
|
||||
let lexer = lexer::Lexer::new(
|
||||
"",
|
||||
lexer::LexerMode::A1,
|
||||
@@ -224,16 +209,10 @@ impl Parser {
|
||||
#[allow(clippy::expect_used)]
|
||||
get_language("en").expect(""),
|
||||
);
|
||||
let context = CellReferenceRC {
|
||||
sheet: worksheets.first().map_or("", |v| v).to_string(),
|
||||
column: 1,
|
||||
row: 1,
|
||||
};
|
||||
Parser {
|
||||
lexer,
|
||||
worksheets,
|
||||
defined_names,
|
||||
context,
|
||||
context: None,
|
||||
tables,
|
||||
}
|
||||
}
|
||||
@@ -241,18 +220,13 @@ impl Parser {
|
||||
self.lexer.set_lexer_mode(mode)
|
||||
}
|
||||
|
||||
pub fn set_worksheets_and_names(
|
||||
&mut self,
|
||||
worksheets: Vec<String>,
|
||||
defined_names: Vec<DefinedNameS>,
|
||||
) {
|
||||
pub fn set_worksheets(&mut self, worksheets: Vec<String>) {
|
||||
self.worksheets = worksheets;
|
||||
self.defined_names = defined_names;
|
||||
}
|
||||
|
||||
pub fn parse(&mut self, formula: &str, context: &CellReferenceRC) -> Node {
|
||||
pub fn parse(&mut self, formula: &str, context: &Option<CellReferenceRC>) -> Node {
|
||||
self.lexer.set_formula(formula);
|
||||
self.context = context.clone();
|
||||
self.context.clone_from(context);
|
||||
self.parse_expr()
|
||||
}
|
||||
|
||||
@@ -266,24 +240,6 @@ impl Parser {
|
||||
None
|
||||
}
|
||||
|
||||
// Returns:
|
||||
// * None: If there is no defined name by that name
|
||||
// * Some((Some(index), formula)): If there is a defined name local to that sheet
|
||||
// * Some(None): If there is a global defined name
|
||||
fn get_defined_name(&self, name: &str, sheet: u32) -> Option<(Option<u32>, String)> {
|
||||
for (df_name, df_scope, df_formula) in &self.defined_names {
|
||||
if name.to_lowercase() == df_name.to_lowercase() && df_scope == &Some(sheet) {
|
||||
return Some((*df_scope, df_formula.to_owned()));
|
||||
}
|
||||
}
|
||||
for (df_name, df_scope, df_formula) in &self.defined_names {
|
||||
if name.to_lowercase() == df_name.to_lowercase() && df_scope.is_none() {
|
||||
return Some((None, df_formula.to_owned()));
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn parse_expr(&mut self) -> Node {
|
||||
let mut t = self.parse_concat();
|
||||
if let Node::ParseErrorKind { .. } = t {
|
||||
@@ -427,7 +383,7 @@ impl Parser {
|
||||
}
|
||||
|
||||
fn parse_range(&mut self) -> Node {
|
||||
let t = self.parse_implicit();
|
||||
let t = self.parse_primary();
|
||||
if let Node::ParseErrorKind { .. } = t {
|
||||
return t;
|
||||
}
|
||||
@@ -446,65 +402,6 @@ impl Parser {
|
||||
t
|
||||
}
|
||||
|
||||
fn parse_implicit(&mut self) -> Node {
|
||||
let next_token = self.lexer.peek_token();
|
||||
if next_token == TokenType::At {
|
||||
self.lexer.advance_token();
|
||||
let t = self.parse_primary();
|
||||
if let Node::ParseErrorKind { .. } = t {
|
||||
return t;
|
||||
}
|
||||
return Node::ImplicitIntersection {
|
||||
automatic: false,
|
||||
child: Box::new(t),
|
||||
};
|
||||
}
|
||||
self.parse_primary()
|
||||
}
|
||||
|
||||
fn parse_array_row(&mut self) -> Result<Vec<ArrayNode>, Node> {
|
||||
let mut row = Vec::new();
|
||||
// and array can only have numbers, string or booleans
|
||||
// otherwise it is a syntax error
|
||||
let first_element = match self.parse_expr() {
|
||||
Node::BooleanKind(s) => ArrayNode::Boolean(s),
|
||||
Node::NumberKind(s) => ArrayNode::Number(s),
|
||||
Node::StringKind(s) => ArrayNode::String(s),
|
||||
Node::ErrorKind(kind) => ArrayNode::Error(kind),
|
||||
error @ Node::ParseErrorKind { .. } => return Err(error),
|
||||
_ => {
|
||||
return Err(Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
message: "Invalid value in array".to_string(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
});
|
||||
}
|
||||
};
|
||||
row.push(first_element);
|
||||
let mut next_token = self.lexer.peek_token();
|
||||
// FIXME: this is not respecting the locale
|
||||
while next_token == TokenType::Comma {
|
||||
self.lexer.advance_token();
|
||||
let value = match self.parse_expr() {
|
||||
Node::BooleanKind(s) => ArrayNode::Boolean(s),
|
||||
Node::NumberKind(s) => ArrayNode::Number(s),
|
||||
Node::StringKind(s) => ArrayNode::String(s),
|
||||
Node::ErrorKind(kind) => ArrayNode::Error(kind),
|
||||
error @ Node::ParseErrorKind { .. } => return Err(error),
|
||||
_ => {
|
||||
return Err(Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
message: "Invalid value in array".to_string(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
});
|
||||
}
|
||||
};
|
||||
row.push(value);
|
||||
next_token = self.lexer.peek_token();
|
||||
}
|
||||
Ok(row)
|
||||
}
|
||||
|
||||
fn parse_primary(&mut self) -> Node {
|
||||
let next_token = self.lexer.next_token();
|
||||
match next_token {
|
||||
@@ -526,35 +423,21 @@ impl Parser {
|
||||
TokenType::Number(s) => Node::NumberKind(s),
|
||||
TokenType::String(s) => Node::StringKind(s),
|
||||
TokenType::LeftBrace => {
|
||||
// It's an array. It's a collection of rows all of the same dimension
|
||||
|
||||
let first_row = match self.parse_array_row() {
|
||||
Ok(s) => s,
|
||||
Err(error) => return error,
|
||||
};
|
||||
let length = first_row.len();
|
||||
|
||||
let mut matrix = Vec::new();
|
||||
matrix.push(first_row);
|
||||
// FIXME: this is not respecting the locale
|
||||
let t = self.parse_expr();
|
||||
if let Node::ParseErrorKind { .. } = t {
|
||||
return t;
|
||||
}
|
||||
let mut next_token = self.lexer.peek_token();
|
||||
let mut args: Vec<Node> = vec![t];
|
||||
while next_token == TokenType::Semicolon {
|
||||
self.lexer.advance_token();
|
||||
let row = match self.parse_array_row() {
|
||||
Ok(s) => s,
|
||||
Err(error) => return error,
|
||||
};
|
||||
next_token = self.lexer.peek_token();
|
||||
if row.len() != length {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
message: "All rows in an array should be the same length".to_string(),
|
||||
};
|
||||
let p = self.parse_expr();
|
||||
if let Node::ParseErrorKind { .. } = p {
|
||||
return p;
|
||||
}
|
||||
matrix.push(row);
|
||||
next_token = self.lexer.peek_token();
|
||||
args.push(p);
|
||||
}
|
||||
|
||||
if let Err(err) = self.lexer.expect(TokenType::RightBrace) {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
@@ -562,7 +445,7 @@ impl Parser {
|
||||
message: err.message,
|
||||
};
|
||||
}
|
||||
Node::ArrayKind(matrix)
|
||||
Node::ArrayKind(args)
|
||||
}
|
||||
TokenType::Reference {
|
||||
sheet,
|
||||
@@ -571,7 +454,16 @@ impl Parser {
|
||||
absolute_column,
|
||||
absolute_row,
|
||||
} => {
|
||||
let context = &self.context;
|
||||
let context = match &self.context {
|
||||
Some(c) => c,
|
||||
None => {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
message: "Expected context for the reference".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
let sheet_index = match &sheet {
|
||||
Some(name) => self.get_sheet_index_by_name(name),
|
||||
None => self.get_sheet_index_by_name(&context.sheet),
|
||||
@@ -606,7 +498,16 @@ impl Parser {
|
||||
}
|
||||
}
|
||||
TokenType::Range { sheet, left, right } => {
|
||||
let context = &self.context;
|
||||
let context = match &self.context {
|
||||
Some(c) => c,
|
||||
None => {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
message: "Expected context for the reference".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
let sheet_index = match &sheet {
|
||||
Some(name) => self.get_sheet_index_by_name(name),
|
||||
None => self.get_sheet_index_by_name(&context.sheet),
|
||||
@@ -621,6 +522,20 @@ impl Parser {
|
||||
let mut absolute_row1 = left.absolute_row;
|
||||
let mut absolute_row2 = right.absolute_row;
|
||||
|
||||
if self.lexer.is_a1_mode() {
|
||||
if !left.absolute_row {
|
||||
row1 -= context.row
|
||||
};
|
||||
if !left.absolute_column {
|
||||
column1 -= context.column
|
||||
};
|
||||
if !right.absolute_row {
|
||||
row2 -= context.row
|
||||
};
|
||||
if !right.absolute_column {
|
||||
column2 -= context.column
|
||||
};
|
||||
}
|
||||
if row1 > row2 {
|
||||
(row2, row1) = (row1, row2);
|
||||
(absolute_row2, absolute_row1) = (absolute_row1, absolute_row2);
|
||||
@@ -629,22 +544,6 @@ impl Parser {
|
||||
(column2, column1) = (column1, column2);
|
||||
(absolute_column2, absolute_column1) = (absolute_column1, absolute_column2);
|
||||
}
|
||||
|
||||
if self.lexer.is_a1_mode() {
|
||||
if !absolute_row1 {
|
||||
row1 -= context.row
|
||||
};
|
||||
if !absolute_column1 {
|
||||
column1 -= context.column
|
||||
};
|
||||
if !absolute_row2 {
|
||||
row2 -= context.row
|
||||
};
|
||||
if !absolute_column2 {
|
||||
column2 -= context.column
|
||||
};
|
||||
}
|
||||
|
||||
match sheet_index {
|
||||
Some(index) => Node::RangeKind {
|
||||
sheet_name: sheet,
|
||||
@@ -692,47 +591,11 @@ impl Parser {
|
||||
kind: function_kind,
|
||||
args,
|
||||
};
|
||||
}
|
||||
if &name == "_xlfn.SINGLE" {
|
||||
if args.len() != 1 {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
message: "Implicit Intersection requires just one argument"
|
||||
.to_string(),
|
||||
};
|
||||
}
|
||||
return Node::ImplicitIntersection {
|
||||
automatic: false,
|
||||
child: Box::new(args[0].clone()),
|
||||
};
|
||||
}
|
||||
return Node::InvalidFunctionKind { name, args };
|
||||
}
|
||||
let context = &self.context;
|
||||
|
||||
let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
|
||||
Some(i) => i,
|
||||
None => {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message: format!("sheet not found: {}", context.sheet),
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
// Could be a defined name or a table
|
||||
if let Some((scope, formula)) = self.get_defined_name(&name, context_sheet_index) {
|
||||
return Node::DefinedNameKind((name, scope, formula));
|
||||
}
|
||||
let name_lower = name.to_lowercase();
|
||||
for table_name in self.tables.keys() {
|
||||
if table_name.to_lowercase() == name_lower {
|
||||
return Node::TableNameKind(name);
|
||||
} else {
|
||||
return Node::InvalidFunctionKind { name, args };
|
||||
}
|
||||
}
|
||||
Node::WrongVariableKind(name)
|
||||
Node::VariableKind(name)
|
||||
}
|
||||
TokenType::Error(kind) => Node::ErrorKind(kind),
|
||||
TokenType::Illegal(error) => Node::ParseErrorKind {
|
||||
@@ -745,38 +608,7 @@ impl Parser {
|
||||
position: 0,
|
||||
message: "Unexpected end of input.".to_string(),
|
||||
},
|
||||
TokenType::Boolean(value) => {
|
||||
// Could be a function call "TRUE()"
|
||||
let next_token = self.lexer.peek_token();
|
||||
if next_token == TokenType::LeftParenthesis {
|
||||
self.lexer.advance_token();
|
||||
// We parse all the arguments, although technically this is moot
|
||||
// But is has the upside of transforming `=TRUE( 4 )` into `=TRUE(4)`
|
||||
let args = match self.parse_function_args() {
|
||||
Ok(s) => s,
|
||||
Err(e) => return e,
|
||||
};
|
||||
if let Err(err) = self.lexer.expect(TokenType::RightParenthesis) {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: err.position,
|
||||
message: err.message,
|
||||
};
|
||||
}
|
||||
if value {
|
||||
return Node::FunctionKind {
|
||||
kind: Function::True,
|
||||
args,
|
||||
};
|
||||
} else {
|
||||
return Node::FunctionKind {
|
||||
kind: Function::False,
|
||||
args,
|
||||
};
|
||||
}
|
||||
}
|
||||
Node::BooleanKind(value)
|
||||
}
|
||||
TokenType::Boolean(value) => Node::BooleanKind(value),
|
||||
TokenType::Compare(_) => {
|
||||
// A primary Node cannot start with an operator
|
||||
Node::ParseErrorKind {
|
||||
@@ -809,14 +641,6 @@ impl Parser {
|
||||
message: "Unexpected token: 'POWER'".to_string(),
|
||||
}
|
||||
}
|
||||
TokenType::At => {
|
||||
// A primary Node cannot start with an operator
|
||||
Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message: "Unexpected token: '@'".to_string(),
|
||||
}
|
||||
}
|
||||
TokenType::RightParenthesis
|
||||
| TokenType::RightBracket
|
||||
| TokenType::Colon
|
||||
@@ -828,7 +652,7 @@ impl Parser {
|
||||
| TokenType::Percent => Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message: format!("Unexpected token: '{next_token:?}'"),
|
||||
message: format!("Unexpected token: '{:?}'", next_token),
|
||||
},
|
||||
TokenType::LeftBracket => Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
@@ -843,177 +667,187 @@ impl Parser {
|
||||
// We will try to convert to a normal reference
|
||||
// table_name[column_name] => cell1:cell2
|
||||
// table_name[[#This Row], [column_name]:[column_name]] => cell1:cell2
|
||||
let context = &self.context;
|
||||
let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
|
||||
Some(i) => i,
|
||||
None => {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message: format!("sheet not found: {}", context.sheet),
|
||||
};
|
||||
}
|
||||
};
|
||||
// table-name => table
|
||||
let table = match self.tables.get(&table_name) {
|
||||
Some(t) => t,
|
||||
None => {
|
||||
let message = format!(
|
||||
"Table not found: '{table_name}' at '{}!{}{}'",
|
||||
context.sheet,
|
||||
number_to_column(context.column)
|
||||
.unwrap_or(format!("{}", context.column)),
|
||||
context.row
|
||||
);
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message,
|
||||
};
|
||||
}
|
||||
};
|
||||
let table_sheet_index = match self.get_sheet_index_by_name(&table.sheet_name) {
|
||||
Some(i) => i,
|
||||
None => {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message: format!("table sheet not found: {}", table.sheet_name),
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
let sheet_name = if table_sheet_index == context_sheet_index {
|
||||
None
|
||||
} else {
|
||||
Some(table.sheet_name.clone())
|
||||
};
|
||||
|
||||
// context must be with tables.reference
|
||||
#[allow(clippy::expect_used)]
|
||||
let (column_start, mut row_start, column_end, mut row_end) =
|
||||
parse_range(&table.reference).expect("Failed parsing range");
|
||||
|
||||
let totals_row_count = table.totals_row_count as i32;
|
||||
let header_row_count = table.header_row_count as i32;
|
||||
row_end -= totals_row_count;
|
||||
|
||||
match specifier {
|
||||
Some(token::TableSpecifier::ThisRow) => {
|
||||
row_start = context.row;
|
||||
row_end = context.row;
|
||||
}
|
||||
Some(token::TableSpecifier::Totals) => {
|
||||
if totals_row_count != 0 {
|
||||
row_start = row_end + 1;
|
||||
row_end = row_start;
|
||||
} else {
|
||||
// Table1[#Totals] is #REF! if Table1 does not have totals
|
||||
return Node::ErrorKind(token::Error::REF);
|
||||
}
|
||||
}
|
||||
Some(token::TableSpecifier::Headers) => {
|
||||
row_end = row_start;
|
||||
}
|
||||
Some(token::TableSpecifier::Data) => {
|
||||
row_start += header_row_count;
|
||||
}
|
||||
Some(token::TableSpecifier::All) => {
|
||||
if totals_row_count != 0 {
|
||||
row_end += 1;
|
||||
}
|
||||
}
|
||||
None => {
|
||||
// skip the headers
|
||||
row_start += header_row_count;
|
||||
}
|
||||
}
|
||||
match table_reference {
|
||||
None => Node::RangeKind {
|
||||
sheet_name,
|
||||
sheet_index: table_sheet_index,
|
||||
absolute_row1: true,
|
||||
absolute_column1: true,
|
||||
row1: row_start,
|
||||
column1: column_start,
|
||||
absolute_row2: true,
|
||||
absolute_column2: true,
|
||||
row2: row_end,
|
||||
column2: column_end,
|
||||
},
|
||||
Some(TableReference::ColumnReference(s)) => {
|
||||
let column_index = match get_table_column_by_name(&s, table) {
|
||||
Some(s) => s + column_start,
|
||||
None => {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
message: format!("Expecting column: {s} in table {table_name}"),
|
||||
};
|
||||
}
|
||||
};
|
||||
if row_start == row_end {
|
||||
return Node::ReferenceKind {
|
||||
sheet_name,
|
||||
sheet_index: table_sheet_index,
|
||||
absolute_row: true,
|
||||
absolute_column: true,
|
||||
row: row_start,
|
||||
column: column_index,
|
||||
if let Some(context) = &self.context {
|
||||
let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
|
||||
Some(i) => i,
|
||||
None => {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message: "sheet not found".to_string(),
|
||||
};
|
||||
}
|
||||
Node::RangeKind {
|
||||
sheet_name,
|
||||
sheet_index: table_sheet_index,
|
||||
absolute_row1: true,
|
||||
absolute_column1: true,
|
||||
row1: row_start,
|
||||
column1: column_index,
|
||||
absolute_row2: true,
|
||||
absolute_column2: true,
|
||||
row2: row_end,
|
||||
column2: column_index,
|
||||
};
|
||||
// table-name => table
|
||||
let table = match self.tables.get(&table_name) {
|
||||
Some(t) => t,
|
||||
None => {
|
||||
let message = format!(
|
||||
"Table not found: '{table_name}' at '{}!{}{}'",
|
||||
context.sheet,
|
||||
number_to_column(context.column)
|
||||
.unwrap_or(format!("{}", context.column)),
|
||||
context.row
|
||||
);
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message,
|
||||
};
|
||||
}
|
||||
}
|
||||
Some(TableReference::RangeReference((left, right))) => {
|
||||
let left_column_index = match get_table_column_by_name(&left, table) {
|
||||
Some(f) => f + column_start,
|
||||
None => {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
message: format!(
|
||||
"Expecting column: {left} in table {table_name}"
|
||||
),
|
||||
};
|
||||
}
|
||||
};
|
||||
};
|
||||
let table_sheet_index = match self.get_sheet_index_by_name(&table.sheet_name) {
|
||||
Some(i) => i,
|
||||
None => {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message: "sheet not found".to_string(),
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
let right_column_index = match get_table_column_by_name(&right, table) {
|
||||
Some(f) => f + column_start,
|
||||
None => {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
message: format!(
|
||||
"Expecting column: {right} in table {table_name}"
|
||||
),
|
||||
};
|
||||
let sheet_name = if table_sheet_index == context_sheet_index {
|
||||
None
|
||||
} else {
|
||||
Some(table.sheet_name.clone())
|
||||
};
|
||||
|
||||
// context must be with tables.reference
|
||||
#[allow(clippy::expect_used)]
|
||||
let (column_start, mut row_start, column_end, mut row_end) =
|
||||
parse_range(&table.reference).expect("Failed parsing range");
|
||||
|
||||
let totals_row_count = table.totals_row_count as i32;
|
||||
let header_row_count = table.header_row_count as i32;
|
||||
row_end -= totals_row_count;
|
||||
|
||||
match specifier {
|
||||
Some(token::TableSpecifier::ThisRow) => {
|
||||
row_start = context.row;
|
||||
row_end = context.row;
|
||||
}
|
||||
Some(token::TableSpecifier::Totals) => {
|
||||
if totals_row_count != 0 {
|
||||
row_start = row_end + 1;
|
||||
row_end = row_start;
|
||||
} else {
|
||||
// Table1[#Totals] is #REF! if Table1 does not have totals
|
||||
return Node::ErrorKind(token::Error::REF);
|
||||
}
|
||||
};
|
||||
Node::RangeKind {
|
||||
sheet_name,
|
||||
sheet_index: table_sheet_index,
|
||||
absolute_row1: true,
|
||||
absolute_column1: true,
|
||||
row1: row_start,
|
||||
column1: left_column_index,
|
||||
absolute_row2: true,
|
||||
absolute_column2: true,
|
||||
row2: row_end,
|
||||
column2: right_column_index,
|
||||
}
|
||||
Some(token::TableSpecifier::Headers) => {
|
||||
row_end = row_start;
|
||||
}
|
||||
Some(token::TableSpecifier::Data) => {
|
||||
row_start += header_row_count;
|
||||
}
|
||||
Some(token::TableSpecifier::All) => {
|
||||
if totals_row_count != 0 {
|
||||
row_end += 1;
|
||||
}
|
||||
}
|
||||
None => {
|
||||
// skip the headers
|
||||
row_start += header_row_count;
|
||||
}
|
||||
}
|
||||
match table_reference {
|
||||
None => {
|
||||
return Node::RangeKind {
|
||||
sheet_name,
|
||||
sheet_index: table_sheet_index,
|
||||
absolute_row1: true,
|
||||
absolute_column1: true,
|
||||
row1: row_start,
|
||||
column1: column_start,
|
||||
absolute_row2: true,
|
||||
absolute_column2: true,
|
||||
row2: row_end,
|
||||
column2: column_end,
|
||||
};
|
||||
}
|
||||
Some(TableReference::ColumnReference(s)) => {
|
||||
let column_index = match get_table_column_by_name(&s, table) {
|
||||
Some(s) => s + column_start,
|
||||
None => {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
message: format!(
|
||||
"Expecting column: {s} in table {table_name}"
|
||||
),
|
||||
};
|
||||
}
|
||||
};
|
||||
if row_start == row_end {
|
||||
return Node::ReferenceKind {
|
||||
sheet_name,
|
||||
sheet_index: table_sheet_index,
|
||||
absolute_row: true,
|
||||
absolute_column: true,
|
||||
row: row_start,
|
||||
column: column_index,
|
||||
};
|
||||
}
|
||||
return Node::RangeKind {
|
||||
sheet_name,
|
||||
sheet_index: table_sheet_index,
|
||||
absolute_row1: true,
|
||||
absolute_column1: true,
|
||||
row1: row_start,
|
||||
column1: column_index,
|
||||
absolute_row2: true,
|
||||
absolute_column2: true,
|
||||
row2: row_end,
|
||||
column2: column_index,
|
||||
};
|
||||
}
|
||||
Some(TableReference::RangeReference((left, right))) => {
|
||||
let left_column_index = match get_table_column_by_name(&left, table) {
|
||||
Some(f) => f + column_start,
|
||||
None => {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
message: format!(
|
||||
"Expecting column: {left} in table {table_name}"
|
||||
),
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
let right_column_index = match get_table_column_by_name(&right, table) {
|
||||
Some(f) => f + column_start,
|
||||
None => {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: self.lexer.get_position() as usize,
|
||||
message: format!(
|
||||
"Expecting column: {right} in table {table_name}"
|
||||
),
|
||||
};
|
||||
}
|
||||
};
|
||||
return Node::RangeKind {
|
||||
sheet_name,
|
||||
sheet_index: table_sheet_index,
|
||||
absolute_row1: true,
|
||||
absolute_column1: true,
|
||||
row1: row_start,
|
||||
column1: left_column_index,
|
||||
absolute_row2: true,
|
||||
absolute_column2: true,
|
||||
row2: row_end,
|
||||
column2: right_column_index,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message: "Structured references not supported in R1C1 mode".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use super::{
|
||||
stringify::{stringify_reference, DisplaceData},
|
||||
ArrayNode, Node, Reference,
|
||||
Node, Reference,
|
||||
};
|
||||
use crate::{
|
||||
constants::{LAST_COLUMN, LAST_ROW},
|
||||
@@ -53,24 +53,15 @@ fn move_function(name: &str, args: &Vec<Node>, move_context: &MoveContext) -> St
|
||||
arguments = to_string_moved(el, move_context);
|
||||
}
|
||||
}
|
||||
format!("{name}({arguments})")
|
||||
}
|
||||
|
||||
pub(crate) fn to_string_array_node(node: &ArrayNode) -> String {
|
||||
match node {
|
||||
ArrayNode::Boolean(value) => format!("{value}").to_ascii_uppercase(),
|
||||
ArrayNode::Number(number) => to_excel_precision_str(*number),
|
||||
ArrayNode::String(value) => format!("\"{value}\""),
|
||||
ArrayNode::Error(kind) => format!("{kind}"),
|
||||
}
|
||||
format!("{}({})", name, arguments)
|
||||
}
|
||||
|
||||
fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
|
||||
use self::Node::*;
|
||||
match node {
|
||||
BooleanKind(value) => format!("{value}").to_ascii_uppercase(),
|
||||
BooleanKind(value) => format!("{}", value).to_ascii_uppercase(),
|
||||
NumberKind(number) => to_excel_precision_str(*number),
|
||||
StringKind(value) => format!("\"{value}\""),
|
||||
StringKind(value) => format!("\"{}\"", value),
|
||||
ReferenceKind {
|
||||
sheet_name,
|
||||
sheet_index,
|
||||
@@ -241,7 +232,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
|
||||
full_row,
|
||||
full_column,
|
||||
);
|
||||
format!("{s1}:{s2}")
|
||||
format!("{}:{}", s1, s2)
|
||||
}
|
||||
WrongReferenceKind {
|
||||
sheet_name,
|
||||
@@ -325,7 +316,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
|
||||
full_row,
|
||||
full_column,
|
||||
);
|
||||
format!("{s1}:{s2}")
|
||||
format!("{}:{}", s1, s2)
|
||||
}
|
||||
OpRangeKind { left, right } => format!(
|
||||
"{}:{}",
|
||||
@@ -358,7 +349,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
|
||||
}
|
||||
_ => to_string_moved(right, move_context),
|
||||
};
|
||||
format!("{x}{kind}{y}")
|
||||
format!("{}{}{}", x, kind, y)
|
||||
}
|
||||
OpPowerKind { left, right } => format!(
|
||||
"{}^{}",
|
||||
@@ -371,43 +362,20 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
|
||||
move_function(name, args, move_context)
|
||||
}
|
||||
ArrayKind(args) => {
|
||||
let mut first_row = true;
|
||||
let mut matrix_string = String::new();
|
||||
|
||||
// Each element in `args` is assumed to be one "row" (itself a `Vec<T>`).
|
||||
for row in args {
|
||||
if !first_row {
|
||||
matrix_string.push(',');
|
||||
// This code is a placeholder. Arrays are not yet implemented
|
||||
let mut first = true;
|
||||
let mut arguments = "".to_string();
|
||||
for el in args {
|
||||
if !first {
|
||||
arguments = format!("{},{}", arguments, to_string_moved(el, move_context));
|
||||
} else {
|
||||
first_row = false;
|
||||
first = false;
|
||||
arguments = to_string_moved(el, move_context);
|
||||
}
|
||||
|
||||
// Build the string for the current row
|
||||
let mut first_col = true;
|
||||
let mut row_string = String::new();
|
||||
for el in row {
|
||||
if !first_col {
|
||||
row_string.push(',');
|
||||
} else {
|
||||
first_col = false;
|
||||
}
|
||||
|
||||
// Reuse your existing element-stringification function
|
||||
row_string.push_str(&to_string_array_node(el));
|
||||
}
|
||||
|
||||
// Enclose the row in braces
|
||||
matrix_string.push('{');
|
||||
matrix_string.push_str(&row_string);
|
||||
matrix_string.push('}');
|
||||
}
|
||||
|
||||
// Enclose the whole matrix in braces
|
||||
format!("{{{matrix_string}}}")
|
||||
format!("{{{}}}", arguments)
|
||||
}
|
||||
DefinedNameKind((name, ..)) => name.to_string(),
|
||||
TableNameKind(name) => name.to_string(),
|
||||
WrongVariableKind(name) => name.to_string(),
|
||||
VariableKind(value) => value.to_string(),
|
||||
CompareKind { kind, left, right } => format!(
|
||||
"{}{}{}",
|
||||
to_string_moved(left, move_context),
|
||||
@@ -418,18 +386,12 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
|
||||
OpUnary::Minus => format!("-{}", to_string_moved(right, move_context)),
|
||||
OpUnary::Percentage => format!("{}%", to_string_moved(right, move_context)),
|
||||
},
|
||||
ErrorKind(kind) => format!("{kind}"),
|
||||
ErrorKind(kind) => format!("{}", kind),
|
||||
ParseErrorKind {
|
||||
formula,
|
||||
message: _,
|
||||
position: _,
|
||||
} => formula.to_string(),
|
||||
EmptyArgKind => "".to_string(),
|
||||
ImplicitIntersection {
|
||||
automatic: _,
|
||||
child,
|
||||
} => {
|
||||
format!("@{}", to_string_moved(child, move_context))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,8 +1,6 @@
|
||||
use super::{super::utils::quote_name, Node, Reference};
|
||||
use crate::constants::{LAST_COLUMN, LAST_ROW};
|
||||
use crate::expressions::parser::move_formula::to_string_array_node;
|
||||
use crate::expressions::parser::static_analysis::add_implicit_intersection;
|
||||
use crate::expressions::token::{OpSum, OpUnary};
|
||||
use crate::expressions::token::OpUnary;
|
||||
use crate::{expressions::types::CellReferenceRC, number_format::to_excel_precision_str};
|
||||
|
||||
pub enum DisplaceData {
|
||||
@@ -28,11 +26,6 @@ pub enum DisplaceData {
|
||||
column: i32,
|
||||
delta: i32,
|
||||
},
|
||||
RowMove {
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
delta: i32,
|
||||
},
|
||||
ColumnMove {
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
@@ -41,21 +34,10 @@ pub enum DisplaceData {
|
||||
None,
|
||||
}
|
||||
|
||||
/// This is the internal mode in IronCalc
|
||||
pub fn to_rc_format(node: &Node) -> String {
|
||||
stringify(node, None, &DisplaceData::None, false)
|
||||
}
|
||||
|
||||
/// This is the mode used to display the formula in the UI
|
||||
pub fn to_string(node: &Node, context: &CellReferenceRC) -> String {
|
||||
stringify(node, Some(context), &DisplaceData::None, false)
|
||||
}
|
||||
|
||||
/// This is the mode used to export the formula to Excel
|
||||
pub fn to_excel_string(node: &Node, context: &CellReferenceRC) -> String {
|
||||
stringify(node, Some(context), &DisplaceData::None, true)
|
||||
}
|
||||
|
||||
pub fn to_string_displaced(
|
||||
node: &Node,
|
||||
context: &CellReferenceRC,
|
||||
@@ -64,10 +46,18 @@ pub fn to_string_displaced(
|
||||
stringify(node, Some(context), displace_data, false)
|
||||
}
|
||||
|
||||
pub fn to_string(node: &Node, context: &CellReferenceRC) -> String {
|
||||
stringify(node, Some(context), &DisplaceData::None, false)
|
||||
}
|
||||
|
||||
pub fn to_excel_string(node: &Node, context: &CellReferenceRC) -> String {
|
||||
stringify(node, Some(context), &DisplaceData::None, true)
|
||||
}
|
||||
|
||||
/// Converts a local reference to a string applying some displacement if needed.
|
||||
/// It uses A1 style if context is not None. If context is None it uses R1C1 style
|
||||
/// If full_row is true then the row details will be omitted in the A1 case
|
||||
/// If full_column is true then column details will be omitted.
|
||||
/// If full_colum is true then column details will be omitted.
|
||||
pub(crate) fn stringify_reference(
|
||||
context: Option<&CellReferenceRC>,
|
||||
displace_data: &DisplaceData,
|
||||
@@ -164,29 +154,6 @@ pub(crate) fn stringify_reference(
|
||||
}
|
||||
}
|
||||
}
|
||||
DisplaceData::RowMove {
|
||||
sheet,
|
||||
row: move_row,
|
||||
delta,
|
||||
} => {
|
||||
if sheet_index == *sheet {
|
||||
if row == *move_row {
|
||||
row += *delta;
|
||||
} else if *delta > 0 {
|
||||
// Moving the row downwards
|
||||
if row > *move_row && row <= *move_row + *delta {
|
||||
// Intermediate rows move up by one position
|
||||
row -= 1;
|
||||
}
|
||||
} else if *delta < 0 {
|
||||
// Moving the row upwards
|
||||
if row < *move_row && row >= *move_row + *delta {
|
||||
// Intermediate rows move down by one position
|
||||
row += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
DisplaceData::ColumnMove {
|
||||
sheet,
|
||||
column: move_column,
|
||||
@@ -195,18 +162,14 @@ pub(crate) fn stringify_reference(
|
||||
if sheet_index == *sheet {
|
||||
if column == *move_column {
|
||||
column += *delta;
|
||||
} else if *delta > 0 {
|
||||
// Moving the column to the right
|
||||
if column > *move_column && column <= *move_column + *delta {
|
||||
// Intermediate columns move left by one position
|
||||
column -= 1;
|
||||
}
|
||||
} else if *delta < 0 {
|
||||
// Moving the column to the left
|
||||
if column < *move_column && column >= *move_column + *delta {
|
||||
// Intermediate columns move right by one position
|
||||
column += 1;
|
||||
}
|
||||
} else if (*delta > 0
|
||||
&& column > *move_column
|
||||
&& column <= *move_column + *delta)
|
||||
|| (*delta < 0
|
||||
&& column < *move_column
|
||||
&& column >= *move_column + *delta)
|
||||
{
|
||||
column -= *delta;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -216,16 +179,16 @@ pub(crate) fn stringify_reference(
|
||||
return "#REF!".to_string();
|
||||
}
|
||||
let mut row_abs = if absolute_row {
|
||||
format!("${row}")
|
||||
format!("${}", row)
|
||||
} else {
|
||||
format!("{row}")
|
||||
format!("{}", row)
|
||||
};
|
||||
let column = match crate::expressions::utils::number_to_column(column) {
|
||||
Some(s) => s,
|
||||
None => return "#REF!".to_string(),
|
||||
};
|
||||
let mut col_abs = if absolute_column {
|
||||
format!("${column}")
|
||||
format!("${}", column)
|
||||
} else {
|
||||
column
|
||||
};
|
||||
@@ -240,27 +203,27 @@ pub(crate) fn stringify_reference(
|
||||
format!("{}!{}{}", quote_name(name), col_abs, row_abs)
|
||||
}
|
||||
None => {
|
||||
format!("{col_abs}{row_abs}")
|
||||
format!("{}{}", col_abs, row_abs)
|
||||
}
|
||||
}
|
||||
}
|
||||
None => {
|
||||
let row_abs = if absolute_row {
|
||||
format!("R{row}")
|
||||
format!("R{}", row)
|
||||
} else {
|
||||
format!("R[{row}]")
|
||||
format!("R[{}]", row)
|
||||
};
|
||||
let col_abs = if absolute_column {
|
||||
format!("C{column}")
|
||||
format!("C{}", column)
|
||||
} else {
|
||||
format!("C[{column}]")
|
||||
format!("C[{}]", column)
|
||||
};
|
||||
match &sheet_name {
|
||||
Some(name) => {
|
||||
format!("{}!{}{}", quote_name(name), row_abs, col_abs)
|
||||
}
|
||||
None => {
|
||||
format!("{row_abs}{col_abs}")
|
||||
format!("{}{}", row_abs, col_abs)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -272,7 +235,7 @@ fn format_function(
|
||||
args: &Vec<Node>,
|
||||
context: Option<&CellReferenceRC>,
|
||||
displace_data: &DisplaceData,
|
||||
export_to_excel: bool,
|
||||
use_original_name: bool,
|
||||
) -> String {
|
||||
let mut first = true;
|
||||
let mut arguments = "".to_string();
|
||||
@@ -281,52 +244,27 @@ fn format_function(
|
||||
arguments = format!(
|
||||
"{},{}",
|
||||
arguments,
|
||||
stringify(el, context, displace_data, export_to_excel)
|
||||
stringify(el, context, displace_data, use_original_name)
|
||||
);
|
||||
} else {
|
||||
first = false;
|
||||
arguments = stringify(el, context, displace_data, export_to_excel);
|
||||
arguments = stringify(el, context, displace_data, use_original_name);
|
||||
}
|
||||
}
|
||||
format!("{name}({arguments})")
|
||||
format!("{}({})", name, arguments)
|
||||
}
|
||||
|
||||
// There is just one representation in the AST (Abstract Syntax Tree) of a formula.
|
||||
// But three different ways to convert it to a string.
|
||||
//
|
||||
// To stringify a formula we need a "context", that is in which cell are we doing the "stringifying"
|
||||
//
|
||||
// But there are three ways to stringify a formula:
|
||||
//
|
||||
// * To show it to the IronCalc user
|
||||
// * To store internally
|
||||
// * To export to Excel
|
||||
//
|
||||
// There are, of course correspondingly three "modes" when parsing a formula.
|
||||
//
|
||||
// The internal representation is the more different as references are stored in the RC representation.
|
||||
// The the AST of the formula is kept close to this representation we don't need a context
|
||||
//
|
||||
// In the export to Excel representation certain things are different:
|
||||
// * We add a _xlfn. in front of some (more modern) functions
|
||||
// * We remove the Implicit Intersection operator when it is automatic and add _xlfn.SINGLE when it is not
|
||||
//
|
||||
// Examples:
|
||||
// * =A1+B2
|
||||
// * =RC+R1C1
|
||||
// * =A1+B1
|
||||
|
||||
fn stringify(
|
||||
node: &Node,
|
||||
context: Option<&CellReferenceRC>,
|
||||
displace_data: &DisplaceData,
|
||||
export_to_excel: bool,
|
||||
use_original_name: bool,
|
||||
) -> String {
|
||||
use self::Node::*;
|
||||
match node {
|
||||
BooleanKind(value) => format!("{value}").to_ascii_uppercase(),
|
||||
BooleanKind(value) => format!("{}", value).to_ascii_uppercase(),
|
||||
NumberKind(number) => to_excel_precision_str(*number),
|
||||
StringKind(value) => format!("\"{value}\""),
|
||||
StringKind(value) => format!("\"{}\"", value),
|
||||
WrongReferenceKind {
|
||||
sheet_name,
|
||||
column,
|
||||
@@ -416,7 +354,7 @@ fn stringify(
|
||||
full_row,
|
||||
full_column,
|
||||
);
|
||||
format!("{s1}:{s2}")
|
||||
format!("{}:{}", s1, s2)
|
||||
}
|
||||
WrongRangeKind {
|
||||
sheet_name,
|
||||
@@ -465,234 +403,114 @@ fn stringify(
|
||||
full_row,
|
||||
full_column,
|
||||
);
|
||||
format!("{s1}:{s2}")
|
||||
format!("{}:{}", s1, s2)
|
||||
}
|
||||
OpRangeKind { left, right } => format!(
|
||||
"{}:{}",
|
||||
stringify(left, context, displace_data, export_to_excel),
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
stringify(left, context, displace_data, use_original_name),
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
OpConcatenateKind { left, right } => format!(
|
||||
"{}&{}",
|
||||
stringify(left, context, displace_data, export_to_excel),
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
stringify(left, context, displace_data, use_original_name),
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
CompareKind { kind, left, right } => format!(
|
||||
"{}{}{}",
|
||||
stringify(left, context, displace_data, export_to_excel),
|
||||
stringify(left, context, displace_data, use_original_name),
|
||||
kind,
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
OpSumKind { kind, left, right } => format!(
|
||||
"{}{}{}",
|
||||
stringify(left, context, displace_data, use_original_name),
|
||||
kind,
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
OpSumKind { kind, left, right } => {
|
||||
let left_str = stringify(left, context, displace_data, export_to_excel);
|
||||
// if kind is minus then we need parentheses in the right side if they are OpSumKind or CompareKind
|
||||
let right_str = if (matches!(kind, OpSum::Minus) && matches!(**right, OpSumKind { .. }))
|
||||
| matches!(**right, CompareKind { .. })
|
||||
{
|
||||
format!(
|
||||
"({})",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
)
|
||||
} else {
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
};
|
||||
|
||||
format!("{left_str}{kind}{right_str}")
|
||||
}
|
||||
OpProductKind { kind, left, right } => {
|
||||
let x = match **left {
|
||||
OpSumKind { .. } | CompareKind { .. } => format!(
|
||||
OpSumKind { .. } => format!(
|
||||
"({})",
|
||||
stringify(left, context, displace_data, export_to_excel)
|
||||
stringify(left, context, displace_data, use_original_name)
|
||||
),
|
||||
_ => stringify(left, context, displace_data, export_to_excel),
|
||||
CompareKind { .. } => format!(
|
||||
"({})",
|
||||
stringify(left, context, displace_data, use_original_name)
|
||||
),
|
||||
_ => stringify(left, context, displace_data, use_original_name),
|
||||
};
|
||||
let y = match **right {
|
||||
OpSumKind { .. } | CompareKind { .. } | OpProductKind { .. } => format!(
|
||||
OpSumKind { .. } => format!(
|
||||
"({})",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
_ => stringify(right, context, displace_data, export_to_excel),
|
||||
CompareKind { .. } => format!(
|
||||
"({})",
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
OpProductKind { .. } => format!(
|
||||
"({})",
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
_ => stringify(right, context, displace_data, use_original_name),
|
||||
};
|
||||
format!("{x}{kind}{y}")
|
||||
}
|
||||
OpPowerKind { left, right } => {
|
||||
let x = match **left {
|
||||
BooleanKind(_)
|
||||
| NumberKind(_)
|
||||
| UnaryKind { .. }
|
||||
| StringKind(_)
|
||||
| ReferenceKind { .. }
|
||||
| RangeKind { .. }
|
||||
| WrongReferenceKind { .. }
|
||||
| DefinedNameKind(_)
|
||||
| TableNameKind(_)
|
||||
| WrongVariableKind(_)
|
||||
| WrongRangeKind { .. } => stringify(left, context, displace_data, export_to_excel),
|
||||
OpRangeKind { .. }
|
||||
| OpConcatenateKind { .. }
|
||||
| OpProductKind { .. }
|
||||
| OpPowerKind { .. }
|
||||
| FunctionKind { .. }
|
||||
| InvalidFunctionKind { .. }
|
||||
| ArrayKind(_)
|
||||
| ErrorKind(_)
|
||||
| ParseErrorKind { .. }
|
||||
| OpSumKind { .. }
|
||||
| CompareKind { .. }
|
||||
| ImplicitIntersection { .. }
|
||||
| EmptyArgKind => format!(
|
||||
"({})",
|
||||
stringify(left, context, displace_data, export_to_excel)
|
||||
),
|
||||
};
|
||||
let y = match **right {
|
||||
BooleanKind(_)
|
||||
| NumberKind(_)
|
||||
| StringKind(_)
|
||||
| ReferenceKind { .. }
|
||||
| RangeKind { .. }
|
||||
| WrongReferenceKind { .. }
|
||||
| DefinedNameKind(_)
|
||||
| TableNameKind(_)
|
||||
| WrongVariableKind(_)
|
||||
| WrongRangeKind { .. } => {
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
}
|
||||
OpRangeKind { .. }
|
||||
| OpConcatenateKind { .. }
|
||||
| OpProductKind { .. }
|
||||
| OpPowerKind { .. }
|
||||
| FunctionKind { .. }
|
||||
| InvalidFunctionKind { .. }
|
||||
| ArrayKind(_)
|
||||
| UnaryKind { .. }
|
||||
| ErrorKind(_)
|
||||
| ParseErrorKind { .. }
|
||||
| OpSumKind { .. }
|
||||
| CompareKind { .. }
|
||||
| ImplicitIntersection { .. }
|
||||
| EmptyArgKind => format!(
|
||||
"({})",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
),
|
||||
};
|
||||
format!("{x}^{y}")
|
||||
format!("{}{}{}", x, kind, y)
|
||||
}
|
||||
OpPowerKind { left, right } => format!(
|
||||
"{}^{}",
|
||||
stringify(left, context, displace_data, use_original_name),
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
),
|
||||
InvalidFunctionKind { name, args } => {
|
||||
format_function(name, args, context, displace_data, export_to_excel)
|
||||
format_function(name, args, context, displace_data, use_original_name)
|
||||
}
|
||||
FunctionKind { kind, args } => {
|
||||
let name = if export_to_excel {
|
||||
let name = if use_original_name {
|
||||
kind.to_xlsx_string()
|
||||
} else {
|
||||
kind.to_string()
|
||||
};
|
||||
format_function(&name, args, context, displace_data, export_to_excel)
|
||||
format_function(&name, args, context, displace_data, use_original_name)
|
||||
}
|
||||
ArrayKind(args) => {
|
||||
let mut first_row = true;
|
||||
let mut matrix_string = String::new();
|
||||
|
||||
for row in args {
|
||||
if !first_row {
|
||||
matrix_string.push(';');
|
||||
let mut first = true;
|
||||
let mut arguments = "".to_string();
|
||||
for el in args {
|
||||
if !first {
|
||||
arguments = format!(
|
||||
"{},{}",
|
||||
arguments,
|
||||
stringify(el, context, displace_data, use_original_name)
|
||||
);
|
||||
} else {
|
||||
first_row = false;
|
||||
first = false;
|
||||
arguments = stringify(el, context, displace_data, use_original_name);
|
||||
}
|
||||
let mut first_column = true;
|
||||
let mut row_string = String::new();
|
||||
for el in row {
|
||||
if !first_column {
|
||||
row_string.push(',');
|
||||
} else {
|
||||
first_column = false;
|
||||
}
|
||||
row_string.push_str(&to_string_array_node(el));
|
||||
}
|
||||
matrix_string.push_str(&row_string);
|
||||
}
|
||||
format!("{{{matrix_string}}}")
|
||||
format!("{{{}}}", arguments)
|
||||
}
|
||||
TableNameKind(value) => value.to_string(),
|
||||
DefinedNameKind((name, ..)) => name.to_string(),
|
||||
WrongVariableKind(name) => name.to_string(),
|
||||
VariableKind(value) => value.to_string(),
|
||||
UnaryKind { kind, right } => match kind {
|
||||
OpUnary::Minus => {
|
||||
let needs_parentheses = match **right {
|
||||
BooleanKind(_)
|
||||
| NumberKind(_)
|
||||
| StringKind(_)
|
||||
| ReferenceKind { .. }
|
||||
| RangeKind { .. }
|
||||
| WrongReferenceKind { .. }
|
||||
| WrongRangeKind { .. }
|
||||
| OpRangeKind { .. }
|
||||
| OpConcatenateKind { .. }
|
||||
| OpProductKind { .. }
|
||||
| FunctionKind { .. }
|
||||
| InvalidFunctionKind { .. }
|
||||
| ArrayKind(_)
|
||||
| DefinedNameKind(_)
|
||||
| TableNameKind(_)
|
||||
| WrongVariableKind(_)
|
||||
| ImplicitIntersection { .. }
|
||||
| CompareKind { .. }
|
||||
| ErrorKind(_)
|
||||
| ParseErrorKind { .. }
|
||||
| EmptyArgKind => false,
|
||||
|
||||
OpPowerKind { .. } | OpSumKind { .. } | UnaryKind { .. } => true,
|
||||
};
|
||||
if needs_parentheses {
|
||||
format!(
|
||||
"-({})",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
)
|
||||
} else {
|
||||
format!(
|
||||
"-{}",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
)
|
||||
}
|
||||
format!(
|
||||
"-{}",
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
)
|
||||
}
|
||||
OpUnary::Percentage => {
|
||||
format!(
|
||||
"{}%",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
stringify(right, context, displace_data, use_original_name)
|
||||
)
|
||||
}
|
||||
},
|
||||
ErrorKind(kind) => format!("{kind}"),
|
||||
ErrorKind(kind) => format!("{}", kind),
|
||||
ParseErrorKind {
|
||||
formula,
|
||||
position: _,
|
||||
message: _,
|
||||
} => formula.to_string(),
|
||||
EmptyArgKind => "".to_string(),
|
||||
ImplicitIntersection {
|
||||
automatic: _,
|
||||
child,
|
||||
} => {
|
||||
if export_to_excel {
|
||||
// We need to check wether the II can be automatic or not
|
||||
let mut new_node = child.as_ref().clone();
|
||||
|
||||
add_implicit_intersection(&mut new_node, true);
|
||||
if matches!(&new_node, Node::ImplicitIntersection { .. }) {
|
||||
return stringify(child, context, displace_data, export_to_excel);
|
||||
}
|
||||
|
||||
return format!(
|
||||
"_xlfn.SINGLE({})",
|
||||
stringify(child, context, displace_data, export_to_excel)
|
||||
);
|
||||
}
|
||||
format!(
|
||||
"@{}",
|
||||
stringify(child, context, displace_data, export_to_excel)
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -780,12 +598,6 @@ pub(crate) fn rename_sheet_in_node(node: &mut Node, sheet_index: u32, new_name:
|
||||
Node::UnaryKind { kind: _, right } => {
|
||||
rename_sheet_in_node(right, sheet_index, new_name);
|
||||
}
|
||||
Node::ImplicitIntersection {
|
||||
automatic: _,
|
||||
child,
|
||||
} => {
|
||||
rename_sheet_in_node(child, sheet_index, new_name);
|
||||
}
|
||||
|
||||
// Do nothing
|
||||
Node::BooleanKind(_) => {}
|
||||
@@ -794,96 +606,7 @@ pub(crate) fn rename_sheet_in_node(node: &mut Node, sheet_index: u32, new_name:
|
||||
Node::ErrorKind(_) => {}
|
||||
Node::ParseErrorKind { .. } => {}
|
||||
Node::ArrayKind(_) => {}
|
||||
Node::DefinedNameKind(_) => {}
|
||||
Node::TableNameKind(_) => {}
|
||||
Node::WrongVariableKind(_) => {}
|
||||
Node::VariableKind(_) => {}
|
||||
Node::EmptyArgKind => {}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn rename_defined_name_in_node(
|
||||
node: &mut Node,
|
||||
name: &str,
|
||||
scope: Option<u32>,
|
||||
new_name: &str,
|
||||
) {
|
||||
match node {
|
||||
// Rename
|
||||
Node::DefinedNameKind((n, s, _)) => {
|
||||
if name.to_lowercase() == n.to_lowercase() && *s == scope {
|
||||
*n = new_name.to_string();
|
||||
}
|
||||
}
|
||||
// Go next level
|
||||
Node::OpRangeKind { left, right } => {
|
||||
rename_defined_name_in_node(left, name, scope, new_name);
|
||||
rename_defined_name_in_node(right, name, scope, new_name);
|
||||
}
|
||||
Node::OpConcatenateKind { left, right } => {
|
||||
rename_defined_name_in_node(left, name, scope, new_name);
|
||||
rename_defined_name_in_node(right, name, scope, new_name);
|
||||
}
|
||||
Node::OpSumKind {
|
||||
kind: _,
|
||||
left,
|
||||
right,
|
||||
} => {
|
||||
rename_defined_name_in_node(left, name, scope, new_name);
|
||||
rename_defined_name_in_node(right, name, scope, new_name);
|
||||
}
|
||||
Node::OpProductKind {
|
||||
kind: _,
|
||||
left,
|
||||
right,
|
||||
} => {
|
||||
rename_defined_name_in_node(left, name, scope, new_name);
|
||||
rename_defined_name_in_node(right, name, scope, new_name);
|
||||
}
|
||||
Node::OpPowerKind { left, right } => {
|
||||
rename_defined_name_in_node(left, name, scope, new_name);
|
||||
rename_defined_name_in_node(right, name, scope, new_name);
|
||||
}
|
||||
Node::FunctionKind { kind: _, args } => {
|
||||
for arg in args {
|
||||
rename_defined_name_in_node(arg, name, scope, new_name);
|
||||
}
|
||||
}
|
||||
Node::InvalidFunctionKind { name: _, args } => {
|
||||
for arg in args {
|
||||
rename_defined_name_in_node(arg, name, scope, new_name);
|
||||
}
|
||||
}
|
||||
Node::CompareKind {
|
||||
kind: _,
|
||||
left,
|
||||
right,
|
||||
} => {
|
||||
rename_defined_name_in_node(left, name, scope, new_name);
|
||||
rename_defined_name_in_node(right, name, scope, new_name);
|
||||
}
|
||||
Node::UnaryKind { kind: _, right } => {
|
||||
rename_defined_name_in_node(right, name, scope, new_name);
|
||||
}
|
||||
Node::ImplicitIntersection {
|
||||
automatic: _,
|
||||
child,
|
||||
} => {
|
||||
rename_defined_name_in_node(child, name, scope, new_name);
|
||||
}
|
||||
|
||||
// Do nothing
|
||||
Node::BooleanKind(_) => {}
|
||||
Node::NumberKind(_) => {}
|
||||
Node::StringKind(_) => {}
|
||||
Node::ErrorKind(_) => {}
|
||||
Node::ParseErrorKind { .. } => {}
|
||||
Node::ArrayKind(_) => {}
|
||||
Node::EmptyArgKind => {}
|
||||
Node::ReferenceKind { .. } => {}
|
||||
Node::RangeKind { .. } => {}
|
||||
Node::WrongReferenceKind { .. } => {}
|
||||
Node::WrongRangeKind { .. } => {}
|
||||
Node::TableNameKind(_) => {}
|
||||
Node::WrongVariableKind(_) => {}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3,11 +3,17 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::lexer::LexerMode;
|
||||
use crate::expressions::parser::stringify::{
|
||||
to_rc_format, to_string, to_string_displaced, DisplaceData,
|
||||
use crate::expressions::parser::stringify::DisplaceData;
|
||||
|
||||
use super::super::types::CellReferenceRC;
|
||||
use super::Parser;
|
||||
use super::{
|
||||
super::parser::{
|
||||
stringify::{to_rc_format, to_string},
|
||||
Node,
|
||||
},
|
||||
stringify::to_string_displaced,
|
||||
};
|
||||
use crate::expressions::parser::{Node, Parser};
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
|
||||
struct Formula<'a> {
|
||||
initial: &'a str,
|
||||
@@ -17,7 +23,7 @@ struct Formula<'a> {
|
||||
#[test]
|
||||
fn test_parser_reference() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -25,14 +31,14 @@ fn test_parser_reference() {
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let t = parser.parse("A2", &cell_reference);
|
||||
let t = parser.parse("A2", &Some(cell_reference));
|
||||
assert_eq!(to_rc_format(&t), "R[1]C[0]");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parser_absolute_column() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -40,14 +46,14 @@ fn test_parser_absolute_column() {
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let t = parser.parse("$A1", &cell_reference);
|
||||
let t = parser.parse("$A1", &Some(cell_reference));
|
||||
assert_eq!(to_rc_format(&t), "R[0]C1");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parser_absolute_row_col() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -55,14 +61,14 @@ fn test_parser_absolute_row_col() {
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let t = parser.parse("$C$5", &cell_reference);
|
||||
let t = parser.parse("$C$5", &Some(cell_reference));
|
||||
assert_eq!(to_rc_format(&t), "R5C3");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parser_absolute_row_col_1() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -70,14 +76,14 @@ fn test_parser_absolute_row_col_1() {
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let t = parser.parse("$A$1", &cell_reference);
|
||||
let t = parser.parse("$A$1", &Some(cell_reference));
|
||||
assert_eq!(to_rc_format(&t), "R1C1");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parser_simple_formula() {
|
||||
let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -86,14 +92,14 @@ fn test_parser_simple_formula() {
|
||||
column: 1,
|
||||
};
|
||||
|
||||
let t = parser.parse("C3+Sheet2!D4", &cell_reference);
|
||||
let t = parser.parse("C3+Sheet2!D4", &Some(cell_reference));
|
||||
assert_eq!(to_rc_format(&t), "R[2]C[2]+Sheet2!R[3]C[3]");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parser_boolean() {
|
||||
let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -102,14 +108,14 @@ fn test_parser_boolean() {
|
||||
column: 1,
|
||||
};
|
||||
|
||||
let t = parser.parse("true", &cell_reference);
|
||||
let t = parser.parse("true", &Some(cell_reference));
|
||||
assert_eq!(to_rc_format(&t), "TRUE");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parser_bad_formula() {
|
||||
let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -117,7 +123,7 @@ fn test_parser_bad_formula() {
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let t = parser.parse("#Value", &cell_reference);
|
||||
let t = parser.parse("#Value", &Some(cell_reference));
|
||||
match &t {
|
||||
Node::ParseErrorKind {
|
||||
formula,
|
||||
@@ -138,7 +144,7 @@ fn test_parser_bad_formula() {
|
||||
#[test]
|
||||
fn test_parser_bad_formula_1() {
|
||||
let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -146,7 +152,7 @@ fn test_parser_bad_formula_1() {
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let t = parser.parse("<5", &cell_reference);
|
||||
let t = parser.parse("<5", &Some(cell_reference));
|
||||
match &t {
|
||||
Node::ParseErrorKind {
|
||||
formula,
|
||||
@@ -167,7 +173,7 @@ fn test_parser_bad_formula_1() {
|
||||
#[test]
|
||||
fn test_parser_bad_formula_2() {
|
||||
let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -175,7 +181,7 @@ fn test_parser_bad_formula_2() {
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let t = parser.parse("*5", &cell_reference);
|
||||
let t = parser.parse("*5", &Some(cell_reference));
|
||||
match &t {
|
||||
Node::ParseErrorKind {
|
||||
formula,
|
||||
@@ -196,7 +202,7 @@ fn test_parser_bad_formula_2() {
|
||||
#[test]
|
||||
fn test_parser_bad_formula_3() {
|
||||
let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -204,7 +210,7 @@ fn test_parser_bad_formula_3() {
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let t = parser.parse("SUM(#VALVE!)", &cell_reference);
|
||||
let t = parser.parse("SUM(#VALVE!)", &Some(cell_reference));
|
||||
match &t {
|
||||
Node::ParseErrorKind {
|
||||
formula,
|
||||
@@ -225,7 +231,7 @@ fn test_parser_bad_formula_3() {
|
||||
#[test]
|
||||
fn test_parser_formulas() {
|
||||
let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
let formulas = vec![
|
||||
Formula {
|
||||
@@ -259,11 +265,11 @@ fn test_parser_formulas() {
|
||||
for formula in formulas {
|
||||
let t = parser.parse(
|
||||
formula.initial,
|
||||
&CellReferenceRC {
|
||||
&Some(CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
},
|
||||
}),
|
||||
);
|
||||
assert_eq!(to_rc_format(&t), formula.expected);
|
||||
assert_eq!(to_string(&t, &cell_reference), formula.initial);
|
||||
@@ -273,7 +279,7 @@ fn test_parser_formulas() {
|
||||
#[test]
|
||||
fn test_parser_r1c1_formulas() {
|
||||
let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
parser.set_lexer_mode(LexerMode::R1C1);
|
||||
|
||||
let formulas = vec![
|
||||
@@ -324,11 +330,11 @@ fn test_parser_r1c1_formulas() {
|
||||
for formula in formulas {
|
||||
let t = parser.parse(
|
||||
formula.initial,
|
||||
&CellReferenceRC {
|
||||
&Some(CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
},
|
||||
}),
|
||||
);
|
||||
assert_eq!(to_string(&t, &cell_reference), formula.expected);
|
||||
assert_eq!(to_rc_format(&t), formula.initial);
|
||||
@@ -338,7 +344,7 @@ fn test_parser_r1c1_formulas() {
|
||||
#[test]
|
||||
fn test_parser_quotes() {
|
||||
let worksheets = vec!["Sheet1".to_string(), "Second Sheet".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -347,14 +353,14 @@ fn test_parser_quotes() {
|
||||
column: 1,
|
||||
};
|
||||
|
||||
let t = parser.parse("C3+'Second Sheet'!D4", &cell_reference);
|
||||
let t = parser.parse("C3+'Second Sheet'!D4", &Some(cell_reference));
|
||||
assert_eq!(to_rc_format(&t), "R[2]C[2]+'Second Sheet'!R[3]C[3]");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parser_escape_quotes() {
|
||||
let worksheets = vec!["Sheet1".to_string(), "Second '2' Sheet".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -363,14 +369,14 @@ fn test_parser_escape_quotes() {
|
||||
column: 1,
|
||||
};
|
||||
|
||||
let t = parser.parse("C3+'Second ''2'' Sheet'!D4", &cell_reference);
|
||||
let t = parser.parse("C3+'Second ''2'' Sheet'!D4", &Some(cell_reference));
|
||||
assert_eq!(to_rc_format(&t), "R[2]C[2]+'Second ''2'' Sheet'!R[3]C[3]");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parser_parenthesis() {
|
||||
let worksheets = vec!["Sheet1".to_string(), "Second2".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -379,14 +385,14 @@ fn test_parser_parenthesis() {
|
||||
column: 1,
|
||||
};
|
||||
|
||||
let t = parser.parse("(C3=\"Yes\")*5", &cell_reference);
|
||||
let t = parser.parse("(C3=\"Yes\")*5", &Some(cell_reference));
|
||||
assert_eq!(to_rc_format(&t), "(R[2]C[2]=\"Yes\")*5");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parser_excel_xlfn() {
|
||||
let worksheets = vec!["Sheet1".to_string(), "Second2".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -395,7 +401,7 @@ fn test_parser_excel_xlfn() {
|
||||
column: 1,
|
||||
};
|
||||
|
||||
let t = parser.parse("_xlfn.CONCAT(C3)", &cell_reference);
|
||||
let t = parser.parse("_xlfn.CONCAT(C3)", &Some(cell_reference));
|
||||
assert_eq!(to_rc_format(&t), "CONCAT(R[2]C[2])");
|
||||
}
|
||||
|
||||
@@ -407,9 +413,9 @@ fn test_to_string_displaced() {
|
||||
column: 1,
|
||||
};
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
let node = parser.parse("C3", context);
|
||||
let node = parser.parse("C3", &Some(context.clone()));
|
||||
let displace_data = DisplaceData::Column {
|
||||
sheet: 0,
|
||||
column: 1,
|
||||
@@ -427,9 +433,9 @@ fn test_to_string_displaced_full_ranges() {
|
||||
column: 1,
|
||||
};
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
let node = parser.parse("SUM(3:3)", context);
|
||||
let node = parser.parse("SUM(3:3)", &Some(context.clone()));
|
||||
let displace_data = DisplaceData::Column {
|
||||
sheet: 0,
|
||||
column: 1,
|
||||
@@ -440,7 +446,7 @@ fn test_to_string_displaced_full_ranges() {
|
||||
"SUM(3:3)".to_string()
|
||||
);
|
||||
|
||||
let node = parser.parse("SUM(D:D)", context);
|
||||
let node = parser.parse("SUM(D:D)", &Some(context.clone()));
|
||||
let displace_data = DisplaceData::Row {
|
||||
sheet: 0,
|
||||
row: 3,
|
||||
@@ -460,9 +466,9 @@ fn test_to_string_displaced_too_low() {
|
||||
column: 1,
|
||||
};
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
let node = parser.parse("C3", context);
|
||||
let node = parser.parse("C3", &Some(context.clone()));
|
||||
let displace_data = DisplaceData::Column {
|
||||
sheet: 0,
|
||||
column: 1,
|
||||
@@ -480,9 +486,9 @@ fn test_to_string_displaced_too_high() {
|
||||
column: 1,
|
||||
};
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
let node = parser.parse("C3", context);
|
||||
let node = parser.parse("C3", &Some(context.clone()));
|
||||
let displace_data = DisplaceData::Column {
|
||||
sheet: 0,
|
||||
column: 1,
|
||||
@@ -1,8 +1,10 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::parser::move_formula::{move_formula, MoveContext};
|
||||
use crate::expressions::parser::Parser;
|
||||
use crate::expressions::types::{Area, CellReferenceRC};
|
||||
use crate::expressions::types::Area;
|
||||
|
||||
use super::super::types::CellReferenceRC;
|
||||
use super::Parser;
|
||||
|
||||
#[test]
|
||||
fn test_move_formula() {
|
||||
@@ -15,7 +17,7 @@ fn test_move_formula() {
|
||||
column,
|
||||
};
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Area is C2:F6
|
||||
let area = &Area {
|
||||
@@ -27,7 +29,7 @@ fn test_move_formula() {
|
||||
};
|
||||
|
||||
// formula AB31 will not change
|
||||
let node = parser.parse("AB31", context);
|
||||
let node = parser.parse("AB31", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -43,7 +45,7 @@ fn test_move_formula() {
|
||||
assert_eq!(t, "AB31");
|
||||
|
||||
// formula $AB$31 will not change
|
||||
let node = parser.parse("AB31", context);
|
||||
let node = parser.parse("AB31", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -59,7 +61,7 @@ fn test_move_formula() {
|
||||
assert_eq!(t, "AB31");
|
||||
|
||||
// but formula D5 will change to N15 (N = D + 10)
|
||||
let node = parser.parse("D5", context);
|
||||
let node = parser.parse("D5", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -75,7 +77,7 @@ fn test_move_formula() {
|
||||
assert_eq!(t, "N15");
|
||||
|
||||
// Also formula $D$5 will change to N15 (N = D + 10)
|
||||
let node = parser.parse("$D$5", context);
|
||||
let node = parser.parse("$D$5", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -102,7 +104,7 @@ fn test_move_formula_context_offset() {
|
||||
column,
|
||||
};
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Area is C2:F6
|
||||
let area = &Area {
|
||||
@@ -113,7 +115,7 @@ fn test_move_formula_context_offset() {
|
||||
height: 5,
|
||||
};
|
||||
|
||||
let node = parser.parse("-X9+C2%", context);
|
||||
let node = parser.parse("-X9+C2%", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -140,7 +142,7 @@ fn test_move_formula_area_limits() {
|
||||
column,
|
||||
};
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Area is C2:F6
|
||||
let area = &Area {
|
||||
@@ -152,7 +154,7 @@ fn test_move_formula_area_limits() {
|
||||
};
|
||||
|
||||
// Outside of the area. Not moved
|
||||
let node = parser.parse("B2+B3+C1+G6+H5", context);
|
||||
let node = parser.parse("B2+B3+C1+G6+H5", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -168,7 +170,7 @@ fn test_move_formula_area_limits() {
|
||||
assert_eq!(t, "B2+B3+C1+G6+H5");
|
||||
|
||||
// In the area. Moved
|
||||
let node = parser.parse("C2+F4+F5+F6", context);
|
||||
let node = parser.parse("C2+F4+F5+F6", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -195,7 +197,7 @@ fn test_move_formula_ranges() {
|
||||
column,
|
||||
};
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
let area = &Area {
|
||||
sheet: 0,
|
||||
@@ -205,7 +207,7 @@ fn test_move_formula_ranges() {
|
||||
height: 5,
|
||||
};
|
||||
// Ranges inside the area are fully displaced (absolute or not)
|
||||
let node = parser.parse("SUM(C2:F5)", context);
|
||||
let node = parser.parse("SUM(C2:F5)", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -220,7 +222,7 @@ fn test_move_formula_ranges() {
|
||||
);
|
||||
assert_eq!(t, "SUM(M12:P15)");
|
||||
|
||||
let node = parser.parse("SUM($C$2:$F$5)", context);
|
||||
let node = parser.parse("SUM($C$2:$F$5)", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -236,7 +238,7 @@ fn test_move_formula_ranges() {
|
||||
assert_eq!(t, "SUM($M$12:$P$15)");
|
||||
|
||||
// Ranges completely outside of the area are not touched
|
||||
let node = parser.parse("SUM(A1:B3)", context);
|
||||
let node = parser.parse("SUM(A1:B3)", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -251,7 +253,7 @@ fn test_move_formula_ranges() {
|
||||
);
|
||||
assert_eq!(t, "SUM(A1:B3)");
|
||||
|
||||
let node = parser.parse("SUM($A$1:$B$3)", context);
|
||||
let node = parser.parse("SUM($A$1:$B$3)", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -267,7 +269,7 @@ fn test_move_formula_ranges() {
|
||||
assert_eq!(t, "SUM($A$1:$B$3)");
|
||||
|
||||
// Ranges that overlap with the area are also NOT displaced
|
||||
let node = parser.parse("SUM(A1:F5)", context);
|
||||
let node = parser.parse("SUM(A1:F5)", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -283,7 +285,7 @@ fn test_move_formula_ranges() {
|
||||
assert_eq!(t, "SUM(A1:F5)");
|
||||
|
||||
// Ranges that contain the area are also NOT displaced
|
||||
let node = parser.parse("SUM(A1:X50)", context);
|
||||
let node = parser.parse("SUM(A1:X50)", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -318,10 +320,10 @@ fn test_move_formula_wrong_reference() {
|
||||
height: 5,
|
||||
};
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Wrong formulas will NOT be displaced
|
||||
let node = parser.parse("Sheet3!AB31", context);
|
||||
let node = parser.parse("Sheet3!AB31", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -335,7 +337,7 @@ fn test_move_formula_wrong_reference() {
|
||||
},
|
||||
);
|
||||
assert_eq!(t, "Sheet3!AB31");
|
||||
let node = parser.parse("Sheet3!$X$9", context);
|
||||
let node = parser.parse("Sheet3!$X$9", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -350,7 +352,7 @@ fn test_move_formula_wrong_reference() {
|
||||
);
|
||||
assert_eq!(t, "Sheet3!$X$9");
|
||||
|
||||
let node = parser.parse("SUM(Sheet3!D2:D3)", context);
|
||||
let node = parser.parse("SUM(Sheet3!D2:D3)", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -377,7 +379,7 @@ fn test_move_formula_misc() {
|
||||
column,
|
||||
};
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Area is C2:F6
|
||||
let area = &Area {
|
||||
@@ -387,7 +389,7 @@ fn test_move_formula_misc() {
|
||||
width: 4,
|
||||
height: 5,
|
||||
};
|
||||
let node = parser.parse("X9^C2-F4*H2+SUM(F2:H4)+SUM(C2:F6)", context);
|
||||
let node = parser.parse("X9^C2-F4*H2", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -400,9 +402,9 @@ fn test_move_formula_misc() {
|
||||
column_delta: 10,
|
||||
},
|
||||
);
|
||||
assert_eq!(t, "X9^M12-P14*H2+SUM(F2:H4)+SUM(M12:P16)");
|
||||
assert_eq!(t, "X9^M12-P14*H2");
|
||||
|
||||
let node = parser.parse("F5*(-D5)*SUM(A1, X9, $D$5)", context);
|
||||
let node = parser.parse("F5*(-D5)*SUM(A1, X9, $D$5)", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -417,7 +419,7 @@ fn test_move_formula_misc() {
|
||||
);
|
||||
assert_eq!(t, "P15*(-N15)*SUM(A1,X9,$N$15)");
|
||||
|
||||
let node = parser.parse("IF(F5 < -D5, X9 & F5, FALSE)", context);
|
||||
let node = parser.parse("IF(F5 < -D5, X9 & F5, FALSE)", &Some(context.clone()));
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -445,7 +447,7 @@ fn test_move_formula_another_sheet() {
|
||||
};
|
||||
// we add two sheets and we cut/paste from Sheet1 to Sheet2
|
||||
let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Area is C2:F6
|
||||
let area = &Area {
|
||||
@@ -457,7 +459,10 @@ fn test_move_formula_another_sheet() {
|
||||
};
|
||||
|
||||
// Formula AB31 and JJ3:JJ4 refers to original Sheet1!AB31 and Sheet1!JJ3:JJ4
|
||||
let node = parser.parse("AB31*SUM(JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(C2:F6)", context);
|
||||
let node = parser.parse(
|
||||
"AB31*SUM(JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(C2:F6)",
|
||||
&Some(context.clone()),
|
||||
);
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
@@ -475,77 +480,3 @@ fn test_move_formula_another_sheet() {
|
||||
"Sheet1!AB31*SUM(Sheet1!JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(M12:P16)"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn move_formula_implicit_intersetion() {
|
||||
// context is E4
|
||||
let row = 4;
|
||||
let column = 5;
|
||||
let context = &CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row,
|
||||
column,
|
||||
};
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Area is C2:F6
|
||||
let area = &Area {
|
||||
sheet: 0,
|
||||
row: 2,
|
||||
column: 3,
|
||||
width: 4,
|
||||
height: 5,
|
||||
};
|
||||
let node = parser.parse("SUM(@F2:H4)+SUM(@C2:F6)", context);
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
source_sheet_name: "Sheet1",
|
||||
row,
|
||||
column,
|
||||
area,
|
||||
target_sheet_name: "Sheet1",
|
||||
row_delta: 10,
|
||||
column_delta: 10,
|
||||
},
|
||||
);
|
||||
assert_eq!(t, "SUM(@F2:H4)+SUM(@M12:P16)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn move_formula_implicit_intersetion_with_ranges() {
|
||||
// context is E4
|
||||
let row = 4;
|
||||
let column = 5;
|
||||
let context = &CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row,
|
||||
column,
|
||||
};
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Area is C2:F6
|
||||
let area = &Area {
|
||||
sheet: 0,
|
||||
row: 2,
|
||||
column: 3,
|
||||
width: 4,
|
||||
height: 5,
|
||||
};
|
||||
let node = parser.parse("SUM(@F2:H4)+SUM(@C2:F6)+SUM(@A1, @X9, @$D$5)", context);
|
||||
let t = move_formula(
|
||||
&node,
|
||||
&MoveContext {
|
||||
source_sheet_name: "Sheet1",
|
||||
row,
|
||||
column,
|
||||
area,
|
||||
target_sheet_name: "Sheet1",
|
||||
row_delta: 10,
|
||||
column_delta: 10,
|
||||
},
|
||||
);
|
||||
assert_eq!(t, "SUM(@F2:H4)+SUM(@M12:P16)+SUM(@A1,@X9,@$N$15)");
|
||||
}
|
||||
@@ -2,9 +2,9 @@ use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::lexer::LexerMode;
|
||||
|
||||
use crate::expressions::parser::stringify::{to_rc_format, to_string};
|
||||
use crate::expressions::parser::Parser;
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
use super::super::parser::stringify::{to_rc_format, to_string};
|
||||
use super::super::types::CellReferenceRC;
|
||||
use super::Parser;
|
||||
|
||||
struct Formula<'a> {
|
||||
formula_a1: &'a str,
|
||||
@@ -14,7 +14,7 @@ struct Formula<'a> {
|
||||
#[test]
|
||||
fn test_parser_formulas_with_full_ranges() {
|
||||
let worksheets = vec!["Sheet1".to_string(), "Second Sheet".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
let formulas = vec![
|
||||
Formula {
|
||||
@@ -52,11 +52,11 @@ fn test_parser_formulas_with_full_ranges() {
|
||||
for formula in &formulas {
|
||||
let t = parser.parse(
|
||||
formula.formula_a1,
|
||||
&CellReferenceRC {
|
||||
&Some(CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
},
|
||||
}),
|
||||
);
|
||||
assert_eq!(to_rc_format(&t), formula.formula_r1c1);
|
||||
assert_eq!(to_string(&t, &cell_reference), formula.formula_a1);
|
||||
@@ -67,11 +67,11 @@ fn test_parser_formulas_with_full_ranges() {
|
||||
for formula in &formulas {
|
||||
let t = parser.parse(
|
||||
formula.formula_r1c1,
|
||||
&CellReferenceRC {
|
||||
&Some(CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
},
|
||||
}),
|
||||
);
|
||||
assert_eq!(to_rc_format(&t), formula.formula_r1c1);
|
||||
assert_eq!(to_string(&t, &cell_reference), formula.formula_a1);
|
||||
@@ -81,7 +81,7 @@ fn test_parser_formulas_with_full_ranges() {
|
||||
#[test]
|
||||
fn test_range_inverse_order() {
|
||||
let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
let mut parser = Parser::new(worksheets, HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -93,7 +93,7 @@ fn test_range_inverse_order() {
|
||||
// D4:C2 => C2:D4
|
||||
let t = parser.parse(
|
||||
"SUM(D4:C2)*SUM(Sheet2!D4:C20)*SUM($C$20:D4)",
|
||||
&cell_reference,
|
||||
&Some(cell_reference.clone()),
|
||||
);
|
||||
assert_eq!(
|
||||
to_string(&t, &cell_reference),
|
||||
@@ -3,11 +3,12 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::parser::stringify::to_string;
|
||||
use crate::expressions::parser::Parser;
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
use crate::expressions::utils::{number_to_column, parse_reference_a1};
|
||||
use crate::types::{Table, TableColumn, TableStyleInfo};
|
||||
|
||||
use super::super::types::CellReferenceRC;
|
||||
use super::Parser;
|
||||
|
||||
fn create_test_table(
|
||||
table_name: &str,
|
||||
column_names: &[&str],
|
||||
@@ -62,7 +63,7 @@ fn simple_table() {
|
||||
let row_count = 3;
|
||||
let tables = create_test_table("tblIncome", &column_names, "A1", row_count);
|
||||
|
||||
let mut parser = Parser::new(worksheets, vec![], tables);
|
||||
let mut parser = Parser::new(worksheets, tables);
|
||||
// Reference cell is 'Sheet One'!F2
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet One".to_string(),
|
||||
@@ -71,7 +72,7 @@ fn simple_table() {
|
||||
};
|
||||
|
||||
let formula = "SUM(tblIncome[[#This Row],[Jan]:[Dec]])";
|
||||
let t = parser.parse(formula, &cell_reference);
|
||||
let t = parser.parse(formula, &Some(cell_reference.clone()));
|
||||
assert_eq!(to_string(&t, &cell_reference), "SUM($A$2:$E$2)");
|
||||
|
||||
// Cell A3
|
||||
@@ -81,7 +82,7 @@ fn simple_table() {
|
||||
column: 1,
|
||||
};
|
||||
let formula = "SUBTOTAL(109, tblIncome[Jan])";
|
||||
let t = parser.parse(formula, &cell_reference);
|
||||
let t = parser.parse(formula, &Some(cell_reference.clone()));
|
||||
assert_eq!(to_string(&t, &cell_reference), "SUBTOTAL(109,$A$2:$A$3)");
|
||||
|
||||
// Cell A3 in 'Second Sheet'
|
||||
@@ -91,7 +92,7 @@ fn simple_table() {
|
||||
column: 1,
|
||||
};
|
||||
let formula = "SUBTOTAL(109, tblIncome[Jan])";
|
||||
let t = parser.parse(formula, &cell_reference);
|
||||
let t = parser.parse(formula, &Some(cell_reference.clone()));
|
||||
assert_eq!(
|
||||
to_string(&t, &cell_reference),
|
||||
"SUBTOTAL(109,'Sheet One'!$A$2:$A$3)"
|
||||
@@ -1,10 +0,0 @@
|
||||
mod test_add_implicit_intersection;
|
||||
mod test_arrays;
|
||||
mod test_general;
|
||||
mod test_implicit_intersection;
|
||||
mod test_issue_155;
|
||||
mod test_issue_483;
|
||||
mod test_move_formula;
|
||||
mod test_ranges;
|
||||
mod test_stringify;
|
||||
mod test_tables;
|
||||
@@ -1,80 +0,0 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::{
|
||||
parser::{
|
||||
stringify::{to_excel_string, to_string},
|
||||
Parser,
|
||||
},
|
||||
types::CellReferenceRC,
|
||||
};
|
||||
|
||||
use crate::expressions::parser::static_analysis::add_implicit_intersection;
|
||||
|
||||
#[test]
|
||||
fn simple_test() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let cases = vec![
|
||||
("A1:A10*SUM(A1:A10)", "@A1:A10*SUM(A1:A10)"),
|
||||
("A1:A10", "@A1:A10"),
|
||||
// Math and trigonometry functions
|
||||
("SUM(A1:A10)", "SUM(A1:A10)"),
|
||||
("SIN(A1:A10)", "SIN(@A1:A10)"),
|
||||
("COS(A1:A10)", "COS(@A1:A10)"),
|
||||
("TAN(A1:A10)", "TAN(@A1:A10)"),
|
||||
("ASIN(A1:A10)", "ASIN(@A1:A10)"),
|
||||
("ACOS(A1:A10)", "ACOS(@A1:A10)"),
|
||||
("ATAN(A1:A10)", "ATAN(@A1:A10)"),
|
||||
("SINH(A1:A10)", "SINH(@A1:A10)"),
|
||||
("COSH(A1:A10)", "COSH(@A1:A10)"),
|
||||
("TANH(A1:A10)", "TANH(@A1:A10)"),
|
||||
("ASINH(A1:A10)", "ASINH(@A1:A10)"),
|
||||
("ACOSH(A1:A10)", "ACOSH(@A1:A10)"),
|
||||
("ATANH(A1:A10)", "ATANH(@A1:A10)"),
|
||||
("ATAN2(A1:A10,B1:B10)", "ATAN2(@A1:A10,@B1:B10)"),
|
||||
("ATAN2(A1:A10,A1)", "ATAN2(@A1:A10,A1)"),
|
||||
("SQRT(A1:A10)", "SQRT(@A1:A10)"),
|
||||
("SQRTPI(A1:A10)", "SQRTPI(@A1:A10)"),
|
||||
("POWER(A1:A10,A1)", "POWER(@A1:A10,A1)"),
|
||||
("POWER(A1:A10,B1:B10)", "POWER(@A1:A10,@B1:B10)"),
|
||||
("MAX(A1:A10)", "MAX(A1:A10)"),
|
||||
("MIN(A1:A10)", "MIN(A1:A10)"),
|
||||
("ABS(A1:A10)", "ABS(@A1:A10)"),
|
||||
("FALSE()", "FALSE()"),
|
||||
("TRUE()", "TRUE()"),
|
||||
// Defined names
|
||||
("BADNMAE", "@BADNMAE"),
|
||||
// Logical
|
||||
("AND(A1:A10)", "AND(A1:A10)"),
|
||||
("OR(A1:A10)", "OR(A1:A10)"),
|
||||
("NOT(A1:A10)", "NOT(@A1:A10)"),
|
||||
("IF(A1:A10,B1:B10,C1:C10)", "IF(@A1:A10,@B1:B10,@C1:C10)"),
|
||||
// Information
|
||||
// ("ISBLANK(A1:A10)", "ISBLANK(A1:A10)"),
|
||||
// ("ISERR(A1:A10)", "ISERR(A1:A10)"),
|
||||
// ("ISERROR(A1:A10)", "ISERROR(A1:A10)"),
|
||||
// ("ISEVEN(A1:A10)", "ISEVEN(A1:A10)"),
|
||||
// ("ISLOGICAL(A1:A10)", "ISLOGICAL(A1:A10)"),
|
||||
// ("ISNA(A1:A10)", "ISNA(A1:A10)"),
|
||||
// ("ISNONTEXT(A1:A10)", "ISNONTEXT(A1:A10)"),
|
||||
// ("ISNUMBER(A1:A10)", "ISNUMBER(A1:A10)"),
|
||||
// ("ISODD(A1:A10)", "ISODD(A1:A10)"),
|
||||
// ("ISREF(A1:A10)", "ISREF(A1:A10)"),
|
||||
// ("ISTEXT(A1:A10)", "ISTEXT(A1:A10)"),
|
||||
];
|
||||
for (formula, expected) in cases {
|
||||
let mut t = parser.parse(formula, &cell_reference);
|
||||
add_implicit_intersection(&mut t, true);
|
||||
let r = to_string(&t, &cell_reference);
|
||||
assert_eq!(r, expected);
|
||||
let excel_formula = to_excel_string(&t, &cell_reference);
|
||||
assert_eq!(excel_formula, formula);
|
||||
}
|
||||
}
|
||||
@@ -1,92 +0,0 @@
|
||||
#![allow(clippy::panic)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::parser::stringify::{to_rc_format, to_string};
|
||||
use crate::expressions::parser::{ArrayNode, Node, Parser};
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
|
||||
#[test]
|
||||
fn simple_horizontal() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let horizontal = parser.parse("{1, 2, 3}", &cell_reference);
|
||||
assert_eq!(
|
||||
horizontal,
|
||||
Node::ArrayKind(vec![vec![
|
||||
ArrayNode::Number(1.0),
|
||||
ArrayNode::Number(2.0),
|
||||
ArrayNode::Number(3.0)
|
||||
]])
|
||||
);
|
||||
|
||||
assert_eq!(to_rc_format(&horizontal), "{1,2,3}");
|
||||
assert_eq!(to_string(&horizontal, &cell_reference), "{1,2,3}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn simple_vertical() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let vertical = parser.parse("{1;2; 3}", &cell_reference);
|
||||
assert_eq!(
|
||||
vertical,
|
||||
Node::ArrayKind(vec![
|
||||
vec![ArrayNode::Number(1.0)],
|
||||
vec![ArrayNode::Number(2.0)],
|
||||
vec![ArrayNode::Number(3.0)]
|
||||
])
|
||||
);
|
||||
assert_eq!(to_rc_format(&vertical), "{1;2;3}");
|
||||
assert_eq!(to_string(&vertical, &cell_reference), "{1;2;3}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn simple_matrix() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let matrix = parser.parse("{1,2,3; 4, 5, 6; 7,8,9}", &cell_reference);
|
||||
assert_eq!(
|
||||
matrix,
|
||||
Node::ArrayKind(vec![
|
||||
vec![
|
||||
ArrayNode::Number(1.0),
|
||||
ArrayNode::Number(2.0),
|
||||
ArrayNode::Number(3.0)
|
||||
],
|
||||
vec![
|
||||
ArrayNode::Number(4.0),
|
||||
ArrayNode::Number(5.0),
|
||||
ArrayNode::Number(6.0)
|
||||
],
|
||||
vec![
|
||||
ArrayNode::Number(7.0),
|
||||
ArrayNode::Number(8.0),
|
||||
ArrayNode::Number(9.0)
|
||||
]
|
||||
])
|
||||
);
|
||||
assert_eq!(to_rc_format(&matrix), "{1,2,3;4,5,6;7,8,9}");
|
||||
assert_eq!(to_string(&matrix, &cell_reference), "{1,2,3;4,5,6;7,8,9}");
|
||||
}
|
||||
@@ -1,75 +0,0 @@
|
||||
#![allow(clippy::panic)]
|
||||
|
||||
use crate::expressions::parser::{Node, Parser};
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
use std::collections::HashMap;
|
||||
|
||||
#[test]
|
||||
fn simple() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!B3
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 3,
|
||||
column: 2,
|
||||
};
|
||||
let t = parser.parse("@A1:A10", &cell_reference);
|
||||
let child = Node::RangeKind {
|
||||
sheet_name: None,
|
||||
sheet_index: 0,
|
||||
absolute_row1: false,
|
||||
absolute_column1: false,
|
||||
row1: -2,
|
||||
column1: -1,
|
||||
absolute_row2: false,
|
||||
absolute_column2: false,
|
||||
row2: 7,
|
||||
column2: -1,
|
||||
};
|
||||
assert_eq!(
|
||||
t,
|
||||
Node::ImplicitIntersection {
|
||||
automatic: false,
|
||||
child: Box::new(child)
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn simple_add() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!B3
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 3,
|
||||
column: 2,
|
||||
};
|
||||
let t = parser.parse("@A1:A10+12", &cell_reference);
|
||||
let child = Node::RangeKind {
|
||||
sheet_name: None,
|
||||
sheet_index: 0,
|
||||
absolute_row1: false,
|
||||
absolute_column1: false,
|
||||
row1: -2,
|
||||
column1: -1,
|
||||
absolute_row2: false,
|
||||
absolute_column2: false,
|
||||
row2: 7,
|
||||
column2: -1,
|
||||
};
|
||||
assert_eq!(
|
||||
t,
|
||||
Node::OpSumKind {
|
||||
kind: crate::expressions::token::OpSum::Add,
|
||||
left: Box::new(Node::ImplicitIntersection {
|
||||
automatic: false,
|
||||
child: Box::new(child)
|
||||
}),
|
||||
right: Box::new(Node::NumberKind(12.0))
|
||||
}
|
||||
)
|
||||
}
|
||||
@@ -1,69 +0,0 @@
|
||||
#![allow(clippy::panic)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::parser::stringify::to_string;
|
||||
use crate::expressions::parser::Parser;
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
|
||||
#[test]
|
||||
fn issue_155_parser() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 2,
|
||||
column: 2,
|
||||
};
|
||||
let t = parser.parse("A$1:A2", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "A$1:A2");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn issue_155_parser_case_2() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 20,
|
||||
column: 20,
|
||||
};
|
||||
let t = parser.parse("C$1:D2", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "C$1:D2");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn issue_155_parser_only_row() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 20,
|
||||
column: 20,
|
||||
};
|
||||
// This is tricky, I am not sure what to do in these cases
|
||||
let t = parser.parse("A$2:B1", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "A1:B$2");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn issue_155_parser_only_column() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 20,
|
||||
column: 20,
|
||||
};
|
||||
// This is tricky, I am not sure what to do in these cases
|
||||
let t = parser.parse("D1:$A3", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "$A1:D3");
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
#![allow(clippy::panic)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::parser::stringify::to_string;
|
||||
use crate::expressions::parser::{Node, Parser};
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
|
||||
#[test]
|
||||
fn issue_483_parser() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 2,
|
||||
column: 2,
|
||||
};
|
||||
let t = parser.parse("-(A1^1.22)", &cell_reference);
|
||||
assert!(matches!(t, Node::UnaryKind { .. }));
|
||||
assert_eq!(to_string(&t, &cell_reference), "-(A1^1.22)");
|
||||
|
||||
let t = parser.parse("-A1^1.22", &cell_reference);
|
||||
assert!(matches!(t, Node::OpPowerKind { .. }));
|
||||
assert_eq!(to_string(&t, &cell_reference), "-A1^1.22");
|
||||
}
|
||||
@@ -1,70 +0,0 @@
|
||||
#![allow(clippy::panic)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::expressions::parser::stringify::to_string;
|
||||
use crate::expressions::parser::Parser;
|
||||
use crate::expressions::types::CellReferenceRC;
|
||||
|
||||
#[test]
|
||||
fn exp_order() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
// Reference cell is Sheet1!A1
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let t = parser.parse("(1 + 2)^3 + 4", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "(1+2)^3+4");
|
||||
|
||||
let t = parser.parse("(C5 + 3)^R4", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "(C5+3)^R4");
|
||||
|
||||
let t = parser.parse("(C5 + 3)^(R4*6)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "(C5+3)^(R4*6)");
|
||||
|
||||
let t = parser.parse("(C5)^(R4)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "C5^R4");
|
||||
|
||||
let t = parser.parse("(5)^(4)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "5^4");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn correct_parenthesis() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
|
||||
let t = parser.parse("-(1 + 1)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "-(1+1)");
|
||||
|
||||
let t = parser.parse("1 - (3 + 4)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "1-(3+4)");
|
||||
|
||||
let t = parser.parse("-(1.05*(0.0284 + 0.0046) - 0.0284)", &cell_reference);
|
||||
assert_eq!(
|
||||
to_string(&t, &cell_reference),
|
||||
"-(1.05*(0.0284+0.0046)-0.0284)"
|
||||
);
|
||||
|
||||
let t = parser.parse("1 + (3+5)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "1+3+5");
|
||||
|
||||
let t = parser.parse("1 - (3+5)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "1-(3+5)");
|
||||
|
||||
let t = parser.parse("(1 - 3) - (3+5)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "1-3-(3+5)");
|
||||
|
||||
let t = parser.parse("1 + (3<5)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "1+(3<5)");
|
||||
}
|
||||
276
base/src/expressions/parser/walk.rs
Normal file
276
base/src/expressions/parser/walk.rs
Normal file
@@ -0,0 +1,276 @@
|
||||
use super::{move_formula::ref_is_in_area, Node};
|
||||
|
||||
use crate::expressions::types::{Area, CellReferenceIndex};
|
||||
|
||||
pub(crate) fn forward_references(
|
||||
node: &mut Node,
|
||||
context: &CellReferenceIndex,
|
||||
source_area: &Area,
|
||||
target_sheet: u32,
|
||||
target_sheet_name: &str,
|
||||
target_row: i32,
|
||||
target_column: i32,
|
||||
) {
|
||||
match node {
|
||||
Node::ReferenceKind {
|
||||
sheet_name,
|
||||
sheet_index: reference_sheet,
|
||||
absolute_row,
|
||||
absolute_column,
|
||||
row: reference_row,
|
||||
column: reference_column,
|
||||
} => {
|
||||
let reference_row_absolute = if *absolute_row {
|
||||
*reference_row
|
||||
} else {
|
||||
*reference_row + context.row
|
||||
};
|
||||
let reference_column_absolute = if *absolute_column {
|
||||
*reference_column
|
||||
} else {
|
||||
*reference_column + context.column
|
||||
};
|
||||
if ref_is_in_area(
|
||||
*reference_sheet,
|
||||
reference_row_absolute,
|
||||
reference_column_absolute,
|
||||
source_area,
|
||||
) {
|
||||
if *reference_sheet != target_sheet {
|
||||
*sheet_name = Some(target_sheet_name.to_string());
|
||||
*reference_sheet = target_sheet;
|
||||
}
|
||||
*reference_row = target_row + *reference_row - source_area.row;
|
||||
*reference_column = target_column + *reference_column - source_area.column;
|
||||
}
|
||||
}
|
||||
Node::RangeKind {
|
||||
sheet_name,
|
||||
sheet_index,
|
||||
absolute_row1,
|
||||
absolute_column1,
|
||||
row1,
|
||||
column1,
|
||||
absolute_row2,
|
||||
absolute_column2,
|
||||
row2,
|
||||
column2,
|
||||
} => {
|
||||
let reference_row1 = if *absolute_row1 {
|
||||
*row1
|
||||
} else {
|
||||
*row1 + context.row
|
||||
};
|
||||
let reference_column1 = if *absolute_column1 {
|
||||
*column1
|
||||
} else {
|
||||
*column1 + context.column
|
||||
};
|
||||
|
||||
let reference_row2 = if *absolute_row2 {
|
||||
*row2
|
||||
} else {
|
||||
*row2 + context.row
|
||||
};
|
||||
let reference_column2 = if *absolute_column2 {
|
||||
*column2
|
||||
} else {
|
||||
*column2 + context.column
|
||||
};
|
||||
if ref_is_in_area(*sheet_index, reference_row1, reference_column1, source_area)
|
||||
&& ref_is_in_area(*sheet_index, reference_row2, reference_column2, source_area)
|
||||
{
|
||||
if *sheet_index != target_sheet {
|
||||
*sheet_index = target_sheet;
|
||||
*sheet_name = Some(target_sheet_name.to_string());
|
||||
}
|
||||
*row1 = target_row + *row1 - source_area.row;
|
||||
*column1 = target_column + *column1 - source_area.column;
|
||||
*row2 = target_row + *row2 - source_area.row;
|
||||
*column2 = target_column + *column2 - source_area.column;
|
||||
}
|
||||
}
|
||||
// Recurse
|
||||
Node::OpRangeKind { left, right } => {
|
||||
forward_references(
|
||||
left,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
forward_references(
|
||||
right,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
Node::OpConcatenateKind { left, right } => {
|
||||
forward_references(
|
||||
left,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
forward_references(
|
||||
right,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
Node::OpSumKind {
|
||||
kind: _,
|
||||
left,
|
||||
right,
|
||||
} => {
|
||||
forward_references(
|
||||
left,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
forward_references(
|
||||
right,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
Node::OpProductKind {
|
||||
kind: _,
|
||||
left,
|
||||
right,
|
||||
} => {
|
||||
forward_references(
|
||||
left,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
forward_references(
|
||||
right,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
Node::OpPowerKind { left, right } => {
|
||||
forward_references(
|
||||
left,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
forward_references(
|
||||
right,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
Node::FunctionKind { kind: _, args } => {
|
||||
for arg in args {
|
||||
forward_references(
|
||||
arg,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
}
|
||||
Node::InvalidFunctionKind { name: _, args } => {
|
||||
for arg in args {
|
||||
forward_references(
|
||||
arg,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
}
|
||||
Node::CompareKind {
|
||||
kind: _,
|
||||
left,
|
||||
right,
|
||||
} => {
|
||||
forward_references(
|
||||
left,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
forward_references(
|
||||
right,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
Node::UnaryKind { kind: _, right } => {
|
||||
forward_references(
|
||||
right,
|
||||
context,
|
||||
source_area,
|
||||
target_sheet,
|
||||
target_sheet_name,
|
||||
target_row,
|
||||
target_column,
|
||||
);
|
||||
}
|
||||
// TODO: Not implemented
|
||||
Node::ArrayKind(_) => {}
|
||||
// Do nothing. Note: we could do a blanket _ => {}
|
||||
Node::VariableKind(_) => {}
|
||||
Node::ErrorKind(_) => {}
|
||||
Node::ParseErrorKind { .. } => {}
|
||||
Node::EmptyArgKind => {}
|
||||
Node::BooleanKind(_) => {}
|
||||
Node::NumberKind(_) => {}
|
||||
Node::StringKind(_) => {}
|
||||
Node::WrongReferenceKind { .. } => {}
|
||||
Node::WrongRangeKind { .. } => {}
|
||||
}
|
||||
}
|
||||
@@ -197,7 +197,7 @@ pub fn is_english_error_string(name: &str) -> bool {
|
||||
"#REF!", "#NAME?", "#VALUE!", "#DIV/0!", "#N/A", "#NUM!", "#ERROR!", "#N/IMPL!", "#SPILL!",
|
||||
"#CALC!", "#CIRC!", "#NULL!",
|
||||
];
|
||||
names.contains(&name)
|
||||
names.iter().any(|e| *e == name)
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
|
||||
@@ -240,7 +240,6 @@ pub enum TokenType {
|
||||
Bang, // !
|
||||
Percent, // %
|
||||
And, // &
|
||||
At, // @
|
||||
Reference {
|
||||
sheet: Option<String>,
|
||||
row: i32,
|
||||
|
||||
@@ -259,23 +259,15 @@ pub fn is_valid_identifier(name: &str) -> bool {
|
||||
fn name_needs_quoting(name: &str) -> bool {
|
||||
let chars = name.chars();
|
||||
// it contains any of these characters: ()'$,;-+{} or space
|
||||
for (i, char) in chars.enumerate() {
|
||||
for char in chars {
|
||||
if [' ', '(', ')', '\'', '$', ',', ';', '-', '+', '{', '}'].contains(&char) {
|
||||
return true;
|
||||
}
|
||||
// if it starts with a number
|
||||
if i == 0 && char.is_ascii_digit() {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if parse_reference_a1(name).is_some() {
|
||||
// cell reference in A1 notation, e.g. B1048576 is quoted, B1048577 is not
|
||||
return true;
|
||||
}
|
||||
if parse_reference_r1c1(name).is_some() {
|
||||
// cell reference in R1C1 notation, e.g. RC, RC2, R5C, R-4C, RC-8, R, C
|
||||
return true;
|
||||
}
|
||||
// TODO:
|
||||
// cell reference in A1 notation, e.g. B1048576 is quoted, B1048577 is not
|
||||
// cell reference in R1C1 notation, e.g. RC, RC2, R5C, R-4C, RC-8, R, C
|
||||
// integers
|
||||
false
|
||||
}
|
||||
|
||||
@@ -287,32 +279,3 @@ pub fn quote_name(name: &str) -> String {
|
||||
};
|
||||
name.to_string()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_quote_name() {
|
||||
assert_eq!(quote_name("Sheet1"), "Sheet1");
|
||||
assert_eq!(quote_name("Sheet 1"), "'Sheet 1'");
|
||||
// escape and quote
|
||||
assert_eq!(quote_name("Sheet1'"), "'Sheet1'''");
|
||||
assert_eq!(quote_name("Data(2024)"), "'Data(2024)'");
|
||||
assert_eq!(quote_name("Data$2024"), "'Data$2024'");
|
||||
assert_eq!(quote_name("Data-2024"), "'Data-2024'");
|
||||
assert_eq!(quote_name("Data+2024"), "'Data+2024'");
|
||||
assert_eq!(quote_name("Data,2024"), "'Data,2024'");
|
||||
assert_eq!(quote_name("Data;2024"), "'Data;2024'");
|
||||
assert_eq!(quote_name("Data{2024}"), "'Data{2024}'");
|
||||
|
||||
assert_eq!(quote_name("2024"), "'2024'");
|
||||
assert_eq!(quote_name("1Data"), "'1Data'");
|
||||
assert_eq!(quote_name("A1"), "'A1'");
|
||||
assert_eq!(quote_name("R1C1"), "'R1C1'");
|
||||
assert_eq!(quote_name("MySheet"), "MySheet");
|
||||
|
||||
assert_eq!(quote_name("B1048576"), "'B1048576'");
|
||||
assert_eq!(quote_name("B1048577"), "B1048577");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -211,6 +211,4 @@ fn test_names() {
|
||||
assert!(!is_valid_identifier("test€"));
|
||||
assert!(!is_valid_identifier("truñe"));
|
||||
assert!(!is_valid_identifier("tr&ue"));
|
||||
|
||||
assert!(!is_valid_identifier("LOG10"));
|
||||
}
|
||||
|
||||
@@ -1,158 +1,18 @@
|
||||
use chrono::Datelike;
|
||||
use chrono::Days;
|
||||
use chrono::Duration;
|
||||
use chrono::Months;
|
||||
use chrono::NaiveDate;
|
||||
|
||||
use crate::constants::EXCEL_DATE_BASE;
|
||||
use crate::constants::MAXIMUM_DATE_SERIAL_NUMBER;
|
||||
use crate::constants::MINIMUM_DATE_SERIAL_NUMBER;
|
||||
|
||||
pub const DATE_OUT_OF_RANGE_MESSAGE: &str = "Out of range parameters for date";
|
||||
|
||||
#[inline]
|
||||
fn convert_to_serial_number(date: NaiveDate) -> i32 {
|
||||
date.num_days_from_ce() - EXCEL_DATE_BASE
|
||||
}
|
||||
|
||||
fn is_date_within_range(date: NaiveDate) -> bool {
|
||||
convert_to_serial_number(date) >= MINIMUM_DATE_SERIAL_NUMBER
|
||||
&& convert_to_serial_number(date) <= MAXIMUM_DATE_SERIAL_NUMBER
|
||||
}
|
||||
|
||||
pub fn from_excel_date(days: i64) -> Result<NaiveDate, String> {
|
||||
if days < MINIMUM_DATE_SERIAL_NUMBER as i64 {
|
||||
return Err(format!(
|
||||
"Excel date must be greater than {MINIMUM_DATE_SERIAL_NUMBER}"
|
||||
));
|
||||
};
|
||||
if days > MAXIMUM_DATE_SERIAL_NUMBER as i64 {
|
||||
return Err(format!(
|
||||
"Excel date must be less than {MAXIMUM_DATE_SERIAL_NUMBER}"
|
||||
));
|
||||
};
|
||||
pub fn from_excel_date(days: i64) -> NaiveDate {
|
||||
#[allow(clippy::expect_used)]
|
||||
let dt = NaiveDate::from_ymd_opt(1900, 1, 1).expect("problem with chrono::NaiveDate");
|
||||
Ok(dt + Duration::days(days - 2))
|
||||
dt + Duration::days(days - 2)
|
||||
}
|
||||
|
||||
pub fn date_to_serial_number(day: u32, month: u32, year: i32) -> Result<i32, String> {
|
||||
match NaiveDate::from_ymd_opt(year, month, day) {
|
||||
Some(native_date) => Ok(convert_to_serial_number(native_date)),
|
||||
None => Err(DATE_OUT_OF_RANGE_MESSAGE.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn permissive_date_to_serial_number(day: i32, month: i32, year: i32) -> Result<i32, String> {
|
||||
// Excel parses `DATE` very permissively. It allows not just for valid date values, but it
|
||||
// allows for invalid dates as well. If you for example enter `DATE(1900, 1, 32)` it will
|
||||
// return the date `1900-02-01`. Despite giving a day that is out of range it will just
|
||||
// wrap the month and year around.
|
||||
//
|
||||
// This function applies that same logic to dates. And does it in the most compatible way as
|
||||
// possible.
|
||||
|
||||
// Special case for the minimum date
|
||||
if year == 1899 && month == 12 && day == 31 {
|
||||
return Ok(MINIMUM_DATE_SERIAL_NUMBER);
|
||||
}
|
||||
let Some(mut date) = NaiveDate::from_ymd_opt(year, 1, 1) else {
|
||||
return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
|
||||
};
|
||||
|
||||
// One thing to note for example is that even if you started with a year out of range
|
||||
// but tried to increment the months so that it wraps around into within range, excel
|
||||
// would still return an error.
|
||||
//
|
||||
// I.E. DATE(0,13,-1) will return an error, despite it being equivalent to DATE(1,1,0) which
|
||||
// is within range.
|
||||
//
|
||||
// As a result, we have to run range checks as we parse the date from the biggest unit to the
|
||||
// smallest unit.
|
||||
if !is_date_within_range(date) {
|
||||
return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
|
||||
}
|
||||
|
||||
date = {
|
||||
let month_diff = month - 1;
|
||||
let abs_month = month_diff.unsigned_abs();
|
||||
if month_diff <= 0 {
|
||||
date = date - Months::new(abs_month);
|
||||
} else {
|
||||
date = date + Months::new(abs_month);
|
||||
}
|
||||
if !is_date_within_range(date) {
|
||||
return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
|
||||
}
|
||||
date
|
||||
};
|
||||
|
||||
date = {
|
||||
let day_diff = day - 1;
|
||||
let abs_day = day_diff.unsigned_abs() as u64;
|
||||
if day_diff <= 0 {
|
||||
date = date - Days::new(abs_day);
|
||||
} else {
|
||||
date = date + Days::new(abs_day);
|
||||
}
|
||||
if !is_date_within_range(date) {
|
||||
return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
|
||||
}
|
||||
date
|
||||
};
|
||||
|
||||
Ok(convert_to_serial_number(date))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_permissive_date_to_serial_number() {
|
||||
assert_eq!(
|
||||
permissive_date_to_serial_number(42, 42, 2002),
|
||||
date_to_serial_number(12, 7, 2005)
|
||||
);
|
||||
assert_eq!(
|
||||
permissive_date_to_serial_number(1, 42, 2002),
|
||||
date_to_serial_number(1, 6, 2005)
|
||||
);
|
||||
assert_eq!(
|
||||
permissive_date_to_serial_number(1, 15, 2000),
|
||||
date_to_serial_number(1, 3, 2001)
|
||||
);
|
||||
assert_eq!(
|
||||
permissive_date_to_serial_number(1, 49, 2000),
|
||||
date_to_serial_number(1, 1, 2004)
|
||||
);
|
||||
assert_eq!(
|
||||
permissive_date_to_serial_number(1, 49, 2000),
|
||||
date_to_serial_number(1, 1, 2004)
|
||||
);
|
||||
assert_eq!(
|
||||
permissive_date_to_serial_number(31, 49, 2000),
|
||||
date_to_serial_number(31, 1, 2004)
|
||||
);
|
||||
assert_eq!(
|
||||
permissive_date_to_serial_number(256, 49, 2000),
|
||||
date_to_serial_number(12, 9, 2004)
|
||||
);
|
||||
assert_eq!(
|
||||
permissive_date_to_serial_number(256, 1, 2004),
|
||||
date_to_serial_number(12, 9, 2004)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_max_and_min_dates() {
|
||||
assert_eq!(
|
||||
permissive_date_to_serial_number(31, 12, 9999),
|
||||
Ok(MAXIMUM_DATE_SERIAL_NUMBER),
|
||||
);
|
||||
assert_eq!(
|
||||
permissive_date_to_serial_number(31, 12, 1899),
|
||||
Ok(MINIMUM_DATE_SERIAL_NUMBER),
|
||||
);
|
||||
Some(native_date) => Ok(native_date.num_days_from_ce() - EXCEL_DATE_BASE),
|
||||
None => Err("Out of range parameters for date".to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -120,7 +120,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
|
||||
// We should have different codepaths for general formatting and errors
|
||||
let value_abs = value.abs();
|
||||
if (1.0e-8..1.0e+11).contains(&value_abs) {
|
||||
let mut text = format!("{value:.9}");
|
||||
let mut text = format!("{:.9}", value);
|
||||
text = text.trim_end_matches('0').trim_end_matches('.').to_string();
|
||||
Formatted {
|
||||
text,
|
||||
@@ -138,7 +138,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
|
||||
let exponent = value_abs.log10().floor();
|
||||
value /= 10.0_f64.powf(exponent);
|
||||
let sign = if exponent < 0.0 { '-' } else { '+' };
|
||||
let s = format!("{value:.5}");
|
||||
let s = format!("{:.5}", value);
|
||||
Formatted {
|
||||
text: format!(
|
||||
"{}E{}{:02}",
|
||||
@@ -154,72 +154,47 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
|
||||
ParsePart::Date(p) => {
|
||||
let tokens = &p.tokens;
|
||||
let mut text = "".to_string();
|
||||
let time_fract = value.fract();
|
||||
let hours = (time_fract * 24.0).floor();
|
||||
let minutes = ((time_fract * 24.0 - hours) * 60.0).floor();
|
||||
let seconds = ((((time_fract * 24.0 - hours) * 60.0) - minutes) * 60.0).round();
|
||||
let date = from_excel_date(value as i64).ok();
|
||||
if !(1.0..=2_958_465.0).contains(&value) {
|
||||
// 2_958_465 is 31 December 9999
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some("Date negative or too long".to_owned()),
|
||||
};
|
||||
}
|
||||
let date = from_excel_date(value as i64);
|
||||
for token in tokens {
|
||||
match token {
|
||||
TextToken::Literal(c) => {
|
||||
text = format!("{text}{c}");
|
||||
text = format!("{}{}", text, c);
|
||||
}
|
||||
TextToken::Text(t) => {
|
||||
text = format!("{text}{t}");
|
||||
text = format!("{}{}", text, t);
|
||||
}
|
||||
TextToken::Ghost(_) => {
|
||||
// we just leave a whitespace
|
||||
// This is what the TEXT function does
|
||||
text = format!("{text} ");
|
||||
text = format!("{} ", text);
|
||||
}
|
||||
TextToken::Spacer(_) => {
|
||||
// we just leave a whitespace
|
||||
// This is what the TEXT function does
|
||||
text = format!("{text} ");
|
||||
text = format!("{} ", text);
|
||||
}
|
||||
TextToken::Raw => {
|
||||
text = format!("{text}{value}");
|
||||
text = format!("{}{}", text, value);
|
||||
}
|
||||
TextToken::Digit(_) => {}
|
||||
TextToken::Period => {}
|
||||
TextToken::Day => match date {
|
||||
Some(date) => {
|
||||
let day = date.day() as usize;
|
||||
text = format!("{text}{day}");
|
||||
}
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
},
|
||||
TextToken::DayPadded => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
TextToken::Day => {
|
||||
let day = date.day() as usize;
|
||||
text = format!("{text}{day:02}");
|
||||
text = format!("{}{}", text, day);
|
||||
}
|
||||
TextToken::DayPadded => {
|
||||
let day = date.day() as usize;
|
||||
text = format!("{}{:02}", text, day);
|
||||
}
|
||||
TextToken::DayNameShort => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
let mut day = date.weekday().number_from_monday() as usize;
|
||||
if day == 7 {
|
||||
day = 0;
|
||||
@@ -227,16 +202,6 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
|
||||
text = format!("{}{}", text, &locale.dates.day_names_short[day]);
|
||||
}
|
||||
TextToken::DayName => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
let mut day = date.weekday().number_from_monday() as usize;
|
||||
if day == 7 {
|
||||
day = 0;
|
||||
@@ -244,144 +209,32 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
|
||||
text = format!("{}{}", text, &locale.dates.day_names[day]);
|
||||
}
|
||||
TextToken::Month => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
let month = date.month() as usize;
|
||||
text = format!("{text}{month}");
|
||||
text = format!("{}{}", text, month);
|
||||
}
|
||||
TextToken::MonthPadded => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
let month = date.month() as usize;
|
||||
text = format!("{text}{month:02}");
|
||||
text = format!("{}{:02}", text, month);
|
||||
}
|
||||
TextToken::MonthNameShort => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
let month = date.month() as usize;
|
||||
text = format!("{}{}", text, &locale.dates.months_short[month - 1]);
|
||||
}
|
||||
TextToken::MonthName => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
let month = date.month() as usize;
|
||||
text = format!("{}{}", text, &locale.dates.months[month - 1]);
|
||||
}
|
||||
TextToken::MonthLetter => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
let month = date.month() as usize;
|
||||
let months_letter = &locale.dates.months_letter[month - 1];
|
||||
text = format!("{text}{months_letter}");
|
||||
text = format!("{}{}", text, months_letter);
|
||||
}
|
||||
TextToken::YearShort => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
text = format!("{}{}", text, date.format("%y"));
|
||||
}
|
||||
TextToken::Year => {
|
||||
let date = match date {
|
||||
Some(d) => d,
|
||||
None => {
|
||||
return Formatted {
|
||||
text: "#VALUE!".to_owned(),
|
||||
color: None,
|
||||
error: Some(format!("Invalid date value: '{value}'")),
|
||||
}
|
||||
}
|
||||
};
|
||||
text = format!("{}{}", text, date.year());
|
||||
}
|
||||
TextToken::Hour => {
|
||||
let mut hour = hours as i32;
|
||||
if p.use_ampm {
|
||||
if hour == 0 {
|
||||
hour = 12;
|
||||
} else if hour > 12 {
|
||||
hour -= 12;
|
||||
}
|
||||
}
|
||||
text = format!("{text}{hour}");
|
||||
}
|
||||
TextToken::HourPadded => {
|
||||
let mut hour = hours as i32;
|
||||
if p.use_ampm {
|
||||
if hour == 0 {
|
||||
hour = 12;
|
||||
} else if hour > 12 {
|
||||
hour -= 12;
|
||||
}
|
||||
}
|
||||
text = format!("{text}{hour:02}");
|
||||
}
|
||||
TextToken::Second => {
|
||||
let second = seconds as i32;
|
||||
text = format!("{text}{second}");
|
||||
}
|
||||
TextToken::SecondPadded => {
|
||||
let second = seconds as i32;
|
||||
text = format!("{text}{second:02}");
|
||||
}
|
||||
TextToken::AMPM => {
|
||||
let ampm = if hours < 12.0 { "AM" } else { "PM" };
|
||||
text = format!("{text}{ampm}");
|
||||
}
|
||||
TextToken::Minute => {
|
||||
let minute = minutes as i32;
|
||||
text = format!("{text}{minute}");
|
||||
}
|
||||
TextToken::MinutePadded => {
|
||||
let minute = minutes as i32;
|
||||
text = format!("{text}{minute:02}");
|
||||
}
|
||||
}
|
||||
}
|
||||
Formatted {
|
||||
@@ -392,9 +245,6 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
|
||||
}
|
||||
ParsePart::Number(p) => {
|
||||
let mut text = "".to_string();
|
||||
if let Some(c) = p.currency {
|
||||
text = format!("{c}");
|
||||
}
|
||||
let tokens = &p.tokens;
|
||||
value = value * 100.0_f64.powi(p.percent) / (1000.0_f64.powi(p.comma));
|
||||
// p.precision is the number of significant digits _after_ the decimal point
|
||||
@@ -441,26 +291,26 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
|
||||
for token in tokens {
|
||||
match token {
|
||||
TextToken::Literal(c) => {
|
||||
text = format!("{text}{c}");
|
||||
text = format!("{}{}", text, c);
|
||||
}
|
||||
TextToken::Text(t) => {
|
||||
text = format!("{text}{t}");
|
||||
text = format!("{}{}", text, t);
|
||||
}
|
||||
TextToken::Ghost(_) => {
|
||||
// we just leave a whitespace
|
||||
// This is what the TEXT function does
|
||||
text = format!("{text} ");
|
||||
text = format!("{} ", text);
|
||||
}
|
||||
TextToken::Spacer(_) => {
|
||||
// we just leave a whitespace
|
||||
// This is what the TEXT function does
|
||||
text = format!("{text} ");
|
||||
text = format!("{} ", text);
|
||||
}
|
||||
TextToken::Raw => {
|
||||
text = format!("{text}{value}");
|
||||
text = format!("{}{}", text, value);
|
||||
}
|
||||
TextToken::Period => {
|
||||
text = format!("{text}{decimal_separator}");
|
||||
text = format!("{}{}", text, decimal_separator);
|
||||
}
|
||||
TextToken::Digit(digit) => {
|
||||
if digit.number == 'i' {
|
||||
@@ -468,7 +318,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
|
||||
let index = digit.index;
|
||||
let number_index = ln - digit_count + index;
|
||||
if index == 0 && is_negative {
|
||||
text = format!("-{text}");
|
||||
text = format!("-{}", text);
|
||||
}
|
||||
if ln <= digit_count {
|
||||
// The number of digits is less or equal than the number of digit tokens
|
||||
@@ -493,7 +343,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
|
||||
} else {
|
||||
""
|
||||
};
|
||||
text = format!("{text}{c}{sep}");
|
||||
text = format!("{}{}{}", text, c, sep);
|
||||
}
|
||||
digit_index += 1;
|
||||
} else {
|
||||
@@ -519,18 +369,18 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
|
||||
if index < fract_part.len() {
|
||||
text = format!("{}{}", text, fract_part[index]);
|
||||
} else if digit.kind == '0' {
|
||||
text = format!("{text}0");
|
||||
text = format!("{}0", text);
|
||||
} else if digit.kind == '?' {
|
||||
text = format!("{text} ");
|
||||
text = format!("{} ", text);
|
||||
}
|
||||
} else if digit.number == 'e' {
|
||||
// 3. Exponent part
|
||||
let index = digit.index;
|
||||
if index == 0 {
|
||||
if exponent_is_negative {
|
||||
text = format!("{text}E-");
|
||||
text = format!("{}E-", text);
|
||||
} else {
|
||||
text = format!("{text}E+");
|
||||
text = format!("{}E+", text);
|
||||
}
|
||||
}
|
||||
let number_index = l_exp - (p.exponent_digit_count - index);
|
||||
@@ -546,7 +396,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
|
||||
exponent_part[number_index as usize]
|
||||
};
|
||||
|
||||
text = format!("{text}{c}");
|
||||
text = format!("{}{}", text, c);
|
||||
}
|
||||
} else {
|
||||
for i in 0..number_index + 1 {
|
||||
@@ -568,13 +418,6 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
|
||||
TextToken::MonthLetter => {}
|
||||
TextToken::YearShort => {}
|
||||
TextToken::Year => {}
|
||||
TextToken::Hour => {}
|
||||
TextToken::HourPadded => {}
|
||||
TextToken::Minute => {}
|
||||
TextToken::MinutePadded => {}
|
||||
TextToken::Second => {}
|
||||
TextToken::SecondPadded => {}
|
||||
TextToken::AMPM => {}
|
||||
}
|
||||
}
|
||||
Formatted {
|
||||
@@ -767,7 +610,7 @@ pub(crate) fn parse_formatted_number(
|
||||
|
||||
// check if it is a currency in currencies
|
||||
for currency in currencies {
|
||||
if let Some(p) = value.strip_prefix(&format!("-{currency}")) {
|
||||
if let Some(p) = value.strip_prefix(&format!("-{}", currency)) {
|
||||
let (f, options) = parse_number(p.trim())?;
|
||||
if options.is_scientific {
|
||||
return Ok((f, Some(scientific_format.to_string())));
|
||||
|
||||
@@ -10,7 +10,6 @@ pub struct Lexer {
|
||||
pub enum Token {
|
||||
Color(i32), // [Red] or [Color 23]
|
||||
Condition(Compare, f64), // [<=100] (Comparator, number)
|
||||
Currency(char), // [$€] ($ currency symbol)
|
||||
Literal(char), // €, $, (, ), /, :, +, -, ^, ', {, }, <, =, !, ~, > and space or scaped \X
|
||||
Spacer(char), // *X
|
||||
Ghost(char), // _X
|
||||
@@ -26,23 +25,19 @@ pub enum Token {
|
||||
Scientific, // E+
|
||||
ScientificMinus, // E-
|
||||
General, // General
|
||||
// Dates and time
|
||||
// Dates
|
||||
Day, // d
|
||||
DayPadded, // dd
|
||||
DayNameShort, // ddd
|
||||
DayName, // dddd+
|
||||
Month, // m (or minute)
|
||||
MonthPadded, // mm (or minute padded)
|
||||
Month, // m
|
||||
MonthPadded, // mm
|
||||
MonthNameShort, // mmm
|
||||
MonthName, // mmmm or mmmmmm+
|
||||
MonthLetter, // mmmmm
|
||||
YearShort, // y or yy
|
||||
Year, // yyy+
|
||||
Hour, // h
|
||||
HourPadded, // hh
|
||||
Second, // s
|
||||
SecondPadded, // ss
|
||||
AMPM, // AM/PM (or A/P)
|
||||
// TODO: Hours Minutes and Seconds
|
||||
ILLEGAL,
|
||||
EOF,
|
||||
}
|
||||
@@ -182,7 +177,10 @@ impl Lexer {
|
||||
}
|
||||
}
|
||||
self.position = position;
|
||||
chars.parse::<f64>().ok()
|
||||
match chars.parse::<f64>() {
|
||||
Err(_) => None,
|
||||
Ok(v) => Some(v),
|
||||
}
|
||||
}
|
||||
|
||||
fn consume_condition(&mut self) -> Option<(Compare, f64)> {
|
||||
@@ -276,15 +274,6 @@ impl Lexer {
|
||||
self.set_error("Failed to parse condition");
|
||||
Token::ILLEGAL
|
||||
}
|
||||
} else if c == '$' {
|
||||
// currency
|
||||
self.read_next_char();
|
||||
if let Some(currency) = self.read_next_char() {
|
||||
self.read_next_char();
|
||||
return Token::Currency(currency);
|
||||
}
|
||||
self.set_error("Failed to parse currency");
|
||||
Token::ILLEGAL
|
||||
} else {
|
||||
// Color
|
||||
if let Some(index) = self.consume_color() {
|
||||
@@ -337,7 +326,7 @@ impl Lexer {
|
||||
} else if s == '-' {
|
||||
Token::ScientificMinus
|
||||
} else {
|
||||
self.set_error(&format!("Unexpected char: {s}. Expected + or -"));
|
||||
self.set_error(&format!("Unexpected char: {}. Expected + or -", s));
|
||||
Token::ILLEGAL
|
||||
}
|
||||
} else {
|
||||
@@ -365,8 +354,8 @@ impl Lexer {
|
||||
self.read_next_char();
|
||||
}
|
||||
match m {
|
||||
1 => Token::Month, // (or minute)
|
||||
2 => Token::MonthPadded, // (or minute padded)
|
||||
1 => Token::Month,
|
||||
2 => Token::MonthPadded,
|
||||
3 => Token::MonthNameShort,
|
||||
4 => Token::MonthName,
|
||||
5 => Token::MonthLetter,
|
||||
@@ -385,75 +374,18 @@ impl Lexer {
|
||||
Token::Year
|
||||
}
|
||||
}
|
||||
'h' => {
|
||||
let mut h = 1;
|
||||
while let Some('h') = self.peek_char() {
|
||||
h += 1;
|
||||
self.read_next_char();
|
||||
}
|
||||
if h == 1 {
|
||||
Token::Hour
|
||||
} else if h == 2 {
|
||||
Token::HourPadded
|
||||
} else {
|
||||
self.set_error("Unexpected character after 'h'");
|
||||
Token::ILLEGAL
|
||||
}
|
||||
}
|
||||
's' => {
|
||||
let mut s = 1;
|
||||
while let Some('s') = self.peek_char() {
|
||||
s += 1;
|
||||
self.read_next_char();
|
||||
}
|
||||
if s == 1 {
|
||||
Token::Second
|
||||
} else if s == 2 {
|
||||
Token::SecondPadded
|
||||
} else {
|
||||
self.set_error("Unexpected character after 's'");
|
||||
Token::ILLEGAL
|
||||
}
|
||||
}
|
||||
'A' | 'a' => {
|
||||
if let Some('M') | Some('m') = self.peek_char() {
|
||||
self.read_next_char();
|
||||
} else {
|
||||
self.set_error("Unexpected character after 'A'");
|
||||
return Token::ILLEGAL;
|
||||
}
|
||||
if let Some('/') = self.peek_char() {
|
||||
self.read_next_char();
|
||||
} else {
|
||||
self.set_error("Unexpected character after 'AM'");
|
||||
return Token::ILLEGAL;
|
||||
}
|
||||
if let Some('P') | Some('p') = self.peek_char() {
|
||||
self.read_next_char();
|
||||
} else {
|
||||
self.set_error("Unexpected character after 'AM'");
|
||||
return Token::ILLEGAL;
|
||||
}
|
||||
if let Some('M') | Some('m') = self.peek_char() {
|
||||
self.read_next_char();
|
||||
} else {
|
||||
self.set_error("Unexpected character after 'AMP'");
|
||||
return Token::ILLEGAL;
|
||||
}
|
||||
Token::AMPM
|
||||
}
|
||||
'g' | 'G' => {
|
||||
for c in "eneral".chars() {
|
||||
let cc = self.read_next_char();
|
||||
if Some(c) != cc {
|
||||
self.set_error(&format!("Unexpected character: {x}"));
|
||||
self.set_error(&format!("Unexpected character: {}", x));
|
||||
return Token::ILLEGAL;
|
||||
}
|
||||
}
|
||||
Token::General
|
||||
}
|
||||
_ => {
|
||||
self.set_error(&format!("Unexpected character: {x}"));
|
||||
self.set_error(&format!("Unexpected character: {}", x));
|
||||
Token::ILLEGAL
|
||||
}
|
||||
},
|
||||
|
||||
@@ -74,7 +74,6 @@ mod test;
|
||||
//
|
||||
// * Color [Red] or [Color 23] or [Color23]
|
||||
// * Conditions [<100]
|
||||
// * Currency [$€]
|
||||
// * Space _X when X is any given char
|
||||
// * A spacer of chars: *X where X is repeated as much as possible
|
||||
// * Literals: $, (, ), :, +, - and space
|
||||
|
||||
@@ -27,13 +27,6 @@ pub enum TextToken {
|
||||
MonthLetter,
|
||||
YearShort,
|
||||
Year,
|
||||
Hour,
|
||||
HourPadded,
|
||||
Minute,
|
||||
MinutePadded,
|
||||
Second,
|
||||
SecondPadded,
|
||||
AMPM,
|
||||
}
|
||||
pub struct NumberPart {
|
||||
pub color: Option<i32>,
|
||||
@@ -47,12 +40,10 @@ pub struct NumberPart {
|
||||
pub is_scientific: bool,
|
||||
pub scientific_minus: bool,
|
||||
pub exponent_digit_count: i32,
|
||||
pub currency: Option<char>,
|
||||
}
|
||||
|
||||
pub struct DatePart {
|
||||
pub color: Option<i32>,
|
||||
pub use_ampm: bool,
|
||||
pub tokens: Vec<TextToken>,
|
||||
}
|
||||
|
||||
@@ -109,7 +100,6 @@ impl Parser {
|
||||
let mut digit_count = 0;
|
||||
let mut precision = 0;
|
||||
let mut is_date = false;
|
||||
let mut use_ampm = false;
|
||||
let mut is_number = false;
|
||||
let mut found_decimal_dot = false;
|
||||
let mut use_thousands = false;
|
||||
@@ -124,8 +114,6 @@ impl Parser {
|
||||
let mut exponent_digit_count = 0;
|
||||
let mut number = 'i';
|
||||
let mut index = 0;
|
||||
let mut currency = None;
|
||||
let mut is_time = false;
|
||||
|
||||
while token != Token::EOF && token != Token::Separator {
|
||||
let next_token = self.lexer.next_token();
|
||||
@@ -182,9 +170,6 @@ impl Parser {
|
||||
Token::Condition(cmp, value) => {
|
||||
condition = Some((cmp, value));
|
||||
}
|
||||
Token::Currency(c) => {
|
||||
currency = Some(c);
|
||||
}
|
||||
Token::QuestionMark => {
|
||||
tokens.push(TextToken::Digit(Digit {
|
||||
kind: '?',
|
||||
@@ -210,9 +195,6 @@ impl Parser {
|
||||
index += 1;
|
||||
}
|
||||
Token::Literal(value) => {
|
||||
if value == ':' {
|
||||
is_time = true;
|
||||
}
|
||||
tokens.push(TextToken::Literal(value));
|
||||
}
|
||||
Token::Text(value) => {
|
||||
@@ -249,22 +231,12 @@ impl Parser {
|
||||
tokens.push(TextToken::MonthName);
|
||||
}
|
||||
Token::Month => {
|
||||
if is_time {
|
||||
// minute
|
||||
tokens.push(TextToken::Minute);
|
||||
} else {
|
||||
is_date = true;
|
||||
tokens.push(TextToken::Month);
|
||||
}
|
||||
is_date = true;
|
||||
tokens.push(TextToken::Month);
|
||||
}
|
||||
Token::MonthPadded => {
|
||||
if is_time {
|
||||
// minute padded
|
||||
tokens.push(TextToken::MinutePadded);
|
||||
} else {
|
||||
is_date = true;
|
||||
tokens.push(TextToken::MonthPadded);
|
||||
}
|
||||
is_date = true;
|
||||
tokens.push(TextToken::MonthPadded);
|
||||
}
|
||||
Token::MonthLetter => {
|
||||
is_date = true;
|
||||
@@ -278,32 +250,6 @@ impl Parser {
|
||||
is_date = true;
|
||||
tokens.push(TextToken::Year);
|
||||
}
|
||||
Token::Hour => {
|
||||
is_date = true;
|
||||
is_time = true;
|
||||
tokens.push(TextToken::Hour);
|
||||
}
|
||||
Token::HourPadded => {
|
||||
is_date = true;
|
||||
is_time = true;
|
||||
tokens.push(TextToken::HourPadded);
|
||||
}
|
||||
Token::Second => {
|
||||
is_date = true;
|
||||
is_time = true;
|
||||
tokens.push(TextToken::Second);
|
||||
}
|
||||
Token::SecondPadded => {
|
||||
is_date = true;
|
||||
is_time = true;
|
||||
tokens.push(TextToken::SecondPadded);
|
||||
}
|
||||
|
||||
Token::AMPM => {
|
||||
is_date = true;
|
||||
use_ampm = true;
|
||||
tokens.push(TextToken::AMPM);
|
||||
}
|
||||
Token::Scientific => {
|
||||
if !is_scientific {
|
||||
index = 0;
|
||||
@@ -331,11 +277,7 @@ impl Parser {
|
||||
if is_number {
|
||||
return ParsePart::Error(ErrorPart {});
|
||||
}
|
||||
ParsePart::Date(DatePart {
|
||||
color,
|
||||
use_ampm,
|
||||
tokens,
|
||||
})
|
||||
ParsePart::Date(DatePart { color, tokens })
|
||||
} else {
|
||||
ParsePart::Number(NumberPart {
|
||||
color,
|
||||
@@ -349,7 +291,6 @@ impl Parser {
|
||||
is_scientific,
|
||||
scientific_minus,
|
||||
exponent_digit_count,
|
||||
currency,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,3 +1,2 @@
|
||||
mod test_general;
|
||||
mod test_parse_formatted_number;
|
||||
mod test_time;
|
||||
|
||||
@@ -76,14 +76,6 @@ fn test_color() {
|
||||
assert_eq!(format_number(3.1, "[blue]0.00", locale).color, Some(4));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dollar_euro() {
|
||||
let locale = get_default_locale();
|
||||
let format = "[$€]#,##0.00";
|
||||
let t = format_number(3.1, format, locale);
|
||||
assert_eq!(t.text, "€3.10");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parts() {
|
||||
let locale = get_default_locale();
|
||||
|
||||
@@ -1,32 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{
|
||||
formatter::format::format_number,
|
||||
locale::{get_locale, Locale},
|
||||
};
|
||||
|
||||
fn get_default_locale() -> &'static Locale {
|
||||
get_locale("en").unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn simple_test() {
|
||||
let locale = get_default_locale();
|
||||
let format = "h:mm AM/PM";
|
||||
let value = 16.001_423_611_111_11; // =1/86400 => 12:02 AM
|
||||
let formatted = format_number(value, format, locale);
|
||||
assert_eq!(formatted.text, "12:02 AM");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn padded_vs_unpadded() {
|
||||
let locale = get_default_locale();
|
||||
let padded_format = "hh:mm:ss AM/PM";
|
||||
let unpadded_format = "h:m:s AM/PM";
|
||||
let value = 0.25351851851851853; // => 6:05:04 AM (21904/(24*60*60)) where 21904 = 6 * 3600 + 5*60 + 4
|
||||
let formatted = format_number(value, padded_format, locale);
|
||||
assert_eq!(formatted.text, "06:05:04 AM");
|
||||
|
||||
let formatted = format_number(value, unpadded_format, locale);
|
||||
assert_eq!(formatted.text, "6:5:4 AM");
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -46,18 +46,18 @@ impl fmt::Display for Complex {
|
||||
// it is a bit weird what Excel does but it seems it uses general notation for
|
||||
// numbers > 1e-20 and scientific notation for the rest
|
||||
let y_str = if y.abs() <= 9e-20 {
|
||||
format!("{y:E}")
|
||||
format!("{:E}", y)
|
||||
} else if y == 1.0 {
|
||||
"".to_string()
|
||||
} else if y == -1.0 {
|
||||
"-".to_string()
|
||||
} else {
|
||||
format!("{y}")
|
||||
format!("{}", y)
|
||||
};
|
||||
let x_str = if x.abs() <= 9e-20 {
|
||||
format!("{x:E}")
|
||||
format!("{:E}", x)
|
||||
} else {
|
||||
format!("{x}")
|
||||
format!("{}", x)
|
||||
};
|
||||
if y == 0.0 && x == 0.0 {
|
||||
write!(f, "0")
|
||||
@@ -188,7 +188,10 @@ impl Model {
|
||||
node: &Node,
|
||||
cell: CellReferenceIndex,
|
||||
) -> Result<(f64, f64, Suffix), CalcResult> {
|
||||
let value = self.get_string(node, cell)?;
|
||||
let value = match self.get_string(node, cell) {
|
||||
Ok(s) => s,
|
||||
Err(s) => return Err(s),
|
||||
};
|
||||
if value.is_empty() {
|
||||
return Ok((0.0, 0.0, Suffix::I));
|
||||
}
|
||||
|
||||
@@ -76,7 +76,7 @@ impl Model {
|
||||
if value < 0 {
|
||||
CalcResult::String(format!("{:0width$X}", HEX_MAX + value, width = 9))
|
||||
} else {
|
||||
let result = format!("{value:X}");
|
||||
let result = format!("{:X}", value);
|
||||
if let Some(places) = places {
|
||||
if places < result.len() as i32 {
|
||||
return CalcResult::new_error(
|
||||
@@ -120,7 +120,7 @@ impl Model {
|
||||
if value < 0 {
|
||||
CalcResult::String(format!("{:0width$o}", OCT_MAX + value, width = 9))
|
||||
} else {
|
||||
let result = format!("{value:o}");
|
||||
let result = format!("{:o}", value);
|
||||
if let Some(places) = places {
|
||||
if places < result.len() as i32 {
|
||||
return CalcResult::new_error(
|
||||
@@ -163,7 +163,7 @@ impl Model {
|
||||
if value < 0 {
|
||||
value += 1024;
|
||||
}
|
||||
let result = format!("{value:b}");
|
||||
let result = format!("{:b}", value);
|
||||
if let Some(places) = places {
|
||||
if value_raw > 0.0 && places < result.len() as i32 {
|
||||
return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
|
||||
@@ -202,7 +202,7 @@ impl Model {
|
||||
if value < 0 {
|
||||
value += HEX_MAX;
|
||||
}
|
||||
let result = format!("{value:X}");
|
||||
let result = format!("{:X}", value);
|
||||
if let Some(places) = places {
|
||||
if value_raw > 0.0 && places < result.len() as i32 {
|
||||
return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
|
||||
@@ -242,7 +242,7 @@ impl Model {
|
||||
if value < 0 {
|
||||
value += OCT_MAX;
|
||||
}
|
||||
let result = format!("{value:o}");
|
||||
let result = format!("{:o}", value);
|
||||
if let Some(places) = places {
|
||||
if value_raw > 0.0 && places < result.len() as i32 {
|
||||
return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
|
||||
@@ -301,7 +301,7 @@ impl Model {
|
||||
if value < 0 {
|
||||
value += 1024;
|
||||
}
|
||||
let result = format!("{value:b}");
|
||||
let result = format!("{:b}", value);
|
||||
if let Some(places) = places {
|
||||
if places <= 0 || (value > 0 && places < result.len() as i32) {
|
||||
return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
|
||||
@@ -391,7 +391,7 @@ impl Model {
|
||||
if value < 0 {
|
||||
value += OCT_MAX;
|
||||
}
|
||||
let result = format!("{value:o}");
|
||||
let result = format!("{:o}", value);
|
||||
if let Some(places) = places {
|
||||
if places <= 0 || (value > 0 && places < result.len() as i32) {
|
||||
return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
|
||||
@@ -446,7 +446,7 @@ impl Model {
|
||||
if value < 0 {
|
||||
value += 1024;
|
||||
}
|
||||
let result = format!("{value:b}");
|
||||
let result = format!("{:b}", value);
|
||||
if let Some(places) = places {
|
||||
if value < 512 && places < result.len() as i32 {
|
||||
return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
|
||||
@@ -532,7 +532,7 @@ impl Model {
|
||||
if value < 0 {
|
||||
value += HEX_MAX;
|
||||
}
|
||||
let result = format!("{value:X}");
|
||||
let result = format!("{:X}", value);
|
||||
if let Some(places) = places {
|
||||
if value < HEX_MAX_HALF && places < result.len() as i32 {
|
||||
return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,6 +1,6 @@
|
||||
use crate::{
|
||||
calc_result::CalcResult,
|
||||
expressions::{parser::Node, token::Error, types::CellReferenceIndex, utils::number_to_column},
|
||||
expressions::{parser::Node, token::Error, types::CellReferenceIndex},
|
||||
model::{Model, ParsedDefinedName},
|
||||
};
|
||||
|
||||
@@ -235,11 +235,6 @@ impl Model {
|
||||
// This cannot happen
|
||||
CalcResult::Number(1.0)
|
||||
}
|
||||
CalcResult::Array(_) => CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
},
|
||||
}
|
||||
}
|
||||
pub(crate) fn fn_sheet(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
@@ -252,218 +247,50 @@ impl Model {
|
||||
return CalcResult::Number(cell.sheet as f64 + 1.0);
|
||||
}
|
||||
// The arg could be a defined name or a table
|
||||
// let = &args[0];
|
||||
match &args[0] {
|
||||
Node::DefinedNameKind((name, scope, _)) => {
|
||||
// Let's see if it is a defined name
|
||||
if let Some(defined_name) = self
|
||||
.parsed_defined_names
|
||||
.get(&(*scope, name.to_lowercase()))
|
||||
{
|
||||
match defined_name {
|
||||
ParsedDefinedName::CellReference(reference) => {
|
||||
return CalcResult::Number(reference.sheet as f64 + 1.0)
|
||||
}
|
||||
ParsedDefinedName::RangeReference(range) => {
|
||||
return CalcResult::Number(range.left.sheet as f64 + 1.0)
|
||||
}
|
||||
ParsedDefinedName::InvalidDefinedNameFormula => {
|
||||
return CalcResult::Error {
|
||||
error: Error::ERROR,
|
||||
origin: cell,
|
||||
message: "Invalid name".to_string(),
|
||||
};
|
||||
}
|
||||
let arg = &args[0];
|
||||
if let Node::VariableKind(name) = arg {
|
||||
// Let's see if it is a defined name
|
||||
if let Some(defined_name) = self.parsed_defined_names.get(&(None, name.to_lowercase()))
|
||||
{
|
||||
match defined_name {
|
||||
ParsedDefinedName::CellReference(reference) => {
|
||||
return CalcResult::Number(reference.sheet as f64 + 1.0)
|
||||
}
|
||||
} else {
|
||||
// This should never happen
|
||||
return CalcResult::Error {
|
||||
error: Error::ERROR,
|
||||
origin: cell,
|
||||
message: "Invalid name".to_string(),
|
||||
};
|
||||
}
|
||||
}
|
||||
Node::TableNameKind(name) => {
|
||||
// Now let's see if it is a table
|
||||
for (table_name, table) in &self.workbook.tables {
|
||||
if table_name == name {
|
||||
if let Some(sheet_index) = self.get_sheet_index_by_name(&table.sheet_name) {
|
||||
return CalcResult::Number(sheet_index as f64 + 1.0);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
ParsedDefinedName::RangeReference(range) => {
|
||||
return CalcResult::Number(range.left.sheet as f64 + 1.0)
|
||||
}
|
||||
ParsedDefinedName::InvalidDefinedNameFormula => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NA,
|
||||
origin: cell,
|
||||
message: "Invalid name".to_string(),
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
Node::WrongVariableKind(name) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NAME,
|
||||
origin: cell,
|
||||
message: format!("Name not found: {name}"),
|
||||
}
|
||||
}
|
||||
arg => {
|
||||
// Now it should be the name of a sheet
|
||||
let sheet_name = match self.get_string(arg, cell) {
|
||||
Ok(s) => s,
|
||||
Err(e) => return e,
|
||||
};
|
||||
if let Some(sheet_index) = self.get_sheet_index_by_name(&sheet_name) {
|
||||
return CalcResult::Number(sheet_index as f64 + 1.0);
|
||||
// Now let's see if it is a table
|
||||
for (table_name, table) in &self.workbook.tables {
|
||||
if table_name == name {
|
||||
if let Some(sheet_index) = self.get_sheet_index_by_name(&table.sheet_name) {
|
||||
return CalcResult::Number(sheet_index as f64 + 1.0);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Now it should be the name of a sheet
|
||||
let sheet_name = match self.get_string(arg, cell) {
|
||||
Ok(s) => s,
|
||||
Err(e) => return e,
|
||||
};
|
||||
if let Some(sheet_index) = self.get_sheet_index_by_name(&sheet_name) {
|
||||
return CalcResult::Number(sheet_index as f64 + 1.0);
|
||||
}
|
||||
CalcResult::Error {
|
||||
error: Error::NA,
|
||||
origin: cell,
|
||||
message: "Invalid name".to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn fn_n(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
let arg_count = args.len();
|
||||
if arg_count != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.evaluate_node_in_context(&args[0], cell) {
|
||||
CalcResult::Number(n) => n,
|
||||
CalcResult::String(_) => 0.0,
|
||||
CalcResult::Boolean(f) => {
|
||||
if f {
|
||||
1.0
|
||||
} else {
|
||||
0.0
|
||||
}
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => 0.0,
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::Range { .. } => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
CalcResult::Number(value)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_sheets(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
let arg_count = args.len();
|
||||
if arg_count > 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
if arg_count == 1 {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Sheets function with an argument is not implemented".to_string(),
|
||||
};
|
||||
}
|
||||
let sheet_count = self.workbook.worksheets.len() as f64;
|
||||
CalcResult::Number(sheet_count)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_cell(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
let arg_count = args.len();
|
||||
if arg_count == 0 || arg_count > 2 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let reference = if arg_count == 2 {
|
||||
match self.evaluate_node_with_reference(&args[1], cell) {
|
||||
CalcResult::Range { left, right: _ } => {
|
||||
// we just take the left cell of the range
|
||||
left
|
||||
}
|
||||
_ => {
|
||||
return CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Argument must be a reference".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
CellReferenceIndex {
|
||||
sheet: cell.sheet,
|
||||
row: cell.row,
|
||||
column: cell.column,
|
||||
}
|
||||
};
|
||||
let info_type = match self.get_string(&args[0], cell) {
|
||||
Ok(s) => s.to_uppercase(),
|
||||
Err(e) => return e,
|
||||
};
|
||||
match info_type.as_str() {
|
||||
"ADDRESS" => {
|
||||
if reference.sheet != cell.sheet {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "References to other sheets not implemented".to_string(),
|
||||
};
|
||||
}
|
||||
let column = match number_to_column(reference.column) {
|
||||
Some(c) => c,
|
||||
None => {
|
||||
return CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Invalid column".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
let address = format!("${}${}", column, reference.row);
|
||||
CalcResult::String(address)
|
||||
}
|
||||
"COL" => CalcResult::Number(reference.column as f64),
|
||||
"COLOR" | "FILENAME" | "FORMAT" | "PARENTHESES" | "PREFIX" | "PROTECT" | "WIDTH" => {
|
||||
CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "info_type not implemented".to_string(),
|
||||
}
|
||||
}
|
||||
"CONTENTS" => self.evaluate_cell(reference),
|
||||
"ROW" => CalcResult::Number(reference.row as f64),
|
||||
"TYPE" => {
|
||||
let cell_type = match self.evaluate_cell(reference) {
|
||||
CalcResult::EmptyCell => "b",
|
||||
CalcResult::String(_) => "l",
|
||||
CalcResult::Number(_) => "v",
|
||||
CalcResult::Boolean(_) => "v",
|
||||
CalcResult::Error { .. } => "v",
|
||||
CalcResult::Range { .. } => "v",
|
||||
CalcResult::EmptyArg => "v",
|
||||
CalcResult::Array(_) => "v",
|
||||
};
|
||||
CalcResult::String(cell_type.to_string())
|
||||
}
|
||||
_ => CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Invalid info_type".to_string(),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn fn_info(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.is_empty() || args.len() > 2 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Info function not implemented".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,22 +7,6 @@ use crate::{
|
||||
use super::util::compare_values;
|
||||
|
||||
impl Model {
|
||||
pub(crate) fn fn_true(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.is_empty() {
|
||||
CalcResult::Boolean(true)
|
||||
} else {
|
||||
CalcResult::new_args_number_error(cell)
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn fn_false(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.is_empty() {
|
||||
CalcResult::Boolean(false)
|
||||
} else {
|
||||
CalcResult::new_args_number_error(cell)
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn fn_if(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() == 2 || args.len() == 3 {
|
||||
let cond_result = self.get_boolean(&args[0], cell);
|
||||
@@ -82,61 +66,24 @@ impl Model {
|
||||
}
|
||||
|
||||
pub(crate) fn fn_and(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
self.logical_nary(
|
||||
args,
|
||||
cell,
|
||||
|acc, value| acc.unwrap_or(true) && value,
|
||||
Some(false),
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_or(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
self.logical_nary(
|
||||
args,
|
||||
cell,
|
||||
|acc, value| acc.unwrap_or(false) || value,
|
||||
Some(true),
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_xor(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
self.logical_nary(args, cell, |acc, value| acc.unwrap_or(false) ^ value, None)
|
||||
}
|
||||
|
||||
/// Base function for AND, OR, XOR. These are all n-ary functions that perform a boolean operation on a series of
|
||||
/// boolean values. These boolean values are sourced from `args`. Note that there is not a 1-1 relationship between
|
||||
/// arguments and boolean values evaluated (see how Ranges are handled for example).
|
||||
///
|
||||
/// Each argument in `args` is evaluated and the resulting value is interpreted as a boolean as follows:
|
||||
/// - Boolean: The value is used directly.
|
||||
/// - Number: 0 is FALSE, all other values are TRUE.
|
||||
/// - Range: Each cell in the range is evaluated as if they were individual arguments with some caveats
|
||||
/// - Empty arg: FALSE
|
||||
/// - Empty cell & String: Ignored, behaves exactly like the argument wasn't passed in at all
|
||||
/// - Error: Propagated
|
||||
///
|
||||
/// If no arguments are provided, or all arguments are ignored, the function returns a #VALUE! error
|
||||
///
|
||||
/// **`fold_fn`:** The function that combines the running result with the next value boolean value. The running result
|
||||
/// starts as `None`.
|
||||
///
|
||||
/// **`short_circuit_value`:** If the running result reaches `short_circuit_value`, the function returns early.
|
||||
fn logical_nary(
|
||||
&mut self,
|
||||
args: &[Node],
|
||||
cell: CellReferenceIndex,
|
||||
fold_fn: fn(Option<bool>, bool) -> bool,
|
||||
short_circuit_value: Option<bool>,
|
||||
) -> CalcResult {
|
||||
if args.is_empty() {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
|
||||
let mut result = None;
|
||||
let mut true_count = 0;
|
||||
for arg in args {
|
||||
match self.evaluate_node_in_context(arg, cell) {
|
||||
CalcResult::Boolean(value) => result = Some(fold_fn(result, value)),
|
||||
CalcResult::Number(value) => result = Some(fold_fn(result, value != 0.0)),
|
||||
CalcResult::Boolean(b) => {
|
||||
if !b {
|
||||
return CalcResult::Boolean(false);
|
||||
}
|
||||
true_count += 1;
|
||||
}
|
||||
CalcResult::Number(value) => {
|
||||
if value == 0.0 {
|
||||
return CalcResult::Boolean(false);
|
||||
}
|
||||
true_count += 1;
|
||||
}
|
||||
CalcResult::String(_value) => {
|
||||
true_count += 1;
|
||||
}
|
||||
CalcResult::Range { left, right } => {
|
||||
if left.sheet != right.sheet {
|
||||
return CalcResult::new_error(
|
||||
@@ -152,72 +99,158 @@ impl Model {
|
||||
row,
|
||||
column,
|
||||
}) {
|
||||
CalcResult::Boolean(value) => result = Some(fold_fn(result, value)),
|
||||
CalcResult::Boolean(b) => {
|
||||
if !b {
|
||||
return CalcResult::Boolean(false);
|
||||
}
|
||||
true_count += 1;
|
||||
}
|
||||
CalcResult::Number(value) => {
|
||||
result = Some(fold_fn(result, value != 0.0))
|
||||
if value == 0.0 {
|
||||
return CalcResult::Boolean(false);
|
||||
}
|
||||
true_count += 1;
|
||||
}
|
||||
CalcResult::String(_value) => {
|
||||
true_count += 1;
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::EmptyArg => {} // unreachable
|
||||
CalcResult::Range { .. }
|
||||
| CalcResult::String { .. }
|
||||
| CalcResult::EmptyCell => {}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
if let (Some(current_result), Some(short_circuit_value)) =
|
||||
(result, short_circuit_value)
|
||||
{
|
||||
if current_result == short_circuit_value {
|
||||
return CalcResult::Boolean(current_result);
|
||||
}
|
||||
CalcResult::Range { .. } => {}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::EmptyArg => result = Some(result.unwrap_or(false)),
|
||||
// Strings are ignored unless they are "TRUE" or "FALSE" (case insensitive). EXCEPT if the string value
|
||||
// comes from a reference, in which case it is always ignored regardless of its value.
|
||||
CalcResult::String(..) => {
|
||||
if !matches!(arg, Node::ReferenceKind { .. }) {
|
||||
if let Ok(f) = self.get_boolean(arg, cell) {
|
||||
result = Some(fold_fn(result, f));
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => {}
|
||||
};
|
||||
}
|
||||
if true_count == 0 {
|
||||
return CalcResult::new_error(
|
||||
Error::VALUE,
|
||||
cell,
|
||||
"Boolean values not found".to_string(),
|
||||
);
|
||||
}
|
||||
CalcResult::Boolean(true)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_or(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
let mut result = false;
|
||||
for arg in args {
|
||||
match self.evaluate_node_in_context(arg, cell) {
|
||||
CalcResult::Boolean(value) => result = value || result,
|
||||
CalcResult::Number(value) => {
|
||||
if value != 0.0 {
|
||||
return CalcResult::Boolean(true);
|
||||
}
|
||||
}
|
||||
CalcResult::String(_value) => {
|
||||
return CalcResult::Boolean(true);
|
||||
}
|
||||
CalcResult::Range { left, right } => {
|
||||
if left.sheet != right.sheet {
|
||||
return CalcResult::new_error(
|
||||
Error::VALUE,
|
||||
cell,
|
||||
"Ranges are in different sheets".to_string(),
|
||||
);
|
||||
}
|
||||
for row in left.row..(right.row + 1) {
|
||||
for column in left.column..(right.column + 1) {
|
||||
match self.evaluate_cell(CellReferenceIndex {
|
||||
sheet: left.sheet,
|
||||
row,
|
||||
column,
|
||||
}) {
|
||||
CalcResult::Boolean(value) => {
|
||||
result = value || result;
|
||||
}
|
||||
CalcResult::Number(value) => {
|
||||
if value != 0.0 {
|
||||
return CalcResult::Boolean(true);
|
||||
}
|
||||
}
|
||||
CalcResult::String(_value) => {
|
||||
return CalcResult::Boolean(true);
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::Range { .. } => {}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// References to empty cells are ignored. If all args are ignored the result is #VALUE!
|
||||
CalcResult::EmptyCell => {}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => {}
|
||||
};
|
||||
}
|
||||
CalcResult::Boolean(result)
|
||||
}
|
||||
|
||||
/// XOR(logical1, [logical]*,...)
|
||||
/// Logical1 is required, subsequent logical values are optional. Can be logical values, arrays, or references.
|
||||
/// The result of XOR is TRUE when the number of TRUE inputs is odd and FALSE when the number of TRUE inputs is even.
|
||||
pub(crate) fn fn_xor(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
let mut true_count = 0;
|
||||
let mut false_count = 0;
|
||||
for arg in args {
|
||||
match self.evaluate_node_in_context(arg, cell) {
|
||||
CalcResult::Boolean(b) => {
|
||||
if b {
|
||||
true_count += 1;
|
||||
} else {
|
||||
false_count += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if let (Some(current_result), Some(short_circuit_value)) = (result, short_circuit_value)
|
||||
{
|
||||
if current_result == short_circuit_value {
|
||||
return CalcResult::Boolean(current_result);
|
||||
CalcResult::Number(value) => {
|
||||
if value != 0.0 {
|
||||
true_count += 1;
|
||||
} else {
|
||||
false_count += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
CalcResult::Range { left, right } => {
|
||||
if left.sheet != right.sheet {
|
||||
return CalcResult::new_error(
|
||||
Error::VALUE,
|
||||
cell,
|
||||
"Ranges are in different sheets".to_string(),
|
||||
);
|
||||
}
|
||||
for row in left.row..(right.row + 1) {
|
||||
for column in left.column..(right.column + 1) {
|
||||
match self.evaluate_cell(CellReferenceIndex {
|
||||
sheet: left.sheet,
|
||||
row,
|
||||
column,
|
||||
}) {
|
||||
CalcResult::Boolean(b) => {
|
||||
if b {
|
||||
true_count += 1;
|
||||
} else {
|
||||
false_count += 1;
|
||||
}
|
||||
}
|
||||
CalcResult::Number(value) => {
|
||||
if value != 0.0 {
|
||||
true_count += 1;
|
||||
} else {
|
||||
false_count += 1;
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
};
|
||||
}
|
||||
|
||||
if let Some(result) = result {
|
||||
CalcResult::Boolean(result)
|
||||
} else {
|
||||
CalcResult::new_error(
|
||||
Error::VALUE,
|
||||
cell,
|
||||
"No logical values in argument list".to_string(),
|
||||
)
|
||||
if true_count == 0 && false_count == 0 {
|
||||
return CalcResult::new_error(Error::VALUE, cell, "No booleans found".to_string());
|
||||
}
|
||||
CalcResult::Boolean(true_count % 2 == 1)
|
||||
}
|
||||
|
||||
/// =SWITCH(expression, case1, value1, [case, value]*, [default])
|
||||
@@ -246,7 +279,7 @@ impl Model {
|
||||
}
|
||||
// None of the cases matched so we return the default
|
||||
// If there is an even number of args is the last one otherwise is #N/A
|
||||
if args_count.is_multiple_of(2) {
|
||||
if args_count % 2 == 0 {
|
||||
return self.evaluate_node_in_context(&args[args_count - 1], cell);
|
||||
}
|
||||
CalcResult::Error {
|
||||
@@ -262,7 +295,7 @@ impl Model {
|
||||
if args_count < 2 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
if !args_count.is_multiple_of(2) {
|
||||
if args_count % 2 != 0 {
|
||||
// Missing value for last condition
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
|
||||
@@ -855,7 +855,7 @@ impl Model {
|
||||
if left.row != right.row || left.column != right.column {
|
||||
// FIXME: Implicit intersection or dynamic arrays
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
error: Error::ERROR,
|
||||
origin: cell,
|
||||
message: "argument must be a reference to a single cell".to_string(),
|
||||
};
|
||||
|
||||
@@ -1,100 +0,0 @@
|
||||
#[macro_export]
|
||||
macro_rules! single_number_fn {
|
||||
// The macro takes:
|
||||
// 1) A function name to define (e.g. fn_sin)
|
||||
// 2) The operation to apply (e.g. f64::sin)
|
||||
($fn_name:ident, $op:expr) => {
|
||||
pub(crate) fn $fn_name(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
// 1) Check exactly one argument
|
||||
if args.len() != 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
// 2) Try to get a "NumberOrArray"
|
||||
match self.get_number_or_array(&args[0], cell) {
|
||||
// -----------------------------------------
|
||||
// Case A: It's a single number
|
||||
// -----------------------------------------
|
||||
Ok(NumberOrArray::Number(f)) => match $op(f) {
|
||||
Ok(x) => CalcResult::Number(x),
|
||||
Err(Error::DIV) => CalcResult::Error {
|
||||
error: Error::DIV,
|
||||
origin: cell,
|
||||
message: "Divide by 0".to_string(),
|
||||
},
|
||||
Err(Error::VALUE) => CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Invalid number".to_string(),
|
||||
},
|
||||
Err(e) => CalcResult::Error {
|
||||
error: e,
|
||||
origin: cell,
|
||||
message: "Unknown error".to_string(),
|
||||
},
|
||||
},
|
||||
|
||||
// -----------------------------------------
|
||||
// Case B: It's an array, so apply $op
|
||||
// element-by-element.
|
||||
// -----------------------------------------
|
||||
Ok(NumberOrArray::Array(a)) => {
|
||||
let mut array = Vec::new();
|
||||
for row in a {
|
||||
let mut data_row = Vec::with_capacity(row.len());
|
||||
for value in row {
|
||||
match value {
|
||||
// If Boolean, treat as 0.0 or 1.0
|
||||
ArrayNode::Boolean(b) => {
|
||||
let n = if b { 1.0 } else { 0.0 };
|
||||
match $op(n) {
|
||||
Ok(x) => data_row.push(ArrayNode::Number(x)),
|
||||
Err(Error::DIV) => {
|
||||
data_row.push(ArrayNode::Error(Error::DIV))
|
||||
}
|
||||
Err(Error::VALUE) => {
|
||||
data_row.push(ArrayNode::Error(Error::VALUE))
|
||||
}
|
||||
Err(e) => data_row.push(ArrayNode::Error(e)),
|
||||
}
|
||||
}
|
||||
// If Number, apply directly
|
||||
ArrayNode::Number(n) => match $op(n) {
|
||||
Ok(x) => data_row.push(ArrayNode::Number(x)),
|
||||
Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
|
||||
Err(Error::VALUE) => {
|
||||
data_row.push(ArrayNode::Error(Error::VALUE))
|
||||
}
|
||||
Err(e) => data_row.push(ArrayNode::Error(e)),
|
||||
},
|
||||
// If String, parse to f64 then apply or #VALUE! error
|
||||
ArrayNode::String(s) => {
|
||||
let node = match s.parse::<f64>() {
|
||||
Ok(f) => match $op(f) {
|
||||
Ok(x) => ArrayNode::Number(x),
|
||||
Err(Error::DIV) => ArrayNode::Error(Error::DIV),
|
||||
Err(Error::VALUE) => ArrayNode::Error(Error::VALUE),
|
||||
Err(e) => ArrayNode::Error(e),
|
||||
},
|
||||
Err(_) => ArrayNode::Error(Error::VALUE),
|
||||
};
|
||||
data_row.push(node);
|
||||
}
|
||||
// If Error, propagate the error
|
||||
e @ ArrayNode::Error(_) => {
|
||||
data_row.push(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
array.push(data_row);
|
||||
}
|
||||
CalcResult::Array(array)
|
||||
}
|
||||
|
||||
// -----------------------------------------
|
||||
// Case C: It's an Error => just return it
|
||||
// -----------------------------------------
|
||||
Err(err_result) => err_result,
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
@@ -1,200 +0,0 @@
|
||||
/// Parse Roman (classic or Excel variants) → number
|
||||
pub fn from_roman(s: &str) -> Result<u32, String> {
|
||||
if s.is_empty() {
|
||||
return Err("empty numeral".into());
|
||||
}
|
||||
fn val(c: char) -> Option<u32> {
|
||||
Some(match c {
|
||||
'I' => 1,
|
||||
'V' => 5,
|
||||
'X' => 10,
|
||||
'L' => 50,
|
||||
'C' => 100,
|
||||
'D' => 500,
|
||||
'M' => 1000,
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
||||
// Accept the union of subtractive pairs used by the tables above (Excel-compatible).
|
||||
fn allowed_subtractive(a: char, b: char) -> bool {
|
||||
matches!(
|
||||
(a, b),
|
||||
// classic:
|
||||
('I','V')|('I','X')|('X','L')|('X','C')|('C','D')|('C','M')
|
||||
// Excel forms:
|
||||
|('V','L')|('L','D')|('L','M') // VL, LD, LM
|
||||
|('X','D')|('X','M') // XD, XM
|
||||
|('V','M') // VM
|
||||
|('I','L')|('I','C')|('I','D')|('I','M') // IL, IC, ID, IM
|
||||
|('V','D')|('V','C') // VD, VC
|
||||
)
|
||||
}
|
||||
|
||||
let chars: Vec<char> = s.chars().map(|c| c.to_ascii_uppercase()).collect();
|
||||
let mut total = 0u32;
|
||||
let mut i = 0usize;
|
||||
|
||||
// Repetition rules similar to classic Romans:
|
||||
// V, L, D cannot repeat; I, X, C, M max 3 in a row.
|
||||
let mut last_char: Option<char> = None;
|
||||
let mut run_len = 0usize;
|
||||
|
||||
while i < chars.len() {
|
||||
let c = chars[i];
|
||||
let v = val(c).ok_or_else(|| format!("invalid character '{c}'"))?;
|
||||
|
||||
if Some(c) == last_char {
|
||||
run_len += 1;
|
||||
match c {
|
||||
'V' | 'L' | 'D' => return Err(format!("invalid repetition of '{c}'")),
|
||||
_ if run_len >= 3 => return Err(format!("invalid repetition of '{c}'")),
|
||||
_ => {}
|
||||
}
|
||||
} else {
|
||||
last_char = Some(c);
|
||||
run_len = 0;
|
||||
}
|
||||
|
||||
if i + 1 < chars.len() {
|
||||
let c2 = chars[i + 1];
|
||||
let v2 = val(c2).ok_or_else(|| format!("invalid character '{c2}'"))?;
|
||||
if v < v2 {
|
||||
if !allowed_subtractive(c, c2) {
|
||||
return Err(format!("invalid subtractive pair '{c}{c2}'"));
|
||||
}
|
||||
// Disallow stacked subtractives like IIV, XXL:
|
||||
if run_len > 0 {
|
||||
return Err(format!("malformed numeral near position {i}"));
|
||||
}
|
||||
total += v2 - v;
|
||||
i += 2;
|
||||
last_char = None;
|
||||
run_len = 0;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
total += v;
|
||||
i += 1;
|
||||
}
|
||||
Ok(total)
|
||||
}
|
||||
|
||||
/// Classic Roman (strict) encoder used as a base for all forms.
|
||||
fn to_roman(mut n: u32) -> Result<String, String> {
|
||||
if !(1..=3999).contains(&n) {
|
||||
return Err("value out of range (must be 1..=3999)".into());
|
||||
}
|
||||
|
||||
const MAP: &[(u32, &str)] = &[
|
||||
(1000, "M"),
|
||||
(900, "CM"),
|
||||
(500, "D"),
|
||||
(400, "CD"),
|
||||
(100, "C"),
|
||||
(90, "XC"),
|
||||
(50, "L"),
|
||||
(40, "XL"),
|
||||
(10, "X"),
|
||||
(9, "IX"),
|
||||
(5, "V"),
|
||||
(4, "IV"),
|
||||
(1, "I"),
|
||||
];
|
||||
|
||||
let mut out = String::with_capacity(15);
|
||||
for &(val, sym) in MAP {
|
||||
while n >= val {
|
||||
out.push_str(sym);
|
||||
n -= val;
|
||||
}
|
||||
if n == 0 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Excel/Google Sheets compatible ROMAN(number, [form]) encoder.
|
||||
/// `form`: 0..=4 (0=Classic, 4=Simplified).
|
||||
pub fn to_roman_with_form(n: u32, form: i32) -> Result<String, String> {
|
||||
let mut s = to_roman(n)?;
|
||||
if form == 0 {
|
||||
return Ok(s);
|
||||
}
|
||||
if !(0..=4).contains(&form) {
|
||||
return Err("form must be between 0 and 4".into());
|
||||
}
|
||||
|
||||
// Base rules (apply for all f >= 1)
|
||||
let base_rules: &[(&str, &str)] = &[
|
||||
// C(D|M)XC -> L$1XL
|
||||
("CDXC", "LDXL"),
|
||||
("CMXC", "LMXL"),
|
||||
// C(D|M)L -> L$1
|
||||
("CDL", "LD"),
|
||||
("CML", "LM"),
|
||||
// X(L|C)IX -> V$1IV
|
||||
("XLIX", "VLIV"),
|
||||
("XCIX", "VCIV"),
|
||||
// X(L|C)V -> V$1
|
||||
("XLV", "VL"),
|
||||
("XCV", "VC"),
|
||||
];
|
||||
|
||||
// Level 2 extra rules
|
||||
let lvl2_rules: &[(&str, &str)] = &[
|
||||
// V(L|C)IV -> I$1
|
||||
("VLIV", "IL"),
|
||||
("VCIV", "IC"),
|
||||
// L(D|M)XL -> X$1
|
||||
("LDXL", "XD"),
|
||||
("LMXL", "XM"),
|
||||
// L(D|M)VL -> X$1V
|
||||
("LDVL", "XDV"),
|
||||
("LMVL", "XMV"),
|
||||
// L(D|M)IL -> X$1IX
|
||||
("LDIL", "XDIX"),
|
||||
("LMIL", "XMIX"),
|
||||
];
|
||||
|
||||
// Level 3 extra rules
|
||||
let lvl3_rules: &[(&str, &str)] = &[
|
||||
// X(D|M)V -> V$1
|
||||
("XDV", "VD"),
|
||||
("XMV", "VM"),
|
||||
// X(D|M)IX -> V$1IV
|
||||
("XDIX", "VDIV"),
|
||||
("XMIX", "VMIV"),
|
||||
];
|
||||
|
||||
// Level 4 extra rules
|
||||
let lvl4_rules: &[(&str, &str)] = &[
|
||||
// V(D|M)IV -> I$1
|
||||
("VDIV", "ID"),
|
||||
("VMIV", "IM"),
|
||||
];
|
||||
|
||||
// Helper to apply a batch of (from -> to) globally, in order.
|
||||
fn apply_rules(mut t: String, rules: &[(&str, &str)]) -> String {
|
||||
for (from, to) in rules {
|
||||
if t.contains(from) {
|
||||
t = t.replace(from, to);
|
||||
}
|
||||
}
|
||||
t
|
||||
}
|
||||
|
||||
s = apply_rules(s, base_rules);
|
||||
if form >= 2 {
|
||||
s = apply_rules(s, lvl2_rules);
|
||||
}
|
||||
if form >= 3 {
|
||||
s = apply_rules(s, lvl3_rules);
|
||||
}
|
||||
if form >= 4 {
|
||||
s = apply_rules(s, lvl4_rules);
|
||||
}
|
||||
Ok(s)
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -15,8 +15,6 @@ mod financial_util;
|
||||
mod information;
|
||||
mod logical;
|
||||
mod lookup_and_reference;
|
||||
mod macros;
|
||||
mod math_util;
|
||||
mod mathematical;
|
||||
mod statistical;
|
||||
mod subtotal;
|
||||
@@ -55,9 +53,6 @@ pub enum Function {
|
||||
Columns,
|
||||
Cos,
|
||||
Cosh,
|
||||
Log,
|
||||
Log10,
|
||||
Ln,
|
||||
Max,
|
||||
Min,
|
||||
Pi,
|
||||
@@ -77,43 +72,6 @@ pub enum Function {
|
||||
Sumifs,
|
||||
Tan,
|
||||
Tanh,
|
||||
Acot,
|
||||
Acoth,
|
||||
Cot,
|
||||
Coth,
|
||||
Csc,
|
||||
Csch,
|
||||
Sec,
|
||||
Sech,
|
||||
Exp,
|
||||
Fact,
|
||||
Factdouble,
|
||||
Sign,
|
||||
Radians,
|
||||
Degrees,
|
||||
Int,
|
||||
Even,
|
||||
Odd,
|
||||
Ceiling,
|
||||
CeilingMath,
|
||||
CeilingPrecise,
|
||||
Floor,
|
||||
FloorMath,
|
||||
FloorPrecise,
|
||||
IsoCeiling,
|
||||
Mod,
|
||||
Quotient,
|
||||
Mround,
|
||||
Trunc,
|
||||
Gcd,
|
||||
Lcm,
|
||||
Base,
|
||||
Decimal,
|
||||
Roman,
|
||||
Arabic,
|
||||
Combin,
|
||||
Combina,
|
||||
Sumsq,
|
||||
|
||||
// Information
|
||||
ErrorType,
|
||||
@@ -134,11 +92,6 @@ pub enum Function {
|
||||
Sheet,
|
||||
Type,
|
||||
|
||||
Sheets,
|
||||
N,
|
||||
Cell,
|
||||
Info,
|
||||
|
||||
// Lookup and reference
|
||||
Hlookup,
|
||||
Index,
|
||||
@@ -187,44 +140,18 @@ pub enum Function {
|
||||
Countifs,
|
||||
Maxifs,
|
||||
Minifs,
|
||||
Geomean,
|
||||
|
||||
// Date and time
|
||||
Date,
|
||||
Datedif,
|
||||
Datevalue,
|
||||
Day,
|
||||
Edate,
|
||||
Eomonth,
|
||||
Month,
|
||||
Time,
|
||||
Timevalue,
|
||||
Hour,
|
||||
Minute,
|
||||
Second,
|
||||
Now,
|
||||
Today,
|
||||
Year,
|
||||
Networkdays,
|
||||
NetworkdaysIntl,
|
||||
Days,
|
||||
Days360,
|
||||
Weekday,
|
||||
Weeknum,
|
||||
Workday,
|
||||
WorkdayIntl,
|
||||
Yearfrac,
|
||||
Isoweeknum,
|
||||
|
||||
// Financial
|
||||
Accrint,
|
||||
Accrintm,
|
||||
Coupdaybs,
|
||||
Coupdays,
|
||||
Coupdaysnc,
|
||||
Coupncd,
|
||||
Coupnum,
|
||||
Couppcd,
|
||||
Cumipmt,
|
||||
Cumprinc,
|
||||
Db,
|
||||
@@ -233,7 +160,6 @@ pub enum Function {
|
||||
Dollarfr,
|
||||
Effect,
|
||||
Fv,
|
||||
Fvschedule,
|
||||
Ipmt,
|
||||
Irr,
|
||||
Ispmt,
|
||||
@@ -241,12 +167,9 @@ pub enum Function {
|
||||
Nominal,
|
||||
Nper,
|
||||
Npv,
|
||||
Duration,
|
||||
Mduration,
|
||||
Pduration,
|
||||
Pmt,
|
||||
Ppmt,
|
||||
Price,
|
||||
Pv,
|
||||
Rate,
|
||||
Rri,
|
||||
@@ -255,16 +178,8 @@ pub enum Function {
|
||||
Tbilleq,
|
||||
Tbillprice,
|
||||
Tbillyield,
|
||||
Pricedisc,
|
||||
Pricemat,
|
||||
Yielddisc,
|
||||
Yieldmat,
|
||||
Disc,
|
||||
Received,
|
||||
Intrate,
|
||||
Xirr,
|
||||
Xnpv,
|
||||
Yield,
|
||||
|
||||
// Engineering: Bessel and transcendental functions
|
||||
Besseli,
|
||||
@@ -333,7 +248,7 @@ pub enum Function {
|
||||
}
|
||||
|
||||
impl Function {
|
||||
pub fn into_iter() -> IntoIter<Function, 276> {
|
||||
pub fn into_iter() -> IntoIter<Function, 194> {
|
||||
[
|
||||
Function::And,
|
||||
Function::False,
|
||||
@@ -360,50 +275,15 @@ impl Function {
|
||||
Function::Atanh,
|
||||
Function::Abs,
|
||||
Function::Pi,
|
||||
Function::Ln,
|
||||
Function::Log,
|
||||
Function::Log10,
|
||||
Function::Sqrt,
|
||||
Function::Sqrtpi,
|
||||
Function::Atan2,
|
||||
Function::Acot,
|
||||
Function::Acoth,
|
||||
Function::Cot,
|
||||
Function::Coth,
|
||||
Function::Csc,
|
||||
Function::Csch,
|
||||
Function::Sec,
|
||||
Function::Sech,
|
||||
Function::Power,
|
||||
Function::Exp,
|
||||
Function::Fact,
|
||||
Function::Factdouble,
|
||||
Function::Sign,
|
||||
Function::Int,
|
||||
Function::Even,
|
||||
Function::Odd,
|
||||
Function::Ceiling,
|
||||
Function::CeilingMath,
|
||||
Function::CeilingPrecise,
|
||||
Function::Floor,
|
||||
Function::FloorMath,
|
||||
Function::FloorPrecise,
|
||||
Function::IsoCeiling,
|
||||
Function::Mod,
|
||||
Function::Quotient,
|
||||
Function::Mround,
|
||||
Function::Trunc,
|
||||
Function::Gcd,
|
||||
Function::Lcm,
|
||||
Function::Base,
|
||||
Function::Decimal,
|
||||
Function::Max,
|
||||
Function::Min,
|
||||
Function::Product,
|
||||
Function::Rand,
|
||||
Function::Randbetween,
|
||||
Function::Radians,
|
||||
Function::Degrees,
|
||||
Function::Round,
|
||||
Function::Rounddown,
|
||||
Function::Roundup,
|
||||
@@ -468,49 +348,26 @@ impl Function {
|
||||
Function::Countifs,
|
||||
Function::Maxifs,
|
||||
Function::Minifs,
|
||||
Function::Geomean,
|
||||
Function::Year,
|
||||
Function::Day,
|
||||
Function::Month,
|
||||
Function::Eomonth,
|
||||
Function::Date,
|
||||
Function::Datedif,
|
||||
Function::Datevalue,
|
||||
Function::Edate,
|
||||
Function::Networkdays,
|
||||
Function::NetworkdaysIntl,
|
||||
Function::Time,
|
||||
Function::Timevalue,
|
||||
Function::Hour,
|
||||
Function::Minute,
|
||||
Function::Second,
|
||||
Function::Today,
|
||||
Function::Now,
|
||||
Function::Days,
|
||||
Function::Days360,
|
||||
Function::Weekday,
|
||||
Function::Weeknum,
|
||||
Function::Workday,
|
||||
Function::WorkdayIntl,
|
||||
Function::Yearfrac,
|
||||
Function::Isoweeknum,
|
||||
Function::Accrint,
|
||||
Function::Accrintm,
|
||||
Function::Pmt,
|
||||
Function::Pv,
|
||||
Function::Rate,
|
||||
Function::Nper,
|
||||
Function::Fv,
|
||||
Function::Fvschedule,
|
||||
Function::Ppmt,
|
||||
Function::Price,
|
||||
Function::Ipmt,
|
||||
Function::Npv,
|
||||
Function::Mirr,
|
||||
Function::Irr,
|
||||
Function::Xirr,
|
||||
Function::Xnpv,
|
||||
Function::Yield,
|
||||
Function::Rept,
|
||||
Function::Textafter,
|
||||
Function::Textbefore,
|
||||
@@ -522,25 +379,10 @@ impl Function {
|
||||
Function::Syd,
|
||||
Function::Nominal,
|
||||
Function::Effect,
|
||||
Function::Duration,
|
||||
Function::Mduration,
|
||||
Function::Pduration,
|
||||
Function::Coupdaybs,
|
||||
Function::Coupdays,
|
||||
Function::Coupdaysnc,
|
||||
Function::Coupncd,
|
||||
Function::Coupnum,
|
||||
Function::Couppcd,
|
||||
Function::Tbillyield,
|
||||
Function::Tbillprice,
|
||||
Function::Tbilleq,
|
||||
Function::Pricedisc,
|
||||
Function::Pricemat,
|
||||
Function::Yielddisc,
|
||||
Function::Yieldmat,
|
||||
Function::Disc,
|
||||
Function::Received,
|
||||
Function::Intrate,
|
||||
Function::Dollarde,
|
||||
Function::Dollarfr,
|
||||
Function::Ddb,
|
||||
@@ -602,15 +444,6 @@ impl Function {
|
||||
Function::Delta,
|
||||
Function::Gestep,
|
||||
Function::Subtotal,
|
||||
Function::Roman,
|
||||
Function::Arabic,
|
||||
Function::Combin,
|
||||
Function::Combina,
|
||||
Function::Sumsq,
|
||||
Function::N,
|
||||
Function::Cell,
|
||||
Function::Info,
|
||||
Function::Sheets,
|
||||
]
|
||||
.into_iter()
|
||||
}
|
||||
@@ -652,19 +485,6 @@ impl Function {
|
||||
Function::Isformula => "_xlfn.ISFORMULA".to_string(),
|
||||
Function::Sheet => "_xlfn.SHEET".to_string(),
|
||||
Function::Formulatext => "_xlfn.FORMULATEXT".to_string(),
|
||||
Function::Isoweeknum => "_xlfn.ISOWEEKNUM".to_string(),
|
||||
Function::Ceiling => "_xlfn.CEILING".to_string(),
|
||||
Function::CeilingMath => "_xlfn.CEILING.MATH".to_string(),
|
||||
Function::CeilingPrecise => "_xlfn.CEILING.PRECISE".to_string(),
|
||||
Function::FloorMath => "_xlfn.FLOOR.MATH".to_string(),
|
||||
Function::FloorPrecise => "_xlfn.FLOOR.PRECISE".to_string(),
|
||||
Function::IsoCeiling => "_xlfn.ISO.CEILING".to_string(),
|
||||
Function::Base => "_xlfn.BASE".to_string(),
|
||||
Function::Decimal => "_xlfn.DECIMAL".to_string(),
|
||||
Function::Arabic => "_xlfn.ARABIC".to_string(),
|
||||
Function::Combina => "_xlfn.COMBINA".to_string(),
|
||||
Function::Sheets => "_xlfn.SHEETS".to_string(),
|
||||
|
||||
_ => self.to_string(),
|
||||
}
|
||||
}
|
||||
@@ -687,61 +507,30 @@ impl Function {
|
||||
"SWITCH" | "_XLFN.SWITCH" => Some(Function::Switch),
|
||||
"TRUE" => Some(Function::True),
|
||||
"XOR" | "_XLFN.XOR" => Some(Function::Xor),
|
||||
|
||||
"SIN" => Some(Function::Sin),
|
||||
"COS" => Some(Function::Cos),
|
||||
"TAN" => Some(Function::Tan),
|
||||
|
||||
"ASIN" => Some(Function::Asin),
|
||||
"ACOS" => Some(Function::Acos),
|
||||
"ATAN" => Some(Function::Atan),
|
||||
|
||||
"SINH" => Some(Function::Sinh),
|
||||
"COSH" => Some(Function::Cosh),
|
||||
"TANH" => Some(Function::Tanh),
|
||||
|
||||
"ASINH" => Some(Function::Asinh),
|
||||
"ACOSH" => Some(Function::Acosh),
|
||||
"ATANH" => Some(Function::Atanh),
|
||||
"ACOT" => Some(Function::Acot),
|
||||
"COTH" => Some(Function::Coth),
|
||||
"COT" => Some(Function::Cot),
|
||||
"CSC" => Some(Function::Csc),
|
||||
"CSCH" => Some(Function::Csch),
|
||||
"SEC" => Some(Function::Sec),
|
||||
"SECH" => Some(Function::Sech),
|
||||
"ACOTH" => Some(Function::Acoth),
|
||||
"FACT" => Some(Function::Fact),
|
||||
"FACTDOUBLE" => Some(Function::Factdouble),
|
||||
"EXP" => Some(Function::Exp),
|
||||
"SIGN" => Some(Function::Sign),
|
||||
"RADIANS" => Some(Function::Radians),
|
||||
"DEGREES" => Some(Function::Degrees),
|
||||
"INT" => Some(Function::Int),
|
||||
"EVEN" => Some(Function::Even),
|
||||
"ODD" => Some(Function::Odd),
|
||||
"CEILING" | "_XLFN.CEILING" => Some(Function::Ceiling),
|
||||
"CEILING.MATH" | "_XLFN.CEILING.MATH" => Some(Function::CeilingMath),
|
||||
"CEILING.PRECISE" | "_XLFN.CEILING.PRECISE" => Some(Function::CeilingPrecise),
|
||||
"FLOOR" => Some(Function::Floor),
|
||||
"FLOOR.MATH" | "_XLFN.FLOOR.MATH" => Some(Function::FloorMath),
|
||||
"FLOOR.PRECISE" | "_XLFN.FLOOR.PRECISE" => Some(Function::FloorPrecise),
|
||||
"ISO.CEILING" | "_XLFN.ISO.CEILING" => Some(Function::IsoCeiling),
|
||||
"MOD" => Some(Function::Mod),
|
||||
"QUOTIENT" => Some(Function::Quotient),
|
||||
"MROUND" => Some(Function::Mround),
|
||||
"TRUNC" => Some(Function::Trunc),
|
||||
"GCD" => Some(Function::Gcd),
|
||||
"LCM" => Some(Function::Lcm),
|
||||
"BASE" | "_XLFN.BASE" => Some(Function::Base),
|
||||
"DECIMAL" | "_XLFN.DECIMAL" => Some(Function::Decimal),
|
||||
"ROMAN" => Some(Function::Roman),
|
||||
"ARABIC" | "_XLFN.ARABIC" => Some(Function::Arabic),
|
||||
|
||||
"PI" => Some(Function::Pi),
|
||||
"ABS" => Some(Function::Abs),
|
||||
"SQRT" => Some(Function::Sqrt),
|
||||
"SQRTPI" => Some(Function::Sqrtpi),
|
||||
"POWER" => Some(Function::Power),
|
||||
"ATAN2" => Some(Function::Atan2),
|
||||
"LN" => Some(Function::Ln),
|
||||
"LOG" => Some(Function::Log),
|
||||
"LOG10" => Some(Function::Log10),
|
||||
|
||||
"MAX" => Some(Function::Max),
|
||||
"MIN" => Some(Function::Min),
|
||||
"PRODUCT" => Some(Function::Product),
|
||||
@@ -753,9 +542,6 @@ impl Function {
|
||||
"SUM" => Some(Function::Sum),
|
||||
"SUMIF" => Some(Function::Sumif),
|
||||
"SUMIFS" => Some(Function::Sumifs),
|
||||
"COMBIN" => Some(Function::Combin),
|
||||
"COMBINA" | "_XLFN.COMBINA" => Some(Function::Combina),
|
||||
"SUMSQ" => Some(Function::Sumsq),
|
||||
|
||||
// Lookup and Reference
|
||||
"CHOOSE" => Some(Function::Choose),
|
||||
@@ -825,48 +611,25 @@ impl Function {
|
||||
"COUNTIFS" => Some(Function::Countifs),
|
||||
"MAXIFS" | "_XLFN.MAXIFS" => Some(Function::Maxifs),
|
||||
"MINIFS" | "_XLFN.MINIFS" => Some(Function::Minifs),
|
||||
"GEOMEAN" => Some(Function::Geomean),
|
||||
// Date and Time
|
||||
"YEAR" => Some(Function::Year),
|
||||
"DAY" => Some(Function::Day),
|
||||
"EOMONTH" => Some(Function::Eomonth),
|
||||
"MONTH" => Some(Function::Month),
|
||||
"DATE" => Some(Function::Date),
|
||||
"DATEDIF" => Some(Function::Datedif),
|
||||
"DATEVALUE" => Some(Function::Datevalue),
|
||||
"EDATE" => Some(Function::Edate),
|
||||
"NETWORKDAYS" => Some(Function::Networkdays),
|
||||
"NETWORKDAYS.INTL" => Some(Function::NetworkdaysIntl),
|
||||
"TIME" => Some(Function::Time),
|
||||
"TIMEVALUE" => Some(Function::Timevalue),
|
||||
"HOUR" => Some(Function::Hour),
|
||||
"MINUTE" => Some(Function::Minute),
|
||||
"SECOND" => Some(Function::Second),
|
||||
"TODAY" => Some(Function::Today),
|
||||
"NOW" => Some(Function::Now),
|
||||
"DAYS" | "_XLFN.DAYS" => Some(Function::Days),
|
||||
"DAYS360" => Some(Function::Days360),
|
||||
"WEEKDAY" => Some(Function::Weekday),
|
||||
"WEEKNUM" => Some(Function::Weeknum),
|
||||
"WORKDAY" => Some(Function::Workday),
|
||||
"WORKDAY.INTL" => Some(Function::WorkdayIntl),
|
||||
"YEARFRAC" => Some(Function::Yearfrac),
|
||||
"ISOWEEKNUM" | "_XLFN.ISOWEEKNUM" => Some(Function::Isoweeknum),
|
||||
// Financial
|
||||
"ACCRINT" => Some(Function::Accrint),
|
||||
"ACCRINTM" => Some(Function::Accrintm),
|
||||
"PMT" => Some(Function::Pmt),
|
||||
"PV" => Some(Function::Pv),
|
||||
"RATE" => Some(Function::Rate),
|
||||
"NPER" => Some(Function::Nper),
|
||||
"FV" => Some(Function::Fv),
|
||||
"FVSCHEDULE" => Some(Function::Fvschedule),
|
||||
"PPMT" => Some(Function::Ppmt),
|
||||
"PRICE" => Some(Function::Price),
|
||||
"IPMT" => Some(Function::Ipmt),
|
||||
"NPV" => Some(Function::Npv),
|
||||
"XNPV" => Some(Function::Xnpv),
|
||||
"YIELD" => Some(Function::Yield),
|
||||
"MIRR" => Some(Function::Mirr),
|
||||
"IRR" => Some(Function::Irr),
|
||||
"XIRR" => Some(Function::Xirr),
|
||||
@@ -877,27 +640,11 @@ impl Function {
|
||||
"SYD" => Some(Function::Syd),
|
||||
"NOMINAL" => Some(Function::Nominal),
|
||||
"EFFECT" => Some(Function::Effect),
|
||||
"DURATION" => Some(Function::Duration),
|
||||
"MDURATION" => Some(Function::Mduration),
|
||||
"PDURATION" | "_XLFN.PDURATION" => Some(Function::Pduration),
|
||||
|
||||
"COUPDAYBS" => Some(Function::Coupdaybs),
|
||||
"COUPDAYS" => Some(Function::Coupdays),
|
||||
"COUPDAYSNC" => Some(Function::Coupdaysnc),
|
||||
"COUPNCD" => Some(Function::Coupncd),
|
||||
"COUPNUM" => Some(Function::Coupnum),
|
||||
"COUPPCD" => Some(Function::Couppcd),
|
||||
|
||||
"TBILLYIELD" => Some(Function::Tbillyield),
|
||||
"TBILLPRICE" => Some(Function::Tbillprice),
|
||||
"TBILLEQ" => Some(Function::Tbilleq),
|
||||
"PRICEDISC" => Some(Function::Pricedisc),
|
||||
"PRICEMAT" => Some(Function::Pricemat),
|
||||
"YIELDDISC" => Some(Function::Yielddisc),
|
||||
"YIELDMAT" => Some(Function::Yieldmat),
|
||||
"DISC" => Some(Function::Disc),
|
||||
"RECEIVED" => Some(Function::Received),
|
||||
"INTRATE" => Some(Function::Intrate),
|
||||
|
||||
"DOLLARDE" => Some(Function::Dollarde),
|
||||
"DOLLARFR" => Some(Function::Dollarfr),
|
||||
@@ -964,12 +711,6 @@ impl Function {
|
||||
"GESTEP" => Some(Function::Gestep),
|
||||
|
||||
"SUBTOTAL" => Some(Function::Subtotal),
|
||||
|
||||
"N" => Some(Function::N),
|
||||
"CELL" => Some(Function::Cell),
|
||||
"INFO" => Some(Function::Info),
|
||||
"SHEETS" | "_XLFN.SHEETS" => Some(Function::Sheets),
|
||||
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
@@ -989,9 +730,6 @@ impl fmt::Display for Function {
|
||||
Function::Switch => write!(f, "SWITCH"),
|
||||
Function::True => write!(f, "TRUE"),
|
||||
Function::Xor => write!(f, "XOR"),
|
||||
Function::Log => write!(f, "LOG"),
|
||||
Function::Log10 => write!(f, "LOG10"),
|
||||
Function::Ln => write!(f, "LN"),
|
||||
Function::Sin => write!(f, "SIN"),
|
||||
Function::Cos => write!(f, "COS"),
|
||||
Function::Tan => write!(f, "TAN"),
|
||||
@@ -1004,14 +742,6 @@ impl fmt::Display for Function {
|
||||
Function::Asinh => write!(f, "ASINH"),
|
||||
Function::Acosh => write!(f, "ACOSH"),
|
||||
Function::Atanh => write!(f, "ATANH"),
|
||||
Function::Acot => write!(f, "ACOT"),
|
||||
Function::Acoth => write!(f, "ACOTH"),
|
||||
Function::Cot => write!(f, "COT"),
|
||||
Function::Coth => write!(f, "COTH"),
|
||||
Function::Csc => write!(f, "CSC"),
|
||||
Function::Csch => write!(f, "CSCH"),
|
||||
Function::Sec => write!(f, "SEC"),
|
||||
Function::Sech => write!(f, "SECH"),
|
||||
Function::Abs => write!(f, "ABS"),
|
||||
Function::Pi => write!(f, "PI"),
|
||||
Function::Sqrt => write!(f, "SQRT"),
|
||||
@@ -1076,6 +806,7 @@ impl fmt::Display for Function {
|
||||
Function::Isformula => write!(f, "ISFORMULA"),
|
||||
Function::Type => write!(f, "TYPE"),
|
||||
Function::Sheet => write!(f, "SHEET"),
|
||||
|
||||
Function::Average => write!(f, "AVERAGE"),
|
||||
Function::Averagea => write!(f, "AVERAGEA"),
|
||||
Function::Averageif => write!(f, "AVERAGEIF"),
|
||||
@@ -1087,49 +818,26 @@ impl fmt::Display for Function {
|
||||
Function::Countifs => write!(f, "COUNTIFS"),
|
||||
Function::Maxifs => write!(f, "MAXIFS"),
|
||||
Function::Minifs => write!(f, "MINIFS"),
|
||||
Function::Geomean => write!(f, "GEOMEAN"),
|
||||
Function::Year => write!(f, "YEAR"),
|
||||
Function::Day => write!(f, "DAY"),
|
||||
Function::Month => write!(f, "MONTH"),
|
||||
Function::Eomonth => write!(f, "EOMONTH"),
|
||||
Function::Date => write!(f, "DATE"),
|
||||
Function::Datedif => write!(f, "DATEDIF"),
|
||||
Function::Datevalue => write!(f, "DATEVALUE"),
|
||||
Function::Edate => write!(f, "EDATE"),
|
||||
Function::Networkdays => write!(f, "NETWORKDAYS"),
|
||||
Function::NetworkdaysIntl => write!(f, "NETWORKDAYS.INTL"),
|
||||
Function::Time => write!(f, "TIME"),
|
||||
Function::Timevalue => write!(f, "TIMEVALUE"),
|
||||
Function::Hour => write!(f, "HOUR"),
|
||||
Function::Minute => write!(f, "MINUTE"),
|
||||
Function::Second => write!(f, "SECOND"),
|
||||
Function::Today => write!(f, "TODAY"),
|
||||
Function::Now => write!(f, "NOW"),
|
||||
Function::Days => write!(f, "DAYS"),
|
||||
Function::Days360 => write!(f, "DAYS360"),
|
||||
Function::Weekday => write!(f, "WEEKDAY"),
|
||||
Function::Weeknum => write!(f, "WEEKNUM"),
|
||||
Function::Workday => write!(f, "WORKDAY"),
|
||||
Function::WorkdayIntl => write!(f, "WORKDAY.INTL"),
|
||||
Function::Yearfrac => write!(f, "YEARFRAC"),
|
||||
Function::Isoweeknum => write!(f, "ISOWEEKNUM"),
|
||||
Function::Accrint => write!(f, "ACCRINT"),
|
||||
Function::Accrintm => write!(f, "ACCRINTM"),
|
||||
Function::Pmt => write!(f, "PMT"),
|
||||
Function::Pv => write!(f, "PV"),
|
||||
Function::Rate => write!(f, "RATE"),
|
||||
Function::Nper => write!(f, "NPER"),
|
||||
Function::Fv => write!(f, "FV"),
|
||||
Function::Fvschedule => write!(f, "FVSCHEDULE"),
|
||||
Function::Ppmt => write!(f, "PPMT"),
|
||||
Function::Price => write!(f, "PRICE"),
|
||||
Function::Ipmt => write!(f, "IPMT"),
|
||||
Function::Npv => write!(f, "NPV"),
|
||||
Function::Mirr => write!(f, "MIRR"),
|
||||
Function::Irr => write!(f, "IRR"),
|
||||
Function::Xirr => write!(f, "XIRR"),
|
||||
Function::Xnpv => write!(f, "XNPV"),
|
||||
Function::Yield => write!(f, "YIELD"),
|
||||
Function::Rept => write!(f, "REPT"),
|
||||
Function::Textafter => write!(f, "TEXTAFTER"),
|
||||
Function::Textbefore => write!(f, "TEXTBEFORE"),
|
||||
@@ -1141,25 +849,10 @@ impl fmt::Display for Function {
|
||||
Function::Syd => write!(f, "SYD"),
|
||||
Function::Nominal => write!(f, "NOMINAL"),
|
||||
Function::Effect => write!(f, "EFFECT"),
|
||||
Function::Duration => write!(f, "DURATION"),
|
||||
Function::Mduration => write!(f, "MDURATION"),
|
||||
Function::Pduration => write!(f, "PDURATION"),
|
||||
Function::Coupdaybs => write!(f, "COUPDAYBS"),
|
||||
Function::Coupdays => write!(f, "COUPDAYS"),
|
||||
Function::Coupdaysnc => write!(f, "COUPDAYSNC"),
|
||||
Function::Coupncd => write!(f, "COUPNCD"),
|
||||
Function::Coupnum => write!(f, "COUPNUM"),
|
||||
Function::Couppcd => write!(f, "COUPPCD"),
|
||||
Function::Tbillyield => write!(f, "TBILLYIELD"),
|
||||
Function::Tbillprice => write!(f, "TBILLPRICE"),
|
||||
Function::Tbilleq => write!(f, "TBILLEQ"),
|
||||
Function::Pricedisc => write!(f, "PRICEDISC"),
|
||||
Function::Pricemat => write!(f, "PRICEMAT"),
|
||||
Function::Yielddisc => write!(f, "YIELDDISC"),
|
||||
Function::Yieldmat => write!(f, "YIELDMAT"),
|
||||
Function::Disc => write!(f, "DISC"),
|
||||
Function::Received => write!(f, "RECEIVED"),
|
||||
Function::Intrate => write!(f, "INTRATE"),
|
||||
Function::Dollarde => write!(f, "DOLLARDE"),
|
||||
Function::Dollarfr => write!(f, "DOLLARFR"),
|
||||
Function::Ddb => write!(f, "DDB"),
|
||||
@@ -1220,41 +913,8 @@ impl fmt::Display for Function {
|
||||
Function::Convert => write!(f, "CONVERT"),
|
||||
Function::Delta => write!(f, "DELTA"),
|
||||
Function::Gestep => write!(f, "GESTEP"),
|
||||
Function::Subtotal => write!(f, "SUBTOTAL"),
|
||||
Function::Exp => write!(f, "EXP"),
|
||||
Function::Fact => write!(f, "FACT"),
|
||||
Function::Factdouble => write!(f, "FACTDOUBLE"),
|
||||
Function::Sign => write!(f, "SIGN"),
|
||||
Function::Radians => write!(f, "RADIANS"),
|
||||
Function::Degrees => write!(f, "DEGREES"),
|
||||
Function::Int => write!(f, "INT"),
|
||||
Function::Even => write!(f, "EVEN"),
|
||||
Function::Odd => write!(f, "ODD"),
|
||||
Function::Ceiling => write!(f, "CEILING"),
|
||||
Function::CeilingMath => write!(f, "CEILING.MATH"),
|
||||
Function::CeilingPrecise => write!(f, "CEILING.PRECISE"),
|
||||
Function::Floor => write!(f, "FLOOR"),
|
||||
Function::FloorMath => write!(f, "FLOOR.MATH"),
|
||||
Function::FloorPrecise => write!(f, "FLOOR.PRECISE"),
|
||||
Function::IsoCeiling => write!(f, "ISO.CEILING"),
|
||||
Function::Mod => write!(f, "MOD"),
|
||||
Function::Quotient => write!(f, "QUOTIENT"),
|
||||
Function::Mround => write!(f, "MROUND"),
|
||||
Function::Trunc => write!(f, "TRUNC"),
|
||||
Function::Gcd => write!(f, "GCD"),
|
||||
Function::Lcm => write!(f, "LCM"),
|
||||
Function::Base => write!(f, "BASE"),
|
||||
Function::Decimal => write!(f, "DECIMAL"),
|
||||
Function::Roman => write!(f, "ROMAN"),
|
||||
Function::Arabic => write!(f, "ARABIC"),
|
||||
Function::Combin => write!(f, "COMBIN"),
|
||||
Function::Combina => write!(f, "COMBINA"),
|
||||
Function::Sumsq => write!(f, "SUMSQ"),
|
||||
|
||||
Function::N => write!(f, "N"),
|
||||
Function::Cell => write!(f, "CELL"),
|
||||
Function::Info => write!(f, "INFO"),
|
||||
Function::Sheets => write!(f, "SHEETS"),
|
||||
Function::Subtotal => write!(f, "SUBTOTAL"),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1283,8 +943,9 @@ impl Model {
|
||||
cell: CellReferenceIndex,
|
||||
) -> CalcResult {
|
||||
match kind {
|
||||
// Logical
|
||||
Function::And => self.fn_and(args, cell),
|
||||
Function::False => self.fn_false(args, cell),
|
||||
Function::False => CalcResult::Boolean(false),
|
||||
Function::If => self.fn_if(args, cell),
|
||||
Function::Iferror => self.fn_iferror(args, cell),
|
||||
Function::Ifna => self.fn_ifna(args, cell),
|
||||
@@ -1292,29 +953,33 @@ impl Model {
|
||||
Function::Not => self.fn_not(args, cell),
|
||||
Function::Or => self.fn_or(args, cell),
|
||||
Function::Switch => self.fn_switch(args, cell),
|
||||
Function::True => self.fn_true(args, cell),
|
||||
Function::True => CalcResult::Boolean(true),
|
||||
Function::Xor => self.fn_xor(args, cell),
|
||||
Function::Log => self.fn_log(args, cell),
|
||||
Function::Log10 => self.fn_log10(args, cell),
|
||||
Function::Ln => self.fn_ln(args, cell),
|
||||
// Math and trigonometry
|
||||
Function::Sin => self.fn_sin(args, cell),
|
||||
Function::Cos => self.fn_cos(args, cell),
|
||||
Function::Tan => self.fn_tan(args, cell),
|
||||
|
||||
Function::Asin => self.fn_asin(args, cell),
|
||||
Function::Acos => self.fn_acos(args, cell),
|
||||
Function::Atan => self.fn_atan(args, cell),
|
||||
|
||||
Function::Sinh => self.fn_sinh(args, cell),
|
||||
Function::Cosh => self.fn_cosh(args, cell),
|
||||
Function::Tanh => self.fn_tanh(args, cell),
|
||||
|
||||
Function::Asinh => self.fn_asinh(args, cell),
|
||||
Function::Acosh => self.fn_acosh(args, cell),
|
||||
Function::Atanh => self.fn_atanh(args, cell),
|
||||
|
||||
Function::Pi => self.fn_pi(args, cell),
|
||||
Function::Abs => self.fn_abs(args, cell),
|
||||
|
||||
Function::Sqrt => self.fn_sqrt(args, cell),
|
||||
Function::Sqrtpi => self.fn_sqrtpi(args, cell),
|
||||
Function::Atan2 => self.fn_atan2(args, cell),
|
||||
Function::Power => self.fn_power(args, cell),
|
||||
|
||||
Function::Max => self.fn_max(args, cell),
|
||||
Function::Min => self.fn_min(args, cell),
|
||||
Function::Product => self.fn_product(args, cell),
|
||||
@@ -1326,6 +991,8 @@ impl Model {
|
||||
Function::Sum => self.fn_sum(args, cell),
|
||||
Function::Sumif => self.fn_sumif(args, cell),
|
||||
Function::Sumifs => self.fn_sumifs(args, cell),
|
||||
|
||||
// Lookup and Reference
|
||||
Function::Choose => self.fn_choose(args, cell),
|
||||
Function::Column => self.fn_column(args, cell),
|
||||
Function::Columns => self.fn_columns(args, cell),
|
||||
@@ -1339,6 +1006,7 @@ impl Model {
|
||||
Function::Rows => self.fn_rows(args, cell),
|
||||
Function::Vlookup => self.fn_vlookup(args, cell),
|
||||
Function::Xlookup => self.fn_xlookup(args, cell),
|
||||
// Text
|
||||
Function::Concatenate => self.fn_concatenate(args, cell),
|
||||
Function::Exact => self.fn_exact(args, cell),
|
||||
Function::Value => self.fn_value(args, cell),
|
||||
@@ -1356,6 +1024,7 @@ impl Model {
|
||||
Function::Trim => self.fn_trim(args, cell),
|
||||
Function::Unicode => self.fn_unicode(args, cell),
|
||||
Function::Upper => self.fn_upper(args, cell),
|
||||
// Information
|
||||
Function::Isnumber => self.fn_isnumber(args, cell),
|
||||
Function::Isnontext => self.fn_isnontext(args, cell),
|
||||
Function::Istext => self.fn_istext(args, cell),
|
||||
@@ -1373,6 +1042,7 @@ impl Model {
|
||||
Function::Isformula => self.fn_isformula(args, cell),
|
||||
Function::Type => self.fn_type(args, cell),
|
||||
Function::Sheet => self.fn_sheet(args, cell),
|
||||
// Statistical
|
||||
Function::Average => self.fn_average(args, cell),
|
||||
Function::Averagea => self.fn_averagea(args, cell),
|
||||
Function::Averageif => self.fn_averageif(args, cell),
|
||||
@@ -1384,50 +1054,28 @@ impl Model {
|
||||
Function::Countifs => self.fn_countifs(args, cell),
|
||||
Function::Maxifs => self.fn_maxifs(args, cell),
|
||||
Function::Minifs => self.fn_minifs(args, cell),
|
||||
Function::Geomean => self.fn_geomean(args, cell),
|
||||
// Date and Time
|
||||
Function::Year => self.fn_year(args, cell),
|
||||
Function::Day => self.fn_day(args, cell),
|
||||
Function::Eomonth => self.fn_eomonth(args, cell),
|
||||
Function::Month => self.fn_month(args, cell),
|
||||
Function::Date => self.fn_date(args, cell),
|
||||
Function::Datedif => self.fn_datedif(args, cell),
|
||||
Function::Datevalue => self.fn_datevalue(args, cell),
|
||||
Function::Edate => self.fn_edate(args, cell),
|
||||
Function::Networkdays => self.fn_networkdays(args, cell),
|
||||
Function::NetworkdaysIntl => self.fn_networkdays_intl(args, cell),
|
||||
Function::Time => self.fn_time(args, cell),
|
||||
Function::Timevalue => self.fn_timevalue(args, cell),
|
||||
Function::Hour => self.fn_hour(args, cell),
|
||||
Function::Minute => self.fn_minute(args, cell),
|
||||
Function::Second => self.fn_second(args, cell),
|
||||
Function::Today => self.fn_today(args, cell),
|
||||
Function::Now => self.fn_now(args, cell),
|
||||
Function::Days => self.fn_days(args, cell),
|
||||
Function::Days360 => self.fn_days360(args, cell),
|
||||
Function::Weekday => self.fn_weekday(args, cell),
|
||||
Function::Weeknum => self.fn_weeknum(args, cell),
|
||||
Function::Workday => self.fn_workday(args, cell),
|
||||
Function::WorkdayIntl => self.fn_workday_intl(args, cell),
|
||||
Function::Yearfrac => self.fn_yearfrac(args, cell),
|
||||
Function::Isoweeknum => self.fn_isoweeknum(args, cell),
|
||||
// Financial
|
||||
Function::Accrint => self.fn_accrint(args, cell),
|
||||
Function::Accrintm => self.fn_accrintm(args, cell),
|
||||
Function::Pmt => self.fn_pmt(args, cell),
|
||||
Function::Pv => self.fn_pv(args, cell),
|
||||
Function::Rate => self.fn_rate(args, cell),
|
||||
Function::Nper => self.fn_nper(args, cell),
|
||||
Function::Fv => self.fn_fv(args, cell),
|
||||
Function::Fvschedule => self.fn_fvschedule(args, cell),
|
||||
Function::Ppmt => self.fn_ppmt(args, cell),
|
||||
Function::Price => self.fn_price(args, cell),
|
||||
Function::Ipmt => self.fn_ipmt(args, cell),
|
||||
Function::Npv => self.fn_npv(args, cell),
|
||||
Function::Mirr => self.fn_mirr(args, cell),
|
||||
Function::Irr => self.fn_irr(args, cell),
|
||||
Function::Xirr => self.fn_xirr(args, cell),
|
||||
Function::Xnpv => self.fn_xnpv(args, cell),
|
||||
Function::Yield => self.fn_yield(args, cell),
|
||||
Function::Rept => self.fn_rept(args, cell),
|
||||
Function::Textafter => self.fn_textafter(args, cell),
|
||||
Function::Textbefore => self.fn_textbefore(args, cell),
|
||||
@@ -1439,31 +1087,17 @@ impl Model {
|
||||
Function::Syd => self.fn_syd(args, cell),
|
||||
Function::Nominal => self.fn_nominal(args, cell),
|
||||
Function::Effect => self.fn_effect(args, cell),
|
||||
Function::Duration => self.fn_duration(args, cell),
|
||||
Function::Mduration => self.fn_mduration(args, cell),
|
||||
Function::Pduration => self.fn_pduration(args, cell),
|
||||
Function::Coupdaybs => self.fn_coupdaybs(args, cell),
|
||||
Function::Coupdays => self.fn_coupdays(args, cell),
|
||||
Function::Coupdaysnc => self.fn_coupdaysnc(args, cell),
|
||||
Function::Coupncd => self.fn_coupncd(args, cell),
|
||||
Function::Coupnum => self.fn_coupnum(args, cell),
|
||||
Function::Couppcd => self.fn_couppcd(args, cell),
|
||||
Function::Tbillyield => self.fn_tbillyield(args, cell),
|
||||
Function::Tbillprice => self.fn_tbillprice(args, cell),
|
||||
Function::Tbilleq => self.fn_tbilleq(args, cell),
|
||||
Function::Pricedisc => self.fn_pricedisc(args, cell),
|
||||
Function::Pricemat => self.fn_pricemat(args, cell),
|
||||
Function::Yielddisc => self.fn_yielddisc(args, cell),
|
||||
Function::Yieldmat => self.fn_yieldmat(args, cell),
|
||||
Function::Disc => self.fn_disc(args, cell),
|
||||
Function::Received => self.fn_received(args, cell),
|
||||
Function::Intrate => self.fn_intrate(args, cell),
|
||||
Function::Dollarde => self.fn_dollarde(args, cell),
|
||||
Function::Dollarfr => self.fn_dollarfr(args, cell),
|
||||
Function::Ddb => self.fn_ddb(args, cell),
|
||||
Function::Db => self.fn_db(args, cell),
|
||||
Function::Cumprinc => self.fn_cumprinc(args, cell),
|
||||
Function::Cumipmt => self.fn_cumipmt(args, cell),
|
||||
// Engineering
|
||||
Function::Besseli => self.fn_besseli(args, cell),
|
||||
Function::Besselj => self.fn_besselj(args, cell),
|
||||
Function::Besselk => self.fn_besselk(args, cell),
|
||||
@@ -1518,48 +1152,8 @@ impl Model {
|
||||
Function::Convert => self.fn_convert(args, cell),
|
||||
Function::Delta => self.fn_delta(args, cell),
|
||||
Function::Gestep => self.fn_gestep(args, cell),
|
||||
|
||||
Function::Subtotal => self.fn_subtotal(args, cell),
|
||||
Function::Acot => self.fn_acot(args, cell),
|
||||
Function::Acoth => self.fn_acoth(args, cell),
|
||||
Function::Cot => self.fn_cot(args, cell),
|
||||
Function::Coth => self.fn_coth(args, cell),
|
||||
Function::Csc => self.fn_csc(args, cell),
|
||||
Function::Csch => self.fn_csch(args, cell),
|
||||
Function::Sec => self.fn_sec(args, cell),
|
||||
Function::Sech => self.fn_sech(args, cell),
|
||||
Function::Exp => self.fn_exp(args, cell),
|
||||
Function::Fact => self.fn_fact(args, cell),
|
||||
Function::Factdouble => self.fn_factdouble(args, cell),
|
||||
Function::Sign => self.fn_sign(args, cell),
|
||||
Function::Radians => self.fn_radians(args, cell),
|
||||
Function::Degrees => self.fn_degrees(args, cell),
|
||||
Function::Int => self.fn_int(args, cell),
|
||||
Function::Even => self.fn_even(args, cell),
|
||||
Function::Odd => self.fn_odd(args, cell),
|
||||
Function::Ceiling => self.fn_ceiling(args, cell),
|
||||
Function::CeilingMath => self.fn_ceiling_math(args, cell),
|
||||
Function::CeilingPrecise => self.fn_ceiling_precise(args, cell),
|
||||
Function::Floor => self.fn_floor(args, cell),
|
||||
Function::FloorMath => self.fn_floor_math(args, cell),
|
||||
Function::FloorPrecise => self.fn_floor_precise(args, cell),
|
||||
Function::IsoCeiling => self.fn_iso_ceiling(args, cell),
|
||||
Function::Mod => self.fn_mod(args, cell),
|
||||
Function::Quotient => self.fn_quotient(args, cell),
|
||||
Function::Mround => self.fn_mround(args, cell),
|
||||
Function::Trunc => self.fn_trunc(args, cell),
|
||||
Function::Gcd => self.fn_gcd(args, cell),
|
||||
Function::Lcm => self.fn_lcm(args, cell),
|
||||
Function::Base => self.fn_base(args, cell),
|
||||
Function::Decimal => self.fn_decimal(args, cell),
|
||||
Function::Roman => self.fn_roman(args, cell),
|
||||
Function::Arabic => self.fn_arabic(args, cell),
|
||||
Function::Combin => self.fn_combin(args, cell),
|
||||
Function::Combina => self.fn_combina(args, cell),
|
||||
Function::Sumsq => self.fn_sumsq(args, cell),
|
||||
Function::N => self.fn_n(args, cell),
|
||||
Function::Cell => self.fn_cell(args, cell),
|
||||
Function::Info => self.fn_info(args, cell),
|
||||
Function::Sheets => self.fn_sheets(args, cell),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1614,7 +1208,7 @@ mod tests {
|
||||
}
|
||||
// We make a list with their functions names, but we escape ".": ERROR.TYPE => ERRORTYPE
|
||||
let iter_list = Function::into_iter()
|
||||
.map(|f| format!("{f}").replace('.', ""))
|
||||
.map(|f| format!("{}", f).replace('.', ""))
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
let len = iter_list.len();
|
||||
|
||||
@@ -134,13 +134,6 @@ impl Model {
|
||||
);
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => {}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -172,13 +165,6 @@ impl Model {
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => {}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
if count == 0.0 {
|
||||
@@ -350,7 +336,7 @@ impl Model {
|
||||
// FIXME: This function shares a lot of code with apply_ifs. Can we merge them?
|
||||
pub(crate) fn fn_countifs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
let args_count = args.len();
|
||||
if args_count < 2 || !args_count.is_multiple_of(2) {
|
||||
if args_count < 2 || args_count % 2 == 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
|
||||
@@ -476,7 +462,7 @@ impl Model {
|
||||
F: FnMut(f64),
|
||||
{
|
||||
let args_count = args.len();
|
||||
if args_count < 3 || args_count.is_multiple_of(2) {
|
||||
if args_count < 3 || args_count % 2 == 0 {
|
||||
return Err(CalcResult::new_args_number_error(cell));
|
||||
}
|
||||
let arg_0 = self.evaluate_node_in_context(&args[0], cell);
|
||||
@@ -649,85 +635,4 @@ impl Model {
|
||||
}
|
||||
CalcResult::Number(max)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_geomean(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.is_empty() {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let mut count = 0.0;
|
||||
let mut product = 1.0;
|
||||
for arg in args {
|
||||
match self.evaluate_node_in_context(arg, cell) {
|
||||
CalcResult::Number(value) => {
|
||||
count += 1.0;
|
||||
product *= value;
|
||||
}
|
||||
CalcResult::Boolean(b) => {
|
||||
if let Node::ReferenceKind { .. } = arg {
|
||||
} else {
|
||||
product *= if b { 1.0 } else { 0.0 };
|
||||
count += 1.0;
|
||||
}
|
||||
}
|
||||
CalcResult::Range { left, right } => {
|
||||
if left.sheet != right.sheet {
|
||||
return CalcResult::new_error(
|
||||
Error::VALUE,
|
||||
cell,
|
||||
"Ranges are in different sheets".to_string(),
|
||||
);
|
||||
}
|
||||
for row in left.row..(right.row + 1) {
|
||||
for column in left.column..(right.column + 1) {
|
||||
match self.evaluate_cell(CellReferenceIndex {
|
||||
sheet: left.sheet,
|
||||
row,
|
||||
column,
|
||||
}) {
|
||||
CalcResult::Number(value) => {
|
||||
count += 1.0;
|
||||
product *= value;
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::Range { .. } => {
|
||||
return CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
"Unexpected Range".to_string(),
|
||||
);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::String(s) => {
|
||||
if let Node::ReferenceKind { .. } = arg {
|
||||
// Do nothing
|
||||
} else if let Ok(t) = s.parse::<f64>() {
|
||||
product *= t;
|
||||
count += 1.0;
|
||||
} else {
|
||||
return CalcResult::Error {
|
||||
error: Error::VALUE,
|
||||
origin: cell,
|
||||
message: "Argument cannot be cast into number".to_string(),
|
||||
};
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
// Ignore everything else
|
||||
}
|
||||
};
|
||||
}
|
||||
if count == 0.0 {
|
||||
return CalcResult::Error {
|
||||
error: Error::DIV,
|
||||
origin: cell,
|
||||
message: "Division by Zero".to_string(),
|
||||
};
|
||||
}
|
||||
CalcResult::Number(product.powf(1.0 / count))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -182,13 +182,6 @@ impl Model {
|
||||
}
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => result.push(0.0),
|
||||
CalcResult::Array(_) => {
|
||||
return Err(CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -433,13 +426,6 @@ impl Model {
|
||||
| CalcResult::Number(_)
|
||||
| CalcResult::Boolean(_)
|
||||
| CalcResult::Error { .. } => counta += 1,
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -55,14 +55,14 @@ impl Model {
|
||||
let mut result = "".to_string();
|
||||
for arg in args {
|
||||
match self.evaluate_node_in_context(arg, cell) {
|
||||
CalcResult::String(value) => result = format!("{result}{value}"),
|
||||
CalcResult::Number(value) => result = format!("{result}{value}"),
|
||||
CalcResult::String(value) => result = format!("{}{}", result, value),
|
||||
CalcResult::Number(value) => result = format!("{}{}", result, value),
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => {}
|
||||
CalcResult::Boolean(value) => {
|
||||
if value {
|
||||
result = format!("{result}TRUE");
|
||||
result = format!("{}TRUE", result);
|
||||
} else {
|
||||
result = format!("{result}FALSE");
|
||||
result = format!("{}FALSE", result);
|
||||
}
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
@@ -82,37 +82,25 @@ impl Model {
|
||||
column,
|
||||
}) {
|
||||
CalcResult::String(value) => {
|
||||
result = format!("{result}{value}");
|
||||
result = format!("{}{}", result, value);
|
||||
}
|
||||
CalcResult::Number(value) => {
|
||||
result = format!("{}{}", result, value)
|
||||
}
|
||||
CalcResult::Number(value) => result = format!("{result}{value}"),
|
||||
CalcResult::Boolean(value) => {
|
||||
if value {
|
||||
result = format!("{result}TRUE");
|
||||
result = format!("{}TRUE", result);
|
||||
} else {
|
||||
result = format!("{result}FALSE");
|
||||
result = format!("{}FALSE", result);
|
||||
}
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => {}
|
||||
CalcResult::Range { .. } => {}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
CalcResult::String(result)
|
||||
@@ -137,13 +125,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => 0.0,
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
let format_code = match self.get_string(&args[1], cell) {
|
||||
Ok(s) => s,
|
||||
@@ -280,7 +261,7 @@ impl Model {
|
||||
pub(crate) fn fn_len(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() == 1 {
|
||||
let s = match self.evaluate_node_in_context(&args[0], cell) {
|
||||
CalcResult::Number(v) => format!("{v}"),
|
||||
CalcResult::Number(v) => format!("{}", v),
|
||||
CalcResult::String(v) => v,
|
||||
CalcResult::Boolean(b) => {
|
||||
if b {
|
||||
@@ -299,13 +280,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
return CalcResult::Number(s.chars().count() as f64);
|
||||
}
|
||||
@@ -315,7 +289,7 @@ impl Model {
|
||||
pub(crate) fn fn_trim(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() == 1 {
|
||||
let s = match self.evaluate_node_in_context(&args[0], cell) {
|
||||
CalcResult::Number(v) => format!("{v}"),
|
||||
CalcResult::Number(v) => format!("{}", v),
|
||||
CalcResult::String(v) => v,
|
||||
CalcResult::Boolean(b) => {
|
||||
if b {
|
||||
@@ -334,13 +308,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
return CalcResult::String(s.trim().to_owned());
|
||||
}
|
||||
@@ -350,7 +317,7 @@ impl Model {
|
||||
pub(crate) fn fn_lower(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() == 1 {
|
||||
let s = match self.evaluate_node_in_context(&args[0], cell) {
|
||||
CalcResult::Number(v) => format!("{v}"),
|
||||
CalcResult::Number(v) => format!("{}", v),
|
||||
CalcResult::String(v) => v,
|
||||
CalcResult::Boolean(b) => {
|
||||
if b {
|
||||
@@ -369,13 +336,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
return CalcResult::String(s.to_lowercase());
|
||||
}
|
||||
@@ -385,7 +345,7 @@ impl Model {
|
||||
pub(crate) fn fn_unicode(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() == 1 {
|
||||
let s = match self.evaluate_node_in_context(&args[0], cell) {
|
||||
CalcResult::Number(v) => format!("{v}"),
|
||||
CalcResult::Number(v) => format!("{}", v),
|
||||
CalcResult::String(v) => v,
|
||||
CalcResult::Boolean(b) => {
|
||||
if b {
|
||||
@@ -410,13 +370,6 @@ impl Model {
|
||||
message: "Empty cell".to_string(),
|
||||
}
|
||||
}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
match s.chars().next() {
|
||||
@@ -439,7 +392,7 @@ impl Model {
|
||||
pub(crate) fn fn_upper(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() == 1 {
|
||||
let s = match self.evaluate_node_in_context(&args[0], cell) {
|
||||
CalcResult::Number(v) => format!("{v}"),
|
||||
CalcResult::Number(v) => format!("{}", v),
|
||||
CalcResult::String(v) => v,
|
||||
CalcResult::Boolean(b) => {
|
||||
if b {
|
||||
@@ -458,13 +411,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
return CalcResult::String(s.to_uppercase());
|
||||
}
|
||||
@@ -476,7 +422,7 @@ impl Model {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let s = match self.evaluate_node_in_context(&args[0], cell) {
|
||||
CalcResult::Number(v) => format!("{v}"),
|
||||
CalcResult::Number(v) => format!("{}", v),
|
||||
CalcResult::String(v) => v,
|
||||
CalcResult::Boolean(b) => {
|
||||
if b {
|
||||
@@ -495,13 +441,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
let num_chars = if args.len() == 2 {
|
||||
match self.evaluate_node_in_context(&args[1], cell) {
|
||||
@@ -532,13 +471,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => 0,
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
1
|
||||
@@ -558,7 +490,7 @@ impl Model {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let s = match self.evaluate_node_in_context(&args[0], cell) {
|
||||
CalcResult::Number(v) => format!("{v}"),
|
||||
CalcResult::Number(v) => format!("{}", v),
|
||||
CalcResult::String(v) => v,
|
||||
CalcResult::Boolean(b) => {
|
||||
if b {
|
||||
@@ -577,13 +509,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
let num_chars = if args.len() == 2 {
|
||||
match self.evaluate_node_in_context(&args[1], cell) {
|
||||
@@ -614,13 +539,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => 0,
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
1
|
||||
@@ -640,7 +558,7 @@ impl Model {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let s = match self.evaluate_node_in_context(&args[0], cell) {
|
||||
CalcResult::Number(v) => format!("{v}"),
|
||||
CalcResult::Number(v) => format!("{}", v),
|
||||
CalcResult::String(v) => v,
|
||||
CalcResult::Boolean(b) => {
|
||||
if b {
|
||||
@@ -659,13 +577,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
let start_num = match self.evaluate_node_in_context(&args[1], cell) {
|
||||
CalcResult::Number(v) => {
|
||||
@@ -730,13 +641,6 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => 0,
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
let mut result = "".to_string();
|
||||
let mut count: usize = 0;
|
||||
@@ -1079,13 +983,6 @@ impl Model {
|
||||
}
|
||||
error @ CalcResult::Error { .. } => return error,
|
||||
CalcResult::EmptyArg | CalcResult::Range { .. } => {}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1105,13 +1002,6 @@ impl Model {
|
||||
}
|
||||
}
|
||||
CalcResult::EmptyArg => {}
|
||||
CalcResult::Array(_) => {
|
||||
return CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
let result = values.join(&delimiter);
|
||||
@@ -1235,11 +1125,6 @@ impl Model {
|
||||
}
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => CalcResult::Number(0.0),
|
||||
CalcResult::Array(_) => CalcResult::Error {
|
||||
error: Error::NIMPL,
|
||||
origin: cell,
|
||||
message: "Arrays not supported yet".to_string(),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -110,7 +110,7 @@ pub(crate) fn from_wildcard_to_regex(
|
||||
|
||||
// And we have a valid Perl regex! (As Kim Kardashian said before me: "I know, right?")
|
||||
if exact {
|
||||
return regex::Regex::new(&format!("^{reg}$"));
|
||||
return regex::Regex::new(&format!("^{}$", reg));
|
||||
}
|
||||
regex::Regex::new(reg)
|
||||
}
|
||||
@@ -393,8 +393,10 @@ pub(crate) fn build_criteria<'a>(value: &'a CalcResult) -> Box<dyn Fn(&CalcResul
|
||||
// An error will match an error (never a string that is an error)
|
||||
Box::new(move |x| result_is_equal_to_error(x, &error.to_string()))
|
||||
}
|
||||
CalcResult::Range { left: _, right: _ } => Box::new(move |_x| false),
|
||||
CalcResult::Array(_) => Box::new(move |_x| false),
|
||||
CalcResult::Range { left: _, right: _ } => {
|
||||
// TODO: Implicit Intersection
|
||||
Box::new(move |_x| false)
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => Box::new(result_is_equal_to_empty),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -141,9 +141,9 @@ impl Model {
|
||||
/// * 1 - Perform a search starting at the first item. This is the default.
|
||||
/// * -1 - Perform a reverse search starting at the last item.
|
||||
/// * 2 - Perform a binary search that relies on lookup_array being sorted
|
||||
/// in ascending order. If not sorted, invalid results will be returned.
|
||||
/// in ascending order. If not sorted, invalid results will be returned.
|
||||
/// * -2 - Perform a binary search that relies on lookup_array being sorted
|
||||
/// in descending order. If not sorted, invalid results will be returned.
|
||||
/// in descending order. If not sorted, invalid results will be returned.
|
||||
pub(crate) fn fn_xlookup(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() < 3 || args.len() > 6 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
use std::{collections::HashMap, sync::OnceLock};
|
||||
use std::collections::HashMap;
|
||||
|
||||
use bitcode::{Decode, Encode};
|
||||
use once_cell::sync::Lazy;
|
||||
|
||||
#[derive(Encode, Decode, Clone)]
|
||||
pub struct Booleans {
|
||||
@@ -30,17 +31,14 @@ pub struct Language {
|
||||
pub errors: Errors,
|
||||
}
|
||||
|
||||
static LANGUAGES: OnceLock<HashMap<String, Language>> = OnceLock::new();
|
||||
|
||||
#[allow(clippy::expect_used)]
|
||||
fn get_languages() -> &'static HashMap<String, Language> {
|
||||
LANGUAGES.get_or_init(|| {
|
||||
bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
|
||||
})
|
||||
}
|
||||
static LANGUAGES: Lazy<HashMap<String, Language>> = Lazy::new(|| {
|
||||
bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
|
||||
});
|
||||
|
||||
pub fn get_language(id: &str) -> Result<&Language, String> {
|
||||
get_languages()
|
||||
let language = LANGUAGES
|
||||
.get(id)
|
||||
.ok_or_else(|| format!("Language is not supported: '{id}'"))
|
||||
.ok_or(format!("Language is not supported: '{}'", id))?;
|
||||
Ok(language)
|
||||
}
|
||||
|
||||
@@ -25,8 +25,6 @@
|
||||
#![doc = include_str!("../examples/formulas_and_errors.rs")]
|
||||
//! ```
|
||||
|
||||
#![warn(clippy::print_stdout)]
|
||||
|
||||
pub mod calc_result;
|
||||
pub mod cell;
|
||||
pub mod expressions;
|
||||
@@ -39,9 +37,9 @@ pub mod types;
|
||||
pub mod worksheet;
|
||||
|
||||
mod actions;
|
||||
mod arithmetic;
|
||||
mod cast;
|
||||
mod constants;
|
||||
mod diffs;
|
||||
mod functions;
|
||||
mod implicit_intersection;
|
||||
mod model;
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
use std::{collections::HashMap, sync::OnceLock};
|
||||
|
||||
use bitcode::{Decode, Encode};
|
||||
use once_cell::sync::Lazy;
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
#[derive(Encode, Decode, Clone)]
|
||||
pub struct Locale {
|
||||
@@ -64,17 +65,12 @@ pub struct DecimalFormats {
|
||||
pub standard: String,
|
||||
}
|
||||
|
||||
static LOCALES: OnceLock<HashMap<String, Locale>> = OnceLock::new();
|
||||
|
||||
#[allow(clippy::expect_used)]
|
||||
fn get_locales() -> &'static HashMap<String, Locale> {
|
||||
LOCALES.get_or_init(|| {
|
||||
bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale")
|
||||
})
|
||||
}
|
||||
static LOCALES: Lazy<HashMap<String, Locale>> =
|
||||
Lazy::new(|| bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale"));
|
||||
|
||||
pub fn get_locale(id: &str) -> Result<&Locale, String> {
|
||||
get_locales()
|
||||
.get(id)
|
||||
.ok_or_else(|| format!("Invalid locale: '{id}'"))
|
||||
// TODO: pass the locale once we implement locales in Rust
|
||||
let locale = LOCALES.get(id).ok_or("Invalid locale")?;
|
||||
Ok(locale)
|
||||
}
|
||||
|
||||
@@ -8,15 +8,14 @@ use crate::{
|
||||
cell::CellValue,
|
||||
constants::{self, LAST_COLUMN, LAST_ROW},
|
||||
expressions::{
|
||||
lexer::LexerMode,
|
||||
parser::{
|
||||
move_formula::{move_formula, MoveContext},
|
||||
stringify::{rename_defined_name_in_node, to_rc_format, to_string},
|
||||
stringify::{to_rc_format, to_string},
|
||||
Node, Parser,
|
||||
},
|
||||
token::{get_error_by_name, Error, OpCompare, OpProduct, OpSum, OpUnary},
|
||||
types::*,
|
||||
utils::{self, is_valid_column_number, is_valid_identifier, is_valid_row},
|
||||
utils::{self, is_valid_column_number, is_valid_row, parse_reference_a1},
|
||||
},
|
||||
formatter::{
|
||||
format::{format_number, parse_formatted_number},
|
||||
@@ -73,7 +72,6 @@ pub(crate) enum CellState {
|
||||
}
|
||||
|
||||
/// A parsed formula for a defined name
|
||||
#[derive(Clone)]
|
||||
pub(crate) enum ParsedDefinedName {
|
||||
/// CellReference (`=C4`)
|
||||
CellReference(CellReferenceIndex),
|
||||
@@ -81,6 +79,9 @@ pub(crate) enum ParsedDefinedName {
|
||||
RangeReference(Range),
|
||||
/// `=SomethingElse`
|
||||
InvalidDefinedNameFormula,
|
||||
// TODO: Support constants in defined names
|
||||
// TODO: Support formulas in defined names
|
||||
// TODO: Support tables in defined names
|
||||
}
|
||||
|
||||
/// A dynamical IronCalc model.
|
||||
@@ -106,15 +107,15 @@ pub struct Model {
|
||||
pub(crate) shared_strings: HashMap<String, usize>,
|
||||
/// An instance of the parser
|
||||
pub(crate) parser: Parser,
|
||||
/// The list of cells with formulas that are evaluated or being evaluated
|
||||
/// The list of cells with formulas that are evaluated of being evaluated
|
||||
pub(crate) cells: HashMap<(u32, i32, i32), CellState>,
|
||||
/// The locale of the model
|
||||
pub(crate) locale: Locale,
|
||||
/// The language used
|
||||
/// Tha language used
|
||||
pub(crate) language: Language,
|
||||
/// The timezone used to evaluate the model
|
||||
pub(crate) tz: Tz,
|
||||
/// The view id. A view consists of a selected sheet and ranges.
|
||||
/// The view id. A view consist of a selected sheet and ranges.
|
||||
pub(crate) view_id: u32,
|
||||
}
|
||||
|
||||
@@ -207,17 +208,6 @@ impl Model {
|
||||
},
|
||||
}
|
||||
}
|
||||
Node::ImplicitIntersection {
|
||||
automatic: _,
|
||||
child,
|
||||
} => match self.evaluate_node_with_reference(child, cell) {
|
||||
CalcResult::Range { left, right } => CalcResult::Range { left, right },
|
||||
_ => CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Error with Implicit Intersection in cell {cell:?}"),
|
||||
),
|
||||
},
|
||||
_ => self.evaluate_node_in_context(node, cell),
|
||||
}
|
||||
}
|
||||
@@ -267,10 +257,27 @@ impl Model {
|
||||
) -> CalcResult {
|
||||
use Node::*;
|
||||
match node {
|
||||
OpSumKind { kind, left, right } => match kind {
|
||||
OpSum::Add => self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1 + f2)),
|
||||
OpSum::Minus => self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1 - f2)),
|
||||
},
|
||||
OpSumKind { kind, left, right } => {
|
||||
// In the future once the feature try trait stabilizes we could use the '?' operator for this :)
|
||||
// See: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=236044e8321a1450988e6ffe5a27dab5
|
||||
let l = match self.get_number(left, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
let r = match self.get_number(right, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
let result = match kind {
|
||||
OpSum::Add => l + r,
|
||||
OpSum::Minus => l - r,
|
||||
};
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
NumberKind(value) => CalcResult::Number(*value),
|
||||
StringKind(value) => CalcResult::String(value.replace(r#""""#, r#"""#)),
|
||||
BooleanKind(value) => CalcResult::Boolean(*value),
|
||||
@@ -355,63 +362,93 @@ impl Model {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
let result = format!("{l}{r}");
|
||||
let result = format!("{}{}", l, r);
|
||||
CalcResult::String(result)
|
||||
}
|
||||
OpProductKind { kind, left, right } => match kind {
|
||||
OpProduct::Times => {
|
||||
self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1 * f2))
|
||||
}
|
||||
OpProduct::Divide => self.handle_arithmetic(left, right, cell, &|f1, f2| {
|
||||
if f2 == 0.0 {
|
||||
Err(Error::DIV)
|
||||
} else {
|
||||
Ok(f1 / f2)
|
||||
OpProductKind { kind, left, right } => {
|
||||
let l = match self.get_number(left, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
}),
|
||||
},
|
||||
};
|
||||
let r = match self.get_number(right, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
let result = match kind {
|
||||
OpProduct::Times => l * r,
|
||||
OpProduct::Divide => {
|
||||
if r == 0.0 {
|
||||
return CalcResult::new_error(
|
||||
Error::DIV,
|
||||
cell,
|
||||
"Divide by Zero".to_string(),
|
||||
);
|
||||
}
|
||||
l / r
|
||||
}
|
||||
};
|
||||
CalcResult::Number(result)
|
||||
}
|
||||
OpPowerKind { left, right } => {
|
||||
self.handle_arithmetic(left, right, cell, &|f1, f2| Ok(f1.powf(f2)))
|
||||
let l = match self.get_number(left, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
let r = match self.get_number(right, cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => {
|
||||
return s;
|
||||
}
|
||||
};
|
||||
// Deal with errors properly
|
||||
CalcResult::Number(l.powf(r))
|
||||
}
|
||||
FunctionKind { kind, args } => self.evaluate_function(kind, args, cell),
|
||||
InvalidFunctionKind { name, args: _ } => {
|
||||
CalcResult::new_error(Error::ERROR, cell, format!("Invalid function: {name}"))
|
||||
CalcResult::new_error(Error::ERROR, cell, format!("Invalid function: {}", name))
|
||||
}
|
||||
ArrayKind(s) => CalcResult::Array(s.to_owned()),
|
||||
DefinedNameKind((name, scope, _)) => {
|
||||
if let Ok(Some(parsed_defined_name)) = self.get_parsed_defined_name(name, *scope) {
|
||||
ArrayKind(_) => {
|
||||
// TODO: NOT IMPLEMENTED
|
||||
CalcResult::new_error(Error::NIMPL, cell, "Arrays not implemented".to_string())
|
||||
}
|
||||
VariableKind(defined_name) => {
|
||||
let parsed_defined_name = self
|
||||
.parsed_defined_names
|
||||
.get(&(Some(cell.sheet), defined_name.to_lowercase())) // try getting local defined name
|
||||
.or_else(|| {
|
||||
self.parsed_defined_names
|
||||
.get(&(None, defined_name.to_lowercase()))
|
||||
}); // fallback to global
|
||||
|
||||
if let Some(parsed_defined_name) = parsed_defined_name {
|
||||
match parsed_defined_name {
|
||||
ParsedDefinedName::CellReference(reference) => {
|
||||
self.evaluate_cell(reference)
|
||||
self.evaluate_cell(*reference)
|
||||
}
|
||||
ParsedDefinedName::RangeReference(range) => CalcResult::Range {
|
||||
left: range.left,
|
||||
right: range.right,
|
||||
},
|
||||
ParsedDefinedName::InvalidDefinedNameFormula => CalcResult::new_error(
|
||||
Error::NAME,
|
||||
Error::NIMPL,
|
||||
cell,
|
||||
format!("Defined name \"{name}\" is not a reference."),
|
||||
format!("Defined name \"{}\" is not a reference.", defined_name),
|
||||
),
|
||||
}
|
||||
} else {
|
||||
CalcResult::new_error(
|
||||
Error::NAME,
|
||||
cell,
|
||||
format!("Defined name \"{name}\" not found."),
|
||||
format!("Defined name \"{}\" not found.", defined_name),
|
||||
)
|
||||
}
|
||||
}
|
||||
TableNameKind(s) => CalcResult::new_error(
|
||||
Error::NAME,
|
||||
cell,
|
||||
format!("table name \"{s}\" not supported."),
|
||||
),
|
||||
WrongVariableKind(s) => CalcResult::new_error(
|
||||
Error::NAME,
|
||||
cell,
|
||||
format!("Variable name \"{s}\" not found."),
|
||||
),
|
||||
CompareKind { kind, left, right } => {
|
||||
let l = self.evaluate_node_in_context(left, cell);
|
||||
if l.is_error() {
|
||||
@@ -487,25 +524,9 @@ impl Model {
|
||||
} => CalcResult::new_error(
|
||||
Error::ERROR,
|
||||
cell,
|
||||
format!("Error parsing {formula}: {message}"),
|
||||
format!("Error parsing {}: {}", formula, message),
|
||||
),
|
||||
EmptyArgKind => CalcResult::EmptyArg,
|
||||
ImplicitIntersection {
|
||||
automatic: _,
|
||||
child,
|
||||
} => match self.evaluate_node_with_reference(child, cell) {
|
||||
CalcResult::Range { left, right } => {
|
||||
match implicit_intersection(&cell, &Range { left, right }) {
|
||||
Some(cell_reference) => self.evaluate_cell(cell_reference),
|
||||
None => CalcResult::new_error(
|
||||
Error::VALUE,
|
||||
cell,
|
||||
format!("Error with Implicit Intersection in cell {cell:?}"),
|
||||
),
|
||||
}
|
||||
}
|
||||
_ => self.evaluate_node_in_context(child, cell),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
@@ -595,15 +616,12 @@ impl Model {
|
||||
};
|
||||
}
|
||||
CalcResult::Range { left, right } => {
|
||||
if left.sheet == right.sheet
|
||||
&& left.row == right.row
|
||||
&& left.column == right.column
|
||||
let range = Range {
|
||||
left: *left,
|
||||
right: *right,
|
||||
};
|
||||
if let Some(intersection_cell) = implicit_intersection(&cell_reference, &range)
|
||||
{
|
||||
let intersection_cell = CellReferenceIndex {
|
||||
sheet: left.sheet,
|
||||
column: left.column,
|
||||
row: left.row,
|
||||
};
|
||||
let v = self.evaluate_cell(intersection_cell);
|
||||
self.set_cell_value(cell_reference, &v);
|
||||
} else {
|
||||
@@ -620,32 +638,10 @@ impl Model {
|
||||
f,
|
||||
s,
|
||||
o,
|
||||
m: "Implicit Intersection not implemented".to_string(),
|
||||
ei: Error::NIMPL,
|
||||
m: "Invalid reference".to_string(),
|
||||
ei: Error::VALUE,
|
||||
};
|
||||
}
|
||||
// if let Some(intersection_cell) = implicit_intersection(&cell_reference, &range)
|
||||
// {
|
||||
// let v = self.evaluate_cell(intersection_cell);
|
||||
// self.set_cell_value(cell_reference, &v);
|
||||
// } else {
|
||||
// let o = match self.cell_reference_to_string(&cell_reference) {
|
||||
// Ok(s) => s,
|
||||
// Err(_) => "".to_string(),
|
||||
// };
|
||||
// *self.workbook.worksheets[sheet as usize]
|
||||
// .sheet_data
|
||||
// .get_mut(&row)
|
||||
// .expect("expected a row")
|
||||
// .get_mut(&column)
|
||||
// .expect("expected a column") = Cell::CellFormulaError {
|
||||
// f,
|
||||
// s,
|
||||
// o,
|
||||
// m: "Invalid reference".to_string(),
|
||||
// ei: Error::VALUE,
|
||||
// };
|
||||
// }
|
||||
}
|
||||
CalcResult::EmptyCell | CalcResult::EmptyArg => {
|
||||
*self.workbook.worksheets[sheet as usize]
|
||||
@@ -655,20 +651,6 @@ impl Model {
|
||||
.get_mut(&column)
|
||||
.expect("expected a column") = Cell::CellFormulaNumber { f, s, v: 0.0 };
|
||||
}
|
||||
CalcResult::Array(_) => {
|
||||
*self.workbook.worksheets[sheet as usize]
|
||||
.sheet_data
|
||||
.get_mut(&row)
|
||||
.expect("expected a row")
|
||||
.get_mut(&column)
|
||||
.expect("expected a column") = Cell::CellFormulaError {
|
||||
f,
|
||||
s,
|
||||
o: "".to_string(),
|
||||
m: "Arrays not supported yet".to_string(),
|
||||
ei: Error::NIMPL,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -697,14 +679,7 @@ impl Model {
|
||||
worksheet.color = Some(color.to_string());
|
||||
return Ok(());
|
||||
}
|
||||
Err(format!("Invalid color: {color}"))
|
||||
}
|
||||
|
||||
/// Changes the visibility of a sheet
|
||||
pub fn set_sheet_state(&mut self, sheet: u32, state: SheetState) -> Result<(), String> {
|
||||
let worksheet = self.workbook.worksheet_mut(sheet)?;
|
||||
worksheet.state = state;
|
||||
Ok(())
|
||||
Err(format!("Invalid color: {}", color))
|
||||
}
|
||||
|
||||
/// Makes the grid lines in the sheet visible (`true`) or hidden (`false`)
|
||||
@@ -772,6 +747,29 @@ impl Model {
|
||||
self.workbook.worksheet(sheet)?.is_empty_cell(row, column)
|
||||
}
|
||||
|
||||
/// Returns 'true' if the cell belongs to any Merged cells
|
||||
/// # Examples
|
||||
///
|
||||
/// ```rust
|
||||
/// # use ironcalc_base::Model;
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// let mut model = Model::new_empty("model", "en", "UTC")?;
|
||||
/// model.merge_cells(0, "A1:D5");
|
||||
/// assert_eq!(model.is_part_of_merged_cells(0, 1, 2)?, true);
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn is_part_of_merged_cells(
|
||||
&self,
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
column: i32,
|
||||
) -> Result<bool, String> {
|
||||
self.workbook
|
||||
.worksheet(sheet)?
|
||||
.is_part_of_merged_cells(row, column)
|
||||
}
|
||||
|
||||
pub(crate) fn evaluate_cell(&mut self, cell_reference: CellReferenceIndex) -> CalcResult {
|
||||
let row_data = match self.workbook.worksheets[cell_reference.sheet as usize]
|
||||
.sheet_data
|
||||
@@ -882,7 +880,6 @@ impl Model {
|
||||
|
||||
let worksheet_names = worksheets.iter().map(|s| s.get_name()).collect();
|
||||
|
||||
let defined_names = workbook.get_defined_names_with_scope();
|
||||
// add all tables
|
||||
// let mut tables = Vec::new();
|
||||
// for worksheet in worksheets {
|
||||
@@ -892,7 +889,7 @@ impl Model {
|
||||
// }
|
||||
// tables.push(tables_in_sheet);
|
||||
// }
|
||||
let parser = Parser::new(worksheet_names, defined_names, workbook.tables.clone());
|
||||
let parser = Parser::new(worksheet_names, workbook.tables.clone());
|
||||
let cells = HashMap::new();
|
||||
let locale = get_locale(&workbook.settings.locale)
|
||||
.map_err(|_| "Invalid locale".to_string())?
|
||||
@@ -973,7 +970,10 @@ impl Model {
|
||||
}
|
||||
}
|
||||
}
|
||||
let sheet = self.get_sheet_index_by_name(&sheet_name)?;
|
||||
let sheet = match self.get_sheet_index_by_name(&sheet_name) {
|
||||
Some(s) => s,
|
||||
None => return None,
|
||||
};
|
||||
let row = match row.parse::<i32>() {
|
||||
Ok(r) => r,
|
||||
Err(_) => return None,
|
||||
@@ -1027,7 +1027,7 @@ impl Model {
|
||||
let source_sheet_name = self
|
||||
.workbook
|
||||
.worksheet(source.sheet)
|
||||
.map_err(|e| format!("Could not find source worksheet: {e}"))?
|
||||
.map_err(|e| format!("Could not find source worksheet: {}", e))?
|
||||
.get_name();
|
||||
if source.sheet != area.sheet {
|
||||
return Err("Source and area are in different sheets".to_string());
|
||||
@@ -1041,7 +1041,7 @@ impl Model {
|
||||
let target_sheet_name = self
|
||||
.workbook
|
||||
.worksheet(target.sheet)
|
||||
.map_err(|e| format!("Could not find target worksheet: {e}"))?
|
||||
.map_err(|e| format!("Could not find target worksheet: {}", e))?
|
||||
.get_name();
|
||||
if let Some(formula) = value.strip_prefix('=') {
|
||||
let cell_reference = CellReferenceRC {
|
||||
@@ -1050,7 +1050,7 @@ impl Model {
|
||||
column: source.column,
|
||||
};
|
||||
let formula_str = move_formula(
|
||||
&self.parser.parse(formula, &cell_reference),
|
||||
&self.parser.parse(formula, &Some(cell_reference)),
|
||||
&MoveContext {
|
||||
source_sheet_name: &source_sheet_name,
|
||||
row: source.row,
|
||||
@@ -1061,7 +1061,7 @@ impl Model {
|
||||
column_delta: target.column - source.column,
|
||||
},
|
||||
);
|
||||
Ok(format!("={formula_str}"))
|
||||
Ok(format!("={}", formula_str))
|
||||
} else {
|
||||
Ok(value.to_string())
|
||||
}
|
||||
@@ -1158,7 +1158,7 @@ impl Model {
|
||||
row: source.row,
|
||||
column: source.column,
|
||||
};
|
||||
let formula = &self.parser.parse(formula_str, &cell_reference);
|
||||
let formula = &self.parser.parse(formula_str, &Some(cell_reference));
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: target_sheet_name,
|
||||
row: target.row,
|
||||
@@ -1248,6 +1248,14 @@ impl Model {
|
||||
column: i32,
|
||||
value: &str,
|
||||
) -> Result<(), String> {
|
||||
// Checking first whether cell we are updating is part of Merged cells
|
||||
// if so returning with Err
|
||||
if self.is_part_of_merged_cells(sheet, row, column)? {
|
||||
return Err(format!(
|
||||
"Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
|
||||
row, column
|
||||
));
|
||||
}
|
||||
let style_index = self.get_cell_style_index(sheet, row, column)?;
|
||||
let new_style_index;
|
||||
if common::value_needs_quoting(value, &self.language) {
|
||||
@@ -1298,6 +1306,15 @@ impl Model {
|
||||
column: i32,
|
||||
value: bool,
|
||||
) -> Result<(), String> {
|
||||
// Checking first whether cell we are updating is part of Merged cells
|
||||
// if so returning with Err
|
||||
if self.is_part_of_merged_cells(sheet, row, column)? {
|
||||
return Err(format!(
|
||||
"Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
|
||||
row, column
|
||||
));
|
||||
}
|
||||
|
||||
let style_index = self.get_cell_style_index(sheet, row, column)?;
|
||||
let new_style_index = if self.workbook.styles.style_is_quote_prefix(style_index) {
|
||||
self.workbook
|
||||
@@ -1340,6 +1357,14 @@ impl Model {
|
||||
column: i32,
|
||||
value: f64,
|
||||
) -> Result<(), String> {
|
||||
// Checking first whether cell we are updating is part of Merged cells
|
||||
// if so returning with Err
|
||||
if self.is_part_of_merged_cells(sheet, row, column)? {
|
||||
return Err(format!(
|
||||
"Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
|
||||
row, column
|
||||
));
|
||||
}
|
||||
let style_index = self.get_cell_style_index(sheet, row, column)?;
|
||||
let new_style_index = if self.workbook.styles.style_is_quote_prefix(style_index) {
|
||||
self.workbook
|
||||
@@ -1385,6 +1410,12 @@ impl Model {
|
||||
column: i32,
|
||||
formula: String,
|
||||
) -> Result<(), String> {
|
||||
if self.is_part_of_merged_cells(sheet, row, column)? {
|
||||
return Err(format!(
|
||||
"Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
|
||||
row, column
|
||||
));
|
||||
}
|
||||
let mut style_index = self.get_cell_style_index(sheet, row, column)?;
|
||||
if self.workbook.styles.style_is_quote_prefix(style_index) {
|
||||
style_index = self
|
||||
@@ -1437,6 +1468,14 @@ impl Model {
|
||||
column: i32,
|
||||
value: String,
|
||||
) -> Result<(), String> {
|
||||
// Checking first whether cell we are updating is part of Merged cells
|
||||
// if so returning with Err
|
||||
if self.is_part_of_merged_cells(sheet, row, column)? {
|
||||
return Err(format!(
|
||||
"Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
|
||||
row, column
|
||||
));
|
||||
}
|
||||
// If value starts with "'" then we force the style to be quote_prefix
|
||||
let style_index = self.get_cell_style_index(sheet, row, column)?;
|
||||
if let Some(new_value) = value.strip_prefix('\'') {
|
||||
@@ -1534,11 +1573,13 @@ impl Model {
|
||||
column,
|
||||
};
|
||||
let shared_formulas = &mut worksheet.shared_formulas;
|
||||
let mut parsed_formula = self.parser.parse(formula, &cell_reference);
|
||||
let mut parsed_formula = self.parser.parse(formula, &Some(cell_reference.clone()));
|
||||
// If the formula fails to parse try adding a parenthesis
|
||||
// SUM(A1:A3 => SUM(A1:A3)
|
||||
if let Node::ParseErrorKind { .. } = parsed_formula {
|
||||
let new_parsed_formula = self.parser.parse(&format!("{formula})"), &cell_reference);
|
||||
let new_parsed_formula = self
|
||||
.parser
|
||||
.parse(&format!("{})", formula), &Some(cell_reference));
|
||||
match new_parsed_formula {
|
||||
Node::ParseErrorKind { .. } => {}
|
||||
_ => parsed_formula = new_parsed_formula,
|
||||
@@ -1617,42 +1658,6 @@ impl Model {
|
||||
.set_cell_with_number(row, column, value, style)
|
||||
}
|
||||
|
||||
// Helper function that returns a defined name given the name and scope
|
||||
fn get_parsed_defined_name(
|
||||
&self,
|
||||
name: &str,
|
||||
scope: Option<u32>,
|
||||
) -> Result<Option<ParsedDefinedName>, String> {
|
||||
let name_upper = name.to_uppercase();
|
||||
|
||||
for (key, df) in &self.parsed_defined_names {
|
||||
if key.1.to_uppercase() == name_upper && key.0 == scope {
|
||||
return Ok(Some(df.clone()));
|
||||
}
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
// Returns the formula for a defined name
|
||||
pub(crate) fn get_defined_name_formula(
|
||||
&self,
|
||||
name: &str,
|
||||
scope: Option<u32>,
|
||||
) -> Result<String, String> {
|
||||
let name_upper = name.to_uppercase();
|
||||
let defined_names = &self.workbook.defined_names;
|
||||
let sheet_id = match scope {
|
||||
Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
|
||||
None => None,
|
||||
};
|
||||
for df in defined_names {
|
||||
if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
|
||||
return Ok(df.formula.clone());
|
||||
}
|
||||
}
|
||||
Err("Defined name not found".to_string())
|
||||
}
|
||||
|
||||
/// Gets the Excel Value (Bool, Number, String) of a cell
|
||||
///
|
||||
/// See also:
|
||||
@@ -1885,29 +1890,12 @@ impl Model {
|
||||
}
|
||||
|
||||
/// Returns the style for cell (`sheet`, `row`, `column`)
|
||||
/// If the cell does not have a style defined we check the row, otherwise the column and finally a default
|
||||
pub fn get_style_for_cell(&self, sheet: u32, row: i32, column: i32) -> Result<Style, String> {
|
||||
let style_index = self.get_cell_style_index(sheet, row, column)?;
|
||||
let style = self.workbook.styles.get_style(style_index)?;
|
||||
Ok(style)
|
||||
}
|
||||
|
||||
/// Returns the style defined in a cell if any.
|
||||
pub fn get_cell_style_or_none(
|
||||
&self,
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
column: i32,
|
||||
) -> Result<Option<Style>, String> {
|
||||
let style = self
|
||||
.workbook
|
||||
.worksheet(sheet)?
|
||||
.cell(row, column)
|
||||
.map(|c| self.workbook.styles.get_style(c.get_style()))
|
||||
.transpose();
|
||||
style
|
||||
}
|
||||
|
||||
/// Returns an internal binary representation of the workbook
|
||||
///
|
||||
/// See also:
|
||||
@@ -2002,6 +1990,7 @@ impl Model {
|
||||
/// Sets the number of frozen rows to `frozen_rows` in the workbook.
|
||||
/// Fails if `frozen`_rows` is either too small (<0) or too large (>LAST_ROW)`
|
||||
pub fn set_frozen_rows(&mut self, sheet: u32, frozen_rows: i32) -> Result<(), String> {
|
||||
// TODO: What is frozen rows and do we need to take of this if row we are frozing is part of merge cells ?
|
||||
if let Some(worksheet) = self.workbook.worksheets.get_mut(sheet as usize) {
|
||||
if frozen_rows < 0 {
|
||||
return Err("Frozen rows cannot be negative".to_string());
|
||||
@@ -2019,6 +2008,7 @@ impl Model {
|
||||
/// Sets the number of frozen columns to `frozen_column` in the workbook.
|
||||
/// Fails if `frozen`_columns` is either too small (<0) or too large (>LAST_COLUMN)`
|
||||
pub fn set_frozen_columns(&mut self, sheet: u32, frozen_columns: i32) -> Result<(), String> {
|
||||
// TODO: What is frozen columns and do we need to take of this if column we are frozing is part of merge cells ?
|
||||
if let Some(worksheet) = self.workbook.worksheets.get_mut(sheet as usize) {
|
||||
if frozen_columns < 0 {
|
||||
return Err("Frozen columns cannot be negative".to_string());
|
||||
@@ -2061,202 +2051,162 @@ impl Model {
|
||||
.set_row_height(column, height)
|
||||
}
|
||||
|
||||
/// Adds a new defined name
|
||||
pub fn new_defined_name(
|
||||
&mut self,
|
||||
name: &str,
|
||||
scope: Option<u32>,
|
||||
formula: &str,
|
||||
) -> Result<(), String> {
|
||||
if !is_valid_identifier(name) {
|
||||
return Err("Invalid defined name".to_string());
|
||||
};
|
||||
let name_upper = name.to_uppercase();
|
||||
let defined_names = &self.workbook.defined_names;
|
||||
let sheet_id = match scope {
|
||||
Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
|
||||
None => None,
|
||||
};
|
||||
// if the defined name already exist return error
|
||||
for df in defined_names {
|
||||
if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
|
||||
return Err("Defined name already exists".to_string());
|
||||
fn parse_merged_range(&mut self, range: &str) -> Result<(i32, i32, i32, i32), String> {
|
||||
let parts: Vec<&str> = range.split(':').collect();
|
||||
if parts.len() == 1 {
|
||||
Err(format!("Invalid range: '{}'", range))
|
||||
} else if parts.len() == 2 {
|
||||
match (parse_reference_a1(parts[0]), parse_reference_a1(parts[1])) {
|
||||
(Some(left), Some(right)) => {
|
||||
return Ok((left.row, left.column, right.row, right.column));
|
||||
}
|
||||
_ => return Err(format!("Invalid range: '{}'", range)),
|
||||
}
|
||||
} else {
|
||||
return Err(format!("Invalid range: '{}'", range));
|
||||
}
|
||||
}
|
||||
|
||||
// Implementing public APIS related to Merge cells handling
|
||||
|
||||
/// Merges given selected cells
|
||||
/// If no overlap, it will create that merged cells with left most top cell value representing the whole merged cells
|
||||
/// If new merge cells creation overlaps with any of the existing merged cells, Overlapped merged cells gets unmerged
|
||||
/// and new merge cells gets added
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```rust
|
||||
/// # use ironcalc_base::Model;
|
||||
/// # use ironcalc_base::cell::CellValue;
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// let mut model = Model::new_empty("model", "en", "UTC")?;
|
||||
/// model.merge_cells(0, "D4:F6").unwrap();
|
||||
/// model.merge_cells(0, "A1:B4").unwrap();
|
||||
/// assert_eq!(model.workbook.worksheet(0).unwrap().merged_cells_list.len(), 2);
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// See also:
|
||||
/// * [Model::update_cell_with_formula()]
|
||||
/// * [Model::update_cell_with_number()]
|
||||
/// * [Model::update_cell_with_bool()]
|
||||
/// * [Model::update_cell_with_text()]
|
||||
pub fn merge_cells(&mut self, sheet: u32, range_ref: &str) -> Result<(), String> {
|
||||
match self.parse_merged_range(range_ref) {
|
||||
Ok(parsed_merge_cell_range) => {
|
||||
// ATTENTION 2: Below thing we can support here but keeping it simple
|
||||
// Web or different client needs to keep this in mind
|
||||
// User can give errored parse ranges like C3:A1
|
||||
// Where col_start and row_start and is greated then col_end and row_end
|
||||
// Return error in these scenario
|
||||
if parsed_merge_cell_range.0 > parsed_merge_cell_range.2
|
||||
|| parsed_merge_cell_range.1 > parsed_merge_cell_range.3
|
||||
{
|
||||
return Err(
|
||||
"Invalid parse range. Merge Mother cell always be top left cell"
|
||||
.to_string(),
|
||||
);
|
||||
}
|
||||
|
||||
let mut merged_cells_overlaped_list: Vec<bool> = Vec::new();
|
||||
// checking whether our new range overlaps with any of the already existing merged cells
|
||||
// if so, need to unmerge those and create this new one
|
||||
{
|
||||
let worksheet = self.workbook.worksheet(sheet)?;
|
||||
let merged_cells = worksheet.get_merged_cells_list();
|
||||
|
||||
for merge_node in merged_cells {
|
||||
// checking whether any overlapping exist with this merge cell
|
||||
if !(parsed_merge_cell_range.1 > merge_node.3
|
||||
|| parsed_merge_cell_range.3 < merge_node.1
|
||||
|| parsed_merge_cell_range.0 > merge_node.2
|
||||
|| parsed_merge_cell_range.2 < merge_node.0)
|
||||
{
|
||||
// overlap has happened
|
||||
merged_cells_overlaped_list.push(true);
|
||||
} else {
|
||||
merged_cells_overlaped_list.push(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if !merged_cells_overlaped_list.is_empty() {
|
||||
// Lets take Mutable ref to Merge cell and deletes all those nodes which has overlapped
|
||||
let worksheet = self.workbook.worksheet_mut(sheet)?;
|
||||
let merged_cells_list_mut = worksheet.get_merged_cells_list_mut();
|
||||
let mut merged_cells_overlaped_list_iter = merged_cells_overlaped_list.iter();
|
||||
merged_cells_list_mut
|
||||
.retain(|_| !(*merged_cells_overlaped_list_iter.next().unwrap()))
|
||||
}
|
||||
|
||||
// Now need to update (n*m - 1) cells with empty cell ( except the Mother cell )
|
||||
for row_index in parsed_merge_cell_range.0..=parsed_merge_cell_range.2 {
|
||||
for col_index in parsed_merge_cell_range.1..=parsed_merge_cell_range.3 {
|
||||
// skip Mother cell
|
||||
if row_index == parsed_merge_cell_range.0
|
||||
&& col_index == parsed_merge_cell_range.2
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
//update the node with empty cell
|
||||
{
|
||||
self.workbook.worksheet_mut(sheet)?.update_cell(
|
||||
row_index,
|
||||
col_index,
|
||||
Cell::EmptyCell { s: 0 },
|
||||
)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let new_merged_cells = MergedCells::new(parsed_merge_cell_range);
|
||||
{
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.merged_cells_list
|
||||
.push(new_merged_cells);
|
||||
}
|
||||
}
|
||||
Err(err) => {
|
||||
return Err(err);
|
||||
}
|
||||
}
|
||||
self.workbook.defined_names.push(DefinedName {
|
||||
name: name.to_string(),
|
||||
formula: formula.to_string(),
|
||||
sheet_id,
|
||||
});
|
||||
self.reset_parsed_structures();
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Delete defined name of name and scope
|
||||
pub fn delete_defined_name(&mut self, name: &str, scope: Option<u32>) -> Result<(), String> {
|
||||
let name_upper = name.to_uppercase();
|
||||
let defined_names = &self.workbook.defined_names;
|
||||
let sheet_id = match scope {
|
||||
Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
|
||||
None => None,
|
||||
};
|
||||
let mut index = None;
|
||||
for (i, df) in defined_names.iter().enumerate() {
|
||||
if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
|
||||
index = Some(i);
|
||||
/// Unmerges a given/selected merged cells
|
||||
/// Once unmerged, only top most left corner value gets retained and all the others will have empty cell
|
||||
/// # Examples
|
||||
///
|
||||
/// ```rust
|
||||
/// # use ironcalc_base::Model;
|
||||
/// # use ironcalc_base::cell::CellValue;
|
||||
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
/// let mut model = Model::new_empty("model", "en", "UTC")?;
|
||||
/// model.merge_cells(0, "D4:F6");
|
||||
/// model.unmerge_cells(0, "D4:F6");
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub fn unmerge_cells(&mut self, sheet: u32, range_ref: &str) -> Result<(), String> {
|
||||
let worksheet = self.workbook.worksheet(sheet)?;
|
||||
let merged_cells = worksheet.get_merged_cells_list();
|
||||
for (index, merge_node) in merged_cells.iter().enumerate() {
|
||||
let merge_block_range_ref = merge_node.get_merged_cells_str_ref()?;
|
||||
// finding the merge cell node to be deleted
|
||||
if merge_block_range_ref.as_str() == range_ref {
|
||||
// Merge cell to be deleted is found
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.merged_cells_list
|
||||
.remove(index);
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
if let Some(i) = index {
|
||||
self.workbook.defined_names.remove(i);
|
||||
self.reset_parsed_structures();
|
||||
Ok(())
|
||||
} else {
|
||||
Err("Defined name not found".to_string())
|
||||
}
|
||||
}
|
||||
|
||||
/// Update defined name
|
||||
pub fn update_defined_name(
|
||||
&mut self,
|
||||
name: &str,
|
||||
scope: Option<u32>,
|
||||
new_name: &str,
|
||||
new_scope: Option<u32>,
|
||||
new_formula: &str,
|
||||
) -> Result<(), String> {
|
||||
if !is_valid_identifier(new_name) {
|
||||
return Err("Invalid defined name".to_string());
|
||||
};
|
||||
let name_upper = name.to_uppercase();
|
||||
let new_name_upper = new_name.to_uppercase();
|
||||
|
||||
if name_upper != new_name_upper || scope != new_scope {
|
||||
for key in self.parsed_defined_names.keys() {
|
||||
if key.1.to_uppercase() == new_name_upper && key.0 == new_scope {
|
||||
return Err("Defined name already exists".to_string());
|
||||
}
|
||||
}
|
||||
}
|
||||
let defined_names = &self.workbook.defined_names;
|
||||
let sheet_id = match scope {
|
||||
Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
|
||||
None => None,
|
||||
};
|
||||
|
||||
let new_sheet_id = match new_scope {
|
||||
Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
|
||||
None => None,
|
||||
};
|
||||
|
||||
let mut index = None;
|
||||
for (i, df) in defined_names.iter().enumerate() {
|
||||
if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
|
||||
index = Some(i);
|
||||
}
|
||||
}
|
||||
if let Some(i) = index {
|
||||
if let Some(df) = self.workbook.defined_names.get_mut(i) {
|
||||
if new_name != df.name {
|
||||
// We need to rename the name in every formula:
|
||||
|
||||
// Parse all formulas with the old name
|
||||
// All internal formulas are R1C1
|
||||
self.parser.set_lexer_mode(LexerMode::R1C1);
|
||||
let worksheets = &mut self.workbook.worksheets;
|
||||
for worksheet in worksheets {
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: worksheet.get_name(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
let mut formulas = Vec::new();
|
||||
for formula in &worksheet.shared_formulas {
|
||||
let mut t = self.parser.parse(formula, &cell_reference);
|
||||
rename_defined_name_in_node(&mut t, name, scope, new_name);
|
||||
formulas.push(to_rc_format(&t));
|
||||
}
|
||||
worksheet.shared_formulas = formulas;
|
||||
}
|
||||
// Se the mode back to A1
|
||||
self.parser.set_lexer_mode(LexerMode::A1);
|
||||
}
|
||||
df.name = new_name.to_string();
|
||||
df.sheet_id = new_sheet_id;
|
||||
df.formula = new_formula.to_string();
|
||||
self.reset_parsed_structures();
|
||||
}
|
||||
Ok(())
|
||||
} else {
|
||||
Err("Defined name not found".to_string())
|
||||
}
|
||||
}
|
||||
/// Returns the style object of a column, if any
|
||||
pub fn get_column_style(&self, sheet: u32, column: i32) -> Result<Option<Style>, String> {
|
||||
if let Some(worksheet) = self.workbook.worksheets.get(sheet as usize) {
|
||||
let cols = &worksheet.cols;
|
||||
for col in cols {
|
||||
if column >= col.min && column <= col.max {
|
||||
if let Some(style_index) = col.style {
|
||||
let style = self.workbook.styles.get_style(style_index)?;
|
||||
return Ok(Some(style));
|
||||
}
|
||||
return Ok(None);
|
||||
}
|
||||
}
|
||||
Ok(None)
|
||||
} else {
|
||||
Err("Invalid sheet".to_string())
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the style object of a row, if any
|
||||
pub fn get_row_style(&self, sheet: u32, row: i32) -> Result<Option<Style>, String> {
|
||||
if let Some(worksheet) = self.workbook.worksheets.get(sheet as usize) {
|
||||
let rows = &worksheet.rows;
|
||||
for r in rows {
|
||||
if row == r.r {
|
||||
let style = self.workbook.styles.get_style(r.s)?;
|
||||
return Ok(Some(style));
|
||||
}
|
||||
}
|
||||
Ok(None)
|
||||
} else {
|
||||
Err("Invalid sheet".to_string())
|
||||
}
|
||||
}
|
||||
|
||||
/// Sets a column with style
|
||||
pub fn set_column_style(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
style: &Style,
|
||||
) -> Result<(), String> {
|
||||
let style_index = self.workbook.styles.get_style_index_or_create(style);
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_column_style(column, style_index)
|
||||
}
|
||||
|
||||
/// Sets a row with style
|
||||
pub fn set_row_style(&mut self, sheet: u32, row: i32, style: &Style) -> Result<(), String> {
|
||||
let style_index = self.workbook.styles.get_style_index_or_create(style);
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_row_style(row, style_index)
|
||||
}
|
||||
|
||||
/// Deletes the style of a column if the is any
|
||||
pub fn delete_column_style(&mut self, sheet: u32, column: i32) -> Result<(), String> {
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.delete_column_style(column)
|
||||
}
|
||||
|
||||
/// Deletes the style of a row if there is any
|
||||
pub fn delete_row_style(&mut self, sheet: u32, row: i32) -> Result<(), String> {
|
||||
self.workbook.worksheet_mut(sheet)?.delete_row_style(row)
|
||||
Err("Invalid merge_cell_ref, Merged cells to be deleted is not found".to_string())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -4,11 +4,11 @@ use std::collections::HashMap;
|
||||
|
||||
use crate::{
|
||||
calc_result::Range,
|
||||
constants::{DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH},
|
||||
constants::{DEFAULT_WINDOW_HEIGH, DEFAULT_WINDOW_WIDTH},
|
||||
expressions::{
|
||||
lexer::LexerMode,
|
||||
parser::{
|
||||
stringify::{rename_sheet_in_node, to_rc_format, to_string},
|
||||
stringify::{rename_sheet_in_node, to_rc_format},
|
||||
Parser,
|
||||
},
|
||||
types::CellReferenceRC,
|
||||
@@ -17,8 +17,7 @@ use crate::{
|
||||
locale::get_locale,
|
||||
model::{get_milliseconds_since_epoch, Model, ParsedDefinedName},
|
||||
types::{
|
||||
DefinedName, Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet,
|
||||
WorksheetView,
|
||||
Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet, WorksheetView,
|
||||
},
|
||||
utils::ParsedReference,
|
||||
};
|
||||
@@ -58,7 +57,7 @@ impl Model {
|
||||
rows: vec![],
|
||||
comments: vec![],
|
||||
dimension: "A1".to_string(),
|
||||
merge_cells: vec![],
|
||||
merged_cells_list: vec![],
|
||||
name: name.to_string(),
|
||||
shared_formulas: vec![],
|
||||
sheet_data: Default::default(),
|
||||
@@ -86,14 +85,14 @@ impl Model {
|
||||
let worksheets = &self.workbook.worksheets;
|
||||
for worksheet in worksheets {
|
||||
let shared_formulas = &worksheet.shared_formulas;
|
||||
let cell_reference = CellReferenceRC {
|
||||
let cell_reference = &Some(CellReferenceRC {
|
||||
sheet: worksheet.get_name(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
});
|
||||
let mut parse_formula = Vec::new();
|
||||
for formula in shared_formulas {
|
||||
let t = self.parser.parse(formula, &cell_reference);
|
||||
let t = self.parser.parse(formula, cell_reference);
|
||||
parse_formula.push(t);
|
||||
}
|
||||
self.parsed_formulas.push(parse_formula);
|
||||
@@ -145,9 +144,8 @@ impl Model {
|
||||
|
||||
/// Reparses all formulas and defined names
|
||||
pub(crate) fn reset_parsed_structures(&mut self) {
|
||||
let defined_names = self.workbook.get_defined_names_with_scope();
|
||||
self.parser
|
||||
.set_worksheets_and_names(self.workbook.get_worksheet_names(), defined_names);
|
||||
.set_worksheets(self.workbook.get_worksheet_names());
|
||||
self.parsed_formulas = vec![];
|
||||
self.parse_formulas();
|
||||
self.parsed_defined_names = HashMap::new();
|
||||
@@ -168,11 +166,11 @@ impl Model {
|
||||
.get_worksheet_names()
|
||||
.iter()
|
||||
.map(|s| s.to_uppercase())
|
||||
.any(|x| x == format!("{base_name_uppercase}{index}"))
|
||||
.any(|x| x == format!("{}{}", base_name_uppercase, index))
|
||||
{
|
||||
index += 1;
|
||||
}
|
||||
let sheet_name = format!("{base_name}{index}");
|
||||
let sheet_name = format!("{}{}", base_name, index);
|
||||
// Now we need a sheet_id
|
||||
let sheet_id = self.get_new_sheet_id();
|
||||
let view_ids: Vec<&u32> = self.workbook.views.keys().collect();
|
||||
@@ -192,7 +190,7 @@ impl Model {
|
||||
sheet_id: Option<u32>,
|
||||
) -> Result<(), String> {
|
||||
if !is_valid_sheet_name(sheet_name) {
|
||||
return Err(format!("Invalid name for a sheet: '{sheet_name}'"));
|
||||
return Err(format!("Invalid name for a sheet: '{}'", sheet_name));
|
||||
}
|
||||
if self
|
||||
.workbook
|
||||
@@ -234,12 +232,12 @@ impl Model {
|
||||
if let Some(sheet_index) = self.get_sheet_index_by_name(old_name) {
|
||||
return self.rename_sheet_by_index(sheet_index, new_name);
|
||||
}
|
||||
Err(format!("Could not find sheet {old_name}"))
|
||||
Err(format!("Could not find sheet {}", old_name))
|
||||
}
|
||||
|
||||
/// Renames a sheet and updates all existing references to that sheet.
|
||||
/// It can fail if:
|
||||
/// * The original index is out of bounds
|
||||
/// * The original index is too large
|
||||
/// * The target sheet name already exists
|
||||
/// * The target sheet name is invalid
|
||||
pub fn rename_sheet_by_index(
|
||||
@@ -248,25 +246,27 @@ impl Model {
|
||||
new_name: &str,
|
||||
) -> Result<(), String> {
|
||||
if !is_valid_sheet_name(new_name) {
|
||||
return Err(format!("Invalid name for a sheet: '{new_name}'."));
|
||||
return Err(format!("Invalid name for a sheet: '{}'.", new_name));
|
||||
}
|
||||
if self.get_sheet_index_by_name(new_name).is_some() {
|
||||
return Err(format!("Sheet already exists: '{new_name}'."));
|
||||
return Err(format!("Sheet already exists: '{}'.", new_name));
|
||||
}
|
||||
let worksheets = &self.workbook.worksheets;
|
||||
let sheet_count = worksheets.len() as u32;
|
||||
if sheet_index >= sheet_count {
|
||||
return Err("Sheet index out of bounds".to_string());
|
||||
}
|
||||
// Gets the new name and checks that a sheet with that index exists
|
||||
let old_name = self.workbook.worksheet(sheet_index)?.get_name();
|
||||
|
||||
// Parse all formulas with the old name
|
||||
// All internal formulas are R1C1
|
||||
self.parser.set_lexer_mode(LexerMode::R1C1);
|
||||
|
||||
for worksheet in &mut self.workbook.worksheets {
|
||||
// R1C1 formulas are not tied to a cell (but are tied to a cell)
|
||||
let cell_reference = &CellReferenceRC {
|
||||
// We use iter because the default would be a mut_iter and we don't need a mutable reference
|
||||
let worksheets = &mut self.workbook.worksheets;
|
||||
for worksheet in worksheets {
|
||||
let cell_reference = &Some(CellReferenceRC {
|
||||
sheet: worksheet.get_name(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
});
|
||||
let mut formulas = Vec::new();
|
||||
for formula in &worksheet.shared_formulas {
|
||||
let mut t = self.parser.parse(formula, cell_reference);
|
||||
@@ -275,32 +275,11 @@ impl Model {
|
||||
}
|
||||
worksheet.shared_formulas = formulas;
|
||||
}
|
||||
|
||||
// Set the mode back to A1
|
||||
// Se the mode back to A1
|
||||
self.parser.set_lexer_mode(LexerMode::A1);
|
||||
|
||||
// We reparse all the defined names formulas
|
||||
let mut defined_names = Vec::new();
|
||||
// Defined names do not have a context, we can use anything
|
||||
let cell_reference = &CellReferenceRC {
|
||||
sheet: old_name.clone(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
for defined_name in &mut self.workbook.defined_names {
|
||||
let mut t = self.parser.parse(&defined_name.formula, cell_reference);
|
||||
rename_sheet_in_node(&mut t, sheet_index, new_name);
|
||||
let formula = to_string(&t, cell_reference);
|
||||
defined_names.push(DefinedName {
|
||||
name: defined_name.name.clone(),
|
||||
formula,
|
||||
sheet_id: defined_name.sheet_id,
|
||||
});
|
||||
}
|
||||
self.workbook.defined_names = defined_names;
|
||||
|
||||
// Update the name of the worksheet
|
||||
self.workbook.worksheet_mut(sheet_index)?.set_name(new_name);
|
||||
let worksheets = &mut self.workbook.worksheets;
|
||||
worksheets[sheet_index as usize].set_name(new_name);
|
||||
self.reset_parsed_structures();
|
||||
Ok(())
|
||||
}
|
||||
@@ -316,7 +295,7 @@ impl Model {
|
||||
};
|
||||
if sheet_index >= sheet_count {
|
||||
return Err("Sheet index too large".to_string());
|
||||
};
|
||||
}
|
||||
self.workbook.worksheets.remove(sheet_index as usize);
|
||||
self.reset_parsed_structures();
|
||||
Ok(())
|
||||
@@ -362,14 +341,14 @@ impl Model {
|
||||
};
|
||||
let locale = match get_locale(locale_id) {
|
||||
Ok(l) => l.clone(),
|
||||
Err(_) => return Err(format!("Invalid locale: {locale_id}")),
|
||||
Err(_) => return Err(format!("Invalid locale: {}", locale_id)),
|
||||
};
|
||||
|
||||
let milliseconds = get_milliseconds_since_epoch();
|
||||
let seconds = milliseconds / 1000;
|
||||
let dt = match DateTime::from_timestamp(seconds, 0) {
|
||||
Some(s) => s,
|
||||
None => return Err(format!("Invalid timestamp: {milliseconds}")),
|
||||
None => return Err(format!("Invalid timestamp: {}", milliseconds)),
|
||||
};
|
||||
// "2020-08-06T21:20:53Z
|
||||
let now = dt.format("%Y-%m-%dT%H:%M:%SZ").to_string();
|
||||
@@ -380,7 +359,7 @@ impl Model {
|
||||
WorkbookView {
|
||||
sheet: 0,
|
||||
window_width: DEFAULT_WINDOW_WIDTH,
|
||||
window_height: DEFAULT_WINDOW_HEIGHT,
|
||||
window_height: DEFAULT_WINDOW_HEIGH,
|
||||
},
|
||||
);
|
||||
|
||||
@@ -409,7 +388,7 @@ impl Model {
|
||||
let parsed_formulas = Vec::new();
|
||||
let worksheets = &workbook.worksheets;
|
||||
let worksheet_names = worksheets.iter().map(|s| s.get_name()).collect();
|
||||
let parser = Parser::new(worksheet_names, vec![], HashMap::new());
|
||||
let parser = Parser::new(worksheet_names, HashMap::new());
|
||||
let cells = HashMap::new();
|
||||
|
||||
// FIXME: Add support for display languages
|
||||
|
||||
@@ -126,7 +126,7 @@ pub fn to_precision_str(value: f64, precision: usize) -> String {
|
||||
let exponent = value.abs().log10().floor();
|
||||
let base = value / 10.0_f64.powf(exponent);
|
||||
let base = format!("{0:.1$}", base, precision - 1);
|
||||
let value = format!("{base}e{exponent}").parse::<f64>().unwrap_or({
|
||||
let value = format!("{}e{}", base, exponent).parse::<f64>().unwrap_or({
|
||||
// TODO: do this in a way that does not require a possible error
|
||||
0.0
|
||||
});
|
||||
|
||||
@@ -4,6 +4,8 @@ use crate::{
|
||||
types::{Border, CellStyles, CellXfs, Fill, Font, NumFmt, Style, Styles},
|
||||
};
|
||||
|
||||
// TODO: Move Styles and all related types from crate::types here
|
||||
// Not doing it right now to not have conflicts with exporter branch
|
||||
impl Styles {
|
||||
fn get_font_index(&self, font: &Font) -> Option<i32> {
|
||||
for (font_index, item) in self.fonts.iter().enumerate() {
|
||||
@@ -154,7 +156,7 @@ impl Styles {
|
||||
return Ok(cell_style.xf_id);
|
||||
}
|
||||
}
|
||||
Err(format!("Style '{style_name}' not found"))
|
||||
Err(format!("Style '{}' not found", style_name))
|
||||
}
|
||||
|
||||
pub fn create_named_style(&mut self, style_name: &str, style: &Style) -> Result<(), String> {
|
||||
@@ -221,6 +223,14 @@ impl Model {
|
||||
column: i32,
|
||||
style: &Style,
|
||||
) -> Result<(), String> {
|
||||
// Checking first whether cell we are updating is part of Merged cells
|
||||
// if so returning with Err
|
||||
if self.is_part_of_merged_cells(sheet, row, column)? {
|
||||
return Err(format!(
|
||||
"Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
|
||||
row, column
|
||||
));
|
||||
}
|
||||
let style_index = self.workbook.styles.get_style_index_or_create(style);
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
@@ -250,6 +260,14 @@ impl Model {
|
||||
column: i32,
|
||||
style_name: &str,
|
||||
) -> Result<(), String> {
|
||||
// Checking first whether cell we are updating is part of Merged cells
|
||||
// if so returning with Err
|
||||
if self.is_part_of_merged_cells(sheet, row, column)? {
|
||||
return Err(format!(
|
||||
"Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
|
||||
row, column
|
||||
));
|
||||
}
|
||||
let style_index = self.workbook.styles.get_style_index_by_name(style_name)?;
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
|
||||
@@ -7,36 +7,26 @@ mod test_column_width;
|
||||
mod test_criteria;
|
||||
mod test_currency;
|
||||
mod test_date_and_time;
|
||||
mod test_datedif_leap_month_end;
|
||||
mod test_days360_month_end;
|
||||
mod test_degrees_radians;
|
||||
mod test_error_propagation;
|
||||
mod test_fn_accrint;
|
||||
mod test_fn_accrintm;
|
||||
mod test_fn_average;
|
||||
mod test_fn_averageifs;
|
||||
mod test_fn_choose;
|
||||
mod test_fn_concatenate;
|
||||
mod test_fn_count;
|
||||
mod test_fn_coupon;
|
||||
mod test_fn_day;
|
||||
mod test_fn_duration;
|
||||
mod test_fn_exact;
|
||||
mod test_fn_financial;
|
||||
mod test_fn_financial_bonds;
|
||||
mod test_fn_formulatext;
|
||||
mod test_fn_if;
|
||||
mod test_fn_maxifs;
|
||||
mod test_fn_minifs;
|
||||
mod test_fn_or_xor;
|
||||
mod test_fn_product;
|
||||
mod test_fn_rept;
|
||||
mod test_fn_sum;
|
||||
mod test_fn_sumifs;
|
||||
mod test_fn_textbefore;
|
||||
mod test_fn_textjoin;
|
||||
mod test_fn_time;
|
||||
mod test_fn_unicode;
|
||||
mod test_forward_references;
|
||||
mod test_frozen_rows_columns;
|
||||
mod test_general;
|
||||
mod test_math;
|
||||
@@ -45,44 +35,27 @@ mod test_model_cell_clear_all;
|
||||
mod test_model_is_empty_cell;
|
||||
mod test_move_formula;
|
||||
mod test_quote_prefix;
|
||||
mod test_row_column_styles;
|
||||
mod test_set_user_input;
|
||||
mod test_sheet_markup;
|
||||
mod test_sheets;
|
||||
mod test_styles;
|
||||
mod test_trigonometric;
|
||||
mod test_true_false;
|
||||
mod test_weekday_return_types;
|
||||
mod test_weeknum_return_types;
|
||||
mod test_workbook;
|
||||
mod test_worksheet;
|
||||
mod test_yearfrac_basis;
|
||||
pub(crate) mod util;
|
||||
|
||||
mod engineering;
|
||||
mod test_fn_offset;
|
||||
mod test_number_format;
|
||||
|
||||
mod test_arrays;
|
||||
mod test_escape_quotes;
|
||||
mod test_extend;
|
||||
mod test_fn_fv;
|
||||
mod test_fn_round;
|
||||
mod test_fn_fvschedule;
|
||||
mod test_fn_type;
|
||||
mod test_frozen_rows_and_columns;
|
||||
mod test_geomean;
|
||||
mod test_get_cell_content;
|
||||
mod test_implicit_intersection;
|
||||
mod test_issue_155;
|
||||
mod test_issue_483;
|
||||
mod test_ln;
|
||||
mod test_log;
|
||||
mod test_log10;
|
||||
mod test_networkdays;
|
||||
mod test_model_merge_cell_fns;
|
||||
mod test_percentage;
|
||||
mod test_set_functions_error_handling;
|
||||
mod test_sheet_names;
|
||||
mod test_today;
|
||||
mod test_types;
|
||||
mod user_model;
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN, LAST_ROW};
|
||||
use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN};
|
||||
use crate::model::Model;
|
||||
use crate::test::util::new_empty_model;
|
||||
use crate::types::Col;
|
||||
@@ -508,10 +508,6 @@ fn test_move_column_right() {
|
||||
assert_eq!(model._get_formula("E5"), "=SUM(H3:J7)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM(H3:H7)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM(G3:G7)");
|
||||
|
||||
// Data moved as well
|
||||
assert_eq!(model._get_text("G1"), "1");
|
||||
assert_eq!(model._get_text("H1"), "3");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -536,249 +532,5 @@ fn tets_move_column_error() {
|
||||
assert!(result.is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_down() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Formulas referencing rows 3 and 4
|
||||
model._set("E3", "=G3");
|
||||
model._set("E4", "=G4");
|
||||
model._set("E5", "=SUM(G3:J3)");
|
||||
model._set("E6", "=SUM(G3:G3)");
|
||||
model._set("E7", "=SUM(G4:G4)");
|
||||
model.evaluate();
|
||||
|
||||
// Move row 3 down by one position
|
||||
let result = model.move_row_action(0, 3, 1);
|
||||
assert!(result.is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E3"), "=G3");
|
||||
assert_eq!(model._get_formula("E4"), "=G4");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM(G4:J4)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM(G4:G4)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM(G3:G3)");
|
||||
|
||||
// Data moved as well
|
||||
assert_eq!(model._get_text("G4"), "-2");
|
||||
assert_eq!(model._get_text("G3"), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_up() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Formulas referencing rows 4 and 5
|
||||
model._set("E4", "=G4");
|
||||
model._set("E5", "=G5");
|
||||
model._set("E6", "=SUM(G4:J4)");
|
||||
model._set("E7", "=SUM(G4:G4)");
|
||||
model._set("E8", "=SUM(G5:G5)");
|
||||
model.evaluate();
|
||||
|
||||
// Move row 5 up by one position
|
||||
let result = model.move_row_action(0, 5, -1);
|
||||
assert!(result.is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E4"), "=G4");
|
||||
assert_eq!(model._get_formula("E5"), "=G5");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM(G5:J5)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM(G5:G5)");
|
||||
assert_eq!(model._get_formula("E8"), "=SUM(G4:G4)");
|
||||
|
||||
// Data moved as well
|
||||
assert_eq!(model._get_text("G4"), "");
|
||||
assert_eq!(model._get_text("G5"), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_error() {
|
||||
let mut model = new_empty_model();
|
||||
model.evaluate();
|
||||
|
||||
let result = model.move_row_action(0, 7, -10);
|
||||
assert!(result.is_err());
|
||||
|
||||
let result = model.move_row_action(0, -7, 20);
|
||||
assert!(result.is_err());
|
||||
|
||||
let result = model.move_row_action(0, LAST_ROW, 1);
|
||||
assert!(result.is_err());
|
||||
|
||||
let result = model.move_row_action(0, LAST_ROW + 1, -10);
|
||||
assert!(result.is_err());
|
||||
|
||||
// This works
|
||||
let result = model.move_row_action(0, LAST_ROW, -1);
|
||||
assert!(result.is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_down_absolute_refs() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Absolute references
|
||||
model._set("E3", "=$G$3");
|
||||
model._set("E4", "=$G$4");
|
||||
model._set("E5", "=SUM($G$3:$J$3)");
|
||||
model._set("E6", "=SUM($G$3:$G$3)");
|
||||
model._set("E7", "=SUM($G$4:$G$4)");
|
||||
model.evaluate();
|
||||
|
||||
assert!(model.move_row_action(0, 3, 1).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E3"), "=$G$3");
|
||||
assert_eq!(model._get_formula("E4"), "=$G$4");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM($G$4:$J$4)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM($G$4:$G$4)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM($G$3:$G$3)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_column_right_absolute_refs() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Absolute references
|
||||
model._set("E3", "=$G$3");
|
||||
model._set("E4", "=$H$3");
|
||||
model._set("E5", "=SUM($G$3:$J$7)");
|
||||
model._set("E6", "=SUM($G$3:$G$7)");
|
||||
model._set("E7", "=SUM($H$3:$H$7)");
|
||||
model.evaluate();
|
||||
|
||||
assert!(model.move_column_action(0, 7, 1).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E3"), "=$H$3");
|
||||
assert_eq!(model._get_formula("E4"), "=$G$3");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM($H$3:$J$7)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM($H$3:$H$7)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM($G$3:$G$7)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_down_mixed_refs() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
model._set("E3", "=$G3"); // absolute col, relative row
|
||||
model._set("E4", "=$G4");
|
||||
model._set("E5", "=SUM($G3:$J3)");
|
||||
model._set("E6", "=SUM($G3:$G3)");
|
||||
model._set("E7", "=SUM($G4:$G4)");
|
||||
model._set("F3", "=H$3"); // relative col, absolute row
|
||||
model._set("F4", "=G$3");
|
||||
model.evaluate();
|
||||
|
||||
assert!(model.move_row_action(0, 3, 1).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E3"), "=$G3");
|
||||
assert_eq!(model._get_formula("E4"), "=$G4");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM($G4:$J4)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM($G4:$G4)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM($G3:$G3)");
|
||||
assert_eq!(model._get_formula("F3"), "=G$4");
|
||||
assert_eq!(model._get_formula("F4"), "=H$4");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_column_right_mixed_refs() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
model._set("E3", "=$G3");
|
||||
model._set("E4", "=$H3");
|
||||
model._set("E5", "=SUM($G3:$J7)");
|
||||
model._set("E6", "=SUM($G3:$G7)");
|
||||
model._set("E7", "=SUM($H3:$H7)");
|
||||
model._set("F3", "=H$3");
|
||||
model._set("F4", "=H$3");
|
||||
model.evaluate();
|
||||
|
||||
assert!(model.move_column_action(0, 7, 1).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E3"), "=$H3");
|
||||
assert_eq!(model._get_formula("E4"), "=$G3");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM($H3:$J7)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM($H3:$H7)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM($G3:$G7)");
|
||||
assert_eq!(model._get_formula("F3"), "=G$3");
|
||||
assert_eq!(model._get_formula("F4"), "=G$3");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_height() {
|
||||
let mut model = new_empty_model();
|
||||
let sheet = 0;
|
||||
let custom_height = DEFAULT_ROW_HEIGHT * 2.0;
|
||||
// Set a custom height for row 3
|
||||
model
|
||||
.workbook
|
||||
.worksheet_mut(sheet)
|
||||
.unwrap()
|
||||
.set_row_height(3, custom_height)
|
||||
.unwrap();
|
||||
|
||||
// Record the original height of row 4 (should be the default)
|
||||
let original_row4_height = model.get_row_height(sheet, 4).unwrap();
|
||||
|
||||
// Move row 3 down by one position
|
||||
assert!(model.move_row_action(sheet, 3, 1).is_ok());
|
||||
|
||||
// The custom height should now be on row 4
|
||||
assert_eq!(model.get_row_height(sheet, 4), Ok(custom_height));
|
||||
|
||||
// Row 3 should now have the previous height of row 4
|
||||
assert_eq!(model.get_row_height(sheet, 3), Ok(original_row4_height));
|
||||
}
|
||||
|
||||
/// Moving a row down by two positions should shift formulas on intermediate
|
||||
/// rows by only one (the row that gets skipped), not by the full delta ‒ this
|
||||
/// guards against the regression fixed in the RowMove displacement logic.
|
||||
#[test]
|
||||
fn test_row_move_down_two_updates_intermediate_refs_by_one() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Set up formulas to verify intermediate rows shift by 1 (not full delta).
|
||||
model._set("E3", "=G3"); // target row
|
||||
model._set("E4", "=G4"); // intermediate row
|
||||
model._set("E5", "=SUM(G3:J3)");
|
||||
model.evaluate();
|
||||
|
||||
// Move row 3 down by two positions (row 3 -> row 5)
|
||||
assert!(model.move_row_action(0, 3, 2).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
// Assert that references for the moved row and intermediate row are correct.
|
||||
assert_eq!(model._get_formula("E3"), "=G3");
|
||||
assert_eq!(model._get_formula("E5"), "=G5");
|
||||
assert_eq!(model._get_formula("E4"), "=SUM(G5:J5)");
|
||||
}
|
||||
|
||||
/// Moving a column right by two positions should shift formulas on
|
||||
/// intermediate columns by only one, ensuring the ColumnMove displacement
|
||||
/// logic handles multi-position moves correctly.
|
||||
#[test]
|
||||
fn test_column_move_right_two_updates_intermediate_refs_by_one() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Set up formulas to verify intermediate columns shift by 1 (not full delta).
|
||||
model._set("E3", "=$G3"); // target column
|
||||
model._set("E4", "=$H3"); // intermediate column
|
||||
model._set("E5", "=SUM($G3:$J7)");
|
||||
model.evaluate();
|
||||
|
||||
// Move column G (7) right by two positions (G -> I)
|
||||
assert!(model.move_column_action(0, 7, 2).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
// Assert that references for moved and intermediate columns are correct.
|
||||
assert_eq!(model._get_formula("E3"), "=$I3");
|
||||
assert_eq!(model._get_formula("E4"), "=$G3");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM($I3:$J7)");
|
||||
}
|
||||
|
||||
// A B C D E F G H I J K L M N O P Q R
|
||||
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
|
||||
|
||||
@@ -1,13 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn sum_arrays() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=SUM({1,2,3}+{3,4,5})");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"18");
|
||||
}
|
||||
@@ -82,21 +82,3 @@ fn test_column_width_higher_edge() {
|
||||
assert!((worksheet.get_column_width(17).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
|
||||
assert_eq!(model.get_cell_style_index(0, 23, 16), Ok(1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_column_width_negative() {
|
||||
let mut model = new_empty_model();
|
||||
let result = model
|
||||
.workbook
|
||||
.worksheet_mut(0)
|
||||
.unwrap()
|
||||
.set_column_width(16, -1.0);
|
||||
assert_eq!(result, Err("Can not set a negative width: -1".to_string()));
|
||||
assert_eq!(model.workbook.worksheets[0].cols.len(), 0);
|
||||
let worksheet = model.workbook.worksheet(0).unwrap();
|
||||
assert_eq!(
|
||||
(worksheet.get_column_width(16).unwrap()),
|
||||
DEFAULT_COLUMN_WIDTH
|
||||
);
|
||||
assert_eq!(model.get_cell_style_index(0, 23, 16), Ok(0));
|
||||
}
|
||||
|
||||
@@ -6,11 +6,6 @@
|
||||
/// We can also enter examples that illustrate/document a part of the function
|
||||
use crate::{cell::CellValue, test::util::new_empty_model};
|
||||
|
||||
// Excel uses a serial date system where Jan 1, 1900 = 1 (though it treats 1900 as a leap year)
|
||||
// Most test dates are documented inline, but we define boundary values here:
|
||||
const EXCEL_MAX_DATE: f64 = 2958465.0; // Dec 31, 9999 - used in boundary tests
|
||||
const EXCEL_INVALID_DATE: f64 = 2958466.0; // One day past max - used in error tests
|
||||
|
||||
#[test]
|
||||
fn test_fn_date_arguments() {
|
||||
let mut model = new_empty_model();
|
||||
@@ -42,12 +37,12 @@ fn test_fn_date_arguments() {
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
|
||||
assert_eq!(model._get_text("A5"), *"10/10/1974");
|
||||
assert_eq!(model._get_text("A6"), *"21/01/1975");
|
||||
assert_eq!(model._get_text("A7"), *"10/02/1976");
|
||||
assert_eq!(model._get_text("A8"), *"02/03/1975");
|
||||
assert_eq!(model._get_text("A5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A6"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A7"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A8"), *"#NUM!");
|
||||
|
||||
assert_eq!(model._get_text("A9"), *"01/03/1975");
|
||||
assert_eq!(model._get_text("A9"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A10"), *"29/02/1976");
|
||||
assert_eq!(
|
||||
model.get_cell_value_by_ref("Sheet1!A10"),
|
||||
@@ -69,18 +64,15 @@ fn test_date_out_of_range() {
|
||||
|
||||
// year (actually years < 1900 don't really make sense)
|
||||
model._set("C1", "=DATE(-1, 5, 5)");
|
||||
// excel is not compatible with years past 9999
|
||||
model._set("C2", "=DATE(10000, 5, 5)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"10/12/2021");
|
||||
assert_eq!(model._get_text("A2"), *"10/01/2023");
|
||||
assert_eq!(model._get_text("B1"), *"30/04/2042");
|
||||
assert_eq!(model._get_text("B2"), *"01/06/2025");
|
||||
assert_eq!(model._get_text("A1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B2"), *"#NUM!");
|
||||
|
||||
assert_eq!(model._get_text("C1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("C2"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -137,7 +129,8 @@ fn test_day_small_serial() {
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A2"), *"#NUM!");
|
||||
// This agrees with Google Docs and disagrees with Excel
|
||||
assert_eq!(model._get_text("A2"), *"30");
|
||||
// Excel thinks is Feb 29, 1900
|
||||
assert_eq!(model._get_text("A3"), *"28");
|
||||
|
||||
@@ -157,7 +150,8 @@ fn test_month_small_serial() {
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A2"), *"#NUM!");
|
||||
// This agrees with Google Docs and disagrees with Excel
|
||||
assert_eq!(model._get_text("A2"), *"12");
|
||||
// We agree with Excel here (We are both in Feb)
|
||||
assert_eq!(model._get_text("A3"), *"2");
|
||||
|
||||
@@ -177,7 +171,8 @@ fn test_year_small_serial() {
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A2"), *"#NUM!");
|
||||
// This agrees with Google Docs and disagrees with Excel
|
||||
assert_eq!(model._get_text("A2"), *"1899");
|
||||
|
||||
assert_eq!(model._get_text("A3"), *"1900");
|
||||
|
||||
@@ -209,10 +204,7 @@ fn test_date_early_dates() {
|
||||
model.get_cell_value_by_ref("Sheet1!A2"),
|
||||
Ok(CellValue::Number(60.0))
|
||||
);
|
||||
|
||||
// This does not agree with Excel, instead of mistakenly allowing
|
||||
// for Feb 29, it will auto-wrap to the next day after Feb 28.
|
||||
assert_eq!(model._get_text("B2"), *"01/03/1900");
|
||||
assert_eq!(model._get_text("B2"), *"#NUM!");
|
||||
|
||||
// This agrees with Excel from he onward
|
||||
assert_eq!(model._get_text("A3"), *"01/03/1900");
|
||||
@@ -221,382 +213,3 @@ fn test_date_early_dates() {
|
||||
Ok(CellValue::Number(61.0))
|
||||
);
|
||||
}
|
||||
#[test]
|
||||
fn test_days_function() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Basic functionality
|
||||
model._set("A1", "=DAYS(44570,44561)");
|
||||
model._set("A2", "=DAYS(44561,44570)"); // Reversed order
|
||||
model._set("A3", "=DAYS(44561,44561)");
|
||||
|
||||
// Edge cases
|
||||
model._set("A4", "=DAYS(1,2)"); // Early dates
|
||||
model._set(
|
||||
"A5",
|
||||
&format!("=DAYS({},{})", EXCEL_MAX_DATE, EXCEL_MAX_DATE - 1.0),
|
||||
); // Near max date
|
||||
|
||||
// Error cases - wrong argument count
|
||||
model._set("A6", "=DAYS()");
|
||||
model._set("A7", "=DAYS(44561)");
|
||||
model._set("A8", "=DAYS(44561,44570,1)");
|
||||
|
||||
// Error cases - invalid dates
|
||||
model._set("A9", "=DAYS(-1,44561)");
|
||||
model._set("A10", &format!("=DAYS(44561,{EXCEL_INVALID_DATE})"));
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"9");
|
||||
assert_eq!(model._get_text("A2"), *"-9");
|
||||
assert_eq!(model._get_text("A3"), *"0");
|
||||
assert_eq!(model._get_text("A4"), *"-1"); // DAYS(1,2) = 1-2 = -1
|
||||
assert_eq!(model._get_text("A5"), *"1");
|
||||
assert_eq!(model._get_text("A6"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A7"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A8"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A9"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A10"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_days360_function() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Basic functionality with different basis values
|
||||
model._set("A1", "=DAYS360(44196,44560)"); // Default basis (US 30/360)
|
||||
model._set("A2", "=DAYS360(44196,44560,FALSE)"); // US 30/360 explicitly
|
||||
model._set("A3", "=DAYS360(44196,44560,TRUE)"); // European 30/360
|
||||
|
||||
// Same date
|
||||
model._set("A4", "=DAYS360(44561,44561)");
|
||||
model._set("A5", "=DAYS360(44561,44561,TRUE)");
|
||||
|
||||
// Reverse order (negative result)
|
||||
model._set("A6", "=DAYS360(44560,44196)");
|
||||
model._set("A7", "=DAYS360(44560,44196,TRUE)");
|
||||
|
||||
// Edge cases
|
||||
model._set("A8", "=DAYS360(1,2)");
|
||||
model._set("A9", "=DAYS360(1,2,FALSE)");
|
||||
|
||||
// Error cases - wrong argument count
|
||||
model._set("A10", "=DAYS360()");
|
||||
model._set("A11", "=DAYS360(44561)");
|
||||
model._set("A12", "=DAYS360(44561,44570,TRUE,1)");
|
||||
|
||||
// Error cases - invalid dates
|
||||
model._set("A13", "=DAYS360(-1,44561)");
|
||||
model._set("A14", &format!("=DAYS360(44561,{EXCEL_INVALID_DATE})"));
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"360");
|
||||
assert_eq!(model._get_text("A2"), *"360");
|
||||
assert_eq!(model._get_text("A3"), *"360");
|
||||
assert_eq!(model._get_text("A4"), *"0");
|
||||
assert_eq!(model._get_text("A5"), *"0");
|
||||
assert_eq!(model._get_text("A6"), *"-360");
|
||||
assert_eq!(model._get_text("A7"), *"-360");
|
||||
assert_eq!(model._get_text("A8"), *"1");
|
||||
assert_eq!(model._get_text("A9"), *"1");
|
||||
assert_eq!(model._get_text("A10"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A11"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A12"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A13"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A14"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_weekday_function() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Test return_type parameter variations with one known date (Friday 44561)
|
||||
model._set("A1", "=WEEKDAY(44561)"); // Default: Sun=1, Fri=6
|
||||
model._set("A2", "=WEEKDAY(44561,2)"); // Mon=1, Fri=5
|
||||
model._set("A3", "=WEEKDAY(44561,3)"); // Mon=0, Fri=4
|
||||
|
||||
// Test boundary days (Sun/Mon) to verify return_type logic
|
||||
model._set("A4", "=WEEKDAY(44556,1)"); // Sunday: should be 1
|
||||
model._set("A5", "=WEEKDAY(44556,2)"); // Sunday: should be 7
|
||||
model._set("A6", "=WEEKDAY(44557,2)"); // Monday: should be 1
|
||||
|
||||
// Error cases
|
||||
model._set("A7", "=WEEKDAY()"); // Wrong arg count
|
||||
model._set("A8", "=WEEKDAY(44561,0)"); // Invalid return_type
|
||||
model._set("A9", "=WEEKDAY(-1)"); // Invalid date
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Core functionality
|
||||
assert_eq!(model._get_text("A1"), *"6"); // Friday default
|
||||
assert_eq!(model._get_text("A2"), *"5"); // Friday Mon=1
|
||||
assert_eq!(model._get_text("A3"), *"4"); // Friday Mon=0
|
||||
|
||||
// Boundary verification
|
||||
assert_eq!(model._get_text("A4"), *"1"); // Sunday Sun=1
|
||||
assert_eq!(model._get_text("A5"), *"7"); // Sunday Mon=1
|
||||
assert_eq!(model._get_text("A6"), *"1"); // Monday Mon=1
|
||||
|
||||
// Error cases
|
||||
assert_eq!(model._get_text("A7"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A8"), *"#VALUE!");
|
||||
assert_eq!(model._get_text("A9"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_weeknum_function() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Test different return_type values (1=week starts Sunday, 2=week starts Monday)
|
||||
model._set("A1", "=WEEKNUM(44561)"); // Default return_type=1
|
||||
model._set("A2", "=WEEKNUM(44561,1)"); // Sunday start
|
||||
model._set("A3", "=WEEKNUM(44561,2)"); // Monday start
|
||||
|
||||
// Test year boundaries
|
||||
model._set("A4", "=WEEKNUM(43831,1)"); // Jan 1, 2020 (Wednesday)
|
||||
model._set("A5", "=WEEKNUM(43831,2)"); // Jan 1, 2020 (Wednesday)
|
||||
model._set("A6", "=WEEKNUM(44196,1)"); // Dec 31, 2020 (Thursday)
|
||||
model._set("A7", "=WEEKNUM(44196,2)"); // Dec 31, 2020 (Thursday)
|
||||
|
||||
// Test first and last weeks of year
|
||||
model._set("A8", "=WEEKNUM(44197,1)"); // Jan 1, 2021 (Friday)
|
||||
model._set("A9", "=WEEKNUM(44197,2)"); // Jan 1, 2021 (Friday)
|
||||
model._set("A10", "=WEEKNUM(44561,1)"); // Dec 31, 2021 (Friday)
|
||||
model._set("A11", "=WEEKNUM(44561,2)"); // Dec 31, 2021 (Friday)
|
||||
|
||||
// Error cases - wrong argument count
|
||||
model._set("A12", "=WEEKNUM()");
|
||||
model._set("A13", "=WEEKNUM(44561,1,1)");
|
||||
|
||||
// Error cases - invalid return_type
|
||||
model._set("A14", "=WEEKNUM(44561,0)");
|
||||
model._set("A15", "=WEEKNUM(44561,3)");
|
||||
model._set("A16", "=WEEKNUM(44561,-1)");
|
||||
|
||||
// Error cases - invalid dates
|
||||
model._set("A17", "=WEEKNUM(-1)");
|
||||
model._set("A18", &format!("=WEEKNUM({EXCEL_INVALID_DATE})"));
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Basic functionality
|
||||
assert_eq!(model._get_text("A1"), *"53"); // Week 53
|
||||
assert_eq!(model._get_text("A2"), *"53"); // Week 53 (Sunday start)
|
||||
assert_eq!(model._get_text("A3"), *"53"); // Week 53 (Monday start)
|
||||
|
||||
// Year boundary tests
|
||||
assert_eq!(model._get_text("A4"), *"1"); // Jan 1, 2020 (Sunday start)
|
||||
assert_eq!(model._get_text("A5"), *"1"); // Jan 1, 2020 (Monday start)
|
||||
assert_eq!(model._get_text("A6"), *"53"); // Dec 31, 2020 (Sunday start)
|
||||
assert_eq!(model._get_text("A7"), *"53"); // Dec 31, 2020 (Monday start)
|
||||
|
||||
// 2021 tests
|
||||
assert_eq!(model._get_text("A8"), *"1"); // Jan 1, 2021 (Sunday start)
|
||||
assert_eq!(model._get_text("A9"), *"1"); // Jan 1, 2021 (Monday start)
|
||||
assert_eq!(model._get_text("A10"), *"53"); // Dec 31, 2021 (Sunday start)
|
||||
assert_eq!(model._get_text("A11"), *"53"); // Dec 31, 2021 (Monday start)
|
||||
|
||||
// Error cases
|
||||
assert_eq!(model._get_text("A12"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A13"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A14"), *"#VALUE!");
|
||||
assert_eq!(model._get_text("A15"), *"#VALUE!");
|
||||
assert_eq!(model._get_text("A16"), *"#VALUE!");
|
||||
assert_eq!(model._get_text("A17"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A18"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_workday_function() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Basic functionality
|
||||
model._set("A1", "=WORKDAY(44560,1)");
|
||||
model._set("A2", "=WORKDAY(44561,-1)");
|
||||
model._set("A3", "=WORKDAY(44561,0)");
|
||||
model._set("A4", "=WORKDAY(44560,5)");
|
||||
|
||||
// Test with holidays
|
||||
model._set("B1", "44561");
|
||||
model._set("A5", "=WORKDAY(44560,1,B1)"); // Should skip the holiday
|
||||
model._set("B2", "44562");
|
||||
model._set("B3", "44563");
|
||||
model._set("A6", "=WORKDAY(44560,3,B1:B3)"); // Multiple holidays
|
||||
|
||||
// Test starting on weekend
|
||||
model._set("A7", "=WORKDAY(44562,1)"); // Saturday start
|
||||
model._set("A8", "=WORKDAY(44563,1)"); // Sunday start
|
||||
|
||||
// Test negative workdays
|
||||
model._set("A9", "=WORKDAY(44565,-3)"); // Go backwards 3 days
|
||||
model._set("A10", "=WORKDAY(44565,-5,B1:B3)"); // Backwards with holidays
|
||||
|
||||
// Edge cases
|
||||
model._set("A11", "=WORKDAY(1,1)"); // Early date
|
||||
model._set("A12", "=WORKDAY(100000,10)"); // Large numbers
|
||||
|
||||
// Error cases - wrong argument count
|
||||
model._set("A13", "=WORKDAY()");
|
||||
model._set("A14", "=WORKDAY(44560)");
|
||||
model._set("A15", "=WORKDAY(44560,1,B1,B2)");
|
||||
|
||||
// Error cases - invalid dates
|
||||
model._set("A16", "=WORKDAY(-1,1)");
|
||||
model._set("A17", &format!("=WORKDAY({EXCEL_INVALID_DATE},1)"));
|
||||
|
||||
// Error cases - invalid holiday dates
|
||||
model._set("B4", "-1");
|
||||
model._set("A18", "=WORKDAY(44560,1,B4)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Basic functionality
|
||||
assert_eq!(model._get_text("A1"), *"44561"); // 1 day forward
|
||||
assert_eq!(model._get_text("A2"), *"44560"); // 1 day backward
|
||||
assert_eq!(model._get_text("A3"), *"44561"); // 0 days
|
||||
assert_eq!(model._get_text("A4"), *"44567"); // 5 days forward
|
||||
|
||||
// With holidays
|
||||
assert_eq!(model._get_text("A5"), *"44564"); // Skip holiday, go to Monday
|
||||
assert_eq!(model._get_text("A6"), *"44566"); // Skip multiple holidays
|
||||
|
||||
// Weekend starts
|
||||
assert_eq!(model._get_text("A7"), *"44564"); // From Saturday
|
||||
assert_eq!(model._get_text("A8"), *"44564"); // From Sunday
|
||||
|
||||
// Negative workdays
|
||||
assert_eq!(model._get_text("A9"), *"44560"); // 3 days back
|
||||
assert_eq!(model._get_text("A10"), *"44557"); // 5 days back with holidays
|
||||
|
||||
// Edge cases
|
||||
assert_eq!(model._get_text("A11"), *"2"); // Early date
|
||||
assert_eq!(model._get_text("A12"), *"100014"); // Large numbers
|
||||
|
||||
// Error cases
|
||||
assert_eq!(model._get_text("A13"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A14"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A15"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A16"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A17"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A18"), *"#NUM!"); // Invalid holiday
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_workday_intl_function() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Test key weekend mask types
|
||||
model._set("A1", "=WORKDAY.INTL(44560,1,1)"); // Numeric: standard (Sat-Sun)
|
||||
model._set("A2", "=WORKDAY.INTL(44560,1,2)"); // Numeric: Sun-Mon
|
||||
model._set("A3", "=WORKDAY.INTL(44560,1,\"0000001\")"); // String: Sunday only
|
||||
model._set("A4", "=WORKDAY.INTL(44560,1,\"1100000\")"); // String: Mon-Tue
|
||||
|
||||
// Test with holidays
|
||||
model._set("B1", "44561");
|
||||
model._set("A5", "=WORKDAY.INTL(44560,2,1,B1)"); // Standard + holiday
|
||||
model._set("A6", "=WORKDAY.INTL(44560,2,7,B1)"); // Fri-Sat + holiday
|
||||
|
||||
// Basic edge cases
|
||||
model._set("A7", "=WORKDAY.INTL(44561,0,1)"); // Zero days
|
||||
model._set("A8", "=WORKDAY.INTL(44565,-1,1)"); // Negative days
|
||||
|
||||
// Error cases
|
||||
model._set("A9", "=WORKDAY.INTL()"); // Wrong arg count
|
||||
model._set("A10", "=WORKDAY.INTL(44560,1,0)"); // Invalid weekend mask
|
||||
model._set("A11", "=WORKDAY.INTL(44560,1,\"123\")"); // Invalid string mask
|
||||
model._set("A12", "=WORKDAY.INTL(-1,1,1)"); // Invalid date
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Weekend mask functionality
|
||||
assert_eq!(model._get_text("A1"), *"44561"); // Standard weekend
|
||||
assert_eq!(model._get_text("A2"), *"44561"); // Sun-Mon weekend
|
||||
assert_eq!(model._get_text("A3"), *"44561"); // Sunday only
|
||||
assert_eq!(model._get_text("A4"), *"44561"); // Mon-Tue weekend
|
||||
|
||||
// With holidays
|
||||
assert_eq!(model._get_text("A5"), *"44565"); // Skip holiday + standard weekend
|
||||
assert_eq!(model._get_text("A6"), *"44564"); // Skip holiday + Fri-Sat weekend
|
||||
|
||||
// Edge cases
|
||||
assert_eq!(model._get_text("A7"), *"44561"); // Zero days
|
||||
assert_eq!(model._get_text("A8"), *"44564"); // Negative days
|
||||
|
||||
// Error cases
|
||||
assert_eq!(model._get_text("A9"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A10"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A11"), *"#VALUE!");
|
||||
assert_eq!(model._get_text("A12"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_yearfrac_function() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Test key basis values (not exhaustive - just verify parameter works)
|
||||
model._set("A1", "=YEARFRAC(44561,44926)"); // Default (30/360)
|
||||
model._set("A2", "=YEARFRAC(44561,44926,1)"); // Actual/actual
|
||||
model._set("A3", "=YEARFRAC(44561,44926,4)"); // European 30/360
|
||||
|
||||
// Edge cases
|
||||
model._set("A4", "=YEARFRAC(44561,44561,1)"); // Same date = 0
|
||||
model._set("A5", "=YEARFRAC(44926,44561,1)"); // Reverse = negative
|
||||
model._set("A6", "=YEARFRAC(44197,44562,1)"); // Exact year (2021)
|
||||
|
||||
// Error cases
|
||||
model._set("A7", "=YEARFRAC()"); // Wrong arg count
|
||||
model._set("A8", "=YEARFRAC(44561,44926,5)"); // Invalid basis
|
||||
model._set("A9", "=YEARFRAC(-1,44926,1)"); // Invalid date
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Basic functionality (approximate values expected)
|
||||
assert_eq!(model._get_text("A1"), *"1"); // About 1 year
|
||||
assert_eq!(model._get_text("A2"), *"1"); // About 1 year
|
||||
assert_eq!(model._get_text("A3"), *"1"); // About 1 year
|
||||
|
||||
// Edge cases
|
||||
assert_eq!(model._get_text("A4"), *"0"); // Same date
|
||||
assert_eq!(model._get_text("A5"), *"-1"); // Negative
|
||||
assert_eq!(model._get_text("A6"), *"1"); // Exact year
|
||||
|
||||
// Error cases
|
||||
assert_eq!(model._get_text("A7"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A8"), *"#NUM!"); // Invalid basis should return #NUM!
|
||||
assert_eq!(model._get_text("A9"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_isoweeknum_function() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Basic functionality
|
||||
model._set("A1", "=ISOWEEKNUM(44563)"); // Mid-week date
|
||||
model._set("A2", "=ISOWEEKNUM(44561)"); // Year-end date
|
||||
|
||||
// Key ISO week boundaries (just critical cases)
|
||||
model._set("A3", "=ISOWEEKNUM(44197)"); // Jan 1, 2021 (Fri) -> Week 53 of 2020
|
||||
model._set("A4", "=ISOWEEKNUM(44200)"); // Jan 4, 2021 (Mon) -> Week 1 of 2021
|
||||
model._set("A5", "=ISOWEEKNUM(44564)"); // Jan 3, 2022 (Mon) -> Week 1 of 2022
|
||||
|
||||
// Error cases
|
||||
model._set("A6", "=ISOWEEKNUM()"); // Wrong arg count
|
||||
model._set("A7", "=ISOWEEKNUM(-1)"); // Invalid date
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Basic functionality
|
||||
assert_eq!(model._get_text("A1"), *"52");
|
||||
assert_eq!(model._get_text("A2"), *"52");
|
||||
|
||||
// ISO week boundaries
|
||||
assert_eq!(model._get_text("A3"), *"53"); // Week 53 of previous year
|
||||
assert_eq!(model._get_text("A4"), *"1"); // Week 1 of current year
|
||||
assert_eq!(model._get_text("A5"), *"1"); // Week 1 of next year
|
||||
|
||||
// Error cases
|
||||
assert_eq!(model._get_text("A6"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A7"), *"#NUM!");
|
||||
}
|
||||
|
||||
@@ -1,33 +0,0 @@
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_datedif_yd_leap_year_edge_cases() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// 29 Feb 2020 → 28 Feb 2021 (should be 0 days)
|
||||
model._set("A1", "=DATEDIF(\"29/2/2020\", \"28/2/2021\", \"YD\")");
|
||||
|
||||
// 29 Feb 2020 → 1 Mar 2021 (should be 1 day)
|
||||
model._set("A2", "=DATEDIF(\"29/2/2020\", \"2021-03-01\", \"YD\")");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0");
|
||||
assert_eq!(model._get_text("A2"), *"1");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datedif_md_month_end_edge_cases() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// 31 Jan 2021 → 28 Feb 2021 (non-leap) => 28
|
||||
model._set("B1", "=DATEDIF(\"31/1/2021\", \"28/2/2021\", \"MD\")");
|
||||
|
||||
// 31 Jan 2020 → 29 Feb 2020 (leap) => 29
|
||||
model._set("B2", "=DATEDIF(\"31/1/2020\", \"29/2/2020\", \"MD\")");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"28");
|
||||
assert_eq!(model._get_text("B2"), *"29");
|
||||
}
|
||||
@@ -1,43 +0,0 @@
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_days360_month_end_us() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// 31 Jan 2021 -> 28 Feb 2021 (non-leap)
|
||||
model._set("A1", "=DAYS360(DATE(2021,1,31),DATE(2021,2,28))");
|
||||
|
||||
// 31 Jan 2020 -> 28 Feb 2020 (leap year – not last day of Feb)
|
||||
model._set("A2", "=DAYS360(DATE(2020,1,31),DATE(2020,2,28))");
|
||||
|
||||
// 28 Feb 2020 -> 31 Mar 2020 (leap year span crossing month ends)
|
||||
model._set("A3", "=DAYS360(DATE(2020,2,28),DATE(2020,3,31))");
|
||||
|
||||
// 30 Apr 2021 -> 31 May 2021 (end-of-month adjustment rule)
|
||||
model._set("A4", "=DAYS360(DATE(2021,4,30),DATE(2021,5,31))");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"30");
|
||||
assert_eq!(model._get_text("A2"), *"28");
|
||||
assert_eq!(model._get_text("A3"), *"33");
|
||||
assert_eq!(model._get_text("A4"), *"30");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_days360_month_end_european() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// European basis = TRUE (or 1)
|
||||
model._set("B1", "=DAYS360(DATE(2021,1,31),DATE(2021,2,28),TRUE)");
|
||||
|
||||
model._set("B2", "=DAYS360(DATE(2020,1,31),DATE(2020,2,29),TRUE)");
|
||||
|
||||
model._set("B3", "=DAYS360(DATE(2021,8,31),DATE(2021,9,30),TRUE)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"28");
|
||||
assert_eq!(model._get_text("B2"), *"29");
|
||||
assert_eq!(model._get_text("B3"), *"30");
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn fn_degrees_radians_arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DEGREES()");
|
||||
model._set("A2", "=RADIANS()");
|
||||
model._set("A3", "=RADIANS(180)");
|
||||
model._set("A4", "=RADIANS(180, 2)");
|
||||
model._set("A5", "=DEGREES(RADIANS(180))");
|
||||
model._set("A6", "=DEGREES(1, 2)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"3.141592654");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A5"), *"180");
|
||||
assert_eq!(model._get_text("A6"), *"#ERROR!");
|
||||
}
|
||||
@@ -1,134 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{cell::CellValue, test::util::new_empty_model};
|
||||
|
||||
#[test]
|
||||
fn fn_accrint() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2020,1,1)");
|
||||
model._set("A2", "=DATE(2020,1,1)");
|
||||
model._set("A3", "=DATE(2020,1,31)");
|
||||
model._set("A4", "10%");
|
||||
model._set("A5", "$1,000");
|
||||
model._set("A6", "2");
|
||||
|
||||
model._set("B1", "=ACCRINT(A1,A2,A3,A4,A5,A6)");
|
||||
model._set("C1", "=ACCRINT(A1)");
|
||||
model._set("C2", "=ACCRINT(A1,A2,A3,A4,A5,3)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
match model.get_cell_value_by_ref("Sheet1!B1") {
|
||||
Ok(CellValue::Number(v)) => {
|
||||
assert!((v - 8.333333333333334).abs() < 1e-9);
|
||||
}
|
||||
other => unreachable!("Expected number for B1, got {:?}", other),
|
||||
}
|
||||
assert_eq!(model._get_text("C1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("C2"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_accrint_parameters() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", "=DATE(2020,1,1)");
|
||||
model._set("A2", "=DATE(2020,1,1)");
|
||||
model._set("A3", "=DATE(2020,7,1)");
|
||||
model._set("A4", "8%");
|
||||
model._set("A5", "1000");
|
||||
|
||||
model._set("B1", "=ACCRINT(A1,A2,A3,A4,A5,2,0,TRUE)");
|
||||
model._set("B2", "=ACCRINT(A1,A2,A3,A4,A5,2,1,TRUE)");
|
||||
model._set("B3", "=ACCRINT(A1,A2,A3,A4,A5,2,4,TRUE)");
|
||||
model._set("B4", "=ACCRINT(A1,A2,A3,A4,A5,1)");
|
||||
model._set("B5", "=ACCRINT(A1,A2,A3,A4,A5,4)");
|
||||
model._set("B6", "=ACCRINT(A1,A2,A3,A4,A5,2)");
|
||||
model._set("B7", "=ACCRINT(A1,A2,A3,A4,A5,2,0)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
match model.get_cell_value_by_ref("Sheet1!B1") {
|
||||
Ok(CellValue::Number(v)) => {
|
||||
assert!((v - 40.0).abs() < 1e-9);
|
||||
}
|
||||
other => unreachable!("Expected number for B1, got {:?}", other),
|
||||
}
|
||||
|
||||
match (
|
||||
model.get_cell_value_by_ref("Sheet1!B1"),
|
||||
model.get_cell_value_by_ref("Sheet1!B6"),
|
||||
) {
|
||||
(Ok(CellValue::Number(v1)), Ok(CellValue::Number(v2))) => {
|
||||
assert!((v1 - v2).abs() < 1e-12);
|
||||
}
|
||||
other => unreachable!("Expected matching numbers, got {:?}", other),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_accrint_errors() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", "=DATE(2020,1,1)");
|
||||
model._set("A2", "=DATE(2020,1,1)");
|
||||
model._set("A3", "=DATE(2020,7,1)");
|
||||
model._set("A4", "8%");
|
||||
model._set("A5", "1000");
|
||||
|
||||
model._set("B1", "=ACCRINT()");
|
||||
model._set("B2", "=ACCRINT(A1,A2,A3,A4,A5)");
|
||||
model._set("B3", "=ACCRINT(A1,A2,A3,A4,A5,2,0,TRUE,1)");
|
||||
model._set("C1", "=ACCRINT(A1,A2,A3,A4,A5,0)");
|
||||
model._set("C2", "=ACCRINT(A1,A2,A3,A4,A5,3)");
|
||||
model._set("C3", "=ACCRINT(A1,A2,A3,A4,A5,-1)");
|
||||
model._set("D1", "=ACCRINT(A1,A2,A3,A4,A5,2,-1)");
|
||||
model._set("D2", "=ACCRINT(A1,A2,A3,A4,A5,2,5)");
|
||||
model._set("E1", "=ACCRINT(A3,A2,A1,A4,A5,2)");
|
||||
model._set("E2", "=ACCRINT(A1,A3,A1,A4,A5,2)");
|
||||
model._set("F1", "=ACCRINT(A1,A2,A3,A4,0,2)");
|
||||
model._set("F2", "=ACCRINT(A1,A2,A3,A4,-1000,2)");
|
||||
model._set("F3", "=ACCRINT(A1,A2,A3,-8%,A5,2)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("B2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("B3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("C1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("C2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("C3"), *"#NUM!");
|
||||
assert_eq!(model._get_text("D1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("D2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("E1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("E2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("F2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("F3"), *"#NUM!");
|
||||
|
||||
match model.get_cell_value_by_ref("Sheet1!F1") {
|
||||
Ok(CellValue::Number(v)) => {
|
||||
assert!((v - 0.0).abs() < 1e-9);
|
||||
}
|
||||
other => unreachable!("Expected 0 for F1, got {:?}", other),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_accrint_combined() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2018,10,15)");
|
||||
model._set("A2", "=DATE(2019,2,1)");
|
||||
model._set("A3", "5%");
|
||||
model._set("A4", "1000");
|
||||
|
||||
model._set("B1", "=ACCRINT(A1,A1,A2,A3,A4,2)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
match model.get_cell_value_by_ref("Sheet1!B1") {
|
||||
Ok(CellValue::Number(v)) => {
|
||||
assert!((v - 14.722222222222221).abs() < 1e-9);
|
||||
}
|
||||
other => unreachable!("Expected number for B1, got {:?}", other),
|
||||
}
|
||||
}
|
||||
@@ -1,122 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{cell::CellValue, test::util::new_empty_model};
|
||||
|
||||
#[test]
|
||||
fn fn_accrintm() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2020,1,1)");
|
||||
model._set("A2", "=DATE(2020,7,1)");
|
||||
model._set("A3", "10%");
|
||||
model._set("A4", "$1,000");
|
||||
|
||||
model._set("B1", "=ACCRINTM(A1,A2,A3,A4)");
|
||||
model._set("C1", "=ACCRINTM(A1)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
match model.get_cell_value_by_ref("Sheet1!B1") {
|
||||
Ok(CellValue::Number(v)) => {
|
||||
assert!((v - 50.0).abs() < 1e-9);
|
||||
}
|
||||
other => unreachable!("Expected number for B1, got {:?}", other),
|
||||
}
|
||||
assert_eq!(model._get_text("C1"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_accrintm_parameters() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", "=DATE(2020,1,1)");
|
||||
model._set("A2", "=DATE(2020,7,1)");
|
||||
model._set("A3", "8%");
|
||||
model._set("A4", "1000");
|
||||
|
||||
model._set("B1", "=ACCRINTM(A1,A2,A3,A4,0)");
|
||||
model._set("B2", "=ACCRINTM(A1,A2,A3,A4,1)");
|
||||
model._set("B3", "=ACCRINTM(A1,A2,A3,A4,4)");
|
||||
model._set("C1", "=ACCRINTM(A1,A2,A3,A4)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
match (
|
||||
model.get_cell_value_by_ref("Sheet1!B1"),
|
||||
model.get_cell_value_by_ref("Sheet1!B2"),
|
||||
) {
|
||||
(Ok(CellValue::Number(v1)), Ok(CellValue::Number(v2))) => {
|
||||
assert!(v1 > 0.0 && v2 > 0.0);
|
||||
}
|
||||
other => unreachable!("Expected numbers for basis test, got {:?}", other),
|
||||
}
|
||||
|
||||
match (
|
||||
model.get_cell_value_by_ref("Sheet1!B1"),
|
||||
model.get_cell_value_by_ref("Sheet1!C1"),
|
||||
) {
|
||||
(Ok(CellValue::Number(v1)), Ok(CellValue::Number(v2))) => {
|
||||
assert!((v1 - v2).abs() < 1e-12);
|
||||
}
|
||||
other => unreachable!(
|
||||
"Expected matching numbers for default test, got {:?}",
|
||||
other
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_accrintm_errors() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", "=DATE(2020,1,1)");
|
||||
model._set("A2", "=DATE(2020,7,1)");
|
||||
model._set("A3", "8%");
|
||||
model._set("A4", "1000");
|
||||
|
||||
model._set("B1", "=ACCRINTM()");
|
||||
model._set("B2", "=ACCRINTM(A1,A2,A3)");
|
||||
model._set("B3", "=ACCRINTM(A1,A2,A3,A4,0,1)");
|
||||
model._set("C1", "=ACCRINTM(A1,A2,A3,A4,-1)");
|
||||
model._set("C2", "=ACCRINTM(A1,A2,A3,A4,5)");
|
||||
model._set("D1", "=ACCRINTM(A2,A1,A3,A4)");
|
||||
model._set("E1", "=ACCRINTM(A1,A2,A3,0)");
|
||||
model._set("E2", "=ACCRINTM(A1,A2,A3,-1000)");
|
||||
model._set("E3", "=ACCRINTM(A1,A2,-8%,A4)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("B2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("B3"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("C1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("C2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("D1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("E2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("E3"), *"#NUM!");
|
||||
|
||||
match model.get_cell_value_by_ref("Sheet1!E1") {
|
||||
Ok(CellValue::Number(v)) => {
|
||||
assert!((v - 0.0).abs() < 1e-9);
|
||||
}
|
||||
other => unreachable!("Expected 0 for E1, got {:?}", other),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_accrintm_combined() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("C1", "=DATE(2016,4,5)");
|
||||
model._set("C2", "=DATE(2019,2,1)");
|
||||
model._set("A3", "5%");
|
||||
model._set("A4", "1000");
|
||||
model._set("B2", "=ACCRINTM(C1,C2,A3,A4)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
match model.get_cell_value_by_ref("Sheet1!B2") {
|
||||
Ok(CellValue::Number(v)) => {
|
||||
assert!((v - 141.11111111111111).abs() < 1e-9);
|
||||
}
|
||||
other => unreachable!("Expected number for B2, got {:?}", other),
|
||||
}
|
||||
}
|
||||
@@ -22,14 +22,13 @@ fn fn_concatenate() {
|
||||
model._set("B1", r#"=CONCATENATE(A1, A2, A3, "!")"#);
|
||||
// This will break once we implement the implicit intersection operator
|
||||
// It should be:
|
||||
model._set("C2", r#"=CONCATENATE(@A1:A3, "!")"#);
|
||||
// model._set("B2", r#"=CONCATENATE(@A1:A3, "!")"#);
|
||||
model._set("B2", r#"=CONCATENATE(A1:A3, "!")"#);
|
||||
model._set("B3", r#"=CONCAT(A1:A3, "!")"#);
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"Hello my World!");
|
||||
assert_eq!(model._get_text("B2"), *"#N/IMPL!");
|
||||
assert_eq!(model._get_text("B2"), *" my !");
|
||||
assert_eq!(model._get_text("B3"), *"Hello my World!");
|
||||
assert_eq!(model._get_text("C2"), *" my !");
|
||||
}
|
||||
|
||||
@@ -1,260 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{cell::CellValue, test::util::new_empty_model};
|
||||
|
||||
#[test]
|
||||
fn fn_coupon_functions() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Test with basis 1 (original test)
|
||||
model._set("A1", "=DATE(2001,1,25)");
|
||||
model._set("A2", "=DATE(2001,11,15)");
|
||||
model._set("B1", "=COUPDAYBS(A1,A2,2,1)");
|
||||
model._set("B2", "=COUPDAYS(A1,A2,2,1)");
|
||||
model._set("B3", "=COUPDAYSNC(A1,A2,2,1)");
|
||||
model._set("B4", "=COUPNCD(A1,A2,2,1)");
|
||||
model._set("B5", "=COUPNUM(A1,A2,2,1)");
|
||||
model._set("B6", "=COUPPCD(A1,A2,2,1)");
|
||||
|
||||
// Test with basis 3 for better coverage
|
||||
model._set("C1", "=COUPDAYBS(DATE(2001,1,25),DATE(2001,11,15),2,3)");
|
||||
model._set("C2", "=COUPDAYS(DATE(2001,1,25),DATE(2001,11,15),2,3)");
|
||||
model._set("C3", "=COUPDAYSNC(DATE(2001,1,25),DATE(2001,11,15),2,3)");
|
||||
model._set("C4", "=COUPNCD(DATE(2001,1,25),DATE(2001,11,15),2,3)");
|
||||
model._set("C5", "=COUPNUM(DATE(2007,1,25),DATE(2008,11,15),2,1)");
|
||||
model._set("C6", "=COUPPCD(DATE(2001,1,25),DATE(2001,11,15),2,3)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Test basis 1
|
||||
assert_eq!(model._get_text("B1"), "71");
|
||||
assert_eq!(model._get_text("B2"), "181");
|
||||
assert_eq!(model._get_text("B3"), "110");
|
||||
assert_eq!(
|
||||
model.get_cell_value_by_ref("Sheet1!B4"),
|
||||
Ok(CellValue::Number(37026.0))
|
||||
);
|
||||
assert_eq!(model._get_text("B5"), "2");
|
||||
assert_eq!(
|
||||
model.get_cell_value_by_ref("Sheet1!B6"),
|
||||
Ok(CellValue::Number(36845.0))
|
||||
);
|
||||
|
||||
// Test basis 3 (more comprehensive coverage)
|
||||
assert_eq!(model._get_text("C1"), "71");
|
||||
assert_eq!(model._get_text("C2"), "181"); // Fixed: actual days
|
||||
assert_eq!(model._get_text("C3"), "110");
|
||||
assert_eq!(model._get_text("C4"), "37026");
|
||||
assert_eq!(model._get_text("C5"), "4");
|
||||
assert_eq!(model._get_text("C6"), "36845");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_coupon_functions_error_cases() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Test invalid frequency
|
||||
model._set("E1", "=COUPDAYBS(DATE(2001,1,25),DATE(2001,11,15),3,1)");
|
||||
// Test invalid basis
|
||||
model._set("E2", "=COUPDAYS(DATE(2001,1,25),DATE(2001,11,15),2,5)");
|
||||
// Test settlement >= maturity
|
||||
model._set("E3", "=COUPDAYSNC(DATE(2001,11,15),DATE(2001,1,25),2,1)");
|
||||
// Test too few arguments
|
||||
model._set("E4", "=COUPNCD(DATE(2001,1,25),DATE(2001,11,15))");
|
||||
// Test too many arguments
|
||||
model._set("E5", "=COUPNUM(DATE(2001,1,25),DATE(2001,11,15),2,1,1)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// All should return errors
|
||||
assert_eq!(model._get_text("E1"), "#NUM!");
|
||||
assert_eq!(model._get_text("E2"), "#NUM!");
|
||||
assert_eq!(model._get_text("E3"), "#NUM!");
|
||||
assert_eq!(model._get_text("E4"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("E5"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_coupdays_actual_day_count_fix() {
|
||||
// Verify COUPDAYS correctly distinguishes between fixed vs actual day count methods
|
||||
// Bug: basis 2&3 were incorrectly using fixed calculations like basis 0&4
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", "=DATE(2023,1,15)");
|
||||
model._set("A2", "=DATE(2023,7,15)");
|
||||
|
||||
model._set("B1", "=COUPDAYS(A1,A2,2,0)"); // 30/360: uses 360/freq
|
||||
model._set("B2", "=COUPDAYS(A1,A2,2,2)"); // Actual/360: uses actual days
|
||||
model._set("B3", "=COUPDAYS(A1,A2,2,3)"); // Actual/365: uses actual days
|
||||
model._set("B4", "=COUPDAYS(A1,A2,2,4)"); // 30/360 European: uses 360/freq
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Basis 0&4: theoretical 360/2 = 180 days
|
||||
assert_eq!(model._get_text("B1"), "180");
|
||||
assert_eq!(model._get_text("B4"), "180");
|
||||
|
||||
// Basis 2&3: actual days between Jan 15 and Jul 15 = 181 days
|
||||
assert_eq!(model._get_text("B2"), "181");
|
||||
assert_eq!(model._get_text("B3"), "181");
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// FEBRUARY EDGE CASE TESTS - Day Count Convention Compliance
|
||||
// =============================================================================
|
||||
// These tests verify that financial functions correctly handle February dates
|
||||
// according to the official 30/360 day count convention specifications.
|
||||
|
||||
#[test]
|
||||
fn test_coupon_functions_february_consistency() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Test that coupon functions behave consistently between US and European methods
|
||||
// when February dates are involved
|
||||
|
||||
// Settlement: Last day of February (non-leap year)
|
||||
// Maturity: Some date in following year that creates a clear test case
|
||||
model._set("A1", "=DATE(2023,2,28)"); // Last day of Feb, non-leap year
|
||||
model._set("A2", "=DATE(2024,2,28)"); // Same day next year
|
||||
|
||||
// Test COUPDAYS with different basis values
|
||||
model._set("B1", "=COUPDAYS(A1,A2,2,0)"); // US 30/360 - should treat Feb 28 as day 30
|
||||
model._set("B2", "=COUPDAYS(A1,A2,2,4)"); // European 30/360 - should treat Feb 28 as day 28
|
||||
model._set("B3", "=COUPDAYS(A1,A2,2,1)"); // Actual/actual - should use real days
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// All should return valid numbers (no errors)
|
||||
assert_ne!(model._get_text("B1"), *"#NUM!");
|
||||
assert_ne!(model._get_text("B2"), *"#NUM!");
|
||||
assert_ne!(model._get_text("B3"), *"#NUM!");
|
||||
|
||||
// US and European 30/360 should potentially give different results for February dates
|
||||
// (though the exact difference depends on the specific coupon calculation logic)
|
||||
let us_result = model._get_text("B1");
|
||||
let european_result = model._get_text("B2");
|
||||
let actual_result = model._get_text("B3");
|
||||
|
||||
// Verify all are numeric
|
||||
assert!(us_result.parse::<f64>().is_ok());
|
||||
assert!(european_result.parse::<f64>().is_ok());
|
||||
assert!(actual_result.parse::<f64>().is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_february_edge_cases_leap_vs_nonleap() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Test leap year vs non-leap year February handling
|
||||
|
||||
// Feb 28 in non-leap year (this IS the last day of February)
|
||||
model._set("A1", "=DATE(2023,2,28)");
|
||||
model._set("A2", "=DATE(2023,8,28)");
|
||||
|
||||
// Feb 28 in leap year (this is NOT the last day of February)
|
||||
model._set("A3", "=DATE(2024,2,28)");
|
||||
model._set("A4", "=DATE(2024,8,28)");
|
||||
|
||||
// Feb 29 in leap year (this IS the last day of February)
|
||||
model._set("A5", "=DATE(2024,2,29)");
|
||||
model._set("A6", "=DATE(2024,8,29)");
|
||||
|
||||
// Test with basis 0 (US 30/360) - should have special February handling
|
||||
model._set("B1", "=COUPDAYS(A1,A2,2,0)"); // Feb 28 non-leap (last day)
|
||||
model._set("B2", "=COUPDAYS(A3,A4,2,0)"); // Feb 28 leap year (not last day)
|
||||
model._set("B3", "=COUPDAYS(A5,A6,2,0)"); // Feb 29 leap year (last day)
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// All should succeed
|
||||
assert_ne!(model._get_text("B1"), *"#NUM!");
|
||||
assert_ne!(model._get_text("B2"), *"#NUM!");
|
||||
assert_ne!(model._get_text("B3"), *"#NUM!");
|
||||
|
||||
// Verify they're all numeric
|
||||
assert!(model._get_text("B1").parse::<f64>().is_ok());
|
||||
assert!(model._get_text("B2").parse::<f64>().is_ok());
|
||||
assert!(model._get_text("B3").parse::<f64>().is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_us_nasd_both_february_rule() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Test the specific US/NASD rule: "If both date A and B fall on the last day of February,
|
||||
// then date B will be changed to the 30th"
|
||||
|
||||
// Case 1: Both dates are Feb 28 in non-leap years (both are last day of February)
|
||||
model._set("A1", "=DATE(2023,2,28)"); // Last day of Feb 2023
|
||||
model._set("A2", "=DATE(2025,2,28)"); // Last day of Feb 2025
|
||||
|
||||
// Case 2: Both dates are Feb 29 in leap years (both are last day of February)
|
||||
model._set("A3", "=DATE(2024,2,29)"); // Last day of Feb 2024
|
||||
model._set("A4", "=DATE(2028,2,29)"); // Last day of Feb 2028
|
||||
|
||||
// Case 3: Mixed - Feb 28 non-leap to Feb 29 leap (both are last day of February)
|
||||
model._set("A5", "=DATE(2023,2,28)"); // Last day of Feb 2023
|
||||
model._set("A6", "=DATE(2024,2,29)"); // Last day of Feb 2024
|
||||
|
||||
// Case 4: Control - Feb 28 in leap year (NOT last day) to Feb 29 (IS last day)
|
||||
model._set("A7", "=DATE(2024,2,28)"); // NOT last day of Feb 2024
|
||||
model._set("A8", "=DATE(2024,2,29)"); // IS last day of Feb 2024
|
||||
|
||||
// Test using coupon functions that should apply US/NASD 30/360 (basis 0)
|
||||
model._set("B1", "=COUPDAYS(A1,A2,1,0)"); // Both last day Feb - Rule 1 should apply
|
||||
model._set("B2", "=COUPDAYS(A3,A4,1,0)"); // Both last day Feb - Rule 1 should apply
|
||||
model._set("B3", "=COUPDAYS(A5,A6,1,0)"); // Both last day Feb - Rule 1 should apply
|
||||
model._set("B4", "=COUPDAYS(A7,A8,1,0)"); // Only end is last day Feb - Rule 1 should NOT apply
|
||||
|
||||
// Compare with European method (basis 4) - should behave differently
|
||||
model._set("C1", "=COUPDAYS(A1,A2,1,4)"); // European - no special Feb handling
|
||||
model._set("C2", "=COUPDAYS(A3,A4,1,4)"); // European - no special Feb handling
|
||||
model._set("C3", "=COUPDAYS(A5,A6,1,4)"); // European - no special Feb handling
|
||||
model._set("C4", "=COUPDAYS(A7,A8,1,4)"); // European - no special Feb handling
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// All should succeed without errors
|
||||
for row in ["B1", "B2", "B3", "B4", "C1", "C2", "C3", "C4"] {
|
||||
assert_ne!(model._get_text(row), *"#NUM!", "Failed for {row}");
|
||||
assert!(
|
||||
model._get_text(row).parse::<f64>().is_ok(),
|
||||
"Non-numeric result for {row}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_coupon_functions_february_edge_cases() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Test that coupon functions handle February dates correctly without errors
|
||||
|
||||
// Settlement: February 28, 2023 (non-leap), Maturity: February 28, 2024 (leap)
|
||||
model._set("A1", "=DATE(2023,2,28)");
|
||||
model._set("A2", "=DATE(2024,2,28)");
|
||||
|
||||
// Test with basis 0 (US 30/360 - should use special February handling)
|
||||
model._set("B1", "=COUPDAYBS(A1,A2,2,0)");
|
||||
model._set("B2", "=COUPDAYS(A1,A2,2,0)");
|
||||
model._set("B3", "=COUPDAYSNC(A1,A2,2,0)");
|
||||
|
||||
// Test with basis 4 (European 30/360 - should NOT use special February handling)
|
||||
model._set("C1", "=COUPDAYBS(A1,A2,2,4)");
|
||||
model._set("C2", "=COUPDAYS(A1,A2,2,4)");
|
||||
model._set("C3", "=COUPDAYSNC(A1,A2,2,4)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// With US method (basis 0), February dates should be handled specially
|
||||
// With European method (basis 4), February dates should use actual dates
|
||||
// Key point: both should work without errors
|
||||
|
||||
// We're ensuring functions complete successfully with February dates
|
||||
assert_ne!(model._get_text("B1"), *"#NUM!");
|
||||
assert_ne!(model._get_text("B2"), *"#NUM!");
|
||||
assert_ne!(model._get_text("B3"), *"#NUM!");
|
||||
assert_ne!(model._get_text("C1"), *"#NUM!");
|
||||
assert_ne!(model._get_text("C2"), *"#NUM!");
|
||||
assert_ne!(model._get_text("C3"), *"#NUM!");
|
||||
}
|
||||
@@ -1,182 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
use crate::types::Cell;
|
||||
|
||||
// Helper to evaluate a formula and return the formatted text
|
||||
fn eval_formula(formula: &str) -> String {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", formula);
|
||||
model.evaluate();
|
||||
model._get_text("A1")
|
||||
}
|
||||
|
||||
// Helper that evaluates a formula and returns the raw value of A1 as a Result<f64, String>
|
||||
fn eval_formula_raw_number(formula: &str) -> Result<f64, String> {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", formula);
|
||||
model.evaluate();
|
||||
match model._get_cell("A1") {
|
||||
Cell::NumberCell { v, .. } => Ok(*v),
|
||||
Cell::BooleanCell { v, .. } => Ok(if *v { 1.0 } else { 0.0 }),
|
||||
Cell::ErrorCell { ei, .. } => Err(format!("{}", ei)),
|
||||
_ => Err(model._get_text("A1")),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datevalue_basic_numeric() {
|
||||
// DATEVALUE should return the serial number representing the date, **not** a formatted date
|
||||
assert_eq!(
|
||||
eval_formula_raw_number("=DATEVALUE(\"2/1/2023\")").unwrap(),
|
||||
44958.0
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datevalue_mmdd_with_leading_zero() {
|
||||
assert_eq!(
|
||||
eval_formula_raw_number("=DATEVALUE(\"02/01/2023\")").unwrap(),
|
||||
44958.0
|
||||
); // 1-Feb-2023
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datevalue_iso() {
|
||||
assert_eq!(
|
||||
eval_formula_raw_number("=DATEVALUE(\"2023-01-02\")").unwrap(),
|
||||
44928.0
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datevalue_month_name() {
|
||||
assert_eq!(
|
||||
eval_formula_raw_number("=DATEVALUE(\"2-Jan-23\")").unwrap(),
|
||||
44928.0
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datevalue_ambiguous_ddmm() {
|
||||
// 01/02/2023 interpreted as MM/DD -> 2-Jan-2023
|
||||
assert_eq!(
|
||||
eval_formula_raw_number("=DATEVALUE(\"01/02/2023\")").unwrap(),
|
||||
44929.0
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datevalue_ddmm_unambiguous() {
|
||||
// 15/01/2023 should be 15-Jan-2023 since 15 cannot be month
|
||||
assert_eq!(
|
||||
eval_formula_raw_number("=DATEVALUE(\"15/01/2023\")").unwrap(),
|
||||
44941.0
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datevalue_leap_day() {
|
||||
assert_eq!(
|
||||
eval_formula_raw_number("=DATEVALUE(\"29/02/2020\")").unwrap(),
|
||||
43890.0
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datevalue_year_first_text_month() {
|
||||
assert_eq!(
|
||||
eval_formula_raw_number("=DATEVALUE(\"2023/Jan/15\")").unwrap(),
|
||||
44941.0
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datevalue_mmdd_with_day_gt_12() {
|
||||
assert_eq!(
|
||||
eval_formula_raw_number("=DATEVALUE(\"6/15/2021\")").unwrap(),
|
||||
44373.0
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datevalue_error_conditions() {
|
||||
let cases = [
|
||||
"=DATEVALUE(\"31/04/2023\")", // invalid day (Apr has 30 days)
|
||||
"=DATEVALUE(\"13/13/2023\")", // invalid month
|
||||
"=DATEVALUE(\"not a date\")", // non-date text
|
||||
];
|
||||
for formula in cases {
|
||||
let result = eval_formula(formula);
|
||||
assert_eq!(result, *"#VALUE!", "Expected #VALUE! for {}", formula);
|
||||
}
|
||||
}
|
||||
|
||||
// Helper to set and evaluate a single DATEDIF call
|
||||
fn eval_datedif(unit: &str) -> String {
|
||||
let mut model = new_empty_model();
|
||||
let formula = format!("=DATEDIF(\"2020-01-01\", \"2021-06-15\", \"{}\")", unit);
|
||||
model._set("A1", &formula);
|
||||
model.evaluate();
|
||||
model._get_text("A1")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datedif_y() {
|
||||
assert_eq!(eval_datedif("Y"), *"1");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datedif_m() {
|
||||
assert_eq!(eval_datedif("M"), *"17");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datedif_d() {
|
||||
assert_eq!(eval_datedif("D"), *"531");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datedif_ym() {
|
||||
assert_eq!(eval_datedif("YM"), *"5");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datedif_yd() {
|
||||
assert_eq!(eval_datedif("YD"), *"165");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datedif_md() {
|
||||
assert_eq!(eval_datedif("MD"), *"14");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datedif_edge_and_error_cases() {
|
||||
let mut model = new_empty_model();
|
||||
// Leap-year spanning
|
||||
model._set("A1", "=DATEDIF(\"28/2/2020\", \"1/3/2020\", \"D\")");
|
||||
// End date before start date => #NUM!
|
||||
model._set("A2", "=DATEDIF(\"1/2/2021\", \"1/1/2021\", \"D\")");
|
||||
// Invalid unit => #VALUE!
|
||||
model._set("A3", "=DATEDIF(\"1/1/2020\", \"1/1/2021\", \"Z\")");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"2");
|
||||
assert_eq!(model._get_text("A2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A3"), *"#VALUE!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datedif_mixed_case_unit() {
|
||||
assert_eq!(eval_datedif("yD"), *"165"); // mixed-case should work
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_datedif_error_propagation() {
|
||||
// Invalid date in arguments should propagate #VALUE!
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATEDIF(\"bad\", \"bad\", \"Y\")");
|
||||
model.evaluate();
|
||||
assert_eq!(model._get_text("A1"), *"#VALUE!");
|
||||
}
|
||||
@@ -1,15 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn test_fn_date_arguments() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", "=DAY(95051806)");
|
||||
model._set("A2", "=DAY(2958465)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("A2"), *"31");
|
||||
}
|
||||
@@ -1,350 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
#![allow(clippy::panic)]
|
||||
|
||||
use crate::{cell::CellValue, test::util::new_empty_model};
|
||||
|
||||
// Test constants for realistic bond scenarios
|
||||
const BOND_SETTLEMENT: &str = "=DATE(2020,1,1)";
|
||||
const BOND_MATURITY_4Y: &str = "=DATE(2024,1,1)";
|
||||
const BOND_MATURITY_INVALID: &str = "=DATE(2016,1,1)"; // Before settlement
|
||||
const BOND_MATURITY_SAME: &str = "=DATE(2020,1,1)"; // Same as settlement
|
||||
const BOND_MATURITY_1DAY: &str = "=DATE(2020,1,2)"; // Very short term
|
||||
|
||||
// Standard investment-grade corporate bond parameters
|
||||
const STD_COUPON: f64 = 0.08; // 8% annual coupon rate
|
||||
const STD_YIELD: f64 = 0.09; // 9% yield (discount bond scenario)
|
||||
const STD_FREQUENCY: i32 = 2; // Semi-annual payments (most common)
|
||||
|
||||
// Helper function to reduce test repetition
|
||||
fn assert_numerical_result(model: &crate::Model, cell_ref: &str, should_be_positive: bool) {
|
||||
if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref(cell_ref) {
|
||||
if should_be_positive {
|
||||
assert!(v > 0.0, "Expected positive value at {cell_ref}, got {v}");
|
||||
}
|
||||
// Value is valid - test passes
|
||||
} else {
|
||||
panic!("Expected numerical result at {cell_ref}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_duration_mduration_arguments() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Test argument count validation
|
||||
model._set("A1", "=DURATION()");
|
||||
model._set("A2", "=DURATION(1,2,3,4)");
|
||||
model._set("A3", "=DURATION(1,2,3,4,5,6,7)");
|
||||
|
||||
model._set("B1", "=MDURATION()");
|
||||
model._set("B2", "=MDURATION(1,2,3,4)");
|
||||
model._set("B3", "=MDURATION(1,2,3,4,5,6,7)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Too few or too many arguments should result in errors
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("B2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("B3"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_duration_mduration_settlement_maturity_errors() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", BOND_SETTLEMENT);
|
||||
model._set("A2", BOND_MATURITY_INVALID); // Before settlement
|
||||
model._set("A3", BOND_MATURITY_SAME); // Same as settlement
|
||||
|
||||
// Both settlement > maturity and settlement = maturity should error
|
||||
model._set(
|
||||
"B1",
|
||||
&format!("=DURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
|
||||
);
|
||||
model._set(
|
||||
"B2",
|
||||
&format!("=DURATION(A1,A3,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
|
||||
);
|
||||
model._set(
|
||||
"B3",
|
||||
&format!("=MDURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
|
||||
);
|
||||
model._set(
|
||||
"B4",
|
||||
&format!("=MDURATION(A1,A3,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
|
||||
);
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B3"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B4"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_duration_mduration_negative_values_errors() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", BOND_SETTLEMENT);
|
||||
model._set("A2", BOND_MATURITY_4Y);
|
||||
|
||||
// Test negative coupon (coupons must be >= 0)
|
||||
model._set(
|
||||
"B1",
|
||||
&format!("=DURATION(A1,A2,-0.01,{STD_YIELD},{STD_FREQUENCY})"),
|
||||
);
|
||||
model._set(
|
||||
"B2",
|
||||
&format!("=MDURATION(A1,A2,-0.01,{STD_YIELD},{STD_FREQUENCY})"),
|
||||
);
|
||||
|
||||
// Test negative yield (yields must be >= 0)
|
||||
model._set(
|
||||
"C1",
|
||||
&format!("=DURATION(A1,A2,{STD_COUPON},-0.01,{STD_FREQUENCY})"),
|
||||
);
|
||||
model._set(
|
||||
"C2",
|
||||
&format!("=MDURATION(A1,A2,{STD_COUPON},-0.01,{STD_FREQUENCY})"),
|
||||
);
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("C1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("C2"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_duration_mduration_invalid_frequency_errors() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", BOND_SETTLEMENT);
|
||||
model._set("A2", BOND_MATURITY_4Y);
|
||||
|
||||
// Only 1, 2, and 4 are valid frequencies (annual, semi-annual, quarterly)
|
||||
let invalid_frequencies = [0, 3, 5, 12]; // Common invalid values
|
||||
|
||||
for (i, &freq) in invalid_frequencies.iter().enumerate() {
|
||||
let row = i + 1;
|
||||
model._set(
|
||||
&format!("B{row}"),
|
||||
&format!("=DURATION(A1,A2,{STD_COUPON},{STD_YIELD},{freq})"),
|
||||
);
|
||||
model._set(
|
||||
&format!("C{row}"),
|
||||
&format!("=MDURATION(A1,A2,{STD_COUPON},{STD_YIELD},{freq})"),
|
||||
);
|
||||
}
|
||||
|
||||
model.evaluate();
|
||||
|
||||
for i in 1..=invalid_frequencies.len() {
|
||||
assert_eq!(model._get_text(&format!("B{i}")), *"#NUM!");
|
||||
assert_eq!(model._get_text(&format!("C{i}")), *"#NUM!");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_duration_mduration_frequency_variations() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", BOND_SETTLEMENT);
|
||||
model._set("A2", BOND_MATURITY_4Y);
|
||||
|
||||
// Test all valid frequencies: 1=annual, 2=semi-annual, 4=quarterly
|
||||
let valid_frequencies = [1, 2, 4];
|
||||
|
||||
for (i, &freq) in valid_frequencies.iter().enumerate() {
|
||||
let row = i + 1;
|
||||
model._set(
|
||||
&format!("B{row}"),
|
||||
&format!("=DURATION(A1,A2,{STD_COUPON},{STD_YIELD},{freq})"),
|
||||
);
|
||||
model._set(
|
||||
&format!("C{row}"),
|
||||
&format!("=MDURATION(A1,A2,{STD_COUPON},{STD_YIELD},{freq})"),
|
||||
);
|
||||
}
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// All should return positive numerical values
|
||||
for i in 1..=valid_frequencies.len() {
|
||||
assert_numerical_result(&model, &format!("Sheet1!B{i}"), true);
|
||||
assert_numerical_result(&model, &format!("Sheet1!C{i}"), true);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_duration_mduration_basis_variations() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", BOND_SETTLEMENT);
|
||||
model._set("A2", BOND_MATURITY_4Y);
|
||||
|
||||
// Test all valid basis values (day count conventions)
|
||||
// 0=30/360 US, 1=Actual/actual, 2=Actual/360, 3=Actual/365, 4=30/360 European
|
||||
for basis in 0..=4 {
|
||||
let row = basis + 1;
|
||||
model._set(
|
||||
&format!("B{row}"),
|
||||
&format!("=DURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY},{basis})"),
|
||||
);
|
||||
model._set(
|
||||
&format!("C{row}"),
|
||||
&format!("=MDURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY},{basis})"),
|
||||
);
|
||||
}
|
||||
|
||||
// Test default basis (should be 0)
|
||||
model._set(
|
||||
"D1",
|
||||
&format!("=DURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
|
||||
);
|
||||
model._set(
|
||||
"D2",
|
||||
&format!("=MDURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
|
||||
);
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// All basis values should work
|
||||
for row in 1..=5 {
|
||||
assert_numerical_result(&model, &format!("Sheet1!B{row}"), true);
|
||||
assert_numerical_result(&model, &format!("Sheet1!C{row}"), true);
|
||||
}
|
||||
|
||||
// Default basis should match basis 0
|
||||
if let (Ok(CellValue::Number(d1)), Ok(CellValue::Number(b1))) = (
|
||||
model.get_cell_value_by_ref("Sheet1!D1"),
|
||||
model.get_cell_value_by_ref("Sheet1!B1"),
|
||||
) {
|
||||
assert!(
|
||||
(d1 - b1).abs() < 1e-10,
|
||||
"Default basis should match basis 0"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_duration_mduration_edge_cases() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", BOND_SETTLEMENT);
|
||||
model._set("A2", BOND_MATURITY_1DAY); // Very short term (1 day)
|
||||
model._set("A3", BOND_MATURITY_4Y); // Standard term
|
||||
|
||||
// Edge case scenarios with explanations
|
||||
let test_cases = [
|
||||
("B", "A1", "A2", STD_COUPON, STD_YIELD, "short_term"), // 1-day bond
|
||||
("C", "A1", "A3", 0.0, STD_YIELD, "zero_coupon"), // Zero coupon bond
|
||||
("D", "A1", "A3", STD_COUPON, 0.0, "zero_yield"), // Zero yield
|
||||
("E", "A1", "A3", 1.0, 0.5, "high_rates"), // High coupon/yield (100%/50%)
|
||||
];
|
||||
|
||||
for (col, settlement, maturity, coupon, yield_rate, _scenario) in test_cases {
|
||||
model._set(
|
||||
&format!("{col}1"),
|
||||
&format!("=DURATION({settlement},{maturity},{coupon},{yield_rate},{STD_FREQUENCY})"),
|
||||
);
|
||||
model._set(
|
||||
&format!("{col}2"),
|
||||
&format!("=MDURATION({settlement},{maturity},{coupon},{yield_rate},{STD_FREQUENCY})"),
|
||||
);
|
||||
}
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// All edge cases should return positive values
|
||||
for col in ["B", "C", "D", "E"] {
|
||||
assert_numerical_result(&model, &format!("Sheet1!{col}1"), true);
|
||||
assert_numerical_result(&model, &format!("Sheet1!{col}2"), true);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_duration_mduration_relationship() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", BOND_SETTLEMENT);
|
||||
model._set("A2", BOND_MATURITY_4Y);
|
||||
|
||||
// Test mathematical relationship: MDURATION = DURATION / (1 + yield/frequency)
|
||||
model._set(
|
||||
"B1",
|
||||
&format!("=DURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
|
||||
);
|
||||
model._set(
|
||||
"B2",
|
||||
&format!("=MDURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
|
||||
);
|
||||
model._set("B3", &format!("=B1/(1+{STD_YIELD}/{STD_FREQUENCY})")); // Manual calculation
|
||||
|
||||
// Test with quarterly frequency and different yield
|
||||
model._set("C1", &format!("=DURATION(A1,A2,{STD_COUPON},0.12,4)"));
|
||||
model._set("C2", &format!("=MDURATION(A1,A2,{STD_COUPON},0.12,4)"));
|
||||
model._set("C3", "=C1/(1+0.12/4)"); // Manual calculation for quarterly
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// MDURATION should equal DURATION / (1 + yield/frequency) for both scenarios
|
||||
if let (Ok(CellValue::Number(md)), Ok(CellValue::Number(manual))) = (
|
||||
model.get_cell_value_by_ref("Sheet1!B2"),
|
||||
model.get_cell_value_by_ref("Sheet1!B3"),
|
||||
) {
|
||||
assert!(
|
||||
(md - manual).abs() < 1e-10,
|
||||
"MDURATION should equal DURATION/(1+yield/freq)"
|
||||
);
|
||||
}
|
||||
|
||||
if let (Ok(CellValue::Number(md)), Ok(CellValue::Number(manual))) = (
|
||||
model.get_cell_value_by_ref("Sheet1!C2"),
|
||||
model.get_cell_value_by_ref("Sheet1!C3"),
|
||||
) {
|
||||
assert!(
|
||||
(md - manual).abs() < 1e-10,
|
||||
"MDURATION should equal DURATION/(1+yield/freq) for quarterly"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_duration_mduration_regression() {
|
||||
// Original regression test with known expected values
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2016,1,1)");
|
||||
model._set("A2", "=DATE(2020,1,1)");
|
||||
model._set(
|
||||
"B1",
|
||||
&format!("=DURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
|
||||
);
|
||||
model._set(
|
||||
"B2",
|
||||
&format!("=MDURATION(A1,A2,{STD_COUPON},{STD_YIELD},{STD_FREQUENCY})"),
|
||||
);
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Verify exact values for regression testing
|
||||
if let Ok(CellValue::Number(v1)) = model.get_cell_value_by_ref("Sheet1!B1") {
|
||||
assert!(
|
||||
(v1 - 3.410746844012284).abs() < 1e-9,
|
||||
"DURATION regression test failed"
|
||||
);
|
||||
} else {
|
||||
panic!("Unexpected value for DURATION");
|
||||
}
|
||||
if let Ok(CellValue::Number(v2)) = model.get_cell_value_by_ref("Sheet1!B2") {
|
||||
assert!(
|
||||
(v2 - 3.263872578002186).abs() < 1e-9,
|
||||
"MDURATION regression test failed"
|
||||
);
|
||||
} else {
|
||||
panic!("Unexpected value for MDURATION");
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,4 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
#![allow(clippy::panic)]
|
||||
|
||||
use crate::{cell::CellValue, test::util::new_empty_model};
|
||||
|
||||
@@ -26,10 +25,6 @@ fn fn_arguments() {
|
||||
model._set("E2", "=RATE(1,1)");
|
||||
model._set("E3", "=RATE(1,1,1,1,1,1)");
|
||||
|
||||
model._set("F1", "=FVSCHEDULE()");
|
||||
model._set("F2", "=FVSCHEDULE(1)");
|
||||
model._set("F3", "=FVSCHEDULE(1,1,1)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
@@ -51,10 +46,6 @@ fn fn_arguments() {
|
||||
assert_eq!(model._get_text("E1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("E2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("E3"), *"#ERROR!");
|
||||
|
||||
assert_eq!(model._get_text("F1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("F2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("F3"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -477,18 +468,3 @@ fn fn_db_misc() {
|
||||
|
||||
assert_eq!(model._get_text("B1"), "$0.00");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_fvschedule() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "1000");
|
||||
model._set("A2", "0.08");
|
||||
model._set("A3", "0.09");
|
||||
model._set("A4", "0.1");
|
||||
|
||||
model._set("B1", "=FVSCHEDULE(A1, A2:A4)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), "1294.92");
|
||||
}
|
||||
|
||||
@@ -1,615 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{cell::CellValue, test::util::new_empty_model};
|
||||
|
||||
#[test]
|
||||
fn fn_price_yield() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2023,1,1)");
|
||||
model._set("A2", "=DATE(2024,1,1)");
|
||||
model._set("A3", "5%");
|
||||
|
||||
model._set("B1", "=PRICE(A1,A2,A3,6%,100,1)");
|
||||
model._set("B2", "=YIELD(A1,A2,A3,B1,100,1)");
|
||||
|
||||
model.evaluate();
|
||||
assert_eq!(model._get_text("B1"), "99.056603774");
|
||||
assert_eq!(model._get_text("B2"), "0.06");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_price_frequencies() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2023,1,1)");
|
||||
model._set("A2", "=DATE(2024,1,1)");
|
||||
|
||||
model._set("B1", "=PRICE(A1,A2,5%,6%,100,1)");
|
||||
model._set("B2", "=PRICE(A1,A2,5%,6%,100,2)");
|
||||
model._set("B3", "=PRICE(A1,A2,5%,6%,100,4)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
let annual: f64 = model._get_text("B1").parse().unwrap();
|
||||
let semi: f64 = model._get_text("B2").parse().unwrap();
|
||||
let quarterly: f64 = model._get_text("B3").parse().unwrap();
|
||||
|
||||
assert_ne!(annual, semi);
|
||||
assert_ne!(semi, quarterly);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_yield_frequencies() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2023,1,1)");
|
||||
model._set("A2", "=DATE(2024,1,1)");
|
||||
|
||||
model._set("B1", "=YIELD(A1,A2,5%,99,100,1)");
|
||||
model._set("B2", "=YIELD(A1,A2,5%,99,100,2)");
|
||||
model._set("B3", "=YIELD(A1,A2,5%,99,100,4)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
let annual: f64 = model._get_text("B1").parse().unwrap();
|
||||
let semi: f64 = model._get_text("B2").parse().unwrap();
|
||||
let quarterly: f64 = model._get_text("B3").parse().unwrap();
|
||||
|
||||
assert_ne!(annual, semi);
|
||||
assert_ne!(semi, quarterly);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_price_argument_errors() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2023,1,1)");
|
||||
model._set("A2", "=DATE(2024,1,1)");
|
||||
|
||||
model._set("B1", "=PRICE()");
|
||||
model._set("B2", "=PRICE(A1,A2,5%,6%,100)");
|
||||
model._set("B3", "=PRICE(A1,A2,5%,6%,100,2,0,99)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("B2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("B3"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_yield_argument_errors() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2023,1,1)");
|
||||
model._set("A2", "=DATE(2024,1,1)");
|
||||
|
||||
model._set("B1", "=YIELD()");
|
||||
model._set("B2", "=YIELD(A1,A2,5%,99,100)");
|
||||
model._set("B3", "=YIELD(A1,A2,5%,99,100,2,0,99)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("B2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("B3"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_price_invalid_frequency() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2023,1,1)");
|
||||
model._set("A2", "=DATE(2024,1,1)");
|
||||
|
||||
model._set("B1", "=PRICE(A1,A2,5%,6%,100,0)");
|
||||
model._set("B2", "=PRICE(A1,A2,5%,6%,100,3)");
|
||||
model._set("B3", "=PRICE(A1,A2,5%,6%,100,5)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B3"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_pricedisc() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A2", "=DATE(2022,1,25)");
|
||||
model._set("A3", "=DATE(2022,11,15)");
|
||||
model._set("A4", "3.75%");
|
||||
model._set("A5", "100");
|
||||
|
||||
model._set("B1", "=PRICEDISC(A2,A3,A4,A5)");
|
||||
model._set("C1", "=PRICEDISC(A2,A3)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), "96.979166667");
|
||||
assert_eq!(model._get_text("C1"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_pricemat() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2019,2,15)");
|
||||
model._set("A2", "=DATE(2025,4,13)");
|
||||
model._set("A3", "=DATE(2018,11,11)");
|
||||
model._set("A4", "5.75%");
|
||||
model._set("A5", "6.5%");
|
||||
|
||||
model._set("B1", "=PRICEMAT(A1,A2,A3,A4,A5)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), "96.271187821");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_yielddisc() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2022,1,25)");
|
||||
model._set("A2", "=DATE(2022,11,15)");
|
||||
model._set("A3", "97");
|
||||
model._set("A4", "100");
|
||||
|
||||
model._set("B1", "=YIELDDISC(A1,A2,A3,A4)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), "0.038393175");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_yieldmat() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2019,2,15)");
|
||||
model._set("A2", "=DATE(2025,4,13)");
|
||||
model._set("A3", "=DATE(2018,11,11)");
|
||||
model._set("A4", "5.75%");
|
||||
model._set("A5", "96.27");
|
||||
|
||||
model._set("B1", "=YIELDMAT(A1,A2,A3,A4,A5)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), "0.065002762");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_disc() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2022,1,25)");
|
||||
model._set("A2", "=DATE(2022,11,15)");
|
||||
model._set("A3", "97");
|
||||
model._set("A4", "100");
|
||||
|
||||
model._set("B1", "=DISC(A1,A2,A3,A4)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), "0.037241379");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_received() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2020,1,1)");
|
||||
model._set("A2", "=DATE(2023,6,30)");
|
||||
model._set("A3", "20000");
|
||||
model._set("A4", "5%");
|
||||
model._set("A5", "3");
|
||||
|
||||
model._set("B1", "=RECEIVED(A1,A2,A3,A4,A5)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), "24236.387782205");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_intrate() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2020,1,1)");
|
||||
model._set("A2", "=DATE(2023,6,30)");
|
||||
model._set("A3", "10000");
|
||||
model._set("A4", "12000");
|
||||
model._set("A5", "3");
|
||||
|
||||
model._set("B1", "=INTRATE(A1,A2,A3,A4,A5)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), "0.057210031");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_bond_functions_arguments() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// PRICEDISC: 4-5 args
|
||||
model._set("A1", "=PRICEDISC()");
|
||||
model._set("A2", "=PRICEDISC(1,2,3)");
|
||||
model._set("A3", "=PRICEDISC(1,2,3,4,5,6)");
|
||||
|
||||
// PRICEMAT: 5-6 args
|
||||
model._set("B1", "=PRICEMAT()");
|
||||
model._set("B2", "=PRICEMAT(1,2,3,4)");
|
||||
model._set("B3", "=PRICEMAT(1,2,3,4,5,6,7)");
|
||||
|
||||
// YIELDDISC: 4-5 args
|
||||
model._set("C1", "=YIELDDISC()");
|
||||
model._set("C2", "=YIELDDISC(1,2,3)");
|
||||
model._set("C3", "=YIELDDISC(1,2,3,4,5,6)");
|
||||
|
||||
// YIELDMAT: 5-6 args
|
||||
model._set("D1", "=YIELDMAT()");
|
||||
model._set("D2", "=YIELDMAT(1,2,3,4)");
|
||||
model._set("D3", "=YIELDMAT(1,2,3,4,5,6,7)");
|
||||
|
||||
// DISC: 4-5 args
|
||||
model._set("E1", "=DISC()");
|
||||
model._set("E2", "=DISC(1,2,3)");
|
||||
model._set("E3", "=DISC(1,2,3,4,5,6)");
|
||||
|
||||
// RECEIVED: 4-5 args
|
||||
model._set("F1", "=RECEIVED()");
|
||||
model._set("F2", "=RECEIVED(1,2,3)");
|
||||
model._set("F3", "=RECEIVED(1,2,3,4,5,6)");
|
||||
|
||||
// INTRATE: 4-5 args
|
||||
model._set("G1", "=INTRATE()");
|
||||
model._set("G2", "=INTRATE(1,2,3)");
|
||||
model._set("G3", "=INTRATE(1,2,3,4,5,6)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("B2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("B3"), *"#ERROR!");
|
||||
|
||||
assert_eq!(model._get_text("C1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("C2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("C3"), *"#ERROR!");
|
||||
|
||||
assert_eq!(model._get_text("D1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("D2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("D3"), *"#ERROR!");
|
||||
|
||||
assert_eq!(model._get_text("E1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("E2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("E3"), *"#ERROR!");
|
||||
|
||||
assert_eq!(model._get_text("F1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("F2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("F3"), *"#ERROR!");
|
||||
|
||||
assert_eq!(model._get_text("G1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("G2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("G3"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_bond_functions_date_boundaries() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
// Date boundary values
|
||||
model._set("A1", "0"); // Below MINIMUM_DATE_SERIAL_NUMBER
|
||||
model._set("A2", "1"); // MINIMUM_DATE_SERIAL_NUMBER
|
||||
model._set("A3", "2958465"); // MAXIMUM_DATE_SERIAL_NUMBER
|
||||
model._set("A4", "2958466"); // Above MAXIMUM_DATE_SERIAL_NUMBER
|
||||
|
||||
// Test settlement < minimum
|
||||
model._set("B1", "=PRICEDISC(A1,A2,0.05,100)");
|
||||
model._set("B2", "=YIELDDISC(A1,A2,95,100)");
|
||||
model._set("B3", "=DISC(A1,A2,95,100)");
|
||||
model._set("B4", "=RECEIVED(A1,A2,1000,0.05)");
|
||||
model._set("B5", "=INTRATE(A1,A2,1000,1050)");
|
||||
|
||||
// Test maturity > maximum
|
||||
model._set("C1", "=PRICEDISC(A2,A4,0.05,100)");
|
||||
model._set("C2", "=YIELDDISC(A2,A4,95,100)");
|
||||
model._set("C3", "=DISC(A2,A4,95,100)");
|
||||
model._set("C4", "=RECEIVED(A2,A4,1000,0.05)");
|
||||
model._set("C5", "=INTRATE(A2,A4,1000,1050)");
|
||||
|
||||
// Test PRICEMAT/YIELDMAT with issue < minimum
|
||||
model._set("D1", "=PRICEMAT(A2,A3,A1,0.06,0.05)");
|
||||
model._set("D2", "=YIELDMAT(A2,A3,A1,0.06,99)");
|
||||
|
||||
// Test PRICEMAT/YIELDMAT with issue > maximum
|
||||
model._set("E1", "=PRICEMAT(A2,A3,A4,0.06,0.05)");
|
||||
model._set("E2", "=YIELDMAT(A2,A3,A4,0.06,99)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B3"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_yield_invalid_frequency() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2023,1,1)");
|
||||
model._set("A2", "=DATE(2024,1,1)");
|
||||
|
||||
model._set("B1", "=YIELD(A1,A2,5%,99,100,0)");
|
||||
model._set("B2", "=YIELD(A1,A2,5%,99,100,3)");
|
||||
model._set("B3", "=YIELD(A1,A2,5%,99,100,5)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B3"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_bond_functions_date_ordering() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", "=DATE(2022,1,1)"); // settlement
|
||||
model._set("A2", "=DATE(2021,12,31)"); // maturity (before settlement)
|
||||
model._set("A3", "=DATE(2020,1,1)"); // issue
|
||||
|
||||
// Test settlement >= maturity
|
||||
model._set("B1", "=PRICEDISC(A1,A2,0.05,100)");
|
||||
model._set("B2", "=YIELDDISC(A1,A2,95,100)");
|
||||
model._set("B3", "=DISC(A1,A2,95,100)");
|
||||
model._set("B4", "=RECEIVED(A1,A2,1000,0.05)");
|
||||
model._set("B5", "=INTRATE(A1,A2,1000,1050)");
|
||||
model._set("B6", "=PRICEMAT(A1,A2,A3,0.06,0.05)");
|
||||
model._set("B7", "=YIELDMAT(A1,A2,A3,0.06,99)");
|
||||
|
||||
// Test settlement < issue for YIELDMAT/PRICEMAT
|
||||
model._set("A4", "=DATE(2023,1,1)"); // later issue date
|
||||
model._set("C1", "=PRICEMAT(A1,A2,A4,0.06,0.05)"); // settlement < issue
|
||||
model._set("C2", "=YIELDMAT(A1,A2,A4,0.06,99)"); // settlement < issue
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B3"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_price_invalid_dates() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2023,1,1)");
|
||||
model._set("A2", "=DATE(2024,1,1)");
|
||||
|
||||
model._set("B1", "=PRICE(A2,A1,5%,6%,100,2)");
|
||||
model._set("B2", "=PRICE(A1,A1,5%,6%,100,2)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B2"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_bond_functions_parameter_validation() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", "=DATE(2022,1,1)");
|
||||
model._set("A2", "=DATE(2022,12,31)");
|
||||
model._set("A3", "=DATE(2021,1,1)");
|
||||
|
||||
// Test negative/zero prices and redemptions
|
||||
model._set("B1", "=PRICEDISC(A1,A2,0.05,0)"); // zero redemption
|
||||
model._set("B2", "=PRICEDISC(A1,A2,0,100)"); // zero discount
|
||||
model._set("B3", "=PRICEDISC(A1,A2,-0.05,100)"); // negative discount
|
||||
|
||||
model._set("C1", "=YIELDDISC(A1,A2,0,100)"); // zero price
|
||||
model._set("C2", "=YIELDDISC(A1,A2,95,0)"); // zero redemption
|
||||
model._set("C3", "=YIELDDISC(A1,A2,-95,100)"); // negative price
|
||||
|
||||
model._set("D1", "=DISC(A1,A2,0,100)"); // zero price
|
||||
model._set("D2", "=DISC(A1,A2,95,0)"); // zero redemption
|
||||
model._set("D3", "=DISC(A1,A2,-95,100)"); // negative price
|
||||
|
||||
model._set("E1", "=RECEIVED(A1,A2,0,0.05)"); // zero investment
|
||||
model._set("E2", "=RECEIVED(A1,A2,1000,0)"); // zero discount
|
||||
model._set("E3", "=RECEIVED(A1,A2,-1000,0.05)"); // negative investment
|
||||
|
||||
model._set("F1", "=INTRATE(A1,A2,0,1050)"); // zero investment
|
||||
model._set("F2", "=INTRATE(A1,A2,1000,0)"); // zero redemption
|
||||
model._set("F3", "=INTRATE(A1,A2,-1000,1050)"); // negative investment
|
||||
|
||||
model._set("G1", "=PRICEMAT(A1,A2,A3,-0.06,0.05)"); // negative rate
|
||||
model._set("G2", "=PRICEMAT(A1,A2,A3,0.06,-0.05)"); // negative yield
|
||||
|
||||
model._set("H1", "=YIELDMAT(A1,A2,A3,0.06,0)"); // zero price
|
||||
model._set("H2", "=YIELDMAT(A1,A2,A3,-0.06,99)"); // negative rate
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B2"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_yield_invalid_dates() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2023,1,1)");
|
||||
model._set("A2", "=DATE(2024,1,1)");
|
||||
|
||||
model._set("B1", "=YIELD(A2,A1,5%,99,100,2)");
|
||||
model._set("B2", "=YIELD(A1,A1,5%,99,100,2)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("B2"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_price_with_basis() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2023,1,1)");
|
||||
model._set("A2", "=DATE(2024,1,1)");
|
||||
|
||||
model._set("B1", "=PRICE(A1,A2,5%,6%,100,2,0)");
|
||||
model._set("B2", "=PRICE(A1,A2,5%,6%,100,2,1)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert!(model._get_text("B1").parse::<f64>().is_ok());
|
||||
assert!(model._get_text("B2").parse::<f64>().is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_yield_with_basis() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2023,1,1)");
|
||||
model._set("A2", "=DATE(2024,1,1)");
|
||||
|
||||
model._set("B1", "=YIELD(A1,A2,5%,99,100,2,0)");
|
||||
model._set("B2", "=YIELD(A1,A2,5%,99,100,2,1)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert!(model._get_text("B1").parse::<f64>().is_ok());
|
||||
assert!(model._get_text("B2").parse::<f64>().is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_price_yield_inverse_functions() {
|
||||
// Verifies PRICE and YIELD are mathematical inverses
|
||||
// Regression test for periods calculation type mismatch
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", "=DATE(2023,1,15)");
|
||||
model._set("A2", "=DATE(2024,7,15)"); // ~1.5 years, fractional periods
|
||||
model._set("A3", "4.75%"); // coupon
|
||||
model._set("A4", "5.125%"); // yield
|
||||
|
||||
model._set("B1", "=PRICE(A1,A2,A3,A4,100,2)");
|
||||
model._set("B2", "=YIELD(A1,A2,A3,B1,100,2)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
let calculated_yield: f64 = model._get_text("B2").parse().unwrap();
|
||||
let expected_yield = 0.05125;
|
||||
|
||||
assert!(
|
||||
(calculated_yield - expected_yield).abs() < 1e-12,
|
||||
"YIELD should recover original yield: expected {expected_yield}, got {calculated_yield}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_price_yield_round_trip_stability() {
|
||||
// Tests numerical stability through multiple PRICE->YIELD->PRICE cycles
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", "=DATE(2023,3,10)");
|
||||
model._set("A2", "=DATE(2024,11,22)"); // Irregular period length
|
||||
model._set("A3", "3.25%"); // coupon rate
|
||||
model._set("A4", "4.875%"); // initial yield
|
||||
|
||||
// First round-trip
|
||||
model._set("B1", "=PRICE(A1,A2,A3,A4,100,4)");
|
||||
model._set("B2", "=YIELD(A1,A2,A3,B1,100,4)");
|
||||
|
||||
// Second round-trip
|
||||
model._set("B3", "=PRICE(A1,A2,A3,B2,100,4)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
let price1: f64 = model._get_text("B1").parse().unwrap();
|
||||
let price2: f64 = model._get_text("B3").parse().unwrap();
|
||||
|
||||
assert!(
|
||||
(price1 - price2).abs() < 1e-10,
|
||||
"Round-trip should be stable: {price1} vs {price2}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_bond_functions_basis_validation() {
|
||||
let mut model = new_empty_model();
|
||||
|
||||
model._set("A1", "=DATE(2022,1,1)");
|
||||
model._set("A2", "=DATE(2022,12,31)");
|
||||
model._set("A3", "=DATE(2021,1,1)");
|
||||
|
||||
// Test valid basis values (0-4)
|
||||
model._set("B1", "=PRICEDISC(A1,A2,0.05,100,0)");
|
||||
model._set("B2", "=PRICEDISC(A1,A2,0.05,100,1)");
|
||||
model._set("B3", "=PRICEDISC(A1,A2,0.05,100,2)");
|
||||
model._set("B4", "=PRICEDISC(A1,A2,0.05,100,3)");
|
||||
model._set("B5", "=PRICEDISC(A1,A2,0.05,100,4)");
|
||||
|
||||
// Test invalid basis values
|
||||
model._set("C1", "=PRICEDISC(A1,A2,0.05,100,-1)");
|
||||
model._set("C2", "=PRICEDISC(A1,A2,0.05,100,5)");
|
||||
model._set("C3", "=YIELDDISC(A1,A2,95,100,10)");
|
||||
model._set("C4", "=DISC(A1,A2,95,100,-5)");
|
||||
model._set("C5", "=RECEIVED(A1,A2,1000,0.05,99)");
|
||||
model._set("C6", "=INTRATE(A1,A2,1000,1050,-2)");
|
||||
model._set("C7", "=PRICEMAT(A1,A2,A3,0.06,0.05,7)");
|
||||
model._set("C8", "=YIELDMAT(A1,A2,A3,0.06,99,-3)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// Valid basis should work
|
||||
assert_ne!(model._get_text("B1"), *"#ERROR!");
|
||||
assert_ne!(model._get_text("B2"), *"#ERROR!");
|
||||
assert_ne!(model._get_text("B3"), *"#ERROR!");
|
||||
assert_ne!(model._get_text("B4"), *"#ERROR!");
|
||||
assert_ne!(model._get_text("B5"), *"#ERROR!");
|
||||
|
||||
// Invalid basis should error
|
||||
assert_eq!(model._get_text("C1"), *"#NUM!");
|
||||
assert_eq!(model._get_text("C2"), *"#NUM!");
|
||||
assert_eq!(model._get_text("C3"), *"#NUM!");
|
||||
assert_eq!(model._get_text("C4"), *"#NUM!");
|
||||
assert_eq!(model._get_text("C5"), *"#NUM!");
|
||||
assert_eq!(model._get_text("C6"), *"#NUM!");
|
||||
assert_eq!(model._get_text("C7"), *"#NUM!");
|
||||
assert_eq!(model._get_text("C8"), *"#NUM!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fn_bond_functions_relationships() {
|
||||
// Test mathematical relationships between functions
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=DATE(2021,1,1)");
|
||||
model._set("A2", "=DATE(2021,7,1)");
|
||||
|
||||
model._set("B1", "=PRICEDISC(A1,A2,5%,100)");
|
||||
model._set("B2", "=YIELDDISC(A1,A2,B1,100)");
|
||||
model._set("B3", "=DISC(A1,A2,B1,100)");
|
||||
model._set("B4", "=RECEIVED(A1,A2,1000,5%)");
|
||||
model._set("B5", "=INTRATE(A1,A2,1000,1050)");
|
||||
model._set("B6", "=PRICEMAT(A1,A2,DATE(2020,7,1),6%,5%)");
|
||||
model._set("B7", "=YIELDMAT(A1,A2,DATE(2020,7,1),6%,99)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(
|
||||
model.get_cell_value_by_ref("Sheet1!B1"),
|
||||
Ok(CellValue::Number(97.5))
|
||||
);
|
||||
if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!B2") {
|
||||
assert!((v - 0.051282051).abs() < 1e-6);
|
||||
}
|
||||
if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!B3") {
|
||||
assert!((v - 0.05).abs() < 1e-6);
|
||||
}
|
||||
if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!B4") {
|
||||
assert!((v - 1025.641025).abs() < 1e-6);
|
||||
}
|
||||
if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!B5") {
|
||||
assert!((v - 0.10).abs() < 1e-6);
|
||||
}
|
||||
if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!B6") {
|
||||
assert!((v - 100.414634).abs() < 1e-6);
|
||||
}
|
||||
if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!B7") {
|
||||
assert!((v - 0.078431372).abs() < 1e-6);
|
||||
}
|
||||
}
|
||||
@@ -2,6 +2,9 @@
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn simple_cases() {}
|
||||
|
||||
#[test]
|
||||
fn wrong_number_of_arguments() {
|
||||
let mut model = new_empty_model();
|
||||
@@ -30,18 +33,8 @@ fn implicit_intersection() {
|
||||
model._set("A2", "=FORMULATEXT(D1:E1)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"#N/IMPL!");
|
||||
assert_eq!(model._get_text("A2"), *"#N/IMPL!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn implicit_intersection_operator() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=1 + 2");
|
||||
model._set("B1", "=FORMULATEXT(@A:A)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("B1"), *"#N/IMPL!");
|
||||
assert_eq!(model._get_text("A1"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user