diff --git a/.github/workflows/advisory-cron.yaml b/.github/workflows/advisory-cron.yaml
index 90923191..31bac5a3 100644
--- a/.github/workflows/advisory-cron.yaml
+++ b/.github/workflows/advisory-cron.yaml
@@ -1,4 +1,4 @@
-name: ci
+name: Advisories
on:
schedule:
- cron: '0 18 * * *'
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index b6e8dc31..8519ac5e 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -1,11 +1,11 @@
-name: ci
-on:
+name: CI
+on:
push:
branches:
- - experiment
+ - main
pull_request:
branches:
- - experiment
+ - main
jobs:
fmt:
runs-on: ubuntu-latest
@@ -14,7 +14,8 @@ jobs:
- uses: actions-rs/toolchain@v1
with:
profile: minimal
- toolchain: stable
+ toolchain: 1.67.0
+ default: true
components: rustfmt
- uses: Swatinem/rust-cache@v1
- run: ./scripts/ci/fmt
@@ -27,7 +28,8 @@ jobs:
- uses: actions-rs/toolchain@v1
with:
profile: minimal
- toolchain: stable
+ toolchain: 1.67.0
+ default: true
components: clippy
- uses: Swatinem/rust-cache@v1
- run: ./scripts/ci/lint
@@ -40,9 +42,14 @@ jobs:
- uses: actions-rs/toolchain@v1
with:
profile: minimal
- toolchain: stable
+ toolchain: 1.67.0
+ default: true
- uses: Swatinem/rust-cache@v1
- - run: ./scripts/ci/docs
+ - name: Build rust docs
+ run: ./scripts/ci/rust-docs
+ shell: bash
+ - name: Install doxygen
+ run: sudo apt-get install -y doxygen
shell: bash
cargo-deny:
@@ -57,31 +64,88 @@ jobs:
- uses: actions/checkout@v2
- uses: EmbarkStudios/cargo-deny-action@v1
with:
+ arguments: '--manifest-path ./rust/Cargo.toml'
command: check ${{ matrix.checks }}
+ wasm_tests:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v2
+ - name: Install wasm-bindgen-cli
+ run: cargo install wasm-bindgen-cli wasm-opt
+ - name: Install wasm32 target
+ run: rustup target add wasm32-unknown-unknown
+ - name: run tests
+ run: ./scripts/ci/wasm_tests
+ deno_tests:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v2
+ - uses: denoland/setup-deno@v1
+ with:
+ deno-version: v1.x
+ - name: Install wasm-bindgen-cli
+ run: cargo install wasm-bindgen-cli wasm-opt
+ - name: Install wasm32 target
+ run: rustup target add wasm32-unknown-unknown
+ - name: run tests
+ run: ./scripts/ci/deno_tests
+
+ js_fmt:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v2
+ - name: install
+ run: yarn global add prettier
+ - name: format
+ run: prettier -c javascript/.prettierrc javascript
+
js_tests:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- - name: Install wasm-pack
- run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+ - name: Install wasm-bindgen-cli
+ run: cargo install wasm-bindgen-cli wasm-opt
+ - name: Install wasm32 target
+ run: rustup target add wasm32-unknown-unknown
- name: run tests
run: ./scripts/ci/js_tests
+ cmake_build:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v2
+ - uses: actions-rs/toolchain@v1
+ with:
+ profile: minimal
+ toolchain: nightly-2023-01-26
+ default: true
+ - uses: Swatinem/rust-cache@v1
+ - name: Install CMocka
+ run: sudo apt-get install -y libcmocka-dev
+ - name: Install/update CMake
+ uses: jwlawson/actions-setup-cmake@v1.12
+ with:
+ cmake-version: latest
+ - name: Install rust-src
+ run: rustup component add rust-src
+ - name: Build and test C bindings
+ run: ./scripts/ci/cmake-build Release Static
+ shell: bash
+
linux:
runs-on: ubuntu-latest
strategy:
matrix:
toolchain:
- - stable
- - nightly
- continue-on-error: ${{ matrix.toolchain == 'nightly' }}
+ - 1.67.0
steps:
- uses: actions/checkout@v2
- uses: actions-rs/toolchain@v1
with:
profile: minimal
toolchain: ${{ matrix.toolchain }}
+ default: true
- uses: Swatinem/rust-cache@v1
- run: ./scripts/ci/build-test
shell: bash
@@ -93,7 +157,8 @@ jobs:
- uses: actions-rs/toolchain@v1
with:
profile: minimal
- toolchain: stable
+ toolchain: 1.67.0
+ default: true
- uses: Swatinem/rust-cache@v1
- run: ./scripts/ci/build-test
shell: bash
@@ -105,8 +170,8 @@ jobs:
- uses: actions-rs/toolchain@v1
with:
profile: minimal
- toolchain: stable
+ toolchain: 1.67.0
+ default: true
- uses: Swatinem/rust-cache@v1
- run: ./scripts/ci/build-test
shell: bash
-
diff --git a/.github/workflows/docs.yaml b/.github/workflows/docs.yaml
new file mode 100644
index 00000000..b501d526
--- /dev/null
+++ b/.github/workflows/docs.yaml
@@ -0,0 +1,52 @@
+on:
+ push:
+ branches:
+ - main
+
+name: Documentation
+
+jobs:
+ deploy-docs:
+ concurrency: deploy-docs
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v2
+
+ - name: Toolchain
+ uses: actions-rs/toolchain@v1
+ with:
+ profile: minimal
+ toolchain: stable
+ override: true
+
+ - name: Cache
+ uses: Swatinem/rust-cache@v1
+
+ - name: Clean docs dir
+ run: rm -rf docs
+ shell: bash
+
+ - name: Clean Rust docs dir
+ uses: actions-rs/cargo@v1
+ with:
+ command: clean
+ args: --manifest-path ./rust/Cargo.toml --doc
+
+ - name: Build Rust docs
+ uses: actions-rs/cargo@v1
+ with:
+ command: doc
+ args: --manifest-path ./rust/Cargo.toml --workspace --all-features --no-deps
+
+ - name: Move Rust docs
+ run: mkdir -p docs && mv rust/target/doc/* docs/.
+ shell: bash
+
+ - name: Configure root page
+ run: echo '' > docs/index.html
+
+ - name: Deploy docs
+ uses: peaceiris/actions-gh-pages@v3
+ with:
+ github_token: ${{ secrets.GITHUB_TOKEN }}
+ publish_dir: ./docs
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
new file mode 100644
index 00000000..762671ff
--- /dev/null
+++ b/.github/workflows/release.yaml
@@ -0,0 +1,214 @@
+name: Release
+on:
+ push:
+ branches:
+ - main
+
+jobs:
+ check_if_wasm_version_upgraded:
+ name: Check if WASM version has been upgraded
+ runs-on: ubuntu-latest
+ outputs:
+ wasm_version: ${{ steps.version-updated.outputs.current-package-version }}
+ wasm_has_updated: ${{ steps.version-updated.outputs.has-updated }}
+ steps:
+ - uses: JiPaix/package-json-updated-action@v1.0.5
+ id: version-updated
+ with:
+ path: rust/automerge-wasm/package.json
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ publish-wasm:
+ name: Publish WASM package
+ runs-on: ubuntu-latest
+ needs:
+ - check_if_wasm_version_upgraded
+ # We create release only if the version in the package.json has been upgraded
+ if: needs.check_if_wasm_version_upgraded.outputs.wasm_has_updated == 'true'
+ steps:
+ - uses: actions/setup-node@v3
+ with:
+ node-version: '16.x'
+ registry-url: 'https://registry.npmjs.org'
+ - uses: denoland/setup-deno@v1
+ - uses: actions/checkout@v3
+ with:
+ fetch-depth: 0
+ ref: ${{ github.ref }}
+ - name: Get rid of local github workflows
+ run: rm -r .github/workflows
+ - name: Remove tmp_branch if it exists
+ run: git push origin :tmp_branch || true
+ - run: git checkout -b tmp_branch
+ - name: Install wasm-bindgen-cli
+ run: cargo install wasm-bindgen-cli wasm-opt
+ - name: Install wasm32 target
+ run: rustup target add wasm32-unknown-unknown
+ - name: run wasm js tests
+ id: wasm_js_tests
+ run: ./scripts/ci/wasm_tests
+ - name: run wasm deno tests
+ id: wasm_deno_tests
+ run: ./scripts/ci/deno_tests
+ - name: build release
+ id: build_release
+ run: |
+ npm --prefix $GITHUB_WORKSPACE/rust/automerge-wasm run release
+ - name: Collate deno release files
+ if: steps.wasm_js_tests.outcome == 'success' && steps.wasm_deno_tests.outcome == 'success'
+ run: |
+ mkdir $GITHUB_WORKSPACE/deno_wasm_dist
+ cp $GITHUB_WORKSPACE/rust/automerge-wasm/deno/* $GITHUB_WORKSPACE/deno_wasm_dist
+ cp $GITHUB_WORKSPACE/rust/automerge-wasm/index.d.ts $GITHUB_WORKSPACE/deno_wasm_dist
+ cp $GITHUB_WORKSPACE/rust/automerge-wasm/README.md $GITHUB_WORKSPACE/deno_wasm_dist
+ cp $GITHUB_WORKSPACE/rust/automerge-wasm/LICENSE $GITHUB_WORKSPACE/deno_wasm_dist
+ sed -i '1i /// ' $GITHUB_WORKSPACE/deno_wasm_dist/automerge_wasm.js
+ - name: Create npm release
+ if: steps.wasm_js_tests.outcome == 'success' && steps.wasm_deno_tests.outcome == 'success'
+ run: |
+ if [ "$(npm --prefix $GITHUB_WORKSPACE/rust/automerge-wasm show . version)" = "$VERSION" ]; then
+ echo "This version is already published"
+ exit 0
+ fi
+ EXTRA_ARGS="--access public"
+ if [[ $VERSION == *"alpha."* ]] || [[ $VERSION == *"beta."* ]] || [[ $VERSION == *"rc."* ]]; then
+ echo "Is pre-release version"
+ EXTRA_ARGS="$EXTRA_ARGS --tag next"
+ fi
+ if [ "$NODE_AUTH_TOKEN" = "" ]; then
+ echo "Can't publish on NPM, You need a NPM_TOKEN secret."
+ false
+ fi
+ npm publish $GITHUB_WORKSPACE/rust/automerge-wasm $EXTRA_ARGS
+ env:
+ NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}
+ VERSION: ${{ needs.check_if_wasm_version_upgraded.outputs.wasm_version }}
+ - name: Commit wasm deno release files
+ run: |
+ git config --global user.name "actions"
+ git config --global user.email actions@github.com
+ git add $GITHUB_WORKSPACE/deno_wasm_dist
+ git commit -am "Add deno release files"
+ git push origin tmp_branch
+ - name: Tag wasm release
+ if: steps.wasm_js_tests.outcome == 'success' && steps.wasm_deno_tests.outcome == 'success'
+ uses: softprops/action-gh-release@v1
+ with:
+ name: Automerge Wasm v${{ needs.check_if_wasm_version_upgraded.outputs.wasm_version }}
+ tag_name: js/automerge-wasm-${{ needs.check_if_wasm_version_upgraded.outputs.wasm_version }}
+ target_commitish: tmp_branch
+ generate_release_notes: false
+ draft: false
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ - name: Remove tmp_branch
+ run: git push origin :tmp_branch
+ check_if_js_version_upgraded:
+ name: Check if JS version has been upgraded
+ runs-on: ubuntu-latest
+ outputs:
+ js_version: ${{ steps.version-updated.outputs.current-package-version }}
+ js_has_updated: ${{ steps.version-updated.outputs.has-updated }}
+ steps:
+ - uses: JiPaix/package-json-updated-action@v1.0.5
+ id: version-updated
+ with:
+ path: javascript/package.json
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ publish-js:
+ name: Publish JS package
+ runs-on: ubuntu-latest
+ needs:
+ - check_if_js_version_upgraded
+ - check_if_wasm_version_upgraded
+ - publish-wasm
+ # We create release only if the version in the package.json has been upgraded and after the WASM release
+ if: |
+ (always() && ! cancelled()) &&
+ (needs.publish-wasm.result == 'success' || needs.publish-wasm.result == 'skipped') &&
+ needs.check_if_js_version_upgraded.outputs.js_has_updated == 'true'
+ steps:
+ - uses: actions/setup-node@v3
+ with:
+ node-version: '16.x'
+ registry-url: 'https://registry.npmjs.org'
+ - uses: denoland/setup-deno@v1
+ - uses: actions/checkout@v3
+ with:
+ fetch-depth: 0
+ ref: ${{ github.ref }}
+ - name: Get rid of local github workflows
+ run: rm -r .github/workflows
+ - name: Remove js_tmp_branch if it exists
+ run: git push origin :js_tmp_branch || true
+ - run: git checkout -b js_tmp_branch
+ - name: check js formatting
+ run: |
+ yarn global add prettier
+ prettier -c javascript/.prettierrc javascript
+ - name: run js tests
+ id: js_tests
+ run: |
+ cargo install wasm-bindgen-cli wasm-opt
+ rustup target add wasm32-unknown-unknown
+ ./scripts/ci/js_tests
+ - name: build js release
+ id: build_release
+ run: |
+ npm --prefix $GITHUB_WORKSPACE/javascript run build
+ - name: build js deno release
+ id: build_deno_release
+ run: |
+ VERSION=$WASM_VERSION npm --prefix $GITHUB_WORKSPACE/javascript run deno:build
+ env:
+ WASM_VERSION: ${{ needs.check_if_wasm_version_upgraded.outputs.wasm_version }}
+ - name: run deno tests
+ id: deno_tests
+ run: |
+ npm --prefix $GITHUB_WORKSPACE/javascript run deno:test
+ - name: Collate deno release files
+ if: steps.js_tests.outcome == 'success' && steps.deno_tests.outcome == 'success'
+ run: |
+ mkdir $GITHUB_WORKSPACE/deno_js_dist
+ cp $GITHUB_WORKSPACE/javascript/deno_dist/* $GITHUB_WORKSPACE/deno_js_dist
+ - name: Create npm release
+ if: steps.js_tests.outcome == 'success' && steps.deno_tests.outcome == 'success'
+ run: |
+ if [ "$(npm --prefix $GITHUB_WORKSPACE/javascript show . version)" = "$VERSION" ]; then
+ echo "This version is already published"
+ exit 0
+ fi
+ EXTRA_ARGS="--access public"
+ if [[ $VERSION == *"alpha."* ]] || [[ $VERSION == *"beta."* ]] || [[ $VERSION == *"rc."* ]]; then
+ echo "Is pre-release version"
+ EXTRA_ARGS="$EXTRA_ARGS --tag next"
+ fi
+ if [ "$NODE_AUTH_TOKEN" = "" ]; then
+ echo "Can't publish on NPM, You need a NPM_TOKEN secret."
+ false
+ fi
+ npm publish $GITHUB_WORKSPACE/javascript $EXTRA_ARGS
+ env:
+ NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}
+ VERSION: ${{ needs.check_if_js_version_upgraded.outputs.js_version }}
+ - name: Commit js deno release files
+ run: |
+ git config --global user.name "actions"
+ git config --global user.email actions@github.com
+ git add $GITHUB_WORKSPACE/deno_js_dist
+ git commit -am "Add deno js release files"
+ git push origin js_tmp_branch
+ - name: Tag JS release
+ if: steps.js_tests.outcome == 'success' && steps.deno_tests.outcome == 'success'
+ uses: softprops/action-gh-release@v1
+ with:
+ name: Automerge v${{ needs.check_if_js_version_upgraded.outputs.js_version }}
+ tag_name: js/automerge-${{ needs.check_if_js_version_upgraded.outputs.js_version }}
+ target_commitish: js_tmp_branch
+ generate_release_notes: false
+ draft: false
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ - name: Remove js_tmp_branch
+ run: git push origin :js_tmp_branch
diff --git a/.gitignore b/.gitignore
index 95d3d639..f77865d0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,6 @@
-/target
/.direnv
perf.*
/Cargo.lock
+build/
+.vim/*
+/target
diff --git a/Makefile b/Makefile
deleted file mode 100644
index 9f8db2d1..00000000
--- a/Makefile
+++ /dev/null
@@ -1,13 +0,0 @@
-rust:
- cd automerge && cargo test
-
-wasm:
- cd automerge-wasm && yarn
- cd automerge-wasm && yarn build
- cd automerge-wasm && yarn test
- cd automerge-wasm && yarn link
-
-js: wasm
- cd automerge-js && yarn
- cd automerge-js && yarn link "automerge-wasm"
- cd automerge-js && yarn test
diff --git a/README.md b/README.md
index e7a277a8..ad174da4 100644
--- a/README.md
+++ b/README.md
@@ -1,81 +1,147 @@
-# Automerge - NEXT
+# Automerge
-This is pretty much a ground up rewrite of automerge-rs. The objective of this
-rewrite is to radically simplify the API. The end goal being to produce a library
-which is easy to work with both in Rust and from FFI.
+
-## How?
+[](https://automerge.org/)
+[](https://automerge.org/automerge-rs/automerge/)
+[](https://github.com/automerge/automerge-rs/actions/workflows/ci.yaml)
+[](https://github.com/automerge/automerge-rs/actions/workflows/docs.yaml)
-The current iteration of automerge-rs is complicated to work with because it
-adopts the frontend/backend split architecture of the JS implementation. This
-architecture was necessary due to basic operations on the automerge opset being
-too slow to perform on the UI thread. Recently @orionz has been able to improve
-the performance to the point where the split is no longer necessary. This means
-we can adopt a much simpler mutable API.
+Automerge is a library which provides fast implementations of several different
+CRDTs, a compact compression format for these CRDTs, and a sync protocol for
+efficiently transmitting those changes over the network. The objective of the
+project is to support [local-first](https://www.inkandswitch.com/local-first/) applications in the same way that relational
+databases support server applications - by providing mechanisms for persistence
+which allow application developers to avoid thinking about hard distributed
+computing problems. Automerge aims to be PostgreSQL for your local-first app.
-The architecture is now built around the `OpTree`. This is a data structure
-which supports efficiently inserting new operations and realising values of
-existing operations. Most interactions with the `OpTree` are in the form of
-implementations of `TreeQuery` - a trait which can be used to traverse the
-optree and producing state of some kind. User facing operations are exposed on
-an `Automerge` object, under the covers these operations typically instantiate
-some `TreeQuery` and run it over the `OpTree`.
+If you're looking for documentation on the JavaScript implementation take a look
+at https://automerge.org/docs/hello/. There are other implementations in both
+Rust and C, but they are earlier and don't have documentation yet. You can find
+them in `rust/automerge` and `rust/automerge-c` if you are comfortable
+reading the code and tests to figure out how to use them.
+
+If you're familiar with CRDTs and interested in the design of Automerge in
+particular take a look at https://automerge.org/docs/how-it-works/backend/
+
+Finally, if you want to talk to us about this project please [join the
+Slack](https://join.slack.com/t/automerge/shared_invite/zt-e4p3760n-kKh7r3KRH1YwwNfiZM8ktw)
## Status
-We have working code which passes all of the tests in the JS test suite. We're
-now working on writing a bunch more tests and cleaning up the API.
+This project is formed of a core Rust implementation which is exposed via FFI in
+javascript+WASM, C, and soon other languages. Alex
+([@alexjg](https://github.com/alexjg/)]) is working full time on maintaining
+automerge, other members of Ink and Switch are also contributing time and there
+are several other maintainers. The focus is currently on shipping the new JS
+package. We expect to be iterating the API and adding new features over the next
+six months so there will likely be several major version bumps in all packages
+in that time.
-## Development
+In general we try and respect semver.
-### Running CI
+### JavaScript
-The steps CI will run are all defined in `./scripts/ci`. Obviously CI will run
-everything when you submit a PR, but if you want to run everything locally
-before you push you can run `./scripts/ci/run` to run everything.
+A stable release of the javascript package is currently available as
+`@automerge/automerge@2.0.0` where. pre-release verisions of the `2.0.1` are
+available as `2.0.1-alpha.n`. `2.0.1*` packages are also available for Deno at
+https://deno.land/x/automerge
-### Running the JS tests
+### Rust
-You will need to have [node](https://nodejs.org/en/), [yarn](https://yarnpkg.com/getting-started/install), [rust](https://rustup.rs/) and [wasm-pack](https://rustwasm.github.io/wasm-pack/installer/) installed.
+The rust codebase is currently oriented around producing a performant backend
+for the Javascript wrapper and as such the API for Rust code is low level and
+not well documented. We will be returning to this over the next few months but
+for now you will need to be comfortable reading the tests and asking questions
+to figure out how to use it. If you are looking to build rust applications which
+use automerge you may want to look into
+[autosurgeon](https://github.com/alexjg/autosurgeon)
-To build and test the rust library:
+## Repository Organisation
-```shell
- $ cd automerge
- $ cargo test
+- `./rust` - the rust rust implementation and also the Rust components of
+ platform specific wrappers (e.g. `automerge-wasm` for the WASM API or
+ `automerge-c` for the C FFI bindings)
+- `./javascript` - The javascript library which uses `automerge-wasm`
+ internally but presents a more idiomatic javascript interface
+- `./scripts` - scripts which are useful to maintenance of the repository.
+ This includes the scripts which are run in CI.
+- `./img` - static assets for use in `.md` files
+
+## Building
+
+To build this codebase you will need:
+
+- `rust`
+- `node`
+- `yarn`
+- `cmake`
+- `cmocka`
+
+You will also need to install the following with `cargo install`
+
+- `wasm-bindgen-cli`
+- `wasm-opt`
+- `cargo-deny`
+
+And ensure you have added the `wasm32-unknown-unknown` target for rust cross-compilation.
+
+The various subprojects (the rust code, the wrapper projects) have their own
+build instructions, but to run the tests that will be run in CI you can run
+`./scripts/ci/run`.
+
+### For macOS
+
+These instructions worked to build locally on macOS 13.1 (arm64) as of
+Nov 29th 2022.
+
+```bash
+# clone the repo
+git clone https://github.com/automerge/automerge-rs
+cd automerge-rs
+
+# install rustup
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+# install homebrew
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+
+# install cmake, node, cmocka
+brew install cmake node cmocka
+
+# install yarn
+npm install --global yarn
+
+# install javascript dependencies
+yarn --cwd ./javascript
+
+# install rust dependencies
+cargo install wasm-bindgen-cli wasm-opt cargo-deny
+
+# get nightly rust to produce optimized automerge-c builds
+rustup toolchain install nightly
+rustup component add rust-src --toolchain nightly
+
+# add wasm target in addition to current architecture
+rustup target add wasm32-unknown-unknown
+
+# Run ci script
+./scripts/ci/run
```
-To build and test the wasm library:
+If your build fails to find `cmocka.h` you may need to teach it about homebrew's
+installation location:
-```shell
- ## setup
- $ cd automerge-wasm
- $ yarn
-
- ## building or testing
- $ yarn build
- $ yarn test
-
- ## without this the js library wont automatically use changes
- $ yarn link
-
- ## cutting a release or doing benchmarking
- $ yarn release
- $ yarn opt ## or set `wasm-opt = false` in Cargo.toml on supported platforms (not arm64 osx)
+```
+export CPATH=/opt/homebrew/include
+export LIBRARY_PATH=/opt/homebrew/lib
+./scripts/ci/run
```
-And finally to test the js library. This is where most of the tests reside.
+## Contributing
-```shell
- ## setup
- $ cd automerge-js
- $ yarn
- $ yarn link "automerge-wasm"
-
- ## testing
- $ yarn test
-```
-
-## Benchmarking
-
-The `edit-trace` folder has the main code for running the edit trace benchmarking.
+Please try and split your changes up into relatively independent commits which
+change one subsystem at a time and add good commit messages which describe what
+the change is and why you're making it (err on the side of longer commit
+messages). `git blame` should give future maintainers a good idea of why
+something is the way it is.
diff --git a/TODO.md b/TODO.md
deleted file mode 100644
index 646c0c20..00000000
--- a/TODO.md
+++ /dev/null
@@ -1,32 +0,0 @@
-### next steps:
- 1. C API
- 2. port rust command line tool
- 3. fast load
-
-### ergonomics:
- 1. value() -> () or something that into's a value
-
-### automerge:
- 1. single pass (fast) load
- 2. micro-patches / bare bones observation API / fully hydrated documents
-
-### future:
- 1. handle columns with unknown data in and out
- 2. branches with different indexes
-
-### Peritext
- 1. add mark / remove mark -- type, start/end elemid (inclusive,exclusive)
- 2. track any formatting ops that start or end on a character
- 3. ops right before the character, ops right after that character
- 4. query a single character - character, plus marks that start or end on that character
- what is its current formatting,
- what are the ops that include that in their span,
- None = same as last time, Set( bold, italic ),
- keep these on index
- 5. op probably belongs with the start character - possible packed at the beginning or end of the list
-
-### maybe:
- 1. tables
-
-### no:
- 1. cursors
diff --git a/automerge-js/.gitignore b/automerge-js/.gitignore
deleted file mode 100644
index 5add9449..00000000
--- a/automerge-js/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-/node_modules
-/yarn.lock
diff --git a/automerge-js/package.json b/automerge-js/package.json
deleted file mode 100644
index 8742d99a..00000000
--- a/automerge-js/package.json
+++ /dev/null
@@ -1,18 +0,0 @@
-{
- "name": "automerge-js",
- "version": "0.1.0",
- "main": "src/index.js",
- "license": "MIT",
- "scripts": {
- "test": "mocha --bail --full-trace"
- },
- "devDependencies": {
- "mocha": "^9.1.1"
- },
- "dependencies": {
- "automerge-wasm": "file:../automerge-wasm/dev",
- "fast-sha256": "^1.3.0",
- "pako": "^2.0.4",
- "uuid": "^8.3"
- }
-}
diff --git a/automerge-js/src/constants.js b/automerge-js/src/constants.js
deleted file mode 100644
index ea92228c..00000000
--- a/automerge-js/src/constants.js
+++ /dev/null
@@ -1,18 +0,0 @@
-// Properties of the document root object
-//const OPTIONS = Symbol('_options') // object containing options passed to init()
-//const CACHE = Symbol('_cache') // map from objectId to immutable object
-const STATE = Symbol('_state') // object containing metadata about current state (e.g. sequence numbers)
-const HEADS = Symbol('_heads') // object containing metadata about current state (e.g. sequence numbers)
-const OBJECT_ID = Symbol('_objectId') // object containing metadata about current state (e.g. sequence numbers)
-const READ_ONLY = Symbol('_readOnly') // object containing metadata about current state (e.g. sequence numbers)
-const FROZEN = Symbol('_frozen') // object containing metadata about current state (e.g. sequence numbers)
-
-// Properties of all Automerge objects
-//const OBJECT_ID = Symbol('_objectId') // the object ID of the current object (string)
-//const CONFLICTS = Symbol('_conflicts') // map or list (depending on object type) of conflicts
-//const CHANGE = Symbol('_change') // the context object on proxy objects used in change callback
-//const ELEM_IDS = Symbol('_elemIds') // list containing the element ID of each list element
-
-module.exports = {
- STATE, HEADS, OBJECT_ID, READ_ONLY, FROZEN
-}
diff --git a/automerge-js/src/index.js b/automerge-js/src/index.js
deleted file mode 100644
index 326fc967..00000000
--- a/automerge-js/src/index.js
+++ /dev/null
@@ -1,372 +0,0 @@
-const AutomergeWASM = require("automerge-wasm")
-const uuid = require('./uuid')
-
-let { rootProxy, listProxy, textProxy, mapProxy } = require("./proxies")
-let { Counter } = require("./counter")
-let { Text } = require("./text")
-let { Int, Uint, Float64 } = require("./numbers")
-let { STATE, HEADS, OBJECT_ID, READ_ONLY, FROZEN } = require("./constants")
-
-function init(actor) {
- if (typeof actor != 'string') {
- actor = null
- }
- const state = AutomergeWASM.create(actor)
- return rootProxy(state, true);
-}
-
-function clone(doc) {
- const state = doc[STATE].clone()
- return rootProxy(state, true);
-}
-
-function free(doc) {
- return doc[STATE].free()
-}
-
-function from(data, actor) {
- let doc1 = init(actor)
- let doc2 = change(doc1, (d) => Object.assign(d, data))
- return doc2
-}
-
-function change(doc, options, callback) {
- if (callback === undefined) {
- // FIXME implement options
- callback = options
- options = {}
- }
- if (typeof options === "string") {
- options = { message: options }
- }
- if (doc === undefined || doc[STATE] === undefined || doc[OBJECT_ID] !== "_root") {
- throw new RangeError("must be the document root");
- }
- if (doc[FROZEN] === true) {
- throw new RangeError("Attempting to use an outdated Automerge document")
- }
- if (!!doc[HEADS] === true) {
- throw new RangeError("Attempting to change an out of date document");
- }
- if (doc[READ_ONLY] === false) {
- throw new RangeError("Calls to Automerge.change cannot be nested")
- }
- const state = doc[STATE]
- const heads = state.getHeads()
- try {
- doc[HEADS] = heads
- doc[FROZEN] = true
- let root = rootProxy(state);
- callback(root)
- if (state.pendingOps() === 0) {
- doc[FROZEN] = false
- doc[HEADS] = undefined
- return doc
- } else {
- state.commit(options.message, options.time)
- return rootProxy(state, true);
- }
- } catch (e) {
- //console.log("ERROR: ",e)
- doc[FROZEN] = false
- doc[HEADS] = undefined
- state.rollback()
- throw e
- }
-}
-
-function emptyChange(doc, options) {
- if (options === undefined) {
- options = {}
- }
- if (typeof options === "string") {
- options = { message: options }
- }
-
- if (doc === undefined || doc[STATE] === undefined || doc[OBJECT_ID] !== "_root") {
- throw new RangeError("must be the document root");
- }
- if (doc[FROZEN] === true) {
- throw new RangeError("Attempting to use an outdated Automerge document")
- }
- if (doc[READ_ONLY] === false) {
- throw new RangeError("Calls to Automerge.change cannot be nested")
- }
-
- const state = doc[STATE]
- state.commit(options.message, options.time)
- return rootProxy(state, true);
-}
-
-function load(data, actor) {
- const state = AutomergeWASM.loadDoc(data, actor)
- return rootProxy(state, true);
-}
-
-function save(doc) {
- const state = doc[STATE]
- return state.save()
-}
-
-function merge(local, remote) {
- if (local[HEADS] === true) {
- throw new RangeError("Attempting to change an out of date document");
- }
- const localState = local[STATE]
- const heads = localState.getHeads()
- const remoteState = remote[STATE]
- const changes = localState.getChangesAdded(remoteState)
- localState.applyChanges(changes)
- local[HEADS] = heads
- return rootProxy(localState, true)
-}
-
-function getActorId(doc) {
- const state = doc[STATE]
- return state.getActorId()
-}
-
-function conflictAt(context, objectId, prop) {
- let values = context.values(objectId, prop)
- if (values.length <= 1) {
- return
- }
- let result = {}
- for (const conflict of values) {
- const datatype = conflict[0]
- const value = conflict[1]
- switch (datatype) {
- case "map":
- result[value] = mapProxy(context, value, [ prop ], true)
- break;
- case "list":
- result[value] = listProxy(context, value, [ prop ], true)
- break;
- case "text":
- result[value] = textProxy(context, value, [ prop ], true)
- break;
- //case "table":
- //case "cursor":
- case "str":
- case "uint":
- case "int":
- case "f64":
- case "boolean":
- case "bytes":
- case "null":
- result[conflict[2]] = value
- break;
- case "counter":
- result[conflict[2]] = new Counter(value)
- break;
- case "timestamp":
- result[conflict[2]] = new Date(value)
- break;
- default:
- throw RangeError(`datatype ${datatype} unimplemented`)
- }
- }
- return result
-}
-
-function getConflicts(doc, prop) {
- const state = doc[STATE]
- const objectId = doc[OBJECT_ID]
- return conflictAt(state, objectId, prop)
-}
-
-function getLastLocalChange(doc) {
- const state = doc[STATE]
- try {
- return state.getLastLocalChange()
- } catch (e) {
- return
- }
-}
-
-function getObjectId(doc) {
- return doc[OBJECT_ID]
-}
-
-function getChanges(oldState, newState) {
- const o = oldState[STATE]
- const n = newState[STATE]
- const heads = oldState[HEADS]
- return n.getChanges(heads || o.getHeads())
-}
-
-function getAllChanges(doc) {
- const state = doc[STATE]
- return state.getChanges([])
-}
-
-function applyChanges(doc, changes) {
- if (doc === undefined || doc[STATE] === undefined || doc[OBJECT_ID] !== "_root") {
- throw new RangeError("must be the document root");
- }
- if (doc[FROZEN] === true) {
- throw new RangeError("Attempting to use an outdated Automerge document")
- }
- if (doc[READ_ONLY] === false) {
- throw new RangeError("Calls to Automerge.change cannot be nested")
- }
- const state = doc[STATE]
- const heads = state.getHeads()
- state.applyChanges(changes)
- doc[HEADS] = heads
- return [rootProxy(state, true)];
-}
-
-function getHistory(doc) {
- const actor = getActorId(doc)
- const history = getAllChanges(doc)
- return history.map((change, index) => ({
- get change () {
- return decodeChange(change)
- },
- get snapshot () {
- const [state] = applyChanges(init(), history.slice(0, index + 1))
- return state
- }
- })
- )
-}
-
-function equals() {
- if (!isObject(val1) || !isObject(val2)) return val1 === val2
- const keys1 = Object.keys(val1).sort(), keys2 = Object.keys(val2).sort()
- if (keys1.length !== keys2.length) return false
- for (let i = 0; i < keys1.length; i++) {
- if (keys1[i] !== keys2[i]) return false
- if (!equals(val1[keys1[i]], val2[keys2[i]])) return false
- }
- return true
-}
-
-function encodeSyncMessage(msg) {
- return AutomergeWASM.encodeSyncMessage(msg)
-}
-
-function decodeSyncMessage(msg) {
- return AutomergeWASM.decodeSyncMessage(msg)
-}
-
-function encodeSyncState(state) {
- return AutomergeWASM.encodeSyncState(AutomergeWASM.importSyncState(state))
-}
-
-function decodeSyncState(state) {
- return AutomergeWASM.exportSyncState(AutomergeWASM.decodeSyncState(state))
-}
-
-function generateSyncMessage(doc, inState) {
- const state = doc[STATE]
- const syncState = AutomergeWASM.importSyncState(inState)
- const message = state.generateSyncMessage(syncState)
- const outState = AutomergeWASM.exportSyncState(syncState)
- return [ outState, message ]
-}
-
-function receiveSyncMessage(doc, inState, message) {
- const syncState = AutomergeWASM.importSyncState(inState)
- if (doc === undefined || doc[STATE] === undefined || doc[OBJECT_ID] !== "_root") {
- throw new RangeError("must be the document root");
- }
- if (doc[FROZEN] === true) {
- throw new RangeError("Attempting to use an outdated Automerge document")
- }
- if (!!doc[HEADS] === true) {
- throw new RangeError("Attempting to change an out of date document");
- }
- if (doc[READ_ONLY] === false) {
- throw new RangeError("Calls to Automerge.change cannot be nested")
- }
- const state = doc[STATE]
- const heads = state.getHeads()
- state.receiveSyncMessage(syncState, message)
- const outState = AutomergeWASM.exportSyncState(syncState)
- doc[HEADS] = heads
- return [rootProxy(state, true), outState, null];
-}
-
-function initSyncState() {
- return AutomergeWASM.exportSyncState(AutomergeWASM.initSyncState(change))
-}
-
-function encodeChange(change) {
- return AutomergeWASM.encodeChange(change)
-}
-
-function decodeChange(data) {
- return AutomergeWASM.decodeChange(data)
-}
-
-function encodeSyncMessage(change) {
- return AutomergeWASM.encodeSyncMessage(change)
-}
-
-function decodeSyncMessage(data) {
- return AutomergeWASM.decodeSyncMessage(data)
-}
-
-function getMissingDeps(doc, heads) {
- const state = doc[STATE]
- return state.getMissingDeps(heads)
-}
-
-function getHeads(doc) {
- const state = doc[STATE]
- return doc[HEADS] || state.getHeads()
-}
-
-function dump(doc) {
- const state = doc[STATE]
- state.dump()
-}
-
-function toJS(doc) {
- if (typeof doc === "object") {
- if (doc instanceof Uint8Array) {
- return doc
- }
- if (doc === null) {
- return doc
- }
- if (doc instanceof Array) {
- return doc.map((a) => toJS(a))
- }
- if (doc instanceof Text) {
- return doc.map((a) => toJS(a))
- }
- let tmp = {}
- for (index in doc) {
- tmp[index] = toJS(doc[index])
- }
- return tmp
- } else {
- return doc
- }
-}
-
-module.exports = {
- init, from, change, emptyChange, clone, free,
- load, save, merge, getChanges, getAllChanges, applyChanges,
- getLastLocalChange, getObjectId, getActorId, getConflicts,
- encodeChange, decodeChange, equals, getHistory, getHeads, uuid,
- generateSyncMessage, receiveSyncMessage, initSyncState,
- decodeSyncMessage, encodeSyncMessage, decodeSyncState, encodeSyncState,
- getMissingDeps,
- dump, Text, Counter, Int, Uint, Float64, toJS,
-}
-
-// depricated
-// Frontend, setDefaultBackend, Backend
-
-// more...
-/*
-for (let name of ['getObjectId', 'getObjectById',
- 'setActorId',
- 'Text', 'Table', 'Counter', 'Observable' ]) {
- module.exports[name] = Frontend[name]
-}
-*/
diff --git a/automerge-js/src/numbers.js b/automerge-js/src/numbers.js
deleted file mode 100644
index 1ee22dee..00000000
--- a/automerge-js/src/numbers.js
+++ /dev/null
@@ -1,33 +0,0 @@
-// Convience classes to allow users to stricly specify the number type they want
-
-class Int {
- constructor(value) {
- if (!(Number.isInteger(value) && value <= Number.MAX_SAFE_INTEGER && value >= Number.MIN_SAFE_INTEGER)) {
- throw new RangeError(`Value ${value} cannot be a uint`)
- }
- this.value = value
- Object.freeze(this)
- }
-}
-
-class Uint {
- constructor(value) {
- if (!(Number.isInteger(value) && value <= Number.MAX_SAFE_INTEGER && value >= 0)) {
- throw new RangeError(`Value ${value} cannot be a uint`)
- }
- this.value = value
- Object.freeze(this)
- }
-}
-
-class Float64 {
- constructor(value) {
- if (typeof value !== 'number') {
- throw new RangeError(`Value ${value} cannot be a float64`)
- }
- this.value = value || 0.0
- Object.freeze(this)
- }
-}
-
-module.exports = { Int, Uint, Float64 }
diff --git a/automerge-js/src/proxies.js b/automerge-js/src/proxies.js
deleted file mode 100644
index ed3a4b97..00000000
--- a/automerge-js/src/proxies.js
+++ /dev/null
@@ -1,623 +0,0 @@
-
-const AutomergeWASM = require("automerge-wasm")
-const { Int, Uint, Float64 } = require("./numbers");
-const { Counter, getWriteableCounter } = require("./counter");
-const { Text } = require("./text");
-const { STATE, HEADS, FROZEN, OBJECT_ID, READ_ONLY } = require("./constants")
-
-function parseListIndex(key) {
- if (typeof key === 'string' && /^[0-9]+$/.test(key)) key = parseInt(key, 10)
- if (typeof key !== 'number') {
- // throw new TypeError('A list index must be a number, but you passed ' + JSON.stringify(key))
- return key
- }
- if (key < 0 || isNaN(key) || key === Infinity || key === -Infinity) {
- throw new RangeError('A list index must be positive, but you passed ' + key)
- }
- return key
-}
-
-function valueAt(target, prop) {
- const { context, objectId, path, readonly, heads} = target
- let value = context.value(objectId, prop, heads)
- if (value === undefined) {
- return
- }
- const datatype = value[0]
- const val = value[1]
- switch (datatype) {
- case undefined: return;
- case "map": return mapProxy(context, val, [ ... path, prop ], readonly, heads);
- case "list": return listProxy(context, val, [ ... path, prop ], readonly, heads);
- case "text": return textProxy(context, val, [ ... path, prop ], readonly, heads);
- //case "table":
- //case "cursor":
- case "str": return val;
- case "uint": return val;
- case "int": return val;
- case "f64": return val;
- case "boolean": return val;
- case "null": return null;
- case "bytes": return val;
- case "timestamp": return val;
- case "counter": {
- if (readonly) {
- return new Counter(val);
- } else {
- return getWriteableCounter(val, context, path, objectId, prop)
- }
- }
- default:
- throw RangeError(`datatype ${datatype} unimplemented`)
- }
-}
-
-function import_value(value) {
- switch (typeof value) {
- case 'object':
- if (value == null) {
- return [ null, "null"]
- } else if (value instanceof Uint) {
- return [ value.value, "uint" ]
- } else if (value instanceof Int) {
- return [ value.value, "int" ]
- } else if (value instanceof Float64) {
- return [ value.value, "f64" ]
- } else if (value instanceof Counter) {
- return [ value.value, "counter" ]
- } else if (value instanceof Date) {
- return [ value.getTime(), "timestamp" ]
- } else if (value instanceof Uint8Array) {
- return [ value, "bytes" ]
- } else if (value instanceof Array) {
- return [ value, "list" ]
- } else if (value instanceof Text) {
- return [ value, "text" ]
- } else if (value[OBJECT_ID]) {
- throw new RangeError('Cannot create a reference to an existing document object')
- } else {
- return [ value, "map" ]
- }
- break;
- case 'boolean':
- return [ value, "boolean" ]
- case 'number':
- if (Number.isInteger(value)) {
- return [ value, "int" ]
- } else {
- return [ value, "f64" ]
- }
- break;
- case 'string':
- return [ value ]
- break;
- default:
- throw new RangeError(`Unsupported type of value: ${typeof value}`)
- }
-}
-
-const MapHandler = {
- get (target, key) {
- const { context, objectId, path, readonly, frozen, heads, cache } = target
- if (key === Symbol.toStringTag) { return target[Symbol.toStringTag] }
- if (key === OBJECT_ID) return objectId
- if (key === READ_ONLY) return readonly
- if (key === FROZEN) return frozen
- if (key === HEADS) return heads
- if (key === STATE) return context;
- if (!cache[key]) {
- cache[key] = valueAt(target, key)
- }
- return cache[key]
- },
-
- set (target, key, val) {
- let { context, objectId, path, readonly, frozen} = target
- target.cache = {} // reset cache on set
- if (val && val[OBJECT_ID]) {
- throw new RangeError('Cannot create a reference to an existing document object')
- }
- if (key === FROZEN) {
- target.frozen = val
- return
- }
- if (key === HEADS) {
- target.heads = val
- return
- }
- let [ value, datatype ] = import_value(val)
- if (frozen) {
- throw new RangeError("Attempting to use an outdated Automerge document")
- }
- if (readonly) {
- throw new RangeError(`Object property "${key}" cannot be modified`)
- }
- switch (datatype) {
- case "list":
- const list = context.set(objectId, key, [])
- const proxyList = listProxy(context, list, [ ... path, key ], readonly );
- for (let i = 0; i < value.length; i++) {
- proxyList[i] = value[i]
- }
- break;
- case "text":
- const text = context.set(objectId, key, "", "text")
- const proxyText = textProxy(context, text, [ ... path, key ], readonly );
- for (let i = 0; i < value.length; i++) {
- proxyText[i] = value.get(i)
- }
- break;
- case "map":
- const map = context.set(objectId, key, {})
- const proxyMap = mapProxy(context, map, [ ... path, key ], readonly );
- for (const key in value) {
- proxyMap[key] = value[key]
- }
- break;
- default:
- context.set(objectId, key, value, datatype)
- }
- return true
- },
-
- deleteProperty (target, key) {
- const { context, objectId, path, readonly, frozen } = target
- target.cache = {} // reset cache on delete
- if (readonly) {
- throw new RangeError(`Object property "${key}" cannot be modified`)
- }
- context.del(objectId, key)
- return true
- },
-
- has (target, key) {
- const value = this.get(target, key)
- return value !== undefined
- },
-
- getOwnPropertyDescriptor (target, key) {
- const { context, objectId } = target
- const value = this.get(target, key)
- if (typeof value !== 'undefined') {
- return {
- configurable: true, enumerable: true, value
- }
- }
- },
-
- ownKeys (target) {
- const { context, objectId, heads} = target
- return context.keys(objectId, heads)
- },
-}
-
-
-const ListHandler = {
- get (target, index) {
- const {context, objectId, path, readonly, frozen, heads } = target
- index = parseListIndex(index)
- if (index === Symbol.hasInstance) { return (instance) => { return [].has(instance) } }
- if (index === Symbol.toStringTag) { return target[Symbol.toStringTag] }
- if (index === OBJECT_ID) return objectId
- if (index === READ_ONLY) return readonly
- if (index === FROZEN) return frozen
- if (index === HEADS) return heads
- if (index === STATE) return context;
- if (index === 'length') return context.length(objectId, heads);
- if (index === Symbol.iterator) {
- let i = 0;
- return function *() {
- // FIXME - ugly
- let value = valueAt(target, i)
- while (value !== undefined) {
- yield value
- i += 1
- value = valueAt(target, i)
- }
- }
- }
- if (typeof index === 'number') {
- return valueAt(target, index)
- } else {
- return listMethods(target)[index]
- }
- },
-
- set (target, index, val) {
- let {context, objectId, path, readonly, frozen } = target
- index = parseListIndex(index)
- if (val && val[OBJECT_ID]) {
- throw new RangeError('Cannot create a reference to an existing document object')
- }
- if (index === FROZEN) {
- target.frozen = val
- return
- }
- if (index === HEADS) {
- target.heads = val
- return
- }
- if (typeof index == "string") {
- throw new RangeError('list index must be a number')
- }
- const [ value, datatype] = import_value(val)
- if (frozen) {
- throw new RangeError("Attempting to use an outdated Automerge document")
- }
- if (readonly) {
- throw new RangeError(`Object property "${index}" cannot be modified`)
- }
- switch (datatype) {
- case "list":
- let list
- if (index >= context.length(objectId)) {
- list = context.insert(objectId, index, [])
- } else {
- list = context.set(objectId, index, [])
- }
- const proxyList = listProxy(context, list, [ ... path, index ], readonly);
- proxyList.splice(0,0,...value)
- break;
- case "text":
- let text
- if (index >= context.length(objectId)) {
- text = context.insert(objectId, index, "", "text")
- } else {
- text = context.set(objectId, index, "", "text")
- }
- const proxyText = textProxy(context, text, [ ... path, index ], readonly);
- proxyText.splice(0,0,...value)
- break;
- case "map":
- let map
- if (index >= context.length(objectId)) {
- map = context.insert(objectId, index, {})
- } else {
- map = context.set(objectId, index, {})
- }
- const proxyMap = mapProxy(context, map, [ ... path, index ], readonly);
- for (const key in value) {
- proxyMap[key] = value[key]
- }
- break;
- default:
- if (index >= context.length(objectId)) {
- context.insert(objectId, index, value, datatype)
- } else {
- context.set(objectId, index, value, datatype)
- }
- }
- return true
- },
-
- deleteProperty (target, index) {
- const {context, objectId} = target
- index = parseListIndex(index)
- if (context.value(objectId, index)[0] == "counter") {
- throw new TypeError('Unsupported operation: deleting a counter from a list')
- }
- context.del(objectId, index)
- return true
- },
-
- has (target, index) {
- const {context, objectId, heads} = target
- index = parseListIndex(index)
- if (typeof index === 'number') {
- return index < context.length(objectId, heads)
- }
- return index === 'length'
- },
-
- getOwnPropertyDescriptor (target, index) {
- const {context, objectId, path, readonly, frozen, heads} = target
-
- if (index === 'length') return {writable: true, value: context.length(objectId, heads) }
- if (index === OBJECT_ID) return {configurable: false, enumerable: false, value: objectId}
-
- index = parseListIndex(index)
-
- let value = valueAt(target, index)
- return { configurable: true, enumerable: true, value }
- },
-
- getPrototypeOf(target) { return Object.getPrototypeOf([]) },
- ownKeys (target) {
- const {context, objectId, heads } = target
- let keys = []
- // uncommenting this causes assert.deepEqual() to fail when comparing to a pojo array
- // but not uncommenting it causes for (i in list) {} to not enumerate values properly
- //for (let i = 0; i < target.context.length(objectId, heads); i++) { keys.push(i.toString()) }
- keys.push("length");
- return keys
- }
-}
-
-const TextHandler = Object.assign({}, ListHandler, {
- get (target, index) {
- // FIXME this is a one line change from ListHandler.get()
- const {context, objectId, path, readonly, frozen, heads } = target
- index = parseListIndex(index)
- if (index === Symbol.toStringTag) { return target[Symbol.toStringTag] }
- if (index === Symbol.hasInstance) { return (instance) => { return [].has(instance) } }
- if (index === OBJECT_ID) return objectId
- if (index === READ_ONLY) return readonly
- if (index === FROZEN) return frozen
- if (index === HEADS) return heads
- if (index === STATE) return context;
- if (index === 'length') return context.length(objectId, heads);
- if (index === Symbol.iterator) {
- let i = 0;
- return function *() {
- let value = valueAt(target, i)
- while (value !== undefined) {
- yield value
- i += 1
- value = valueAt(target, i)
- }
- }
- }
- if (typeof index === 'number') {
- return valueAt(target, index)
- } else {
- return textMethods(target)[index] || listMethods(target)[index]
- }
- },
- getPrototypeOf(target) {
- return Object.getPrototypeOf(new Text())
- },
-})
-
-function mapProxy(context, objectId, path, readonly, heads) {
- return new Proxy({context, objectId, path, readonly: !!readonly, frozen: false, heads, cache: {}}, MapHandler)
-}
-
-function listProxy(context, objectId, path, readonly, heads) {
- let target = []
- Object.assign(target, {context, objectId, path, readonly: !!readonly, frozen: false, heads, cache: {}})
- return new Proxy(target, ListHandler)
-}
-
-function textProxy(context, objectId, path, readonly, heads) {
- let target = []
- Object.assign(target, {context, objectId, path, readonly: !!readonly, frozen: false, heads, cache: {}})
- return new Proxy(target, TextHandler)
-}
-
-function rootProxy(context, readonly) {
- return mapProxy(context, "_root", [], readonly)
-}
-
-function listMethods(target) {
- const {context, objectId, path, readonly, frozen, heads} = target
- const methods = {
- deleteAt(index, numDelete) {
- if (typeof numDelete === 'number') {
- context.splice(objectId, index, numDelete)
- } else {
- context.del(objectId, index)
- }
- return this
- },
-
- fill(val, start, end) {
- // FIXME
- let list = context.getObject(objectId)
- let [value, datatype] = valueAt(target, index)
- for (let index = parseListIndex(start || 0); index < parseListIndex(end || list.length); index++) {
- context.set(objectId, index, value, datatype)
- }
- return this
- },
-
- indexOf(o, start = 0) {
- // FIXME
- const id = o[OBJECT_ID]
- if (id) {
- const list = context.getObject(objectId)
- for (let index = start; index < list.length; index++) {
- if (list[index][OBJECT_ID] === id) {
- return index
- }
- }
- return -1
- } else {
- return context.indexOf(objectId, o, start)
- }
- },
-
- insertAt(index, ...values) {
- this.splice(index, 0, ...values)
- return this
- },
-
- pop() {
- let length = context.length(objectId)
- if (length == 0) {
- return undefined
- }
- let last = valueAt(target, length - 1)
- context.del(objectId, length - 1)
- return last
- },
-
- push(...values) {
- let len = context.length(objectId)
- this.splice(len, 0, ...values)
- return context.length(objectId)
- },
-
- shift() {
- if (context.length(objectId) == 0) return
- const first = valueAt(target, 0)
- context.del(objectId, 0)
- return first
- },
-
- splice(index, del, ...vals) {
- index = parseListIndex(index)
- del = parseListIndex(del)
- for (let val of vals) {
- if (val && val[OBJECT_ID]) {
- throw new RangeError('Cannot create a reference to an existing document object')
- }
- }
- if (frozen) {
- throw new RangeError("Attempting to use an outdated Automerge document")
- }
- if (readonly) {
- throw new RangeError("Sequence object cannot be modified outside of a change block")
- }
- let result = []
- for (let i = 0; i < del; i++) {
- let value = valueAt(target, index)
- result.push(value)
- context.del(objectId, index)
- }
- const values = vals.map((val) => import_value(val))
- for (let [value,datatype] of values) {
- switch (datatype) {
- case "list":
- const list = context.insert(objectId, index, [])
- const proxyList = listProxy(context, list, [ ... path, index ], readonly);
- proxyList.splice(0,0,...value)
- break;
- case "text":
- const text = context.insert(objectId, index, "", "text")
- const proxyText = textProxy(context, text, [ ... path, index ], readonly);
- proxyText.splice(0,0,...value)
- break;
- case "map":
- const map = context.insert(objectId, index, {})
- const proxyMap = mapProxy(context, map, [ ... path, index ], readonly);
- for (const key in value) {
- proxyMap[key] = value[key]
- }
- break;
- default:
- context.insert(objectId, index, value, datatype)
- }
- index += 1
- }
- return result
- },
-
- unshift(...values) {
- this.splice(0, 0, ...values)
- return context.length(objectId)
- },
-
- entries() {
- let i = 0;
- const iterator = {
- next: () => {
- let value = valueAt(target, i)
- if (value === undefined) {
- return { value: undefined, done: true }
- } else {
- return { value: [ i, value ], done: false }
- }
- }
- }
- return iterator
- },
-
- keys() {
- let i = 0;
- let len = context.length(objectId, heads)
- const iterator = {
- next: () => {
- let value = undefined
- if (i < len) { value = i; i++ }
- return { value, done: true }
- }
- }
- return iterator
- },
-
- values() {
- let i = 0;
- const iterator = {
- next: () => {
- let value = valueAt(target, i)
- if (value === undefined) {
- return { value: undefined, done: true }
- } else {
- return { value, done: false }
- }
- }
- }
- return iterator
- }
- }
-
- // Read-only methods that can delegate to the JavaScript built-in implementations
- // FIXME - super slow
- for (let method of ['concat', 'every', 'filter', 'find', 'findIndex', 'forEach', 'includes',
- 'join', 'lastIndexOf', 'map', 'reduce', 'reduceRight',
- 'slice', 'some', 'toLocaleString', 'toString']) {
- methods[method] = (...args) => {
- const list = []
- while (true) {
- let value = valueAt(target, list.length)
- if (value == undefined) {
- break
- }
- list.push(value)
- }
-
- return list[method](...args)
- }
- }
-
- return methods
-}
-
-function textMethods(target) {
- const {context, objectId, path, readonly, frozen} = target
- const methods = {
- set (index, value) {
- return this[index] = value
- },
- get (index) {
- return this[index]
- },
- toString () {
- let str = ''
- let length = this.length
- for (let i = 0; i < length; i++) {
- const value = this.get(i)
- if (typeof value === 'string') str += value
- }
- return str
- },
- toSpans () {
- let spans = []
- let chars = ''
- let length = this.length
- for (let i = 0; i < length; i++) {
- const value = this[i]
- if (typeof value === 'string') {
- chars += value
- } else {
- if (chars.length > 0) {
- spans.push(chars)
- chars = ''
- }
- spans.push(value)
- }
- }
- if (chars.length > 0) {
- spans.push(chars)
- }
- return spans
- },
- toJSON () {
- return this.toString()
- }
- }
- return methods
-}
-
-
-module.exports = { rootProxy, textProxy, listProxy, mapProxy, MapHandler, ListHandler, TextHandler }
diff --git a/automerge-js/src/text.js b/automerge-js/src/text.js
deleted file mode 100644
index a7f442fe..00000000
--- a/automerge-js/src/text.js
+++ /dev/null
@@ -1,132 +0,0 @@
-const { OBJECT_ID } = require('./constants')
-const { isObject } = require('../src/common')
-
-class Text {
- constructor (text) {
- const instance = Object.create(Text.prototype)
- if (typeof text === 'string') {
- instance.elems = [...text]
- } else if (Array.isArray(text)) {
- instance.elems = text
- } else if (text === undefined) {
- instance.elems = []
- } else {
- throw new TypeError(`Unsupported initial value for Text: ${text}`)
- }
- return instance
- }
-
- get length () {
- return this.elems.length
- }
-
- get (index) {
- return this.elems[index]
- }
-
- getElemId (index) {
- return undefined
- }
-
- /**
- * Iterates over the text elements character by character, including any
- * inline objects.
- */
- [Symbol.iterator] () {
- let elems = this.elems, index = -1
- return {
- next () {
- index += 1
- if (index < elems.length) {
- return {done: false, value: elems[index]}
- } else {
- return {done: true}
- }
- }
- }
- }
-
- /**
- * Returns the content of the Text object as a simple string, ignoring any
- * non-character elements.
- */
- toString() {
- // Concatting to a string is faster than creating an array and then
- // .join()ing for small (<100KB) arrays.
- // https://jsperf.com/join-vs-loop-w-type-test
- let str = ''
- for (const elem of this.elems) {
- if (typeof elem === 'string') str += elem
- }
- return str
- }
-
- /**
- * Returns the content of the Text object as a sequence of strings,
- * interleaved with non-character elements.
- *
- * For example, the value ['a', 'b', {x: 3}, 'c', 'd'] has spans:
- * => ['ab', {x: 3}, 'cd']
- */
- toSpans() {
- let spans = []
- let chars = ''
- for (const elem of this.elems) {
- if (typeof elem === 'string') {
- chars += elem
- } else {
- if (chars.length > 0) {
- spans.push(chars)
- chars = ''
- }
- spans.push(elem)
- }
- }
- if (chars.length > 0) {
- spans.push(chars)
- }
- return spans
- }
-
- /**
- * Returns the content of the Text object as a simple string, so that the
- * JSON serialization of an Automerge document represents text nicely.
- */
- toJSON() {
- return this.toString()
- }
-
- /**
- * Updates the list item at position `index` to a new value `value`.
- */
- set (index, value) {
- this.elems[index] = value
- }
-
- /**
- * Inserts new list items `values` starting at position `index`.
- */
- insertAt(index, ...values) {
- this.elems.splice(index, 0, ... values)
- }
-
- /**
- * Deletes `numDelete` list items starting at position `index`.
- * if `numDelete` is not given, one item is deleted.
- */
- deleteAt(index, numDelete = 1) {
- this.elems.splice(index, numDelete)
- }
-}
-
-// Read-only methods that can delegate to the JavaScript built-in array
-for (let method of ['concat', 'every', 'filter', 'find', 'findIndex', 'forEach', 'includes',
- 'indexOf', 'join', 'lastIndexOf', 'map', 'reduce', 'reduceRight',
- 'slice', 'some', 'toLocaleString']) {
- Text.prototype[method] = function (...args) {
- const array = [...this]
- return array[method](...args)
- }
-}
-
-module.exports = { Text }
diff --git a/automerge-js/src/uuid.js b/automerge-js/src/uuid.js
deleted file mode 100644
index 42a8cc6e..00000000
--- a/automerge-js/src/uuid.js
+++ /dev/null
@@ -1,16 +0,0 @@
-const { v4: uuid } = require('uuid')
-
-function defaultFactory() {
- return uuid().replace(/-/g, '')
-}
-
-let factory = defaultFactory
-
-function makeUuid() {
- return factory()
-}
-
-makeUuid.setFactory = newFactory => { factory = newFactory }
-makeUuid.reset = () => { factory = defaultFactory }
-
-module.exports = makeUuid
diff --git a/automerge-js/test/basic_test.js b/automerge-js/test/basic_test.js
deleted file mode 100644
index 68d2fecf..00000000
--- a/automerge-js/test/basic_test.js
+++ /dev/null
@@ -1,164 +0,0 @@
-
-const assert = require('assert')
-const util = require('util')
-const Automerge = require('..')
-
-describe('Automerge', () => {
- describe('basics', () => {
- it('should init clone and free', () => {
- let doc1 = Automerge.init()
- let doc2 = Automerge.clone(doc1);
- })
-
- it('handle basic set and read on root object', () => {
- let doc1 = Automerge.init()
- let doc2 = Automerge.change(doc1, (d) => {
- d.hello = "world"
- d.big = "little"
- d.zip = "zop"
- d.app = "dap"
- assert.deepEqual(d, { hello: "world", big: "little", zip: "zop", app: "dap" })
- })
- assert.deepEqual(doc2, { hello: "world", big: "little", zip: "zop", app: "dap" })
- })
-
- it('handle basic sets over many changes', () => {
- let doc1 = Automerge.init()
- let timestamp = new Date();
- let counter = new Automerge.Counter(100);
- let bytes = new Uint8Array([10,11,12]);
- let doc2 = Automerge.change(doc1, (d) => {
- d.hello = "world"
- })
- let doc3 = Automerge.change(doc2, (d) => {
- d.counter1 = counter
- })
- let doc4 = Automerge.change(doc3, (d) => {
- d.timestamp1 = timestamp
- })
- let doc5 = Automerge.change(doc4, (d) => {
- d.app = null
- })
- let doc6 = Automerge.change(doc5, (d) => {
- d.bytes1 = bytes
- })
- let doc7 = Automerge.change(doc6, (d) => {
- d.uint = new Automerge.Uint(1)
- d.int = new Automerge.Int(-1)
- d.float64 = new Automerge.Float64(5.5)
- d.number1 = 100
- d.number2 = -45.67
- d.true = true
- d.false = false
- })
-
- assert.deepEqual(doc7, { hello: "world", true: true, false: false, int: -1, uint: 1, float64: 5.5, number1: 100, number2: -45.67, counter1: counter, timestamp1: timestamp, bytes1: bytes, app: null })
-
- let changes = Automerge.getAllChanges(doc7)
- let t1 = Automerge.init()
- ;let [t2] = Automerge.applyChanges(t1, changes)
- assert.deepEqual(doc7,t2)
- })
-
- it('handle overwrites to values', () => {
- let doc1 = Automerge.init()
- let doc2 = Automerge.change(doc1, (d) => {
- d.hello = "world1"
- })
- let doc3 = Automerge.change(doc2, (d) => {
- d.hello = "world2"
- })
- let doc4 = Automerge.change(doc3, (d) => {
- d.hello = "world3"
- })
- let doc5 = Automerge.change(doc4, (d) => {
- d.hello = "world4"
- })
- assert.deepEqual(doc5, { hello: "world4" } )
- })
-
- it('handle set with object value', () => {
- let doc1 = Automerge.init()
- let doc2 = Automerge.change(doc1, (d) => {
- d.subobj = { hello: "world", subsubobj: { zip: "zop" } }
- })
- assert.deepEqual(doc2, { subobj: { hello: "world", subsubobj: { zip: "zop" } } })
- })
-
- it('handle simple list creation', () => {
- let doc1 = Automerge.init()
- let doc2 = Automerge.change(doc1, (d) => d.list = [])
- assert.deepEqual(doc2, { list: []})
- })
-
- it('handle simple lists', () => {
- let doc1 = Automerge.init()
- let doc2 = Automerge.change(doc1, (d) => {
- d.list = [ 1, 2, 3 ]
- })
- assert.deepEqual(doc2.list.length, 3)
- assert.deepEqual(doc2.list[0], 1)
- assert.deepEqual(doc2.list[1], 2)
- assert.deepEqual(doc2.list[2], 3)
- assert.deepEqual(doc2, { list: [1,2,3] })
- // assert.deepStrictEqual(Automerge.toJS(doc2), { list: [1,2,3] })
-
- let doc3 = Automerge.change(doc2, (d) => {
- d.list[1] = "a"
- })
-
- assert.deepEqual(doc3.list.length, 3)
- assert.deepEqual(doc3.list[0], 1)
- assert.deepEqual(doc3.list[1], "a")
- assert.deepEqual(doc3.list[2], 3)
- assert.deepEqual(doc3, { list: [1,"a",3] })
- })
- it('handle simple lists', () => {
- let doc1 = Automerge.init()
- let doc2 = Automerge.change(doc1, (d) => {
- d.list = [ 1, 2, 3 ]
- })
- let changes = Automerge.getChanges(doc1, doc2)
- let docB1 = Automerge.init()
- ;let [docB2] = Automerge.applyChanges(docB1, changes)
- assert.deepEqual(docB2, doc2);
- })
- it('handle text', () => {
- let doc1 = Automerge.init()
- let tmp = new Automerge.Text("hello")
- let doc2 = Automerge.change(doc1, (d) => {
- d.list = new Automerge.Text("hello")
- d.list.insertAt(2,"Z")
- })
- let changes = Automerge.getChanges(doc1, doc2)
- let docB1 = Automerge.init()
- ;let [docB2] = Automerge.applyChanges(docB1, changes)
- assert.deepEqual(docB2, doc2);
- })
-
- it('have many list methods', () => {
- let doc1 = Automerge.from({ list: [1,2,3] })
- assert.deepEqual(doc1, { list: [1,2,3] });
- let doc2 = Automerge.change(doc1, (d) => {
- d.list.splice(1,1,9,10)
- })
- assert.deepEqual(doc2, { list: [1,9,10,3] });
- let doc3 = Automerge.change(doc2, (d) => {
- d.list.push(11,12)
- })
- assert.deepEqual(doc3, { list: [1,9,10,3,11,12] });
- let doc4 = Automerge.change(doc3, (d) => {
- d.list.unshift(2,2)
- })
- assert.deepEqual(doc4, { list: [2,2,1,9,10,3,11,12] });
- let doc5 = Automerge.change(doc4, (d) => {
- d.list.shift()
- })
- assert.deepEqual(doc5, { list: [2,1,9,10,3,11,12] });
- let doc6 = Automerge.change(doc5, (d) => {
- d.list.insertAt(3,100,101)
- })
- assert.deepEqual(doc6, { list: [2,1,9,100,101,10,3,11,12] });
- })
- })
-})
diff --git a/automerge-js/test/columnar_test.js b/automerge-js/test/columnar_test.js
deleted file mode 100644
index 8cbe1482..00000000
--- a/automerge-js/test/columnar_test.js
+++ /dev/null
@@ -1,97 +0,0 @@
-const assert = require('assert')
-const { checkEncoded } = require('./helpers')
-const Automerge = require('..')
-const { encodeChange, decodeChange } = Automerge
-
-describe('change encoding', () => {
- it('should encode text edits', () => {
- /*
- const change1 = {actor: 'aaaa', seq: 1, startOp: 1, time: 9, message: '', deps: [], ops: [
- {action: 'makeText', obj: '_root', key: 'text', insert: false, pred: []},
- {action: 'set', obj: '1@aaaa', elemId: '_head', insert: true, value: 'h', pred: []},
- {action: 'del', obj: '1@aaaa', elemId: '2@aaaa', insert: false, pred: ['2@aaaa']},
- {action: 'set', obj: '1@aaaa', elemId: '_head', insert: true, value: 'H', pred: []},
- {action: 'set', obj: '1@aaaa', elemId: '4@aaaa', insert: true, value: 'i', pred: []}
- ]}
- */
- const change1 = {actor: 'aaaa', seq: 1, startOp: 1, time: 9, message: null, deps: [], ops: [
- {action: 'makeText', obj: '_root', key: 'text', pred: []},
- {action: 'set', obj: '1@aaaa', elemId: '_head', insert: true, value: 'h', pred: []},
- {action: 'del', obj: '1@aaaa', elemId: '2@aaaa', pred: ['2@aaaa']},
- {action: 'set', obj: '1@aaaa', elemId: '_head', insert: true, value: 'H', pred: []},
- {action: 'set', obj: '1@aaaa', elemId: '4@aaaa', insert: true, value: 'i', pred: []}
- ]}
- checkEncoded(encodeChange(change1), [
- 0x85, 0x6f, 0x4a, 0x83, // magic bytes
- 0xe2, 0xbd, 0xfb, 0xf5, // checksum
- 1, 94, 0, 2, 0xaa, 0xaa, // chunkType: change, length, deps, actor 'aaaa'
- 1, 1, 9, 0, 0, // seq, startOp, time, message, actor list
- 12, 0x01, 4, 0x02, 4, // column count, objActor, objCtr
- 0x11, 8, 0x13, 7, 0x15, 8, // keyActor, keyCtr, keyStr
- 0x34, 4, 0x42, 6, // insert, action
- 0x56, 6, 0x57, 3, // valLen, valRaw
- 0x70, 6, 0x71, 2, 0x73, 2, // predNum, predActor, predCtr
- 0, 1, 4, 0, // objActor column: null, 0, 0, 0, 0
- 0, 1, 4, 1, // objCtr column: null, 1, 1, 1, 1
- 0, 2, 0x7f, 0, 0, 1, 0x7f, 0, // keyActor column: null, null, 0, null, 0
- 0, 1, 0x7c, 0, 2, 0x7e, 4, // keyCtr column: null, 0, 2, 0, 4
- 0x7f, 4, 0x74, 0x65, 0x78, 0x74, 0, 4, // keyStr column: 'text', null, null, null, null
- 1, 1, 1, 2, // insert column: false, true, false, true, true
- 0x7d, 4, 1, 3, 2, 1, // action column: makeText, set, del, set, set
- 0x7d, 0, 0x16, 0, 2, 0x16, // valLen column: 0, 0x16, 0, 0x16, 0x16
- 0x68, 0x48, 0x69, // valRaw column: 'h', 'H', 'i'
- 2, 0, 0x7f, 1, 2, 0, // predNum column: 0, 0, 1, 0, 0
- 0x7f, 0, // predActor column: 0
- 0x7f, 2 // predCtr column: 2
- ])
- const decoded = decodeChange(encodeChange(change1))
- assert.deepStrictEqual(decoded, Object.assign({hash: decoded.hash}, change1))
- })
-
- // FIXME - skipping this b/c it was never implemented in the rust impl and isnt trivial
-/*
- it.skip('should require strict ordering of preds', () => {
- const change = new Uint8Array([
- 133, 111, 74, 131, 31, 229, 112, 44, 1, 105, 1, 58, 30, 190, 100, 253, 180, 180, 66, 49, 126,
- 81, 142, 10, 3, 35, 140, 189, 231, 34, 145, 57, 66, 23, 224, 149, 64, 97, 88, 140, 168, 194,
- 229, 4, 244, 209, 58, 138, 67, 140, 1, 152, 236, 250, 2, 0, 1, 4, 55, 234, 66, 242, 8, 21, 11,
- 52, 1, 66, 2, 86, 3, 87, 10, 112, 2, 113, 3, 115, 4, 127, 9, 99, 111, 109, 109, 111, 110, 86,
- 97, 114, 1, 127, 1, 127, 166, 1, 52, 48, 57, 49, 52, 57, 52, 53, 56, 50, 127, 2, 126, 0, 1,
- 126, 139, 1, 0
- ])
- assert.throws(() => { decodeChange(change) }, /operation IDs are not in ascending order/)
- })
-*/
-
- describe('with trailing bytes', () => {
- let change = new Uint8Array([
- 0x85, 0x6f, 0x4a, 0x83, // magic bytes
- 0xb2, 0x98, 0x9e, 0xa9, // checksum
- 1, 61, 0, 2, 0x12, 0x34, // chunkType: change, length, deps, actor '1234'
- 1, 1, 252, 250, 220, 255, 5, // seq, startOp, time
- 14, 73, 110, 105, 116, 105, 97, 108, 105, 122, 97, 116, 105, 111, 110, // message: 'Initialization'
- 0, 6, // actor list, column count
- 0x15, 3, 0x34, 1, 0x42, 2, // keyStr, insert, action
- 0x56, 2, 0x57, 1, 0x70, 2, // valLen, valRaw, predNum
- 0x7f, 1, 0x78, // keyStr: 'x'
- 1, // insert: false
- 0x7f, 1, // action: set
- 0x7f, 19, // valLen: 1 byte of type uint
- 1, // valRaw: 1
- 0x7f, 0, // predNum: 0
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 // 10 trailing bytes
- ])
-
- it('should allow decoding and re-encoding', () => {
- // NOTE: This calls the JavaScript encoding and decoding functions, even when the WebAssembly
- // backend is loaded. Should the wasm backend export its own functions for testing?
- checkEncoded(change, encodeChange(decodeChange(change)))
- })
-
- it('should be preserved in document encoding', () => {
- const [doc] = Automerge.applyChanges(Automerge.init(), [change])
- const [reconstructed] = Automerge.getAllChanges(Automerge.load(Automerge.save(doc)))
- checkEncoded(change, reconstructed)
- })
- })
-})
diff --git a/automerge-js/test/legacy_tests.js b/automerge-js/test/legacy_tests.js
deleted file mode 100644
index 76348d06..00000000
--- a/automerge-js/test/legacy_tests.js
+++ /dev/null
@@ -1,1419 +0,0 @@
-const assert = require('assert')
-//const Automerge = process.env.TEST_DIST === '1' ? require('../dist/automerge') : require('../src/automerge')
-const Automerge = require('../src')
-const { assertEqualsOneOf } = require('./helpers')
-const { decodeChange } = require('../src/columnar')
-//const { decodeChange } = Automerge
-
-const UUID_PATTERN = /^[0-9a-f]{32}$/
-const OPID_PATTERN = /^[0-9]+@[0-9a-f]{32}$/
-
-// CORE FEATURES
-//
-// TODO - Cursors
-// TODO - Tables
-// TODO - on-pass load() & reconstruct change from opset
-// TODO - micro-patches (needed for fully hydrated object in js)
-// TODO - valueAt(heads) / GC
-//
-// AUTOMERGE UNSUPPORTED
-//
-// TODO - patchCallback
-
-
-describe('Automerge', () => {
- describe('initialization ', () => {
- it('should initially be an empty map', () => {
- const doc = Automerge.init()
- assert.deepStrictEqual(doc, {})
- })
-
- it('should allow instantiating from an existing object', () => {
- const initialState = { birds: { wrens: 3, magpies: 4 } }
- const doc = Automerge.from(initialState)
- assert.deepStrictEqual(doc, initialState)
- })
-
- it('should allow merging of an object initialized with `from`', () => {
- let doc1 = Automerge.from({ cards: [] })
- let doc2 = Automerge.merge(Automerge.init(), doc1)
- assert.deepStrictEqual(doc2, { cards: [] })
- })
-
- it('should allow passing an actorId when instantiating from an existing object', () => {
- const actorId = '1234'
- let doc = Automerge.from({ foo: 1 }, actorId)
- assert.strictEqual(Automerge.getActorId(doc), '1234')
- })
-
- it('accepts an empty object as initial state', () => {
- const doc = Automerge.from({})
- assert.deepStrictEqual(doc, {})
- })
-
- it('accepts an array as initial state, but converts it to an object', () => {
- const doc = Automerge.from(['a', 'b', 'c'])
- assert.deepStrictEqual(doc, { '0': 'a', '1': 'b', '2': 'c' })
- })
-
- it('accepts strings as initial values, but treats them as an array of characters', () => {
- const doc = Automerge.from('abc')
- assert.deepStrictEqual(doc, { '0': 'a', '1': 'b', '2': 'c' })
- })
-
- it('ignores numbers provided as initial values', () => {
- const doc = Automerge.from(123)
- assert.deepStrictEqual(doc, {})
- })
-
- it('ignores booleans provided as initial values', () => {
- const doc1 = Automerge.from(false)
- assert.deepStrictEqual(doc1, {})
- const doc2 = Automerge.from(true)
- assert.deepStrictEqual(doc2, {})
- })
- })
-
- describe('sequential use', () => {
- let s1, s2
- beforeEach(() => {
- s1 = Automerge.init()
- })
-
- it('should not mutate objects', () => {
- s2 = Automerge.change(s1, doc => doc.foo = 'bar')
- assert.strictEqual(s1.foo, undefined)
- assert.strictEqual(s2.foo, 'bar')
- })
-
- it('changes should be retrievable', () => {
- const change1 = Automerge.getLastLocalChange(s1)
- s2 = Automerge.change(s1, doc => doc.foo = 'bar')
- const change2 = Automerge.getLastLocalChange(s2)
- assert.strictEqual(change1, undefined)
- const change = decodeChange(change2)
- assert.deepStrictEqual(change, {
- actor: change.actor, deps: [], seq: 1, startOp: 1,
- hash: change.hash, message: '', time: change.time,
- ops: [{obj: '_root', key: 'foo', action: 'set', insert: false, value: 'bar', pred: []}]
- })
- })
-
- it('should not register any conflicts on repeated assignment', () => {
- assert.strictEqual(Automerge.getConflicts(s1, 'foo'), undefined)
- s1 = Automerge.change(s1, 'change', doc => doc.foo = 'one')
- assert.strictEqual(Automerge.getConflicts(s1, 'foo'), undefined)
- s1 = Automerge.change(s1, 'change', doc => doc.foo = 'two')
- assert.strictEqual(Automerge.getConflicts(s1, 'foo'), undefined)
- })
-
- describe('changes', () => {
- it('should group several changes', () => {
- s2 = Automerge.change(s1, 'change message', doc => {
- doc.first = 'one'
- assert.strictEqual(doc.first, 'one')
- doc.second = 'two'
- assert.deepStrictEqual(doc, {
- first: 'one', second: 'two'
- })
- })
- assert.deepStrictEqual(s1, {})
- assert.deepStrictEqual(s2, {first: 'one', second: 'two'})
- })
-
- it('should freeze objects if desired', () => {
- s1 = Automerge.init({freeze: true})
- s2 = Automerge.change(s1, doc => doc.foo = 'bar')
- try {
- s2.foo = 'lemon'
- } catch (e) { }
- assert.strictEqual(s2.foo, 'bar')
-
- let deleted = false
- try {
- deleted = delete s2.foo
- } catch (e) { }
- assert.strictEqual(s2.foo, 'bar')
- assert.strictEqual(deleted, false)
-
- Automerge.change(s2, () => {
- try {
- s2.foo = 'lemon'
- } catch (e) { }
- assert.strictEqual(s2.foo, 'bar')
- })
-
- assert.throws(() => { Object.assign(s2, {x: 4}) })
- assert.strictEqual(s2.x, undefined)
- })
-
- it('should allow repeated reading and writing of values', () => {
- s2 = Automerge.change(s1, 'change message', doc => {
- doc.value = 'a'
- assert.strictEqual(doc.value, 'a')
- doc.value = 'b'
- doc.value = 'c'
- assert.strictEqual(doc.value, 'c')
- })
- assert.deepStrictEqual(s1, {})
- assert.deepStrictEqual(s2, {value: 'c'})
- })
-
- it('should not record conflicts when writing the same field several times within one change', () => {
- s1 = Automerge.change(s1, 'change message', doc => {
- doc.value = 'a'
- doc.value = 'b'
- doc.value = 'c'
- })
- assert.strictEqual(s1.value, 'c')
- assert.strictEqual(Automerge.getConflicts(s1, 'value'), undefined)
- })
-
- it('should return the unchanged state object if nothing changed', () => {
- s2 = Automerge.change(s1, () => {})
- assert.strictEqual(s2, s1)
- })
-
- it('should ignore field updates that write the existing value', () => {
- s1 = Automerge.change(s1, doc => doc.field = 123)
- s2 = Automerge.change(s1, doc => doc.field = 123)
- assert.strictEqual(s2, s1)
- })
-
- it('should not ignore field updates that resolve a conflict', () => {
- s2 = Automerge.merge(Automerge.init(), s1)
- s1 = Automerge.change(s1, doc => doc.field = 123)
- s2 = Automerge.change(s2, doc => doc.field = 321)
- s1 = Automerge.merge(s1, s2)
- assert.strictEqual(Object.keys(Automerge.getConflicts(s1, 'field')).length, 2)
- const resolved = Automerge.change(s1, doc => doc.field = s1.field)
- assert.notStrictEqual(resolved, s1)
- assert.deepStrictEqual(resolved, {field: s1.field})
- assert.strictEqual(Automerge.getConflicts(resolved, 'field'), undefined)
- })
-
- it('should ignore list element updates that write the existing value', () => {
- s1 = Automerge.change(s1, doc => doc.list = [123])
- s2 = Automerge.change(s1, doc => doc.list[0] = 123)
- assert.strictEqual(s2, s1)
- })
-
- it('should not ignore list element updates that resolve a conflict', () => {
- s1 = Automerge.change(s1, doc => doc.list = [1])
- s2 = Automerge.merge(Automerge.init(), s1)
- s1 = Automerge.change(s1, doc => doc.list[0] = 123)
- s2 = Automerge.change(s2, doc => doc.list[0] = 321)
- s1 = Automerge.merge(s1, s2)
- assert.deepStrictEqual(Automerge.getConflicts(s1.list, 0), {
- [`3@${Automerge.getActorId(s1)}`]: 123,
- [`3@${Automerge.getActorId(s2)}`]: 321
- })
- const resolved = Automerge.change(s1, doc => doc.list[0] = s1.list[0])
- assert.deepStrictEqual(resolved, s1)
- assert.notStrictEqual(resolved, s1)
- assert.strictEqual(Automerge.getConflicts(resolved.list, 0), undefined)
- })
-
- it('should sanity-check arguments', () => {
- s1 = Automerge.change(s1, doc => doc.nested = {})
- assert.throws(() => { Automerge.change({}, doc => doc.foo = 'bar') }, /must be the document root/)
- assert.throws(() => { Automerge.change(s1.nested, doc => doc.foo = 'bar') }, /must be the document root/)
- })
-
- it('should not allow nested change blocks', () => {
- assert.throws(() => {
- Automerge.change(s1, doc1 => {
- Automerge.change(doc1, doc2 => {
- doc2.foo = 'bar'
- })
- })
- }, /Calls to Automerge.change cannot be nested/)
- assert.throws(() => {
- s1 = Automerge.change(s1, doc1 => {
- s2 = Automerge.change(s1, doc2 => doc2.two = 2)
- doc1.one = 1
- })
- }, /Attempting to use an outdated Automerge document/)
- })
-
- it('should not allow the same base document to be used for multiple changes', () => {
- assert.throws(() => {
- Automerge.change(s1, doc => doc.one = 1)
- Automerge.change(s1, doc => doc.two = 2)
- }, /Attempting to use an outdated Automerge document/)
- })
-
- it('should allow a document to be cloned', () => {
- s1 = Automerge.change(s1, doc => doc.zero = 0)
- s2 = Automerge.clone(s1)
- s1 = Automerge.change(s1, doc => doc.one = 1)
- s2 = Automerge.change(s2, doc => doc.two = 2)
- assert.deepStrictEqual(s1, {zero: 0, one: 1})
- assert.deepStrictEqual(s2, {zero: 0, two: 2})
- Automerge.free(s1)
- Automerge.free(s2)
- })
-
- it('should work with Object.assign merges', () => {
- s1 = Automerge.change(s1, doc1 => {
- doc1.stuff = {foo: 'bar', baz: 'blur'}
- })
- s1 = Automerge.change(s1, doc1 => {
- doc1.stuff = Object.assign({}, doc1.stuff, {baz: 'updated!'})
- })
- assert.deepStrictEqual(s1, {stuff: {foo: 'bar', baz: 'updated!'}})
- })
-
- it('should support Date objects in maps', () => {
- const now = new Date()
- s1 = Automerge.change(s1, doc => doc.now = now)
- let changes = Automerge.getAllChanges(s1)
- ;[s2] = Automerge.applyChanges(Automerge.init(), changes)
- assert.strictEqual(s2.now instanceof Date, true)
- assert.strictEqual(s2.now.getTime(), now.getTime())
- })
-
- it('should support Date objects in lists', () => {
- const now = new Date()
- s1 = Automerge.change(s1, doc => doc.list = [now])
- let changes = Automerge.getAllChanges(s1)
- ;[s2] = Automerge.applyChanges(Automerge.init(), changes)
- assert.strictEqual(s2.list[0] instanceof Date, true)
- assert.strictEqual(s2.list[0].getTime(), now.getTime())
- })
-
- /*
- it.skip('should call patchCallback if supplied', () => {
- const callbacks = [], actor = Automerge.getActorId(s1)
- const s2 = Automerge.change(s1, {
- patchCallback: (patch, before, after, local) => callbacks.push({patch, before, after, local})
- }, doc => {
- doc.birds = ['Goldfinch']
- })
- assert.strictEqual(callbacks.length, 1)
- assert.deepStrictEqual(callbacks[0].patch, {
- actor, seq: 1, maxOp: 2, deps: [], clock: {[actor]: 1}, pendingChanges: 0,
- diffs: {objectId: '_root', type: 'map', props: {birds: {[`1@${actor}`]: {
- objectId: `1@${actor}`, type: 'list', edits: [
- {action: 'insert', index: 0, elemId: `2@${actor}`, opId: `2@${actor}`, value: {'type': 'value', value: 'Goldfinch'}}
- ]
- }}}}
- })
- assert.strictEqual(callbacks[0].before, s1)
- assert.strictEqual(callbacks[0].after, s2)
- assert.strictEqual(callbacks[0].local, true)
- })
- */
-
- /*
- it.skip('should call a patchCallback set up on document initialisation', () => {
- const callbacks = []
- s1 = Automerge.init({
- patchCallback: (patch, before, after, local) => callbacks.push({patch, before, after, local})
- })
- const s2 = Automerge.change(s1, doc => doc.bird = 'Goldfinch')
- const actor = Automerge.getActorId(s1)
- assert.strictEqual(callbacks.length, 1)
- assert.deepStrictEqual(callbacks[0].patch, {
- actor, seq: 1, maxOp: 1, deps: [], clock: {[actor]: 1}, pendingChanges: 0,
- diffs: {objectId: '_root', type: 'map', props: {bird: {[`1@${actor}`]: {type: 'value', value: 'Goldfinch'}}}}
- })
- assert.strictEqual(callbacks[0].before, s1)
- assert.strictEqual(callbacks[0].after, s2)
- assert.strictEqual(callbacks[0].local, true)
- })
- */
- })
-
- describe('emptyChange()', () => {
- it('should append an empty change to the history', () => {
- s1 = Automerge.change(s1, 'first change', doc => doc.field = 123)
- s2 = Automerge.emptyChange(s1, 'empty change')
- assert.notStrictEqual(s2, s1)
- assert.deepStrictEqual(s2, s1)
- assert.deepStrictEqual(Automerge.getHistory(s2).map(state => state.change.message), ['first change', 'empty change'])
- })
-
- it('should reference dependencies', () => {
- s1 = Automerge.change(s1, doc => doc.field = 123)
- s2 = Automerge.merge(Automerge.init(), s1)
- s2 = Automerge.change(s2, doc => doc.other = 'hello')
- s1 = Automerge.emptyChange(Automerge.merge(s1, s2))
- const history = Automerge.getHistory(s1)
- const emptyChange = history[2].change
- assert.deepStrictEqual(emptyChange.deps, [history[0].change.hash, history[1].change.hash].sort())
- assert.deepStrictEqual(emptyChange.ops, [])
- })
- })
-
- describe('root object', () => {
- it('should handle single-property assignment', () => {
- s1 = Automerge.change(s1, 'set bar', doc => doc.foo = 'bar')
- s1 = Automerge.change(s1, 'set zap', doc => doc.zip = 'zap')
- assert.strictEqual(s1.foo, 'bar')
- assert.strictEqual(s1.zip, 'zap')
- assert.deepStrictEqual(s1, {foo: 'bar', zip: 'zap'})
- })
-
- it('should allow floating-point values', () => {
- s1 = Automerge.change(s1, doc => doc.number = 1589032171.1)
- assert.strictEqual(s1.number, 1589032171.1)
- })
-
- it('should handle multi-property assignment', () => {
- s1 = Automerge.change(s1, 'multi-assign', doc => {
- Object.assign(doc, {foo: 'bar', answer: 42})
- })
- assert.strictEqual(s1.foo, 'bar')
- assert.strictEqual(s1.answer, 42)
- assert.deepStrictEqual(s1, {foo: 'bar', answer: 42})
- })
-
- it('should handle root property deletion', () => {
- s1 = Automerge.change(s1, 'set foo', doc => { doc.foo = 'bar'; doc.something = null })
- s1 = Automerge.change(s1, 'del foo', doc => { delete doc.foo })
- assert.strictEqual(s1.foo, undefined)
- assert.strictEqual(s1.something, null)
- assert.deepStrictEqual(s1, {something: null})
- })
-
- it('should follow JS delete behavior', () => {
- s1 = Automerge.change(s1, 'set foo', doc => { doc.foo = 'bar' })
- let deleted
- s1 = Automerge.change(s1, 'del foo', doc => {
- deleted = delete doc.foo
- })
- assert.strictEqual(deleted, true)
- let deleted2
- assert.doesNotThrow(() => {
- s1 = Automerge.change(s1, 'del baz', doc => {
- deleted2 = delete doc.baz
- })
- })
- assert.strictEqual(deleted2, true)
- })
-
- it('should allow the type of a property to be changed', () => {
- s1 = Automerge.change(s1, 'set number', doc => doc.prop = 123)
- assert.strictEqual(s1.prop, 123)
- s1 = Automerge.change(s1, 'set string', doc => doc.prop = '123')
- assert.strictEqual(s1.prop, '123')
- s1 = Automerge.change(s1, 'set null', doc => doc.prop = null)
- assert.strictEqual(s1.prop, null)
- s1 = Automerge.change(s1, 'set bool', doc => doc.prop = true)
- assert.strictEqual(s1.prop, true)
- })
-
- it('should require property names to be valid', () => {
- assert.throws(() => {
- Automerge.change(s1, 'foo', doc => doc[''] = 'x')
- }, /must not be an empty string/)
- })
-
- it('should not allow assignment of unsupported datatypes', () => {
- Automerge.change(s1, doc => {
- assert.throws(() => { doc.foo = undefined }, /Unsupported type of value: undefined/)
- assert.throws(() => { doc.foo = {prop: undefined} }, /Unsupported type of value: undefined/)
- assert.throws(() => { doc.foo = () => {} }, /Unsupported type of value: function/)
- assert.throws(() => { doc.foo = Symbol('foo') }, /Unsupported type of value: symbol/)
- })
- })
- })
-
- describe('nested maps', () => {
- it('should assign an objectId to nested maps', () => {
- s1 = Automerge.change(s1, doc => { doc.nested = {} })
- let id = Automerge.getObjectId(s1.nested)
- assert.strictEqual(OPID_PATTERN.test(Automerge.getObjectId(s1.nested)), true)
- assert.notEqual(Automerge.getObjectId(s1.nested), '_root')
- })
-
- it('should handle assignment of a nested property', () => {
- s1 = Automerge.change(s1, 'first change', doc => {
- doc.nested = {}
- doc.nested.foo = 'bar'
- })
- s1 = Automerge.change(s1, 'second change', doc => {
- doc.nested.one = 1
- })
- assert.deepStrictEqual(s1, {nested: {foo: 'bar', one: 1}})
- assert.deepStrictEqual(s1.nested, {foo: 'bar', one: 1})
- assert.strictEqual(s1.nested.foo, 'bar')
- assert.strictEqual(s1.nested.one, 1)
- })
-
- it('should handle assignment of an object literal', () => {
- s1 = Automerge.change(s1, doc => {
- doc.textStyle = {bold: false, fontSize: 12}
- })
- assert.deepStrictEqual(s1, {textStyle: {bold: false, fontSize: 12}})
- assert.deepStrictEqual(s1.textStyle, {bold: false, fontSize: 12})
- assert.strictEqual(s1.textStyle.bold, false)
- assert.strictEqual(s1.textStyle.fontSize, 12)
- })
-
- it('should handle assignment of multiple nested properties', () => {
- s1 = Automerge.change(s1, doc => {
- doc.textStyle = {bold: false, fontSize: 12}
- Object.assign(doc.textStyle, {typeface: 'Optima', fontSize: 14})
- })
- assert.strictEqual(s1.textStyle.typeface, 'Optima')
- assert.strictEqual(s1.textStyle.bold, false)
- assert.strictEqual(s1.textStyle.fontSize, 14)
- assert.deepStrictEqual(s1.textStyle, {typeface: 'Optima', bold: false, fontSize: 14})
- })
-
- it('should handle arbitrary-depth nesting', () => {
- s1 = Automerge.change(s1, doc => {
- doc.a = {b: {c: {d: {e: {f: {g: 'h'}}}}}}
- })
- s1 = Automerge.change(s1, doc => {
- doc.a.b.c.d.e.f.i = 'j'
- })
- assert.deepStrictEqual(s1, {a: { b: { c: { d: { e: { f: { g: 'h', i: 'j'}}}}}}})
- assert.strictEqual(s1.a.b.c.d.e.f.g, 'h')
- assert.strictEqual(s1.a.b.c.d.e.f.i, 'j')
- })
-
- it('should allow an old object to be replaced with a new one', () => {
- s1 = Automerge.change(s1, 'change 1', doc => {
- doc.myPet = {species: 'dog', legs: 4, breed: 'dachshund'}
- })
- s2 = Automerge.change(s1, 'change 2', doc => {
- doc.myPet = {species: 'koi', variety: '紅白', colors: {red: true, white: true, black: false}}
- })
- assert.deepStrictEqual(s1.myPet, {
- species: 'dog', legs: 4, breed: 'dachshund'
- })
- assert.strictEqual(s1.myPet.breed, 'dachshund')
- assert.deepStrictEqual(s2.myPet, {
- species: 'koi', variety: '紅白',
- colors: {red: true, white: true, black: false}
- })
- assert.strictEqual(s2.myPet.breed, undefined)
- assert.strictEqual(s2.myPet.variety, '紅白')
- })
-
- it('should allow fields to be changed between primitive and nested map', () => {
- s1 = Automerge.change(s1, doc => doc.color = '#ff7f00')
- assert.strictEqual(s1.color, '#ff7f00')
- s1 = Automerge.change(s1, doc => doc.color = {red: 255, green: 127, blue: 0})
- assert.deepStrictEqual(s1.color, {red: 255, green: 127, blue: 0})
- s1 = Automerge.change(s1, doc => doc.color = '#ff7f00')
- assert.strictEqual(s1.color, '#ff7f00')
- })
-
- it('should not allow several references to the same map object', () => {
- s1 = Automerge.change(s1, doc => doc.object = {})
- assert.throws(() => {
- Automerge.change(s1, doc => { doc.x = doc.object })
- }, /Cannot create a reference to an existing document object/)
- assert.throws(() => {
- Automerge.change(s1, doc => { doc.x = s1.object })
- }, /Cannot create a reference to an existing document object/)
- assert.throws(() => {
- Automerge.change(s1, doc => { doc.x = {}; doc.y = doc.x })
- }, /Cannot create a reference to an existing document object/)
- })
-
- it('should not allow object-copying idioms', () => {
- s1 = Automerge.change(s1, doc => {
- doc.items = [{id: 'id1', name: 'one'}, {id: 'id2', name: 'two'}]
- })
- // People who have previously worked with immutable state in JavaScript may be tempted
- // to use idioms like this, which don't work well with Automerge -- see e.g.
- // https://github.com/automerge/automerge/issues/260
- assert.throws(() => {
- Automerge.change(s1, doc => {
- doc.items = [...doc.items, {id: 'id3', name: 'three'}]
- })
- }, /Cannot create a reference to an existing document object/)
- })
-
- it('should handle deletion of properties within a map', () => {
- s1 = Automerge.change(s1, 'set style', doc => {
- doc.textStyle = {typeface: 'Optima', bold: false, fontSize: 12}
- })
- s1 = Automerge.change(s1, 'non-bold', doc => delete doc.textStyle.bold)
- assert.strictEqual(s1.textStyle.bold, undefined)
- assert.deepStrictEqual(s1.textStyle, {typeface: 'Optima', fontSize: 12})
- })
-
- it('should handle deletion of references to a map', () => {
- s1 = Automerge.change(s1, 'make rich text doc', doc => {
- Object.assign(doc, {title: 'Hello', textStyle: {typeface: 'Optima', fontSize: 12}})
- })
- s1 = Automerge.change(s1, doc => delete doc.textStyle)
- assert.strictEqual(s1.textStyle, undefined)
- assert.deepStrictEqual(s1, {title: 'Hello'})
- })
-
- it('should validate field names', () => {
- s1 = Automerge.change(s1, doc => doc.nested = {})
- assert.throws(() => { Automerge.change(s1, doc => doc.nested[''] = 'x') }, /must not be an empty string/)
- assert.throws(() => { Automerge.change(s1, doc => doc.nested = {'': 'x'}) }, /must not be an empty string/)
- })
- })
-
- describe('lists', () => {
- it('should allow elements to be inserted', () => {
- s1 = Automerge.change(s1, doc => doc.noodles = [])
- s1 = Automerge.change(s1, doc => doc.noodles.insertAt(0, 'udon', 'soba'))
- s1 = Automerge.change(s1, doc => doc.noodles.insertAt(1, 'ramen'))
- assert.deepStrictEqual(s1, {noodles: ['udon', 'ramen', 'soba']})
- assert.deepStrictEqual(s1.noodles, ['udon', 'ramen', 'soba'])
- assert.strictEqual(s1.noodles[0], 'udon')
- assert.strictEqual(s1.noodles[1], 'ramen')
- assert.strictEqual(s1.noodles[2], 'soba')
- assert.strictEqual(s1.noodles.length, 3)
- })
-
- it('should handle assignment of a list literal', () => {
- s1 = Automerge.change(s1, doc => doc.noodles = ['udon', 'ramen', 'soba'])
- assert.deepStrictEqual(s1, {noodles: ['udon', 'ramen', 'soba']})
- assert.deepStrictEqual(s1.noodles, ['udon', 'ramen', 'soba'])
- assert.strictEqual(s1.noodles[0], 'udon')
- assert.strictEqual(s1.noodles[1], 'ramen')
- assert.strictEqual(s1.noodles[2], 'soba')
- assert.strictEqual(s1.noodles[3], undefined)
- assert.strictEqual(s1.noodles.length, 3)
- })
-
- it('should only allow numeric indexes', () => {
- s1 = Automerge.change(s1, doc => doc.noodles = ['udon', 'ramen', 'soba'])
- s1 = Automerge.change(s1, doc => doc.noodles[1] = 'Ramen!')
- assert.strictEqual(s1.noodles[1], 'Ramen!')
- s1 = Automerge.change(s1, doc => doc.noodles['1'] = 'RAMEN!!!')
- assert.strictEqual(s1.noodles[1], 'RAMEN!!!')
- assert.throws(() => { Automerge.change(s1, doc => doc.noodles.favourite = 'udon') }, /list index must be a number/)
- assert.throws(() => { Automerge.change(s1, doc => doc.noodles[''] = 'udon') }, /list index must be a number/)
- assert.throws(() => { Automerge.change(s1, doc => doc.noodles['1e6'] = 'udon') }, /list index must be a number/)
- })
-
- it('should handle deletion of list elements', () => {
- s1 = Automerge.change(s1, doc => doc.noodles = ['udon', 'ramen', 'soba'])
- s1 = Automerge.change(s1, doc => delete doc.noodles[1])
- assert.deepStrictEqual(s1.noodles, ['udon', 'soba'])
- s1 = Automerge.change(s1, doc => doc.noodles.deleteAt(1))
- assert.deepStrictEqual(s1.noodles, ['udon'])
- assert.strictEqual(s1.noodles[0], 'udon')
- assert.strictEqual(s1.noodles[1], undefined)
- assert.strictEqual(s1.noodles[2], undefined)
- assert.strictEqual(s1.noodles.length, 1)
- })
-
- it('should handle assignment of individual list indexes', () => {
- s1 = Automerge.change(s1, doc => doc.japaneseFood = ['udon', 'ramen', 'soba'])
- s1 = Automerge.change(s1, doc => doc.japaneseFood[1] = 'sushi')
- assert.deepStrictEqual(s1.japaneseFood, ['udon', 'sushi', 'soba'])
- assert.strictEqual(s1.japaneseFood[0], 'udon')
- assert.strictEqual(s1.japaneseFood[1], 'sushi')
- assert.strictEqual(s1.japaneseFood[2], 'soba')
- assert.strictEqual(s1.japaneseFood[3], undefined)
- assert.strictEqual(s1.japaneseFood.length, 3)
- })
-
- it('concurrent edits insert in reverse actorid order if counters equal', () => {
- s1 = Automerge.init('aaaa')
- s2 = Automerge.init('bbbb')
- s1 = Automerge.change(s1, doc => doc.list = [])
- s2 = Automerge.merge(s2, s1)
- s1 = Automerge.change(s1, doc => doc.list.splice(0, 0, "2@aaaa"))
- s2 = Automerge.change(s2, doc => doc.list.splice(0, 0, "2@bbbb"))
- s2 = Automerge.merge(s2, s1)
- assert.deepStrictEqual(Automerge.toJS(s2).list, ["2@bbbb", "2@aaaa"])
- })
-
- it('concurrent edits insert in reverse counter order if different', () => {
- s1 = Automerge.init('aaaa')
- s2 = Automerge.init('bbbb')
- s1 = Automerge.change(s1, doc => doc.list = [])
- s2 = Automerge.merge(s2, s1)
- s1 = Automerge.change(s1, doc => doc.list.splice(0, 0, "2@aaaa"))
- s2 = Automerge.change(s2, doc => doc.foo = "2@bbbb")
- s2 = Automerge.change(s2, doc => doc.list.splice(0, 0, "3@bbbb"))
- s2 = Automerge.merge(s2, s1)
- assert.deepStrictEqual(s2.list, ["3@bbbb", "2@aaaa"])
- })
-
- it('should treat out-by-one assignment as insertion', () => {
- s1 = Automerge.change(s1, doc => doc.japaneseFood = ['udon'])
- s1 = Automerge.change(s1, doc => doc.japaneseFood[1] = 'sushi')
- assert.deepStrictEqual(s1.japaneseFood, ['udon', 'sushi'])
- assert.strictEqual(s1.japaneseFood[0], 'udon')
- assert.strictEqual(s1.japaneseFood[1], 'sushi')
- assert.strictEqual(s1.japaneseFood[2], undefined)
- assert.strictEqual(s1.japaneseFood.length, 2)
- })
-
- it('should not allow out-of-range assignment', () => {
- s1 = Automerge.change(s1, doc => doc.japaneseFood = ['udon'])
- assert.throws(() => { Automerge.change(s1, doc => doc.japaneseFood[4] = 'ramen') }, /is out of bounds/)
- })
-
- it('should allow bulk assignment of multiple list indexes', () => {
- s1 = Automerge.change(s1, doc => doc.noodles = ['udon', 'ramen', 'soba'])
- s1 = Automerge.change(s1, doc => Object.assign(doc.noodles, {0: 'うどん', 2: 'そば'}))
- assert.deepStrictEqual(s1.noodles, ['うどん', 'ramen', 'そば'])
- assert.strictEqual(s1.noodles[0], 'うどん')
- assert.strictEqual(s1.noodles[1], 'ramen')
- assert.strictEqual(s1.noodles[2], 'そば')
- assert.strictEqual(s1.noodles.length, 3)
- })
-
- it('should handle nested objects', () => {
- s1 = Automerge.change(s1, doc => doc.noodles = [{type: 'ramen', dishes: ['tonkotsu', 'shoyu']}])
- s1 = Automerge.change(s1, doc => doc.noodles.push({type: 'udon', dishes: ['tempura udon']}))
- s1 = Automerge.change(s1, doc => doc.noodles[0].dishes.push('miso'))
- assert.deepStrictEqual(s1, {noodles: [
- {type: 'ramen', dishes: ['tonkotsu', 'shoyu', 'miso']},
- {type: 'udon', dishes: ['tempura udon']}
- ]})
- assert.deepStrictEqual(s1.noodles[0], {
- type: 'ramen', dishes: ['tonkotsu', 'shoyu', 'miso']
- })
- assert.deepStrictEqual(s1.noodles[1], {
- type: 'udon', dishes: ['tempura udon']
- })
- })
-
- it('should handle nested lists', () => {
- s1 = Automerge.change(s1, doc => doc.noodleMatrix = [['ramen', 'tonkotsu', 'shoyu']])
- s1 = Automerge.change(s1, doc => doc.noodleMatrix.push(['udon', 'tempura udon']))
- s1 = Automerge.change(s1, doc => doc.noodleMatrix[0].push('miso'))
- assert.deepStrictEqual(s1.noodleMatrix, [['ramen', 'tonkotsu', 'shoyu', 'miso'], ['udon', 'tempura udon']])
- assert.deepStrictEqual(s1.noodleMatrix[0], ['ramen', 'tonkotsu', 'shoyu', 'miso'])
- assert.deepStrictEqual(s1.noodleMatrix[1], ['udon', 'tempura udon'])
- })
-
- it('should handle deep nesting', () => {
- s1 = Automerge.change(s1, doc => doc.nesting = {
- maps: { m1: { m2: { foo: "bar", baz: {} }, m2a: { } } },
- lists: [ [ 1, 2, 3 ], [ [ 3, 4, 5, [6]], 7 ] ],
- mapsinlists: [ { foo: "bar" }, [ { bar: "baz" } ] ],
- listsinmaps: { foo: [1, 2, 3], bar: [ [ { baz: "123" } ] ] }
- })
- s1 = Automerge.change(s1, doc => {
- doc.nesting.maps.m1a = "123"
- doc.nesting.maps.m1.m2.baz.xxx = "123"
- delete doc.nesting.maps.m1.m2a
- doc.nesting.lists.shift()
- doc.nesting.lists[0][0].pop()
- doc.nesting.lists[0][0].push(100)
- doc.nesting.mapsinlists[0].foo = "baz"
- doc.nesting.mapsinlists[1][0].foo = "bar"
- delete doc.nesting.mapsinlists[1]
- doc.nesting.listsinmaps.foo.push(4)
- doc.nesting.listsinmaps.bar[0][0].baz = "456"
- delete doc.nesting.listsinmaps.bar
- })
- assert.deepStrictEqual(s1, { nesting: {
- maps: { m1: { m2: { foo: "bar", baz: { xxx: "123" } } }, m1a: "123" },
- lists: [ [ [ 3, 4, 5, 100 ], 7 ] ],
- mapsinlists: [ { foo: "baz" } ],
- listsinmaps: { foo: [1, 2, 3, 4] }
- }})
- })
-
- it('should handle replacement of the entire list', () => {
- s1 = Automerge.change(s1, doc => doc.noodles = ['udon', 'soba', 'ramen'])
- s1 = Automerge.change(s1, doc => doc.japaneseNoodles = doc.noodles.slice())
- s1 = Automerge.change(s1, doc => doc.noodles = ['wonton', 'pho'])
- assert.deepStrictEqual(s1, {
- noodles: ['wonton', 'pho'],
- japaneseNoodles: ['udon', 'soba', 'ramen']
- })
- assert.deepStrictEqual(s1.noodles, ['wonton', 'pho'])
- assert.strictEqual(s1.noodles[0], 'wonton')
- assert.strictEqual(s1.noodles[1], 'pho')
- assert.strictEqual(s1.noodles[2], undefined)
- assert.strictEqual(s1.noodles.length, 2)
- })
-
- it('should allow assignment to change the type of a list element', () => {
- s1 = Automerge.change(s1, doc => doc.noodles = ['udon', 'soba', 'ramen'])
- assert.deepStrictEqual(s1.noodles, ['udon', 'soba', 'ramen'])
- s1 = Automerge.change(s1, doc => doc.noodles[1] = {type: 'soba', options: ['hot', 'cold']})
- assert.deepStrictEqual(s1.noodles, ['udon', {type: 'soba', options: ['hot', 'cold']}, 'ramen'])
- s1 = Automerge.change(s1, doc => doc.noodles[1] = ['hot soba', 'cold soba'])
- assert.deepStrictEqual(s1.noodles, ['udon', ['hot soba', 'cold soba'], 'ramen'])
- s1 = Automerge.change(s1, doc => doc.noodles[1] = 'soba is the best')
- assert.deepStrictEqual(s1.noodles, ['udon', 'soba is the best', 'ramen'])
- })
-
- it('should allow list creation and assignment in the same change callback', () => {
- s1 = Automerge.change(Automerge.init(), doc => {
- doc.letters = ['a', 'b', 'c']
- doc.letters[1] = 'd'
- })
- assert.strictEqual(s1.letters[1], 'd')
- })
-
- it('should allow adding and removing list elements in the same change callback', () => {
- s1 = Automerge.change(Automerge.init(), doc => doc.noodles = [])
- s1 = Automerge.change(s1, doc => {
- doc.noodles.push('udon')
- doc.noodles.deleteAt(0)
- })
- assert.deepStrictEqual(s1, {noodles: []})
- // do the add-remove cycle twice, test for #151 (https://github.com/automerge/automerge/issues/151)
- s1 = Automerge.change(s1, doc => {
- doc.noodles.push('soba')
- doc.noodles.deleteAt(0)
- })
- assert.deepStrictEqual(s1, {noodles: []})
- })
-
- it('should handle arbitrary-depth nesting', () => {
- s1 = Automerge.change(s1, doc => doc.maze = [[[[[[[['noodles', ['here']]]]]]]]])
- s1 = Automerge.change(s1, doc => doc.maze[0][0][0][0][0][0][0][1].unshift('found'))
- assert.deepStrictEqual(s1.maze, [[[[[[[['noodles', ['found', 'here']]]]]]]]])
- assert.deepStrictEqual(s1.maze[0][0][0][0][0][0][0][1][1], 'here')
- s2 = Automerge.load(Automerge.save(s1))
- assert.deepStrictEqual(s1,s2)
- })
-
- it('should not allow several references to the same list object', () => {
- s1 = Automerge.change(s1, doc => doc.list = [])
- assert.throws(() => {
- Automerge.change(s1, doc => { doc.x = doc.list })
- }, /Cannot create a reference to an existing document object/)
- assert.throws(() => {
- Automerge.change(s1, doc => { doc.x = s1.list })
- }, /Cannot create a reference to an existing document object/)
- assert.throws(() => {
- Automerge.change(s1, doc => { doc.x = []; doc.y = doc.x })
- }, /Cannot create a reference to an existing document object/)
- })
- })
-
- describe('counters', () => {
- // counter
- it('should allow deleting counters from maps', () => {
- const s1 = Automerge.change(Automerge.init(), doc => doc.birds = {wrens: new Automerge.Counter(1)})
- const s2 = Automerge.change(s1, doc => doc.birds.wrens.increment(2))
- const s3 = Automerge.change(s2, doc => delete doc.birds.wrens)
- assert.deepStrictEqual(s2, {birds: {wrens: new Automerge.Counter(3)}})
- assert.deepStrictEqual(s3, {birds: {}})
- })
-
- // counter
- /*
- it('should not allow deleting counters from lists', () => {
- const s1 = Automerge.change(Automerge.init(), doc => doc.recordings = [new Automerge.Counter(1)])
- const s2 = Automerge.change(s1, doc => doc.recordings[0].increment(2))
- assert.deepStrictEqual(s2, {recordings: [new Automerge.Counter(3)]})
- assert.throws(() => { Automerge.change(s2, doc => doc.recordings.deleteAt(0)) }, /Unsupported operation/)
- })
- */
- })
- })
-
- describe('concurrent use', () => {
- let s1, s2, s3
- beforeEach(() => {
- s1 = Automerge.init()
- s2 = Automerge.init()
- s3 = Automerge.init()
- })
-
- it('should merge concurrent updates of different properties', () => {
- s1 = Automerge.change(s1, doc => doc.foo = 'bar')
- s2 = Automerge.change(s2, doc => doc.hello = 'world')
- s3 = Automerge.merge(s1, s2)
- assert.strictEqual(s3.foo, 'bar')
- assert.strictEqual(s3.hello, 'world')
- assert.deepStrictEqual(s3, {foo: 'bar', hello: 'world'})
- assert.strictEqual(Automerge.getConflicts(s3, 'foo'), undefined)
- assert.strictEqual(Automerge.getConflicts(s3, 'hello'), undefined)
- s4 = Automerge.load(Automerge.save(s3))
- assert.deepEqual(s3,s4)
- })
-
- it('should add concurrent increments of the same property', () => {
- s1 = Automerge.change(s1, doc => doc.counter = new Automerge.Counter())
- s2 = Automerge.merge(s2, s1)
- s1 = Automerge.change(s1, doc => doc.counter.increment())
- s2 = Automerge.change(s2, doc => doc.counter.increment(2))
- s3 = Automerge.merge(s1, s2)
- assert.strictEqual(s1.counter.value, 1)
- assert.strictEqual(s2.counter.value, 2)
- assert.strictEqual(s3.counter.value, 3)
- assert.strictEqual(Automerge.getConflicts(s3, 'counter'), undefined)
- s4 = Automerge.load(Automerge.save(s3))
- assert.deepEqual(s3,s4)
- })
-
- it('should add increments only to the values they precede', () => {
- s1 = Automerge.change(s1, doc => doc.counter = new Automerge.Counter(0))
- s1 = Automerge.change(s1, doc => doc.counter.increment())
- s2 = Automerge.change(s2, doc => doc.counter = new Automerge.Counter(100))
- s2 = Automerge.change(s2, doc => doc.counter.increment(3))
- s3 = Automerge.merge(s1, s2)
- if (Automerge.getActorId(s1) > Automerge.getActorId(s2)) {
- assert.deepStrictEqual(s3, {counter: new Automerge.Counter(1)})
- } else {
- assert.deepStrictEqual(s3, {counter: new Automerge.Counter(103)})
- }
- assert.deepStrictEqual(Automerge.getConflicts(s3, 'counter'), {
- [`1@${Automerge.getActorId(s1)}`]: new Automerge.Counter(1),
- [`1@${Automerge.getActorId(s2)}`]: new Automerge.Counter(103)
- })
- s4 = Automerge.load(Automerge.save(s3))
- assert.deepEqual(s3,s4)
- })
-
- it('should detect concurrent updates of the same field', () => {
- s1 = Automerge.change(s1, doc => doc.field = 'one')
- s2 = Automerge.change(s2, doc => doc.field = 'two')
- s3 = Automerge.merge(s1, s2)
- if (Automerge.getActorId(s1) > Automerge.getActorId(s2)) {
- assert.deepStrictEqual(s3, {field: 'one'})
- } else {
- assert.deepStrictEqual(s3, {field: 'two'})
- }
- assert.deepStrictEqual(Automerge.getConflicts(s3, 'field'), {
- [`1@${Automerge.getActorId(s1)}`]: 'one',
- [`1@${Automerge.getActorId(s2)}`]: 'two'
- })
- })
-
- it('should detect concurrent updates of the same list element', () => {
- s1 = Automerge.change(s1, doc => doc.birds = ['finch'])
- s2 = Automerge.merge(s2, s1)
- s1 = Automerge.change(s1, doc => doc.birds[0] = 'greenfinch')
- s2 = Automerge.change(s2, doc => doc.birds[0] = 'goldfinch')
- s3 = Automerge.merge(s1, s2)
- if (Automerge.getActorId(s1) > Automerge.getActorId(s2)) {
- assert.deepStrictEqual(s3.birds, ['greenfinch'])
- } else {
- assert.deepStrictEqual(s3.birds, ['goldfinch'])
- }
- assert.deepStrictEqual(Automerge.getConflicts(s3.birds, 0), {
- [`3@${Automerge.getActorId(s1)}`]: 'greenfinch',
- [`3@${Automerge.getActorId(s2)}`]: 'goldfinch'
- })
- })
-
- it('should handle assignment conflicts of different types', () => {
- s1 = Automerge.change(s1, doc => doc.field = 'string')
- s2 = Automerge.change(s2, doc => doc.field = ['list'])
- s3 = Automerge.change(s3, doc => doc.field = {thing: 'map'})
- s1 = Automerge.merge(Automerge.merge(s1, s2), s3)
- assertEqualsOneOf(s1.field, 'string', ['list'], {thing: 'map'})
- assert.deepStrictEqual(Automerge.getConflicts(s1, 'field'), {
- [`1@${Automerge.getActorId(s1)}`]: 'string',
- [`1@${Automerge.getActorId(s2)}`]: ['list'],
- [`1@${Automerge.getActorId(s3)}`]: {thing: 'map'}
- })
- })
-
- it('should handle changes within a conflicting map field', () => {
- s1 = Automerge.change(s1, doc => doc.field = 'string')
- s2 = Automerge.change(s2, doc => doc.field = {})
- s2 = Automerge.change(s2, doc => doc.field.innerKey = 42)
- s3 = Automerge.merge(s1, s2)
- assertEqualsOneOf(s3.field, 'string', {innerKey: 42})
- assert.deepStrictEqual(Automerge.getConflicts(s3, 'field'), {
- [`1@${Automerge.getActorId(s1)}`]: 'string',
- [`1@${Automerge.getActorId(s2)}`]: {innerKey: 42}
- })
- })
-
- it('should handle changes within a conflicting list element', () => {
- s1 = Automerge.change(s1, doc => doc.list = ['hello'])
- s2 = Automerge.merge(s2, s1)
- s1 = Automerge.change(s1, doc => doc.list[0] = {map1: true})
- s1 = Automerge.change(s1, doc => doc.list[0].key = 1)
- s2 = Automerge.change(s2, doc => doc.list[0] = {map2: true})
- s2 = Automerge.change(s2, doc => doc.list[0].key = 2)
- s3 = Automerge.merge(s1, s2)
- if (Automerge.getActorId(s1) > Automerge.getActorId(s2)) {
- assert.deepStrictEqual(s3.list, [{map1: true, key: 1}])
- } else {
- assert.deepStrictEqual(s3.list, [{map2: true, key: 2}])
- }
- assert.deepStrictEqual(Automerge.getConflicts(s3.list, 0), {
- [`3@${Automerge.getActorId(s1)}`]: {map1: true, key: 1},
- [`3@${Automerge.getActorId(s2)}`]: {map2: true, key: 2}
- })
- })
-
- it('should not merge concurrently assigned nested maps', () => {
- s1 = Automerge.change(s1, doc => doc.config = {background: 'blue'})
- s2 = Automerge.change(s2, doc => doc.config = {logo_url: 'logo.png'})
- s3 = Automerge.merge(s1, s2)
- assertEqualsOneOf(s3.config, {background: 'blue'}, {logo_url: 'logo.png'})
- assert.deepStrictEqual(Automerge.getConflicts(s3, 'config'), {
- [`1@${Automerge.getActorId(s1)}`]: {background: 'blue'},
- [`1@${Automerge.getActorId(s2)}`]: {logo_url: 'logo.png'}
- })
- })
-
- it('should clear conflicts after assigning a new value', () => {
- s1 = Automerge.change(s1, doc => doc.field = 'one')
- s2 = Automerge.change(s2, doc => doc.field = 'two')
- s3 = Automerge.merge(s1, s2)
- s3 = Automerge.change(s3, doc => doc.field = 'three')
- assert.deepStrictEqual(s3, {field: 'three'})
- assert.strictEqual(Automerge.getConflicts(s3, 'field'), undefined)
- s2 = Automerge.merge(s2, s3)
- assert.deepStrictEqual(s2, {field: 'three'})
- assert.strictEqual(Automerge.getConflicts(s2, 'field'), undefined)
- })
-
- it('should handle concurrent insertions at different list positions', () => {
- s1 = Automerge.change(s1, doc => doc.list = ['one', 'three'])
- s2 = Automerge.merge(s2, s1)
- s1 = Automerge.change(s1, doc => doc.list.splice(1, 0, 'two'))
- s2 = Automerge.change(s2, doc => doc.list.push('four'))
- s3 = Automerge.merge(s1, s2)
- assert.deepStrictEqual(s3, {list: ['one', 'two', 'three', 'four']})
- assert.strictEqual(Automerge.getConflicts(s3, 'list'), undefined)
- })
-
- it('should handle concurrent insertions at the same list position', () => {
- s1 = Automerge.change(s1, doc => doc.birds = ['parakeet'])
- s2 = Automerge.merge(s2, s1)
- s1 = Automerge.change(s1, doc => doc.birds.push('starling'))
- s2 = Automerge.change(s2, doc => doc.birds.push('chaffinch'))
- s3 = Automerge.merge(s1, s2)
- assertEqualsOneOf(s3.birds, ['parakeet', 'starling', 'chaffinch'], ['parakeet', 'chaffinch', 'starling'])
- s2 = Automerge.merge(s2, s3)
- assert.deepStrictEqual(s2, s3)
- })
-
- it('should handle concurrent assignment and deletion of a map entry', () => {
- // Add-wins semantics
- s1 = Automerge.change(s1, doc => doc.bestBird = 'robin')
- s2 = Automerge.merge(s2, s1)
- s1 = Automerge.change(s1, doc => delete doc.bestBird)
- s2 = Automerge.change(s2, doc => doc.bestBird = 'magpie')
- s3 = Automerge.merge(s1, s2)
- assert.deepStrictEqual(s1, {})
- assert.deepStrictEqual(s2, {bestBird: 'magpie'})
- assert.deepStrictEqual(s3, {bestBird: 'magpie'})
- assert.strictEqual(Automerge.getConflicts(s3, 'bestBird'), undefined)
- })
-
- it('should handle concurrent assignment and deletion of a list element', () => {
- // Concurrent assignment ressurects a deleted list element. Perhaps a little
- // surprising, but consistent with add-wins semantics of maps (see test above)
- s1 = Automerge.change(s1, doc => doc.birds = ['blackbird', 'thrush', 'goldfinch'])
- s2 = Automerge.merge(s2, s1)
- s1 = Automerge.change(s1, doc => doc.birds[1] = 'starling')
- s2 = Automerge.change(s2, doc => doc.birds.splice(1, 1))
- s3 = Automerge.merge(s1, s2)
- assert.deepStrictEqual(s1.birds, ['blackbird', 'starling', 'goldfinch'])
- assert.deepStrictEqual(s2.birds, ['blackbird', 'goldfinch'])
- assert.deepStrictEqual(s3.birds, ['blackbird', 'starling', 'goldfinch'])
- s4 = Automerge.load(Automerge.save(s3))
- assert.deepStrictEqual(s3, s4);
- })
-
- it('should handle insertion after a deleted list element', () => {
- s1 = Automerge.change(s1, doc => doc.birds = ['blackbird', 'thrush', 'goldfinch'])
- s2 = Automerge.merge(s2, s1)
- s1 = Automerge.change(s1, doc => doc.birds.splice(1, 2))
- s2 = Automerge.change(s2, doc => doc.birds.splice(2, 0, 'starling'))
- s3 = Automerge.merge(s1, s2)
- assert.deepStrictEqual(s3, {birds: ['blackbird', 'starling']})
- assert.deepStrictEqual(Automerge.merge(s2, s3), {birds: ['blackbird', 'starling']})
- })
-
- it('should handle concurrent deletion of the same element', () => {
- s1 = Automerge.change(s1, doc => doc.birds = ['albatross', 'buzzard', 'cormorant'])
- s2 = Automerge.merge(s2, s1)
- s1 = Automerge.change(s1, doc => doc.birds.deleteAt(1)) // buzzard
- s2 = Automerge.change(s2, doc => doc.birds.deleteAt(1)) // buzzard
- s3 = Automerge.merge(s1, s2)
- assert.deepStrictEqual(s3.birds, ['albatross', 'cormorant'])
- })
-
- it('should handle concurrent deletion of different elements', () => {
- s1 = Automerge.change(s1, doc => doc.birds = ['albatross', 'buzzard', 'cormorant'])
- s2 = Automerge.merge(s2, s1)
- s1 = Automerge.change(s1, doc => doc.birds.deleteAt(0)) // albatross
- s2 = Automerge.change(s2, doc => doc.birds.deleteAt(1)) // buzzard
- s3 = Automerge.merge(s1, s2)
- assert.deepStrictEqual(s3.birds, ['cormorant'])
- })
-
- it('should handle concurrent updates at different levels of the tree', () => {
- // A delete higher up in the tree overrides an update in a subtree
- s1 = Automerge.change(s1, doc => doc.animals = {birds: {pink: 'flamingo', black: 'starling'}, mammals: ['badger']})
- s2 = Automerge.merge(s2, s1)
- s1 = Automerge.change(s1, doc => doc.animals.birds.brown = 'sparrow')
- s2 = Automerge.change(s2, doc => delete doc.animals.birds)
- s3 = Automerge.merge(s1, s2)
- assert.deepStrictEqual(s1.animals, {
- birds: {
- pink: 'flamingo', brown: 'sparrow', black: 'starling'
- },
- mammals: ['badger']
- })
- assert.deepStrictEqual(s2.animals, {mammals: ['badger']})
- assert.deepStrictEqual(s3.animals, {mammals: ['badger']})
- })
-
- it('should handle updates of concurrently deleted objects', () => {
- s1 = Automerge.change(s1, doc => doc.birds = {blackbird: {feathers: 'black'}})
- s2 = Automerge.merge(s2, s1)
- s1 = Automerge.change(s1, doc => delete doc.birds.blackbird)
- s2 = Automerge.change(s2, doc => doc.birds.blackbird.beak = 'orange')
- s3 = Automerge.merge(s1, s2)
- assert.deepStrictEqual(s1, {birds: {}})
- })
-
- it('should not interleave sequence insertions at the same position', () => {
- s1 = Automerge.change(s1, doc => doc.wisdom = [])
- s2 = Automerge.merge(s2, s1)
- s1 = Automerge.change(s1, doc => doc.wisdom.push('to', 'be', 'is', 'to', 'do'))
- s2 = Automerge.change(s2, doc => doc.wisdom.push('to', 'do', 'is', 'to', 'be'))
- s3 = Automerge.merge(s1, s2)
- assertEqualsOneOf(s3.wisdom,
- ['to', 'be', 'is', 'to', 'do', 'to', 'do', 'is', 'to', 'be'],
- ['to', 'do', 'is', 'to', 'be', 'to', 'be', 'is', 'to', 'do'])
- // In case you're wondering: http://quoteinvestigator.com/2013/09/16/do-be-do/
- })
-
- describe('multiple insertions at the same list position', () => {
- it('should handle insertion by greater actor ID', () => {
- s1 = Automerge.init('aaaa')
- s2 = Automerge.init('bbbb')
- s1 = Automerge.change(s1, doc => doc.list = ['two'])
- s2 = Automerge.merge(s2, s1)
- s2 = Automerge.change(s2, doc => doc.list.splice(0, 0, 'one'))
- assert.deepStrictEqual(s2.list, ['one', 'two'])
- })
-
- it('should handle insertion by lesser actor ID', () => {
- s1 = Automerge.init('bbbb')
- s2 = Automerge.init('aaaa')
- s1 = Automerge.change(s1, doc => doc.list = ['two'])
- s2 = Automerge.merge(s2, s1)
- s2 = Automerge.change(s2, doc => doc.list.splice(0, 0, 'one'))
- assert.deepStrictEqual(s2.list, ['one', 'two'])
- })
-
- it('should handle insertion regardless of actor ID', () => {
- s1 = Automerge.change(s1, doc => doc.list = ['two'])
- s2 = Automerge.merge(s2, s1)
- s2 = Automerge.change(s2, doc => doc.list.splice(0, 0, 'one'))
- assert.deepStrictEqual(s2.list, ['one', 'two'])
- })
-
- it('should make insertion order consistent with causality', () => {
- s1 = Automerge.change(s1, doc => doc.list = ['four'])
- s2 = Automerge.merge(s2, s1)
- s2 = Automerge.change(s2, doc => doc.list.unshift('three'))
- s1 = Automerge.merge(s1, s2)
- s1 = Automerge.change(s1, doc => doc.list.unshift('two'))
- s2 = Automerge.merge(s2, s1)
- s2 = Automerge.change(s2, doc => doc.list.unshift('one'))
- assert.deepStrictEqual(s2.list, ['one', 'two', 'three', 'four'])
- })
- })
- })
-
- describe('saving and loading', () => {
- it('should save and restore an empty document', () => {
- let s = Automerge.load(Automerge.save(Automerge.init()))
- assert.deepStrictEqual(s, {})
- })
-
- it('should generate a new random actor ID', () => {
- let s1 = Automerge.init()
- let s2 = Automerge.load(Automerge.save(s1))
- assert.strictEqual(UUID_PATTERN.test(Automerge.getActorId(s1).toString()), true)
- assert.strictEqual(UUID_PATTERN.test(Automerge.getActorId(s2).toString()), true)
- assert.notEqual(Automerge.getActorId(s1), Automerge.getActorId(s2))
- })
-
- it('should allow a custom actor ID to be set', () => {
- let s = Automerge.load(Automerge.save(Automerge.init()), '333333')
- assert.strictEqual(Automerge.getActorId(s), '333333')
- })
-
- it('should reconstitute complex datatypes', () => {
- let s1 = Automerge.change(Automerge.init(), doc => doc.todos = [{title: 'water plants', done: false}])
- let s2 = Automerge.load(Automerge.save(s1))
- assert.deepStrictEqual(s2, {todos: [{title: 'water plants', done: false}]})
- })
-
- it('should save and load maps with @ symbols in the keys', () => {
- let s1 = Automerge.change(Automerge.init(), doc => doc["123@4567"] = "hello")
- let s2 = Automerge.load(Automerge.save(s1))
- assert.deepStrictEqual(s2, { "123@4567": "hello" })
- })
-
- it('should reconstitute conflicts', () => {
- let s1 = Automerge.change(Automerge.init('111111'), doc => doc.x = 3)
- let s2 = Automerge.change(Automerge.init('222222'), doc => doc.x = 5)
- s1 = Automerge.merge(s1, s2)
- let s3 = Automerge.load(Automerge.save(s1))
- assert.strictEqual(s1.x, 5)
- assert.strictEqual(s3.x, 5)
- assert.deepStrictEqual(Automerge.getConflicts(s1, 'x'), {'1@111111': 3, '1@222222': 5})
- assert.deepStrictEqual(Automerge.getConflicts(s3, 'x'), {'1@111111': 3, '1@222222': 5})
- })
-
- it('should reconstitute element ID counters', () => {
- const s1 = Automerge.init('01234567')
- const s2 = Automerge.change(s1, doc => doc.list = ['a'])
- const listId = Automerge.getObjectId(s2.list)
- const changes12 = Automerge.getAllChanges(s2).map(decodeChange)
- assert.deepStrictEqual(changes12, [{
- hash: changes12[0].hash, actor: '01234567', seq: 1, startOp: 1,
- time: changes12[0].time, message: '', deps: [], ops: [
- {obj: '_root', action: 'makeList', key: 'list', insert: false, pred: []},
- {obj: listId, action: 'set', elemId: '_head', insert: true, value: 'a', pred: []}
- ]
- }])
- const s3 = Automerge.change(s2, doc => doc.list.deleteAt(0))
- const s4 = Automerge.load(Automerge.save(s3), '01234567')
- const s5 = Automerge.change(s4, doc => doc.list.push('b'))
- const changes45 = Automerge.getAllChanges(s5).map(decodeChange)
- assert.deepStrictEqual(s5, {list: ['b']})
- assert.deepStrictEqual(changes45[2], {
- hash: changes45[2].hash, actor: '01234567', seq: 3, startOp: 4,
- time: changes45[2].time, message: '', deps: [changes45[1].hash], ops: [
- {obj: listId, action: 'set', elemId: '_head', insert: true, value: 'b', pred: []}
- ]
- })
- })
-
- it('should allow a reloaded list to be mutated', () => {
- let doc = Automerge.change(Automerge.init(), doc => doc.foo = [])
- doc = Automerge.load(Automerge.save(doc))
- doc = Automerge.change(doc, 'add', doc => doc.foo.push(1))
- doc = Automerge.load(Automerge.save(doc))
- assert.deepStrictEqual(doc.foo, [1])
- })
-
- it('should reload a document containing deflated columns', () => {
- // In this test, the keyCtr column is long enough for deflate compression to kick in, but the
- // keyStr column is short. Thus, the deflate bit gets set for keyCtr but not for keyStr.
- // When checking whether the columns appear in ascending order, we must ignore the deflate bit.
- let doc = Automerge.change(Automerge.init(), doc => {
- doc.list = []
- for (let i = 0; i < 200; i++) doc.list.insertAt(Math.floor(Math.random() * i), 'a')
- })
- Automerge.load(Automerge.save(doc))
- let expected = []
- for (let i = 0; i < 200; i++) expected.push('a')
- assert.deepStrictEqual(doc, {list: expected})
- })
-
- /*
- it.skip('should call patchCallback if supplied', () => {
- const s1 = Automerge.change(Automerge.init(), doc => doc.birds = ['Goldfinch'])
- const s2 = Automerge.change(s1, doc => doc.birds.push('Chaffinch'))
- const callbacks = [], actor = Automerge.getActorId(s1)
- const reloaded = Automerge.load(Automerge.save(s2), {
- patchCallback(patch, before, after, local) {
- callbacks.push({patch, before, after, local})
- }
- })
- assert.strictEqual(callbacks.length, 1)
- assert.deepStrictEqual(callbacks[0].patch, {
- maxOp: 3, deps: [decodeChange(Automerge.getAllChanges(s2)[1]).hash], clock: {[actor]: 2}, pendingChanges: 0,
- diffs: {objectId: '_root', type: 'map', props: {birds: {[`1@${actor}`]: {
- objectId: `1@${actor}`, type: 'list', edits: [
- {action: 'multi-insert', index: 0, elemId: `2@${actor}`, values: ['Goldfinch', 'Chaffinch']}
- ]
- }}}}
- })
- assert.deepStrictEqual(callbacks[0].before, {})
- assert.strictEqual(callbacks[0].after, reloaded)
- assert.strictEqual(callbacks[0].local, false)
- })
- */
- })
-
- describe('history API', () => {
- it('should return an empty history for an empty document', () => {
- assert.deepStrictEqual(Automerge.getHistory(Automerge.init()), [])
- })
-
- it('should make past document states accessible', () => {
- let s = Automerge.init()
- s = Automerge.change(s, doc => doc.config = {background: 'blue'})
- s = Automerge.change(s, doc => doc.birds = ['mallard'])
- s = Automerge.change(s, doc => doc.birds.unshift('oystercatcher'))
- assert.deepStrictEqual(Automerge.getHistory(s).map(state => state.snapshot), [
- {config: {background: 'blue'}},
- {config: {background: 'blue'}, birds: ['mallard']},
- {config: {background: 'blue'}, birds: ['oystercatcher', 'mallard']}
- ])
- })
-
- it('should make change messages accessible', () => {
- let s = Automerge.init()
- s = Automerge.change(s, 'Empty Bookshelf', doc => doc.books = [])
- s = Automerge.change(s, 'Add Orwell', doc => doc.books.push('Nineteen Eighty-Four'))
- s = Automerge.change(s, 'Add Huxley', doc => doc.books.push('Brave New World'))
- assert.deepStrictEqual(s.books, ['Nineteen Eighty-Four', 'Brave New World'])
- assert.deepStrictEqual(Automerge.getHistory(s).map(state => state.change.message),
- ['Empty Bookshelf', 'Add Orwell', 'Add Huxley'])
- })
- })
-
- describe('changes API', () => {
- it('should return an empty list on an empty document', () => {
- let changes = Automerge.getAllChanges(Automerge.init())
- assert.deepStrictEqual(changes, [])
- })
-
- it('should return an empty list when nothing changed', () => {
- let s1 = Automerge.change(Automerge.init(), doc => doc.birds = ['Chaffinch'])
- assert.deepStrictEqual(Automerge.getChanges(s1, s1), [])
- })
-
- it('should do nothing when applying an empty list of changes', () => {
- let s1 = Automerge.change(Automerge.init(), doc => doc.birds = ['Chaffinch'])
- assert.deepStrictEqual(Automerge.applyChanges(s1, [])[0], s1)
- })
-
- it('should return all changes when compared to an empty document', () => {
- let s1 = Automerge.change(Automerge.init(), 'Add Chaffinch', doc => doc.birds = ['Chaffinch'])
- let s2 = Automerge.change(s1, 'Add Bullfinch', doc => doc.birds.push('Bullfinch'))
- let changes = Automerge.getChanges(Automerge.init(), s2)
- assert.strictEqual(changes.length, 2)
- })
-
- it('should allow a document copy to be reconstructed from scratch', () => {
- let s1 = Automerge.change(Automerge.init(), 'Add Chaffinch', doc => doc.birds = ['Chaffinch'])
- let s2 = Automerge.change(s1, 'Add Bullfinch', doc => doc.birds.push('Bullfinch'))
- let changes = Automerge.getAllChanges(s2)
- let [s3] = Automerge.applyChanges(Automerge.init(), changes)
- assert.deepStrictEqual(s3.birds, ['Chaffinch', 'Bullfinch'])
- })
-
- it('should return changes since the last given version', () => {
- let s1 = Automerge.change(Automerge.init(), 'Add Chaffinch', doc => doc.birds = ['Chaffinch'])
- let changes1 = Automerge.getAllChanges(s1)
- let s2 = Automerge.change(s1, 'Add Bullfinch', doc => doc.birds.push('Bullfinch'))
- let changes2 = Automerge.getChanges(s1, s2)
- assert.strictEqual(changes1.length, 1) // Add Chaffinch
- assert.strictEqual(changes2.length, 1) // Add Bullfinch
- })
-
- it('should incrementally apply changes since the last given version', () => {
- let s1 = Automerge.change(Automerge.init(), 'Add Chaffinch', doc => doc.birds = ['Chaffinch'])
- let changes1 = Automerge.getAllChanges(s1)
- let s2 = Automerge.change(s1, 'Add Bullfinch', doc => doc.birds.push('Bullfinch'))
- let changes2 = Automerge.getChanges(s1, s2)
- let [s3] = Automerge.applyChanges(Automerge.init(), changes1)
- let [s4] = Automerge.applyChanges(s3, changes2)
- assert.deepStrictEqual(s3.birds, ['Chaffinch'])
- assert.deepStrictEqual(s4.birds, ['Chaffinch', 'Bullfinch'])
- })
-
- it('should handle updates to a list element', () => {
- let s1 = Automerge.change(Automerge.init(), doc => doc.birds = ['Chaffinch', 'Bullfinch'])
- let s2 = Automerge.change(s1, doc => doc.birds[0] = 'Goldfinch')
- let [s3] = Automerge.applyChanges(Automerge.init(), Automerge.getAllChanges(s2))
- assert.deepStrictEqual(s3.birds, ['Goldfinch', 'Bullfinch'])
- assert.strictEqual(Automerge.getConflicts(s3.birds, 0), undefined)
- })
-
- // TEXT
- it('should handle updates to a text object', () => {
- let s1 = Automerge.change(Automerge.init(), doc => doc.text = new Automerge.Text('ab'))
- let s2 = Automerge.change(s1, doc => doc.text.set(0, 'A'))
- let [s3] = Automerge.applyChanges(Automerge.init(), Automerge.getAllChanges(s2))
- assert.deepStrictEqual([...s3.text], ['A', 'b'])
- })
-
- /*
- it.skip('should report missing dependencies', () => {
- let s1 = Automerge.change(Automerge.init(), doc => doc.birds = ['Chaffinch'])
- let s2 = Automerge.merge(Automerge.init(), s1)
- s2 = Automerge.change(s2, doc => doc.birds.push('Bullfinch'))
- let changes = Automerge.getAllChanges(s2)
- let [s3, patch] = Automerge.applyChanges(Automerge.init(), [changes[1]])
- assert.deepStrictEqual(s3, {})
- assert.deepStrictEqual(Automerge.Backend.getMissingDeps(Automerge.Frontend.getBackendState(s3)),
- decodeChange(changes[1]).deps)
- assert.strictEqual(patch.pendingChanges, 1)
- ;[s3, patch] = Automerge.applyChanges(s3, [changes[0]])
- assert.deepStrictEqual(s3.birds, ['Chaffinch', 'Bullfinch'])
- assert.deepStrictEqual(Automerge.Backend.getMissingDeps(Automerge.Frontend.getBackendState(s3)), [])
- assert.strictEqual(patch.pendingChanges, 0)
- })
- */
-
- it('should report missing dependencies with out-of-order applyChanges', () => {
- let s0 = Automerge.init()
- let s1 = Automerge.change(s0, doc => doc.test = ['a'])
- let changes01 = Automerge.getAllChanges(s1)
- let s2 = Automerge.change(s1, doc => doc.test = ['b'])
- let changes12 = Automerge.getChanges(s1, s2)
- let s3 = Automerge.change(s2, doc => doc.test = ['c'])
- let changes23 = Automerge.getChanges(s2, s3)
- let s4 = Automerge.init()
- let [s5] = Automerge.applyChanges(s4, changes23)
- let [s6] = Automerge.applyChanges(s5, changes12)
-// assert.deepStrictEqual(Automerge.Backend.getMissingDeps(Automerge.Frontend.getBackendState(s6)), [decodeChange(changes01[0]).hash])
- assert.deepStrictEqual(Automerge.getMissingDeps(s6), [decodeChange(changes01[0]).hash])
- })
-
- /*
- it.skip('should call patchCallback if supplied when applying changes', () => {
- const s1 = Automerge.change(Automerge.init(), doc => doc.birds = ['Goldfinch'])
- const callbacks = [], actor = Automerge.getActorId(s1)
- const before = Automerge.init()
- const [after, patch] = Automerge.applyChanges(before, Automerge.getAllChanges(s1), {
- patchCallback(patch, before, after, local) {
- callbacks.push({patch, before, after, local})
- }
- })
- assert.strictEqual(callbacks.length, 1)
- assert.deepStrictEqual(callbacks[0].patch, {
- maxOp: 2, deps: [decodeChange(Automerge.getAllChanges(s1)[0]).hash], clock: {[actor]: 1}, pendingChanges: 0,
- diffs: {objectId: '_root', type: 'map', props: {birds: {[`1@${actor}`]: {
- objectId: `1@${actor}`, type: 'list', edits: [
- {action: 'insert', index: 0, elemId: `2@${actor}`, opId: `2@${actor}`, value: {type: 'value', value: 'Goldfinch'}}
- ]
- }}}}
- })
- assert.strictEqual(callbacks[0].patch, patch)
- assert.strictEqual(callbacks[0].before, before)
- assert.strictEqual(callbacks[0].after, after)
- assert.strictEqual(callbacks[0].local, false)
- })
- */
-
- /*
- it.skip('should merge multiple applied changes into one patch', () => {
- const s1 = Automerge.change(Automerge.init(), doc => doc.birds = ['Goldfinch'])
- const s2 = Automerge.change(s1, doc => doc.birds.push('Chaffinch'))
- const patches = [], actor = Automerge.getActorId(s2)
- Automerge.applyChanges(Automerge.init(), Automerge.getAllChanges(s2),
- {patchCallback: p => patches.push(p)})
- assert.deepStrictEqual(patches, [{
- maxOp: 3, deps: [decodeChange(Automerge.getAllChanges(s2)[1]).hash], clock: {[actor]: 2}, pendingChanges: 0,
- diffs: {objectId: '_root', type: 'map', props: {birds: {[`1@${actor}`]: {
- objectId: `1@${actor}`, type: 'list', edits: [
- {action: 'multi-insert', index: 0, elemId: `2@${actor}`, values: ['Goldfinch', 'Chaffinch']}
- ]
- }}}}
- }])
- })
- */
-
- /*
- it.skip('should call a patchCallback registered on doc initialisation', () => {
- const s1 = Automerge.change(Automerge.init(), doc => doc.bird = 'Goldfinch')
- const patches = [], actor = Automerge.getActorId(s1)
- const before = Automerge.init({patchCallback: p => patches.push(p)})
- Automerge.applyChanges(before, Automerge.getAllChanges(s1))
- assert.deepStrictEqual(patches, [{
- maxOp: 1, deps: [decodeChange(Automerge.getAllChanges(s1)[0]).hash], clock: {[actor]: 1}, pendingChanges: 0,
- diffs: {objectId: '_root', type: 'map', props: {bird: {[`1@${actor}`]: {type: 'value', value: 'Goldfinch'}}}}
- }])
- })
- */
- })
-})
diff --git a/automerge-js/test/text_test.js b/automerge-js/test/text_test.js
deleted file mode 100644
index 57e8884e..00000000
--- a/automerge-js/test/text_test.js
+++ /dev/null
@@ -1,697 +0,0 @@
-const assert = require('assert')
-const Automerge = require('..')
-const { assertEqualsOneOf } = require('./helpers')
-
-function attributeStateToAttributes(accumulatedAttributes) {
- const attributes = {}
- Object.entries(accumulatedAttributes).forEach(([key, values]) => {
- if (values.length && values[0] !== null) {
- attributes[key] = values[0]
- }
- })
- return attributes
-}
-
-function isEquivalent(a, b) {
- const aProps = Object.getOwnPropertyNames(a)
- const bProps = Object.getOwnPropertyNames(b)
-
- if (aProps.length != bProps.length) {
- return false
- }
-
- for (let i = 0; i < aProps.length; i++) {
- const propName = aProps[i]
- if (a[propName] !== b[propName]) {
- return false
- }
- }
-
- return true
-}
-
-function isControlMarker(pseudoCharacter) {
- return typeof pseudoCharacter === 'object' && pseudoCharacter.attributes
-}
-
-function opFrom(text, attributes) {
- let op = { insert: text }
- if (Object.keys(attributes).length > 0) {
- op.attributes = attributes
- }
- return op
-}
-
-function accumulateAttributes(span, accumulatedAttributes) {
- Object.entries(span).forEach(([key, value]) => {
- if (!accumulatedAttributes[key]) {
- accumulatedAttributes[key] = []
- }
- if (value === null) {
- if (accumulatedAttributes[key].length === 0 || accumulatedAttributes[key] === null) {
- accumulatedAttributes[key].unshift(null)
- } else {
- accumulatedAttributes[key].shift()
- }
- } else {
- if (accumulatedAttributes[key][0] === null) {
- accumulatedAttributes[key].shift()
- } else {
- accumulatedAttributes[key].unshift(value)
- }
- }
- })
- return accumulatedAttributes
-}
-
-function automergeTextToDeltaDoc(text) {
- let ops = []
- let controlState = {}
- let currentString = ""
- let attributes = {}
- text.toSpans().forEach((span) => {
- if (isControlMarker(span)) {
- controlState = accumulateAttributes(span.attributes, controlState)
- } else {
- let next = attributeStateToAttributes(controlState)
-
- // if the next span has the same calculated attributes as the current span
- // don't bother outputting it as a separate span, just let it ride
- if (typeof span === 'string' && isEquivalent(next, attributes)) {
- currentString = currentString + span
- return
- }
-
- if (currentString) {
- ops.push(opFrom(currentString, attributes))
- }
-
- // If we've got a string, we might be able to concatenate it to another
- // same-attributed-string, so remember it and go to the next iteration.
- if (typeof span === 'string') {
- currentString = span
- attributes = next
- } else {
- // otherwise we have an embed "character" and should output it immediately.
- // embeds are always one-"character" in length.
- ops.push(opFrom(span, next))
- currentString = ''
- attributes = {}
- }
- }
- })
-
- // at the end, flush any accumulated string out
- if (currentString) {
- ops.push(opFrom(currentString, attributes))
- }
-
- return ops
-}
-
-function inverseAttributes(attributes) {
- let invertedAttributes = {}
- Object.keys(attributes).forEach((key) => {
- invertedAttributes[key] = null
- })
- return invertedAttributes
-}
-
-function applyDeleteOp(text, offset, op) {
- let length = op.delete
- while (length > 0) {
- if (isControlMarker(text.get(offset))) {
- offset += 1
- } else {
- // we need to not delete control characters, but we do delete embed characters
- text.deleteAt(offset, 1)
- length -= 1
- }
- }
- return [text, offset]
-}
-
-function applyRetainOp(text, offset, op) {
- let length = op.retain
-
- if (op.attributes) {
- text.insertAt(offset, { attributes: op.attributes })
- offset += 1
- }
-
- while (length > 0) {
- const char = text.get(offset)
- offset += 1
- if (!isControlMarker(char)) {
- length -= 1
- }
- }
-
- if (op.attributes) {
- text.insertAt(offset, { attributes: inverseAttributes(op.attributes) })
- offset += 1
- }
-
- return [text, offset]
-}
-
-
-function applyInsertOp(text, offset, op) {
- let originalOffset = offset
-
- if (typeof op.insert === 'string') {
- text.insertAt(offset, ...op.insert.split(''))
- offset += op.insert.length
- } else {
- // we have an embed or something similar
- text.insertAt(offset, op.insert)
- offset += 1
- }
-
- if (op.attributes) {
- text.insertAt(originalOffset, { attributes: op.attributes })
- offset += 1
- }
- if (op.attributes) {
- text.insertAt(offset, { attributes: inverseAttributes(op.attributes) })
- offset += 1
- }
- return [text, offset]
-}
-
-// XXX: uhhhhh, why can't I pass in text?
-function applyDeltaDocToAutomergeText(delta, doc) {
- let offset = 0
-
- delta.forEach(op => {
- if (op.retain) {
- [, offset] = applyRetainOp(doc.text, offset, op)
- } else if (op.delete) {
- [, offset] = applyDeleteOp(doc.text, offset, op)
- } else if (op.insert) {
- [, offset] = applyInsertOp(doc.text, offset, op)
- }
- })
-}
-
-describe('Automerge.Text', () => {
- let s1, s2
- beforeEach(() => {
- s1 = Automerge.change(Automerge.init(), doc => doc.text = new Automerge.Text())
- s2 = Automerge.merge(Automerge.init(), s1)
- })
-
- it('should support insertion', () => {
- s1 = Automerge.change(s1, doc => doc.text.insertAt(0, 'a'))
- assert.strictEqual(s1.text.length, 1)
- assert.strictEqual(s1.text.get(0), 'a')
- assert.strictEqual(s1.text.toString(), 'a')
- //assert.strictEqual(s1.text.getElemId(0), `2@${Automerge.getActorId(s1)}`)
- })
-
- it('should support deletion', () => {
- s1 = Automerge.change(s1, doc => doc.text.insertAt(0, 'a', 'b', 'c'))
- s1 = Automerge.change(s1, doc => doc.text.deleteAt(1, 1))
- assert.strictEqual(s1.text.length, 2)
- assert.strictEqual(s1.text.get(0), 'a')
- assert.strictEqual(s1.text.get(1), 'c')
- assert.strictEqual(s1.text.toString(), 'ac')
- })
-
- it("should support implicit and explicit deletion", () => {
- s1 = Automerge.change(s1, doc => doc.text.insertAt(0, "a", "b", "c"))
- s1 = Automerge.change(s1, doc => doc.text.deleteAt(1))
- s1 = Automerge.change(s1, doc => doc.text.deleteAt(1, 0))
- assert.strictEqual(s1.text.length, 2)
- assert.strictEqual(s1.text.get(0), "a")
- assert.strictEqual(s1.text.get(1), "c")
- assert.strictEqual(s1.text.toString(), "ac")
- })
-
- it('should handle concurrent insertion', () => {
- s1 = Automerge.change(s1, doc => doc.text.insertAt(0, 'a', 'b', 'c'))
- s2 = Automerge.change(s2, doc => doc.text.insertAt(0, 'x', 'y', 'z'))
- s1 = Automerge.merge(s1, s2)
- assert.strictEqual(s1.text.length, 6)
- assertEqualsOneOf(s1.text.toString(), 'abcxyz', 'xyzabc')
- assertEqualsOneOf(s1.text.join(''), 'abcxyz', 'xyzabc')
- })
-
- it('should handle text and other ops in the same change', () => {
- s1 = Automerge.change(s1, doc => {
- doc.foo = 'bar'
- doc.text.insertAt(0, 'a')
- })
- assert.strictEqual(s1.foo, 'bar')
- assert.strictEqual(s1.text.toString(), 'a')
- assert.strictEqual(s1.text.join(''), 'a')
- })
-
- it('should serialize to JSON as a simple string', () => {
- s1 = Automerge.change(s1, doc => doc.text.insertAt(0, 'a', '"', 'b'))
- assert.strictEqual(JSON.stringify(s1), '{"text":"a\\"b"}')
- })
-
- it('should allow modification before an object is assigned to a document', () => {
- s1 = Automerge.change(Automerge.init(), doc => {
- const text = new Automerge.Text()
- text.insertAt(0, 'a', 'b', 'c', 'd')
- text.deleteAt(2)
- doc.text = text
- assert.strictEqual(doc.text.toString(), 'abd')
- assert.strictEqual(doc.text.join(''), 'abd')
- })
- assert.strictEqual(s1.text.toString(), 'abd')
- assert.strictEqual(s1.text.join(''), 'abd')
- })
-
- it('should allow modification after an object is assigned to a document', () => {
- s1 = Automerge.change(Automerge.init(), doc => {
- const text = new Automerge.Text()
- doc.text = text
- doc.text.insertAt(0, 'a', 'b', 'c', 'd')
- doc.text.deleteAt(2)
- assert.strictEqual(doc.text.toString(), 'abd')
- assert.strictEqual(doc.text.join(''), 'abd')
- })
- assert.strictEqual(s1.text.join(''), 'abd')
- })
-
- it('should not allow modification outside of a change callback', () => {
- assert.throws(() => s1.text.insertAt(0, 'a'), /object cannot be modified outside of a change block/)
- })
-
- describe('with initial value', () => {
- it('should accept a string as initial value', () => {
- let s1 = Automerge.change(Automerge.init(), doc => doc.text = new Automerge.Text('init'))
- assert.strictEqual(s1.text.length, 4)
- assert.strictEqual(s1.text.get(0), 'i')
- assert.strictEqual(s1.text.get(1), 'n')
- assert.strictEqual(s1.text.get(2), 'i')
- assert.strictEqual(s1.text.get(3), 't')
- assert.strictEqual(s1.text.toString(), 'init')
- })
-
- it('should accept an array as initial value', () => {
- let s1 = Automerge.change(Automerge.init(), doc => doc.text = new Automerge.Text(['i', 'n', 'i', 't']))
- assert.strictEqual(s1.text.length, 4)
- assert.strictEqual(s1.text.get(0), 'i')
- assert.strictEqual(s1.text.get(1), 'n')
- assert.strictEqual(s1.text.get(2), 'i')
- assert.strictEqual(s1.text.get(3), 't')
- assert.strictEqual(s1.text.toString(), 'init')
- })
-
- it('should initialize text in Automerge.from()', () => {
- let s1 = Automerge.from({text: new Automerge.Text('init')})
- assert.strictEqual(s1.text.length, 4)
- assert.strictEqual(s1.text.get(0), 'i')
- assert.strictEqual(s1.text.get(1), 'n')
- assert.strictEqual(s1.text.get(2), 'i')
- assert.strictEqual(s1.text.get(3), 't')
- assert.strictEqual(s1.text.toString(), 'init')
- })
-
- it('should encode the initial value as a change', () => {
- const s1 = Automerge.from({text: new Automerge.Text('init')})
- const changes = Automerge.getAllChanges(s1)
- assert.strictEqual(changes.length, 1)
- const [s2] = Automerge.applyChanges(Automerge.init(), changes)
- assert.strictEqual(s2.text instanceof Automerge.Text, true)
- assert.strictEqual(s2.text.toString(), 'init')
- assert.strictEqual(s2.text.join(''), 'init')
- })
-
- it('should allow immediate access to the value', () => {
- Automerge.change(Automerge.init(), doc => {
- const text = new Automerge.Text('init')
- assert.strictEqual(text.length, 4)
- assert.strictEqual(text.get(0), 'i')
- assert.strictEqual(text.toString(), 'init')
- doc.text = text
- assert.strictEqual(doc.text.length, 4)
- assert.strictEqual(doc.text.get(0), 'i')
- assert.strictEqual(doc.text.toString(), 'init')
- })
- })
-
- it('should allow pre-assignment modification of the initial value', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- const text = new Automerge.Text('init')
- text.deleteAt(3)
- assert.strictEqual(text.join(''), 'ini')
- doc.text = text
- assert.strictEqual(doc.text.join(''), 'ini')
- assert.strictEqual(doc.text.toString(), 'ini')
- })
- assert.strictEqual(s1.text.toString(), 'ini')
- assert.strictEqual(s1.text.join(''), 'ini')
- })
-
- it('should allow post-assignment modification of the initial value', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- const text = new Automerge.Text('init')
- doc.text = text
- doc.text.deleteAt(0)
- doc.text.insertAt(0, 'I')
- assert.strictEqual(doc.text.join(''), 'Init')
- assert.strictEqual(doc.text.toString(), 'Init')
- })
- assert.strictEqual(s1.text.join(''), 'Init')
- assert.strictEqual(s1.text.toString(), 'Init')
- })
- })
-
- describe('non-textual control characters', () => {
- let s1
- beforeEach(() => {
- s1 = Automerge.change(Automerge.init(), doc => {
- doc.text = new Automerge.Text()
- doc.text.insertAt(0, 'a')
- doc.text.insertAt(1, { attribute: 'bold' })
- })
- })
-
- it('should allow fetching non-textual characters', () => {
- assert.deepEqual(s1.text.get(1), { attribute: 'bold' })
- //assert.strictEqual(s1.text.getElemId(1), `3@${Automerge.getActorId(s1)}`)
- })
-
- it('should include control characters in string length', () => {
- assert.strictEqual(s1.text.length, 2)
- assert.strictEqual(s1.text.get(0), 'a')
- })
-
- it('should exclude control characters from toString()', () => {
- assert.strictEqual(s1.text.toString(), 'a')
- })
-
- it('should allow control characters to be updated', () => {
- const s2 = Automerge.change(s1, doc => doc.text.get(1).attribute = 'italic')
- const s3 = Automerge.load(Automerge.save(s2))
- assert.strictEqual(s1.text.get(1).attribute, 'bold')
- assert.strictEqual(s2.text.get(1).attribute, 'italic')
- assert.strictEqual(s3.text.get(1).attribute, 'italic')
- })
-
- describe('spans interface to Text', () => {
- it('should return a simple string as a single span', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- doc.text = new Automerge.Text('hello world')
- })
- assert.deepEqual(s1.text.toSpans(), ['hello world'])
- })
- it('should return an empty string as an empty array', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- doc.text = new Automerge.Text()
- })
- assert.deepEqual(s1.text.toSpans(), [])
- })
- it('should split a span at a control character', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- doc.text = new Automerge.Text('hello world')
- doc.text.insertAt(5, { attributes: { bold: true } })
- })
- assert.deepEqual(s1.text.toSpans(),
- ['hello', { attributes: { bold: true } }, ' world'])
- })
- it('should allow consecutive control characters', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- doc.text = new Automerge.Text('hello world')
- doc.text.insertAt(5, { attributes: { bold: true } })
- doc.text.insertAt(6, { attributes: { italic: true } })
- })
- assert.deepEqual(s1.text.toSpans(),
- ['hello',
- { attributes: { bold: true } },
- { attributes: { italic: true } },
- ' world'
- ])
- })
- it('should allow non-consecutive control characters', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- doc.text = new Automerge.Text('hello world')
- doc.text.insertAt(5, { attributes: { bold: true } })
- doc.text.insertAt(12, { attributes: { italic: true } })
- })
- assert.deepEqual(s1.text.toSpans(),
- ['hello',
- { attributes: { bold: true } },
- ' world',
- { attributes: { italic: true } }
- ])
- })
-
- it('should be convertable into a Quill delta', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- doc.text = new Automerge.Text('Gandalf the Grey')
- doc.text.insertAt(0, { attributes: { bold: true } })
- doc.text.insertAt(7 + 1, { attributes: { bold: null } })
- doc.text.insertAt(12 + 2, { attributes: { color: '#cccccc' } })
- })
-
- let deltaDoc = automergeTextToDeltaDoc(s1.text)
-
- // From https://quilljs.com/docs/delta/
- let expectedDoc = [
- { insert: 'Gandalf', attributes: { bold: true } },
- { insert: ' the ' },
- { insert: 'Grey', attributes: { color: '#cccccc' } }
- ]
-
- assert.deepEqual(deltaDoc, expectedDoc)
- })
-
- it('should support embeds', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- doc.text = new Automerge.Text('')
- doc.text.insertAt(0, { attributes: { link: 'https://quilljs.com' } })
- doc.text.insertAt(1, {
- image: 'https://quilljs.com/assets/images/icon.png'
- })
- doc.text.insertAt(2, { attributes: { link: null } })
- })
-
- let deltaDoc = automergeTextToDeltaDoc(s1.text)
-
- // From https://quilljs.com/docs/delta/
- let expectedDoc = [{
- // An image link
- insert: {
- image: 'https://quilljs.com/assets/images/icon.png'
- },
- attributes: {
- link: 'https://quilljs.com'
- }
- }]
-
- assert.deepEqual(deltaDoc, expectedDoc)
- })
-
- it('should handle concurrent overlapping spans', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- doc.text = new Automerge.Text('Gandalf the Grey')
- })
-
- let s2 = Automerge.merge(Automerge.init(), s1)
-
- let s3 = Automerge.change(s1, doc => {
- doc.text.insertAt(8, { attributes: { bold: true } })
- doc.text.insertAt(16 + 1, { attributes: { bold: null } })
- })
-
- let s4 = Automerge.change(s2, doc => {
- doc.text.insertAt(0, { attributes: { bold: true } })
- doc.text.insertAt(11 + 1, { attributes: { bold: null } })
- })
-
- let merged = Automerge.merge(s3, s4)
-
- let deltaDoc = automergeTextToDeltaDoc(merged.text)
-
- // From https://quilljs.com/docs/delta/
- let expectedDoc = [
- { insert: 'Gandalf the Grey', attributes: { bold: true } },
- ]
-
- assert.deepEqual(deltaDoc, expectedDoc)
- })
-
- it('should handle debolding spans', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- doc.text = new Automerge.Text('Gandalf the Grey')
- })
-
- let s2 = Automerge.merge(Automerge.init(), s1)
-
- let s3 = Automerge.change(s1, doc => {
- doc.text.insertAt(0, { attributes: { bold: true } })
- doc.text.insertAt(16 + 1, { attributes: { bold: null } })
- })
-
- let s4 = Automerge.change(s2, doc => {
- doc.text.insertAt(8, { attributes: { bold: null } })
- doc.text.insertAt(11 + 1, { attributes: { bold: true } })
- })
-
-
- let merged = Automerge.merge(s3, s4)
-
- let deltaDoc = automergeTextToDeltaDoc(merged.text)
-
- // From https://quilljs.com/docs/delta/
- let expectedDoc = [
- { insert: 'Gandalf ', attributes: { bold: true } },
- { insert: 'the' },
- { insert: ' Grey', attributes: { bold: true } },
- ]
-
- assert.deepEqual(deltaDoc, expectedDoc)
- })
-
- // xxx: how would this work for colors?
- it('should handle destyling across destyled spans', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- doc.text = new Automerge.Text('Gandalf the Grey')
- })
-
- let s2 = Automerge.merge(Automerge.init(), s1)
-
- let s3 = Automerge.change(s1, doc => {
- doc.text.insertAt(0, { attributes: { bold: true } })
- doc.text.insertAt(16 + 1, { attributes: { bold: null } })
- })
-
- let s4 = Automerge.change(s2, doc => {
- doc.text.insertAt(8, { attributes: { bold: null } })
- doc.text.insertAt(11 + 1, { attributes: { bold: true } })
- })
-
- let merged = Automerge.merge(s3, s4)
-
- let final = Automerge.change(merged, doc => {
- doc.text.insertAt(3 + 1, { attributes: { bold: null } })
- doc.text.insertAt(doc.text.length, { attributes: { bold: true } })
- })
-
- let deltaDoc = automergeTextToDeltaDoc(final.text)
-
- // From https://quilljs.com/docs/delta/
- let expectedDoc = [
- { insert: 'Gan', attributes: { bold: true } },
- { insert: 'dalf the Grey' },
- ]
-
- assert.deepEqual(deltaDoc, expectedDoc)
- })
-
- it('should apply an insert', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- doc.text = new Automerge.Text('Hello world')
- })
-
- const delta = [
- { retain: 6 },
- { insert: 'reader' },
- { delete: 5 }
- ]
-
- let s2 = Automerge.change(s1, doc => {
- applyDeltaDocToAutomergeText(delta, doc)
- })
-
- assert.strictEqual(s2.text.join(''), 'Hello reader')
- })
-
- it('should apply an insert with control characters', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- doc.text = new Automerge.Text('Hello world')
- })
-
- const delta = [
- { retain: 6 },
- { insert: 'reader', attributes: { bold: true } },
- { delete: 5 },
- { insert: '!' }
- ]
-
- let s2 = Automerge.change(s1, doc => {
- applyDeltaDocToAutomergeText(delta, doc)
- })
-
- assert.strictEqual(s2.text.toString(), 'Hello reader!')
- assert.deepEqual(s2.text.toSpans(), [
- "Hello ",
- { attributes: { bold: true } },
- "reader",
- { attributes: { bold: null } },
- "!"
- ])
- })
-
- it('should account for control characters in retain/delete lengths', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- doc.text = new Automerge.Text('Hello world')
- doc.text.insertAt(4, { attributes: { color: '#ccc' } })
- doc.text.insertAt(10, { attributes: { color: '#f00' } })
- })
-
- const delta = [
- { retain: 6 },
- { insert: 'reader', attributes: { bold: true } },
- { delete: 5 },
- { insert: '!' }
- ]
-
- let s2 = Automerge.change(s1, doc => {
- applyDeltaDocToAutomergeText(delta, doc)
- })
-
- assert.strictEqual(s2.text.toString(), 'Hello reader!')
- assert.deepEqual(s2.text.toSpans(), [
- "Hell",
- { attributes: { color: '#ccc'} },
- "o ",
- { attributes: { bold: true } },
- "reader",
- { attributes: { bold: null } },
- { attributes: { color: '#f00'} },
- "!"
- ])
- })
-
- it('should support embeds', () => {
- let s1 = Automerge.change(Automerge.init(), doc => {
- doc.text = new Automerge.Text('')
- })
-
- let deltaDoc = [{
- // An image link
- insert: {
- image: 'https://quilljs.com/assets/images/icon.png'
- },
- attributes: {
- link: 'https://quilljs.com'
- }
- }]
-
- let s2 = Automerge.change(s1, doc => {
- applyDeltaDocToAutomergeText(deltaDoc, doc)
- })
-
- assert.deepEqual(s2.text.toSpans(), [
- { attributes: { link: 'https://quilljs.com' } },
- { image: 'https://quilljs.com/assets/images/icon.png'},
- { attributes: { link: null } },
- ])
- })
- })
- })
-
- it('should support unicode when creating text', () => {
- s1 = Automerge.from({
- text: new Automerge.Text('🐦')
- })
- assert.strictEqual(s1.text.get(0), '🐦')
- })
-})
diff --git a/automerge-js/test/uuid_test.js b/automerge-js/test/uuid_test.js
deleted file mode 100644
index a0f83df1..00000000
--- a/automerge-js/test/uuid_test.js
+++ /dev/null
@@ -1,32 +0,0 @@
-const assert = require('assert')
-const Automerge = require('..')
-
-const uuid = Automerge.uuid
-
-describe('uuid', () => {
- afterEach(() => {
- uuid.reset()
- })
-
- describe('default implementation', () => {
- it('generates unique values', () => {
- assert.notEqual(uuid(), uuid())
- })
- })
-
- describe('custom implementation', () => {
- let counter
-
- function customUuid() {
- return `custom-uuid-${counter++}`
- }
-
- before(() => uuid.setFactory(customUuid))
- beforeEach(() => counter = 0)
-
- it('invokes the custom factory', () => {
- assert.equal(uuid(), 'custom-uuid-0')
- assert.equal(uuid(), 'custom-uuid-1')
- })
- })
-})
diff --git a/automerge-wasm/README.md b/automerge-wasm/README.md
deleted file mode 100644
index bee84123..00000000
--- a/automerge-wasm/README.md
+++ /dev/null
@@ -1,4 +0,0 @@
-## Automerge WASM Low Level Interface
-
-This is a low level automerge library written in rust exporting a javascript API via WASM. This low level api is the underpinning to the `automerge-js` library that reimplements the Automerge API via these low level functions.
-
diff --git a/automerge-wasm/index.d.ts b/automerge-wasm/index.d.ts
deleted file mode 100644
index 7b97583e..00000000
--- a/automerge-wasm/index.d.ts
+++ /dev/null
@@ -1,223 +0,0 @@
-
-export type Actor = string;
-export type ObjID = string;
-export type Change = Uint8Array;
-export type SyncMessage = Uint8Array;
-export type Prop = string | number;
-export type Hash = string;
-export type Heads = Hash[];
-export type Value = string | number | boolean | null | Date | Uint8Array | Array | Object;
-export type FullValue =
- ["str", string] |
- ["int", number] |
- ["uint", number] |
- ["f64", number] |
- ["boolean", boolean] |
- ["timestamp", Date] |
- ["counter", number] |
- ["bytes", Uint8Array] |
- ["null", Uint8Array] |
- ["map", ObjID] |
- ["list", ObjID] |
- ["text", ObjID] |
- ["table", ObjID]
-
-export enum ObjTypeName {
- list = "list",
- map = "map",
- table = "table",
- text = "text",
-}
-
-export type Datatype =
- "boolean" |
- "str" |
- "int" |
- "uint" |
- "f64" |
- "null" |
- "timestamp" |
- "counter" |
- "bytes" |
- "map" |
- "text" |
- "list";
-
-export type DecodedSyncMessage = {
- heads: Heads,
- need: Heads,
- have: any[]
- changes: Change[]
-}
-
-export type DecodedChange = {
- actor: Actor,
- seq: number
- startOp: number,
- time: number,
- message: string | null,
- deps: Heads,
- hash: Hash,
- ops: Op[]
-}
-
-export type Op = {
- action: string,
- obj: ObjID,
- key: string,
- value?: string | number | boolean,
- datatype?: string,
- pred: string[],
-}
-
-export function create(actor?: Actor): Automerge;
-export function loadDoc(data: Uint8Array, actor?: Actor): Automerge;
-export function encodeChange(change: DecodedChange): Change;
-export function decodeChange(change: Change): DecodedChange;
-export function initSyncState(): SyncState;
-export function encodeSyncMessage(message: DecodedSyncMessage): SyncMessage;
-export function decodeSyncMessage(msg: SyncMessage): DecodedSyncMessage;
-export function encodeSyncState(state: SyncState): Uint8Array;
-export function decodeSyncState(data: Uint8Array): SyncState;
-
-export class Automerge {
- // change state
- set(obj: ObjID, prop: Prop, value: Value, datatype?: Datatype): ObjID | undefined;
- make(obj: ObjID, prop: Prop, value: Value, datatype?: Datatype): ObjID;
- insert(obj: ObjID, index: number, value: Value, datatype?: Datatype): ObjID | undefined;
- push(obj: ObjID, value: Value, datatype?: Datatype): ObjID | undefined;
- splice(obj: ObjID, start: number, delete_count: number, text?: string | Array): ObjID[] | undefined;
- inc(obj: ObjID, prop: Prop, value: number): void;
- del(obj: ObjID, prop: Prop): void;
-
- // returns a single value - if there is a conflict return the winner
- value(obj: ObjID, prop: any, heads?: Heads): FullValue | null;
- // return all values in case of a conflict
- values(obj: ObjID, arg: any, heads?: Heads): FullValue[];
- keys(obj: ObjID, heads?: Heads): string[];
- text(obj: ObjID, heads?: Heads): string;
- length(obj: ObjID, heads?: Heads): number;
-
- // experimental spans api - unstable!
- mark(obj: ObjID, name: string, range: string, value: Value, datatype?: Datatype): void;
- spans(obj: ObjID): any;
- raw_spans(obj: ObjID): any;
-
- // transactions
- commit(message?: string, time?: number): Heads;
- merge(other: Automerge): Heads;
- getActorId(): Actor;
- pendingOps(): number;
- rollback(): number;
-
- // save and load to local store
- save(): Uint8Array;
- saveIncremental(): Uint8Array;
- loadIncremental(data: Uint8Array): number;
-
- // sync over network
- receiveSyncMessage(state: SyncState, message: SyncMessage): void;
- generateSyncMessage(state: SyncState): SyncMessage;
-
- // low level change functions
- applyChanges(changes: Change[]): void;
- getChanges(have_deps: Heads): Change[];
- getChangesAdded(other: Automerge): Change[];
- getHeads(): Heads;
- getLastLocalChange(): Change;
- getMissingDeps(heads?: Heads): Heads;
-
- // memory management
- free(): void;
- clone(actor?: string): Automerge;
- fork(actor?: string): Automerge;
-
- // dump internal state to console.log
- dump(): void;
-
- // dump internal state to a JS object
- toJS(): any;
-}
-
-export class SyncState {
- free(): void;
- clone(): SyncState;
- lastSentHeads: any;
- sentHashes: any;
- readonly sharedHeads: any;
-}
-
-export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
-
-export interface InitOutput {
- readonly memory: WebAssembly.Memory;
- readonly __wbg_automerge_free: (a: number) => void;
- readonly automerge_new: (a: number, b: number, c: number) => void;
- readonly automerge_clone: (a: number, b: number, c: number, d: number) => void;
- readonly automerge_free: (a: number) => void;
- readonly automerge_pendingOps: (a: number) => number;
- readonly automerge_commit: (a: number, b: number, c: number, d: number, e: number) => number;
- readonly automerge_rollback: (a: number) => number;
- readonly automerge_keys: (a: number, b: number, c: number, d: number, e: number) => void;
- readonly automerge_text: (a: number, b: number, c: number, d: number, e: number) => void;
- readonly automerge_splice: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
- readonly automerge_push: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
- readonly automerge_insert: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
- readonly automerge_set: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
- readonly automerge_inc: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
- readonly automerge_value: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
- readonly automerge_values: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
- readonly automerge_length: (a: number, b: number, c: number, d: number, e: number) => void;
- readonly automerge_del: (a: number, b: number, c: number, d: number, e: number) => void;
- readonly automerge_save: (a: number, b: number) => void;
- readonly automerge_saveIncremental: (a: number) => number;
- readonly automerge_loadIncremental: (a: number, b: number, c: number) => void;
- readonly automerge_applyChanges: (a: number, b: number, c: number) => void;
- readonly automerge_getChanges: (a: number, b: number, c: number) => void;
- readonly automerge_getChangesAdded: (a: number, b: number, c: number) => void;
- readonly automerge_getHeads: (a: number) => number;
- readonly automerge_getActorId: (a: number, b: number) => void;
- readonly automerge_getLastLocalChange: (a: number, b: number) => void;
- readonly automerge_dump: (a: number) => void;
- readonly automerge_getMissingDeps: (a: number, b: number, c: number) => void;
- readonly automerge_receiveSyncMessage: (a: number, b: number, c: number, d: number) => void;
- readonly automerge_generateSyncMessage: (a: number, b: number, c: number) => void;
- readonly automerge_toJS: (a: number) => number;
- readonly create: (a: number, b: number, c: number) => void;
- readonly loadDoc: (a: number, b: number, c: number, d: number) => void;
- readonly encodeChange: (a: number, b: number) => void;
- readonly decodeChange: (a: number, b: number) => void;
- readonly initSyncState: () => number;
- readonly importSyncState: (a: number, b: number) => void;
- readonly exportSyncState: (a: number) => number;
- readonly encodeSyncMessage: (a: number, b: number) => void;
- readonly decodeSyncMessage: (a: number, b: number) => void;
- readonly encodeSyncState: (a: number, b: number) => void;
- readonly decodeSyncState: (a: number, b: number) => void;
- readonly __wbg_list_free: (a: number) => void;
- readonly __wbg_map_free: (a: number) => void;
- readonly __wbg_text_free: (a: number) => void;
- readonly __wbg_table_free: (a: number) => void;
- readonly __wbg_syncstate_free: (a: number) => void;
- readonly syncstate_sharedHeads: (a: number) => number;
- readonly syncstate_lastSentHeads: (a: number) => number;
- readonly syncstate_set_lastSentHeads: (a: number, b: number, c: number) => void;
- readonly syncstate_set_sentHashes: (a: number, b: number, c: number) => void;
- readonly syncstate_clone: (a: number) => number;
- readonly __wbindgen_malloc: (a: number) => number;
- readonly __wbindgen_realloc: (a: number, b: number, c: number) => number;
- readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
- readonly __wbindgen_free: (a: number, b: number) => void;
- readonly __wbindgen_exn_store: (a: number) => void;
-}
-
-/**
-* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
-* for everything else, calls `WebAssembly.instantiate` directly.
-*
-* @param {InitInput | Promise} module_or_path
-*
-* @returns {Promise}
-*/
-
-export default function init (module_or_path?: InitInput | Promise): Promise;
diff --git a/automerge-wasm/package.json b/automerge-wasm/package.json
deleted file mode 100644
index d1e39f12..00000000
--- a/automerge-wasm/package.json
+++ /dev/null
@@ -1,43 +0,0 @@
-{
- "collaborators": [
- "Orion Henry ",
- "Alex Good ",
- "Martin Kleppmann"
- ],
- "name": "automerge-wasm-pack",
- "description": "wasm-bindgen bindings to the automerge rust implementation",
- "version": "0.0.14",
- "license": "MIT",
- "files": [
- "README.md",
- "package.json",
- "index.d.ts",
- "node/index.js",
- "node/index_bg.wasm",
- "web/index.js",
- "web/index_bg.wasm"
- ],
- "types": "index.d.ts",
- "module": "./web/index.js",
- "main": "./node/index.js",
- "scripts": {
- "build": "rimraf ./node && wasm-pack build --target nodejs --dev --out-name index -d node && cp index.d.ts node",
- "release-w": "rimraf ./web && wasm-pack build --target web --dev --out-name index -d web && cp index.d.ts web",
- "release-n": "rimraf ./node && wasm-pack build --target nodejs --dev --out-name index -d node && cp index.d.ts node",
- "release": "yarn release-w && yarn release-n",
- "test": "yarn build && ts-mocha -p tsconfig.json --type-check --bail --full-trace test/*.ts"
- },
- "dependencies": {},
- "devDependencies": {
- "@types/expect": "^24.3.0",
- "@types/jest": "^27.4.0",
- "@types/mocha": "^9.1.0",
- "@types/node": "^17.0.13",
- "fast-sha256": "^1.3.0",
- "mocha": "^9.1.3",
- "pako": "^2.0.4",
- "rimraf": "^3.0.2",
- "ts-mocha": "^9.0.2",
- "typescript": "^4.5.5"
- }
-}
diff --git a/automerge-wasm/src/interop.rs b/automerge-wasm/src/interop.rs
deleted file mode 100644
index cf53abf3..00000000
--- a/automerge-wasm/src/interop.rs
+++ /dev/null
@@ -1,376 +0,0 @@
-use automerge as am;
-use automerge::transaction::Transactable;
-use automerge::{Change, ChangeHash, Prop};
-use js_sys::{Array, Object, Reflect, Uint8Array};
-use std::collections::HashSet;
-use std::fmt::Display;
-use unicode_segmentation::UnicodeSegmentation;
-use wasm_bindgen::prelude::*;
-use wasm_bindgen::JsCast;
-
-use crate::{ObjId, ScalarValue, Value};
-
-pub(crate) struct JS(pub JsValue);
-pub(crate) struct AR(pub Array);
-
-impl From for JsValue {
- fn from(ar: AR) -> Self {
- ar.0.into()
- }
-}
-
-impl From for JsValue {
- fn from(js: JS) -> Self {
- js.0
- }
-}
-
-impl From for JS {
- fn from(state: am::SyncState) -> Self {
- let shared_heads: JS = state.shared_heads.into();
- let last_sent_heads: JS = state.last_sent_heads.into();
- let their_heads: JS = state.their_heads.into();
- let their_need: JS = state.their_need.into();
- let sent_hashes: JS = state.sent_hashes.into();
- let their_have = if let Some(have) = &state.their_have {
- JsValue::from(AR::from(have.as_slice()).0)
- } else {
- JsValue::null()
- };
- let result: JsValue = Object::new().into();
- // we can unwrap here b/c we made the object and know its not frozen
- Reflect::set(&result, &"sharedHeads".into(), &shared_heads.0).unwrap();
- Reflect::set(&result, &"lastSentHeads".into(), &last_sent_heads.0).unwrap();
- Reflect::set(&result, &"theirHeads".into(), &their_heads.0).unwrap();
- Reflect::set(&result, &"theirNeed".into(), &their_need.0).unwrap();
- Reflect::set(&result, &"theirHave".into(), &their_have).unwrap();
- Reflect::set(&result, &"sentHashes".into(), &sent_hashes.0).unwrap();
- JS(result)
- }
-}
-
-impl From> for JS {
- fn from(heads: Vec) -> Self {
- let heads: Array = heads
- .iter()
- .map(|h| JsValue::from_str(&h.to_string()))
- .collect();
- JS(heads.into())
- }
-}
-
-impl From> for JS {
- fn from(heads: HashSet) -> Self {
- let result: JsValue = Object::new().into();
- for key in &heads {
- Reflect::set(&result, &key.to_string().into(), &true.into()).unwrap();
- }
- JS(result)
- }
-}
-
-impl From>> for JS {
- fn from(heads: Option>) -> Self {
- if let Some(v) = heads {
- let v: Array = v
- .iter()
- .map(|h| JsValue::from_str(&h.to_string()))
- .collect();
- JS(v.into())
- } else {
- JS(JsValue::null())
- }
- }
-}
-
-impl TryFrom for HashSet {
- type Error = JsValue;
-
- fn try_from(value: JS) -> Result {
- let mut result = HashSet::new();
- for key in Reflect::own_keys(&value.0)?.iter() {
- if let Some(true) = Reflect::get(&value.0, &key)?.as_bool() {
- result.insert(key.into_serde().map_err(to_js_err)?);
- }
- }
- Ok(result)
- }
-}
-
-impl TryFrom for Vec {
- type Error = JsValue;
-
- fn try_from(value: JS) -> Result {
- let value = value.0.dyn_into::()?;
- let value: Result, _> = value.iter().map(|j| j.into_serde()).collect();
- let value = value.map_err(to_js_err)?;
- Ok(value)
- }
-}
-
-impl From for Option> {
- fn from(value: JS) -> Self {
- let value = value.0.dyn_into::().ok()?;
- let value: Result, _> = value.iter().map(|j| j.into_serde()).collect();
- let value = value.ok()?;
- Some(value)
- }
-}
-
-impl TryFrom for Vec {
- type Error = JsValue;
-
- fn try_from(value: JS) -> Result {
- let value = value.0.dyn_into::()?;
- let changes: Result, _> = value.iter().map(|j| j.dyn_into()).collect();
- let changes = changes?;
- let changes: Result, _> = changes
- .iter()
- .map(|a| am::decode_change(a.to_vec()))
- .collect();
- let changes = changes.map_err(to_js_err)?;
- Ok(changes)
- }
-}
-
-impl TryFrom for am::SyncState {
- type Error = JsValue;
-
- fn try_from(value: JS) -> Result {
- let value = value.0;
- let shared_heads = js_get(&value, "sharedHeads")?.try_into()?;
- let last_sent_heads = js_get(&value, "lastSentHeads")?.try_into()?;
- let their_heads = js_get(&value, "theirHeads")?.into();
- let their_need = js_get(&value, "theirNeed")?.into();
- let their_have = js_get(&value, "theirHave")?.try_into()?;
- let sent_hashes = js_get(&value, "sentHashes")?.try_into()?;
- Ok(am::SyncState {
- shared_heads,
- last_sent_heads,
- their_heads,
- their_need,
- their_have,
- sent_hashes,
- })
- }
-}
-
-impl TryFrom for Option> {
- type Error = JsValue;
-
- fn try_from(value: JS) -> Result {
- if value.0.is_null() {
- Ok(None)
- } else {
- Ok(Some(value.try_into()?))
- }
- }
-}
-
-impl TryFrom for Vec {
- type Error = JsValue;
-
- fn try_from(value: JS) -> Result {
- let value = value.0.dyn_into::()?;
- let have: Result, JsValue> = value
- .iter()
- .map(|s| {
- let last_sync = js_get(&s, "lastSync")?.try_into()?;
- let bloom = js_get(&s, "bloom")?.try_into()?;
- Ok(am::SyncHave { last_sync, bloom })
- })
- .collect();
- let have = have?;
- Ok(have)
- }
-}
-
-impl TryFrom for am::BloomFilter {
- type Error = JsValue;
-
- fn try_from(value: JS) -> Result {
- let value: Uint8Array = value.0.dyn_into()?;
- let value = value.to_vec();
- let value = value.as_slice().try_into().map_err(to_js_err)?;
- Ok(value)
- }
-}
-
-impl From<&[ChangeHash]> for AR {
- fn from(value: &[ChangeHash]) -> Self {
- AR(value
- .iter()
- .map(|h| JsValue::from_str(&hex::encode(&h.0)))
- .collect())
- }
-}
-
-impl From<&[Change]> for AR {
- fn from(value: &[Change]) -> Self {
- let changes: Array = value
- .iter()
- .map(|c| Uint8Array::from(c.raw_bytes()))
- .collect();
- AR(changes)
- }
-}
-
-impl From<&[am::SyncHave]> for AR {
- fn from(value: &[am::SyncHave]) -> Self {
- AR(value
- .iter()
- .map(|have| {
- let last_sync: Array = have
- .last_sync
- .iter()
- .map(|h| JsValue::from_str(&hex::encode(&h.0)))
- .collect();
- // FIXME - the clone and the unwrap here shouldnt be needed - look at into_bytes()
- let bloom = Uint8Array::from(have.bloom.clone().into_bytes().unwrap().as_slice());
- let obj: JsValue = Object::new().into();
- // we can unwrap here b/c we created the object and know its not frozen
- Reflect::set(&obj, &"lastSync".into(), &last_sync.into()).unwrap();
- Reflect::set(&obj, &"bloom".into(), &bloom.into()).unwrap();
- obj
- })
- .collect())
- }
-}
-
-pub(crate) fn to_js_err(err: T) -> JsValue {
- js_sys::Error::new(&std::format!("{}", err)).into()
-}
-
-pub(crate) fn js_get>(obj: J, prop: &str) -> Result {
- Ok(JS(Reflect::get(&obj.into(), &prop.into())?))
-}
-
-pub(crate) fn js_set>(obj: &JsValue, prop: &str, val: V) -> Result {
- Reflect::set(obj, &prop.into(), &val.into())
-}
-
-pub(crate) fn to_prop(p: JsValue) -> Result {
- if let Some(s) = p.as_string() {
- Ok(Prop::Map(s))
- } else if let Some(n) = p.as_f64() {
- Ok(Prop::Seq(n as usize))
- } else {
- Err(to_js_err("prop must me a string or number"))
- }
-}
-
-pub(crate) fn to_objtype(
- value: &JsValue,
- datatype: &Option,
-) -> Option<(am::ObjType, Vec<(Prop, JsValue)>)> {
- match datatype.as_deref() {
- Some("map") => {
- let map = value.clone().dyn_into::().ok()?;
- // FIXME unwrap
- let map = js_sys::Object::keys(&map)
- .iter()
- .zip(js_sys::Object::values(&map).iter())
- .map(|(key, val)| (key.as_string().unwrap().into(), val))
- .collect();
- Some((am::ObjType::Map, map))
- }
- Some("list") => {
- let list = value.clone().dyn_into::().ok()?;
- let list = list
- .iter()
- .enumerate()
- .map(|(i, e)| (i.into(), e))
- .collect();
- Some((am::ObjType::List, list))
- }
- Some("text") => {
- let text = value.as_string()?;
- let text = text
- .graphemes(true)
- .enumerate()
- .map(|(i, ch)| (i.into(), ch.into()))
- .collect();
- Some((am::ObjType::Text, text))
- }
- Some(_) => None,
- None => {
- if let Ok(list) = value.clone().dyn_into::() {
- let list = list
- .iter()
- .enumerate()
- .map(|(i, e)| (i.into(), e))
- .collect();
- Some((am::ObjType::List, list))
- } else if let Ok(map) = value.clone().dyn_into::() {
- // FIXME unwrap
- let map = js_sys::Object::keys(&map)
- .iter()
- .zip(js_sys::Object::values(&map).iter())
- .map(|(key, val)| (key.as_string().unwrap().into(), val))
- .collect();
- Some((am::ObjType::Map, map))
- } else if let Some(text) = value.as_string() {
- let text = text
- .graphemes(true)
- .enumerate()
- .map(|(i, ch)| (i.into(), ch.into()))
- .collect();
- Some((am::ObjType::Text, text))
- } else {
- None
- }
- }
- }
-}
-
-pub(crate) fn get_heads(heads: Option) -> Option> {
- let heads = heads?;
- let heads: Result, _> = heads.iter().map(|j| j.into_serde()).collect();
- heads.ok()
-}
-
-pub(crate) fn map_to_js(doc: &am::AutoCommit, obj: &ObjId) -> JsValue {
- let keys = doc.keys(obj);
- let map = Object::new();
- for k in keys {
- let val = doc.value(obj, &k);
- match val {
- Ok(Some((Value::Object(o), exid)))
- if o == am::ObjType::Map || o == am::ObjType::Table =>
- {
- Reflect::set(&map, &k.into(), &map_to_js(doc, &exid)).unwrap();
- }
- Ok(Some((Value::Object(_), exid))) => {
- Reflect::set(&map, &k.into(), &list_to_js(doc, &exid)).unwrap();
- }
- Ok(Some((Value::Scalar(v), _))) => {
- Reflect::set(&map, &k.into(), &ScalarValue(v).into()).unwrap();
- }
- _ => (),
- };
- }
- map.into()
-}
-
-fn list_to_js(doc: &am::AutoCommit, obj: &ObjId) -> JsValue {
- let len = doc.length(obj);
- let array = Array::new();
- for i in 0..len {
- let val = doc.value(obj, i as usize);
- match val {
- Ok(Some((Value::Object(o), exid)))
- if o == am::ObjType::Map || o == am::ObjType::Table =>
- {
- array.push(&map_to_js(doc, &exid));
- }
- Ok(Some((Value::Object(_), exid))) => {
- array.push(&list_to_js(doc, &exid));
- }
- Ok(Some((Value::Scalar(v), _))) => {
- array.push(&ScalarValue(v).into());
- }
- _ => (),
- };
- }
- array.into()
-}
diff --git a/automerge-wasm/src/lib.rs b/automerge-wasm/src/lib.rs
deleted file mode 100644
index 7ad1befe..00000000
--- a/automerge-wasm/src/lib.rs
+++ /dev/null
@@ -1,704 +0,0 @@
-#![allow(clippy::unused_unit)]
-use am::transaction::CommitOptions;
-use am::transaction::Transactable;
-use automerge as am;
-use automerge::{Change, ObjId, Prop, Value, ROOT};
-use js_sys::{Array, Object, Uint8Array};
-use regex::Regex;
-use std::convert::TryInto;
-use wasm_bindgen::prelude::*;
-use wasm_bindgen::JsCast;
-
-mod interop;
-mod sync;
-mod value;
-
-use interop::{get_heads, js_get, js_set, map_to_js, to_js_err, to_objtype, to_prop, AR, JS};
-use sync::SyncState;
-use value::{datatype, ScalarValue};
-
-#[allow(unused_macros)]
-macro_rules! log {
- ( $( $t:tt )* ) => {
- web_sys::console::log_1(&format!( $( $t )* ).into());
- };
-}
-
-#[cfg(feature = "wee_alloc")]
-#[global_allocator]
-static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
-
-#[wasm_bindgen]
-#[derive(Debug)]
-pub struct Automerge(automerge::AutoCommit);
-
-#[wasm_bindgen]
-impl Automerge {
- pub fn new(actor: Option) -> Result {
- let mut automerge = automerge::AutoCommit::new();
- if let Some(a) = actor {
- let a = automerge::ActorId::from(hex::decode(a).map_err(to_js_err)?.to_vec());
- automerge.set_actor(a);
- }
- Ok(Automerge(automerge))
- }
-
- #[allow(clippy::should_implement_trait)]
- pub fn clone(&mut self, actor: Option) -> Result {
- if self.0.pending_ops() > 0 {
- self.0.commit();
- }
- let mut automerge = Automerge(self.0.clone());
- if let Some(s) = actor {
- let actor = automerge::ActorId::from(hex::decode(s).map_err(to_js_err)?.to_vec());
- automerge.0.set_actor(actor)
- }
- Ok(automerge)
- }
-
- #[allow(clippy::should_implement_trait)]
- pub fn fork(&mut self, actor: Option) -> Result {
- let mut automerge = Automerge(self.0.fork());
- if let Some(s) = actor {
- let actor = automerge::ActorId::from(hex::decode(s).map_err(to_js_err)?.to_vec());
- automerge.0.set_actor(actor)
- }
- Ok(automerge)
- }
-
- pub fn free(self) {}
-
- #[wasm_bindgen(js_name = pendingOps)]
- pub fn pending_ops(&self) -> JsValue {
- (self.0.pending_ops() as u32).into()
- }
-
- pub fn commit(&mut self, message: Option, time: Option) -> Array {
- let mut commit_opts = CommitOptions::default();
- if let Some(message) = message {
- commit_opts.set_message(message);
- }
- if let Some(time) = time {
- commit_opts.set_time(time as i64);
- }
- let heads = self.0.commit_with(commit_opts);
- let heads: Array = heads
- .iter()
- .map(|h| JsValue::from_str(&hex::encode(&h.0)))
- .collect();
- heads
- }
-
- pub fn merge(&mut self, other: &mut Automerge) -> Result {
- let heads = self.0.merge(&mut other.0)?;
- let heads: Array = heads
- .iter()
- .map(|h| JsValue::from_str(&hex::encode(&h.0)))
- .collect();
- Ok(heads)
- }
-
- pub fn rollback(&mut self) -> f64 {
- self.0.rollback() as f64
- }
-
- pub fn keys(&mut self, obj: JsValue, heads: Option) -> Result {
- let obj = self.import(obj)?;
- let result = if let Some(heads) = get_heads(heads) {
- self.0.keys_at(&obj, &heads)
- } else {
- self.0.keys(&obj)
- }
- .iter()
- .map(|s| JsValue::from_str(s))
- .collect();
- Ok(result)
- }
-
- pub fn text(&mut self, obj: JsValue, heads: Option) -> Result {
- let obj = self.import(obj)?;
- if let Some(heads) = get_heads(heads) {
- Ok(self.0.text_at(&obj, &heads)?)
- } else {
- Ok(self.0.text(&obj)?)
- }
- }
-
- pub fn splice(
- &mut self,
- obj: JsValue,
- start: f64,
- delete_count: f64,
- text: JsValue,
- ) -> Result, JsValue> {
- let obj = self.import(obj)?;
- let start = start as usize;
- let delete_count = delete_count as usize;
- let mut vals = vec![];
- if let Some(t) = text.as_string() {
- self.0.splice_text(&obj, start, delete_count, &t)?;
- Ok(None)
- } else {
- if let Ok(array) = text.dyn_into::() {
- for i in array.iter() {
- let (value, subvals) = self.import_value(&i, None)?;
- if !subvals.is_empty() {
- return Err(to_js_err("splice must be shallow"));
- }
- vals.push(value);
- }
- }
- let result = self.0.splice(&obj, start, delete_count, vals)?;
- if result.is_empty() {
- Ok(None)
- } else {
- let result: Array = result
- .iter()
- .map(|r| JsValue::from(r.to_string()))
- .collect();
- Ok(result.into())
- }
- }
- }
-
- pub fn push(
- &mut self,
- obj: JsValue,
- value: JsValue,
- datatype: JsValue,
- ) -> Result, JsValue> {
- let obj = self.import(obj)?;
- let (value, subvals) = self.import_value(&value, datatype.as_string())?;
- let index = self.0.length(&obj);
- let opid = self.0.insert(&obj, index, value)?;
- self.subset(&opid, subvals)?;
- Ok(opid.map(|id| id.to_string()))
- }
-
- pub fn insert(
- &mut self,
- obj: JsValue,
- index: f64,
- value: JsValue,
- datatype: JsValue,
- ) -> Result, JsValue> {
- let obj = self.import(obj)?;
- let index = index as f64;
- let (value, subvals) = self.import_value(&value, datatype.as_string())?;
- let opid = self.0.insert(&obj, index as usize, value)?;
- self.subset(&opid, subvals)?;
- Ok(opid.map(|id| id.to_string()))
- }
-
- pub fn set(
- &mut self,
- obj: JsValue,
- prop: JsValue,
- value: JsValue,
- datatype: JsValue,
- ) -> Result {
- let obj = self.import(obj)?;
- let prop = self.import_prop(prop)?;
- let (value, subvals) = self.import_value(&value, datatype.as_string())?;
- let opid = self.0.set(&obj, prop, value)?;
- self.subset(&opid, subvals)?;
- Ok(opid.map(|id| id.to_string()).into())
- }
-
- fn subset(
- &mut self,
- obj: &Option,
- vals: Vec<(am::Prop, JsValue)>,
- ) -> Result<(), JsValue> {
- if let Some(id) = obj {
- for (p, v) in vals {
- let (value, subvals) = self.import_value(&v, None)?;
- //let opid = self.0.set(id, p, value)?;
- let opid = match p {
- Prop::Map(s) => self.0.set(id, s, value)?,
- Prop::Seq(i) => self.0.insert(id, i, value)?,
- };
- self.subset(&opid, subvals)?;
- }
- }
- Ok(())
- }
-
- pub fn make(&mut self, obj: JsValue, prop: JsValue, value: JsValue) -> Result {
- let obj = self.import(obj)?;
- let prop = self.import_prop(prop)?;
- if let Some((value, subvals)) = to_objtype(&value, &None) {
- let opid = self.0.set(&obj, prop, value)?;
- self.subset(&opid, subvals)?;
- Ok(opid.unwrap().to_string())
- } else {
- Err(to_js_err("invalid object type"))
- }
- }
-
- pub fn inc(&mut self, obj: JsValue, prop: JsValue, value: JsValue) -> Result<(), JsValue> {
- let obj = self.import(obj)?;
- let prop = self.import_prop(prop)?;
- let value: f64 = value
- .as_f64()
- .ok_or_else(|| to_js_err("inc needs a numberic value"))?;
- self.0.inc(&obj, prop, value as i64)?;
- Ok(())
- }
-
- pub fn value(
- &mut self,
- obj: JsValue,
- prop: JsValue,
- heads: Option,
- ) -> Result, JsValue> {
- let obj = self.import(obj)?;
- let result = Array::new();
- let prop = to_prop(prop);
- let heads = get_heads(heads);
- if let Ok(prop) = prop {
- let value = if let Some(h) = heads {
- self.0.value_at(&obj, prop, &h)?
- } else {
- self.0.value(&obj, prop)?
- };
- match value {
- Some((Value::Object(obj_type), obj_id)) => {
- result.push(&obj_type.to_string().into());
- result.push(&obj_id.to_string().into());
- Ok(Some(result))
- }
- Some((Value::Scalar(value), _)) => {
- result.push(&datatype(&value).into());
- result.push(&ScalarValue(value).into());
- Ok(Some(result))
- }
- None => Ok(None),
- }
- } else {
- Ok(None)
- }
- }
-
- pub fn values(
- &mut self,
- obj: JsValue,
- arg: JsValue,
- heads: Option,
- ) -> Result {
- let obj = self.import(obj)?;
- let result = Array::new();
- let prop = to_prop(arg);
- if let Ok(prop) = prop {
- let values = if let Some(heads) = get_heads(heads) {
- self.0.values_at(&obj, prop, &heads)
- } else {
- self.0.values(&obj, prop)
- }
- .map_err(to_js_err)?;
- for value in values {
- match value {
- (Value::Object(obj_type), obj_id) => {
- let sub = Array::new();
- sub.push(&obj_type.to_string().into());
- sub.push(&obj_id.to_string().into());
- result.push(&sub.into());
- }
- (Value::Scalar(value), id) => {
- let sub = Array::new();
- sub.push(&datatype(&value).into());
- sub.push(&ScalarValue(value).into());
- sub.push(&id.to_string().into());
- result.push(&sub.into());
- }
- }
- }
- }
- Ok(result)
- }
-
- pub fn length(&mut self, obj: JsValue, heads: Option) -> Result {
- let obj = self.import(obj)?;
- if let Some(heads) = get_heads(heads) {
- Ok(self.0.length_at(&obj, &heads) as f64)
- } else {
- Ok(self.0.length(&obj) as f64)
- }
- }
-
- pub fn del(&mut self, obj: JsValue, prop: JsValue) -> Result<(), JsValue> {
- let obj = self.import(obj)?;
- let prop = to_prop(prop)?;
- self.0.del(&obj, prop).map_err(to_js_err)?;
- Ok(())
- }
-
- pub fn mark(
- &mut self,
- obj: JsValue,
- range: JsValue,
- name: JsValue,
- value: JsValue,
- datatype: JsValue,
- ) -> Result<(), JsValue> {
- let obj = self.import(obj)?;
- let re = Regex::new(r"([\[\(])(\d+)\.\.(\d+)([\)\]])").unwrap();
- let range = range.as_string().ok_or("range must be a string")?;
- let cap = re.captures_iter(&range).next().ok_or("range must be in the form of (start..end] or [start..end) etc... () for sticky, [] for normal")?;
- let start: usize = cap[2].parse().map_err(|_| to_js_err("invalid start"))?;
- let end: usize = cap[3].parse().map_err(|_| to_js_err("invalid end"))?;
- let start_sticky = &cap[1] == "(";
- let end_sticky = &cap[4] == ")";
- let name = name
- .as_string()
- .ok_or("invalid mark name")
- .map_err(to_js_err)?;
- let value = self
- .import_scalar(&value, &datatype.as_string())
- .ok_or_else(|| to_js_err("invalid value"))?;
- self.0
- .mark(&obj, start, start_sticky, end, end_sticky, &name, value)
- .map_err(to_js_err)?;
- Ok(())
- }
-
- pub fn spans(&mut self, obj: JsValue) -> Result {
- let obj = self.import(obj)?;
- let text = self.0.list(&obj).map_err(to_js_err)?;
- let spans = self.0.spans(&obj).map_err(to_js_err)?;
- let mut last_pos = 0;
- let result = Array::new();
- for s in spans {
- let marks = Array::new();
- for m in s.marks {
- let mark = Array::new();
- mark.push(&m.0.into());
- mark.push(&datatype(&m.1).into());
- mark.push(&ScalarValue(m.1).into());
- marks.push(&mark.into());
- }
- let text_span = &text[last_pos..s.pos]; //.slice(last_pos, s.pos);
- if !text_span.is_empty() {
- let t: String = text_span
- .iter()
- .filter_map(|(v, _)| v.as_string())
- .collect();
- result.push(&t.into());
- }
- result.push(&marks);
- last_pos = s.pos;
- //let obj = Object::new().into();
- //js_set(&obj, "pos", s.pos as i32)?;
- //js_set(&obj, "marks", marks)?;
- //result.push(&obj.into());
- }
- let text_span = &text[last_pos..];
- if !text_span.is_empty() {
- let t: String = text_span
- .iter()
- .filter_map(|(v, _)| v.as_string())
- .collect();
- result.push(&t.into());
- }
- Ok(result.into())
- }
-
- pub fn raw_spans(&mut self, obj: JsValue) -> Result {
- let obj = self.import(obj)?;
- let spans = self.0.raw_spans(&obj).map_err(to_js_err)?;
- let result = Array::new();
- for s in spans {
- result.push(&JsValue::from_serde(&s).map_err(to_js_err)?);
- }
- Ok(result)
- }
-
- pub fn save(&mut self) -> Result {
- self.0
- .save()
- .map(|v| Uint8Array::from(v.as_slice()))
- .map_err(to_js_err)
- }
-
- #[wasm_bindgen(js_name = saveIncremental)]
- pub fn save_incremental(&mut self) -> Uint8Array {
- let bytes = self.0.save_incremental();
- Uint8Array::from(bytes.as_slice())
- }
-
- #[wasm_bindgen(js_name = loadIncremental)]
- pub fn load_incremental(&mut self, data: Uint8Array) -> Result {
- let data = data.to_vec();
- let len = self.0.load_incremental(&data).map_err(to_js_err)?;
- Ok(len as f64)
- }
-
- #[wasm_bindgen(js_name = applyChanges)]
- pub fn apply_changes(&mut self, changes: JsValue) -> Result<(), JsValue> {
- let changes: Vec<_> = JS(changes).try_into()?;
- self.0.apply_changes(&changes).map_err(to_js_err)?;
- Ok(())
- }
-
- #[wasm_bindgen(js_name = getChanges)]
- pub fn get_changes(&mut self, have_deps: JsValue) -> Result {
- let deps: Vec<_> = JS(have_deps).try_into()?;
- let changes = self.0.get_changes(&deps);
- let changes: Array = changes
- .iter()
- .map(|c| Uint8Array::from(c.raw_bytes()))
- .collect();
- Ok(changes)
- }
-
- #[wasm_bindgen(js_name = getChangesAdded)]
- pub fn get_changes_added(&mut self, other: &mut Automerge) -> Result {
- let changes = self.0.get_changes_added(&mut other.0);
- let changes: Array = changes
- .iter()
- .map(|c| Uint8Array::from(c.raw_bytes()))
- .collect();
- Ok(changes)
- }
-
- #[wasm_bindgen(js_name = getHeads)]
- pub fn get_heads(&mut self) -> Array {
- let heads = self.0.get_heads();
- let heads: Array = heads
- .iter()
- .map(|h| JsValue::from_str(&hex::encode(&h.0)))
- .collect();
- heads
- }
-
- #[wasm_bindgen(js_name = getActorId)]
- pub fn get_actor_id(&mut self) -> String {
- let actor = self.0.get_actor();
- actor.to_string()
- }
-
- #[wasm_bindgen(js_name = getLastLocalChange)]
- pub fn get_last_local_change(&mut self) -> Result {
- if let Some(change) = self.0.get_last_local_change() {
- Ok(Uint8Array::from(change.raw_bytes()))
- } else {
- Err(to_js_err("no local changes"))
- }
- }
-
- pub fn dump(&self) {
- self.0.dump()
- }
-
- #[wasm_bindgen(js_name = getMissingDeps)]
- pub fn get_missing_deps(&mut self, heads: Option) -> Result {
- let heads = get_heads(heads).unwrap_or_default();
- let deps = self.0.get_missing_deps(&heads);
- let deps: Array = deps
- .iter()
- .map(|h| JsValue::from_str(&hex::encode(&h.0)))
- .collect();
- Ok(deps)
- }
-
- #[wasm_bindgen(js_name = receiveSyncMessage)]
- pub fn receive_sync_message(
- &mut self,
- state: &mut SyncState,
- message: Uint8Array,
- ) -> Result<(), JsValue> {
- let message = message.to_vec();
- let message = am::SyncMessage::decode(message.as_slice()).map_err(to_js_err)?;
- self.0
- .receive_sync_message(&mut state.0, message)
- .map_err(to_js_err)?;
- Ok(())
- }
-
- #[wasm_bindgen(js_name = generateSyncMessage)]
- pub fn generate_sync_message(&mut self, state: &mut SyncState) -> Result {
- if let Some(message) = self.0.generate_sync_message(&mut state.0) {
- Ok(Uint8Array::from(message.encode().map_err(to_js_err)?.as_slice()).into())
- } else {
- Ok(JsValue::null())
- }
- }
-
- #[wasm_bindgen(js_name = toJS)]
- pub fn to_js(&self) -> JsValue {
- map_to_js(&self.0, &ROOT)
- }
-
- fn import(&self, id: JsValue) -> Result {
- if let Some(s) = id.as_string() {
- Ok(self.0.import(&s)?)
- } else {
- Err(to_js_err("invalid objid"))
- }
- }
-
- fn import_prop(&mut self, prop: JsValue) -> Result {
- if let Some(s) = prop.as_string() {
- Ok(s.into())
- } else if let Some(n) = prop.as_f64() {
- Ok((n as usize).into())
- } else {
- Err(to_js_err(format!("invalid prop {:?}", prop)))
- }
- }
-
- fn import_scalar(
- &mut self,
- value: &JsValue,
- datatype: &Option,
- ) -> Option {
- match datatype.as_deref() {
- Some("boolean") => value.as_bool().map(am::ScalarValue::Boolean),
- Some("int") => value.as_f64().map(|v| am::ScalarValue::Int(v as i64)),
- Some("uint") => value.as_f64().map(|v| am::ScalarValue::Uint(v as u64)),
- Some("f64") => value.as_f64().map(am::ScalarValue::F64),
- Some("bytes") => Some(am::ScalarValue::Bytes(
- value.clone().dyn_into::().unwrap().to_vec(),
- )),
- Some("counter") => value.as_f64().map(|v| am::ScalarValue::counter(v as i64)),
- Some("timestamp") => value.as_f64().map(|v| am::ScalarValue::Timestamp(v as i64)),
- Some("null") => Some(am::ScalarValue::Null),
- Some(_) => None,
- None => {
- if value.is_null() {
- Some(am::ScalarValue::Null)
- } else if let Some(b) = value.as_bool() {
- Some(am::ScalarValue::Boolean(b))
- } else if let Some(s) = value.as_string() {
- Some(am::ScalarValue::Str(s.into()))
- } else if let Some(n) = value.as_f64() {
- if (n.round() - n).abs() < f64::EPSILON {
- Some(am::ScalarValue::Int(n as i64))
- } else {
- Some(am::ScalarValue::F64(n))
- }
- } else if let Ok(d) = value.clone().dyn_into::() {
- Some(am::ScalarValue::Timestamp(d.get_time() as i64))
- } else if let Ok(o) = &value.clone().dyn_into::() {
- Some(am::ScalarValue::Bytes(o.to_vec()))
- } else {
- None
- }
- }
- }
- }
-
- fn import_value(
- &mut self,
- value: &JsValue,
- datatype: Option,
- ) -> Result<(Value, Vec<(Prop, JsValue)>), JsValue> {
- match self.import_scalar(value, &datatype) {
- Some(val) => Ok((val.into(), vec![])),
- None => {
- if let Some((o, subvals)) = to_objtype(value, &datatype) {
- Ok((o.into(), subvals))
- } else {
- web_sys::console::log_2(&"Invalid value".into(), value);
- Err(to_js_err("invalid value"))
- }
- }
- }
- }
-}
-
-#[wasm_bindgen(js_name = create)]
-pub fn init(actor: Option) -> Result {
- console_error_panic_hook::set_once();
- Automerge::new(actor)
-}
-
-#[wasm_bindgen(js_name = loadDoc)]
-pub fn load(data: Uint8Array, actor: Option) -> Result {
- let data = data.to_vec();
- let mut automerge = am::AutoCommit::load(&data).map_err(to_js_err)?;
- if let Some(s) = actor {
- let actor = automerge::ActorId::from(hex::decode(s).map_err(to_js_err)?.to_vec());
- automerge.set_actor(actor)
- }
- Ok(Automerge(automerge))
-}
-
-#[wasm_bindgen(js_name = encodeChange)]
-pub fn encode_change(change: JsValue) -> Result {
- let change: am::ExpandedChange = change.into_serde().map_err(to_js_err)?;
- let change: Change = change.into();
- Ok(Uint8Array::from(change.raw_bytes()))
-}
-
-#[wasm_bindgen(js_name = decodeChange)]
-pub fn decode_change(change: Uint8Array) -> Result {
- let change = Change::from_bytes(change.to_vec()).map_err(to_js_err)?;
- let change: am::ExpandedChange = change.decode();
- JsValue::from_serde(&change).map_err(to_js_err)
-}
-
-#[wasm_bindgen(js_name = initSyncState)]
-pub fn init_sync_state() -> SyncState {
- SyncState(am::SyncState::new())
-}
-
-// this is needed to be compatible with the automerge-js api
-#[wasm_bindgen(js_name = importSyncState)]
-pub fn import_sync_state(state: JsValue) -> Result {
- Ok(SyncState(JS(state).try_into()?))
-}
-
-// this is needed to be compatible with the automerge-js api
-#[wasm_bindgen(js_name = exportSyncState)]
-pub fn export_sync_state(state: SyncState) -> JsValue {
- JS::from(state.0).into()
-}
-
-#[wasm_bindgen(js_name = encodeSyncMessage)]
-pub fn encode_sync_message(message: JsValue) -> Result {
- let heads = js_get(&message, "heads")?.try_into()?;
- let need = js_get(&message, "need")?.try_into()?;
- let changes = js_get(&message, "changes")?.try_into()?;
- let have = js_get(&message, "have")?.try_into()?;
- Ok(Uint8Array::from(
- am::SyncMessage {
- heads,
- need,
- have,
- changes,
- }
- .encode()
- .unwrap()
- .as_slice(),
- ))
-}
-
-#[wasm_bindgen(js_name = decodeSyncMessage)]
-pub fn decode_sync_message(msg: Uint8Array) -> Result {
- let data = msg.to_vec();
- let msg = am::SyncMessage::decode(&data).map_err(to_js_err)?;
- let heads = AR::from(msg.heads.as_slice());
- let need = AR::from(msg.need.as_slice());
- let changes = AR::from(msg.changes.as_slice());
- let have = AR::from(msg.have.as_slice());
- let obj = Object::new().into();
- js_set(&obj, "heads", heads)?;
- js_set(&obj, "need", need)?;
- js_set(&obj, "have", have)?;
- js_set(&obj, "changes", changes)?;
- Ok(obj)
-}
-
-#[wasm_bindgen(js_name = encodeSyncState)]
-pub fn encode_sync_state(state: SyncState) -> Result {
- let state = state.0;
- Ok(Uint8Array::from(
- state.encode().map_err(to_js_err)?.as_slice(),
- ))
-}
-
-#[wasm_bindgen(js_name = decodeSyncState)]
-pub fn decode_sync_state(data: Uint8Array) -> Result {
- SyncState::decode(data)
-}
diff --git a/automerge-wasm/src/value.rs b/automerge-wasm/src/value.rs
deleted file mode 100644
index a2388436..00000000
--- a/automerge-wasm/src/value.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use automerge as am;
-use js_sys::Uint8Array;
-use wasm_bindgen::prelude::*;
-
-#[derive(Debug)]
-pub struct ScalarValue(pub(crate) am::ScalarValue);
-
-impl From for JsValue {
- fn from(val: ScalarValue) -> Self {
- match &val.0 {
- am::ScalarValue::Bytes(v) => Uint8Array::from(v.as_slice()).into(),
- am::ScalarValue::Str(v) => v.to_string().into(),
- am::ScalarValue::Int(v) => (*v as f64).into(),
- am::ScalarValue::Uint(v) => (*v as f64).into(),
- am::ScalarValue::F64(v) => (*v).into(),
- am::ScalarValue::Counter(v) => (f64::from(v)).into(),
- am::ScalarValue::Timestamp(v) => js_sys::Date::new(&(*v as f64).into()).into(),
- am::ScalarValue::Boolean(v) => (*v).into(),
- am::ScalarValue::Null => JsValue::null(),
- }
- }
-}
-
-pub(crate) fn datatype(s: &am::ScalarValue) -> String {
- match s {
- am::ScalarValue::Bytes(_) => "bytes".into(),
- am::ScalarValue::Str(_) => "str".into(),
- am::ScalarValue::Int(_) => "int".into(),
- am::ScalarValue::Uint(_) => "uint".into(),
- am::ScalarValue::F64(_) => "f64".into(),
- am::ScalarValue::Counter(_) => "counter".into(),
- am::ScalarValue::Timestamp(_) => "timestamp".into(),
- am::ScalarValue::Boolean(_) => "boolean".into(),
- am::ScalarValue::Null => "null".into(),
- }
-}
diff --git a/automerge-wasm/test/helpers/columnar.js b/automerge-wasm/test/helpers/columnar.js
deleted file mode 100644
index 8d266f5b..00000000
--- a/automerge-wasm/test/helpers/columnar.js
+++ /dev/null
@@ -1,1415 +0,0 @@
-const pako = require('pako')
-const { copyObject, parseOpId, equalBytes } = require('./common')
-const {
- utf8ToString, hexStringToBytes, bytesToHexString,
- Encoder, Decoder, RLEEncoder, RLEDecoder, DeltaEncoder, DeltaDecoder, BooleanEncoder, BooleanDecoder
-} = require('./encoding')
-
-// Maybe we should be using the platform's built-in hash implementation?
-// Node has the crypto module: https://nodejs.org/api/crypto.html and browsers have
-// https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest
-// However, the WebCrypto API is asynchronous (returns promises), which would
-// force all our APIs to become asynchronous as well, which would be annoying.
-//
-// I think on balance, it's safe enough to use a random library off npm:
-// - We only need one hash function (not a full suite of crypto algorithms);
-// - SHA256 is quite simple and has fairly few opportunities for subtle bugs
-// (compared to asymmetric cryptography anyway);
-// - It does not need a secure source of random bits and does not need to be
-// constant-time;
-// - I have reviewed the source code and it seems pretty reasonable.
-const { Hash } = require('fast-sha256')
-
-// These bytes don't mean anything, they were generated randomly
-const MAGIC_BYTES = new Uint8Array([0x85, 0x6f, 0x4a, 0x83])
-
-const CHUNK_TYPE_DOCUMENT = 0
-const CHUNK_TYPE_CHANGE = 1
-const CHUNK_TYPE_DEFLATE = 2 // like CHUNK_TYPE_CHANGE but with DEFLATE compression
-
-// Minimum number of bytes in a value before we enable DEFLATE compression (there is no point
-// compressing very short values since compression may actually make them bigger)
-const DEFLATE_MIN_SIZE = 256
-
-// The least-significant 3 bits of a columnId indicate its datatype
-const COLUMN_TYPE = {
- GROUP_CARD: 0, ACTOR_ID: 1, INT_RLE: 2, INT_DELTA: 3, BOOLEAN: 4,
- STRING_RLE: 5, VALUE_LEN: 6, VALUE_RAW: 7
-}
-
-// The 4th-least-significant bit of a columnId is set if the column is DEFLATE-compressed
-const COLUMN_TYPE_DEFLATE = 8
-
-// In the values in a column of type VALUE_LEN, the bottom four bits indicate the type of the value,
-// one of the following types in VALUE_TYPE. The higher bits indicate the length of the value in the
-// associated VALUE_RAW column (in bytes).
-const VALUE_TYPE = {
- NULL: 0, FALSE: 1, TRUE: 2, LEB128_UINT: 3, LEB128_INT: 4, IEEE754: 5,
- UTF8: 6, BYTES: 7, COUNTER: 8, TIMESTAMP: 9, MIN_UNKNOWN: 10, MAX_UNKNOWN: 15
-}
-
-// make* actions must be at even-numbered indexes in this list
-const ACTIONS = ['makeMap', 'set', 'makeList', 'del', 'makeText', 'inc', 'makeTable', 'link']
-
-const OBJECT_TYPE = {makeMap: 'map', makeList: 'list', makeText: 'text', makeTable: 'table'}
-
-const COMMON_COLUMNS = [
- {columnName: 'objActor', columnId: 0 << 4 | COLUMN_TYPE.ACTOR_ID},
- {columnName: 'objCtr', columnId: 0 << 4 | COLUMN_TYPE.INT_RLE},
- {columnName: 'keyActor', columnId: 1 << 4 | COLUMN_TYPE.ACTOR_ID},
- {columnName: 'keyCtr', columnId: 1 << 4 | COLUMN_TYPE.INT_DELTA},
- {columnName: 'keyStr', columnId: 1 << 4 | COLUMN_TYPE.STRING_RLE},
- {columnName: 'idActor', columnId: 2 << 4 | COLUMN_TYPE.ACTOR_ID},
- {columnName: 'idCtr', columnId: 2 << 4 | COLUMN_TYPE.INT_DELTA},
- {columnName: 'insert', columnId: 3 << 4 | COLUMN_TYPE.BOOLEAN},
- {columnName: 'action', columnId: 4 << 4 | COLUMN_TYPE.INT_RLE},
- {columnName: 'valLen', columnId: 5 << 4 | COLUMN_TYPE.VALUE_LEN},
- {columnName: 'valRaw', columnId: 5 << 4 | COLUMN_TYPE.VALUE_RAW},
- {columnName: 'chldActor', columnId: 6 << 4 | COLUMN_TYPE.ACTOR_ID},
- {columnName: 'chldCtr', columnId: 6 << 4 | COLUMN_TYPE.INT_DELTA}
-]
-
-const CHANGE_COLUMNS = COMMON_COLUMNS.concat([
- {columnName: 'predNum', columnId: 7 << 4 | COLUMN_TYPE.GROUP_CARD},
- {columnName: 'predActor', columnId: 7 << 4 | COLUMN_TYPE.ACTOR_ID},
- {columnName: 'predCtr', columnId: 7 << 4 | COLUMN_TYPE.INT_DELTA}
-])
-
-const DOC_OPS_COLUMNS = COMMON_COLUMNS.concat([
- {columnName: 'succNum', columnId: 8 << 4 | COLUMN_TYPE.GROUP_CARD},
- {columnName: 'succActor', columnId: 8 << 4 | COLUMN_TYPE.ACTOR_ID},
- {columnName: 'succCtr', columnId: 8 << 4 | COLUMN_TYPE.INT_DELTA}
-])
-
-const DOCUMENT_COLUMNS = [
- {columnName: 'actor', columnId: 0 << 4 | COLUMN_TYPE.ACTOR_ID},
- {columnName: 'seq', columnId: 0 << 4 | COLUMN_TYPE.INT_DELTA},
- {columnName: 'maxOp', columnId: 1 << 4 | COLUMN_TYPE.INT_DELTA},
- {columnName: 'time', columnId: 2 << 4 | COLUMN_TYPE.INT_DELTA},
- {columnName: 'message', columnId: 3 << 4 | COLUMN_TYPE.STRING_RLE},
- {columnName: 'depsNum', columnId: 4 << 4 | COLUMN_TYPE.GROUP_CARD},
- {columnName: 'depsIndex', columnId: 4 << 4 | COLUMN_TYPE.INT_DELTA},
- {columnName: 'extraLen', columnId: 5 << 4 | COLUMN_TYPE.VALUE_LEN},
- {columnName: 'extraRaw', columnId: 5 << 4 | COLUMN_TYPE.VALUE_RAW}
-]
-
-/**
- * Maps an opId of the form {counter: 12345, actorId: 'someActorId'} to the form
- * {counter: 12345, actorNum: 123, actorId: 'someActorId'}, where the actorNum
- * is the index into the `actorIds` array.
- */
-function actorIdToActorNum(opId, actorIds) {
- if (!opId || !opId.actorId) return opId
- const counter = opId.counter
- const actorNum = actorIds.indexOf(opId.actorId)
- if (actorNum < 0) throw new RangeError('missing actorId') // should not happen
- return {counter, actorNum, actorId: opId.actorId}
-}
-
-/**
- * Comparison function to pass to Array.sort(), which compares two opIds in the
- * form produced by `actorIdToActorNum` so that they are sorted in increasing
- * Lamport timestamp order (sorted first by counter, then by actorId).
- */
-function compareParsedOpIds(id1, id2) {
- if (id1.counter < id2.counter) return -1
- if (id1.counter > id2.counter) return +1
- if (id1.actorId < id2.actorId) return -1
- if (id1.actorId > id2.actorId) return +1
- return 0
-}
-
-/**
- * Takes `changes`, an array of changes (represented as JS objects). Returns an
- * object `{changes, actorIds}`, where `changes` is a copy of the argument in
- * which all string opIds have been replaced with `{counter, actorNum}` objects,
- * and where `actorIds` is a lexicographically sorted array of actor IDs occurring
- * in any of the operations. `actorNum` is an index into that array of actorIds.
- * If `single` is true, the actorId of the author of the change is moved to the
- * beginning of the array of actorIds, so that `actorNum` is zero when referencing
- * the author of the change itself. This special-casing is omitted if `single` is
- * false.
- */
-function parseAllOpIds(changes, single) {
- const actors = {}, newChanges = []
- for (let change of changes) {
- change = copyObject(change)
- actors[change.actor] = true
- change.ops = expandMultiOps(change.ops, change.startOp, change.actor)
- change.ops = change.ops.map(op => {
- op = copyObject(op)
- if (op.obj !== '_root') op.obj = parseOpId(op.obj)
- if (op.elemId && op.elemId !== '_head') op.elemId = parseOpId(op.elemId)
- if (op.child) op.child = parseOpId(op.child)
- if (op.pred) op.pred = op.pred.map(parseOpId)
- if (op.obj.actorId) actors[op.obj.actorId] = true
- if (op.elemId && op.elemId.actorId) actors[op.elemId.actorId] = true
- if (op.child && op.child.actorId) actors[op.child.actorId] = true
- for (let pred of op.pred) actors[pred.actorId] = true
- return op
- })
- newChanges.push(change)
- }
-
- let actorIds = Object.keys(actors).sort()
- if (single) {
- actorIds = [changes[0].actor].concat(actorIds.filter(actor => actor !== changes[0].actor))
- }
- for (let change of newChanges) {
- change.actorNum = actorIds.indexOf(change.actor)
- for (let i = 0; i < change.ops.length; i++) {
- let op = change.ops[i]
- op.id = {counter: change.startOp + i, actorNum: change.actorNum, actorId: change.actor}
- op.obj = actorIdToActorNum(op.obj, actorIds)
- op.elemId = actorIdToActorNum(op.elemId, actorIds)
- op.child = actorIdToActorNum(op.child, actorIds)
- op.pred = op.pred.map(pred => actorIdToActorNum(pred, actorIds))
- }
- }
- return {changes: newChanges, actorIds}
-}
-
-/**
- * Encodes the `obj` property of operation `op` into the two columns
- * `objActor` and `objCtr`.
- */
-function encodeObjectId(op, columns) {
- if (op.obj === '_root') {
- columns.objActor.appendValue(null)
- columns.objCtr.appendValue(null)
- } else if (op.obj.actorNum >= 0 && op.obj.counter > 0) {
- columns.objActor.appendValue(op.obj.actorNum)
- columns.objCtr.appendValue(op.obj.counter)
- } else {
- throw new RangeError(`Unexpected objectId reference: ${JSON.stringify(op.obj)}`)
- }
-}
-
-/**
- * Encodes the `key` and `elemId` properties of operation `op` into the three
- * columns `keyActor`, `keyCtr`, and `keyStr`.
- */
-function encodeOperationKey(op, columns) {
- if (op.key) {
- columns.keyActor.appendValue(null)
- columns.keyCtr.appendValue(null)
- columns.keyStr.appendValue(op.key)
- } else if (op.elemId === '_head' && op.insert) {
- columns.keyActor.appendValue(null)
- columns.keyCtr.appendValue(0)
- columns.keyStr.appendValue(null)
- } else if (op.elemId && op.elemId.actorNum >= 0 && op.elemId.counter > 0) {
- columns.keyActor.appendValue(op.elemId.actorNum)
- columns.keyCtr.appendValue(op.elemId.counter)
- columns.keyStr.appendValue(null)
- } else {
- throw new RangeError(`Unexpected operation key: ${JSON.stringify(op)}`)
- }
-}
-
-/**
- * Encodes the `action` property of operation `op` into the `action` column.
- */
-function encodeOperationAction(op, columns) {
- const actionCode = ACTIONS.indexOf(op.action)
- if (actionCode >= 0) {
- columns.action.appendValue(actionCode)
- } else if (typeof op.action === 'number') {
- columns.action.appendValue(op.action)
- } else {
- throw new RangeError(`Unexpected operation action: ${op.action}`)
- }
-}
-
-/**
- * Encodes the integer `value` into the two columns `valLen` and `valRaw`,
- * with the datatype tag set to `typeTag`. If `typeTag` is zero, it is set
- * automatically to signed or unsigned depending on the sign of the value.
- * Values with non-zero type tags are always encoded as signed integers.
- */
-function encodeInteger(value, typeTag, columns) {
- let numBytes
- if (value < 0 || typeTag > 0) {
- numBytes = columns.valRaw.appendInt53(value)
- if (!typeTag) typeTag = VALUE_TYPE.LEB128_INT
- } else {
- numBytes = columns.valRaw.appendUint53(value)
- typeTag = VALUE_TYPE.LEB128_UINT
- }
- columns.valLen.appendValue(numBytes << 4 | typeTag)
-}
-
-/**
- * Encodes the `value` property of operation `op` into the two columns
- * `valLen` and `valRaw`.
- */
-function encodeValue(op, columns) {
- if ((op.action !== 'set' && op.action !== 'inc') || op.value === null) {
- columns.valLen.appendValue(VALUE_TYPE.NULL)
- } else if (op.value === false) {
- columns.valLen.appendValue(VALUE_TYPE.FALSE)
- } else if (op.value === true) {
- columns.valLen.appendValue(VALUE_TYPE.TRUE)
- } else if (typeof op.value === 'string') {
- const numBytes = columns.valRaw.appendRawString(op.value)
- columns.valLen.appendValue(numBytes << 4 | VALUE_TYPE.UTF8)
- } else if (ArrayBuffer.isView(op.value)) {
- const numBytes = columns.valRaw.appendRawBytes(new Uint8Array(op.value.buffer))
- columns.valLen.appendValue(numBytes << 4 | VALUE_TYPE.BYTES)
- } else if (op.datatype === 'counter' && typeof op.value === 'number') {
- encodeInteger(op.value, VALUE_TYPE.COUNTER, columns)
- } else if (op.datatype === 'timestamp' && typeof op.value === 'number') {
- encodeInteger(op.value, VALUE_TYPE.TIMESTAMP, columns)
- } else if (typeof op.datatype === 'number' && op.datatype >= VALUE_TYPE.MIN_UNKNOWN &&
- op.datatype <= VALUE_TYPE.MAX_UNKNOWN && op.value instanceof Uint8Array) {
- const numBytes = columns.valRaw.appendRawBytes(op.value)
- columns.valLen.appendValue(numBytes << 4 | op.datatype)
- } else if (op.datatype) {
- throw new RangeError(`Unknown datatype ${op.datatype} for value ${op.value}`)
- } else if (typeof op.value === 'number') {
- if (Number.isInteger(op.value) && op.value <= Number.MAX_SAFE_INTEGER && op.value >= Number.MIN_SAFE_INTEGER) {
- encodeInteger(op.value, 0, columns)
- } else {
- // Encode number in 32-bit float if this can be done without loss of precision
- const buf32 = new ArrayBuffer(4), view32 = new DataView(buf32)
- view32.setFloat32(0, op.value, true) // true means little-endian
- if (view32.getFloat32(0, true) === op.value) {
- columns.valRaw.appendRawBytes(new Uint8Array(buf32))
- columns.valLen.appendValue(4 << 4 | VALUE_TYPE.IEEE754)
- } else {
- const buf64 = new ArrayBuffer(8), view64 = new DataView(buf64)
- view64.setFloat64(0, op.value, true) // true means little-endian
- columns.valRaw.appendRawBytes(new Uint8Array(buf64))
- columns.valLen.appendValue(8 << 4 | VALUE_TYPE.IEEE754)
- }
- }
- } else {
- throw new RangeError(`Unsupported value in operation: ${op.value}`)
- }
-}
-
-/**
- * Given `sizeTag` (an unsigned integer read from a VALUE_LEN column) and `bytes` (a Uint8Array
- * read from a VALUE_RAW column, with length `sizeTag >> 4`), this function returns an object of the
- * form `{value: value, datatype: datatypeTag}` where `value` is a JavaScript primitive datatype
- * corresponding to the value, and `datatypeTag` is a datatype annotation such as 'counter'.
- */
-function decodeValue(sizeTag, bytes) {
- if (sizeTag === VALUE_TYPE.NULL) {
- return {value: null}
- } else if (sizeTag === VALUE_TYPE.FALSE) {
- return {value: false}
- } else if (sizeTag === VALUE_TYPE.TRUE) {
- return {value: true}
- } else if (sizeTag % 16 === VALUE_TYPE.UTF8) {
- return {value: utf8ToString(bytes)}
- } else {
- if (sizeTag % 16 === VALUE_TYPE.LEB128_UINT) {
- return {value: new Decoder(bytes).readUint53()}
- } else if (sizeTag % 16 === VALUE_TYPE.LEB128_INT) {
- return {value: new Decoder(bytes).readInt53()}
- } else if (sizeTag % 16 === VALUE_TYPE.IEEE754) {
- const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
- if (bytes.byteLength === 4) {
- return {value: view.getFloat32(0, true)} // true means little-endian
- } else if (bytes.byteLength === 8) {
- return {value: view.getFloat64(0, true)}
- } else {
- throw new RangeError(`Invalid length for floating point number: ${bytes.byteLength}`)
- }
- } else if (sizeTag % 16 === VALUE_TYPE.COUNTER) {
- return {value: new Decoder(bytes).readInt53(), datatype: 'counter'}
- } else if (sizeTag % 16 === VALUE_TYPE.TIMESTAMP) {
- return {value: new Decoder(bytes).readInt53(), datatype: 'timestamp'}
- } else {
- return {value: bytes, datatype: sizeTag % 16}
- }
- }
-}
-
-/**
- * Reads one value from the column `columns[colIndex]` and interprets it based
- * on the column type. `actorIds` is a list of actors that appear in the change;
- * `actorIds[0]` is the actorId of the change's author. Mutates the `result`
- * object with the value, and returns the number of columns processed (this is 2
- * in the case of a pair of VALUE_LEN and VALUE_RAW columns, which are processed
- * in one go).
- */
-function decodeValueColumns(columns, colIndex, actorIds, result) {
- const { columnId, columnName, decoder } = columns[colIndex]
- if (columnId % 8 === COLUMN_TYPE.VALUE_LEN && colIndex + 1 < columns.length &&
- columns[colIndex + 1].columnId === columnId + 1) {
- const sizeTag = decoder.readValue()
- const rawValue = columns[colIndex + 1].decoder.readRawBytes(sizeTag >> 4)
- const { value, datatype } = decodeValue(sizeTag, rawValue)
- result[columnName] = value
- if (datatype) result[columnName + '_datatype'] = datatype
- return 2
- } else if (columnId % 8 === COLUMN_TYPE.ACTOR_ID) {
- const actorNum = decoder.readValue()
- if (actorNum === null) {
- result[columnName] = null
- } else {
- if (!actorIds[actorNum]) throw new RangeError(`No actor index ${actorNum}`)
- result[columnName] = actorIds[actorNum]
- }
- } else {
- result[columnName] = decoder.readValue()
- }
- return 1
-}
-
-/**
- * Encodes an array of operations in a set of columns. The operations need to
- * be parsed with `parseAllOpIds()` beforehand. If `forDocument` is true, we use
- * the column structure of a whole document, otherwise we use the column
- * structure for an individual change. Returns an array of `{id, name, encoder}`
- * objects.
- */
-function encodeOps(ops, forDocument) {
- const columns = {
- objActor : new RLEEncoder('uint'),
- objCtr : new RLEEncoder('uint'),
- keyActor : new RLEEncoder('uint'),
- keyCtr : new DeltaEncoder(),
- keyStr : new RLEEncoder('utf8'),
- insert : new BooleanEncoder(),
- action : new RLEEncoder('uint'),
- valLen : new RLEEncoder('uint'),
- valRaw : new Encoder(),
- chldActor : new RLEEncoder('uint'),
- chldCtr : new DeltaEncoder()
- }
-
- if (forDocument) {
- columns.idActor = new RLEEncoder('uint')
- columns.idCtr = new DeltaEncoder()
- columns.succNum = new RLEEncoder('uint')
- columns.succActor = new RLEEncoder('uint')
- columns.succCtr = new DeltaEncoder()
- } else {
- columns.predNum = new RLEEncoder('uint')
- columns.predCtr = new DeltaEncoder()
- columns.predActor = new RLEEncoder('uint')
- }
-
- for (let op of ops) {
- encodeObjectId(op, columns)
- encodeOperationKey(op, columns)
- columns.insert.appendValue(!!op.insert)
- encodeOperationAction(op, columns)
- encodeValue(op, columns)
-
- if (op.child && op.child.counter) {
- columns.chldActor.appendValue(op.child.actorNum)
- columns.chldCtr.appendValue(op.child.counter)
- } else {
- columns.chldActor.appendValue(null)
- columns.chldCtr.appendValue(null)
- }
-
- if (forDocument) {
- columns.idActor.appendValue(op.id.actorNum)
- columns.idCtr.appendValue(op.id.counter)
- columns.succNum.appendValue(op.succ.length)
- op.succ.sort(compareParsedOpIds)
- for (let i = 0; i < op.succ.length; i++) {
- columns.succActor.appendValue(op.succ[i].actorNum)
- columns.succCtr.appendValue(op.succ[i].counter)
- }
- } else {
- columns.predNum.appendValue(op.pred.length)
- op.pred.sort(compareParsedOpIds)
- for (let i = 0; i < op.pred.length; i++) {
- columns.predActor.appendValue(op.pred[i].actorNum)
- columns.predCtr.appendValue(op.pred[i].counter)
- }
- }
- }
-
- let columnList = []
- for (let {columnName, columnId} of forDocument ? DOC_OPS_COLUMNS : CHANGE_COLUMNS) {
- if (columns[columnName]) columnList.push({id: columnId, name: columnName, encoder: columns[columnName]})
- }
- return columnList.sort((a, b) => a.id - b.id)
-}
-
-function expandMultiOps(ops, startOp, actor) {
- let opNum = startOp
- let expandedOps = []
- for (const op of ops) {
- if (op.action === 'set' && op.values && op.insert) {
- if (op.pred.length !== 0) throw new RangeError('multi-insert pred must be empty')
- let lastElemId = op.elemId
- for (const value of op.values) {
- expandedOps.push({action: 'set', obj: op.obj, elemId: lastElemId, value, pred: [], insert: true})
- lastElemId = `${opNum}@${actor}`
- opNum += 1
- }
- } else if (op.action === 'del' && op.multiOp > 1) {
- if (op.pred.length !== 1) throw new RangeError('multiOp deletion must have exactly one pred')
- const startElemId = parseOpId(op.elemId), startPred = parseOpId(op.pred[0])
- for (let i = 0; i < op.multiOp; i++) {
- const elemId = `${startElemId.counter + i}@${startElemId.actorId}`
- const pred = [`${startPred.counter + i}@${startPred.actorId}`]
- expandedOps.push({action: 'del', obj: op.obj, elemId, pred})
- opNum += 1
- }
- } else {
- expandedOps.push(op)
- opNum += 1
- }
- }
- return expandedOps
-}
-
-/**
- * Takes a change as decoded by `decodeColumns`, and changes it into the form
- * expected by the rest of the backend. If `forDocument` is true, we use the op
- * structure of a whole document, otherwise we use the op structure for an
- * individual change.
- */
-function decodeOps(ops, forDocument) {
- const newOps = []
- for (let op of ops) {
- const obj = (op.objCtr === null) ? '_root' : `${op.objCtr}@${op.objActor}`
- const elemId = op.keyStr ? undefined : (op.keyCtr === 0 ? '_head' : `${op.keyCtr}@${op.keyActor}`)
- const action = ACTIONS[op.action] || op.action
- const newOp = elemId ? {obj, elemId, action} : {obj, key: op.keyStr, action}
- newOp.insert = !!op.insert
- if (ACTIONS[op.action] === 'set' || ACTIONS[op.action] === 'inc') {
- newOp.value = op.valLen
- if (op.valLen_datatype) newOp.datatype = op.valLen_datatype
- }
- if (!!op.chldCtr !== !!op.chldActor) {
- throw new RangeError(`Mismatched child columns: ${op.chldCtr} and ${op.chldActor}`)
- }
- if (op.chldCtr !== null) newOp.child = `${op.chldCtr}@${op.chldActor}`
- if (forDocument) {
- newOp.id = `${op.idCtr}@${op.idActor}`
- newOp.succ = op.succNum.map(succ => `${succ.succCtr}@${succ.succActor}`)
- checkSortedOpIds(op.succNum.map(succ => ({counter: succ.succCtr, actorId: succ.succActor})))
- } else {
- newOp.pred = op.predNum.map(pred => `${pred.predCtr}@${pred.predActor}`)
- checkSortedOpIds(op.predNum.map(pred => ({counter: pred.predCtr, actorId: pred.predActor})))
- }
- newOps.push(newOp)
- }
- return newOps
-}
-
-/**
- * Throws an exception if the opIds in the given array are not in sorted order.
- */
-function checkSortedOpIds(opIds) {
- let last = null
- for (let opId of opIds) {
- if (last && compareParsedOpIds(last, opId) !== -1) {
- throw new RangeError('operation IDs are not in ascending order')
- }
- last = opId
- }
-}
-
-function encoderByColumnId(columnId) {
- if ((columnId & 7) === COLUMN_TYPE.INT_DELTA) {
- return new DeltaEncoder()
- } else if ((columnId & 7) === COLUMN_TYPE.BOOLEAN) {
- return new BooleanEncoder()
- } else if ((columnId & 7) === COLUMN_TYPE.STRING_RLE) {
- return new RLEEncoder('utf8')
- } else if ((columnId & 7) === COLUMN_TYPE.VALUE_RAW) {
- return new Encoder()
- } else {
- return new RLEEncoder('uint')
- }
-}
-
-function decoderByColumnId(columnId, buffer) {
- if ((columnId & 7) === COLUMN_TYPE.INT_DELTA) {
- return new DeltaDecoder(buffer)
- } else if ((columnId & 7) === COLUMN_TYPE.BOOLEAN) {
- return new BooleanDecoder(buffer)
- } else if ((columnId & 7) === COLUMN_TYPE.STRING_RLE) {
- return new RLEDecoder('utf8', buffer)
- } else if ((columnId & 7) === COLUMN_TYPE.VALUE_RAW) {
- return new Decoder(buffer)
- } else {
- return new RLEDecoder('uint', buffer)
- }
-}
-
-function makeDecoders(columns, columnSpec) {
- const emptyBuf = new Uint8Array(0)
- let decoders = [], columnIndex = 0, specIndex = 0
-
- while (columnIndex < columns.length || specIndex < columnSpec.length) {
- if (columnIndex === columns.length ||
- (specIndex < columnSpec.length && columnSpec[specIndex].columnId < columns[columnIndex].columnId)) {
- const {columnId, columnName} = columnSpec[specIndex]
- decoders.push({columnId, columnName, decoder: decoderByColumnId(columnId, emptyBuf)})
- specIndex++
- } else if (specIndex === columnSpec.length || columns[columnIndex].columnId < columnSpec[specIndex].columnId) {
- const {columnId, buffer} = columns[columnIndex]
- decoders.push({columnId, decoder: decoderByColumnId(columnId, buffer)})
- columnIndex++
- } else { // columns[columnIndex].columnId === columnSpec[specIndex].columnId
- const {columnId, buffer} = columns[columnIndex], {columnName} = columnSpec[specIndex]
- decoders.push({columnId, columnName, decoder: decoderByColumnId(columnId, buffer)})
- columnIndex++
- specIndex++
- }
- }
- return decoders
-}
-
-function decodeColumns(columns, actorIds, columnSpec) {
- columns = makeDecoders(columns, columnSpec)
- let parsedRows = []
- while (columns.some(col => !col.decoder.done)) {
- let row = {}, col = 0
- while (col < columns.length) {
- const columnId = columns[col].columnId
- let groupId = columnId >> 4, groupCols = 1
- while (col + groupCols < columns.length && columns[col + groupCols].columnId >> 4 === groupId) {
- groupCols++
- }
-
- if (columnId % 8 === COLUMN_TYPE.GROUP_CARD) {
- const values = [], count = columns[col].decoder.readValue()
- for (let i = 0; i < count; i++) {
- let value = {}
- for (let colOffset = 1; colOffset < groupCols; colOffset++) {
- decodeValueColumns(columns, col + colOffset, actorIds, value)
- }
- values.push(value)
- }
- row[columns[col].columnName] = values
- col += groupCols
- } else {
- col += decodeValueColumns(columns, col, actorIds, row)
- }
- }
- parsedRows.push(row)
- }
- return parsedRows
-}
-
-function decodeColumnInfo(decoder) {
- // A number that is all 1 bits except for the bit that indicates whether a column is
- // deflate-compressed. We ignore this bit when checking whether columns are sorted by ID.
- const COLUMN_ID_MASK = (-1 ^ COLUMN_TYPE_DEFLATE) >>> 0
-
- let lastColumnId = -1, columns = [], numColumns = decoder.readUint53()
- for (let i = 0; i < numColumns; i++) {
- const columnId = decoder.readUint53(), bufferLen = decoder.readUint53()
- if ((columnId & COLUMN_ID_MASK) <= (lastColumnId & COLUMN_ID_MASK)) {
- throw new RangeError('Columns must be in ascending order')
- }
- lastColumnId = columnId
- columns.push({columnId, bufferLen})
- }
- return columns
-}
-
-function encodeColumnInfo(encoder, columns) {
- const nonEmptyColumns = columns.filter(column => column.encoder.buffer.byteLength > 0)
- encoder.appendUint53(nonEmptyColumns.length)
- for (let column of nonEmptyColumns) {
- encoder.appendUint53(column.id)
- encoder.appendUint53(column.encoder.buffer.byteLength)
- }
-}
-
-function decodeChangeHeader(decoder) {
- const numDeps = decoder.readUint53(), deps = []
- for (let i = 0; i < numDeps; i++) {
- deps.push(bytesToHexString(decoder.readRawBytes(32)))
- }
- let change = {
- actor: decoder.readHexString(),
- seq: decoder.readUint53(),
- startOp: decoder.readUint53(),
- time: decoder.readInt53(),
- message: decoder.readPrefixedString(),
- deps
- }
- const actorIds = [change.actor], numActorIds = decoder.readUint53()
- for (let i = 0; i < numActorIds; i++) actorIds.push(decoder.readHexString())
- change.actorIds = actorIds
- return change
-}
-
-/**
- * Assembles a chunk of encoded data containing a checksum, headers, and a
- * series of encoded columns. Calls `encodeHeaderCallback` with an encoder that
- * should be used to add the headers. The columns should be given as `columns`.
- */
-function encodeContainer(chunkType, encodeContentsCallback) {
- const CHECKSUM_SIZE = 4 // checksum is first 4 bytes of SHA-256 hash of the rest of the data
- const HEADER_SPACE = MAGIC_BYTES.byteLength + CHECKSUM_SIZE + 1 + 5 // 1 byte type + 5 bytes length
- const body = new Encoder()
- // Make space for the header at the beginning of the body buffer. We will
- // copy the header in here later. This is cheaper than copying the body since
- // the body is likely to be much larger than the header.
- body.appendRawBytes(new Uint8Array(HEADER_SPACE))
- encodeContentsCallback(body)
-
- const bodyBuf = body.buffer
- const header = new Encoder()
- header.appendByte(chunkType)
- header.appendUint53(bodyBuf.byteLength - HEADER_SPACE)
-
- // Compute the hash over chunkType, length, and body
- const headerBuf = header.buffer
- const sha256 = new Hash()
- sha256.update(headerBuf)
- sha256.update(bodyBuf.subarray(HEADER_SPACE))
- const hash = sha256.digest(), checksum = hash.subarray(0, CHECKSUM_SIZE)
-
- // Copy header into the body buffer so that they are contiguous
- bodyBuf.set(MAGIC_BYTES, HEADER_SPACE - headerBuf.byteLength - CHECKSUM_SIZE - MAGIC_BYTES.byteLength)
- bodyBuf.set(checksum, HEADER_SPACE - headerBuf.byteLength - CHECKSUM_SIZE)
- bodyBuf.set(headerBuf, HEADER_SPACE - headerBuf.byteLength)
- return {hash, bytes: bodyBuf.subarray(HEADER_SPACE - headerBuf.byteLength - CHECKSUM_SIZE - MAGIC_BYTES.byteLength)}
-}
-
-function decodeContainerHeader(decoder, computeHash) {
- if (!equalBytes(decoder.readRawBytes(MAGIC_BYTES.byteLength), MAGIC_BYTES)) {
- throw new RangeError('Data does not begin with magic bytes 85 6f 4a 83')
- }
- const expectedHash = decoder.readRawBytes(4)
- const hashStartOffset = decoder.offset
- const chunkType = decoder.readByte()
- const chunkLength = decoder.readUint53()
- const header = {chunkType, chunkLength, chunkData: decoder.readRawBytes(chunkLength)}
-
- if (computeHash) {
- const sha256 = new Hash()
- sha256.update(decoder.buf.subarray(hashStartOffset, decoder.offset))
- const binaryHash = sha256.digest()
- if (!equalBytes(binaryHash.subarray(0, 4), expectedHash)) {
- throw new RangeError('checksum does not match data')
- }
- header.hash = bytesToHexString(binaryHash)
- }
- return header
-}
-
-/**
- * Returns the checksum of a change (bytes 4 to 7) as a 32-bit unsigned integer.
- */
-function getChangeChecksum(change) {
- if (change[0] !== MAGIC_BYTES[0] || change[1] !== MAGIC_BYTES[1] ||
- change[2] !== MAGIC_BYTES[2] || change[3] !== MAGIC_BYTES[3]) {
- throw new RangeError('Data does not begin with magic bytes 85 6f 4a 83')
- }
- return ((change[4] << 24) | (change[5] << 16) | (change[6] << 8) | change[7]) >>> 0
-}
-
-function encodeChange(changeObj) {
- const { changes, actorIds } = parseAllOpIds([changeObj], true)
- const change = changes[0]
-
- const { hash, bytes } = encodeContainer(CHUNK_TYPE_CHANGE, encoder => {
- if (!Array.isArray(change.deps)) throw new TypeError('deps is not an array')
- encoder.appendUint53(change.deps.length)
- for (let hash of change.deps.slice().sort()) {
- encoder.appendRawBytes(hexStringToBytes(hash))
- }
- encoder.appendHexString(change.actor)
- encoder.appendUint53(change.seq)
- encoder.appendUint53(change.startOp)
- encoder.appendInt53(change.time)
- encoder.appendPrefixedString(change.message || '')
- encoder.appendUint53(actorIds.length - 1)
- for (let actor of actorIds.slice(1)) encoder.appendHexString(actor)
-
- const columns = encodeOps(change.ops, false)
- encodeColumnInfo(encoder, columns)
- for (let column of columns) encoder.appendRawBytes(column.encoder.buffer)
- if (change.extraBytes) encoder.appendRawBytes(change.extraBytes)
- })
-
- const hexHash = bytesToHexString(hash)
- if (changeObj.hash && changeObj.hash !== hexHash) {
- throw new RangeError(`Change hash does not match encoding: ${changeObj.hash} != ${hexHash}`)
- }
- return (bytes.byteLength >= DEFLATE_MIN_SIZE) ? deflateChange(bytes) : bytes
-}
-
-function decodeChangeColumns(buffer) {
- if (buffer[8] === CHUNK_TYPE_DEFLATE) buffer = inflateChange(buffer)
- const decoder = new Decoder(buffer)
- const header = decodeContainerHeader(decoder, true)
- const chunkDecoder = new Decoder(header.chunkData)
- if (!decoder.done) throw new RangeError('Encoded change has trailing data')
- if (header.chunkType !== CHUNK_TYPE_CHANGE) throw new RangeError(`Unexpected chunk type: ${header.chunkType}`)
-
- const change = decodeChangeHeader(chunkDecoder)
- const columns = decodeColumnInfo(chunkDecoder)
- for (let i = 0; i < columns.length; i++) {
- if ((columns[i].columnId & COLUMN_TYPE_DEFLATE) !== 0) {
- throw new RangeError('change must not contain deflated columns')
- }
- columns[i].buffer = chunkDecoder.readRawBytes(columns[i].bufferLen)
- }
- if (!chunkDecoder.done) {
- const restLen = chunkDecoder.buf.byteLength - chunkDecoder.offset
- change.extraBytes = chunkDecoder.readRawBytes(restLen)
- }
-
- change.columns = columns
- change.hash = header.hash
- return change
-}
-
-/**
- * Decodes one change in binary format into its JS object representation.
- */
-function decodeChange(buffer) {
- const change = decodeChangeColumns(buffer)
- change.ops = decodeOps(decodeColumns(change.columns, change.actorIds, CHANGE_COLUMNS), false)
- delete change.actorIds
- delete change.columns
- return change
-}
-
-/**
- * Decodes the header fields of a change in binary format, but does not decode
- * the operations. Saves work when we only need to inspect the headers. Only
- * computes the hash of the change if `computeHash` is true.
- */
-function decodeChangeMeta(buffer, computeHash) {
- if (buffer[8] === CHUNK_TYPE_DEFLATE) buffer = inflateChange(buffer)
- const header = decodeContainerHeader(new Decoder(buffer), computeHash)
- if (header.chunkType !== CHUNK_TYPE_CHANGE) {
- throw new RangeError('Buffer chunk type is not a change')
- }
- const meta = decodeChangeHeader(new Decoder(header.chunkData))
- meta.change = buffer
- if (computeHash) meta.hash = header.hash
- return meta
-}
-
-/**
- * Compresses a binary change using DEFLATE.
- */
-function deflateChange(buffer) {
- const header = decodeContainerHeader(new Decoder(buffer), false)
- if (header.chunkType !== CHUNK_TYPE_CHANGE) throw new RangeError(`Unexpected chunk type: ${header.chunkType}`)
- const compressed = pako.deflateRaw(header.chunkData)
- const encoder = new Encoder()
- encoder.appendRawBytes(buffer.subarray(0, 8)) // copy MAGIC_BYTES and checksum
- encoder.appendByte(CHUNK_TYPE_DEFLATE)
- encoder.appendUint53(compressed.byteLength)
- encoder.appendRawBytes(compressed)
- return encoder.buffer
-}
-
-/**
- * Decompresses a binary change that has been compressed with DEFLATE.
- */
-function inflateChange(buffer) {
- const header = decodeContainerHeader(new Decoder(buffer), false)
- if (header.chunkType !== CHUNK_TYPE_DEFLATE) throw new RangeError(`Unexpected chunk type: ${header.chunkType}`)
- const decompressed = pako.inflateRaw(header.chunkData)
- const encoder = new Encoder()
- encoder.appendRawBytes(buffer.subarray(0, 8)) // copy MAGIC_BYTES and checksum
- encoder.appendByte(CHUNK_TYPE_CHANGE)
- encoder.appendUint53(decompressed.byteLength)
- encoder.appendRawBytes(decompressed)
- return encoder.buffer
-}
-
-/**
- * Takes an Uint8Array that may contain multiple concatenated changes, and
- * returns an array of subarrays, each subarray containing one change.
- */
-function splitContainers(buffer) {
- let decoder = new Decoder(buffer), chunks = [], startOffset = 0
- while (!decoder.done) {
- decodeContainerHeader(decoder, false)
- chunks.push(buffer.subarray(startOffset, decoder.offset))
- startOffset = decoder.offset
- }
- return chunks
-}
-
-/**
- * Decodes a list of changes from the binary format into JS objects.
- * `binaryChanges` is an array of `Uint8Array` objects.
- */
-function decodeChanges(binaryChanges) {
- let decoded = []
- for (let binaryChange of binaryChanges) {
- for (let chunk of splitContainers(binaryChange)) {
- if (chunk[8] === CHUNK_TYPE_DOCUMENT) {
- decoded = decoded.concat(decodeDocument(chunk))
- } else if (chunk[8] === CHUNK_TYPE_CHANGE || chunk[8] === CHUNK_TYPE_DEFLATE) {
- decoded.push(decodeChange(chunk))
- } else {
- // ignoring chunk of unknown type
- }
- }
- }
- return decoded
-}
-
-function sortOpIds(a, b) {
- if (a === b) return 0
- if (a === '_root') return -1
- if (b === '_root') return +1
- const a_ = parseOpId(a), b_ = parseOpId(b)
- if (a_.counter < b_.counter) return -1
- if (a_.counter > b_.counter) return +1
- if (a_.actorId < b_.actorId) return -1
- if (a_.actorId > b_.actorId) return +1
- return 0
-}
-
-function groupDocumentOps(changes) {
- let byObjectId = {}, byReference = {}, objectType = {}
- for (let change of changes) {
- for (let i = 0; i < change.ops.length; i++) {
- const op = change.ops[i], opId = `${op.id.counter}@${op.id.actorId}`
- const objectId = (op.obj === '_root') ? '_root' : `${op.obj.counter}@${op.obj.actorId}`
- if (op.action.startsWith('make')) {
- objectType[opId] = op.action
- if (op.action === 'makeList' || op.action === 'makeText') {
- byReference[opId] = {'_head': []}
- }
- }
-
- let key
- if (objectId === '_root' || objectType[objectId] === 'makeMap' || objectType[objectId] === 'makeTable') {
- key = op.key
- } else if (objectType[objectId] === 'makeList' || objectType[objectId] === 'makeText') {
- if (op.insert) {
- key = opId
- const ref = (op.elemId === '_head') ? '_head' : `${op.elemId.counter}@${op.elemId.actorId}`
- byReference[objectId][ref].push(opId)
- byReference[objectId][opId] = []
- } else {
- key = `${op.elemId.counter}@${op.elemId.actorId}`
- }
- } else {
- throw new RangeError(`Unknown object type for object ${objectId}`)
- }
-
- if (!byObjectId[objectId]) byObjectId[objectId] = {}
- if (!byObjectId[objectId][key]) byObjectId[objectId][key] = {}
- byObjectId[objectId][key][opId] = op
- op.succ = []
-
- for (let pred of op.pred) {
- const predId = `${pred.counter}@${pred.actorId}`
- if (!byObjectId[objectId][key][predId]) {
- throw new RangeError(`No predecessor operation ${predId}`)
- }
- byObjectId[objectId][key][predId].succ.push(op.id)
- }
- }
- }
-
- let ops = []
- for (let objectId of Object.keys(byObjectId).sort(sortOpIds)) {
- let keys = []
- if (objectType[objectId] === 'makeList' || objectType[objectId] === 'makeText') {
- let stack = ['_head']
- while (stack.length > 0) {
- const key = stack.pop()
- if (key !== '_head') keys.push(key)
- for (let opId of byReference[objectId][key].sort(sortOpIds)) stack.push(opId)
- }
- } else {
- // FIXME JavaScript sorts based on UTF-16 encoding. We should change this to use the UTF-8
- // encoding instead (the sort order will be different beyond the basic multilingual plane)
- keys = Object.keys(byObjectId[objectId]).sort()
- }
-
- for (let key of keys) {
- for (let opId of Object.keys(byObjectId[objectId][key]).sort(sortOpIds)) {
- const op = byObjectId[objectId][key][opId]
- if (op.action !== 'del') ops.push(op)
- }
- }
- }
- return ops
-}
-
-/**
- * Takes a set of operations `ops` loaded from an encoded document, and
- * reconstructs the changes that they originally came from.
- * Does not return anything, only mutates `changes`.
- */
-function groupChangeOps(changes, ops) {
- let changesByActor = {} // map from actorId to array of changes by that actor
- for (let change of changes) {
- change.ops = []
- if (!changesByActor[change.actor]) changesByActor[change.actor] = []
- if (change.seq !== changesByActor[change.actor].length + 1) {
- throw new RangeError(`Expected seq = ${changesByActor[change.actor].length + 1}, got ${change.seq}`)
- }
- if (change.seq > 1 && changesByActor[change.actor][change.seq - 2].maxOp > change.maxOp) {
- throw new RangeError('maxOp must increase monotonically per actor')
- }
- changesByActor[change.actor].push(change)
- }
-
- let opsById = {}
- for (let op of ops) {
- if (op.action === 'del') throw new RangeError('document should not contain del operations')
- op.pred = opsById[op.id] ? opsById[op.id].pred : []
- opsById[op.id] = op
- for (let succ of op.succ) {
- if (!opsById[succ]) {
- if (op.elemId) {
- const elemId = op.insert ? op.id : op.elemId
- opsById[succ] = {id: succ, action: 'del', obj: op.obj, elemId, pred: []}
- } else {
- opsById[succ] = {id: succ, action: 'del', obj: op.obj, key: op.key, pred: []}
- }
- }
- opsById[succ].pred.push(op.id)
- }
- delete op.succ
- }
- for (let op of Object.values(opsById)) {
- if (op.action === 'del') ops.push(op)
- }
-
- for (let op of ops) {
- const { counter, actorId } = parseOpId(op.id)
- const actorChanges = changesByActor[actorId]
- // Binary search to find the change that should contain this operation
- let left = 0, right = actorChanges.length
- while (left < right) {
- const index = Math.floor((left + right) / 2)
- if (actorChanges[index].maxOp < counter) {
- left = index + 1
- } else {
- right = index
- }
- }
- if (left >= actorChanges.length) {
- throw new RangeError(`Operation ID ${op.id} outside of allowed range`)
- }
- actorChanges[left].ops.push(op)
- }
-
- for (let change of changes) {
- change.ops.sort((op1, op2) => sortOpIds(op1.id, op2.id))
- change.startOp = change.maxOp - change.ops.length + 1
- delete change.maxOp
- for (let i = 0; i < change.ops.length; i++) {
- const op = change.ops[i], expectedId = `${change.startOp + i}@${change.actor}`
- if (op.id !== expectedId) {
- throw new RangeError(`Expected opId ${expectedId}, got ${op.id}`)
- }
- delete op.id
- }
- }
-}
-
-function encodeDocumentChanges(changes) {
- const columns = { // see DOCUMENT_COLUMNS
- actor : new RLEEncoder('uint'),
- seq : new DeltaEncoder(),
- maxOp : new DeltaEncoder(),
- time : new DeltaEncoder(),
- message : new RLEEncoder('utf8'),
- depsNum : new RLEEncoder('uint'),
- depsIndex : new DeltaEncoder(),
- extraLen : new RLEEncoder('uint'),
- extraRaw : new Encoder()
- }
- let indexByHash = {} // map from change hash to its index in the changes array
- let heads = {} // change hashes that are not a dependency of any other change
-
- for (let i = 0; i < changes.length; i++) {
- const change = changes[i]
- indexByHash[change.hash] = i
- heads[change.hash] = true
-
- columns.actor.appendValue(change.actorNum)
- columns.seq.appendValue(change.seq)
- columns.maxOp.appendValue(change.startOp + change.ops.length - 1)
- columns.time.appendValue(change.time)
- columns.message.appendValue(change.message)
- columns.depsNum.appendValue(change.deps.length)
-
- for (let dep of change.deps) {
- if (typeof indexByHash[dep] !== 'number') {
- throw new RangeError(`Unknown dependency hash: ${dep}`)
- }
- columns.depsIndex.appendValue(indexByHash[dep])
- if (heads[dep]) delete heads[dep]
- }
-
- if (change.extraBytes) {
- columns.extraLen.appendValue(change.extraBytes.byteLength << 4 | VALUE_TYPE.BYTES)
- columns.extraRaw.appendRawBytes(change.extraBytes)
- } else {
- columns.extraLen.appendValue(VALUE_TYPE.BYTES) // zero-length byte array
- }
- }
-
- let changesColumns = []
- for (let {columnName, columnId} of DOCUMENT_COLUMNS) {
- changesColumns.push({id: columnId, name: columnName, encoder: columns[columnName]})
- }
- changesColumns.sort((a, b) => a.id - b.id)
- return { changesColumns, heads: Object.keys(heads).sort() }
-}
-
-function decodeDocumentChanges(changes, expectedHeads) {
- let heads = {} // change hashes that are not a dependency of any other change
- for (let i = 0; i < changes.length; i++) {
- let change = changes[i]
- change.deps = []
- for (let index of change.depsNum.map(d => d.depsIndex)) {
- if (!changes[index] || !changes[index].hash) {
- throw new RangeError(`No hash for index ${index} while processing index ${i}`)
- }
- const hash = changes[index].hash
- change.deps.push(hash)
- if (heads[hash]) delete heads[hash]
- }
- change.deps.sort()
- delete change.depsNum
-
- if (change.extraLen_datatype !== VALUE_TYPE.BYTES) {
- throw new RangeError(`Bad datatype for extra bytes: ${VALUE_TYPE.BYTES}`)
- }
- change.extraBytes = change.extraLen
- delete change.extraLen_datatype
-
- // Encoding and decoding again to compute the hash of the change
- changes[i] = decodeChange(encodeChange(change))
- heads[changes[i].hash] = true
- }
-
- const actualHeads = Object.keys(heads).sort()
- let headsEqual = (actualHeads.length === expectedHeads.length), i = 0
- while (headsEqual && i < actualHeads.length) {
- headsEqual = (actualHeads[i] === expectedHeads[i])
- i++
- }
- if (!headsEqual) {
- throw new RangeError(`Mismatched heads hashes: expected ${expectedHeads.join(', ')}, got ${actualHeads.join(', ')}`)
- }
-}
-
-/**
- * Transforms a list of changes into a binary representation of the document state.
- */
-function encodeDocument(binaryChanges) {
- const { changes, actorIds } = parseAllOpIds(decodeChanges(binaryChanges), false)
- const { changesColumns, heads } = encodeDocumentChanges(changes)
- const opsColumns = encodeOps(groupDocumentOps(changes), true)
- for (let column of changesColumns) deflateColumn(column)
- for (let column of opsColumns) deflateColumn(column)
-
- return encodeContainer(CHUNK_TYPE_DOCUMENT, encoder => {
- encoder.appendUint53(actorIds.length)
- for (let actor of actorIds) {
- encoder.appendHexString(actor)
- }
- encoder.appendUint53(heads.length)
- for (let head of heads.sort()) {
- encoder.appendRawBytes(hexStringToBytes(head))
- }
- encodeColumnInfo(encoder, changesColumns)
- encodeColumnInfo(encoder, opsColumns)
- for (let column of changesColumns) encoder.appendRawBytes(column.encoder.buffer)
- for (let column of opsColumns) encoder.appendRawBytes(column.encoder.buffer)
- }).bytes
-}
-
-function decodeDocumentHeader(buffer) {
- const documentDecoder = new Decoder(buffer)
- const header = decodeContainerHeader(documentDecoder, true)
- const decoder = new Decoder(header.chunkData)
- if (!documentDecoder.done) throw new RangeError('Encoded document has trailing data')
- if (header.chunkType !== CHUNK_TYPE_DOCUMENT) throw new RangeError(`Unexpected chunk type: ${header.chunkType}`)
-
- const actorIds = [], numActors = decoder.readUint53()
- for (let i = 0; i < numActors; i++) {
- actorIds.push(decoder.readHexString())
- }
- const heads = [], numHeads = decoder.readUint53()
- for (let i = 0; i < numHeads; i++) {
- heads.push(bytesToHexString(decoder.readRawBytes(32)))
- }
-
- const changesColumns = decodeColumnInfo(decoder)
- const opsColumns = decodeColumnInfo(decoder)
- for (let i = 0; i < changesColumns.length; i++) {
- changesColumns[i].buffer = decoder.readRawBytes(changesColumns[i].bufferLen)
- inflateColumn(changesColumns[i])
- }
- for (let i = 0; i < opsColumns.length; i++) {
- opsColumns[i].buffer = decoder.readRawBytes(opsColumns[i].bufferLen)
- inflateColumn(opsColumns[i])
- }
-
- const extraBytes = decoder.readRawBytes(decoder.buf.byteLength - decoder.offset)
- return { changesColumns, opsColumns, actorIds, heads, extraBytes }
-}
-
-function decodeDocument(buffer) {
- const { changesColumns, opsColumns, actorIds, heads } = decodeDocumentHeader(buffer)
- const changes = decodeColumns(changesColumns, actorIds, DOCUMENT_COLUMNS)
- const ops = decodeOps(decodeColumns(opsColumns, actorIds, DOC_OPS_COLUMNS), true)
- groupChangeOps(changes, ops)
- decodeDocumentChanges(changes, heads)
- return changes
-}
-
-/**
- * DEFLATE-compresses the given column if it is large enough to make the compression worthwhile.
- */
-function deflateColumn(column) {
- if (column.encoder.buffer.byteLength >= DEFLATE_MIN_SIZE) {
- column.encoder = {buffer: pako.deflateRaw(column.encoder.buffer)}
- column.id |= COLUMN_TYPE_DEFLATE
- }
-}
-
-/**
- * Decompresses the given column if it is DEFLATE-compressed.
- */
-function inflateColumn(column) {
- if ((column.columnId & COLUMN_TYPE_DEFLATE) !== 0) {
- column.buffer = pako.inflateRaw(column.buffer)
- column.columnId ^= COLUMN_TYPE_DEFLATE
- }
-}
-
-/**
- * Takes all the operations for the same property (i.e. the same key in a map, or the same list
- * element) and mutates the object patch to reflect the current value(s) of that property. There
- * might be multiple values in the case of a conflict. `objects` is a map from objectId to the
- * patch for that object. `property` contains `objId`, `key`, a list of `ops`, and `index` (the
- * current list index if the object is a list). Returns true if one or more values are present,
- * or false if the property has been deleted.
- */
-function addPatchProperty(objects, property) {
- let values = {}, counter = null
- for (let op of property.ops) {
- // Apply counters and their increments regardless of the number of successor operations
- if (op.actionName === 'set' && op.value.datatype === 'counter') {
- if (!counter) counter = {opId: op.opId, value: 0, succ: {}}
- counter.value += op.value.value
- for (let succId of op.succ) counter.succ[succId] = true
- } else if (op.actionName === 'inc') {
- if (!counter) throw new RangeError(`inc operation ${op.opId} without a counter`)
- counter.value += op.value.value
- delete counter.succ[op.opId]
- for (let succId of op.succ) counter.succ[succId] = true
-
- } else if (op.succ.length === 0) { // Ignore any ops that have been overwritten
- if (op.actionName.startsWith('make')) {
- values[op.opId] = objects[op.opId]
- } else if (op.actionName === 'set') {
- values[op.opId] = {value: op.value.value, type: 'value'}
- if (op.value.datatype) {
- values[op.opId].datatype = op.value.datatype
- }
- } else if (op.actionName === 'link') {
- // NB. This assumes that the ID of the child object is greater than the ID of the current
- // object. This is true as long as link operations are only used to redo undone make*
- // operations, but it will cease to be true once subtree moves are allowed.
- if (!op.childId) throw new RangeError(`link operation ${op.opId} without a childId`)
- values[op.opId] = objects[op.childId]
- } else {
- throw new RangeError(`Unexpected action type: ${op.actionName}`)
- }
- }
- }
-
- // If the counter had any successor operation that was not an increment, that means the counter
- // must have been deleted, so we omit it from the patch.
- if (counter && Object.keys(counter.succ).length === 0) {
- values[counter.opId] = {type: 'value', value: counter.value, datatype: 'counter'}
- }
-
- if (Object.keys(values).length > 0) {
- let obj = objects[property.objId]
- if (obj.type === 'map' || obj.type === 'table') {
- obj.props[property.key] = values
- } else if (obj.type === 'list' || obj.type === 'text') {
- makeListEdits(obj, values, property.key, property.index)
- }
- return true
- } else {
- return false
- }
-}
-
-/**
- * When constructing a patch to instantiate a loaded document, this function adds the edits to
- * insert one list element. Usually there is one value, but in the case of a conflict there may be
- * several values. `elemId` is the ID of the list element, and `index` is the list index at which
- * the value(s) should be placed.
- */
-function makeListEdits(list, values, elemId, index) {
- let firstValue = true
- const opIds = Object.keys(values).sort((id1, id2) => compareParsedOpIds(parseOpId(id1), parseOpId(id2)))
- for (const opId of opIds) {
- if (firstValue) {
- list.edits.push({action: 'insert', value: values[opId], elemId, opId, index})
- } else {
- list.edits.push({action: 'update', value: values[opId], opId, index})
- }
- firstValue = false
- }
-}
-
-/**
- * Recursively walks the patch tree, calling appendEdit on every list edit in order to consense
- * consecutive sequences of insertions into multi-inserts.
- */
-function condenseEdits(diff) {
- if (diff.type === 'list' || diff.type === 'text') {
- diff.edits.forEach(e => condenseEdits(e.value))
- let newEdits = diff.edits
- diff.edits = []
- for (const edit of newEdits) appendEdit(diff.edits, edit)
- } else if (diff.type === 'map' || diff.type === 'table') {
- for (const prop of Object.keys(diff.props)) {
- for (const opId of Object.keys(diff.props[prop])) {
- condenseEdits(diff.props[prop][opId])
- }
- }
- }
-}
-
-/**
- * Appends a list edit operation (insert, update, remove) to an array of existing operations. If the
- * last existing operation can be extended (as a multi-op), we do that.
- */
-function appendEdit(existingEdits, nextEdit) {
- if (existingEdits.length === 0) {
- existingEdits.push(nextEdit)
- return
- }
-
- let lastEdit = existingEdits[existingEdits.length - 1]
- if (lastEdit.action === 'insert' && nextEdit.action === 'insert' &&
- lastEdit.index === nextEdit.index - 1 &&
- lastEdit.value.type === 'value' && nextEdit.value.type === 'value' &&
- lastEdit.elemId === lastEdit.opId && nextEdit.elemId === nextEdit.opId &&
- opIdDelta(lastEdit.elemId, nextEdit.elemId, 1)) {
- lastEdit.action = 'multi-insert'
- lastEdit.values = [lastEdit.value.value, nextEdit.value.value]
- delete lastEdit.value
- delete lastEdit.opId
-
- } else if (lastEdit.action === 'multi-insert' && nextEdit.action === 'insert' &&
- lastEdit.index + lastEdit.values.length === nextEdit.index &&
- nextEdit.value.type === 'value' && nextEdit.elemId === nextEdit.opId &&
- opIdDelta(lastEdit.elemId, nextEdit.elemId, lastEdit.values.length)) {
- lastEdit.values.push(nextEdit.value.value)
-
- } else if (lastEdit.action === 'remove' && nextEdit.action === 'remove' &&
- lastEdit.index === nextEdit.index) {
- lastEdit.count += nextEdit.count
-
- } else {
- existingEdits.push(nextEdit)
- }
-}
-
-/**
- * Returns true if the two given operation IDs have the same actor ID, and the counter of `id2` is
- * exactly `delta` greater than the counter of `id1`.
- */
-function opIdDelta(id1, id2, delta = 1) {
- const parsed1 = parseOpId(id1), parsed2 = parseOpId(id2)
- return parsed1.actorId === parsed2.actorId && parsed1.counter + delta === parsed2.counter
-}
-
-/**
- * Parses the document (in compressed binary format) given as `documentBuffer`
- * and returns a patch that can be sent to the frontend to instantiate the
- * current state of that document.
- */
-function constructPatch(documentBuffer) {
- const { opsColumns, actorIds } = decodeDocumentHeader(documentBuffer)
- const col = makeDecoders(opsColumns, DOC_OPS_COLUMNS).reduce(
- (acc, col) => Object.assign(acc, {[col.columnName]: col.decoder}), {})
-
- let objects = {_root: {objectId: '_root', type: 'map', props: {}}}
- let property = null
-
- while (!col.idActor.done) {
- const opId = `${col.idCtr.readValue()}@${actorIds[col.idActor.readValue()]}`
- const action = col.action.readValue(), actionName = ACTIONS[action]
- if (action % 2 === 0) { // even-numbered actions are object creation
- const type = OBJECT_TYPE[actionName] || 'unknown'
- if (type === 'list' || type === 'text') {
- objects[opId] = {objectId: opId, type, edits: []}
- } else {
- objects[opId] = {objectId: opId, type, props: {}}
- }
- }
-
- const objActor = col.objActor.readValue(), objCtr = col.objCtr.readValue()
- const objId = objActor === null ? '_root' : `${objCtr}@${actorIds[objActor]}`
- let obj = objects[objId]
- if (!obj) throw new RangeError(`Operation for nonexistent object: ${objId}`)
-
- const keyActor = col.keyActor.readValue(), keyCtr = col.keyCtr.readValue()
- const keyStr = col.keyStr.readValue(), insert = !!col.insert.readValue()
- const chldActor = col.chldActor.readValue(), chldCtr = col.chldCtr.readValue()
- const childId = chldActor === null ? null : `${chldCtr}@${actorIds[chldActor]}`
- const sizeTag = col.valLen.readValue()
- const rawValue = col.valRaw.readRawBytes(sizeTag >> 4)
- const value = decodeValue(sizeTag, rawValue)
- const succNum = col.succNum.readValue()
- let succ = []
- for (let i = 0; i < succNum; i++) {
- succ.push(`${col.succCtr.readValue()}@${actorIds[col.succActor.readValue()]}`)
- }
-
- if (!actionName || obj.type === 'unknown') continue
-
- let key
- if (obj.type === 'list' || obj.type === 'text') {
- if (keyCtr === null || (keyCtr === 0 && !insert)) {
- throw new RangeError(`Operation ${opId} on ${obj.type} object has no key`)
- }
- key = insert ? opId : `${keyCtr}@${actorIds[keyActor]}`
- } else {
- if (keyStr === null) {
- throw new RangeError(`Operation ${opId} on ${obj.type} object has no key`)
- }
- key = keyStr
- }
-
- if (!property || property.objId !== objId || property.key !== key) {
- let index = 0
- if (property) {
- index = property.index
- if (addPatchProperty(objects, property)) index += 1
- if (property.objId !== objId) index = 0
- }
- property = {objId, key, index, ops: []}
- }
- property.ops.push({opId, actionName, value, childId, succ})
- }
-
- if (property) addPatchProperty(objects, property)
- condenseEdits(objects._root)
- return objects._root
-}
-
-module.exports = {
- COLUMN_TYPE, VALUE_TYPE, ACTIONS, OBJECT_TYPE, DOC_OPS_COLUMNS, CHANGE_COLUMNS,
- encoderByColumnId, decoderByColumnId, makeDecoders, decodeValue,
- splitContainers, encodeChange, decodeChangeColumns, decodeChange, decodeChangeMeta, decodeChanges,
- decodeDocumentHeader, encodeDocument, decodeDocument,
- getChangeChecksum, appendEdit, constructPatch
-}
diff --git a/automerge-wasm/test/marks.ts b/automerge-wasm/test/marks.ts
deleted file mode 100644
index 76702caf..00000000
--- a/automerge-wasm/test/marks.ts
+++ /dev/null
@@ -1,195 +0,0 @@
-import { describe, it } from 'mocha';
-//@ts-ignore
-import assert from 'assert'
-//@ts-ignore
-import { create, loadDoc, Automerge, encodeChange, decodeChange } from '..'
-
-describe('Automerge', () => {
- describe('marks', () => {
- it('should handle marks [..]', () => {
- let doc = create()
- let list = doc.make("_root", "list", "")
- if (!list) throw new Error('should not be undefined')
- doc.splice(list, 0, 0, "aaabbbccc")
- doc.mark(list, "[3..6]", "bold" , true)
- let spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ 'aaa', [ [ 'bold', 'boolean', true ] ], 'bbb', [], 'ccc' ]);
- doc.insert(list, 6, "A")
- doc.insert(list, 3, "A")
- spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ 'aaaA', [ [ 'bold', 'boolean', true ] ], 'bbb', [], 'Accc' ]);
- })
-
- it('should handle marks [..] at the beginning of a string', () => {
- let doc = create()
- let list = doc.make("_root", "list", "")
- if (!list) throw new Error('should not be undefined')
- doc.splice(list, 0, 0, "aaabbbccc")
- doc.mark(list, "[0..3]", "bold", true)
- let spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ [ [ 'bold', 'boolean', true ] ], 'aaa', [], 'bbbccc' ]);
-
- let doc2 = doc.fork()
- doc2.insert(list, 0, "A")
- doc2.insert(list, 4, "B")
- doc.merge(doc2)
- spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ 'A', [ [ 'bold', 'boolean', true ] ], 'aaa', [], 'Bbbbccc' ]);
- })
-
- it('should handle marks [..] with splice', () => {
- let doc = create()
- let list = doc.make("_root", "list", "")
- if (!list) throw new Error('should not be undefined')
- doc.splice(list, 0, 0, "aaabbbccc")
- doc.mark(list, "[0..3]", "bold", true)
- let spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ [ [ 'bold', 'boolean', true ] ], 'aaa', [], 'bbbccc' ]);
-
- let doc2 = doc.fork()
- doc2.splice(list, 0, 2, "AAA")
- doc2.splice(list, 4, 0, "BBB")
- doc.merge(doc2)
- spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ 'AAA', [ [ 'bold', 'boolean', true ] ], 'a', [], 'BBBbbbccc' ]);
- })
-
- it('should handle marks across multiple forks', () => {
- let doc = create()
- let list = doc.make("_root", "list", "")
- if (!list) throw new Error('should not be undefined')
- doc.splice(list, 0, 0, "aaabbbccc")
- doc.mark(list, "[0..3]", "bold", true)
- let spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ [ [ 'bold', 'boolean', true ] ], 'aaa', [], 'bbbccc' ]);
-
- let doc2 = doc.fork()
- doc2.splice(list, 1, 1, "Z") // replace 'aaa' with 'aZa' inside mark.
-
- let doc3 = doc.fork()
- doc3.insert(list, 0, "AAA") // should not be included in mark.
-
- doc.merge(doc2)
- doc.merge(doc3)
-
- spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ 'AAA', [ [ 'bold', 'boolean', true ] ], 'aZa', [], 'bbbccc' ]);
- })
-
-
- it('should handle marks with deleted ends [..]', () => {
- let doc = create()
- let list = doc.make("_root", "list", "")
- if (!list) throw new Error('should not be undefined')
-
- doc.splice(list, 0, 0, "aaabbbccc")
- doc.mark(list, "[3..6]", "bold" , true)
- let spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ 'aaa', [ [ 'bold', 'boolean', true ] ], 'bbb', [], 'ccc' ]);
- doc.del(list,5);
- doc.del(list,5);
- doc.del(list,2);
- doc.del(list,2);
- spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ 'aa', [ [ 'bold', 'boolean', true ] ], 'b', [], 'cc' ])
- doc.insert(list, 3, "A")
- doc.insert(list, 2, "A")
- spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ 'aaA', [ [ 'bold', 'boolean', true ] ], 'b', [], 'Acc' ])
- })
-
- it('should handle sticky marks (..)', () => {
- let doc = create()
- let list = doc.make("_root", "list", "")
- if (!list) throw new Error('should not be undefined')
- doc.splice(list, 0, 0, "aaabbbccc")
- doc.mark(list, "(3..6)", "bold" , true)
- let spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ 'aaa', [ [ 'bold', 'boolean', true ] ], 'bbb', [], 'ccc' ]);
- doc.insert(list, 6, "A")
- doc.insert(list, 3, "A")
- spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ 'aaa', [ [ 'bold', 'boolean', true ] ], 'AbbbA', [], 'ccc' ]);
- })
-
- it('should handle sticky marks with deleted ends (..)', () => {
- let doc = create()
- let list = doc.make("_root", "list", "")
- if (!list) throw new Error('should not be undefined')
- doc.splice(list, 0, 0, "aaabbbccc")
- doc.mark(list, "(3..6)", "bold" , true)
- let spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ 'aaa', [ [ 'bold', 'boolean', true ] ], 'bbb', [], 'ccc' ]);
- doc.del(list,5);
- doc.del(list,5);
- doc.del(list,2);
- doc.del(list,2);
- spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ 'aa', [ [ 'bold', 'boolean', true ] ], 'b', [], 'cc' ])
- doc.insert(list, 3, "A")
- doc.insert(list, 2, "A")
- spans = doc.spans(list);
- assert.deepStrictEqual(spans, [ 'aa', [ [ 'bold', 'boolean', true ] ], 'AbA', [], 'cc' ])
-
- // make sure save/load can handle marks
-
- let doc2 = loadDoc(doc.save())
- spans = doc2.spans(list);
- assert.deepStrictEqual(spans, [ 'aa', [ [ 'bold', 'boolean', true ] ], 'AbA', [], 'cc' ])
-
- assert.deepStrictEqual(doc.getHeads(), doc2.getHeads())
- assert.deepStrictEqual(doc.save(), doc2.save())
- })
-
- it('should handle overlapping marks', () => {
- let doc : Automerge = create("aabbcc")
- let list = doc.make("_root", "list", "")
- if (!list) throw new Error('should not be undefined')
- doc.splice(list, 0, 0, "the quick fox jumps over the lazy dog")
- doc.mark(list, "[0..37]", "bold" , true)
- doc.mark(list, "[4..19]", "itallic" , true)
- doc.mark(list, "[10..13]", "comment" , "foxes are my favorite animal!")
- doc.commit("marks",999);
- let spans = doc.spans(list);
- assert.deepStrictEqual(spans,
- [
- [ [ 'bold', 'boolean', true ] ],
- 'the ',
- [ [ 'bold', 'boolean', true ], [ 'itallic', 'boolean', true ] ],
- 'quick ',
- [
- [ 'bold', 'boolean', true ],
- [ 'comment', 'str', 'foxes are my favorite animal!' ],
- [ 'itallic', 'boolean', true ]
- ],
- 'fox',
- [ [ 'bold', 'boolean', true ], [ 'itallic', 'boolean', true ] ],
- ' jumps',
- [ [ 'bold', 'boolean', true ] ],
- ' over the lazy dog',
- [],
- ]
- )
- let text = doc.text(list);
- assert.deepStrictEqual(text, "the quick fox jumps over the lazy dog");
- let raw_spans = doc.raw_spans(list);
- assert.deepStrictEqual(raw_spans,
- [
- { id: "39@aabbcc", time: 999, start: 0, end: 37, type: 'bold', value: true },
- { id: "41@aabbcc", time: 999, start: 4, end: 19, type: 'itallic', value: true },
- { id: "43@aabbcc", time: 999, start: 10, end: 13, type: 'comment', value: 'foxes are my favorite animal!' }
- ]);
-
- // mark sure encode decode can handle marks
-
- let all = doc.getChanges([])
- let decoded = all.map((c) => decodeChange(c))
- let encoded = decoded.map((c) => encodeChange(c))
- let doc2 = create();
- doc2.applyChanges(encoded)
-
- assert.deepStrictEqual(doc.spans(list) , doc2.spans(list))
- assert.deepStrictEqual(doc.save(), doc2.save())
- })
- })
-})
diff --git a/automerge-wasm/test/test.ts b/automerge-wasm/test/test.ts
deleted file mode 100644
index 9d7a8960..00000000
--- a/automerge-wasm/test/test.ts
+++ /dev/null
@@ -1,1400 +0,0 @@
-import { describe, it } from 'mocha';
-//@ts-ignore
-import assert from 'assert'
-//@ts-ignore
-import { BloomFilter } from './helpers/sync'
-import { create, loadDoc, SyncState, Automerge, encodeChange, decodeChange, initSyncState, decodeSyncMessage, decodeSyncState, encodeSyncState, encodeSyncMessage } from '..'
-import { DecodedSyncMessage, Hash } from '..'
-
-function sync(a: Automerge, b: Automerge, aSyncState = initSyncState(), bSyncState = initSyncState()) {
- const MAX_ITER = 10
- let aToBmsg = null, bToAmsg = null, i = 0
- do {
- aToBmsg = a.generateSyncMessage(aSyncState)
- bToAmsg = b.generateSyncMessage(bSyncState)
-
- if (aToBmsg) {
- b.receiveSyncMessage(bSyncState, aToBmsg)
- }
- if (bToAmsg) {
- a.receiveSyncMessage(aSyncState, bToAmsg)
- }
-
- if (i++ > MAX_ITER) {
- throw new Error(`Did not synchronize within ${MAX_ITER} iterations`)
- }
- } while (aToBmsg || bToAmsg)
-}
-
-describe('Automerge', () => {
- describe('basics', () => {
- it('should init clone and free', () => {
- let doc1 = create()
- let doc2 = doc1.clone()
- doc1.free()
- doc2.free()
- })
-
- it('should be able to start and commit', () => {
- let doc = create()
- doc.commit()
- doc.free()
- })
-
- it('getting a nonexistant prop does not throw an error', () => {
- let doc = create()
- let root = "_root"
- let result = doc.value(root,"hello")
- assert.deepEqual(result,undefined)
- doc.free()
- })
-
- it('should be able to set and get a simple value', () => {
- let doc : Automerge = create("aabbcc")
- let root = "_root"
- let result
-
- doc.set(root, "hello", "world")
- doc.set(root, "number1", 5, "uint")
- doc.set(root, "number2", 5)
- doc.set(root, "number3", 5.5)
- doc.set(root, "number4", 5.5, "f64")
- doc.set(root, "number5", 5.5, "int")
- doc.set(root, "bool", true)
- doc.set(root, "time1", 1000, "timestamp")
- doc.set(root, "time2", new Date(1001))
- doc.set(root, "list", []);
- doc.set(root, "null", null)
-
- result = doc.value(root,"hello")
- assert.deepEqual(result,["str","world"])
-
- result = doc.value(root,"number1")
- assert.deepEqual(result,["uint",5])
-
- result = doc.value(root,"number2")
- assert.deepEqual(result,["int",5])
-
- result = doc.value(root,"number3")
- assert.deepEqual(result,["f64",5.5])
-
- result = doc.value(root,"number4")
- assert.deepEqual(result,["f64",5.5])
-
- result = doc.value(root,"number5")
- assert.deepEqual(result,["int",5])
-
- result = doc.value(root,"bool")
- assert.deepEqual(result,["boolean",true])
-
- doc.set(root, "bool", false, "boolean")
-
- result = doc.value(root,"bool")
- assert.deepEqual(result,["boolean",false])
-
- result = doc.value(root,"time1")
- assert.deepEqual(result,["timestamp",new Date(1000)])
-
- result = doc.value(root,"time2")
- assert.deepEqual(result,["timestamp",new Date(1001)])
-
- result = doc.value(root,"list")
- assert.deepEqual(result,["list","10@aabbcc"]);
-
- result = doc.value(root,"null")
- assert.deepEqual(result,["null",null]);
-
- doc.free()
- })
-
- it('should be able to use bytes', () => {
- let doc = create()
- doc.set("_root","data1", new Uint8Array([10,11,12]));
- doc.set("_root","data2", new Uint8Array([13,14,15]), "bytes");
- let value1 = doc.value("_root", "data1")
- assert.deepEqual(value1, ["bytes", new Uint8Array([10,11,12])]);
- let value2 = doc.value("_root", "data2")
- assert.deepEqual(value2, ["bytes", new Uint8Array([13,14,15])]);
- doc.free()
- })
-
- it('should be able to make sub objects', () => {
- let doc = create()
- let root = "_root"
- let result
-
- let submap = doc.set(root, "submap", {})
- if (!submap) throw new Error('should be not null')
- doc.set(submap, "number", 6, "uint")
- assert.strictEqual(doc.pendingOps(),2)
-
- result = doc.value(root,"submap")
- assert.deepEqual(result,["map",submap])
-
- result = doc.value(submap,"number")
- assert.deepEqual(result,["uint",6])
- doc.free()
- })
-
- it('should be able to make lists', () => {
- let doc = create()
- let root = "_root"
-
- let submap = doc.set(root, "numbers", [])
- if (!submap) throw new Error('should be not null')
- doc.insert(submap, 0, "a");
- doc.insert(submap, 1, "b");
- doc.insert(submap, 2, "c");
- doc.insert(submap, 0, "z");
-
- assert.deepEqual(doc.value(submap, 0),["str","z"])
- assert.deepEqual(doc.value(submap, 1),["str","a"])
- assert.deepEqual(doc.value(submap, 2),["str","b"])
- assert.deepEqual(doc.value(submap, 3),["str","c"])
- assert.deepEqual(doc.length(submap),4)
-
- doc.set(submap, 2, "b v2");
-
- assert.deepEqual(doc.value(submap, 2),["str","b v2"])
- assert.deepEqual(doc.length(submap),4)
- doc.free()
- })
-
- it('lists have insert, set, splice, and push ops', () => {
- let doc = create()
- let root = "_root"
-
- let submap = doc.set(root, "letters", [])
- if (!submap) throw new Error('should be not null')
- doc.insert(submap, 0, "a");
- doc.insert(submap, 0, "b");
- assert.deepEqual(doc.toJS(), { letters: ["b", "a" ] })
- doc.push(submap, "c");
- assert.deepEqual(doc.toJS(), { letters: ["b", "a", "c" ] })
- doc.push(submap, 3, "timestamp");
- assert.deepEqual(doc.toJS(), { letters: ["b", "a", "c", new Date(3) ] })
- doc.splice(submap, 1, 1, ["d","e","f"]);
- assert.deepEqual(doc.toJS(), { letters: ["b", "d", "e", "f", "c", new Date(3) ] })
- doc.set(submap, 0, "z");
- assert.deepEqual(doc.toJS(), { letters: ["z", "d", "e", "f", "c", new Date(3) ] })
- assert.deepEqual(doc.length(submap),6)
-
- doc.free()
- })
-
- it('should be able delete non-existant props', () => {
- let doc = create()
-
- doc.set("_root", "foo","bar")
- doc.set("_root", "bip","bap")
- let heads1 = doc.commit()
-
- assert.deepEqual(doc.keys("_root"),["bip","foo"])
-
- doc.del("_root", "foo")
- doc.del("_root", "baz")
- let heads2 = doc.commit()
-
- assert.deepEqual(doc.keys("_root"),["bip"])
- assert.deepEqual(doc.keys("_root", heads1),["bip", "foo"])
- assert.deepEqual(doc.keys("_root", heads2),["bip"])
- doc.free()
- })
-
- it('should be able to del', () => {
- let doc = create()
- let root = "_root"
-
- doc.set(root, "xxx", "xxx");
- assert.deepEqual(doc.value(root, "xxx"),["str","xxx"])
- doc.del(root, "xxx");
- assert.deepEqual(doc.value(root, "xxx"),undefined)
- doc.free()
- })
-
- it('should be able to use counters', () => {
- let doc = create()
- let root = "_root"
-
- doc.set(root, "counter", 10, "counter");
- assert.deepEqual(doc.value(root, "counter"),["counter",10])
- doc.inc(root, "counter", 10);
- assert.deepEqual(doc.value(root, "counter"),["counter",20])
- doc.inc(root, "counter", -5);
- assert.deepEqual(doc.value(root, "counter"),["counter",15])
- doc.free()
- })
-
- it('should be able to splice text', () => {
- let doc = create()
- let root = "_root";
-
- let text = doc.set(root, "text", "", "text");
- if (!text) throw new Error('should not be undefined')
- doc.splice(text, 0, 0, "hello ")
- doc.splice(text, 6, 0, ["w","o","r","l","d"])
- doc.splice(text, 11, 0, ["!","?"])
- assert.deepEqual(doc.value(text, 0),["str","h"])
- assert.deepEqual(doc.value(text, 1),["str","e"])
- assert.deepEqual(doc.value(text, 9),["str","l"])
- assert.deepEqual(doc.value(text, 10),["str","d"])
- assert.deepEqual(doc.value(text, 11),["str","!"])
- assert.deepEqual(doc.value(text, 12),["str","?"])
- doc.free()
- })
-
- it('should be able save all or incrementally', () => {
- let doc = create()
-
- doc.set("_root", "foo", 1)
-
- let save1 = doc.save()
-
- doc.set("_root", "bar", 2)
-
- let saveMidway = doc.clone().save();
-
- let save2 = doc.saveIncremental();
-
- doc.set("_root", "baz", 3);
-
- let save3 = doc.saveIncremental();
-
- let saveA = doc.save();
- let saveB = new Uint8Array([... save1, ...save2, ...save3]);
-
- assert.notDeepEqual(saveA, saveB);
-
- let docA = loadDoc(saveA);
- let docB = loadDoc(saveB);
- let docC = loadDoc(saveMidway)
- docC.loadIncremental(save3)
-
- assert.deepEqual(docA.keys("_root"), docB.keys("_root"));
- assert.deepEqual(docA.save(), docB.save());
- assert.deepEqual(docA.save(), docC.save());
- doc.free()
- docA.free()
- docB.free()
- docC.free()
- })
-
- it('should be able to splice text', () => {
- let doc = create()
- let text = doc.set("_root", "text", "", "text");
- if (!text) throw new Error('should not be undefined')
- doc.splice(text, 0, 0, "hello world");
- let heads1 = doc.commit();
- doc.splice(text, 6, 0, "big bad ");
- let heads2 = doc.commit();
- assert.strictEqual(doc.text(text), "hello big bad world")
- assert.strictEqual(doc.length(text), 19)
- assert.strictEqual(doc.text(text, heads1), "hello world")
- assert.strictEqual(doc.length(text, heads1), 11)
- assert.strictEqual(doc.text(text, heads2), "hello big bad world")
- assert.strictEqual(doc.length(text, heads2), 19)
- doc.free()
- })
-
- it('local inc increments all visible counters in a map', () => {
- let doc1 = create("aaaa")
- doc1.set("_root", "hello", "world")
- let doc2 = loadDoc(doc1.save(), "bbbb");
- let doc3 = loadDoc(doc1.save(), "cccc");
- doc1.set("_root", "cnt", 20)
- doc2.set("_root", "cnt", 0, "counter")
- doc3.set("_root", "cnt", 10, "counter")
- doc1.applyChanges(doc2.getChanges(doc1.getHeads()))
- doc1.applyChanges(doc3.getChanges(doc1.getHeads()))
- let result = doc1.values("_root", "cnt")
- assert.deepEqual(result,[
- ['int',20,'2@aaaa'],
- ['counter',0,'2@bbbb'],
- ['counter',10,'2@cccc'],
- ])
- doc1.inc("_root", "cnt", 5)
- result = doc1.values("_root", "cnt")
- assert.deepEqual(result, [
- [ 'counter', 5, '2@bbbb' ],
- [ 'counter', 15, '2@cccc' ],
- ])
-
- let save1 = doc1.save()
- let doc4 = loadDoc(save1)
- assert.deepEqual(doc4.save(), save1);
- doc1.free()
- doc2.free()
- doc3.free()
- doc4.free()
- })
-
- it('local inc increments all visible counters in a sequence', () => {
- let doc1 = create("aaaa")
- let seq = doc1.set("_root", "seq", [])
- if (!seq) throw new Error('Should not be undefined')
- doc1.insert(seq, 0, "hello")
- let doc2 = loadDoc(doc1.save(), "bbbb");
- let doc3 = loadDoc(doc1.save(), "cccc");
- doc1.set(seq, 0, 20)
- doc2.set(seq, 0, 0, "counter")
- doc3.set(seq, 0, 10, "counter")
- doc1.applyChanges(doc2.getChanges(doc1.getHeads()))
- doc1.applyChanges(doc3.getChanges(doc1.getHeads()))
- let result = doc1.values(seq, 0)
- assert.deepEqual(result,[
- ['int',20,'3@aaaa'],
- ['counter',0,'3@bbbb'],
- ['counter',10,'3@cccc'],
- ])
- doc1.inc(seq, 0, 5)
- result = doc1.values(seq, 0)
- assert.deepEqual(result, [
- [ 'counter', 5, '3@bbbb' ],
- [ 'counter', 15, '3@cccc' ],
- ])
-
- let save = doc1.save()
- let doc4 = loadDoc(save)
- assert.deepEqual(doc4.save(), save);
- doc1.free()
- doc2.free()
- doc3.free()
- doc4.free()
- })
-
- it('recursive sets are possible', () => {
- let doc = create("aaaa")
- let l1 = doc.make("_root","list",[{ foo: "bar"}, [1,2,3]])
- let l2 = doc.insert(l1, 0, { zip: ["a", "b"] })
- let l3 = doc.make("_root","info1","hello world") // 'text'
- let l4 = doc.set("_root","info2","hello world") // 'str'
- let l5 = doc.set("_root","info3","hello world", "text")
- assert.deepEqual(doc.toJS(), {
- "list": [ { zip: ["a", "b"] }, { foo: "bar"}, [ 1,2,3]],
- "info1": "hello world".split(""),
- "info2": "hello world",
- "info3": "hello world".split("")
- })
- doc.free()
- })
-
- it('only returns an object id when objects are created', () => {
- let doc = create("aaaa")
- let r1 = doc.set("_root","foo","bar")
- let r2 = doc.set("_root","list",[])
- let r3 = doc.set("_root","counter",10, "counter")
- let r4 = doc.inc("_root","counter",1)
- let r5 = doc.del("_root","counter")
- if (!r2) throw new Error('should not be undefined')
- let r6 = doc.insert(r2,0,10);
- let r7 = doc.insert(r2,0,{});
- let r8 = doc.splice(r2,1,0,["a","b","c"]);
- let r9 = doc.splice(r2,1,0,["a",[],{},"d"]);
- assert.deepEqual(r1,null);
- assert.deepEqual(r2,"2@aaaa");
- assert.deepEqual(r3,null);
- assert.deepEqual(r4,null);
- assert.deepEqual(r5,null);
- assert.deepEqual(r6,null);
- assert.deepEqual(r7,"7@aaaa");
- assert.deepEqual(r8,null);
- assert.deepEqual(r9,["12@aaaa","13@aaaa"]);
- doc.free()
- })
-
- it('objects without properties are preserved', () => {
- let doc1 = create("aaaa")
- let a = doc1.set("_root","a",{});
- if (!a) throw new Error('should not be undefined')
- let b = doc1.set("_root","b",{});
- if (!b) throw new Error('should not be undefined')
- let c = doc1.set("_root","c",{});
- if (!c) throw new Error('should not be undefined')
- let d = doc1.set(c,"d","dd");
- let saved = doc1.save();
- let doc2 = loadDoc(saved);
- assert.deepEqual(doc2.value("_root","a"),["map",a])
- assert.deepEqual(doc2.keys(a),[])
- assert.deepEqual(doc2.value("_root","b"),["map",b])
- assert.deepEqual(doc2.keys(b),[])
- assert.deepEqual(doc2.value("_root","c"),["map",c])
- assert.deepEqual(doc2.keys(c),["d"])
- assert.deepEqual(doc2.value(c,"d"),["str","dd"])
- doc1.free()
- doc2.free()
- })
-
- it('should handle merging text conflicts then saving & loading', () => {
- let A = create("aabbcc")
- let At = A.make('_root', 'text', "", "text")
- A.splice(At, 0, 0, 'hello')
-
- let B = A.fork()
-
- assert.deepEqual(B.value("_root","text"), [ "text", At])
-
- B.splice(At, 4, 1)
- B.splice(At, 4, 0, '!')
- B.splice(At, 5, 0, ' ')
- B.splice(At, 6, 0, 'world')
-
- A.merge(B)
-
- let binary = A.save()
-
- let C = loadDoc(binary)
-
- assert.deepEqual(C.value('_root', 'text'), ['text', '1@aabbcc'])
- assert.deepEqual(C.text(At), 'hell! world')
- })
-
- })
- describe('sync', () => {
- it('should send a sync message implying no local data', () => {
- let doc = create()
- let s1 = initSyncState()
- let m1 = doc.generateSyncMessage(s1)
- const message: DecodedSyncMessage = decodeSyncMessage(m1)
- assert.deepStrictEqual(message.heads, [])
- assert.deepStrictEqual(message.need, [])
- assert.deepStrictEqual(message.have.length, 1)
- assert.deepStrictEqual(message.have[0].lastSync, [])
- assert.deepStrictEqual(message.have[0].bloom.byteLength, 0)
- assert.deepStrictEqual(message.changes, [])
- })
-
- it('should not reply if we have no data as well', () => {
- let n1 = create(), n2 = create()
- let s1 = initSyncState(), s2 = initSyncState()
- let m1 = n1.generateSyncMessage(s1)
- n2.receiveSyncMessage(s2, m1)
- let m2 = n2.generateSyncMessage(s2)
- assert.deepStrictEqual(m2, null)
- })
-
- it('repos with equal heads do not need a reply message', () => {
- let n1 = create(), n2 = create()
- let s1 = initSyncState(), s2 = initSyncState()
-
- // make two nodes with the same changes
- let list = n1.set("_root","n", [])
- if (!list) throw new Error('undefined')
- n1.commit("",0)
- for (let i = 0; i < 10; i++) {
- n1.insert(list,i,i)
- n1.commit("",0)
- }
- n2.applyChanges(n1.getChanges([]))
- assert.deepStrictEqual(n1.toJS(), n2.toJS())
-
- // generate a naive sync message
- let m1 = n1.generateSyncMessage(s1)
- assert.deepStrictEqual(s1.lastSentHeads, n1.getHeads())
-
- // heads are equal so this message should be null
- n2.receiveSyncMessage(s2, m1)
- let m2 = n2.generateSyncMessage(s2)
- assert.strictEqual(m2, null)
- })
-
- it('n1 should offer all changes to n2 when starting from nothing', () => {
- let n1 = create(), n2 = create()
-
- // make changes for n1 that n2 should request
- let list = n1.set("_root","n",[])
- if (!list) throw new Error('undefined')
- n1.commit("",0)
- for (let i = 0; i < 10; i++) {
- n1.insert(list, i, i)
- n1.commit("",0)
- }
-
- assert.notDeepStrictEqual(n1.toJS(), n2.toJS())
- sync(n1, n2)
- assert.deepStrictEqual(n1.toJS(), n2.toJS())
- })
-
- it('should sync peers where one has commits the other does not', () => {
- let n1 = create(), n2 = create()
-
- // make changes for n1 that n2 should request
- let list = n1.set("_root","n",[])
- if (!list) throw new Error('undefined')
- n1.commit("",0)
- for (let i = 0; i < 10; i++) {
- n1.insert(list,i,i)
- n1.commit("",0)
- }
-
- assert.notDeepStrictEqual(n1.toJS(), n2.toJS())
- sync(n1, n2)
- assert.deepStrictEqual(n1.toJS(), n2.toJS())
- })
-
- it('should work with prior sync state', () => {
- // create & synchronize two nodes
- let n1 = create(), n2 = create()
- let s1 = initSyncState(), s2 = initSyncState()
-
- for (let i = 0; i < 5; i++) {
- n1.set("_root","x",i)
- n1.commit("",0)
- }
-
- sync(n1, n2, s1, s2)
-
- // modify the first node further
- for (let i = 5; i < 10; i++) {
- n1.set("_root", "x", i)
- n1.commit("",0)
- }
-
- assert.notDeepStrictEqual(n1.toJS(), n2.toJS())
- sync(n1, n2, s1, s2)
- assert.deepStrictEqual(n1.toJS(), n2.toJS())
- })
-
- it('should not generate messages once synced', () => {
- // create & synchronize two nodes
- let n1 = create('abc123'), n2 = create('def456')
- let s1 = initSyncState(), s2 = initSyncState()
-
- let message, patch
- for (let i = 0; i < 5; i++) {
- n1.set("_root","x",i)
- n1.commit("",0)
- }
- for (let i = 0; i < 5; i++) {
- n2.set("_root","y",i)
- n2.commit("",0)
- }
-
- // n1 reports what it has
- message = n1.generateSyncMessage(s1)
-
- // n2 receives that message and sends changes along with what it has
- n2.receiveSyncMessage(s2, message)
- message = n2.generateSyncMessage(s2)
- assert.deepStrictEqual(decodeSyncMessage(message).changes.length, 5)
- //assert.deepStrictEqual(patch, null) // no changes arrived
-
- // n1 receives the changes and replies with the changes it now knows n2 needs
- n1.receiveSyncMessage(s1, message)
- message = n1.generateSyncMessage(s1)
- assert.deepStrictEqual(decodeSyncMessage(message).changes.length, 5)
-
- // n2 applies the changes and sends confirmation ending the exchange
- n2.receiveSyncMessage(s2, message)
- message = n2.generateSyncMessage(s2)
-
- // n1 receives the message and has nothing more to say
- n1.receiveSyncMessage(s1, message)
- message = n1.generateSyncMessage(s1)
- assert.deepStrictEqual(message, null)
- //assert.deepStrictEqual(patch, null) // no changes arrived
-
- // n2 also has nothing left to say
- message = n2.generateSyncMessage(s2)
- assert.deepStrictEqual(message, null)
- })
-
- it('should allow simultaneous messages during synchronization', () => {
- // create & synchronize two nodes
- let n1 = create('abc123'), n2 = create('def456')
- let s1 = initSyncState(), s2 = initSyncState()
-
- for (let i = 0; i < 5; i++) {
- n1.set("_root", "x", i)
- n1.commit("",0)
- }
- for (let i = 0; i < 5; i++) {
- n2.set("_root","y", i)
- n2.commit("",0)
- }
-
- const head1 = n1.getHeads()[0], head2 = n2.getHeads()[0]
-
- // both sides report what they have but have no shared peer state
- let msg1to2, msg2to1
- msg1to2 = n1.generateSyncMessage(s1)
- msg2to1 = n2.generateSyncMessage(s2)
- assert.deepStrictEqual(decodeSyncMessage(msg1to2).changes.length, 0)
- assert.deepStrictEqual(decodeSyncMessage(msg1to2).have[0].lastSync.length, 0)
- assert.deepStrictEqual(decodeSyncMessage(msg2to1).changes.length, 0)
- assert.deepStrictEqual(decodeSyncMessage(msg2to1).have[0].lastSync.length, 0)
-
- // n1 and n2 receives that message and update sync state but make no patch
- n1.receiveSyncMessage(s1, msg2to1)
- n2.receiveSyncMessage(s2, msg1to2)
-
- // now both reply with their local changes the other lacks
- // (standard warning that 1% of the time this will result in a "need" message)
- msg1to2 = n1.generateSyncMessage(s1)
- assert.deepStrictEqual(decodeSyncMessage(msg1to2).changes.length, 5)
- msg2to1 = n2.generateSyncMessage(s2)
- assert.deepStrictEqual(decodeSyncMessage(msg2to1).changes.length, 5)
-
- // both should now apply the changes and update the frontend
- n1.receiveSyncMessage(s1, msg2to1)
- assert.deepStrictEqual(n1.getMissingDeps(), [])
- //assert.notDeepStrictEqual(patch1, null)
- assert.deepStrictEqual(n1.toJS(), {x: 4, y: 4})
-
- n2.receiveSyncMessage(s2, msg1to2)
- assert.deepStrictEqual(n2.getMissingDeps(), [])
- //assert.notDeepStrictEqual(patch2, null)
- assert.deepStrictEqual(n2.toJS(), {x: 4, y: 4})
-
- // The response acknowledges the changes received, and sends no further changes
- msg1to2 = n1.generateSyncMessage(s1)
- assert.deepStrictEqual(decodeSyncMessage(msg1to2).changes.length, 0)
- msg2to1 = n2.generateSyncMessage(s2)
- assert.deepStrictEqual(decodeSyncMessage(msg2to1).changes.length, 0)
-
- // After receiving acknowledgements, their shared heads should be equal
- n1.receiveSyncMessage(s1, msg2to1)
- n2.receiveSyncMessage(s2, msg1to2)
- assert.deepStrictEqual(s1.sharedHeads, [head1, head2].sort())
- assert.deepStrictEqual(s2.sharedHeads, [head1, head2].sort())
- //assert.deepStrictEqual(patch1, null)
- //assert.deepStrictEqual(patch2, null)
-
- // We're in sync, no more messages required
- msg1to2 = n1.generateSyncMessage(s1)
- msg2to1 = n2.generateSyncMessage(s2)
- assert.deepStrictEqual(msg1to2, null)
- assert.deepStrictEqual(msg2to1, null)
-
- // If we make one more change, and start another sync, its lastSync should be updated
- n1.set("_root","x",5)
- msg1to2 = n1.generateSyncMessage(s1)
- assert.deepStrictEqual(decodeSyncMessage(msg1to2).have[0].lastSync, [head1, head2].sort())
- })
-
- it('should assume sent changes were recieved until we hear otherwise', () => {
- let n1 = create('01234567'), n2 = create('89abcdef')
- let s1 = initSyncState(), s2 = initSyncState(), message = null
-
- let items = n1.set("_root", "items", [])
- if (!items) throw new Error('undefined')
- n1.commit("",0)
-
- sync(n1, n2, s1, s2)
-
- n1.push(items, "x")
- n1.commit("",0)
- message = n1.generateSyncMessage(s1)
- assert.deepStrictEqual(decodeSyncMessage(message).changes.length, 1)
-
- n1.push(items, "y")
- n1.commit("",0)
- message = n1.generateSyncMessage(s1)
- assert.deepStrictEqual(decodeSyncMessage(message).changes.length, 1)
-
- n1.push(items, "z")
- n1.commit("",0)
-
- message = n1.generateSyncMessage(s1)
- assert.deepStrictEqual(decodeSyncMessage(message).changes.length, 1)
- })
-
- it('should work regardless of who initiates the exchange', () => {
- // create & synchronize two nodes
- let n1 = create(), n2 = create()
- let s1 = initSyncState(), s2 = initSyncState()
-
- for (let i = 0; i < 5; i++) {
- n1.set("_root", "x", i)
- n1.commit("",0)
- }
-
- sync(n1, n2, s1, s2)
-
- // modify the first node further
- for (let i = 5; i < 10; i++) {
- n1.set("_root", "x", i)
- n1.commit("",0)
- }
-
- assert.notDeepStrictEqual(n1.toJS(), n2.toJS())
- sync(n1, n2, s1, s2)
- assert.deepStrictEqual(n1.toJS(), n2.toJS())
- })
-
- it('should work without prior sync state', () => {
- // Scenario: ,-- c10 <-- c11 <-- c12 <-- c13 <-- c14
- // c0 <-- c1 <-- c2 <-- c3 <-- c4 <-- c5 <-- c6 <-- c7 <-- c8 <-- c9 <-+
- // `-- c15 <-- c16 <-- c17
- // lastSync is undefined.
-
- // create two peers both with divergent commits
- let n1 = create('01234567'), n2 = create('89abcdef')
- let s1 = initSyncState(), s2 = initSyncState()
-
- for (let i = 0; i < 10; i++) {
- n1.set("_root","x",i)
- n1.commit("",0)
- }
-
- sync(n1, n2)
-
- for (let i = 10; i < 15; i++) {
- n1.set("_root","x",i)
- n1.commit("",0)
- }
-
- for (let i = 15; i < 18; i++) {
- n2.set("_root","x",i)
- n2.commit("",0)
- }
-
- assert.notDeepStrictEqual(n1.toJS(), n2.toJS())
- sync(n1, n2)
- assert.deepStrictEqual(n1.getHeads(), n2.getHeads())
- assert.deepStrictEqual(n1.toJS(), n2.toJS())
- })
-
- it('should work with prior sync state', () => {
- // Scenario: ,-- c10 <-- c11 <-- c12 <-- c13 <-- c14
- // c0 <-- c1 <-- c2 <-- c3 <-- c4 <-- c5 <-- c6 <-- c7 <-- c8 <-- c9 <-+
- // `-- c15 <-- c16 <-- c17
- // lastSync is c9.
-
- // create two peers both with divergent commits
- let n1 = create('01234567'), n2 = create('89abcdef')
- let s1 = initSyncState(), s2 = initSyncState()
-
- for (let i = 0; i < 10; i++) {
- n1.set("_root","x",i)
- n1.commit("",0)
- }
-
- sync(n1, n2, s1, s2)
-
- for (let i = 10; i < 15; i++) {
- n1.set("_root","x",i)
- n1.commit("",0)
- }
- for (let i = 15; i < 18; i++) {
- n2.set("_root","x",i)
- n2.commit("",0)
- }
-
- s1 = decodeSyncState(encodeSyncState(s1))
- s2 = decodeSyncState(encodeSyncState(s2))
-
- assert.notDeepStrictEqual(n1.toJS(), n2.toJS())
- sync(n1, n2, s1, s2)
- assert.deepStrictEqual(n1.getHeads(), n2.getHeads())
- assert.deepStrictEqual(n1.toJS(), n2.toJS())
- })
-
- it('should ensure non-empty state after sync', () => {
- let n1 = create('01234567'), n2 = create('89abcdef')
- let s1 = initSyncState(), s2 = initSyncState()
-
- for (let i = 0; i < 3; i++) {
- n1.set("_root","x",i)
- n1.commit("",0)
- }
-
- sync(n1, n2, s1, s2)
-
- assert.deepStrictEqual(s1.sharedHeads, n1.getHeads())
- assert.deepStrictEqual(s2.sharedHeads, n1.getHeads())
- })
-
- it('should re-sync after one node crashed with data loss', () => {
- // Scenario: (r) (n2) (n1)
- // c0 <-- c1 <-- c2 <-- c3 <-- c4 <-- c5 <-- c6 <-- c7 <-- c8
- // n2 has changes {c0, c1, c2}, n1's lastSync is c5, and n2's lastSync is c2.
- // we want to successfully sync (n1) with (r), even though (n1) believes it's talking to (n2)
- let n1 = create('01234567'), n2 = create('89abcdef')
- let s1 = initSyncState(), s2 = initSyncState()
-
- // n1 makes three changes, which we sync to n2
- for (let i = 0; i < 3; i++) {
- n1.set("_root","x",i)
- n1.commit("",0)
- }
-
- sync(n1, n2, s1, s2)
-
- // save a copy of n2 as "r" to simulate recovering from crash
- let r, rSyncState
- ;[r, rSyncState] = [n2.clone(), s2.clone()]
-
- // sync another few commits
- for (let i = 3; i < 6; i++) {
- n1.set("_root","x",i)
- n1.commit("",0)
- }
-
- sync(n1, n2, s1, s2)
-
- // everyone should be on the same page here
- assert.deepStrictEqual(n1.getHeads(), n2.getHeads())
- assert.deepStrictEqual(n1.toJS(), n2.toJS())
-
- // now make a few more changes, then attempt to sync the fully-up-to-date n1 with the confused r
- for (let i = 6; i < 9; i++) {
- n1.set("_root","x",i)
- n1.commit("",0)
- }
-
- s1 = decodeSyncState(encodeSyncState(s1))
- rSyncState = decodeSyncState(encodeSyncState(rSyncState))
-
- assert.notDeepStrictEqual(n1.getHeads(), r.getHeads())
- assert.notDeepStrictEqual(n1.toJS(), r.toJS())
- assert.deepStrictEqual(n1.toJS(), {x: 8})
- assert.deepStrictEqual(r.toJS(), {x: 2})
- sync(n1, r, s1, rSyncState)
- assert.deepStrictEqual(n1.getHeads(), r.getHeads())
- assert.deepStrictEqual(n1.toJS(), r.toJS())
- })
-
- it('should resync after one node experiences data loss without disconnecting', () => {
- let n1 = create('01234567'), n2 = create('89abcdef')
- let s1 = initSyncState(), s2 = initSyncState()
-
- // n1 makes three changes, which we sync to n2
- for (let i = 0; i < 3; i++) {
- n1.set("_root","x",i)
- n1.commit("",0)
- }
-
- sync(n1, n2, s1, s2)
-
- assert.deepStrictEqual(n1.getHeads(), n2.getHeads())
- assert.deepStrictEqual(n1.toJS(), n2.toJS())
-
- let n2AfterDataLoss = create('89abcdef')
-
- // "n2" now has no data, but n1 still thinks it does. Note we don't do
- // decodeSyncState(encodeSyncState(s1)) in order to simulate data loss without disconnecting
- sync(n1, n2AfterDataLoss, s1, initSyncState())
- assert.deepStrictEqual(n1.getHeads(), n2.getHeads())
- assert.deepStrictEqual(n1.toJS(), n2.toJS())
- })
-
- it('should handle changes concurrent to the last sync heads', () => {
- let n1 = create('01234567'), n2 = create('89abcdef'), n3 = create('fedcba98')
- let s12 = initSyncState(), s21 = initSyncState(), s23 = initSyncState(), s32 = initSyncState()
-
- // Change 1 is known to all three nodes
- //n1 = Automerge.change(n1, {time: 0}, doc => doc.x = 1)
- n1.set("_root","x",1); n1.commit("",0)
-
- sync(n1, n2, s12, s21)
- sync(n2, n3, s23, s32)
-
- // Change 2 is known to n1 and n2
- n1.set("_root","x",2); n1.commit("",0)
-
- sync(n1, n2, s12, s21)
-
- // Each of the three nodes makes one change (changes 3, 4, 5)
- n1.set("_root","x",3); n1.commit("",0)
- n2.set("_root","x",4); n2.commit("",0)
- n3.set("_root","x",5); n3.commit("",0)
-
- // Apply n3's latest change to n2. If running in Node, turn the Uint8Array into a Buffer, to
- // simulate transmission over a network (see https://github.com/automerge/automerge/pull/362)
- let change = n3.getLastLocalChange()
- //@ts-ignore
- if (typeof Buffer === 'function') change = Buffer.from(change)
- if (change === undefined) { throw new RangeError("last local change failed") }
- n2.applyChanges([change])
-
- // Now sync n1 and n2. n3's change is concurrent to n1 and n2's last sync heads
- sync(n1, n2, s12, s21)
- assert.deepStrictEqual(n1.getHeads(), n2.getHeads())
- assert.deepStrictEqual(n1.toJS(), n2.toJS())
- })
-
- it('should handle histories with lots of branching and merging', () => {
- let n1 = create('01234567'), n2 = create('89abcdef'), n3 = create('fedcba98')
- n1.set("_root","x",0); n1.commit("",0)
- n2.applyChanges([n1.getLastLocalChange()])
- n3.applyChanges([n1.getLastLocalChange()])
- n3.set("_root","x",1); n3.commit("",0)
-
- // - n1c1 <------ n1c2 <------ n1c3 <-- etc. <-- n1c20 <------ n1c21
- // / \/ \/ \/
- // / /\ /\ /\
- // c0 <---- n2c1 <------ n2c2 <------ n2c3 <-- etc. <-- n2c20 <------ n2c21
- // \ /
- // ---------------------------------------------- n3c1 <-----
- for (let i = 1; i < 20; i++) {
- n1.set("_root","n1",i); n1.commit("",0)
- n2.set("_root","n2",i); n2.commit("",0)
- const change1 = n1.getLastLocalChange()
- const change2 = n2.getLastLocalChange()
- n1.applyChanges([change2])
- n2.applyChanges([change1])
- }
-
- let s1 = initSyncState(), s2 = initSyncState()
- sync(n1, n2, s1, s2)
-
- // Having n3's last change concurrent to the last sync heads forces us into the slower code path
- n2.applyChanges([n3.getLastLocalChange()])
- n1.set("_root","n1","final"); n1.commit("",0)
- n2.set("_root","n2","final"); n2.commit("",0)
-
- sync(n1, n2, s1, s2)
- assert.deepStrictEqual(n1.getHeads(), n2.getHeads())
- assert.deepStrictEqual(n1.toJS(), n2.toJS())
- })
-
- it('should handle a false-positive head', () => {
- // Scenario: ,-- n1
- // c0 <-- c1 <-- c2 <-- c3 <-- c4 <-- c5 <-- c6 <-- c7 <-- c8 <-- c9 <-+
- // `-- n2
- // where n2 is a false positive in the Bloom filter containing {n1}.
- // lastSync is c9.
- let n1 = create('01234567'), n2 = create('89abcdef')
- let s1 = initSyncState(), s2 = initSyncState()
-
- for (let i = 0; i < 10; i++) {
- n1.set("_root","x",i); n1.commit("",0)
- }
-
- sync(n1, n2, s1, s2)
- for (let i = 1; ; i++) { // search for false positive; see comment above
- const n1up = n1.clone('01234567');
- n1up.set("_root","x",`${i} @ n1`); n1up.commit("",0)
- const n2up = n2.clone('89abcdef');
- n2up.set("_root","x",`${i} @ n2`); n2up.commit("",0)
- if (new BloomFilter(n1up.getHeads()).containsHash(n2up.getHeads()[0])) {
- n1.free(); n2.free()
- n1 = n1up; n2 = n2up; break
- }
- }
- const allHeads = [...n1.getHeads(), ...n2.getHeads()].sort()
- s1 = decodeSyncState(encodeSyncState(s1))
- s2 = decodeSyncState(encodeSyncState(s2))
- sync(n1, n2, s1, s2)
- assert.deepStrictEqual(n1.getHeads(), allHeads)
- assert.deepStrictEqual(n2.getHeads(), allHeads)
- })
-
-
- describe('with a false-positive dependency', () => {
- let n1: Automerge, n2: Automerge, s1: SyncState, s2: SyncState, n1hash2: Hash, n2hash2: Hash
-
- beforeEach(() => {
- // Scenario: ,-- n1c1 <-- n1c2
- // c0 <-- c1 <-- c2 <-- c3 <-- c4 <-- c5 <-- c6 <-- c7 <-- c8 <-- c9 <-+
- // `-- n2c1 <-- n2c2
- // where n2c1 is a false positive in the Bloom filter containing {n1c1, n1c2}.
- // lastSync is c9.
- n1 = create('01234567')
- n2 = create('89abcdef')
- s1 = initSyncState()
- s2 = initSyncState()
- for (let i = 0; i < 10; i++) {
- n1.set("_root","x",i); n1.commit("",0)
- }
- sync(n1, n2, s1, s2)
-
- let n1hash1, n2hash1
- for (let i = 29; ; i++) { // search for false positive; see comment above
- const n1us1 = n1.clone('01234567')
- n1us1.set("_root","x",`${i} @ n1`); n1us1.commit("",0)
-
- const n2us1 = n2.clone('89abcdef')
- n2us1.set("_root","x",`${i} @ n1`); n2us1.commit("",0)
-
- n1hash1 = n1us1.getHeads()[0]; n2hash1 = n2us1.getHeads()[0]
-
- const n1us2 = n1us1.clone();
- n1us2.set("_root","x",`final @ n1`); n1us2.commit("",0)
-
- const n2us2 = n2us1.clone();
- n2us2.set("_root","x",`final @ n2`); n2us2.commit("",0)
-
- n1hash2 = n1us2.getHeads()[0]; n2hash2 = n2us2.getHeads()[0]
- if (new BloomFilter([n1hash1, n1hash2]).containsHash(n2hash1)) {
- n1.free(); n2.free()
- n1 = n1us2; n2 = n2us2; break
- }
- }
- })
-
- it('should sync two nodes without connection reset', () => {
- sync(n1, n2, s1, s2)
- assert.deepStrictEqual(n1.getHeads(), [n1hash2, n2hash2].sort())
- assert.deepStrictEqual(n2.getHeads(), [n1hash2, n2hash2].sort())
- })
-
- it('should sync two nodes with connection reset', () => {
- s1 = decodeSyncState(encodeSyncState(s1))
- s2 = decodeSyncState(encodeSyncState(s2))
- sync(n1, n2, s1, s2)
- assert.deepStrictEqual(n1.getHeads(), [n1hash2, n2hash2].sort())
- assert.deepStrictEqual(n2.getHeads(), [n1hash2, n2hash2].sort())
- })
-
- it('should sync three nodes', () => {
- s1 = decodeSyncState(encodeSyncState(s1))
- s2 = decodeSyncState(encodeSyncState(s2))
-
- // First n1 and n2 exchange Bloom filters
- let m1, m2
- m1 = n1.generateSyncMessage(s1)
- m2 = n2.generateSyncMessage(s2)
- n1.receiveSyncMessage(s1, m2)
- n2.receiveSyncMessage(s2, m1)
-
- // Then n1 and n2 send each other their changes, except for the false positive
- m1 = n1.generateSyncMessage(s1)
- m2 = n2.generateSyncMessage(s2)
- n1.receiveSyncMessage(s1, m2)
- n2.receiveSyncMessage(s2, m1)
- assert.strictEqual(decodeSyncMessage(m1).changes.length, 2) // n1c1 and n1c2
- assert.strictEqual(decodeSyncMessage(m2).changes.length, 1) // only n2c2; change n2c1 is not sent
-
- // n3 is a node that doesn't have the missing change. Nevertheless n1 is going to ask n3 for it
- let n3 = create('fedcba98'), s13 = initSyncState(), s31 = initSyncState()
- sync(n1, n3, s13, s31)
- assert.deepStrictEqual(n1.getHeads(), [n1hash2])
- assert.deepStrictEqual(n3.getHeads(), [n1hash2])
- })
- })
-
- it('should not require an additional request when a false-positive depends on a true-negative', () => {
- // Scenario: ,-- n1c1 <-- n1c2 <-- n1c3
- // c0 <-- c1 <-- c2 <-- c3 <-- c4 <-+
- // `-- n2c1 <-- n2c2 <-- n2c3
- // where n2c2 is a false positive in the Bloom filter containing {n1c1, n1c2, n1c3}.
- // lastSync is c4.
- let n1 = create('01234567'), n2 = create('89abcdef')
- let s1 = initSyncState(), s2 = initSyncState()
- let n1hash3, n2hash3
-
- for (let i = 0; i < 5; i++) {
- n1.set("_root","x",i); n1.commit("",0)
- }
- sync(n1, n2, s1, s2)
- for (let i = 86; ; i++) { // search for false positive; see comment above
- const n1us1 = n1.clone('01234567')
- n1us1.set("_root","x",`${i} @ n1`); n1us1.commit("",0)
-
- const n2us1 = n2.clone('89abcdef')
- n2us1.set("_root","x",`${i} @ n2`); n2us1.commit("",0)
-
- //const n1us1 = Automerge.change(Automerge.clone(n1, {actorId: '01234567'}), {time: 0}, doc => doc.x = `${i} @ n1`)
- //const n2us1 = Automerge.change(Automerge.clone(n2, {actorId: '89abcdef'}), {time: 0}, doc => doc.x = `${i} @ n2`)
- const n1hash1 = n1us1.getHeads()[0]
-
- const n1us2 = n1us1.clone()
- n1us2.set("_root","x",`${i + 1} @ n1`); n1us2.commit("",0)
-
- const n2us2 = n2us1.clone()
- n2us2.set("_root","x",`${i + 1} @ n2`); n2us2.commit("",0)
-
- const n1hash2 = n1us2.getHeads()[0], n2hash2 = n2us2.getHeads()[0]
-
- const n1us3 = n1us2.clone()
- n1us3.set("_root","x",`final @ n1`); n1us3.commit("",0)
-
- const n2us3 = n2us2.clone()
- n2us3.set("_root","x",`final @ n2`); n2us3.commit("",0)
-
- n1hash3 = n1us3.getHeads()[0]; n2hash3 = n2us3.getHeads()[0]
-
- if (new BloomFilter([n1hash1, n1hash2, n1hash3]).containsHash(n2hash2)) {
- n1.free(); n2.free();
- n1 = n1us3; n2 = n2us3; break
- }
- }
- const bothHeads = [n1hash3, n2hash3].sort()
- s1 = decodeSyncState(encodeSyncState(s1))
- s2 = decodeSyncState(encodeSyncState(s2))
- sync(n1, n2, s1, s2)
- assert.deepStrictEqual(n1.getHeads(), bothHeads)
- assert.deepStrictEqual(n2.getHeads(), bothHeads)
- })
-
- it('should handle chains of false-positives', () => {
- // Scenario: ,-- c5
- // c0 <-- c1 <-- c2 <-- c3 <-- c4 <-+
- // `-- n2c1 <-- n2c2 <-- n2c3
- // where n2c1 and n2c2 are both false positives in the Bloom filter containing {c5}.
- // lastSync is c4.
- let n1 = create('01234567'), n2 = create('89abcdef')
- let s1 = initSyncState(), s2 = initSyncState()
-
- for (let i = 0; i < 5; i++) {
- n1.set("_root","x",i); n1.commit("",0)
- }
-
- sync(n1, n2, s1, s2)
-
- n1.set("_root","x",5); n1.commit("",0)
-
- for (let i = 2; ; i++) { // search for false positive; see comment above
- const n2us1 = n2.clone('89abcdef')
- n2us1.set("_root","x",`${i} @ n2`); n2us1.commit("",0)
- if (new BloomFilter(n1.getHeads()).containsHash(n2us1.getHeads()[0])) {
- n2 = n2us1; break
- }
- }
- for (let i = 141; ; i++) { // search for false positive; see comment above
- const n2us2 = n2.clone('89abcdef')
- n2us2.set("_root","x",`${i} again`); n2us2.commit("",0)
- if (new BloomFilter(n1.getHeads()).containsHash(n2us2.getHeads()[0])) {
- n2 = n2us2; break
- }
- }
- n2.set("_root","x",`final @ n2`); n2.commit("",0)
-
- const allHeads = [...n1.getHeads(), ...n2.getHeads()].sort()
- s1 = decodeSyncState(encodeSyncState(s1))
- s2 = decodeSyncState(encodeSyncState(s2))
- sync(n1, n2, s1, s2)
- assert.deepStrictEqual(n1.getHeads(), allHeads)
- assert.deepStrictEqual(n2.getHeads(), allHeads)
- })
-
- it('should allow the false-positive hash to be explicitly requested', () => {
- // Scenario: ,-- n1
- // c0 <-- c1 <-- c2 <-- c3 <-- c4 <-- c5 <-- c6 <-- c7 <-- c8 <-- c9 <-+
- // `-- n2
- // where n2 causes a false positive in the Bloom filter containing {n1}.
- let n1 = create('01234567'), n2 = create('89abcdef')
- let s1 = initSyncState(), s2 = initSyncState()
- let message
-
- for (let i = 0; i < 10; i++) {
- n1.set("_root","x",i); n1.commit("",0)
- }
-
- sync(n1, n2, s1, s2)
-
- s1 = decodeSyncState(encodeSyncState(s1))
- s2 = decodeSyncState(encodeSyncState(s2))
-
- for (let i = 1; ; i++) { // brute-force search for false positive; see comment above
- const n1up = n1.clone('01234567'); n1up.set("_root","x",`${i} @ n1`); n1up.commit("",0)
- const n2up = n1.clone('89abcdef'); n2up.set("_root","x",`${i} @ n2`); n2up.commit("",0)
-
- // check if the bloom filter on n2 will believe n1 already has a particular hash
- // this will mean n2 won't offer that data to n2 by receiving a sync message from n1
- if (new BloomFilter(n1up.getHeads()).containsHash(n2up.getHeads()[0])) {
- n1 = n1up; n2 = n2up; break
- }
- }
-
- // n1 creates a sync message for n2 with an ill-fated bloom
- message = n1.generateSyncMessage(s1)
- assert.strictEqual(decodeSyncMessage(message).changes.length, 0)
-
- // n2 receives it and DOESN'T send a change back
- n2.receiveSyncMessage(s2, message)
- message = n2.generateSyncMessage(s2)
- assert.strictEqual(decodeSyncMessage(message).changes.length, 0)
-
- // n1 should now realize it's missing that change and request it explicitly
- n1.receiveSyncMessage(s1, message)
- message = n1.generateSyncMessage(s1)
- assert.deepStrictEqual(decodeSyncMessage(message).need, n2.getHeads())
-
- // n2 should fulfill that request
- n2.receiveSyncMessage(s2, message)
- message = n2.generateSyncMessage(s2)
- assert.strictEqual(decodeSyncMessage(message).changes.length, 1)
-
- // n1 should apply the change and the two should now be in sync
- n1.receiveSyncMessage(s1, message)
- assert.deepStrictEqual(n1.getHeads(), n2.getHeads())
- })
-
- describe('protocol features', () => {
- it('should allow multiple Bloom filters', () => {
- // Scenario: ,-- n1c1 <-- n1c2 <-- n1c3
- // c0 <-- c1 <-- c2 <-+--- n2c1 <-- n2c2 <-- n2c3
- // `-- n3c1 <-- n3c2 <-- n3c3
- // n1 has {c0, c1, c2, n1c1, n1c2, n1c3, n2c1, n2c2};
- // n2 has {c0, c1, c2, n1c1, n1c2, n2c1, n2c2, n2c3};
- // n3 has {c0, c1, c2, n3c1, n3c2, n3c3}.
- let n1 = create('01234567'), n2 = create('89abcdef'), n3 = create('76543210')
- let s13 = initSyncState(), s12 = initSyncState(), s21 = initSyncState()
- let s32 = initSyncState(), s31 = initSyncState(), s23 = initSyncState()
- let message1, message2, message3
-
- for (let i = 0; i < 3; i++) {
- n1.set("_root","x",i); n1.commit("",0)
- }
-
- // sync all 3 nodes
- sync(n1, n2, s12, s21) // eslint-disable-line no-unused-vars -- kept for consistency
- sync(n1, n3, s13, s31)
- sync(n3, n2, s32, s23)
- for (let i = 0; i < 2; i++) {
- n1.set("_root","x",`${i} @ n1`); n1.commit("",0)
- }
- for (let i = 0; i < 2; i++) {
- n2.set("_root","x",`${i} @ n2`); n2.commit("",0)
- }
- n1.applyChanges(n2.getChanges([]))
- n2.applyChanges(n1.getChanges([]))
- n1.set("_root","x",`3 @ n1`); n1.commit("",0)
- n2.set("_root","x",`3 @ n2`); n2.commit("",0)
-
- for (let i = 0; i < 3; i++) {
- n3.set("_root","x",`${i} @ n3`); n3.commit("",0)
- }
- const n1c3 = n1.getHeads()[0], n2c3 = n2.getHeads()[0], n3c3 = n3.getHeads()[0]
- s13 = decodeSyncState(encodeSyncState(s13))
- s31 = decodeSyncState(encodeSyncState(s31))
- s23 = decodeSyncState(encodeSyncState(s23))
- s32 = decodeSyncState(encodeSyncState(s32))
-
-
- // Now n3 concurrently syncs with n1 and n2. Doing this naively would result in n3 receiving
- // changes {n1c1, n1c2, n2c1, n2c2} twice (those are the changes that both n1 and n2 have, but
- // that n3 does not have). We want to prevent this duplication.
- message1 = n1.generateSyncMessage(s13) // message from n1 to n3
- assert.strictEqual(decodeSyncMessage(message1).changes.length, 0)
- n3.receiveSyncMessage(s31, message1)
- message3 = n3.generateSyncMessage(s31) // message from n3 to n1
- assert.strictEqual(decodeSyncMessage(message3).changes.length, 3) // {n3c1, n3c2, n3c3}
- n1.receiveSyncMessage(s13, message3)
-
- // Copy the Bloom filter received from n1 into the message sent from n3 to n2. This Bloom
- // filter indicates what changes n3 is going to receive from n1.
- message3 = n3.generateSyncMessage(s32) // message from n3 to n2
- const modifiedMessage = decodeSyncMessage(message3)
- modifiedMessage.have.push(decodeSyncMessage(message1).have[0])
- assert.strictEqual(modifiedMessage.changes.length, 0)
- n2.receiveSyncMessage(s23, encodeSyncMessage(modifiedMessage))
-
- // n2 replies to n3, sending only n2c3 (the one change that n2 has but n1 doesn't)
- message2 = n2.generateSyncMessage(s23)
- assert.strictEqual(decodeSyncMessage(message2).changes.length, 1) // {n2c3}
- n3.receiveSyncMessage(s32, message2)
-
- // n1 replies to n3
- message1 = n1.generateSyncMessage(s13)
- assert.strictEqual(decodeSyncMessage(message1).changes.length, 5) // {n1c1, n1c2, n1c3, n2c1, n2c2}
- n3.receiveSyncMessage(s31, message1)
- assert.deepStrictEqual(n3.getHeads(), [n1c3, n2c3, n3c3].sort())
- })
-
- it('should allow any change to be requested', () => {
- let n1 = create('01234567'), n2 = create('89abcdef')
- let s1 = initSyncState(), s2 = initSyncState()
- let message = null
-
- for (let i = 0; i < 3; i++) {
- n1.set("_root","x",i); n1.commit("",0)
- }
-
- const lastSync = n1.getHeads()
-
- for (let i = 3; i < 6; i++) {
- n1.set("_root","x",i); n1.commit("",0)
- }
-
- sync(n1, n2, s1, s2)
- s1.lastSentHeads = [] // force generateSyncMessage to return a message even though nothing changed
- message = n1.generateSyncMessage(s1)
- const modMsg = decodeSyncMessage(message)
- modMsg.need = lastSync // re-request change 2
- n2.receiveSyncMessage(s2, encodeSyncMessage(modMsg))
- message = n2.generateSyncMessage(s2)
- assert.strictEqual(decodeSyncMessage(message).changes.length, 1)
- assert.strictEqual(decodeChange(decodeSyncMessage(message).changes[0]).hash, lastSync[0])
- })
-
- it('should ignore requests for a nonexistent change', () => {
- let n1 = create('01234567'), n2 = create('89abcdef')
- let s1 = initSyncState(), s2 = initSyncState()
- let message = null
-
- for (let i = 0; i < 3; i++) {
- n1.set("_root","x",i); n1.commit("",0)
- }
-
- n2.applyChanges(n1.getChanges([]))
- message = n1.generateSyncMessage(s1)
- message = decodeSyncMessage(message)
- message.need = ['0000000000000000000000000000000000000000000000000000000000000000']
- message = encodeSyncMessage(message)
- n2.receiveSyncMessage(s2, message)
- message = n2.generateSyncMessage(s2)
- assert.strictEqual(message, null)
- })
-
- it('should allow a subset of changes to be sent', () => {
- // ,-- c1 <-- c2
- // c0 <-+
- // `-- c3 <-- c4 <-- c5 <-- c6 <-- c7 <-- c8
- let n1 = create('01234567'), n2 = create('89abcdef'), n3 = create('76543210')
- let s1 = initSyncState(), s2 = initSyncState()
- let msg, decodedMsg
-
- n1.set("_root","x",0); n1.commit("",0)
- n3.applyChanges(n3.getChangesAdded(n1)) // merge()
- for (let i = 1; i <= 2; i++) {
- n1.set("_root","x",i); n1.commit("",0)
- }
- for (let i = 3; i <= 4; i++) {
- n3.set("_root","x",i); n3.commit("",0)
- }
- const c2 = n1.getHeads()[0], c4 = n3.getHeads()[0]
- n2.applyChanges(n2.getChangesAdded(n3)) // merge()
-
- // Sync n1 and n2, so their shared heads are {c2, c4}
- sync(n1, n2, s1, s2)
- s1 = decodeSyncState(encodeSyncState(s1))
- s2 = decodeSyncState(encodeSyncState(s2))
- assert.deepStrictEqual(s1.sharedHeads, [c2, c4].sort())
- assert.deepStrictEqual(s2.sharedHeads, [c2, c4].sort())
-
- // n2 and n3 apply {c5, c6, c7, c8}
- n3.set("_root","x",5); n3.commit("",0)
- const change5 = n3.getLastLocalChange()
- n3.set("_root","x",6); n3.commit("",0)
- const change6 = n3.getLastLocalChange(), c6 = n3.getHeads()[0]
- for (let i = 7; i <= 8; i++) {
- n3.set("_root","x",i); n3.commit("",0)
- }
- const c8 = n3.getHeads()[0]
- n2.applyChanges(n2.getChangesAdded(n3)) // merge()
-
- // Now n1 initiates a sync with n2, and n2 replies with {c5, c6}. n2 does not send {c7, c8}
- msg = n1.generateSyncMessage(s1)
- n2.receiveSyncMessage(s2, msg)
- msg = n2.generateSyncMessage(s2)
- decodedMsg = decodeSyncMessage(msg)
- decodedMsg.changes = [change5, change6]
- msg = encodeSyncMessage(decodedMsg)
- const sentHashes: any = {}
-
- sentHashes[decodeChange(change5).hash] = true
- sentHashes[decodeChange(change6).hash] = true
- s2.sentHashes = sentHashes
- n1.receiveSyncMessage(s1, msg)
- assert.deepStrictEqual(s1.sharedHeads, [c2, c6].sort())
-
- // n1 replies, confirming the receipt of {c5, c6} and requesting the remaining changes
- msg = n1.generateSyncMessage(s1)
- n2.receiveSyncMessage(s2, msg)
- assert.deepStrictEqual(decodeSyncMessage(msg).need, [c8])
- assert.deepStrictEqual(decodeSyncMessage(msg).have[0].lastSync, [c2, c6].sort())
- assert.deepStrictEqual(s1.sharedHeads, [c2, c6].sort())
- assert.deepStrictEqual(s2.sharedHeads, [c2, c6].sort())
-
- // n2 sends the remaining changes {c7, c8}
- msg = n2.generateSyncMessage(s2)
- n1.receiveSyncMessage(s1, msg)
- assert.strictEqual(decodeSyncMessage(msg).changes.length, 2)
- assert.deepStrictEqual(s1.sharedHeads, [c2, c8].sort())
- })
- })
- })
-})
diff --git a/automerge/Cargo.toml b/automerge/Cargo.toml
deleted file mode 100644
index 7d385301..00000000
--- a/automerge/Cargo.toml
+++ /dev/null
@@ -1,41 +0,0 @@
-[package]
-name = "automerge"
-version = "0.1.0"
-edition = "2021"
-license = "MIT"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[features]
-optree-visualisation = ["dot"]
-
-[dependencies]
-hex = "^0.4.3"
-leb128 = "^0.2.5"
-sha2 = "^0.10.0"
-rand = { version = "^0.8.4" }
-thiserror = "^1.0.16"
-itertools = "^0.10.3"
-flate2 = "^1.0.22"
-nonzero_ext = "^0.2.0"
-uuid = { version = "^0.8.2", features=["v4", "wasm-bindgen", "serde"] }
-smol_str = "^0.1.21"
-tracing = { version = "^0.1.29", features = ["log"] }
-fxhash = "^0.2.1"
-tinyvec = { version = "^1.5.1", features = ["alloc"] }
-unicode-segmentation = "1.7.1"
-serde = { version = "^1.0", features=["derive"] }
-dot = { version = "0.1.4", optional = true }
-js-sys = "^0.3"
-wasm-bindgen = "^0.2"
-
-[dependencies.web-sys]
-version = "^0.3.55"
-features = ["console"]
-
-[dev-dependencies]
-pretty_assertions = "1.0.0"
-proptest = { version = "^1.0.0", default-features = false, features = ["std"] }
-serde_json = { version = "^1.0.73", features=["float_roundtrip"], default-features=true }
-maplit = { version = "^1.0" }
-decorum = "0.3.1"
diff --git a/automerge/src/autocommit.rs b/automerge/src/autocommit.rs
deleted file mode 100644
index a5673a57..00000000
--- a/automerge/src/autocommit.rs
+++ /dev/null
@@ -1,470 +0,0 @@
-use crate::exid::ExId;
-use crate::transaction::{CommitOptions, Transactable};
-use crate::types::Patch;
-use crate::{
- change::export_change, query, transaction::TransactionInner, ActorId, Automerge,
- AutomergeError, Change, ChangeHash, Prop, ScalarValue, Value,
-};
-use crate::{SyncMessage, SyncState};
-
-/// An automerge document that automatically manages transactions.
-#[derive(Debug, Clone)]
-pub struct AutoCommit {
- doc: Automerge,
- transaction: Option,
-}
-
-impl Default for AutoCommit {
- fn default() -> Self {
- Self::new()
- }
-}
-
-impl AutoCommit {
- pub fn new() -> Self {
- Self {
- doc: Automerge::new(),
- transaction: None,
- }
- }
-
- /// Get the inner document.
- #[doc(hidden)]
- pub fn document(&mut self) -> &Automerge {
- self.ensure_transaction_closed();
- &self.doc
- }
-
- pub fn set_actor(&mut self, actor: ActorId) {
- self.ensure_transaction_closed();
- self.doc.set_actor(actor)
- }
-
- pub fn get_actor(&mut self) -> ActorId {
- self.doc.get_actor()
- }
-
- pub fn maybe_get_actor(&self) -> Option {
- self.doc.maybe_get_actor()
- }
-
- pub fn new_with_actor_id(actor: ActorId) -> Self {
- Self {
- doc: Automerge::new_with_actor_id(actor),
- transaction: None,
- }
- }
-
- fn ensure_transaction_open(&mut self) {
- if self.transaction.is_none() {
- let actor = self.doc.get_actor_index();
-
- let seq = self.doc.states.entry(actor).or_default().len() as u64 + 1;
- let mut deps = self.doc.get_heads();
- if seq > 1 {
- let last_hash = self.get_hash(actor, seq - 1).unwrap();
- if !deps.contains(&last_hash) {
- deps.push(last_hash);
- }
- }
-
- self.transaction = Some(TransactionInner {
- actor,
- seq,
- start_op: self.doc.max_op + 1,
- time: 0,
- message: None,
- extra_bytes: Default::default(),
- hash: None,
- operations: vec![],
- deps,
- });
- }
- }
-
- fn get_hash(&mut self, actor: usize, seq: u64) -> Result {
- self.doc
- .states
- .get(&actor)
- .and_then(|v| v.get(seq as usize - 1))
- .and_then(|&i| self.doc.history.get(i))
- .map(|c| c.hash)
- .ok_or(AutomergeError::InvalidSeq(seq))
- }
-
- fn update_history(&mut self, change: Change) -> usize {
- self.doc.max_op = std::cmp::max(self.doc.max_op, change.start_op + change.len() as u64 - 1);
-
- self.update_deps(&change);
-
- let history_index = self.doc.history.len();
-
- self.doc
- .states
- .entry(self.doc.ops.m.actors.cache(change.actor_id().clone()))
- .or_default()
- .push(history_index);
-
- self.doc.history_index.insert(change.hash, history_index);
- self.doc.history.push(change);
-
- history_index
- }
-
- fn update_deps(&mut self, change: &Change) {
- for d in &change.deps {
- self.doc.deps.remove(d);
- }
- self.doc.deps.insert(change.hash);
- }
-
- pub fn fork(&mut self) -> Self {
- self.ensure_transaction_closed();
- Self {
- doc: self.doc.fork(),
- transaction: self.transaction.clone(),
- }
- }
-
- pub fn ensure_transaction_closed(&mut self) {
- if let Some(tx) = self.transaction.take() {
- self.update_history(export_change(
- &tx,
- &self.doc.ops.m.actors,
- &self.doc.ops.m.props,
- ));
- }
- }
-
- pub fn load(data: &[u8]) -> Result {
- let doc = Automerge::load(data)?;
- Ok(Self {
- doc,
- transaction: None,
- })
- }
-
- pub fn load_incremental(&mut self, data: &[u8]) -> Result {
- self.ensure_transaction_closed();
- self.doc.load_incremental(data)
- }
-
- pub fn apply_changes(&mut self, changes: &[Change]) -> Result {
- self.ensure_transaction_closed();
- self.doc.apply_changes(changes)
- }
-
- pub fn apply_change(&mut self, change: Change) {
- self.ensure_transaction_closed();
- self.doc.apply_change(change)
- }
-
- /// Takes all the changes in `other` which are not in `self` and applies them
- pub fn merge(&mut self, other: &mut Self) -> Result, AutomergeError> {
- self.ensure_transaction_closed();
- other.ensure_transaction_closed();
- self.doc.merge(&mut other.doc)
- }
-
- pub fn save(&mut self) -> Result, AutomergeError> {
- self.ensure_transaction_closed();
- self.doc.save()
- }
-
- // should this return an empty vec instead of None?
- pub fn save_incremental(&mut self) -> Vec {
- self.ensure_transaction_closed();
- self.doc.save_incremental()
- }
-
- pub fn get_missing_deps(&mut self, heads: &[ChangeHash]) -> Vec {
- self.ensure_transaction_closed();
- self.doc.get_missing_deps(heads)
- }
-
- pub fn get_last_local_change(&mut self) -> Option<&Change> {
- self.ensure_transaction_closed();
- self.doc.get_last_local_change()
- }
-
- pub fn get_changes(&mut self, have_deps: &[ChangeHash]) -> Vec<&Change> {
- self.ensure_transaction_closed();
- self.doc.get_changes(have_deps)
- }
-
- pub fn get_change_by_hash(&mut self, hash: &ChangeHash) -> Option<&Change> {
- self.ensure_transaction_closed();
- self.doc.get_change_by_hash(hash)
- }
-
- pub fn get_changes_added<'a>(&mut self, other: &'a mut Self) -> Vec<&'a Change> {
- self.ensure_transaction_closed();
- other.ensure_transaction_closed();
- self.doc.get_changes_added(&other.doc)
- }
-
- pub fn import(&self, s: &str) -> Result {
- self.doc.import(s)
- }
-
- pub fn dump(&self) {
- self.doc.dump()
- }
-
- pub fn generate_sync_message(&mut self, sync_state: &mut SyncState) -> Option {
- self.ensure_transaction_closed();
- self.doc.generate_sync_message(sync_state)
- }
-
- pub fn receive_sync_message(
- &mut self,
- sync_state: &mut SyncState,
- message: SyncMessage,
- ) -> Result, AutomergeError> {
- self.ensure_transaction_closed();
- self.doc.receive_sync_message(sync_state, message)
- }
-
- #[cfg(feature = "optree-visualisation")]
- pub fn visualise_optree(&self) -> String {
- self.doc.visualise_optree()
- }
-
- /// Get the current heads of the document.
- ///
- /// This closes the transaction first, if one is in progress.
- pub fn get_heads(&mut self) -> Vec {
- self.ensure_transaction_closed();
- self.doc.get_heads()
- }
-
- pub fn commit(&mut self) -> Vec {
- // ensure that even no changes triggers a change
- self.ensure_transaction_open();
- self.transaction
- .take()
- .map(|tx| tx.commit(&mut self.doc, None, None))
- .unwrap_or_else(|| self.doc.get_heads())
- }
-
- /// Commit the current operations with some options.
- ///
- /// ```
- /// # use automerge::transaction::CommitOptions;
- /// # use automerge::transaction::Transactable;
- /// # use automerge::Value;
- /// # use automerge::ROOT;
- /// # use automerge::AutoCommit;
- /// # use std::time::SystemTime;
- /// let mut doc = AutoCommit::new();
- /// doc.set(&ROOT, "todos", Value::list()).unwrap();
- /// let now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs() as
- /// i64;
- /// doc.commit_with(CommitOptions::default().with_message("Create todos list").with_time(now));
- /// ```
- pub fn commit_with(&mut self, options: CommitOptions) -> Vec {
- self.ensure_transaction_open();
- self.transaction
- .take()
- .map(|tx| tx.commit(&mut self.doc, options.message, options.time))
- .unwrap_or_else(|| self.doc.get_heads())
- }
-
- pub fn rollback(&mut self) -> usize {
- self.transaction
- .take()
- .map(|tx| tx.rollback(&mut self.doc))
- .unwrap_or(0)
- }
-}
-
-impl Transactable for AutoCommit {
- fn pending_ops(&self) -> usize {
- self.transaction
- .as_ref()
- .map(|t| t.pending_ops())
- .unwrap_or(0)
- }
-
- // KeysAt::()
- // LenAt::()
- // PropAt::()
- // NthAt::()
-
- fn keys(&self, obj: &ExId) -> Vec {
- self.doc.keys(obj)
- }
-
- fn keys_at(&self, obj: &ExId, heads: &[ChangeHash]) -> Vec {
- self.doc.keys_at(obj, heads)
- }
-
- fn length(&self, obj: &ExId) -> usize {
- self.doc.length(obj)
- }
-
- fn length_at(&self, obj: &ExId, heads: &[ChangeHash]) -> usize {
- self.doc.length_at(obj, heads)
- }
-
- // set(obj, prop, value) - value can be scalar or objtype
- // del(obj, prop)
- // inc(obj, prop, value)
- // insert(obj, index, value)
-
- /// Set the value of property `P` to value `V` in object `obj`.
- ///
- /// # Returns
- ///
- /// The opid of the operation which was created, or None if this operation doesn't change the
- /// document or create a new object.
- ///
- /// # Errors
- ///
- /// This will return an error if
- /// - The object does not exist
- /// - The key is the wrong type for the object
- /// - The key does not exist in the object
- fn set, V: Into>(
- &mut self,
- obj: &ExId,
- prop: P,
- value: V,
- ) -> Result, AutomergeError> {
- self.ensure_transaction_open();
- let tx = self.transaction.as_mut().unwrap();
- tx.set(&mut self.doc, obj, prop, value)
- }
-
- fn insert>(
- &mut self,
- obj: &ExId,
- index: usize,
- value: V,
- ) -> Result, AutomergeError> {
- self.ensure_transaction_open();
- let tx = self.transaction.as_mut().unwrap();
- tx.insert(&mut self.doc, obj, index, value)
- }
-
- #[allow(clippy::too_many_arguments)]
- fn mark(
- &mut self,
- obj: &ExId,
- start: usize,
- expand_start: bool,
- end: usize,
- expand_end: bool,
- mark: &str,
- value: ScalarValue,
- ) -> Result<(), AutomergeError> {
- self.ensure_transaction_open();
- let tx = self.transaction.as_mut().unwrap();
- tx.mark(
- &mut self.doc,
- obj,
- start,
- expand_start,
- end,
- expand_end,
- mark,
- value,
- )
- }
-
- fn inc>(
- &mut self,
- obj: &ExId,
- prop: P,
- value: i64,
- ) -> Result<(), AutomergeError> {
- self.ensure_transaction_open();
- let tx = self.transaction.as_mut().unwrap();
- tx.inc(&mut self.doc, obj, prop, value)
- }
-
- fn del>(&mut self, obj: &ExId, prop: P) -> Result<(), AutomergeError> {
- self.ensure_transaction_open();
- let tx = self.transaction.as_mut().unwrap();
- tx.del(&mut self.doc, obj, prop)
- }
-
- /// Splice new elements into the given sequence. Returns a vector of the OpIds used to insert
- /// the new elements
- fn splice(
- &mut self,
- obj: &ExId,
- pos: usize,
- del: usize,
- vals: Vec,
- ) -> Result, AutomergeError> {
- self.ensure_transaction_open();
- let tx = self.transaction.as_mut().unwrap();
- tx.splice(&mut self.doc, obj, pos, del, vals)
- }
-
- fn text(&self, obj: &ExId) -> Result {
- self.doc.text(obj)
- }
-
- fn text_at(&self, obj: &ExId, heads: &[ChangeHash]) -> Result {
- self.doc.text_at(obj, heads)
- }
-
- fn list(&self, obj: &ExId) -> Result, AutomergeError> {
- self.doc.list(obj)
- }
-
- fn list_at(
- &self,
- obj: &ExId,
- heads: &[ChangeHash],
- ) -> Result, AutomergeError> {
- self.doc.list_at(obj, heads)
- }
-
- fn spans(&self, obj: &ExId) -> Result, AutomergeError> {
- self.doc.spans(obj)
- }
-
- fn raw_spans(&self, obj: &ExId) -> Result, AutomergeError> {
- self.doc.raw_spans(obj)
- }
-
- // TODO - I need to return these OpId's here **only** to get
- // the legacy conflicts format of { [opid]: value }
- // Something better?
- fn value>(
- &self,
- obj: &ExId,
- prop: P,
- ) -> Result, AutomergeError> {
- self.doc.value(obj, prop)
- }
-
- fn value_at>(
- &self,
- obj: &ExId,
- prop: P,
- heads: &[ChangeHash],
- ) -> Result, AutomergeError> {
- self.doc.value_at(obj, prop, heads)
- }
-
- fn values>(
- &self,
- obj: &ExId,
- prop: P,
- ) -> Result, AutomergeError> {
- self.doc.values(obj, prop)
- }
-
- fn values_at>(
- &self,
- obj: &ExId,
- prop: P,
- heads: &[ChangeHash],
- ) -> Result, AutomergeError> {
- self.doc.values_at(obj, prop, heads)
- }
-}
diff --git a/automerge/src/automerge.rs b/automerge/src/automerge.rs
deleted file mode 100644
index fb5e4d45..00000000
--- a/automerge/src/automerge.rs
+++ /dev/null
@@ -1,1243 +0,0 @@
-use std::collections::{HashMap, HashSet, VecDeque};
-
-use crate::change::encode_document;
-use crate::exid::ExId;
-use crate::op_set::OpSet;
-use crate::transaction::{
- CommitOptions, Transaction, TransactionFailure, TransactionInner, TransactionResult,
- TransactionSuccess,
-};
-use crate::types::{
- ActorId, ChangeHash, Clock, ElemId, Export, Exportable, Key, ObjId, Op, OpId, OpType, Patch,
- ScalarValue, Value,
-};
-use crate::{legacy, query, types, ObjType};
-use crate::{AutomergeError, Change, Prop};
-
-/// An automerge document.
-#[derive(Debug, Clone)]
-pub struct Automerge {
- pub(crate) queue: Vec,
- pub(crate) history: Vec,
- pub(crate) history_index: HashMap,
- pub(crate) states: HashMap>,
- pub(crate) deps: HashSet,
- pub(crate) saved: Vec,
- pub(crate) ops: OpSet,
- pub(crate) actor: Option,
- pub(crate) max_op: u64,
-}
-
-impl Automerge {
- pub fn new() -> Self {
- Automerge {
- queue: vec![],
- history: vec![],
- history_index: HashMap::new(),
- states: HashMap::new(),
- ops: Default::default(),
- deps: Default::default(),
- saved: Default::default(),
- actor: None,
- max_op: 0,
- }
- }
-
- pub fn set_actor(&mut self, actor: ActorId) {
- self.actor = Some(self.ops.m.actors.cache(actor))
- }
-
- fn random_actor(&mut self) -> ActorId {
- let actor = ActorId::from(uuid::Uuid::new_v4().as_bytes().to_vec());
- self.actor = Some(self.ops.m.actors.cache(actor.clone()));
- actor
- }
-
- pub fn get_actor(&mut self) -> ActorId {
- if let Some(actor) = self.actor {
- self.ops.m.actors[actor].clone()
- } else {
- self.random_actor()
- }
- }
-
- pub fn maybe_get_actor(&self) -> Option {
- self.actor.map(|i| self.ops.m.actors[i].clone())
- }
-
- pub(crate) fn get_actor_index(&mut self) -> usize {
- if let Some(actor) = self.actor {
- actor
- } else {
- self.random_actor();
- self.actor.unwrap() // random_actor always sets actor to is_some()
- }
- }
-
- pub fn new_with_actor_id(actor: ActorId) -> Self {
- let mut am = Automerge {
- queue: vec![],
- history: vec![],
- history_index: HashMap::new(),
- states: HashMap::new(),
- ops: Default::default(),
- deps: Default::default(),
- saved: Default::default(),
- actor: None,
- max_op: 0,
- };
- am.actor = Some(am.ops.m.actors.cache(actor));
- am
- }
-
- /// Start a transaction.
- pub fn transaction(&mut self) -> Transaction {
- let actor = self.get_actor_index();
-
- let seq = self.states.entry(actor).or_default().len() as u64 + 1;
- let mut deps = self.get_heads();
- if seq > 1 {
- let last_hash = self.get_hash(actor, seq - 1).unwrap();
- if !deps.contains(&last_hash) {
- deps.push(last_hash);
- }
- }
-
- let tx_inner = TransactionInner {
- actor,
- seq,
- start_op: self.max_op + 1,
- time: 0,
- message: None,
- extra_bytes: Default::default(),
- hash: None,
- operations: vec![],
- deps,
- };
- Transaction {
- inner: Some(tx_inner),
- doc: self,
- }
- }
-
- /// Run a transaction on this document in a closure, automatically handling commit or rollback
- /// afterwards.
- pub fn transact(&mut self, f: F) -> TransactionResult
- where
- F: FnOnce(&mut Transaction) -> Result,
- {
- let mut tx = self.transaction();
- let result = f(&mut tx);
- match result {
- Ok(result) => Ok(TransactionSuccess {
- result,
- heads: tx.commit(),
- }),
- Err(error) => Err(TransactionFailure {
- error,
- cancelled: tx.rollback(),
- }),
- }
- }
-
- /// Like [`Self::transact`] but with a function for generating the commit options.
- pub fn transact_with(&mut self, f: F, c: C) -> TransactionResult
- where
- F: FnOnce(&mut Transaction) -> Result,
- C: FnOnce() -> CommitOptions,
- {
- let mut tx = self.transaction();
- let result = f(&mut tx);
- match result {
- Ok(result) => Ok(TransactionSuccess {
- result,
- heads: tx.commit_with(c()),
- }),
- Err(error) => Err(TransactionFailure {
- error,
- cancelled: tx.rollback(),
- }),
- }
- }
-
- pub fn fork(&self) -> Self {
- let mut f = self.clone();
- f.actor = None;
- f
- }
-
- fn insert_op(&mut self, op: Op) -> Op {
- let q = self.ops.search(op.obj, query::SeekOp::new(&op));
-
- for i in q.succ {
- self.ops.replace(op.obj, i, |old_op| old_op.add_succ(&op));
- }
-
- if !op.is_del() {
- self.ops.insert(q.pos, op.clone());
- }
- op
- }
-
- // KeysAt::()
- // LenAt::()
- // PropAt::()
- // NthAt::()
-
- pub fn keys(&self, obj: &ExId) -> Vec {
- if let Ok(obj) = self.exid_to_obj(obj) {
- let q = self.ops.search(obj, query::Keys::new());
- q.keys.iter().map(|k| self.to_string(*k)).collect()
- } else {
- vec![]
- }
- }
-
- pub fn keys_at(&self, obj: &ExId, heads: &[ChangeHash]) -> Vec {
- if let Ok(obj) = self.exid_to_obj(obj) {
- let clock = self.clock_at(heads);
- let q = self.ops.search(obj, query::KeysAt::new(clock));
- q.keys.iter().map(|k| self.to_string(*k)).collect()
- } else {
- vec![]
- }
- }
-
- pub fn length(&self, obj: &ExId) -> usize {
- if let Ok(inner_obj) = self.exid_to_obj(obj) {
- match self.ops.object_type(&inner_obj) {
- Some(ObjType::Map) | Some(ObjType::Table) => self.keys(obj).len(),
- Some(ObjType::List) | Some(ObjType::Text) => {
- self.ops.search(inner_obj, query::Len::new()).len
- }
- None => 0,
- }
- } else {
- 0
- }
- }
-
- pub fn length_at(&self, obj: &ExId, heads: &[ChangeHash]) -> usize {
- if let Ok(inner_obj) = self.exid_to_obj(obj) {
- let clock = self.clock_at(heads);
- match self.ops.object_type(&inner_obj) {
- Some(ObjType::Map) | Some(ObjType::Table) => self.keys_at(obj, heads).len(),
- Some(ObjType::List) | Some(ObjType::Text) => {
- self.ops.search(inner_obj, query::LenAt::new(clock)).len
- }
- None => 0,
- }
- } else {
- 0
- }
- }
-
- pub(crate) fn exid_to_obj(&self, id: &ExId) -> Result {
- match id {
- ExId::Root => Ok(ObjId::root()),
- ExId::Id(ctr, actor, idx) => {
- // do a direct get here b/c this could be foriegn and not be within the array
- // bounds
- if self.ops.m.actors.cache.get(*idx) == Some(actor) {
- Ok(ObjId(OpId(*ctr, *idx)))
- } else {
- // FIXME - make a real error
- let idx = self
- .ops
- .m
- .actors
- .lookup(actor)
- .ok_or(AutomergeError::Fail)?;
- Ok(ObjId(OpId(*ctr, idx)))
- }
- }
- }
- }
-
- pub(crate) fn id_to_exid(&self, id: OpId) -> ExId {
- ExId::Id(id.0, self.ops.m.actors.cache[id.1].clone(), id.1)
- }
-
- pub fn text(&self, obj: &ExId) -> Result {
- let obj = self.exid_to_obj(obj)?;
- let query = self.ops.search(obj, query::ListVals::new());
- let mut buffer = String::new();
- for q in &query.ops {
- if let OpType::Set(ScalarValue::Str(s)) = &q.action {
- buffer.push_str(s);
- }
- }
- Ok(buffer)
- }
-
- pub fn text_at(&self, obj: &ExId, heads: &[ChangeHash]) -> Result {
- let obj = self.exid_to_obj(obj)?;
- let clock = self.clock_at(heads);
- let query = self.ops.search(obj, query::ListValsAt::new(clock));
- let mut buffer = String::new();
- for q in &query.ops {
- if let OpType::Set(ScalarValue::Str(s)) = &q.action {
- buffer.push_str(s);
- }
- }
- Ok(buffer)
- }
-
- pub fn list(&self, obj: &ExId) -> Result, AutomergeError> {
- let obj = self.exid_to_obj(obj)?;
- let query = self.ops.search(obj, query::ListVals::new());
- Ok(query
- .ops
- .iter()
- .map(|o| (o.value(), self.id_to_exid(o.id)))
- .collect())
- }
-
- pub fn list_at(
- &self,
- obj: &ExId,
- heads: &[ChangeHash],
- ) -> Result, AutomergeError> {
- let obj = self.exid_to_obj(obj)?;
- let clock = self.clock_at(heads);
- let query = self.ops.search(obj, query::ListValsAt::new(clock));
- Ok(query
- .ops
- .iter()
- .map(|o| (o.value(), self.id_to_exid(o.id)))
- .collect())
- }
-
- pub fn spans(&self, obj: &ExId) -> Result, AutomergeError> {
- let obj = self.exid_to_obj(obj)?;
- let mut query = self.ops.search(obj, query::Spans::new());
- query.check_marks();
- Ok(query.spans)
- }
-
- pub fn blame(
- &self,
- obj: &ExId,
- base: &[ChangeHash],
- points: &[Vec],
- ) -> Result, AutomergeError> {
- let obj = self.exid_to_obj(obj)?;
- let base = self.clock_at(base);
- let points: Vec = points.iter().map(|p| self.clock_at(p)).collect();
- let points: Vec = points
- .iter()
- .enumerate()
- .map(|(j, _)| {
- points
- .iter()
- .enumerate()
- .filter(|(i, _)| *i != j)
- .fold(base.clone(), |acc, (_, c)| acc.union(c))
- })
- .collect();
-
- let query = self.ops.search(obj, query::Blame::new(points));
- //Ok(query.points)
- unimplemented!()
- }
-
- pub fn raw_spans(&self, obj: &ExId) -> Result, AutomergeError> {
- let obj = self.exid_to_obj(obj)?;
- let query = self.ops.search(obj, query::RawSpans::new());
- let result = query
- .spans
- .into_iter()
- .map(|s| query::SpanInfo {
- id: self.id_to_exid(s.id),
- time: self.history[s.change].time,
- start: s.start,
- end: s.end,
- span_type: s.name,
- value: s.value,
- })
- .collect();
- Ok(result)
- }
-
- /*
- #[allow(clippy::too_many_arguments)]
- pub fn mark(
- &mut self,
- obj: &ExId,
- start: usize,
- expand_start: bool,
- end: usize,
- expand_end: bool,
- mark: &str,
- value: ScalarValue,
- ) -> Result<(), AutomergeError> {
- let obj = self.exid_to_obj(obj)?;
-
- self.do_insert(obj, start, OpType::mark(mark.into(), expand_start, value))?;
- self.do_insert(obj, end, OpType::MarkEnd(expand_end))?;
-
- Ok(())
- }
-
- pub fn unmark(
- &self,
- _obj: &ExId,
- _start: usize,
- _end: usize,
- _inclusive: bool,
- _mark: &str,
- ) -> Result {
- unimplemented!()
- }
- */
-
- // TODO - I need to return these OpId's here **only** to get
- // the legacy conflicts format of { [opid]: value }
- // Something better?
- pub fn value>(
- &self,
- obj: &ExId,
- prop: P,
- ) -> Result, AutomergeError> {
- Ok(self.values(obj, prop.into())?.last().cloned())
- }
-
- pub fn value_at>(
- &self,
- obj: &ExId,
- prop: P,
- heads: &[ChangeHash],
- ) -> Result, AutomergeError> {
- Ok(self.values_at(obj, prop, heads)?.last().cloned())
- }
-
- pub fn values>(
- &self,
- obj: &ExId,
- prop: P,
- ) -> Result, AutomergeError> {
- let obj = self.exid_to_obj(obj)?;
- let result = match prop.into() {
- Prop::Map(p) => {
- let prop = self.ops.m.props.lookup(&p);
- if let Some(p) = prop {
- self.ops
- .search(obj, query::Prop::new(p))
- .ops
- .into_iter()
- .map(|o| (o.value(), self.id_to_exid(o.id)))
- .collect()
- } else {
- vec![]
- }
- }
- Prop::Seq(n) => self
- .ops
- .search(obj, query::Nth::new(n))
- .ops
- .into_iter()
- .map(|o| (o.value(), self.id_to_exid(o.id)))
- .collect(),
- };
- Ok(result)
- }
-
- pub fn values_at>(
- &self,
- obj: &ExId,
- prop: P,
- heads: &[ChangeHash],
- ) -> Result, AutomergeError> {
- let prop = prop.into();
- let obj = self.exid_to_obj(obj)?;
- let clock = self.clock_at(heads);
- let result = match prop {
- Prop::Map(p) => {
- let prop = self.ops.m.props.lookup(&p);
- if let Some(p) = prop {
- self.ops
- .search(obj, query::PropAt::new(p, clock))
- .ops
- .into_iter()
- .map(|o| (o.value(), self.id_to_exid(o.id)))
- .collect()
- } else {
- vec![]
- }
- }
- Prop::Seq(n) => self
- .ops
- .search(obj, query::NthAt::new(n, clock))
- .ops
- .into_iter()
- .map(|o| (o.value(), self.id_to_exid(o.id)))
- .collect(),
- };
- Ok(result)
- }
-
- pub fn load(data: &[u8]) -> Result {
- let changes = Change::load_document(data)?;
- let mut doc = Self::new();
- doc.apply_changes(&changes)?;
- Ok(doc)
- }
-
- pub fn load_incremental(&mut self, data: &[u8]) -> Result {
- let changes = Change::load_document(data)?;
- let start = self.ops.len();
- self.apply_changes(&changes)?;
- let delta = self.ops.len() - start;
- Ok(delta)
- }
-
- fn duplicate_seq(&self, change: &Change) -> bool {
- let mut dup = false;
- if let Some(actor_index) = self.ops.m.actors.lookup(change.actor_id()) {
- if let Some(s) = self.states.get(&actor_index) {
- dup = s.len() >= change.seq as usize;
- }
- }
- dup
- }
-
- pub fn apply_changes(&mut self, changes: &[Change]) -> Result {
- for c in changes {
- if !self.history_index.contains_key(&c.hash) {
- if self.duplicate_seq(c) {
- return Err(AutomergeError::DuplicateSeqNumber(
- c.seq,
- c.actor_id().clone(),
- ));
- }
- if self.is_causally_ready(c) {
- self.apply_change(c.clone());
- } else {
- self.queue.push(c.clone());
- }
- }
- }
- while let Some(c) = self.pop_next_causally_ready_change() {
- self.apply_change(c);
- }
- Ok(Patch {})
- }
-
- pub fn apply_change(&mut self, change: Change) {
- let ops = self.import_ops(&change, self.history.len());
- self.update_history(change);
- for op in ops {
- self.insert_op(op);
- }
- }
-
- fn is_causally_ready(&self, change: &Change) -> bool {
- change
- .deps
- .iter()
- .all(|d| self.history_index.contains_key(d))
- }
-
- fn pop_next_causally_ready_change(&mut self) -> Option {
- let mut index = 0;
- while index < self.queue.len() {
- if self.is_causally_ready(&self.queue[index]) {
- return Some(self.queue.swap_remove(index));
- }
- index += 1;
- }
- None
- }
-
- fn import_ops(&mut self, change: &Change, change_id: usize) -> Vec {
- change
- .iter_ops()
- .enumerate()
- .map(|(i, c)| {
- let actor = self.ops.m.actors.cache(change.actor_id().clone());
- let id = OpId(change.start_op + i as u64, actor);
- let obj = match c.obj {
- legacy::ObjectId::Root => ObjId::root(),
- legacy::ObjectId::Id(id) => ObjId(OpId(id.0, self.ops.m.actors.cache(id.1))),
- };
- let pred = c
- .pred
- .iter()
- .map(|i| OpId(i.0, self.ops.m.actors.cache(i.1.clone())))
- .collect();
- let key = match &c.key {
- legacy::Key::Map(n) => Key::Map(self.ops.m.props.cache(n.to_string())),
- legacy::Key::Seq(legacy::ElementId::Head) => Key::Seq(types::HEAD),
- legacy::Key::Seq(legacy::ElementId::Id(i)) => {
- Key::Seq(ElemId(OpId(i.0, self.ops.m.actors.cache(i.1.clone()))))
- }
- };
- Op {
- change: change_id,
- id,
- action: c.action,
- obj,
- key,
- succ: Default::default(),
- pred,
- insert: c.insert,
- }
- })
- .collect()
- }
-
- /// Takes all the changes in `other` which are not in `self` and applies them
- pub fn merge(&mut self, other: &mut Self) -> Result, AutomergeError> {
- // TODO: Make this fallible and figure out how to do this transactionally
- let changes = self
- .get_changes_added(other)
- .into_iter()
- .cloned()
- .collect::>();
- self.apply_changes(&changes)?;
- Ok(self.get_heads())
- }
-
- pub fn save(&mut self) -> Result, AutomergeError> {
- // TODO - would be nice if I could pass an iterator instead of a collection here
- let c: Vec<_> = self.history.iter().map(|c| c.decode()).collect();
- let ops: Vec<_> = self.ops.iter().cloned().collect();
- // TODO - can we make encode_document error free
- let bytes = encode_document(
- &c,
- ops.as_slice(),
- &self.ops.m.actors,
- &self.ops.m.props.cache,
- );
- if bytes.is_ok() {
- self.saved = self.get_heads().to_vec();
- }
- bytes
- }
-
- // should this return an empty vec instead of None?
- pub fn save_incremental(&mut self) -> Vec {
- let changes = self.get_changes(self.saved.as_slice());
- let mut bytes = vec![];
- for c in changes {
- bytes.extend(c.raw_bytes());
- }
- if !bytes.is_empty() {
- self.saved = self.get_heads().to_vec()
- }
- bytes
- }
-
- /// Filter the changes down to those that are not transitive dependencies of the heads.
- ///
- /// Thus a graph with these heads has not seen the remaining changes.
- pub(crate) fn filter_changes(&self, heads: &[ChangeHash], changes: &mut HashSet) {
- // Reduce the working set to find to those which we may be able to find.
- // This filters out those hashes that are successors of or concurrent with all of the
- // heads.
- // This can help in avoiding traversing the entire graph back to the roots when we try to
- // search for a hash we can know won't be found there.
- let max_head_index = heads
- .iter()
- .map(|h| self.history_index.get(h).unwrap_or(&0))
- .max()
- .unwrap_or(&0);
- let mut may_find: HashSet = changes
- .iter()
- .filter(|hash| {
- let change_index = self.history_index.get(hash).unwrap_or(&0);
- change_index <= max_head_index
- })
- .copied()
- .collect();
-
- if may_find.is_empty() {
- return;
- }
-
- let mut queue: VecDeque<_> = heads.iter().collect();
- let mut seen = HashSet::new();
- while let Some(hash) = queue.pop_front() {
- if seen.contains(hash) {
- continue;
- }
- seen.insert(hash);
-
- let removed = may_find.remove(hash);
- changes.remove(hash);
- if may_find.is_empty() {
- break;
- }
-
- for dep in self
- .history_index
- .get(hash)
- .and_then(|i| self.history.get(*i))
- .map(|c| c.deps.as_slice())
- .unwrap_or_default()
- {
- // if we just removed something from our hashes then it is likely there is more
- // down here so do a quick inspection on the children.
- // When we don't remove anything it is less likely that there is something down
- // that chain so delay it.
- if removed {
- queue.push_front(dep);
- } else {
- queue.push_back(dep);
- }
- }
- }
- }
-
- pub fn get_missing_deps(&self, heads: &[ChangeHash]) -> Vec {
- let in_queue: HashSet<_> = self.queue.iter().map(|change| change.hash).collect();
- let mut missing = HashSet::new();
-
- for head in self.queue.iter().flat_map(|change| &change.deps) {
- if !self.history_index.contains_key(head) {
- missing.insert(head);
- }
- }
-
- for head in heads {
- if !self.history_index.contains_key(head) {
- missing.insert(head);
- }
- }
-
- let mut missing = missing
- .into_iter()
- .filter(|hash| !in_queue.contains(hash))
- .copied()
- .collect::>();
- missing.sort();
- missing
- }
-
- fn get_changes_fast(&self, have_deps: &[ChangeHash]) -> Option> {
- if have_deps.is_empty() {
- return Some(self.history.iter().collect());
- }
-
- let lowest_idx = have_deps
- .iter()
- .filter_map(|h| self.history_index.get(h))
- .min()?
- + 1;
-
- let mut missing_changes = vec![];
- let mut has_seen: HashSet<_> = have_deps.iter().collect();
- for change in &self.history[lowest_idx..] {
- let deps_seen = change.deps.iter().filter(|h| has_seen.contains(h)).count();
- if deps_seen > 0 {
- if deps_seen != change.deps.len() {
- // future change depends on something we haven't seen - fast path cant work
- return None;
- }
- missing_changes.push(change);
- has_seen.insert(&change.hash);
- }
- }
-
- // if we get to the end and there is a head we haven't seen then fast path cant work
- if self.get_heads().iter().all(|h| has_seen.contains(h)) {
- Some(missing_changes)
- } else {
- None
- }
- }
-
- fn get_changes_slow(&self, have_deps: &[ChangeHash]) -> Vec<&Change> {
- let mut stack: Vec<_> = have_deps.iter().collect();
- let mut has_seen = HashSet::new();
- while let Some(hash) = stack.pop() {
- if has_seen.contains(&hash) {
- continue;
- }
- if let Some(change) = self
- .history_index
- .get(hash)
- .and_then(|i| self.history.get(*i))
- {
- stack.extend(change.deps.iter());
- }
- has_seen.insert(hash);
- }
- self.history
- .iter()
- .filter(|change| !has_seen.contains(&change.hash))
- .collect()
- }
-
- pub fn get_last_local_change(&self) -> Option<&Change> {
- if let Some(actor) = &self.actor {
- let actor = &self.ops.m.actors[*actor];
- return self.history.iter().rev().find(|c| c.actor_id() == actor);
- }
- None
- }
-
- pub fn get_changes(&self, have_deps: &[ChangeHash]) -> Vec<&Change> {
- if let Some(changes) = self.get_changes_fast(have_deps) {
- changes
- } else {
- self.get_changes_slow(have_deps)
- }
- }
-
- fn clock_at(&self, heads: &[ChangeHash]) -> Clock {
- let mut clock = Clock::new();
- let mut seen = HashSet::new();
- let mut to_see = heads.to_vec();
- // FIXME - faster
- while let Some(hash) = to_see.pop() {
- if let Some(c) = self.get_change_by_hash(&hash) {
- for h in &c.deps {
- if !seen.contains(h) {
- to_see.push(*h);
- }
- }
- let actor = self.ops.m.actors.lookup(c.actor_id()).unwrap();
- clock.include(actor, c.max_op());
- seen.insert(hash);
- }
- }
- clock
- }
-
- pub fn get_change_by_hash(&self, hash: &ChangeHash) -> Option<&Change> {
- self.history_index
- .get(hash)
- .and_then(|index| self.history.get(*index))
- }
-
- pub fn get_changes_added<'a>(&self, other: &'a Self) -> Vec<&'a Change> {
- // Depth-first traversal from the heads through the dependency graph,
- // until we reach a change that is already present in other
- let mut stack: Vec<_> = other.get_heads();
- let mut seen_hashes = HashSet::new();
- let mut added_change_hashes = Vec::new();
- while let Some(hash) = stack.pop() {
- if !seen_hashes.contains(&hash) && self.get_change_by_hash(&hash).is_none() {
- seen_hashes.insert(hash);
- added_change_hashes.push(hash);
- if let Some(change) = other.get_change_by_hash(&hash) {
- stack.extend(&change.deps);
- }
- }
- }
- // Return those changes in the reverse of the order in which the depth-first search
- // found them. This is not necessarily a topological sort, but should usually be close.
- added_change_hashes.reverse();
- added_change_hashes
- .into_iter()
- .filter_map(|h| other.get_change_by_hash(&h))
- .collect()
- }
-
- /// Get the heads of this document.
- pub fn get_heads(&self) -> Vec {
- let mut deps: Vec<_> = self.deps.iter().copied().collect();
- deps.sort_unstable();
- deps
- }
-
- fn get_hash(&self, actor: usize, seq: u64) -> Result {
- self.states
- .get(&actor)
- .and_then(|v| v.get(seq as usize - 1))
- .and_then(|&i| self.history.get(i))
- .map(|c| c.hash)
- .ok_or(AutomergeError::InvalidSeq(seq))
- }
-
- pub(crate) fn update_history(&mut self, change: Change) -> usize {
- self.max_op = std::cmp::max(self.max_op, change.start_op + change.len() as u64 - 1);
-
- self.update_deps(&change);
-
- let history_index = self.history.len();
-
- self.states
- .entry(self.ops.m.actors.cache(change.actor_id().clone()))
- .or_default()
- .push(history_index);
-
- self.history_index.insert(change.hash, history_index);
- self.history.push(change);
-
- history_index
- }
-
- fn update_deps(&mut self, change: &Change) {
- for d in &change.deps {
- self.deps.remove(d);
- }
- self.deps.insert(change.hash);
- }
-
- pub fn import(&self, s: &str) -> Result {
- if s == "_root" {
- Ok(ExId::Root)
- } else {
- let n = s
- .find('@')
- .ok_or_else(|| AutomergeError::InvalidOpId(s.to_owned()))?;
- let counter = s[0..n]
- .parse()
- .map_err(|_| AutomergeError::InvalidOpId(s.to_owned()))?;
- let actor = ActorId::from(hex::decode(&s[(n + 1)..]).unwrap());
- let actor = self
- .ops
- .m
- .actors
- .lookup(&actor)
- .ok_or_else(|| AutomergeError::InvalidOpId(s.to_owned()))?;
- Ok(ExId::Id(
- counter,
- self.ops.m.actors.cache[actor].clone(),
- actor,
- ))
- }
- }
-
- fn to_string(&self, id: E) -> String {
- match id.export() {
- Export::Id(id) => format!("{}@{}", id.counter(), self.ops.m.actors[id.actor()]),
- Export::Prop(index) => self.ops.m.props[index].clone(),
- Export::Special(s) => s,
- }
- }
-
- pub fn dump(&self) {
- log!(
- " {:12} {:12} {:12} {} {} {}",
- "id",
- "obj",
- "key",
- "value",
- "pred",
- "succ"
- );
- for i in self.ops.iter() {
- let id = self.to_string(i.id);
- let obj = self.to_string(i.obj);
- let key = match i.key {
- Key::Map(n) => self.ops.m.props[n].clone(),
- Key::Seq(n) => self.to_string(n),
- };
- let value: String = match &i.action {
- OpType::Set(value) => format!("{}", value),
- OpType::Make(obj) => format!("make({})", obj),
- OpType::Inc(obj) => format!("inc({})", obj),
- OpType::MarkBegin(m) => format!("mark({}={})", m.name, m.value),
- OpType::MarkEnd(_) => "/mark".into(),
- OpType::Del => format!("del{}", 0),
- };
- let pred: Vec<_> = i.pred.iter().map(|id| self.to_string(*id)).collect();
- let succ: Vec<_> = i.succ.iter().map(|id| self.to_string(*id)).collect();
- log!(
- " {:12} {:12} {:12} {} {:?} {:?}",
- id,
- obj,
- key,
- value,
- pred,
- succ
- );
- }
- }
-
- #[cfg(feature = "optree-visualisation")]
- pub fn visualise_optree(&self) -> String {
- self.ops.visualise()
- }
-}
-
-impl Default for Automerge {
- fn default() -> Self {
- Self::new()
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use crate::transaction::Transactable;
- use crate::*;
- use std::convert::TryInto;
-
- #[test]
- fn insert_op() -> Result<(), AutomergeError> {
- let mut doc = Automerge::new();
- doc.set_actor(ActorId::random());
- let mut tx = doc.transaction();
- tx.set(&ROOT, "hello", "world")?;
- tx.value(&ROOT, "hello")?;
- tx.commit();
- Ok(())
- }
-
- #[test]
- fn test_set() -> Result<(), AutomergeError> {
- let mut doc = Automerge::new();
- let mut tx = doc.transaction();
- // setting a scalar value shouldn't return an opid as no object was created.
- assert!(tx.set(&ROOT, "a", 1)?.is_none());
- // setting the same value shouldn't return an opid as there is no change.
- assert!(tx.set(&ROOT, "a", 1)?.is_none());
-
- assert!(tx.set(&ROOT, "b", Value::map())?.is_some());
- // object already exists at b but setting a map again overwrites it so we get an opid.
- assert!(tx.set(&ROOT, "b", Value::map())?.is_some());
- tx.commit();
- Ok(())
- }
-
- #[test]
- fn test_list() -> Result<(), AutomergeError> {
- let mut doc = Automerge::new();
- doc.set_actor(ActorId::random());
- let mut tx = doc.transaction();
- let list_id = tx.set(&ROOT, "items", Value::list())?.unwrap();
- tx.set(&ROOT, "zzz", "zzzval")?;
- assert!(tx.value(&ROOT, "items")?.unwrap().1 == list_id);
- tx.insert(&list_id, 0, "a")?;
- tx.insert(&list_id, 0, "b")?;
- tx.insert(&list_id, 2, "c")?;
- tx.insert(&list_id, 1, "d")?;
- assert!(tx.value(&list_id, 0)?.unwrap().0 == "b".into());
- assert!(tx.value(&list_id, 1)?.unwrap().0 == "d".into());
- assert!(tx.value(&list_id, 2)?.unwrap().0 == "a".into());
- assert!(tx.value(&list_id, 3)?.unwrap().0 == "c".into());
- assert!(tx.length(&list_id) == 4);
- tx.commit();
- doc.save()?;
- Ok(())
- }
-
- #[test]
- fn test_del() -> Result<(), AutomergeError> {
- let mut doc = Automerge::new();
- doc.set_actor(ActorId::random());
- let mut tx = doc.transaction();
- tx.set(&ROOT, "xxx", "xxx")?;
- assert!(!tx.values(&ROOT, "xxx")?.is_empty());
- tx.del(&ROOT, "xxx")?;
- assert!(tx.values(&ROOT, "xxx")?.is_empty());
- tx.commit();
- Ok(())
- }
-
- #[test]
- fn test_inc() -> Result<(), AutomergeError> {
- let mut doc = Automerge::new();
- let mut tx = doc.transaction();
- tx.set(&ROOT, "counter", Value::counter(10))?;
- assert!(tx.value(&ROOT, "counter")?.unwrap().0 == Value::counter(10));
- tx.inc(&ROOT, "counter", 10)?;
- assert!(tx.value(&ROOT, "counter")?.unwrap().0 == Value::counter(20));
- tx.inc(&ROOT, "counter", -5)?;
- assert!(tx.value(&ROOT, "counter")?.unwrap().0 == Value::counter(15));
- tx.commit();
- Ok(())
- }
-
- #[test]
- fn test_save_incremental() -> Result<(), AutomergeError> {
- let mut doc = Automerge::new();
-
- let mut tx = doc.transaction();
- tx.set(&ROOT, "foo", 1)?;
- tx.commit();
-
- let save1 = doc.save().unwrap();
-
- let mut tx = doc.transaction();
- tx.set(&ROOT, "bar", 2)?;
- tx.commit();
-
- let save2 = doc.save_incremental();
-
- let mut tx = doc.transaction();
- tx.set(&ROOT, "baz", 3)?;
- tx.commit();
-
- let save3 = doc.save_incremental();
-
- let mut save_a: Vec = vec![];
- save_a.extend(&save1);
- save_a.extend(&save2);
- save_a.extend(&save3);
-
- assert!(doc.save_incremental().is_empty());
-
- let save_b = doc.save().unwrap();
-
- assert!(save_b.len() < save_a.len());
-
- let mut doc_a = Automerge::load(&save_a)?;
- let mut doc_b = Automerge::load(&save_b)?;
-
- assert!(doc_a.values(&ROOT, "baz")? == doc_b.values(&ROOT, "baz")?);
-
- assert!(doc_a.save().unwrap() == doc_b.save().unwrap());
-
- Ok(())
- }
-
- #[test]
- fn test_save_text() -> Result<(), AutomergeError> {
- let mut doc = Automerge::new();
- let mut tx = doc.transaction();
- let text = tx.set(&ROOT, "text", Value::text())?.unwrap();
- tx.commit();
- let heads1 = doc.get_heads();
- let mut tx = doc.transaction();
- tx.splice_text(&text, 0, 0, "hello world")?;
- tx.commit();
- let heads2 = doc.get_heads();
- let mut tx = doc.transaction();
- tx.splice_text(&text, 6, 0, "big bad ")?;
- tx.commit();
- let heads3 = doc.get_heads();
-
- assert!(&doc.text(&text)? == "hello big bad world");
- assert!(&doc.text_at(&text, &heads1)?.is_empty());
- assert!(&doc.text_at(&text, &heads2)? == "hello world");
- assert!(&doc.text_at(&text, &heads3)? == "hello big bad world");
-
- Ok(())
- }
-
- #[test]
- fn test_props_vals_at() -> Result<(), AutomergeError> {
- let mut doc = Automerge::new();
- doc.set_actor("aaaa".try_into().unwrap());
- let mut tx = doc.transaction();
- tx.set(&ROOT, "prop1", "val1")?;
- tx.commit();
- doc.get_heads();
- let heads1 = doc.get_heads();
- let mut tx = doc.transaction();
- tx.set(&ROOT, "prop1", "val2")?;
- tx.commit();
- doc.get_heads();
- let heads2 = doc.get_heads();
- let mut tx = doc.transaction();
- tx.set(&ROOT, "prop2", "val3")?;
- tx.commit();
- doc.get_heads();
- let heads3 = doc.get_heads();
- let mut tx = doc.transaction();
- tx.del(&ROOT, "prop1")?;
- tx.commit();
- doc.get_heads();
- let heads4 = doc.get_heads();
- let mut tx = doc.transaction();
- tx.set(&ROOT, "prop3", "val4")?;
- tx.commit();
- doc.get_heads();
- let heads5 = doc.get_heads();
- assert!(doc.keys_at(&ROOT, &heads1) == vec!["prop1".to_owned()]);
- assert_eq!(doc.length_at(&ROOT, &heads1), 1);
- assert!(doc.value_at(&ROOT, "prop1", &heads1)?.unwrap().0 == Value::str("val1"));
- assert!(doc.value_at(&ROOT, "prop2", &heads1)? == None);
- assert!(doc.value_at(&ROOT, "prop3", &heads1)? == None);
-
- assert!(doc.keys_at(&ROOT, &heads2) == vec!["prop1".to_owned()]);
- assert_eq!(doc.length_at(&ROOT, &heads2), 1);
- assert!(doc.value_at(&ROOT, "prop1", &heads2)?.unwrap().0 == Value::str("val2"));
- assert!(doc.value_at(&ROOT, "prop2", &heads2)? == None);
- assert!(doc.value_at(&ROOT, "prop3", &heads2)? == None);
-
- assert!(doc.keys_at(&ROOT, &heads3) == vec!["prop1".to_owned(), "prop2".to_owned()]);
- assert_eq!(doc.length_at(&ROOT, &heads3), 2);
- assert!(doc.value_at(&ROOT, "prop1", &heads3)?.unwrap().0 == Value::str("val2"));
- assert!(doc.value_at(&ROOT, "prop2", &heads3)?.unwrap().0 == Value::str("val3"));
- assert!(doc.value_at(&ROOT, "prop3", &heads3)? == None);
-
- assert!(doc.keys_at(&ROOT, &heads4) == vec!["prop2".to_owned()]);
- assert_eq!(doc.length_at(&ROOT, &heads4), 1);
- assert!(doc.value_at(&ROOT, "prop1", &heads4)? == None);
- assert!(doc.value_at(&ROOT, "prop2", &heads4)?.unwrap().0 == Value::str("val3"));
- assert!(doc.value_at(&ROOT, "prop3", &heads4)? == None);
-
- assert!(doc.keys_at(&ROOT, &heads5) == vec!["prop2".to_owned(), "prop3".to_owned()]);
- assert_eq!(doc.length_at(&ROOT, &heads5), 2);
- assert_eq!(doc.length(&ROOT), 2);
- assert!(doc.value_at(&ROOT, "prop1", &heads5)? == None);
- assert!(doc.value_at(&ROOT, "prop2", &heads5)?.unwrap().0 == Value::str("val3"));
- assert!(doc.value_at(&ROOT, "prop3", &heads5)?.unwrap().0 == Value::str("val4"));
-
- assert!(doc.keys_at(&ROOT, &[]).is_empty());
- assert_eq!(doc.length_at(&ROOT, &[]), 0);
- assert!(doc.value_at(&ROOT, "prop1", &[])? == None);
- assert!(doc.value_at(&ROOT, "prop2", &[])? == None);
- assert!(doc.value_at(&ROOT, "prop3", &[])? == None);
- Ok(())
- }
-
- #[test]
- fn test_len_at() -> Result<(), AutomergeError> {
- let mut doc = Automerge::new();
- doc.set_actor("aaaa".try_into().unwrap());
-
- let mut tx = doc.transaction();
- let list = tx.set(&ROOT, "list", Value::list())?.unwrap();
- tx.commit();
- let heads1 = doc.get_heads();
-
- let mut tx = doc.transaction();
- tx.insert(&list, 0, Value::int(10))?;
- tx.commit();
- let heads2 = doc.get_heads();
-
- let mut tx = doc.transaction();
- tx.set(&list, 0, Value::int(20))?;
- tx.insert(&list, 0, Value::int(30))?;
- tx.commit();
- let heads3 = doc.get_heads();
-
- let mut tx = doc.transaction();
- tx.set(&list, 1, Value::int(40))?;
- tx.insert(&list, 1, Value::int(50))?;
- tx.commit();
- let heads4 = doc.get_heads();
-
- let mut tx = doc.transaction();
- tx.del(&list, 2)?;
- tx.commit();
- let heads5 = doc.get_heads();
-
- let mut tx = doc.transaction();
- tx.del(&list, 0)?;
- tx.commit();
- let heads6 = doc.get_heads();
-
- assert!(doc.length_at(&list, &heads1) == 0);
- assert!(doc.value_at(&list, 0, &heads1)?.is_none());
-
- assert!(doc.length_at(&list, &heads2) == 1);
- assert!(doc.value_at(&list, 0, &heads2)?.unwrap().0 == Value::int(10));
-
- assert!(doc.length_at(&list, &heads3) == 2);
- assert!(doc.value_at(&list, 0, &heads3)?.unwrap().0 == Value::int(30));
- assert!(doc.value_at(&list, 1, &heads3)?.unwrap().0 == Value::int(20));
-
- assert!(doc.length_at(&list, &heads4) == 3);
- assert!(doc.value_at(&list, 0, &heads4)?.unwrap().0 == Value::int(30));
- assert!(doc.value_at(&list, 1, &heads4)?.unwrap().0 == Value::int(50));
- assert!(doc.value_at(&list, 2, &heads4)?.unwrap().0 == Value::int(40));
-
- assert!(doc.length_at(&list, &heads5) == 2);
- assert!(doc.value_at(&list, 0, &heads5)?.unwrap().0 == Value::int(30));
- assert!(doc.value_at(&list, 1, &heads5)?.unwrap().0 == Value::int(50));
-
- assert!(doc.length_at(&list, &heads6) == 1);
- assert!(doc.length(&list) == 1);
- assert!(doc.value_at(&list, 0, &heads6)?.unwrap().0 == Value::int(50));
-
- Ok(())
- }
-}
diff --git a/automerge/src/change.rs b/automerge/src/change.rs
deleted file mode 100644
index 67c56d6c..00000000
--- a/automerge/src/change.rs
+++ /dev/null
@@ -1,991 +0,0 @@
-use crate::columnar::{
- ChangeEncoder, ChangeIterator, ColumnEncoder, DepsIterator, DocChange, DocOp, DocOpEncoder,
- DocOpIterator, OperationIterator, COLUMN_TYPE_DEFLATE,
-};
-use crate::decoding;
-use crate::decoding::{Decodable, InvalidChangeError};
-use crate::encoding::{Encodable, DEFLATE_MIN_SIZE};
-use crate::error::AutomergeError;
-use crate::indexed_cache::IndexedCache;
-use crate::legacy as amp;
-use crate::transaction::TransactionInner;
-use crate::types;
-use crate::types::{ActorId, ElemId, Key, ObjId, Op, OpId, OpType};
-use core::ops::Range;
-use flate2::{
- bufread::{DeflateDecoder, DeflateEncoder},
- Compression,
-};
-use itertools::Itertools;
-use sha2::Digest;
-use sha2::Sha256;
-use std::collections::{HashMap, HashSet};
-use std::convert::TryInto;
-use std::fmt::Debug;
-use std::io::{Read, Write};
-use tracing::instrument;
-
-const MAGIC_BYTES: [u8; 4] = [0x85, 0x6f, 0x4a, 0x83];
-const PREAMBLE_BYTES: usize = 8;
-const HEADER_BYTES: usize = PREAMBLE_BYTES + 1;
-
-const HASH_BYTES: usize = 32;
-const BLOCK_TYPE_DOC: u8 = 0;
-const BLOCK_TYPE_CHANGE: u8 = 1;
-const BLOCK_TYPE_DEFLATE: u8 = 2;
-const CHUNK_START: usize = 8;
-const HASH_RANGE: Range = 4..8;
-
-fn get_heads(changes: &[amp::Change]) -> HashSet {
- changes.iter().fold(HashSet::new(), |mut acc, c| {
- if let Some(h) = c.hash {
- acc.insert(h);
- }
- for dep in &c.deps {
- acc.remove(dep);
- }
- acc
- })
-}
-
-pub(crate) fn encode_document(
- changes: &[amp::Change],
- doc_ops: &[Op],
- actors_index: &IndexedCache,
- props: &[String],
-) -> Result, AutomergeError> {
- let mut bytes: Vec = Vec::new();
-
- let heads = get_heads(changes);
-
- let actors_map = actors_index.encode_index();
- let actors = actors_index.sorted();
-
- /*
- // this assumes that all actor_ids referenced are seen in changes.actor_id which is true
- // so long as we have a full history
- let mut actors: Vec<_> = changes
- .iter()
- .map(|c| &c.actor)
- .unique()
- .sorted()
- .cloned()
- .collect();
- */
-
- let (change_bytes, change_info) = ChangeEncoder::encode_changes(changes, &actors);
-
- //let doc_ops = group_doc_ops(changes, &actors);
-
- let (ops_bytes, ops_info) = DocOpEncoder::encode_doc_ops(doc_ops, &actors_map, props);
-
- bytes.extend(&MAGIC_BYTES);
- bytes.extend(vec![0, 0, 0, 0]); // we dont know the hash yet so fill in a fake
- bytes.push(BLOCK_TYPE_DOC);
-
- let mut chunk = Vec::new();
-
- actors.len().encode(&mut chunk)?;
-
- for a in actors.into_iter() {
- a.to_bytes().encode(&mut chunk)?;
- }
-
- heads.len().encode(&mut chunk)?;
- for head in heads.iter().sorted() {
- chunk.write_all(&head.0).unwrap();
- }
-
- chunk.extend(change_info);
- chunk.extend(ops_info);
-
- chunk.extend(change_bytes);
- chunk.extend(ops_bytes);
-
- leb128::write::unsigned(&mut bytes, chunk.len() as u64).unwrap();
-
- bytes.extend(&chunk);
-
- let hash_result = Sha256::digest(&bytes[CHUNK_START..bytes.len()]);
-
- bytes.splice(HASH_RANGE, hash_result[0..4].iter().copied());
-
- Ok(bytes)
-}
-
-/// When encoding a change we take all the actor IDs referenced by a change and place them in an
-/// array. The array has the actor who authored the change as the first element and all remaining
-/// actors (i.e. those referenced in object IDs in the target of an operation or in the `pred` of
-/// an operation) lexicographically ordered following the change author.
-fn actor_ids_in_change(change: &::Change) -> Vec {
- let mut other_ids: Vec<&::ActorId> = change
- .operations
- .iter()
- .flat_map(opids_in_operation)
- .filter(|a| *a != &change.actor_id)
- .unique()
- .collect();
- other_ids.sort();
- // Now prepend the change actor
- std::iter::once(&change.actor_id)
- .chain(other_ids.into_iter())
- .cloned()
- .collect()
-}
-
-fn opids_in_operation(op: &::Op) -> impl Iterator- {
- let obj_actor_id = match &op.obj {
- amp::ObjectId::Root => None,
- amp::ObjectId::Id(opid) => Some(opid.actor()),
- };
- let pred_ids = op.pred.iter().map(amp::OpId::actor);
- let key_actor = match &op.key {
- amp::Key::Seq(amp::ElementId::Id(i)) => Some(i.actor()),
- _ => None,
- };
- obj_actor_id
- .into_iter()
- .chain(key_actor.into_iter())
- .chain(pred_ids)
-}
-
-impl From for Change {
- fn from(value: amp::Change) -> Self {
- encode(&value)
- }
-}
-
-impl From<&::Change> for Change {
- fn from(value: &::Change) -> Self {
- encode(value)
- }
-}
-
-fn encode(change: &::Change) -> Change {
- let mut deps = change.deps.clone();
- deps.sort_unstable();
-
- let mut chunk = encode_chunk(change, &deps);
-
- let mut bytes = Vec::with_capacity(MAGIC_BYTES.len() + 4 + chunk.bytes.len());
-
- bytes.extend(&MAGIC_BYTES);
-
- bytes.extend(vec![0, 0, 0, 0]); // we dont know the hash yet so fill in a fake
-
- bytes.push(BLOCK_TYPE_CHANGE);
-
- leb128::write::unsigned(&mut bytes, chunk.bytes.len() as u64).unwrap();
-
- let body_start = bytes.len();
-
- increment_range(&mut chunk.body, bytes.len());
- increment_range(&mut chunk.message, bytes.len());
- increment_range(&mut chunk.extra_bytes, bytes.len());
- increment_range_map(&mut chunk.ops, bytes.len());
-
- bytes.extend(&chunk.bytes);
-
- let hash_result = Sha256::digest(&bytes[CHUNK_START..bytes.len()]);
- let hash: amp::ChangeHash = hash_result[..].try_into().unwrap();
-
- bytes.splice(HASH_RANGE, hash_result[0..4].iter().copied());
-
- // any time I make changes to the encoder decoder its a good idea
- // to run it through a round trip to detect errors the tests might not
- // catch
- // let c0 = Change::from_bytes(bytes.clone()).unwrap();
- // std::assert_eq!(c1, c0);
- // perhaps we should add something like this to the test suite
-
- let bytes = ChangeBytes::Uncompressed(bytes);
-
- Change {
- bytes,
- body_start,
- hash,
- seq: change.seq,
- start_op: change.start_op,
- time: change.time,
- actors: chunk.actors,
- message: chunk.message,
- deps,
- ops: chunk.ops,
- extra_bytes: chunk.extra_bytes,
- }
-}
-
-struct ChunkIntermediate {
- bytes: Vec,
- body: Range,
- actors: Vec,
- message: Range,
- ops: HashMap>,
- extra_bytes: Range,
-}
-
-fn encode_chunk(change: &::Change, deps: &[amp::ChangeHash]) -> ChunkIntermediate {
- let mut bytes = Vec::new();
-
- // All these unwraps are okay because we're writing to an in memory buffer so io erros should
- // not happen
-
- // encode deps
- deps.len().encode(&mut bytes).unwrap();
- for hash in deps.iter() {
- bytes.write_all(&hash.0).unwrap();
- }
-
- let actors = actor_ids_in_change(change);
- change.actor_id.to_bytes().encode(&mut bytes).unwrap();
-
- // encode seq, start_op, time, message
- change.seq.encode(&mut bytes).unwrap();
- change.start_op.encode(&mut bytes).unwrap();
- change.time.encode(&mut bytes).unwrap();
- let message = bytes.len() + 1;
- change.message.encode(&mut bytes).unwrap();
- let message = message..bytes.len();
-
- // encode ops into a side buffer - collect all other actors
- let (ops_buf, mut ops) = ColumnEncoder::encode_ops(&change.operations, &actors);
-
- // encode all other actors
- actors[1..].encode(&mut bytes).unwrap();
-
- // now we know how many bytes ops are offset by so we can adjust the ranges
- increment_range_map(&mut ops, bytes.len());
-
- // write out the ops
-
- bytes.write_all(&ops_buf).unwrap();
-
- // write out the extra bytes
- let extra_bytes = bytes.len()..(bytes.len() + change.extra_bytes.len());
- bytes.write_all(&change.extra_bytes).unwrap();
- let body = 0..bytes.len();
-
- ChunkIntermediate {
- bytes,
- body,
- actors,
- message,
- ops,
- extra_bytes,
- }
-}
-
-#[derive(PartialEq, Debug, Clone)]
-enum ChangeBytes {
- Compressed {
- compressed: Vec,
- uncompressed: Vec,
- },
- Uncompressed(Vec),
-}
-
-impl ChangeBytes {
- fn uncompressed(&self) -> &[u8] {
- match self {
- ChangeBytes::Compressed { uncompressed, .. } => &uncompressed[..],
- ChangeBytes::Uncompressed(b) => &b[..],
- }
- }
-
- fn compress(&mut self, body_start: usize) {
- match self {
- ChangeBytes::Compressed { .. } => {}
- ChangeBytes::Uncompressed(uncompressed) => {
- if uncompressed.len() > DEFLATE_MIN_SIZE {
- let mut result = Vec::with_capacity(uncompressed.len());
- result.extend(&uncompressed[0..8]);
- result.push(BLOCK_TYPE_DEFLATE);
- let mut deflater =
- DeflateEncoder::new(&uncompressed[body_start..], Compression::default());
- let mut deflated = Vec::new();
- let deflated_len = deflater.read_to_end(&mut deflated).unwrap();
- leb128::write::unsigned(&mut result, deflated_len as u64).unwrap();
- result.extend(&deflated[..]);
- *self = ChangeBytes::Compressed {
- compressed: result,
- uncompressed: std::mem::take(uncompressed),
- }
- }
- }
- }
- }
-
- fn raw(&self) -> &[u8] {
- match self {
- ChangeBytes::Compressed { compressed, .. } => &compressed[..],
- ChangeBytes::Uncompressed(b) => &b[..],
- }
- }
-}
-
-#[derive(PartialEq, Debug, Clone)]
-pub struct Change {
- bytes: ChangeBytes,
- body_start: usize,
- pub hash: amp::ChangeHash,
- pub seq: u64,
- pub start_op: u64,
- pub time: i64,
- message: Range,
- actors: Vec,
- pub deps: Vec,
- ops: HashMap>,
- extra_bytes: Range,
-}
-
-impl Change {
- pub fn actor_id(&self) -> &ActorId {
- &self.actors[0]
- }
-
- #[instrument(level = "debug", skip(bytes))]
- pub fn load_document(bytes: &[u8]) -> Result, AutomergeError> {
- load_blocks(bytes)
- }
-
- pub fn from_bytes(bytes: Vec) -> Result {
- decode_change(bytes)
- }
-
- pub fn is_empty(&self) -> bool {
- self.len() == 0
- }
-
- pub fn len(&self) -> usize {
- // TODO - this could be a lot more efficient
- self.iter_ops().count()
- }
-
- pub fn max_op(&self) -> u64 {
- self.start_op + (self.len() as u64) - 1
- }
-
- fn message(&self) -> Option {
- let m = &self.bytes.uncompressed()[self.message.clone()];
- if m.is_empty() {
- None
- } else {
- std::str::from_utf8(m).map(ToString::to_string).ok()
- }
- }
-
- pub fn decode(&self) -> amp::Change {
- amp::Change {
- start_op: self.start_op,
- seq: self.seq,
- time: self.time,
- hash: Some(self.hash),
- message: self.message(),
- actor_id: self.actors[0].clone(),
- deps: self.deps.clone(),
- operations: self
- .iter_ops()
- .map(|op| amp::Op {
- action: op.action.clone(),
- obj: op.obj.clone(),
- key: op.key.clone(),
- pred: op.pred.clone(),
- insert: op.insert,
- })
- .collect(),
- extra_bytes: self.extra_bytes().into(),
- }
- }
-
- pub(crate) fn iter_ops(&self) -> OperationIterator {
- OperationIterator::new(self.bytes.uncompressed(), self.actors.as_slice(), &self.ops)
- }
-
- pub fn extra_bytes(&self) -> &[u8] {
- &self.bytes.uncompressed()[self.extra_bytes.clone()]
- }
-
- pub fn compress(&mut self) {
- self.bytes.compress(self.body_start);
- }
-
- pub fn raw_bytes(&self) -> &[u8] {
- self.bytes.raw()
- }
-}
-
-fn read_leb128(bytes: &mut &[u8]) -> Result<(usize, usize), decoding::Error> {
- let mut buf = &bytes[..];
- let val = leb128::read::unsigned(&mut buf)? as usize;
- let leb128_bytes = bytes.len() - buf.len();
- Ok((val, leb128_bytes))
-}
-
-fn read_slice(
- bytes: &[u8],
- cursor: &mut Range,
-) -> Result {
- let mut view = &bytes[cursor.clone()];
- let init_len = view.len();
- let val = T::decode::<&[u8]>(&mut view).ok_or(decoding::Error::NoDecodedValue);
- let bytes_read = init_len - view.len();
- *cursor = (cursor.start + bytes_read)..cursor.end;
- val
-}
-
-fn slice_bytes(bytes: &[u8], cursor: &mut Range) -> Result, decoding::Error> {
- let (val, len) = read_leb128(&mut &bytes[cursor.clone()])?;
- let start = cursor.start + len;
- let end = start + val;
- *cursor = end..cursor.end;
- Ok(start..end)
-}
-
-fn increment_range(range: &mut Range, len: usize) {
- range.end += len;
- range.start += len;
-}
-
-fn increment_range_map(ranges: &mut HashMap>, len: usize) {
- for range in ranges.values_mut() {
- increment_range(range, len);
- }
-}
-
-fn export_objid(id: &ObjId, actors: &IndexedCache) -> amp::ObjectId {
- if id == &ObjId::root() {
- amp::ObjectId::Root
- } else {
- export_opid(&id.0, actors).into()
- }
-}
-
-fn export_elemid(id: &ElemId, actors: &IndexedCache) -> amp::ElementId {
- if id == &types::HEAD {
- amp::ElementId::Head
- } else {
- export_opid(&id.0, actors).into()
- }
-}
-
-fn export_opid(id: &OpId, actors: &IndexedCache) -> amp::OpId {
- amp::OpId(id.0, actors.get(id.1).clone())
-}
-
-fn export_op(op: &Op, actors: &IndexedCache, props: &IndexedCache) -> amp::Op {
- let action = op.action.clone();
- let key = match &op.key {
- Key::Map(n) => amp::Key::Map(props.get(*n).clone().into()),
- Key::Seq(id) => amp::Key::Seq(export_elemid(id, actors)),
- };
- let obj = export_objid(&op.obj, actors);
- let pred = op.pred.iter().map(|id| export_opid(id, actors)).collect();
- amp::Op {
- action,
- obj,
- insert: op.insert,
- pred,
- key,
- }
-}
-
-pub(crate) fn export_change(
- change: &TransactionInner,
- actors: &IndexedCache,
- props: &IndexedCache,
-) -> Change {
- amp::Change {
- actor_id: actors.get(change.actor).clone(),
- seq: change.seq,
- start_op: change.start_op,
- time: change.time,
- deps: change.deps.clone(),
- message: change.message.clone(),
- hash: change.hash,
- operations: change
- .operations
- .iter()
- .map(|op| export_op(op, actors, props))
- .collect(),
- extra_bytes: change.extra_bytes.clone(),
- }
- .into()
-}
-
-pub fn decode_change(bytes: Vec) -> Result