UPDATE: Adds bincode to serializer/deserializer

.github/workflows/npm.yml

@@ -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 }}

.github/workflows/pypi.yml

@@ -1,143 +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@v3
-        with:
-          name: wheels
-          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@v3
-        with:
-          name: wheels
-          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@v3
-        with:
-          name: wheels
-          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@v3
-        with:
-          name: wheels
-          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@v3
-        with:
-          name: wheels
-          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 *
-          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@v3
-        with:
-          name: wheels
-          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 *
-          working-directory: bindings/python

.github/workflows/rust-build-test.yaml

@@ -16,9 +16,6 @@ jobs:
         steps:
             - uses: actions/checkout@v3
 
-            - name: Install wasm-pack
-              run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
-
             - name: Build
               run: cargo build --release --verbose
 

.github/workflows/test-coverage.yaml

@@ -1,7 +1,6 @@
 name: Coverage
 
-on:
-  workflow_dispatch:
+on: [pull_request, push]
 
 jobs:
   coverage:
@@ -15,11 +14,10 @@ jobs:
       - name: Install cargo-llvm-cov
         uses: taiki-e/install-action@cargo-llvm-cov
       - name: Generate code coverage
-        run: cargo llvm-cov --all-features --workspace --exclude pyroncalc --exclude wasm --lcov --output-path lcov.info
+        run: cargo llvm-cov --all-features --workspace --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

.gitignore

@@ -1,3 +1 @@
-target/*
-**/node_modules/**
-.DS_Store
+target/*

.readthedocs.yaml

@@ -1,32 +0,0 @@
-# .readthedocs.yaml
-# Read the Docs configuration file
-# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
-
-# Required
-version: 2
-
-# Set the OS, Python version and other tools you might need
-build:
-  os: ubuntu-22.04
-  tools:
-    python: "3.12"
-    # You can also specify other tool versions:
-    # nodejs: "19"
-    # rust: "1.64"
-    # golang: "1.19"
-
-# Build documentation in the "docs/" directory with Sphinx
-sphinx:
-  configuration: bindings/python/docs/conf.py
-
-# Optionally build your docs in additional formats such as PDF and ePub
-# formats:
-#    - pdf
-#    - epub
-
-# Optional but recommended, declare the Python requirements required
-# to build your documentation
-# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
-# python:
-#    install:
-#    - requirements: docs/requirements.txt

CHANGELOG.md

@@ -1,36 +0,0 @@
-# CHANGELOG
-
-## Unreleased
-
-### Added
-
-- 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)
-
-### Added
-
-- Rust crate ironcalc_base
-- Rust crate ironcalc
-- Minimal Python bindings (only Linux)
-- JavaScript bindings
-- React WebApp
-
-[0.2.0]: https://github.com/IronCalc/ironcalc/releases/tag/v0.2.0

CONTRIBUTING.md

@@ -1,73 +0,0 @@
-# Contributing to IronCalc
-
-Whether you are a seasoned developer or a rookie, welcome to IronCalc! 
-
-🎉 We appreciate your interest in contributing to our project.
-
-Before starting any work it is best if you get in touch to make sure your work is relevant.
-
-Please be patient, I am only one and this is a side project.
-
----
-
-## 🛠 Changes to the main repo
-
-If are comfortable working with GitHub and Git, the following steps should be straightforward. For more general information visit [GitHub Docs](https://docs.github.com/en) and [Git Documentation](https://git-scm.com/doc). 
-
-1. **Fork the repository**
-   Start by forking the repository to your own GitHub account. You can do this by clicking the "Fork" button on the top right of the repository page.
-
-2. **Clone the original repository**
-   Clone the original repository to your local machine:
-   ```bash
-   git clone https://github.com/ironcalc/IronCalc.git
-   cd IronCalc
-   ```
-
-
-3. **Add your fork as a remote**
-    Add your forked repository as a remote named fork:
-
-    ```bash
-    git remote add fork https://github.com/<your-username>/IronCalc.git
-    ```
-4. **Create a new branch**
-    Always create a new branch for your changes to keep your work isolated:
-
-    ```bash
-    git checkout -b your-feature-name
-    ```
-5. **Make changes**
-    Implement your changes, improvements, or bug fixes. Make sure to follow any coding style or project-specific guidelines.
-
-6. **Commit your changes**
-    Write clear and concise commit messages:
-
-    ```bash
-    git add .
-    git commit -m "Brief description of your changes"
-    ```
-7. **Push to your fork**
-    Push your branch to your forked repository:
-    ```bash
-    git push fork your-feature-name
-    ````
-
-8. **Create a Pull Request (PR)**
-   Follow the steps on the terminal or go to the orig IronCalc repository, and click on "New Pull Request."
-   Ensure your PR has a clear title and description explaining the purpose of your changes.
-
-Always start from the main branch in a clean state. `git pull` will generally get the lastest changes form the original repo.
-
-You should make sure that your changes are properly tested.
-
-# 🤝 Community and Support
-
-Feel free to reach out if you have questions or need help. Via GitHub, email, our discord server or bluesky.
-
-* Open an issue to report a bug or discuss a feature before implementing it.
-* Engage with the community to share ideas or seek guidance.
-
-Note that not all contributors need to be coding. To contribute testing, bug reports, typos, ideas of all kinds, you can just send us an email.
-
-Thank you for your contributions! 💪 Together, we can make IronCalc even better.

Cargo.toml

@@ -4,14 +4,10 @@ resolver = "2"
 members = [
   "base",
   "xlsx",
-  "bindings/wasm",
-  "bindings/python",
-  "bindings/nodejs",
 ]
 
 exclude = [
   "generate_locale",
-  "webapp/app.ironcalc.com/server",
 ]
 
 [profile.release]

Makefile

@@ -1,46 +1,33 @@
-.PHONY: lint
 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
+	cargo clippy --all-targets --all-features
 
-.PHONY: format
 format:
 	cargo fmt
 
-.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 bindings/python && ./run_tests.sh && ./run_examples.sh
+	make remove-xlsx
 
-.PHONY: remove-artifacts
-remove-artifacts:
+remove-xlsx:
 	rm -f xlsx/hello-calc.xlsx
 	rm -f xlsx/hello-styles.xlsx
 	rm -f xlsx/widths-and-heights.xlsx
 
-.PHONY: clean
-clean: remove-artifacts
+clean: remove-xlsx
 	cargo clean
 	rm -r -f base/target
 	rm -r -f xlsx/target
-	rm -r -f bindings/python/target
-	rm -r -f bindings/wasm/targets
 	rm -f cargo-test-*
 	rm -f base/cargo-test-*
 	rm -f xlsx/cargo-test-*
 
-.PHONY: coverage
+
 coverage:
 	CARGO_INCREMENTAL=0 RUSTFLAGS='-C instrument-coverage' LLVM_PROFILE_FILE='cargo-test-%p-%m.profraw' cargo test
 	grcov . --binary-path ./target/debug/deps/ -s . -t html --branch --ignore-not-existing --ignore '../*' --ignore "/*" -o target/coverage/html
 
-.PHONY: docs
 docs:
 	cargo doc --no-deps
+
+.PHONY: lint format tests docs coverage all

README.md

@@ -123,12 +123,12 @@ See https://github.com/ironcalc
 
 An early preview of the technology running entirely in your browser:
 
-https://app.ironcalc.com
+https://playground.ironcalc.com
 
 
 # Collaborators needed!. Call to action
 
-We don't have a vibrant community just yet. This is the very stages of the project. But if you are passionate about code with high standards and no compromises, if you are looking for a project with high impact, if you are interested in a better, more open infrastructure for spreadsheets, whether you are a developer (rust, python, TypeScript, electron/tauri/anything else native app, React, you name it), a designer, an Excel power user who wants features, a business looking to integrate a MIT/Apache licensed spreadsheet in your own SaaS application join us!
+We don't have a vibrant community just yet. This is the very stages of the project. But if you are passionate about code with high standards and no compromises, if you are looking for a project with high impact, if you are interested in a better, more open infrastructure for spreadsheets, whether you are a developer (rust, python, TypeScript, electron/tauri/anything else native app, React, you name it), a designer (we need a logo desperately!), an Excel power user who wants features, a business looking to integrate a MIT/Apache licensed spreadsheet in your own SaaS application join us!
 
 The best place to start will be to join or [discord channel](https://discord.gg/zZYWfh3RHJ) or send us an email at hello@ironcalc.com.
 

assets/icon/ironcalc_icon.svg

@@ -1,8 +0,0 @@
-<svg width="600" height="600" viewBox="0 0 600 600" fill="none" xmlns="http://www.w3.org/2000/svg">
-<rect width="600" height="600" rx="20" fill="#F2994A"/>
-<path opacity="0.8" fill-rule="evenodd" clip-rule="evenodd" d="M348.98 100C348.98 166.034 322.748 229.362 276.055 276.055C268.163 283.947 259.796 291.255 251.021 297.95L251.021 500L348.98 500H251.021C251.021 433.966 277.252 370.637 323.945 323.945C331.837 316.053 340.204 308.745 348.98 302.05L348.98 100Z" fill="white"/>
-<path opacity="0.8" fill-rule="evenodd" clip-rule="evenodd" d="M251.021 100.068C251.003 140.096 235.094 178.481 206.788 206.787C178.466 235.109 140.053 251.02 100 251.02V348.979C154.873 348.979 207.877 330.866 251.021 297.95V100.068Z" fill="white"/>
-<path opacity="0.8" fill-rule="evenodd" clip-rule="evenodd" d="M348.98 499.882C349.011 459.872 364.918 421.507 393.213 393.213C421.534 364.891 459.947 348.98 500 348.98V251.02C445.128 251.02 392.123 269.134 348.98 302.05V499.882Z" fill="white"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M276.055 276.055C322.748 229.362 348.98 166.034 348.98 100H251.021V297.95C259.796 291.255 268.163 283.947 276.055 276.055Z" fill="white"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M348.98 302.05V499.895C348.98 499.93 348.98 499.965 348.98 500L251.021 500C251.021 499.946 251.02 499.891 251.021 499.837C251.064 433.862 277.291 370.599 323.945 323.945C331.837 316.053 340.204 308.745 348.98 302.05Z" fill="white"/>
-</svg>

base/Cargo.toml

@@ -1,38 +1,30 @@
 [package]
 name = "ironcalc_base"
-version = "0.3.0"
+version = "0.1.2"
 authors = ["Nicolás Hatcher <nicolas@theuniverse.today>"]
-edition = "2024"
+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
 
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+serde_repr = "0.1"
 ryu = "1.0"
 chrono = "0.4"
-chrono-tz = "0.10"
-regex = { version = "1.0", optional = true}
-regex-lite = { version = "0.1.6", optional = true}
+chrono-tz = "0.7.0"
+regex = "1.0"
 once_cell = "1.16.0"
-bitcode = "0.6.3"
-csv = "1.3.0"
-
-[features]
-default = ["use_regex_full"]
-use_regex_full = ["regex"]
-use_regex_lite = ["regex-lite"]
-
-[dev-dependencies]
-serde_json = "1.0"
+bincode = "=2.0.0-rc.3"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-js-sys = { version = "0.3.69" }
+js-sys = { version = "0.3.60" }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-rand = "0.8.5"
+rand = "0.8.4"
 
 

base/examples/formulas_and_errors.rs

@@ -1,17 +1,17 @@
-use ironcalc_base::{Model, types::CellType};
+use ironcalc_base::{model::Model, types::CellType};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut model = Model::new_empty("formulas-and-errors", "en", "UTC")?;
     // A1
-    model.set_user_input(0, 1, 1, "1".to_string())?;
+    model.set_user_input(0, 1, 1, "1".to_string());
     // A2
-    model.set_user_input(0, 2, 1, "2".to_string())?;
+    model.set_user_input(0, 2, 1, "2".to_string());
     // A3
-    model.set_user_input(0, 3, 1, "3".to_string())?;
+    model.set_user_input(0, 3, 1, "3".to_string());
     // B1
-    model.set_user_input(0, 1, 2, "=SUM(A1:A3)".to_string())?;
+    model.set_user_input(0, 1, 2, "=SUM(A1:A3)".to_string());
     // B2
-    model.set_user_input(0, 2, 2, "=B1/0".to_string())?;
+    model.set_user_input(0, 2, 2, "=B1/0".to_string());
     // Evaluate
     model.evaluate();
 

base/examples/hello_world.rs

@@ -1,13 +1,13 @@
-use ironcalc_base::{Model, cell::CellValue};
+use ironcalc_base::{cell::CellValue, model::Model};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut model = Model::new_empty("hello-world", "en", "UTC")?;
     // A1
-    model.set_user_input(0, 1, 1, "Hello".to_string())?;
+    model.set_user_input(0, 1, 1, "Hello".to_string());
     // B1
-    model.set_user_input(0, 1, 2, "world!".to_string())?;
+    model.set_user_input(0, 1, 2, "world!".to_string());
     // C1
-    model.set_user_input(0, 1, 3, "=CONCAT(A1, \" \", B1".to_string())?;
+    model.set_user_input(0, 1, 3, "=CONCAT(A1, \" \", B1".to_string());
     // evaluates
     model.evaluate();
 

base/src/actions.rs

@@ -77,13 +77,14 @@ impl Model {
         let style = source_cell.get_style();
         // FIXME: we need some user_input getter instead of get_text
         let formula_or_value = self
-            .get_cell_formula(sheet, source_row, source_column)?
+            .cell_formula(sheet, source_row, source_column)?
             .unwrap_or_else(|| source_cell.get_text(&self.workbook.shared_strings, &self.language));
-        self.set_user_input(sheet, target_row, target_column, formula_or_value)?;
+        self.set_user_input(sheet, target_row, target_column, formula_or_value);
         self.workbook
             .worksheet_mut(sheet)?
-            .set_cell_style(target_row, target_column, style)?;
-        self.cell_clear_all(sheet, source_row, source_column)
+            .set_cell_style(target_row, target_column, style);
+        self.delete_cell(sheet, source_row, source_column)?;
+        Ok(())
     }
 
     /// Inserts one or more new columns into the model at the specified index.
@@ -136,33 +137,6 @@ impl Model {
             }),
         );
 
-        // 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(())
     }
 
@@ -183,11 +157,6 @@ impl Model {
             return Err("Please use insert columns instead".to_string());
         }
 
-        // first column being deleted
-        let column_start = column;
-        // last column being deleted
-        let column_end = column + column_count - 1;
-
         // Move cells
         let worksheet = &self.workbook.worksheet(sheet)?;
         let mut all_rows: Vec<i32> = worksheet.sheet_data.keys().copied().collect();
@@ -197,11 +166,11 @@ impl Model {
         for r in all_rows {
             let columns: Vec<i32> = self.get_columns_for_row(sheet, r, false)?;
             for col in columns {
-                if col >= column_start {
-                    if col > column_end {
+                if col >= column {
+                    if col >= column + column_count {
                         self.move_cell(sheet, r, col, r, col - column_count)?;
                     } else {
-                        self.cell_clear_all(sheet, r, col)?;
+                        self.delete_cell(sheet, r, col)?;
                     }
                 }
             }
@@ -215,64 +184,6 @@ impl Model {
                 delta: -column_count,
             }),
         );
-        let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
-
-        // deletes all the column styles
-        let mut new_columns = Vec::new();
-        for col in worksheet.cols.iter_mut() {
-            // range under study
-            let min = col.min;
-            let max = col.max;
-            // In the diagram:
-            // |xxxxx| range we are studying [min, max]
-            // |*****| range we are deleting [column_start, column_end]
-            // we are going to split it in three big cases:
-            // ----------------|xxxxxxxx|-----------------
-            // -----|*****|------------------------------- Case A
-            // -------|**********|------------------------ Case B
-            // -------------|**************|-------------- Case C
-            // ------------------|****|------------------- Case D
-            // ---------------------|**********|---------- Case E
-            // -----------------------------|*****|------- Case F
-            if column_start < min {
-                if column_end < min {
-                    // Case A
-                    // We displace all columns
-                    let mut new_column = col.clone();
-                    new_column.min = min - column_count;
-                    new_column.max = max - column_count;
-                    new_columns.push(new_column);
-                } else if column_end < max {
-                    // Case B
-                    // We displace the end
-                    let mut new_column = col.clone();
-                    new_column.min = column_start;
-                    new_column.max = max - column_count;
-                    new_columns.push(new_column);
-                } else {
-                    // Case C
-                    // skip this, we are deleting the whole range
-                }
-            } else if column_start <= max {
-                if column_end <= max {
-                    // Case D
-                    // We displace the end
-                    let mut new_column = col.clone();
-                    new_column.max = max - column_count;
-                    new_columns.push(new_column);
-                } else {
-                    // Case E
-                    let mut new_column = col.clone();
-                    new_column.max = column_start - 1;
-                    new_columns.push(new_column);
-                }
-            } else {
-                // Case F
-                // No action required
-                new_columns.push(col.clone());
-            }
-        }
-        worksheet.cols = new_columns;
 
         Ok(())
     }
@@ -372,7 +283,7 @@ impl Model {
                     // remove all cells in row
                     // FIXME: We could just remove the entire row in one go
                     for column in columns {
-                        self.cell_clear_all(sheet, r, column)?;
+                        self.delete_cell(sheet, r, column)?;
                     }
                 }
             }
@@ -410,11 +321,11 @@ impl Model {
     ///    * All cell references to initial_column will go to target_column
     ///    * All cell references to columns in between (initial_column, target_column] will be displaced one to the left
     ///    * All other cell references are left unchanged
-    ///      Ranges. This is the tricky bit:
+    /// Ranges. This is the tricky bit:
     ///    * 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 does NOT move the data in the columns or move the colum styles
+    /// NOTE: This does NOT move the data in the columns or move the colum styles
     pub fn move_column_action(
         &mut self,
         sheet: u32,

base/src/calc_result.rs

@@ -2,7 +2,6 @@ use std::cmp::Ordering;
 
 use crate::expressions::{token::Error, types::CellReferenceIndex};
 
-#[derive(Clone)]
 pub struct Range {
     pub left: CellReferenceIndex,
     pub right: CellReferenceIndex,

base/src/cell.rs

@@ -1,9 +1,12 @@
 use crate::{
     expressions::token::Error, language::Language, number_format::to_excel_precision_str, types::*,
 };
+use serde::{Deserialize, Serialize};
+use serde_json::json;
 
 /// A CellValue is the representation of the cell content.
-#[derive(Debug, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+#[serde(untagged)]
 pub enum CellValue {
     None,
     String(String),
@@ -11,6 +14,17 @@ pub enum CellValue {
     Boolean(bool),
 }
 
+impl CellValue {
+    pub fn to_json_str(&self) -> String {
+        match &self {
+            CellValue::None => "null".to_string(),
+            CellValue::String(s) => json!(s).to_string(),
+            CellValue::Number(f) => json!(f).to_string(),
+            CellValue::Boolean(b) => json!(b).to_string(),
+        }
+    }
+}
+
 impl From<f64> for CellValue {
     fn from(value: f64) -> Self {
         Self::Number(value)

base/src/constants.rs

@@ -2,12 +2,10 @@
 /// COLUMN_WIDTH and ROW_HEIGHT are pixel values
 /// A column width of Excel value `w` will result in `w * COLUMN_WIDTH_FACTOR` pixels
 /// Note that these constants are inlined
-pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 125.0;
-pub(crate) const DEFAULT_ROW_HEIGHT: f64 = 28.0;
+pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 100.0;
+pub(crate) const DEFAULT_ROW_HEIGHT: f64 = 21.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_WIDTH: i64 = 800;
 
 pub(crate) const LAST_COLUMN: i32 = 16_384;
 pub(crate) const LAST_ROW: i32 = 1_048_576;
@@ -16,10 +14,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;

base/src/diffs.rs

@@ -2,7 +2,7 @@ use crate::{
     expressions::{
         parser::{
             move_formula::ref_is_in_area,
-            stringify::{DisplaceData, to_string, to_string_displaced},
+            stringify::{to_string, to_string_displaced, DisplaceData},
             walk::forward_references,
         },
         types::{Area, CellReferenceIndex, CellReferenceRC},
@@ -26,7 +26,6 @@ pub struct SetCellValue {
 }
 
 impl Model {
-    #[allow(clippy::expect_used)]
     pub(crate) fn shift_cell_formula(
         &mut self,
         sheet: u32,
@@ -58,7 +57,6 @@ impl Model {
         }
     }
 
-    #[allow(clippy::expect_used)]
     pub fn forward_references(
         &mut self,
         source_area: &Area,

base/src/expressions/lexer/mod.rs

@@ -308,9 +308,9 @@ impl Lexer {
                                 return self.consume_range(None);
                             }
                             let name_upper = name.to_ascii_uppercase();
-                            if name_upper == self.language.booleans.r#true {
+                            if name_upper == self.language.booleans.true_value {
                                 return TokenType::Boolean(true);
-                            } else if name_upper == self.language.booleans.r#false {
+                            } else if name_upper == self.language.booleans.false_value {
                                 return TokenType::Boolean(false);
                             }
                             if self.mode == LexerMode::A1 {
@@ -660,8 +660,8 @@ impl Lexer {
     fn consume_error(&mut self) -> TokenType {
         let errors = &self.language.errors;
         let rest_of_formula: String = self.chars[self.position - 1..self.len].iter().collect();
-        if rest_of_formula.starts_with(&errors.r#ref) {
-            self.position += errors.r#ref.chars().count() - 1;
+        if rest_of_formula.starts_with(&errors.ref_value) {
+            self.position += errors.ref_value.chars().count() - 1;
             return TokenType::Error(Error::REF);
         } else if rest_of_formula.starts_with(&errors.name) {
             self.position += errors.name.chars().count() - 1;

base/src/expressions/lexer/ranges.rs

@@ -149,16 +149,14 @@ impl Lexer {
                         Ok(n) => n,
                         Err(_) => {
                             return Err(self
-                                .set_error(&format!("Failed parsing row {}", row_left), position));
+                                .set_error(&format!("Failed parsing row {}", row_left), position))
                         }
                     };
                     let row_right = match row_right.parse::<i32>() {
                         Ok(n) => n,
                         Err(_) => {
-                            return Err(self.set_error(
-                                &format!("Failed parsing row {}", row_right),
-                                position,
-                            ));
+                            return Err(self
+                                .set_error(&format!("Failed parsing row {}", row_right), position))
                         }
                     };
                     if row_left > LAST_ROW {

base/src/expressions/lexer/test/test_locale.rs

@@ -6,11 +6,11 @@ use crate::{
         token::TokenType,
     },
     language::get_language,
-    locale::get_locale,
+    locale::get_locale_fix,
 };
 
 fn new_language_lexer(formula: &str, locale: &str, language: &str) -> Lexer {
-    let locale = get_locale(locale).unwrap();
+    let locale = get_locale_fix(locale).unwrap();
     let language = get_language(language).unwrap();
     Lexer::new(formula, LexerMode::A1, locale, language)
 }

base/src/expressions/lexer/test/test_util.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::expect_used)]
-
 use crate::expressions::{
     lexer::util::get_tokens,
     token::{OpCompare, OpSum, TokenType},
@@ -24,25 +22,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!(

base/src/expressions/lexer/util.rs

@@ -52,9 +52,7 @@ pub fn get_tokens(formula: &str) -> Vec<MarkedToken> {
     let mut lexer = Lexer::new(
         formula,
         LexerMode::A1,
-        #[allow(clippy::expect_used)]
         get_locale("en").expect(""),
-        #[allow(clippy::expect_used)]
         get_language("en").expect(""),
     );
     let mut start = lexer.get_position();

base/src/expressions/parser/mod.rs

@@ -49,15 +49,21 @@ 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(
         formula,
         lexer::LexerMode::A1,
-        #[allow(clippy::expect_used)]
         get_locale("en").expect(""),
-        #[allow(clippy::expect_used)]
         get_language("en").expect(""),
     );
     if let TokenType::Range {
@@ -164,9 +170,7 @@ pub enum Node {
         args: Vec<Node>,
     },
     ArrayKind(Vec<Node>),
-    DefinedNameKind((String, Option<u32>)),
-    TableNameKind(String),
-    WrongVariableKind(String),
+    VariableKind(String),
     CompareKind {
         kind: OpCompare,
         left: Box<Node>,
@@ -189,35 +193,22 @@ pub enum Node {
 pub struct Parser {
     lexer: lexer::Lexer,
     worksheets: Vec<String>,
-    defined_names: Vec<(String, Option<u32>)>,
-    context: CellReferenceRC,
+    context: Option<CellReferenceRC>,
     tables: HashMap<String, Table>,
 }
 
 impl Parser {
-    pub fn new(
-        worksheets: Vec<String>,
-        defined_names: Vec<(String, Option<u32>)>,
-        tables: HashMap<String, Table>,
-    ) -> Parser {
+    pub fn new(worksheets: Vec<String>, tables: HashMap<String, Table>) -> Parser {
         let lexer = lexer::Lexer::new(
             "",
             lexer::LexerMode::A1,
-            #[allow(clippy::expect_used)]
             get_locale("en").expect(""),
-            #[allow(clippy::expect_used)]
             get_language("en").expect(""),
         );
-        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,
         }
     }
@@ -225,16 +216,11 @@ impl Parser {
         self.lexer.set_lexer_mode(mode)
     }
 
-    pub fn set_worksheets_and_names(
-        &mut self,
-        worksheets: Vec<String>,
-        defined_names: Vec<(String, Option<u32>)>,
-    ) {
+    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.parse_expr()
@@ -250,24 +236,6 @@ impl Parser {
         None
     }
 
-    // Returns:
-    //  * None: If there is no defined name by that name
-    //  * Some(Some(index)): If there is a defined name local to that sheet
-    //  * Some(None): If there is a global defined name
-    fn get_defined_name(&self, name: &str, sheet: u32) -> Option<Option<u32>> {
-        for (df_name, df_scope) in &self.defined_names {
-            if name.to_lowercase() == df_name.to_lowercase() && df_scope == &Some(sheet) {
-                return Some(*df_scope);
-            }
-        }
-        for (df_name, df_scope) in &self.defined_names {
-            if name.to_lowercase() == df_name.to_lowercase() && df_scope.is_none() {
-                return Some(None);
-            }
-        }
-        None
-    }
-
     fn parse_expr(&mut self) -> Node {
         let mut t = self.parse_concat();
         if let Node::ParseErrorKind { .. } = t {
@@ -482,7 +450,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),
@@ -517,7 +494,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),
@@ -532,6 +518,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);
@@ -540,22 +540,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,
@@ -603,33 +587,11 @@ impl Parser {
                             kind: function_kind,
                             args,
                         };
-                    }
-                    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: "sheet not found".to_string(),
-                        };
-                    }
-                };
-
-                // Could be a defined name or a table
-                if let Some(scope) = self.get_defined_name(&name, context_sheet_index) {
-                    return Node::DefinedNameKind((name, scope));
-                }
-                let name_lower = name.to_lowercase();
-                for table_name in self.tables.keys() {
-                    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 {
@@ -642,38 +604,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 {
@@ -732,177 +663,177 @@ 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: "sheet not found".to_string(),
-                        };
-                    }
-                };
-                // 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: "sheet not found".to_string(),
-                        };
-                    }
-                };
-
-                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 = self.tables.get(&table_name).unwrap_or_else(|| {
+                        panic!(
+                            "Table not found: '{table_name}' at '{}!{}{}'",
+                            context.sheet,
+                            number_to_column(context.column).expect(""),
+                            context.row
+                        )
+                    });
+                    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(),
+                            };
                         }
-                    }
-                    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}"
-                                    ),
-                                };
+                    let sheet_name = if table_sheet_index == context_sheet_index {
+                        None
+                    } else {
+                        Some(table.sheet_name.clone())
+                    };
+
+                    // context must be with tables.reference
+                    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(),
                 }
             }
         }

base/src/expressions/parser/move_formula.rs

@@ -1,6 +1,6 @@
 use super::{
+    stringify::{stringify_reference, DisplaceData},
     Node, Reference,
-    stringify::{DisplaceData, stringify_reference},
 };
 use crate::{
     constants::{LAST_COLUMN, LAST_ROW},
@@ -375,9 +375,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> 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),

base/src/expressions/parser/stringify.rs

@@ -456,69 +456,11 @@ fn stringify(
             };
             format!("{}{}{}", x, kind, y)
         }
-        OpPowerKind { left, right } => {
-            let x = match **left {
-                BooleanKind(_)
-                | NumberKind(_)
-                | StringKind(_)
-                | ReferenceKind { .. }
-                | RangeKind { .. }
-                | WrongReferenceKind { .. }
-                | DefinedNameKind(_)
-                | TableNameKind(_)
-                | WrongVariableKind(_)
-                | WrongRangeKind { .. } => {
-                    stringify(left, context, displace_data, use_original_name)
-                }
-                OpRangeKind { .. }
-                | OpConcatenateKind { .. }
-                | OpProductKind { .. }
-                | OpPowerKind { .. }
-                | FunctionKind { .. }
-                | InvalidFunctionKind { .. }
-                | ArrayKind(_)
-                | UnaryKind { .. }
-                | ErrorKind(_)
-                | ParseErrorKind { .. }
-                | OpSumKind { .. }
-                | CompareKind { .. }
-                | EmptyArgKind => format!(
-                    "({})",
-                    stringify(left, context, displace_data, use_original_name)
-                ),
-            };
-            let y = match **right {
-                BooleanKind(_)
-                | NumberKind(_)
-                | StringKind(_)
-                | ReferenceKind { .. }
-                | RangeKind { .. }
-                | WrongReferenceKind { .. }
-                | DefinedNameKind(_)
-                | TableNameKind(_)
-                | WrongVariableKind(_)
-                | WrongRangeKind { .. } => {
-                    stringify(right, context, displace_data, use_original_name)
-                }
-                OpRangeKind { .. }
-                | OpConcatenateKind { .. }
-                | OpProductKind { .. }
-                | OpPowerKind { .. }
-                | FunctionKind { .. }
-                | InvalidFunctionKind { .. }
-                | ArrayKind(_)
-                | UnaryKind { .. }
-                | ErrorKind(_)
-                | ParseErrorKind { .. }
-                | OpSumKind { .. }
-                | CompareKind { .. }
-                | EmptyArgKind => format!(
-                    "({})",
-                    stringify(right, context, displace_data, use_original_name)
-                ),
-            };
-            format!("{}^{}", x, 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, use_original_name)
         }
@@ -547,9 +489,7 @@ fn stringify(
             }
             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 => {
                 format!(
@@ -666,90 +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);
-        }
-
-        // 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(_) => {}
-    }
-}

base/src/expressions/parser/test.rs

@@ -1,13 +1,17 @@
-#![allow(clippy::panic)]
-
 use std::collections::HashMap;
 
 use crate::expressions::lexer::LexerMode;
-use crate::expressions::parser::stringify::{
-    DisplaceData, to_rc_format, to_string, to_string_displaced,
+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 +21,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 +29,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 +44,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 +59,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 +74,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 +90,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 +106,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 +121,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 +142,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 +150,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 +171,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 +179,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 +200,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 +208,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 +229,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 +263,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 +277,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 +328,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 +342,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 +351,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 +367,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 +383,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 +399,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 +411,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 +431,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 +444,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 +464,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 +484,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,

base/src/expressions/parser/test_move_formula.rs

@@ -1,8 +1,10 @@
 use std::collections::HashMap;
 
-use crate::expressions::parser::Parser;
-use crate::expressions::parser::move_formula::{MoveContext, move_formula};
-use crate::expressions::types::{Area, CellReferenceRC};
+use crate::expressions::parser::move_formula::{move_formula, MoveContext};
+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", context);
+    let node = parser.parse("X9^C2-F4*H2", &Some(context.clone()));
     let t = move_formula(
         &node,
         &MoveContext {
@@ -402,7 +404,7 @@ fn test_move_formula_misc() {
     );
     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 {

base/src/expressions/parser/test_ranges.rs

@@ -2,9 +2,9 @@ use std::collections::HashMap;
 
 use crate::expressions::lexer::LexerMode;
 
-use crate::expressions::parser::Parser;
-use crate::expressions::parser::stringify::{to_rc_format, to_string};
-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),

base/src/expressions/parser/test_tables.rs

@@ -6,8 +6,8 @@ use crate::expressions::parser::stringify::to_string;
 use crate::expressions::utils::{number_to_column, parse_reference_a1};
 use crate::types::{Table, TableColumn, TableStyleInfo};
 
-use crate::expressions::parser::Parser;
-use crate::expressions::types::CellReferenceRC;
+use super::super::types::CellReferenceRC;
+use super::Parser;
 
 fn create_test_table(
     table_name: &str,
@@ -63,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(),
@@ -72,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
@@ -82,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'
@@ -92,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)"

base/src/expressions/parser/tests/mod.rs

@@ -1,6 +0,0 @@
-mod test_general;
-mod test_issue_155;
-mod test_move_formula;
-mod test_ranges;
-mod test_stringify;
-mod test_tables;

base/src/expressions/parser/tests/test_issue_155.rs

@@ -1,69 +0,0 @@
-#![allow(clippy::panic)]
-
-use std::collections::HashMap;
-
-use crate::expressions::parser::Parser;
-use crate::expressions::parser::stringify::to_string;
-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");
-}

base/src/expressions/parser/tests/test_stringify.rs

@@ -1,34 +0,0 @@
-#![allow(clippy::panic)]
-
-use std::collections::HashMap;
-
-use crate::expressions::parser::Parser;
-use crate::expressions::parser::stringify::to_string;
-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");
-}

base/src/expressions/parser/walk.rs

@@ -1,4 +1,4 @@
-use super::{Node, move_formula::ref_is_in_area};
+use super::{move_formula::ref_is_in_area, Node};
 
 use crate::expressions::types::{Area, CellReferenceIndex};
 
@@ -263,9 +263,7 @@ pub(crate) fn forward_references(
         // TODO: Not implemented
         Node::ArrayKind(_) => {}
         // Do nothing. Note: we could do a blanket _ => {}
-        Node::DefinedNameKind(_) => {}
-        Node::TableNameKind(_) => {}
-        Node::WrongVariableKind(_) => {}
+        Node::VariableKind(_) => {}
         Node::ErrorKind(_) => {}
         Node::ParseErrorKind { .. } => {}
         Node::EmptyArgKind => {}

base/src/expressions/token.rs

@@ -1,7 +1,8 @@
 use std::fmt;
 
-use bitcode::{Decode, Encode};
+use bincode::{Decode, Encode};
 use serde::{Deserialize, Serialize};
+use serde_repr::{Deserialize_repr, Serialize_repr};
 
 use crate::language::Language;
 
@@ -79,8 +80,9 @@ impl fmt::Display for OpProduct {
 /// Note that "#ERROR!" and "#N/IMPL!" are not part of the xlsx standard
 ///  * "#ERROR!" means there was an error processing the formula (for instance "=A1+")
 ///  * "#N/IMPL!" means the formula or feature in Excel but has not been implemented in IronCalc
-///    Note that they are serialized/deserialized by index
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+/// Note that they are serialized/deserialized by index
+#[derive(Serialize_repr, Deserialize_repr, Decode, Encode, Debug, PartialEq, Eq, Clone)]
+#[repr(u8)]
 pub enum Error {
     REF,
     NAME,
@@ -118,7 +120,7 @@ impl Error {
     pub fn to_localized_error_string(&self, language: &Language) -> String {
         match self {
             Error::NULL => language.errors.null.to_string(),
-            Error::REF => language.errors.r#ref.to_string(),
+            Error::REF => language.errors.ref_value.to_string(),
             Error::NAME => language.errors.name.to_string(),
             Error::VALUE => language.errors.value.to_string(),
             Error::DIV => language.errors.div.to_string(),
@@ -135,7 +137,7 @@ impl Error {
 
 pub fn get_error_by_name(name: &str, language: &Language) -> Option<Error> {
     let errors = &language.errors;
-    if name == errors.r#ref {
+    if name == errors.ref_value {
         return Some(Error::REF);
     } else if name == errors.name {
         return Some(Error::NAME);

base/src/formatter/dates.rs

@@ -1,158 +1,17 @@
 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;
 
-#[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
-        ));
-    };
-    #[allow(clippy::expect_used)]
+pub fn from_excel_date(days: i64) -> NaiveDate {
     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)),
+        Some(native_date) => Ok(native_date.num_days_from_ce() - EXCEL_DATE_BASE),
         None => Err("Out of range parameters for date".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("Out of range parameters for date".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("Out of range parameters for date".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("Out of range parameters for date".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("Out of range parameters for date".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),
-        );
-    }
-}

base/src/formatter/format.rs

@@ -154,16 +154,15 @@ 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 date = match from_excel_date(value as i64) {
-                Ok(d) => d,
-                Err(e) => {
-                    return Formatted {
-                        text: "#VALUE!".to_owned(),
-                        color: None,
-                        error: Some(e),
-                    };
-                }
-            };
+            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) => {
@@ -246,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
@@ -391,7 +387,11 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                             if l_exp <= p.exponent_digit_count {
                                 if !(number_index < 0 && digit.kind == '#') {
                                     let c = if number_index < 0 {
-                                        if digit.kind == '?' { ' ' } else { '0' }
+                                        if digit.kind == '?' {
+                                            ' '
+                                        } else {
+                                            '0'
+                                        }
                                     } else {
                                         exponent_part[number_index as usize]
                                     };

base/src/formatter/lexer.rs

@@ -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
@@ -275,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() {

base/src/formatter/mod.rs

@@ -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

base/src/formatter/parser.rs

@@ -40,7 +40,6 @@ pub struct NumberPart {
     pub is_scientific: bool,
     pub scientific_minus: bool,
     pub exponent_digit_count: i32,
-    pub currency: Option<char>,
 }
 
 pub struct DatePart {
@@ -115,7 +114,6 @@ impl Parser {
         let mut exponent_digit_count = 0;
         let mut number = 'i';
         let mut index = 0;
-        let mut currency = None;
 
         while token != Token::EOF && token != Token::Separator {
             let next_token = self.lexer.next_token();
@@ -172,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: '?',
@@ -296,7 +291,6 @@ impl Parser {
                 is_scientific,
                 scientific_minus,
                 exponent_digit_count,
-                currency,
             })
         }
     }

base/src/formatter/test/test_general.rs

@@ -2,7 +2,7 @@
 
 use crate::{
     formatter::format::format_number,
-    locale::{Locale, get_locale},
+    locale::{get_locale, Locale},
 };
 
 fn get_default_locale() -> &'static Locale {
@@ -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();

base/src/functions/date_and_time.rs

@@ -1,13 +1,11 @@
-use chrono::DateTime;
 use chrono::Datelike;
 use chrono::Months;
+use chrono::NaiveDateTime;
+use chrono::TimeZone;
 use chrono::Timelike;
 
-use crate::constants::MAXIMUM_DATE_SERIAL_NUMBER;
-use crate::constants::MINIMUM_DATE_SERIAL_NUMBER;
 use crate::expressions::types::CellReferenceIndex;
 use crate::formatter::dates::date_to_serial_number;
-use crate::formatter::dates::permissive_date_to_serial_number;
 use crate::model::get_milliseconds_since_epoch;
 use crate::{
     calc_result::CalcResult, constants::EXCEL_DATE_BASE, expressions::parser::Node,
@@ -21,19 +19,20 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let serial_number = match self.get_number(&args[0], cell) {
-            Ok(c) => c.floor() as i64,
+            Ok(c) => {
+                let t = c.floor() as i64;
+                if t < 0 {
+                    return CalcResult::Error {
+                        error: Error::NUM,
+                        origin: cell,
+                        message: "Function DAY parameter 1 value is negative. It should be positive or zero.".to_string(),
+                    };
+                }
+                t
+            }
             Err(s) => return s,
         };
-        let date = match from_excel_date(serial_number) {
-            Ok(date) => date,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Out of range parameters for date".to_string(),
-                };
-            }
-        };
+        let date = from_excel_date(serial_number);
         let day = date.day() as f64;
         CalcResult::Number(day)
     }
@@ -44,19 +43,20 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let serial_number = match self.get_number(&args[0], cell) {
-            Ok(c) => c.floor() as i64,
+            Ok(c) => {
+                let t = c.floor() as i64;
+                if t < 0 {
+                    return CalcResult::Error {
+                        error: Error::NUM,
+                        origin: cell,
+                        message: "Function MONTH parameter 1 value is negative. It should be positive or zero.".to_string(),
+                    };
+                }
+                t
+            }
             Err(s) => return s,
         };
-        let date = match from_excel_date(serial_number) {
-            Ok(date) => date,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Out of range parameters for date".to_string(),
-                };
-            }
-        };
+        let date = from_excel_date(serial_number);
         let month = date.month() as f64;
         CalcResult::Number(month)
     }
@@ -80,23 +80,6 @@ impl Model {
             }
             Err(s) => return s,
         };
-        let date = match from_excel_date(serial_number) {
-            Ok(date) => date,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Out of range parameters for date".to_string(),
-                };
-            }
-        };
-        if serial_number > MAXIMUM_DATE_SERIAL_NUMBER as i64 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Function DAY parameter 1 value is too large.".to_string(),
-            };
-        }
 
         let months = match self.get_number_no_bools(&args[1], cell) {
             Ok(c) => {
@@ -109,9 +92,9 @@ impl Model {
         let months_abs = months.unsigned_abs();
 
         let native_date = if months > 0 {
-            date + Months::new(months_abs)
+            from_excel_date(serial_number) + Months::new(months_abs)
         } else {
-            date - Months::new(months_abs)
+            from_excel_date(serial_number) - Months::new(months_abs)
         };
 
         // Instead of calculating the end of month we compute the first day of the following month
@@ -155,18 +138,32 @@ impl Model {
         let month = match self.get_number(&args[1], cell) {
             Ok(c) => {
                 let t = c.floor();
-                t as i32
+                if t < 0.0 {
+                    return CalcResult::Error {
+                        error: Error::NUM,
+                        origin: cell,
+                        message: "Out of range parameters for date".to_string(),
+                    };
+                }
+                t as u32
             }
             Err(s) => return s,
         };
         let day = match self.get_number(&args[2], cell) {
             Ok(c) => {
                 let t = c.floor();
-                t as i32
+                if t < 0.0 {
+                    return CalcResult::Error {
+                        error: Error::NUM,
+                        origin: cell,
+                        message: "Out of range parameters for date".to_string(),
+                    };
+                }
+                t as u32
             }
             Err(s) => return s,
         };
-        match permissive_date_to_serial_number(day, month, year) {
+        match date_to_serial_number(day, month, year) {
             Ok(serial_number) => CalcResult::Number(serial_number as f64),
             Err(message) => CalcResult::Error {
                 error: Error::NUM,
@@ -182,19 +179,20 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let serial_number = match self.get_number(&args[0], cell) {
-            Ok(c) => c.floor() as i64,
+            Ok(c) => {
+                let t = c.floor() as i64;
+                if t < 0 {
+                    return CalcResult::Error {
+                        error: Error::NUM,
+                        origin: cell,
+                        message: "Function YEAR parameter 1 value is negative. It should be positive or zero.".to_string(),
+                    };
+                }
+                t
+            }
             Err(s) => return s,
         };
-        let date = match from_excel_date(serial_number) {
-            Ok(date) => date,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Out of range parameters for date".to_string(),
-                };
-            }
-        };
+        let date = from_excel_date(serial_number);
         let year = date.year() as f64;
         CalcResult::Number(year)
     }
@@ -206,18 +204,19 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let serial_number = match self.get_number(&args[0], cell) {
-            Ok(c) => c.floor() as i64,
-            Err(s) => return s,
-        };
-        let date = match from_excel_date(serial_number) {
-            Ok(date) => date,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Out of range parameters for date".to_string(),
-                };
+            Ok(c) => {
+                let t = c.floor() as i64;
+                if t < 0 {
+                    return CalcResult::Error {
+                        error: Error::NUM,
+                        origin: cell,
+                        message: "Parameter 1 value is negative. It should be positive or zero."
+                            .to_string(),
+                    };
+                }
+                t
             }
+            Err(s) => return s,
         };
 
         let months = match self.get_number(&args[1], cell) {
@@ -231,13 +230,13 @@ impl Model {
         let months_abs = months.unsigned_abs();
 
         let native_date = if months > 0 {
-            date + Months::new(months_abs)
+            from_excel_date(serial_number) + Months::new(months_abs)
         } else {
-            date - Months::new(months_abs)
+            from_excel_date(serial_number) - Months::new(months_abs)
         };
 
         let serial_number = native_date.num_days_from_ce() - EXCEL_DATE_BASE;
-        if serial_number < MINIMUM_DATE_SERIAL_NUMBER {
+        if serial_number < 0 {
             return CalcResult::Error {
                 error: Error::NUM,
                 origin: cell,
@@ -259,16 +258,17 @@ impl Model {
         // milliseconds since January 1, 1970 00:00:00 UTC.
         let milliseconds = get_milliseconds_since_epoch();
         let seconds = milliseconds / 1000;
-        let local_time = match DateTime::from_timestamp(seconds, 0) {
-            Some(dt) => dt.with_timezone(&self.tz),
+        let dt = match NaiveDateTime::from_timestamp_opt(seconds, 0) {
+            Some(dt) => dt,
             None => {
                 return CalcResult::Error {
                     error: Error::ERROR,
                     origin: cell,
                     message: "Invalid date".to_string(),
-                };
+                }
             }
         };
+        let local_time = self.tz.from_utc_datetime(&dt);
         // 693_594 is computed as:
         // NaiveDate::from_ymd(1900, 1, 1).num_days_from_ce() - 2
         // The 2 days offset is because of Excel 1900 bug
@@ -289,16 +289,17 @@ impl Model {
         // milliseconds since January 1, 1970 00:00:00 UTC.
         let milliseconds = get_milliseconds_since_epoch();
         let seconds = milliseconds / 1000;
-        let local_time = match DateTime::from_timestamp(seconds, 0) {
-            Some(dt) => dt.with_timezone(&self.tz),
+        let dt = match NaiveDateTime::from_timestamp_opt(seconds, 0) {
+            Some(dt) => dt,
             None => {
                 return CalcResult::Error {
                     error: Error::ERROR,
                     origin: cell,
                     message: "Invalid date".to_string(),
-                };
+                }
             }
         };
+        let local_time = self.tz.from_utc_datetime(&dt);
         // 693_594 is computed as:
         // NaiveDate::from_ymd(1900, 1, 1).num_days_from_ce() - 2
         // The 2 days offset is because of Excel 1900 bug

base/src/functions/engineering/complex.rs

@@ -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));
         }

base/src/functions/engineering/transcendental/bessel_j0_y0.rs

@@ -57,7 +57,7 @@
 
 use std::f64::consts::FRAC_2_PI;
 
-use super::bessel_util::{FRAC_2_SQRT_PI, HUGE, high_word, split_words};
+use super::bessel_util::{high_word, split_words, FRAC_2_SQRT_PI, HUGE};
 
 // R0/S0 on [0, 2.00]
 const R02: f64 = 1.562_499_999_999_999_5e-2; // 0x3F8FFFFF, 0xFFFFFFFD

base/src/functions/engineering/transcendental/bessel_j1_y1.rs

@@ -56,7 +56,7 @@
 
 use std::f64::consts::FRAC_2_PI;
 
-use super::bessel_util::{FRAC_2_SQRT_PI, HUGE, high_word, split_words};
+use super::bessel_util::{high_word, split_words, FRAC_2_SQRT_PI, HUGE};
 
 // R0/S0 on [0,2]
 const R00: f64 = -6.25e-2; // 0xBFB00000, 0x00000000

base/src/functions/engineering/transcendental/bessel_jn_yn.rs

@@ -40,7 +40,7 @@
 use super::{
     bessel_j0_y0::{j0, y0},
     bessel_j1_y1::{j1, y1},
-    bessel_util::{FRAC_2_SQRT_PI, split_words},
+    bessel_util::{split_words, FRAC_2_SQRT_PI},
 };
 
 // Special cases are:
@@ -232,7 +232,11 @@ pub(crate) fn jn(n: i32, x: f64) -> f64 {
             }
         }
     };
-    if sign == 1 { -b } else { b }
+    if sign == 1 {
+        -b
+    } else {
+        b
+    }
 }
 
 // Yn returns the order-n Bessel function of the second kind.
@@ -317,5 +321,9 @@ pub(crate) fn yn(n: i32, x: f64) -> f64 {
         }
         b
     };
-    if sign > 0 { b } else { -b }
+    if sign > 0 {
+        b
+    } else {
+        -b
+    }
 }

base/src/functions/engineering/transcendental/erf.rs

@@ -45,5 +45,9 @@ pub(crate) fn erf(x: f64) -> f64 {
     }
 
     let res = t * f64::exp(-x_abs * x_abs + 0.5 * (cof[0] + ty * d) - dd);
-    if x < 0.0 { res - 1.0 } else { 1.0 - res }
+    if x < 0.0 {
+        res - 1.0
+    } else {
+        1.0 - res
+    }
 }

base/src/functions/engineering/transcendental/test_bessel.rs

@@ -12,7 +12,7 @@ const EPS_LOW: f64 = 1e-6;
 
 // Known values computed with Arb via Nemo.jl in Julia
 // You can also use Mathematica
-// But please do not use Excel or any other software without arbitrary precision
+/// But please do not use Excel or any other software without arbitrary precision
 
 fn numbers_are_close(a: f64, b: f64) -> bool {
     if a == b {

base/src/functions/financial.rs

@@ -2,7 +2,7 @@ use chrono::Datelike;
 
 use crate::{
     calc_result::CalcResult,
-    constants::{LAST_COLUMN, LAST_ROW, MAXIMUM_DATE_SERIAL_NUMBER, MINIMUM_DATE_SERIAL_NUMBER},
+    constants::{LAST_COLUMN, LAST_ROW},
     expressions::{parser::Node, token::Error, types::CellReferenceIndex},
     formatter::dates::from_excel_date,
     model::Model,
@@ -13,32 +13,37 @@ use super::financial_util::{compute_irr, compute_npv, compute_rate, compute_xirr
 // See:
 // https://github.com/apache/openoffice/blob/c014b5f2b55cff8d4b0c952d5c16d62ecde09ca1/main/scaddins/source/analysis/financial.cxx
 
-fn is_less_than_one_year(start_date: i64, end_date: i64) -> Result<bool, String> {
-    let end = from_excel_date(end_date)?;
-    let start = from_excel_date(start_date)?;
+// FIXME: Is this enough?
+fn is_valid_date(date: f64) -> bool {
+    date > 0.0
+}
+
+fn is_less_than_one_year(start_date: i64, end_date: i64) -> bool {
     if end_date - start_date < 365 {
-        return Ok(true);
+        return true;
     }
+    let end = from_excel_date(end_date);
+    let start = from_excel_date(start_date);
     let end_year = end.year();
     let start_year = start.year();
     if end_year == start_year {
-        return Ok(true);
+        return true;
     }
     if end_year != start_year + 1 {
-        return Ok(false);
+        return false;
     }
     let start_month = start.month();
     let end_month = end.month();
     if end_month < start_month {
-        return Ok(true);
+        return true;
     }
     if end_month > start_month {
-        return Ok(false);
+        return false;
     }
     // we are one year later same month
     let start_day = start.day();
     let end_day = end.day();
-    Ok(end_day <= start_day)
+    end_day <= start_day
 }
 
 fn compute_payment(
@@ -84,9 +89,6 @@ fn compute_future_value(
     if rate == 0.0 {
         return Ok(-pv - pmt * nper);
     }
-    if rate == -1.0 && nper < 0.0 {
-        return Err((Error::DIV, "Divide by zero".to_string()));
-    }
 
     let rate_nper = (1.0 + rate).powf(nper);
     let fv = if period_start {
@@ -192,24 +194,16 @@ fn compute_ppmt(
 // In these formulas the payment (pmt) is normally negative
 
 impl Model {
-    fn get_array_of_numbers_generic(
+    // FIXME: These three functions (get_array_of_numbers..) need to be refactored
+    // They are really similar expect for small issues
+    fn get_array_of_numbers(
         &mut self,
         arg: &Node,
         cell: &CellReferenceIndex,
-        accept_number_node: bool,
-        handle_empty_cell: impl Fn() -> Result<Option<f64>, CalcResult>,
-        handle_non_number_cell: impl Fn() -> Result<Option<f64>, CalcResult>,
     ) -> Result<Vec<f64>, CalcResult> {
         let mut values = Vec::new();
         match self.evaluate_node_in_context(arg, *cell) {
-            CalcResult::Number(value) if accept_number_node => values.push(value),
-            CalcResult::Number(_) => {
-                return Err(CalcResult::new_error(
-                    Error::VALUE,
-                    *cell,
-                    "Expected range of numbers".to_string(),
-                ));
-            }
+            CalcResult::Number(value) => values.push(value),
             CalcResult::Range { left, right } => {
                 if left.sheet != right.sheet {
                     return Err(CalcResult::new_error(
@@ -218,7 +212,6 @@ impl Model {
                         "Ranges are in different sheets".to_string(),
                     ));
                 }
-                let sheet = left.sheet;
                 let row1 = left.row;
                 let mut row2 = right.row;
                 let column1 = left.column;
@@ -226,46 +219,32 @@ impl Model {
                 if row1 == 1 && row2 == LAST_ROW {
                     row2 = self
                         .workbook
-                        .worksheet(sheet)
-                        .map_err(|_| {
-                            CalcResult::new_error(
-                                Error::ERROR,
-                                *cell,
-                                format!("Invalid worksheet index: '{}'", sheet),
-                            )
-                        })?
+                        .worksheet(left.sheet)
+                        .expect("Sheet expected during evaluation.")
                         .dimension()
                         .max_row;
                 }
                 if column1 == 1 && column2 == LAST_COLUMN {
                     column2 = self
                         .workbook
-                        .worksheet(sheet)
-                        .map_err(|_| {
-                            CalcResult::new_error(
-                                Error::ERROR,
-                                *cell,
-                                format!("Invalid worksheet index: '{}'", sheet),
-                            )
-                        })?
+                        .worksheet(left.sheet)
+                        .expect("Sheet expected during evaluation.")
                         .dimension()
                         .max_column;
                 }
-                for row in row1..=row2 {
-                    for column in column1..=column2 {
-                        let cell_ref = CellReferenceIndex { sheet, row, column };
-                        match self.evaluate_cell(cell_ref) {
-                            CalcResult::Number(value) => values.push(value),
-                            error @ CalcResult::Error { .. } => return Err(error),
-                            CalcResult::EmptyCell => {
-                                if let Some(value) = handle_empty_cell()? {
-                                    values.push(value);
-                                }
+                for row in row1..row2 + 1 {
+                    for column in column1..(column2 + 1) {
+                        match self.evaluate_cell(CellReferenceIndex {
+                            sheet: left.sheet,
+                            row,
+                            column,
+                        }) {
+                            CalcResult::Number(value) => {
+                                values.push(value);
                             }
+                            error @ CalcResult::Error { .. } => return Err(error),
                             _ => {
-                                if let Some(value) = handle_non_number_cell()? {
-                                    values.push(value);
-                                }
+                                // We ignore booleans and strings
                             }
                         }
                     }
@@ -273,51 +252,88 @@ impl Model {
             }
             error @ CalcResult::Error { .. } => return Err(error),
             _ => {
-                handle_non_number_cell()?;
+                // We ignore booleans and strings
             }
-        }
+        };
         Ok(values)
     }
 
-    fn get_array_of_numbers(
-        &mut self,
-        arg: &Node,
-        cell: &CellReferenceIndex,
-    ) -> Result<Vec<f64>, CalcResult> {
-        self.get_array_of_numbers_generic(
-            arg,
-            cell,
-            true,        // accept_number_node
-            || Ok(None), // Ignore empty cells
-            || Ok(None), // Ignore non-number cells
-        )
-    }
-
     fn get_array_of_numbers_xpnv(
         &mut self,
         arg: &Node,
         cell: &CellReferenceIndex,
         error: Error,
     ) -> Result<Vec<f64>, CalcResult> {
-        self.get_array_of_numbers_generic(
-            arg,
-            cell,
-            true, // accept_number_node
-            || {
-                Err(CalcResult::new_error(
-                    Error::NUM,
+        let mut values = Vec::new();
+        match self.evaluate_node_in_context(arg, *cell) {
+            CalcResult::Number(value) => values.push(value),
+            CalcResult::Range { left, right } => {
+                if left.sheet != right.sheet {
+                    return Err(CalcResult::new_error(
+                        Error::VALUE,
+                        *cell,
+                        "Ranges are in different sheets".to_string(),
+                    ));
+                }
+                let row1 = left.row;
+                let mut row2 = right.row;
+                let column1 = left.column;
+                let mut column2 = right.column;
+                if row1 == 1 && row2 == LAST_ROW {
+                    row2 = self
+                        .workbook
+                        .worksheet(left.sheet)
+                        .expect("Sheet expected during evaluation.")
+                        .dimension()
+                        .max_row;
+                }
+                if column1 == 1 && column2 == LAST_COLUMN {
+                    column2 = self
+                        .workbook
+                        .worksheet(left.sheet)
+                        .expect("Sheet expected during evaluation.")
+                        .dimension()
+                        .max_column;
+                }
+                for row in row1..row2 + 1 {
+                    for column in column1..(column2 + 1) {
+                        match self.evaluate_cell(CellReferenceIndex {
+                            sheet: left.sheet,
+                            row,
+                            column,
+                        }) {
+                            CalcResult::Number(value) => {
+                                values.push(value);
+                            }
+                            error @ CalcResult::Error { .. } => return Err(error),
+                            CalcResult::EmptyCell => {
+                                return Err(CalcResult::new_error(
+                                    Error::NUM,
+                                    *cell,
+                                    "Expected number".to_string(),
+                                ));
+                            }
+                            _ => {
+                                return Err(CalcResult::new_error(
+                                    error,
+                                    *cell,
+                                    "Expected number".to_string(),
+                                ));
+                            }
+                        }
+                    }
+                }
+            }
+            error @ CalcResult::Error { .. } => return Err(error),
+            _ => {
+                return Err(CalcResult::new_error(
+                    error,
                     *cell,
                     "Expected number".to_string(),
-                ))
-            },
-            || {
-                Err(CalcResult::new_error(
-                    error.clone(),
-                    *cell,
-                    "Expected number".to_string(),
-                ))
-            },
-        )
+                ));
+            }
+        };
+        Ok(values)
     }
 
     fn get_array_of_numbers_xirr(
@@ -325,19 +341,69 @@ impl Model {
         arg: &Node,
         cell: &CellReferenceIndex,
     ) -> Result<Vec<f64>, CalcResult> {
-        self.get_array_of_numbers_generic(
-            arg,
-            cell,
-            false,            // Do not accept a single number node
-            || Ok(Some(0.0)), // Treat empty cells as zero
-            || {
-                Err(CalcResult::new_error(
+        let mut values = Vec::new();
+        match self.evaluate_node_in_context(arg, *cell) {
+            CalcResult::Range { left, right } => {
+                if left.sheet != right.sheet {
+                    return Err(CalcResult::new_error(
+                        Error::VALUE,
+                        *cell,
+                        "Ranges are in different sheets".to_string(),
+                    ));
+                }
+                let row1 = left.row;
+                let mut row2 = right.row;
+                let column1 = left.column;
+                let mut column2 = right.column;
+                if row1 == 1 && row2 == LAST_ROW {
+                    row2 = self
+                        .workbook
+                        .worksheet(left.sheet)
+                        .expect("Sheet expected during evaluation.")
+                        .dimension()
+                        .max_row;
+                }
+                if column1 == 1 && column2 == LAST_COLUMN {
+                    column2 = self
+                        .workbook
+                        .worksheet(left.sheet)
+                        .expect("Sheet expected during evaluation.")
+                        .dimension()
+                        .max_column;
+                }
+                for row in row1..row2 + 1 {
+                    for column in column1..(column2 + 1) {
+                        match self.evaluate_cell(CellReferenceIndex {
+                            sheet: left.sheet,
+                            row,
+                            column,
+                        }) {
+                            CalcResult::Number(value) => {
+                                values.push(value);
+                            }
+                            error @ CalcResult::Error { .. } => return Err(error),
+                            CalcResult::EmptyCell => values.push(0.0),
+                            _ => {
+                                return Err(CalcResult::new_error(
+                                    Error::VALUE,
+                                    *cell,
+                                    "Expected number".to_string(),
+                                ));
+                            }
+                        }
+                    }
+                }
+            }
+            error @ CalcResult::Error { .. } => return Err(error),
+            _ => {
+                return Err(CalcResult::new_error(
                     Error::VALUE,
                     *cell,
                     "Expected number".to_string(),
-                ))
-            },
-        )
+                ));
+            }
+        };
+        Ok(values)
     }
 
     /// PMT(rate, nper, pv, [fv], [type])
@@ -431,7 +497,7 @@ impl Model {
         }
         if rate == -1.0 {
             return CalcResult::Error {
-                error: Error::DIV,
+                error: Error::NUM,
                 origin: cell,
                 message: "Rate must be != -1".to_string(),
             };
@@ -698,7 +764,7 @@ impl Model {
                     error: error.0,
                     origin: cell,
                     message: error.1,
-                };
+                }
             }
         };
         CalcResult::Number(ipmt)
@@ -762,7 +828,7 @@ impl Model {
                     error: error.0,
                     origin: cell,
                     message: error.1,
-                };
+                }
             }
         };
         CalcResult::Number(ppmt)
@@ -796,28 +862,20 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_row,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
+                        row2 = self
+                            .workbook
+                            .worksheet(left.sheet)
+                            .expect("Sheet expected during evaluation.")
+                            .dimension()
+                            .max_row;
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_column,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
+                        column2 = self
+                            .workbook
+                            .worksheet(left.sheet)
+                            .expect("Sheet expected during evaluation.")
+                            .dimension()
+                            .max_column;
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {
@@ -918,9 +976,7 @@ impl Model {
         }
         let first_date = dates[0];
         for date in &dates {
-            if *date < MINIMUM_DATE_SERIAL_NUMBER as f64
-                || *date > MAXIMUM_DATE_SERIAL_NUMBER as f64
-            {
+            if !is_valid_date(*date) {
                 // Excel docs claim that if any number in dates is not a valid date,
                 // XNPV returns the #VALUE! error value, but it seems to return #VALUE!
                 return CalcResult::new_error(
@@ -986,9 +1042,7 @@ impl Model {
         }
         let first_date = dates[0];
         for date in &dates {
-            if *date < MINIMUM_DATE_SERIAL_NUMBER as f64
-                || *date > MAXIMUM_DATE_SERIAL_NUMBER as f64
-            {
+            if !is_valid_date(*date) {
                 return CalcResult::new_error(
                     Error::NUM,
                     cell,
@@ -1075,7 +1129,7 @@ impl Model {
                         error,
                         origin: cell,
                         message,
-                    };
+                    }
                 }
             }
         };
@@ -1096,7 +1150,7 @@ impl Model {
                         error,
                         origin: cell,
                         message,
-                    };
+                    }
                 }
             }
         };
@@ -1339,21 +1393,21 @@ impl Model {
         CalcResult::Number(result)
     }
 
-    // This next three functions deal with Treasure Bills or T-Bills for short
-    // They are zero-coupon that mature in one year or less.
-    //  Definitions:
-    //    $r$ be the discount rate
-    //    $v$ the face value of the Bill
-    //    $p$ the price of the Bill
-    //    $d_m$ is the number of days from the settlement to maturity
-    // Then:
-    //   $$ p = v \times\left(1-\frac{d_m}{r}\right) $$
-    // If d_m is less than 183 days the he Bond Equivalent Yield (BEY, here $y$) is given by:
-    // $$ y = \frac{F - B}{M}\times \frac{365}{d_m} = \frac{365\times r}{360-r\times d_m}
-    // If d_m>= 183 days things are a bit more complicated.
-    // Let $d_e = d_m - 365/2$ if $d_m <= 365$ or $d_e = 183$ if $d_m = 366$.
-    // $$ v = p\times \left(1+\frac{y}{2}\right)\left(1+d_e\times\frac{y}{365}\right) $$
-    // Together with the previous relation of $p$ and $v$ gives us a quadratic equation for $y$.
+    /// This next three functions deal with Treasure Bills or T-Bills for short
+    /// They are zero-coupon that mature in one year or less.
+    ///  Definitions:
+    ///    $r$ be the discount rate
+    ///    $v$ the face value of the Bill
+    ///    $p$ the price of the Bill
+    ///    $d_m$ is the number of days from the settlement to maturity
+    /// Then:
+    ///   $$ p = v \times\left(1-\frac{d_m}{r}\right) $$
+    /// If d_m is less than 183 days the he Bond Equivalent Yield (BEY, here $y$) is given by:
+    /// $$ y = \frac{F - B}{M}\times \frac{365}{d_m} = \frac{365\times r}{360-r\times d_m}
+    /// If d_m>= 183 days things are a bit more complicated.
+    /// Let $d_e = d_m - 365/2$ if $d_m <= 365$ or $d_e = 183$ if $d_m = 366$.
+    /// $$ v = p\times \left(1+\frac{y}{2}\right)\left(1+d_e\times\frac{y}{365}\right) $$
+    /// Together with the previous relation of $p$ and $v$ gives us a quadratic equation for $y$.
 
     // TBILLEQ(settlement, maturity, discount)
     pub(crate) fn fn_tbilleq(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
@@ -1372,10 +1426,9 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        let less_than_one_year = match is_less_than_one_year(settlement as i64, maturity as i64) {
-            Ok(f) => f,
-            Err(_) => return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string()),
-        };
+        if !is_valid_date(settlement) || !is_valid_date(maturity) {
+            return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string());
+        }
         if settlement > maturity {
             return CalcResult::new_error(
                 Error::NUM,
@@ -1383,7 +1436,7 @@ impl Model {
                 "settlement should be <= maturity".to_string(),
             );
         }
-        if !less_than_one_year {
+        if !is_less_than_one_year(settlement as i64, maturity as i64) {
             return CalcResult::new_error(
                 Error::NUM,
                 cell,
@@ -1437,10 +1490,9 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        let less_than_one_year = match is_less_than_one_year(settlement as i64, maturity as i64) {
-            Ok(f) => f,
-            Err(_) => return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string()),
-        };
+        if !is_valid_date(settlement) || !is_valid_date(maturity) {
+            return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string());
+        }
         if settlement > maturity {
             return CalcResult::new_error(
                 Error::NUM,
@@ -1448,7 +1500,7 @@ impl Model {
                 "settlement should be <= maturity".to_string(),
             );
         }
-        if !less_than_one_year {
+        if !is_less_than_one_year(settlement as i64, maturity as i64) {
             return CalcResult::new_error(
                 Error::NUM,
                 cell,
@@ -1488,10 +1540,9 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        let less_than_one_year = match is_less_than_one_year(settlement as i64, maturity as i64) {
-            Ok(f) => f,
-            Err(_) => return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string()),
-        };
+        if !is_valid_date(settlement) || !is_valid_date(maturity) {
+            return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string());
+        }
         if settlement > maturity {
             return CalcResult::new_error(
                 Error::NUM,
@@ -1499,7 +1550,7 @@ impl Model {
                 "settlement should be <= maturity".to_string(),
             );
         }
-        if !less_than_one_year {
+        if !is_less_than_one_year(settlement as i64, maturity as i64) {
             return CalcResult::new_error(
                 Error::NUM,
                 cell,
@@ -1634,7 +1685,7 @@ impl Model {
                         error: error.0,
                         origin: cell,
                         message: error.1,
-                    };
+                    }
                 }
             }
         }
@@ -1702,7 +1753,7 @@ impl Model {
                         error: error.0,
                         origin: cell,
                         message: error.1,
-                    };
+                    }
                 }
             }
         }
@@ -1750,7 +1801,11 @@ impl Model {
             rate = 1.0
         };
         let value = if rate == 1.0 {
-            if period == 1.0 { cost } else { 0.0 }
+            if period == 1.0 {
+                cost
+            } else {
+                0.0
+            }
         } else {
             cost * (1.0 - rate).powf(period - 1.0)
         };

base/src/functions/information.rs

@@ -165,8 +165,7 @@ impl Model {
                     message: "argument must be a reference to a single cell".to_string(),
                 };
             }
-            let is_formula = if let Ok(f) = self.get_cell_formula(left.sheet, left.row, left.column)
-            {
+            let is_formula = if let Ok(f) = self.cell_formula(left.sheet, left.row, left.column) {
                 f.is_some()
             } else {
                 false
@@ -247,68 +246,46 @@ 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,

base/src/functions/logical.rs

@@ -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,58 +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 => {}
-                            }
-                            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 => {}
-            }
+                error @ CalcResult::Error { .. } => return error,
+                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+            };
+        }
+        CalcResult::Boolean(result)
+    }
 
-            if let (Some(current_result), Some(short_circuit_value)) = (result, short_circuit_value)
-            {
-                if current_result == short_circuit_value {
-                    return CalcResult::Boolean(current_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;
+                    }
                 }
-            }
+                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])

base/src/functions/lookup_and_reference.rs

@@ -838,43 +838,4 @@ impl Model {
         };
         CalcResult::Range { left, right }
     }
-
-    pub(crate) fn fn_formulatext(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        if let CalcResult::Range { left, right } = self.evaluate_node_with_reference(&args[0], cell)
-        {
-            if left.sheet != right.sheet {
-                return CalcResult::Error {
-                    error: Error::ERROR,
-                    origin: cell,
-                    message: "3D ranges not supported".to_string(),
-                };
-            }
-            if left.row != right.row || left.column != right.column {
-                // FIXME: Implicit intersection or dynamic arrays
-                return CalcResult::Error {
-                    error: Error::ERROR,
-                    origin: cell,
-                    message: "argument must be a reference to a single cell".to_string(),
-                };
-            }
-            if let Ok(Some(f)) = self.get_cell_formula(left.sheet, left.row, left.column) {
-                CalcResult::String(f)
-            } else {
-                CalcResult::Error {
-                    error: Error::NA,
-                    origin: cell,
-                    message: "Reference does not have a formula".to_string(),
-                }
-            }
-        } else {
-            CalcResult::Error {
-                error: Error::ERROR,
-                origin: cell,
-                message: "Argument must be a reference".to_string(),
-            }
-        }
-    }
 }

base/src/functions/mathematical.rs

@@ -128,28 +128,20 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_row,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
+                        row2 = self
+                            .workbook
+                            .worksheet(left.sheet)
+                            .expect("Sheet expected during evaluation.")
+                            .dimension()
+                            .max_row;
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_column,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
+                        column2 = self
+                            .workbook
+                            .worksheet(left.sheet)
+                            .expect("Sheet expected during evaluation.")
+                            .dimension()
+                            .max_column;
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {
@@ -203,28 +195,20 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_row,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
+                        row2 = self
+                            .workbook
+                            .worksheet(left.sheet)
+                            .expect("Sheet expected during evaluation.")
+                            .dimension()
+                            .max_row;
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_column,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
+                        column2 = self
+                            .workbook
+                            .worksheet(left.sheet)
+                            .expect("Sheet expected during evaluation.")
+                            .dimension()
+                            .max_column;
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {

base/src/functions/mod.rs

@@ -1,5 +1,4 @@
 use core::fmt;
-use std::array::IntoIter;
 
 use crate::{
     calc_result::CalcResult,
@@ -75,7 +74,6 @@ pub enum Function {
 
     // Information
     ErrorType,
-    Formulatext,
     Isblank,
     Iserr,
     Iserror,
@@ -123,7 +121,6 @@ pub enum Function {
     Textbefore,
     Textjoin,
     Trim,
-    Unicode,
     Upper,
     Value,
     Valuetotext,
@@ -140,7 +137,6 @@ pub enum Function {
     Countifs,
     Maxifs,
     Minifs,
-    Geomean,
 
     // Date and time
     Date,
@@ -248,209 +244,6 @@ pub enum Function {
     Subtotal,
 }
 
-impl Function {
-    pub fn into_iter() -> IntoIter<Function, 195> {
-        [
-            Function::And,
-            Function::False,
-            Function::If,
-            Function::Iferror,
-            Function::Ifna,
-            Function::Ifs,
-            Function::Not,
-            Function::Or,
-            Function::Switch,
-            Function::True,
-            Function::Xor,
-            Function::Sin,
-            Function::Cos,
-            Function::Tan,
-            Function::Asin,
-            Function::Acos,
-            Function::Atan,
-            Function::Sinh,
-            Function::Cosh,
-            Function::Tanh,
-            Function::Asinh,
-            Function::Acosh,
-            Function::Atanh,
-            Function::Abs,
-            Function::Pi,
-            Function::Sqrt,
-            Function::Sqrtpi,
-            Function::Atan2,
-            Function::Power,
-            Function::Max,
-            Function::Min,
-            Function::Product,
-            Function::Rand,
-            Function::Randbetween,
-            Function::Round,
-            Function::Rounddown,
-            Function::Roundup,
-            Function::Sum,
-            Function::Sumif,
-            Function::Sumifs,
-            Function::Choose,
-            Function::Column,
-            Function::Columns,
-            Function::Index,
-            Function::Indirect,
-            Function::Hlookup,
-            Function::Lookup,
-            Function::Match,
-            Function::Offset,
-            Function::Row,
-            Function::Rows,
-            Function::Vlookup,
-            Function::Xlookup,
-            Function::Concatenate,
-            Function::Exact,
-            Function::Value,
-            Function::T,
-            Function::Valuetotext,
-            Function::Concat,
-            Function::Find,
-            Function::Left,
-            Function::Len,
-            Function::Lower,
-            Function::Mid,
-            Function::Right,
-            Function::Search,
-            Function::Text,
-            Function::Trim,
-            Function::Unicode,
-            Function::Upper,
-            Function::Isnumber,
-            Function::Isnontext,
-            Function::Istext,
-            Function::Islogical,
-            Function::Isblank,
-            Function::Iserr,
-            Function::Iserror,
-            Function::Isna,
-            Function::Na,
-            Function::Isref,
-            Function::Isodd,
-            Function::Iseven,
-            Function::ErrorType,
-            Function::Formulatext,
-            Function::Isformula,
-            Function::Type,
-            Function::Sheet,
-            Function::Average,
-            Function::Averagea,
-            Function::Averageif,
-            Function::Averageifs,
-            Function::Count,
-            Function::Counta,
-            Function::Countblank,
-            Function::Countif,
-            Function::Countifs,
-            Function::Maxifs,
-            Function::Minifs,
-            Function::Geomean,
-            Function::Year,
-            Function::Day,
-            Function::Month,
-            Function::Eomonth,
-            Function::Date,
-            Function::Edate,
-            Function::Today,
-            Function::Now,
-            Function::Pmt,
-            Function::Pv,
-            Function::Rate,
-            Function::Nper,
-            Function::Fv,
-            Function::Ppmt,
-            Function::Ipmt,
-            Function::Npv,
-            Function::Mirr,
-            Function::Irr,
-            Function::Xirr,
-            Function::Xnpv,
-            Function::Rept,
-            Function::Textafter,
-            Function::Textbefore,
-            Function::Textjoin,
-            Function::Substitute,
-            Function::Ispmt,
-            Function::Rri,
-            Function::Sln,
-            Function::Syd,
-            Function::Nominal,
-            Function::Effect,
-            Function::Pduration,
-            Function::Tbillyield,
-            Function::Tbillprice,
-            Function::Tbilleq,
-            Function::Dollarde,
-            Function::Dollarfr,
-            Function::Ddb,
-            Function::Db,
-            Function::Cumprinc,
-            Function::Cumipmt,
-            Function::Besseli,
-            Function::Besselj,
-            Function::Besselk,
-            Function::Bessely,
-            Function::Erf,
-            Function::ErfPrecise,
-            Function::Erfc,
-            Function::ErfcPrecise,
-            Function::Bin2dec,
-            Function::Bin2hex,
-            Function::Bin2oct,
-            Function::Dec2Bin,
-            Function::Dec2hex,
-            Function::Dec2oct,
-            Function::Hex2bin,
-            Function::Hex2dec,
-            Function::Hex2oct,
-            Function::Oct2bin,
-            Function::Oct2dec,
-            Function::Oct2hex,
-            Function::Bitand,
-            Function::Bitlshift,
-            Function::Bitor,
-            Function::Bitrshift,
-            Function::Bitxor,
-            Function::Complex,
-            Function::Imabs,
-            Function::Imaginary,
-            Function::Imargument,
-            Function::Imconjugate,
-            Function::Imcos,
-            Function::Imcosh,
-            Function::Imcot,
-            Function::Imcsc,
-            Function::Imcsch,
-            Function::Imdiv,
-            Function::Imexp,
-            Function::Imln,
-            Function::Imlog10,
-            Function::Imlog2,
-            Function::Impower,
-            Function::Improduct,
-            Function::Imreal,
-            Function::Imsec,
-            Function::Imsech,
-            Function::Imsin,
-            Function::Imsinh,
-            Function::Imsqrt,
-            Function::Imsub,
-            Function::Imsum,
-            Function::Imtan,
-            Function::Convert,
-            Function::Delta,
-            Function::Gestep,
-            Function::Subtotal,
-        ]
-        .into_iter()
-    }
-}
-
 impl Function {
     /// Some functions in Excel like CONCAT are stringified as `_xlfn.CONCAT`.
     pub fn to_xlsx_string(&self) -> String {
@@ -466,7 +259,6 @@ impl Function {
             Function::Textbefore => "_xlfn.TEXTBEFORE".to_string(),
             Function::Textafter => "_xlfn.TEXTAFTER".to_string(),
             Function::Textjoin => "_xlfn.TEXTJOIN".to_string(),
-            Function::Unicode => "_xlfn.UNICODE".to_string(),
             Function::Rri => "_xlfn.RRI".to_string(),
             Function::Pduration => "_xlfn.PDURATION".to_string(),
             Function::Bitand => "_xlfn.BITAND".to_string(),
@@ -486,7 +278,6 @@ impl Function {
             Function::Valuetotext => "_xlfn.VALUETOTEXT".to_string(),
             Function::Isformula => "_xlfn.ISFORMULA".to_string(),
             Function::Sheet => "_xlfn.SHEET".to_string(),
-            Function::Formulatext => "_xlfn.FORMULATEXT".to_string(),
             _ => self.to_string(),
         }
     }
@@ -575,7 +366,6 @@ impl Function {
             "SEARCH" => Some(Function::Search),
             "TEXT" => Some(Function::Text),
             "TRIM" => Some(Function::Trim),
-            "UNICODE" | "_XLFN.UNICODE" => Some(Function::Unicode),
             "UPPER" => Some(Function::Upper),
 
             "REPT" => Some(Function::Rept),
@@ -597,7 +387,6 @@ impl Function {
             "ISODD" => Some(Function::Isodd),
             "ISEVEN" => Some(Function::Iseven),
             "ERROR.TYPE" => Some(Function::ErrorType),
-            "FORMULATEXT" | "_XLFN.FORMULATEXT" => Some(Function::Formulatext),
             "ISFORMULA" | "_XLFN.ISFORMULA" => Some(Function::Isformula),
             "TYPE" => Some(Function::Type),
             "SHEET" | "_XLFN.SHEET" => Some(Function::Sheet),
@@ -613,7 +402,6 @@ 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),
@@ -790,7 +578,6 @@ impl fmt::Display for Function {
             Function::Search => write!(f, "SEARCH"),
             Function::Text => write!(f, "TEXT"),
             Function::Trim => write!(f, "TRIM"),
-            Function::Unicode => write!(f, "UNICODE"),
             Function::Upper => write!(f, "UPPER"),
             Function::Isnumber => write!(f, "ISNUMBER"),
             Function::Isnontext => write!(f, "ISNONTEXT"),
@@ -805,7 +592,6 @@ impl fmt::Display for Function {
             Function::Isodd => write!(f, "ISODD"),
             Function::Iseven => write!(f, "ISEVEN"),
             Function::ErrorType => write!(f, "ERROR.TYPE"),
-            Function::Formulatext => write!(f, "FORMULATEXT"),
             Function::Isformula => write!(f, "ISFORMULA"),
             Function::Type => write!(f, "TYPE"),
             Function::Sheet => write!(f, "SHEET"),
@@ -821,7 +607,6 @@ 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"),
@@ -923,23 +708,7 @@ impl fmt::Display for Function {
     }
 }
 
-/// Documentation for one function
-pub struct Documentation {
-    pub name: String,
-}
-
 impl Model {
-    /// Produces documentation for all implemented functions
-    pub fn documentation() -> Vec<Documentation> {
-        let mut doc = Vec::new();
-        for function in Function::into_iter() {
-            doc.push(Documentation {
-                name: function.to_string(),
-            });
-        }
-        doc
-    }
-
     pub(crate) fn evaluate_function(
         &mut self,
         kind: &Function,
@@ -949,7 +718,7 @@ impl Model {
         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),
@@ -957,7 +726,7 @@ 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),
             // Math and trigonometry
             Function::Sin => self.fn_sin(args, cell),
@@ -1026,7 +795,6 @@ impl Model {
             Function::Search => self.fn_search(args, cell),
             Function::Text => self.fn_text(args, cell),
             Function::Trim => self.fn_trim(args, cell),
-            Function::Unicode => self.fn_unicode(args, cell),
             Function::Upper => self.fn_upper(args, cell),
             // Information
             Function::Isnumber => self.fn_isnumber(args, cell),
@@ -1042,7 +810,6 @@ impl Model {
             Function::Isodd => self.fn_isodd(args, cell),
             Function::Iseven => self.fn_iseven(args, cell),
             Function::ErrorType => self.fn_errortype(args, cell),
-            Function::Formulatext => self.fn_formulatext(args, cell),
             Function::Isformula => self.fn_isformula(args, cell),
             Function::Type => self.fn_type(args, cell),
             Function::Sheet => self.fn_sheet(args, cell),
@@ -1058,7 +825,6 @@ 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),
@@ -1162,67 +928,3 @@ impl Model {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    #![allow(clippy::unwrap_used)]
-    use std::{
-        fs::File,
-        io::{BufRead, BufReader},
-    };
-
-    use crate::functions::Function;
-
-    #[test]
-    fn function_iterator() {
-        // This checks that the number of functions in the enum is the same
-        // as the number of functions in the Iterator.
-
-        // This is tricky. In Rust we cannot loop over all the members of an enum.
-        // There are alternatives like using an external crate like strum.
-        // But I am not in the mood for that.
-
-        // What we do here is read this file , extract the functions in the enum
-        // and check they are the same as in the iterator
-        let file = File::open("src/functions/mod.rs").unwrap();
-        let reader = BufReader::new(file);
-        let mut start = false;
-        let mut list = Vec::new();
-
-        for line in reader.lines() {
-            let text = line.unwrap();
-            let text = text.trim().trim_end_matches(',');
-            if text == "pub enum Function {" {
-                start = true;
-                continue;
-            }
-            if start {
-                if text == "}" {
-                    break;
-                }
-                if text.starts_with("//") {
-                    // skip comments
-                    continue;
-                }
-                if text.is_empty() {
-                    // skip empty lines
-                    continue;
-                }
-                list.push(text.to_owned());
-            }
-        }
-        // 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('.', ""))
-            .collect::<Vec<_>>();
-
-        let len = iter_list.len();
-
-        assert_eq!(list.len(), len);
-        // We still need to check there are no duplicates. This will fail if a function in iter_list
-        // is included twice and one is missing
-        for function in list {
-            assert!(iter_list.contains(&function.to_uppercase()));
-        }
-    }
-}

base/src/functions/statistical.rs

@@ -381,16 +381,11 @@ impl Model {
         let right_row = first_range.right.row;
         let right_column = first_range.right.column;
 
-        let dimension = match self.workbook.worksheet(first_range.left.sheet) {
-            Ok(s) => s.dimension(),
-            Err(_) => {
-                return CalcResult::new_error(
-                    Error::ERROR,
-                    cell,
-                    format!("Invalid worksheet index: '{}'", first_range.left.sheet),
-                );
-            }
-        };
+        let dimension = self
+            .workbook
+            .worksheet(first_range.left.sheet)
+            .expect("Sheet expected during evaluation.")
+            .dimension();
         let max_row = dimension.max_row;
         let max_column = dimension.max_column;
 
@@ -531,28 +526,20 @@ impl Model {
         let mut right_column = sum_range.right.column;
 
         if left_row == 1 && right_row == LAST_ROW {
-            right_row = match self.workbook.worksheet(sum_range.left.sheet) {
-                Ok(s) => s.dimension().max_row,
-                Err(_) => {
-                    return Err(CalcResult::new_error(
-                        Error::ERROR,
-                        cell,
-                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
-                    ));
-                }
-            };
+            right_row = self
+                .workbook
+                .worksheet(sum_range.left.sheet)
+                .expect("Sheet expected during evaluation.")
+                .dimension()
+                .max_row;
         }
         if left_column == 1 && right_column == LAST_COLUMN {
-            right_column = match self.workbook.worksheet(sum_range.left.sheet) {
-                Ok(s) => s.dimension().max_column,
-                Err(_) => {
-                    return Err(CalcResult::new_error(
-                        Error::ERROR,
-                        cell,
-                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
-                    ));
-                }
-            };
+            right_column = self
+                .workbook
+                .worksheet(sum_range.left.sheet)
+                .expect("Sheet expected during evaluation.")
+                .dimension()
+                .max_column;
         }
 
         for row in left_row..right_row + 1 {
@@ -635,85 +622,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))
-    }
 }

base/src/functions/subtotal.rs

@@ -1,7 +1,7 @@
 use crate::{
     calc_result::CalcResult,
     expressions::{
-        parser::{Node, parse_range},
+        parser::{parse_range, Node},
         token::Error,
         types::CellReferenceIndex,
     },
@@ -53,13 +53,8 @@ impl Model {
         false
     }
 
-    fn cell_hidden_status(
-        &self,
-        sheet_index: u32,
-        row: i32,
-        column: i32,
-    ) -> Result<CellTableStatus, String> {
-        let worksheet = self.workbook.worksheet(sheet_index)?;
+    fn cell_hidden_status(&self, sheet_index: u32, row: i32, column: i32) -> CellTableStatus {
+        let worksheet = self.workbook.worksheet(sheet_index).expect("");
         let mut hidden = false;
         for row_style in &worksheet.rows {
             if row_style.r == row {
@@ -68,13 +63,13 @@ impl Model {
             }
         }
         if !hidden {
-            return Ok(CellTableStatus::Normal);
+            return CellTableStatus::Normal;
         }
         // The row is hidden we need to know if the table has filters
         if self.get_table_for_cell(sheet_index, row, column) {
-            Ok(CellTableStatus::Filtered)
+            CellTableStatus::Filtered
         } else {
-            Ok(CellTableStatus::Hidden)
+            CellTableStatus::Hidden
         }
     }
 
@@ -148,11 +143,7 @@ impl Model {
                             let column2 = right.column;
 
                             for row in row1..=row2 {
-                                let cell_status = self
-                                    .cell_hidden_status(left.sheet, row, column1)
-                                    .map_err(|message| {
-                                        CalcResult::new_error(Error::ERROR, cell, message)
-                                    })?;
+                                let cell_status = self.cell_hidden_status(left.sheet, row, column1);
                                 if cell_status == CellTableStatus::Filtered {
                                     continue;
                                 }
@@ -389,14 +380,7 @@ impl Model {
                             let column2 = right.column;
 
                             for row in row1..=row2 {
-                                let cell_status = match self
-                                    .cell_hidden_status(left.sheet, row, column1)
-                                {
-                                    Ok(s) => s,
-                                    Err(message) => {
-                                        return CalcResult::new_error(Error::ERROR, cell, message);
-                                    }
-                                };
+                                let cell_status = self.cell_hidden_status(left.sheet, row, column1);
                                 if cell_status == CellTableStatus::Filtered {
                                     continue;
                                 }
@@ -465,14 +449,7 @@ impl Model {
                             let column2 = right.column;
 
                             for row in row1..=row2 {
-                                let cell_status = match self
-                                    .cell_hidden_status(left.sheet, row, column1)
-                                {
-                                    Ok(s) => s,
-                                    Err(message) => {
-                                        return CalcResult::new_error(Error::ERROR, cell, message);
-                                    }
-                                };
+                                let cell_status = self.cell_hidden_status(left.sheet, row, column1);
                                 if cell_status == CellTableStatus::Filtered {
                                     continue;
                                 }

base/src/functions/text.rs

@@ -8,7 +8,7 @@ use crate::{
 };
 
 use super::{
-    text_util::{Case, substitute, text_after, text_before},
+    text_util::{substitute, text_after, text_before, Case},
     util::from_wildcard_to_regex,
 };
 
@@ -151,7 +151,7 @@ impl Model {
     ///  * If find_text does not appear in within_text, FIND and FINDB return the #VALUE! error value.
     ///  * If start_num is not greater than zero, FIND and FINDB return the #VALUE! error value.
     ///  * If start_num is greater than the length of within_text, FIND and FINDB return the #VALUE! error value.
-    ///    NB: FINDB is not implemented. It is the same as FIND function unless locale is a DBCS (Double Byte Character Set)
+    /// NB: FINDB is not implemented. It is the same as FIND function unless locale is a DBCS (Double Byte Character Set)
     pub(crate) fn fn_find(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() < 2 || args.len() > 3 {
             return CalcResult::new_args_number_error(cell);
@@ -203,7 +203,7 @@ impl Model {
     /// Same API as FIND but:
     ///  * Allows wildcards
     ///  * It is case insensitive
-    ///    SEARCH(find_text, within_text, [start_num])
+    /// SEARCH(find_text, within_text, [start_num])
     pub(crate) fn fn_search(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() < 2 || args.len() > 3 {
             return CalcResult::new_args_number_error(cell);
@@ -342,53 +342,6 @@ impl Model {
         CalcResult::new_args_number_error(cell)
     }
 
-    pub(crate) fn fn_unicode(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() == 1 {
-            let s = match self.evaluate_node_in_context(&args[0], cell) {
-                CalcResult::Number(v) => format!("{}", v),
-                CalcResult::String(v) => v,
-                CalcResult::Boolean(b) => {
-                    if b {
-                        "TRUE".to_string()
-                    } else {
-                        "FALSE".to_string()
-                    }
-                }
-                error @ CalcResult::Error { .. } => return error,
-                CalcResult::Range { .. } => {
-                    // Implicit Intersection not implemented
-                    return CalcResult::Error {
-                        error: Error::NIMPL,
-                        origin: cell,
-                        message: "Implicit Intersection not implemented".to_string(),
-                    };
-                }
-                CalcResult::EmptyCell | CalcResult::EmptyArg => {
-                    return CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: "Empty cell".to_string(),
-                    };
-                }
-            };
-
-            match s.chars().next() {
-                Some(c) => {
-                    let unicode_number = c as u32;
-                    return CalcResult::Number(unicode_number as f64);
-                }
-                None => {
-                    return CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: "Empty cell".to_string(),
-                    };
-                }
-            }
-        }
-        CalcResult::new_args_number_error(cell)
-    }
-
     pub(crate) fn fn_upper(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 1 {
             let s = match self.evaluate_node_in_context(&args[0], cell) {
@@ -550,7 +503,7 @@ impl Model {
             }
             result.push(ch);
         }
-        CalcResult::String(result.chars().rev().collect::<String>())
+        return CalcResult::String(result.chars().rev().collect::<String>());
     }
 
     pub(crate) fn fn_mid(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
@@ -629,7 +582,7 @@ impl Model {
                     error: Error::VALUE,
                     origin: cell,
                     message: "Expecting number".to_string(),
-                };
+                }
             }
             error @ CalcResult::Error { .. } => return error,
             CalcResult::Range { .. } => {
@@ -935,28 +888,20 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_row,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
+                        row2 = self
+                            .workbook
+                            .worksheet(left.sheet)
+                            .expect("Sheet expected during evaluation.")
+                            .dimension()
+                            .max_row;
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = match self.workbook.worksheet(left.sheet) {
-                            Ok(s) => s.dimension().max_column,
-                            Err(_) => {
-                                return CalcResult::new_error(
-                                    Error::ERROR,
-                                    cell,
-                                    format!("Invalid worksheet index: '{}'", left.sheet),
-                                );
-                            }
-                        };
+                        column2 = self
+                            .workbook
+                            .worksheet(left.sheet)
+                            .expect("Sheet expected during evaluation.")
+                            .dimension()
+                            .max_column;
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {

base/src/functions/util.rs

@@ -1,5 +1,4 @@
-#[cfg(feature = "use_regex_lite")]
-use regex_lite as regex;
+use regex::{escape, Regex};
 
 use crate::{calc_result::CalcResult, expressions::token::is_english_error_string};
 
@@ -26,9 +25,9 @@ pub(crate) fn values_are_equal(left: &CalcResult, right: &CalcResult) -> bool {
     }
 }
 
-// In Excel there are two ways of comparing cell values.
-// The old school comparison valid in formulas like D3 < D4 or HLOOKUP,... cast empty cells into empty strings or 0
-// For the new formulas like XLOOKUP or SORT an empty cell is always larger than anything else.
+/// In Excel there are two ways of comparing cell values.
+/// The old school comparison valid in formulas like D3 < D4 or HLOOKUP,... cast empty cells into empty strings or 0
+/// For the new formulas like XLOOKUP or SORT an empty cell is always larger than anything else.
 
 // ..., -2, -1, 0, 1, 2, ..., A-Z, FALSE, TRUE;
 pub(crate) fn compare_values(left: &CalcResult, right: &CalcResult) -> i32 {
@@ -87,7 +86,7 @@ pub(crate) fn from_wildcard_to_regex(
     exact: bool,
 ) -> Result<regex::Regex, regex::Error> {
     // 1. Escape all
-    let reg = &regex::escape(wildcard);
+    let reg = &escape(wildcard);
 
     // 2. We convert the escaped '?' into '.' (matches a single character)
     let reg = &reg.replace("\\?", ".");
@@ -110,13 +109,13 @@ pub(crate) fn from_wildcard_to_regex(
 
     // And we have a valid Perl regex! (As Kim Kardashian said before me: "I know, right?")
     if exact {
-        return regex::Regex::new(&format!("^{}$", reg));
+        return Regex::new(&format!("^{}$", reg));
     }
-    regex::Regex::new(reg)
+    Regex::new(reg)
 }
 
-// NUMBERS ///
-//*********///
+/// NUMBERS ///
+///*********///
 
 // It could be either the number or a string representation of the number
 // In the rest of the cases calc_result needs to be a number (cannot be the string "23", for instance)
@@ -181,8 +180,8 @@ fn result_is_not_equal_to_number(calc_result: &CalcResult, target: f64) -> bool
     }
 }
 
-// BOOLEANS ///
-//**********///
+/// BOOLEANS ///
+///**********///
 
 // Booleans have to be "exactly" equal
 fn result_is_equal_to_bool(calc_result: &CalcResult, target: bool) -> bool {
@@ -199,12 +198,12 @@ fn result_is_not_equal_to_bool(calc_result: &CalcResult, target: bool) -> bool {
     }
 }
 
-// STRINGS ///
-//*********///
+/// STRINGS ///
+///*********///
 
-// Note that strings are case insensitive. `target` must always be lower case.
+/// Note that strings are case insensitive. `target` must always be lower case.
 
-pub(crate) fn result_matches_regex(calc_result: &CalcResult, reg: &regex::Regex) -> bool {
+pub(crate) fn result_matches_regex(calc_result: &CalcResult, reg: &Regex) -> bool {
     match calc_result {
         CalcResult::String(s) => reg.is_match(&s.to_lowercase()),
         _ => false,
@@ -270,8 +269,8 @@ fn result_is_greater_or_equal_than_string(calc_result: &CalcResult, target: &str
     }
 }
 
-// ERRORS ///
-//********///
+/// ERRORS ///
+///********///
 
 fn result_is_equal_to_error(calc_result: &CalcResult, target: &str) -> bool {
     match calc_result {
@@ -287,8 +286,8 @@ fn result_is_not_equal_to_error(calc_result: &CalcResult, target: &str) -> bool
     }
 }
 
-// EMPTY ///
-//*******///
+/// EMPTY ///
+///*******///
 
 // Note that these two are not inverse of each other.
 // In particular, you can never match an empty cell.

base/src/functions/xlookup.rs

@@ -251,28 +251,20 @@ impl Model {
                         let column1 = left.column;
 
                         if row1 == 1 && row2 == LAST_ROW {
-                            row2 = match self.workbook.worksheet(left.sheet) {
-                                Ok(s) => s.dimension().max_row,
-                                Err(_) => {
-                                    return CalcResult::new_error(
-                                        Error::ERROR,
-                                        cell,
-                                        format!("Invalid worksheet index: '{}'", left.sheet),
-                                    );
-                                }
-                            };
+                            row2 = self
+                                .workbook
+                                .worksheet(left.sheet)
+                                .expect("Sheet expected during evaluation.")
+                                .dimension()
+                                .max_row;
                         }
                         if column1 == 1 && column2 == LAST_COLUMN {
-                            column2 = match self.workbook.worksheet(left.sheet) {
-                                Ok(s) => s.dimension().max_column,
-                                Err(_) => {
-                                    return CalcResult::new_error(
-                                        Error::ERROR,
-                                        cell,
-                                        format!("Invalid worksheet index: '{}'", left.sheet),
-                                    );
-                                }
-                            };
+                            column2 = self
+                                .workbook
+                                .worksheet(left.sheet)
+                                .expect("Sheet expected during evaluation.")
+                                .dimension()
+                                .max_column;
                         }
                         let left = CellReferenceIndex {
                             sheet: left.sheet,

base/src/language/language.bin

@@ -1 +0,0 @@
-PfrendeesD<>VRAITRUEWAHRVERDADEROTVFAUXFALSEFALSCHFALSOUw#REF!#REF!#BEZUG!#¡REF!e<>#NOM?#NAME?#NAME?#¿NOMBRE?x<>#VALEUR!#VALUE!#WERT!#¡VALOR!w<>#DIV/0!#DIV/0!#DIV/0!#¡DIV/0!<04>#N/A#N/A#NV#N/AXv#NOMBRE!#NUM!#ZAHL!#¡NUM!<02><>#N/IMPL!#N/IMPL!#N/IMPL!#N/IMPL!w{#SPILL!#SPILL!#ÜBERLAUF!#SPILL!ff#CALC!#CALC!#CALC!#CALC!ff#CIRC!#CIRC!#CIRC!#CIRC!ww#ERROR!#ERROR!#ERROR!#ERROR!ff#NULL!#NULL!#NULL!#NULL!

base/src/language/mod.rs

@@ -1,17 +1,20 @@
+use once_cell::sync::Lazy;
+use serde::{Deserialize, Serialize};
+
 use std::collections::HashMap;
 
-use bitcode::{Decode, Encode};
-use once_cell::sync::Lazy;
-
-#[derive(Encode, Decode, Clone)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct Booleans {
-    pub r#true: String,
-    pub r#false: String,
+    #[serde(rename = "true")]
+    pub true_value: String,
+    #[serde(rename = "false")]
+    pub false_value: String,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct Errors {
-    pub r#ref: String,
+    #[serde(rename = "ref")]
+    pub ref_value: String,
     pub name: String,
     pub value: String,
     pub div: String,
@@ -25,15 +28,14 @@ pub struct Errors {
     pub null: String,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct Language {
     pub booleans: Booleans,
     pub errors: Errors,
 }
 
-#[allow(clippy::expect_used)]
 static LANGUAGES: Lazy<HashMap<String, Language>> = Lazy::new(|| {
-    bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
+    serde_json::from_str(include_str!("language.json")).expect("Failed parsing language file")
 });
 
 pub fn get_language(id: &str) -> Result<&Language, String> {

base/src/lib.rs

@@ -8,7 +8,7 @@
 //!
 //! ```toml
 //! [dependencies]
-//! ironcalc_base = { git = "https://github.com/ironcalc/IronCalc" }
+//! ironcalc_base = { git = "https://github.com/ironcalc/IronCalc", version = "0.1"}
 //! ```
 //!
 //! <small> until version 0.5.0 you should use the git dependencies as stated </small>
@@ -25,29 +25,29 @@
 #![doc = include_str!("../examples/formulas_and_errors.rs")]
 //! ```
 
-#![warn(clippy::print_stdout)]
-
 pub mod calc_result;
 pub mod cell;
 pub mod expressions;
 pub mod formatter;
 pub mod language;
 pub mod locale;
+pub mod model;
 pub mod new_empty;
 pub mod number_format;
 pub mod types;
 pub mod worksheet;
 
+mod functions;
+
 mod actions;
 mod cast;
 mod constants;
-mod diffs;
-mod functions;
-mod implicit_intersection;
-mod model;
 mod styles;
+
+mod diffs;
+mod implicit_intersection;
+
 mod units;
-mod user_model;
 mod utils;
 mod workbook;
 
@@ -56,9 +56,3 @@ mod test;
 
 #[cfg(test)]
 pub mod mock_time;
-
-pub use model::Model;
-pub use model::get_milliseconds_since_epoch;
-pub use user_model::BorderArea;
-pub use user_model::ClipboardData;
-pub use user_model::UserModel;

base/src/locale/mod.rs

@@ -1,29 +1,32 @@
-use bitcode::{Decode, Encode};
 use once_cell::sync::Lazy;
+use serde::{Deserialize, Serialize};
 
 use std::collections::HashMap;
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct Locale {
     pub dates: Dates,
     pub numbers: NumbersProperties,
     pub currency: Currency,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct Currency {
     pub iso: String,
     pub symbol: String,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct NumbersProperties {
+    #[serde(rename = "symbols-numberSystem-latn")]
     pub symbols: NumbersSymbols,
+    #[serde(rename = "decimalFormats-numberSystem-latn")]
     pub decimal_formats: DecimalFormats,
+    #[serde(rename = "currencyFormats-numberSystem-latn")]
     pub currency_formats: CurrencyFormats,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct Dates {
     pub day_names: Vec<String>,
     pub day_names_short: Vec<String>,
@@ -32,7 +35,8 @@ pub struct Dates {
     pub months_letter: Vec<String>,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
 pub struct NumbersSymbols {
     pub decimal: String,
     pub group: String,
@@ -50,27 +54,40 @@ pub struct NumbersSymbols {
 }
 
 // See: https://cldr.unicode.org/translation/number-currency-formats/number-and-currency-patterns
-#[derive(Encode, Decode, Clone)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct CurrencyFormats {
     pub standard: String,
+    #[serde(rename = "standard-alphaNextToNumber")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub standard_alpha_next_to_number: Option<String>,
+    #[serde(rename = "standard-noCurrency")]
     pub standard_no_currency: String,
     pub accounting: String,
+    #[serde(rename = "accounting-alphaNextToNumber")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub accounting_alpha_next_to_number: Option<String>,
+    #[serde(rename = "accounting-noCurrency")]
     pub accounting_no_currency: String,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
 pub struct DecimalFormats {
     pub standard: String,
 }
 
-#[allow(clippy::expect_used)]
-static LOCALES: Lazy<HashMap<String, Locale>> =
-    Lazy::new(|| bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale"));
+static LOCALES: Lazy<HashMap<String, Locale>> = Lazy::new(|| {
+    serde_json::from_str(include_str!("locales.json")).expect("Failed parsing locale")
+});
 
-pub fn get_locale(id: &str) -> Result<&Locale, String> {
+pub fn get_locale(_id: &str) -> Result<&Locale, String> {
     // TODO: pass the locale once we implement locales in Rust
+    let locale = LOCALES.get("en").ok_or("Invalid locale")?;
+    Ok(locale)
+}
+
+// TODO: Remove this function one we implement locales properly
+pub fn get_locale_fix(id: &str) -> Result<&Locale, String> {
     let locale = LOCALES.get(id).ok_or("Invalid locale")?;
     Ok(locale)
 }

base/src/mock_time.rs

@@ -10,7 +10,7 @@ use std::cell::RefCell;
 // 8 November 2022 12:13 Berlin time
 
 thread_local! {
-    static MOCK_TIME: RefCell<i64> = const { RefCell::new(1667906008578) };
+    static MOCK_TIME: RefCell<i64> = RefCell::new(1667906008578);
 }
 
 pub fn get_milliseconds_since_epoch() -> i64 {
@@ -20,18 +20,3 @@ pub fn get_milliseconds_since_epoch() -> i64 {
 pub fn set_mock_time(time: i64) {
     MOCK_TIME.with(|cell| *cell.borrow_mut() = time);
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::mock_time::MOCK_TIME;
-
-    use super::get_milliseconds_since_epoch;
-
-    #[test]
-    fn mock_time() {
-        let t = get_milliseconds_since_epoch();
-        assert_eq!(t, 1667906008578);
-
-        MOCK_TIME.with_borrow(|v| assert_eq!(*v, 1667906008578));
-    }
-}

base/src/new_empty.rs

@@ -1,24 +1,19 @@
-use chrono::DateTime;
+use chrono::NaiveDateTime;
 
 use std::collections::HashMap;
 
 use crate::{
     calc_result::Range,
-    constants::{DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH},
     expressions::{
         lexer::LexerMode,
-        parser::{
-            Parser,
-            stringify::{rename_sheet_in_node, to_rc_format},
-        },
+        parser::stringify::{rename_sheet_in_node, to_rc_format},
+        parser::Parser,
         types::CellReferenceRC,
     },
     language::get_language,
     locale::get_locale,
-    model::{Model, ParsedDefinedName, get_milliseconds_since_epoch},
-    types::{
-        Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet, WorksheetView,
-    },
+    model::{get_milliseconds_since_epoch, Model, ParsedDefinedName},
+    types::{Metadata, SheetState, Workbook, WorkbookSettings, Worksheet},
     utils::ParsedReference,
 };
 
@@ -38,20 +33,7 @@ fn is_valid_sheet_name(name: &str) -> bool {
 
 impl Model {
     /// Creates a new worksheet. Note that it does not check if the name or the sheet_id exists
-    fn new_empty_worksheet(name: &str, sheet_id: u32, view_ids: &[&u32]) -> Worksheet {
-        let mut views = HashMap::new();
-        for id in view_ids {
-            views.insert(
-                **id,
-                WorksheetView {
-                    row: 1,
-                    column: 1,
-                    range: [1, 1, 1, 1],
-                    top_row: 1,
-                    left_column: 1,
-                },
-            );
-        }
+    fn new_empty_worksheet(name: &str, sheet_id: u32) -> Worksheet {
         Worksheet {
             cols: vec![],
             rows: vec![],
@@ -66,8 +48,6 @@ impl Model {
             color: Default::default(),
             frozen_columns: 0,
             frozen_rows: 0,
-            show_grid_lines: true,
-            views,
         }
     }
 
@@ -85,14 +65,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);
@@ -142,16 +122,10 @@ impl Model {
         self.parsed_defined_names = parsed_defined_names;
     }
 
-    /// Reparses all formulas and defined names
-    pub(crate) fn reset_parsed_structures(&mut self) {
-        let defined_names = self
-            .workbook
-            .get_defined_names_with_scope()
-            .iter()
-            .map(|s| (s.0.to_owned(), s.1))
-            .collect();
+    // Reparses all formulas and defined names
+    fn reset_parsed_structures(&mut self) {
         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();
@@ -160,10 +134,10 @@ impl Model {
     }
 
     /// Adds a sheet with a automatically generated name
-    pub fn new_sheet(&mut self) -> (String, u32) {
+    pub fn new_sheet(&mut self) {
         // First we find a name
 
-        // TODO: The name should depend on the locale
+        // TODO: When/if we support i18n the name could depend on the locale
         let base_name = "Sheet";
         let base_name_uppercase = base_name.to_uppercase();
         let mut index = 1;
@@ -179,11 +153,9 @@ impl Model {
         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();
-        let worksheet = Model::new_empty_worksheet(&sheet_name, sheet_id, &view_ids);
+        let worksheet = Model::new_empty_worksheet(&sheet_name, sheet_id);
         self.workbook.worksheets.push(worksheet);
         self.reset_parsed_structures();
-        (sheet_name, self.workbook.worksheets.len() as u32 - 1)
     }
 
     /// Inserts a sheet with a particular index
@@ -211,8 +183,7 @@ impl Model {
             Some(id) => id,
             None => self.get_new_sheet_id(),
         };
-        let view_ids: Vec<&u32> = self.workbook.views.keys().collect();
-        let worksheet = Model::new_empty_worksheet(sheet_name, sheet_id, &view_ids);
+        let worksheet = Model::new_empty_worksheet(sheet_name, sheet_id);
         if sheet_index as usize > self.workbook.worksheets.len() {
             return Err("Sheet index out of range".to_string());
         }
@@ -252,10 +223,10 @@ 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;
@@ -268,11 +239,11 @@ impl Model {
         // We use iter because the default would be a mut_iter and we don't need a mutable reference
         let worksheets = &mut self.workbook.worksheets;
         for worksheet in worksheets {
-            let cell_reference = &CellReferenceRC {
+            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);
@@ -299,9 +270,9 @@ impl Model {
         if sheet_count == 1 {
             return Err("Cannot delete only sheet".to_string());
         };
-        if sheet_index >= sheet_count {
+        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(())
@@ -352,28 +323,18 @@ impl Model {
 
         let milliseconds = get_milliseconds_since_epoch();
         let seconds = milliseconds / 1000;
-        let dt = match DateTime::from_timestamp(seconds, 0) {
+        let dt = match NaiveDateTime::from_timestamp_opt(seconds, 0) {
             Some(s) => s,
             None => return Err(format!("Invalid timestamp: {}", milliseconds)),
         };
         // "2020-08-06T21:20:53Z
         let now = dt.format("%Y-%m-%dT%H:%M:%SZ").to_string();
 
-        let mut views = HashMap::new();
-        views.insert(
-            0,
-            WorkbookView {
-                sheet: 0,
-                window_width: DEFAULT_WINDOW_WIDTH,
-                window_height: DEFAULT_WINDOW_HEIGHT,
-            },
-        );
-
         // String versions of the locale are added here to simplify the serialize/deserialize logic
         let workbook = Workbook {
             shared_strings: vec![],
             defined_names: vec![],
-            worksheets: vec![Model::new_empty_worksheet("Sheet1", 1, &[&0])],
+            worksheets: vec![Model::new_empty_worksheet("Sheet1", 1)],
             styles: Default::default(),
             name: name.to_string(),
             settings: WorkbookSettings {
@@ -389,16 +350,14 @@ impl Model {
                 last_modified: now,
             },
             tables: HashMap::new(),
-            views,
         };
         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
-        #[allow(clippy::expect_used)]
         let language = get_language("en").expect("").clone();
 
         let mut model = Model {
@@ -411,7 +370,6 @@ impl Model {
             locale,
             language,
             tz,
-            view_id: 0,
         };
         model.parse_formulas();
         Ok(model)

base/src/number_format.rs

@@ -150,7 +150,7 @@ pub fn format_number(value: f64, format_code: &str, locale: &str) -> Formatted {
                 text: "#ERROR!".to_owned(),
                 color: None,
                 error: Some("Invalid locale".to_string()),
-            };
+            }
         }
     };
     formatter::format::format_number(value, format_code, locale)

base/src/styles.rs

@@ -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() {
@@ -159,29 +161,26 @@ impl Styles {
 
     pub fn create_named_style(&mut self, style_name: &str, style: &Style) -> Result<(), String> {
         let style_index = self.create_new_style(style);
-        self.add_named_cell_style(style_name, style_index)
+        self.add_named_cell_style(style_name, style_index)?;
+        Ok(())
     }
 
-    pub(crate) fn get_style_with_quote_prefix(&mut self, index: i32) -> Result<i32, String> {
-        let mut style = self.get_style(index)?;
+    pub(crate) fn get_style_with_quote_prefix(&mut self, index: i32) -> i32 {
+        let mut style = self.get_style(index);
         style.quote_prefix = true;
-        Ok(self.get_style_index_or_create(&style))
+        self.get_style_index_or_create(&style)
     }
 
-    pub(crate) fn get_style_with_format(
-        &mut self,
-        index: i32,
-        num_fmt: &str,
-    ) -> Result<i32, String> {
-        let mut style = self.get_style(index)?;
+    pub(crate) fn get_style_with_format(&mut self, index: i32, num_fmt: &str) -> i32 {
+        let mut style = self.get_style(index);
         style.num_fmt = num_fmt.to_string();
-        Ok(self.get_style_index_or_create(&style))
+        self.get_style_index_or_create(&style)
     }
 
-    pub(crate) fn get_style_without_quote_prefix(&mut self, index: i32) -> Result<i32, String> {
-        let mut style = self.get_style(index)?;
+    pub(crate) fn get_style_without_quote_prefix(&mut self, index: i32) -> i32 {
+        let mut style = self.get_style(index);
         style.quote_prefix = false;
-        Ok(self.get_style_index_or_create(&style))
+        self.get_style_index_or_create(&style)
     }
 
     pub(crate) fn style_is_quote_prefix(&self, index: i32) -> bool {
@@ -189,11 +188,9 @@ impl Styles {
         cell_xf.quote_prefix
     }
 
-    pub(crate) fn get_style(&self, index: i32) -> Result<Style, String> {
-        let cell_xf = &self
-            .cell_xfs
-            .get(index as usize)
-            .ok_or("Invalid index provided".to_string())?;
+    pub(crate) fn get_style(&self, index: i32) -> Style {
+        let cell_xf = &self.cell_xfs[index as usize];
+
         let border_id = cell_xf.border_id as usize;
         let fill_id = cell_xf.fill_id as usize;
         let font_id = cell_xf.font_id as usize;
@@ -201,14 +198,14 @@ impl Styles {
         let quote_prefix = cell_xf.quote_prefix;
         let alignment = cell_xf.alignment.clone();
 
-        Ok(Style {
+        Style {
             alignment,
             num_fmt: get_num_fmt(num_fmt_id, &self.num_fmts),
             fill: self.fills[fill_id].clone(),
             font: self.fonts[font_id].clone(),
             border: self.borders[border_id].clone(),
             quote_prefix,
-        })
+        }
     }
 }
 
@@ -224,7 +221,8 @@ impl Model {
         let style_index = self.workbook.styles.get_style_index_or_create(style);
         self.workbook
             .worksheet_mut(sheet)?
-            .set_cell_style(row, column, style_index)
+            .set_cell_style(row, column, style_index);
+        Ok(())
     }
 
     pub fn copy_cell_style(
@@ -239,7 +237,9 @@ impl Model {
 
         self.workbook
             .worksheet_mut(destination_cell.0)?
-            .set_cell_style(destination_cell.1, destination_cell.2, source_style_index)
+            .set_cell_style(destination_cell.1, destination_cell.2, source_style_index);
+
+        Ok(())
     }
 
     /// Sets the style "style_name" in cell
@@ -253,7 +253,8 @@ impl Model {
         let style_index = self.workbook.styles.get_style_index_by_name(style_name)?;
         self.workbook
             .worksheet_mut(sheet)?
-            .set_cell_style(row, column, style_index)
+            .set_cell_style(row, column, style_index);
+        Ok(())
     }
 
     pub fn set_sheet_style(&mut self, sheet: u32, style_name: &str) -> Result<(), String> {

base/src/test/engineering/test_complex.rs

@@ -76,16 +76,10 @@ fn fn_imconjugate() {
 fn fn_imcos() {
     let mut model = new_empty_model();
     model._set("A1", r#"=IMCOS("4+3i")"#);
-    // In macos non intel this is "-6.58066304055116+7.58155274274655i"
-    model._set("A2", r#"=COMPLEX(-6.58066304055116, 7.58155274274654)"#);
-    model._set("A3", r#"=IMABS(IMSUB(A1, A2)) < G1"#);
-
-    // small number
-    model._set("G1", "0.0000001");
 
     model.evaluate();
 
-    assert_eq!(model._get_text("A3"), "TRUE");
+    assert_eq!(model._get_text("A1"), "-6.58066304055116+7.58155274274654i");
 }
 
 #[test]

base/src/test/mod.rs

@@ -1,7 +1,6 @@
 mod test_actions;
 mod test_binary_search;
 mod test_cell;
-mod test_cell_clear_contents;
 mod test_circular_references;
 mod test_column_width;
 mod test_criteria;
@@ -13,37 +12,32 @@ mod test_fn_averageifs;
 mod test_fn_choose;
 mod test_fn_concatenate;
 mod test_fn_count;
-mod test_fn_day;
 mod test_fn_exact;
 mod test_fn_financial;
-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_unicode;
 mod test_forward_references;
 mod test_frozen_rows_columns;
 mod test_general;
 mod test_math;
 mod test_metadata;
-mod test_model_cell_clear_all;
+mod test_model_delete_cell;
 mod test_model_is_empty_cell;
+mod test_model_set_cell_empty;
 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_workbook;
 mod test_worksheet;
 pub(crate) mod util;
@@ -54,14 +48,8 @@ mod test_number_format;
 
 mod test_escape_quotes;
 mod test_extend;
-mod test_fn_fv;
 mod test_fn_type;
 mod test_frozen_rows_and_columns;
-mod test_geomean;
 mod test_get_cell_content;
-mod test_issue_155;
 mod test_percentage;
-mod test_set_functions_error_handling;
 mod test_today;
-mod test_types;
-mod user_model;

base/src/test/test_actions.rs

@@ -1,9 +1,8 @@
 #![allow(clippy::unwrap_used)]
 
-use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN};
+use crate::constants::LAST_COLUMN;
 use crate::model::Model;
 use crate::test::util::new_empty_model;
-use crate::types::Col;
 
 #[test]
 fn test_insert_columns() {
@@ -87,8 +86,7 @@ fn test_insert_rows_styles() {
     let mut model = new_empty_model();
 
     assert!(
-        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
-            < f64::EPSILON
+        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
     );
     // sets height 42 in row 10
     model
@@ -107,8 +105,7 @@ fn test_insert_rows_styles() {
 
     // Row 10 has the default height
     assert!(
-        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
-            < f64::EPSILON
+        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
     );
 
     // Row 10 is now row 15
@@ -122,8 +119,7 @@ fn test_delete_rows_styles() {
     let mut model = new_empty_model();
 
     assert!(
-        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
-            < f64::EPSILON
+        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
     );
     // sets height 42 in row 10
     model
@@ -142,8 +138,7 @@ fn test_delete_rows_styles() {
 
     // Row 10 has the default height
     assert!(
-        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
-            < f64::EPSILON
+        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
     );
 
     // Row 10 is now row 5
@@ -200,252 +195,6 @@ fn test_delete_columns() {
     assert_eq!(model._get_formula("A3"), *"=SUM(#REF!:K4)");
 }
 
-#[test]
-fn test_delete_column_width() {
-    let mut model = new_empty_model();
-    let (sheet, column) = (0, 5);
-    let normal_width = model.get_column_width(sheet, column).unwrap();
-    // Set the width of one column to 5 times the normal width
-    assert!(
-        model
-            .set_column_width(sheet, column, normal_width * 5.0)
-            .is_ok()
-    );
-
-    // delete it
-    assert!(model.delete_columns(sheet, column, 1).is_ok());
-
-    // all the columns around have the expected width
-    assert_eq!(
-        model.get_column_width(sheet, column - 1).unwrap(),
-        normal_width
-    );
-    assert_eq!(model.get_column_width(sheet, column).unwrap(), normal_width);
-    assert_eq!(
-        model.get_column_width(sheet, column + 1).unwrap(),
-        normal_width
-    );
-}
-
-#[test]
-// We set the style of columns 4 to 7 and delete column 4
-// We check that columns 4 to 6 have the new style
-fn test_delete_first_column_width() {
-    let mut model = new_empty_model();
-    model.workbook.worksheets[0].cols = vec![Col {
-        min: 4,
-        max: 7,
-        width: 300.0,
-        custom_width: true,
-        style: None,
-    }];
-    let (sheet, column) = (0, 4);
-    assert!(model.delete_columns(sheet, column, 1).is_ok());
-    let cols = &model.workbook.worksheets[0].cols;
-    assert_eq!(cols.len(), 1);
-    assert_eq!(
-        cols[0],
-        Col {
-            min: 4,
-            max: 6,
-            width: 300.0,
-            custom_width: true,
-            style: None
-        }
-    );
-}
-
-#[test]
-// Delete the last column in the range
-fn test_delete_last_column_width() {
-    let mut model = new_empty_model();
-    model.workbook.worksheets[0].cols = vec![Col {
-        min: 4,
-        max: 7,
-        width: 300.0,
-        custom_width: true,
-        style: None,
-    }];
-    let (sheet, column) = (0, 7);
-    assert!(model.delete_columns(sheet, column, 1).is_ok());
-    let cols = &model.workbook.worksheets[0].cols;
-    assert_eq!(cols.len(), 1);
-    assert_eq!(
-        cols[0],
-        Col {
-            min: 4,
-            max: 6,
-            width: 300.0,
-            custom_width: true,
-            style: None
-        }
-    );
-}
-
-#[test]
-// Deletes columns at the end
-fn test_delete_last_few_columns_width() {
-    let mut model = new_empty_model();
-    model.workbook.worksheets[0].cols = vec![Col {
-        min: 4,
-        max: 17,
-        width: 300.0,
-        custom_width: true,
-        style: None,
-    }];
-    let (sheet, column) = (0, 13);
-    assert!(model.delete_columns(sheet, column, 10).is_ok());
-    let cols = &model.workbook.worksheets[0].cols;
-    assert_eq!(cols.len(), 1);
-    assert_eq!(
-        cols[0],
-        Col {
-            min: 4,
-            max: 12,
-            width: 300.0,
-            custom_width: true,
-            style: None
-        }
-    );
-}
-
-#[test]
-fn test_delete_columns_non_overlapping_left() {
-    let mut model = new_empty_model();
-    model.workbook.worksheets[0].cols = vec![Col {
-        min: 10,
-        max: 17,
-        width: 300.0,
-        custom_width: true,
-        style: None,
-    }];
-    let (sheet, column) = (0, 3);
-    assert!(model.delete_columns(sheet, column, 4).is_ok());
-    let cols = &model.workbook.worksheets[0].cols;
-    assert_eq!(cols.len(), 1);
-    assert_eq!(
-        cols[0],
-        Col {
-            min: 6,
-            max: 13,
-            width: 300.0,
-            custom_width: true,
-            style: None
-        }
-    );
-}
-
-#[test]
-fn test_delete_columns_overlapping_left() {
-    let mut model = new_empty_model();
-    model.workbook.worksheets[0].cols = vec![Col {
-        min: 10,
-        max: 20,
-        width: 300.0,
-        custom_width: true,
-        style: None,
-    }];
-    let (sheet, column) = (0, 8);
-    assert!(model.delete_columns(sheet, column, 4).is_ok());
-    let cols = &model.workbook.worksheets[0].cols;
-    assert_eq!(cols.len(), 1);
-    assert_eq!(
-        cols[0],
-        Col {
-            min: 8,
-            max: 16,
-            width: 300.0,
-            custom_width: true,
-            style: None
-        }
-    );
-}
-
-#[test]
-fn test_delete_columns_non_overlapping_right() {
-    let mut model = new_empty_model();
-    model.workbook.worksheets[0].cols = vec![Col {
-        min: 10,
-        max: 17,
-        width: 300.0,
-        custom_width: true,
-        style: None,
-    }];
-    let (sheet, column) = (0, 23);
-    assert!(model.delete_columns(sheet, column, 4).is_ok());
-    let cols = &model.workbook.worksheets[0].cols;
-    assert_eq!(cols.len(), 1);
-    assert_eq!(
-        cols[0],
-        Col {
-            min: 10,
-            max: 17,
-            width: 300.0,
-            custom_width: true,
-            style: None
-        }
-    );
-}
-
-#[test]
-// deletes some columns in the middle of the range
-fn test_delete_middle_column_width() {
-    let mut model = new_empty_model();
-    // styled columns [4, 17]
-    model.workbook.worksheets[0].cols = vec![Col {
-        min: 4,
-        max: 17,
-        width: 300.0,
-        custom_width: true,
-        style: None,
-    }];
-
-    // deletes columns 10, 11, 12
-    let (sheet, column) = (0, 10);
-    assert!(model.delete_columns(sheet, column, 3).is_ok());
-    let cols = &model.workbook.worksheets[0].cols;
-    assert_eq!(cols.len(), 1);
-    assert_eq!(
-        cols[0],
-        Col {
-            min: 4,
-            max: 14,
-            width: 300.0,
-            custom_width: true,
-            style: None
-        }
-    );
-}
-
-#[test]
-// the range is inside the deleted columns
-fn delete_range_in_columns() {
-    let mut model = new_empty_model();
-    // styled columns [6, 10]
-    model.workbook.worksheets[0].cols = vec![Col {
-        min: 6,
-        max: 10,
-        width: 300.0,
-        custom_width: true,
-        style: None,
-    }];
-
-    // deletes columns [4, 17]
-    let (sheet, column) = (0, 4);
-    assert!(model.delete_columns(sheet, column, 8).is_ok());
-    let cols = &model.workbook.worksheets[0].cols;
-    assert_eq!(cols.len(), 0);
-}
-
-#[test]
-fn test_delete_columns_error() {
-    let mut model = new_empty_model();
-    let (sheet, column) = (0, 5);
-    assert!(model.delete_columns(sheet, column, -1).is_err());
-    assert!(model.delete_columns(sheet, column, 0).is_err());
-    assert!(model.delete_columns(sheet, column, 1).is_ok());
-}
-
 #[test]
 fn test_delete_rows() {
     let mut model = new_empty_model();

base/src/test/test_column_width.rs

@@ -23,10 +23,10 @@ fn test_column_width() {
         .unwrap();
     assert_eq!(model.workbook.worksheets[0].cols.len(), 3);
     let worksheet = model.workbook.worksheet(0).unwrap();
-    assert!((worksheet.get_column_width(1).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
-    assert!((worksheet.get_column_width(2).unwrap() - 30.0).abs() < f64::EPSILON);
-    assert!((worksheet.get_column_width(3).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
-    assert_eq!(model.get_cell_style_index(0, 23, 2), Ok(6));
+    assert!((worksheet.column_width(1).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
+    assert!((worksheet.column_width(2).unwrap() - 30.0).abs() < f64::EPSILON);
+    assert!((worksheet.column_width(3).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
+    assert_eq!(model.get_cell_style_index(0, 23, 2), 6);
 }
 
 #[test]
@@ -48,12 +48,10 @@ fn test_column_width_lower_edge() {
         .unwrap();
     assert_eq!(model.workbook.worksheets[0].cols.len(), 2);
     let worksheet = model.workbook.worksheet(0).unwrap();
-    assert!((worksheet.get_column_width(4).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
-    assert!((worksheet.get_column_width(5).unwrap() - 30.0).abs() < f64::EPSILON);
-    assert!(
-        (worksheet.get_column_width(6).unwrap() - 10.0 * COLUMN_WIDTH_FACTOR).abs() < f64::EPSILON
-    );
-    assert_eq!(model.get_cell_style_index(0, 23, 5), Ok(1));
+    assert!((worksheet.column_width(4).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
+    assert!((worksheet.column_width(5).unwrap() - 30.0).abs() < f64::EPSILON);
+    assert!((worksheet.column_width(6).unwrap() - 10.0 * COLUMN_WIDTH_FACTOR).abs() < f64::EPSILON);
+    assert_eq!(model.get_cell_style_index(0, 23, 5), 1);
 }
 
 #[test]
@@ -76,27 +74,9 @@ fn test_column_width_higher_edge() {
     assert_eq!(model.workbook.worksheets[0].cols.len(), 2);
     let worksheet = model.workbook.worksheet(0).unwrap();
     assert!(
-        (worksheet.get_column_width(15).unwrap() - 10.0 * COLUMN_WIDTH_FACTOR).abs() < f64::EPSILON
+        (worksheet.column_width(15).unwrap() - 10.0 * COLUMN_WIDTH_FACTOR).abs() < f64::EPSILON
     );
-    assert!((worksheet.get_column_width(16).unwrap() - 30.0).abs() < f64::EPSILON);
-    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));
+    assert!((worksheet.column_width(16).unwrap() - 30.0).abs() < f64::EPSILON);
+    assert!((worksheet.column_width(17).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
+    assert_eq!(model.get_cell_style_index(0, 23, 16), 1);
 }

base/src/test/test_date_and_time.rs

@@ -37,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"),
@@ -64,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]
@@ -132,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");
 
@@ -152,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");
 
@@ -172,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");
 
@@ -204,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");

base/src/test/test_error_propagation.rs

@@ -1,5 +1,4 @@
 #![allow(clippy::unwrap_used)]
-#![allow(clippy::panic)]
 
 use crate::test::util::new_empty_model;
 use crate::types::Cell;

base/src/test/test_fn_day.rs

@@ -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");
-}

base/src/test/test_fn_formulatext.rs

@@ -1,44 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn wrong_number_of_arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=FORMULATEXT()");
-    model._set("A2", "=FORMULATEXT(\"B\",\"A\")");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-}
-
-#[test]
-fn multi_sheet_ref() {
-    let mut model = new_empty_model();
-    model.new_sheet();
-    model._set("A1", "=FORMULATEXT(Sheet1!A1:Sheet2!A1)");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-}
-
-#[test]
-fn implicit_intersection() {
-    let mut model = new_empty_model();
-    model._set("A1", "=FORMULATEXT(C1:C2)");
-    model._set("A2", "=FORMULATEXT(D1:E1)");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-}
-
-#[test]
-fn non_reference() {
-    let mut model = new_empty_model();
-    model._set("A1", "=FORMULATEXT(42)");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-}

base/src/test/test_fn_fv.rs

@@ -1,36 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn computation() {
-    let i2 = "=-C2*(1+D2)^E2-F2*((D2+1)*((1+D2)^E2-1))/D2";
-
-    let mut model = new_empty_model();
-    model._set("C2", "1");
-    model._set("D2", "2");
-    model._set("E2", "3");
-    model._set("F2", "4");
-
-    model._set("I2", i2);
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("I2"), "-183");
-    assert_eq!(model._get_formula("I2"), i2);
-}
-
-#[test]
-fn format_as_currency() {
-    let mut model = new_empty_model();
-    model._set("C2", "1");
-    model._set("D2", "2");
-    model._set("E2", "3");
-    model._set("F2", "4");
-
-    model._set("I2", "=FV(D2,E2,F2,C2,1)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("I2"), "-$183.00");
-}

base/src/test/test_fn_or_xor.rs

@@ -1,204 +0,0 @@
-#![allow(clippy::unwrap_used)]
-#![allow(clippy::print_stdout)]
-use crate::test::util::new_empty_model;
-
-// These tests are grouped because in many cases XOR and OR have similar behaviour.
-
-// Test specific to xor
-#[test]
-fn fn_xor() {
-    let mut model = new_empty_model();
-
-    model._set("A1", "=XOR(1, 1, 1, 0, 0)");
-    model._set("A2", "=XOR(1, 1, 0, 0, 0)");
-    model._set("A3", "=XOR(TRUE, TRUE, TRUE, FALSE, FALSE)");
-    model._set("A4", "=XOR(TRUE, TRUE, FALSE, FALSE, FALSE)");
-    model._set("A5", "=XOR(FALSE, FALSE, FALSE, FALSE, FALSE)");
-    model._set("A6", "=XOR(TRUE, TRUE)");
-    model._set("A7", "=XOR(0,0,0)");
-    model._set("A8", "=XOR(0,0,1)");
-    model._set("A9", "=XOR(0,1,0)");
-    model._set("A10", "=XOR(0,1,1)");
-    model._set("A11", "=XOR(1,0,0)");
-    model._set("A12", "=XOR(1,0,1)");
-    model._set("A13", "=XOR(1,1,0)");
-    model._set("A14", "=XOR(1,1,1)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"TRUE");
-    assert_eq!(model._get_text("A2"), *"FALSE");
-    assert_eq!(model._get_text("A3"), *"TRUE");
-    assert_eq!(model._get_text("A4"), *"FALSE");
-    assert_eq!(model._get_text("A5"), *"FALSE");
-    assert_eq!(model._get_text("A6"), *"FALSE");
-    assert_eq!(model._get_text("A7"), *"FALSE");
-    assert_eq!(model._get_text("A8"), *"TRUE");
-    assert_eq!(model._get_text("A9"), *"TRUE");
-    assert_eq!(model._get_text("A10"), *"FALSE");
-    assert_eq!(model._get_text("A11"), *"TRUE");
-    assert_eq!(model._get_text("A12"), *"FALSE");
-    assert_eq!(model._get_text("A13"), *"FALSE");
-    assert_eq!(model._get_text("A14"), *"TRUE");
-}
-
-#[test]
-fn fn_or() {
-    let mut model = new_empty_model();
-
-    model._set("A1", "=OR(1, 1, 1, 0, 0)");
-    model._set("A2", "=OR(1, 1, 0, 0, 0)");
-    model._set("A3", "=OR(TRUE, TRUE, TRUE, FALSE, FALSE)");
-    model._set("A4", "=OR(TRUE, TRUE, FALSE, FALSE, FALSE)");
-    model._set("A5", "=OR(FALSE, FALSE, FALSE, FALSE, FALSE)");
-    model._set("A6", "=OR(TRUE, TRUE)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"TRUE");
-    assert_eq!(model._get_text("A2"), *"TRUE");
-    assert_eq!(model._get_text("A3"), *"TRUE");
-    assert_eq!(model._get_text("A4"), *"TRUE");
-    assert_eq!(model._get_text("A5"), *"FALSE");
-    assert_eq!(model._get_text("A6"), *"TRUE");
-}
-
-#[test]
-fn fn_or_xor() {
-    inner("or");
-    inner("xor");
-
-    fn inner(func: &str) {
-        println!("Testing function: {func}");
-
-        let mut model = new_empty_model();
-
-        // Text args
-        model._set("A1", &format!(r#"={func}("")"#));
-        model._set("A2", &format!(r#"={func}("", "")"#));
-        model._set("A3", &format!(r#"={func}("", TRUE)"#));
-        model._set("A4", &format!(r#"={func}("", FALSE)"#));
-
-        model._set("A5", &format!("={func}(FALSE, TRUE)"));
-        model._set("A6", &format!("={func}(FALSE, FALSE)"));
-        model._set("A7", &format!("={func}(TRUE, FALSE)"));
-
-        // Reference to empty cell, plus true argument
-        model._set("A8", &format!("={func}(Z99, 1)"));
-
-        // Reference to empty cell/range
-        model._set("A9", &format!("={func}(Z99)"));
-        model._set("A10", &format!("={func}(X99:Z99"));
-
-        // Reference to cell with reference to empty range
-        model._set("B11", "=X99:Z99");
-        model._set("A11", &format!("={func}(B11)"));
-
-        // Reference to cell with non-empty range
-        model._set("X12", "1");
-        model._set("B12", "=X12:Z12");
-        model._set("A12", &format!("={func}(B12)"));
-
-        // Reference to text cell
-        model._set("B13", "some_text");
-        model._set("A13", &format!("={func}(B13)"));
-        model._set("A14", &format!("={func}(B13, 0)"));
-        model._set("A15", &format!("={func}(B13, 1)"));
-
-        // Reference to Implicit intersection
-        model._set("X16", "1");
-        model._set("B16", "=@X15:X16");
-        model._set("A16", &format!("={func}(B16)"));
-
-        // Non-empty range
-        model._set("B17", "1");
-        model._set("A17", &format!("={func}(B17:C17)"));
-
-        // Non-empty range with text
-        model._set("B18", "text");
-        model._set("A18", &format!("={func}(B18:C18)"));
-
-        // Non-empty range with text and number
-        model._set("B19", "text");
-        model._set("C19", "1");
-        model._set("A19", &format!("={func}(B19:C19)"));
-
-        // range with error
-        model._set("B20", "=1/0");
-        model._set("A20", &format!("={func}(B20:C20)"));
-
-        model.evaluate();
-
-        assert_eq!(model._get_text("A1"), *"#VALUE!");
-        assert_eq!(model._get_text("A2"), *"#VALUE!");
-        assert_eq!(model._get_text("A3"), *"TRUE");
-        assert_eq!(model._get_text("A4"), *"FALSE");
-
-        assert_eq!(model._get_text("A5"), *"TRUE");
-        assert_eq!(model._get_text("A6"), *"FALSE");
-        assert_eq!(model._get_text("A7"), *"TRUE");
-
-        assert_eq!(model._get_text("A8"), *"TRUE");
-
-        assert_eq!(model._get_text("A9"), *"#VALUE!");
-        assert_eq!(model._get_text("A10"), *"#VALUE!");
-
-        assert_eq!(model._get_text("A11"), *"#VALUE!");
-
-        // TODO: This one depends on spill behaviour which isn't implemented yet
-        // assert_eq!(model._get_text("A12"), *"TRUE");
-
-        assert_eq!(model._get_text("A13"), *"#VALUE!");
-        assert_eq!(model._get_text("A14"), *"FALSE");
-        assert_eq!(model._get_text("A15"), *"TRUE");
-
-        // TODO: This one depends on @ implicit intersection behaviour which isn't implemented yet
-        // assert_eq!(model._get_text("A16"), *"TRUE");
-
-        assert_eq!(model._get_text("A17"), *"TRUE");
-
-        assert_eq!(model._get_text("A18"), *"#VALUE!");
-
-        assert_eq!(model._get_text("A19"), *"TRUE");
-
-        assert_eq!(model._get_text("A20"), *"#DIV/0!");
-    }
-}
-
-#[test]
-fn fn_or_xor_no_arguments() {
-    inner("or");
-    inner("xor");
-
-    fn inner(func: &str) {
-        println!("Testing function: {func}");
-
-        let mut model = new_empty_model();
-        model._set("A1", &format!("={}()", func));
-        model.evaluate();
-        assert_eq!(model._get_text("A1"), *"#ERROR!");
-    }
-}
-
-#[test]
-fn fn_or_xor_missing_arguments() {
-    inner("or");
-    inner("xor");
-
-    fn inner(func: &str) {
-        println!("Testing function: {func}");
-
-        let mut model = new_empty_model();
-        model._set("A1", &format!("={func}(,)"));
-        model._set("A2", &format!("={func}(,1)"));
-        model._set("A3", &format!("={func}(1,)"));
-        model._set("A4", &format!("={func}(,B1)"));
-        model._set("A5", &format!("={func}(,B1:B4)"));
-        model.evaluate();
-        assert_eq!(model._get_text("A1"), *"FALSE");
-        assert_eq!(model._get_text("A2"), *"TRUE");
-        assert_eq!(model._get_text("A3"), *"TRUE");
-        assert_eq!(model._get_text("A4"), *"FALSE");
-        assert_eq!(model._get_text("A5"), *"FALSE");
-    }
-}

base/src/test/test_fn_unicode.rs

@@ -1,63 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn simple_cases() {
-    let mut model = new_empty_model();
-    model._set("A1", "=UNICODE(\"1,00\")");
-    model._set("A2", "=UNICODE(\"1\")");
-    model._set("A3", "=UNICODE(1)");
-    model._set("A4", "=UNICODE(\"T\")");
-    model._set("A5", "=UNICODE(\"TRUE\")");
-    model._set("A6", "=UNICODE(TRUE)");
-    model._set("A7", "=UNICODE(FALSE)");
-    model._set("A8", "=UNICODE(\"の\")");
-    model._set("A9", "=UNICODE(\" \")");
-
-    model._set("A10", "=_xlfn.UNICODE(\"T\")");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"49");
-    assert_eq!(model._get_text("A2"), *"49");
-    assert_eq!(model._get_text("A3"), *"49");
-    assert_eq!(model._get_text("A4"), *"84");
-    assert_eq!(model._get_text("A5"), *"84");
-    assert_eq!(model._get_text("A6"), *"84");
-    assert_eq!(model._get_text("A7"), *"70");
-    assert_eq!(model._get_text("A8"), *"12398");
-    assert_eq!(model._get_text("A9"), *"32");
-    assert_eq!(model._get_text("A10"), *"84");
-}
-
-#[test]
-fn test_error_cases() {
-    let mut model = new_empty_model();
-    model._set("A1", "=UNICODE(\"\")");
-    model._set("A2", "=UNICODE(#CALC!)");
-    model._set("A3", "=UNICODE(#NAME?)");
-    model._set("A4", "=UNICODE(#VALUE!)");
-    model._set("A5", "=UNICODE(#REF!)");
-    model._set("A6", "=UNICODE(#DIV/0!)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"#VALUE!");
-    assert_eq!(model._get_text("A2"), *"#CALC!");
-    assert_eq!(model._get_text("A3"), *"#NAME?");
-    assert_eq!(model._get_text("A4"), *"#VALUE!");
-    assert_eq!(model._get_text("A5"), *"#REF!");
-    assert_eq!(model._get_text("A6"), *"#DIV/0!");
-}
-
-#[test]
-fn wrong_number_of_arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=UNICODE()");
-    model._set("A2", "=UNICODE(\"B\",\"A\")");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-}

base/src/test/test_frozen_rows_and_columns.rs

@@ -8,37 +8,34 @@ use crate::{
 #[test]
 fn test_empty_model() {
     let mut model = new_empty_model();
-    assert_eq!(model.get_frozen_rows_count(0), Ok(0));
-    assert_eq!(model.get_frozen_columns_count(0), Ok(0));
+    assert_eq!(model.get_frozen_rows(0), Ok(0));
+    assert_eq!(model.get_frozen_columns(0), Ok(0));
 
     let e = model.set_frozen_rows(0, 3);
     assert!(e.is_ok());
-    assert_eq!(model.get_frozen_rows_count(0), Ok(3));
-    assert_eq!(model.get_frozen_columns_count(0), Ok(0));
+    assert_eq!(model.get_frozen_rows(0), Ok(3));
+    assert_eq!(model.get_frozen_columns(0), Ok(0));
 
     let e = model.set_frozen_columns(0, 53);
     assert!(e.is_ok());
-    assert_eq!(model.get_frozen_rows_count(0), Ok(3));
-    assert_eq!(model.get_frozen_columns_count(0), Ok(53));
+    assert_eq!(model.get_frozen_rows(0), Ok(3));
+    assert_eq!(model.get_frozen_columns(0), Ok(53));
 
     // Set them back to zero
     let e = model.set_frozen_rows(0, 0);
     assert!(e.is_ok());
     let e = model.set_frozen_columns(0, 0);
     assert!(e.is_ok());
-    assert_eq!(model.get_frozen_rows_count(0), Ok(0));
-    assert_eq!(model.get_frozen_columns_count(0), Ok(0));
+    assert_eq!(model.get_frozen_rows(0), Ok(0));
+    assert_eq!(model.get_frozen_columns(0), Ok(0));
 }
 
 #[test]
 fn test_invalid_sheet() {
     let mut model = new_empty_model();
+    assert_eq!(model.get_frozen_rows(1), Err("Invalid sheet".to_string()));
     assert_eq!(
-        model.get_frozen_rows_count(1),
-        Err("Invalid sheet".to_string())
-    );
-    assert_eq!(
-        model.get_frozen_columns_count(3),
+        model.get_frozen_columns(3),
         Err("Invalid sheet".to_string())
     );