Release v0.4.1

We ran the tests first, but did not cross compile them. This step would
also compile all the grammar libraries (but for the host machine). On
the actual release build, the editor would get built for the target, but
the grammar libraries would be detected as present and wouldn't
recompile.

Refs #577

.envrc

@@ -1,2 +1,5 @@
 watch_file shell.nix
-use flake
+watch_file flake.lock
+
+# try to use flakes, if it fails use normal nix (ie. shell.nix)
+use flake || use nix

.github/ISSUE_TEMPLATE/blank_issue.md

@@ -0,0 +1,4 @@
+---
+name: Blank Issue
+about: Create a blank issue.
+---

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,28 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: C-bug
+assignees: ''
+
+---
+
+<!-- Your issue may already be reported!
+Please search on the issue tracker before creating one. -->
+
+### Reproduction steps
+
+<!-- Ideally provide a key sequence and/or asciinema.org recording. --> 
+
+### Environment
+
+- Platform: <!--  macOS / Windows / Linux -->
+- Helix version: <!--  'hx -v' if using a release, 'git describe' if building from master -->
+
+<details><summary>~/.cache/helix/helix.log</summary>
+
+```
+please provide a copy of `~/.cache/helix/helix.log` here if possible, you may need to redact some of the lines
+```
+
+</details>

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,13 @@
+---
+name: Feature request
+about: Suggest a new feature or improvement
+title: ''
+labels: C-enhancement
+assignees: ''
+---
+
+<!-- Your feature may already be reported!
+Please search on the issue tracker before creating one. -->
+
+#### Describe your feature request
+

.github/dependabot.yml

@@ -0,0 +1,14 @@
+# Please see the documentation for all configuration options:
+# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/build.yml

@@ -1,11 +1,11 @@
 name: Build
 on:
+  pull_request:
   push:
     branches:
       - master
-  pull_request:
-    branches:
-      - master
+  schedule:
+    - cron: '00 01 * * *'
 
 jobs:
   check:
@@ -25,19 +25,19 @@ jobs:
           override: true
 
       - name: Cache cargo registry
-        uses: actions/cache@v1
+        uses: actions/cache@v2.1.6
         with:
           path: ~/.cargo/registry
           key: ${{ runner.os }}-v1-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Cache cargo index
-        uses: actions/cache@v1
+        uses: actions/cache@v2.1.6
         with:
           path: ~/.cargo/git
           key: ${{ runner.os }}-v1-cargo-index-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Cache cargo target dir
-        uses: actions/cache@v1
+        uses: actions/cache@v2.1.6
         with:
           path: target
           key: ${{ runner.os }}-v1-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}
@@ -49,7 +49,7 @@ jobs:
 
   test:
     name: Test Suite
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout sources
         uses: actions/checkout@v2
@@ -60,23 +60,23 @@ jobs:
         uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: stable
+          toolchain: ${{ matrix.rust }}
           override: true
 
       - name: Cache cargo registry
-        uses: actions/cache@v1
+        uses: actions/cache@v2.1.6
         with:
           path: ~/.cargo/registry
           key: ${{ runner.os }}-v1-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Cache cargo index
-        uses: actions/cache@v1
+        uses: actions/cache@v2.1.6
         with:
           path: ~/.cargo/git
           key: ${{ runner.os }}-v1-cargo-index-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Cache cargo target dir
-        uses: actions/cache@v1
+        uses: actions/cache@v2.1.6
         with:
           path: target
           key: ${{ runner.os }}-v1-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}
@@ -86,6 +86,11 @@ jobs:
         with:
           command: test
 
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        rust: [stable]
+
   lints:
     name: Lints
     runs-on: ubuntu-latest
@@ -104,19 +109,19 @@ jobs:
           components: rustfmt, clippy
 
       - name: Cache cargo registry
-        uses: actions/cache@v1
+        uses: actions/cache@v2.1.6
         with:
           path: ~/.cargo/registry
           key: ${{ runner.os }}-v1-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Cache cargo index
-        uses: actions/cache@v1
+        uses: actions/cache@v2.1.6
         with:
           path: ~/.cargo/git
           key: ${{ runner.os }}-v1-cargo-index-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Cache cargo target dir
-        uses: actions/cache@v1
+        uses: actions/cache@v2.1.6
         with:
           path: target
           key: ${{ runner.os }}-v1-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}

.github/workflows/gh-pages.yml

@@ -0,0 +1,27 @@
+name: Github Pages
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Setup mdBook
+        uses: peaceiris/actions-mdbook@v1
+        with:
+          mdbook-version: 'latest'
+          # mdbook-version: '0.4.8'
+
+      - run: mdbook build book
+
+      - name: Deploy
+        uses: peaceiris/actions-gh-pages@v3
+        if: github.ref == 'refs/heads/master'
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./book/book

.github/workflows/release.yml

@@ -37,6 +37,10 @@ jobs:
           rust: stable
           target: x86_64-pc-windows-msvc
           cross: false
+        # - build: aarch64-macos
+        #   os: macos-latest
+        #   rust: stable
+        #   target: aarch64-apple-darwin
         # - build: x86_64-win-gnu
         #   os: windows-2019
         #   rust: stable-x86_64-gnu
@@ -63,8 +67,9 @@ jobs:
       - name: Run cargo test
         uses: actions-rs/cargo@v1
         with:
+          use-cross: ${{ matrix.cross }}
           command: test
-          args: --locked
+          args: --release --locked --target ${{ matrix.target }}
 
       - name: Build release binary
         uses: actions-rs/cargo@v1
@@ -95,8 +100,9 @@ jobs:
           else
             cp "target/${{ matrix.target }}/release/hx" "dist/"
           fi
+          cp -r runtime dist
 
-      - uses: actions/upload-artifact@v1
+      - uses: actions/upload-artifact@v2.2.4
         with:
           name: bins-${{ matrix.build }}
           path: dist
@@ -144,7 +150,7 @@ jobs:
               pkgname=helix-$TAG-$platform
               mkdir tmp/$pkgname
               cp LICENSE README.md tmp/$pkgname
-              cp -r runtime tmp/$pkgname/
+              mv bins-$platform/runtime tmp/$pkgname/
               mv bins-$platform/hx$exe tmp/$pkgname
               chmod +x tmp/$pkgname/hx$exe
 

.gitignore

@@ -2,3 +2,5 @@ target
 .direnv
 helix-term/rustfmt.toml
 helix-syntax/languages/
+result
+runtime/grammars

.gitmodules

@@ -82,3 +82,15 @@
 	path = helix-syntax/languages/tree-sitter-toml
 	url = https://github.com/ikatyang/tree-sitter-toml
 	shallow = true
+[submodule "helix-syntax/languages/tree-sitter-elixir"]
+	path = helix-syntax/languages/tree-sitter-elixir
+	url = https://github.com/IceDragon200/tree-sitter-elixir
+	shallow = true
+[submodule "helix-syntax/languages/tree-sitter-nix"]
+	path = helix-syntax/languages/tree-sitter-nix
+	url = https://github.com/cstrahan/tree-sitter-nix
+	shallow = true
+[submodule "helix-syntax/languages/tree-sitter-latex"]
+	path = helix-syntax/languages/tree-sitter-latex
+	url = https://github.com/latex-lsp/tree-sitter-latex
+	shallow = true

CHANGELOG.md

@@ -0,0 +1,131 @@
+
+# 0.4.1 (2021-08-14)
+
+A minor release that includes:
+- A fix for rendering glitches that would occur after editing with multiple selections.
+- CI fix for grammars not being cross-compiled for aarch64 
+
+# 0.4.1 (2021-08-13)
+
+Two months have passed, so this is another big release. A big thank you to all
+the contributors and package maintainers!
+
+Helix has popped up in [Arch, Manjaro, Nix, MacPorts and Parabola and Termux repositories](https://repology.org/project/helix/versions)!
+
+A [large scale refactor](https://github.com/helix-editor/helix/pull/376) landed that allows us to support zero width (empty)
+selections in the future as well as resolves many bugs and edge cases.
+
+- Multi-key remapping! Key binds now support much more complex usecases ([#454](https://github.com/helix-editor/helix/pull/454))
+- Pending keys are shown in the statusline ([#515](https://github.com/helix-editor/helix/pull/515))
+- Object selection / textobjects. `mi(` to select text inside parentheses ([#385](https://github.com/helix-editor/helix/pull/385))
+- Autoinfo: `whichkey`-like popups which show available sub-mode shortcuts ([#316](https://github.com/helix-editor/helix/pull/316))
+- Added WORD movements (W/B/E) ([#390](https://github.com/helix-editor/helix/pull/390))
+- Vertical selections (repeat selection above/below) ([#462](https://github.com/helix-editor/helix/pull/462))
+- Selection rotation via `(` and `)` ([66a90130](https://github.com/helix-editor/helix/commit/66a90130a5f99d769e9f6034025297f78ecaa3ec))
+- Selection contents rotation via `Alt-(` and `Alt-)` ([02cba2a](https://github.com/helix-editor/helix/commit/02cba2a7f403f48eccb18100fb751f7b42373dba))
+- Completion behavior improvements ([f917b5a4](https://github.com/helix-editor/helix/commit/f917b5a441ff3ae582358b6939ffbf889f4aa530), [627b899](https://github.com/helix-editor/helix/commit/627b89931576f7af86166ae8d5cbc55537877473))
+- Fixed a language server crash ([385a6b5a](https://github.com/helix-editor/helix/commit/385a6b5a1adddfc26e917982641530e1a7c7aa81))
+- Case change commands (`\``, `~`, `<a-~>`) ([#441](https://github.com/helix-editor/helix/pull/441))
+- File pickers (including goto) now provide a preview! ([#534](https://github.com/helix-editor/helix/pull/534))
+- Injection query support. Rust macro calls and embedded languages are now properly highlighted ([#430](https://github.com/helix-editor/helix/pull/430))
+- Formatting is now asynchronous, and the async job infrastructure has been improved ([#285](https://github.com/helix-editor/helix/pull/285))
+- Grammars are now compiled as separate shared libraries and loaded on-demand at runtime ([#432](https://github.com/helix-editor/helix/pull/432))
+- Code action support ([#478](https://github.com/helix-editor/helix/pull/478))
+- Mouse support ([#509](https://github.com/helix-editor/helix/pull/509), [#548](https://github.com/helix-editor/helix/pull/548))
+- Native Windows clipboard support ([#373](https://github.com/helix-editor/helix/pull/373))
+- Themes can now use color palettes ([#393](https://github.com/helix-editor/helix/pull/393))
+- `:reload` command ([#374](https://github.com/helix-editor/helix/pull/374))
+- Ctrl-z to suspend ([#464](https://github.com/helix-editor/helix/pull/464))
+- Language servers can now be configured with a custom JSON config ([#460](https://github.com/helix-editor/helix/pull/460))
+- Comment toggling now uses a language specific comment token ([#463](https://github.com/helix-editor/helix/pull/463))
+- Julia support ([#413](https://github.com/helix-editor/helix/pull/413))
+- Java support ([#448](https://github.com/helix-editor/helix/pull/448))
+- Prompts have an (in-memory) history ([63e54e30](https://github.com/helix-editor/helix/commit/63e54e30a74bb0d1d782877ddbbcf95f2817d061))
+
+# 0.3.0 (2021-06-27)
+
+Another big release. 
+
+Highlights:
+
+- Indentation is now automatically detected from file heuristics. ([#245](https://github.com/helix-editor/helix/pull/245))
+- Support for other line endings (CRLF). Significantly improved Windows support. ([#224](https://github.com/helix-editor/helix/pull/224))
+- Encodings other than UTF-8 are now supported! ([#228](https://github.com/helix-editor/helix/pull/228))
+- Key bindings can now be configured via a `config.toml` file ([#268](https://github.com/helix-editor/helix/pull/268))
+- Theme can now be configured and changed at runtime ([please feel free to contribute more themes!](https://github.com/helix-editor/helix/tree/master/runtime/themes)) ([#267](https://github.com/helix-editor/helix/pull/267))
+- System clipboard yank/paste is now supported! ([#310](https://github.com/helix-editor/helix/pull/310))
+- Surround commands were implemented ([#320](https://github.com/helix-editor/helix/pull/320))
+
+Features:
+
+- File picker can now be repeatedly filtered ([#232](https://github.com/helix-editor/helix/pull/232))
+- LSP progress is now received and rendered as a spinner ([#234](https://github.com/helix-editor/helix/pull/234))
+- Current line number can now be themed ([#260](https://github.com/helix-editor/helix/pull/260))
+- Arrow keys & home/end now work in insert mode ([#305](https://github.com/helix-editor/helix/pull/305))
+- Cursors and selections can now be themed ([#325](https://github.com/helix-editor/helix/pull/325))
+- Language servers are now gracefully shut down before `hx` exits ([#287](https://github.com/helix-editor/helix/pull/287))
+- `:show-directory`/`:change-directory` ([#335](https://github.com/helix-editor/helix/pull/335))
+- File picker is now sorted by access time (before filtering) ([#336](https://github.com/helix-editor/helix/pull/336))
+- Code is being migrated from helix-term to helix-view (prerequisite for
+  alternative frontends) ([#366](https://github.com/helix-editor/helix/pull/366))
+- `x` and `X` merged
+  ([f41688d9](https://github.com/helix-editor/helix/commit/f41688d960ef89c29c4a51c872b8406fb8f81a85))
+
+Fixes:
+
+- The IME popup is now correctly positioned ([#273](https://github.com/helix-editor/helix/pull/273))
+- A bunch of bugs regarding `o`/`O` behavior ([#281](https://github.com/helix-editor/helix/pull/281))
+- `~` expansion now works in file completion ([#284](https://github.com/helix-editor/helix/pull/284))
+- Several UI related overflow crashes ([#318](https://github.com/helix-editor/helix/pull/318))
+- Fix a test failure occuring only on `test --release` ([4f108ab1](https://github.com/helix-editor/helix/commit/4f108ab1b2197809506bd7305ad903a3525eabfa))
+- Prompts now support unicode input ([#295](https://github.com/helix-editor/helix/pull/295))
+- Completion documentation no longer overlaps the popup ([#322](https://github.com/helix-editor/helix/pull/322))
+- Fix a crash when trying to select `^` ([9c534614](https://github.com/helix-editor/helix/commit/9c53461429a3e72e3b1fb87d7ca490e168d7dee2))
+- Prompt completions are now paginated ([39dc09e6](https://github.com/helix-editor/helix/commit/39dc09e6c4172299bc79de4c1c52288d3f624bd7))
+- Goto did not work on Windows ([503ca112](https://github.com/helix-editor/helix/commit/503ca112ae57ebdf3ea323baf8940346204b46d2))
+
+# 0.2.1
+
+Includes a fix where wq/wqa could exit before file saving completed.
+
+# 0.2.0
+
+Enough has changed to bump the version. We're skipping 0.1.x because
+previously the CLI would always report version as 0.1.0, and we'd like
+to distinguish it in bug reports..
+
+- The `runtime/` directory is now properly detected on binary releases and
+  on cargo run. `~/.config/helix/runtime` can also be used.
+- Registers can now be selected via " (for example `"ay`)
+- Support for Nix files was added
+- Movement is now fully tested and matches kakoune implementation
+- A per-file LSP symbol picker was added to space+s
+- Selection can be replaced with yanked text via R
+
+- `1g` now correctly goes to line 1
+- `ctrl-i` now correctly jumps backwards in history
+- A small memory leak was fixed, where we tried to reuse tree-sitter
+  query cursors, but always allocated a new one
+- Auto-formatting is now only on for certain languages
+- The root directory is now provided in LSP initialization, fixing
+  certain language servers (typescript)
+- LSP failing to start no longer panics
+- Elixir language queries were fixed
+
+# 0.0.10
+
+Keymaps:
+- Add mappings to jump to diagnostics
+- Add gt/gm/gb mappings to jump to top/middle/bottom of screen
+- ^ and $ are now gh, gl
+
+- The runtime/ can now optionally be embedded in the binary
+- Haskell syntax added
+- Window mode (ctrl-w) added
+- Show matching bracket (vim's matchbrackets)
+- Themes now support style modifiers
+- First user contributed theme
+- Create a document if it doesn't exist yet on save
+- Detect language on a new file on save
+
+- Panic fixes, lots of them

Cargo.lock

@@ -13,9 +13,15 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.40"
+version = "1.0.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28b2cd92db5cbd74e8e5028f7e27dd7aa3090e89e4f2a197cc7c8dfb69c7063b"
+checksum = "595d3cfa7a60d4555cb5067b99f07142a08ea778de5cf993f7b75c7d8fabc486"
+
+[[package]]
+name = "arc-swap"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e906254e445520903e7fc9da4f709886c84ae4bc4ddaf0e093188d66df4dc820"
 
 [[package]]
 name = "autocfg"
@@ -25,9 +31,9 @@ checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
 
 [[package]]
 name = "bitflags"
-version = "1.2.1"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
+checksum = "2da1976d75adbe5fbc88130ecd119529cf1cc6a93ae1546d8696ee66f0d21af1"
 
 [[package]]
 name = "bstr"
@@ -52,12 +58,9 @@ checksum = "df8670b8c7b9dae1793364eafadf7239c40d669904660c5960d74cfd80b46a53"
 
 [[package]]
 name = "cc"
-version = "1.0.67"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3c69b077ad434294d3ce9f1f6143a2a4b89a8a2d54ef813d85003a4fd1137fd"
-dependencies = [
- "jobserver",
-]
+checksum = "e70cc2f62c6ce1868963827bd677764c62d07c3d9a3e1fb1177ee1a9ab199eb2"
 
 [[package]]
 name = "cfg-if"
@@ -65,6 +68,17 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "chardetng"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36a5a2ca47925d19fb6835f53b3e70dec0d25659211c8ee5cc784f1fd6838f9c"
+dependencies = [
+ "cfg-if",
+ "encoding_rs",
+ "memchr",
+]
+
 [[package]]
 name = "chrono"
 version = "0.4.19"
@@ -78,53 +92,48 @@ dependencies = [
 ]
 
 [[package]]
-name = "clap"
-version = "3.0.0-beta.2"
+name = "clipboard-win"
+version = "4.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bd1061998a501ee7d4b6d449020df3266ca3124b941ec56cf2005c3779ca142"
+checksum = "4e4ea1881992efc993e4dc50a324cdbd03216e41bdc8385720ff47efc9bd2ca8"
 dependencies = [
- "bitflags",
- "indexmap",
- "lazy_static",
- "os_str_bytes",
- "textwrap",
- "unicode-width",
- "vec_map",
+ "error-code",
+ "str-buf",
+ "winapi",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4feb231f0d4d6af81aed15928e58ecf5816aa62a2393e2c82f46973e92a9a278"
+checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db"
 dependencies = [
- "autocfg",
  "cfg-if",
  "lazy_static",
 ]
 
 [[package]]
 name = "crossterm"
-version = "0.19.0"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c36c10130df424b2f3552fcc2ddcd9b28a27b1e54b358b45874f88d1ca6888c"
+checksum = "c0ebde6a9dd5e331cd6c6f48253254d117642c31653baa475e394657c59c1f7d"
 dependencies = [
  "bitflags",
  "crossterm_winapi",
  "futures-core",
- "lazy_static",
  "libc",
  "mio",
  "parking_lot",
  "signal-hook",
+ "signal-hook-mio",
  "winapi",
 ]
 
 [[package]]
 name = "crossterm_winapi"
-version = "0.7.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0da8964ace4d3e4a044fd027919b2237000b24315a37c916f61809f1ff2140b9"
+checksum = "3a6966607622438301997d3dac0d2f6e9a90c68bb6bc1785ea98456ab93c0507"
 dependencies = [
  "winapi",
 ]
@@ -150,6 +159,31 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "either"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80df024fbc5ac80f87dfef0d9f5209a252f2a497f7f42944cff24d8253cac065"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "error-code"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5115567ac25674e0043e472be13d14e537f37ea8aa4bdc4aef0c89add1db1ff"
+dependencies = [
+ "libc",
+ "str-buf",
+]
+
 [[package]]
 name = "etcetera"
 version = "0.3.2"
@@ -198,15 +232,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.15"
+version = "0.3.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0402f765d8a89a26043b889b26ce3c4679d268fa6bb22cd7c6aad98340e179d1"
+checksum = "af51b1b4a7fdff033703db39de8802c673eb91855f2e0d47dcf3bf2c0ef01f99"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.15"
+version = "0.3.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "badaa6a909fac9e7236d0620a2f57f7664640c56575b71a7552fbd68deafab79"
+checksum = "4d0d535a57b87e1ae31437b892713aee90cd2d7b0ee48727cd11fc72ef54761c"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -215,15 +249,15 @@ dependencies = [
 
 [[package]]
 name = "futures-task"
-version = "0.3.15"
+version = "0.3.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a16bef9fc1a4dddb5bee51c989e3fbba26569cbb0e31f5b303c184e3dd33dae"
+checksum = "bbe54a98670017f3be909561f6ad13e810d9a51f3f061b902062ca3da80799f2"
 
 [[package]]
 name = "futures-util"
-version = "0.3.15"
+version = "0.3.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "feb5c238d27e2bf94ffdfd27b2c29e3df4a68c4193bb6427384259e2bf191967"
+checksum = "67eb846bfd58e44a8481a00049e82c43e0ccb5d61f8dc071057cb19249dd4d78"
 dependencies = [
  "autocfg",
  "futures-core",
@@ -244,26 +278,20 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9495705279e7140bf035dde1f6e750c162df8b625267cd52cc44e0b156732c8"
+checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
 dependencies = [
  "cfg-if",
  "libc",
  "wasi",
 ]
 
-[[package]]
-name = "glob"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
-
 [[package]]
 name = "globset"
-version = "0.4.6"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c152169ef1e421390738366d2f796655fec62621dabbd0fd476f905934061e4a"
+checksum = "10463d9ff00a2a068db14231982f5132edebad0d7660cd956a1c30292dbcbfbd"
 dependencies = [
  "aho-corasick",
  "bstr",
@@ -272,71 +300,64 @@ dependencies = [
  "regex",
 ]
 
-[[package]]
-name = "hashbrown"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7afe4a420e3fe79967a00898cc1f4db7c8a49a9333a29f8a4bd76a253d5cd04"
-
 [[package]]
 name = "helix-core"
-version = "0.1.0"
+version = "0.4.1"
 dependencies = [
- "anyhow",
+ "arc-swap",
  "etcetera",
  "helix-syntax",
  "once_cell",
+ "quickcheck",
  "regex",
  "ropey",
  "serde",
+ "similar",
  "smallvec",
  "tendril",
+ "toml",
  "tree-sitter",
+ "unicode-general-category",
  "unicode-segmentation",
  "unicode-width",
 ]
 
 [[package]]
 name = "helix-lsp"
-version = "0.1.0"
+version = "0.4.1"
 dependencies = [
  "anyhow",
  "futures-executor",
  "futures-util",
- "glob",
  "helix-core",
  "jsonrpc-core",
  "log",
  "lsp-types",
- "once_cell",
- "pathdiff",
  "serde",
  "serde_json",
  "thiserror",
  "tokio",
  "tokio-stream",
- "url",
 ]
 
 [[package]]
 name = "helix-syntax"
-version = "0.1.0"
+version = "0.4.1"
 dependencies = [
+ "anyhow",
  "cc",
- "serde",
+ "libloading",
  "threadpool",
  "tree-sitter",
 ]
 
 [[package]]
 name = "helix-term"
-version = "0.1.0"
+version = "0.4.1"
 dependencies = [
  "anyhow",
  "chrono",
- "clap",
  "crossterm",
- "dirs-next",
  "fern",
  "futures-util",
  "fuzzy-matcher",
@@ -351,44 +372,54 @@ dependencies = [
  "pulldown-cmark",
  "serde",
  "serde_json",
+ "signal-hook",
+ "signal-hook-tokio",
  "tokio",
  "toml",
 ]
 
 [[package]]
 name = "helix-tui"
-version = "0.1.0"
+version = "0.4.1"
 dependencies = [
  "bitflags",
  "cassowary",
  "crossterm",
+ "helix-core",
+ "helix-view",
  "serde",
  "unicode-segmentation",
- "unicode-width",
 ]
 
 [[package]]
 name = "helix-view"
-version = "0.1.0"
+version = "0.4.1"
 dependencies = [
  "anyhow",
+ "bitflags",
+ "chardetng",
+ "clipboard-win",
  "crossterm",
+ "encoding_rs",
+ "futures-util",
  "helix-core",
  "helix-lsp",
  "helix-tui",
+ "log",
  "once_cell",
  "serde",
  "slotmap",
  "tokio",
  "toml",
  "url",
+ "which",
 ]
 
 [[package]]
 name = "hermit-abi"
-version = "0.1.18"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
 dependencies = [
  "libc",
 ]
@@ -406,9 +437,9 @@ dependencies = [
 
 [[package]]
 name = "ignore"
-version = "0.4.17"
+version = "0.4.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b287fb45c60bb826a0dc68ff08742b9d88a2fea13d6e0c286b3172065aaf878c"
+checksum = "713f1b139373f96a2e0ce3ac931cd01ee973c3c5dd7c40c0c2efe96ad2b6751d"
 dependencies = [
  "crossbeam-utils",
  "globset",
@@ -422,21 +453,11 @@ dependencies = [
  "winapi-util",
 ]
 
-[[package]]
-name = "indexmap"
-version = "1.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "824845a0bf897a9042383849b02c1bc219c2383772efcd5c6f9766fa4b81aef3"
-dependencies = [
- "autocfg",
- "hashbrown",
-]
-
 [[package]]
 name = "instant"
-version = "0.1.9"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61124eeebbd69b8190558df225adf7e4caafce0d743919e5d6b19652314ec5ec"
+checksum = "bee0328b1209d157ef001c94dd85b4f8f64139adb0eac2659f4b08382b2f474d"
 dependencies = [
  "cfg-if",
 ]
@@ -447,19 +468,11 @@ version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"
 
-[[package]]
-name = "jobserver"
-version = "0.1.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "972f5ae5d1cb9c6ae417789196c803205313edde988685da5e3aae0827b9e7fd"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "jsonrpc-core"
-version = "17.1.0"
-source = "git+https://github.com/paritytech/jsonrpc#609d7a6cc160742d035510fa89fb424ccf077660"
+version = "18.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14f7f76aef2d054868398427f6c54943cf3d1caa9a7ec7d0c38d69df97a965eb"
 dependencies = [
  "futures-util",
  "log",
@@ -476,9 +489,19 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.94"
+version = "0.2.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18794a8ad5b29321f790b55d93dfba91e125cb1a9edbd4f8e3150acc771c1a5e"
+checksum = "a7f823d141fe0a24df1e23b4af4e3c7ba9e5966ec514ea068c93024aa7deb765"
+
+[[package]]
+name = "libloading"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f84d96438c15fcd6c3f244c8fce01d1e2b9c6b5623e9c711dc9286d8fc92d6a"
+dependencies = [
+ "cfg-if",
+ "winapi",
+]
 
 [[package]]
 name = "lock_api"
@@ -500,9 +523,9 @@ dependencies = [
 
 [[package]]
 name = "lsp-types"
-version = "0.89.0"
+version = "0.89.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07731ecd4ee0654728359a5b95e2a254c857876c04b85225496a35d60345daa7"
+checksum = "852e0dedfd52cc32325598b2631e0eba31b7b708959676a9f837042f276b09a2"
 dependencies = [
  "bitflags",
  "serde",
@@ -519,9 +542,9 @@ checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
 
 [[package]]
 name = "matches"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
+checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
 
 [[package]]
 name = "memchr"
@@ -531,9 +554,9 @@ checksum = "b16bd47d9e329435e309c58469fe0791c2d0d1ba96ec0954152a5ae2b04387dc"
 
 [[package]]
 name = "mio"
-version = "0.7.11"
+version = "0.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf80d3e903b34e0bd7282b218398aec54e082c840d9baf8339e0080a0c542956"
+checksum = "8c2bdb6314ec10835cd3293dd268473a835c02b7b352e788be788b3c6ca6bb16"
 dependencies = [
  "libc",
  "log",
@@ -597,15 +620,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.7.2"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af8b08b04175473088b46763e51ee54da5f9a164bc162f615b91bc179dbf15a3"
-
-[[package]]
-name = "os_str_bytes"
-version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afb2e1c3ee07430c2cf76151675e583e0f19985fa6efae47d6848a3e2c824f85"
+checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"
 
 [[package]]
 name = "parking_lot"
@@ -632,12 +649,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "pathdiff"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877630b3de15c0b64cc52f659345724fbf6bdad9bd9566699fc53688f3c34a34"
-
 [[package]]
 name = "percent-encoding"
 version = "2.1.0"
@@ -646,9 +657,9 @@ checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.6"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc0e1f259c92177c30a4c9d177246edd0a3568b25756a977d0632cf8fa37e905"
+checksum = "8d31d11c69a6b52a174b42bdc0c30e5e11670f90788b2c471c31c1d17d449443"
 
 [[package]]
 name = "pin-utils"
@@ -658,9 +669,9 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.26"
+version = "1.0.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a152013215dca273577e18d2bf00fa862b89b24169fb78c4c95aeb07992c9cec"
+checksum = "5c7ed8b8c7b886ea3ed7dde405212185f423ab44682667c8c6dd14aa1d9f6612"
 dependencies = [
  "unicode-xid",
 ]
@@ -676,6 +687,15 @@ dependencies = [
  "unicase",
 ]
 
+[[package]]
+name = "quickcheck"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "588f6378e4dd99458b60ec275b4477add41ce4fa9f64dcba6f15adccb19b50d6"
+dependencies = [
+ "rand",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.9"
@@ -686,10 +706,28 @@ dependencies = [
 ]
 
 [[package]]
-name = "redox_syscall"
-version = "0.2.8"
+name = "rand"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "742739e41cd49414de871ea5e549afb7e2a3ac77b589bcbebe8c82fab37147fc"
+checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
 dependencies = [
  "bitflags",
 ]
@@ -723,9 +761,9 @@ checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
 
 [[package]]
 name = "ropey"
-version = "1.2.0"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f3ef16589fdbb3e8fbce3dca944c08e61f39c7f16064b21a257d68ea911a83"
+checksum = "9150aff6deb25b20ed110889f070a678bcd1033e46e5e9d6fb1abeab17947f28"
 dependencies = [
  "smallvec",
 ]
@@ -753,18 +791,18 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "serde"
-version = "1.0.125"
+version = "1.0.127"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "558dc50e1a5a5fa7112ca2ce4effcb321b0300c0d4ccf0776a9f60cd89031171"
+checksum = "f03b9878abf6d14e6779d3f24f07b2cfa90352cfec4acc5aab8f1ac7f146fae8"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.125"
+version = "1.0.127"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b093b7a2bb58203b5da3056c05b4ec1fed827dcfdb37347a8841695263b3d06d"
+checksum = "a024926d3432516606328597e0f224a51355a493b49fdd67e9209187cbe55ecc"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -773,9 +811,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.64"
+version = "1.0.66"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "799e97dc9fdae36a5c8b8f2cae9ce2ee9fdce2058c57a93e6099d919fd982f79"
+checksum = "336b10da19a12ad094b59d870ebde26a45402e5b470add4b5fd03c5048a32127"
 dependencies = [
  "itoa",
  "ryu",
@@ -795,35 +833,63 @@ dependencies = [
 
 [[package]]
 name = "signal-hook"
-version = "0.1.17"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e31d442c16f047a671b5a71e2161d6e68814012b7f5379d269ebd915fac2729"
+checksum = "470c5a6397076fae0094aaf06a08e6ba6f37acb77d3b1b91ea92b4d6c8650c39"
 dependencies = [
  "libc",
- "mio",
  "signal-hook-registry",
 ]
 
 [[package]]
-name = "signal-hook-registry"
-version = "1.3.0"
+name = "signal-hook-mio"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16f1d0fef1604ba8f7a073c7e701f213e056707210e9020af4528e0101ce11a6"
+checksum = "29fd5867f1c4f2c5be079aee7a2adf1152ebb04a4bc4d341f504b7dece607ed4"
+dependencies = [
+ "libc",
+ "mio",
+ "signal-hook",
+]
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0"
 dependencies = [
  "libc",
 ]
 
 [[package]]
-name = "slab"
-version = "0.4.3"
+name = "signal-hook-tokio"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f173ac3d1a7e3b28003f40de0b5ce7fe2710f9b9dc3fc38664cebee46b3b6527"
+checksum = "f6c5d32165ff8b94e68e7b3bdecb1b082e958c22434b363482cfb89dcd6f3ff8"
+dependencies = [
+ "futures-core",
+ "libc",
+ "signal-hook",
+ "tokio",
+]
+
+[[package]]
+name = "similar"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad1d488a557b235fc46dae55512ffbfc429d2482b08b4d9435ab07384ca8aec"
+
+[[package]]
+name = "slab"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c307a32c1c5c437f38c7fd45d753050587732ba8628319fbdf12a7e289ccc590"
 
 [[package]]
 name = "slotmap"
-version = "1.0.3"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "585cd5dffe4e9e06f6dfdf66708b70aca3f781bed561f4f667b2d9c0d4559e36"
+checksum = "a952280edbecfb1d4bd3cf2dbc309dc6ab523e53487c438ae21a6df09fe84bc4"
 dependencies = [
  "version_check",
 ]
@@ -835,10 +901,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e"
 
 [[package]]
-name = "syn"
-version = "1.0.72"
+name = "str-buf"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1e8cdbefb79a9a5a65e0db8b47b723ee907b7c7f8496c76a1770b5c310bab82"
+checksum = "d44a3643b4ff9caf57abcee9c2c621d6c03d9135e0d8b589bd9afb5992cb176a"
+
+[[package]]
+name = "syn"
+version = "1.0.74"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1873d832550d4588c3dbc20f01361ab00bfe741048f71e3fecf145a7cc18b29c"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -856,29 +928,20 @@ dependencies = [
  "utf-8",
 ]
 
-[[package]]
-name = "textwrap"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "203008d98caf094106cfaba70acfed15e18ed3ddb7d94e49baec153a2b462789"
-dependencies = [
- "unicode-width",
-]
-
 [[package]]
 name = "thiserror"
-version = "1.0.24"
+version = "1.0.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0f4a65597094d4483ddaed134f409b2cb7c1beccf25201a9f73c719254fa98e"
+checksum = "93119e4feac1cbe6c798c34d3a53ea0026b0b1de6a120deef895137c0529bfe2"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.24"
+version = "1.0.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7765189610d8241a44529806d6fd1f2e0a08734313a35d5b3a556f92b381f3c0"
+checksum = "060d69a0afe7796bf42e9e2ff91f5ee691fb15c53d38b4b62a9a53eb23164745"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -905,9 +968,9 @@ dependencies = [
 
 [[package]]
 name = "tinyvec"
-version = "1.2.0"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b5220f05bb7de7f3f53c7c065e1199b3172696fe2db9f9c4d8ad9b4ee74c342"
+checksum = "848a1e1181b9f6753b5e96a092749e29b11d19ede67dfbbd6c7dc7e0f49b5338"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -920,9 +983,9 @@ checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
 
 [[package]]
 name = "tokio"
-version = "1.5.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83f0c8e7c0addab50b663055baf787d0af7f413a46e6e7fb9559a4e4db7137a5"
+checksum = "01cf844b23c6131f624accf65ce0e4e9956a8bb329400ea5bcc26ae3a5c20b0b"
 dependencies = [
  "autocfg",
  "bytes",
@@ -940,9 +1003,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-macros"
-version = "1.1.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "caf7b11a536f46a809a8a9f0bb4237020f70ecbf115b842360afb127ea2fda57"
+checksum = "54473be61f4ebe4efd09cec9bd5d16fa51d70ea0192213d754d2d500457db110"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -951,9 +1014,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.5"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e177a5d8c3bf36de9ebe6d58537d8879e964332f93fb3339e43f618c81361af0"
+checksum = "7b2f3f698253f03119ac0102beaa64f67a67e08074d03a22d18784104543727f"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -971,9 +1034,9 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter"
-version = "0.19.3"
+version = "0.19.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f41201fed3db3b520405a9c01c61773a250d4c3f43e9861c14b2bb232c981ab"
+checksum = "ad726ec26496bf4c083fff0f43d4eb3a2ad1bba305323af5ff91383c0b6ecac0"
 dependencies = [
  "cc",
  "regex",
@@ -990,27 +1053,30 @@ dependencies = [
 
 [[package]]
 name = "unicode-bidi"
-version = "0.3.5"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eeb8be209bb1c96b7c177c7420d26e04eccacb0eeae6b980e35fcb74678107e0"
-dependencies = [
- "matches",
-]
+checksum = "246f4c42e67e7a4e3c6106ff716a5d067d4132a642840b242e357e468a2a0085"
+
+[[package]]
+name = "unicode-general-category"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07547e3ee45e28326cc23faac56d44f58f16ab23e413db526debce3b0bfd2742"
 
 [[package]]
 name = "unicode-normalization"
-version = "0.1.17"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07fbfce1c8a97d547e8b5334978438d9d6ec8c20e38f56d4a4374d181493eaef"
+checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
 dependencies = [
  "tinyvec",
 ]
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.7.1"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb0d2e7be6ae3a5fa87eed5fb451aff96f2573d2694942e40543ae0bbe19c796"
+checksum = "8895849a949e7845e06bd6dc1aa51731a103c42707010a5b591c0038fb73385b"
 
 [[package]]
 name = "unicode-width"
@@ -1043,12 +1109,6 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
 
-[[package]]
-name = "vec_map"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
-
 [[package]]
 name = "version_check"
 version = "0.9.3"
@@ -1072,6 +1132,17 @@ version = "0.10.2+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
 
+[[package]]
+name = "which"
+version = "4.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea187a8ef279bc014ec368c27a920da2024d2a711109bfbe3440585d5cf27ad9"
+dependencies = [
+ "either",
+ "lazy_static",
+ "libc",
+]
+
 [[package]]
 name = "winapi"
 version = "0.3.9"

README.md

@@ -1,7 +1,7 @@
 # Helix
 
 
-[![Build status](https://github.com/helix-editor/helix/workflows/ci/badge.svg)](https://github.com/helix-editor/helix/actions)
+[![Build status](https://github.com/helix-editor/helix/actions/workflows/build.yml/badge.svg)](https://github.com/helix-editor/helix/actions)
 
 ![Screenshot](./screenshot.png)
 
@@ -10,7 +10,12 @@ A kakoune / neovim inspired editor, written in Rust.
 The editing model is very heavily based on kakoune; during development I found
 myself agreeing with most of kakoune's design decisions.
 
-For more information, see the [website](https://helix-editor.com).
+For more information, see the [website](https://helix-editor.com) or
+[documentation](https://docs.helix-editor.com/).
+
+All shortcuts/keymaps can be found [in the documentation on the website](https://docs.helix-editor.com/keymap.html).
+
+[Troubleshooting](https://github.com/helix-editor/helix/wiki/Troubleshooting)
 
 # Features
 
@@ -24,7 +29,8 @@ It's a terminal-based editor first, but I'd like to explore a custom renderer
 
 # Installation
 
-Note: Only the Rust syntax has indentation definitions at the moment.
+Note: Only certain languages have indentation definitions at the moment. Check
+`runtime/queries/<lang>/` for `indents.toml`.
 
 We provide packaging for various distributions, but here's a quick method to
 build from source.
@@ -37,18 +43,37 @@ cargo install --path helix-term
 
 This will install the `hx` binary to `$HOME/.cargo/bin`.
 
-Now copy the `runtime/` directory somewhere. Helix will by default look for the
-runtime inside the same folder as the executable, but that can be overriden via
-the `HELIX_RUNTIME` environment variable.
+Helix also needs it's runtime files so make sure to copy/symlink the `runtime/` directory into the
+config directory (for example `~/.config/helix/runtime` on Linux/macOS). This location can be overriden
+via the `HELIX_RUNTIME` environment variable.
 
+Packages already solve this for you by wrapping the `hx` binary with a wrapper
+that sets the variable to the install dir.
+
+> NOTE: running via cargo also doesn't require setting explicit `HELIX_RUNTIME` path, it will automatically
+> detect the `runtime` directory in the project root.
+
+[![Packaging status](https://repology.org/badge/vertical-allrepos/helix.svg)](https://repology.org/project/helix/versions)
+
+## MacOS
+Helix can be installed on MacOS through homebrew via:
+
+```
+brew tap helix-editor/helix
+brew install helix
+```
+ 
 # Contributing
 
 Contributors are very welcome! **No contribution is too small and all contributions are valued.**
 
 Some suggestions to get started:
 
-- You can look at the [good first issue](https://github.com/helix-editor/helix/labels/good%20first%20issue) label on the issue tracker.
+- You can look at the [good first issue](https://github.com/helix-editor/helix/labels/E-easy) label on the issue tracker.
 - Help with packaging on various distributions needed!
+- To use print debugging to the `~/.cache/helix/helix.log` file, you must:
+  * Print using `log::info!`, `warn!`, or `error!`. (`log::info!("helix!")`)
+  * Pass the appropriate verbosity level option for the desired log level. (`hx -v <file>` for info, more `v`s for higher severity inclusive)
 - If your preferred language is missing, integrating a tree-sitter grammar for
     it and defining syntax highlight queries for it is straight forward and
     doesn't require much knowledge of the internals.
@@ -58,5 +83,4 @@ a good overview of the internals.
 
 # Getting help
 
-Discuss the project on the community [Matrix channel](https://matrix.to/#/#helix-editor:matrix.org).
-
+Discuss the project on the community [Matrix Space](https://matrix.to/#/#helix-community:matrix.org) (make sure to join `#helix-editor:matrix.org` if you're on a client that doesn't support Matrix Spaces yet).

TODO.md

@@ -1,7 +1,3 @@
-- Refactor tree-sitter-highlight to work like the atom one, recomputing partial tree updates.
-- syntax errors highlight query
-
-------
 
 - tree sitter:
   - lua
@@ -14,48 +10,30 @@
   - clojure
   - erlang
 
+as you type completion!
 - [ ] use signature_help_provider and completion_provider trigger characters in
     a hook to trigger signature help text / autocompletion
 - [ ] document.on_type provider triggers
 - [ ] completion isIncomplete support
 
-- [ ] extract indentation calculation queries so we can support other languages.
-
 1
-- [ ] :format/:fmt that formats the buffer
 - [ ] respect view fullscreen flag
 - [ ] Implement marks (superset of Selection/Range)
 
-- [ ] nixos packaging
-- [ ] CI binary builds
-
 - [ ] = for auto indent line/selection
 - [ ]  :x for closing buffers
-
 - [ ] repeat selection
 
-- [] jump to alt buffer
-
 - [ ] lsp: signature help
-- [x] lsp: hover
-- [ ] lsp: document symbols (nested/vec)
-- [ ] lsp: code actions
-- [ ] lsp: formatting
-- [x] lsp: goto
 
 - [ ] search: smart case by default: insensitive unless upper detected
 
-- [ ] move Compositor into tui
-
 2
-- [ ] surround bindings (select + surround ( wraps selection in parens )
 - [ ] macro recording
 - [ ] extend selection (treesitter select parent node) (replaces viw, vi(, va( etc )
-- [x] bracket pairs
-- [x] comment block (gcc)
 - [ ] selection align
 - [ ] store some state between restarts: file positions, prompt history
-- [ ] highlight matched characters in completion
+- [ ] highlight matched characters in picker
 
 3
 - [ ] diff mode with highlighting?

book/book.toml

@@ -4,3 +4,7 @@ language = "en"
 multilingual = false
 src = "src"
 theme = "colibri"
+edit-url-template = "https://github.com/helix-editor/helix/tree/master/book/{path}?mode=edit"
+
+[output.html]
+cname = "docs.helix-editor.com"

book/src/SUMMARY.md

@@ -3,5 +3,7 @@
 - [Installation](./install.md)
 - [Usage](./usage.md)
 - [Configuration](./configuration.md)
+  - [Themes](./themes.md)
   - [Keymap](./keymap.md)
+  - [Key Remapping](./remapping.md)
   - [Hooks](./hooks.md)

book/src/configuration.md

@@ -1 +1,11 @@
 # Configuration
+
+To override global configuration parameters create a `config.toml` file located in your config directory (i.e `~/.config/helix/config.toml`).
+
+## LSP
+
+To display all language server messages in the status line add the following to your `config.toml`:
+```toml
+[lsp]
+display-messages = true
+```

book/src/install.md

@@ -2,13 +2,15 @@
 
 We provide pre-built binaries on the [GitHub Releases page](https://github.com/helix-editor/helix/releases).
 
+[![Packaging status](https://repology.org/badge/vertical-allrepos/helix.svg)](https://repology.org/project/helix/versions)
+
 ## OSX
 
-TODO: brew tap
+A Homebrew tap is available:
 
 ```
-$ brew tap helix-editor/helix
-$ brew install helix
+brew tap helix-editor/helix
+brew install helix
 ```
 
 ## Linux
@@ -21,7 +23,9 @@ shell for working on Helix.
 
 ### Arch Linux
 
-TODO: AUR
+Binary packages are available on AUR:
+- [helix-bin](https://aur.archlinux.org/packages/helix-bin/) contains the pre-built release
+- [helix-git](https://aur.archlinux.org/packages/helix-git/) builds the master branch
 
 ## Build from source
 
@@ -33,6 +37,6 @@ cargo install --path helix-term
 
 This will install the `hx` binary to `$HOME/.cargo/bin`.
 
-Now copy the `runtime/` directory somewhere. Helix will by default look for the
-runtime inside the same folder as the executable, but that can be overriden via
-the `HELIX_RUNTIME` environment variable.
+Helix also needs it's runtime files so make sure to copy/symlink the `runtime/` directory into the
+config directory (for example `~/.config/helix/runtime` on Linux/macOS). This location can be overriden
+via the `HELIX_RUNTIME` environment variable.

book/src/keymap.md

@@ -4,87 +4,122 @@
 
 ### Movement
 
-| Key | Description |
-|-----|-----------|
-| h   | move left |
-| j   | move down |
-| k   | move up |
-| l   | move right |
-| w   | move next word start |
-| b   | move previous word start |
-| e   | move next word end |
-| t   | find 'till next char |
-| f   | find next char |
-| T   | find 'till previous char |
-| F   | find previous char |
-| 0   | move to the start of the line |
-| $   | move to the end of the line |
-| m   | Jump to matching bracket | 
-| PageUp | Move page up |
-| PageDown | Move page down |
-| ctrl-u | Move half page up |
-| ctrl-d | Move half page down |
-| Tab | Switch to next view |
-| ctrl-i | Jump forward on the jumplist TODO: conflicts tab |
-| ctrl-o | Jump backward on the jumplist |
-| v   | Enter select (extend) mode |
-| g   | Enter goto mode |
-| :   | Enter command mode |
-| z   | Enter view mode |
-| space   | Enter space mode |
-| K | Show documentation for the item under the cursor |
+> NOTE: `f`, `F`, `t` and `T` are not confined to the current line.
+
+| Key          | Description                                                                |
+| -----        | -----------                                                                |
+| `h`, `Left`  | Move left                                                                  |
+| `j`, `Down`  | Move down                                                                  |
+| `k`, `Up`    | Move up                                                                    |
+| `l`, `Right` | Move right                                                                 |
+| `w`          | Move next word start                                                       |
+| `b`          | Move previous word start                                                   |
+| `e`          | Move next word end                                                         |
+| `W`          | Move next WORD start                                                       |
+| `B`          | Move previous WORD start                                                   |
+| `E`          | Move next WORD end                                                         |
+| `t`          | Find 'till next char                                                       |
+| `f`          | Find next char                                                             |
+| `T`          | Find 'till previous char                                                   |
+| `F`          | Find previous char                                                         |
+| `Home`       | Move to the start of the line                                              |
+| `End`        | Move to the end of the line                                                |
+| `PageUp`     | Move page up                                                               |
+| `PageDown`   | Move page down                                                             |
+| `Ctrl-u`     | Move half page up                                                          |
+| `Ctrl-d`     | Move half page down                                                        |
+| `Ctrl-i`     | Jump forward on the jumplist TODO: conflicts tab                           |
+| `Ctrl-o`     | Jump backward on the jumplist                                              |
+| `v`          | Enter [select (extend) mode](#select--extend-mode)                         |
+| `g`          | Enter [goto mode](#goto-mode)                                              |
+| `m`          | Enter [match mode](#match-mode)                                            |
+| `:`          | Enter command mode                                                         |
+| `z`          | Enter [view mode](#view-mode)                                              |
+| `Ctrl-w`     | Enter [window mode](#window-mode) (maybe will be remove for spc w w later) |
+| `Space`      | Enter [space mode](#space-mode)                                            |
+| `K`          | Show documentation for the item under the cursor                           |
 
 ### Changes
 
-| Key | Description |
-|-----|-----------|
-| r   | replace (single character change) |
-| i   | Insert before selection |
-| a   | Insert after selection (append) |
-| I   | Insert at the start of the line | 
-| A   | Insert at the end of the line | 
-| o   | Open new line below selection | 
-| o   | Open new line above selection | 
-| u   | Undo change |
-| U   | Redo change |
-| y   | Yank selection |
-| p   | Paste after selection |
-| P   | Paste before selection |
-| >   | Indent selection |
-| <   | Unindent selection |
-| =   | Format selection |
-| d   | Delete selection | 
-| c   | Change selection (delete and enter insert mode) | 
+| Key         | Description                                     |
+| -----       | -----------                                     |
+| `r`         | Replace with a character                        |
+| `R`         | Replace with yanked text                        |
+| `~`         | Switch case of the selected text                |
+| `` ` ``     | Set the selected text to lower case             |
+| `` Alt-` `` | Set the selected text to upper case             |
+| `i`         | Insert before selection                         |
+| `a`         | Insert after selection (append)                 |
+| `I`         | Insert at the start of the line                 |
+| `A`         | Insert at the end of the line                   |
+| `o`         | Open new line below selection                   |
+| `O`         | Open new line above selection                   |
+| `u`         | Undo change                                     |
+| `U`         | Redo change                                     |
+| `y`         | Yank selection                                  |
+| `p`         | Paste after selection                           |
+| `P`         | Paste before selection                          |
+| `>`         | Indent selection                                |
+| `<`         | Unindent selection                              |
+| `=`         | Format selection                                |
+| `d`         | Delete selection                                |
+| `c`         | Change selection (delete and enter insert mode) |
 
 ### Selection manipulation
 
-| Key | Description |
-|-----|-----------|
-| s   | Select all regex matches inside selections | 
-| S   | Split selection into subselections on regex matches | 
-| alt-s   | Split selection on newlines | 
-| ;   | Collapse selection onto a single cursor | 
-| alt-;   | Flip selection cursor and anchor | 
-| %   | Select entire file | 
-| x   | Select current line | 
-| X   | Extend to next line | 
-| [   | Expand selection to parent syntax node TODO: pick a key | 
-| J | join lines inside selection |
-| K | keep selections matching the regex TODO: overlapped by hover help |
-| space | keep only the primary selection TODO: overlapped by space mode |
-| ctrl-c | Comment/uncomment the selections | 
+| Key      | Description                                                       |
+| -----    | -----------                                                       |
+| `s`      | Select all regex matches inside selections                        |
+| `S`      | Split selection into subselections on regex matches               |
+| `Alt-s`  | Split selection on newlines                                       |
+| `;`      | Collapse selection onto a single cursor                           |
+| `Alt-;`  | Flip selection cursor and anchor                                  |
+| `C`      | Copy selection onto the next line                                 |
+| `Alt-C`  | Copy selection onto the previous line                             |
+| `(`      | Rotate main selection forward                                     |
+| `)`      | Rotate main selection backward                                    |
+| `Alt-(`  | Rotate selection contents forward                                 |
+| `Alt-)`  | Rotate selection contents backward                                |
+| `%`      | Select entire file                                                |
+| `x`      | Select current line, if already selected, extend to next line     |
+| `X`      | Extend selection to line bounds (line-wise selection)             |
+|          | Expand selection to parent syntax node TODO: pick a key           |
+| `J`      | Join lines inside selection                                       |
+| `K`      | Keep selections matching the regex TODO: overlapped by hover help |
+| `Space`  | Keep only the primary selection TODO: overlapped by space mode    |
+| `Ctrl-c` | Comment/uncomment the selections                                  |
+
+### Insert Mode
+
+| Key      | Description           |
+| -----    | -----------           |
+| `Escape` | Switch to normal mode |
+| `Ctrl-x` | Autocomplete          |
+| `Ctrl-w` | Delete previous word  |
 
 ### Search
 
 > TODO: The search implementation isn't ideal yet -- we don't support searching
 in reverse, or searching via smartcase.
 
-| Key | Description |
-|-----|-----------|
-| /   | Search for regex pattern | 
-| n   | Select next search match | 
-| N   | Add next search match to selection | 
-| *   | Use current selection as the search pattern | 
+| Key   | Description                                 |
+| ----- | -----------                                 |
+| `/`   | Search for regex pattern                    |
+| `n`   | Select next search match                    |
+| `N`   | Add next search match to selection          |
+| `*`   | Use current selection as the search pattern |
+
+### Diagnostics
+
+> NOTE: `[` and `]` will likely contain more pair mappings in the style of
+> [vim-unimpaired](https://github.com/tpope/vim-unimpaired)
+
+| Key   | Description                        |
+| ----- | -----------                        |
+| `[d`  | Go to previous diagnostic          |
+| `]d`  | Go to next diagnostic              |
+| `[D`  | Go to first diagnostic in document |
+| `]D`  | Go to last diagnostic in document  |
 
 ## Select / extend mode
 
@@ -99,14 +134,14 @@ commands to extend the existing selection instead of replacing it.
 View mode is intended for scrolling and manipulating the view without changing
 the selection.
 
-| Key | Description |
-|-----|-----------|
-| z , c | Vertically center the line |
-| t   | Align the line to the top of the screen |
-| b   | Align the line to the bottom of the screen |
-| m   | Align the line to the middle of the screen (horizontally) |
-| j   | Scroll the view downwards |
-| k   | Scroll the view upwards |
+| Key       | Description                                               |
+| -----     | -----------                                               |
+| `z` , `c` | Vertically center the line                                |
+| `t`       | Align the line to the top of the screen                   |
+| `b`       | Align the line to the bottom of the screen                |
+| `m`       | Align the line to the middle of the screen (horizontally) |
+| `j`       | Scroll the view downwards                                 |
+| `k`       | Scroll the view upwards                                   |
 
 ## Goto mode
 
@@ -114,28 +149,81 @@ Jumps to various locations.
 
 > NOTE: Some of these features are only available with the LSP present.
 
-| Key | Description |
-|-----|-----------|
-| g   | Go to the start of the file |
-| e   | Go to the end of the file |
-| e   | Go to definition |
-| t   | Go to type definition |
-| r   | Go to references |
-| i   | Go to implementation |
+| Key   | Description                                      |
+| ----- | -----------                                      |
+| `g`   | Go to the start of the file                      |
+| `e`   | Go to the end of the file                        |
+| `h`   | Go to the start of the line                      |
+| `l`   | Go to the end of the line                        |
+| `s`   | Go to first non-whitespace character of the line |
+| `t`   | Go to the top of the screen                      |
+| `m`   | Go to the middle of the screen                   |
+| `b`   | Go to the bottom of the screen                   |
+| `d`   | Go to definition                                 |
+| `y`   | Go to type definition                            |
+| `r`   | Go to references                                 |
+| `i`   | Go to implementation                             |
+| `a`   | Go to the last accessed/alternate file           |
+
+## Match mode
+
+Enter this mode using `m` from normal mode. See the relavant section
+in [Usage](./usage.md) for an explanation about [surround](./usage.md#surround)
+and [textobject](./usage.md#textobject) usage.
+
+| Key              | Description                                     |
+| -----            | -----------                                     |
+| `m`              | Goto matching bracket                           |
+| `s` `<char>`     | Surround current selection with `<char>`        |
+| `r` `<from><to>` | Replace surround character `<from>` with `<to>` |
+| `d` `<char>`     | Delete surround character `<char>`              |
+| `a` `<object>`   | Select around textobject                        |
+| `i` `<object>`   | Select inside textobject                        |
 
 ## Object mode
 
 TODO: Mappings for selecting syntax nodes (a superset of `[`).
 
+## Window mode
+
+This layer is similar to vim keybindings as kakoune does not support window.
+
+| Key           | Description             |
+| -----         | -------------           |
+| `w`, `Ctrl-w` | Switch to next window   |
+| `v`, `Ctrl-v` | Vertical right split    |
+| `h`, `Ctrl-h` | Horizontal bottom split |
+| `q`, `Ctrl-q` | Close current window    |
+
 ## Space mode
 
 This layer is a kludge of mappings I had under leader key in neovim.
 
-| Key | Description |
-|-----|-----------|
-| f   | Open file picker |
-| b   | Open buffer picker |
-| v   | Open a new vertical split into the current file |
-| w   | Save changes to file |
-| c   | Close the current split |
-| space   | Keep primary selection TODO: it's here because space mode replaced it |
+| Key     | Description                                                           |
+| -----   | -----------                                                           |
+| `f`     | Open file picker                                                      |
+| `b`     | Open buffer picker                                                    |
+| `s`     | Open symbol picker (current document)                                 |
+| `a`     | Apply code action                                                     |
+| `'`     | Open last fuzzy picker                                                |
+| `w`     | Enter [window mode](#window-mode)                                     |
+| `space` | Keep primary selection TODO: it's here because space mode replaced it |
+| `p`     | Paste system clipboard after selections                               |
+| `P`     | Paste system clipboard before selections                              |
+| `y`     | Join and yank selections to clipboard                                 |
+| `Y`     | Yank main selection to clipboard                                      |
+| `R`     | Replace selections by clipboard contents                              |
+
+# Picker
+
+Keys to use within picker.
+
+| Key                | Description       |
+| -----              | -------------     |
+| `Up`, `Ctrl-p`     | Previous entry    |
+| `Down`, `Ctrl-n`   | Next entry        |
+| `Ctrl-space`       | Filter options    |
+| `Enter`            | Open selected     |
+| `Ctrl-h`           | Open horizontally |
+| `Ctrl-v`           | Open vertically   |
+| `Escape`, `Ctrl-c` | Close picker      |

book/src/remapping.md

@@ -0,0 +1,50 @@
+# Key Remapping
+
+One-way key remapping is temporarily supported via a simple TOML configuration
+file. (More powerful solutions such as rebinding via commands will be
+available in the feature).
+
+To remap keys, write a `config.toml` file in your `helix` configuration
+directory (default `~/.config/helix` in Linux systems) with a structure like
+this:
+
+```toml
+# At most one section each of 'keys.normal', 'keys.insert' and 'keys.select'
+[keys.normal]
+a = "move_char_left" # Maps the 'a' key to the move_char_left command
+w = "move_line_up" # Maps the 'w' key move_line_up
+C-S-esc = "extend_line" # Maps Control-Shift-Escape to extend_line
+
+[keys.insert]
+A-x = "normal_mode" # Maps Alt-X to enter normal mode
+```
+
+Control, Shift and Alt modifiers are encoded respectively with the prefixes
+`C-`, `S-` and `A-`. Special keys are encoded as follows:
+
+| Key name     | Representation |
+| ---          | ---            |
+| Backspace    | `"backspace"`  |
+| Space        | `"space"`      |
+| Return/Enter | `"ret"`        |
+| <            | `"lt"`         |
+| \>           | `"gt"`         |
+| \+           | `"plus"`       |
+| \-           | `"minus"`      |
+| ;            | `"semicolon"`  |
+| %            | `"percent"`    |
+| Left         | `"left"`       |
+| Right        | `"right"`      |
+| Up           | `"up"`         |
+| Home         | `"home"`       |
+| End          | `"end"`        |
+| Page         | `"pageup"`     |
+| Page         | `"pagedown"`   |
+| Tab          | `"tab"`        |
+| Back         | `"backtab"`    |
+| Delete       | `"del"`        |
+| Insert       | `"ins"`        |
+| Null         | `"null"`       |
+| Escape       | `"esc"`        |
+
+Commands can be found in the source code at [`helix-term/src/commands.rs`](https://github.com/helix-editor/helix/blob/master/helix-term/src/commands.rs)

book/src/themes.md

@@ -0,0 +1,122 @@
+# Themes
+
+First you'll need to place selected themes in your `themes` directory (i.e `~/.config/helix/themes`), the directory might have to be created beforehand.
+
+To use a custom theme add `theme = <name>` to your [`config.toml`](./configuration.md) or override it during runtime using `:theme <name>`.
+
+The default theme.toml can be found [here](https://github.com/helix-editor/helix/blob/master/theme.toml), and user submitted themes [here](https://github.com/helix-editor/helix/blob/master/runtime/themes). 
+
+## Creating a theme
+
+First create a file with the name of your theme as file name (i.e `mytheme.toml`) and place it in your `themes` directory (i.e `~/.config/helix/themes`).
+
+Each line in the theme file is specified as below:
+
+```toml
+key = { fg = "#ffffff", bg = "#000000", modifiers = ["bold", "italic"] }
+```
+
+where `key` represents what you want to style, `fg` specifies the foreground color, `bg` the background color, and `modifiers` is a list of style modifiers. `bg` and `modifiers` can be omitted to defer to the defaults.
+
+To specify only the foreground color:
+
+```toml
+key = "#ffffff"
+```
+
+if the key contains a dot `'.'`, it must be quoted to prevent it being parsed as a [dotted key](https://toml.io/en/v1.0.0#keys).
+
+```toml
+"key.key" = "#ffffff"
+```
+
+Possible modifiers:
+
+| Modifier       |
+| ---            |
+| `bold`         |
+| `dim`          |
+| `italic`       |
+| `underlined`   |
+| `slow\_blink`  |
+| `rapid\_blink` |
+| `reversed`     |
+| `hidden`       |
+| `crossed\_out` |
+
+Possible keys:
+
+| Key                      | Notes                               |
+| ---                      | ---                                 |
+| `attribute`              |                                     |
+| `keyword`                |                                     |
+| `keyword.directive`      | Preprocessor directives (\#if in C) |
+| `keyword.control`        | Control flow                        |
+| `namespace`              |                                     |
+| `punctuation`            |                                     |
+| `punctuation.delimiter`  |                                     |
+| `operator`               |                                     |
+| `special`                |                                     |
+| `property`               |                                     |
+| `variable`               |                                     |
+| `variable.parameter`     |                                     |
+| `type`                   |                                     |
+| `type.builtin`           |                                     |
+| `type.enum.variant`      | Enum variants                       |
+| `constructor`            |                                     |
+| `function`               |                                     |
+| `function.macro`         |                                     |
+| `function.builtin`       |                                     |
+| `comment`                |                                     |
+| `variable.builtin`       |                                     |
+| `constant`               |                                     |
+| `constant.builtin`       |                                     |
+| `string`                 |                                     |
+| `number`                 |                                     |
+| `escape`                 | Escaped characters                  |
+| `label`                  | For lifetimes                       |
+| `module`                 |                                     |
+| `ui.background`          |                                     |
+| `ui.cursor`              |                                     |
+| `ui.cursor.insert`       |                                     |
+| `ui.cursor.select`       |                                     |
+| `ui.cursor.match`        | Matching bracket etc.               |
+| `ui.cursor.primary`      | Cursor with primary selection       |
+| `ui.linenr`              |                                     |
+| `ui.linenr.selected`     |                                     |
+| `ui.statusline`          |                                     |
+| `ui.statusline.inactive` |                                     |
+| `ui.popup`               |                                     |
+| `ui.window`              |                                     |
+| `ui.help`                |                                     |
+| `ui.text`                |                                     |
+| `ui.text.focus`          |                                     |
+| `ui.menu.selected`       |                                     |
+| `ui.selection`           | For selections in the editing area  |
+| `ui.selection.primary`   |                                     |
+| `warning`                | LSP warning                         |
+| `error`                  | LSP error                           |
+| `info`                   | LSP info                            |
+| `hint`                   | LSP hint                            |
+
+These keys match [tree-sitter scopes](https://tree-sitter.github.io/tree-sitter/syntax-highlighting#theme). We half-follow the common scopes from [macromates language grammars](https://macromates.com/manual/en/language_grammars) with some differences.
+
+For a given highlight produced, styling will be determined based on the longest matching theme key. So it's enough to provide function to highlight `function.macro` and `function.builtin` as well, but you can use more specific scopes to highlight specific cases differently.
+
+## Color palettes
+
+You can define a palette of named colors, and refer to them from the
+configuration values in your theme. To do this, add a table called
+`palette` to your theme file:
+
+```toml
+ui.background = "white"
+ui.text = "black"
+
+[palette]
+white = "#ffffff"
+black = "#000000"
+```
+
+Remember that the `[palette]` table includes all keys after its header,
+so you should define the palette after normal theme options.

book/src/usage.md

@@ -1 +1,42 @@
 # Usage
+
+(Currently not fully documented, see the [keymappings](./keymap.md) list for more.)
+
+## Surround
+
+Functionality similar to [vim-surround](https://github.com/tpope/vim-surround) is built into
+helix. The keymappings have been inspired from [vim-sandwich](https://github.com/machakann/vim-sandwich):
+
+![surround demo](https://user-images.githubusercontent.com/23398472/122865801-97073180-d344-11eb-8142-8f43809982c6.gif)
+
+- `ms` - Add surround characters
+- `mr` - Replace surround characters
+- `md` - Delete surround characters
+
+`ms` acts on a selection, so select the text first and use `ms<char>`. `mr` and `md` work
+on the closest pairs found and selections are not required; use counts to act in outer pairs.
+
+It can also act on multiple seletions (yay!). For example, to change every occurance of `(use)` to `[use]`:
+
+- `%` to select the whole file
+- `s` to split the selections on a search term
+- Input `use` and hit Enter
+- `mr([` to replace the parens with square brackets
+
+Multiple characters are currently not supported, but planned.
+
+## Textobjects
+
+Currently supported: `word`, `surround`.
+
+![textobject-demo](https://user-images.githubusercontent.com/23398472/124231131-81a4bb00-db2d-11eb-9d10-8e577ca7b177.gif)
+
+- `ma` - Select around the object (`va` in vim, `<alt-a>` in kakoune)
+- `mi` - Select inside the object (`vi` in vim, `<alt-i>` in kakoune)
+
+| Key after `mi` or `ma` | Textobject selected      |
+| ---                    | ---                      |
+| `w`                    | Word                     |
+| `(`, `[`, `'`, etc     | Specified surround pairs |
+
+Textobjects based on treesitter, like `function`, `class`, etc are planned.

book/theme/css/general.css

@@ -109,7 +109,7 @@ h6:target::before {
     margin-top: 1.275em;
     margin-bottom: .875em;
 }
-.content p, .content ol, .content ul, .content table, .content blockquote {
+.content p, .content ol, .content ul, .content table {
     margin-top: 0;
     margin-bottom: .875em;
 }
@@ -123,8 +123,7 @@ h6:target::before {
 .content .header:link,
 .content .header:visited {
     color: var(--fg);
-    /* color: white; */
-    color: #281733;
+    color: var(--heading-fg);
 }
 .content .header:link,
 .content .header:visited:hover {
@@ -168,12 +167,15 @@ table tbody tr:nth-child(2n) {
 
 
 blockquote {
-    margin: 20px 0;
-    padding: 0 20px;
+    margin: 1.5rem 0;
+    padding: 1rem 1.5rem;
     color: var(--fg);
+    opacity: .9;
     background-color: var(--quote-bg);
-    border-top: .1em solid var(--quote-border);
-    border-bottom: .1em solid var(--quote-border);
+    border-left: 4px solid var(--quote-border);
+}
+blockquote *:last-child {
+  margin-bottom: 0;
 }
 
 

book/theme/css/variables.css

@@ -13,6 +13,7 @@
 .ayu {
     --bg: hsl(210, 25%, 8%);
     --fg: #c5c5c5;
+    --heading-fg: #c5c5c5;
 
     --sidebar-bg: #14191f;
     --sidebar-fg: #c8c9db;
@@ -53,6 +54,7 @@
 .coal {
     --bg: hsl(200, 7%, 8%);
     --fg: #98a3ad;
+    --heading-fg: #98a3ad;
 
     --sidebar-bg: #292c2f;
     --sidebar-fg: #a1adb8;
@@ -93,6 +95,7 @@
 .light {
     --bg: hsl(0, 0%, 100%);
     --fg: hsl(0, 0%, 0%);
+    --heading-fg: hsl(0, 0%, 0%);
 
     --sidebar-bg: #fafafa;
     --sidebar-fg: hsl(0, 0%, 0%);
@@ -133,6 +136,7 @@
 .navy {
     --bg: hsl(226, 23%, 11%);
     --fg: #bcbdd0;
+    --heading-fg: #bcbdd0;
 
     --sidebar-bg: #282d3f;
     --sidebar-fg: #c8c9db;
@@ -173,6 +177,7 @@
 .rust {
     --bg: hsl(60, 9%, 87%);
     --fg: #262625;
+    --heading-fg: #262625;
 
     --sidebar-bg: #3b2e2a;
     --sidebar-fg: #c8c9db;
@@ -214,6 +219,7 @@
     .light.no-js {
         --bg: hsl(200, 7%, 8%);
         --fg: #ebeafa;
+        --heading-fg: #ebeafa;
 
         --sidebar-bg: #292c2f;
         --sidebar-fg: #a1adb8;
@@ -297,6 +303,7 @@
     --bg: #ffffff;
     --fg: #452859;
     --fg: #5a5977;
+    --heading-fg: #281733;
 
     --sidebar-bg: #281733;
     --sidebar-fg: #c8c9db;
@@ -317,8 +324,8 @@
     --theme-popup-border: #737480;
     --theme-hover: rgba(0,0,0, .2);
 
-    --quote-bg: hsl(226, 15%, 17%);
-    --quote-border: hsl(226, 15%, 22%);
+    --quote-bg: rgba(0, 0, 0, 0);
+    --quote-border: hsl(226, 15%, 75%);
 
     --table-border-color: #5a5977;
     --table-border-color: hsl(201deg 10% 67%);

contrib/themes

@@ -0,0 +1 @@
+../runtime/themes

docs/architecture.md

@@ -8,68 +8,78 @@
 | helix-term   | Terminal UI                                            |
 | helix-tui    | TUI primitives, forked from tui-rs, inspired by Cursive |
 
-# Notes
 
-- server-client architecture via gRPC, UI separate from core
-- multi cursor based editing and slicing
-- WASM based plugins (builtin LSP & fuzzy file finder)
+This document contains a high-level overview of Helix internals.
 
-Structure similar to codemirror:
+> NOTE: Use `cargo doc --open` for API documentation as well as dependency
+> documentation.
 
-- text (ropes)
-- transactions
-  - changes
-  - invert changes (generates a revert)
-  - annotations (time changed etc)
-  - state effects
-  - additional editor state as facets
-- snapshots as an async view into current state
-- selections { anchor (nonmoving), head (moving) from/to } -> SelectionSet with a primary
-  - cursor is just a single range selection
-- markers
-  track a position inside text that synchronizes with edits
-- { doc, selection, update(), splice, changes(), facets, tabSize, identUnit, lineSeparator, changeFilter/transactionFilter to modify stuff before }
-- view (actual UI)
-- viewport(Lines) -> what's actually visible
-- extend the view via Decorations (inline styling) or Components (UI)
-    - mark / wieget / line / replace decoration
-- commands (transform state)
-- movement
-- selection extension
-- deletion
-- indentation
-- keymap (maps keys to commands)
-- history (undo tree via immutable ropes)
-  - undoes transactions via reverts
-- (collab mode)
-- gutter (line numbers, diagnostic marker, etc) -> ties into UI components
-- rangeset/span -> mappable over changes (can be a marker primitive?)
-- syntax (treesitter)
-- fold
-- selections (select mode/multiselect)
-- matchbrackets
-- closebrackets
-- special-chars (shows dots etc for specials)
-- panel (for UI: file pickers, search dialogs, etc)
-- tooltip (for UI)
-- search (regex)
-- lint (async linters)
-- lsp
-- highlight
-- stream-syntax
-- autocomplete
-- comment (gc, etc for auto commenting)
-- snippets
-- terminal mode?
+## Core
 
-- plugins can contain more commands/ui abstractions to use elsewhere
-- languageData as presets for each language (syntax, indent, comment, etc)
+The core contains basic building blocks used to construct the editor. It is
+heavily based on [CodeMirror 6](https://codemirror.net/6/docs/). The primitives
+are functional: most operations won't modify data in place but instead return
+a new copy.
 
-Vim stuff:
-- motions/operators/text objects
-- full visual mode
-- macros
-- jump lists
-- marks
-- yank/paste
-- conceal for markdown markers, etc
+The main data structure used for representing buffers is a `Rope`. We re-export
+the excellent [ropey](https://github.com/cessen/ropey) library. Ropes are cheap
+to clone, and allow us to easily make snapshots of a text state.
+
+Multiple selections are a core editing primitive. Document selections are
+represented by a `Selection`. Each `Range` in the selection consists of a moving
+`head` and an immovable `anchor`. A single cursor in the editor is simply
+a selection with a single range, with the head and the anchor in the same
+position.
+
+Ropes are modified by constructing an OT-like `Transaction`. It's represents
+a single coherent change to the document and can be applied to the rope.
+A transaction can be inverted to produce an undo. Selections and marks can be
+mapped over a transaction to translate to a position in the new text state after
+applying the transaction.
+
+> NOTE: `Transaction::change`/`Transaction::change_by_selection` is the main
+> interface used to generate text edits.
+
+`Syntax` is the interface used to interact with tree-sitter ASTs for syntax
+highling and other features.
+
+## View
+
+The `view` layer was supposed to be a frontend-agnostic imperative library that
+would build on top of `core` to provide the common editor logic. Currently it's
+tied to the terminal UI.
+
+A `Document` ties together the `Rope`, `Selection`(s), `Syntax`, document
+`History`, language server (etc.) into a comprehensive representation of an open
+file.
+
+A `View` represents an open split in the UI. It holds the currently open
+document ID and other related state.
+
+> NOTE: Multiple views are able to display the same document, so the document
+> contains selections for each view. To retrieve, `document.selection()` takes
+> a `ViewId`.
+
+The `Editor` holds the global state: all the open documents, a tree
+representation of all the view splits, and a registry of language servers. To
+open or close files, interact with the editor.
+
+## LSP
+
+A language server protocol client.
+
+## Term
+
+The terminal frontend.
+
+The `main` function sets up a new `Application` that runs the event loop.
+
+`commands.rs` is probably the most interesting file. It contains all commands
+(actions tied to keybindings). 
+
+`keymap.rs` links commands to key combinations.
+
+
+## TUI / Term
+
+TODO: document Component and rendering related stuff

flake.lock

@@ -1,73 +1,65 @@
 {
   "nodes": {
-    "flake-utils": {
+    "devshell": {
       "locked": {
-        "lastModified": 1619345332,
-        "narHash": "sha256-qHnQkEp1uklKTpx3MvKtY6xzgcqXDsz5nLilbbuL+3A=",
+        "lastModified": 1625086391,
+        "narHash": "sha256-IpNPv1v8s4L3CoxhwcgZIitGpcrnNgnj09X7TA0QV3k=",
         "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "2ebf2558e5bf978c7fb8ea927dfaed8fefab2e28",
+        "repo": "devshell",
+        "rev": "4b5ac7cf7d9a1cc60b965bb51b59922f2210cbc7",
         "type": "github"
       },
       "original": {
         "owner": "numtide",
-        "repo": "flake-utils",
+        "repo": "devshell",
         "type": "github"
       }
     },
-    "flake-utils_2": {
+    "flakeCompat": {
+      "flake": false,
       "locked": {
-        "lastModified": 1614513358,
-        "narHash": "sha256-LakhOx3S1dRjnh0b5Dg3mbZyH0ToC9I8Y2wKSkBaTzU=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "5466c5bbece17adaab2d82fae80b46e807611bf3",
+        "lastModified": 1627913399,
+        "narHash": "sha256-hY8g6H2KFL8ownSiFeMOjwPC8P0ueXpCVEbxgda3pko=",
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "12c64ca55c1014cdc1b16ed5a804aa8576601ff2",
         "type": "github"
       },
       "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
+        "owner": "edolstra",
+        "repo": "flake-compat",
         "type": "github"
       }
     },
-    "naersk": {
+    "nixCargoIntegration": {
       "inputs": {
-        "nixpkgs": "nixpkgs"
+        "devshell": "devshell",
+        "nixpkgs": [
+          "nixpkgs"
+        ],
+        "rustOverlay": "rustOverlay"
       },
       "locked": {
-        "lastModified": 1620316130,
-        "narHash": "sha256-sU0VS5oJS1FsHsZsLELAXc7G2eIelVuucRw+q5B1x9k=",
-        "owner": "nmattia",
-        "repo": "naersk",
-        "rev": "a3f40fe42cc6d267ff7518fa3199e99ff1444ac4",
+        "lastModified": 1628489367,
+        "narHash": "sha256-ADYKHf8aPo1qTw1J+eqVprnEbH8lES0yZamD/yM7RAM=",
+        "owner": "yusdacra",
+        "repo": "nix-cargo-integration",
+        "rev": "0dc8383aae5f791a48e34120edb04670b947dc0b",
         "type": "github"
       },
       "original": {
-        "owner": "nmattia",
-        "repo": "naersk",
+        "owner": "yusdacra",
+        "repo": "nix-cargo-integration",
         "type": "github"
       }
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1619775165,
-        "narHash": "sha256-2qaBErjxuWpTIq6Yee5GJmhr84hmzBotLQ0ayg1VXg8=",
-        "path": "/nix/store/gs997rgx3pvdgcb54wd3fi9wbnznd9g4-source",
-        "rev": "849b29b4f76d66ec7aeeeed699b7e27ef3db7c02",
-        "type": "path"
-      },
-      "original": {
-        "id": "nixpkgs",
-        "type": "indirect"
-      }
-    },
-    "nixpkgs_2": {
-      "locked": {
-        "lastModified": 1620252427,
-        "narHash": "sha256-U1Q5QceuT4chJTJ1UOt7bZOn9Y2o5/7w27RISjqXoQw=",
+        "lastModified": 1628465643,
+        "narHash": "sha256-QSNw9bDq9uGUniQQtakRuw4m21Jxugm23SXLVgEV4DM=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "d3ba49889a76539ea0f7d7285b203e7f81326ded",
+        "rev": "6ef4f522d63f22b40004319778761040d3197390",
         "type": "github"
       },
       "original": {
@@ -77,40 +69,21 @@
         "type": "github"
       }
     },
-    "nixpkgs_3": {
-      "locked": {
-        "lastModified": 1617325113,
-        "narHash": "sha256-GksR0nvGxfZ79T91UUtWjjccxazv6Yh/MvEJ82v1Xmw=",
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "54c1e44240d8a527a8f4892608c4bce5440c3ecb",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
     "root": {
       "inputs": {
-        "flake-utils": "flake-utils",
-        "naersk": "naersk",
-        "nixpkgs": "nixpkgs_2",
-        "rust-overlay": "rust-overlay"
+        "flakeCompat": "flakeCompat",
+        "nixCargoIntegration": "nixCargoIntegration",
+        "nixpkgs": "nixpkgs"
       }
     },
-    "rust-overlay": {
-      "inputs": {
-        "flake-utils": "flake-utils_2",
-        "nixpkgs": "nixpkgs_3"
-      },
+    "rustOverlay": {
+      "flake": false,
       "locked": {
-        "lastModified": 1620355527,
-        "narHash": "sha256-mUTnUODiAtxH83gbv7uuvCbqZ/BNkYYk/wa3MkwrskE=",
+        "lastModified": 1628475192,
+        "narHash": "sha256-A32shcfPMCll7psCS0OBxVCkA+PKfeWvmU4y9lgNZzU=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "d8efe70dc561c4bea0b7bf440d36ce98c497e054",
+        "rev": "56a8ddb827cbe7a914be88f4a52998a5f93ff468",
         "type": "github"
       },
       "original": {

flake.nix

@@ -3,31 +3,86 @@
 
   inputs = {
     nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
-    flake-utils.url = "github:numtide/flake-utils";
-    rust-overlay.url = "github:oxalica/rust-overlay";
-    naersk.url = "github:nmattia/naersk";
+    nixCargoIntegration = {
+      url = "github:yusdacra/nix-cargo-integration";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+    flakeCompat = {
+      url = "github:edolstra/flake-compat";
+      flake = false;
+    };
   };
 
-  outputs = inputs@{ self, nixpkgs, naersk, rust-overlay, flake-utils, ... }:
-    flake-utils.lib.eachDefaultSystem (system:
-      let
-        pkgs = import nixpkgs { inherit system; overlays = [ rust-overlay.overlay ]; };
-        rust = (pkgs.rustChannelOf {
-            date = "2021-05-01";
-            channel = "nightly";
-        }).minimal; # cargo, rustc and rust-std
-        naerskLib = naersk.lib."${system}".override {
-          # naersk can't build with stable?!
-          # inherit (pkgs.rust-bin.stable.latest) rustc cargo;
-          rustc = rust;
-          cargo = rust;
+  outputs = inputs@{ self, nixCargoIntegration, ... }:
+    nixCargoIntegration.lib.makeOutputs {
+      root = ./.;
+      buildPlatform = "crate2nix";
+      renameOutputs = { "helix-term" = "helix"; };
+      # Set default app to hx (binary is from helix-term release build)
+      # Set default package to helix-term release build
+      defaultOutputs = { app = "hx"; package = "helix"; };
+      overrides = {
+        crateOverrides = common: _: {
+          helix-term = prev: {
+            # link languages and theme toml files since helix-term expects them (for tests)
+            preConfigure = "ln -s ${common.root}/{languages.toml,theme.toml} ..";
+            buildInputs = (prev.buildInputs or [ ]) ++ [ common.cCompiler.cc.lib ];
+          };
+          # link languages and theme toml files since helix-view expects them
+          helix-view = _: { preConfigure = "ln -s ${common.root}/{languages.toml,theme.toml} .."; };
+          helix-syntax = prev: {
+            src =
+              let
+                pkgs = common.pkgs;
+                helix = pkgs.fetchgit {
+                  url = "https://github.com/helix-editor/helix.git";
+                  rev = "d4bd5b37669708361a0a6cd2917464b010e6b7f5";
+                  fetchSubmodules = true;
+                  sha256 = "sha256-KayR7K7UC0mT6EjHsZsCYY9IVDJzft63fGpPKGSY8nQ=";
+                };
+              in
+              pkgs.runCommand prev.src.name { } ''
+                mkdir -p $out
+                ln -s ${prev.src}/* $out
+                ln -sf ${helix}/helix-syntax/languages $out
+              '';
+            preConfigure = "mkdir -p ../runtime/grammars";
+            postInstall = "cp -r ../runtime $out/runtime";
+          };
         };
-      in rec {
-        packages.helix = naerskLib.buildPackage {
-          pname = "helix";
-          root = ./.;
+        mainBuild = common: prev:
+          let
+            inherit (common) pkgs lib;
+            helixSyntax = lib.buildCrate {
+              root = self;
+              memberName = "helix-syntax";
+              defaultCrateOverrides = {
+                helix-syntax = common.crateOverrides.helix-syntax;
+              };
+              release = false;
+            };
+            runtimeDir = pkgs.runCommand "helix-runtime" { } ''
+              mkdir -p $out
+              ln -s ${common.root}/runtime/* $out
+              ln -sf ${helixSyntax}/runtime/grammars $out
+            '';
+          in
+          lib.optionalAttrs (common.memberName == "helix-term") {
+            nativeBuildInputs = [ pkgs.makeWrapper ];
+            postFixup = ''
+              if [ -f "$out/bin/hx" ]; then
+                wrapProgram "$out/bin/hx" --set HELIX_RUNTIME "${runtimeDir}"
+              fi
+            '';
+          };
+        shell = common: prev: {
+          packages = prev.packages ++ (with common.pkgs; [ lld_10 lldb cargo-tarpaulin ]);
+          env = prev.env ++ [
+            { name = "HELIX_RUNTIME"; eval = "$PWD/runtime"; }
+            { name = "RUST_BACKTRACE"; value = "1"; }
+            { name = "RUSTFLAGS"; value = "-C link-arg=-fuse-ld=lld -C target-cpu=native"; }
+          ];
         };
-        defaultPackage = packages.helix;
-        devShell = pkgs.callPackage ./shell.nix {};
-      });
+      };
+    };
 }

helix-core/Cargo.toml

@@ -1,26 +1,38 @@
 [package]
 name = "helix-core"
-version = "0.1.0"
+version = "0.4.1"
 authors = ["Blaž Hrastnik <blaz@mxxn.io>"]
 edition = "2018"
 license = "MPL-2.0"
+description = "Helix editor core editing primitives"
+categories = ["editor"]
+repository = "https://github.com/helix-editor/helix"
+homepage = "https://helix-editor.com"
+include = ["src/**/*", "README.md"]
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
 
 [dependencies]
-helix-syntax = { path = "../helix-syntax" }
+helix-syntax = { version = "0.4", path = "../helix-syntax" }
 
-ropey = "1.2"
-anyhow = "1"
+ropey = "1.3"
 smallvec = "1.4"
 tendril = "0.4.2"
-unicode-segmentation = "1.6"
+unicode-segmentation = "1.8"
 unicode-width = "0.1"
+unicode-general-category = "0.4"
 # slab = "0.4.2"
 tree-sitter = "0.19"
-once_cell = "1.4"
+once_cell = "1.8"
+arc-swap = "1"
 regex = "1"
 
 serde = { version = "1.0", features = ["derive"] }
+toml = "0.5"
+
+similar = "1.3"
 
 etcetera = "0.3"
+
+[dev-dependencies]
+quickcheck = { version = "1", default-features = false }

helix-core/src/auto_pairs.rs

@@ -12,7 +12,7 @@ pub const PAIRS: &[(char, char)] = &[
     ('`', '`'),
 ];
 
-const CLOSE_BEFORE: &str = ")]}'\":;> \n"; // includes space and newline
+const CLOSE_BEFORE: &str = ")]}'\":;> \n\r\u{000B}\u{000C}\u{0085}\u{2028}\u{2029}"; // includes space and newlines
 
 // insert hook:
 // Fn(doc, selection, char) => Option<Transaction>
@@ -65,14 +65,20 @@ fn handle_open(
 ) -> Transaction {
     let mut ranges = SmallVec::with_capacity(selection.len());
 
-    let mut transaction = Transaction::change_by_selection(doc, selection, |range| {
+    let mut offs = 0;
+
+    let transaction = Transaction::change_by_selection(doc, selection, |range| {
         let pos = range.head;
         let next = next_char(doc, pos);
 
-        let head = pos + open.len_utf8();
+        let head = pos + offs + open.len_utf8();
         // if selection, retain anchor, if cursor, move over
         ranges.push(Range::new(
-            if range.is_empty() { head } else { range.anchor },
+            if range.is_empty() {
+                head
+            } else {
+                range.anchor + offs
+            },
             head,
         ));
 
@@ -88,6 +94,8 @@ fn handle_open(
                 pair.push_char(open);
                 pair.push_char(close);
 
+                offs += 2;
+
                 (pos, pos, Some(pair))
             }
         }
@@ -99,14 +107,20 @@ fn handle_open(
 fn handle_close(doc: &Rope, selection: &Selection, _open: char, close: char) -> Transaction {
     let mut ranges = SmallVec::with_capacity(selection.len());
 
-    let mut transaction = Transaction::change_by_selection(doc, selection, |range| {
+    let mut offs = 0;
+
+    let transaction = Transaction::change_by_selection(doc, selection, |range| {
         let pos = range.head;
         let next = next_char(doc, pos);
 
-        let head = pos + close.len_utf8();
+        let head = pos + offs + close.len_utf8();
         // if selection, retain anchor, if cursor, move over
         ranges.push(Range::new(
-            if range.is_empty() { head } else { range.anchor },
+            if range.is_empty() {
+                head
+            } else {
+                range.anchor + offs
+            },
             head,
         ));
 
@@ -114,6 +128,8 @@ fn handle_close(doc: &Rope, selection: &Selection, _open: char, close: char) ->
             //  return transaction that moves past close
             (pos, pos, None) // no-op
         } else {
+            offs += close.len_utf8();
+
             // TODO: else return (use default handler that inserts close)
             (pos, pos, Some(Tendril::from_char(close)))
         }
@@ -123,7 +139,7 @@ fn handle_close(doc: &Rope, selection: &Selection, _open: char, close: char) ->
 }
 
 // handle cases where open and close is the same, or in triples ("""docstring""")
-fn handle_same(doc: &Rope, selection: &Selection, token: char) -> Option<Transaction> {
+fn handle_same(_doc: &Rope, _selection: &Selection, _token: char) -> Option<Transaction> {
     // if not cursor but selection, wrap
     // let next = next char
 

helix-core/src/chars.rs

@@ -0,0 +1,133 @@
+use crate::LineEnding;
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum CharCategory {
+    Whitespace,
+    Eol,
+    Word,
+    Punctuation,
+    Unknown,
+}
+
+#[inline]
+pub fn categorize_char(ch: char) -> CharCategory {
+    if char_is_line_ending(ch) {
+        CharCategory::Eol
+    } else if ch.is_whitespace() {
+        CharCategory::Whitespace
+    } else if char_is_word(ch) {
+        CharCategory::Word
+    } else if char_is_punctuation(ch) {
+        CharCategory::Punctuation
+    } else {
+        CharCategory::Unknown
+    }
+}
+
+/// Determine whether a character is a line ending.
+#[inline]
+pub fn char_is_line_ending(ch: char) -> bool {
+    LineEnding::from_char(ch).is_some()
+}
+
+/// Determine whether a character qualifies as (non-line-break)
+/// whitespace.
+#[inline]
+pub fn char_is_whitespace(ch: char) -> bool {
+    // TODO: this is a naive binary categorization of whitespace
+    // characters.  For display, word wrapping, etc. we'll need a better
+    // categorization based on e.g. breaking vs non-breaking spaces
+    // and whether they're zero-width or not.
+    match ch {
+        //'\u{1680}' | // Ogham Space Mark (here for completeness, but usually displayed as a dash, not as whitespace)
+        '\u{0009}' | // Character Tabulation
+        '\u{0020}' | // Space
+        '\u{00A0}' | // No-break Space
+        '\u{180E}' | // Mongolian Vowel Separator
+        '\u{202F}' | // Narrow No-break Space
+        '\u{205F}' | // Medium Mathematical Space
+        '\u{3000}' | // Ideographic Space
+        '\u{FEFF}'   // Zero Width No-break Space
+        => true,
+
+        // En Quad, Em Quad, En Space, Em Space, Three-per-em Space,
+        // Four-per-em Space, Six-per-em Space, Figure Space,
+        // Punctuation Space, Thin Space, Hair Space, Zero Width Space.
+        ch if ('\u{2000}' ..= '\u{200B}').contains(&ch) => true,
+
+        _ => false,
+    }
+}
+
+#[inline]
+pub fn char_is_punctuation(ch: char) -> bool {
+    use unicode_general_category::{get_general_category, GeneralCategory};
+
+    matches!(
+        get_general_category(ch),
+        GeneralCategory::OtherPunctuation
+            | GeneralCategory::OpenPunctuation
+            | GeneralCategory::ClosePunctuation
+            | GeneralCategory::InitialPunctuation
+            | GeneralCategory::FinalPunctuation
+            | GeneralCategory::ConnectorPunctuation
+            | GeneralCategory::DashPunctuation
+            | GeneralCategory::MathSymbol
+            | GeneralCategory::CurrencySymbol
+            | GeneralCategory::ModifierSymbol
+    )
+}
+
+#[inline]
+pub fn char_is_word(ch: char) -> bool {
+    ch.is_alphanumeric() || ch == '_'
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_categorize() {
+        const EOL_TEST_CASE: &'static str = "\n\r\u{000B}\u{000C}\u{0085}\u{2028}\u{2029}";
+        const WORD_TEST_CASE: &'static str =
+            "_hello_world_あいうえおー1234567890１２３４５６７８９０";
+        const PUNCTUATION_TEST_CASE: &'static str =
+            "!\"#$%&\'()*+,-./:;<=>?@[\\]^`{|}~！”＃＄％＆’（）＊＋、。：；＜＝＞？＠「」＾｀｛｜｝～";
+        const WHITESPACE_TEST_CASE: &'static str = "  　   ";
+
+        for ch in EOL_TEST_CASE.chars() {
+            assert_eq!(CharCategory::Eol, categorize_char(ch));
+        }
+
+        for ch in WHITESPACE_TEST_CASE.chars() {
+            assert_eq!(
+                CharCategory::Whitespace,
+                categorize_char(ch),
+                "Testing '{}', but got `{:?}` instead of `Category::Whitespace`",
+                ch,
+                categorize_char(ch)
+            );
+        }
+
+        for ch in WORD_TEST_CASE.chars() {
+            assert_eq!(
+                CharCategory::Word,
+                categorize_char(ch),
+                "Testing '{}', but got `{:?}` instead of `Category::Word`",
+                ch,
+                categorize_char(ch)
+            );
+        }
+
+        for ch in PUNCTUATION_TEST_CASE.chars() {
+            assert_eq!(
+                CharCategory::Punctuation,
+                categorize_char(ch),
+                "Testing '{}', but got `{:?}` instead of `Category::Punctuation`",
+                ch,
+                categorize_char(ch)
+            );
+        }
+    }
+}

helix-core/src/comment.rs

@@ -1,20 +1,30 @@
 use crate::{
-    find_first_non_whitespace_char2, Change, Rope, RopeSlice, Selection, Tendril, Transaction,
+    find_first_non_whitespace_char, Change, Rope, RopeSlice, Selection, Tendril, Transaction,
 };
-use core::ops::Range;
 use std::borrow::Cow;
 
+/// Given text, a comment token, and a set of line indices, returns the following:
+/// - Whether the given lines should be considered commented
+///     - If any of the lines are uncommented, all lines are considered as such.
+/// - The lines to change for toggling comments
+///     - This is all provided lines excluding blanks lines.
+/// - The column of the comment tokens
+///     - Column of existing tokens, if the lines are commented; column to place tokens at otherwise.
+/// - The margin to the right of the comment tokens
+///     - Defaults to `1`. If any existing comment token is not followed by a space, changes to `0`.
 fn find_line_comment(
     token: &str,
     text: RopeSlice,
-    lines: Range<usize>,
-) -> (bool, Vec<usize>, usize) {
+    lines: impl IntoIterator<Item = usize>,
+) -> (bool, Vec<usize>, usize, usize) {
     let mut commented = true;
-    let mut skipped = Vec::new();
+    let mut to_change = Vec::new();
     let mut min = usize::MAX; // minimum col for find_first_non_whitespace_char
+    let mut margin = 1;
+    let token_len = token.chars().count();
     for line in lines {
         let line_slice = text.line(line);
-        if let Some(pos) = find_first_non_whitespace_char2(line_slice) {
+        if let Some(pos) = find_first_non_whitespace_char(line_slice) {
             let len = line_slice.len_chars();
 
             if pos < min {
@@ -29,47 +39,55 @@ fn find_line_comment(
                 // considered uncommented.
                 commented = false;
             }
-        } else {
-            // blank line
-            skipped.push(line);
+
+            // determine margin of 0 or 1 for uncommenting; if any comment token is not followed by a space,
+            // a margin of 0 is used for all lines.
+            if matches!(line_slice.get_char(pos + token_len), Some(c) if c != ' ') {
+                margin = 0;
+            }
+
+            // blank lines don't get pushed.
+            to_change.push(line);
         }
     }
-    (commented, skipped, min)
+    (commented, to_change, min, margin)
 }
 
 #[must_use]
-pub fn toggle_line_comments(doc: &Rope, selection: &Selection) -> Transaction {
+pub fn toggle_line_comments(doc: &Rope, selection: &Selection, token: Option<&str>) -> Transaction {
     let text = doc.slice(..);
-    let mut changes: Vec<Change> = Vec::new();
 
-    let token = "//";
+    let token = token.unwrap_or("//");
     let comment = Tendril::from(format!("{} ", token));
 
+    let mut lines: Vec<usize> = Vec::new();
+
+    let mut min_next_line = 0;
     for selection in selection {
-        let start = text.char_to_line(selection.from());
-        let end = text.char_to_line(selection.to());
-        let lines = start..end + 1;
-        let (commented, skipped, min) = find_line_comment(token, text, lines.clone());
+        let (start, end) = selection.line_range(text);
+        let start = start.max(min_next_line).min(text.len_lines());
+        let end = (end + 1).min(text.len_lines());
 
-        changes.reserve(end - start - skipped.len());
+        lines.extend(start..end);
+        min_next_line = end + 1;
+    }
 
-        for line in lines {
-            if skipped.contains(&line) {
-                continue;
-            }
+    let (commented, to_change, min, margin) = find_line_comment(token, text, lines);
 
-            let pos = text.line_to_char(line) + min;
+    let mut changes: Vec<Change> = Vec::with_capacity(to_change.len());
 
-            if !commented {
-                // comment line
-                changes.push((pos, pos, Some(comment.clone())))
-            } else {
-                // uncomment line
-                let margin = 1; // TODO: margin is hardcoded 1 but could easily be 0
-                changes.push((pos, pos + token.len() + margin, None))
-            }
+    for line in to_change {
+        let pos = text.line_to_char(line) + min;
+
+        if !commented {
+            // comment line
+            changes.push((pos, pos, Some(comment.clone())));
+        } else {
+            // uncomment line
+            changes.push((pos, pos + token.len() + margin, None));
         }
     }
+
     Transaction::change(doc, changes.into_iter())
 }
 
@@ -91,23 +109,32 @@ mod test {
         let text = state.doc.slice(..);
 
         let res = find_line_comment("//", text, 0..3);
-        // (commented = true, skipped = [line 1], min = col 2)
-        assert_eq!(res, (false, vec![1], 2));
+        // (commented = true, to_change = [line 0, line 2], min = col 2, margin = 1)
+        assert_eq!(res, (false, vec![0, 2], 2, 1));
 
         // comment
-        let transaction = toggle_line_comments(&state.doc, &state.selection);
+        let transaction = toggle_line_comments(&state.doc, &state.selection, None);
         transaction.apply(&mut state.doc);
-        state.selection = state.selection.clone().map(transaction.changes());
+        state.selection = state.selection.map(transaction.changes());
 
         assert_eq!(state.doc, "  // 1\n\n  // 2\n  // 3");
 
         // uncomment
-        let transaction = toggle_line_comments(&state.doc, &state.selection);
+        let transaction = toggle_line_comments(&state.doc, &state.selection, None);
         transaction.apply(&mut state.doc);
-        state.selection = state.selection.clone().map(transaction.changes());
+        state.selection = state.selection.map(transaction.changes());
+        assert_eq!(state.doc, "  1\n\n  2\n  3");
+
+        // 0 margin comments
+        state.doc = Rope::from("  //1\n\n  //2\n  //3");
+        // reset the selection.
+        state.selection = Selection::single(0, state.doc.len_chars() - 1);
+
+        let transaction = toggle_line_comments(&state.doc, &state.selection, None);
+        transaction.apply(&mut state.doc);
+        state.selection = state.selection.map(transaction.changes());
         assert_eq!(state.doc, "  1\n\n  2\n  3");
 
-        // TODO: account for no margin after comment
         // TODO: account for uncommenting with uneven comment indentation
     }
 }

helix-core/src/diagnostic.rs

@@ -1,4 +1,4 @@
-#[derive(Eq, PartialEq)]
+#[derive(Debug, Eq, PartialEq)]
 pub enum Severity {
     Error,
     Warning,
@@ -6,10 +6,13 @@ pub enum Severity {
     Hint,
 }
 
+#[derive(Debug)]
 pub struct Range {
     pub start: usize,
     pub end: usize,
 }
+
+#[derive(Debug)]
 pub struct Diagnostic {
     pub range: Range,
     pub line: usize,

helix-core/src/diff.rs

@@ -0,0 +1,68 @@
+use crate::{Rope, Transaction};
+
+/// Compares `old` and `new` to generate a [`Transaction`] describing
+/// the steps required to get from `old` to `new`.
+pub fn compare_ropes(old: &Rope, new: &Rope) -> Transaction {
+    // `similar` only works on contiguous data, so a `Rope` has
+    // to be temporarily converted into a `String`.
+    let old_converted = old.to_string();
+    let new_converted = new.to_string();
+
+    // A timeout is set so after 1 seconds, the algorithm will start
+    // approximating. This is especially important for big `Rope`s or
+    // `Rope`s that are extremely dissimilar to each other.
+    //
+    // Note: Ignore the clippy warning, as the trait bounds of
+    // `Transaction::change()` require an iterator implementing
+    // `ExactIterator`.
+    let mut config = similar::TextDiff::configure();
+    config.timeout(std::time::Duration::from_secs(1));
+
+    let diff = config.diff_chars(&old_converted, &new_converted);
+
+    // The current position of the change needs to be tracked to
+    // construct the `Change`s.
+    let mut pos = 0;
+    Transaction::change(
+        old,
+        diff.ops()
+            .iter()
+            .map(|op| op.as_tag_tuple())
+            .filter_map(|(tag, old_range, new_range)| {
+                // `old_pos..pos` is equivalent to `start..end` for where
+                // the change should be applied.
+                let old_pos = pos;
+                pos += old_range.end - old_range.start;
+
+                match tag {
+                    // Semantically, inserts and replacements are the same thing.
+                    similar::DiffTag::Insert | similar::DiffTag::Replace => {
+                        // This is the text from the `new` rope that should be
+                        // inserted into `old`.
+                        let text: &str = {
+                            let start = new.char_to_byte(new_range.start);
+                            let end = new.char_to_byte(new_range.end);
+                            &new_converted[start..end]
+                        };
+                        Some((old_pos, pos, Some(text.into())))
+                    }
+                    similar::DiffTag::Delete => Some((old_pos, pos, None)),
+                    similar::DiffTag::Equal => None,
+                }
+            }),
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    quickcheck::quickcheck! {
+        fn test_compare_ropes(a: String, b: String) -> bool {
+            let mut old = Rope::from(a);
+            let new = Rope::from(b);
+            compare_ropes(&old, &new).apply(&mut old);
+            old.to_string() == new.to_string()
+        }
+    }
+}

helix-core/src/graphemes.rs

@@ -3,6 +3,8 @@ use ropey::{iter::Chunks, str_utils::byte_to_char_idx, RopeSlice};
 use unicode_segmentation::{GraphemeCursor, GraphemeIncomplete};
 use unicode_width::UnicodeWidthStr;
 
+use std::fmt;
+
 #[must_use]
 pub fn grapheme_width(g: &str) -> usize {
     if g.as_bytes()[0] <= 127 {
@@ -69,6 +71,8 @@ pub fn nth_prev_grapheme_boundary(slice: RopeSlice, char_idx: usize, n: usize) -
 }
 
 /// Finds the previous grapheme boundary before the given char position.
+#[must_use]
+#[inline(always)]
 pub fn prev_grapheme_boundary(slice: RopeSlice, char_idx: usize) -> usize {
     nth_prev_grapheme_boundary(slice, char_idx, 1)
 }
@@ -115,11 +119,38 @@ pub fn nth_next_grapheme_boundary(slice: RopeSlice, char_idx: usize, n: usize) -
 }
 
 /// Finds the next grapheme boundary after the given char position.
+#[must_use]
+#[inline(always)]
 pub fn next_grapheme_boundary(slice: RopeSlice, char_idx: usize) -> usize {
     nth_next_grapheme_boundary(slice, char_idx, 1)
 }
 
+/// Returns the passed char index if it's already a grapheme boundary,
+/// or the next grapheme boundary char index if not.
+#[must_use]
+#[inline]
+pub fn ensure_grapheme_boundary_next(slice: RopeSlice, char_idx: usize) -> usize {
+    if char_idx == 0 {
+        char_idx
+    } else {
+        next_grapheme_boundary(slice, char_idx - 1)
+    }
+}
+
+/// Returns the passed char index if it's already a grapheme boundary,
+/// or the prev grapheme boundary char index if not.
+#[must_use]
+#[inline]
+pub fn ensure_grapheme_boundary_prev(slice: RopeSlice, char_idx: usize) -> usize {
+    if char_idx == slice.len_chars() {
+        char_idx
+    } else {
+        prev_grapheme_boundary(slice, char_idx + 1)
+    }
+}
+
 /// Returns whether the given char position is a grapheme boundary.
+#[must_use]
 pub fn is_grapheme_boundary(slice: RopeSlice, char_idx: usize) -> bool {
     // Bounds check
     debug_assert!(char_idx <= slice.len_chars());
@@ -156,6 +187,18 @@ pub struct RopeGraphemes<'a> {
     cursor: GraphemeCursor,
 }
 
+impl<'a> fmt::Debug for RopeGraphemes<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("RopeGraphemes")
+            .field("text", &self.text)
+            .field("chunks", &self.chunks)
+            .field("cur_chunk", &self.cur_chunk)
+            .field("cur_chunk_start", &self.cur_chunk_start)
+            // .field("cursor", &self.cursor)
+            .finish()
+    }
+}
+
 impl<'a> RopeGraphemes<'a> {
     #[must_use]
     pub fn new(slice: RopeSlice) -> RopeGraphemes {
@@ -193,6 +236,10 @@ impl<'a> Iterator for RopeGraphemes<'a> {
                     self.cur_chunk_start += self.cur_chunk.len();
                     self.cur_chunk = self.chunks.next().unwrap_or("");
                 }
+                Err(GraphemeIncomplete::PreContext(idx)) => {
+                    let (chunk, byte_idx, _, _) = self.text.chunk_at_byte(idx.saturating_sub(1));
+                    self.cursor.provide_context(chunk, byte_idx);
+                }
                 _ => unreachable!(),
             }
         }

helix-core/src/history.rs

@@ -1,19 +1,60 @@
 use crate::{ChangeSet, Rope, State, Transaction};
-use smallvec::{smallvec, SmallVec};
+use once_cell::sync::Lazy;
+use regex::Regex;
+use std::num::NonZeroUsize;
+use std::time::{Duration, Instant};
 
-/// Undo-tree style history store.
+// Stores the history of changes to a buffer.
+//
+// Currently the history is represented as a vector of revisions. The vector
+// always has at least one element: the empty root revision. Each revision
+// with the exception of the root has a parent revision, a [Transaction]
+// that can be applied to its parent to transition from the parent to itself,
+// and an inversion of that transaction to transition from the parent to its
+// latest child.
+//
+// When using `u` to undo a change, an inverse of the stored transaction will
+// be applied which will transition the buffer to the parent state.
+//
+// Each revision with the exception of the last in the vector also has a
+// last child revision. When using `U` to redo a change, the last child transaction
+// will be applied to the current state of the buffer.
+//
+// The current revision is the one currently displayed in the buffer.
+//
+// Commiting a new revision to the history will update the last child of the
+// current revision, and push a new revision to the end of the vector.
+//
+// Revisions are commited with a timestamp. :earlier and :later can be used
+// to jump to the closest revision to a moment in time relative to the timestamp
+// of the current revision plus (:later) or minus (:earlier) the duration
+// given to the command. If a single integer is given, the editor will instead
+// jump the given number of revisions in the vector.
+//
+// Limitations:
+//  * Changes in selections currently don't commit history changes. The selection
+//    will only be updated to the state after a commited buffer change.
+//  * The vector of history revisions is currently unbounded. This might
+//    cause the memory consumption to grow significantly large during long
+//    editing sessions.
+//  * Because delete transactions currently don't store the text that they
+//    delete, we also store an inversion of the transaction.
+#[derive(Debug)]
 pub struct History {
     revisions: Vec<Revision>,
-    cursor: usize,
+    current: usize,
 }
 
+// A single point in history. See [History] for more information.
 #[derive(Debug)]
 struct Revision {
     parent: usize,
-    children: SmallVec<[(usize, Transaction); 1]>,
-    /// The transaction to revert to previous state.
-    revert: Transaction,
-    // selection before, selection after?
+    last_child: Option<NonZeroUsize>,
+    transaction: Transaction,
+    // We need an inversion for undos because delete transactions don't store
+    // the deleted text.
+    inversion: Transaction,
+    timestamp: Instant,
 }
 
 impl Default for History {
@@ -22,74 +63,252 @@ impl Default for History {
         Self {
             revisions: vec![Revision {
                 parent: 0,
-                children: SmallVec::new(),
-                revert: Transaction::from(ChangeSet::new(&Rope::new())),
+                last_child: None,
+                transaction: Transaction::from(ChangeSet::new(&Rope::new())),
+                inversion: Transaction::from(ChangeSet::new(&Rope::new())),
+                timestamp: Instant::now(),
             }],
-            cursor: 0,
+            current: 0,
         }
     }
 }
 
 impl History {
     pub fn commit_revision(&mut self, transaction: &Transaction, original: &State) {
-        // TODO: could store a single transaction, if deletes also stored the text they delete
-        let revert = transaction
+        self.commit_revision_at_timestamp(transaction, original, Instant::now());
+    }
+
+    pub fn commit_revision_at_timestamp(
+        &mut self,
+        transaction: &Transaction,
+        original: &State,
+        timestamp: Instant,
+    ) {
+        let inversion = transaction
             .invert(&original.doc)
             // Store the current cursor position
             .with_selection(original.selection.clone());
 
-        let new_cursor = self.revisions.len();
+        let new_current = self.revisions.len();
+        self.revisions[self.current].last_child = NonZeroUsize::new(new_current);
         self.revisions.push(Revision {
-            parent: self.cursor,
-            children: SmallVec::new(),
-            revert,
+            parent: self.current,
+            last_child: None,
+            transaction: transaction.clone(),
+            inversion,
+            timestamp,
         });
-
-        // add a reference to the parent
-        self.revisions
-            .get_mut(self.cursor)
-            .unwrap() // TODO: get_unchecked_mut
-            .children
-            .push((new_cursor, transaction.clone()));
-
-        self.cursor = new_cursor;
+        self.current = new_current;
     }
 
     #[inline]
     pub fn current_revision(&self) -> usize {
-        self.cursor
+        self.current
     }
 
     #[inline]
     pub const fn at_root(&self) -> bool {
-        self.cursor == 0
+        self.current == 0
     }
 
-    // TODO: I'd like to pass Transaction by reference but it fights with the borrowck
-
-    pub fn undo(&mut self) -> Option<Transaction> {
+    pub fn undo(&mut self) -> Option<&Transaction> {
         if self.at_root() {
-            // We're at the root of undo, nothing to do.
             return None;
         }
 
-        let current_revision = &self.revisions[self.cursor];
-
-        self.cursor = current_revision.parent;
-
-        Some(current_revision.revert.clone())
+        let current_revision = &self.revisions[self.current];
+        self.current = current_revision.parent;
+        Some(&current_revision.inversion)
     }
 
-    pub fn redo(&mut self) -> Option<Transaction> {
-        let current_revision = &self.revisions[self.cursor];
+    pub fn redo(&mut self) -> Option<&Transaction> {
+        let current_revision = &self.revisions[self.current];
+        let last_child = current_revision.last_child?;
+        self.current = last_child.get();
 
-        // for now, simply pick the latest child (linear undo / redo)
-        if let Some((index, transaction)) = current_revision.children.last() {
-            self.cursor = *index;
+        Some(&self.revisions[last_child.get()].transaction)
+    }
 
-            return Some(transaction.clone());
+    fn lowest_common_ancestor(&self, mut a: usize, mut b: usize) -> usize {
+        use std::collections::HashSet;
+        let mut a_path_set = HashSet::new();
+        let mut b_path_set = HashSet::new();
+        loop {
+            a_path_set.insert(a);
+            b_path_set.insert(b);
+            if a_path_set.contains(&b) {
+                return b;
+            }
+            if b_path_set.contains(&a) {
+                return a;
+            }
+            a = self.revisions[a].parent; // Relies on the parent of 0 being 0.
+            b = self.revisions[b].parent; // Same as above.
+        }
+    }
+
+    // List of nodes on the way from `n` to 'a`. Doesn`t include `a`.
+    // Includes `n` unless `a == n`. `a` must be an ancestor of `n`.
+    fn path_up(&self, mut n: usize, a: usize) -> Vec<usize> {
+        let mut path = Vec::new();
+        while n != a {
+            path.push(n);
+            n = self.revisions[n].parent;
+        }
+        path
+    }
+
+    fn jump_to(&mut self, to: usize) -> Vec<Transaction> {
+        let lca = self.lowest_common_ancestor(self.current, to);
+        let up = self.path_up(self.current, lca);
+        let down = self.path_up(to, lca);
+        self.current = to;
+        let up_txns = up.iter().map(|&n| self.revisions[n].inversion.clone());
+        let down_txns = down
+            .iter()
+            .rev()
+            .map(|&n| self.revisions[n].transaction.clone());
+        up_txns.chain(down_txns).collect()
+    }
+
+    fn jump_backward(&mut self, delta: usize) -> Vec<Transaction> {
+        self.jump_to(self.current.saturating_sub(delta))
+    }
+
+    fn jump_forward(&mut self, delta: usize) -> Vec<Transaction> {
+        self.jump_to(
+            self.current
+                .saturating_add(delta)
+                .min(self.revisions.len() - 1),
+        )
+    }
+
+    // Helper for a binary search case below.
+    fn revision_closer_to_instant(&self, i: usize, instant: Instant) -> usize {
+        let dur_im1 = instant.duration_since(self.revisions[i - 1].timestamp);
+        let dur_i = self.revisions[i].timestamp.duration_since(instant);
+        use std::cmp::Ordering::*;
+        match dur_im1.cmp(&dur_i) {
+            Less => i - 1,
+            Equal | Greater => i,
+        }
+    }
+
+    fn jump_instant(&mut self, instant: Instant) -> Vec<Transaction> {
+        let search_result = self
+            .revisions
+            .binary_search_by(|rev| rev.timestamp.cmp(&instant));
+        let revision = match search_result {
+            Ok(revision) => revision,
+            Err(insert_point) => match insert_point {
+                0 => 0,
+                n if n == self.revisions.len() => n - 1,
+                i => self.revision_closer_to_instant(i, instant),
+            },
+        };
+        self.jump_to(revision)
+    }
+
+    fn jump_duration_backward(&mut self, duration: Duration) -> Vec<Transaction> {
+        match self.revisions[self.current].timestamp.checked_sub(duration) {
+            Some(instant) => self.jump_instant(instant),
+            None => self.jump_to(0),
+        }
+    }
+
+    fn jump_duration_forward(&mut self, duration: Duration) -> Vec<Transaction> {
+        match self.revisions[self.current].timestamp.checked_add(duration) {
+            Some(instant) => self.jump_instant(instant),
+            None => self.jump_to(self.revisions.len() - 1),
+        }
+    }
+
+    pub fn earlier(&mut self, uk: UndoKind) -> Vec<Transaction> {
+        use UndoKind::*;
+        match uk {
+            Steps(n) => self.jump_backward(n),
+            TimePeriod(d) => self.jump_duration_backward(d),
+        }
+    }
+
+    pub fn later(&mut self, uk: UndoKind) -> Vec<Transaction> {
+        use UndoKind::*;
+        match uk {
+            Steps(n) => self.jump_forward(n),
+            TimePeriod(d) => self.jump_duration_forward(d),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum UndoKind {
+    Steps(usize),
+    TimePeriod(std::time::Duration),
+}
+
+// A subset of sytemd.time time span syntax units.
+const TIME_UNITS: &[(&[&str], &str, u64)] = &[
+    (&["seconds", "second", "sec", "s"], "seconds", 1),
+    (&["minutes", "minute", "min", "m"], "minutes", 60),
+    (&["hours", "hour", "hr", "h"], "hours", 60 * 60),
+    (&["days", "day", "d"], "days", 24 * 60 * 60),
+];
+
+static DURATION_VALIDATION_REGEX: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r"^(?:\d+\s*[a-z]+\s*)+$").unwrap());
+
+static NUMBER_UNIT_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"(\d+)\s*([a-z]+)").unwrap());
+
+fn parse_human_duration(s: &str) -> Result<Duration, String> {
+    if !DURATION_VALIDATION_REGEX.is_match(s) {
+        return Err("duration should be composed \
+        of positive integers followed by time units"
+            .to_string());
+    }
+
+    let mut specified = [false; TIME_UNITS.len()];
+    let mut seconds = 0u64;
+    for cap in NUMBER_UNIT_REGEX.captures_iter(s) {
+        let (n, unit_str) = (&cap[1], &cap[2]);
+
+        let n: u64 = n.parse().map_err(|_| format!("integer too large: {}", n))?;
+
+        let time_unit = TIME_UNITS
+            .iter()
+            .enumerate()
+            .find(|(_, (forms, _, _))| forms.iter().any(|f| f == &unit_str));
+
+        if let Some((i, (_, unit, mul))) = time_unit {
+            if specified[i] {
+                return Err(format!("{} specified more than once", unit));
+            }
+            specified[i] = true;
+
+            let new_seconds = n.checked_mul(*mul).and_then(|s| seconds.checked_add(s));
+            match new_seconds {
+                Some(ns) => seconds = ns,
+                None => return Err("duration too large".to_string()),
+            }
+        } else {
+            return Err(format!("incorrect time unit: {}", unit_str));
+        }
+    }
+
+    Ok(Duration::from_secs(seconds))
+}
+
+impl std::str::FromStr for UndoKind {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s.trim();
+        if s.is_empty() {
+            Ok(Self::Steps(1usize))
+        } else if let Ok(n) = s.parse::<usize>() {
+            Ok(UndoKind::Steps(n))
+        } else {
+            Ok(Self::TimePeriod(parse_human_duration(s)?))
         }
-        None
     }
 }
 
@@ -145,4 +364,191 @@ mod test {
         undo(&mut history, &mut state);
         assert_eq!("hello", state.doc);
     }
+
+    #[test]
+    fn test_earlier_later() {
+        let mut history = History::default();
+        let doc = Rope::from("a\n");
+        let mut state = State::new(doc);
+
+        fn undo(history: &mut History, state: &mut State) {
+            if let Some(transaction) = history.undo() {
+                transaction.apply(&mut state.doc);
+            }
+        }
+
+        fn earlier(history: &mut History, state: &mut State, uk: UndoKind) {
+            let txns = history.earlier(uk);
+            for txn in txns {
+                txn.apply(&mut state.doc);
+            }
+        }
+
+        fn later(history: &mut History, state: &mut State, uk: UndoKind) {
+            let txns = history.later(uk);
+            for txn in txns {
+                txn.apply(&mut state.doc);
+            }
+        }
+
+        fn commit_change(
+            history: &mut History,
+            state: &mut State,
+            change: crate::transaction::Change,
+            instant: Instant,
+        ) {
+            let txn = Transaction::change(&state.doc, vec![change.clone()].into_iter());
+            history.commit_revision_at_timestamp(&txn, &state, instant);
+            txn.apply(&mut state.doc);
+        }
+
+        let t0 = Instant::now();
+        let t = |n| t0.checked_add(Duration::from_secs(n)).unwrap();
+
+        commit_change(&mut history, &mut state, (1, 1, Some(" b".into())), t(0));
+        assert_eq!("a b\n", state.doc);
+
+        commit_change(&mut history, &mut state, (3, 3, Some(" c".into())), t(10));
+        assert_eq!("a b c\n", state.doc);
+
+        commit_change(&mut history, &mut state, (5, 5, Some(" d".into())), t(20));
+        assert_eq!("a b c d\n", state.doc);
+
+        undo(&mut history, &mut state);
+        assert_eq!("a b c\n", state.doc);
+
+        commit_change(&mut history, &mut state, (5, 5, Some(" e".into())), t(30));
+        assert_eq!("a b c e\n", state.doc);
+
+        undo(&mut history, &mut state);
+        undo(&mut history, &mut state);
+        assert_eq!("a b\n", state.doc);
+
+        commit_change(&mut history, &mut state, (1, 3, None), t(40));
+        assert_eq!("a\n", state.doc);
+
+        commit_change(&mut history, &mut state, (1, 1, Some(" f".into())), t(50));
+        assert_eq!("a f\n", state.doc);
+
+        use UndoKind::*;
+
+        earlier(&mut history, &mut state, Steps(3));
+        assert_eq!("a b c d\n", state.doc);
+
+        later(&mut history, &mut state, TimePeriod(Duration::new(20, 0)));
+        assert_eq!("a\n", state.doc);
+
+        earlier(&mut history, &mut state, TimePeriod(Duration::new(19, 0)));
+        assert_eq!("a b c d\n", state.doc);
+
+        earlier(
+            &mut history,
+            &mut state,
+            TimePeriod(Duration::new(10000, 0)),
+        );
+        assert_eq!("a\n", state.doc);
+
+        later(&mut history, &mut state, Steps(50));
+        assert_eq!("a f\n", state.doc);
+
+        earlier(&mut history, &mut state, Steps(4));
+        assert_eq!("a b c\n", state.doc);
+
+        later(&mut history, &mut state, TimePeriod(Duration::new(1, 0)));
+        assert_eq!("a b c\n", state.doc);
+
+        later(&mut history, &mut state, TimePeriod(Duration::new(5, 0)));
+        assert_eq!("a b c d\n", state.doc);
+
+        later(&mut history, &mut state, TimePeriod(Duration::new(6, 0)));
+        assert_eq!("a b c e\n", state.doc);
+
+        later(&mut history, &mut state, Steps(1));
+        assert_eq!("a\n", state.doc);
+    }
+
+    #[test]
+    fn test_parse_undo_kind() {
+        use UndoKind::*;
+
+        // Default is one step.
+        assert_eq!("".parse(), Ok(Steps(1)));
+
+        // An integer means the number of steps.
+        assert_eq!("1".parse(), Ok(Steps(1)));
+        assert_eq!("  16 ".parse(), Ok(Steps(16)));
+
+        // Duration has a strict format.
+        let validation_err = Err("duration should be composed \
+         of positive integers followed by time units"
+            .to_string());
+        assert_eq!("  16 33".parse::<UndoKind>(), validation_err);
+        assert_eq!("  seconds 22  ".parse::<UndoKind>(), validation_err);
+        assert_eq!("  -4 m".parse::<UndoKind>(), validation_err);
+        assert_eq!("5s 3".parse::<UndoKind>(), validation_err);
+
+        // Units are u64.
+        assert_eq!(
+            "18446744073709551616minutes".parse::<UndoKind>(),
+            Err("integer too large: 18446744073709551616".to_string())
+        );
+
+        // Units are validated.
+        assert_eq!(
+            "1 millenium".parse::<UndoKind>(),
+            Err("incorrect time unit: millenium".to_string())
+        );
+
+        // Units can't be specified twice.
+        assert_eq!(
+            "2 seconds 6s".parse::<UndoKind>(),
+            Err("seconds specified more than once".to_string())
+        );
+
+        // Various formats are correctly handled.
+        assert_eq!(
+            "4s".parse::<UndoKind>(),
+            Ok(TimePeriod(Duration::from_secs(4)))
+        );
+        assert_eq!(
+            "2m".parse::<UndoKind>(),
+            Ok(TimePeriod(Duration::from_secs(120)))
+        );
+        assert_eq!(
+            "5h".parse::<UndoKind>(),
+            Ok(TimePeriod(Duration::from_secs(5 * 60 * 60)))
+        );
+        assert_eq!(
+            "3d".parse::<UndoKind>(),
+            Ok(TimePeriod(Duration::from_secs(3 * 24 * 60 * 60)))
+        );
+        assert_eq!(
+            "1m30s".parse::<UndoKind>(),
+            Ok(TimePeriod(Duration::from_secs(90)))
+        );
+        assert_eq!(
+            "1m 20 seconds".parse::<UndoKind>(),
+            Ok(TimePeriod(Duration::from_secs(80)))
+        );
+        assert_eq!(
+            "  2 minute 1day".parse::<UndoKind>(),
+            Ok(TimePeriod(Duration::from_secs(24 * 60 * 60 + 2 * 60)))
+        );
+        assert_eq!(
+            "3 d 2hour 5 minutes 30sec".parse::<UndoKind>(),
+            Ok(TimePeriod(Duration::from_secs(
+                3 * 24 * 60 * 60 + 2 * 60 * 60 + 5 * 60 + 30
+            )))
+        );
+
+        // Sum overflow is handled.
+        assert_eq!(
+            "18446744073709551615minutes".parse::<UndoKind>(),
+            Err("duration too large".to_string())
+        );
+        assert_eq!(
+            "1 minute 18446744073709551615 seconds".parse::<UndoKind>(),
+            Err("duration too large".to_string())
+        );
+    }
 }

helix-core/src/indent.rs

@@ -1,13 +1,180 @@
 use crate::{
+    chars::{char_is_line_ending, char_is_whitespace},
     find_first_non_whitespace_char,
-    syntax::Syntax,
-    tree_sitter::{Node, Tree},
+    syntax::{IndentQuery, LanguageConfiguration, Syntax},
+    tree_sitter::Node,
     Rope, RopeSlice,
 };
 
+/// Enum representing indentation style.
+///
+/// Only values 1-8 are valid for the `Spaces` variant.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum IndentStyle {
+    Tabs,
+    Spaces(u8),
+}
+
+impl IndentStyle {
+    /// Creates an `IndentStyle` from an indentation string.
+    ///
+    /// For example, passing `"    "` (four spaces) will create `IndentStyle::Spaces(4)`.
+    #[allow(clippy::should_implement_trait)]
+    #[inline]
+    pub fn from_str(indent: &str) -> Self {
+        // XXX: do we care about validating the input more than this?  Probably not...?
+        debug_assert!(!indent.is_empty() && indent.len() <= 8);
+
+        if indent.starts_with(' ') {
+            IndentStyle::Spaces(indent.len() as u8)
+        } else {
+            IndentStyle::Tabs
+        }
+    }
+
+    #[inline]
+    pub fn as_str(&self) -> &'static str {
+        match *self {
+            IndentStyle::Tabs => "\t",
+            IndentStyle::Spaces(1) => " ",
+            IndentStyle::Spaces(2) => "  ",
+            IndentStyle::Spaces(3) => "   ",
+            IndentStyle::Spaces(4) => "    ",
+            IndentStyle::Spaces(5) => "     ",
+            IndentStyle::Spaces(6) => "      ",
+            IndentStyle::Spaces(7) => "       ",
+            IndentStyle::Spaces(8) => "        ",
+
+            // Unsupported indentation style.  This should never happen,
+            // but just in case fall back to two spaces.
+            IndentStyle::Spaces(n) => {
+                debug_assert!(n > 0 && n <= 8); // Always triggers. `debug_panic!()` wanted.
+                "  "
+            }
+        }
+    }
+}
+
+/// Attempts to detect the indentation style used in a document.
+///
+/// Returns the indentation style if the auto-detect confidence is
+/// reasonably high, otherwise returns `None`.
+pub fn auto_detect_indent_style(document_text: &Rope) -> Option<IndentStyle> {
+    // Build a histogram of the indentation *increases* between
+    // subsequent lines, ignoring lines that are all whitespace.
+    //
+    // Index 0 is for tabs, the rest are 1-8 spaces.
+    let histogram: [usize; 9] = {
+        let mut histogram = [0; 9];
+        let mut prev_line_is_tabs = false;
+        let mut prev_line_leading_count = 0usize;
+
+        // Loop through the lines, checking for and recording indentation
+        // increases as we go.
+        'outer: for line in document_text.lines().take(1000) {
+            let mut c_iter = line.chars();
+
+            // Is first character a tab or space?
+            let is_tabs = match c_iter.next() {
+                Some('\t') => true,
+                Some(' ') => false,
+
+                // Ignore blank lines.
+                Some(c) if char_is_line_ending(c) => continue,
+
+                _ => {
+                    prev_line_is_tabs = false;
+                    prev_line_leading_count = 0;
+                    continue;
+                }
+            };
+
+            // Count the line's total leading tab/space characters.
+            let mut leading_count = 1;
+            let mut count_is_done = false;
+            for c in c_iter {
+                match c {
+                    '\t' if is_tabs && !count_is_done => leading_count += 1,
+                    ' ' if !is_tabs && !count_is_done => leading_count += 1,
+
+                    // We stop counting if we hit whitespace that doesn't
+                    // qualify as indent or doesn't match the leading
+                    // whitespace, but we don't exit the loop yet because
+                    // we still want to determine if the line is blank.
+                    c if char_is_whitespace(c) => count_is_done = true,
+
+                    // Ignore blank lines.
+                    c if char_is_line_ending(c) => continue 'outer,
+
+                    _ => break,
+                }
+
+                // Bound the worst-case execution time for weird text files.
+                if leading_count > 256 {
+                    continue 'outer;
+                }
+            }
+
+            // If there was an increase in indentation over the previous
+            // line, update the histogram with that increase.
+            if (prev_line_is_tabs == is_tabs || prev_line_leading_count == 0)
+                && prev_line_leading_count < leading_count
+            {
+                if is_tabs {
+                    histogram[0] += 1;
+                } else {
+                    let amount = leading_count - prev_line_leading_count;
+                    if amount <= 8 {
+                        histogram[amount] += 1;
+                    }
+                }
+            }
+
+            // Store this line's leading whitespace info for use with
+            // the next line.
+            prev_line_is_tabs = is_tabs;
+            prev_line_leading_count = leading_count;
+        }
+
+        // Give more weight to tabs, because their presence is a very
+        // strong indicator.
+        histogram[0] *= 2;
+
+        histogram
+    };
+
+    // Find the most frequent indent, its frequency, and the frequency of
+    // the next-most frequent indent.
+    let indent = histogram
+        .iter()
+        .enumerate()
+        .max_by_key(|kv| kv.1)
+        .unwrap()
+        .0;
+    let indent_freq = histogram[indent];
+    let indent_freq_2 = *histogram
+        .iter()
+        .enumerate()
+        .filter(|kv| kv.0 != indent)
+        .map(|kv| kv.1)
+        .max()
+        .unwrap();
+
+    // Return the the auto-detected result if we're confident enough in its
+    // accuracy, based on some heuristics.
+    if indent_freq >= 1 && (indent_freq_2 as f64 / indent_freq as f64) < 0.66 {
+        Some(match indent {
+            0 => IndentStyle::Tabs,
+            _ => IndentStyle::Spaces(indent as u8),
+        })
+    } else {
+        None
+    }
+}
+
 /// To determine indentation of a newly inserted line, figure out the indentation at the last col
 /// of the previous line.
-
+#[allow(dead_code)]
 fn indent_level_for_line(line: RopeSlice, tab_width: usize) -> usize {
     let mut len = 0;
     for ch in line.chars() {
@@ -43,40 +210,11 @@ fn get_highest_syntax_node_at_bytepos(syntax: &Syntax, pos: usize) -> Option<Nod
     Some(node)
 }
 
-fn calculate_indentation(node: Option<Node>, newline: bool) -> usize {
-    let mut increment: i32 = 0;
+fn calculate_indentation(query: &IndentQuery, node: Option<Node>, newline: bool) -> usize {
+    // NOTE: can't use contains() on query because of comparing Vec<String> and &str
+    // https://doc.rust-lang.org/std/vec/struct.Vec.html#method.contains
 
-    // Hardcoded for rust for now
-    let indent_scopes = &[
-        "while_expression",
-        "for_expression",
-        "loop_expression",
-        "if_expression",
-        "if_let_expression",
-        // "match_expression",
-        // "match_arm",
-        "tuple_expression",
-        "array_expression",
-        // indent_except_first_scopes
-        "use_list",
-        "block",
-        "match_block",
-        "arguments",
-        "parameters",
-        "declaration_list",
-        "field_declaration_list",
-        "field_initializer_list",
-        "struct_pattern",
-        "tuple_pattern",
-        "enum_variant_list",
-        // "function_item",
-        // "closure_expression",
-        "binary_expression",
-        "field_expression",
-        "where_clause",
-    ];
-
-    let outdent = &["where", "}", "]", ")"];
+    let mut increment: isize = 0;
 
     let mut node = match node {
         Some(node) => node,
@@ -88,7 +226,7 @@ fn calculate_indentation(node: Option<Node>, newline: bool) -> usize {
     // if we're calculating indentation for a brand new line then the current node will become the
     // parent node. We need to take it's indentation level into account too.
     let node_kind = node.kind();
-    if newline && indent_scopes.contains(&node_kind) {
+    if newline && query.indent.contains(node_kind) {
         increment += 1;
     }
 
@@ -102,14 +240,14 @@ fn calculate_indentation(node: Option<Node>, newline: bool) -> usize {
         // })               <-- }) is two scopes
         let starts_same_line = start == prev_start;
 
-        if outdent.contains(&node.kind()) && !starts_same_line {
+        if query.outdent.contains(node.kind()) && !starts_same_line {
             // we outdent by skipping the rules for the current level and jumping up
             // node = parent;
             increment -= 1;
             // continue;
         }
 
-        if indent_scopes.contains(&parent_kind) // && not_first_or_last_sibling
+        if query.indent.contains(parent_kind) // && not_first_or_last_sibling
             && !starts_same_line
         {
             // println!("is_scope {}", parent_kind);
@@ -122,22 +260,25 @@ fn calculate_indentation(node: Option<Node>, newline: bool) -> usize {
         node = parent;
     }
 
-    assert!(increment >= 0);
-
-    increment as usize
+    increment.max(0) as usize
 }
 
+#[allow(dead_code)]
 fn suggested_indent_for_line(
+    language_config: &LanguageConfiguration,
     syntax: Option<&Syntax>,
     text: RopeSlice,
     line_num: usize,
-    tab_width: usize,
+    _tab_width: usize,
 ) -> usize {
-    let line = text.line(line_num);
-    let current = indent_level_for_line(line, tab_width);
-
-    if let Some(start) = find_first_non_whitespace_char(text, line_num) {
-        return suggested_indent_for_pos(syntax, text, start, false);
+    if let Some(start) = find_first_non_whitespace_char(text.line(line_num)) {
+        return suggested_indent_for_pos(
+            Some(language_config),
+            syntax,
+            text,
+            start + text.line_to_char(line_num),
+            false,
+        );
     };
 
     // if the line is blank, indent should be zero
@@ -148,27 +289,54 @@ fn suggested_indent_for_line(
 // - it should return 0 when mass indenting stuff
 // - it should look up the wrapper node and count it too when we press o/O
 pub fn suggested_indent_for_pos(
+    language_config: Option<&LanguageConfiguration>,
     syntax: Option<&Syntax>,
     text: RopeSlice,
     pos: usize,
     new_line: bool,
 ) -> usize {
-    if let Some(syntax) = syntax {
+    if let (Some(query), Some(syntax)) = (
+        language_config.and_then(|config| config.indent_query()),
+        syntax,
+    ) {
         let byte_start = text.char_to_byte(pos);
         let node = get_highest_syntax_node_at_bytepos(syntax, byte_start);
 
+        // let config = load indentation query config from Syntax(should contain language_config)
+
         // TODO: special case for comments
         // TODO: if preserve_leading_whitespace
-        calculate_indentation(node, new_line)
+        calculate_indentation(query, node, new_line)
     } else {
         // TODO: heuristics for non-tree sitter grammars
         0
     }
 }
 
+pub fn get_scopes(syntax: Option<&Syntax>, text: RopeSlice, pos: usize) -> Vec<&'static str> {
+    let mut scopes = Vec::new();
+    if let Some(syntax) = syntax {
+        let byte_start = text.char_to_byte(pos);
+        let node = match get_highest_syntax_node_at_bytepos(syntax, byte_start) {
+            Some(node) => node,
+            None => return scopes,
+        };
+
+        scopes.push(node.kind());
+
+        while let Some(parent) = node.parent() {
+            scopes.push(parent.kind())
+        }
+    }
+
+    scopes.reverse();
+    scopes
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::Rope;
 
     #[test]
     fn test_indent_level() {
@@ -270,22 +438,26 @@ where
 
         let doc = Rope::from(doc);
         use crate::syntax::{
-            Configuration, IndentationConfiguration, Lang, LanguageConfiguration, Loader,
+            Configuration, IndentationConfiguration, LanguageConfiguration, Loader,
         };
         use once_cell::sync::OnceCell;
         let loader = Loader::new(Configuration {
             language: vec![LanguageConfiguration {
                 scope: "source.rust".to_string(),
                 file_types: vec!["rs".to_string()],
-                language_id: Lang::Rust,
+                language_id: "Rust".to_string(),
                 highlight_config: OnceCell::new(),
+                config: None,
                 //
                 roots: vec![],
+                comment_token: None,
+                auto_format: false,
                 language_server: None,
                 indent: Some(IndentationConfiguration {
                     tab_width: 4,
                     unit: String::from("    "),
                 }),
+                indent_query: OnceCell::new(),
             }],
         });
 
@@ -304,7 +476,7 @@ where
             let line = text.line(i);
             let indent = indent_level_for_line(line, tab_width);
             assert_eq!(
-                suggested_indent_for_line(Some(&syntax), text, i, tab_width),
+                suggested_indent_for_line(&language_config, Some(&syntax), text, i, tab_width),
                 indent,
                 "line {}: {}",
                 i,

helix-core/src/lib.rs

@@ -1,10 +1,12 @@
-#![allow(unused)]
 pub mod auto_pairs;
+pub mod chars;
 pub mod comment;
 pub mod diagnostic;
+pub mod diff;
 pub mod graphemes;
-mod history;
+pub mod history;
 pub mod indent;
+pub mod line_ending;
 pub mod macros;
 pub mod match_brackets;
 pub mod movement;
@@ -13,72 +15,107 @@ mod position;
 pub mod register;
 pub mod search;
 pub mod selection;
-pub mod state;
+mod state;
+pub mod surround;
 pub mod syntax;
+pub mod textobject;
 mod transaction;
 
-pub(crate) fn find_first_non_whitespace_char2(line: RopeSlice) -> Option<usize> {
-    // find first non-whitespace char
-    for (start, ch) in line.chars().enumerate() {
-        // TODO: could use memchr with chunks?
-        if ch != ' ' && ch != '\t' && ch != '\n' {
-            return Some(start);
-        }
-    }
-
-    None
+pub mod unicode {
+    pub use unicode_general_category as category;
+    pub use unicode_segmentation as segmentation;
+    pub use unicode_width as width;
 }
-pub(crate) fn find_first_non_whitespace_char(text: RopeSlice, line_num: usize) -> Option<usize> {
-    let line = text.line(line_num);
-    let mut start = text.line_to_char(line_num);
 
-    // find first non-whitespace char
-    for ch in line.chars() {
-        // TODO: could use memchr with chunks?
-        if ch != ' ' && ch != '\t' && ch != '\n' {
-            return Some(start);
+static RUNTIME_DIR: once_cell::sync::Lazy<std::path::PathBuf> =
+    once_cell::sync::Lazy::new(runtime_dir);
+
+pub fn find_first_non_whitespace_char(line: RopeSlice) -> Option<usize> {
+    line.chars().position(|ch| !ch.is_whitespace())
+}
+
+pub fn find_root(root: Option<&str>) -> Option<std::path::PathBuf> {
+    let current_dir = std::env::current_dir().expect("unable to determine current directory");
+
+    let root = match root {
+        Some(root) => {
+            let root = std::path::Path::new(root);
+            if root.is_absolute() {
+                root.to_path_buf()
+            } else {
+                current_dir.join(root)
+            }
         }
-        start += 1;
-    }
+        None => current_dir,
+    };
 
+    for ancestor in root.ancestors() {
+        // TODO: also use defined roots if git isn't found
+        if ancestor.join(".git").is_dir() {
+            return Some(ancestor.to_path_buf());
+        }
+    }
     None
 }
 
 pub fn runtime_dir() -> std::path::PathBuf {
-    // runtime env var || dir where binary is located
-    std::env::var("HELIX_RUNTIME")
-        .map(|path| path.into())
-        .unwrap_or_else(|_| {
-            std::env::current_exe()
-                .ok()
-                .and_then(|path| path.parent().map(|path| path.to_path_buf()))
-                .unwrap()
-        })
+    if let Ok(dir) = std::env::var("HELIX_RUNTIME") {
+        return dir.into();
+    }
+
+    const RT_DIR: &str = "runtime";
+    let conf_dir = config_dir().join(RT_DIR);
+    if conf_dir.exists() {
+        return conf_dir;
+    }
+
+    if let Ok(dir) = std::env::var("CARGO_MANIFEST_DIR") {
+        // this is the directory of the crate being run by cargo, we need the workspace path so we take the parent
+        return std::path::PathBuf::from(dir).parent().unwrap().join(RT_DIR);
+    }
+
+    // fallback to location of the executable being run
+    std::env::current_exe()
+        .ok()
+        .and_then(|path| path.parent().map(|path| path.to_path_buf().join(RT_DIR)))
+        .unwrap()
 }
 
 pub fn config_dir() -> std::path::PathBuf {
     // TODO: allow env var override
-    use etcetera::base_strategy::{choose_base_strategy, BaseStrategy};
     let strategy = choose_base_strategy().expect("Unable to find the config directory!");
     let mut path = strategy.config_dir();
     path.push("helix");
     path
 }
 
-pub use ropey::{Rope, RopeSlice};
+pub fn cache_dir() -> std::path::PathBuf {
+    // TODO: allow env var override
+    let strategy = choose_base_strategy().expect("Unable to find the config directory!");
+    let mut path = strategy.cache_dir();
+    path.push("helix");
+    path
+}
+
+pub use etcetera::home_dir;
+
+use etcetera::base_strategy::{choose_base_strategy, BaseStrategy};
+
+pub use ropey::{Rope, RopeBuilder, RopeSlice};
 
 pub use tendril::StrTendril as Tendril;
 
 #[doc(inline)]
 pub use {regex, tree_sitter};
 
+pub use graphemes::RopeGraphemes;
 pub use position::{coords_at_pos, pos_at_coords, Position};
 pub use selection::{Range, Selection};
 pub use smallvec::SmallVec;
 pub use syntax::Syntax;
 
 pub use diagnostic::Diagnostic;
-pub use history::History;
 pub use state::State;
 
+pub use line_ending::{LineEnding, DEFAULT_LINE_ENDING};
 pub use transaction::{Assoc, Change, ChangeSet, Operation, Transaction};

helix-core/src/line_ending.rs

@@ -0,0 +1,265 @@
+use crate::{Rope, RopeSlice};
+
+#[cfg(target_os = "windows")]
+pub const DEFAULT_LINE_ENDING: LineEnding = LineEnding::Crlf;
+#[cfg(not(target_os = "windows"))]
+pub const DEFAULT_LINE_ENDING: LineEnding = LineEnding::LF;
+
+/// Represents one of the valid Unicode line endings.
+#[derive(PartialEq, Copy, Clone, Debug)]
+pub enum LineEnding {
+    Crlf, // CarriageReturn followed by LineFeed
+    LF,   // U+000A -- LineFeed
+    VT,   // U+000B -- VerticalTab
+    FF,   // U+000C -- FormFeed
+    CR,   // U+000D -- CarriageReturn
+    Nel,  // U+0085 -- NextLine
+    LS,   // U+2028 -- Line Separator
+    PS,   // U+2029 -- ParagraphSeparator
+}
+
+impl LineEnding {
+    #[inline]
+    pub fn len_chars(&self) -> usize {
+        match self {
+            Self::Crlf => 2,
+            _ => 1,
+        }
+    }
+
+    #[inline]
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::Crlf => "\u{000D}\u{000A}",
+            Self::LF => "\u{000A}",
+            Self::VT => "\u{000B}",
+            Self::FF => "\u{000C}",
+            Self::CR => "\u{000D}",
+            Self::Nel => "\u{0085}",
+            Self::LS => "\u{2028}",
+            Self::PS => "\u{2029}",
+        }
+    }
+
+    #[inline]
+    pub fn from_char(ch: char) -> Option<LineEnding> {
+        match ch {
+            '\u{000A}' => Some(LineEnding::LF),
+            '\u{000B}' => Some(LineEnding::VT),
+            '\u{000C}' => Some(LineEnding::FF),
+            '\u{000D}' => Some(LineEnding::CR),
+            '\u{0085}' => Some(LineEnding::Nel),
+            '\u{2028}' => Some(LineEnding::LS),
+            '\u{2029}' => Some(LineEnding::PS),
+            // Not a line ending
+            _ => None,
+        }
+    }
+
+    // Normally we'd want to implement the FromStr trait, but in this case
+    // that would force us into a different return type than from_char or
+    // or from_rope_slice, which would be weird.
+    #[allow(clippy::should_implement_trait)]
+    #[inline]
+    pub fn from_str(g: &str) -> Option<LineEnding> {
+        match g {
+            "\u{000D}\u{000A}" => Some(LineEnding::Crlf),
+            "\u{000A}" => Some(LineEnding::LF),
+            "\u{000B}" => Some(LineEnding::VT),
+            "\u{000C}" => Some(LineEnding::FF),
+            "\u{000D}" => Some(LineEnding::CR),
+            "\u{0085}" => Some(LineEnding::Nel),
+            "\u{2028}" => Some(LineEnding::LS),
+            "\u{2029}" => Some(LineEnding::PS),
+            // Not a line ending
+            _ => None,
+        }
+    }
+
+    #[inline]
+    pub fn from_rope_slice(g: &RopeSlice) -> Option<LineEnding> {
+        if let Some(text) = g.as_str() {
+            LineEnding::from_str(text)
+        } else {
+            // Non-contiguous, so it can't be a line ending.
+            // Specifically, Ropey guarantees that CRLF is always
+            // contiguous.  And the remaining line endings are all
+            // single `char`s, and therefore trivially contiguous.
+            None
+        }
+    }
+}
+
+#[inline]
+pub fn str_is_line_ending(s: &str) -> bool {
+    LineEnding::from_str(s).is_some()
+}
+
+/// Attempts to detect what line ending the passed document uses.
+pub fn auto_detect_line_ending(doc: &Rope) -> Option<LineEnding> {
+    // Return first matched line ending. Not all possible line endings
+    // are being matched, as they might be special-use only
+    for line in doc.lines().take(100) {
+        match get_line_ending(&line) {
+            None | Some(LineEnding::VT) | Some(LineEnding::FF) | Some(LineEnding::PS) => {}
+            ending => return ending,
+        }
+    }
+    None
+}
+
+/// Returns the passed line's line ending, if any.
+pub fn get_line_ending(line: &RopeSlice) -> Option<LineEnding> {
+    // Last character as str.
+    let g1 = line
+        .slice(line.len_chars().saturating_sub(1)..)
+        .as_str()
+        .unwrap();
+
+    // Last two characters as str, or empty str if they're not contiguous.
+    // It's fine to punt on the non-contiguous case, because Ropey guarantees
+    // that CRLF is always contiguous.
+    let g2 = line
+        .slice(line.len_chars().saturating_sub(2)..)
+        .as_str()
+        .unwrap_or("");
+
+    // First check the two-character case for CRLF, then check the single-character case.
+    LineEnding::from_str(g2).or_else(|| LineEnding::from_str(g1))
+}
+
+/// Returns the passed line's line ending, if any.
+pub fn get_line_ending_of_str(line: &str) -> Option<LineEnding> {
+    if line.ends_with("\u{000D}\u{000A}") {
+        Some(LineEnding::Crlf)
+    } else if line.ends_with('\u{000A}') {
+        Some(LineEnding::LF)
+    } else if line.ends_with('\u{000B}') {
+        Some(LineEnding::VT)
+    } else if line.ends_with('\u{000C}') {
+        Some(LineEnding::FF)
+    } else if line.ends_with('\u{000D}') {
+        Some(LineEnding::CR)
+    } else if line.ends_with('\u{0085}') {
+        Some(LineEnding::Nel)
+    } else if line.ends_with('\u{2028}') {
+        Some(LineEnding::LS)
+    } else if line.ends_with('\u{2029}') {
+        Some(LineEnding::PS)
+    } else {
+        None
+    }
+}
+
+/// Returns the char index of the end of the given line, not including its line ending.
+pub fn line_end_char_index(slice: &RopeSlice, line: usize) -> usize {
+    slice.line_to_char(line + 1)
+        - get_line_ending(&slice.line(line))
+            .map(|le| le.len_chars())
+            .unwrap_or(0)
+}
+
+/// Fetches line `line_idx` from the passed rope slice, sans any line ending.
+pub fn line_without_line_ending<'a>(slice: &'a RopeSlice, line_idx: usize) -> RopeSlice<'a> {
+    let start = slice.line_to_char(line_idx);
+    let end = line_end_char_index(slice, line_idx);
+    slice.slice(start..end)
+}
+
+/// Returns the char index of the end of the given RopeSlice, not including
+/// any final line ending.
+pub fn rope_end_without_line_ending(slice: &RopeSlice) -> usize {
+    slice.len_chars() - get_line_ending(slice).map(|le| le.len_chars()).unwrap_or(0)
+}
+
+#[cfg(test)]
+mod line_ending_tests {
+    use super::*;
+
+    #[test]
+    fn line_ending_autodetect() {
+        assert_eq!(
+            auto_detect_line_ending(&Rope::from_str("\n")),
+            Some(LineEnding::LF)
+        );
+        assert_eq!(
+            auto_detect_line_ending(&Rope::from_str("\r\n")),
+            Some(LineEnding::Crlf)
+        );
+        assert_eq!(auto_detect_line_ending(&Rope::from_str("hello")), None);
+        assert_eq!(auto_detect_line_ending(&Rope::from_str("")), None);
+        assert_eq!(
+            auto_detect_line_ending(&Rope::from_str("hello\nhelix\r\n")),
+            Some(LineEnding::LF)
+        );
+        assert_eq!(
+            auto_detect_line_ending(&Rope::from_str("a formfeed\u{000C}")),
+            None
+        );
+        assert_eq!(
+            auto_detect_line_ending(&Rope::from_str("\n\u{000A}\n \u{000A}")),
+            Some(LineEnding::LF)
+        );
+        assert_eq!(
+            auto_detect_line_ending(&Rope::from_str(
+                "a formfeed\u{000C} with a\u{000C} linefeed\u{000A}"
+            )),
+            Some(LineEnding::LF)
+        );
+        assert_eq!(auto_detect_line_ending(&Rope::from_str("a formfeed\u{000C} with a\u{000C} carriage return linefeed\u{000D}\u{000A} and a linefeed\u{000A}")), Some(LineEnding::Crlf));
+    }
+
+    #[test]
+    fn str_to_line_ending() {
+        assert_eq!(LineEnding::from_str("\r"), Some(LineEnding::CR));
+        assert_eq!(LineEnding::from_str("\n"), Some(LineEnding::LF));
+        assert_eq!(LineEnding::from_str("\r\n"), Some(LineEnding::Crlf));
+        assert_eq!(LineEnding::from_str("hello\n"), None);
+    }
+
+    #[test]
+    fn rope_slice_to_line_ending() {
+        let r = Rope::from_str("hello\r\n");
+        assert_eq!(
+            LineEnding::from_rope_slice(&r.slice(5..6)),
+            Some(LineEnding::CR)
+        );
+        assert_eq!(
+            LineEnding::from_rope_slice(&r.slice(6..7)),
+            Some(LineEnding::LF)
+        );
+        assert_eq!(
+            LineEnding::from_rope_slice(&r.slice(5..7)),
+            Some(LineEnding::Crlf)
+        );
+        assert_eq!(LineEnding::from_rope_slice(&r.slice(..)), None);
+    }
+
+    #[test]
+    fn get_line_ending_rope_slice() {
+        let r = Rope::from_str("Hello\rworld\nhow\r\nare you?");
+        assert_eq!(get_line_ending(&r.slice(..6)), Some(LineEnding::CR));
+        assert_eq!(get_line_ending(&r.slice(..12)), Some(LineEnding::LF));
+        assert_eq!(get_line_ending(&r.slice(..17)), Some(LineEnding::Crlf));
+        assert_eq!(get_line_ending(&r.slice(..)), None);
+    }
+
+    #[test]
+    fn get_line_ending_str() {
+        let text = "Hello\rworld\nhow\r\nare you?";
+        assert_eq!(get_line_ending_of_str(&text[..6]), Some(LineEnding::CR));
+        assert_eq!(get_line_ending_of_str(&text[..12]), Some(LineEnding::LF));
+        assert_eq!(get_line_ending_of_str(&text[..17]), Some(LineEnding::Crlf));
+        assert_eq!(get_line_ending_of_str(&text[..]), None);
+    }
+
+    #[test]
+    fn line_end_char_index_rope_slice() {
+        let r = Rope::from_str("Hello\rworld\nhow\r\nare you?");
+        let s = &r.slice(..);
+        assert_eq!(line_end_char_index(s, 0), 5);
+        assert_eq!(line_end_char_index(s, 1), 11);
+        assert_eq!(line_end_char_index(s, 2), 15);
+        assert_eq!(line_end_char_index(s, 3), 25);
+    }
+}

helix-core/src/match_brackets.rs

@@ -1,6 +1,6 @@
-use crate::{Range, Rope, Selection, Syntax};
+use crate::{Rope, Syntax};
 
-// const PAIRS: &[(char, char)] = &[('(', ')'), ('{', '}'), ('[', ']')];
+const PAIRS: &[(char, char)] = &[('(', ')'), ('{', '}'), ('[', ']'), ('<', '>')];
 // limit matching pairs to only ( ) { } [ ] < >
 
 #[must_use]
@@ -12,7 +12,7 @@ pub fn find(syntax: &Syntax, doc: &Rope, pos: usize) -> Option<usize> {
     // most naive implementation: find the innermost syntax node, if we're at the edge of a node,
     // return the other edge.
 
-    let mut node = match tree
+    let node = match tree
         .root_node()
         .named_descendant_for_byte_range(byte_pos, byte_pos)
     {
@@ -20,15 +20,28 @@ pub fn find(syntax: &Syntax, doc: &Rope, pos: usize) -> Option<usize> {
         None => return None,
     };
 
-    let start_byte = node.start_byte();
-    let end_byte = node.end_byte() - 1; // it's end exclusive
-
-    if start_byte == byte_pos {
-        return Some(doc.byte_to_char(end_byte));
+    if node.is_error() {
+        return None;
     }
 
-    if end_byte == byte_pos {
-        return Some(doc.byte_to_char(start_byte));
+    let len = doc.len_bytes();
+    let start_byte = node.start_byte();
+    let end_byte = node.end_byte() - 1; // it's end exclusive
+    if start_byte >= len || end_byte >= len {
+        return None;
+    }
+
+    let start_char = doc.byte_to_char(start_byte);
+    let end_char = doc.byte_to_char(end_byte);
+
+    if PAIRS.contains(&(doc.char(start_char), doc.char(end_char))) {
+        if start_byte == byte_pos {
+            return Some(end_char);
+        }
+
+        if end_byte == byte_pos {
+            return Some(start_char);
+        }
     }
 
     None

helix-core/src/object.rs

@@ -1,12 +1,11 @@
 use crate::{Range, RopeSlice, Selection, Syntax};
-use smallvec::smallvec;
 
 // TODO: to contract_selection we'd need to store the previous ranges before expand.
 // Maybe just contract to the first child node?
 pub fn expand_selection(syntax: &Syntax, text: RopeSlice, selection: &Selection) -> Selection {
     let tree = syntax.tree();
 
-    selection.transform(|range| {
+    selection.clone().transform(|range| {
         let from = text.char_to_byte(range.from());
         let to = text.char_to_byte(range.to());
 

helix-core/src/position.rs

@@ -1,6 +1,8 @@
 use crate::{
-    graphemes::{nth_next_grapheme_boundary, RopeGraphemes},
-    Rope, RopeSlice,
+    chars::char_is_line_ending,
+    graphemes::{ensure_grapheme_boundary_prev, RopeGraphemes},
+    line_ending::line_end_char_index,
+    RopeSlice,
 };
 
 /// Represents a single point in a text buffer. Zero indexed.
@@ -23,8 +25,9 @@ impl Position {
     pub fn traverse(self, text: &crate::Tendril) -> Self {
         let Self { mut row, mut col } = self;
         // TODO: there should be a better way here
-        for ch in text.chars() {
-            if ch == '\n' {
+        let mut chars = text.chars().peekable();
+        while let Some(ch) = chars.next() {
+            if char_is_line_ending(ch) && !(ch == '\r' && chars.peek() == Some(&'\n')) {
                 row += 1;
                 col = 0;
             } else {
@@ -50,24 +53,65 @@ impl From<Position> for tree_sitter::Point {
     }
 }
 /// Convert a character index to (line, column) coordinates.
+///
+/// TODO: this should be split into two methods: one for visual
+/// row/column, and one for "objective" row/column (possibly with
+/// the column specified in `char`s).  The former would be used
+/// for cursor movement, and the latter would be used for e.g. the
+/// row:column display in the status line.
 pub fn coords_at_pos(text: RopeSlice, pos: usize) -> Position {
     let line = text.char_to_line(pos);
+
     let line_start = text.line_to_char(line);
+    let pos = ensure_grapheme_boundary_prev(text, pos);
     let col = RopeGraphemes::new(text.slice(line_start..pos)).count();
+
     Position::new(line, col)
 }
 
 /// Convert (line, column) coordinates to a character index.
-pub fn pos_at_coords(text: RopeSlice, coords: Position) -> usize {
+///
+/// If the `line` coordinate is beyond the end of the file, the EOF
+/// position will be returned.
+///
+/// If the `column` coordinate is past the end of the given line, the
+/// line-end position will be returned.  What constitutes the "line-end
+/// position" depends on the parameter `limit_before_line_ending`.  If it's
+/// `true`, the line-end position will be just *before* the line ending
+/// character.  If `false` it will be just *after* the line ending
+/// character--on the border between the current line and the next.
+///
+/// Usually you only want `limit_before_line_ending` to be `true` if you're working
+/// with left-side block-cursor positions, as this prevents the the block cursor
+/// from jumping to the next line.  Otherwise you typically want it to be `false`,
+/// such as when dealing with raw anchor/head positions.
+///
+/// TODO: this should be changed to work in terms of visual row/column, not
+/// graphemes.
+pub fn pos_at_coords(text: RopeSlice, coords: Position, limit_before_line_ending: bool) -> usize {
     let Position { row, col } = coords;
     let line_start = text.line_to_char(row);
-    // line_start + col
-    nth_next_grapheme_boundary(text, line_start, col)
+    let line_end = if limit_before_line_ending {
+        line_end_char_index(&text, row)
+    } else {
+        text.line_to_char((row + 1).min(text.len_lines()))
+    };
+
+    let mut col_char_offset = 0;
+    for (i, g) in RopeGraphemes::new(text.slice(line_start..line_end)).enumerate() {
+        if i == col {
+            break;
+        }
+        col_char_offset += g.chars().count();
+    }
+
+    line_start + col_char_offset
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::Rope;
 
     #[test]
     fn test_ordering() {
@@ -79,53 +123,107 @@ mod test {
     fn test_coords_at_pos() {
         let text = Rope::from("ḧëḷḷö\nẅöṛḷḋ");
         let slice = text.slice(..);
-        // assert_eq!(coords_at_pos(slice, 0), (0, 0).into());
-        // assert_eq!(coords_at_pos(slice, 5), (0, 5).into()); // position on \n
-        // assert_eq!(coords_at_pos(slice, 6), (1, 0).into()); // position on w
-        // assert_eq!(coords_at_pos(slice, 7), (1, 1).into()); // position on o
-        // assert_eq!(coords_at_pos(slice, 10), (1, 4).into()); // position on d
+        assert_eq!(coords_at_pos(slice, 0), (0, 0).into());
+        assert_eq!(coords_at_pos(slice, 5), (0, 5).into()); // position on \n
+        assert_eq!(coords_at_pos(slice, 6), (1, 0).into()); // position on w
+        assert_eq!(coords_at_pos(slice, 7), (1, 1).into()); // position on o
+        assert_eq!(coords_at_pos(slice, 10), (1, 4).into()); // position on d
 
-        // test with grapheme clusters
+        // Test with wide characters.
+        // TODO: account for character width.
+        let text = Rope::from("今日はいい\n");
+        let slice = text.slice(..);
+        assert_eq!(coords_at_pos(slice, 0), (0, 0).into());
+        assert_eq!(coords_at_pos(slice, 1), (0, 1).into());
+        assert_eq!(coords_at_pos(slice, 2), (0, 2).into());
+        assert_eq!(coords_at_pos(slice, 3), (0, 3).into());
+        assert_eq!(coords_at_pos(slice, 4), (0, 4).into());
+        assert_eq!(coords_at_pos(slice, 5), (0, 5).into());
+        assert_eq!(coords_at_pos(slice, 6), (1, 0).into());
+
+        // Test with grapheme clusters.
         let text = Rope::from("a̐éö̲\r\n");
         let slice = text.slice(..);
         assert_eq!(coords_at_pos(slice, 0), (0, 0).into());
         assert_eq!(coords_at_pos(slice, 2), (0, 1).into());
         assert_eq!(coords_at_pos(slice, 4), (0, 2).into());
         assert_eq!(coords_at_pos(slice, 7), (0, 3).into());
+        assert_eq!(coords_at_pos(slice, 9), (1, 0).into());
 
-        let text = Rope::from("किमपि");
+        // Test with wide-character grapheme clusters.
+        // TODO: account for character width.
+        let text = Rope::from("किमपि\n");
         let slice = text.slice(..);
         assert_eq!(coords_at_pos(slice, 0), (0, 0).into());
         assert_eq!(coords_at_pos(slice, 2), (0, 1).into());
         assert_eq!(coords_at_pos(slice, 3), (0, 2).into());
         assert_eq!(coords_at_pos(slice, 5), (0, 3).into());
+        assert_eq!(coords_at_pos(slice, 6), (1, 0).into());
+
+        // Test with tabs.
+        // Todo: account for tab stops.
+        let text = Rope::from("\tHello\n");
+        let slice = text.slice(..);
+        assert_eq!(coords_at_pos(slice, 0), (0, 0).into());
+        assert_eq!(coords_at_pos(slice, 1), (0, 1).into());
+        assert_eq!(coords_at_pos(slice, 2), (0, 2).into());
     }
 
     #[test]
     fn test_pos_at_coords() {
         let text = Rope::from("ḧëḷḷö\nẅöṛḷḋ");
         let slice = text.slice(..);
-        assert_eq!(pos_at_coords(slice, (0, 0).into()), 0);
-        assert_eq!(pos_at_coords(slice, (0, 5).into()), 5); // position on \n
-        assert_eq!(pos_at_coords(slice, (1, 0).into()), 6); // position on w
-        assert_eq!(pos_at_coords(slice, (1, 1).into()), 7); // position on o
-        assert_eq!(pos_at_coords(slice, (1, 4).into()), 10); // position on d
+        assert_eq!(pos_at_coords(slice, (0, 0).into(), false), 0);
+        assert_eq!(pos_at_coords(slice, (0, 5).into(), false), 5); // position on \n
+        assert_eq!(pos_at_coords(slice, (0, 6).into(), false), 6); // position after \n
+        assert_eq!(pos_at_coords(slice, (0, 6).into(), true), 5); // position after \n
+        assert_eq!(pos_at_coords(slice, (1, 0).into(), false), 6); // position on w
+        assert_eq!(pos_at_coords(slice, (1, 1).into(), false), 7); // position on o
+        assert_eq!(pos_at_coords(slice, (1, 4).into(), false), 10); // position on d
 
-        // test with grapheme clusters
+        // Test with wide characters.
+        // TODO: account for character width.
+        let text = Rope::from("今日はいい\n");
+        let slice = text.slice(..);
+        assert_eq!(pos_at_coords(slice, (0, 0).into(), false), 0);
+        assert_eq!(pos_at_coords(slice, (0, 1).into(), false), 1);
+        assert_eq!(pos_at_coords(slice, (0, 2).into(), false), 2);
+        assert_eq!(pos_at_coords(slice, (0, 3).into(), false), 3);
+        assert_eq!(pos_at_coords(slice, (0, 4).into(), false), 4);
+        assert_eq!(pos_at_coords(slice, (0, 5).into(), false), 5);
+        assert_eq!(pos_at_coords(slice, (0, 6).into(), false), 6);
+        assert_eq!(pos_at_coords(slice, (0, 6).into(), true), 5);
+        assert_eq!(pos_at_coords(slice, (1, 0).into(), false), 6);
+
+        // Test with grapheme clusters.
         let text = Rope::from("a̐éö̲\r\n");
         let slice = text.slice(..);
-        assert_eq!(pos_at_coords(slice, (0, 0).into()), 0);
-        assert_eq!(pos_at_coords(slice, (0, 1).into()), 2);
-        assert_eq!(pos_at_coords(slice, (0, 2).into()), 4);
-        assert_eq!(pos_at_coords(slice, (0, 3).into()), 7); // \r\n is one char here
-        assert_eq!(pos_at_coords(slice, (0, 4).into()), 9);
+        assert_eq!(pos_at_coords(slice, (0, 0).into(), false), 0);
+        assert_eq!(pos_at_coords(slice, (0, 1).into(), false), 2);
+        assert_eq!(pos_at_coords(slice, (0, 2).into(), false), 4);
+        assert_eq!(pos_at_coords(slice, (0, 3).into(), false), 7); // \r\n is one char here
+        assert_eq!(pos_at_coords(slice, (0, 4).into(), false), 9);
+        assert_eq!(pos_at_coords(slice, (0, 4).into(), true), 7);
+        assert_eq!(pos_at_coords(slice, (1, 0).into(), false), 9);
+
+        // Test with wide-character grapheme clusters.
+        // TODO: account for character width.
         let text = Rope::from("किमपि");
         // 2 - 1 - 2 codepoints
         // TODO: delete handling as per https://news.ycombinator.com/item?id=20058454
         let slice = text.slice(..);
-        assert_eq!(pos_at_coords(slice, (0, 0).into()), 0);
-        assert_eq!(pos_at_coords(slice, (0, 1).into()), 2);
-        assert_eq!(pos_at_coords(slice, (0, 2).into()), 3);
-        assert_eq!(pos_at_coords(slice, (0, 3).into()), 5); // eol
+        assert_eq!(pos_at_coords(slice, (0, 0).into(), false), 0);
+        assert_eq!(pos_at_coords(slice, (0, 1).into(), false), 2);
+        assert_eq!(pos_at_coords(slice, (0, 2).into(), false), 3);
+        assert_eq!(pos_at_coords(slice, (0, 3).into(), false), 5);
+        assert_eq!(pos_at_coords(slice, (0, 3).into(), true), 5);
+
+        // Test with tabs.
+        // Todo: account for tab stops.
+        let text = Rope::from("\tHello\n");
+        let slice = text.slice(..);
+        assert_eq!(pos_at_coords(slice, (0, 0).into(), false), 0);
+        assert_eq!(pos_at_coords(slice, (0, 1).into(), false), 1);
+        assert_eq!(pos_at_coords(slice, (0, 2).into(), false), 2);
     }
 }

helix-core/src/register.rs

@@ -1,21 +1,63 @@
-use crate::Tendril;
-use once_cell::sync::Lazy;
-use std::{collections::HashMap, sync::RwLock};
+use std::collections::HashMap;
 
-// TODO: could be an instance on Editor
-static REGISTRY: Lazy<RwLock<HashMap<char, Vec<String>>>> =
-    Lazy::new(|| RwLock::new(HashMap::new()));
-
-pub fn get(register: char) -> Option<Vec<String>> {
-    let registry = REGISTRY.read().unwrap();
-
-    // TODO: no cloning
-    registry.get(&register).cloned()
+#[derive(Debug)]
+pub struct Register {
+    name: char,
+    values: Vec<String>,
 }
 
-// restoring: bool
-pub fn set(register: char, values: Vec<String>) {
-    let mut registry = REGISTRY.write().unwrap();
+impl Register {
+    pub fn new(name: char) -> Self {
+        Self {
+            name,
+            values: Vec::new(),
+        }
+    }
 
-    registry.insert(register, values);
+    pub fn new_with_values(name: char, values: Vec<String>) -> Self {
+        Self { name, values }
+    }
+
+    pub fn name(&self) -> char {
+        self.name
+    }
+
+    pub fn read(&self) -> &[String] {
+        &self.values
+    }
+
+    pub fn write(&mut self, values: Vec<String>) {
+        self.values = values;
+    }
+
+    pub fn push(&mut self, value: String) {
+        self.values.push(value);
+    }
+}
+
+/// Currently just wraps a `HashMap` of `Register`s
+#[derive(Debug, Default)]
+pub struct Registers {
+    inner: HashMap<char, Register>,
+}
+
+impl Registers {
+    pub fn get(&self, name: char) -> Option<&Register> {
+        self.inner.get(&name)
+    }
+
+    pub fn get_mut(&mut self, name: char) -> &mut Register {
+        self.inner
+            .entry(name)
+            .or_insert_with(|| Register::new(name))
+    }
+
+    pub fn write(&mut self, name: char, values: Vec<String>) {
+        self.inner
+            .insert(name, Register::new_with_values(name, values));
+    }
+
+    pub fn read(&self, name: char) -> Option<&[String]> {
+        self.get(name).map(|reg| reg.read())
+    }
 }

helix-core/src/search.rs

@@ -1,14 +1,11 @@
 use crate::RopeSlice;
 
-pub fn find_nth_next(
-    text: RopeSlice,
-    ch: char,
-    mut pos: usize,
-    n: usize,
-    inclusive: bool,
-) -> Option<usize> {
-    // start searching right after pos
-    let mut chars = text.chars_at(pos + 1);
+pub fn find_nth_next(text: RopeSlice, ch: char, mut pos: usize, n: usize) -> Option<usize> {
+    if pos >= text.len_chars() || n == 0 {
+        return None;
+    }
+
+    let mut chars = text.chars_at(pos);
 
     for _ in 0..n {
         loop {
@@ -22,28 +19,21 @@ pub fn find_nth_next(
         }
     }
 
-    if !inclusive {
-        pos -= 1;
-    }
-
-    Some(pos)
+    Some(pos - 1)
 }
 
-pub fn find_nth_prev(
-    text: RopeSlice,
-    ch: char,
-    mut pos: usize,
-    n: usize,
-    inclusive: bool,
-) -> Option<usize> {
-    // start searching right before pos
-    let mut chars = text.chars_at(pos.saturating_sub(1));
+pub fn find_nth_prev(text: RopeSlice, ch: char, mut pos: usize, n: usize) -> Option<usize> {
+    if pos == 0 || n == 0 {
+        return None;
+    }
+
+    let mut chars = text.chars_at(pos);
 
     for _ in 0..n {
         loop {
             let c = chars.prev()?;
 
-            pos = pos.saturating_sub(1);
+            pos -= 1;
 
             if c == ch {
                 break;
@@ -51,9 +41,5 @@ pub fn find_nth_prev(
         }
     }
 
-    if !inclusive {
-        pos -= 1;
-    }
-
     Some(pos)
 }

helix-core/src/selection.rs

@@ -1,30 +1,59 @@
-//! Selections are the primary editing construct. Even a single cursor is defined as an empty
-//! single selection range.
+//! Selections are the primary editing construct. Even cursors are
+//! defined as a selection range.
 //!
 //! All positioning is done via `char` offsets into the buffer.
-use crate::{Assoc, ChangeSet, Rope, RopeSlice};
+use crate::{
+    graphemes::{
+        ensure_grapheme_boundary_next, ensure_grapheme_boundary_prev, next_grapheme_boundary,
+        prev_grapheme_boundary,
+    },
+    Assoc, ChangeSet, RopeSlice,
+};
 use smallvec::{smallvec, SmallVec};
 use std::borrow::Cow;
 
-#[inline]
-fn abs_difference(x: usize, y: usize) -> usize {
-    if x < y {
-        y - x
-    } else {
-        x - y
-    }
-}
-
-/// A single selection range. Anchor-inclusive, head-exclusive.
+/// A single selection range.
+///
+/// A range consists of an "anchor" and "head" position in
+/// the text.  The head is the part that the user moves when
+/// directly extending a selection.  The head and anchor
+/// can be in any order, or even share the same position.
+///
+/// The anchor and head positions use gap indexing, meaning
+/// that their indices represent the the gaps *between* `char`s
+/// rather than the `char`s themselves. For example, 1
+/// represents the position between the first and second `char`.
+///
+/// Below are some example `Range` configurations to better
+/// illustrate.  The anchor and head indices are show as
+/// "(anchor, head)", followed by example text with "[" and "]"
+/// inserted to represent the anchor and head positions:
+///
+/// - (0, 3): [Som]e text.
+/// - (3, 0): ]Som[e text.
+/// - (2, 7): So[me te]xt.
+/// - (1, 1): S[]ome text.
+///
+/// Ranges are considered to be inclusive on the left and
+/// exclusive on the right, regardless of anchor-head ordering.
+/// This means, for example, that non-zero-width ranges that
+/// are directly adjecent, sharing an edge, do not overlap.
+/// However, a zero-width range will overlap with the shared
+/// left-edge of another range.
+///
+/// By convention, user-facing ranges are considered to have
+/// a block cursor on the head-side of the range that spans a
+/// single grapheme inward from the range's edge.  There are a
+/// variety of helper methods on `Range` for working in terms of
+/// that block cursor, all of which have `cursor` in their name.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct Range {
-    // TODO: optimize into u32
     /// The anchor of the range: the side that doesn't move when extending.
     pub anchor: usize,
     /// The head of the range, moved when extending.
     pub head: usize,
     pub horiz: Option<u32>,
-} // TODO: might be cheaper to store normalized as from/to and an inverted flag
+}
 
 impl Range {
     pub fn new(anchor: usize, head: usize) -> Self {
@@ -35,6 +64,10 @@ impl Range {
         }
     }
 
+    pub fn point(head: usize) -> Self {
+        Self::new(head, head)
+    }
+
     /// Start of the range.
     #[inline]
     #[must_use]
@@ -49,6 +82,20 @@ impl Range {
         std::cmp::max(self.anchor, self.head)
     }
 
+    /// The (inclusive) range of lines that the range overlaps.
+    #[inline]
+    #[must_use]
+    pub fn line_range(&self, text: RopeSlice) -> (usize, usize) {
+        let from = self.from();
+        let to = if self.is_empty() {
+            self.to()
+        } else {
+            prev_grapheme_boundary(text, self.to()).max(from)
+        };
+
+        (text.char_to_line(from), text.char_to_line(to))
+    }
+
     /// `true` when head and anchor are at the same position.
     #[inline]
     pub fn is_empty(&self) -> bool {
@@ -58,37 +105,39 @@ impl Range {
     /// Check two ranges for overlap.
     #[must_use]
     pub fn overlaps(&self, other: &Self) -> bool {
-        // cursor overlap is checked differently
-        if self.is_empty() {
-            let pos = self.head;
-            pos >= other.from() && other.to() >= pos
-        } else {
-            self.to() > other.from() && other.to() > self.from()
-        }
+        // To my eye, it's non-obvious why this works, but I arrived
+        // at it after transforming the slower version that explicitly
+        // enumerated more cases.  The unit tests are thorough.
+        self.from() == other.from() || (self.to() > other.from() && other.to() > self.from())
     }
 
     pub fn contains(&self, pos: usize) -> bool {
-        if self.is_empty() {
-            return false;
-        }
-
-        if self.anchor < self.head {
-            self.anchor <= pos && pos < self.head
-        } else {
-            self.head < pos && pos <= self.anchor
-        }
+        self.from() <= pos && pos < self.to()
     }
 
     /// Map a range through a set of changes. Returns a new range representing the same position
     /// after the changes are applied.
     pub fn map(self, changes: &ChangeSet) -> Self {
-        let anchor = changes.map_pos(self.anchor, Assoc::After);
-        let head = changes.map_pos(self.head, Assoc::After);
+        use std::cmp::Ordering;
+        let (anchor, head) = match self.anchor.cmp(&self.head) {
+            Ordering::Equal => (
+                changes.map_pos(self.anchor, Assoc::After),
+                changes.map_pos(self.head, Assoc::After),
+            ),
+            Ordering::Less => (
+                changes.map_pos(self.anchor, Assoc::After),
+                changes.map_pos(self.head, Assoc::Before),
+            ),
+            Ordering::Greater => (
+                changes.map_pos(self.anchor, Assoc::Before),
+                changes.map_pos(self.head, Assoc::After),
+            ),
+        };
 
-        // TODO: possibly unnecessary
-        if self.anchor == anchor && self.head == head {
-            return self;
-        }
+        // We want to return a new `Range` with `horiz == None` every time,
+        // even if the anchor and head haven't changed, because we don't
+        // know if the *visual* position hasn't changed due to
+        // character-width or grapheme changes earlier in the text.
         Self {
             anchor,
             head,
@@ -99,22 +148,41 @@ impl Range {
     /// Extend the range to cover at least `from` `to`.
     #[must_use]
     pub fn extend(&self, from: usize, to: usize) -> Self {
-        if from <= self.anchor && to >= self.anchor {
-            return Self {
-                anchor: from,
-                head: to,
-                horiz: None,
-            };
-        }
+        debug_assert!(from <= to);
 
-        Self {
-            anchor: self.anchor,
-            head: if abs_difference(from, self.anchor) > abs_difference(to, self.anchor) {
-                from
-            } else {
-                to
-            },
-            horiz: None,
+        if self.anchor <= self.head {
+            Self {
+                anchor: self.anchor.min(from),
+                head: self.head.max(to),
+                horiz: None,
+            }
+        } else {
+            Self {
+                anchor: self.anchor.max(to),
+                head: self.head.min(from),
+                horiz: None,
+            }
+        }
+    }
+
+    /// Returns a range that encompasses both input ranges.
+    ///
+    /// This is like `extend()`, but tries to negotiate the
+    /// anchor/head ordering between the two input ranges.
+    #[must_use]
+    pub fn merge(&self, other: Self) -> Self {
+        if self.anchor > self.head && other.anchor > other.head {
+            Range {
+                anchor: self.anchor.max(other.anchor),
+                head: self.head.min(other.head),
+                horiz: None,
+            }
+        } else {
+            Range {
+                anchor: self.from().min(other.from()),
+                head: self.to().max(other.to()),
+                horiz: None,
+            }
         }
     }
 
@@ -122,7 +190,130 @@ impl Range {
 
     #[inline]
     pub fn fragment<'a, 'b: 'a>(&'a self, text: RopeSlice<'b>) -> Cow<'b, str> {
-        Cow::from(text.slice(self.from()..self.to() + 1))
+        text.slice(self.from()..self.to()).into()
+    }
+
+    //--------------------------------
+    // Alignment methods.
+
+    /// Compute a possibly new range from this range, with its ends
+    /// shifted as needed to align with grapheme boundaries.
+    ///
+    /// Zero-width ranges will always stay zero-width, and non-zero-width
+    /// ranges will never collapse to zero-width.
+    #[must_use]
+    pub fn grapheme_aligned(&self, slice: RopeSlice) -> Self {
+        use std::cmp::Ordering;
+        let (new_anchor, new_head) = match self.anchor.cmp(&self.head) {
+            Ordering::Equal => {
+                let pos = ensure_grapheme_boundary_prev(slice, self.anchor);
+                (pos, pos)
+            }
+            Ordering::Less => (
+                ensure_grapheme_boundary_prev(slice, self.anchor),
+                ensure_grapheme_boundary_next(slice, self.head),
+            ),
+            Ordering::Greater => (
+                ensure_grapheme_boundary_next(slice, self.anchor),
+                ensure_grapheme_boundary_prev(slice, self.head),
+            ),
+        };
+        Range {
+            anchor: new_anchor,
+            head: new_head,
+            horiz: if new_anchor == self.anchor {
+                self.horiz
+            } else {
+                None
+            },
+        }
+    }
+
+    /// Compute a possibly new range from this range, attempting to ensure
+    /// a minimum range width of 1 char by shifting the head in the forward
+    /// direction as needed.
+    ///
+    /// This method will never shift the anchor, and will only shift the
+    /// head in the forward direction.  Therefore, this method can fail
+    /// at ensuring the minimum width if and only if the passed range is
+    /// both zero-width and at the end of the `RopeSlice`.
+    ///
+    /// If the input range is grapheme-boundary aligned, the returned range
+    /// will also be.  Specifically, if the head needs to shift to achieve
+    /// the minimum width, it will shift to the next grapheme boundary.
+    #[must_use]
+    #[inline]
+    pub fn min_width_1(&self, slice: RopeSlice) -> Self {
+        if self.anchor == self.head {
+            Range {
+                anchor: self.anchor,
+                head: next_grapheme_boundary(slice, self.head),
+                horiz: self.horiz,
+            }
+        } else {
+            *self
+        }
+    }
+
+    //--------------------------------
+    // Block-cursor methods.
+
+    /// Gets the left-side position of the block cursor.
+    #[must_use]
+    #[inline]
+    pub fn cursor(self, text: RopeSlice) -> usize {
+        if self.head > self.anchor {
+            prev_grapheme_boundary(text, self.head)
+        } else {
+            self.head
+        }
+    }
+
+    /// Puts the left side of the block cursor at `char_idx`, optionally extending.
+    ///
+    /// This follows "1-width" semantics, and therefore does a combination of anchor
+    /// and head moves to behave as if both the front and back of the range are 1-width
+    /// blocks
+    ///
+    /// This method assumes that the range and `char_idx` are already properly
+    /// grapheme-aligned.
+    #[must_use]
+    #[inline]
+    pub fn put_cursor(self, text: RopeSlice, char_idx: usize, extend: bool) -> Range {
+        if extend {
+            let anchor = if self.head >= self.anchor && char_idx < self.anchor {
+                next_grapheme_boundary(text, self.anchor)
+            } else if self.head < self.anchor && char_idx >= self.anchor {
+                prev_grapheme_boundary(text, self.anchor)
+            } else {
+                self.anchor
+            };
+
+            if anchor <= char_idx {
+                Range::new(anchor, next_grapheme_boundary(text, char_idx))
+            } else {
+                Range::new(anchor, char_idx)
+            }
+        } else {
+            Range::point(char_idx)
+        }
+    }
+
+    /// The line number that the block-cursor is on.
+    #[inline]
+    #[must_use]
+    pub fn cursor_line(&self, text: RopeSlice) -> usize {
+        text.char_to_line(self.cursor(text))
+    }
+}
+
+impl From<(usize, usize)> for Range {
+    fn from(tuple: (usize, usize)) -> Self {
+        Self {
+            anchor: tuple.0,
+            head: tuple.1,
+            horiz: None,
+        }
     }
 }
 
@@ -138,14 +329,16 @@ pub struct Selection {
 impl Selection {
     // eq
 
+    #[inline]
     #[must_use]
     pub fn primary(&self) -> Range {
         self.ranges[self.primary_index]
     }
 
+    #[inline]
     #[must_use]
-    pub fn cursor(&self) -> usize {
-        self.primary().head
+    pub fn primary_mut(&mut self) -> &mut Range {
+        &mut self.ranges[self.primary_index]
     }
 
     /// Ensure selection containing only the primary selection.
@@ -160,13 +353,12 @@ impl Selection {
         }
     }
 
+    /// Adds a new range to the selection and makes it the primary range.
     pub fn push(mut self, range: Range) -> Self {
-        let index = self.ranges.len();
         self.ranges.push(range);
-
-        Self::normalize(self.ranges, index)
+        self.set_primary_index(self.ranges().len() - 1);
+        self.normalize()
     }
-    // replace_range
 
     /// Map selections over a set of changes. Useful for adjusting the selection position after
     /// applying changes to a document.
@@ -192,6 +384,11 @@ impl Selection {
         self.primary_index
     }
 
+    pub fn set_primary_index(&mut self, idx: usize) {
+        assert!(idx < self.ranges.len());
+        self.primary_index = idx;
+    }
+
     #[must_use]
     /// Constructs a selection holding a single range.
     pub fn single(anchor: usize, head: usize) -> Self {
@@ -210,77 +407,79 @@ impl Selection {
         Self::single(pos, pos)
     }
 
-    fn normalize(mut ranges: SmallVec<[Range; 1]>, mut primary_index: usize) -> Self {
-        let primary = ranges[primary_index];
-        ranges.sort_unstable_by_key(Range::from);
-        primary_index = ranges.iter().position(|&range| range == primary).unwrap();
+    /// Normalizes a `Selection`.
+    fn normalize(mut self) -> Self {
+        let primary = self.ranges[self.primary_index];
+        self.ranges.sort_unstable_by_key(Range::from);
+        self.primary_index = self
+            .ranges
+            .iter()
+            .position(|&range| range == primary)
+            .unwrap();
 
-        let mut result = SmallVec::with_capacity(ranges.len()); // approx
-
-        // TODO: we could do with one vec by removing elements as we mutate
-
-        for (i, range) in ranges.into_iter().enumerate() {
-            // if previous value exists
-            if let Some(prev) = result.last_mut() {
-                // and we overlap it
-
-                // TODO: we used to simply check range.from() <(=) prev.to()
-                // avoiding two comparisons
-                if range.overlaps(prev) {
-                    let from = prev.from();
-                    let to = std::cmp::max(range.to(), prev.to());
-
-                    if i <= primary_index {
-                        primary_index -= 1
-                    }
-
-                    // merge into previous
-                    if range.anchor > range.head {
-                        prev.anchor = to;
-                        prev.head = from;
-                    } else {
-                        prev.anchor = from;
-                        prev.head = to;
-                    }
-                    continue;
-                }
+        let mut prev_i = 0;
+        for i in 1..self.ranges.len() {
+            if self.ranges[prev_i].overlaps(&self.ranges[i]) {
+                self.ranges[prev_i] = self.ranges[prev_i].merge(self.ranges[i]);
+            } else {
+                prev_i += 1;
+                self.ranges[prev_i] = self.ranges[i];
+            }
+            if i == self.primary_index {
+                self.primary_index = prev_i;
             }
-
-            result.push(range)
         }
 
-        Self {
-            ranges: result,
-            primary_index,
-        }
+        self.ranges.truncate(prev_i + 1);
+
+        self
     }
 
     // TODO: consume an iterator or a vec to reduce allocations?
     #[must_use]
     pub fn new(ranges: SmallVec<[Range; 1]>, primary_index: usize) -> Self {
         assert!(!ranges.is_empty());
+        debug_assert!(primary_index < ranges.len());
 
-        // fast path for a single selection (cursor)
-        if ranges.len() == 1 {
-            return Self {
-                ranges,
-                primary_index: 0,
-            };
+        let mut selection = Self {
+            ranges,
+            primary_index,
+        };
+
+        if selection.ranges.len() > 1 {
+            // TODO: only normalize if needed (any ranges out of order)
+            selection = selection.normalize();
         }
 
-        // TODO: only normalize if needed (any ranges out of order)
-        Self::normalize(ranges, primary_index)
+        selection
     }
 
-    /// Takes a closure and maps each selection over the closure.
-    pub fn transform<F>(&self, f: F) -> Self
+    /// Takes a closure and maps each `Range` over the closure.
+    pub fn transform<F>(mut self, f: F) -> Self
     where
         F: Fn(Range) -> Range,
     {
-        Self::new(
-            self.ranges.iter().copied().map(f).collect(),
-            self.primary_index,
-        )
+        for range in self.ranges.iter_mut() {
+            *range = f(*range)
+        }
+        self.normalize()
+    }
+
+    // Ensures the selection adheres to the following invariants:
+    // 1. All ranges are grapheme aligned.
+    // 2. All ranges are at least 1 character wide, unless at the
+    //    very end of the document.
+    // 3. Ranges are non-overlapping.
+    // 4. Ranges are sorted by their position in the text.
+    pub fn ensure_invariants(self, text: RopeSlice) -> Self {
+        self.transform(|r| r.min_width_1(text).grapheme_aligned(text))
+            .normalize()
+    }
+
+    /// Transforms the selection into all of the left-side head positions,
+    /// using block-cursor semantics.
+    pub fn cursors(self, text: RopeSlice) -> Self {
+        self.transform(|range| Range::point(range.cursor(text)))
     }
 
     pub fn fragments<'a>(&'a self, text: RopeSlice<'a>) -> impl Iterator<Item = Cow<str>> + 'a {
@@ -338,17 +537,15 @@ pub fn select_on_matches(
         // TODO: can't avoid occasional allocations since Regex can't operate on chunks yet
         let fragment = sel.fragment(text);
 
-        let mut sel_start = sel.from();
-        let sel_end = sel.to();
-
-        let mut start_byte = text.char_to_byte(sel_start);
+        let sel_start = sel.from();
+        let start_byte = text.char_to_byte(sel_start);
 
         for mat in regex.find_iter(&fragment) {
             // TODO: retain range direction
 
             let start = text.byte_to_char(start_byte + mat.start());
             let end = text.byte_to_char(start_byte + mat.end());
-            result.push(Range::new(start, end - 1));
+            result.push(Range::new(start, end));
         }
     }
 
@@ -369,25 +566,30 @@ pub fn split_on_matches(
     let mut result = SmallVec::with_capacity(selection.len());
 
     for sel in selection {
+        // Special case: zero-width selection.
+        if sel.from() == sel.to() {
+            result.push(*sel);
+            continue;
+        }
+
         // TODO: can't avoid occasional allocations since Regex can't operate on chunks yet
         let fragment = sel.fragment(text);
 
-        let mut sel_start = sel.from();
+        let sel_start = sel.from();
         let sel_end = sel.to();
 
-        let mut start_byte = text.char_to_byte(sel_start);
+        let start_byte = text.char_to_byte(sel_start);
 
         let mut start = sel_start;
 
         for mat in regex.find_iter(&fragment) {
             // TODO: retain range direction
-
             let end = text.byte_to_char(start_byte + mat.start());
-            result.push(Range::new(start, end - 1));
+            result.push(Range::new(start, end));
             start = text.byte_to_char(start_byte + mat.end());
         }
 
-        if start <= sel_end {
+        if start < sel_end {
             result.push(Range::new(start, sel_end));
         }
     }
@@ -399,11 +601,12 @@ pub fn split_on_matches(
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::Rope;
 
     #[test]
     #[should_panic]
     fn test_new_empty() {
-        let sel = Selection::new(smallvec![], 0);
+        let _ = Selection::new(smallvec![], 0);
     }
 
     #[test]
@@ -430,6 +633,22 @@ mod test {
             .join(",");
 
         assert_eq!(res, "0/6,6/7,7/8,9/13,13/14");
+
+        // it correctly calculates a new primary index
+        let sel = Selection::new(
+            smallvec![Range::new(0, 2), Range::new(1, 5), Range::new(4, 7)],
+            2,
+        );
+
+        let res = sel
+            .ranges
+            .into_iter()
+            .map(|range| format!("{}/{}", range.anchor, range.head))
+            .collect::<Vec<String>>()
+            .join(",");
+
+        assert_eq!(res, "0/7");
+        assert_eq!(sel.primary_index, 0);
     }
 
     #[test]
@@ -452,7 +671,7 @@ mod test {
             .collect::<Vec<String>>()
             .join(",");
 
-        assert_eq!(res, "8/10,10/12");
+        assert_eq!(res, "8/10,10/12,12/12");
     }
 
     #[test]
@@ -466,35 +685,251 @@ mod test {
         assert_eq!(range.contains(13), false);
 
         let range = Range::new(9, 6);
-        assert_eq!(range.contains(9), true);
+        assert_eq!(range.contains(9), false);
         assert_eq!(range.contains(7), true);
-        assert_eq!(range.contains(6), false);
+        assert_eq!(range.contains(6), true);
+    }
+
+    #[test]
+    fn test_overlaps() {
+        fn overlaps(a: (usize, usize), b: (usize, usize)) -> bool {
+            Range::new(a.0, a.1).overlaps(&Range::new(b.0, b.1))
+        }
+
+        // Two non-zero-width ranges, no overlap.
+        assert!(!overlaps((0, 3), (3, 6)));
+        assert!(!overlaps((0, 3), (6, 3)));
+        assert!(!overlaps((3, 0), (3, 6)));
+        assert!(!overlaps((3, 0), (6, 3)));
+        assert!(!overlaps((3, 6), (0, 3)));
+        assert!(!overlaps((3, 6), (3, 0)));
+        assert!(!overlaps((6, 3), (0, 3)));
+        assert!(!overlaps((6, 3), (3, 0)));
+
+        // Two non-zero-width ranges, overlap.
+        assert!(overlaps((0, 4), (3, 6)));
+        assert!(overlaps((0, 4), (6, 3)));
+        assert!(overlaps((4, 0), (3, 6)));
+        assert!(overlaps((4, 0), (6, 3)));
+        assert!(overlaps((3, 6), (0, 4)));
+        assert!(overlaps((3, 6), (4, 0)));
+        assert!(overlaps((6, 3), (0, 4)));
+        assert!(overlaps((6, 3), (4, 0)));
+
+        // Zero-width and non-zero-width range, no overlap.
+        assert!(!overlaps((0, 3), (3, 3)));
+        assert!(!overlaps((3, 0), (3, 3)));
+        assert!(!overlaps((3, 3), (0, 3)));
+        assert!(!overlaps((3, 3), (3, 0)));
+
+        // Zero-width and non-zero-width range, overlap.
+        assert!(overlaps((1, 4), (1, 1)));
+        assert!(overlaps((4, 1), (1, 1)));
+        assert!(overlaps((1, 1), (1, 4)));
+        assert!(overlaps((1, 1), (4, 1)));
+
+        assert!(overlaps((1, 4), (3, 3)));
+        assert!(overlaps((4, 1), (3, 3)));
+        assert!(overlaps((3, 3), (1, 4)));
+        assert!(overlaps((3, 3), (4, 1)));
+
+        // Two zero-width ranges, no overlap.
+        assert!(!overlaps((0, 0), (1, 1)));
+        assert!(!overlaps((1, 1), (0, 0)));
+
+        // Two zero-width ranges, overlap.
+        assert!(overlaps((1, 1), (1, 1)));
+    }
+
+    #[test]
+    fn test_graphem_aligned() {
+        let r = Rope::from_str("\r\nHi\r\n");
+        let s = r.slice(..);
+
+        // Zero-width.
+        assert_eq!(Range::new(0, 0).grapheme_aligned(s), Range::new(0, 0));
+        assert_eq!(Range::new(1, 1).grapheme_aligned(s), Range::new(0, 0));
+        assert_eq!(Range::new(2, 2).grapheme_aligned(s), Range::new(2, 2));
+        assert_eq!(Range::new(3, 3).grapheme_aligned(s), Range::new(3, 3));
+        assert_eq!(Range::new(4, 4).grapheme_aligned(s), Range::new(4, 4));
+        assert_eq!(Range::new(5, 5).grapheme_aligned(s), Range::new(4, 4));
+        assert_eq!(Range::new(6, 6).grapheme_aligned(s), Range::new(6, 6));
+
+        // Forward.
+        assert_eq!(Range::new(0, 1).grapheme_aligned(s), Range::new(0, 2));
+        assert_eq!(Range::new(1, 2).grapheme_aligned(s), Range::new(0, 2));
+        assert_eq!(Range::new(2, 3).grapheme_aligned(s), Range::new(2, 3));
+        assert_eq!(Range::new(3, 4).grapheme_aligned(s), Range::new(3, 4));
+        assert_eq!(Range::new(4, 5).grapheme_aligned(s), Range::new(4, 6));
+        assert_eq!(Range::new(5, 6).grapheme_aligned(s), Range::new(4, 6));
+
+        assert_eq!(Range::new(0, 2).grapheme_aligned(s), Range::new(0, 2));
+        assert_eq!(Range::new(1, 3).grapheme_aligned(s), Range::new(0, 3));
+        assert_eq!(Range::new(2, 4).grapheme_aligned(s), Range::new(2, 4));
+        assert_eq!(Range::new(3, 5).grapheme_aligned(s), Range::new(3, 6));
+        assert_eq!(Range::new(4, 6).grapheme_aligned(s), Range::new(4, 6));
+
+        // Reverse.
+        assert_eq!(Range::new(1, 0).grapheme_aligned(s), Range::new(2, 0));
+        assert_eq!(Range::new(2, 1).grapheme_aligned(s), Range::new(2, 0));
+        assert_eq!(Range::new(3, 2).grapheme_aligned(s), Range::new(3, 2));
+        assert_eq!(Range::new(4, 3).grapheme_aligned(s), Range::new(4, 3));
+        assert_eq!(Range::new(5, 4).grapheme_aligned(s), Range::new(6, 4));
+        assert_eq!(Range::new(6, 5).grapheme_aligned(s), Range::new(6, 4));
+
+        assert_eq!(Range::new(2, 0).grapheme_aligned(s), Range::new(2, 0));
+        assert_eq!(Range::new(3, 1).grapheme_aligned(s), Range::new(3, 0));
+        assert_eq!(Range::new(4, 2).grapheme_aligned(s), Range::new(4, 2));
+        assert_eq!(Range::new(5, 3).grapheme_aligned(s), Range::new(6, 3));
+        assert_eq!(Range::new(6, 4).grapheme_aligned(s), Range::new(6, 4));
+    }
+
+    #[test]
+    fn test_min_width_1() {
+        let r = Rope::from_str("\r\nHi\r\n");
+        let s = r.slice(..);
+
+        // Zero-width.
+        assert_eq!(Range::new(0, 0).min_width_1(s), Range::new(0, 2));
+        assert_eq!(Range::new(1, 1).min_width_1(s), Range::new(1, 2));
+        assert_eq!(Range::new(2, 2).min_width_1(s), Range::new(2, 3));
+        assert_eq!(Range::new(3, 3).min_width_1(s), Range::new(3, 4));
+        assert_eq!(Range::new(4, 4).min_width_1(s), Range::new(4, 6));
+        assert_eq!(Range::new(5, 5).min_width_1(s), Range::new(5, 6));
+        assert_eq!(Range::new(6, 6).min_width_1(s), Range::new(6, 6));
+
+        // Forward.
+        assert_eq!(Range::new(0, 1).min_width_1(s), Range::new(0, 1));
+        assert_eq!(Range::new(1, 2).min_width_1(s), Range::new(1, 2));
+        assert_eq!(Range::new(2, 3).min_width_1(s), Range::new(2, 3));
+        assert_eq!(Range::new(3, 4).min_width_1(s), Range::new(3, 4));
+        assert_eq!(Range::new(4, 5).min_width_1(s), Range::new(4, 5));
+        assert_eq!(Range::new(5, 6).min_width_1(s), Range::new(5, 6));
+
+        // Reverse.
+        assert_eq!(Range::new(1, 0).min_width_1(s), Range::new(1, 0));
+        assert_eq!(Range::new(2, 1).min_width_1(s), Range::new(2, 1));
+        assert_eq!(Range::new(3, 2).min_width_1(s), Range::new(3, 2));
+        assert_eq!(Range::new(4, 3).min_width_1(s), Range::new(4, 3));
+        assert_eq!(Range::new(5, 4).min_width_1(s), Range::new(5, 4));
+        assert_eq!(Range::new(6, 5).min_width_1(s), Range::new(6, 5));
+    }
+
+    #[test]
+    fn test_line_range() {
+        let r = Rope::from_str("\r\nHi\r\nthere!");
+        let s = r.slice(..);
+
+        // Zero-width ranges.
+        assert_eq!(Range::new(0, 0).line_range(s), (0, 0));
+        assert_eq!(Range::new(1, 1).line_range(s), (0, 0));
+        assert_eq!(Range::new(2, 2).line_range(s), (1, 1));
+        assert_eq!(Range::new(3, 3).line_range(s), (1, 1));
+
+        // Forward ranges.
+        assert_eq!(Range::new(0, 1).line_range(s), (0, 0));
+        assert_eq!(Range::new(0, 2).line_range(s), (0, 0));
+        assert_eq!(Range::new(0, 3).line_range(s), (0, 1));
+        assert_eq!(Range::new(1, 2).line_range(s), (0, 0));
+        assert_eq!(Range::new(2, 3).line_range(s), (1, 1));
+        assert_eq!(Range::new(3, 8).line_range(s), (1, 2));
+        assert_eq!(Range::new(0, 12).line_range(s), (0, 2));
+
+        // Reverse ranges.
+        assert_eq!(Range::new(1, 0).line_range(s), (0, 0));
+        assert_eq!(Range::new(2, 0).line_range(s), (0, 0));
+        assert_eq!(Range::new(3, 0).line_range(s), (0, 1));
+        assert_eq!(Range::new(2, 1).line_range(s), (0, 0));
+        assert_eq!(Range::new(3, 2).line_range(s), (1, 1));
+        assert_eq!(Range::new(8, 3).line_range(s), (1, 2));
+        assert_eq!(Range::new(12, 0).line_range(s), (0, 2));
+    }
+
+    #[test]
+    fn test_cursor() {
+        let r = Rope::from_str("\r\nHi\r\nthere!");
+        let s = r.slice(..);
+
+        // Zero-width ranges.
+        assert_eq!(Range::new(0, 0).cursor(s), 0);
+        assert_eq!(Range::new(2, 2).cursor(s), 2);
+        assert_eq!(Range::new(3, 3).cursor(s), 3);
+
+        // Forward ranges.
+        assert_eq!(Range::new(0, 2).cursor(s), 0);
+        assert_eq!(Range::new(0, 3).cursor(s), 2);
+        assert_eq!(Range::new(3, 6).cursor(s), 4);
+
+        // Reverse ranges.
+        assert_eq!(Range::new(2, 0).cursor(s), 0);
+        assert_eq!(Range::new(6, 2).cursor(s), 2);
+        assert_eq!(Range::new(6, 3).cursor(s), 3);
+    }
+
+    #[test]
+    fn test_put_cursor() {
+        let r = Rope::from_str("\r\nHi\r\nthere!");
+        let s = r.slice(..);
+
+        // Zero-width ranges.
+        assert_eq!(Range::new(0, 0).put_cursor(s, 0, true), Range::new(0, 2));
+        assert_eq!(Range::new(0, 0).put_cursor(s, 2, true), Range::new(0, 3));
+        assert_eq!(Range::new(2, 3).put_cursor(s, 4, true), Range::new(2, 6));
+        assert_eq!(Range::new(2, 8).put_cursor(s, 4, true), Range::new(2, 6));
+        assert_eq!(Range::new(8, 8).put_cursor(s, 4, true), Range::new(9, 4));
+
+        // Forward ranges.
+        assert_eq!(Range::new(3, 6).put_cursor(s, 0, true), Range::new(4, 0));
+        assert_eq!(Range::new(3, 6).put_cursor(s, 2, true), Range::new(4, 2));
+        assert_eq!(Range::new(3, 6).put_cursor(s, 3, true), Range::new(3, 4));
+        assert_eq!(Range::new(3, 6).put_cursor(s, 4, true), Range::new(3, 6));
+        assert_eq!(Range::new(3, 6).put_cursor(s, 6, true), Range::new(3, 7));
+        assert_eq!(Range::new(3, 6).put_cursor(s, 8, true), Range::new(3, 9));
+
+        // Reverse ranges.
+        assert_eq!(Range::new(6, 3).put_cursor(s, 0, true), Range::new(6, 0));
+        assert_eq!(Range::new(6, 3).put_cursor(s, 2, true), Range::new(6, 2));
+        assert_eq!(Range::new(6, 3).put_cursor(s, 3, true), Range::new(6, 3));
+        assert_eq!(Range::new(6, 3).put_cursor(s, 4, true), Range::new(6, 4));
+        assert_eq!(Range::new(6, 3).put_cursor(s, 6, true), Range::new(4, 7));
+        assert_eq!(Range::new(6, 3).put_cursor(s, 8, true), Range::new(4, 9));
     }
 
     #[test]
     fn test_split_on_matches() {
         use crate::regex::Regex;
 
-        let text = Rope::from("abcd efg wrs   xyz 123 456");
+        let text = Rope::from(" abcd efg wrs   xyz 123 456");
 
-        let selection = Selection::new(smallvec![Range::new(0, 8), Range::new(10, 19),], 0);
+        let selection = Selection::new(smallvec![Range::new(0, 9), Range::new(11, 20),], 0);
 
         let result = split_on_matches(text.slice(..), &selection, &Regex::new(r"\s+").unwrap());
 
         assert_eq!(
             result.ranges(),
             &[
-                Range::new(0, 3),
-                Range::new(5, 7),
-                Range::new(10, 11),
-                Range::new(15, 17),
-                Range::new(19, 19),
+                // TODO: rather than this behavior, maybe we want it
+                // to be based on which side is the anchor?
+                //
+                // We get a leading zero-width range when there's
+                // a leading match because ranges are inclusive on
+                // the left.  Imagine, for example, if the entire
+                // selection range were matched: you'd still want
+                // at least one range to remain after the split.
+                Range::new(0, 0),
+                Range::new(1, 5),
+                Range::new(6, 9),
+                Range::new(11, 13),
+                Range::new(16, 19),
+                // In contrast to the comment above, there is no
+                // _trailing_ zero-width range despite the trailing
+                // match, because ranges are exclusive on the right.
             ]
         );
 
         assert_eq!(
             result.fragments(text.slice(..)).collect::<Vec<_>>(),
-            &["abcd", "efg", "rs", "xyz", "1"]
+            &["", "abcd", "efg", "rs", "xyz"]
         );
     }
 }

helix-core/src/state.rs

@@ -1,7 +1,7 @@
 use crate::{Rope, Selection};
 
 /// A state represents the current editor state of a single buffer.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct State {
     pub doc: Rope,
     pub selection: Selection,

helix-core/src/surround.rs

@@ -0,0 +1,286 @@
+use crate::{search, Selection};
+use ropey::RopeSlice;
+
+pub const PAIRS: &[(char, char)] = &[
+    ('(', ')'),
+    ('[', ']'),
+    ('{', '}'),
+    ('<', '>'),
+    ('«', '»'),
+    ('「', '」'),
+    ('（', '）'),
+];
+
+/// Given any char in [PAIRS], return the open and closing chars. If not found in
+/// [PAIRS] return (ch, ch).
+///
+/// ```
+/// use helix_core::surround::get_pair;
+///
+/// assert_eq!(get_pair('['), ('[', ']'));
+/// assert_eq!(get_pair('}'), ('{', '}'));
+/// assert_eq!(get_pair('"'), ('"', '"'));
+/// ```
+pub fn get_pair(ch: char) -> (char, char) {
+    PAIRS
+        .iter()
+        .find(|(open, close)| *open == ch || *close == ch)
+        .copied()
+        .unwrap_or((ch, ch))
+}
+
+/// Find the position of surround pairs of `ch` which can be either a closing
+/// or opening pair. `n` will skip n - 1 pairs (eg. n=2 will discard (only)
+/// the first pair found and keep looking)
+pub fn find_nth_pairs_pos(
+    text: RopeSlice,
+    ch: char,
+    pos: usize,
+    n: usize,
+) -> Option<(usize, usize)> {
+    let (open, close) = get_pair(ch);
+
+    if text.len_chars() < 2 || pos >= text.len_chars() {
+        return None;
+    }
+
+    if open == close {
+        if Some(open) == text.get_char(pos) {
+            // Special case: cursor is directly on a matching char.
+            match pos {
+                0 => Some((pos, search::find_nth_next(text, close, pos + 1, n)?)),
+                _ if (pos + 1) == text.len_chars() => {
+                    Some((search::find_nth_prev(text, open, pos, n)?, pos))
+                }
+                // We return no match because there's no way to know which
+                // side of the char we should be searching on.
+                _ => None,
+            }
+        } else {
+            Some((
+                search::find_nth_prev(text, open, pos, n)?,
+                search::find_nth_next(text, close, pos, n)?,
+            ))
+        }
+    } else {
+        Some((
+            find_nth_open_pair(text, open, close, pos, n)?,
+            find_nth_close_pair(text, open, close, pos, n)?,
+        ))
+    }
+}
+
+fn find_nth_open_pair(
+    text: RopeSlice,
+    open: char,
+    close: char,
+    mut pos: usize,
+    n: usize,
+) -> Option<usize> {
+    let mut chars = text.chars_at(pos + 1);
+
+    // Adjusts pos for the first iteration, and handles the case of the
+    // cursor being *on* the close character which will get falsely stepped over
+    // if not skipped here
+    if chars.prev()? == open {
+        return Some(pos);
+    }
+
+    for _ in 0..n {
+        let mut step_over: usize = 0;
+
+        loop {
+            let c = chars.prev()?;
+            pos = pos.saturating_sub(1);
+
+            // ignore other surround pairs that are enclosed *within* our search scope
+            if c == close {
+                step_over += 1;
+            } else if c == open {
+                if step_over == 0 {
+                    break;
+                }
+
+                step_over = step_over.saturating_sub(1);
+            }
+        }
+    }
+
+    Some(pos)
+}
+
+fn find_nth_close_pair(
+    text: RopeSlice,
+    open: char,
+    close: char,
+    mut pos: usize,
+    n: usize,
+) -> Option<usize> {
+    if pos >= text.len_chars() {
+        return None;
+    }
+
+    let mut chars = text.chars_at(pos);
+
+    if chars.next()? == close {
+        return Some(pos);
+    }
+
+    for _ in 0..n {
+        let mut step_over: usize = 0;
+
+        loop {
+            let c = chars.next()?;
+            pos += 1;
+
+            if c == open {
+                step_over += 1;
+            } else if c == close {
+                if step_over == 0 {
+                    break;
+                }
+
+                step_over = step_over.saturating_sub(1);
+            }
+        }
+    }
+
+    Some(pos)
+}
+
+/// Find position of surround characters around every cursor. Returns None
+/// if any positions overlap. Note that the positions are in a flat Vec.
+/// Use get_surround_pos().chunks(2) to get matching pairs of surround positions.
+/// `ch` can be either closing or opening pair.
+pub fn get_surround_pos(
+    text: RopeSlice,
+    selection: &Selection,
+    ch: char,
+    skip: usize,
+) -> Option<Vec<usize>> {
+    let mut change_pos = Vec::new();
+
+    for range in selection {
+        let (open_pos, close_pos) = find_nth_pairs_pos(text, ch, range.head, skip)?;
+        if change_pos.contains(&open_pos) || change_pos.contains(&close_pos) {
+            return None;
+        }
+        change_pos.extend_from_slice(&[open_pos, close_pos]);
+    }
+    Some(change_pos)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::Range;
+
+    use ropey::Rope;
+    use smallvec::SmallVec;
+
+    #[test]
+    fn test_find_nth_pairs_pos() {
+        let doc = Rope::from("some (text) here");
+        let slice = doc.slice(..);
+
+        // cursor on [t]ext
+        assert_eq!(find_nth_pairs_pos(slice, '(', 6, 1), Some((5, 10)));
+        assert_eq!(find_nth_pairs_pos(slice, ')', 6, 1), Some((5, 10)));
+        // cursor on so[m]e
+        assert_eq!(find_nth_pairs_pos(slice, '(', 2, 1), None);
+        // cursor on bracket itself
+        assert_eq!(find_nth_pairs_pos(slice, '(', 5, 1), Some((5, 10)));
+        assert_eq!(find_nth_pairs_pos(slice, '(', 10, 1), Some((5, 10)));
+    }
+
+    #[test]
+    fn test_find_nth_pairs_pos_skip() {
+        let doc = Rope::from("(so (many (good) text) here)");
+        let slice = doc.slice(..);
+
+        // cursor on go[o]d
+        assert_eq!(find_nth_pairs_pos(slice, '(', 13, 1), Some((10, 15)));
+        assert_eq!(find_nth_pairs_pos(slice, '(', 13, 2), Some((4, 21)));
+        assert_eq!(find_nth_pairs_pos(slice, '(', 13, 3), Some((0, 27)));
+    }
+
+    #[test]
+    fn test_find_nth_pairs_pos_same() {
+        let doc = Rope::from("'so 'many 'good' text' here'");
+        let slice = doc.slice(..);
+
+        // cursor on go[o]d
+        assert_eq!(find_nth_pairs_pos(slice, '\'', 13, 1), Some((10, 15)));
+        assert_eq!(find_nth_pairs_pos(slice, '\'', 13, 2), Some((4, 21)));
+        assert_eq!(find_nth_pairs_pos(slice, '\'', 13, 3), Some((0, 27)));
+        // cursor on the quotes
+        assert_eq!(find_nth_pairs_pos(slice, '\'', 10, 1), None);
+        // this is the best we can do since opening and closing pairs are same
+        assert_eq!(find_nth_pairs_pos(slice, '\'', 0, 1), Some((0, 4)));
+        assert_eq!(find_nth_pairs_pos(slice, '\'', 27, 1), Some((21, 27)));
+    }
+
+    #[test]
+    fn test_find_nth_pairs_pos_step() {
+        let doc = Rope::from("((so)((many) good (text))(here))");
+        let slice = doc.slice(..);
+
+        // cursor on go[o]d
+        assert_eq!(find_nth_pairs_pos(slice, '(', 15, 1), Some((5, 24)));
+        assert_eq!(find_nth_pairs_pos(slice, '(', 15, 2), Some((0, 31)));
+    }
+
+    #[test]
+    fn test_find_nth_pairs_pos_mixed() {
+        let doc = Rope::from("(so [many {good} text] here)");
+        let slice = doc.slice(..);
+
+        // cursor on go[o]d
+        assert_eq!(find_nth_pairs_pos(slice, '{', 13, 1), Some((10, 15)));
+        assert_eq!(find_nth_pairs_pos(slice, '[', 13, 1), Some((4, 21)));
+        assert_eq!(find_nth_pairs_pos(slice, '(', 13, 1), Some((0, 27)));
+    }
+
+    #[test]
+    fn test_get_surround_pos() {
+        let doc = Rope::from("(some) (chars)\n(newline)");
+        let slice = doc.slice(..);
+        let selection = Selection::new(
+            SmallVec::from_slice(&[Range::point(2), Range::point(9), Range::point(20)]),
+            0,
+        );
+
+        // cursor on s[o]me, c[h]ars, newl[i]ne
+        assert_eq!(
+            get_surround_pos(slice, &selection, '(', 1)
+                .unwrap()
+                .as_slice(),
+            &[0, 5, 7, 13, 15, 23]
+        );
+    }
+
+    #[test]
+    fn test_get_surround_pos_bail() {
+        let doc = Rope::from("[some]\n(chars)xx\n(newline)");
+        let slice = doc.slice(..);
+
+        let selection =
+            Selection::new(SmallVec::from_slice(&[Range::point(2), Range::point(9)]), 0);
+
+        // cursor on s[o]me, c[h]ars
+        assert_eq!(
+            get_surround_pos(slice, &selection, '(', 1),
+            None // different surround chars
+        );
+
+        let selection = Selection::new(
+            SmallVec::from_slice(&[Range::point(14), Range::point(24)]),
+            0,
+        );
+        // cursor on [x]x, newli[n]e
+        assert_eq!(
+            get_surround_pos(slice, &selection, '(', 1),
+            None // overlapping surround chars
+        );
+    }
+}

helix-core/src/syntax.rs

@@ -1,34 +1,45 @@
-use crate::{regex::Regex, Change, Rope, RopeSlice, Transaction};
-pub use helix_syntax::{get_language, get_language_name, Lang};
+use crate::{
+    chars::char_is_line_ending,
+    regex::Regex,
+    transaction::{ChangeSet, Operation},
+    Rope, RopeSlice, Tendril,
+};
+
+pub use helix_syntax::get_language;
+
+use arc_swap::ArcSwap;
 
 use std::{
     borrow::Cow,
     cell::RefCell,
-    collections::HashMap,
-    path::{Path, PathBuf},
+    collections::{HashMap, HashSet},
+    fmt,
+    path::Path,
     sync::Arc,
 };
 
 use once_cell::sync::{Lazy, OnceCell};
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct Configuration {
     pub language: Vec<LanguageConfiguration>,
 }
 
 // largely based on tree-sitter/cli/src/loader.rs
-#[derive(Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct LanguageConfiguration {
     #[serde(rename = "name")]
-    pub(crate) language_id: Lang,
+    pub(crate) language_id: String,
     pub scope: String,           // source.rust
     pub file_types: Vec<String>, // filename ends_with? <Gemfile, rb, etc>
     pub roots: Vec<String>,      // these indicate project roots <.git, Cargo.toml>
+    pub comment_token: Option<String>,
+    pub config: Option<String>,
 
-    // pub path: PathBuf,
-    // root_path for tree-sitter (^)
+    #[serde(default)]
+    pub auto_format: bool,
 
     // content_regex
     // injection_regex
@@ -41,9 +52,12 @@ pub struct LanguageConfiguration {
     pub language_server: Option<LanguageServerConfiguration>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub indent: Option<IndentationConfiguration>,
+
+    #[serde(skip)]
+    pub(crate) indent_query: OnceCell<Option<IndentQuery>>,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct LanguageServerConfiguration {
     pub command: String,
@@ -52,23 +66,37 @@ pub struct LanguageServerConfiguration {
     pub args: Vec<String>,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct IndentationConfiguration {
     pub tab_width: usize,
     pub unit: String,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct IndentQuery {
+    #[serde(default)]
+    #[serde(skip_serializing_if = "HashSet::is_empty")]
+    pub indent: HashSet<String>,
+    #[serde(default)]
+    #[serde(skip_serializing_if = "HashSet::is_empty")]
+    pub outdent: HashSet<String>,
+}
+
+fn load_runtime_file(language: &str, filename: &str) -> Result<String, std::io::Error> {
+    let path = crate::RUNTIME_DIR
+        .join("queries")
+        .join(language)
+        .join(filename);
+    std::fs::read_to_string(&path)
+}
+
 fn read_query(language: &str, filename: &str) -> String {
     static INHERITS_REGEX: Lazy<Regex> =
         Lazy::new(|| Regex::new(r";+\s*inherits\s*:?\s*([a-z_,()]+)\s*").unwrap());
 
-    let root = crate::runtime_dir();
-    // let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-
-    let path = root.join("queries").join(language).join(filename);
-
-    let query = std::fs::read_to_string(&path).unwrap_or_default();
+    let query = load_runtime_file(language, filename).unwrap_or_default();
 
     // TODO: the collect() is not ideal
     let inherits = INHERITS_REGEX
@@ -96,44 +124,66 @@ fn read_query(language: &str, filename: &str) -> String {
 }
 
 impl LanguageConfiguration {
+    fn initialize_highlight(&self, scopes: &[String]) -> Option<Arc<HighlightConfiguration>> {
+        let language = self.language_id.to_ascii_lowercase();
+
+        let highlights_query = read_query(&language, "highlights.scm");
+        // always highlight syntax errors
+        // highlights_query += "\n(ERROR) @error";
+
+        let injections_query = read_query(&language, "injections.scm");
+
+        let locals_query = read_query(&language, "locals.scm");
+
+        if highlights_query.is_empty() {
+            None
+        } else {
+            let language = get_language(&crate::RUNTIME_DIR, &self.language_id).ok()?;
+            let config = HighlightConfiguration::new(
+                language,
+                &highlights_query,
+                &injections_query,
+                &locals_query,
+            )
+            .unwrap(); // TODO: no unwrap
+            config.configure(scopes);
+            Some(Arc::new(config))
+        }
+    }
+
+    pub fn reconfigure(&self, scopes: &[String]) {
+        if let Some(Some(config)) = self.highlight_config.get() {
+            config.configure(scopes);
+        }
+    }
+
     pub fn highlight_config(&self, scopes: &[String]) -> Option<Arc<HighlightConfiguration>> {
         self.highlight_config
-            .get_or_init(|| {
-                let language = get_language_name(self.language_id).to_ascii_lowercase();
-
-                let highlights_query = read_query(&language, "highlights.scm");
-                // always highlight syntax errors
-                // highlights_query += "\n(ERROR) @error";
-
-                let injections_query = read_query(&language, "injections.scm");
-
-                let locals_query = "";
-
-                if highlights_query.is_empty() {
-                    None
-                } else {
-                    let language = get_language(self.language_id);
-                    let mut config = HighlightConfiguration::new(
-                        language,
-                        &highlights_query,
-                        &injections_query,
-                        locals_query,
-                    )
-                    .unwrap(); // TODO: no unwrap
-                    config.configure(scopes);
-                    Some(Arc::new(config))
-                }
-            })
+            .get_or_init(|| self.initialize_highlight(scopes))
             .clone()
     }
 
+    pub fn is_highlight_initialized(&self) -> bool {
+        self.highlight_config.get().is_some()
+    }
+
+    pub fn indent_query(&self) -> Option<&IndentQuery> {
+        self.indent_query
+            .get_or_init(|| {
+                let language = self.language_id.to_ascii_lowercase();
+
+                let toml = load_runtime_file(&language, "indents.toml").ok()?;
+                toml::from_slice(toml.as_bytes()).ok()
+            })
+            .as_ref()
+    }
+
     pub fn scope(&self) -> &str {
         &self.scope
     }
 }
 
-pub static LOADER: OnceCell<Loader> = OnceCell::new();
-
+#[derive(Debug)]
 pub struct Loader {
     // highlight_names ?
     language_configs: Vec<Arc<LanguageConfiguration>>,
@@ -188,6 +238,10 @@ impl Loader {
             .find(|config| config.scope == scope)
             .cloned()
     }
+
+    pub fn language_configs_iter(&self) -> impl Iterator<Item = &Arc<LanguageConfiguration>> {
+        self.language_configs.iter()
+    }
 }
 
 pub struct TsParser {
@@ -195,6 +249,12 @@ pub struct TsParser {
     cursors: Vec<QueryCursor>,
 }
 
+impl fmt::Debug for TsParser {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TsParser").finish()
+    }
+}
+
 // could also just use a pool, or a single instance?
 thread_local! {
     pub static PARSER: RefCell<TsParser> = RefCell::new(TsParser {
@@ -203,6 +263,7 @@ thread_local! {
     })
 }
 
+#[derive(Debug)]
 pub struct Syntax {
     config: Arc<HighlightConfiguration>,
 
@@ -244,7 +305,8 @@ impl Syntax {
 
         // update root layer
         PARSER.with(|ts_parser| {
-            syntax.root_layer.parse(
+            // TODO: handle the returned `Result` properly.
+            let _ = syntax.root_layer.parse(
                 &mut ts_parser.borrow_mut(),
                 &syntax.config,
                 source,
@@ -299,13 +361,17 @@ impl Syntax {
         source: RopeSlice<'a>,
         range: Option<std::ops::Range<usize>>,
         cancellation_flag: Option<&'a AtomicUsize>,
-        mut injection_callback: impl FnMut(&str) -> Option<&'a HighlightConfiguration> + 'a,
+        injection_callback: impl FnMut(&str) -> Option<&'a HighlightConfiguration> + 'a,
     ) -> impl Iterator<Item = Result<HighlightEvent, Error>> + 'a {
         // The `captures` iterator borrows the `Tree` and the `QueryCursor`, which
         // prevents them from being moved. But both of these values are really just
         // pointers, so it's actually ok to move them.
 
-        let mut cursor = QueryCursor::new(); // reuse a pool
+        // reuse a cursor from the pool if possible
+        let mut cursor = PARSER.with(|ts_parser| {
+            let highlighter = &mut ts_parser.borrow_mut();
+            highlighter.cursors.pop().unwrap_or_else(QueryCursor::new)
+        });
         let tree_ref = unsafe { mem::transmute::<_, &'static Tree>(self.tree()) };
         let cursor_ref = unsafe { mem::transmute::<_, &'static mut QueryCursor>(&mut cursor) };
         let query_ref = unsafe { mem::transmute::<_, &'static Query>(&self.config.query) };
@@ -379,6 +445,7 @@ impl Syntax {
     // buffer_range_for_scope_at_pos
 }
 
+#[derive(Debug)]
 pub struct LanguageLayer {
     // mode
     // grammar
@@ -386,12 +453,6 @@ pub struct LanguageLayer {
     pub(crate) tree: Option<Tree>,
 }
 
-use crate::{
-    coords_at_pos,
-    transaction::{ChangeSet, Operation},
-    Tendril,
-};
-
 impl LanguageLayer {
     // pub fn new() -> Self {
     //     Self { tree: None }
@@ -407,8 +468,8 @@ impl LanguageLayer {
         ts_parser: &mut TsParser,
         config: &HighlightConfiguration,
         source: &Rope,
-        mut depth: usize,
-        mut ranges: Vec<Range>,
+        _depth: usize,
+        ranges: Vec<Range>,
     ) -> Result<(), Error> {
         if ts_parser.parser.set_included_ranges(&ranges).is_ok() {
             ts_parser
@@ -479,7 +540,6 @@ impl LanguageLayer {
     ) -> Vec<tree_sitter::InputEdit> {
         use Operation::*;
         let mut old_pos = 0;
-        let mut new_pos = 0;
 
         let mut edits = Vec::new();
 
@@ -502,9 +562,10 @@ impl LanguageLayer {
                 mut column,
             } = point;
 
-            // TODO: there should be a better way here
-            for ch in text.bytes() {
-                if ch == b'\n' {
+            // TODO: there should be a better way here.
+            let mut chars = text.chars().peekable();
+            while let Some(ch) = chars.next() {
+                if char_is_line_ending(ch) && !(ch == '\r' && chars.peek() == Some(&'\n')) {
                     row += 1;
                     column = 0;
                 } else {
@@ -522,9 +583,7 @@ impl LanguageLayer {
             let mut old_end = old_pos + len;
 
             match change {
-                Retain(_) => {
-                    new_pos += len;
-                }
+                Retain(_) => {}
                 Delete(_) => {
                     let (start_byte, start_position) = point_at_pos(old_text, old_pos);
                     let (old_end_byte, old_end_position) = point_at_pos(old_text, old_end);
@@ -548,8 +607,6 @@ impl LanguageLayer {
                 Insert(s) => {
                     let (start_byte, start_position) = point_at_pos(old_text, old_pos);
 
-                    let ins = s.chars().count();
-
                     // a subsequent delete means a replace, consume it
                     if let Some(Delete(len)) = iter.peek() {
                         old_end = old_pos + len;
@@ -577,8 +634,6 @@ impl LanguageLayer {
                             new_end_position: traverse(start_position, s), // old pos + chars, newlines matter too (iter over)
                         });
                     }
-
-                    new_pos += ins;
                 }
             }
             old_pos = old_end;
@@ -601,8 +656,10 @@ impl LanguageLayer {
         let edits = Self::generate_edits(old_source.slice(..), changeset);
 
         // Notify the tree about all the changes
-        for edit in edits {
-            self.tree.as_mut().unwrap().edit(&edit);
+        for edit in edits.iter().rev() {
+            // apply the edits in reverse. If we applied them in order then edit 1 would disrupt
+            // the positioning of edit 2
+            self.tree.as_mut().unwrap().edit(edit);
         }
 
         self.parse(
@@ -687,13 +744,14 @@ pub enum HighlightEvent {
 /// Contains the data neeeded to higlight code written in a particular language.
 ///
 /// This struct is immutable and can be shared between threads.
+#[derive(Debug)]
 pub struct HighlightConfiguration {
     pub language: Grammar,
     pub query: Query,
     combined_injections_query: Option<Query>,
     locals_pattern_index: usize,
     highlights_pattern_index: usize,
-    highlight_indices: Vec<Option<Highlight>>,
+    highlight_indices: ArcSwap<Vec<Option<Highlight>>>,
     non_local_variable_patterns: Vec<bool>,
     injection_content_capture_index: Option<u32>,
     injection_language_capture_index: Option<u32>,
@@ -717,7 +775,8 @@ struct LocalScope<'a> {
     local_defs: Vec<LocalDef<'a>>,
 }
 
-struct HighlightIter<'a, F>
+#[derive(Debug)]
+struct HighlightIter<'a, 'tree: 'a, F>
 where
     F: FnMut(&str) -> Option<&'a HighlightConfiguration> + 'a,
 {
@@ -725,16 +784,16 @@ where
     byte_offset: usize,
     injection_callback: F,
     cancellation_flag: Option<&'a AtomicUsize>,
-    layers: Vec<HighlightIterLayer<'a>>,
+    layers: Vec<HighlightIterLayer<'a, 'tree>>,
     iter_count: usize,
     next_event: Option<HighlightEvent>,
     last_highlight_range: Option<(usize, usize, usize)>,
 }
 
-struct HighlightIterLayer<'a> {
+struct HighlightIterLayer<'a, 'tree: 'a> {
     _tree: Option<Tree>,
     cursor: QueryCursor,
-    captures: iter::Peekable<QueryCaptures<'a, Cow<'a, [u8]>>>,
+    captures: iter::Peekable<QueryCaptures<'a, 'tree, Cow<'a, [u8]>>>,
     config: &'a HighlightConfiguration,
     highlight_end_stack: Vec<usize>,
     scope_stack: Vec<LocalScope<'a>>,
@@ -742,6 +801,12 @@ struct HighlightIterLayer<'a> {
     depth: usize,
 }
 
+impl<'a, 'tree: 'a> fmt::Debug for HighlightIterLayer<'a, 'tree> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("HighlightIterLayer").finish()
+    }
+}
+
 impl HighlightConfiguration {
     /// Creates a `HighlightConfiguration` for a given `Grammar` and set of highlighting
     /// queries.
@@ -838,7 +903,7 @@ impl HighlightConfiguration {
             }
         }
 
-        let highlight_indices = vec![None; query.capture_names().len()];
+        let highlight_indices = ArcSwap::from_pointee(vec![None; query.capture_names().len()]);
         Ok(Self {
             language,
             query,
@@ -871,17 +936,20 @@ impl HighlightConfiguration {
     ///
     /// When highlighting, results are returned as `Highlight` values, which contain the index
     /// of the matched highlight this list of highlight names.
-    pub fn configure(&mut self, recognized_names: &[String]) {
+    pub fn configure(&self, recognized_names: &[String]) {
         let mut capture_parts = Vec::new();
-        self.highlight_indices.clear();
-        self.highlight_indices
-            .extend(self.query.capture_names().iter().map(move |capture_name| {
+        let indices: Vec<_> = self
+            .query
+            .capture_names()
+            .iter()
+            .map(move |capture_name| {
                 capture_parts.clear();
                 capture_parts.extend(capture_name.split('.'));
 
                 let mut best_index = None;
                 let mut best_match_len = 0;
                 for (i, recognized_name) in recognized_names.iter().enumerate() {
+                    let recognized_name = recognized_name;
                     let mut len = 0;
                     let mut matches = true;
                     for part in recognized_name.split('.') {
@@ -897,11 +965,14 @@ impl HighlightConfiguration {
                     }
                 }
                 best_index.map(Highlight)
-            }));
+            })
+            .collect();
+
+        self.highlight_indices.store(Arc::new(indices));
     }
 }
 
-impl<'a> HighlightIterLayer<'a> {
+impl<'a, 'tree: 'a> HighlightIterLayer<'a, 'tree> {
     /// Create a new 'layer' of highlighting for this document.
     ///
     /// In the even that the new layer contains "combined injections" (injections where multiple
@@ -1165,7 +1236,7 @@ impl<'a> HighlightIterLayer<'a> {
     }
 }
 
-impl<'a, F> HighlightIter<'a, F>
+impl<'a, 'tree: 'a, F> HighlightIter<'a, 'tree, F>
 where
     F: FnMut(&str) -> Option<&'a HighlightConfiguration> + 'a,
 {
@@ -1216,7 +1287,7 @@ where
         }
     }
 
-    fn insert_layer(&mut self, mut layer: HighlightIterLayer<'a>) {
+    fn insert_layer(&mut self, mut layer: HighlightIterLayer<'a, 'tree>) {
         if let Some(sort_key) = layer.sort_key() {
             let mut i = 1;
             while i < self.layers.len() {
@@ -1235,7 +1306,7 @@ where
     }
 }
 
-impl<'a, F> Iterator for HighlightIter<'a, F>
+impl<'a, 'tree: 'a, F> Iterator for HighlightIter<'a, 'tree, F>
 where
     F: FnMut(&str) -> Option<&'a HighlightConfiguration> + 'a,
 {
@@ -1378,7 +1449,6 @@ where
                 // local scope at the top of the scope stack.
                 else if Some(capture.index) == layer.config.local_def_capture_index {
                     reference_highlight = None;
-                    definition_highlight = None;
                     let scope = layer.scope_stack.last_mut().unwrap();
 
                     let mut value_range = 0..0;
@@ -1476,7 +1546,7 @@ where
                 }
             }
 
-            let current_highlight = layer.config.highlight_indices[capture.index as usize];
+            let current_highlight = layer.config.highlight_indices.load()[capture.index as usize];
 
             // If this node represents a local definition, then store the current
             // highlight value on the local scope entry representing this node.
@@ -1542,133 +1612,283 @@ fn injection_for_match<'a>(
     (language_name, content_node, include_children)
 }
 
-fn shrink_and_clear<T>(vec: &mut Vec<T>, capacity: usize) {
-    if vec.len() > capacity {
-        vec.truncate(capacity);
-        vec.shrink_to_fit();
-    }
-    vec.clear();
+// fn shrink_and_clear<T>(vec: &mut Vec<T>, capacity: usize) {
+//     if vec.len() > capacity {
+//         vec.truncate(capacity);
+//         vec.shrink_to_fit();
+//     }
+//     vec.clear();
+// }
+
+pub struct Merge<I> {
+    iter: I,
+    spans: Box<dyn Iterator<Item = (usize, std::ops::Range<usize>)>>,
+
+    next_event: Option<HighlightEvent>,
+    next_span: Option<(usize, std::ops::Range<usize>)>,
+
+    queue: Vec<HighlightEvent>,
 }
 
-#[test]
-fn test_parser() {
-    let highlight_names: Vec<String> = [
-        "attribute",
-        "constant",
-        "function.builtin",
-        "function",
-        "keyword",
-        "operator",
-        "property",
-        "punctuation",
-        "punctuation.bracket",
-        "punctuation.delimiter",
-        "string",
-        "string.special",
-        "tag",
-        "type",
-        "type.builtin",
-        "variable",
-        "variable.builtin",
-        "variable.parameter",
-    ]
-    .iter()
-    .cloned()
-    .map(String::from)
-    .collect();
-
-    let language = get_language(Lang::Rust);
-    let mut config = HighlightConfiguration::new(
-        language,
-        &std::fs::read_to_string(
-            "../helix-syntax/languages/tree-sitter-rust/queries/highlights.scm",
-        )
-        .unwrap(),
-        &std::fs::read_to_string(
-            "../helix-syntax/languages/tree-sitter-rust/queries/injections.scm",
-        )
-        .unwrap(),
-        "", // locals.scm
-    )
-    .unwrap();
-    config.configure(&highlight_names);
-
-    let source = Rope::from_str(
-        "
-        struct Stuff {}
-        fn main() {}
-    ",
-    );
-    let syntax = Syntax::new(&source, Arc::new(config));
-    let tree = syntax.tree();
-    let root = tree.root_node();
-    assert_eq!(root.kind(), "source_file");
-
-    assert_eq!(
-        root.to_sexp(),
-        concat!(
-            "(source_file ",
-            "(struct_item name: (type_identifier) body: (field_declaration_list)) ",
-            "(function_item name: (identifier) parameters: (parameters) body: (block)))"
-        )
-    );
-
-    let struct_node = root.child(0).unwrap();
-    assert_eq!(struct_node.kind(), "struct_item");
+/// Merge a list of spans into the highlight event stream.
+pub fn merge<I: Iterator<Item = HighlightEvent>>(
+    iter: I,
+    spans: Vec<(usize, std::ops::Range<usize>)>,
+) -> Merge<I> {
+    let spans = Box::new(spans.into_iter());
+    let mut merge = Merge {
+        iter,
+        spans,
+        next_event: None,
+        next_span: None,
+        queue: Vec::new(),
+    };
+    merge.next_event = merge.iter.next();
+    merge.next_span = merge.spans.next();
+    merge
 }
 
-#[test]
-fn test_input_edits() {
-    use crate::State;
-    use tree_sitter::InputEdit;
+impl<I: Iterator<Item = HighlightEvent>> Iterator for Merge<I> {
+    type Item = HighlightEvent;
+    fn next(&mut self) -> Option<Self::Item> {
+        use HighlightEvent::*;
+        if let Some(event) = self.queue.pop() {
+            return Some(event);
+        }
 
-    let mut state = State::new("hello world!\ntest 123".into());
-    let transaction = Transaction::change(
-        &state.doc,
-        vec![(6, 11, Some("test".into())), (12, 17, None)].into_iter(),
-    );
-    let edits = LanguageLayer::generate_edits(state.doc.slice(..), transaction.changes());
-    // transaction.apply(&mut state);
-
-    assert_eq!(
-        edits,
-        &[
-            InputEdit {
-                start_byte: 6,
-                old_end_byte: 11,
-                new_end_byte: 10,
-                start_position: Point { row: 0, column: 6 },
-                old_end_position: Point { row: 0, column: 11 },
-                new_end_position: Point { row: 0, column: 10 }
-            },
-            InputEdit {
-                start_byte: 12,
-                old_end_byte: 17,
-                new_end_byte: 12,
-                start_position: Point { row: 0, column: 12 },
-                old_end_position: Point { row: 1, column: 4 },
-                new_end_position: Point { row: 0, column: 12 }
+        loop {
+            match (self.next_event, &self.next_span) {
+                // this happens when range is partially or fully offscreen
+                (Some(Source { start, .. }), Some((span, range))) if start > range.start => {
+                    if start > range.end {
+                        self.next_span = self.spans.next();
+                    } else {
+                        self.next_span = Some((*span, start..range.end));
+                    };
+                }
+                _ => break,
             }
-        ]
-    );
+        }
 
-    // Testing with the official example from tree-sitter
-    let mut state = State::new("fn test() {}".into());
-    let transaction =
-        Transaction::change(&state.doc, vec![(8, 8, Some("a: u32".into()))].into_iter());
-    let edits = LanguageLayer::generate_edits(state.doc.slice(..), transaction.changes());
-    transaction.apply(&mut state.doc);
+        match (self.next_event, &self.next_span) {
+            (Some(HighlightStart(i)), _) => {
+                self.next_event = self.iter.next();
+                Some(HighlightStart(i))
+            }
+            (Some(HighlightEnd), _) => {
+                self.next_event = self.iter.next();
+                Some(HighlightEnd)
+            }
+            (Some(Source { start, end }), Some((_, range))) if start < range.start => {
+                let intersect = range.start.min(end);
+                let event = Source {
+                    start,
+                    end: intersect,
+                };
 
-    assert_eq!(state.doc, "fn test(a: u32) {}");
-    assert_eq!(
-        edits,
-        &[InputEdit {
-            start_byte: 8,
-            old_end_byte: 8,
-            new_end_byte: 14,
-            start_position: Point { row: 0, column: 8 },
-            old_end_position: Point { row: 0, column: 8 },
-            new_end_position: Point { row: 0, column: 14 }
-        }]
-    );
+                if end == intersect {
+                    // the event is complete
+                    self.next_event = self.iter.next();
+                } else {
+                    // subslice the event
+                    self.next_event = Some(Source {
+                        start: intersect,
+                        end,
+                    });
+                };
+
+                Some(event)
+            }
+            (Some(Source { start, end }), Some((span, range))) if start == range.start => {
+                let intersect = range.end.min(end);
+                let event = HighlightStart(Highlight(*span));
+
+                // enqueue in reverse order
+                self.queue.push(HighlightEnd);
+                self.queue.push(Source {
+                    start,
+                    end: intersect,
+                });
+
+                if end == intersect {
+                    // the event is complete
+                    self.next_event = self.iter.next();
+                } else {
+                    // subslice the event
+                    self.next_event = Some(Source {
+                        start: intersect,
+                        end,
+                    });
+                };
+
+                if intersect == range.end {
+                    self.next_span = self.spans.next();
+                } else {
+                    self.next_span = Some((*span, intersect..range.end));
+                }
+
+                Some(event)
+            }
+            (Some(event), None) => {
+                self.next_event = self.iter.next();
+                Some(event)
+            }
+            // Can happen if cursor at EOF and/or diagnostic reaches past the end.
+            // We need to actually emit events for the cursor-at-EOF situation,
+            // even though the range is past the end of the text.  This needs to be
+            // handled appropriately by the drawing code by not assuming that
+            // all `Source` events point to valid indices in the rope.
+            (None, Some((span, range))) => {
+                let event = HighlightStart(Highlight(*span));
+                self.queue.push(HighlightEnd);
+                self.queue.push(Source {
+                    start: range.start,
+                    end: range.end,
+                });
+                self.next_span = self.spans.next();
+                Some(event)
+            }
+            (None, None) => None,
+            e => unreachable!("{:?}", e),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::{Rope, Transaction};
+
+    #[test]
+    fn test_parser() {
+        let highlight_names: Vec<String> = [
+            "attribute",
+            "constant",
+            "function.builtin",
+            "function",
+            "keyword",
+            "operator",
+            "property",
+            "punctuation",
+            "punctuation.bracket",
+            "punctuation.delimiter",
+            "string",
+            "string.special",
+            "tag",
+            "type",
+            "type.builtin",
+            "variable",
+            "variable.builtin",
+            "variable.parameter",
+        ]
+        .iter()
+        .cloned()
+        .map(String::from)
+        .collect();
+
+        let language = get_language(&crate::RUNTIME_DIR, "Rust").unwrap();
+        let config = HighlightConfiguration::new(
+            language,
+            &std::fs::read_to_string(
+                "../helix-syntax/languages/tree-sitter-rust/queries/highlights.scm",
+            )
+            .unwrap(),
+            &std::fs::read_to_string(
+                "../helix-syntax/languages/tree-sitter-rust/queries/injections.scm",
+            )
+            .unwrap(),
+            "", // locals.scm
+        )
+        .unwrap();
+        config.configure(&highlight_names);
+
+        let source = Rope::from_str(
+            "
+            struct Stuff {}
+            fn main() {}
+        ",
+        );
+        let syntax = Syntax::new(&source, Arc::new(config));
+        let tree = syntax.tree();
+        let root = tree.root_node();
+        assert_eq!(root.kind(), "source_file");
+
+        assert_eq!(
+            root.to_sexp(),
+            concat!(
+                "(source_file ",
+                "(struct_item name: (type_identifier) body: (field_declaration_list)) ",
+                "(function_item name: (identifier) parameters: (parameters) body: (block)))"
+            )
+        );
+
+        let struct_node = root.child(0).unwrap();
+        assert_eq!(struct_node.kind(), "struct_item");
+    }
+
+    #[test]
+    fn test_input_edits() {
+        use crate::State;
+        use tree_sitter::InputEdit;
+
+        let state = State::new("hello world!\ntest 123".into());
+        let transaction = Transaction::change(
+            &state.doc,
+            vec![(6, 11, Some("test".into())), (12, 17, None)].into_iter(),
+        );
+        let edits = LanguageLayer::generate_edits(state.doc.slice(..), transaction.changes());
+        // transaction.apply(&mut state);
+
+        assert_eq!(
+            edits,
+            &[
+                InputEdit {
+                    start_byte: 6,
+                    old_end_byte: 11,
+                    new_end_byte: 10,
+                    start_position: Point { row: 0, column: 6 },
+                    old_end_position: Point { row: 0, column: 11 },
+                    new_end_position: Point { row: 0, column: 10 }
+                },
+                InputEdit {
+                    start_byte: 12,
+                    old_end_byte: 17,
+                    new_end_byte: 12,
+                    start_position: Point { row: 0, column: 12 },
+                    old_end_position: Point { row: 1, column: 4 },
+                    new_end_position: Point { row: 0, column: 12 }
+                }
+            ]
+        );
+
+        // Testing with the official example from tree-sitter
+        let mut state = State::new("fn test() {}".into());
+        let transaction =
+            Transaction::change(&state.doc, vec![(8, 8, Some("a: u32".into()))].into_iter());
+        let edits = LanguageLayer::generate_edits(state.doc.slice(..), transaction.changes());
+        transaction.apply(&mut state.doc);
+
+        assert_eq!(state.doc, "fn test(a: u32) {}");
+        assert_eq!(
+            edits,
+            &[InputEdit {
+                start_byte: 8,
+                old_end_byte: 8,
+                new_end_byte: 14,
+                start_position: Point { row: 0, column: 8 },
+                old_end_position: Point { row: 0, column: 8 },
+                new_end_position: Point { row: 0, column: 14 }
+            }]
+        );
+    }
+
+    #[test]
+    fn test_load_runtime_file() {
+        // Test to make sure we can load some data from the runtime directory.
+        let contents = load_runtime_file("rust", "indents.toml").unwrap();
+        assert!(!contents.is_empty());
+
+        let results = load_runtime_file("rust", "does-not-exist");
+        assert!(results.is_err());
+    }
 }

helix-core/src/textobject.rs

@@ -0,0 +1,321 @@
+use ropey::RopeSlice;
+
+use crate::chars::{categorize_char, char_is_whitespace, CharCategory};
+use crate::graphemes::next_grapheme_boundary;
+use crate::movement::Direction;
+use crate::surround;
+use crate::Range;
+
+fn find_word_boundary(slice: RopeSlice, mut pos: usize, direction: Direction) -> usize {
+    use CharCategory::{Eol, Whitespace};
+
+    let iter = match direction {
+        Direction::Forward => slice.chars_at(pos),
+        Direction::Backward => {
+            let mut iter = slice.chars_at(pos);
+            iter.reverse();
+            iter
+        }
+    };
+
+    let mut prev_category = match direction {
+        Direction::Forward if pos == 0 => Whitespace,
+        Direction::Forward => categorize_char(slice.char(pos - 1)),
+        Direction::Backward if pos == slice.len_chars() => Whitespace,
+        Direction::Backward => categorize_char(slice.char(pos)),
+    };
+
+    for ch in iter {
+        match categorize_char(ch) {
+            Eol | Whitespace => return pos,
+            category => {
+                if category != prev_category && pos != 0 && pos != slice.len_chars() {
+                    return pos;
+                } else {
+                    match direction {
+                        Direction::Forward => pos += 1,
+                        Direction::Backward => pos = pos.saturating_sub(1),
+                    }
+                    prev_category = category;
+                }
+            }
+        }
+    }
+
+    pos
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum TextObject {
+    Around,
+    Inside,
+}
+
+// count doesn't do anything yet
+pub fn textobject_word(
+    slice: RopeSlice,
+    range: Range,
+    textobject: TextObject,
+    _count: usize,
+) -> Range {
+    let pos = range.cursor(slice);
+
+    let word_start = find_word_boundary(slice, pos, Direction::Backward);
+    let word_end = match slice.get_char(pos).map(categorize_char) {
+        None | Some(CharCategory::Whitespace | CharCategory::Eol) => pos,
+        _ => find_word_boundary(slice, pos + 1, Direction::Forward),
+    };
+
+    // Special case.
+    if word_start == word_end {
+        return Range::new(word_start, word_end);
+    }
+
+    match textobject {
+        TextObject::Inside => Range::new(word_start, word_end),
+        TextObject::Around => {
+            let whitespace_count_right = slice
+                .chars_at(word_end)
+                .take_while(|c| char_is_whitespace(*c))
+                .count();
+
+            if whitespace_count_right > 0 {
+                Range::new(word_start, word_end + whitespace_count_right)
+            } else {
+                let whitespace_count_left = {
+                    let mut iter = slice.chars_at(word_start);
+                    iter.reverse();
+                    iter.take_while(|c| char_is_whitespace(*c)).count()
+                };
+                Range::new(word_start - whitespace_count_left, word_end)
+            }
+        }
+    }
+}
+
+pub fn textobject_surround(
+    slice: RopeSlice,
+    range: Range,
+    textobject: TextObject,
+    ch: char,
+    count: usize,
+) -> Range {
+    surround::find_nth_pairs_pos(slice, ch, range.head, count)
+        .map(|(anchor, head)| match textobject {
+            TextObject::Inside => Range::new(next_grapheme_boundary(slice, anchor), head),
+            TextObject::Around => Range::new(anchor, next_grapheme_boundary(slice, head)),
+        })
+        .unwrap_or(range)
+}
+
+#[cfg(test)]
+mod test {
+    use super::TextObject::*;
+    use super::*;
+
+    use crate::Range;
+    use ropey::Rope;
+
+    #[test]
+    fn test_textobject_word() {
+        // (text, [(cursor position, textobject, final range), ...])
+        let tests = &[
+            (
+                "cursor at beginning of doc",
+                vec![(0, Inside, (0, 6)), (0, Around, (0, 7))],
+            ),
+            (
+                "cursor at middle of word",
+                vec![
+                    (13, Inside, (10, 16)),
+                    (10, Inside, (10, 16)),
+                    (15, Inside, (10, 16)),
+                    (13, Around, (10, 17)),
+                    (10, Around, (10, 17)),
+                    (15, Around, (10, 17)),
+                ],
+            ),
+            (
+                "cursor between word whitespace",
+                vec![(6, Inside, (6, 6)), (6, Around, (6, 6))],
+            ),
+            (
+                "cursor on word before newline\n",
+                vec![
+                    (22, Inside, (22, 29)),
+                    (28, Inside, (22, 29)),
+                    (25, Inside, (22, 29)),
+                    (22, Around, (21, 29)),
+                    (28, Around, (21, 29)),
+                    (25, Around, (21, 29)),
+                ],
+            ),
+            (
+                "cursor on newline\nnext line",
+                vec![(17, Inside, (17, 17)), (17, Around, (17, 17))],
+            ),
+            (
+                "cursor on word after newline\nnext line",
+                vec![
+                    (29, Inside, (29, 33)),
+                    (30, Inside, (29, 33)),
+                    (32, Inside, (29, 33)),
+                    (29, Around, (29, 34)),
+                    (30, Around, (29, 34)),
+                    (32, Around, (29, 34)),
+                ],
+            ),
+            (
+                "cursor on #$%:;* punctuation",
+                vec![
+                    (13, Inside, (10, 16)),
+                    (10, Inside, (10, 16)),
+                    (15, Inside, (10, 16)),
+                    (13, Around, (10, 17)),
+                    (10, Around, (10, 17)),
+                    (15, Around, (10, 17)),
+                ],
+            ),
+            (
+                "cursor on punc%^#$:;.tuation",
+                vec![
+                    (14, Inside, (14, 21)),
+                    (20, Inside, (14, 21)),
+                    (17, Inside, (14, 21)),
+                    (14, Around, (14, 21)),
+                    (20, Around, (14, 21)),
+                    (17, Around, (14, 21)),
+                ],
+            ),
+            (
+                "cursor in   extra whitespace",
+                vec![
+                    (9, Inside, (9, 9)),
+                    (10, Inside, (10, 10)),
+                    (11, Inside, (11, 11)),
+                    (9, Around, (9, 9)),
+                    (10, Around, (10, 10)),
+                    (11, Around, (11, 11)),
+                ],
+            ),
+            (
+                "cursor on word   with extra whitespace",
+                vec![(11, Inside, (10, 14)), (11, Around, (10, 17))],
+            ),
+            (
+                "cursor at end with extra   whitespace",
+                vec![(28, Inside, (27, 37)), (28, Around, (24, 37))],
+            ),
+            (
+                "cursor at end of doc",
+                vec![(19, Inside, (17, 20)), (19, Around, (16, 20))],
+            ),
+        ];
+
+        for (sample, scenario) in tests {
+            let doc = Rope::from(*sample);
+            let slice = doc.slice(..);
+            for &case in scenario {
+                let (pos, objtype, expected_range) = case;
+                let result = textobject_word(slice, Range::point(pos), objtype, 1);
+                assert_eq!(
+                    result,
+                    expected_range.into(),
+                    "\nCase failed: {:?} - {:?}",
+                    sample,
+                    case
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn test_textobject_surround() {
+        // (text, [(cursor position, textobject, final range, count), ...])
+        let tests = &[
+            (
+                "simple (single) surround pairs",
+                vec![
+                    (3, Inside, (3, 3), '(', 1),
+                    (7, Inside, (8, 14), ')', 1),
+                    (10, Inside, (8, 14), '(', 1),
+                    (14, Inside, (8, 14), ')', 1),
+                    (3, Around, (3, 3), '(', 1),
+                    (7, Around, (7, 15), ')', 1),
+                    (10, Around, (7, 15), '(', 1),
+                    (14, Around, (7, 15), ')', 1),
+                ],
+            ),
+            (
+                "samexx 'single' surround pairs",
+                vec![
+                    (3, Inside, (3, 3), '\'', 1),
+                    (7, Inside, (7, 7), '\'', 1),
+                    (10, Inside, (8, 14), '\'', 1),
+                    (14, Inside, (14, 14), '\'', 1),
+                    (3, Around, (3, 3), '\'', 1),
+                    (7, Around, (7, 7), '\'', 1),
+                    (10, Around, (7, 15), '\'', 1),
+                    (14, Around, (14, 14), '\'', 1),
+                ],
+            ),
+            (
+                "(nested (surround (pairs)) 3 levels)",
+                vec![
+                    (0, Inside, (1, 35), '(', 1),
+                    (6, Inside, (1, 35), ')', 1),
+                    (8, Inside, (9, 25), '(', 1),
+                    (8, Inside, (9, 35), ')', 2),
+                    (20, Inside, (9, 25), '(', 2),
+                    (20, Inside, (1, 35), ')', 3),
+                    (0, Around, (0, 36), '(', 1),
+                    (6, Around, (0, 36), ')', 1),
+                    (8, Around, (8, 26), '(', 1),
+                    (8, Around, (8, 36), ')', 2),
+                    (20, Around, (8, 26), '(', 2),
+                    (20, Around, (0, 36), ')', 3),
+                ],
+            ),
+            (
+                "(mixed {surround [pair] same} line)",
+                vec![
+                    (2, Inside, (1, 34), '(', 1),
+                    (9, Inside, (8, 28), '{', 1),
+                    (18, Inside, (18, 22), '[', 1),
+                    (2, Around, (0, 35), '(', 1),
+                    (9, Around, (7, 29), '{', 1),
+                    (18, Around, (17, 23), '[', 1),
+                ],
+            ),
+            (
+                "(stepped (surround) pairs (should) skip)",
+                vec![(22, Inside, (1, 39), '(', 1), (22, Around, (0, 40), '(', 1)],
+            ),
+            (
+                "[surround pairs{\non different]\nlines}",
+                vec![
+                    (7, Inside, (1, 29), '[', 1),
+                    (15, Inside, (16, 36), '{', 1),
+                    (7, Around, (0, 30), '[', 1),
+                    (15, Around, (15, 37), '{', 1),
+                ],
+            ),
+        ];
+
+        for (sample, scenario) in tests {
+            let doc = Rope::from(*sample);
+            let slice = doc.slice(..);
+            for &case in scenario {
+                let (pos, objtype, expected_range, ch, count) = case;
+                let result = textobject_surround(slice, Range::point(pos), objtype, ch, count);
+                assert_eq!(
+                    result,
+                    expected_range.into(),
+                    "\nCase failed: {:?} - {:?}",
+                    sample,
+                    case
+                );
+            }
+        }
+    }
+}

helix-core/src/transaction.rs

@@ -1,5 +1,5 @@
-use crate::{Range, Rope, Selection, State, Tendril};
-use std::{borrow::Cow, convert::TryFrom};
+use crate::{Range, Rope, Selection, Tendril};
+use std::borrow::Cow;
 
 /// (from, to, replacement)
 pub type Change = (usize, usize, Option<Tendril>);
@@ -15,7 +15,7 @@ pub enum Operation {
     Insert(Tendril),
 }
 
-#[derive(Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum Assoc {
     Before,
     After,
@@ -90,7 +90,8 @@ impl ChangeSet {
             return;
         }
 
-        self.len_after += fragment.len();
+        // Avoiding std::str::len() to account for UTF-8 characters.
+        self.len_after += fragment.chars().count();
 
         let new_last = match self.changes.as_mut_slice() {
             [.., Insert(prev)] | [.., Insert(prev), Delete(_)] => {
@@ -162,7 +163,7 @@ impl ChangeSet {
                     head_a = a;
                     head_b = changes_b.next();
                 }
-                (None, _) | (_, None) => return unreachable!(),
+                (None, val) | (val, None) => unreachable!("({:?})", val),
                 (Some(Retain(i)), Some(Retain(j))) => match i.cmp(&j) {
                     Ordering::Less => {
                         changes.retain(i);
@@ -192,15 +193,16 @@ impl ChangeSet {
                             head_b = changes_b.next();
                         }
                         Ordering::Greater => {
+                            // TODO: cover this with a test
                             // figure out the byte index of the truncated string end
-                            let (pos, _) = s.char_indices().nth(len - j).unwrap();
-                            s.pop_front(s.len() as u32 - pos as u32);
+                            let (pos, _) = s.char_indices().nth(j).unwrap();
+                            s.pop_front(pos as u32);
                             head_a = Some(Insert(s));
                             head_b = changes_b.next();
                         }
                     }
                 }
-                (Some(Insert(mut s)), Some(Retain(j))) => {
+                (Some(Insert(s)), Some(Retain(j))) => {
                     let len = s.chars().count();
                     match len.cmp(&j) {
                         Ordering::Less => {
@@ -272,7 +274,6 @@ impl ChangeSet {
         let mut changes = Self::with_capacity(self.changes.len());
 
         let mut pos = 0;
-        let mut len = 0;
 
         for change in &self.changes {
             use Operation::*;
@@ -415,7 +416,7 @@ impl ChangeSet {
 
 /// Transaction represents a single undoable unit of changes. Several changes can be grouped into
 /// a single transaction.
-#[derive(Debug, Clone)]
+#[derive(Debug, Default, Clone)]
 pub struct Transaction {
     changes: ChangeSet,
     selection: Option<Selection>,
@@ -472,11 +473,13 @@ impl Transaction {
     /// Generate a transaction from a set of changes.
     pub fn change<I>(doc: &Rope, changes: I) -> Self
     where
-        I: IntoIterator<Item = Change> + ExactSizeIterator,
+        I: IntoIterator<Item = Change> + Iterator,
     {
         let len = doc.len_chars();
 
-        let mut changeset = ChangeSet::with_capacity(2 * changes.len() + 1); // rough estimate
+        let (lower, upper) = changes.size_hint();
+        let size = upper.unwrap_or(lower);
+        let mut changeset = ChangeSet::with_capacity(2 * size + 1); // rough estimate
 
         // TODO: verify ranges are ordered and not overlapping or change will panic.
 
@@ -579,6 +582,7 @@ impl<'a> Iterator for ChangeIterator<'a> {
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::State;
 
     #[test]
     fn composition() {
@@ -597,7 +601,7 @@ mod test {
         };
 
         let b = ChangeSet {
-            changes: vec![Delete(10), Insert("world".into()), Retain(5)],
+            changes: vec![Delete(10), Insert("世orld".into()), Retain(5)],
             len: 15,
             len_after: 10,
         };
@@ -608,7 +612,7 @@ mod test {
         let composed = a.compose(b);
         assert_eq!(composed.len, 8);
         assert!(composed.apply(&mut text));
-        assert_eq!(text, "world! abc");
+        assert_eq!(text, "世orld! abc");
     }
 
     #[test]
@@ -697,7 +701,7 @@ mod test {
 
     #[test]
     fn changes_iter() {
-        let mut state = State::new("hello world!\ntest 123".into());
+        let state = State::new("hello world!\ntest 123".into());
         let changes = vec![(6, 11, Some("void".into())), (12, 17, None)];
         let transaction = Transaction::change(&state.doc, changes.clone().into_iter());
         assert_eq!(transaction.changes_iter().collect::<Vec<_>>(), changes);
@@ -729,7 +733,7 @@ mod test {
         // retain 1, e
         // retain 2, l
 
-        let mut changes = t1
+        let changes = t1
             .changes
             .compose(t2.changes)
             .compose(t3.changes)
@@ -744,7 +748,7 @@ mod test {
     #[test]
     fn combine_with_empty() {
         let empty = Rope::from("");
-        let mut a = ChangeSet::new(&empty);
+        let a = ChangeSet::new(&empty);
 
         let mut b = ChangeSet::new(&empty);
         b.insert("a".into());
@@ -754,4 +758,21 @@ mod test {
         use Operation::*;
         assert_eq!(changes.changes, &[Insert("a".into())]);
     }
+
+    #[test]
+    fn combine_with_utf8() {
+        const TEST_CASE: &'static str = "Hello, これはヘリックスエディターです！";
+
+        let empty = Rope::from("");
+        let a = ChangeSet::new(&empty);
+
+        let mut b = ChangeSet::new(&empty);
+        b.insert(TEST_CASE.into());
+
+        let changes = a.compose(b);
+
+        use Operation::*;
+        assert_eq!(changes.changes, &[Insert(TEST_CASE.into())]);
+        assert_eq!(changes.len_after, TEST_CASE.chars().count());
+    }
 }

helix-lsp/Cargo.toml

@@ -1,29 +1,27 @@
 [package]
 name = "helix-lsp"
-version = "0.1.0"
+version = "0.4.1"
 authors = ["Blaž Hrastnik <blaz@mxxn.io>"]
 edition = "2018"
 license = "MPL-2.0"
+description = "LSP client implementation for Helix project"
+categories = ["editor"]
+repository = "https://github.com/helix-editor/helix"
+homepage = "https://helix-editor.com"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-helix-core = { path = "../helix-core" }
+helix-core = { version = "0.4", path = "../helix-core" }
 
-once_cell = "1.4"
-
-lsp-types = { version = "0.89", features = ["proposed"] }
-tokio = { version = "1", features = ["full"] }
-tokio-stream = "0.1.5"
-futures-executor = { version =  "0.3" }
-url = "2"
-pathdiff = "0.2"
-glob = "0.3"
-anyhow = "1"
-serde_json = "1.0"
-serde = { version = "1.0", features = ["derive"] }
-# jsonrpc-core = { version = "17.1", default-features = false } # don't pull in all of futures
-jsonrpc-core = { git = "https://github.com/paritytech/jsonrpc", default-features = false } # don't pull in all of futures
+anyhow = "1.0"
+futures-executor = "0.3"
 futures-util = { version = "0.3", features = ["std", "async-await"], default-features = false }
+jsonrpc-core = { version = "18.0", default-features = false } # don't pull in all of futures
+log = "0.4"
+lsp-types = { version = "0.89", features = ["proposed"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
 thiserror = "1.0"
-log = "~0.4"
+tokio = { version = "1.9", features = ["rt", "rt-multi-thread", "io-util", "io-std", "time", "process", "macros", "fs", "parking_lot"] }
+tokio-stream = "0.1.7"

helix-lsp/src/client.rs

@@ -3,37 +3,37 @@ use crate::{
     Call, Error, OffsetEncoding, Result,
 };
 
-use helix_core::{ChangeSet, Rope};
-
-// use std::collections::HashMap;
-use std::future::Future;
-use std::sync::atomic::{AtomicU64, Ordering};
-
+use helix_core::{chars::char_is_line_ending, find_root, ChangeSet, Rope};
 use jsonrpc_core as jsonrpc;
 use lsp_types as lsp;
 use serde_json::Value;
-
+use std::future::Future;
 use std::process::Stdio;
+use std::sync::atomic::{AtomicU64, Ordering};
 use tokio::{
     io::{BufReader, BufWriter},
-    // prelude::*,
     process::{Child, Command},
     sync::mpsc::{channel, UnboundedReceiver, UnboundedSender},
 };
 
+#[derive(Debug)]
 pub struct Client {
+    id: usize,
     _process: Child,
-
-    outgoing: UnboundedSender<Payload>,
-    // pub incoming: Receiver<Call>,
-    pub request_counter: AtomicU64,
-
+    server_tx: UnboundedSender<Payload>,
+    request_counter: AtomicU64,
     capabilities: Option<lsp::ServerCapabilities>,
     offset_encoding: OffsetEncoding,
+    config: Option<Value>,
 }
 
 impl Client {
-    pub fn start(cmd: &str, args: &[String]) -> Result<(Self, UnboundedReceiver<Call>)> {
+    pub fn start(
+        cmd: &str,
+        args: &[String],
+        config: Option<Value>,
+        id: usize,
+    ) -> Result<(Self, UnboundedReceiver<(usize, Call)>)> {
         let process = Command::new(cmd)
             .args(args)
             .stdin(Stdio::piped())
@@ -43,40 +43,33 @@ impl Client {
             .kill_on_drop(true)
             .spawn();
 
-        // use std::io::ErrorKind;
-        let mut process = match process {
-            Ok(process) => process,
-            Err(err) => match err.kind() {
-                // ErrorKind::NotFound | ErrorKind::PermissionDenied => {
-                //     return Err(Error::Other(err.into()))
-                // }
-                _kind => return Err(Error::Other(err.into())),
-            },
-        };
+        let mut process = process?;
 
         // TODO: do we need bufreader/writer here? or do we use async wrappers on unblock?
         let writer = BufWriter::new(process.stdin.take().expect("Failed to open stdin"));
         let reader = BufReader::new(process.stdout.take().expect("Failed to open stdout"));
         let stderr = BufReader::new(process.stderr.take().expect("Failed to open stderr"));
 
-        let (incoming, outgoing) = Transport::start(reader, writer, stderr);
+        let (server_rx, server_tx) = Transport::start(reader, writer, stderr, id);
 
         let client = Self {
+            id,
             _process: process,
-
-            outgoing,
-            // incoming,
+            server_tx,
             request_counter: AtomicU64::new(0),
-
             capabilities: None,
-            // diagnostics: HashMap::new(),
             offset_encoding: OffsetEncoding::Utf8,
+            config,
         };
 
         // TODO: async client.initialize()
         // maybe use an arc<atomic> flag
 
-        Ok((client, incoming))
+        Ok((client, server_rx))
+    }
+
+    pub fn id(&self) -> usize {
+        self.id
     }
 
     fn next_request_id(&self) -> jsonrpc::Id {
@@ -106,7 +99,7 @@ impl Client {
     }
 
     /// Execute a RPC request on the language server.
-    pub async fn request<R: lsp::request::Request>(&self, params: R::Params) -> Result<R::Result>
+    async fn request<R: lsp::request::Request>(&self, params: R::Params) -> Result<R::Result>
     where
         R::Params: serde::Serialize,
         R::Result: core::fmt::Debug, // TODO: temporary
@@ -118,17 +111,20 @@ impl Client {
     }
 
     /// Execute a RPC request on the language server.
-    pub fn call<R: lsp::request::Request>(
+    fn call<R: lsp::request::Request>(
         &self,
         params: R::Params,
     ) -> impl Future<Output = Result<Value>>
     where
         R::Params: serde::Serialize,
     {
-        let outgoing = self.outgoing.clone();
+        let server_tx = self.server_tx.clone();
         let id = self.next_request_id();
 
         async move {
+            use std::time::Duration;
+            use tokio::time::timeout;
+
             let params = serde_json::to_value(params)?;
 
             let request = jsonrpc::MethodCall {
@@ -140,32 +136,29 @@ impl Client {
 
             let (tx, mut rx) = channel::<Result<Value>>(1);
 
-            outgoing
+            server_tx
                 .send(Payload::Request {
                     chan: tx,
                     value: request,
                 })
                 .map_err(|e| Error::Other(e.into()))?;
 
-            use std::time::Duration;
-            use tokio::time::timeout;
-
             timeout(Duration::from_secs(2), rx.recv())
                 .await
                 .map_err(|_| Error::Timeout)? // return Timeout
-                .unwrap() // TODO: None if channel closed
+                .ok_or(Error::StreamClosed)?
         }
     }
 
     /// Send a RPC notification to the language server.
-    pub fn notify<R: lsp::notification::Notification>(
+    fn notify<R: lsp::notification::Notification>(
         &self,
         params: R::Params,
     ) -> impl Future<Output = Result<()>>
     where
         R::Params: serde::Serialize,
     {
-        let outgoing = self.outgoing.clone();
+        let server_tx = self.server_tx.clone();
 
         async move {
             let params = serde_json::to_value(params)?;
@@ -176,7 +169,7 @@ impl Client {
                 params: Self::value_into_params(params),
             };
 
-            outgoing
+            server_tx
                 .send(Payload::Notification(notification))
                 .map_err(|e| Error::Other(e.into()))?;
 
@@ -185,47 +178,56 @@ impl Client {
     }
 
     /// Reply to a language server RPC call.
-    pub async fn reply(
+    pub fn reply(
         &self,
         id: jsonrpc::Id,
         result: core::result::Result<Value, jsonrpc::Error>,
-    ) -> Result<()> {
+    ) -> impl Future<Output = Result<()>> {
         use jsonrpc::{Failure, Output, Success, Version};
 
-        let output = match result {
-            Ok(result) => Output::Success(Success {
-                jsonrpc: Some(Version::V2),
-                id,
-                result,
-            }),
-            Err(error) => Output::Failure(Failure {
-                jsonrpc: Some(Version::V2),
-                id,
-                error,
-            }),
-        };
+        let server_tx = self.server_tx.clone();
 
-        self.outgoing
-            .send(Payload::Response(output))
-            .map_err(|e| Error::Other(e.into()))?;
+        async move {
+            let output = match result {
+                Ok(result) => Output::Success(Success {
+                    jsonrpc: Some(Version::V2),
+                    id,
+                    result,
+                }),
+                Err(error) => Output::Failure(Failure {
+                    jsonrpc: Some(Version::V2),
+                    id,
+                    error,
+                }),
+            };
 
-        Ok(())
+            server_tx
+                .send(Payload::Response(output))
+                .map_err(|e| Error::Other(e.into()))?;
+
+            Ok(())
+        }
     }
 
     // -------------------------------------------------------------------------------------------
     // General messages
     // -------------------------------------------------------------------------------------------
 
-    pub async fn initialize(&mut self) -> Result<()> {
+    pub(crate) async fn initialize(&mut self) -> Result<()> {
         // TODO: delay any requests that are triggered prior to initialize
+        let root = find_root(None).and_then(|root| lsp::Url::from_file_path(root).ok());
+
+        if self.config.is_some() {
+            log::info!("Using custom LSP config: {}", self.config.as_ref().unwrap());
+        }
 
         #[allow(deprecated)]
         let params = lsp::InitializeParams {
             process_id: Some(std::process::id()),
+            // root_path is obsolete, use root_uri
             root_path: None,
-            // root_uri: Some(lsp_types::Url::parse("file://localhost/")?),
-            root_uri: None, // set to project root in the future
-            initialization_options: None,
+            root_uri: root,
+            initialization_options: self.config.clone(),
             capabilities: lsp::ClientCapabilities {
                 text_document: Some(lsp::TextDocumentClientCapabilities {
                     completion: Some(lsp::CompletionClientCapabilities {
@@ -245,6 +247,30 @@ impl Client {
                         content_format: Some(vec![lsp::MarkupKind::Markdown]),
                         ..Default::default()
                     }),
+                    code_action: Some(lsp::CodeActionClientCapabilities {
+                        code_action_literal_support: Some(lsp::CodeActionLiteralSupport {
+                            code_action_kind: lsp::CodeActionKindLiteralSupport {
+                                value_set: [
+                                    lsp::CodeActionKind::EMPTY,
+                                    lsp::CodeActionKind::QUICKFIX,
+                                    lsp::CodeActionKind::REFACTOR,
+                                    lsp::CodeActionKind::REFACTOR_EXTRACT,
+                                    lsp::CodeActionKind::REFACTOR_INLINE,
+                                    lsp::CodeActionKind::REFACTOR_REWRITE,
+                                    lsp::CodeActionKind::SOURCE,
+                                    lsp::CodeActionKind::SOURCE_ORGANIZE_IMPORTS,
+                                ]
+                                .iter()
+                                .map(|kind| kind.as_str().to_string())
+                                .collect(),
+                            },
+                        }),
+                        ..Default::default()
+                    }),
+                    ..Default::default()
+                }),
+                window: Some(lsp::WindowClientCapabilities {
+                    work_done_progress: Some(true),
                     ..Default::default()
                 }),
                 ..Default::default()
@@ -273,6 +299,21 @@ impl Client {
         self.notify::<lsp::notification::Exit>(())
     }
 
+    /// Tries to shut down the language server but returns
+    /// early if server responds with an error.
+    pub async fn shutdown_and_exit(&self) -> Result<()> {
+        self.shutdown().await?;
+        self.exit().await
+    }
+
+    /// Forcefully shuts down the language server ignoring any errors.
+    pub async fn force_shutdown(&self) -> Result<()> {
+        if let Err(e) = self.shutdown().await {
+            log::warn!("language server failed to terminate gracefully - {}", e);
+        }
+        self.exit().await
+    }
+
     // -------------------------------------------------------------------------------------------
     // Text document
     // -------------------------------------------------------------------------------------------
@@ -323,8 +364,9 @@ impl Client {
                 mut character,
             } = pos;
 
-            for ch in text.chars() {
-                if ch == '\n' {
+            let mut chars = text.chars().peekable();
+            while let Some(ch) = chars.next() {
+                if char_is_line_ending(ch) && !(ch == '\r' && chars.peek() == Some(&'\n')) {
                     line += 1;
                     character = 0;
                 } else {
@@ -479,6 +521,7 @@ impl Client {
         &self,
         text_document: lsp::TextDocumentIdentifier,
         position: lsp::Position,
+        work_done_token: Option<lsp::ProgressToken>,
     ) -> impl Future<Output = Result<Value>> {
         // ) -> Result<Vec<lsp::CompletionItem>> {
         let params = lsp::CompletionParams {
@@ -487,9 +530,7 @@ impl Client {
                 position,
             },
             // TODO: support these tokens by async receiving and updating the choice list
-            work_done_progress_params: lsp::WorkDoneProgressParams {
-                work_done_token: None,
-            },
+            work_done_progress_params: lsp::WorkDoneProgressParams { work_done_token },
             partial_result_params: lsp::PartialResultParams {
                 partial_result_token: None,
             },
@@ -504,15 +545,14 @@ impl Client {
         &self,
         text_document: lsp::TextDocumentIdentifier,
         position: lsp::Position,
+        work_done_token: Option<lsp::ProgressToken>,
     ) -> impl Future<Output = Result<Value>> {
         let params = lsp::SignatureHelpParams {
             text_document_position_params: lsp::TextDocumentPositionParams {
                 text_document,
                 position,
             },
-            work_done_progress_params: lsp::WorkDoneProgressParams {
-                work_done_token: None,
-            },
+            work_done_progress_params: lsp::WorkDoneProgressParams { work_done_token },
             context: None,
             // lsp::SignatureHelpContext
         };
@@ -524,15 +564,14 @@ impl Client {
         &self,
         text_document: lsp::TextDocumentIdentifier,
         position: lsp::Position,
+        work_done_token: Option<lsp::ProgressToken>,
     ) -> impl Future<Output = Result<Value>> {
         let params = lsp::HoverParams {
             text_document_position_params: lsp::TextDocumentPositionParams {
                 text_document,
                 position,
             },
-            work_done_progress_params: lsp::WorkDoneProgressParams {
-                work_done_token: None,
-            },
+            work_done_progress_params: lsp::WorkDoneProgressParams { work_done_token },
             // lsp::SignatureHelpContext
         };
 
@@ -545,6 +584,7 @@ impl Client {
         &self,
         text_document: lsp::TextDocumentIdentifier,
         options: lsp::FormattingOptions,
+        work_done_token: Option<lsp::ProgressToken>,
     ) -> anyhow::Result<Vec<lsp::TextEdit>> {
         let capabilities = self.capabilities.as_ref().unwrap();
 
@@ -559,9 +599,7 @@ impl Client {
         let params = lsp::DocumentFormattingParams {
             text_document,
             options,
-            work_done_progress_params: lsp::WorkDoneProgressParams {
-                work_done_token: None,
-            },
+            work_done_progress_params: lsp::WorkDoneProgressParams { work_done_token },
         };
 
         let response = self.request::<lsp::request::Formatting>(params).await?;
@@ -574,6 +612,7 @@ impl Client {
         text_document: lsp::TextDocumentIdentifier,
         range: lsp::Range,
         options: lsp::FormattingOptions,
+        work_done_token: Option<lsp::ProgressToken>,
     ) -> anyhow::Result<Vec<lsp::TextEdit>> {
         let capabilities = self.capabilities.as_ref().unwrap();
 
@@ -589,9 +628,7 @@ impl Client {
             text_document,
             range,
             options,
-            work_done_progress_params: lsp::WorkDoneProgressParams {
-                work_done_token: None,
-            },
+            work_done_progress_params: lsp::WorkDoneProgressParams { work_done_token },
         };
 
         let response = self
@@ -610,15 +647,14 @@ impl Client {
         &self,
         text_document: lsp::TextDocumentIdentifier,
         position: lsp::Position,
+        work_done_token: Option<lsp::ProgressToken>,
     ) -> impl Future<Output = Result<Value>> {
         let params = lsp::GotoDefinitionParams {
             text_document_position_params: lsp::TextDocumentPositionParams {
                 text_document,
                 position,
             },
-            work_done_progress_params: lsp::WorkDoneProgressParams {
-                work_done_token: None,
-            },
+            work_done_progress_params: lsp::WorkDoneProgressParams { work_done_token },
             partial_result_params: lsp::PartialResultParams {
                 partial_result_token: None,
             },
@@ -631,30 +667,42 @@ impl Client {
         &self,
         text_document: lsp::TextDocumentIdentifier,
         position: lsp::Position,
+        work_done_token: Option<lsp::ProgressToken>,
     ) -> impl Future<Output = Result<Value>> {
-        self.goto_request::<lsp::request::GotoDefinition>(text_document, position)
+        self.goto_request::<lsp::request::GotoDefinition>(text_document, position, work_done_token)
     }
 
     pub fn goto_type_definition(
         &self,
         text_document: lsp::TextDocumentIdentifier,
         position: lsp::Position,
+        work_done_token: Option<lsp::ProgressToken>,
     ) -> impl Future<Output = Result<Value>> {
-        self.goto_request::<lsp::request::GotoTypeDefinition>(text_document, position)
+        self.goto_request::<lsp::request::GotoTypeDefinition>(
+            text_document,
+            position,
+            work_done_token,
+        )
     }
 
     pub fn goto_implementation(
         &self,
         text_document: lsp::TextDocumentIdentifier,
         position: lsp::Position,
+        work_done_token: Option<lsp::ProgressToken>,
     ) -> impl Future<Output = Result<Value>> {
-        self.goto_request::<lsp::request::GotoImplementation>(text_document, position)
+        self.goto_request::<lsp::request::GotoImplementation>(
+            text_document,
+            position,
+            work_done_token,
+        )
     }
 
     pub fn goto_reference(
         &self,
         text_document: lsp::TextDocumentIdentifier,
         position: lsp::Position,
+        work_done_token: Option<lsp::ProgressToken>,
     ) -> impl Future<Output = Result<Value>> {
         let params = lsp::ReferenceParams {
             text_document_position: lsp::TextDocumentPositionParams {
@@ -664,9 +712,7 @@ impl Client {
             context: lsp::ReferenceContext {
                 include_declaration: true,
             },
-            work_done_progress_params: lsp::WorkDoneProgressParams {
-                work_done_token: None,
-            },
+            work_done_progress_params: lsp::WorkDoneProgressParams { work_done_token },
             partial_result_params: lsp::PartialResultParams {
                 partial_result_token: None,
             },
@@ -674,4 +720,44 @@ impl Client {
 
         self.call::<lsp::request::References>(params)
     }
+
+    pub fn document_symbols(
+        &self,
+        text_document: lsp::TextDocumentIdentifier,
+    ) -> impl Future<Output = Result<Value>> {
+        let params = lsp::DocumentSymbolParams {
+            text_document,
+            work_done_progress_params: lsp::WorkDoneProgressParams::default(),
+            partial_result_params: lsp::PartialResultParams::default(),
+        };
+
+        self.call::<lsp::request::DocumentSymbolRequest>(params)
+    }
+
+    // empty string to get all symbols
+    pub fn workspace_symbols(&self, query: String) -> impl Future<Output = Result<Value>> {
+        let params = lsp::WorkspaceSymbolParams {
+            query,
+            work_done_progress_params: lsp::WorkDoneProgressParams::default(),
+            partial_result_params: lsp::PartialResultParams::default(),
+        };
+
+        self.call::<lsp::request::WorkspaceSymbol>(params)
+    }
+
+    pub fn code_actions(
+        &self,
+        text_document: lsp::TextDocumentIdentifier,
+        range: lsp::Range,
+    ) -> impl Future<Output = Result<Value>> {
+        let params = lsp::CodeActionParams {
+            text_document,
+            range,
+            context: lsp::CodeActionContext::default(),
+            work_done_progress_params: lsp::WorkDoneProgressParams::default(),
+            partial_result_params: lsp::PartialResultParams::default(),
+        };
+
+        self.call::<lsp::request::CodeActionRequest>(params)
+    }
 }

helix-lsp/src/lib.rs

@@ -1,26 +1,30 @@
 mod client;
-mod select_all;
 mod transport;
 
+pub use client::Client;
+pub use futures_executor::block_on;
+pub use jsonrpc::Call;
 pub use jsonrpc_core as jsonrpc;
+pub use lsp::{Position, Url};
 pub use lsp_types as lsp;
 
-pub use client::Client;
-pub use lsp::{Position, Url};
-
-pub type Result<T> = core::result::Result<T, Error>;
-
+use futures_util::stream::select_all::SelectAll;
 use helix_core::syntax::LanguageConfiguration;
 
-use thiserror::Error;
-
-use std::{collections::HashMap, sync::Arc};
+use std::{
+    collections::{hash_map::Entry, HashMap},
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+};
 
 use serde::{Deserialize, Serialize};
-
+use thiserror::Error;
 use tokio_stream::wrappers::UnboundedReceiverStream;
 
-pub use futures_executor::block_on;
+pub type Result<T> = core::result::Result<T, Error>;
+type LanguageId = String;
 
 #[derive(Error, Debug)]
 pub enum Error {
@@ -28,8 +32,14 @@ pub enum Error {
     Rpc(#[from] jsonrpc::Error),
     #[error("failed to parse: {0}")]
     Parse(#[from] serde_json::Error),
+    #[error("IO Error: {0}")]
+    IO(#[from] std::io::Error),
     #[error("request timed out")]
     Timeout,
+    #[error("server closed the stream")]
+    StreamClosed,
+    #[error("LSP not defined")]
+    LspNotDefined,
     #[error(transparent)]
     Other(#[from] anyhow::Error),
 }
@@ -48,23 +58,54 @@ pub mod util {
     use super::*;
     use helix_core::{Range, Rope, Transaction};
 
+    /// Converts [`lsp::Position`] to a position in the document.
+    ///
+    /// Returns `None` if position exceeds document length or an operation overflows.
     pub fn lsp_pos_to_pos(
         doc: &Rope,
         pos: lsp::Position,
         offset_encoding: OffsetEncoding,
-    ) -> usize {
+    ) -> Option<usize> {
+        let max_line = doc.lines().count().saturating_sub(1);
+        let pos_line = pos.line as usize;
+        let pos_line = if pos_line > max_line {
+            return None;
+        } else {
+            pos_line
+        };
         match offset_encoding {
             OffsetEncoding::Utf8 => {
-                let line = doc.line_to_char(pos.line as usize);
-                line + pos.character as usize
+                let max_char = doc
+                    .line_to_char(max_line)
+                    .checked_add(doc.line(max_line).len_chars())?;
+                let line = doc.line_to_char(pos_line);
+                let pos = line.checked_add(pos.character as usize)?;
+                if pos <= max_char {
+                    Some(pos)
+                } else {
+                    None
+                }
             }
             OffsetEncoding::Utf16 => {
-                let line = doc.line_to_char(pos.line as usize);
+                let max_char = doc
+                    .line_to_char(max_line)
+                    .checked_add(doc.line(max_line).len_chars())?;
+                let max_cu = doc.char_to_utf16_cu(max_char);
+                let line = doc.line_to_char(pos_line);
                 let line_start = doc.char_to_utf16_cu(line);
-                doc.utf16_cu_to_char(line_start + pos.character as usize)
+                let pos = line_start.checked_add(pos.character as usize)?;
+                if pos <= max_cu {
+                    Some(doc.utf16_cu_to_char(pos))
+                } else {
+                    None
+                }
             }
         }
     }
+
+    /// Converts position in the document to [`lsp::Position`].
+    ///
+    /// Panics when `pos` is out of `doc` bounds or operation overflows.
     pub fn pos_to_lsp_pos(
         doc: &Rope,
         pos: usize,
@@ -88,6 +129,7 @@ pub mod util {
         }
     }
 
+    /// Converts a range in the document to [`lsp::Range`].
     pub fn range_to_lsp_range(
         doc: &Rope,
         range: Range,
@@ -99,6 +141,17 @@ pub mod util {
         lsp::Range::new(start, end)
     }
 
+    pub fn lsp_range_to_range(
+        doc: &Rope,
+        range: lsp::Range,
+        offset_encoding: OffsetEncoding,
+    ) -> Option<Range> {
+        let start = lsp_pos_to_pos(doc, range.start, offset_encoding)?;
+        let end = lsp_pos_to_pos(doc, range.end, offset_encoding)?;
+
+        Some(Range::new(start, end))
+    }
+
     pub fn generate_transaction_from_edits(
         doc: &Rope,
         edits: Vec<lsp::TextEdit>,
@@ -114,14 +167,61 @@ pub mod util {
                     None
                 };
 
-                let start = lsp_pos_to_pos(doc, edit.range.start, offset_encoding);
-                let end = lsp_pos_to_pos(doc, edit.range.end, offset_encoding);
+                let start =
+                    if let Some(start) = lsp_pos_to_pos(doc, edit.range.start, offset_encoding) {
+                        start
+                    } else {
+                        return (0, 0, None);
+                    };
+                let end = if let Some(end) = lsp_pos_to_pos(doc, edit.range.end, offset_encoding) {
+                    end
+                } else {
+                    return (0, 0, None);
+                };
                 (start, end, replacement)
             }),
         )
     }
 
-    // apply_insert_replace_edit
+    /// The result of asking the language server to format the document. This can be turned into a
+    /// `Transaction`, but the advantage of not doing that straight away is that this one is
+    /// `Send` and `Sync`.
+    #[derive(Clone, Debug)]
+    pub struct LspFormatting {
+        pub doc: Rope,
+        pub edits: Vec<lsp::TextEdit>,
+        pub offset_encoding: OffsetEncoding,
+    }
+
+    impl From<LspFormatting> for Transaction {
+        fn from(fmt: LspFormatting) -> Transaction {
+            generate_transaction_from_edits(&fmt.doc, fmt.edits, fmt.offset_encoding)
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum MethodCall {
+    WorkDoneProgressCreate(lsp::WorkDoneProgressCreateParams),
+}
+
+impl MethodCall {
+    pub fn parse(method: &str, params: jsonrpc::Params) -> Option<MethodCall> {
+        use lsp::request::Request;
+        let request = match method {
+            lsp::request::WorkDoneProgressCreate::METHOD => {
+                let params: lsp::WorkDoneProgressCreateParams = params
+                    .parse()
+                    .expect("Failed to parse WorkDoneCreate params");
+                Self::WorkDoneProgressCreate(params)
+            }
+            _ => {
+                log::warn!("unhandled lsp request: {}", method);
+                return None;
+            }
+        };
+        Some(request)
+    }
 }
 
 #[derive(Debug, PartialEq, Clone)]
@@ -129,6 +229,7 @@ pub enum Notification {
     PublishDiagnostics(lsp::PublishDiagnosticsParams),
     ShowMessage(lsp::ShowMessageParams),
     LogMessage(lsp::LogMessageParams),
+    ProgressMessage(lsp::ProgressParams),
 }
 
 impl Notification {
@@ -146,17 +247,20 @@ impl Notification {
             }
 
             lsp::notification::ShowMessage::METHOD => {
-                let params: lsp::ShowMessageParams =
-                    params.parse().expect("Failed to parse ShowMessage params");
+                let params: lsp::ShowMessageParams = params.parse().ok()?;
 
                 Self::ShowMessage(params)
             }
             lsp::notification::LogMessage::METHOD => {
-                let params: lsp::LogMessageParams =
-                    params.parse().expect("Failed to parse ShowMessage params");
+                let params: lsp::LogMessageParams = params.parse().ok()?;
 
                 Self::LogMessage(params)
             }
+            lsp::notification::Progress::METHOD => {
+                let params: lsp::ProgressParams = params.parse().ok()?;
+
+                Self::ProgressMessage(params)
+            }
             _ => {
                 log::error!("unhandled LSP notification: {}", method);
                 return None;
@@ -167,16 +271,12 @@ impl Notification {
     }
 }
 
-pub use jsonrpc::Call;
-
-type LanguageId = String;
-
-use crate::select_all::SelectAll;
-
+#[derive(Debug)]
 pub struct Registry {
-    inner: HashMap<LanguageId, Option<Arc<Client>>>,
+    inner: HashMap<LanguageId, (usize, Arc<Client>)>,
 
-    pub incoming: SelectAll<UnboundedReceiverStream<Call>>,
+    counter: AtomicUsize,
+    pub incoming: SelectAll<UnboundedReceiverStream<(usize, Call)>>,
 }
 
 impl Default for Registry {
@@ -189,39 +289,129 @@ impl Registry {
     pub fn new() -> Self {
         Self {
             inner: HashMap::new(),
+            counter: AtomicUsize::new(0),
             incoming: SelectAll::new(),
         }
     }
 
-    pub fn get(&mut self, language_config: &LanguageConfiguration) -> Option<Arc<Client>> {
-        // TODO: propagate the error
+    pub fn get_by_id(&mut self, id: usize) -> Option<&Client> {
+        self.inner
+            .values()
+            .find(|(client_id, _)| client_id == &id)
+            .map(|(_, client)| client.as_ref())
+    }
+
+    pub fn get(&mut self, language_config: &LanguageConfiguration) -> Result<Arc<Client>> {
         if let Some(config) = &language_config.language_server {
             // avoid borrow issues
             let inner = &mut self.inner;
-            let s_incoming = &self.incoming;
-
-            let language_server = inner
-                .entry(language_config.scope.clone()) // can't use entry with Borrow keys: https://github.com/rust-lang/rfcs/pull/1769
-                .or_insert_with(|| {
-                    // TODO: lookup defaults for id (name, args)
+            let s_incoming = &mut self.incoming;
 
+            match inner.entry(language_config.scope.clone()) {
+                Entry::Occupied(entry) => Ok(entry.get().1.clone()),
+                Entry::Vacant(entry) => {
                     // initialize a new client
-                    let (mut client, incoming) =
-                        Client::start(&config.command, &config.args).ok()?;
-
+                    let id = self.counter.fetch_add(1, Ordering::Relaxed);
+                    let (mut client, incoming) = Client::start(
+                        &config.command,
+                        &config.args,
+                        serde_json::from_str(language_config.config.as_deref().unwrap_or("")).ok(),
+                        id,
+                    )?;
                     // TODO: run this async without blocking
-                    futures_executor::block_on(client.initialize()).unwrap();
-
+                    futures_executor::block_on(client.initialize())?;
                     s_incoming.push(UnboundedReceiverStream::new(incoming));
+                    let client = Arc::new(client);
 
-                    Some(Arc::new(client))
-                })
-                .clone();
-
-            return language_server;
+                    entry.insert((id, client.clone()));
+                    Ok(client)
+                }
+            }
+        } else {
+            Err(Error::LspNotDefined)
         }
+    }
 
-        None
+    pub fn iter_clients(&self) -> impl Iterator<Item = &Arc<Client>> {
+        self.inner.values().map(|(_, client)| client)
+    }
+}
+
+#[derive(Debug)]
+pub enum ProgressStatus {
+    Created,
+    Started(lsp::WorkDoneProgress),
+}
+
+impl ProgressStatus {
+    pub fn progress(&self) -> Option<&lsp::WorkDoneProgress> {
+        match &self {
+            ProgressStatus::Created => None,
+            ProgressStatus::Started(progress) => Some(progress),
+        }
+    }
+}
+
+#[derive(Default, Debug)]
+/// Acts as a container for progress reported by language servers. Each server
+/// has a unique id assigned at creation through [`Registry`]. This id is then used
+/// to store the progress in this map.
+pub struct LspProgressMap(HashMap<usize, HashMap<lsp::ProgressToken, ProgressStatus>>);
+
+impl LspProgressMap {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Returns a map of all tokens coresponding to the lanaguage server with `id`.
+    pub fn progress_map(&self, id: usize) -> Option<&HashMap<lsp::ProgressToken, ProgressStatus>> {
+        self.0.get(&id)
+    }
+
+    pub fn is_progressing(&self, id: usize) -> bool {
+        self.0.get(&id).map(|it| !it.is_empty()).unwrap_or_default()
+    }
+
+    /// Returns last progress status for a given server with `id` and `token`.
+    pub fn progress(&self, id: usize, token: &lsp::ProgressToken) -> Option<&ProgressStatus> {
+        self.0.get(&id).and_then(|values| values.get(token))
+    }
+
+    /// Checks if progress `token` for server with `id` is created.
+    pub fn is_created(&mut self, id: usize, token: &lsp::ProgressToken) -> bool {
+        self.0
+            .get(&id)
+            .map(|values| values.get(token).is_some())
+            .unwrap_or_default()
+    }
+
+    pub fn create(&mut self, id: usize, token: lsp::ProgressToken) {
+        self.0
+            .entry(id)
+            .or_default()
+            .insert(token, ProgressStatus::Created);
+    }
+
+    /// Ends the progress by removing the `token` from server with `id`, if removed returns the value.
+    pub fn end_progress(
+        &mut self,
+        id: usize,
+        token: &lsp::ProgressToken,
+    ) -> Option<ProgressStatus> {
+        self.0.get_mut(&id).and_then(|vals| vals.remove(token))
+    }
+
+    /// Updates the progess of `token` for server with `id` to `status`, returns the value replaced or `None`.
+    pub fn update(
+        &mut self,
+        id: usize,
+        token: lsp::ProgressToken,
+        status: lsp::WorkDoneProgress,
+    ) -> Option<ProgressStatus> {
+        self.0
+            .entry(id)
+            .or_default()
+            .insert(token, ProgressStatus::Started(status))
     }
 }
 
@@ -250,3 +440,34 @@ impl Registry {
 // there needs to be a way to process incoming lsp messages from all clients.
 //  -> notifications need to be dispatched to wherever
 //  -> requests need to generate a reply and travel back to the same lsp!
+
+#[cfg(test)]
+mod tests {
+    use super::{lsp, util::*, OffsetEncoding};
+    use helix_core::Rope;
+
+    #[test]
+    fn converts_lsp_pos_to_pos() {
+        macro_rules! test_case {
+            ($doc:expr, ($x:expr, $y:expr) => $want:expr) => {
+                let doc = Rope::from($doc);
+                let pos = lsp::Position::new($x, $y);
+                assert_eq!($want, lsp_pos_to_pos(&doc, pos, OffsetEncoding::Utf16));
+                assert_eq!($want, lsp_pos_to_pos(&doc, pos, OffsetEncoding::Utf8))
+            };
+        }
+
+        test_case!("", (0, 0) => Some(0));
+        test_case!("", (0, 1) => None);
+        test_case!("", (1, 0) => None);
+        test_case!("\n\n", (0, 0) => Some(0));
+        test_case!("\n\n", (1, 0) => Some(1));
+        test_case!("\n\n", (1, 1) => Some(2));
+        test_case!("\n\n", (2, 0) => Some(2));
+        test_case!("\n\n", (3, 0) => None);
+        test_case!("test\n\n\n\ncase", (4, 3) => Some(11));
+        test_case!("test\n\n\n\ncase", (4, 4) => Some(12));
+        test_case!("test\n\n\n\ncase", (4, 5) => None);
+        test_case!("", (u32::MAX, u32::MAX) => None);
+    }
+}

helix-lsp/src/select_all.rs

@@ -1,143 +0,0 @@
-//! An unbounded set of streams
-
-use core::{
-    fmt::{self, Debug},
-    iter::FromIterator,
-    pin::Pin,
-};
-
-use std::task::{Context, Poll};
-
-use futures_util::stream::{FusedStream, FuturesUnordered, StreamExt, StreamFuture};
-use futures_util::{ready, stream::Stream};
-
-/// An unbounded set of streams
-///
-/// This "combinator" provides the ability to maintain a set of streams
-/// and drive them all to completion.
-///
-/// Streams are pushed into this set and their realized values are
-/// yielded as they become ready. Streams will only be polled when they
-/// generate notifications. This allows to coordinate a large number of streams.
-///
-/// Note that you can create a ready-made `SelectAll` via the
-/// `select_all` function in the `stream` module, or you can start with an
-/// empty set with the `SelectAll::new` constructor.
-#[must_use = "streams do nothing unless polled"]
-pub struct SelectAll<St> {
-    inner: FuturesUnordered<StreamFuture<St>>,
-}
-
-impl<St: Debug> Debug for SelectAll<St> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "SelectAll {{ ... }}")
-    }
-}
-
-impl<St: Stream + Unpin> SelectAll<St> {
-    /// Constructs a new, empty `SelectAll`
-    ///
-    /// The returned `SelectAll` does not contain any streams and, in this
-    /// state, `SelectAll::poll` will return `Poll::Ready(None)`.
-    pub fn new() -> Self {
-        Self {
-            inner: FuturesUnordered::new(),
-        }
-    }
-
-    /// Returns the number of streams contained in the set.
-    ///
-    /// This represents the total number of in-flight streams.
-    pub fn len(&self) -> usize {
-        self.inner.len()
-    }
-
-    /// Returns `true` if the set contains no streams
-    pub fn is_empty(&self) -> bool {
-        self.inner.is_empty()
-    }
-
-    /// Push a stream into the set.
-    ///
-    /// This function submits the given stream to the set for managing. This
-    /// function will not call `poll` on the submitted stream. The caller must
-    /// ensure that `SelectAll::poll` is called in order to receive task
-    /// notifications.
-    pub fn push(&self, stream: St) {
-        self.inner.push(stream.into_future());
-    }
-}
-
-impl<St: Stream + Unpin> Default for SelectAll<St> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<St: Stream + Unpin> Stream for SelectAll<St> {
-    type Item = St::Item;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        loop {
-            match ready!(self.inner.poll_next_unpin(cx)) {
-                Some((Some(item), remaining)) => {
-                    self.push(remaining);
-                    return Poll::Ready(Some(item));
-                }
-                Some((None, _)) => {
-                    // `FuturesUnordered` thinks it isn't terminated
-                    // because it yielded a Some.
-                    // We do not return, but poll `FuturesUnordered`
-                    // in the next loop iteration.
-                }
-                None => return Poll::Ready(None),
-            }
-        }
-    }
-}
-
-impl<St: Stream + Unpin> FusedStream for SelectAll<St> {
-    fn is_terminated(&self) -> bool {
-        self.inner.is_terminated()
-    }
-}
-
-/// Convert a list of streams into a `Stream` of results from the streams.
-///
-/// This essentially takes a list of streams (e.g. a vector, an iterator, etc.)
-/// and bundles them together into a single stream.
-/// The stream will yield items as they become available on the underlying
-/// streams internally, in the order they become available.
-///
-/// Note that the returned set can also be used to dynamically push more
-/// futures into the set as they become available.
-///
-/// This function is only available when the `std` or `alloc` feature of this
-/// library is activated, and it is activated by default.
-pub fn select_all<I>(streams: I) -> SelectAll<I::Item>
-where
-    I: IntoIterator,
-    I::Item: Stream + Unpin,
-{
-    let set = SelectAll::new();
-
-    for stream in streams {
-        set.push(stream);
-    }
-
-    set
-}
-
-impl<St: Stream + Unpin> FromIterator<St> for SelectAll<St> {
-    fn from_iter<T: IntoIterator<Item = St>>(iter: T) -> Self {
-        select_all(iter)
-    }
-}
-
-impl<St: Stream + Unpin> Extend<St> for SelectAll<St> {
-    fn extend<T: IntoIterator<Item = St>>(&mut self, iter: T) {
-        for st in iter {
-            self.push(st)
-        }
-    }
-}

helix-lsp/src/transport.rs

@@ -1,19 +1,18 @@
-use std::collections::HashMap;
-use std::io;
-
-use log::{error, info};
-
-use crate::Error;
-
-type Result<T> = core::result::Result<T, Error>;
-
+use crate::Result;
+use anyhow::Context;
 use jsonrpc_core as jsonrpc;
+use log::{error, info};
+use serde::{Deserialize, Serialize};
 use serde_json::Value;
-
+use std::collections::HashMap;
+use std::sync::Arc;
 use tokio::{
     io::{AsyncBufRead, AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader, BufWriter},
     process::{ChildStderr, ChildStdin, ChildStdout},
-    sync::mpsc::{unbounded_channel, Sender, UnboundedReceiver, UnboundedSender},
+    sync::{
+        mpsc::{unbounded_channel, Sender, UnboundedReceiver, UnboundedSender},
+        Mutex,
+    },
 };
 
 #[derive(Debug)]
@@ -26,153 +25,165 @@ pub enum Payload {
     Response(jsonrpc::Output),
 }
 
-use serde::{Deserialize, Serialize};
 /// A type representing all possible values sent from the server to the client.
 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
 #[serde(deny_unknown_fields)]
 #[serde(untagged)]
-enum Message {
+enum ServerMessage {
     /// A regular JSON-RPC request output (single response).
     Output(jsonrpc::Output),
     /// A JSON-RPC request or notification.
     Call(jsonrpc::Call),
 }
 
+#[derive(Debug)]
 pub struct Transport {
-    incoming: UnboundedSender<jsonrpc::Call>,
-    outgoing: UnboundedReceiver<Payload>,
-
-    pending_requests: HashMap<jsonrpc::Id, Sender<Result<Value>>>,
-    headers: HashMap<String, String>,
-
-    writer: BufWriter<ChildStdin>,
-    reader: BufReader<ChildStdout>,
-    stderr: BufReader<ChildStderr>,
+    id: usize,
+    pending_requests: Mutex<HashMap<jsonrpc::Id, Sender<Result<Value>>>>,
 }
 
 impl Transport {
     pub fn start(
-        reader: BufReader<ChildStdout>,
-        writer: BufWriter<ChildStdin>,
-        stderr: BufReader<ChildStderr>,
-    ) -> (UnboundedReceiver<jsonrpc::Call>, UnboundedSender<Payload>) {
-        let (incoming, rx) = unbounded_channel();
-        let (tx, outgoing) = unbounded_channel();
+        server_stdout: BufReader<ChildStdout>,
+        server_stdin: BufWriter<ChildStdin>,
+        server_stderr: BufReader<ChildStderr>,
+        id: usize,
+    ) -> (
+        UnboundedReceiver<(usize, jsonrpc::Call)>,
+        UnboundedSender<Payload>,
+    ) {
+        let (client_tx, rx) = unbounded_channel();
+        let (tx, client_rx) = unbounded_channel();
 
         let transport = Self {
-            reader,
-            writer,
-            stderr,
-            incoming,
-            outgoing,
-            pending_requests: HashMap::default(),
-            headers: HashMap::default(),
+            id,
+            pending_requests: Mutex::new(HashMap::default()),
         };
 
-        tokio::spawn(transport.duplex());
+        let transport = Arc::new(transport);
+
+        tokio::spawn(Self::recv(transport.clone(), server_stdout, client_tx));
+        tokio::spawn(Self::err(transport.clone(), server_stderr));
+        tokio::spawn(Self::send(transport, server_stdin, client_rx));
 
         (rx, tx)
     }
 
-    async fn recv(
+    async fn recv_server_message(
         reader: &mut (impl AsyncBufRead + Unpin + Send),
-        headers: &mut HashMap<String, String>,
-    ) -> core::result::Result<Message, std::io::Error> {
-        // read headers
+        buffer: &mut String,
+    ) -> Result<ServerMessage> {
+        let mut content_length = None;
         loop {
-            let mut header = String::new();
-            // detect pipe closed if 0
-            reader.read_line(&mut header).await?;
-            let header = header.trim();
+            buffer.truncate(0);
+            reader.read_line(buffer).await?;
+            let header = buffer.trim();
 
             if header.is_empty() {
                 break;
             }
 
-            let parts: Vec<&str> = header.split(": ").collect();
-            if parts.len() != 2 {
-                return Err(std::io::Error::new(
-                    std::io::ErrorKind::Other,
-                    "Failed to parse header",
-                ));
+            let mut parts = header.split(": ");
+
+            match (parts.next(), parts.next(), parts.next()) {
+                (Some("Content-Length"), Some(value), None) => {
+                    content_length = Some(value.parse().context("invalid content length")?);
+                }
+                (Some(_), Some(_), None) => {}
+                _ => {
+                    return Err(std::io::Error::new(
+                        std::io::ErrorKind::Other,
+                        "Failed to parse header",
+                    )
+                    .into());
+                }
             }
-            headers.insert(parts[0].to_string(), parts[1].to_string());
         }
 
-        // find content-length
-        let content_length = headers.get("Content-Length").unwrap().parse().unwrap();
+        let content_length = content_length.context("missing content length")?;
 
+        //TODO: reuse vector
         let mut content = vec![0; content_length];
         reader.read_exact(&mut content).await?;
-        let msg = String::from_utf8(content).unwrap();
-
-        // read data
+        let msg = std::str::from_utf8(&content).context("invalid utf8 from server")?;
 
         info!("<- {}", msg);
 
         // try parsing as output (server response) or call (server request)
-        let output: serde_json::Result<Message> = serde_json::from_str(&msg);
+        let output: serde_json::Result<ServerMessage> = serde_json::from_str(msg);
 
         Ok(output?)
     }
 
-    async fn err(
+    async fn recv_server_error(
         err: &mut (impl AsyncBufRead + Unpin + Send),
-    ) -> core::result::Result<(), std::io::Error> {
-        let mut line = String::new();
-        err.read_line(&mut line).await?;
-        error!("err <- {}", line);
+        buffer: &mut String,
+    ) -> Result<()> {
+        buffer.truncate(0);
+        err.read_line(buffer).await?;
+        error!("err <- {}", buffer);
 
         Ok(())
     }
 
-    pub async fn send_payload(&mut self, payload: Payload) -> io::Result<()> {
-        match payload {
+    async fn send_payload_to_server(
+        &self,
+        server_stdin: &mut BufWriter<ChildStdin>,
+        payload: Payload,
+    ) -> Result<()> {
+        //TODO: reuse string
+        let json = match payload {
             Payload::Request { chan, value } => {
-                self.pending_requests.insert(value.id.clone(), chan);
-
-                let json = serde_json::to_string(&value)?;
-                self.send(json).await
+                self.pending_requests
+                    .lock()
+                    .await
+                    .insert(value.id.clone(), chan);
+                serde_json::to_string(&value)?
             }
-            Payload::Notification(value) => {
-                let json = serde_json::to_string(&value)?;
-                self.send(json).await
-            }
-            Payload::Response(error) => {
-                let json = serde_json::to_string(&error)?;
-                self.send(json).await
-            }
-        }
+            Payload::Notification(value) => serde_json::to_string(&value)?,
+            Payload::Response(error) => serde_json::to_string(&error)?,
+        };
+        self.send_string_to_server(server_stdin, json).await
     }
 
-    pub async fn send(&mut self, request: String) -> io::Result<()> {
+    async fn send_string_to_server(
+        &self,
+        server_stdin: &mut BufWriter<ChildStdin>,
+        request: String,
+    ) -> Result<()> {
         info!("-> {}", request);
 
         // send the headers
-        self.writer
+        server_stdin
             .write_all(format!("Content-Length: {}\r\n\r\n", request.len()).as_bytes())
             .await?;
 
         // send the body
-        self.writer.write_all(request.as_bytes()).await?;
+        server_stdin.write_all(request.as_bytes()).await?;
 
-        self.writer.flush().await?;
+        server_stdin.flush().await?;
 
         Ok(())
     }
 
-    async fn recv_msg(&mut self, msg: Message) -> anyhow::Result<()> {
+    async fn process_server_message(
+        &self,
+        client_tx: &UnboundedSender<(usize, jsonrpc::Call)>,
+        msg: ServerMessage,
+    ) -> Result<()> {
         match msg {
-            Message::Output(output) => self.recv_response(output).await?,
-            Message::Call(call) => {
-                self.incoming.send(call).unwrap();
+            ServerMessage::Output(output) => self.process_request_response(output).await?,
+            ServerMessage::Call(call) => {
+                client_tx
+                    .send((self.id, call))
+                    .context("failed to send a message to server")?;
                 // let notification = Notification::parse(&method, params);
             }
         };
         Ok(())
     }
 
-    async fn recv_response(&mut self, output: jsonrpc::Output) -> io::Result<()> {
+    async fn process_request_response(&self, output: jsonrpc::Output) -> Result<()> {
         let (id, result) = match output {
             jsonrpc::Output::Success(jsonrpc::Success { id, result, .. }) => {
                 info!("<- {}", result);
@@ -186,6 +197,8 @@ impl Transport {
 
         let tx = self
             .pending_requests
+            .lock()
+            .await
             .remove(&id)
             .expect("pending_request with id not found!");
 
@@ -200,30 +213,51 @@ impl Transport {
         Ok(())
     }
 
-    pub async fn duplex(mut self) {
+    async fn recv(
+        transport: Arc<Self>,
+        mut server_stdout: BufReader<ChildStdout>,
+        client_tx: UnboundedSender<(usize, jsonrpc::Call)>,
+    ) {
+        let mut recv_buffer = String::new();
         loop {
-            tokio::select! {
-                // client -> server
-                msg = self.outgoing.recv() => {
-                    if msg.is_none() {
-                        break;
-                    }
-                    let msg = msg.unwrap();
-
-                    self.send_payload(msg).await.unwrap();
+            match Self::recv_server_message(&mut server_stdout, &mut recv_buffer).await {
+                Ok(msg) => {
+                    transport
+                        .process_server_message(&client_tx, msg)
+                        .await
+                        .unwrap();
                 }
-                // server <- client
-                msg = Self::recv(&mut self.reader, &mut self.headers) => {
-                    if msg.is_err() {
-                        error!("err: <- {:?}", msg);
-                        break;
-                    }
-                    let msg = msg.unwrap();
-
-                    self.recv_msg(msg).await.unwrap();
+                Err(err) => {
+                    error!("err: <- {:?}", err);
+                    break;
                 }
-                _msg = Self::err(&mut self.stderr) => {}
             }
         }
     }
+
+    async fn err(_transport: Arc<Self>, mut server_stderr: BufReader<ChildStderr>) {
+        let mut recv_buffer = String::new();
+        loop {
+            match Self::recv_server_error(&mut server_stderr, &mut recv_buffer).await {
+                Ok(_) => {}
+                Err(err) => {
+                    error!("err: <- {:?}", err);
+                    break;
+                }
+            }
+        }
+    }
+
+    async fn send(
+        transport: Arc<Self>,
+        mut server_stdin: BufWriter<ChildStdin>,
+        mut client_rx: UnboundedReceiver<Payload>,
+    ) {
+        while let Some(msg) = client_rx.recv().await {
+            transport
+                .send_payload_to_server(&mut server_stdin, msg)
+                .await
+                .unwrap()
+        }
+    }
 }

helix-syntax/Cargo.toml

@@ -1,16 +1,21 @@
 [package]
 name = "helix-syntax"
-version = "0.1.0"
+version = "0.4.1"
 authors = ["Blaž Hrastnik <blaz@mxxn.io>"]
 edition = "2018"
 license = "MPL-2.0"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+description = "Tree-sitter grammars support"
+categories = ["editor"]
+repository = "https://github.com/helix-editor/helix"
+homepage = "https://helix-editor.com"
+include = ["src/**/*", "languages/**/*", "build.rs", "!**/docs/**/*", "!**/test/**/*", "!**/examples/**/*", "!**/build/**/*"]
 
 [dependencies]
 tree-sitter = "0.19"
-serde = { version = "1.0", features = ["derive"] }
+libloading = "0.7"
+anyhow = "1"
 
 [build-dependencies]
-cc = { version = "1",  features = ["parallel"] }
+cc = { version = "1" }
 threadpool = { version = "1.0" }
+anyhow = "1"

helix-syntax/build.rs

@@ -1,84 +1,147 @@
-use std::path::PathBuf;
-use std::{env, fs};
+use anyhow::{anyhow, Context, Result};
+use std::fs;
+use std::time::SystemTime;
+use std::{
+    path::{Path, PathBuf},
+    process::Command,
+};
 
 use std::sync::mpsc::channel;
 
-fn get_opt_level() -> u32 {
-    env::var("OPT_LEVEL").unwrap().parse::<u32>().unwrap()
-}
-
-fn get_debug() -> bool {
-    env::var("DEBUG").unwrap() == "true"
-}
-
-fn collect_tree_sitter_dirs(ignore: &[String]) -> Vec<String> {
+fn collect_tree_sitter_dirs(ignore: &[String]) -> Result<Vec<String>> {
     let mut dirs = Vec::new();
-    for entry in fs::read_dir("languages").unwrap().flatten() {
-        let path = entry.path();
-        let dir = path.file_name().unwrap().to_str().unwrap().to_string();
-        if !ignore.contains(&dir) {
-            dirs.push(dir);
-        }
-    }
-    dirs
-}
+    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("languages");
 
-fn collect_src_files(dir: &str) -> (Vec<String>, Vec<String>) {
-    eprintln!("Collect files for {}", dir);
-
-    let mut c_files = Vec::new();
-    let mut cpp_files = Vec::new();
-    let path = PathBuf::from("languages").join(&dir).join("src");
-    for entry in fs::read_dir(path).unwrap().flatten() {
+    for entry in fs::read_dir(path)? {
+        let entry = entry?;
         let path = entry.path();
-        if path
-            .file_stem()
-            .unwrap()
-            .to_str()
-            .unwrap()
-            .starts_with("binding")
-        {
+
+        if !entry.file_type()?.is_dir() {
             continue;
         }
-        if let Some(ext) = path.extension() {
-            if ext == "c" {
-                c_files.push(path.to_str().unwrap().to_string());
-            } else if ext == "cc" || ext == "cpp" || ext == "cxx" {
-                cpp_files.push(path.to_str().unwrap().to_string());
+
+        let dir = path.file_name().unwrap().to_str().unwrap().to_string();
+
+        // filter ignores
+        if ignore.contains(&dir) {
+            continue;
+        }
+        dirs.push(dir)
+    }
+
+    Ok(dirs)
+}
+
+#[cfg(unix)]
+const DYLIB_EXTENSION: &str = "so";
+
+#[cfg(windows)]
+const DYLIB_EXTENSION: &str = "dll";
+
+fn build_library(src_path: &Path, language: &str) -> Result<()> {
+    let header_path = src_path;
+    // let grammar_path = src_path.join("grammar.json");
+    let parser_path = src_path.join("parser.c");
+    let mut scanner_path = src_path.join("scanner.c");
+
+    let scanner_path = if scanner_path.exists() {
+        Some(scanner_path)
+    } else {
+        scanner_path.set_extension("cc");
+        if scanner_path.exists() {
+            Some(scanner_path)
+        } else {
+            None
+        }
+    };
+    let parser_lib_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../runtime/grammars");
+    let mut library_path = parser_lib_path.join(language);
+    library_path.set_extension(DYLIB_EXTENSION);
+
+    let recompile = needs_recompile(&library_path, &parser_path, &scanner_path)
+        .with_context(|| "Failed to compare source and binary timestamps")?;
+
+    if !recompile {
+        return Ok(());
+    }
+    let mut config = cc::Build::new();
+    config.cpp(true).opt_level(2).cargo_metadata(false);
+    let compiler = config.get_compiler();
+    let mut command = Command::new(compiler.path());
+    command.current_dir(src_path);
+    for (key, value) in compiler.env() {
+        command.env(key, value);
+    }
+
+    if cfg!(windows) {
+        command
+            .args(&["/nologo", "/LD", "/I"])
+            .arg(header_path)
+            .arg("/Od");
+        if let Some(scanner_path) = scanner_path.as_ref() {
+            command.arg(scanner_path);
+        }
+
+        command
+            .arg(parser_path)
+            .arg("/link")
+            .arg(format!("/out:{}", library_path.to_str().unwrap()));
+    } else {
+        command
+            .arg("-shared")
+            .arg("-fPIC")
+            .arg("-fno-exceptions")
+            .arg("-g")
+            .arg("-I")
+            .arg(header_path)
+            .arg("-o")
+            .arg(&library_path)
+            .arg("-O2");
+        if let Some(scanner_path) = scanner_path.as_ref() {
+            if scanner_path.extension() == Some("c".as_ref()) {
+                command.arg("-xc").arg("-std=c99").arg(scanner_path);
+            } else {
+                command.arg(scanner_path);
             }
         }
+        command.arg("-xc").arg(parser_path);
     }
-    (c_files, cpp_files)
+
+    let output = command
+        .output()
+        .with_context(|| "Failed to execute C compiler")?;
+    if !output.status.success() {
+        return Err(anyhow!(
+            "Parser compilation failed.\nStdout: {}\nStderr: {}",
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        ));
+    }
+
+    Ok(())
+}
+fn needs_recompile(
+    lib_path: &Path,
+    parser_c_path: &Path,
+    scanner_path: &Option<PathBuf>,
+) -> Result<bool> {
+    if !lib_path.exists() {
+        return Ok(true);
+    }
+    let lib_mtime = mtime(lib_path)?;
+    if mtime(parser_c_path)? > lib_mtime {
+        return Ok(true);
+    }
+    if let Some(scanner_path) = scanner_path {
+        if mtime(scanner_path)? > lib_mtime {
+            return Ok(true);
+        }
+    }
+    Ok(false)
 }
 
-fn build_c(files: Vec<String>, language: &str) {
-    let mut build = cc::Build::new();
-    for file in files {
-        build
-            .file(&file)
-            .include(PathBuf::from(file).parent().unwrap())
-            .pic(true)
-            .opt_level(get_opt_level())
-            .debug(get_debug())
-            .warnings(false)
-            .flag_if_supported("-std=c99");
-    }
-    build.compile(&format!("tree-sitter-{}-c", language));
-}
-
-fn build_cpp(files: Vec<String>, language: &str) {
-    let mut build = cc::Build::new();
-    for file in files {
-        build
-            .file(&file)
-            .include(PathBuf::from(file).parent().unwrap())
-            .pic(true)
-            .opt_level(get_opt_level())
-            .debug(get_debug())
-            .warnings(false)
-            .cpp(true);
-    }
-    build.compile(&format!("tree-sitter-{}-cpp", language));
+fn mtime(path: &Path) -> Result<SystemTime> {
+    Ok(fs::metadata(path)?.modified()?)
 }
 
 fn build_dir(dir: &str, language: &str) {
@@ -97,18 +160,21 @@ fn build_dir(dir: &str, language: &str) {
         eprintln!("You can fix in using 'git submodule init && git submodule update --recursive'.");
         std::process::exit(1);
     }
-    let (c, cpp) = collect_src_files(dir);
-    if !c.is_empty() {
-        build_c(c, language);
-    }
-    if !cpp.is_empty() {
-        build_cpp(cpp, language);
-    }
+
+    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("languages")
+        .join(dir)
+        .join("src");
+
+    build_library(&path, language).unwrap();
 }
 
 fn main() {
-    let ignore = vec!["tree-sitter-typescript".to_string()];
-    let dirs = collect_tree_sitter_dirs(&ignore);
+    let ignore = vec![
+        "tree-sitter-typescript".to_string(),
+        "tree-sitter-haskell".to_string(), // aarch64 failures: https://github.com/tree-sitter/tree-sitter-haskell/issues/34
+    ];
+    let dirs = collect_tree_sitter_dirs(&ignore).unwrap();
 
     let mut n_jobs = 0;
     let pool = threadpool::Builder::new().build(); // by going through the builder, it'll use num_cpus
@@ -119,7 +185,7 @@ fn main() {
         n_jobs += 1;
 
         pool.execute(move || {
-            let language = &dir[12..]; // skip tree-sitter- prefix
+            let language = &dir.strip_prefix("tree-sitter-").unwrap();
             build_dir(&dir, language);
 
             // report progress

helix-syntax/src/lib.rs

@@ -1,91 +1,31 @@
-use serde::{Deserialize, Serialize};
+use anyhow::{Context, Result};
+use libloading::{Library, Symbol};
 use tree_sitter::Language;
 
-#[macro_export]
-macro_rules! mk_extern {
-    ( $( $name:ident ),* ) => {
-        $(
-            extern "C" { pub fn $name() -> Language; }
-        )*
-    };
+fn replace_dashes_with_underscores(name: &str) -> String {
+    name.replace('-', "_")
 }
+#[cfg(unix)]
+const DYLIB_EXTENSION: &str = "so";
 
-#[macro_export]
-macro_rules! mk_enum {
-    ( $( $camel:ident ),* ) => {
-        #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
-        #[serde(rename_all = "lowercase")]
-        pub enum Lang {
-            $(
-                $camel,
-            )*
-        }
+#[cfg(windows)]
+const DYLIB_EXTENSION: &str = "dll";
+
+pub fn get_language(runtime_path: &std::path::Path, name: &str) -> Result<Language> {
+    let name = name.to_ascii_lowercase();
+    let mut library_path = runtime_path.join("grammars").join(&name);
+    // TODO: duplicated under build
+    library_path.set_extension(DYLIB_EXTENSION);
+
+    let library = unsafe { Library::new(&library_path) }
+        .with_context(|| format!("Error opening dynamic library {:?}", &library_path))?;
+    let language_fn_name = format!("tree_sitter_{}", replace_dashes_with_underscores(&name));
+    let language = unsafe {
+        let language_fn: Symbol<unsafe extern "C" fn() -> Language> = library
+            .get(language_fn_name.as_bytes())
+            .with_context(|| format!("Failed to load symbol {}", language_fn_name))?;
+        language_fn()
     };
+    std::mem::forget(library);
+    Ok(language)
 }
-
-#[macro_export]
-macro_rules! mk_get_language {
-    ( $( ($camel:ident, $name:ident) ),* ) => {
-        #[must_use]
-        pub fn get_language(lang: Lang) -> Language {
-            unsafe {
-                match lang {
-                    $(
-                        Lang::$camel => $name(),
-                    )*
-                }
-            }
-        }
-    };
-}
-
-#[macro_export]
-macro_rules! mk_get_language_name {
-    ( $( $camel:ident ),* ) => {
-        #[must_use]
-        pub const fn get_language_name(lang: Lang) -> &'static str {
-            match lang {
-                $(
-                    Lang::$camel => stringify!($camel),
-                )*
-            }
-        }
-    };
-}
-
-#[macro_export]
-macro_rules! mk_langs {
-    ( $( ($camel:ident, $name:ident) ),* ) => {
-        mk_extern!($( $name ),*);
-        mk_enum!($( $camel ),*);
-        mk_get_language!($( ($camel, $name) ),*);
-        mk_get_language_name!($( $camel ),*);
-    };
-}
-
-mk_langs!(
-    // 1) Name for enum
-    // 2) tree-sitter function to call to get a Language
-    (Agda, tree_sitter_agda),
-    (Bash, tree_sitter_bash),
-    (C, tree_sitter_c),
-    (CSharp, tree_sitter_c_sharp),
-    (Cpp, tree_sitter_cpp),
-    (Css, tree_sitter_css),
-    (Go, tree_sitter_go),
-    // (Haskell, tree_sitter_haskell),
-    (Html, tree_sitter_html),
-    (Java, tree_sitter_java),
-    (Javascript, tree_sitter_javascript),
-    (Json, tree_sitter_json),
-    (Julia, tree_sitter_julia),
-    (Php, tree_sitter_php),
-    (Python, tree_sitter_python),
-    (Ruby, tree_sitter_ruby),
-    (Rust, tree_sitter_rust),
-    (Scala, tree_sitter_scala),
-    (Swift, tree_sitter_swift),
-    (Toml, tree_sitter_toml),
-    (Tsx, tree_sitter_tsx),
-    (Typescript, tree_sitter_typescript)
-);

helix-term/Cargo.toml

@@ -1,30 +1,38 @@
 [package]
 name = "helix-term"
-version = "0.1.0"
+version = "0.4.1"
 description = "A post-modern text editor."
 authors = ["Blaž Hrastnik <blaz@mxxn.io>"]
 edition = "2018"
 license = "MPL-2.0"
+categories = ["editor", "command-line-utilities"]
+repository = "https://github.com/helix-editor/helix"
+homepage = "https://helix-editor.com"
+include = ["src/**/*", "README.md"]
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[package.metadata.nix]
+build = true
+app = true
+
+[features]
 
 [[bin]]
 name = "hx"
 path = "src/main.rs"
 
 [dependencies]
-helix-core = { path = "../helix-core" }
-helix-view = { path = "../helix-view", features = ["term"]}
-helix-lsp = { path = "../helix-lsp"}
+helix-core = { version = "0.4", path = "../helix-core" }
+helix-view = { version = "0.4", path = "../helix-view" }
+helix-lsp = { version = "0.4", path = "../helix-lsp" }
 
 anyhow = "1"
-once_cell = "1.4"
+once_cell = "1.8"
 
-tokio = { version = "1", features = ["full"] }
+tokio = { version = "1", features = ["rt", "rt-multi-thread", "io-util", "io-std", "time", "process", "macros", "fs", "parking_lot"] }
 num_cpus = "1"
 tui = { path = "../helix-tui", package = "helix-tui", default-features = false, features = ["crossterm"] }
-crossterm = { version = "0.19", features = ["event-stream"] }
-clap = { version = "3.0.0-beta.2 ", default-features = false, features = ["std", "cargo"] }
+crossterm = { version = "0.20", features = ["event-stream"] }
+signal-hook = "0.3"
 
 futures-util = { version = "0.3", features = ["std", "async-await"], default-features = false }
 
@@ -37,7 +45,7 @@ log = "0.4"
 fuzzy-matcher = "0.3"
 ignore = "0.4"
 # shellexpand = "2.1"
-dirs-next = "2.0"
+# dirs-next = "2.0"
 # markdown doc rendering
 pulldown-cmark = { version = "0.8", default-features = false }
 
@@ -46,3 +54,6 @@ toml = "0.5"
 
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
+
+[target.'cfg(not(windows))'.dependencies]  # https://github.com/vorner/signal-hook/issues/100
+signal-hook-tokio = { version = "0.3", features = ["futures-v0_3"] }

helix-term/README.md

@@ -1,7 +0,0 @@
-
-window -> buffer -> text
-\-> contains "view", a viewport into the buffer
-
-view
-\-> selections etc
--> cursor

helix-term/src/application.rs

@@ -1,67 +1,137 @@
-use clap::ArgMatches as Args;
+use helix_core::syntax;
+use helix_lsp::{lsp, util::lsp_pos_to_pos, LspProgressMap};
+use helix_view::{theme, Editor};
 
-use helix_view::{document::Mode, Document, Editor, Theme, View};
+use crate::{args::Args, compositor::Compositor, config::Config, job::Jobs, ui};
 
-use crate::{compositor::Compositor, ui};
-
-use log::{error, info};
+use log::error;
 
 use std::{
-    future::Future,
-    io::{self, stdout, Stdout, Write},
-    path::PathBuf,
+    io::{stdout, Write},
     sync::Arc,
-    time::Duration,
+    time::{Duration, Instant},
 };
 
 use anyhow::Error;
 
 use crossterm::{
-    event::{Event, EventStream},
+    event::{DisableMouseCapture, EnableMouseCapture, Event, EventStream},
     execute, terminal,
 };
-
-use tui::layout::Rect;
-
-use futures_util::stream::FuturesUnordered;
-use std::pin::Pin;
-
-type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
-pub type LspCallback =
-    BoxFuture<Result<Box<dyn FnOnce(&mut Editor, &mut Compositor) + Send>, anyhow::Error>>;
-
-pub type LspCallbacks = FuturesUnordered<LspCallback>;
-pub type LspCallbackWrapper = Box<dyn FnOnce(&mut Editor, &mut Compositor) + Send>;
+#[cfg(not(windows))]
+use {
+    signal_hook::{consts::signal, low_level},
+    signal_hook_tokio::Signals,
+};
+#[cfg(windows)]
+type Signals = futures_util::stream::Empty<()>;
 
 pub struct Application {
     compositor: Compositor,
     editor: Editor,
 
-    callbacks: LspCallbacks,
+    // TODO should be separate to take only part of the config
+    config: Config,
+
+    // Currently never read from.  Remove the `allow(dead_code)` when
+    // that changes.
+    #[allow(dead_code)]
+    theme_loader: Arc<theme::Loader>,
+
+    // Currently never read from.  Remove the `allow(dead_code)` when
+    // that changes.
+    #[allow(dead_code)]
+    syn_loader: Arc<syntax::Loader>,
+
+    signals: Signals,
+    jobs: Jobs,
+    lsp_progress: LspProgressMap,
 }
 
 impl Application {
-    pub fn new(mut args: Args) -> Result<Self, Error> {
+    pub fn new(args: Args, mut config: Config) -> Result<Self, Error> {
         use helix_view::editor::Action;
         let mut compositor = Compositor::new()?;
         let size = compositor.size();
-        let mut editor = Editor::new(size);
 
-        if let Ok(files) = args.values_of_t::<PathBuf>("files") {
-            for file in files {
-                editor.open(file, Action::VerticalSplit)?;
+        let conf_dir = helix_core::config_dir();
+
+        let theme_loader =
+            std::sync::Arc::new(theme::Loader::new(&conf_dir, &helix_core::runtime_dir()));
+
+        // load $HOME/.config/helix/languages.toml, fallback to default config
+        let lang_conf = std::fs::read(conf_dir.join("languages.toml"));
+        let lang_conf = lang_conf
+            .as_deref()
+            .unwrap_or(include_bytes!("../../languages.toml"));
+
+        let theme = if let Some(theme) = &config.theme {
+            match theme_loader.load(theme) {
+                Ok(theme) => theme,
+                Err(e) => {
+                    log::warn!("failed to load theme `{}` - {}", theme, e);
+                    theme_loader.default()
+                }
+            }
+        } else {
+            theme_loader.default()
+        };
+
+        let syn_loader_conf = toml::from_slice(lang_conf).expect("Could not parse languages.toml");
+        let syn_loader = std::sync::Arc::new(syntax::Loader::new(syn_loader_conf));
+
+        let mut editor = Editor::new(
+            size,
+            theme_loader.clone(),
+            syn_loader.clone(),
+            config.editor.clone(),
+        );
+
+        let editor_view = Box::new(ui::EditorView::new(std::mem::take(&mut config.keys)));
+        compositor.push(editor_view);
+
+        if !args.files.is_empty() {
+            let first = &args.files[0]; // we know it's not empty
+            if first.is_dir() {
+                editor.new_file(Action::VerticalSplit);
+                compositor.push(Box::new(ui::file_picker(first.clone())));
+            } else {
+                let nr_of_files = args.files.len();
+                editor.open(first.to_path_buf(), Action::VerticalSplit)?;
+                for file in args.files {
+                    if file.is_dir() {
+                        return Err(anyhow::anyhow!(
+                            "expected a path to file, found a directory. (to open a directory pass it as first argument)"
+                        ));
+                    } else {
+                        editor.open(file.to_path_buf(), Action::Load)?;
+                    }
+                }
+                editor.set_status(format!("Loaded {} files.", nr_of_files));
             }
         } else {
             editor.new_file(Action::VerticalSplit);
         }
 
-        compositor.push(Box::new(ui::EditorView::new()));
+        editor.set_theme(theme);
 
-        let mut app = Self {
+        #[cfg(windows)]
+        let signals = futures_util::stream::empty();
+        #[cfg(not(windows))]
+        let signals = Signals::new(&[signal::SIGTSTP, signal::SIGCONT])?;
+
+        let app = Self {
             compositor,
             editor,
 
-            callbacks: FuturesUnordered::new(),
+            config,
+
+            theme_loader,
+            syn_loader,
+
+            signals,
+            jobs: Jobs::new(),
+            lsp_progress: LspProgressMap::new(),
         };
 
         Ok(app)
@@ -70,11 +140,11 @@ impl Application {
     fn render(&mut self) {
         let editor = &mut self.editor;
         let compositor = &mut self.compositor;
-        let callbacks = &mut self.callbacks;
+        let jobs = &mut self.jobs;
 
         let mut cx = crate::compositor::Context {
             editor,
-            callbacks,
+            jobs,
             scroll: None,
         };
 
@@ -83,44 +153,78 @@ impl Application {
 
     pub async fn event_loop(&mut self) {
         let mut reader = EventStream::new();
+        let mut last_render = Instant::now();
+        let deadline = Duration::from_secs(1) / 60;
 
         self.render();
 
         loop {
             if self.editor.should_close() {
+                self.jobs.finish();
                 break;
             }
 
             use futures_util::StreamExt;
 
             tokio::select! {
+                biased;
+
                 event = reader.next() => {
                     self.handle_terminal_events(event)
                 }
-                Some(call) = self.editor.language_servers.incoming.next() => {
-                    self.handle_language_server_message(call).await
+                Some(signal) = self.signals.next() => {
+                    self.handle_signals(signal).await;
                 }
-                Some(callback) = &mut self.callbacks.next() => {
-                    self.handle_language_server_callback(callback)
+                Some((id, call)) = self.editor.language_servers.incoming.next() => {
+                    self.handle_language_server_message(call, id).await;
+                    // limit render calls for fast language server messages
+                    let last = self.editor.language_servers.incoming.is_empty();
+                    if last || last_render.elapsed() > deadline {
+                        self.render();
+                        last_render = Instant::now();
+                    }
+                }
+                Some(callback) = self.jobs.futures.next() => {
+                    self.jobs.handle_callback(&mut self.editor, &mut self.compositor, callback);
+                    self.render();
+                }
+                Some(callback) = self.jobs.wait_futures.next() => {
+                    self.jobs.handle_callback(&mut self.editor, &mut self.compositor, callback);
+                    self.render();
                 }
             }
         }
     }
-    pub fn handle_language_server_callback(
-        &mut self,
-        callback: Result<LspCallbackWrapper, anyhow::Error>,
-    ) {
-        if let Ok(callback) = callback {
-            // TODO: handle Err()
-            callback(&mut self.editor, &mut self.compositor);
-            self.render();
+
+    #[cfg(windows)]
+    // no signal handling available on windows
+    pub async fn handle_signals(&mut self, _signal: ()) {}
+
+    #[cfg(not(windows))]
+    pub async fn handle_signals(&mut self, signal: i32) {
+        use helix_view::graphics::Rect;
+        match signal {
+            signal::SIGTSTP => {
+                self.compositor.save_cursor();
+                self.restore_term().unwrap();
+                low_level::emulate_default_handler(signal::SIGTSTP).unwrap();
+            }
+            signal::SIGCONT => {
+                self.claim_term().await.unwrap();
+                // redraw the terminal
+                let Rect { width, height, .. } = self.compositor.size();
+                self.compositor.resize(width, height);
+                self.compositor.load_cursor();
+                self.render();
+            }
+            _ => unreachable!(),
         }
     }
 
     pub fn handle_terminal_events(&mut self, event: Option<Result<Event, crossterm::ErrorKind>>) {
         let mut cx = crate::compositor::Context {
             editor: &mut self.editor,
-            callbacks: &mut self.callbacks,
+            jobs: &mut self.jobs,
             scroll: None,
         };
         // Handle key events
@@ -141,8 +245,21 @@ impl Application {
         }
     }
 
-    pub async fn handle_language_server_message(&mut self, call: helix_lsp::Call) {
-        use helix_lsp::{Call, Notification};
+    pub async fn handle_language_server_message(
+        &mut self,
+        call: helix_lsp::Call,
+        server_id: usize,
+    ) {
+        use helix_lsp::{Call, MethodCall, Notification};
+        let editor_view = self
+            .compositor
+            .find(std::any::type_name::<ui::EditorView>())
+            .expect("expected at least one EditorView");
+        let editor_view = editor_view
+            .as_any_mut()
+            .downcast_mut::<ui::EditorView>()
+            .unwrap();
+
         match call {
             Call::Notification(helix_lsp::jsonrpc::Notification { method, params, .. }) => {
                 let notification = match Notification::parse(&method, params) {
@@ -150,7 +267,6 @@ impl Application {
                     None => return,
                 };
 
-                // TODO: parse should return Result/Option
                 match notification {
                     Notification::PublishDiagnostics(params) => {
                         let path = Some(params.uri.to_file_path().unwrap());
@@ -167,29 +283,39 @@ impl Application {
                             let diagnostics = params
                                 .diagnostics
                                 .into_iter()
-                                .map(|diagnostic| {
+                                .filter_map(|diagnostic| {
                                     use helix_core::{
-                                        diagnostic::{Range, Severity, Severity::*},
+                                        diagnostic::{Range, Severity::*},
                                         Diagnostic,
                                     };
-                                    use helix_lsp::{lsp, util::lsp_pos_to_pos};
                                     use lsp::DiagnosticSeverity;
 
                                     let language_server = doc.language_server().unwrap();
 
                                     // TODO: convert inside server
-                                    let start = lsp_pos_to_pos(
+                                    let start = if let Some(start) = lsp_pos_to_pos(
                                         text,
                                         diagnostic.range.start,
                                         language_server.offset_encoding(),
-                                    );
-                                    let end = lsp_pos_to_pos(
+                                    ) {
+                                        start
+                                    } else {
+                                        log::warn!("lsp position out of bounds - {:?}", diagnostic);
+                                        return None;
+                                    };
+
+                                    let end = if let Some(end) = lsp_pos_to_pos(
                                         text,
                                         diagnostic.range.end,
                                         language_server.offset_encoding(),
-                                    );
+                                    ) {
+                                        end
+                                    } else {
+                                        log::warn!("lsp position out of bounds - {:?}", diagnostic);
+                                        return None;
+                                    };
 
-                                    Diagnostic {
+                                    Some(Diagnostic {
                                         range: Range { start, end },
                                         line: diagnostic.range.start.line as usize,
                                         message: diagnostic.message,
@@ -203,13 +329,11 @@ impl Application {
                                         ),
                                         // code
                                         // source
-                                    }
+                                    })
                                 })
                                 .collect();
 
-                            doc.diagnostics = diagnostics;
-                            // TODO: we want to process all the events in queue, then render. publishDiagnostic tends to send a whole bunch of events
-                            self.render();
+                            doc.set_diagnostics(diagnostics);
                         }
                     }
                     Notification::ShowMessage(params) => {
@@ -218,12 +342,140 @@ impl Application {
                     Notification::LogMessage(params) => {
                         log::warn!("unhandled window/logMessage: {:?}", params);
                     }
-                    _ => unreachable!(),
+                    Notification::ProgressMessage(params) => {
+                        let lsp::ProgressParams { token, value } = params;
+
+                        let lsp::ProgressParamsValue::WorkDone(work) = value;
+                        let parts = match &work {
+                            lsp::WorkDoneProgress::Begin(lsp::WorkDoneProgressBegin {
+                                title,
+                                message,
+                                percentage,
+                                ..
+                            }) => (Some(title), message, percentage),
+                            lsp::WorkDoneProgress::Report(lsp::WorkDoneProgressReport {
+                                message,
+                                percentage,
+                                ..
+                            }) => (None, message, percentage),
+                            lsp::WorkDoneProgress::End(lsp::WorkDoneProgressEnd { message }) => {
+                                if message.is_some() {
+                                    (None, message, &None)
+                                } else {
+                                    self.lsp_progress.end_progress(server_id, &token);
+                                    if !self.lsp_progress.is_progressing(server_id) {
+                                        editor_view.spinners_mut().get_or_create(server_id).stop();
+                                    }
+                                    self.editor.clear_status();
+
+                                    // we want to render to clear any leftover spinners or messages
+                                    return;
+                                }
+                            }
+                        };
+
+                        let token_d: &dyn std::fmt::Display = match &token {
+                            lsp::NumberOrString::Number(n) => n,
+                            lsp::NumberOrString::String(s) => s,
+                        };
+
+                        let status = match parts {
+                            (Some(title), Some(message), Some(percentage)) => {
+                                format!("[{}] {}% {} - {}", token_d, percentage, title, message)
+                            }
+                            (Some(title), None, Some(percentage)) => {
+                                format!("[{}] {}% {}", token_d, percentage, title)
+                            }
+                            (Some(title), Some(message), None) => {
+                                format!("[{}] {} - {}", token_d, title, message)
+                            }
+                            (None, Some(message), Some(percentage)) => {
+                                format!("[{}] {}% {}", token_d, percentage, message)
+                            }
+                            (Some(title), None, None) => {
+                                format!("[{}] {}", token_d, title)
+                            }
+                            (None, Some(message), None) => {
+                                format!("[{}] {}", token_d, message)
+                            }
+                            (None, None, Some(percentage)) => {
+                                format!("[{}] {}%", token_d, percentage)
+                            }
+                            (None, None, None) => format!("[{}]", token_d),
+                        };
+
+                        if let lsp::WorkDoneProgress::End(_) = work {
+                            self.lsp_progress.end_progress(server_id, &token);
+                            if !self.lsp_progress.is_progressing(server_id) {
+                                editor_view.spinners_mut().get_or_create(server_id).stop();
+                            }
+                        } else {
+                            self.lsp_progress.update(server_id, token, work);
+                        }
+
+                        if self.config.lsp.display_messages {
+                            self.editor.set_status(status);
+                        }
+                    }
                 }
             }
-            Call::MethodCall(call) => {
-                error!("Method not found {}", call.method);
+            Call::MethodCall(helix_lsp::jsonrpc::MethodCall {
+                method, params, id, ..
+            }) => {
+                let call = match MethodCall::parse(&method, params) {
+                    Some(call) => call,
+                    None => {
+                        error!("Method not found {}", method);
+                        return;
+                    }
+                };
 
+                match call {
+                    MethodCall::WorkDoneProgressCreate(params) => {
+                        self.lsp_progress.create(server_id, params.token);
+
+                        let spinner = editor_view.spinners_mut().get_or_create(server_id);
+                        if spinner.is_stopped() {
+                            spinner.start();
+                        }
+
+                        let doc = self.editor.documents().find(|doc| {
+                            doc.language_server()
+                                .map(|server| server.id() == server_id)
+                                .unwrap_or_default()
+                        });
+                        match doc {
+                            Some(doc) => {
+                                // it's ok to unwrap, we check for the language server before
+                                let server = doc.language_server().unwrap();
+                                tokio::spawn(server.reply(id, Ok(serde_json::Value::Null)));
+                            }
+                            None => {
+                                if let Some(server) =
+                                    self.editor.language_servers.get_by_id(server_id)
+                                {
+                                    log::warn!(
+                                        "missing document with language server id `{}`",
+                                        server_id
+                                    );
+                                    tokio::spawn(server.reply(
+                                        id,
+                                        Err(helix_lsp::jsonrpc::Error {
+                                            code: helix_lsp::jsonrpc::ErrorCode::InternalError,
+                                            message: "document missing".to_string(),
+                                            data: None,
+                                        }),
+                                    ));
+                                } else {
+                                    log::warn!(
+                                        "can't find language server with id `{}`",
+                                        server_id
+                                    );
+                                }
+                            }
+                        }
+                    }
+                }
                 // self.language_server.reply(
                 //     call.id,
                 //     // TODO: make a Into trait that can cast to Err(jsonrpc::Error)
@@ -238,29 +490,48 @@ impl Application {
         }
     }
 
-    pub async fn run(&mut self) -> Result<(), Error> {
+    async fn claim_term(&mut self) -> Result<(), Error> {
         terminal::enable_raw_mode()?;
-
         let mut stdout = stdout();
-
         execute!(stdout, terminal::EnterAlternateScreen)?;
+        if self.config.editor.mouse {
+            execute!(stdout, EnableMouseCapture)?;
+        }
+        Ok(())
+    }
+
+    fn restore_term(&mut self) -> Result<(), Error> {
+        let mut stdout = stdout();
+        // reset cursor shape
+        write!(stdout, "\x1B[2 q")?;
+        execute!(stdout, DisableMouseCapture)?;
+        execute!(stdout, terminal::LeaveAlternateScreen)?;
+        terminal::disable_raw_mode()?;
+        Ok(())
+    }
+
+    pub async fn run(&mut self) -> Result<(), Error> {
+        self.claim_term().await?;
 
         // Exit the alternate screen and disable raw mode before panicking
         let hook = std::panic::take_hook();
         std::panic::set_hook(Box::new(move |info| {
-            execute!(std::io::stdout(), terminal::LeaveAlternateScreen);
-            terminal::disable_raw_mode();
+            // We can't handle errors properly inside this closure.  And it's
+            // probably not a good idea to `unwrap()` inside a panic handler.
+            // So we just ignore the `Result`s.
+            let _ = execute!(std::io::stdout(), DisableMouseCapture);
+            let _ = execute!(std::io::stdout(), terminal::LeaveAlternateScreen);
+            let _ = terminal::disable_raw_mode();
             hook(info);
         }));
 
         self.event_loop().await;
 
-        // reset cursor shape
-        write!(stdout, "\x1B[2 q");
+        if self.editor.close_language_servers(None).await.is_err() {
+            log::error!("Timed out waiting for language servers to shutdown");
+        };
 
-        execute!(stdout, terminal::LeaveAlternateScreen)?;
-
-        terminal::disable_raw_mode()?;
+        self.restore_term()?;
 
         Ok(())
     }

helix-term/src/args.rs

@@ -0,0 +1,53 @@
+use anyhow::{Error, Result};
+use std::path::PathBuf;
+
+#[derive(Default)]
+pub struct Args {
+    pub display_help: bool,
+    pub display_version: bool,
+    pub verbosity: u64,
+    pub files: Vec<PathBuf>,
+}
+
+impl Args {
+    pub fn parse_args() -> Result<Args> {
+        let mut args = Args::default();
+        let argv: Vec<String> = std::env::args().collect();
+        let mut iter = argv.iter();
+
+        iter.next(); // skip the program, we don't care about that
+
+        for arg in &mut iter {
+            match arg.as_str() {
+                "--" => break, // stop parsing at this point treat the remaining as files
+                "--version" => args.display_version = true,
+                "--help" => args.display_help = true,
+                arg if arg.starts_with("--") => {
+                    return Err(Error::msg(format!(
+                        "unexpected double dash argument: {}",
+                        arg
+                    )))
+                }
+                arg if arg.starts_with('-') => {
+                    let arg = arg.get(1..).unwrap().chars();
+                    for chr in arg {
+                        match chr {
+                            'v' => args.verbosity += 1,
+                            'V' => args.display_version = true,
+                            'h' => args.display_help = true,
+                            _ => return Err(Error::msg(format!("unexpected short arg {}", chr))),
+                        }
+                    }
+                }
+                arg => args.files.push(PathBuf::from(arg)),
+            }
+        }
+
+        // push the remaining args, if any to the files
+        for filename in iter {
+            args.files.push(PathBuf::from(filename));
+        }
+
+        Ok(args)
+    }
+}

helix-term/src/compositor.rs

@@ -1,10 +1,11 @@
 // Each component declares it's own size constraints and gets fitted based on it's parent.
 // Q: how does this work with popups?
 // cursive does compositor.screen_mut().add_layer_at(pos::absolute(x, y), <component>)
+use helix_core::Position;
+use helix_view::graphics::{CursorKind, Rect};
 
 use crossterm::event::Event;
-use helix_core::Position;
-use tui::{buffer::Buffer as Surface, layout::Rect};
+use tui::buffer::Buffer as Surface;
 
 pub type Callback = Box<dyn FnOnce(&mut Compositor)>;
 
@@ -24,17 +25,17 @@ pub enum EventResult {
 
 use helix_view::Editor;
 
-use crate::application::LspCallbacks;
+use crate::job::Jobs;
 
 pub struct Context<'a> {
     pub editor: &'a mut Editor,
     pub scroll: Option<usize>,
-    pub callbacks: &'a mut LspCallbacks,
+    pub jobs: &'a mut Jobs,
 }
 
 pub trait Component: Any + AnyComponent {
     /// Process input events, return true if handled.
-    fn handle_event(&mut self, event: Event, ctx: &mut Context) -> EventResult {
+    fn handle_event(&mut self, _event: Event, _ctx: &mut Context) -> EventResult {
         EventResult::Ignored
     }
     // , args: ()
@@ -45,15 +46,16 @@ pub trait Component: Any + AnyComponent {
     }
 
     /// Render the component onto the provided surface.
-    fn render(&self, area: Rect, frame: &mut Surface, ctx: &mut Context);
+    fn render(&mut self, area: Rect, frame: &mut Surface, ctx: &mut Context);
 
-    fn cursor_position(&self, area: Rect, ctx: &Editor) -> Option<Position> {
-        None
+    /// Get cursor position and cursor kind.
+    fn cursor(&self, _area: Rect, _ctx: &Editor) -> (Option<Position>, CursorKind) {
+        (None, CursorKind::Hidden)
     }
 
     /// May be used by the parent component to compute the child area.
     /// viewport is the maximum allowed area, and the child should stay within those bounds.
-    fn required_size(&mut self, viewport: (u16, u16)) -> Option<(u16, u16)> {
+    fn required_size(&mut self, _viewport: (u16, u16)) -> Option<(u16, u16)> {
         // TODO: for scrolling, the scroll wrapper should place a size + offset on the Context
         // that way render can use it
         None
@@ -66,21 +68,24 @@ pub trait Component: Any + AnyComponent {
 
 use anyhow::Error;
 use std::io::stdout;
-use tui::backend::CrosstermBackend;
+use tui::backend::{Backend, CrosstermBackend};
 type Terminal = tui::terminal::Terminal<CrosstermBackend<std::io::Stdout>>;
 
 pub struct Compositor {
     layers: Vec<Box<dyn Component>>,
     terminal: Terminal,
+
+    pub(crate) last_picker: Option<Box<dyn Component>>,
 }
 
 impl Compositor {
     pub fn new() -> Result<Self, Error> {
         let backend = CrosstermBackend::new(stdout());
-        let mut terminal = Terminal::new(backend)?;
+        let terminal = Terminal::new(backend)?;
         Ok(Self {
             layers: Vec::new(),
             terminal,
+            last_picker: None,
         })
     }
 
@@ -94,6 +99,21 @@ impl Compositor {
             .expect("Unable to resize terminal")
     }
 
+    pub fn save_cursor(&mut self) {
+        if self.terminal.cursor_kind() == CursorKind::Hidden {
+            self.terminal
+                .backend_mut()
+                .show_cursor(CursorKind::Block)
+                .ok();
+        }
+    }
+
+    pub fn load_cursor(&mut self) {
+        if self.terminal.cursor_kind() == CursorKind::Hidden {
+            self.terminal.backend_mut().hide_cursor().ok();
+        }
+    }
+
     pub fn push(&mut self, mut layer: Box<dyn Component>) {
         let size = self.size();
         // trigger required_size on init
@@ -101,8 +121,8 @@ impl Compositor {
         self.layers.push(layer);
     }
 
-    pub fn pop(&mut self) {
-        self.layers.pop();
+    pub fn pop(&mut self) -> Option<Box<dyn Component>> {
+        self.layers.pop()
     }
 
     pub fn handle_event(&mut self, event: Event, cx: &mut Context) -> bool {
@@ -122,27 +142,33 @@ impl Compositor {
     }
 
     pub fn render(&mut self, cx: &mut Context) {
-        let area = self.size();
+        self.terminal
+            .autoresize()
+            .expect("Unable to determine terminal size");
+
+        // TODO: need to recalculate view tree if necessary
+
         let surface = self.terminal.current_buffer_mut();
 
-        for layer in &self.layers {
-            layer.render(area, surface, cx)
+        let area = *surface.area();
+
+        for layer in &mut self.layers {
+            layer.render(area, surface, cx);
         }
 
-        let pos = self
-            .cursor_position(area, cx.editor)
-            .map(|pos| (pos.col as u16, pos.row as u16));
+        let (pos, kind) = self.cursor(area, cx.editor);
+        let pos = pos.map(|pos| (pos.col as u16, pos.row as u16));
 
-        self.terminal.draw(pos);
+        self.terminal.draw(pos, kind).unwrap();
     }
 
-    pub fn cursor_position(&self, area: Rect, editor: &Editor) -> Option<Position> {
+    pub fn cursor(&self, area: Rect, editor: &Editor) -> (Option<Position>, CursorKind) {
         for layer in self.layers.iter().rev() {
-            if let Some(pos) = layer.cursor_position(area, editor) {
-                return Some(pos);
+            if let (Some(pos), kind) = layer.cursor(area, editor) {
+                return (Some(pos), kind);
             }
         }
-        None
+        (None, CursorKind::Hidden)
     }
 
     pub fn find(&mut self, type_name: &str) -> Option<&mut dyn Component> {
@@ -174,10 +200,9 @@ pub trait AnyComponent {
     /// # Examples
     ///
     /// ```rust
-    /// # use cursive_core::views::TextComponent;
-    /// # use cursive_core::view::Component;
-    /// let boxed: Box<Component> = Box::new(TextComponent::new("text"));
-    /// let text: Box<TextComponent> = boxed.as_boxed_any().downcast().unwrap();
+    /// use helix_term::{ui::Text, compositor::Component};
+    /// let boxed: Box<Component> = Box::new(Text::new("text".to_string()));
+    /// let text: Box<Text> = boxed.as_boxed_any().downcast().unwrap();
     /// ```
     fn as_boxed_any(self: Box<Self>) -> Box<dyn Any>;
 }

helix-term/src/config.rs

@@ -0,0 +1,53 @@
+use serde::Deserialize;
+
+use crate::keymap::Keymaps;
+
+#[derive(Debug, Default, Clone, PartialEq, Deserialize)]
+pub struct Config {
+    pub theme: Option<String>,
+    #[serde(default)]
+    pub lsp: LspConfig,
+    #[serde(default)]
+    pub keys: Keymaps,
+    #[serde(default)]
+    pub editor: helix_view::editor::Config,
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct LspConfig {
+    pub display_messages: bool,
+}
+
+#[test]
+fn parsing_keymaps_config_file() {
+    use crate::keymap;
+    use crate::keymap::Keymap;
+    use helix_core::hashmap;
+    use helix_view::document::Mode;
+
+    let sample_keymaps = r#"
+            [keys.insert]
+            y = "move_line_down"
+            S-C-a = "delete_selection"
+
+            [keys.normal]
+            A-F12 = "move_next_word_end"
+        "#;
+
+    assert_eq!(
+        toml::from_str::<Config>(sample_keymaps).unwrap(),
+        Config {
+            keys: Keymaps(hashmap! {
+                Mode::Insert => Keymap::new(keymap!({ "Insert mode"
+                    "y" => move_line_down,
+                    "S-C-a" => delete_selection,
+                })),
+                Mode::Normal => Keymap::new(keymap!({ "Normal mode"
+                    "A-F12" => move_next_word_end,
+                })),
+            }),
+            ..Default::default()
+        }
+    );
+}

helix-term/src/job.rs

@@ -0,0 +1,100 @@
+use helix_view::Editor;
+
+use crate::compositor::Compositor;
+
+use futures_util::future::{self, BoxFuture, Future, FutureExt};
+use futures_util::stream::{FuturesUnordered, StreamExt};
+
+pub type Callback = Box<dyn FnOnce(&mut Editor, &mut Compositor) + Send>;
+pub type JobFuture = BoxFuture<'static, anyhow::Result<Option<Callback>>>;
+
+pub struct Job {
+    pub future: BoxFuture<'static, anyhow::Result<Option<Callback>>>,
+    /// Do we need to wait for this job to finish before exiting?
+    pub wait: bool,
+}
+
+#[derive(Default)]
+pub struct Jobs {
+    pub futures: FuturesUnordered<JobFuture>,
+    /// These are the ones that need to complete before we exit.
+    pub wait_futures: FuturesUnordered<JobFuture>,
+}
+
+impl Job {
+    pub fn new<F: Future<Output = anyhow::Result<()>> + Send + 'static>(f: F) -> Job {
+        Job {
+            future: f.map(|r| r.map(|()| None)).boxed(),
+            wait: false,
+        }
+    }
+
+    pub fn with_callback<F: Future<Output = anyhow::Result<Callback>> + Send + 'static>(
+        f: F,
+    ) -> Job {
+        Job {
+            future: f.map(|r| r.map(Some)).boxed(),
+            wait: false,
+        }
+    }
+
+    pub fn wait_before_exiting(mut self) -> Job {
+        self.wait = true;
+        self
+    }
+}
+
+impl Jobs {
+    pub fn new() -> Jobs {
+        Jobs::default()
+    }
+
+    pub fn spawn<F: Future<Output = anyhow::Result<()>> + Send + 'static>(&mut self, f: F) {
+        self.add(Job::new(f));
+    }
+
+    pub fn callback<F: Future<Output = anyhow::Result<Callback>> + Send + 'static>(
+        &mut self,
+        f: F,
+    ) {
+        self.add(Job::with_callback(f));
+    }
+
+    pub fn handle_callback(
+        &mut self,
+        editor: &mut Editor,
+        compositor: &mut Compositor,
+        call: anyhow::Result<Option<Callback>>,
+    ) {
+        match call {
+            Ok(None) => {}
+            Ok(Some(call)) => {
+                call(editor, compositor);
+            }
+            Err(e) => {
+                editor.set_error(format!("Async job failed: {}", e));
+            }
+        }
+    }
+
+    pub async fn next_job(&mut self) -> Option<anyhow::Result<Option<Callback>>> {
+        tokio::select! {
+            event = self.futures.next() => {  event }
+            event = self.wait_futures.next() => { event }
+        }
+    }
+
+    pub fn add(&mut self, j: Job) {
+        if j.wait {
+            self.wait_futures.push(j.future);
+        } else {
+            self.futures.push(j.future);
+        }
+    }
+
+    /// Blocks until all the jobs that need to be waited on are done.
+    pub fn finish(&mut self) {
+        let wait_futures = std::mem::take(&mut self.wait_futures);
+        helix_lsp::block_on(wait_futures.for_each(|_| future::ready(())));
+    }
+}

helix-term/src/keymap.rs

@@ -1,326 +1,629 @@
-use crate::commands::{self, Command};
+pub use crate::commands::Command;
+use crate::config::Config;
 use helix_core::hashmap;
-use helix_view::document::Mode;
-use std::collections::HashMap;
-
-// Kakoune-inspired:
-// mode = {
-//      normal = {
-//          q = record_macro
-//          w = (next) word
-//          W = next WORD
-//          e = end of word
-//          E = end of WORD
-//          r =
-//          t = 'till char
-//          y = yank
-//          u = undo
-//          U = redo
-//          i = insert
-//          I = INSERT (start of line)
-//          o = open below (insert on new line below)
-//          O = open above (insert on new line above)
-//          p = paste (before cursor)
-//          P = PASTE (after cursor)
-//          ` =
-//          [ = select to text object start (alt = select whole object)
-//          ] = select to text object end
-//          { = extend to inner object start
-//          } = extend to inner object end
-//          a = append
-//          A = APPEND (end of line)
-//          s = split
-//          S = select
-//          d = delete()
-//          f = find_char()
-//          g = goto (gg, G, gc, gd, etc)
-//
-//          h = move_char_left(n)
-//          j = move_line_down(n)
-//          k = move_line_up(n)
-//          l = move_char_right(n)
-//          : = command line
-//          ; = collapse selection to cursor
-//          " = use register
-//          ` = convert case? (to lower) (alt = swap case)
-//          ~ = convert to upper case
-//          . = repeat last command
-//          \ = disable hook?
-//          / = search
-//          > = indent
-//          < = deindent
-//          % = select whole buffer (in vim = jump to matching bracket)
-//          * = search pattern in selection
-//          ( = rotate main selection backward
-//          ) = rotate main selection forward
-//          - = trim selections? (alt = merge contiguous sel together)
-//          @ = convert tabs to spaces
-//          & = align cursor
-//          ? = extend to next given regex match (alt = to prev)
-//
-//          in kakoune these are alt-h alt-l / gh gl
-//                              select from curs to begin end / move curs to begin end
-//          0 = start of line
-//          ^ = start of line (first non blank char)
-//          $ = end of line
-//
-//          z = save selections
-//          Z = restore selections
-//          x = select line
-//          X = extend line
-//          c = change selected text
-//          C = copy selection?
-//          v = view menu (viewport manipulation)
-//          b = select to previous word start
-//          B = select to previous WORD start
-//
-//
-//
-//
-//
-//
-//          = = align?
-//          + =
-//      }
-//
-//      gd = goto definition
-//      gr = goto reference
-// }
-
-// #[cfg(feature = "term")]
-pub use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
-
-pub type Keymap = HashMap<KeyEvent, Command>;
-pub type Keymaps = HashMap<Mode, Keymap>;
+use helix_view::{document::Mode, info::Info, input::KeyEvent};
+use serde::Deserialize;
+use std::{
+    collections::HashMap,
+    ops::{Deref, DerefMut},
+};
 
 #[macro_export]
 macro_rules! key {
+    ($key:ident) => {
+        KeyEvent {
+            code: ::helix_view::keyboard::KeyCode::$key,
+            modifiers: ::helix_view::keyboard::KeyModifiers::NONE,
+        }
+    };
     ($($ch:tt)*) => {
         KeyEvent {
-            code: KeyCode::Char($($ch)*),
-            modifiers: KeyModifiers::NONE,
+            code: ::helix_view::keyboard::KeyCode::Char($($ch)*),
+            modifiers: ::helix_view::keyboard::KeyModifiers::NONE,
         }
     };
 }
 
-macro_rules! shift {
-    ($($ch:tt)*) => {
-        KeyEvent {
-            code: KeyCode::Char($($ch)*),
-            modifiers: KeyModifiers::SHIFT,
+/// Macro for defining the root of a `Keymap` object. Example:
+///
+/// ```
+/// # use helix_core::hashmap;
+/// # use helix_term::keymap;
+/// # use helix_term::keymap::Keymap;
+/// let normal_mode = keymap!({ "Normal mode"
+///     "i" => insert_mode,
+///     "g" => { "Goto"
+///         "g" => goto_file_start,
+///         "e" => goto_file_end,
+///     },
+///     "j" | "down" => move_line_down,
+/// });
+/// let keymap = Keymap::new(normal_mode);
+/// ```
+#[macro_export]
+macro_rules! keymap {
+    (@trie $cmd:ident) => {
+        $crate::keymap::KeyTrie::Leaf($crate::commands::Command::$cmd)
+    };
+
+    (@trie
+        { $label:literal $($($key:literal)|+ => $value:tt,)+ }
+    ) => {
+        keymap!({ $label $($($key)|+ => $value,)+ })
+    };
+
+    (
+        { $label:literal $($($key:literal)|+ => $value:tt,)+ }
+    ) => {
+        // modified from the hashmap! macro
+        {
+            let _cap = hashmap!(@count $($($key),+),*);
+            let mut _map = ::std::collections::HashMap::with_capacity(_cap);
+            let mut _order = ::std::vec::Vec::with_capacity(_cap);
+            $(
+                $(
+                    let _key = $key.parse::<::helix_view::input::KeyEvent>().unwrap();
+                    _map.insert(
+                        _key,
+                        keymap!(@trie $value)
+                    );
+                    _order.push(_key);
+                )+
+            )*
+            $crate::keymap::KeyTrie::Node($crate::keymap::KeyTrieNode::new($label, _map, _order))
         }
     };
 }
 
-macro_rules! ctrl {
-    ($($ch:tt)*) => {
-        KeyEvent {
-            code: KeyCode::Char($($ch)*),
-            modifiers: KeyModifiers::CONTROL,
-        }
-    };
+#[derive(Debug, Clone, Deserialize)]
+pub struct KeyTrieNode {
+    /// A label for keys coming under this node, like "Goto mode"
+    #[serde(skip)]
+    name: String,
+    #[serde(flatten)]
+    map: HashMap<KeyEvent, KeyTrie>,
+    #[serde(skip)]
+    order: Vec<KeyEvent>,
 }
 
-macro_rules! alt {
-    ($($ch:tt)*) => {
-        KeyEvent {
-            code: KeyCode::Char($($ch)*),
-            modifiers: KeyModifiers::ALT,
+impl KeyTrieNode {
+    pub fn new(name: &str, map: HashMap<KeyEvent, KeyTrie>, order: Vec<KeyEvent>) -> Self {
+        Self {
+            name: name.to_string(),
+            map,
+            order,
         }
-    };
+    }
+
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    /// Merge another Node in. Leaves and subnodes from the other node replace
+    /// corresponding keyevent in self, except when both other and self have
+    /// subnodes for same key. In that case the merge is recursive.
+    pub fn merge(&mut self, mut other: Self) {
+        for (key, trie) in std::mem::take(&mut other.map) {
+            if let Some(KeyTrie::Node(node)) = self.map.get_mut(&key) {
+                if let KeyTrie::Node(other_node) = trie {
+                    node.merge(other_node);
+                    continue;
+                }
+            }
+            self.map.insert(key, trie);
+        }
+
+        for &key in self.map.keys() {
+            if !self.order.contains(&key) {
+                self.order.push(key);
+            }
+        }
+    }
 }
 
-pub fn default() -> Keymaps {
-    let normal = hashmap!(
-        key!('h') => commands::move_char_left as Command,
-        key!('j') => commands::move_line_down,
-        key!('k') => commands::move_line_up,
-        key!('l') => commands::move_char_right,
+impl From<KeyTrieNode> for Info {
+    fn from(node: KeyTrieNode) -> Self {
+        let mut body: Vec<(&str, Vec<KeyEvent>)> = Vec::with_capacity(node.len());
+        for (&key, trie) in node.iter() {
+            let desc = match trie {
+                KeyTrie::Leaf(cmd) => cmd.doc(),
+                KeyTrie::Node(n) => n.name(),
+            };
+            match body.iter().position(|(d, _)| d == &desc) {
+                // FIXME: multiple keys are ordered randomly (use BTreeSet)
+                Some(pos) => body[pos].1.push(key),
+                None => body.push((desc, vec![key])),
+            }
+        }
+        body.sort_unstable_by_key(|(_, keys)| {
+            node.order.iter().position(|&k| k == keys[0]).unwrap()
+        });
+        let prefix = format!("{} ", node.name());
+        if body.iter().all(|(desc, _)| desc.starts_with(&prefix)) {
+            body = body
+                .into_iter()
+                .map(|(desc, keys)| (desc.strip_prefix(&prefix).unwrap(), keys))
+                .collect();
+        }
+        Info::key(node.name(), body)
+    }
+}
 
-        key!('t') => commands::find_till_char,
-        key!('f') => commands::find_next_char,
-        shift!('T') => commands::till_prev_char,
-        shift!('F') => commands::find_prev_char,
-        // and matching set for select mode (extend)
-        //
-        key!('r') => commands::replace,
+impl Default for KeyTrieNode {
+    fn default() -> Self {
+        Self::new("", HashMap::new(), Vec::new())
+    }
+}
 
-        key!('0') => commands::move_line_start,
-        key!('$') => commands::move_line_end,
+impl PartialEq for KeyTrieNode {
+    fn eq(&self, other: &Self) -> bool {
+        self.map == other.map
+    }
+}
 
-        key!('w') => commands::move_next_word_start,
-        key!('b') => commands::move_prev_word_start,
-        key!('e') => commands::move_next_word_end,
+impl Deref for KeyTrieNode {
+    type Target = HashMap<KeyEvent, KeyTrie>;
 
-        key!('v') => commands::select_mode,
-        key!('g') => commands::goto_mode,
-        key!(':') => commands::command_mode,
+    fn deref(&self) -> &Self::Target {
+        &self.map
+    }
+}
 
-        key!('i') => commands::insert_mode,
-        shift!('I') => commands::prepend_to_line,
-        key!('a') => commands::append_mode,
-        shift!('A') => commands::append_to_line,
-        key!('o') => commands::open_below,
-        shift!('O') => commands::open_above,
-        // [<space>  ]<space> equivalents too (add blank new line, no edit)
+impl DerefMut for KeyTrieNode {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.map
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+#[serde(untagged)]
+pub enum KeyTrie {
+    Leaf(Command),
+    Node(KeyTrieNode),
+}
+
+impl KeyTrie {
+    pub fn node(&self) -> Option<&KeyTrieNode> {
+        match *self {
+            KeyTrie::Node(ref node) => Some(node),
+            KeyTrie::Leaf(_) => None,
+        }
+    }
+
+    pub fn node_mut(&mut self) -> Option<&mut KeyTrieNode> {
+        match *self {
+            KeyTrie::Node(ref mut node) => Some(node),
+            KeyTrie::Leaf(_) => None,
+        }
+    }
+
+    /// Merge another KeyTrie in, assuming that this KeyTrie and the other
+    /// are both Nodes. Panics otherwise.
+    pub fn merge_nodes(&mut self, mut other: Self) {
+        let node = std::mem::take(other.node_mut().unwrap());
+        self.node_mut().unwrap().merge(node);
+    }
+
+    pub fn search(&self, keys: &[KeyEvent]) -> Option<&KeyTrie> {
+        let mut trie = self;
+        for key in keys {
+            trie = match trie {
+                KeyTrie::Node(map) => map.get(key),
+                // leaf encountered while keys left to process
+                KeyTrie::Leaf(_) => None,
+            }?
+        }
+        Some(trie)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum KeymapResult {
+    /// Needs more keys to execute a command. Contains valid keys for next keystroke.
+    Pending(KeyTrieNode),
+    Matched(Command),
+    /// Key was not found in the root keymap
+    NotFound,
+    /// Key is invalid in combination with previous keys. Contains keys leading upto
+    /// and including current (invalid) key.
+    Cancelled(Vec<KeyEvent>),
+}
+
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+pub struct Keymap {
+    /// Always a Node
+    #[serde(flatten)]
+    root: KeyTrie,
+    /// Stores pending keys waiting for the next key
+    #[serde(skip)]
+    state: Vec<KeyEvent>,
+}
+
+impl Keymap {
+    pub fn new(root: KeyTrie) -> Self {
+        Keymap {
+            root,
+            state: Vec::new(),
+        }
+    }
+
+    pub fn root(&self) -> &KeyTrie {
+        &self.root
+    }
+
+    /// Returns list of keys waiting to be disambiguated.
+    pub fn pending(&self) -> &[KeyEvent] {
+        &self.state
+    }
+
+    /// Lookup `key` in the keymap to try and find a command to execute
+    pub fn get(&mut self, key: KeyEvent) -> KeymapResult {
+        let &first = self.state.get(0).unwrap_or(&key);
+        let trie = match self.root.search(&[first]) {
+            Some(&KeyTrie::Leaf(cmd)) => return KeymapResult::Matched(cmd),
+            None => return KeymapResult::NotFound,
+            Some(t) => t,
+        };
+        self.state.push(key);
+        match trie.search(&self.state[1..]) {
+            Some(&KeyTrie::Node(ref map)) => KeymapResult::Pending(map.clone()),
+            Some(&KeyTrie::Leaf(command)) => {
+                self.state.clear();
+                KeymapResult::Matched(command)
+            }
+            None => KeymapResult::Cancelled(self.state.drain(..).collect()),
+        }
+    }
+
+    pub fn merge(&mut self, other: Self) {
+        self.root.merge_nodes(other.root);
+    }
+}
+
+impl Deref for Keymap {
+    type Target = KeyTrieNode;
+
+    fn deref(&self) -> &Self::Target {
+        self.root.node().unwrap()
+    }
+}
+
+impl Default for Keymap {
+    fn default() -> Self {
+        Self::new(KeyTrie::Node(KeyTrieNode::default()))
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+#[serde(transparent)]
+pub struct Keymaps(pub HashMap<Mode, Keymap>);
+
+impl Keymaps {
+    /// Returns list of keys waiting to be disambiguated in current mode.
+    pub fn pending(&self) -> &[KeyEvent] {
+        self.0
+            .values()
+            .find_map(|keymap| match keymap.pending().is_empty() {
+                true => None,
+                false => Some(keymap.pending()),
+            })
+            .unwrap_or_default()
+    }
+}
+
+impl Deref for Keymaps {
+    type Target = HashMap<Mode, Keymap>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for Keymaps {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl Default for Keymaps {
+    fn default() -> Keymaps {
+        let normal = keymap!({ "Normal mode"
+            "h" | "left" => move_char_left,
+            "j" | "down" => move_line_down,
+            "k" | "up" => move_line_up,
+            "l" | "right" => move_char_right,
+
+            "t" => find_till_char,
+            "f" => find_next_char,
+            "T" => till_prev_char,
+            "F" => find_prev_char,
+            "r" => replace,
+            "R" => replace_with_yanked,
+
+            "~" => switch_case,
+            "`" => switch_to_lowercase,
+            "A-`" => switch_to_uppercase,
+
+            "home" => goto_line_start,
+            "end" => goto_line_end,
+
+            "w" => move_next_word_start,
+            "b" => move_prev_word_start,
+            "e" => move_next_word_end,
+
+            "W" => move_next_long_word_start,
+            "B" => move_prev_long_word_start,
+            "E" => move_next_long_word_end,
+
+            "v" => select_mode,
+            "G" => goto_line,
+            "g" => { "Goto"
+                "g" => goto_file_start,
+                "e" => goto_last_line,
+                "h" => goto_line_start,
+                "l" => goto_line_end,
+                "s" => goto_first_nonwhitespace,
+                "d" => goto_definition,
+                "y" => goto_type_definition,
+                "r" => goto_reference,
+                "i" => goto_implementation,
+                "t" => goto_window_top,
+                "m" => goto_window_middle,
+                "b" => goto_window_bottom,
+                "a" => goto_last_accessed_file,
+            },
+            ":" => command_mode,
+
+            "i" => insert_mode,
+            "I" => prepend_to_line,
+            "a" => append_mode,
+            "A" => append_to_line,
+            "o" => open_below,
+            "O" => open_above,
+            // [<space>  ]<space> equivalents too (add blank new line, no edit)
+
+            "d" => delete_selection,
+            // TODO: also delete without yanking
+            "c" => change_selection,
+            // TODO: also change delete without yanking
+
+            "C" => copy_selection_on_next_line,
+            "A-C" => copy_selection_on_prev_line,
 
 
-        key!('d') => commands::delete_selection,
-        // TODO: also delete without yanking
-        key!('c') => commands::change_selection,
-        // TODO: also change delete without yanking
+            "s" => select_regex,
+            "A-s" => split_selection_on_newline,
+            "S" => split_selection,
+            ";" => collapse_selection,
+            "A-;" => flip_selections,
+            "%" => select_all,
+            "x" => extend_line,
+            "X" => extend_to_line_bounds,
+            // crop_to_whole_line
 
-        // key!('r') => commands::replace_with_char,
+            "m" => { "Match"
+                "m" => match_brackets,
+                "s" => surround_add,
+                "r" => surround_replace,
+                "d" => surround_delete,
+                "a" => select_textobject_around,
+                "i" => select_textobject_inner,
+            },
+            "[" => { "Left bracket"
+                "d" => goto_prev_diag,
+                "D" => goto_first_diag,
+            },
+            "]" => { "Right bracket"
+                "d" => goto_next_diag,
+                "D" => goto_last_diag,
+            },
 
-        key!('s') => commands::select_regex,
-        alt!('s') => commands::split_selection_on_newline,
-        shift!('S') => commands::split_selection,
-        key!(';') => commands::collapse_selection,
-        alt!(';') => commands::flip_selections,
-        key!('%') => commands::select_all,
-        key!('x') => commands::select_line,
-        shift!('X') => commands::extend_line,
-        // or select mode X?
-        // extend_to_whole_line, crop_to_whole_line
+            "/" => search,
+            // ? for search_reverse
+            "n" => search_next,
+            "N" => extend_search_next,
+            // N for search_prev
+            "*" => search_selection,
 
+            "u" => undo,
+            "U" => redo,
 
-        key!('m') => commands::match_brackets,
-        // TODO: refactor into
-        // key!('m') => commands::select_to_matching,
-        // key!('M') => commands::back_select_to_matching,
-        // select mode extend equivalents
+            "y" => yank,
+            // yank_all
+            "p" => paste_after,
+            // paste_all
+            "P" => paste_before,
 
-        // key!('.') => commands::repeat_insert,
-        // repeat_select
+            ">" => indent,
+            "<" => unindent,
+            "=" => format_selections,
+            "J" => join_selections,
+            // TODO: conflicts hover/doc
+            "K" => keep_selections,
+            // TODO: and another method for inverse
 
-        // TODO: figure out what key to use
-        key!('[') => commands::expand_selection,
+            // TODO: clashes with space mode
+            "space" => keep_primary_selection,
 
-        key!('/') => commands::search,
-        // ? for search_reverse
-        key!('n') => commands::search_next,
-        shift!('N') => commands::extend_search_next,
-        // N for search_prev
-        key!('*') => commands::search_selection,
+            // "q" => record_macro,
+            // "Q" => replay_macro,
 
-        key!('u') => commands::undo,
-        shift!('U') => commands::redo,
+            // & align selections
+            // _ trim selections
 
-        key!('y') => commands::yank,
-        // yank_all
-        key!('p') => commands::paste_after,
-        // paste_all
-        shift!('P') => commands::paste_before,
+            "(" => rotate_selections_backward,
+            ")" => rotate_selections_forward,
+            "A-(" => rotate_selection_contents_backward,
+            "A-)" => rotate_selection_contents_forward,
 
-        key!('>') => commands::indent,
-        key!('<') => commands::unindent,
-        key!('=') => commands::format_selections,
-        shift!('J') => commands::join_selections,
-        // TODO: conflicts hover/doc
-        shift!('K') => commands::keep_selections,
-        // TODO: and another method for inverse
+            "esc" => normal_mode,
+            "C-b" | "pageup" => page_up,
+            "C-f" | "pagedown" => page_down,
+            "C-u" => half_page_up,
+            "C-d" => half_page_down,
 
-        // TODO: clashes with space mode
-        key!(' ') => commands::keep_primary_selection,
+            "C-w" => { "Window"
+                "C-w" | "w" => rotate_view,
+                "C-h" | "h" => hsplit,
+                "C-v" | "v" => vsplit,
+                "C-q" | "q" => wclose,
+            },
 
-        // key!('q') => commands::record_macro,
-        // key!('Q') => commands::replay_macro,
+            // move under <space>c
+            "C-c" => toggle_comments,
+            "K" => hover,
 
-        // ~ / apostrophe => change case
-        // & align selections
-        // _ trim selections
+            // z family for save/restore/combine from/to sels from register
 
-        // C / altC = copy (repeat) selections on prev/next lines
+            "tab" => jump_forward, // tab == <C-i>
+            "C-o" => jump_backward,
+            // "C-s" => save_selection,
 
-        KeyEvent {
-            code: KeyCode::Esc,
-            modifiers: KeyModifiers::NONE
-        } => commands::normal_mode,
-        KeyEvent {
-            code: KeyCode::PageUp,
-            modifiers: KeyModifiers::NONE
-        } => commands::page_up,
-        KeyEvent {
-            code: KeyCode::PageDown,
-            modifiers: KeyModifiers::NONE
-        } => commands::page_down,
-        ctrl!('u') => commands::half_page_up,
-        ctrl!('d') => commands::half_page_down,
+            "space" => { "Space"
+                "f" => file_picker,
+                "b" => buffer_picker,
+                "s" => symbol_picker,
+                "a" => code_action,
+                "'" => last_picker,
+                "w" => { "Window"
+                    "C-w" | "w" => rotate_view,
+                    "C-h" | "h" => hsplit,
+                    "C-v" | "v" => vsplit,
+                    "C-q" | "q" => wclose,
+                },
+                "y" => yank_joined_to_clipboard,
+                "Y" => yank_main_selection_to_clipboard,
+                "p" => paste_clipboard_after,
+                "P" => paste_clipboard_before,
+                "R" => replace_selections_with_clipboard,
+                "space" => keep_primary_selection,
+            },
+            "z" => { "View"
+                "z" | "c" => align_view_center,
+                "t" => align_view_top,
+                "b" => align_view_bottom,
+                "m" => align_view_middle,
+                "k" => scroll_up,
+                "j" => scroll_down,
+            },
 
-        KeyEvent {
-            code: KeyCode::Tab,
-            modifiers: KeyModifiers::NONE
-        } => commands::next_view,
+            "\"" => select_register,
+            "C-z" => suspend,
+        });
+        let mut select = normal.clone();
+        select.merge_nodes(keymap!({ "Select mode"
+            "h" | "left" => extend_char_left,
+            "j" | "down" => extend_line_down,
+            "k" | "up" => extend_line_up,
+            "l" | "right" => extend_char_right,
 
-        // move under <space>c
-        ctrl!('c') => commands::toggle_comments,
-        shift!('K') => commands::hover,
+            "w" => extend_next_word_start,
+            "b" => extend_prev_word_start,
+            "e" => extend_next_word_end,
 
-        // z family for save/restore/combine from/to sels from register
+            "t" => extend_till_char,
+            "f" => extend_next_char,
+            "T" => extend_till_prev_char,
+            "F" => extend_prev_char,
 
-        ctrl!('i') => commands::jump_forward, // TODO: ctrl-i conflicts tab
-        ctrl!('o') => commands::jump_backward,
-        // ctrl!('s') => commands::save_selection,
+            "home" => goto_line_start,
+            "end" => goto_line_end,
+            "esc" => exit_select_mode,
+        }));
+        let insert = keymap!({ "Insert mode"
+            "esc" => normal_mode,
 
-        key!(' ') => commands::space_mode,
-        key!('z') => commands::view_mode,
+            "backspace" => delete_char_backward,
+            "del" => delete_char_forward,
+            "ret" => insert_newline,
+            "tab" => insert_tab,
+            "C-w" => delete_word_backward,
+
+            "left" => move_char_left,
+            "down" => move_line_down,
+            "up" => move_line_up,
+            "right" => move_char_right,
+            "pageup" => page_up,
+            "pagedown" => page_down,
+            "home" => goto_line_start,
+            "end" => goto_line_end_newline,
+
+            "C-x" => completion,
+        });
+        Keymaps(hashmap!(
+            Mode::Normal => Keymap::new(normal),
+            Mode::Select => Keymap::new(select),
+            Mode::Insert => Keymap::new(insert),
+        ))
+    }
+}
+
+/// Merge default config keys with user overwritten keys for custom user config.
+pub fn merge_keys(mut config: Config) -> Config {
+    let mut delta = std::mem::take(&mut config.keys);
+    for (mode, keys) in &mut *config.keys {
+        keys.merge(delta.remove(mode).unwrap_or_default())
+    }
+    config
+}
+
+#[test]
+fn merge_partial_keys() {
+    let config = Config {
+        keys: Keymaps(hashmap! {
+            Mode::Normal => Keymap::new(
+                keymap!({ "Normal mode"
+                    "i" => normal_mode,
+                    "无" => insert_mode,
+                    "z" => jump_backward,
+                    "g" => { "Merge into goto mode"
+                        "$" => goto_line_end,
+                        "g" => delete_char_forward,
+                    },
+                })
+            )
+        }),
+        ..Default::default()
+    };
+    let mut merged_config = merge_keys(config.clone());
+    assert_ne!(config, merged_config);
+
+    let keymap = merged_config.keys.0.get_mut(&Mode::Normal).unwrap();
+    assert_eq!(
+        keymap.get(key!('i')),
+        KeymapResult::Matched(Command::normal_mode),
+        "Leaf should replace leaf"
     );
-    // TODO: decide whether we want normal mode to also be select mode (kakoune-like), or whether
-    // we keep this separate select mode. More keys can fit into normal mode then, but it's weird
-    // because some selection operations can now be done from normal mode, some from select mode.
-    let mut select = normal.clone();
-    select.extend(
-        hashmap!(
-            key!('h') => commands::extend_char_left as Command,
-            key!('j') => commands::extend_line_down,
-            key!('k') => commands::extend_line_up,
-            key!('l') => commands::extend_char_right,
-
-            key!('w') => commands::extend_next_word_start,
-            key!('b') => commands::extend_prev_word_start,
-            key!('e') => commands::extend_next_word_end,
-
-            key!('t') => commands::extend_till_char,
-            key!('f') => commands::extend_next_char,
-            shift!('T') => commands::extend_till_prev_char,
-            shift!('F') => commands::extend_prev_char,
-
-            KeyEvent {
-                code: KeyCode::Esc,
-                modifiers: KeyModifiers::NONE
-            } => commands::exit_select_mode as Command,
-        )
-        .into_iter(),
+    assert_eq!(
+        keymap.get(key!('无')),
+        KeymapResult::Matched(Command::insert_mode),
+        "New leaf should be present in merged keymap"
+    );
+    // Assumes that z is a node in the default keymap
+    assert_eq!(
+        keymap.get(key!('z')),
+        KeymapResult::Matched(Command::jump_backward),
+        "Leaf should replace node"
+    );
+    // Assumes that `g` is a node in default keymap
+    assert_eq!(
+        keymap.root().search(&[key!('g'), key!('$')]).unwrap(),
+        &KeyTrie::Leaf(Command::goto_line_end),
+        "Leaf should be present in merged subnode"
+    );
+    // Assumes that `gg` is in default keymap
+    assert_eq!(
+        keymap.root().search(&[key!('g'), key!('g')]).unwrap(),
+        &KeyTrie::Leaf(Command::delete_char_forward),
+        "Leaf should replace old leaf in merged subnode"
+    );
+    // Assumes that `ge` is in default keymap
+    assert_eq!(
+        keymap.root().search(&[key!('g'), key!('e')]).unwrap(),
+        &KeyTrie::Leaf(Command::goto_last_line),
+        "Old leaves in subnode should be present in merged node"
     );
 
-    hashmap!(
-        // as long as you cast the first item, rust is able to infer the other cases
-        // TODO: select could be normal mode with some bindings merged over
-        Mode::Normal => normal,
-        Mode::Select => select,
-        Mode::Insert => hashmap!(
-            KeyEvent {
-                code: KeyCode::Esc,
-                modifiers: KeyModifiers::NONE
-            } => commands::normal_mode as Command,
-            KeyEvent {
-                code: KeyCode::Backspace,
-                modifiers: KeyModifiers::NONE
-            } => commands::insert::delete_char_backward,
-            KeyEvent {
-                code: KeyCode::Delete,
-                modifiers: KeyModifiers::NONE
-            } => commands::insert::delete_char_forward,
-            KeyEvent {
-                code: KeyCode::Enter,
-                modifiers: KeyModifiers::NONE
-            } => commands::insert::insert_newline,
-            KeyEvent {
-                code: KeyCode::Tab,
-                modifiers: KeyModifiers::NONE
-            } => commands::insert::insert_tab,
-
-            ctrl!('x') => commands::completion,
-        ),
-    )
+    assert!(merged_config.keys.0.get(&Mode::Normal).unwrap().len() > 1);
+    assert!(merged_config.keys.0.get(&Mode::Insert).unwrap().len() > 0);
 }

helix-term/src/lib.rs

@@ -0,0 +1,11 @@
+#[macro_use]
+extern crate helix_view;
+
+pub mod application;
+pub mod args;
+pub mod commands;
+pub mod compositor;
+pub mod config;
+pub mod job;
+pub mod keymap;
+pub mod ui;

helix-term/src/main.rs

@@ -1,26 +1,13 @@
-#![allow(unused)]
-
-mod application;
-mod commands;
-mod compositor;
-mod keymap;
-mod ui;
-
-use application::Application;
-
-use clap::{App, Arg};
+use anyhow::{Context, Error, Result};
+use helix_term::application::Application;
+use helix_term::args::Args;
+use helix_term::config::Config;
+use helix_term::keymap::merge_keys;
 use std::path::PathBuf;
 
-use anyhow::Error;
-
-fn setup_logging(verbosity: u64) -> Result<(), fern::InitError> {
+fn setup_logging(logpath: PathBuf, verbosity: u64) -> Result<()> {
     let mut base_config = fern::Dispatch::new();
 
-    // Let's say we depend on something which whose "info" level messages are too
-    // verbose to include in end-user output. If we don't need them,
-    // let's not include them.
-    // .level_for("overly-verbose-target", log::LevelFilter::Warn)
-
     base_config = match verbosity {
         0 => base_config.level(log::LevelFilter::Warn),
         1 => base_config.level(log::LevelFilter::Info),
@@ -28,8 +15,6 @@ fn setup_logging(verbosity: u64) -> Result<(), fern::InitError> {
         _3_or_more => base_config.level(log::LevelFilter::Trace),
     };
 
-    let home = dirs_next::home_dir().expect("can't find the home directory");
-
     // Separate file config so we can include year, month and day in file logs
     let file_config = fern::Dispatch::new()
         .format(|out, message, record| {
@@ -41,56 +26,75 @@ fn setup_logging(verbosity: u64) -> Result<(), fern::InitError> {
                 message
             ))
         })
-        .chain(fern::log_file(home.join("helix.log"))?);
+        .chain(fern::log_file(logpath)?);
 
     base_config.chain(file_config).apply()?;
 
     Ok(())
 }
 
-fn main() {
-    let args = clap::app_from_crate!()
-        .arg(
-            Arg::new("files")
-                .about("Sets the input file to use")
-                .required(false)
-                .multiple(true)
-                .index(1),
-        )
-        .arg(
-            Arg::new("verbose")
-                .about("Increases logging verbosity each use for up to 3 times")
-                .short('v')
-                .takes_value(false)
-                .multiple_occurrences(true),
-        )
-        .get_matches();
+#[tokio::main]
+async fn main() -> Result<()> {
+    let cache_dir = helix_core::cache_dir();
+    if !cache_dir.exists() {
+        std::fs::create_dir_all(&cache_dir).ok();
+    }
 
-    let verbosity: u64 = args.occurrences_of("verbose");
+    let logpath = cache_dir.join("helix.log");
+    let help = format!(
+        "\
+{} {}
+{}
+{}
 
-    setup_logging(verbosity).expect("failed to initialize logging.");
+USAGE:
+    hx [FLAGS] [files]...
 
-    // initialize language registry
-    use helix_core::config_dir;
-    use helix_core::syntax::{Loader, LOADER};
+ARGS:
+    <files>...    Sets the input file to use
 
-    // load $HOME/.config/helix/languages.toml, fallback to default config
-    let config = std::fs::read(config_dir().join("languages.toml"));
-    let toml = config
-        .as_deref()
-        .unwrap_or(include_bytes!("../../languages.toml"));
+FLAGS:
+    -h, --help       Prints help information
+    -v               Increases logging verbosity each use for up to 3 times
+                     (default file: {})
+    -V, --version    Prints version information
+",
+        env!("CARGO_PKG_NAME"),
+        env!("CARGO_PKG_VERSION"),
+        env!("CARGO_PKG_AUTHORS"),
+        env!("CARGO_PKG_DESCRIPTION"),
+        logpath.display(),
+    );
 
-    LOADER.get_or_init(|| {
-        let config = toml::from_slice(toml).expect("Could not parse languages.toml");
-        Loader::new(config)
-    });
+    let args = Args::parse_args().context("could not parse arguments")?;
 
-    let runtime = tokio::runtime::Runtime::new().unwrap();
+    // Help has a higher priority and should be handled separately.
+    if args.display_help {
+        print!("{}", help);
+        std::process::exit(0);
+    }
+
+    if args.display_version {
+        println!("helix {}", env!("CARGO_PKG_VERSION"));
+        std::process::exit(0);
+    }
+
+    let conf_dir = helix_core::config_dir();
+    if !conf_dir.exists() {
+        std::fs::create_dir_all(&conf_dir).ok();
+    }
+
+    let config = match std::fs::read_to_string(conf_dir.join("config.toml")) {
+        Ok(config) => merge_keys(toml::from_str(&config)?),
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => Config::default(),
+        Err(err) => return Err(Error::new(err)),
+    };
+
+    setup_logging(logpath, args.verbosity).context("failed to initialize logging")?;
 
     // TODO: use the thread local executor to spawn the application task separately from the work pool
-    runtime.block_on(async move {
-        let mut app = Application::new(args).unwrap();
+    let mut app = Application::new(args, config).context("unable to create new application")?;
+    app.run().await.unwrap();
 
-        app.run().await;
-    });
+    Ok(())
 }

helix-term/src/ui/completion.rs

@@ -1,25 +1,74 @@
-use crate::compositor::{Component, Compositor, Context, EventResult};
-use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
-use tui::{
-    buffer::Buffer as Surface,
-    layout::Rect,
-    style::{Color, Style},
-};
+use crate::compositor::{Component, Context, EventResult};
+use crossterm::event::{Event, KeyCode, KeyEvent};
+use tui::buffer::Buffer as Surface;
 
 use std::borrow::Cow;
 
-use helix_core::{Position, Transaction};
-use helix_view::Editor;
+use helix_core::Transaction;
+use helix_view::{graphics::Rect, Document, Editor, View};
 
 use crate::commands;
-use crate::ui::{Markdown, Menu, Popup, PromptEvent};
+use crate::ui::{menu, Markdown, Menu, Popup, PromptEvent};
 
-use helix_lsp::lsp;
+use helix_lsp::{lsp, util};
 use lsp::CompletionItem;
 
+impl menu::Item for CompletionItem {
+    fn sort_text(&self) -> &str {
+        self.filter_text.as_ref().unwrap_or(&self.label).as_str()
+    }
+
+    fn filter_text(&self) -> &str {
+        self.filter_text.as_ref().unwrap_or(&self.label).as_str()
+    }
+
+    fn label(&self) -> &str {
+        self.label.as_str()
+    }
+
+    fn row(&self) -> menu::Row {
+        menu::Row::new(vec![
+            menu::Cell::from(self.label.as_str()),
+            menu::Cell::from(match self.kind {
+                Some(lsp::CompletionItemKind::Text) => "text",
+                Some(lsp::CompletionItemKind::Method) => "method",
+                Some(lsp::CompletionItemKind::Function) => "function",
+                Some(lsp::CompletionItemKind::Constructor) => "constructor",
+                Some(lsp::CompletionItemKind::Field) => "field",
+                Some(lsp::CompletionItemKind::Variable) => "variable",
+                Some(lsp::CompletionItemKind::Class) => "class",
+                Some(lsp::CompletionItemKind::Interface) => "interface",
+                Some(lsp::CompletionItemKind::Module) => "module",
+                Some(lsp::CompletionItemKind::Property) => "property",
+                Some(lsp::CompletionItemKind::Unit) => "unit",
+                Some(lsp::CompletionItemKind::Value) => "value",
+                Some(lsp::CompletionItemKind::Enum) => "enum",
+                Some(lsp::CompletionItemKind::Keyword) => "keyword",
+                Some(lsp::CompletionItemKind::Snippet) => "snippet",
+                Some(lsp::CompletionItemKind::Color) => "color",
+                Some(lsp::CompletionItemKind::File) => "file",
+                Some(lsp::CompletionItemKind::Reference) => "reference",
+                Some(lsp::CompletionItemKind::Folder) => "folder",
+                Some(lsp::CompletionItemKind::EnumMember) => "enum_member",
+                Some(lsp::CompletionItemKind::Constant) => "constant",
+                Some(lsp::CompletionItemKind::Struct) => "struct",
+                Some(lsp::CompletionItemKind::Event) => "event",
+                Some(lsp::CompletionItemKind::Operator) => "operator",
+                Some(lsp::CompletionItemKind::TypeParameter) => "type_param",
+                None => "",
+            }),
+            // self.detail.as_deref().unwrap_or("")
+            // self.label_details
+            //     .as_ref()
+            //     .or(self.detail())
+            //     .as_str(),
+        ])
+    }
+}
+
 /// Wraps a Menu.
 pub struct Completion {
-    popup: Popup<Menu<CompletionItem>>, // TODO: Popup<Menu> need to be able to access contents.
+    popup: Popup<Menu<CompletionItem>>,
     trigger_offset: usize,
     // TODO: maintain a completioncontext with trigger kind & trigger char
 }
@@ -31,89 +80,100 @@ impl Completion {
         trigger_offset: usize,
     ) -> Self {
         // let items: Vec<CompletionItem> = Vec::new();
-        let mut menu = Menu::new(
-            items,
-            |item| {
-                // format_fn
-                item.label.as_str().into()
-
-                // TODO: use item.filter_text for filtering
-            },
-            move |editor: &mut Editor, item, event| {
-                match event {
-                    PromptEvent::Abort => {
-                        // revert state
-                        // let id = editor.view().doc;
-                        // let doc = &mut editor.documents[id];
-                        // doc.state = snapshot.clone();
-                    }
-                    PromptEvent::Validate => {
-                        let (view, doc) = editor.current();
-
-                        // revert state to what it was before the last update
-                        // doc.state = snapshot.clone();
-
-                        // extract as fn(doc, item):
-
-                        // TODO: need to apply without composing state...
-                        // TODO: need to update lsp on accept/cancel by diffing the snapshot with
-                        // the final state?
-                        // -> on update simply update the snapshot, then on accept redo the call,
-                        // finally updating doc.changes + notifying lsp.
-                        //
-                        // or we could simply use doc.undo + apply when changing between options
-
-                        // always present here
-                        let item = item.unwrap();
-
-                        use helix_lsp::{lsp, util};
-                        // determine what to insert: text_edit | insert_text | label
-                        let edit = if let Some(edit) = &item.text_edit {
-                            match edit {
-                                lsp::CompletionTextEdit::Edit(edit) => edit.clone(),
-                                lsp::CompletionTextEdit::InsertAndReplace(item) => {
-                                    unimplemented!("completion: insert_and_replace {:?}", item)
-                                }
-                            }
-                        } else {
-                            item.insert_text.as_ref().unwrap_or(&item.label);
-                            unimplemented!();
-                            // lsp::TextEdit::new(); TODO: calculate a TextEdit from insert_text
-                            // and we insert at position.
-                        };
-
-                        // TODO: merge edit with additional_text_edits
-                        if let Some(additional_edits) = &item.additional_text_edits {
-                            if !additional_edits.is_empty() {
-                                unimplemented!(
-                                    "completion: additional_text_edits: {:?}",
-                                    additional_edits
-                                );
-                            }
+        let menu = Menu::new(items, move |editor: &mut Editor, item, event| {
+            fn item_to_transaction(
+                doc: &Document,
+                view: &View,
+                item: &CompletionItem,
+                offset_encoding: helix_lsp::OffsetEncoding,
+            ) -> Transaction {
+                if let Some(edit) = &item.text_edit {
+                    let edit = match edit {
+                        lsp::CompletionTextEdit::Edit(edit) => edit.clone(),
+                        lsp::CompletionTextEdit::InsertAndReplace(item) => {
+                            unimplemented!("completion: insert_and_replace {:?}", item)
                         }
+                    };
+                    util::generate_transaction_from_edits(
+                        doc.text(),
+                        vec![edit],
+                        offset_encoding, // TODO: should probably transcode in Client
+                    )
+                } else {
+                    let text = item.insert_text.as_ref().unwrap_or(&item.label);
+                    let cursor = doc
+                        .selection(view.id)
+                        .primary()
+                        .cursor(doc.text().slice(..));
+                    Transaction::change(
+                        doc.text(),
+                        vec![(cursor, cursor, Some(text.as_str().into()))].into_iter(),
+                    )
+                }
+            }
 
-                        // if more text was entered, remove it
-                        let cursor = doc.selection(view.id).cursor();
-                        if trigger_offset < cursor {
-                            let remove = Transaction::change(
-                                doc.text(),
-                                vec![(trigger_offset, cursor, None)].into_iter(),
-                            );
-                            doc.apply(&remove, view.id);
-                        }
+            match event {
+                PromptEvent::Abort => {}
+                PromptEvent::Update => {
+                    let (view, doc) = current!(editor);
 
-                        use helix_lsp::OffsetEncoding;
-                        let transaction = util::generate_transaction_from_edits(
+                    // always present here
+                    let item = item.unwrap();
+
+                    // if more text was entered, remove it
+                    // TODO: ideally to undo we should keep the last completion tx revert, and map it over new changes
+                    let cursor = doc
+                        .selection(view.id)
+                        .primary()
+                        .cursor(doc.text().slice(..));
+                    if trigger_offset < cursor {
+                        let remove = Transaction::change(
                             doc.text(),
-                            vec![edit],
-                            offset_encoding, // TODO: should probably transcode in Client
+                            vec![(trigger_offset, cursor, None)].into_iter(),
                         );
-                        doc.apply(&transaction, view.id);
+                        doc.apply(&remove, view.id);
                     }
-                    _ => (),
-                };
-            },
-        );
+
+                    let transaction = item_to_transaction(doc, view, item, offset_encoding);
+                    doc.apply(&transaction, view.id);
+                }
+                PromptEvent::Validate => {
+                    let (view, doc) = current!(editor);
+
+                    // always present here
+                    let item = item.unwrap();
+
+                    // if more text was entered, remove it
+                    // TODO: ideally to undo we should keep the last completion tx revert, and map it over new changes
+                    let cursor = doc
+                        .selection(view.id)
+                        .primary()
+                        .cursor(doc.text().slice(..));
+                    if trigger_offset < cursor {
+                        let remove = Transaction::change(
+                            doc.text(),
+                            vec![(trigger_offset, cursor, None)].into_iter(),
+                        );
+                        doc.apply(&remove, view.id);
+                    }
+
+                    let transaction = item_to_transaction(doc, view, item, offset_encoding);
+                    doc.apply(&transaction, view.id);
+
+                    if let Some(additional_edits) = &item.additional_text_edits {
+                        // gopls uses this to add extra imports
+                        if !additional_edits.is_empty() {
+                            let transaction = util::generate_transaction_from_edits(
+                                doc.text(),
+                                additional_edits.clone(),
+                                offset_encoding, // TODO: should probably transcode in Client
+                            );
+                            doc.apply(&transaction, view.id);
+                        }
+                    }
+                }
+            };
+        });
         let popup = Popup::new(menu);
         Self {
             popup,
@@ -124,7 +184,7 @@ impl Completion {
     pub fn update(&mut self, cx: &mut commands::Context) {
         // recompute menu based on matches
         let menu = self.popup.contents_mut();
-        let (view, doc) = cx.editor.current();
+        let (view, doc) = current!(cx.editor);
 
         // cx.hooks()
         // cx.add_hook(enum type,  ||)
@@ -136,7 +196,10 @@ impl Completion {
         // TODO: hooks should get processed immediately so maybe do it after select!(), before
         // looping?
 
-        let cursor = doc.selection(view.id).cursor();
+        let cursor = doc
+            .selection(view.id)
+            .primary()
+            .cursor(doc.text().slice(..));
         if self.trigger_offset <= cursor {
             let fragment = doc.text().slice(self.trigger_offset..cursor);
             let text = Cow::from(fragment);
@@ -164,6 +227,13 @@ impl Completion {
 
 impl Component for Completion {
     fn handle_event(&mut self, event: Event, cx: &mut Context) -> EventResult {
+        // let the Editor handle Esc instead
+        if let Event::Key(KeyEvent {
+            code: KeyCode::Esc, ..
+        }) = event
+        {
+            return EventResult::Ignored;
+        }
         self.popup.handle_event(event, cx)
     }
 
@@ -171,41 +241,94 @@ impl Component for Completion {
         self.popup.required_size(viewport)
     }
 
-    fn render(&self, area: Rect, surface: &mut Surface, cx: &mut Context) {
+    fn render(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) {
         self.popup.render(area, surface, cx);
 
-        // TODO: if we have a selection, render a markdown popup on top/below with info
+        // if we have a selection, render a markdown popup on top/below with info
         if let Some(option) = self.popup.contents().selection() {
             // need to render:
             // option.detail
             // ---
             // option.documentation
-            match &option.documentation {
-                Some(lsp::Documentation::String(s))
+
+            let (view, doc) = current!(cx.editor);
+            let language = doc
+                .language()
+                .and_then(|scope| scope.strip_prefix("source."))
+                .unwrap_or("");
+            let cursor_pos = doc
+                .selection(view.id)
+                .primary()
+                .cursor(doc.text().slice(..));
+            let cursor_pos = (helix_core::coords_at_pos(doc.text().slice(..), cursor_pos).row
+                - view.first_line) as u16;
+
+            let mut doc = match &option.documentation {
+                Some(lsp::Documentation::String(contents))
                 | Some(lsp::Documentation::MarkupContent(lsp::MarkupContent {
                     kind: lsp::MarkupKind::PlainText,
-                    value: s,
+                    value: contents,
                 })) => {
                     // TODO: convert to wrapped text
-                    let doc = s;
+                    Markdown::new(
+                        format!(
+                            "```{}\n{}\n```\n{}",
+                            language,
+                            option.detail.as_deref().unwrap_or_default(),
+                            contents.clone()
+                        ),
+                        cx.editor.syn_loader.clone(),
+                    )
                 }
                 Some(lsp::Documentation::MarkupContent(lsp::MarkupContent {
                     kind: lsp::MarkupKind::Markdown,
                     value: contents,
                 })) => {
-                    let doc = Markdown::new(contents.clone());
-                    let half = area.height / 2;
-                    let height = 15.min(half);
-                    // -2 to subtract command line + statusline. a bit of a hack, because of splits.
-                    let area = Rect::new(0, area.height - height - 2, area.width, height);
-
-                    // clear area
-                    let background = cx.editor.theme.get("ui.popup");
-                    surface.clear_with(area, background);
-                    doc.render(area, surface, cx);
+                    // TODO: set language based on doc scope
+                    Markdown::new(
+                        format!(
+                            "```{}\n{}\n```\n{}",
+                            language,
+                            option.detail.as_deref().unwrap_or_default(),
+                            contents.clone()
+                        ),
+                        cx.editor.syn_loader.clone(),
+                    )
                 }
-                None => (),
-            }
+                None if option.detail.is_some() => {
+                    // TODO: copied from above
+
+                    // TODO: set language based on doc scope
+                    Markdown::new(
+                        format!(
+                            "```{}\n{}\n```",
+                            language,
+                            option.detail.as_deref().unwrap_or_default(),
+                        ),
+                        cx.editor.syn_loader.clone(),
+                    )
+                }
+                None => return,
+            };
+
+            let half = area.height / 2;
+            let height = 15.min(half);
+            // we want to make sure the cursor is visible (not hidden behind the documentation)
+            let y = if cursor_pos + view.area.y
+                >= (cx.editor.tree.area().height - height - 2/* statusline + commandline */)
+            {
+                0
+            } else {
+                // -2 to subtract command line + statusline. a bit of a hack, because of splits.
+                area.height.saturating_sub(height).saturating_sub(2)
+            };
+
+            let area = Rect::new(0, y, area.width, height);
+
+            // clear area
+            let background = cx.editor.theme.get("ui.popup");
+            surface.clear_with(area, background);
+            doc.render(area, surface, cx);
         }
     }
 }

helix-term/src/ui/info.rs

@@ -0,0 +1,38 @@
+use crate::compositor::{Component, Context};
+use helix_view::graphics::Rect;
+use helix_view::info::Info;
+use tui::buffer::Buffer as Surface;
+use tui::widgets::{Block, Borders, Widget};
+
+impl Component for Info {
+    fn render(&mut self, viewport: Rect, surface: &mut Surface, cx: &mut Context) {
+        let style = cx.editor.theme.get("ui.popup");
+
+        // Calculate the area of the terminal to modify. Because we want to
+        // render at the bottom right, we use the viewport's width and height
+        // which evaluate to the most bottom right coordinate.
+        let (width, height) = (self.width + 2, self.height + 2);
+        let area = viewport.intersection(Rect::new(
+            viewport.width.saturating_sub(width),
+            viewport.height.saturating_sub(height + 2),
+            width,
+            height,
+        ));
+        surface.clear_with(area, style);
+
+        let block = Block::default()
+            .title(self.title.as_str())
+            .borders(Borders::ALL)
+            .border_style(style);
+        let inner = block.inner(area);
+        block.render(area, surface);
+
+        // Only write as many lines as there are rows available.
+        for (y, line) in (inner.y..)
+            .zip(self.text.lines())
+            .take(inner.height as usize)
+        {
+            surface.set_string(inner.x, y, line, style);
+        }
+    }
+}

helix-term/src/ui/markdown.rs

@@ -1,36 +1,47 @@
-use crate::compositor::{Component, Compositor, Context, EventResult};
-use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
+use crate::compositor::{Component, Context};
 use tui::{
     buffer::Buffer as Surface,
-    layout::Rect,
-    style::{Color, Style},
-    text::Text,
+    text::{Span, Spans, Text},
 };
 
-use std::borrow::Cow;
+use std::sync::Arc;
 
-use helix_core::Position;
-use helix_view::{Editor, Theme};
+use pulldown_cmark::{CodeBlockKind, CowStr, Event, Options, Parser, Tag};
+
+use helix_core::{
+    syntax::{self, HighlightEvent, Syntax},
+    Rope,
+};
+use helix_view::{
+    graphics::{Color, Rect, Style},
+    Theme,
+};
 
 pub struct Markdown {
     contents: String,
+
+    config_loader: Arc<syntax::Loader>,
 }
 
 // TODO: pre-render and self reference via Pin
 // better yet, just use Tendril + subtendril for references
 
 impl Markdown {
-    pub fn new(contents: String) -> Self {
-        Self { contents }
+    pub fn new(contents: String, config_loader: Arc<syntax::Loader>) -> Self {
+        Self {
+            contents,
+            config_loader,
+        }
     }
 }
 
-fn parse<'a>(contents: &'a str, theme: Option<&Theme>) -> tui::text::Text<'a> {
-    use pulldown_cmark::{CodeBlockKind, CowStr, Event, Options, Parser, Tag};
-    use tui::text::{Span, Spans, Text};
-
-    // also 2021-03-04T16:33:58.553 helix_lsp::transport [INFO] <- {"contents":{"kind":"markdown","value":"\n```rust\ncore::num\n```\n\n```rust\npub const fn saturating_sub(self, rhs:Self) ->Self\n```\n\n---\n\n```rust\n```"},"range":{"end":{"character":61,"line":101},"start":{"character":47,"line":101}}}
-    let text = "\n```rust\ncore::iter::traits::iterator::Iterator\n```\n\n```rust\nfn collect<B: FromIterator<Self::Item>>(self) -> B\nwhere\n        Self: Sized,\n```\n\n---\n\nTransforms an iterator into a collection.\n\n`collect()` can take anything iterable, and turn it into a relevant\ncollection. This is one of the more powerful methods in the standard\nlibrary, used in a variety of contexts.\n\nThe most basic pattern in which `collect()` is used is to turn one\ncollection into another. You take a collection, call [`iter`](https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html) on it,\ndo a bunch of transformations, and then `collect()` at the end.\n\n`collect()` can also create instances of types that are not typical\ncollections. For example, a [`String`](https://doc.rust-lang.org/nightly/core/iter/std/string/struct.String.html) can be built from [`char`](type@char)s,\nand an iterator of [`Result<T, E>`](https://doc.rust-lang.org/nightly/core/result/enum.Result.html) items can be collected\ninto `Result<Collection<T>, E>`. See the examples below for more.\n\nBecause `collect()` is so general, it can cause problems with type\ninference. As such, `collect()` is one of the few times you'll see\nthe syntax affectionately known as the 'turbofish': `::<>`. This\nhelps the inference algorithm understand specifically which collection\nyou're trying to collect into.\n\n# Examples\n\nBasic usage:\n\n```rust\nlet a = [1, 2, 3];\n\nlet doubled: Vec<i32> = a.iter()\n                         .map(|&x| x * 2)\n                         .collect();\n\nassert_eq!(vec![2, 4, 6], doubled);\n```\n\nNote that we needed the `: Vec<i32>` on the left-hand side. This is because\nwe could collect into, for example, a [`VecDeque<T>`](https://doc.rust-lang.org/nightly/core/iter/std/collections/struct.VecDeque.html) instead:\n\n```rust\nuse std::collections::VecDeque;\n\nlet a = [1, 2, 3];\n\nlet doubled: VecDeque<i32> = a.iter().map(|&x| x * 2).collect();\n\nassert_eq!(2, doubled[0]);\nassert_eq!(4, doubled[1]);\nassert_eq!(6, doubled[2]);\n```\n\nUsing the 'turbofish' instead of annotating `doubled`:\n\n```rust\nlet a = [1, 2, 3];\n\nlet doubled = a.iter().map(|x| x * 2).collect::<Vec<i32>>();\n\nassert_eq!(vec![2, 4, 6], doubled);\n```\n\nBecause `collect()` only cares about what you're collecting into, you can\nstill use a partial type hint, `_`, with the turbofish:\n\n```rust\nlet a = [1, 2, 3];\n\nlet doubled = a.iter().map(|x| x * 2).collect::<Vec<_>>();\n\nassert_eq!(vec![2, 4, 6], doubled);\n```\n\nUsing `collect()` to make a [`String`](https://doc.rust-lang.org/nightly/core/iter/std/string/struct.String.html):\n\n```rust\nlet chars = ['g', 'd', 'k', 'k', 'n'];\n\nlet hello: String = chars.iter()\n    .map(|&x| x as u8)\n    .map(|x| (x + 1) as char)\n    .collect();\n\nassert_eq!(\"hello\", hello);\n```\n\nIf you have a list of [`Result<T, E>`](https://doc.rust-lang.org/nightly/core/result/enum.Result.html)s, you can use `collect()` to\nsee if any of them failed:\n\n```rust\nlet results = [Ok(1), Err(\"nope\"), Ok(3), Err(\"bad\")];\n\nlet result: Result<Vec<_>, &str> = results.iter().cloned().collect();\n\n// gives us the first error\nassert_eq!(Err(\"nope\"), result);\n\nlet results = [Ok(1), Ok(3)];\n\nlet result: Result<Vec<_>, &str> = results.iter().cloned().collect();\n\n// gives us the list of answers\nassert_eq!(Ok(vec![1, 3]), result);\n```";
+fn parse<'a>(
+    contents: &'a str,
+    theme: Option<&Theme>,
+    loader: &syntax::Loader,
+) -> tui::text::Text<'a> {
+    // // also 2021-03-04T16:33:58.553 helix_lsp::transport [INFO] <- {"contents":{"kind":"markdown","value":"\n```rust\ncore::num\n```\n\n```rust\npub const fn saturating_sub(self, rhs:Self) ->Self\n```\n\n---\n\n```rust\n```"},"range":{"end":{"character":61,"line":101},"start":{"character":47,"line":101}}}
+    // let text = "\n```rust\ncore::iter::traits::iterator::Iterator\n```\n\n```rust\nfn collect<B: FromIterator<Self::Item>>(self) -> B\nwhere\n        Self: Sized,\n```\n\n---\n\nTransforms an iterator into a collection.\n\n`collect()` can take anything iterable, and turn it into a relevant\ncollection. This is one of the more powerful methods in the standard\nlibrary, used in a variety of contexts.\n\nThe most basic pattern in which `collect()` is used is to turn one\ncollection into another. You take a collection, call [`iter`](https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html) on it,\ndo a bunch of transformations, and then `collect()` at the end.\n\n`collect()` can also create instances of types that are not typical\ncollections. For example, a [`String`](https://doc.rust-lang.org/nightly/core/iter/std/string/struct.String.html) can be built from [`char`](type@char)s,\nand an iterator of [`Result<T, E>`](https://doc.rust-lang.org/nightly/core/result/enum.Result.html) items can be collected\ninto `Result<Collection<T>, E>`. See the examples below for more.\n\nBecause `collect()` is so general, it can cause problems with type\ninference. As such, `collect()` is one of the few times you'll see\nthe syntax affectionately known as the 'turbofish': `::<>`. This\nhelps the inference algorithm understand specifically which collection\nyou're trying to collect into.\n\n# Examples\n\nBasic usage:\n\n```rust\nlet a = [1, 2, 3];\n\nlet doubled: Vec<i32> = a.iter()\n                         .map(|&x| x * 2)\n                         .collect();\n\nassert_eq!(vec![2, 4, 6], doubled);\n```\n\nNote that we needed the `: Vec<i32>` on the left-hand side. This is because\nwe could collect into, for example, a [`VecDeque<T>`](https://doc.rust-lang.org/nightly/core/iter/std/collections/struct.VecDeque.html) instead:\n\n```rust\nuse std::collections::VecDeque;\n\nlet a = [1, 2, 3];\n\nlet doubled: VecDeque<i32> = a.iter().map(|&x| x * 2).collect();\n\nassert_eq!(2, doubled[0]);\nassert_eq!(4, doubled[1]);\nassert_eq!(6, doubled[2]);\n```\n\nUsing the 'turbofish' instead of annotating `doubled`:\n\n```rust\nlet a = [1, 2, 3];\n\nlet doubled = a.iter().map(|x| x * 2).collect::<Vec<i32>>();\n\nassert_eq!(vec![2, 4, 6], doubled);\n```\n\nBecause `collect()` only cares about what you're collecting into, you can\nstill use a partial type hint, `_`, with the turbofish:\n\n```rust\nlet a = [1, 2, 3];\n\nlet doubled = a.iter().map(|x| x * 2).collect::<Vec<_>>();\n\nassert_eq!(vec![2, 4, 6], doubled);\n```\n\nUsing `collect()` to make a [`String`](https://doc.rust-lang.org/nightly/core/iter/std/string/struct.String.html):\n\n```rust\nlet chars = ['g', 'd', 'k', 'k', 'n'];\n\nlet hello: String = chars.iter()\n    .map(|&x| x as u8)\n    .map(|x| (x + 1) as char)\n    .collect();\n\nassert_eq!(\"hello\", hello);\n```\n\nIf you have a list of [`Result<T, E>`](https://doc.rust-lang.org/nightly/core/result/enum.Result.html)s, you can use `collect()` to\nsee if any of them failed:\n\n```rust\nlet results = [Ok(1), Err(\"nope\"), Ok(3), Err(\"bad\")];\n\nlet result: Result<Vec<_>, &str> = results.iter().cloned().collect();\n\n// gives us the first error\nassert_eq!(Err(\"nope\"), result);\n\nlet results = [Ok(1), Ok(3)];\n\nlet result: Result<Vec<_>, &str> = results.iter().cloned().collect();\n\n// gives us the list of answers\nassert_eq!(Ok(vec![1, 3]), result);\n```";
 
     let mut options = Options::empty();
     options.insert(Options::ENABLE_STRIKETHROUGH);
@@ -75,18 +86,13 @@ fn parse<'a>(contents: &'a str, theme: Option<&Theme>) -> tui::text::Text<'a> {
                 // TODO: temp workaround
                 if let Some(Tag::CodeBlock(CodeBlockKind::Fenced(language))) = tags.last() {
                     if let Some(theme) = theme {
-                        use helix_core::syntax::{self, HighlightEvent, Syntax};
-                        use helix_core::Rope;
-
                         let rope = Rope::from(text.as_ref());
-                        let syntax = syntax::LOADER
-                            .get()
-                            .unwrap()
+                        let syntax = loader
                             .language_config_for_scope(&format!("source.{}", language))
                             .and_then(|config| config.highlight_config(theme.scopes()))
                             .map(|config| Syntax::new(&rope, config));
 
-                        if let Some(mut syntax) = syntax {
+                        if let Some(syntax) = syntax {
                             // if we have a syntax available, highlight_iter and generate spans
                             let mut highlights = Vec::new();
 
@@ -101,17 +107,20 @@ fn parse<'a>(contents: &'a str, theme: Option<&Theme>) -> tui::text::Text<'a> {
                                     }
                                     HighlightEvent::Source { start, end } => {
                                         let style = match highlights.first() {
-                                            Some(span) => {
-                                                theme.get(theme.scopes()[span.0].as_str())
-                                            }
+                                            Some(span) => theme.get(&theme.scopes()[span.0]),
                                             None => text_style,
                                         };
 
+                                        // TODO: replace tabs with indentation
+
                                         let mut slice = &text[start..end];
+                                        // TODO: do we need to handle all unicode line endings
+                                        // here, or is just '\n' okay?
                                         while let Some(end) = slice.find('\n') {
                                             // emit span up to newline
                                             let text = &slice[..end];
-                                            let span = Span::styled(text.to_owned(), style);
+                                            let text = text.replace('\t', "    "); // replace tabs
+                                            let span = Span::styled(text, style);
                                             spans.push(span);
 
                                             // truncate slice to after newline
@@ -124,7 +133,8 @@ fn parse<'a>(contents: &'a str, theme: Option<&Theme>) -> tui::text::Text<'a> {
 
                                         // if there's anything left, emit it too
                                         if !slice.is_empty() {
-                                            let span = Span::styled(slice.to_owned(), style);
+                                            let span =
+                                                Span::styled(slice.replace('\t', "    "), style);
                                             spans.push(span);
                                         }
                                     }
@@ -132,13 +142,13 @@ fn parse<'a>(contents: &'a str, theme: Option<&Theme>) -> tui::text::Text<'a> {
                             }
                         } else {
                             for line in text.lines() {
-                                let mut span = Span::styled(line.to_string(), code_style);
+                                let span = Span::styled(line.to_string(), code_style);
                                 lines.push(Spans::from(span));
                             }
                         }
                     } else {
                         for line in text.lines() {
-                            let mut span = Span::styled(line.to_string(), code_style);
+                            let span = Span::styled(line.to_string(), code_style);
                             lines.push(Spans::from(span));
                         }
                     }
@@ -167,7 +177,9 @@ fn parse<'a>(contents: &'a str, theme: Option<&Theme>) -> tui::text::Text<'a> {
                 lines.push(Spans::default());
             }
             // TaskListMarker(bool) true if checked
-            _ => (),
+            _ => {
+                log::warn!("unhandled markdown event {:?}", event);
+            }
         }
         // build up a vec of Paragraph tui widgets
     }
@@ -186,10 +198,10 @@ fn parse<'a>(contents: &'a str, theme: Option<&Theme>) -> tui::text::Text<'a> {
     Text::from(lines)
 }
 impl Component for Markdown {
-    fn render(&self, area: Rect, surface: &mut Surface, cx: &mut Context) {
+    fn render(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) {
         use tui::widgets::{Paragraph, Widget, Wrap};
 
-        let text = parse(&self.contents, Some(&cx.editor.theme));
+        let text = parse(&self.contents, Some(&cx.editor.theme), &self.config_loader);
 
         let par = Paragraph::new(text)
             .wrap(Wrap { trim: false })
@@ -200,7 +212,7 @@ impl Component for Markdown {
     }
 
     fn required_size(&mut self, viewport: (u16, u16)) -> Option<(u16, u16)> {
-        let contents = parse(&self.contents, None);
+        let contents = parse(&self.contents, None, &self.config_loader);
         let padding = 2;
         let width = std::cmp::min(contents.width() as u16 + padding, viewport.0);
         let height = std::cmp::min(contents.height() as u16 + padding, viewport.1);

helix-term/src/ui/menu.rs

@@ -1,20 +1,24 @@
 use crate::compositor::{Component, Compositor, Context, EventResult};
 use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
-use tui::{
-    buffer::Buffer as Surface,
-    layout::Rect,
-    style::{Color, Style},
-};
+use tui::{buffer::Buffer as Surface, widgets::Table};
 
-use std::borrow::Cow;
+pub use tui::widgets::{Cell, Row};
 
 use fuzzy_matcher::skim::SkimMatcherV2 as Matcher;
 use fuzzy_matcher::FuzzyMatcher;
 
-use helix_core::Position;
-use helix_view::Editor;
+use helix_view::{graphics::Rect, Editor};
+use tui::layout::Constraint;
 
-pub struct Menu<T> {
+pub trait Item {
+    fn sort_text(&self) -> &str;
+    fn filter_text(&self) -> &str;
+
+    fn label(&self) -> &str;
+    fn row(&self) -> Row;
+}
+
+pub struct Menu<T: Item> {
     options: Vec<T>,
 
     cursor: Option<usize>,
@@ -23,19 +27,19 @@ pub struct Menu<T> {
     /// (index, score)
     matches: Vec<(usize, i64)>,
 
-    format_fn: Box<dyn Fn(&T) -> Cow<str>>,
+    widths: Vec<Constraint>,
+
     callback_fn: Box<dyn Fn(&mut Editor, Option<&T>, MenuEvent)>,
 
     scroll: usize,
     size: (u16, u16),
 }
 
-impl<T> Menu<T> {
+impl<T: Item> Menu<T> {
     // TODO: it's like a slimmed down picker, share code? (picker = menu + prompt with different
     // rendering)
     pub fn new(
         options: Vec<T>,
-        format_fn: impl Fn(&T) -> Cow<str> + 'static,
         callback_fn: impl Fn(&mut Editor, Option<&T>, MenuEvent) + 'static,
     ) -> Self {
         let mut menu = Self {
@@ -43,7 +47,7 @@ impl<T> Menu<T> {
             matcher: Box::new(Matcher::default()),
             matches: Vec::new(),
             cursor: None,
-            format_fn: Box::new(format_fn),
+            widths: Vec::new(),
             callback_fn: Box::new(callback_fn),
             scroll: 0,
             size: (0, 0),
@@ -58,29 +62,23 @@ impl<T> Menu<T> {
     pub fn score(&mut self, pattern: &str) {
         // need to borrow via pattern match otherwise it complains about simultaneous borrow
         let Self {
-            ref mut options,
             ref mut matcher,
             ref mut matches,
-            ref format_fn,
+            ref options,
             ..
         } = *self;
 
         // reuse the matches allocation
         matches.clear();
-        matches.extend(
-            self.options
-                .iter()
-                .enumerate()
-                .filter_map(|(index, option)| {
-                    // TODO: maybe using format_fn isn't the best idea here
-                    let text = (format_fn)(option);
-                    // TODO: using fuzzy_indices could give us the char idx for match highlighting
-                    matcher
-                        .fuzzy_match(&text, pattern)
-                        .map(|score| (index, score))
-                }),
-        );
-        matches.sort_unstable_by_key(|(_, score)| -score);
+        matches.extend(options.iter().enumerate().filter_map(|(index, option)| {
+            let text = option.filter_text();
+            // TODO: using fuzzy_indices could give us the char idx for match highlighting
+            matcher
+                .fuzzy_match(text, pattern)
+                .map(|score| (index, score))
+        }));
+        // matches.sort_unstable_by_key(|(_, score)| -score);
+        matches.sort_unstable_by_key(|(index, _score)| options[*index].sort_text());
 
         // reset cursor position
         self.cursor = None;
@@ -88,14 +86,15 @@ impl<T> Menu<T> {
     }
 
     pub fn move_up(&mut self) {
-        // TODO: wrap around to end
-        let pos = self.cursor.map_or(0, |i| i.saturating_sub(1)) % self.options.len();
+        let len = self.matches.len();
+        let pos = self.cursor.map_or(0, |i| (i + len.saturating_sub(1)) % len) % len;
         self.cursor = Some(pos);
         self.adjust_scroll();
     }
 
     pub fn move_down(&mut self) {
-        let pos = self.cursor.map_or(0, |i| i + 1) % self.options.len();
+        let len = self.matches.len();
+        let pos = self.cursor.map_or(0, |i| i + 1) % len;
         self.cursor = Some(pos);
         self.adjust_scroll();
     }
@@ -134,7 +133,7 @@ impl<T> Menu<T> {
 
 use super::PromptEvent as MenuEvent;
 
-impl<T: 'static> Component for Menu<T> {
+impl<T: Item + 'static> Component for Menu<T> {
     fn handle_event(&mut self, event: Event, cx: &mut Context) -> EventResult {
         let event = match event {
             Event::Key(event) => event,
@@ -160,8 +159,8 @@ impl<T: 'static> Component for Menu<T> {
             }
             // arrow up/ctrl-p/shift-tab prev completion choice (including updating the doc)
             KeyEvent {
-                code: KeyCode::Tab,
-                modifiers: KeyModifiers::SHIFT,
+                code: KeyCode::BackTab,
+                ..
             }
             | KeyEvent {
                 code: KeyCode::Up, ..
@@ -222,11 +221,32 @@ impl<T: 'static> Component for Menu<T> {
     }
 
     fn required_size(&mut self, viewport: (u16, u16)) -> Option<(u16, u16)> {
-        let width = std::cmp::min(30, viewport.0);
+        let n = self
+            .options
+            .first()
+            .map(|option| option.row().cells.len())
+            .unwrap_or_default();
+        let max_lens = self.options.iter().fold(vec![0; n], |mut acc, option| {
+            let row = option.row();
+            // maintain max for each column
+            for (acc, cell) in acc.iter_mut().zip(row.cells.iter()) {
+                let width = cell.content.width();
+                if width > *acc {
+                    *acc = width;
+                }
+            }
 
-        const MAX: usize = 5;
-        let height = std::cmp::min(self.options.len(), MAX);
-        let height = std::cmp::min(height, viewport.1 as usize);
+            acc
+        });
+        let len = max_lens.iter().sum::<usize>() + n + 1; // +1: reserve some space for scrollbar
+        let width = len.min(viewport.0 as usize);
+
+        self.widths = max_lens
+            .into_iter()
+            .map(|len| Constraint::Length(len as u16))
+            .collect();
+
+        let height = self.options.len().min(10).min(viewport.1 as usize);
 
         self.size = (width as u16, height as u16);
 
@@ -236,9 +256,11 @@ impl<T: 'static> Component for Menu<T> {
         Some(self.size)
     }
 
-    fn render(&self, area: Rect, surface: &mut Surface, cx: &mut Context) {
+    // TODO: required size should re-trigger when we filter items so we can draw a smaller menu
+
+    fn render(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) {
         let style = cx.editor.theme.get("ui.text");
-        let selected = Style::default().fg(Color::Rgb(255, 255, 255));
+        let selected = cx.editor.theme.get("ui.menu.selected");
 
         let scroll = self.scroll;
 
@@ -264,26 +286,39 @@ impl<T: 'static> Component for Menu<T> {
         let scroll_line = (win_height - scroll_height) * scroll
             / std::cmp::max(1, len.saturating_sub(win_height));
 
-        for (i, option) in options[scroll..(scroll + win_height).min(len)]
-            .iter()
-            .enumerate()
-        {
-            let line = Some(i + scroll);
-            // TODO: set bg for the whole row if selected
-            surface.set_stringn(
-                area.x,
-                area.y + i as u16,
-                (self.format_fn)(option),
-                area.width as usize - 1,
-                if line == self.cursor { selected } else { style },
-            );
+        let rows = options.iter().map(|option| option.row());
+        let table = Table::new(rows)
+            .style(style)
+            .highlight_style(selected)
+            .column_spacing(1)
+            .widths(&self.widths);
 
+        use tui::widgets::TableState;
+
+        table.render_table(
+            area,
+            surface,
+            &mut TableState {
+                offset: scroll,
+                selected: self.cursor,
+            },
+        );
+
+        // // TODO: set bg for the whole row if selected
+        // if line == self.cursor {
+        //     surface.set_style(
+        //         Rect::new(area.x, area.y + i as u16, area.width - 1, 1),
+        //         selected,
+        //     )
+        // }
+
+        for (i, _) in (scroll..(scroll + win_height).min(len)).enumerate() {
             let is_marked = i >= scroll_line && i < scroll_line + scroll_height;
 
             if is_marked {
                 let cell = surface.get_mut(area.x + area.width - 2, area.y + i as u16);
                 cell.set_symbol("▐ ");
-                cell.set_style(selected);
+                // cell.set_style(selected);
                 // cell.set_style(if is_marked { selected } else { style });
             }
         }

helix-term/src/ui/mod.rs

@@ -1,45 +1,47 @@
 mod completion;
-mod editor;
+pub(crate) mod editor;
+mod info;
 mod markdown;
 mod menu;
 mod picker;
 mod popup;
 mod prompt;
+mod spinner;
 mod text;
 
 pub use completion::Completion;
 pub use editor::EditorView;
 pub use markdown::Markdown;
 pub use menu::Menu;
-pub use picker::Picker;
+pub use picker::{FilePicker, Picker};
 pub use popup::Popup;
 pub use prompt::{Prompt, PromptEvent};
+pub use spinner::{ProgressSpinners, Spinner};
 pub use text::Text;
 
-pub use tui::layout::Rect;
-pub use tui::style::{Color, Modifier, Style};
-
 use helix_core::regex::Regex;
+use helix_core::register::Registers;
 use helix_view::{Document, Editor, View};
 
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
 pub fn regex_prompt(
     cx: &mut crate::commands::Context,
     prompt: String,
-    fun: impl Fn(&mut View, &mut Document, Regex) + 'static,
+    fun: impl Fn(&mut View, &mut Document, &mut Registers, Regex) + 'static,
 ) -> Prompt {
-    let view_id = cx.view().id;
-    let snapshot = cx.doc().selection(view_id).clone();
+    let (view, doc) = current!(cx.editor);
+    let view_id = view.id;
+    let snapshot = doc.selection(view_id).clone();
 
     Prompt::new(
         prompt,
-        |input: &str| Vec::new(), // this is fine because Vec::new() doesn't allocate
-        move |editor: &mut Editor, input: &str, event: PromptEvent| {
+        None,
+        |_input: &str| Vec::new(), // this is fine because Vec::new() doesn't allocate
+        move |cx: &mut crate::compositor::Context, input: &str, event: PromptEvent| {
             match event {
                 PromptEvent::Abort => {
-                    // TODO: also revert text
-                    let (view, doc) = editor.current();
+                    let (view, doc) = current!(cx.editor);
                     doc.set_selection(view.id, snapshot.clone());
                 }
                 PromptEvent::Validate => {
@@ -53,15 +55,15 @@ pub fn regex_prompt(
 
                     match Regex::new(input) {
                         Ok(regex) => {
-                            let (view, doc) = editor.current();
+                            let (view, doc) = current!(cx.editor);
+                            let registers = &mut cx.editor.registers;
 
                             // revert state to what it was before the last update
-                            // TODO: also revert text
                             doc.set_selection(view.id, snapshot.clone());
 
-                            fun(view, doc, regex);
+                            fun(view, doc, registers, regex);
 
-                            view.ensure_cursor_in_view(doc);
+                            view.ensure_cursor_in_view(doc, cx.editor.config.scrolloff);
                         }
                         Err(_err) => (), // TODO: mark command line as error
                     }
@@ -71,24 +73,41 @@ pub fn regex_prompt(
     )
 }
 
-pub fn file_picker(root: PathBuf) -> Picker<PathBuf> {
+pub fn file_picker(root: PathBuf) -> FilePicker<PathBuf> {
     use ignore::Walk;
-    let files = Walk::new(root.clone()).filter_map(|entry| match entry {
-        Ok(entry) => {
-            // filter dirs, but we might need special handling for symlinks!
-            if !entry.file_type().map_or(false, |entry| entry.is_dir()) {
-                Some(entry.into_path())
-            } else {
-                None
-            }
+    use std::time;
+    let files = Walk::new(root.clone()).filter_map(|entry| {
+        let entry = entry.ok()?;
+        // Path::is_dir() traverses symlinks, so we use it over DirEntry::is_dir
+        if entry.path().is_dir() {
+            // Will give a false positive if metadata cannot be read (eg. permission error)
+            return None;
         }
-        Err(_err) => None,
+
+        let time = entry.metadata().map_or(time::UNIX_EPOCH, |metadata| {
+            metadata
+                .accessed()
+                .or_else(|_| metadata.modified())
+                .or_else(|_| metadata.created())
+                .unwrap_or(time::UNIX_EPOCH)
+        });
+
+        Some((entry.into_path(), time))
     });
 
-    const MAX: usize = 1024;
+    let mut files: Vec<_> = if root.join(".git").is_dir() {
+        files.collect()
+    } else {
+        const MAX: usize = 8192;
+        files.take(MAX).collect()
+    };
 
-    Picker::new(
-        files.take(MAX).collect(),
+    files.sort_by_key(|file| std::cmp::Reverse(file.1));
+
+    let files = files.into_iter().map(|(path, _)| path).collect();
+
+    FilePicker::new(
+        files,
         move |path: &PathBuf| {
             // format_fn
             path.strip_prefix(&root)
@@ -98,30 +117,101 @@ pub fn file_picker(root: PathBuf) -> Picker<PathBuf> {
                 .into()
         },
         move |editor: &mut Editor, path: &PathBuf, action| {
-            let document_id = editor
+            editor
                 .open(path.into(), action)
                 .expect("editor.open failed");
         },
+        |_editor, path| Some((path.clone(), None)),
     )
 }
 
 pub mod completers {
     use crate::ui::prompt::Completion;
+    use fuzzy_matcher::skim::SkimMatcherV2 as Matcher;
+    use fuzzy_matcher::FuzzyMatcher;
+    use helix_view::theme;
     use std::borrow::Cow;
+    use std::cmp::Reverse;
 
     pub type Completer = fn(&str) -> Vec<Completion>;
 
-    // TODO: we could return an iter/lazy thing so it can fetch as many as it needs.
+    pub fn theme(input: &str) -> Vec<Completion> {
+        let mut names = theme::Loader::read_names(&helix_core::runtime_dir().join("themes"));
+        names.extend(theme::Loader::read_names(
+            &helix_core::config_dir().join("themes"),
+        ));
+        names.push("default".into());
+
+        let mut names: Vec<_> = names
+            .into_iter()
+            .map(|name| ((0..), Cow::from(name)))
+            .collect();
+
+        let matcher = Matcher::default();
+
+        let mut matches: Vec<_> = names
+            .into_iter()
+            .filter_map(|(_range, name)| {
+                matcher.fuzzy_match(&name, input).map(|score| (name, score))
+            })
+            .collect();
+
+        matches.sort_unstable_by_key(|(_file, score)| Reverse(*score));
+        names = matches.into_iter().map(|(name, _)| ((0..), name)).collect();
+
+        names
+    }
+
     pub fn filename(input: &str) -> Vec<Completion> {
+        filename_impl(input, |entry| {
+            let is_dir = entry.file_type().map_or(false, |entry| entry.is_dir());
+
+            if is_dir {
+                FileMatch::AcceptIncomplete
+            } else {
+                FileMatch::Accept
+            }
+        })
+    }
+
+    pub fn directory(input: &str) -> Vec<Completion> {
+        filename_impl(input, |entry| {
+            let is_dir = entry.file_type().map_or(false, |entry| entry.is_dir());
+
+            if is_dir {
+                FileMatch::Accept
+            } else {
+                FileMatch::Reject
+            }
+        })
+    }
+
+    #[derive(Copy, Clone, PartialEq, Eq)]
+    enum FileMatch {
+        /// Entry should be ignored
+        Reject,
+        /// Entry is usable but can't be the end (for instance if the entry is a directory and we
+        /// try to match a file)
+        AcceptIncomplete,
+        /// Entry is usable and can be the end of the match
+        Accept,
+    }
+
+    // TODO: we could return an iter/lazy thing so it can fetch as many as it needs.
+    fn filename_impl<F>(input: &str, filter_fn: F) -> Vec<Completion>
+    where
+        F: Fn(&ignore::DirEntry) -> FileMatch,
+    {
         // Rust's filename handling is really annoying.
 
         use ignore::WalkBuilder;
-        use std::path::{Path, PathBuf};
+        use std::path::Path;
 
-        let path = Path::new(input);
+        let is_tilde = input.starts_with('~') && input.len() == 1;
+        let path = helix_view::document::expand_tilde(Path::new(input));
 
         let (dir, file_name) = if input.ends_with('/') {
-            (path.into(), None)
+            (path, None)
         } else {
             let file_name = path
                 .file_name()
@@ -136,23 +226,39 @@ pub mod completers {
             (path, file_name)
         };
 
-        let end = (input.len()..);
+        let end = input.len()..;
 
         let mut files: Vec<_> = WalkBuilder::new(dir.clone())
             .max_depth(Some(1))
             .build()
             .filter_map(|file| {
-                file.ok().map(|entry| {
-                    let is_dir = entry.file_type().map_or(false, |entry| entry.is_dir());
+                file.ok().and_then(|entry| {
+                    let fmatch = filter_fn(&entry);
+
+                    if fmatch == FileMatch::Reject {
+                        return None;
+                    }
+
+                    //let is_dir = entry.file_type().map_or(false, |entry| entry.is_dir());
 
                     let path = entry.path();
-                    let mut path = path.strip_prefix(&dir).unwrap_or(path).to_path_buf();
+                    let mut path = if is_tilde {
+                        // if it's a single tilde an absolute path is displayed so that when `TAB` is pressed on
+                        // one of the directories the tilde will be replaced with a valid path not with a relative
+                        // home directory name.
+                        // ~ -> <TAB> -> /home/user
+                        // ~/ -> <TAB> -> ~/first_entry
+                        path.to_path_buf()
+                    } else {
+                        path.strip_prefix(&dir).unwrap_or(path).to_path_buf()
+                    };
 
-                    if is_dir {
+                    if fmatch == FileMatch::AcceptIncomplete {
                         path.push("");
                     }
+
                     let path = path.to_str().unwrap().to_owned();
-                    (end.clone(), Cow::from(path))
+                    Some((end.clone(), Cow::from(path)))
                 })
             }) // TODO: unwrap or skip
             .filter(|(_, path)| !path.is_empty()) // TODO
@@ -160,23 +266,19 @@ pub mod completers {
 
         // if empty, return a list of dirs and files in current dir
         if let Some(file_name) = file_name {
-            use fuzzy_matcher::skim::SkimMatcherV2 as Matcher;
-            use fuzzy_matcher::FuzzyMatcher;
-            use std::cmp::Reverse;
-
             let matcher = Matcher::default();
 
             // inefficient, but we need to calculate the scores, filter out None, then sort.
             let mut matches: Vec<_> = files
                 .into_iter()
-                .filter_map(|(range, file)| {
+                .filter_map(|(_range, file)| {
                     matcher
                         .fuzzy_match(&file, &file_name)
                         .map(|score| (file, score))
                 })
                 .collect();
 
-            let range = ((input.len() - file_name.len())..);
+            let range = (input.len().saturating_sub(file_name.len()))..;
 
             matches.sort_unstable_by_key(|(_file, score)| Reverse(*score));
             files = matches

helix-term/src/ui/picker.rs

@@ -1,21 +1,161 @@
-use crate::compositor::{Component, Compositor, Context, EventResult};
+use crate::{
+    compositor::{Component, Compositor, Context, EventResult},
+    ui::EditorView,
+};
 use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
 use tui::{
     buffer::Buffer as Surface,
-    layout::Rect,
-    style::{Color, Style},
     widgets::{Block, BorderType, Borders},
 };
 
 use fuzzy_matcher::skim::SkimMatcherV2 as Matcher;
 use fuzzy_matcher::FuzzyMatcher;
+use tui::widgets::Widget;
 
-use std::borrow::Cow;
+use std::{borrow::Cow, collections::HashMap, path::PathBuf};
 
 use crate::ui::{Prompt, PromptEvent};
 use helix_core::Position;
-use helix_view::editor::Action;
-use helix_view::Editor;
+use helix_view::{
+    document::canonicalize_path,
+    editor::Action,
+    graphics::{Color, CursorKind, Rect, Style},
+    Document, Editor,
+};
+
+pub const MIN_SCREEN_WIDTH_FOR_PREVIEW: u16 = 80;
+
+/// File path and line number (used to align and highlight a line)
+type FileLocation = (PathBuf, Option<usize>);
+
+pub struct FilePicker<T> {
+    picker: Picker<T>,
+    /// Caches paths to documents
+    preview_cache: HashMap<PathBuf, Document>,
+    /// Given an item in the picker, return the file path and line number to display.
+    file_fn: Box<dyn Fn(&Editor, &T) -> Option<FileLocation>>,
+}
+
+impl<T> FilePicker<T> {
+    pub fn new(
+        options: Vec<T>,
+        format_fn: impl Fn(&T) -> Cow<str> + 'static,
+        callback_fn: impl Fn(&mut Editor, &T, Action) + 'static,
+        preview_fn: impl Fn(&Editor, &T) -> Option<FileLocation> + 'static,
+    ) -> Self {
+        Self {
+            picker: Picker::new(false, options, format_fn, callback_fn),
+            preview_cache: HashMap::new(),
+            file_fn: Box::new(preview_fn),
+        }
+    }
+
+    fn current_file(&self, editor: &Editor) -> Option<FileLocation> {
+        self.picker
+            .selection()
+            .and_then(|current| (self.file_fn)(editor, current))
+            .and_then(|(path, line)| canonicalize_path(&path).ok().zip(Some(line)))
+    }
+
+    fn calculate_preview(&mut self, editor: &Editor) {
+        if let Some((path, _line)) = self.current_file(editor) {
+            if !self.preview_cache.contains_key(&path) && editor.document_by_path(&path).is_none() {
+                // TODO: enable syntax highlighting; blocked by async rendering
+                let doc = Document::open(&path, None, Some(&editor.theme), None).unwrap();
+                self.preview_cache.insert(path, doc);
+            }
+        }
+    }
+}
+
+impl<T: 'static> Component for FilePicker<T> {
+    fn render(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) {
+        // +---------+ +---------+
+        // |prompt   | |preview  |
+        // +---------+ |         |
+        // |picker   | |         |
+        // |         | |         |
+        // +---------+ +---------+
+        self.calculate_preview(cx.editor);
+        let render_preview = area.width > MIN_SCREEN_WIDTH_FOR_PREVIEW;
+        let area = inner_rect(area);
+        // -- Render the frame:
+        // clear area
+        let background = cx.editor.theme.get("ui.background");
+        surface.clear_with(area, background);
+
+        let picker_width = if render_preview {
+            area.width / 2
+        } else {
+            area.width
+        };
+
+        let picker_area = Rect::new(area.x, area.y, picker_width, area.height);
+        self.picker.render(picker_area, surface, cx);
+
+        if !render_preview {
+            return;
+        }
+
+        let preview_area = Rect::new(area.x + picker_width, area.y, area.width / 2, area.height);
+
+        // don't like this but the lifetime sucks
+        let block = Block::default().borders(Borders::ALL);
+
+        // calculate the inner area inside the box
+        let mut inner = block.inner(preview_area);
+        // 1 column gap on either side
+        inner.x += 1;
+        inner.width = inner.width.saturating_sub(2);
+
+        block.render(preview_area, surface);
+
+        if let Some((doc, line)) = self.current_file(cx.editor).and_then(|(path, line)| {
+            cx.editor
+                .document_by_path(&path)
+                .or_else(|| self.preview_cache.get(&path))
+                .zip(Some(line))
+        }) {
+            // align to middle
+            let first_line = line.unwrap_or(0).saturating_sub(inner.height as usize / 2);
+            let offset = Position::new(first_line, 0);
+
+            let highlights = EditorView::doc_syntax_highlights(
+                doc,
+                offset,
+                area.height,
+                &cx.editor.theme,
+                &cx.editor.syn_loader,
+            );
+            EditorView::render_text_highlights(
+                doc,
+                offset,
+                inner,
+                surface,
+                &cx.editor.theme,
+                highlights,
+            );
+
+            // highlight the line
+            if let Some(line) = line {
+                for x in inner.left()..inner.right() {
+                    surface
+                        .get_mut(x, inner.y + line.saturating_sub(first_line) as u16)
+                        .set_style(cx.editor.theme.get("ui.selection"));
+                }
+            }
+        }
+    }
+
+    fn handle_event(&mut self, event: Event, ctx: &mut Context) -> EventResult {
+        // TODO: keybinds for scrolling preview
+        self.picker.handle_event(event, ctx)
+    }
+
+    fn cursor(&self, area: Rect, ctx: &Editor) -> (Option<Position>, CursorKind) {
+        self.picker.cursor(area, ctx)
+    }
+}
 
 pub struct Picker<T> {
     options: Vec<T>,
@@ -23,10 +163,14 @@ pub struct Picker<T> {
     matcher: Box<Matcher>,
     /// (index, score)
     matches: Vec<(usize, i64)>,
+    /// Filter over original options.
+    filters: Vec<usize>, // could be optimized into bit but not worth it now
 
     cursor: usize,
     // pattern: String,
     prompt: Prompt,
+    /// Whether to render in the middle of the area
+    render_centered: bool,
 
     format_fn: Box<dyn Fn(&T) -> Cow<str>>,
     callback_fn: Box<dyn Fn(&mut Editor, &T, Action)>,
@@ -34,14 +178,16 @@ pub struct Picker<T> {
 
 impl<T> Picker<T> {
     pub fn new(
+        render_centered: bool,
         options: Vec<T>,
         format_fn: impl Fn(&T) -> Cow<str> + 'static,
         callback_fn: impl Fn(&mut Editor, &T, Action) + 'static,
     ) -> Self {
         let prompt = Prompt::new(
             "".to_string(),
-            |pattern: &str| Vec::new(),
-            |editor: &mut Editor, pattern: &str, event: PromptEvent| {
+            None,
+            |_pattern: &str| Vec::new(),
+            |_editor: &mut Context, _pattern: &str, _event: PromptEvent| {
                 //
             },
         );
@@ -50,8 +196,10 @@ impl<T> Picker<T> {
             options,
             matcher: Box::new(Matcher::default()),
             matches: Vec::new(),
+            filters: Vec::new(),
             cursor: 0,
             prompt,
+            render_centered,
             format_fn: Box::new(format_fn),
             callback_fn: Box::new(callback_fn),
         };
@@ -65,9 +213,9 @@ impl<T> Picker<T> {
     pub fn score(&mut self) {
         // need to borrow via pattern match otherwise it complains about simultaneous borrow
         let Self {
-            ref mut options,
             ref mut matcher,
             ref mut matches,
+            ref filters,
             ref format_fn,
             ..
         } = *self;
@@ -81,6 +229,10 @@ impl<T> Picker<T> {
                 .iter()
                 .enumerate()
                 .filter_map(|(index, option)| {
+                    // filter options first before matching
+                    if !filters.is_empty() {
+                        filters.binary_search(&index).ok()?;
+                    }
                     // TODO: maybe using format_fn isn't the best idea here
                     let text = (format_fn)(option);
                     // TODO: using fuzzy_indices could give us the char idx for match highlighting
@@ -100,8 +252,11 @@ impl<T> Picker<T> {
     }
 
     pub fn move_down(&mut self) {
-        // TODO: len - 1
-        if self.cursor < self.options.len() {
+        if self.matches.is_empty() {
+            return;
+        }
+
+        if self.cursor < self.matches.len() - 1 {
             self.cursor += 1;
         }
     }
@@ -111,6 +266,14 @@ impl<T> Picker<T> {
             .get(self.cursor)
             .map(|(index, _score)| &self.options[*index])
     }
+
+    pub fn save_filter(&mut self) {
+        self.filters.clear();
+        self.filters
+            .extend(self.matches.iter().map(|(index, _)| *index));
+        self.filters.sort_unstable(); // used for binary search later
+        self.prompt.clear();
+    }
 }
 
 // process:
@@ -118,6 +281,18 @@ impl<T> Picker<T> {
 // - on input change:
 //  - score all the names in relation to input
 
+fn inner_rect(area: Rect) -> Rect {
+    let padding_vertical = area.height * 10 / 100;
+    let padding_horizontal = area.width * 10 / 100;
+
+    Rect::new(
+        area.x + padding_horizontal,
+        area.y + padding_vertical,
+        area.width - padding_horizontal * 2,
+        area.height - padding_vertical * 2,
+    )
+}
+
 impl<T: 'static> Component for Picker<T> {
     fn handle_event(&mut self, event: Event, cx: &mut Context) -> EventResult {
         let key_event = match event {
@@ -128,7 +303,7 @@ impl<T: 'static> Component for Picker<T> {
 
         let close_fn = EventResult::Consumed(Some(Box::new(|compositor: &mut Compositor| {
             // remove the layer
-            compositor.pop();
+            compositor.last_picker = compositor.pop();
         })));
 
         match key_event {
@@ -136,19 +311,34 @@ impl<T: 'static> Component for Picker<T> {
                 code: KeyCode::Up, ..
             }
             | KeyEvent {
-                code: KeyCode::Char('k'),
+                code: KeyCode::BackTab,
+                ..
+            }
+            | KeyEvent {
+                code: KeyCode::Char('p'),
                 modifiers: KeyModifiers::CONTROL,
-            } => self.move_up(),
+            } => {
+                self.move_up();
+            }
             KeyEvent {
                 code: KeyCode::Down,
                 ..
             }
             | KeyEvent {
-                code: KeyCode::Char('j'),
+                code: KeyCode::Tab, ..
+            }
+            | KeyEvent {
+                code: KeyCode::Char('n'),
                 modifiers: KeyModifiers::CONTROL,
-            } => self.move_down(),
+            } => {
+                self.move_down();
+            }
             KeyEvent {
                 code: KeyCode::Esc, ..
+            }
+            | KeyEvent {
+                code: KeyCode::Char('c'),
+                modifiers: KeyModifiers::CONTROL,
             } => {
                 return close_fn;
             }
@@ -162,7 +352,7 @@ impl<T: 'static> Component for Picker<T> {
                 return close_fn;
             }
             KeyEvent {
-                code: KeyCode::Char('x'),
+                code: KeyCode::Char('h'),
                 modifiers: KeyModifiers::CONTROL,
             } => {
                 if let Some(option) = self.selection() {
@@ -179,6 +369,12 @@ impl<T: 'static> Component for Picker<T> {
                 }
                 return close_fn;
             }
+            KeyEvent {
+                code: KeyCode::Char(' '),
+                modifiers: KeyModifiers::CONTROL,
+            } => {
+                self.save_filter();
+            }
             _ => {
                 if let EventResult::Consumed(_) = self.prompt.handle_event(event, cx) {
                     // TODO: recalculate only if pattern changed
@@ -190,24 +386,20 @@ impl<T: 'static> Component for Picker<T> {
         EventResult::Consumed(None)
     }
 
-    fn render(&self, area: Rect, surface: &mut Surface, cx: &mut Context) {
-        let padding_vertical = area.height * 20 / 100;
-        let padding_horizontal = area.width * 20 / 100;
+    fn render(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) {
+        let area = if self.render_centered {
+            inner_rect(area)
+        } else {
+            area
+        };
 
-        let area = Rect::new(
-            area.x + padding_horizontal,
-            area.y + padding_vertical,
-            area.width - padding_horizontal * 2,
-            area.height - padding_vertical * 2,
-        );
+        let text_style = cx.editor.theme.get("ui.text");
 
         // -- Render the frame:
-
         // clear area
         let background = cx.editor.theme.get("ui.background");
         surface.clear_with(area, background);
 
-        use tui::widgets::Widget;
         // don't like this but the lifetime sucks
         let block = Block::default().borders(Borders::ALL);
 
@@ -215,51 +407,75 @@ impl<T: 'static> Component for Picker<T> {
         let inner = block.inner(area);
 
         block.render(area, surface);
-        // TODO: abstract into a clear(area) fn
-        // surface.set_style(inner, Style::default().bg(Color::Rgb(150, 50, 0)));
 
         // -- Render the input bar:
 
         let area = Rect::new(inner.x + 1, inner.y, inner.width - 1, 1);
+
+        let count = format!("{}/{}", self.matches.len(), self.options.len());
+        surface.set_stringn(
+            (area.x + area.width).saturating_sub(count.len() as u16 + 1),
+            area.y,
+            &count,
+            (count.len()).min(area.width as usize),
+            text_style,
+        );
+
         self.prompt.render(area, surface, cx);
 
         // -- Separator
-        let style = Style::default().fg(Color::Rgb(90, 89, 119));
-        let symbols = BorderType::line_symbols(BorderType::Plain);
+        let sep_style = Style::default().fg(Color::Rgb(90, 89, 119));
+        let borders = BorderType::line_symbols(BorderType::Plain);
         for x in inner.left()..inner.right() {
             surface
                 .get_mut(x, inner.y + 1)
-                .set_symbol(symbols.horizontal)
-                .set_style(style);
+                .set_symbol(borders.horizontal)
+                .set_style(sep_style);
         }
 
         // -- Render the contents:
+        // subtract the area of the prompt (-2) and current item marker " > " (-3)
+        let inner = Rect::new(inner.x + 3, inner.y + 2, inner.width - 3, inner.height - 2);
 
-        let style = cx.editor.theme.get("ui.text");
         let selected = Style::default().fg(Color::Rgb(255, 255, 255));
 
-        let rows = inner.height - 2; // -1 for search bar
+        let rows = inner.height;
+        let offset = self.cursor / (rows as usize) * (rows as usize);
 
-        let files = self.matches.iter().map(|(index, _score)| {
+        let files = self.matches.iter().skip(offset).map(|(index, _score)| {
             (index, self.options.get(*index).unwrap()) // get_unchecked
         });
 
         for (i, (_index, option)) in files.take(rows as usize).enumerate() {
-            if i == self.cursor {
-                surface.set_string(inner.x + 1, inner.y + 2 + i as u16, ">", selected);
+            if i == (self.cursor - offset) {
+                surface.set_string(inner.x - 2, inner.y + i as u16, ">", selected);
             }
 
-            surface.set_stringn(
-                inner.x + 3,
-                inner.y + 2 + i as u16,
+            surface.set_string_truncated(
+                inner.x,
+                inner.y + i as u16,
                 (self.format_fn)(option),
-                inner.width as usize - 1,
-                if i == self.cursor { selected } else { style },
+                inner.width as usize,
+                if i == (self.cursor - offset) {
+                    selected
+                } else {
+                    text_style
+                },
+                true,
             );
         }
     }
 
-    fn cursor_position(&self, area: Rect, editor: &Editor) -> Option<Position> {
-        self.prompt.cursor_position(area, editor)
+    fn cursor(&self, area: Rect, editor: &Editor) -> (Option<Position>, CursorKind) {
+        // TODO: this is mostly duplicate code
+        let area = inner_rect(area);
+        let block = Block::default().borders(Borders::ALL);
+        // calculate the inner area inside the box
+        let inner = block.inner(area);
+
+        // prompt area
+        let area = Rect::new(inner.x + 1, inner.y, inner.width - 1, 1);
+
+        self.prompt.cursor(area, editor)
     }
 }

helix-term/src/ui/popup.rs

@@ -1,15 +1,9 @@
 use crate::compositor::{Component, Compositor, Context, EventResult};
 use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
-use tui::{
-    buffer::Buffer as Surface,
-    layout::Rect,
-    style::{Color, Style},
-};
-
-use std::borrow::Cow;
+use tui::buffer::Buffer as Surface;
 
 use helix_core::Position;
-use helix_view::Editor;
+use helix_view::graphics::Rect;
 
 // TODO: share logic with Menu, it's essentially Popup(render_fn), but render fn needs to return
 // a width/height hint. maybe Popup(Box<Component>)
@@ -58,7 +52,7 @@ impl<T: Component> Component for Popup<T> {
     fn handle_event(&mut self, event: Event, cx: &mut Context) -> EventResult {
         let key = match event {
             Event::Key(event) => event,
-            Event::Resize(width, height) => {
+            Event::Resize(_, _) => {
                 // TODO: calculate inner area, call component's handle_event with that area
                 return EventResult::Ignored;
             }
@@ -100,7 +94,7 @@ impl<T: Component> Component for Popup<T> {
         // tab/enter/ctrl-k or whatever will confirm the selection/ ctrl-n/ctrl-p for scroll.
     }
 
-    fn required_size(&mut self, viewport: (u16, u16)) -> Option<(u16, u16)> {
+    fn required_size(&mut self, _viewport: (u16, u16)) -> Option<(u16, u16)> {
         let (width, height) = self
             .contents
             .required_size((120, 26)) // max width, max height
@@ -111,12 +105,12 @@ impl<T: Component> Component for Popup<T> {
         Some(self.size)
     }
 
-    fn render(&self, viewport: Rect, surface: &mut Surface, cx: &mut Context) {
+    fn render(&mut self, viewport: Rect, surface: &mut Surface, cx: &mut Context) {
         cx.scroll = Some(self.scroll);
 
         let position = self
             .position
-            .or_else(|| cx.editor.cursor_position())
+            .or_else(|| cx.editor.cursor().0)
             .unwrap_or_default();
 
         let (width, height) = self.size;
@@ -125,18 +119,17 @@ impl<T: Component> Component for Popup<T> {
         let mut rel_x = position.col as u16;
         let mut rel_y = position.row as u16;
         if viewport.width <= rel_x + width {
-            rel_x -= ((rel_x + width) - viewport.width)
+            rel_x = rel_x.saturating_sub((rel_x + width).saturating_sub(viewport.width));
         };
 
         // TODO: be able to specify orientation preference. We want above for most popups, below
         // for menus/autocomplete.
         if height <= rel_y {
-            rel_y -= height // position above point
+            rel_y = rel_y.saturating_sub(height) // position above point
         } else {
             rel_y += 1 // position below point
         }
 
-        let area = Rect::new(rel_x, rel_y, width, height);
         // clip to viewport
         let area = viewport.intersection(Rect::new(rel_x, rel_y, width, height));
 

helix-term/src/ui/prompt.rs

@@ -1,9 +1,16 @@
 use crate::compositor::{Component, Compositor, Context, EventResult};
 use crate::ui;
 use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
-use helix_core::Position;
-use helix_view::{Editor, Theme};
 use std::{borrow::Cow, ops::RangeFrom};
+use tui::buffer::Buffer as Surface;
+
+use helix_core::{
+    unicode::segmentation::GraphemeCursor, unicode::width::UnicodeWidthStr, Position,
+};
+use helix_view::{
+    graphics::{CursorKind, Margin, Rect},
+    Editor,
+};
 
 pub type Completion = (RangeFrom<usize>, Cow<'static, str>);
 
@@ -13,12 +20,14 @@ pub struct Prompt {
     cursor: usize,
     completion: Vec<Completion>,
     selection: Option<usize>,
+    history_register: Option<char>,
+    history_pos: Option<usize>,
     completion_fn: Box<dyn FnMut(&str) -> Vec<Completion>>,
-    callback_fn: Box<dyn FnMut(&mut Editor, &str, PromptEvent)>,
+    callback_fn: Box<dyn FnMut(&mut Context, &str, PromptEvent)>,
     pub doc_fn: Box<dyn Fn(&str) -> Option<&'static str>>,
 }
 
-#[derive(PartialEq)]
+#[derive(Clone, Copy, PartialEq)]
 pub enum PromptEvent {
     /// The prompt input has been updated.
     Update,
@@ -28,11 +37,28 @@ pub enum PromptEvent {
     Abort,
 }
 
+pub enum CompletionDirection {
+    Forward,
+    Backward,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum Movement {
+    BackwardChar(usize),
+    BackwardWord(usize),
+    ForwardChar(usize),
+    ForwardWord(usize),
+    StartOfLine,
+    EndOfLine,
+    None,
+}
+
 impl Prompt {
     pub fn new(
         prompt: String,
+        history_register: Option<char>,
         mut completion_fn: impl FnMut(&str) -> Vec<Completion> + 'static,
-        callback_fn: impl FnMut(&mut Editor, &str, PromptEvent) + 'static,
+        callback_fn: impl FnMut(&mut Context, &str, PromptEvent) + 'static,
     ) -> Self {
         Self {
             prompt,
@@ -40,27 +66,128 @@ impl Prompt {
             cursor: 0,
             completion: completion_fn(""),
             selection: None,
+            history_register,
+            history_pos: None,
             completion_fn: Box::new(completion_fn),
             callback_fn: Box::new(callback_fn),
             doc_fn: Box::new(|_| None),
         }
     }
 
+    /// Compute the cursor position after applying movement
+    /// Taken from: https://github.com/wez/wezterm/blob/e0b62d07ca9bf8ce69a61e30a3c20e7abc48ce7e/termwiz/src/lineedit/mod.rs#L516-L611
+    fn eval_movement(&self, movement: Movement) -> usize {
+        match movement {
+            Movement::BackwardChar(rep) => {
+                let mut position = self.cursor;
+                for _ in 0..rep {
+                    let mut cursor = GraphemeCursor::new(position, self.line.len(), false);
+                    if let Ok(Some(pos)) = cursor.prev_boundary(&self.line, 0) {
+                        position = pos;
+                    } else {
+                        break;
+                    }
+                }
+                position
+            }
+            Movement::BackwardWord(rep) => {
+                let char_indices: Vec<(usize, char)> = self.line.char_indices().collect();
+                if char_indices.is_empty() {
+                    return self.cursor;
+                }
+                let mut char_position = char_indices
+                    .iter()
+                    .position(|(idx, _)| *idx == self.cursor)
+                    .unwrap_or(char_indices.len() - 1);
+
+                for _ in 0..rep {
+                    if char_position == 0 {
+                        break;
+                    }
+
+                    let mut found = None;
+                    for prev in (0..char_position - 1).rev() {
+                        if char_indices[prev].1.is_whitespace() {
+                            found = Some(prev + 1);
+                            break;
+                        }
+                    }
+
+                    char_position = found.unwrap_or(0);
+                }
+                char_indices[char_position].0
+            }
+            Movement::ForwardWord(rep) => {
+                let char_indices: Vec<(usize, char)> = self.line.char_indices().collect();
+                if char_indices.is_empty() {
+                    return self.cursor;
+                }
+                let mut char_position = char_indices
+                    .iter()
+                    .position(|(idx, _)| *idx == self.cursor)
+                    .unwrap_or_else(|| char_indices.len());
+
+                for _ in 0..rep {
+                    // Skip any non-whitespace characters
+                    while char_position < char_indices.len()
+                        && !char_indices[char_position].1.is_whitespace()
+                    {
+                        char_position += 1;
+                    }
+
+                    // Skip any whitespace characters
+                    while char_position < char_indices.len()
+                        && char_indices[char_position].1.is_whitespace()
+                    {
+                        char_position += 1;
+                    }
+
+                    // We are now on the start of the next word
+                }
+                char_indices
+                    .get(char_position)
+                    .map(|(i, _)| *i)
+                    .unwrap_or_else(|| self.line.len())
+            }
+            Movement::ForwardChar(rep) => {
+                let mut position = self.cursor;
+                for _ in 0..rep {
+                    let mut cursor = GraphemeCursor::new(position, self.line.len(), false);
+                    if let Ok(Some(pos)) = cursor.next_boundary(&self.line, 0) {
+                        position = pos;
+                    } else {
+                        break;
+                    }
+                }
+                position
+            }
+            Movement::StartOfLine => 0,
+            Movement::EndOfLine => {
+                let mut cursor =
+                    GraphemeCursor::new(self.line.len().saturating_sub(1), self.line.len(), false);
+                if let Ok(Some(pos)) = cursor.next_boundary(&self.line, 0) {
+                    pos
+                } else {
+                    self.cursor
+                }
+            }
+            Movement::None => self.cursor,
+        }
+    }
+
     pub fn insert_char(&mut self, c: char) {
         self.line.insert(self.cursor, c);
-        self.cursor += 1;
+        let mut cursor = GraphemeCursor::new(self.cursor, self.line.len(), false);
+        if let Ok(Some(pos)) = cursor.next_boundary(&self.line, 0) {
+            self.cursor = pos;
+        }
         self.completion = (self.completion_fn)(&self.line);
         self.exit_selection();
     }
 
-    pub fn move_char_left(&mut self) {
-        self.cursor = self.cursor.saturating_sub(1)
-    }
-
-    pub fn move_char_right(&mut self) {
-        if self.cursor < self.line.len() {
-            self.cursor += 1;
-        }
+    pub fn move_cursor(&mut self, movement: Movement) {
+        let pos = self.eval_movement(movement);
+        self.cursor = pos
     }
 
     pub fn move_start(&mut self) {
@@ -72,19 +199,72 @@ impl Prompt {
     }
 
     pub fn delete_char_backwards(&mut self) {
-        if self.cursor > 0 {
-            self.line.remove(self.cursor - 1);
-            self.cursor -= 1;
-            self.completion = (self.completion_fn)(&self.line);
-        }
+        let pos = self.eval_movement(Movement::BackwardChar(1));
+        self.line.replace_range(pos..self.cursor, "");
+        self.cursor = pos;
+
+        self.exit_selection();
+        self.completion = (self.completion_fn)(&self.line);
+    }
+
+    pub fn delete_word_backwards(&mut self) {
+        let pos = self.eval_movement(Movement::BackwardWord(1));
+        self.line.replace_range(pos..self.cursor, "");
+        self.cursor = pos;
+
+        self.exit_selection();
+        self.completion = (self.completion_fn)(&self.line);
+    }
+
+    pub fn kill_to_end_of_line(&mut self) {
+        let pos = self.eval_movement(Movement::EndOfLine);
+        self.line.replace_range(self.cursor..pos, "");
+
+        self.exit_selection();
+        self.completion = (self.completion_fn)(&self.line);
+    }
+
+    pub fn clear(&mut self) {
+        self.line.clear();
+        self.cursor = 0;
+        self.completion = (self.completion_fn)(&self.line);
         self.exit_selection();
     }
 
-    pub fn change_completion_selection(&mut self) {
+    pub fn change_history(&mut self, register: &[String], direction: CompletionDirection) {
+        if register.is_empty() {
+            return;
+        }
+
+        let end = register.len().saturating_sub(1);
+
+        let index = match direction {
+            CompletionDirection::Forward => self.history_pos.map_or(0, |i| i + 1),
+            CompletionDirection::Backward => {
+                self.history_pos.unwrap_or(register.len()).saturating_sub(1)
+            }
+        }
+        .min(end);
+
+        self.line = register[index].clone();
+
+        self.history_pos = Some(index);
+
+        self.move_end();
+    }
+
+    pub fn change_completion_selection(&mut self, direction: CompletionDirection) {
         if self.completion.is_empty() {
             return;
         }
-        let index = self.selection.map_or(0, |i| i + 1) % self.completion.len();
+
+        let index = match direction {
+            CompletionDirection::Forward => self.selection.map_or(0, |i| i + 1),
+            CompletionDirection::Backward => {
+                self.selection.unwrap_or(0) + self.completion.len() - 1
+            }
+        } % self.completion.len();
+
         self.selection = Some(index);
 
         let (range, item) = &self.completion[index];
@@ -92,29 +272,37 @@ impl Prompt {
         self.line.replace_range(range.clone(), item);
 
         self.move_end();
-        // TODO: recalculate completion when completion item is accepted, (Enter)
     }
+
     pub fn exit_selection(&mut self) {
         self.selection = None;
     }
 }
 
-use tui::{
-    buffer::Buffer as Surface,
-    layout::Rect,
-    style::{Color, Modifier, Style},
-};
-
 const BASE_WIDTH: u16 = 30;
 
 impl Prompt {
     pub fn render_prompt(&self, area: Rect, surface: &mut Surface, cx: &mut Context) {
         let theme = &cx.editor.theme;
         let text_color = theme.get("ui.text.focus");
+        let selected_color = theme.get("ui.menu.selected");
         // completion
 
-        let max_col = area.width / BASE_WIDTH;
-        let height = ((self.completion.len() as u16 + max_col - 1) / max_col);
+        let max_len = self
+            .completion
+            .iter()
+            .map(|(_, completion)| completion.len() as u16)
+            .max()
+            .unwrap_or(BASE_WIDTH)
+            .max(BASE_WIDTH);
+
+        let cols = std::cmp::max(1, area.width / max_len);
+        let col_width = (area.width - (cols)) / cols;
+
+        let height = ((self.completion.len() as u16 + cols - 1) / cols)
+            .min(10) // at most 10 rows (or less)
+            .min(area.height.saturating_sub(1));
+
         let completion_area = Rect::new(
             area.x,
             (area.height - height).saturating_sub(1),
@@ -126,22 +314,33 @@ impl Prompt {
             let area = completion_area;
             let background = theme.get("ui.statusline");
 
+            let items = height as usize * cols as usize;
+
+            let offset = self
+                .selection
+                .map(|selection| selection / items * items)
+                .unwrap_or_default();
+
             surface.clear_with(area, background);
 
             let mut row = 0;
             let mut col = 0;
 
-            for (i, (_range, completion)) in self.completion.iter().enumerate() {
+            // TODO: paginate
+            for (i, (_range, completion)) in
+                self.completion.iter().enumerate().skip(offset).take(items)
+            {
                 let color = if Some(i) == self.selection {
-                    Style::default().bg(Color::Rgb(104, 60, 232))
+                    // Style::default().bg(Color::Rgb(104, 60, 232))
+                    selected_color // TODO: just invert bg
                 } else {
                     text_color
                 };
                 surface.set_stringn(
-                    area.x + 1 + col * BASE_WIDTH,
+                    area.x + col * (1 + col_width),
                     area.y + row,
                     &completion,
-                    BASE_WIDTH as usize - 1,
+                    col_width.saturating_sub(1) as usize,
                     color,
                 );
                 row += 1;
@@ -149,26 +348,23 @@ impl Prompt {
                     row = 0;
                     col += 1;
                 }
-                if col > max_col {
-                    break;
-                }
             }
         }
 
         if let Some(doc) = (self.doc_fn)(&self.line) {
-            let text = ui::Text::new(doc.to_string());
+            let mut text = ui::Text::new(doc.to_string());
 
-            let area = Rect::new(
+            let viewport = area;
+            let area = viewport.intersection(Rect::new(
                 completion_area.x,
-                completion_area.y - 3,
-                completion_area.width,
+                completion_area.y.saturating_sub(3),
+                BASE_WIDTH * 3,
                 3,
-            );
+            ));
 
-            let background = theme.get("ui.window");
+            let background = theme.get("ui.help");
             surface.clear_with(area, background);
 
-            use tui::layout::Margin;
             text.render(
                 area.inner(&Margin {
                     vertical: 1,
@@ -215,47 +411,131 @@ impl Component for Prompt {
                 modifiers: KeyModifiers::SHIFT,
             } => {
                 self.insert_char(c);
-                (self.callback_fn)(cx.editor, &self.line, PromptEvent::Update);
+                (self.callback_fn)(cx, &self.line, PromptEvent::Update);
             }
             KeyEvent {
+                code: KeyCode::Char('c'),
+                modifiers: KeyModifiers::CONTROL,
+            }
+            | KeyEvent {
                 code: KeyCode::Esc, ..
             } => {
-                (self.callback_fn)(cx.editor, &self.line, PromptEvent::Abort);
+                (self.callback_fn)(cx, &self.line, PromptEvent::Abort);
                 return close_fn;
             }
             KeyEvent {
+                code: KeyCode::Left,
+                modifiers: KeyModifiers::ALT,
+            }
+            | KeyEvent {
+                code: KeyCode::Char('b'),
+                modifiers: KeyModifiers::ALT,
+            } => self.move_cursor(Movement::BackwardWord(1)),
+            KeyEvent {
+                code: KeyCode::Right,
+                modifiers: KeyModifiers::ALT,
+            }
+            | KeyEvent {
+                code: KeyCode::Char('f'),
+                modifiers: KeyModifiers::ALT,
+            } => self.move_cursor(Movement::ForwardWord(1)),
+            KeyEvent {
+                code: KeyCode::Char('f'),
+                modifiers: KeyModifiers::CONTROL,
+            }
+            | KeyEvent {
                 code: KeyCode::Right,
                 ..
-            } => self.move_char_right(),
+            } => self.move_cursor(Movement::ForwardChar(1)),
             KeyEvent {
+                code: KeyCode::Char('b'),
+                modifiers: KeyModifiers::CONTROL,
+            }
+            | KeyEvent {
                 code: KeyCode::Left,
                 ..
-            } => self.move_char_left(),
+            } => self.move_cursor(Movement::BackwardChar(1)),
             KeyEvent {
+                code: KeyCode::End,
+                modifiers: KeyModifiers::NONE,
+            }
+            | KeyEvent {
                 code: KeyCode::Char('e'),
                 modifiers: KeyModifiers::CONTROL,
             } => self.move_end(),
             KeyEvent {
+                code: KeyCode::Home,
+                modifiers: KeyModifiers::NONE,
+            }
+            | KeyEvent {
                 code: KeyCode::Char('a'),
                 modifiers: KeyModifiers::CONTROL,
             } => self.move_start(),
+            KeyEvent {
+                code: KeyCode::Char('w'),
+                modifiers: KeyModifiers::CONTROL,
+            } => self.delete_word_backwards(),
+            KeyEvent {
+                code: KeyCode::Char('k'),
+                modifiers: KeyModifiers::CONTROL,
+            } => self.kill_to_end_of_line(),
             KeyEvent {
                 code: KeyCode::Backspace,
                 modifiers: KeyModifiers::NONE,
             } => {
                 self.delete_char_backwards();
-                (self.callback_fn)(cx.editor, &self.line, PromptEvent::Update);
+                (self.callback_fn)(cx, &self.line, PromptEvent::Update);
             }
             KeyEvent {
                 code: KeyCode::Enter,
                 ..
             } => {
-                (self.callback_fn)(cx.editor, &self.line, PromptEvent::Validate);
-                return close_fn;
+                if self.selection.is_some() && self.line.ends_with('/') {
+                    self.completion = (self.completion_fn)(&self.line);
+                    self.exit_selection();
+                } else {
+                    (self.callback_fn)(cx, &self.line, PromptEvent::Validate);
+
+                    if let Some(register) = self.history_register {
+                        // store in history
+                        let register = cx.editor.registers.get_mut(register);
+                        register.push(self.line.clone());
+                    }
+                    return close_fn;
+                }
+            }
+            KeyEvent {
+                code: KeyCode::Char('p'),
+                modifiers: KeyModifiers::CONTROL,
+            }
+            | KeyEvent {
+                code: KeyCode::Up, ..
+            } => {
+                if let Some(register) = self.history_register {
+                    let register = cx.editor.registers.get_mut(register);
+                    self.change_history(register.read(), CompletionDirection::Backward);
+                }
+            }
+            KeyEvent {
+                code: KeyCode::Char('n'),
+                modifiers: KeyModifiers::CONTROL,
+            }
+            | KeyEvent {
+                code: KeyCode::Down,
+                ..
+            } => {
+                if let Some(register) = self.history_register {
+                    let register = cx.editor.registers.get_mut(register);
+                    self.change_history(register.read(), CompletionDirection::Forward);
+                }
             }
             KeyEvent {
                 code: KeyCode::Tab, ..
-            } => self.change_completion_selection(),
+            } => self.change_completion_selection(CompletionDirection::Forward),
+            KeyEvent {
+                code: KeyCode::BackTab,
+                ..
+            } => self.change_completion_selection(CompletionDirection::Backward),
             KeyEvent {
                 code: KeyCode::Char('q'),
                 modifiers: KeyModifiers::CONTROL,
@@ -266,14 +546,20 @@ impl Component for Prompt {
         EventResult::Consumed(None)
     }
 
-    fn render(&self, area: Rect, surface: &mut Surface, cx: &mut Context) {
+    fn render(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) {
         self.render_prompt(area, surface, cx)
     }
 
-    fn cursor_position(&self, area: Rect, editor: &Editor) -> Option<Position> {
-        Some(Position::new(
-            area.height as usize,
-            area.x as usize + self.prompt.len() + self.cursor,
-        ))
+    fn cursor(&self, area: Rect, _editor: &Editor) -> (Option<Position>, CursorKind) {
+        let line = area.height as usize - 1;
+        (
+            Some(Position::new(
+                area.y as usize + line,
+                area.x as usize
+                    + self.prompt.len()
+                    + UnicodeWidthStr::width(&self.line[..self.cursor]),
+            )),
+            CursorKind::Block,
+        )
     }
 }

helix-term/src/ui/spinner.rs

@@ -0,0 +1,75 @@
+use std::{collections::HashMap, time::SystemTime};
+
+#[derive(Default, Debug)]
+pub struct ProgressSpinners {
+    inner: HashMap<usize, Spinner>,
+}
+
+impl ProgressSpinners {
+    pub fn get(&self, id: usize) -> Option<&Spinner> {
+        self.inner.get(&id)
+    }
+
+    pub fn get_or_create(&mut self, id: usize) -> &mut Spinner {
+        self.inner.entry(id).or_insert_with(Spinner::default)
+    }
+}
+
+impl Default for Spinner {
+    fn default() -> Self {
+        Self::dots(80)
+    }
+}
+
+#[derive(Debug)]
+pub struct Spinner {
+    frames: Vec<&'static str>,
+    count: usize,
+    start: Option<SystemTime>,
+    interval: u64,
+}
+
+impl Spinner {
+    /// Creates a new spinner with `frames` and `interval`.
+    /// Expects the frames count and interval to be greater than 0.
+    pub fn new(frames: Vec<&'static str>, interval: u64) -> Self {
+        let count = frames.len();
+        assert!(count > 0);
+        assert!(interval > 0);
+
+        Self {
+            frames,
+            count,
+            interval,
+            start: None,
+        }
+    }
+
+    pub fn dots(interval: u64) -> Self {
+        Self::new(vec!["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"], interval)
+    }
+
+    pub fn start(&mut self) {
+        self.start = Some(SystemTime::now());
+    }
+
+    pub fn frame(&self) -> Option<&str> {
+        let idx = (self
+            .start
+            .map(|time| SystemTime::now().duration_since(time))?
+            .ok()?
+            .as_millis()
+            / self.interval as u128) as usize
+            % self.count;
+
+        self.frames.get(idx).copied()
+    }
+
+    pub fn stop(&mut self) {
+        self.start = None;
+    }
+
+    pub fn is_stopped(&self) -> bool {
+        self.start.is_none()
+    }
+}

helix-term/src/ui/text.rs

@@ -1,15 +1,7 @@
-use crate::compositor::{Component, Compositor, Context, EventResult};
-use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
-use tui::{
-    buffer::Buffer as Surface,
-    layout::Rect,
-    style::{Color, Style},
-};
+use crate::compositor::{Component, Context};
+use tui::buffer::Buffer as Surface;
 
-use std::borrow::Cow;
-
-use helix_core::Position;
-use helix_view::Editor;
+use helix_view::graphics::Rect;
 
 pub struct Text {
     contents: String,
@@ -21,12 +13,10 @@ impl Text {
     }
 }
 impl Component for Text {
-    fn render(&self, area: Rect, surface: &mut Surface, cx: &mut Context) {
+    fn render(&mut self, area: Rect, surface: &mut Surface, _cx: &mut Context) {
         use tui::widgets::{Paragraph, Widget, Wrap};
         let contents = tui::text::Text::from(self.contents.clone());
 
-        let style = cx.editor.theme.get("ui.text");
-
         let par = Paragraph::new(contents).wrap(Wrap { trim: false });
         // .scroll(x, y) offsets
 

helix-tui/Cargo.toml

@@ -1,12 +1,16 @@
 [package]
 name = "helix-tui"
-version = "0.1.0"
+version = "0.4.1"
 authors = ["Blaž Hrastnik <blaz@mxxn.io>"]
 description = """
 A library to build rich terminal user interfaces or dashboards
 """
 edition = "2018"
 license = "MPL-2.0"
+categories = ["editor"]
+repository = "https://github.com/helix-editor/helix"
+homepage = "https://helix-editor.com"
+include = ["src/**/*", "README.md"]
 
 [features]
 default = ["crossterm"]
@@ -14,7 +18,8 @@ default = ["crossterm"]
 [dependencies]
 bitflags = "1.0"
 cassowary = "0.3"
-unicode-segmentation = "1.2"
-unicode-width = "0.1"
-crossterm = { version = "0.19", optional = true }
+unicode-segmentation = "1.8"
+crossterm = { version = "0.20", optional = true }
 serde = { version = "1", "optional" = true, features = ["derive"]}
+helix-view = { version = "0.4", path = "../helix-view", features = ["term"] }
+helix-core = { version = "0.4", path = "../helix-core" }

helix-tui/src/backend/crossterm.rs

@@ -1,11 +1,6 @@
-use crate::{
-    backend::Backend,
-    buffer::Cell,
-    layout::Rect,
-    style::{Color, Modifier},
-};
+use crate::{backend::Backend, buffer::Cell};
 use crossterm::{
-    cursor::{Hide, MoveTo, Show},
+    cursor::{CursorShape, Hide, MoveTo, SetCursorShape, Show},
     execute, queue,
     style::{
         Attribute as CAttribute, Color as CColor, Print, SetAttribute, SetBackgroundColor,
@@ -13,6 +8,7 @@ use crossterm::{
     },
     terminal::{self, Clear, ClearType},
 };
+use helix_view::graphics::{Color, CursorKind, Modifier, Rect};
 use std::io::{self, Write};
 
 pub struct CrosstermBackend<W: Write> {
@@ -93,8 +89,14 @@ where
         map_error(execute!(self.buffer, Hide))
     }
 
-    fn show_cursor(&mut self) -> io::Result<()> {
-        map_error(execute!(self.buffer, Show))
+    fn show_cursor(&mut self, kind: CursorKind) -> io::Result<()> {
+        let shape = match kind {
+            CursorKind::Block => CursorShape::Block,
+            CursorKind::Bar => CursorShape::Line,
+            CursorKind::Underline => CursorShape::UnderScore,
+            CursorKind::Hidden => unreachable!(),
+        };
+        map_error(execute!(self.buffer, Show, SetCursorShape(shape)))
     }
 
     fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
@@ -126,32 +128,6 @@ fn map_error(error: crossterm::Result<()>) -> io::Result<()> {
     error.map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))
 }
 
-impl From<Color> for CColor {
-    fn from(color: Color) -> Self {
-        match color {
-            Color::Reset => CColor::Reset,
-            Color::Black => CColor::Black,
-            Color::Red => CColor::DarkRed,
-            Color::Green => CColor::DarkGreen,
-            Color::Yellow => CColor::DarkYellow,
-            Color::Blue => CColor::DarkBlue,
-            Color::Magenta => CColor::DarkMagenta,
-            Color::Cyan => CColor::DarkCyan,
-            Color::Gray => CColor::Grey,
-            Color::DarkGray => CColor::DarkGrey,
-            Color::LightRed => CColor::Red,
-            Color::LightGreen => CColor::Green,
-            Color::LightBlue => CColor::Blue,
-            Color::LightYellow => CColor::Yellow,
-            Color::LightMagenta => CColor::Magenta,
-            Color::LightCyan => CColor::Cyan,
-            Color::White => CColor::White,
-            Color::Indexed(i) => CColor::AnsiValue(i),
-            Color::Rgb(r, g, b) => CColor::Rgb { r, g, b },
-        }
-    }
-}
-
 #[derive(Debug)]
 struct ModifierDiff {
     pub from: Modifier,

helix-tui/src/backend/mod.rs

@@ -1,7 +1,8 @@
 use std::io;
 
 use crate::buffer::Cell;
-use crate::layout::Rect;
+
+use helix_view::graphics::{CursorKind, Rect};
 
 #[cfg(feature = "crossterm")]
 mod crossterm;
@@ -16,7 +17,7 @@ pub trait Backend {
     where
         I: Iterator<Item = (u16, u16, &'a Cell)>;
     fn hide_cursor(&mut self) -> Result<(), io::Error>;
-    fn show_cursor(&mut self) -> Result<(), io::Error>;
+    fn show_cursor(&mut self, kind: CursorKind) -> Result<(), io::Error>;
     fn get_cursor(&mut self) -> Result<(u16, u16), io::Error>;
     fn set_cursor(&mut self, x: u16, y: u16) -> Result<(), io::Error>;
     fn clear(&mut self) -> Result<(), io::Error>;

helix-tui/src/backend/test.rs

@@ -1,10 +1,10 @@
 use crate::{
     backend::Backend,
     buffer::{Buffer, Cell},
-    layout::Rect,
 };
+use helix_core::unicode::width::UnicodeWidthStr;
+use helix_view::graphics::{CursorKind, Rect};
 use std::{fmt::Write, io};
-use unicode_width::UnicodeWidthStr;
 
 /// A backend used for the integration tests.
 #[derive(Debug)]
@@ -122,7 +122,7 @@ impl Backend for TestBackend {
         Ok(())
     }
 
-    fn show_cursor(&mut self) -> Result<(), io::Error> {
+    fn show_cursor(&mut self, _kind: CursorKind) -> Result<(), io::Error> {
         self.cursor = true;
         Ok(())
     }

helix-tui/src/buffer.rs

@@ -1,11 +1,9 @@
-use crate::{
-    layout::Rect,
-    style::{Color, Modifier, Style},
-    text::{Span, Spans},
-};
+use crate::text::{Span, Spans};
+use helix_core::unicode::width::UnicodeWidthStr;
 use std::cmp::min;
 use unicode_segmentation::UnicodeSegmentation;
-use unicode_width::UnicodeWidthStr;
+
+use helix_view::graphics::{Color, Modifier, Rect, Style};
 
 /// A buffer cell
 #[derive(Debug, Clone, PartialEq)]
@@ -89,8 +87,7 @@ impl Default for Cell {
 ///
 /// ```
 /// use helix_tui::buffer::{Buffer, Cell};
-/// use helix_tui::layout::Rect;
-/// use helix_tui::style::{Color, Style, Modifier};
+/// use helix_view::graphics::{Rect, Color, Style, Modifier};
 ///
 /// let mut buf = Buffer::empty(Rect{x: 0, y: 0, width: 10, height: 5});
 /// buf.get_mut(0, 2).set_symbol("x");
@@ -193,7 +190,7 @@ impl Buffer {
     ///
     /// ```
     /// # use helix_tui::buffer::Buffer;
-    /// # use helix_tui::layout::Rect;
+    /// # use helix_view::graphics::Rect;
     /// let rect = Rect::new(200, 100, 10, 10);
     /// let buffer = Buffer::empty(rect);
     /// // Global coordinates to the top corner of this buffer's area
@@ -203,16 +200,6 @@ impl Buffer {
     /// # Panics
     ///
     /// Panics when given an coordinate that is outside of this Buffer's area.
-    ///
-    /// ```should_panic
-    /// # use helix_tui::buffer::Buffer;
-    /// # use helix_tui::layout::Rect;
-    /// let rect = Rect::new(200, 100, 10, 10);
-    /// let buffer = Buffer::empty(rect);
-    /// // Top coordinate is outside of the buffer in global coordinate space, as the Buffer's area
-    /// // starts at (200, 100).
-    /// buffer.index_of(0, 0); // Panics
-    /// ```
     pub fn index_of(&self, x: u16, y: u16) -> usize {
         debug_assert!(
             x >= self.area.left()
@@ -235,7 +222,7 @@ impl Buffer {
     ///
     /// ```
     /// # use helix_tui::buffer::Buffer;
-    /// # use helix_tui::layout::Rect;
+    /// # use helix_view::graphics::Rect;
     /// let rect = Rect::new(200, 100, 10, 10);
     /// let buffer = Buffer::empty(rect);
     /// assert_eq!(buffer.pos_of(0), (200, 100));
@@ -245,15 +232,6 @@ impl Buffer {
     /// # Panics
     ///
     /// Panics when given an index that is outside the Buffer's content.
-    ///
-    /// ```should_panic
-    /// # use helix_tui::buffer::Buffer;
-    /// # use helix_tui::layout::Rect;
-    /// let rect = Rect::new(0, 0, 10, 10); // 100 cells in total
-    /// let buffer = Buffer::empty(rect);
-    /// // Index 100 is the 101th cell, which lies outside of the area of this Buffer.
-    /// buffer.pos_of(100); // Panics
-    /// ```
     pub fn pos_of(&self, i: usize) -> (u16, u16) {
         debug_assert!(
             i < self.content.len(),
@@ -285,11 +263,30 @@ impl Buffer {
         width: usize,
         style: Style,
     ) -> (u16, u16)
+    where
+        S: AsRef<str>,
+    {
+        self.set_string_truncated(x, y, string, width, style, false)
+    }
+
+    /// Print at most the first `width` characters of a string if enough space is available
+    /// until the end of the line. If `markend` is true appends a `…` at the end of
+    /// truncated lines.
+    pub fn set_string_truncated<S>(
+        &mut self,
+        x: u16,
+        y: u16,
+        string: S,
+        width: usize,
+        style: Style,
+        ellipsis: bool,
+    ) -> (u16, u16)
     where
         S: AsRef<str>,
     {
         let mut index = self.index_of(x, y);
         let mut x_offset = x as usize;
+        let width = if ellipsis { width - 1 } else { width };
         let graphemes = UnicodeSegmentation::graphemes(string.as_ref(), true);
         let max_offset = min(self.area.right() as usize, width.saturating_add(x as usize));
         for s in graphemes {
@@ -312,6 +309,9 @@ impl Buffer {
             index += width;
             x_offset += width;
         }
+        if ellipsis && x_offset - (x as usize) < string.as_ref().width() {
+            self.content[index].set_symbol("…");
+        }
         (x_offset as u16, y)
     }
 
@@ -510,6 +510,7 @@ mod tests {
 
     #[test]
     #[should_panic(expected = "outside the buffer")]
+    #[cfg(debug_assertions)]
     fn pos_of_panics_on_out_of_bounds() {
         let rect = Rect::new(0, 0, 10, 10);
         let buf = Buffer::empty(rect);
@@ -520,6 +521,7 @@ mod tests {
 
     #[test]
     #[should_panic(expected = "outside the buffer")]
+    #[cfg(debug_assertions)]
     fn index_of_panics_on_out_of_bounds() {
         let rect = Rect::new(0, 0, 10, 10);
         let buf = Buffer::empty(rect);

helix-tui/src/layout.rs

@@ -1,11 +1,12 @@
 use std::cell::RefCell;
-use std::cmp::{max, min};
 use std::collections::HashMap;
 
 use cassowary::strength::{REQUIRED, WEAK};
 use cassowary::WeightedRelation::*;
 use cassowary::{Constraint as CassowaryConstraint, Expression, Solver, Variable};
 
+use helix_view::graphics::{Margin, Rect};
+
 #[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)]
 pub enum Corner {
     TopLeft,
@@ -45,12 +46,6 @@ impl Constraint {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Margin {
-    pub vertical: u16,
-    pub horizontal: u16,
-}
-
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Alignment {
     Left,
@@ -119,7 +114,8 @@ impl Layout {
     ///
     /// # Examples
     /// ```
-    /// # use helix_tui::layout::{Rect, Constraint, Direction, Layout};
+    /// # use helix_tui::layout::{Constraint, Direction, Layout};
+    /// # use helix_view::graphics::Rect;
     /// let chunks = Layout::default()
     ///     .direction(Direction::Vertical)
     ///     .constraints([Constraint::Length(5), Constraint::Min(0)].as_ref())
@@ -348,117 +344,6 @@ impl Element {
     }
 }
 
-/// A simple rectangle used in the computation of the layout and to give widgets an hint about the
-/// area they are supposed to render to.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
-pub struct Rect {
-    pub x: u16,
-    pub y: u16,
-    pub width: u16,
-    pub height: u16,
-}
-
-impl Default for Rect {
-    fn default() -> Rect {
-        Rect {
-            x: 0,
-            y: 0,
-            width: 0,
-            height: 0,
-        }
-    }
-}
-
-impl Rect {
-    /// Creates a new rect, with width and height limited to keep the area under max u16.
-    /// If clipped, aspect ratio will be preserved.
-    pub fn new(x: u16, y: u16, width: u16, height: u16) -> Rect {
-        let max_area = u16::max_value();
-        let (clipped_width, clipped_height) =
-            if u32::from(width) * u32::from(height) > u32::from(max_area) {
-                let aspect_ratio = f64::from(width) / f64::from(height);
-                let max_area_f = f64::from(max_area);
-                let height_f = (max_area_f / aspect_ratio).sqrt();
-                let width_f = height_f * aspect_ratio;
-                (width_f as u16, height_f as u16)
-            } else {
-                (width, height)
-            };
-        Rect {
-            x,
-            y,
-            width: clipped_width,
-            height: clipped_height,
-        }
-    }
-
-    pub fn area(self) -> u16 {
-        self.width * self.height
-    }
-
-    pub fn left(self) -> u16 {
-        self.x
-    }
-
-    pub fn right(self) -> u16 {
-        self.x.saturating_add(self.width)
-    }
-
-    pub fn top(self) -> u16 {
-        self.y
-    }
-
-    pub fn bottom(self) -> u16 {
-        self.y.saturating_add(self.height)
-    }
-
-    pub fn inner(self, margin: &Margin) -> Rect {
-        if self.width < 2 * margin.horizontal || self.height < 2 * margin.vertical {
-            Rect::default()
-        } else {
-            Rect {
-                x: self.x + margin.horizontal,
-                y: self.y + margin.vertical,
-                width: self.width - 2 * margin.horizontal,
-                height: self.height - 2 * margin.vertical,
-            }
-        }
-    }
-
-    pub fn union(self, other: Rect) -> Rect {
-        let x1 = min(self.x, other.x);
-        let y1 = min(self.y, other.y);
-        let x2 = max(self.x + self.width, other.x + other.width);
-        let y2 = max(self.y + self.height, other.y + other.height);
-        Rect {
-            x: x1,
-            y: y1,
-            width: x2 - x1,
-            height: y2 - y1,
-        }
-    }
-
-    pub fn intersection(self, other: Rect) -> Rect {
-        let x1 = max(self.x, other.x);
-        let y1 = max(self.y, other.y);
-        let x2 = min(self.x + self.width, other.x + other.width);
-        let y2 = min(self.y + self.height, other.y + other.height);
-        Rect {
-            x: x1,
-            y: y1,
-            width: x2 - x1,
-            height: y2 - y1,
-        }
-    }
-
-    pub fn intersects(self, other: Rect) -> bool {
-        self.x < other.x + other.width
-            && self.x + self.width > other.x
-            && self.y < other.y + other.height
-            && self.y + self.height > other.y
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -487,48 +372,4 @@ mod tests {
         assert_eq!(target.height, chunks.iter().map(|r| r.height).sum::<u16>());
         chunks.windows(2).for_each(|w| assert!(w[0].y <= w[1].y));
     }
-
-    #[test]
-    fn test_rect_size_truncation() {
-        for width in 256u16..300u16 {
-            for height in 256u16..300u16 {
-                let rect = Rect::new(0, 0, width, height);
-                rect.area(); // Should not panic.
-                assert!(rect.width < width || rect.height < height);
-                // The target dimensions are rounded down so the math will not be too precise
-                // but let's make sure the ratios don't diverge crazily.
-                assert!(
-                    (f64::from(rect.width) / f64::from(rect.height)
-                        - f64::from(width) / f64::from(height))
-                    .abs()
-                        < 1.0
-                )
-            }
-        }
-
-        // One dimension below 255, one above. Area above max u16.
-        let width = 900;
-        let height = 100;
-        let rect = Rect::new(0, 0, width, height);
-        assert_ne!(rect.width, 900);
-        assert_ne!(rect.height, 100);
-        assert!(rect.width < width || rect.height < height);
-    }
-
-    #[test]
-    fn test_rect_size_preservation() {
-        for width in 0..256u16 {
-            for height in 0..256u16 {
-                let rect = Rect::new(0, 0, width, height);
-                rect.area(); // Should not panic.
-                assert_eq!(rect.width, width);
-                assert_eq!(rect.height, height);
-            }
-        }
-
-        // One dimension below 255, one above. Area below max u16.
-        let rect = Rect::new(0, 0, 300, 100);
-        assert_eq!(rect.width, 300);
-        assert_eq!(rect.height, 100);
-    }
 }

helix-tui/src/lib.rs

@@ -44,7 +44,7 @@
 //! implement your own.
 //!
 //! Each widget follows a builder pattern API providing a default configuration along with methods
-//! to customize them. The widget is then rendered using the [`Frame::render_widget`] which take
+//! to customize them. The widget is then rendered using the `Frame::render_widget` which take
 //! your widget instance an area to draw to.
 //!
 //! The following example renders a block of the size of the terminal:
@@ -125,7 +125,6 @@
 pub mod backend;
 pub mod buffer;
 pub mod layout;
-pub mod style;
 pub mod symbols;
 pub mod terminal;
 pub mod text;

helix-tui/src/style.rs

@@ -1,281 +0,0 @@
-//! `style` contains the primitives used to control how your user interface will look.
-
-use bitflags::bitflags;
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub enum Color {
-    Reset,
-    Black,
-    Red,
-    Green,
-    Yellow,
-    Blue,
-    Magenta,
-    Cyan,
-    Gray,
-    DarkGray,
-    LightRed,
-    LightGreen,
-    LightYellow,
-    LightBlue,
-    LightMagenta,
-    LightCyan,
-    White,
-    Rgb(u8, u8, u8),
-    Indexed(u8),
-}
-
-bitflags! {
-    /// Modifier changes the way a piece of text is displayed.
-    ///
-    /// They are bitflags so they can easily be composed.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use helix_tui::style::Modifier;
-    ///
-    /// let m = Modifier::BOLD | Modifier::ITALIC;
-    /// ```
-    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-    pub struct Modifier: u16 {
-        const BOLD              = 0b0000_0000_0001;
-        const DIM               = 0b0000_0000_0010;
-        const ITALIC            = 0b0000_0000_0100;
-        const UNDERLINED        = 0b0000_0000_1000;
-        const SLOW_BLINK        = 0b0000_0001_0000;
-        const RAPID_BLINK       = 0b0000_0010_0000;
-        const REVERSED          = 0b0000_0100_0000;
-        const HIDDEN            = 0b0000_1000_0000;
-        const CROSSED_OUT       = 0b0001_0000_0000;
-    }
-}
-
-/// Style let you control the main characteristics of the displayed elements.
-///
-/// ```rust
-/// # use helix_tui::style::{Color, Modifier, Style};
-/// Style::default()
-///     .fg(Color::Black)
-///     .bg(Color::Green)
-///     .add_modifier(Modifier::ITALIC | Modifier::BOLD);
-/// ```
-///
-/// It represents an incremental change. If you apply the styles S1, S2, S3 to a cell of the
-/// terminal buffer, the style of this cell will be the result of the merge of S1, S2 and S3, not
-/// just S3.
-///
-/// ```rust
-/// # use helix_tui::style::{Color, Modifier, Style};
-/// # use helix_tui::buffer::Buffer;
-/// # use helix_tui::layout::Rect;
-/// let styles = [
-///     Style::default().fg(Color::Blue).add_modifier(Modifier::BOLD | Modifier::ITALIC),
-///     Style::default().bg(Color::Red),
-///     Style::default().fg(Color::Yellow).remove_modifier(Modifier::ITALIC),
-/// ];
-/// let mut buffer = Buffer::empty(Rect::new(0, 0, 1, 1));
-/// for style in &styles {
-///   buffer.get_mut(0, 0).set_style(*style);
-/// }
-/// assert_eq!(
-///     Style {
-///         fg: Some(Color::Yellow),
-///         bg: Some(Color::Red),
-///         add_modifier: Modifier::BOLD,
-///         sub_modifier: Modifier::empty(),
-///     },
-///     buffer.get(0, 0).style(),
-/// );
-/// ```
-///
-/// The default implementation returns a `Style` that does not modify anything. If you wish to
-/// reset all properties until that point use [`Style::reset`].
-///
-/// ```
-/// # use helix_tui::style::{Color, Modifier, Style};
-/// # use helix_tui::buffer::Buffer;
-/// # use helix_tui::layout::Rect;
-/// let styles = [
-///     Style::default().fg(Color::Blue).add_modifier(Modifier::BOLD | Modifier::ITALIC),
-///     Style::reset().fg(Color::Yellow),
-/// ];
-/// let mut buffer = Buffer::empty(Rect::new(0, 0, 1, 1));
-/// for style in &styles {
-///   buffer.get_mut(0, 0).set_style(*style);
-/// }
-/// assert_eq!(
-///     Style {
-///         fg: Some(Color::Yellow),
-///         bg: Some(Color::Reset),
-///         add_modifier: Modifier::empty(),
-///         sub_modifier: Modifier::empty(),
-///     },
-///     buffer.get(0, 0).style(),
-/// );
-/// ```
-#[derive(Debug, Clone, Copy, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct Style {
-    pub fg: Option<Color>,
-    pub bg: Option<Color>,
-    pub add_modifier: Modifier,
-    pub sub_modifier: Modifier,
-}
-
-impl Default for Style {
-    fn default() -> Style {
-        Style {
-            fg: None,
-            bg: None,
-            add_modifier: Modifier::empty(),
-            sub_modifier: Modifier::empty(),
-        }
-    }
-}
-
-impl Style {
-    /// Returns a `Style` resetting all properties.
-    pub fn reset() -> Style {
-        Style {
-            fg: Some(Color::Reset),
-            bg: Some(Color::Reset),
-            add_modifier: Modifier::empty(),
-            sub_modifier: Modifier::all(),
-        }
-    }
-
-    /// Changes the foreground color.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use helix_tui::style::{Color, Style};
-    /// let style = Style::default().fg(Color::Blue);
-    /// let diff = Style::default().fg(Color::Red);
-    /// assert_eq!(style.patch(diff), Style::default().fg(Color::Red));
-    /// ```
-    pub fn fg(mut self, color: Color) -> Style {
-        self.fg = Some(color);
-        self
-    }
-
-    /// Changes the background color.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use helix_tui::style::{Color, Style};
-    /// let style = Style::default().bg(Color::Blue);
-    /// let diff = Style::default().bg(Color::Red);
-    /// assert_eq!(style.patch(diff), Style::default().bg(Color::Red));
-    /// ```
-    pub fn bg(mut self, color: Color) -> Style {
-        self.bg = Some(color);
-        self
-    }
-
-    /// Changes the text emphasis.
-    ///
-    /// When applied, it adds the given modifier to the `Style` modifiers.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use helix_tui::style::{Color, Modifier, Style};
-    /// let style = Style::default().add_modifier(Modifier::BOLD);
-    /// let diff = Style::default().add_modifier(Modifier::ITALIC);
-    /// let patched = style.patch(diff);
-    /// assert_eq!(patched.add_modifier, Modifier::BOLD | Modifier::ITALIC);
-    /// assert_eq!(patched.sub_modifier, Modifier::empty());
-    /// ```
-    pub fn add_modifier(mut self, modifier: Modifier) -> Style {
-        self.sub_modifier.remove(modifier);
-        self.add_modifier.insert(modifier);
-        self
-    }
-
-    /// Changes the text emphasis.
-    ///
-    /// When applied, it removes the given modifier from the `Style` modifiers.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use helix_tui::style::{Color, Modifier, Style};
-    /// let style = Style::default().add_modifier(Modifier::BOLD | Modifier::ITALIC);
-    /// let diff = Style::default().remove_modifier(Modifier::ITALIC);
-    /// let patched = style.patch(diff);
-    /// assert_eq!(patched.add_modifier, Modifier::BOLD);
-    /// assert_eq!(patched.sub_modifier, Modifier::ITALIC);
-    /// ```
-    pub fn remove_modifier(mut self, modifier: Modifier) -> Style {
-        self.add_modifier.remove(modifier);
-        self.sub_modifier.insert(modifier);
-        self
-    }
-
-    /// Results in a combined style that is equivalent to applying the two individual styles to
-    /// a style one after the other.
-    ///
-    /// ## Examples
-    /// ```
-    /// # use helix_tui::style::{Color, Modifier, Style};
-    /// let style_1 = Style::default().fg(Color::Yellow);
-    /// let style_2 = Style::default().bg(Color::Red);
-    /// let combined = style_1.patch(style_2);
-    /// assert_eq!(
-    ///     Style::default().patch(style_1).patch(style_2),
-    ///     Style::default().patch(combined));
-    /// ```
-    pub fn patch(mut self, other: Style) -> Style {
-        self.fg = other.fg.or(self.fg);
-        self.bg = other.bg.or(self.bg);
-
-        self.add_modifier.remove(other.sub_modifier);
-        self.add_modifier.insert(other.add_modifier);
-        self.sub_modifier.remove(other.add_modifier);
-        self.sub_modifier.insert(other.sub_modifier);
-
-        self
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn styles() -> Vec<Style> {
-        vec![
-            Style::default(),
-            Style::default().fg(Color::Yellow),
-            Style::default().bg(Color::Yellow),
-            Style::default().add_modifier(Modifier::BOLD),
-            Style::default().remove_modifier(Modifier::BOLD),
-            Style::default().add_modifier(Modifier::ITALIC),
-            Style::default().remove_modifier(Modifier::ITALIC),
-            Style::default().add_modifier(Modifier::ITALIC | Modifier::BOLD),
-            Style::default().remove_modifier(Modifier::ITALIC | Modifier::BOLD),
-        ]
-    }
-
-    #[test]
-    fn combined_patch_gives_same_result_as_individual_patch() {
-        let styles = styles();
-        for &a in &styles {
-            for &b in &styles {
-                for &c in &styles {
-                    for &d in &styles {
-                        let combined = a.patch(b.patch(c.patch(d)));
-
-                        assert_eq!(
-                            Style::default().patch(a).patch(b).patch(c).patch(d),
-                            Style::default().patch(combined)
-                        );
-                    }
-                }
-            }
-        }
-    }
-}

helix-tui/src/terminal.rs

@@ -1,4 +1,5 @@
-use crate::{backend::Backend, buffer::Buffer, layout::Rect};
+use crate::{backend::Backend, buffer::Buffer};
+use helix_view::graphics::{CursorKind, Rect};
 use std::io;
 
 #[derive(Debug, Clone, PartialEq)]
@@ -44,8 +45,8 @@ where
     buffers: [Buffer; 2],
     /// Index of the current buffer in the previous array
     current: usize,
-    /// Whether the cursor is currently hidden
-    hidden_cursor: bool,
+    /// Kind of cursor (hidden or others)
+    cursor_kind: CursorKind,
     /// Viewport
     viewport: Viewport,
 }
@@ -56,8 +57,8 @@ where
 {
     fn drop(&mut self) {
         // Attempt to restore the cursor state
-        if self.hidden_cursor {
-            if let Err(err) = self.show_cursor() {
+        if self.cursor_kind == CursorKind::Hidden {
+            if let Err(err) = self.show_cursor(CursorKind::Block) {
                 eprintln!("Failed to show the cursor: {}", err);
             }
         }
@@ -92,7 +93,7 @@ where
                 Buffer::empty(options.viewport.area),
             ],
             current: 0,
-            hidden_cursor: false,
+            cursor_kind: CursorKind::Block,
             viewport: options.viewport,
         })
     }
@@ -137,19 +138,21 @@ where
     }
 
     /// Queries the backend for size and resizes if it doesn't match the previous size.
-    pub fn autoresize(&mut self) -> io::Result<()> {
-        if self.viewport.resize_behavior == ResizeBehavior::Auto {
-            let size = self.size()?;
-            if size != self.viewport.area {
-                self.resize(size)?;
-            }
+    pub fn autoresize(&mut self) -> io::Result<Rect> {
+        let size = self.size()?;
+        if size != self.viewport.area {
+            self.resize(size)?;
         };
-        Ok(())
+        Ok(size)
     }
 
     /// Synchronizes terminal size, calls the rendering closure, flushes the current internal state
     /// and prepares for the next draw call.
-    pub fn draw(&mut self, cursor_position: Option<(u16, u16)>) -> io::Result<()> {
+    pub fn draw(
+        &mut self,
+        cursor_position: Option<(u16, u16)>,
+        cursor_kind: CursorKind,
+    ) -> io::Result<()> {
         // // Autoresize - otherwise we get glitches if shrinking or potential desync between widgets
         // // and the terminal (if growing), which may OOB.
         // self.autoresize()?;
@@ -164,12 +167,13 @@ where
         // Draw to stdout
         self.flush()?;
 
-        match cursor_position {
-            None => self.hide_cursor()?,
-            Some((x, y)) => {
-                self.show_cursor()?;
-                self.set_cursor(x, y)?;
-            }
+        if let Some((x, y)) = cursor_position {
+            self.set_cursor(x, y)?;
+        }
+
+        match cursor_kind {
+            CursorKind::Hidden => self.hide_cursor()?,
+            kind => self.show_cursor(kind)?,
         }
 
         // Swap buffers
@@ -181,15 +185,20 @@ where
         Ok(())
     }
 
+    #[inline]
+    pub fn cursor_kind(&self) -> CursorKind {
+        self.cursor_kind
+    }
+
     pub fn hide_cursor(&mut self) -> io::Result<()> {
         self.backend.hide_cursor()?;
-        self.hidden_cursor = true;
+        self.cursor_kind = CursorKind::Hidden;
         Ok(())
     }
 
-    pub fn show_cursor(&mut self) -> io::Result<()> {
-        self.backend.show_cursor()?;
-        self.hidden_cursor = false;
+    pub fn show_cursor(&mut self, kind: CursorKind) -> io::Result<()> {
+        self.backend.show_cursor(kind)?;
+        self.cursor_kind = kind;
         Ok(())
     }
 

helix-tui/src/text.rs

@@ -21,7 +21,7 @@
 //! ```rust
 //! # use helix_tui::widgets::Block;
 //! # use helix_tui::text::{Span, Spans};
-//! # use helix_tui::style::{Color, Style};
+//! # use helix_view::graphics::{Color, Style};
 //! // A simple string with no styling.
 //! // Converted to Spans(vec![
 //! //   Span { content: Cow::Borrowed("My title"), style: Style { .. } }
@@ -46,10 +46,11 @@
 //!     Span::raw(" title"),
 //! ]);
 //! ```
-use crate::style::Style;
+use helix_core::line_ending::str_is_line_ending;
+use helix_core::unicode::width::UnicodeWidthStr;
+use helix_view::graphics::Style;
 use std::borrow::Cow;
 use unicode_segmentation::UnicodeSegmentation;
-use unicode_width::UnicodeWidthStr;
 
 /// A grapheme associated to a style.
 #[derive(Debug, Clone, PartialEq)]
@@ -91,7 +92,7 @@ impl<'a> Span<'a> {
     ///
     /// ```rust
     /// # use helix_tui::text::Span;
-    /// # use helix_tui::style::{Color, Modifier, Style};
+    /// # use helix_view::graphics::{Color, Modifier, Style};
     /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
     /// Span::styled("My text", style);
     /// Span::styled(String::from("My text"), style);
@@ -120,7 +121,7 @@ impl<'a> Span<'a> {
     ///
     /// ```rust
     /// # use helix_tui::text::{Span, StyledGrapheme};
-    /// # use helix_tui::style::{Color, Modifier, Style};
+    /// # use helix_view::graphics::{Color, Modifier, Style};
     /// # use std::iter::Iterator;
     /// let style = Style::default().fg(Color::Yellow);
     /// let span = Span::styled("Text", style);
@@ -177,7 +178,7 @@ impl<'a> Span<'a> {
                 symbol: g,
                 style: base_style.patch(self.style),
             })
-            .filter(|s| s.symbol != "\n")
+            .filter(|s| !str_is_line_ending(s.symbol))
     }
 }
 
@@ -210,7 +211,7 @@ impl<'a> Spans<'a> {
     ///
     /// ```rust
     /// # use helix_tui::text::{Span, Spans};
-    /// # use helix_tui::style::{Color, Style};
+    /// # use helix_view::graphics::{Color, Style};
     /// let spans = Spans::from(vec![
     ///     Span::styled("My", Style::default().fg(Color::Yellow)),
     ///     Span::raw(" text"),
@@ -264,7 +265,7 @@ impl<'a> From<Spans<'a>> for String {
 ///
 /// ```rust
 /// # use helix_tui::text::Text;
-/// # use helix_tui::style::{Color, Modifier, Style};
+/// # use helix_view::graphics::{Color, Modifier, Style};
 /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
 ///
 /// // An initial two lines of `Text` built from a `&str`
@@ -318,7 +319,7 @@ impl<'a> Text<'a> {
     ///
     /// ```rust
     /// # use helix_tui::text::Text;
-    /// # use helix_tui::style::{Color, Modifier, Style};
+    /// # use helix_view::graphics::{Color, Modifier, Style};
     /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
     /// Text::styled("The first line\nThe second line", style);
     /// Text::styled(String::from("The first line\nThe second line"), style);
@@ -368,7 +369,7 @@ impl<'a> Text<'a> {
     ///
     /// ```rust
     /// # use helix_tui::text::Text;
-    /// # use helix_tui::style::{Color, Modifier, Style};
+    /// # use helix_view::graphics::{Color, Modifier, Style};
     /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
     /// let mut raw_text = Text::raw("The first line\nThe second line");
     /// let styled_text = Text::styled(String::from("The first line\nThe second line"), style);

helix-tui/src/widgets/block.rs

@@ -1,11 +1,10 @@
 use crate::{
     buffer::Buffer,
-    layout::Rect,
-    style::Style,
     symbols::line,
     text::{Span, Spans},
     widgets::{Borders, Widget},
 };
+use helix_view::graphics::{Rect, Style};
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum BorderType {
@@ -33,7 +32,7 @@ impl BorderType {
 ///
 /// ```
 /// # use helix_tui::widgets::{Block, BorderType, Borders};
-/// # use helix_tui::style::{Style, Color};
+/// # use helix_view::graphics::{Style, Color};
 /// Block::default()
 ///     .title("Block")
 ///     .borders(Borders::LEFT | Borders::RIGHT)
@@ -212,7 +211,6 @@ impl<'a> Widget for Block<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::layout::Rect;
 
     #[test]
     fn inner_takes_into_account_the_borders() {

helix-tui/src/widgets/mod.rs

@@ -1,4 +1,4 @@
-//! `widgets` is a collection of types that implement [`Widget`] or [`StatefulWidget`] or both.
+//! `widgets` is a collection of types that implement [`Widget`].
 //!
 //! All widgets are implemented using the builder pattern and are consumable objects. They are not
 //! meant to be stored but used as *commands* to draw common figures in the UI.
@@ -13,16 +13,18 @@ mod block;
 // mod list;
 mod paragraph;
 mod reflow;
-// mod table;
+mod table;
 
 pub use self::block::{Block, BorderType};
 // pub use self::list::{List, ListItem, ListState};
 pub use self::paragraph::{Paragraph, Wrap};
-// pub use self::table::{Cell, Row, Table, TableState};
+pub use self::table::{Cell, Row, Table, TableState};
 
-use crate::{buffer::Buffer, layout::Rect};
+use crate::buffer::Buffer;
 use bitflags::bitflags;
 
+use helix_view::graphics::Rect;
+
 bitflags! {
     /// Bitflags that can be composed to set the visible borders essentially on the block widget.
     pub struct Borders: u32 {

helix-tui/src/widgets/paragraph.rs

@@ -1,15 +1,15 @@
 use crate::{
     buffer::Buffer,
-    layout::{Alignment, Rect},
-    style::Style,
+    layout::Alignment,
     text::{StyledGrapheme, Text},
     widgets::{
         reflow::{LineComposer, LineTruncator, WordWrapper},
         Block, Widget,
     },
 };
+use helix_core::unicode::width::UnicodeWidthStr;
+use helix_view::graphics::{Rect, Style};
 use std::iter;
-use unicode_width::UnicodeWidthStr;
 
 fn get_line_offset(line_width: u16, text_area_width: u16, alignment: Alignment) -> u16 {
     match alignment {
@@ -26,8 +26,8 @@ fn get_line_offset(line_width: u16, text_area_width: u16, alignment: Alignment)
 /// ```
 /// # use helix_tui::text::{Text, Spans, Span};
 /// # use helix_tui::widgets::{Block, Borders, Paragraph, Wrap};
-/// # use helix_tui::style::{Style, Color, Modifier};
 /// # use helix_tui::layout::{Alignment};
+/// # use helix_view::graphics::{Style, Color, Modifier};
 /// let text = vec![
 ///     Spans::from(vec![
 ///         Span::raw("First"),

helix-tui/src/widgets/reflow.rs

@@ -1,6 +1,7 @@
 use crate::text::StyledGrapheme;
+use helix_core::line_ending::str_is_line_ending;
+use helix_core::unicode::width::UnicodeWidthStr;
 use unicode_segmentation::UnicodeSegmentation;
-use unicode_width::UnicodeWidthStr;
 
 const NBSP: &str = "\u{00a0}";
 
@@ -62,13 +63,13 @@ impl<'a, 'b> LineComposer<'a> for WordWrapper<'a, 'b> {
             // Ignore characters wider that the total max width.
             if symbol.width() as u16 > self.max_line_width
                 // Skip leading whitespace when trim is enabled.
-                || self.trim && symbol_whitespace && symbol != "\n" && current_line_width == 0
+                || self.trim && symbol_whitespace && !str_is_line_ending(symbol) && current_line_width == 0
             {
                 continue;
             }
 
             // Break on newline and discard it.
-            if symbol == "\n" {
+            if str_is_line_ending(symbol) {
                 if prev_whitespace {
                     current_line_width = width_to_last_word_end;
                     self.current_line.truncate(symbols_to_last_word_end);
@@ -170,7 +171,7 @@ impl<'a, 'b> LineComposer<'a> for LineTruncator<'a, 'b> {
             }
 
             // Break on newline and discard it.
-            if symbol == "\n" {
+            if str_is_line_ending(symbol) {
                 break;
             }
 
@@ -199,7 +200,7 @@ impl<'a, 'b> LineComposer<'a> for LineTruncator<'a, 'b> {
 
         if skip_rest {
             for StyledGrapheme { symbol, .. } in &mut self.symbols {
-                if symbol == "\n" {
+                if str_is_line_ending(symbol) {
                     break;
                 }
             }

helix-tui/src/widgets/table.rs

@@ -1,28 +1,25 @@
 use crate::{
     buffer::Buffer,
-    layout::{Constraint, Rect},
-    style::Style,
+    layout::Constraint,
     text::Text,
-    widgets::{Block, StatefulWidget, Widget},
+    widgets::{Block, Widget},
 };
 use cassowary::{
     strength::{MEDIUM, REQUIRED, WEAK},
     WeightedRelation::*,
     {Expression, Solver},
 };
-use std::{
-    collections::HashMap,
-    iter::{self, Iterator},
-};
-use unicode_width::UnicodeWidthStr;
+use helix_core::unicode::width::UnicodeWidthStr;
+use helix_view::graphics::{Rect, Style};
+use std::collections::HashMap;
 
 /// A [`Cell`] contains the [`Text`] to be displayed in a [`Row`] of a [`Table`].
 ///
 /// It can be created from anything that can be converted to a [`Text`].
 /// ```rust
 /// # use helix_tui::widgets::Cell;
-/// # use helix_tui::style::{Style, Modifier};
 /// # use helix_tui::text::{Span, Spans, Text};
+/// # use helix_view::graphics::{Style, Modifier};
 /// Cell::from("simple string");
 ///
 /// Cell::from(Span::from("span"));
@@ -39,7 +36,7 @@ use unicode_width::UnicodeWidthStr;
 /// capabilities of [`Text`].
 #[derive(Debug, Clone, PartialEq, Default)]
 pub struct Cell<'a> {
-    content: Text<'a>,
+    pub content: Text<'a>,
     style: Style,
 }
 
@@ -74,7 +71,7 @@ where
 /// But if you need a bit more control over individual cells, you can explicity create [`Cell`]s:
 /// ```rust
 /// # use helix_tui::widgets::{Row, Cell};
-/// # use helix_tui::style::{Style, Color};
+/// # use helix_view::graphics::{Style, Color};
 /// Row::new(vec![
 ///     Cell::from("Cell1"),
 ///     Cell::from("Cell2").style(Style::default().fg(Color::Yellow)),
@@ -84,7 +81,7 @@ where
 /// By default, a row has a height of 1 but you can change this using [`Row::height`].
 #[derive(Debug, Clone, PartialEq, Default)]
 pub struct Row<'a> {
-    cells: Vec<Cell<'a>>,
+    pub cells: Vec<Cell<'a>>,
     height: u16,
     style: Style,
     bottom_margin: u16,
@@ -137,7 +134,7 @@ impl<'a> Row<'a> {
 /// ```rust
 /// # use helix_tui::widgets::{Block, Borders, Table, Row, Cell};
 /// # use helix_tui::layout::Constraint;
-/// # use helix_tui::style::{Style, Color, Modifier};
+/// # use helix_view::graphics::{Style, Color, Modifier};
 /// # use helix_tui::text::{Text, Spans, Span};
 /// Table::new(vec![
 ///     // Row can be created from simple strings.
@@ -368,8 +365,8 @@ impl<'a> Table<'a> {
 
 #[derive(Debug, Clone)]
 pub struct TableState {
-    offset: usize,
-    selected: Option<usize>,
+    pub offset: usize,
+    pub selected: Option<usize>,
 }
 
 impl Default for TableState {
@@ -394,10 +391,11 @@ impl TableState {
     }
 }
 
-impl<'a> StatefulWidget for Table<'a> {
-    type State = TableState;
+// impl<'a> StatefulWidget for Table<'a> {
+impl<'a> Table<'a> {
+    // type State = TableState;
 
-    fn render(mut self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
+    pub fn render_table(mut self, area: Rect, buf: &mut Buffer, state: &mut TableState) {
         if area.area() == 0 {
             return;
         }
@@ -414,9 +412,7 @@ impl<'a> StatefulWidget for Table<'a> {
         let has_selection = state.selected.is_some();
         let columns_widths = self.get_columns_widths(table_area.width, has_selection);
         let highlight_symbol = self.highlight_symbol.unwrap_or("");
-        let blank_symbol = iter::repeat(" ")
-            .take(highlight_symbol.width())
-            .collect::<String>();
+        let blank_symbol = " ".repeat(highlight_symbol.width());
         let mut current_height = 0;
         let mut rows_height = table_area.height;
 
@@ -522,7 +518,7 @@ fn render_cell(buf: &mut Buffer, cell: &Cell, area: Rect) {
 impl<'a> Widget for Table<'a> {
     fn render(self, area: Rect, buf: &mut Buffer) {
         let mut state = TableState::default();
-        StatefulWidget::render(self, area, buf, &mut state);
+        Table::render_table(self, area, buf, &mut state);
     }
 }