diff --git a/.envrc b/.envrc
index 00cc6f20e..8643617f0 100644
--- a/.envrc
+++ b/.envrc
@@ -3,3 +3,4 @@ watch_file flake.lock
# try to use flakes, if it fails use normal nix (ie. shell.nix)
use flake || use nix
+eval "$shellHook"
\ No newline at end of file
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
deleted file mode 100644
index 41b00230f..000000000
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: C-bug
-assignees: ''
-
----
-
-
-
-### Reproduction steps
-
-
-
-### Environment
-
-- Platform:
-- Terminal emulator:
-- Helix version:
-
-~/.cache/helix/helix.log
-
-```
-please provide a copy of `~/.cache/helix/helix.log` here if possible, you may need to redact some of the lines
-```
-
-~/.cache/helix/helix.log
+
+ ```
+ please provide a copy of `~/.cache/helix/helix.log` here if possible, you may need to redact some of the lines
+ ```
+
+
Windows: `["cmd", "/C"]` |
| `line-number` | Line number display: `absolute` simply shows each line's number, while `relative` shows the distance from the current line. When unfocused or in insert mode, `relative` will still show absolute line numbers. | `absolute` |
-| `smart-case` | Enable smart case regex searching (case insensitive unless pattern contains upper case characters) | `true` |
-| `auto-pairs` | Enable automatic insertion of pairs to parenthese, brackets, etc. | `true` |
| `auto-completion` | Enable automatic pop up of auto-completion. | `true` |
| `idle-timeout` | Time in milliseconds since last keypress before idle timers trigger. Used for autocompletion, set to 0 for instant. | `400` |
| `completion-trigger-len` | The min-length of word under cursor to trigger autocompletion | `2` |
| `auto-info` | Whether to display infoboxes | `true` |
| `true-color` | Set to `true` to override automatic detection of terminal truecolor support in the event of a false negative. | `false` |
+### `[editor.lsp]` Section
+
+| Key | Description | Default |
+| --- | ----------- | ------- |
+| `display-messages` | Display LSP progress messages below statusline[^1] | `false` |
+
+[^1]: A progress spinner is always shown in the statusline beside the file path.
+
### `[editor.cursor-shape]` Section
Defines the shape of cursor in each mode. Note that due to limitations
@@ -76,10 +84,53 @@ available, which is not defined by default.
|`git-exclude` | Enables reading `.git/info/exclude` files. | true
|`max-depth` | Set with an integer value for maximum depth to recurse. | Defaults to `None`.
-## LSP
+### `[editor.auto-pairs]` Section
+
+Enable automatic insertion of pairs to parentheses, brackets, etc. Can be
+a simple boolean value, or a specific mapping of pairs of single characters.
+
+| Key | Description |
+| --- | ----------- |
+| `false` | Completely disable auto pairing, regardless of language-specific settings
+| `true` | Use the default pairs: (){}[]''""``
+| Mapping of pairs | e.g. `{ "(" = ")", "{" = "}", ... }`
+
+Example
-To display all language server messages in the status line add the following to your `config.toml`:
```toml
-[lsp]
-display-messages = true
+[editor.auto-pairs]
+'(' = ')'
+'{' = '}'
+'[' = ']'
+'"' = '"'
+'`' = '`'
+'<' = '>'
```
+
+Additionally, this setting can be used in a language config. Unless
+the editor setting is `false`, this will override the editor config in
+documents with this language.
+
+Example `languages.toml` that adds <> and removes ''
+
+```toml
+[[language]]
+name = "rust"
+
+[language.auto-pairs]
+'(' = ')'
+'{' = '}'
+'[' = ']'
+'"' = '"'
+'`' = '`'
+'<' = '>'
+```
+
+### `[editor.search]` Section
+
+Search specific options.
+
+| Key | Description | Default |
+|--|--|---------|
+| `smart-case` | Enable smart case regex searching (case insensitive unless pattern contains upper case characters) | `true` |
+| `wrap-around`| Whether the search should wrap after depleting the matches | `true` |
diff --git a/book/src/generated/lang-support.md b/book/src/generated/lang-support.md
index 894050731..34e65e46c 100644
--- a/book/src/generated/lang-support.md
+++ b/book/src/generated/lang-support.md
@@ -2,7 +2,7 @@
| --- | --- | --- | --- | --- |
| bash | ✓ | | | `bash-language-server` |
| c | ✓ | ✓ | ✓ | `clangd` |
-| c-sharp | ✓ | | | |
+| c-sharp | ✓ | | | `OmniSharp` |
| cmake | ✓ | ✓ | ✓ | `cmake-language-server` |
| comment | ✓ | | | |
| cpp | ✓ | ✓ | ✓ | `clangd` |
@@ -11,22 +11,25 @@
| dockerfile | ✓ | | | `docker-langserver` |
| elixir | ✓ | | | `elixir-ls` |
| elm | ✓ | | | `elm-language-server` |
-| erlang | ✓ | | | |
+| erlang | ✓ | | | `erlang_ls` |
| fish | ✓ | ✓ | ✓ | |
| git-commit | ✓ | | | |
| git-config | ✓ | | | |
| git-diff | ✓ | | | |
| git-rebase | ✓ | | | |
+| gleam | ✓ | | | |
| glsl | ✓ | | ✓ | |
| go | ✓ | ✓ | ✓ | `gopls` |
| graphql | ✓ | | | |
| haskell | ✓ | | | `haskell-language-server-wrapper` |
+| hcl | ✓ | | ✓ | `terraform-ls` |
| html | ✓ | | | |
| iex | ✓ | | | |
| java | ✓ | | | |
| javascript | ✓ | | ✓ | `typescript-language-server` |
| json | ✓ | | ✓ | |
| julia | ✓ | | | `julia` |
+| kotlin | ✓ | | | `kotlin-language-server` |
| latex | ✓ | | | |
| lean | ✓ | | | `lean` |
| ledger | ✓ | | | |
@@ -40,6 +43,7 @@
| nix | ✓ | | ✓ | `rnix-lsp` |
| ocaml | ✓ | | ✓ | |
| ocaml-interface | ✓ | | | |
+| org | ✓ | | | |
| perl | ✓ | ✓ | ✓ | |
| php | ✓ | ✓ | ✓ | |
| prolog | | | | `swipl` |
@@ -51,6 +55,7 @@
| ruby | ✓ | | ✓ | `solargraph` |
| rust | ✓ | ✓ | ✓ | `rust-analyzer` |
| scala | ✓ | | ✓ | `metals` |
+| solidity | ✓ | | | `solc` |
| svelte | ✓ | | ✓ | `svelteserver` |
| tablegen | ✓ | ✓ | ✓ | |
| toml | ✓ | | | |
diff --git a/book/src/generated/typable-cmd.md b/book/src/generated/typable-cmd.md
index 04e5fae31..1404c168b 100644
--- a/book/src/generated/typable-cmd.md
+++ b/book/src/generated/typable-cmd.md
@@ -5,6 +5,10 @@
| `:open`, `:o` | Open a file from disk into the current view. |
| `:buffer-close`, `:bc`, `:bclose` | Close the current buffer. |
| `:buffer-close!`, `:bc!`, `:bclose!` | Close the current buffer forcefully (ignoring unsaved changes). |
+| `:buffer-close-others`, `:bco`, `:bcloseother` | Close all buffers but the currently focused one. |
+| `:buffer-close-others!`, `:bco!`, `:bcloseother!` | Close all buffers but the currently focused one. |
+| `:buffer-close-all`, `:bca`, `:bcloseall` | Close all buffers, without quiting. |
+| `:buffer-close-all!`, `:bca!`, `:bcloseall!` | Close all buffers forcefully (ignoring unsaved changes), without quiting. |
| `:write`, `:w` | Write changes to disk. Accepts an optional path (:write some/path.txt) |
| `:new`, `:n` | Create a new scratch buffer. |
| `:format`, `:fmt` | Format the file using the LSP formatter. |
@@ -42,11 +46,15 @@
| `:debug-remote`, `:dbg-tcp` | Connect to a debug adapter by TCP address and start a debugging session from a given template with given parameters. |
| `:debug-eval` | Evaluate expression in current debug context. |
| `:vsplit`, `:vs` | Open the file in a vertical split. |
+| `:vsplit-new`, `:vnew` | Open a scratch buffer in a vertical split. |
| `:hsplit`, `:hs`, `:sp` | Open the file in a horizontal split. |
+| `:hsplit-new`, `:hnew` | Open a scratch buffer in a horizontal split. |
| `:tutor` | Open the tutorial. |
| `:goto`, `:g` | Go to line number. |
| `:set-option`, `:set` | Set a config option at runtime |
| `:sort` | Sort ranges in selection. |
| `:rsort` | Sort ranges in selection in reverse order. |
| `:tree-sitter-subtree`, `:ts-subtree` | Display tree sitter subtree under cursor, primarily for debugging queries. |
+| `:config-reload` | Refreshes helix's config. |
+| `:config-open` | Open the helix config.toml file. |
| `:help`, `:h` | Open documentation for a command or keybind. |
diff --git a/book/src/guides/adding_languages.md b/book/src/guides/adding_languages.md
index 5844a48ee..e5fa456c6 100644
--- a/book/src/guides/adding_languages.md
+++ b/book/src/guides/adding_languages.md
@@ -1,45 +1,68 @@
# Adding languages
-## Submodules
+## Language configuration
-To add a new language, you should first add a tree-sitter submodule. To do this,
-you can run the command
-```sh
-git submodule add -f helix-syntax/languages/tree-sitter-
-```
-For example, to add tree-sitter-ocaml you would run
-```sh
-git submodule add -f https://github.com/tree-sitter/tree-sitter-ocaml helix-syntax/languages/tree-sitter-ocaml
+To add a new language, you need to add a `language` entry to the
+[`languages.toml`][languages.toml] found in the root of the repository;
+this `languages.toml` file is included at compilation time, and is
+distinct from the `languages.toml` file in the user's [configuration
+directory](../configuration.md).
+
+```toml
+[[language]]
+name = "mylang"
+scope = "scope.mylang"
+injection-regex = "^mylang$"
+file-types = ["mylang", "myl"]
+comment-token = "#"
+indent = { tab-width = 2, unit = " " }
```
-Make sure the submodule is shallow by doing
-```sh
-git config -f .gitmodules submodule.helix-syntax/languages/tree-sitter-.shallow true
+
+These are the available keys and descriptions for the file.
+
+| Key | Description |
+| ---- | ----------- |
+| `name` | The name of the language |
+| `scope` | A string like `source.js` that identifies the language. Currently, we strive to match the scope names used by popular TextMate grammars and by the Linguist library. Usually `source.` or `text.` in case of markup languages |
+| `injection-regex` | regex pattern that will be tested against a language name in order to determine whether this language should be used for a potential [language injection][treesitter-language-injection] site. |
+| `file-types` | The filetypes of the language, for example `["yml", "yaml"]`. Extensions and full file names are supported. |
+| `shebangs` | The interpreters from the shebang line, for example `["sh", "bash"]` |
+| `roots` | A set of marker files to look for when trying to find the workspace root. For example `Cargo.lock`, `yarn.lock` |
+| `auto-format` | Whether to autoformat this language when saving |
+| `diagnostic-severity` | Minimal severity of diagnostic for it to be displayed. (Allowed values: `Error`, `Warning`, `Info`, `Hint`) |
+| `comment-token` | The token to use as a comment-token |
+| `indent` | The indent to use. Has sub keys `tab-width` and `unit` |
+| `config` | Language server configuration |
+| `grammar` | The tree-sitter grammar to use (defaults to the value of `name`) |
+
+## Grammar configuration
+
+If a tree-sitter grammar is available for the language, add a new `grammar`
+entry to `languages.toml`.
+
+```toml
+[[grammar]]
+name = "mylang"
+source = { git = "https://github.com/example/mylang", rev = "a250c4582510ff34767ec3b7dcdd3c24e8c8aa68" }
```
-or you can manually add `shallow = true` to `.gitmodules`.
+Grammar configuration takes these keys:
-## languages.toml
+| Key | Description |
+| --- | ----------- |
+| `name` | The name of the tree-sitter grammar |
+| `source` | The method of fetching the grammar - a table with a schema defined below |
-Next, you need to add the language to the [`languages.toml`][languages.toml] found in the root of
-the repository; this `languages.toml` file is included at compilation time, and
-is distinct from the `language.toml` file in the user's [configuration
-directory](../configuration.md).
+Where `source` is a table with either these keys when using a grammar from a
+git repository:
-These are the available keys and descriptions for the file.
+| Key | Description |
+| --- | ----------- |
+| `git` | A git remote URL from which the grammar should be cloned |
+| `rev` | The revision (commit hash or tag) which should be fetched |
+| `subpath` | A path within the grammar directory which should be built. Some grammar repositories host multiple grammars (for example `tree-sitter-typescript` and `tree-sitter-ocaml`) in subdirectories. This key is used to point `hx --grammar build` to the correct path for compilation. When omitted, the root of repository is used |
-| Key | Description |
-| ---- | ----------- |
-| name | The name of the language |
-| scope | A string like `source.js` that identifies the language. Currently, we strive to match the scope names used by popular TextMate grammars and by the Linguist library. Usually `source.` or `text.` in case of markup languages |
-| injection-regex | regex pattern that will be tested against a language name in order to determine whether this language should be used for a potential [language injection][treesitter-language-injection] site. |
-| file-types | The filetypes of the language, for example `["yml", "yaml"]` |
-| shebangs | The interpreters from the shebang line, for example `["sh", "bash"]` |
-| roots | A set of marker files to look for when trying to find the workspace root. For example `Cargo.lock`, `yarn.lock` |
-| auto-format | Whether to autoformat this language when saving |
-| diagnostic-severity | Minimal severity of diagnostic for it to be displayed. (Allowed values: `Error`, `Warning`, `Info`, `Hint`) |
-| comment-token | The token to use as a comment-token |
-| indent | The indent to use. Has sub keys `tab-width` and `unit` |
-| config | Language server configuration |
+Or a `path` key with an absolute path to a locally available grammar directory.
## Queries
@@ -51,18 +74,14 @@ gives more info on how to write queries.
> NOTE: When evaluating queries, the first matching query takes
precedence, which is different from other editors like neovim where
-the last matching query supercedes the ones before it. See
+the last matching query supersedes the ones before it. See
[this issue][neovim-query-precedence] for an example.
## Common Issues
-- If you get errors when building after switching branches, you may have to remove or update tree-sitter submodules. You can update submodules by running
- ```sh
- git submodule sync; git submodule update --init
- ```
-- Make sure to not use the `--remote` flag. To remove submodules look inside the `.gitmodules` and remove directories that are not present inside of it.
+- If you get errors when running after switching branches, you may have to update the tree-sitter grammars. Run `hx --grammar fetch` to fetch the grammars and `hx --grammar build` to build any out-of-date grammars.
-- If a parser is segfaulting or you want to remove the parser, make sure to remove the submodule *and* the compiled parser in `runtime/grammar/.so`
+- If a parser is segfaulting or you want to remove the parser, make sure to remove the compiled parser in `runtime/grammar/.so`
- The indents query is `indents.toml`, *not* `indents.scm`. See [this](https://github.com/helix-editor/helix/issues/114) issue for more information.
diff --git a/book/src/guides/indent.md b/book/src/guides/indent.md
new file mode 100644
index 000000000..235a30c44
--- /dev/null
+++ b/book/src/guides/indent.md
@@ -0,0 +1,79 @@
+# Adding Indent Queries
+
+Helix uses tree-sitter to correctly indent new lines. This requires
+a tree-sitter grammar and an `indent.scm` query file placed in
+`runtime/queries/{language}/indents.scm`. The indentation for a line
+is calculated by traversing the syntax tree from the lowest node at the
+beginning of the new line. Each of these nodes contributes to the total
+indent when it is captured by the query (in what way depends on the name
+of the capture).
+
+Note that it matters where these added indents begin. For example,
+multiple indent level increases that start on the same line only increase
+the total indent level by 1.
+
+## Scopes
+
+Added indents don't always apply to the whole node. For example, in most
+cases when a node should be indented, we actually only want everything
+except for its first line to be indented. For this, there are several
+scopes (more scopes may be added in the future if required):
+
+- `all`:
+This scope applies to the whole captured node. This is only different from
+`tail` when the captured node is the first node on its line.
+
+- `tail`:
+This scope applies to everything except for the first line of the
+captured node.
+
+Every capture type has a default scope which should do the right thing
+in most situations. When a different scope is required, this can be
+changed by using a `#set!` declaration anywhere in the pattern:
+```scm
+(assignment_expression
+ right: (_) @indent
+ (#set! "scope" "all"))
+```
+
+## Capture Types
+
+- `@indent` (default scope `tail`):
+Increase the indent level by 1. Multiple occurences in the same line
+don't stack. If there is at least one `@indent` and one `@outdent`
+capture on the same line, the indent level isn't changed at all.
+
+- `@outdent` (default scope `all`):
+Decrease the indent level by 1. The same rules as for `@indent` apply.
+
+## Predicates
+
+In some cases, an S-expression cannot express exactly what pattern should be matched.
+For that, tree-sitter allows for predicates to appear anywhere within a pattern,
+similar to how `#set!` declarations work:
+```scm
+(some_kind
+ (child_kind) @indent
+ (#predicate? arg1 arg2 ...)
+)
+```
+The number of arguments depends on the predicate that's used.
+Each argument is either a capture (`@name`) or a string (`"some string"`).
+The following predicates are supported by tree-sitter:
+
+- `#eq?`/`#not-eq?`:
+The first argument (a capture) must/must not be equal to the second argument
+(a capture or a string).
+
+- `#match?`/`#not-match?`:
+The first argument (a capture) must/must not match the regex given in the
+second argument (a string).
+
+Additionally, we support some custom predicates for indent queries:
+
+- `#not-kind-eq?`:
+The kind of the first argument (a capture) must not be equal to the second
+argument (a string).
+
+- `#same-line?`/`#not-same-line?`:
+The captures given by the 2 arguments must/must not start on the same line.
diff --git a/book/src/guides/textobject.md b/book/src/guides/textobject.md
index 7200a5144..cccd4bbf0 100644
--- a/book/src/guides/textobject.md
+++ b/book/src/guides/textobject.md
@@ -21,6 +21,8 @@ The following [captures][tree-sitter-captures] are recognized:
| `class.inside` |
| `class.around` |
| `parameter.inside` |
+| `comment.inside` |
+| `comment.around` |
[Example query files][textobject-examples] can be found in the helix GitHub repository.
diff --git a/book/src/install.md b/book/src/install.md
index 1a5a9daa9..b3d42aaf4 100644
--- a/book/src/install.md
+++ b/book/src/install.md
@@ -19,7 +19,12 @@ brew install helix
A [flake](https://nixos.wiki/wiki/Flakes) containing the package is available in
the project root. The flake can also be used to spin up a reproducible development
-shell for working on Helix.
+shell for working on Helix with `nix develop`.
+
+Flake outputs are cached for each push to master using
+[Cachix](https://www.cachix.org/). With Cachix
+[installed](https://docs.cachix.org/installation), `cachix use helix` will
+configure Nix to use cached outputs when possible.
### Arch Linux
@@ -39,7 +44,7 @@ sudo dnf install helix
## Build from source
```
-git clone --recurse-submodules --shallow-submodules -j8 https://github.com/helix-editor/helix
+git clone https://github.com/helix-editor/helix
cd helix
cargo install --path helix-term
```
@@ -49,3 +54,9 @@ This will install the `hx` binary to `$HOME/.cargo/bin`.
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.
+
+## Building tree-sitter grammars
+
+Tree-sitter grammars must be fetched and compiled if not pre-packaged.
+Fetch grammars with `hx --grammar fetch` (requires `git`) and compile them
+with `hx --grammar build` (requires a C compiler).
diff --git a/book/src/keymap.md b/book/src/keymap.md
index 5de4edf93..374513be0 100644
--- a/book/src/keymap.md
+++ b/book/src/keymap.md
@@ -9,42 +9,33 @@
> NOTE: Unlike vim, `f`, `F`, `t` and `T` are not confined to the current line.
-| Key | Description | Command |
-| ----- | ----------- | ------- |
-| `h`/`Left` | Move left | `move_char_left` |
-| `j`/`Down` | Move down | `move_line_down` |
-| `k`/`Up` | Move up | `move_line_up` |
-| `l`/`Right` | Move right | `move_char_right` |
-| `w` | Move next word start | `move_next_word_start` |
-| `b` | Move previous word start | `move_prev_word_start` |
-| `e` | Move next word end | `move_next_word_end` |
-| `W` | Move next WORD start | `move_next_long_word_start` |
-| `B` | Move previous WORD start | `move_prev_long_word_start` |
-| `E` | Move next WORD end | `move_next_long_word_end` |
-| `t` | Find 'till next char | `find_till_char` |
-| `f` | Find next char | `find_next_char` |
-| `T` | Find 'till previous char | `till_prev_char` |
-| `F` | Find previous char | `find_prev_char` |
-| `G` | Go to line number `` | `goto_line` |
-| `Alt-.` | Repeat last motion (`f`, `t` or `m`) | `repeat_last_motion` |
-| `Alt-:` | Ensures the selection is in forward direction | `ensure_selections_forward` |
-| `Home` | Move to the start of the line | `goto_line_start` |
-| `End` | Move to the end of the line | `goto_line_end` |
-| `PageUp` | Move page up | `page_up` |
-| `PageDown` | Move page down | `page_down` |
-| `Ctrl-u` | Move half page up | `half_page_up` |
-| `Ctrl-d` | Move half page down | `half_page_down` |
-| `Ctrl-i` | Jump forward on the jumplist | `jump_forward` |
-| `Ctrl-o` | Jump backward on the jumplist | `jump_backward` |
-| `Ctrl-s` | Save the current selection to the jumplist | `save_selection` |
-| `v` | Enter [select (extend) mode](#select--extend-mode) | `select_mode` |
-| `g` | Enter [goto mode](#goto-mode) | N/A |
-| `m` | Enter [match mode](#match-mode) | N/A |
-| `:` | Enter command mode | `command_mode` |
-| `z` | Enter [view mode](#view-mode) | N/A |
-| `Z` | Enter sticky [view mode](#view-mode) | N/A |
-| `Ctrl-w` | Enter [window mode](#window-mode) | N/A |
-| `Space` | Enter [space mode](#space-mode) | N/A |
+| Key | Description | Command |
+| ----- | ----------- | ------- |
+| `h`, `Left` | Move left | `move_char_left` |
+| `j`, `Down` | Move down | `move_line_down` |
+| `k`, `Up` | Move up | `move_line_up` |
+| `l`, `Right` | Move right | `move_char_right` |
+| `w` | Move next word start | `move_next_word_start` |
+| `b` | Move previous word start | `move_prev_word_start` |
+| `e` | Move next word end | `move_next_word_end` |
+| `W` | Move next WORD start | `move_next_long_word_start` |
+| `B` | Move previous WORD start | `move_prev_long_word_start` |
+| `E` | Move next WORD end | `move_next_long_word_end` |
+| `t` | Find 'till next char | `find_till_char` |
+| `f` | Find next char | `find_next_char` |
+| `T` | Find 'till previous char | `till_prev_char` |
+| `F` | Find previous char | `find_prev_char` |
+| `G` | Go to line number `` | `goto_line` |
+| `Alt-.` | Repeat last motion (`f`, `t` or `m`) | `repeat_last_motion` |
+| `Home` | Move to the start of the line | `goto_line_start` |
+| `End` | Move to the end of the line | `goto_line_end` |
+| `Ctrl-b`, `PageUp` | Move page up | `page_up` |
+| `Ctrl-f`, `PageDown` | Move page down | `page_down` |
+| `Ctrl-u` | Move half page up | `half_page_up` |
+| `Ctrl-d` | Move half page down | `half_page_down` |
+| `Ctrl-i` | Jump forward on the jumplist | `jump_forward` |
+| `Ctrl-o` | Jump backward on the jumplist | `jump_backward` |
+| `Ctrl-s` | Save the current selection to the jumplist | `save_selection` |
### Changes
@@ -84,48 +75,50 @@
#### Shell
-| Key | Description | Command |
-| ------ | ----------- | ------- |
-| | | Pipe each selection through shell command, replacing with output | `shell_pipe` |
-| Alt-| | Pipe each selection into shell command, ignoring output | `shell_pipe_to` |
-| `!` | Run shell command, inserting output before each selection | `shell_insert_output` |
-| `Alt-!` | Run shell command, appending output after each selection | `shell_append_output` |
+| Key | Description | Command |
+| ------ | ----------- | ------- |
+| | | Pipe each selection through shell command, replacing with output | `shell_pipe` |
+| Alt-| | Pipe each selection into shell command, ignoring output | `shell_pipe_to` |
+| `!` | Run shell command, inserting output before each selection | `shell_insert_output` |
+| `Alt-!` | Run shell command, appending output after each selection | `shell_append_output` |
| `$` | Pipe each selection into shell command, keep selections where command returned 0 | `shell_keep_pipe` |
### Selection manipulation
-| Key | Description | Command |
-| ----- | ----------- | ------- |
-| `s` | Select all regex matches inside selections | `select_regex` |
-| `S` | Split selection into subselections on regex matches | `split_selection` |
-| `Alt-s` | Split selection on newlines | `split_selection_on_newline` |
-| `&` | Align selection in columns | `align_selections` |
-| `_` | Trim whitespace from the selection | `trim_selections` |
-| `;` | Collapse selection onto a single cursor | `collapse_selection` |
-| `Alt-;` | Flip selection cursor and anchor | `flip_selections` |
-| `,` | Keep only the primary selection | `keep_primary_selection` |
-| `Alt-,` | Remove the primary selection | `remove_primary_selection` |
-| `C` | Copy selection onto the next line (Add cursor below) | `copy_selection_on_next_line` |
-| `Alt-C` | Copy selection onto the previous line (Add cursor above) | `copy_selection_on_prev_line` |
-| `(` | Rotate main selection backward | `rotate_selections_backward` |
-| `)` | Rotate main selection forward | `rotate_selections_forward` |
-| `Alt-(` | Rotate selection contents backward | `rotate_selection_contents_backward` |
-| `Alt-)` | Rotate selection contents forward | `rotate_selection_contents_forward` |
-| `%` | Select entire file | `select_all` |
-| `x` | Select current line, if already selected, extend to next line | `extend_line` |
-| `X` | Extend selection to line bounds (line-wise selection) | `extend_to_line_bounds` |
-| `J` | Join lines inside selection | `join_selections` |
-| `K` | Keep selections matching the regex | `keep_selections` |
-| `Alt-K` | Remove selections matching the regex | `remove_selections` |
-| `Ctrl-c` | Comment/uncomment the selections | `toggle_comments` |
-| `Alt-k` | Expand selection to parent syntax node (**TS**) | `expand_selection` |
-| `Alt-j` | Shrink syntax tree object selection (**TS**) | `shrink_selection` |
-| `Alt-h` | Select previous sibling node in syntax tree (**TS**) | `select_prev_sibling` |
-| `Alt-l` | Select next sibling node in syntax tree (**TS**) | `select_next_sibling` |
+| Key | Description | Command |
+| ----- | ----------- | ------- |
+| `s` | Select all regex matches inside selections | `select_regex` |
+| `S` | Split selection into subselections on regex matches | `split_selection` |
+| `Alt-s` | Split selection on newlines | `split_selection_on_newline` |
+| `&` | Align selection in columns | `align_selections` |
+| `_` | Trim whitespace from the selection | `trim_selections` |
+| `;` | Collapse selection onto a single cursor | `collapse_selection` |
+| `Alt-;` | Flip selection cursor and anchor | `flip_selections` |
+| `Alt-:` | Ensures the selection is in forward direction | `ensure_selections_forward` |
+| `,` | Keep only the primary selection | `keep_primary_selection` |
+| `Alt-,` | Remove the primary selection | `remove_primary_selection` |
+| `C` | Copy selection onto the next line (Add cursor below) | `copy_selection_on_next_line` |
+| `Alt-C` | Copy selection onto the previous line (Add cursor above) | `copy_selection_on_prev_line` |
+| `(` | Rotate main selection backward | `rotate_selections_backward` |
+| `)` | Rotate main selection forward | `rotate_selections_forward` |
+| `Alt-(` | Rotate selection contents backward | `rotate_selection_contents_backward` |
+| `Alt-)` | Rotate selection contents forward | `rotate_selection_contents_forward` |
+| `%` | Select entire file | `select_all` |
+| `x` | Select current line, if already selected, extend to next line | `extend_line` |
+| `X` | Extend selection to line bounds (line-wise selection) | `extend_to_line_bounds` |
+| `J` | Join lines inside selection | `join_selections` |
+| `K` | Keep selections matching the regex | `keep_selections` |
+| `Alt-K` | Remove selections matching the regex | `remove_selections` |
+| `Ctrl-c` | Comment/uncomment the selections | `toggle_comments` |
+| `Alt-k`, `Alt-up` | Expand selection to parent syntax node (**TS**) | `expand_selection` |
+| `Alt-j`, `Alt-down` | Shrink syntax tree object selection (**TS**) | `shrink_selection` |
+| `Alt-h`, `Alt-left` | Select previous sibling node in syntax tree (**TS**) | `select_prev_sibling` |
+| `Alt-l`, `Alt-right` | Select next sibling node in syntax tree (**TS**) | `select_next_sibling` |
### Search
+Search commands all operate on the `/` register by default. Use `"` to operate on a different one.
| Key | Description | Command |
| ----- | ----------- | ------- |
@@ -139,6 +132,17 @@
These sub-modes are accessible from normal mode and typically switch back to normal mode after a command.
+| Key | Description | Command |
+| ----- | ----------- | ------- |
+| `v` | Enter [select (extend) mode](#select--extend-mode) | `select_mode` |
+| `g` | Enter [goto mode](#goto-mode) | N/A |
+| `m` | Enter [match mode](#match-mode) | N/A |
+| `:` | Enter command mode | `command_mode` |
+| `z` | Enter [view mode](#view-mode) | N/A |
+| `Z` | Enter sticky [view mode](#view-mode) | N/A |
+| `Ctrl-w` | Enter [window mode](#window-mode) | N/A |
+| `Space` | Enter [space mode](#space-mode) | N/A |
+
#### View mode
View mode is intended for scrolling and manipulating the view without changing
@@ -147,18 +151,18 @@ key to return to normal mode after usage (useful when you're simply looking
over text and not actively editing it).
-| Key | Description | Command |
-| ----- | ----------- | ------- |
-| `z` , `c` | Vertically center the line | `align_view_center` |
-| `t` | Align the line to the top of the screen | `align_view_top` |
-| `b` | Align the line to the bottom of the screen | `align_view_bottom` |
-| `m` | Align the line to the middle of the screen (horizontally) | `align_view_middle` |
-| `j` , `down` | Scroll the view downwards | `scroll_down` |
-| `k` , `up` | Scroll the view upwards | `scroll_up` |
-| `Ctrl-f` | Move page down | `page_down` |
-| `Ctrl-b` | Move page up | `page_up` |
-| `Ctrl-d` | Move half page down | `half_page_down` |
-| `Ctrl-u` | Move half page up | `half_page_up` |
+| Key | Description | Command |
+| ----- | ----------- | ------- |
+| `z`, `c` | Vertically center the line | `align_view_center` |
+| `t` | Align the line to the top of the screen | `align_view_top` |
+| `b` | Align the line to the bottom of the screen | `align_view_bottom` |
+| `m` | Align the line to the middle of the screen (horizontally) | `align_view_middle` |
+| `j`, `down` | Scroll the view downwards | `scroll_down` |
+| `k`, `up` | Scroll the view upwards | `scroll_up` |
+| `Ctrl-f`, `PageDown` | Move page down | `page_down` |
+| `Ctrl-b`, `PageUp` | Move page up | `page_up` |
+| `Ctrl-d` | Move half page down | `half_page_down` |
+| `Ctrl-u` | Move half page up | `half_page_up` |
#### Goto mode
@@ -206,19 +210,19 @@ TODO: Mappings for selecting syntax nodes (a superset of `[`).
This layer is similar to vim keybindings as kakoune does not support window.
-| Key | Description | Command |
-| ----- | ------------- | ------- |
-| `w`, `Ctrl-w` | Switch to next window | `rotate_view` |
-| `v`, `Ctrl-v` | Vertical right split | `vsplit` |
-| `s`, `Ctrl-s` | Horizontal bottom split | `hsplit` |
-| `h`, `Ctrl-h`, `left` | Move to left split | `jump_view_left` |
-| `f` | Go to files in the selection in horizontal splits | `goto_file` |
-| `F` | Go to files in the selection in vertical splits | `goto_file` |
-| `j`, `Ctrl-j`, `down` | Move to split below | `jump_view_down` |
-| `k`, `Ctrl-k`, `up` | Move to split above | `jump_view_up` |
-| `l`, `Ctrl-l`, `right` | Move to right split | `jump_view_right` |
-| `q`, `Ctrl-q` | Close current window | `wclose` |
-| `o`, `Ctrl-o` | Only keep the current window, closing all the others | `wonly` |
+| Key | Description | Command |
+| ----- | ------------- | ------- |
+| `w`, `Ctrl-w` | Switch to next window | `rotate_view` |
+| `v`, `Ctrl-v` | Vertical right split | `vsplit` |
+| `s`, `Ctrl-s` | Horizontal bottom split | `hsplit` |
+| `f` | Go to files in the selection in horizontal splits | `goto_file` |
+| `F` | Go to files in the selection in vertical splits | `goto_file` |
+| `h`, `Ctrl-h`, `Left` | Move to left split | `jump_view_left` |
+| `j`, `Ctrl-j`, `Down` | Move to split below | `jump_view_down` |
+| `k`, `Ctrl-k`, `Up` | Move to split above | `jump_view_up` |
+| `l`, `Ctrl-l`, `Right` | Move to right split | `jump_view_right` |
+| `q`, `Ctrl-q` | Close current window | `wclose` |
+| `o`, `Ctrl-o` | Only keep the current window, closing all the others | `wonly` |
#### Space mode
@@ -242,6 +246,7 @@ This layer is a kludge of mappings, mostly pickers.
| `Y` | Yank main selection to clipboard | `yank_main_selection_to_clipboard` |
| `R` | Replace selections by clipboard contents | `replace_selections_with_clipboard` |
| `/` | Global search in workspace folder | `global_search` |
+| `?` | Open command palette | `command_palette` |
> TIP: Global search displays results in a fuzzy picker, use `space + '` to bring it back up after opening a file.
@@ -268,40 +273,57 @@ Mappings in the style of [vim-unimpaired](https://github.com/tpope/vim-unimpaire
| `[f` | Go to previous function (**TS**) | `goto_prev_function` |
| `]c` | Go to next class (**TS**) | `goto_next_class` |
| `[c` | Go to previous class (**TS**) | `goto_prev_class` |
-| `]p` | Go to next parameter (**TS**) | `goto_next_parameter` |
-| `[p` | Go to previous parameter (**TS**) | `goto_prev_parameter` |
+| `]a` | Go to next argument/parameter (**TS**) | `goto_next_parameter` |
+| `[a` | Go to previous argument/parameter (**TS**) | `goto_prev_parameter` |
+| `]o` | Go to next comment (**TS**) | `goto_next_comment` |
+| `[o` | Go to previous comment (**TS**) | `goto_prev_comment` |
| `[space` | Add newline above | `add_newline_above` |
| `]space` | Add newline below | `add_newline_below` |
## Insert Mode
-| Key | Description | Command |
-| ----- | ----------- | ------- |
-| `Escape` | Switch to normal mode | `normal_mode` |
-| `Ctrl-x` | Autocomplete | `completion` |
-| `Ctrl-r` | Insert a register content | `insert_register` |
-| `Ctrl-w` | Delete previous word | `delete_word_backward` |
-| `Alt-d` | Delete next word | `delete_word_forward` |
-| `Alt-b`, `Alt-Left` | Backward a word | `move_prev_word_end` |
-| `Ctrl-b`, `Left` | Backward a char | `move_char_left` |
-| `Alt-f`, `Alt-Right` | Forward a word | `move_next_word_start` |
-| `Ctrl-f`, `Right` | Forward a char | `move_char_right` |
-| `Ctrl-e`, `End` | move to line end | `goto_line_end_newline` |
-| `Ctrl-a`, `Home` | move to line start | `goto_line_start` |
-| `Ctrl-u` | delete to start of line | `kill_to_line_start` |
-| `Ctrl-k` | delete to end of line | `kill_to_line_end` |
-| `backspace`, `Ctrl-h` | delete previous char | `delete_char_backward` |
-| `delete`, `Ctrl-d` | delete previous char | `delete_char_forward` |
-| `Ctrl-p`, `Up` | move to previous line | `move_line_up` |
-| `Ctrl-n`, `Down` | move to next line | `move_line_down` |
+We support many readline/emacs style bindings in insert mode for
+convenience. These can be helpful for making simple modifications
+without escaping to normal mode, but beware that you will not have an
+undo-able "save point" until you return to normal mode.
+
+| Key | Description | Command |
+| ----- | ----------- | ------- |
+| `Escape` | Switch to normal mode | `normal_mode` |
+| `Ctrl-x` | Autocomplete | `completion` |
+| `Ctrl-r` | Insert a register content | `insert_register` |
+| `Ctrl-w`, `Alt-Backspace` | Delete previous word | `delete_word_backward` |
+| `Alt-d` | Delete next word | `delete_word_forward` |
+| `Alt-b`, `Alt-Left` | Backward a word | `move_prev_word_end` |
+| `Ctrl-b`, `Left` | Backward a char | `move_char_left` |
+| `Alt-f`, `Alt-Right` | Forward a word | `move_next_word_start` |
+| `Ctrl-f`, `Right` | Forward a char | `move_char_right` |
+| `Ctrl-e`, `End` | Move to line end | `goto_line_end_newline` |
+| `Ctrl-a`, `Home` | Move to line start | `goto_line_start` |
+| `Ctrl-u` | Delete to start of line | `kill_to_line_start` |
+| `Ctrl-k` | Delete to end of line | `kill_to_line_end` |
+| `Ctrl-j`, `Enter` | Insert new line | `insert_newline` |
+| `Backspace`, `Ctrl-h` | Delete previous char | `delete_char_backward` |
+| `Delete`, `Ctrl-d` | Delete previous char | `delete_char_forward` |
+| `Ctrl-p`, `Up` | Move to previous line | `move_line_up` |
+| `Ctrl-n`, `Down` | Move to next line | `move_line_down` |
+| `PageUp` | Move one page up | `page_up` |
+| `PageDown` | Move one page down | `page_down` |
+| `Alt->` | Go to end of buffer | `goto_file_end` |
+| `Alt-<` | Go to start of buffer | `goto_file_start` |
## Select / extend mode
-I'm still pondering whether to keep this mode or not. It changes movement
-commands (including goto) to extend the existing selection instead of replacing it.
+This mode echoes Normal mode, but changes any movements to extend
+selections rather than replace them. Goto motions are also changed to
+extend, so that `vgl` for example extends the selection to the end of
+the line.
-> NOTE: It's a bit confusing at the moment because extend hasn't been
-> implemented for all movement commands yet.
+Search is also affected. By default, `n` and `N` will remove the current
+selection and select the next instance of the search term. Toggling this
+mode before pressing `n` or `N` makes it possible to keep the current
+selection. Toggling it on and off during your iterative searching allows
+you to selectively add search terms to your selections.
# Picker
diff --git a/book/src/languages.md b/book/src/languages.md
index 4c4dc326d..3372a1202 100644
--- a/book/src/languages.md
+++ b/book/src/languages.md
@@ -4,10 +4,37 @@ Language-specific settings and settings for particular language servers can be c
Changes made to the `languages.toml` file in a user's [configuration directory](./configuration.md) are merged with helix's defaults on start-up, such that a user's settings will take precedence over defaults in the event of a collision. For example, the default `languages.toml` sets rust's `auto-format` to `true`. If a user wants to disable auto-format, they can change the `languages.toml` in their [configuration directory](./configuration.md) to make the rust entry read like the example below; the new key/value pair `auto-format = false` will override the default when the two sets of settings are merged on start-up:
-```
+```toml
# in /helix/languages.toml
[[language]]
name = "rust"
auto-format = false
```
+
+## Tree-sitter grammars
+
+Tree-sitter grammars can also be configured in `languages.toml`:
+
+```toml
+# in /helix/languages.toml
+
+[[grammar]]
+name = "rust"
+source = { git = "https://github.com/tree-sitter/tree-sitter-rust", rev = "a250c4582510ff34767ec3b7dcdd3c24e8c8aa68" }
+
+[[grammar]]
+name = "c"
+source = { path = "/path/to/tree-sitter-c" }
+```
+
+You may use a top-level `use-grammars` key to control which grammars are fetched and built.
+
+```toml
+# Note: this key must come **before** the [[language]] and [[grammar]] sections
+use-grammars = { only = [ "rust", "c", "cpp" ] }
+# or
+use-grammars = { except = [ "yaml", "json" ] }
+```
+
+When omitted, all grammars are fetched and built.
diff --git a/book/src/themes.md b/book/src/themes.md
index 9abcfe8c1..62265e28b 100644
--- a/book/src/themes.md
+++ b/book/src/themes.md
@@ -166,6 +166,8 @@ We use a similar set of scopes as
- `markup`
- `heading`
+ - `marker`
+ - `1`, `2`, `3`, `4`, `5`, `6` - heading text for h1 through h6
- `list`
- `unnumbered`
- `numbered`
@@ -216,12 +218,12 @@ These scopes are used for theming the editor interface.
| `ui.statusline` | Statusline |
| `ui.statusline.inactive` | Statusline (unfocused document) |
| `ui.popup` | |
+| `ui.popup.info` | |
| `ui.window` | |
| `ui.help` | |
| `ui.text` | |
| `ui.text.focus` | |
-| `ui.info` | |
-| `ui.info.text` | |
+| `ui.text.info` | |
| `ui.menu` | |
| `ui.menu.selected` | |
| `ui.selection` | For selections in the editing area |
diff --git a/book/src/title-page.md b/book/src/title-page.md
new file mode 100644
index 000000000..c182a753c
--- /dev/null
+++ b/book/src/title-page.md
@@ -0,0 +1,15 @@
+# Helix
+
+Docs for bleeding edge master can be found at
+[https://docs.helix-editor.com/master](https://docs.helix-editor.com/master).
+
+See the [usage] section for a quick overview of the editor, [keymap]
+section for all available keybindings and the [configuration] section
+for defining custom keybindings, setting themes, etc.
+
+Refer the [FAQ] for common questions.
+
+[FAQ]: https://github.com/helix-editor/helix/wiki/FAQ
+[usage]: ./usage.md
+[keymap]: ./keymap.md
+[configuration]: ./configuration.md
diff --git a/book/src/usage.md b/book/src/usage.md
index 039628bf8..010e30f59 100644
--- a/book/src/usage.md
+++ b/book/src/usage.md
@@ -68,7 +68,8 @@ Currently supported: `word`, `surround`, `function`, `class`, `parameter`.
| `(`, `[`, `'`, etc | Specified surround pairs |
| `f` | Function |
| `c` | Class |
-| `p` | Parameter |
+| `a` | Argument/parameter |
+| `o` | Comment |
> NOTE: `f`, `c`, etc need a tree-sitter grammar active for the current
document and a special tree-sitter query file to work properly. [Only
diff --git a/docs/architecture.md b/docs/architecture.md
index 17ef296dc..33624aac2 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -1,12 +1,13 @@
-| Crate | Description |
-| ----------- | ----------- |
-| helix-core | Core editing primitives, functional. |
-| helix-syntax | Tree-sitter grammars |
-| helix-lsp | Language server client |
-| helix-view | UI abstractions for use in backends, imperative shell. |
-| helix-term | Terminal UI |
-| helix-tui | TUI primitives, forked from tui-rs, inspired by Cursive |
+| Crate | Description |
+| ----------- | ----------- |
+| helix-core | Core editing primitives, functional. |
+| helix-lsp | Language server client |
+| helix-dap | Debug Adapter Protocol (DAP) client |
+| helix-loader | Functions for building, fetching, and loading external resources |
+| helix-view | UI abstractions for use in backends, imperative shell. |
+| helix-term | Terminal UI |
+| helix-tui | TUI primitives, forked from tui-rs, inspired by Cursive |
This document contains a high-level overview of Helix internals.
@@ -54,15 +55,40 @@ A `Document` ties together the `Rope`, `Selection`(s), `Syntax`, document
file.
A `View` represents an open split in the UI. It holds the currently open
-document ID and other related state.
+document ID and other related state. Views encapsulate the gutter, status line,
+diagnostics, and the inner area where the code is displayed.
> 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`.
+`Info` is the autoinfo box that shows hints when awaiting another key with bindings
+like `g` and `m`. It is attached to the viewport as a whole.
+
+`Surface` is like a buffer to which widgets draw themselves to, and the
+surface is then rendered on the screen on each cycle.
+
+`Rect`s are areas (simply an x and y coordinate with the origin at the
+screen top left and then a height and width) which are part of a
+`Surface`. They can be used to limit the area to which a `Component` can
+render. For example if we wrap a `Markdown` component in a `Popup`
+(think the documentation popup with space+k), Markdown's render method
+will get a Rect that is the exact size of the popup.
+
+Widgets are called `Component`s internally, and you can see most of them
+in `helix-term/src/ui`. Some components like `Popup` and `Overlay` can take
+other components as children.
+
+`Layer`s are how multiple components are displayed, and is simply a
+`Vec`. Layers are managed by the `Compositor`. On each top
+level render call, the compositor renders each component in the order
+they were pushed into the stack. This makes multiple components "layer"
+on top of one another. Hence we get a file picker displayed over the
+editor, etc.
+
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.
+representation of all the view splits, the configuration, and a registry of
+language servers. To open or close files, interact with the editor.
## LSP
diff --git a/flake.lock b/flake.lock
index 94e443e3a..40a87eb55 100644
--- a/flake.lock
+++ b/flake.lock
@@ -1,12 +1,35 @@
{
"nodes": {
+ "crane": {
+ "flake": false,
+ "locked": {
+ "lastModified": 1644785799,
+ "narHash": "sha256-VpAJO1L0XeBvtCuNGK4IDKp6ENHIpTrlaZT7yfBCvwo=",
+ "owner": "ipetkov",
+ "repo": "crane",
+ "rev": "fc7a94f841347c88f2cb44217b2a3faa93e2a0b2",
+ "type": "github"
+ },
+ "original": {
+ "owner": "ipetkov",
+ "repo": "crane",
+ "type": "github"
+ }
+ },
"devshell": {
+ "inputs": {
+ "flake-utils": "flake-utils",
+ "nixpkgs": [
+ "nixCargoIntegration",
+ "nixpkgs"
+ ]
+ },
"locked": {
- "lastModified": 1641980203,
- "narHash": "sha256-RiWJ3+6V267Ji+P54K1Xrj1Nsah9BfG/aLfIhqgVyBY=",
+ "lastModified": 1646667754,
+ "narHash": "sha256-LahZHvCC3UVzGQ55iWDRZkuDssXl1rYgqgScrPV9S38=",
"owner": "numtide",
"repo": "devshell",
- "rev": "d897c1ddb4eab66cc2b783c7868d78555b9880ad",
+ "rev": "59fbe1dfc0de8c3332957c16998a7d16dff365d8",
"type": "github"
},
"original": {
@@ -15,7 +38,73 @@
"type": "github"
}
},
+ "dream2nix": {
+ "inputs": {
+ "alejandra": [
+ "nixCargoIntegration",
+ "nixpkgs"
+ ],
+ "crane": "crane",
+ "flake-utils-pre-commit": [
+ "nixCargoIntegration",
+ "nixpkgs"
+ ],
+ "gomod2nix": [
+ "nixCargoIntegration",
+ "nixpkgs"
+ ],
+ "mach-nix": [
+ "nixCargoIntegration",
+ "nixpkgs"
+ ],
+ "nixpkgs": [
+ "nixCargoIntegration",
+ "nixpkgs"
+ ],
+ "node2nix": [
+ "nixCargoIntegration",
+ "nixpkgs"
+ ],
+ "poetry2nix": [
+ "nixCargoIntegration",
+ "nixpkgs"
+ ],
+ "pre-commit-hooks": [
+ "nixCargoIntegration",
+ "nixpkgs"
+ ]
+ },
+ "locked": {
+ "lastModified": 1646710334,
+ "narHash": "sha256-eLBcDgcbOUfeH4k6SEW5a5v0PTp2KNCn+5ZXIoWGYww=",
+ "owner": "nix-community",
+ "repo": "dream2nix",
+ "rev": "5dcfbfd3b60ce0208b894c1bdea00e2bdf80ca6a",
+ "type": "github"
+ },
+ "original": {
+ "owner": "nix-community",
+ "ref": "main",
+ "repo": "dream2nix",
+ "type": "github"
+ }
+ },
"flake-utils": {
+ "locked": {
+ "lastModified": 1642700792,
+ "narHash": "sha256-XqHrk7hFb+zBvRg6Ghl+AZDq03ov6OshJLiSWOoX5es=",
+ "owner": "numtide",
+ "repo": "flake-utils",
+ "rev": "846b2ae0fc4cc943637d3d1def4454213e203cba",
+ "type": "github"
+ },
+ "original": {
+ "owner": "numtide",
+ "repo": "flake-utils",
+ "type": "github"
+ }
+ },
+ "flake-utils_2": {
"locked": {
"lastModified": 1637014545,
"narHash": "sha256-26IZAc5yzlD9FlDT54io1oqG/bBoyka+FJk5guaX4x4=",
@@ -33,6 +122,7 @@
"nixCargoIntegration": {
"inputs": {
"devshell": "devshell",
+ "dream2nix": "dream2nix",
"nixpkgs": [
"nixpkgs"
],
@@ -41,11 +131,11 @@
]
},
"locked": {
- "lastModified": 1642054253,
- "narHash": "sha256-kHh9VmaB7gbS6pheheC4x0uT84LEmhfbsbWEQJgU2E4=",
+ "lastModified": 1646766572,
+ "narHash": "sha256-DV3+zxvAIKsMHsHedJKYFsracvFyLKpFQqurUBR86oY=",
"owner": "yusdacra",
"repo": "nix-cargo-integration",
- "rev": "f8fa9af990195a3f63fe2dde84aa187e193da793",
+ "rev": "3a3f47f43ba486b7554164a698c8dfc5a38624ce",
"type": "github"
},
"original": {
@@ -56,11 +146,11 @@
},
"nixpkgs": {
"locked": {
- "lastModified": 1641887635,
- "narHash": "sha256-kDGpufwzVaiGe5e1sBUBPo9f1YN+nYHJlYqCaVpZTQQ=",
+ "lastModified": 1646497237,
+ "narHash": "sha256-Ccpot1h/rV8MgcngDp5OrdmLTMaUTbStZTR5/sI7zW0=",
"owner": "nixos",
"repo": "nixpkgs",
- "rev": "b2737d4980a17cc2b7d600d7d0b32fd7333aca88",
+ "rev": "062a0c5437b68f950b081bbfc8a699d57a4ee026",
"type": "github"
},
"original": {
@@ -70,22 +160,6 @@
"type": "github"
}
},
- "nixpkgs_2": {
- "locked": {
- "lastModified": 1637453606,
- "narHash": "sha256-Gy6cwUswft9xqsjWxFYEnx/63/qzaFUwatcbV5GF/GQ=",
- "owner": "NixOS",
- "repo": "nixpkgs",
- "rev": "8afc4e543663ca0a6a4f496262cd05233737e732",
- "type": "github"
- },
- "original": {
- "owner": "NixOS",
- "ref": "nixpkgs-unstable",
- "repo": "nixpkgs",
- "type": "github"
- }
- },
"root": {
"inputs": {
"nixCargoIntegration": "nixCargoIntegration",
@@ -95,15 +169,17 @@
},
"rust-overlay": {
"inputs": {
- "flake-utils": "flake-utils",
- "nixpkgs": "nixpkgs_2"
+ "flake-utils": "flake-utils_2",
+ "nixpkgs": [
+ "nixpkgs"
+ ]
},
"locked": {
- "lastModified": 1642128126,
- "narHash": "sha256-av8JUACdrTfQYl/ftZJvKpZEmZfa0avCq7tt5Usdoq0=",
+ "lastModified": 1646792695,
+ "narHash": "sha256-2drCXIKIQnJMlTZbcCfuHZAh+iPcdlRkCqtZnA6MHLY=",
"owner": "oxalica",
"repo": "rust-overlay",
- "rev": "ce4ef6f2d74f2b68f7547df1de22d1b0037ce4ad",
+ "rev": "7f599870402c8d2a5806086c8ee0f2d92b175c54",
"type": "github"
},
"original": {
diff --git a/flake.nix b/flake.nix
index 660207eda..38ba9fd0c 100644
--- a/flake.nix
+++ b/flake.nix
@@ -3,7 +3,10 @@
inputs = {
nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
- rust-overlay.url = "github:oxalica/rust-overlay";
+ rust-overlay = {
+ url = "github:oxalica/rust-overlay";
+ inputs.nixpkgs.follows = "nixpkgs";
+ };
nixCargoIntegration = {
url = "github:yusdacra/nix-cargo-integration";
inputs.nixpkgs.follows = "nixpkgs";
@@ -11,60 +14,37 @@
};
};
- outputs = inputs@{ self, nixCargoIntegration, ... }:
+ outputs = inputs@{ 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"; };
+ defaultOutputs = {
+ app = "hx";
+ package = "helix";
+ };
overrides = {
- crateOverrides = common: _: rec {
- # link languages and theme toml files since helix-core/helix-view expects them
- helix-core = _: { preConfigure = "ln -s ${common.root}/{languages.toml,theme.toml,base16_theme.toml} .."; };
- helix-view = _: { preConfigure = "ln -s ${common.root}/{languages.toml,theme.toml,base16_theme.toml} .."; };
- helix-syntax = prev: {
- src =
- let
- pkgs = common.pkgs;
- helix = pkgs.fetchgit {
- url = "https://github.com/helix-editor/helix.git";
- rev = "a8fd33ac012a79069ef1409503a2edcf3a585153";
- fetchSubmodules = true;
- sha256 = "sha256-5AtOC55ttWT+7RYMboaFxpGZML51ix93wAkYJTt+8JI=";
- };
- 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";
- };
+ crateOverrides = common: _: {
helix-term = prev:
let
- inherit (common) pkgs lib;
- helixSyntax = lib.buildCrate {
- root = self;
- memberName = "helix-syntax";
- defaultCrateOverrides = {
- helix-syntax = helix-syntax;
- };
- release = false;
- };
+ inherit (common) pkgs;
+ grammars = pkgs.callPackage ./grammars.nix { };
runtimeDir = pkgs.runCommand "helix-runtime" { } ''
mkdir -p $out
ln -s ${common.root}/runtime/* $out
- ln -sf ${helixSyntax}/runtime/grammars $out
+ rm -r $out/grammars
+ ln -s ${grammars} $out/grammars
'';
in
{
+ # disable fetching and building of tree-sitter grammars in the helix-term build.rs
+ HELIX_DISABLE_AUTO_GRAMMAR_BUILD = "1";
# link languages and theme toml files since helix-term expects them (for tests)
preConfigure = "ln -s ${common.root}/{languages.toml,theme.toml,base16_theme.toml} ..";
buildInputs = (prev.buildInputs or [ ]) ++ [ common.cCompiler.cc.lib ];
nativeBuildInputs = [ pkgs.makeWrapper ];
+
postFixup = ''
if [ -f "$out/bin/hx" ]; then
wrapProgram "$out/bin/hx" --set HELIX_RUNTIME "${runtimeDir}"
diff --git a/grammars.nix b/grammars.nix
new file mode 100644
index 000000000..ada14aaf9
--- /dev/null
+++ b/grammars.nix
@@ -0,0 +1,106 @@
+{ stdenv, lib, runCommand, yj }:
+let
+ # HACK: nix < 2.6 has a bug in the toml parser, so we convert to JSON
+ # before parsing
+ languages-json = runCommand "languages-toml-to-json" { } ''
+ ${yj}/bin/yj -t < ${./languages.toml} > $out
+ '';
+ languagesConfig = if lib.versionAtLeast builtins.nixVersion "2.6.0" then
+ builtins.fromTOML (builtins.readFile ./languages.toml)
+ else
+ builtins.fromJSON (builtins.readFile (builtins.toPath languages-json));
+ isGitGrammar = (grammar:
+ builtins.hasAttr "source" grammar && builtins.hasAttr "git" grammar.source
+ && builtins.hasAttr "rev" grammar.source);
+ isGitHubGrammar = grammar: lib.hasPrefix "https://github.com" grammar.source.git;
+ toGitHubFetcher = url: let
+ match = builtins.match "https://github\.com/([^/]*)/([^/]*)/?" url;
+ in {
+ owner = builtins.elemAt match 0;
+ repo = builtins.elemAt match 1;
+ };
+ gitGrammars = builtins.filter isGitGrammar languagesConfig.grammar;
+ buildGrammar = grammar:
+ let
+ gh = toGitHubFetcher grammar.source.git;
+ sourceGit = builtins.fetchTree {
+ type = "git";
+ url = grammar.source.git;
+ rev = grammar.source.rev;
+ ref = grammar.source.ref or "HEAD";
+ shallow = true;
+ };
+ sourceGitHub = builtins.fetchTree {
+ type = "github";
+ owner = gh.owner;
+ repo = gh.repo;
+ inherit (grammar.source) rev;
+ };
+ source = if isGitHubGrammar grammar then sourceGitHub else sourceGit;
+ in stdenv.mkDerivation rec {
+ # see https://github.com/NixOS/nixpkgs/blob/fbdd1a7c0bc29af5325e0d7dd70e804a972eb465/pkgs/development/tools/parsing/tree-sitter/grammar.nix
+
+ pname = "helix-tree-sitter-${grammar.name}";
+ version = grammar.source.rev;
+
+ src = if builtins.hasAttr "subpath" grammar.source then
+ "${source}/${grammar.source.subpath}"
+ else
+ source;
+
+ dontUnpack = true;
+ dontConfigure = true;
+
+ FLAGS = [
+ "-I${src}/src"
+ "-g"
+ "-O3"
+ "-fPIC"
+ "-fno-exceptions"
+ "-Wl,-z,relro,-z,now"
+ ];
+
+ NAME = grammar.name;
+
+ buildPhase = ''
+ runHook preBuild
+
+ if [[ -e "$src/src/scanner.cc" ]]; then
+ $CXX -c "$src/src/scanner.cc" -o scanner.o $FLAGS
+ elif [[ -e "$src/src/scanner.c" ]]; then
+ $CC -c "$src/src/scanner.c" -o scanner.o $FLAGS
+ fi
+
+ $CC -c "$src/src/parser.c" -o parser.o $FLAGS
+ $CXX -shared -o $NAME.so *.o
+
+ ls -al
+
+ runHook postBuild
+ '';
+
+ installPhase = ''
+ runHook preInstall
+ mkdir $out
+ mv $NAME.so $out/
+ runHook postInstall
+ '';
+
+ # Strip failed on darwin: strip: error: symbols referenced by indirect symbol table entries that can't be stripped
+ fixupPhase = lib.optionalString stdenv.isLinux ''
+ runHook preFixup
+ $STRIP $out/$NAME.so
+ runHook postFixup
+ '';
+ };
+ builtGrammars = builtins.map (grammar: {
+ inherit (grammar) name;
+ artifact = buildGrammar grammar;
+ }) gitGrammars;
+ grammarLinks = builtins.map (grammar:
+ "ln -s ${grammar.artifact}/${grammar.name}.so $out/${grammar.name}.so")
+ builtGrammars;
+in runCommand "consolidated-helix-grammars" { } ''
+ mkdir -p $out
+ ${builtins.concatStringsSep "\n" grammarLinks}
+''
diff --git a/helix-core/Cargo.toml b/helix-core/Cargo.toml
index 7ff91cfda..6e019a42e 100644
--- a/helix-core/Cargo.toml
+++ b/helix-core/Cargo.toml
@@ -11,20 +11,21 @@ homepage = "https://helix-editor.com"
include = ["src/**/*", "README.md"]
[features]
+unicode-lines = ["ropey/unicode_lines"]
[dependencies]
-helix-syntax = { version = "0.6", path = "../helix-syntax" }
+helix-loader = { version = "0.6", path = "../helix-loader" }
-ropey = "1.3"
+ropey = { version = "1.4", default-features = false }
smallvec = "1.8"
-smartstring = "0.2.9"
+smartstring = "1.0.1"
unicode-segmentation = "1.9"
unicode-width = "0.1"
unicode-general-category = "0.5"
# slab = "0.4.2"
slotmap = "1.0"
tree-sitter = "0.20"
-once_cell = "1.9"
+once_cell = "1.10"
arc-swap = "1"
regex = "1"
@@ -35,10 +36,11 @@ toml = "0.5"
similar = "2.1"
-etcetera = "0.3"
encoding_rs = "0.8"
chrono = { version = "0.4", default-features = false, features = ["alloc", "std"] }
+etcetera = "0.3"
+
[dev-dependencies]
quickcheck = { version = "1", default-features = false }
diff --git a/helix-core/src/auto_pairs.rs b/helix-core/src/auto_pairs.rs
index f4359a342..bcd47356f 100644
--- a/helix-core/src/auto_pairs.rs
+++ b/helix-core/src/auto_pairs.rs
@@ -4,12 +4,14 @@
use crate::{
graphemes, movement::Direction, Range, Rope, RopeGraphemes, Selection, Tendril, Transaction,
};
+use std::collections::HashMap;
+
use log::debug;
use smallvec::SmallVec;
// Heavily based on https://github.com/codemirror/closebrackets/
-pub const PAIRS: &[(char, char)] = &[
+pub const DEFAULT_PAIRS: &[(char, char)] = &[
('(', ')'),
('{', '}'),
('[', ']'),
@@ -18,9 +20,95 @@ pub const PAIRS: &[(char, char)] = &[
('`', '`'),
];
-// [TODO] build this dynamically in language config. see #992
-const OPEN_BEFORE: &str = "([{'\":;,> \n\r\u{000B}\u{000C}\u{0085}\u{2028}\u{2029}";
-const CLOSE_BEFORE: &str = ")]}'\":;,> \n\r\u{000B}\u{000C}\u{0085}\u{2028}\u{2029}"; // includes space and newlines
+/// The type that represents the collection of auto pairs,
+/// keyed by the opener.
+#[derive(Debug, Clone)]
+pub struct AutoPairs(HashMap);
+
+/// Represents the config for a particular pairing.
+#[derive(Debug, Clone, Copy)]
+pub struct Pair {
+ pub open: char,
+ pub close: char,
+}
+
+impl Pair {
+ /// true if open == close
+ pub fn same(&self) -> bool {
+ self.open == self.close
+ }
+
+ /// true if all of the pair's conditions hold for the given document and range
+ pub fn should_close(&self, doc: &Rope, range: &Range) -> bool {
+ let mut should_close = Self::next_is_not_alpha(doc, range);
+
+ if self.same() {
+ should_close &= Self::prev_is_not_alpha(doc, range);
+ }
+
+ should_close
+ }
+
+ pub fn next_is_not_alpha(doc: &Rope, range: &Range) -> bool {
+ let cursor = range.cursor(doc.slice(..));
+ let next_char = doc.get_char(cursor);
+ next_char.map(|c| !c.is_alphanumeric()).unwrap_or(true)
+ }
+
+ pub fn prev_is_not_alpha(doc: &Rope, range: &Range) -> bool {
+ let cursor = range.cursor(doc.slice(..));
+ let prev_char = prev_char(doc, cursor);
+ prev_char.map(|c| !c.is_alphanumeric()).unwrap_or(true)
+ }
+}
+
+impl From<&(char, char)> for Pair {
+ fn from(&(open, close): &(char, char)) -> Self {
+ Self { open, close }
+ }
+}
+
+impl From<(&char, &char)> for Pair {
+ fn from((open, close): (&char, &char)) -> Self {
+ Self {
+ open: *open,
+ close: *close,
+ }
+ }
+}
+
+impl AutoPairs {
+ /// Make a new AutoPairs set with the given pairs and default conditions.
+ pub fn new<'a, V: 'a, A>(pairs: V) -> Self
+ where
+ V: IntoIterator- ,
+ A: Into,
+ {
+ let mut auto_pairs = HashMap::new();
+
+ for pair in pairs.into_iter() {
+ let auto_pair = pair.into();
+
+ auto_pairs.insert(auto_pair.open, auto_pair);
+
+ if auto_pair.open != auto_pair.close {
+ auto_pairs.insert(auto_pair.close, auto_pair);
+ }
+ }
+
+ Self(auto_pairs)
+ }
+
+ pub fn get(&self, ch: char) -> Option<&Pair> {
+ self.0.get(&ch)
+ }
+}
+
+impl Default for AutoPairs {
+ fn default() -> Self {
+ AutoPairs::new(DEFAULT_PAIRS.iter())
+ }
+}
// insert hook:
// Fn(doc, selection, char) => Option
@@ -36,21 +124,17 @@ const CLOSE_BEFORE: &str = ")]}'\":;,> \n\r\u{000B}\u{000C}\u{0085}\u{2028}\u{20
// middle of triple quotes, and more exotic pairs like Jinja's {% %}
#[must_use]
-pub fn hook(doc: &Rope, selection: &Selection, ch: char) -> Option {
+pub fn hook(doc: &Rope, selection: &Selection, ch: char, pairs: &AutoPairs) -> Option {
debug!("autopairs hook selection: {:#?}", selection);
- for &(open, close) in PAIRS {
- if open == ch {
- if open == close {
- return Some(handle_same(doc, selection, open, CLOSE_BEFORE, OPEN_BEFORE));
- } else {
- return Some(handle_open(doc, selection, open, close, CLOSE_BEFORE));
- }
- }
-
- if close == ch {
+ if let Some(pair) = pairs.get(ch) {
+ if pair.same() {
+ return Some(handle_same(doc, selection, pair));
+ } else if pair.open == ch {
+ return Some(handle_open(doc, selection, pair));
+ } else if pair.close == ch {
// && char_at pos == close
- return Some(handle_close(doc, selection, open, close));
+ return Some(handle_close(doc, selection, pair));
}
}
@@ -196,13 +280,7 @@ fn get_next_range(
Range::new(end_anchor, end_head)
}
-fn handle_open(
- doc: &Rope,
- selection: &Selection,
- open: char,
- close: char,
- close_before: &str,
-) -> Transaction {
+fn handle_open(doc: &Rope, selection: &Selection, pair: &Pair) -> Transaction {
let mut end_ranges = SmallVec::with_capacity(selection.len());
let mut offs = 0;
@@ -212,22 +290,21 @@ fn handle_open(
let len_inserted;
let change = match next_char {
- Some(ch) if !close_before.contains(ch) => {
- len_inserted = open.len_utf8();
+ Some(_) if !pair.should_close(doc, start_range) => {
+ len_inserted = pair.open.len_utf8();
let mut tendril = Tendril::new();
- tendril.push(open);
+ tendril.push(pair.open);
(cursor, cursor, Some(tendril))
}
- // None | Some(ch) if close_before.contains(ch) => {}
_ => {
// insert open & close
- let pair = Tendril::from_iter([open, close]);
- len_inserted = open.len_utf8() + close.len_utf8();
- (cursor, cursor, Some(pair))
+ let pair_str = Tendril::from_iter([pair.open, pair.close]);
+ len_inserted = pair.open.len_utf8() + pair.close.len_utf8();
+ (cursor, cursor, Some(pair_str))
}
};
- let next_range = get_next_range(doc, start_range, offs, open, len_inserted);
+ let next_range = get_next_range(doc, start_range, offs, pair.open, len_inserted);
end_ranges.push(next_range);
offs += len_inserted;
@@ -239,7 +316,7 @@ fn handle_open(
t
}
-fn handle_close(doc: &Rope, selection: &Selection, _open: char, close: char) -> Transaction {
+fn handle_close(doc: &Rope, selection: &Selection, pair: &Pair) -> Transaction {
let mut end_ranges = SmallVec::with_capacity(selection.len());
let mut offs = 0;
@@ -249,17 +326,17 @@ fn handle_close(doc: &Rope, selection: &Selection, _open: char, close: char) ->
let next_char = doc.get_char(cursor);
let mut len_inserted = 0;
- let change = if next_char == Some(close) {
+ let change = if next_char == Some(pair.close) {
// return transaction that moves past close
(cursor, cursor, None) // no-op
} else {
- len_inserted += close.len_utf8();
+ len_inserted += pair.close.len_utf8();
let mut tendril = Tendril::new();
- tendril.push(close);
+ tendril.push(pair.close);
(cursor, cursor, Some(tendril))
};
- let next_range = get_next_range(doc, start_range, offs, close, len_inserted);
+ let next_range = get_next_range(doc, start_range, offs, pair.close, len_inserted);
end_ranges.push(next_range);
offs += len_inserted;
@@ -272,13 +349,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,
- close_before: &str,
- open_before: &str,
-) -> Transaction {
+fn handle_same(doc: &Rope, selection: &Selection, pair: &Pair) -> Transaction {
let mut end_ranges = SmallVec::with_capacity(selection.len());
let mut offs = 0;
@@ -286,30 +357,26 @@ fn handle_same(
let transaction = Transaction::change_by_selection(doc, selection, |start_range| {
let cursor = start_range.cursor(doc.slice(..));
let mut len_inserted = 0;
-
let next_char = doc.get_char(cursor);
- let prev_char = prev_char(doc, cursor);
- let change = if next_char == Some(token) {
+ let change = if next_char == Some(pair.open) {
// return transaction that moves past close
(cursor, cursor, None) // no-op
} else {
- let mut pair = Tendril::new();
- pair.push(token);
+ let mut pair_str = Tendril::new();
+ pair_str.push(pair.open);
// for equal pairs, don't insert both open and close if either
// side has a non-pair char
- if (next_char.is_none() || close_before.contains(next_char.unwrap()))
- && (prev_char.is_none() || open_before.contains(prev_char.unwrap()))
- {
- pair.push(token);
+ if pair.should_close(doc, start_range) {
+ pair_str.push(pair.close);
}
- len_inserted += pair.len();
- (cursor, cursor, Some(pair))
+ len_inserted += pair_str.len();
+ (cursor, cursor, Some(pair_str))
};
- let next_range = get_next_range(doc, start_range, offs, token, len_inserted);
+ let next_range = get_next_range(doc, start_range, offs, pair.open, len_inserted);
end_ranges.push(next_range);
offs += len_inserted;
@@ -329,21 +396,23 @@ mod test {
const LINE_END: &str = crate::DEFAULT_LINE_ENDING.as_str();
fn differing_pairs() -> impl Iterator
- {
- PAIRS.iter().filter(|(open, close)| open != close)
+ DEFAULT_PAIRS.iter().filter(|(open, close)| open != close)
}
fn matching_pairs() -> impl Iterator
- {
- PAIRS.iter().filter(|(open, close)| open == close)
+ DEFAULT_PAIRS.iter().filter(|(open, close)| open == close)
}
fn test_hooks(
in_doc: &Rope,
in_sel: &Selection,
ch: char,
+ pairs: &[(char, char)],
expected_doc: &Rope,
expected_sel: &Selection,
) {
- let trans = hook(in_doc, in_sel, ch).unwrap();
+ let pairs = AutoPairs::new(pairs.iter());
+ let trans = hook(in_doc, in_sel, ch, &pairs).unwrap();
let mut actual_doc = in_doc.clone();
assert!(trans.apply(&mut actual_doc));
assert_eq!(expected_doc, &actual_doc);
@@ -353,7 +422,8 @@ mod test {
fn test_hooks_with_pairs(
in_doc: &Rope,
in_sel: &Selection,
- pairs: I,
+ test_pairs: I,
+ pairs: &[(char, char)],
get_expected_doc: F,
actual_sel: &Selection,
) where
@@ -362,11 +432,12 @@ mod test {
R: Into,
Rope: From,
{
- pairs.into_iter().for_each(|(open, close)| {
+ test_pairs.into_iter().for_each(|(open, close)| {
test_hooks(
in_doc,
in_sel,
*open,
+ pairs,
&Rope::from(get_expected_doc(*open, *close)),
actual_sel,
)
@@ -381,7 +452,8 @@ mod test {
test_hooks_with_pairs(
&Rope::from(LINE_END),
&Selection::single(1, 0),
- PAIRS,
+ DEFAULT_PAIRS,
+ DEFAULT_PAIRS,
|open, close| format!("{}{}{}", open, close, LINE_END),
&Selection::single(2, 1),
);
@@ -391,7 +463,8 @@ mod test {
test_hooks_with_pairs(
&empty_doc,
&Selection::single(empty_doc.len_chars(), LINE_END.len()),
- PAIRS,
+ DEFAULT_PAIRS,
+ DEFAULT_PAIRS,
|open, close| {
format!(
"{line_end}{open}{close}{line_end}",
@@ -406,13 +479,16 @@ mod test {
#[test]
fn test_insert_before_multi_code_point_graphemes() {
- test_hooks_with_pairs(
- &Rope::from(format!("hello 👨👩👧👦 goodbye{}", LINE_END)),
- &Selection::single(13, 6),
- PAIRS,
- |open, _| format!("hello {}👨👩👧👦 goodbye{}", open, LINE_END),
- &Selection::single(14, 7),
- );
+ for (_, close) in differing_pairs() {
+ test_hooks(
+ &Rope::from(format!("hello 👨👩👧👦 goodbye{}", LINE_END)),
+ &Selection::single(13, 6),
+ *close,
+ DEFAULT_PAIRS,
+ &Rope::from(format!("hello {}👨👩👧👦 goodbye{}", close, LINE_END)),
+ &Selection::single(14, 7),
+ );
+ }
}
#[test]
@@ -420,7 +496,8 @@ mod test {
test_hooks_with_pairs(
&Rope::from(LINE_END),
&Selection::single(LINE_END.len(), LINE_END.len()),
- PAIRS,
+ DEFAULT_PAIRS,
+ DEFAULT_PAIRS,
|open, close| format!("{}{}{}", LINE_END, open, close),
&Selection::single(LINE_END.len() + 1, LINE_END.len() + 1),
);
@@ -428,7 +505,8 @@ mod test {
test_hooks_with_pairs(
&Rope::from(format!("foo{}", LINE_END)),
&Selection::single(3 + LINE_END.len(), 3 + LINE_END.len()),
- PAIRS,
+ DEFAULT_PAIRS,
+ DEFAULT_PAIRS,
|open, close| format!("foo{}{}{}", LINE_END, open, close),
&Selection::single(LINE_END.len() + 4, LINE_END.len() + 4),
);
@@ -442,7 +520,8 @@ mod test {
&Rope::from(format!("{line_end}{line_end}", line_end = LINE_END)),
// before inserting the pair, the cursor covers all of both empty lines
&Selection::single(0, LINE_END.len() * 2),
- PAIRS,
+ DEFAULT_PAIRS,
+ DEFAULT_PAIRS,
|open, close| {
format!(
"{line_end}{open}{close}{line_end}",
@@ -467,7 +546,8 @@ mod test {
smallvec!(Range::new(1, 0), Range::new(2, 1), Range::new(3, 2),),
0,
),
- PAIRS,
+ DEFAULT_PAIRS,
+ DEFAULT_PAIRS,
|open, close| {
format!(
"{open}{close}\n{open}{close}\n{open}{close}\n",
@@ -489,6 +569,7 @@ mod test {
&Rope::from("foo\n"),
&Selection::single(2, 4),
differing_pairs(),
+ DEFAULT_PAIRS,
|open, close| format!("foo{}{}\n", open, close),
&Selection::single(2, 5),
);
@@ -501,6 +582,7 @@ mod test {
&Rope::from(format!("foo{}", LINE_END)),
&Selection::single(3, 3 + LINE_END.len()),
differing_pairs(),
+ DEFAULT_PAIRS,
|open, close| format!("foo{}{}{}", open, close, LINE_END),
&Selection::single(4, 5),
);
@@ -518,6 +600,7 @@ mod test {
0,
),
differing_pairs(),
+ DEFAULT_PAIRS,
|open, close| {
format!(
"foo{open}{close}\nfoo{open}{close}\nfoo{open}{close}\n",
@@ -535,13 +618,14 @@ mod test {
/// ([)] -> insert ) -> ()[]
#[test]
fn test_insert_close_inside_pair() {
- for (open, close) in PAIRS {
+ for (open, close) in DEFAULT_PAIRS {
let doc = Rope::from(format!("{}{}{}", open, close, LINE_END));
test_hooks(
&doc,
&Selection::single(2, 1),
*close,
+ DEFAULT_PAIRS,
&doc,
&Selection::single(2 + LINE_END.len(), 2),
);
@@ -551,13 +635,14 @@ mod test {
/// [(]) -> append ) -> [()]
#[test]
fn test_append_close_inside_pair() {
- for (open, close) in PAIRS {
+ for (open, close) in DEFAULT_PAIRS {
let doc = Rope::from(format!("{}{}{}", open, close, LINE_END));
test_hooks(
&doc,
&Selection::single(0, 2),
*close,
+ DEFAULT_PAIRS,
&doc,
&Selection::single(0, 2 + LINE_END.len()),
);
@@ -579,14 +664,14 @@ mod test {
0,
);
- for (open, close) in PAIRS {
+ for (open, close) in DEFAULT_PAIRS {
let doc = Rope::from(format!(
"{open}{close}\n{open}{close}\n{open}{close}\n",
open = open,
close = close
));
- test_hooks(&doc, &sel, *close, &doc, &expected_sel);
+ test_hooks(&doc, &sel, *close, DEFAULT_PAIRS, &doc, &expected_sel);
}
}
@@ -605,14 +690,14 @@ mod test {
0,
);
- for (open, close) in PAIRS {
+ for (open, close) in DEFAULT_PAIRS {
let doc = Rope::from(format!(
"{open}{close}\n{open}{close}\n{open}{close}\n",
open = open,
close = close
));
- test_hooks(&doc, &sel, *close, &doc, &expected_sel);
+ test_hooks(&doc, &sel, *close, DEFAULT_PAIRS, &doc, &expected_sel);
}
}
@@ -630,7 +715,14 @@ mod test {
close = close
));
- test_hooks(&doc, &sel, *open, &expected_doc, &expected_sel);
+ test_hooks(
+ &doc,
+ &sel,
+ *open,
+ DEFAULT_PAIRS,
+ &expected_doc,
+ &expected_sel,
+ );
}
}
@@ -648,7 +740,14 @@ mod test {
close = close
));
- test_hooks(&doc, &sel, *open, &expected_doc, &expected_sel);
+ test_hooks(
+ &doc,
+ &sel,
+ *open,
+ DEFAULT_PAIRS,
+ &expected_doc,
+ &expected_sel,
+ );
}
}
@@ -667,7 +766,14 @@ mod test {
outer_open, inner_open, inner_close, outer_close
));
- test_hooks(&doc, &sel, *inner_open, &expected_doc, &expected_sel);
+ test_hooks(
+ &doc,
+ &sel,
+ *inner_open,
+ DEFAULT_PAIRS,
+ &expected_doc,
+ &expected_sel,
+ );
}
}
}
@@ -687,7 +793,14 @@ mod test {
outer_open, inner_open, inner_close, outer_close
));
- test_hooks(&doc, &sel, *inner_open, &expected_doc, &expected_sel);
+ test_hooks(
+ &doc,
+ &sel,
+ *inner_open,
+ DEFAULT_PAIRS,
+ &expected_doc,
+ &expected_sel,
+ );
}
}
}
@@ -698,7 +811,8 @@ mod test {
test_hooks_with_pairs(
&Rope::from("word"),
&Selection::single(1, 0),
- PAIRS,
+ DEFAULT_PAIRS,
+ DEFAULT_PAIRS,
|open, _| format!("{}word", open),
&Selection::single(2, 1),
)
@@ -710,7 +824,8 @@ mod test {
test_hooks_with_pairs(
&Rope::from("word"),
&Selection::single(3, 0),
- PAIRS,
+ DEFAULT_PAIRS,
+ DEFAULT_PAIRS,
|open, _| format!("{}word", open),
&Selection::single(4, 1),
)
@@ -722,10 +837,17 @@ mod test {
let sel = Selection::single(0, 4);
let expected_sel = Selection::single(0, 5);
- for (_, close) in PAIRS {
+ for (_, close) in DEFAULT_PAIRS {
let doc = Rope::from("word");
let expected_doc = Rope::from(format!("wor{}d", close));
- test_hooks(&doc, &sel, *close, &expected_doc, &expected_sel);
+ test_hooks(
+ &doc,
+ &sel,
+ *close,
+ DEFAULT_PAIRS,
+ &expected_doc,
+ &expected_sel,
+ );
}
}
@@ -736,6 +858,7 @@ mod test {
&Rope::from("foo word"),
&Selection::single(7, 3),
differing_pairs(),
+ DEFAULT_PAIRS,
|open, close| format!("foo{}{} word", open, close),
&Selection::single(9, 4),
)
@@ -749,6 +872,7 @@ mod test {
&Rope::from(format!("foo{}{} word{}", open, close, LINE_END)),
&Selection::single(9, 4),
*close,
+ DEFAULT_PAIRS,
&Rope::from(format!("foo{}{} word{}", open, close, LINE_END)),
&Selection::single(9, 5),
)
@@ -771,6 +895,7 @@ mod test {
&doc,
&sel,
differing_pairs(),
+ DEFAULT_PAIRS,
|open, close| format!("word{}{}{}", open, close, LINE_END),
&expected_sel,
);
@@ -779,8 +904,34 @@ mod test {
&doc,
&sel,
matching_pairs(),
+ DEFAULT_PAIRS,
|open, _| format!("word{}{}", open, LINE_END),
&expected_sel,
);
}
+
+ #[test]
+ fn test_configured_pairs() {
+ let test_pairs = &[('`', ':'), ('+', '-')];
+
+ test_hooks_with_pairs(
+ &Rope::from(LINE_END),
+ &Selection::single(1, 0),
+ test_pairs,
+ test_pairs,
+ |open, close| format!("{}{}{}", open, close, LINE_END),
+ &Selection::single(2, 1),
+ );
+
+ let doc = Rope::from(format!("foo`: word{}", LINE_END));
+
+ test_hooks(
+ &doc,
+ &Selection::single(9, 4),
+ ':',
+ test_pairs,
+ &doc,
+ &Selection::single(9, 5),
+ )
+ }
}
diff --git a/helix-core/src/chars.rs b/helix-core/src/chars.rs
index 549915740..817bbb86b 100644
--- a/helix-core/src/chars.rs
+++ b/helix-core/src/chars.rs
@@ -91,7 +91,10 @@ mod test {
#[test]
fn test_categorize() {
- const EOL_TEST_CASE: &str = "\n\r\u{000B}\u{000C}\u{0085}\u{2028}\u{2029}";
+ #[cfg(not(feature = "unicode-lines"))]
+ const EOL_TEST_CASE: &str = "\n";
+ #[cfg(feature = "unicode-lines")]
+ const EOL_TEST_CASE: &str = "\n\u{000B}\u{000C}\u{0085}\u{2028}\u{2029}";
const WORD_TEST_CASE: &str = "_hello_world_あいうえおー1234567890１２３４５６７８９０";
const PUNCTUATION_TEST_CASE: &str =
"!\"#$%&\'()*+,-./:;<=>?@[\\]^`{|}~！”＃＄％＆’（）＊＋、。：；＜＝＞？＠「」＾｀｛｜｝～";
diff --git a/helix-core/src/config.rs b/helix-core/src/config.rs
index 5bd16abde..f399850e6 100644
--- a/helix-core/src/config.rs
+++ b/helix-core/src/config.rs
@@ -1,33 +1,10 @@
-use crate::merge_toml_values;
-
-/// Default bultin-in languages.toml.
-pub fn default_lang_config() -> toml::Value {
- toml::from_slice(include_bytes!("../../languages.toml"))
- .expect("Could not parse bultin-in languages.toml to valid toml")
-}
-
-/// User configured languages.toml file, merged with the default config.
-pub fn user_lang_config() -> Result {
- let def_lang_conf = default_lang_config();
- let data = std::fs::read(crate::config_dir().join("languages.toml"));
- let user_lang_conf = match data {
- Ok(raw) => {
- let value = toml::from_slice(&raw)?;
- merge_toml_values(def_lang_conf, value)
- }
- Err(_) => def_lang_conf,
- };
-
- Ok(user_lang_conf)
-}
-
/// Syntax configuration loader based on built-in languages.toml.
pub fn default_syntax_loader() -> crate::syntax::Configuration {
- default_lang_config()
+ helix_loader::default_lang_config()
.try_into()
- .expect("Could not serialize built-in language.toml")
+ .expect("Could not serialize built-in languages.toml")
}
/// Syntax configuration loader based on user configured languages.toml.
pub fn user_syntax_loader() -> Result {
- user_lang_config()?.try_into()
+ helix_loader::user_lang_config()?.try_into()
}
diff --git a/helix-core/src/graphemes.rs b/helix-core/src/graphemes.rs
index aa8986844..c0c617750 100644
--- a/helix-core/src/graphemes.rs
+++ b/helix-core/src/graphemes.rs
@@ -333,10 +333,7 @@ impl<'a> Iterator for RopeGraphemes<'a> {
}
if a < self.cur_chunk_start {
- let a_char = self.text.byte_to_char(a);
- let b_char = self.text.byte_to_char(b);
-
- Some(self.text.slice(a_char..b_char))
+ Some(self.text.byte_slice(a..b))
} else {
let a2 = a - self.cur_chunk_start;
let b2 = b - self.cur_chunk_start;
diff --git a/helix-core/src/indent.rs b/helix-core/src/indent.rs
index 5d20edc1a..529139b81 100644
--- a/helix-core/src/indent.rs
+++ b/helix-core/src/indent.rs
@@ -1,6 +1,10 @@
+use std::collections::HashMap;
+
+use tree_sitter::{Query, QueryCursor, QueryPredicateArg};
+
use crate::{
chars::{char_is_line_ending, char_is_whitespace},
- syntax::{IndentQuery, LanguageConfiguration, Syntax},
+ syntax::{LanguageConfiguration, RopeProvider, Syntax},
tree_sitter::Node,
Rope, RopeSlice,
};
@@ -186,103 +190,405 @@ pub fn indent_level_for_line(line: RopeSlice, tab_width: usize) -> usize {
len / tab_width
}
-/// Find the highest syntax node at position.
-/// This is to identify the column where this node (e.g., an HTML closing tag) ends.
-fn get_highest_syntax_node_at_bytepos(syntax: &Syntax, pos: usize) -> Option {
- let tree = syntax.tree();
-
- // named_descendant
- let mut node = tree.root_node().descendant_for_byte_range(pos, pos)?;
-
- while let Some(parent) = node.parent() {
- if parent.start_byte() == node.start_byte() {
- node = parent
+/// Computes for node and all ancestors whether they are the first node on their line.
+/// The first entry in the return value represents the root node, the last one the node itself
+fn get_first_in_line(mut node: Node, byte_pos: usize, new_line: bool) -> Vec {
+ let mut first_in_line = Vec::new();
+ loop {
+ if let Some(prev) = node.prev_sibling() {
+ // If we insert a new line, the first node at/after the cursor is considered to be the first in its line
+ let first = prev.end_position().row != node.start_position().row
+ || (new_line && node.start_byte() >= byte_pos && prev.start_byte() < byte_pos);
+ first_in_line.push(Some(first));
+ } else {
+ // Nodes that have no previous siblings are first in their line if and only if their parent is
+ // (which we don't know yet)
+ first_in_line.push(None);
+ }
+ if let Some(parent) = node.parent() {
+ node = parent;
} else {
break;
}
}
- Some(node)
+ let mut result = Vec::with_capacity(first_in_line.len());
+ let mut parent_is_first = true; // The root node is by definition the first node in its line
+ for first in first_in_line.into_iter().rev() {
+ if let Some(first) = first {
+ result.push(first);
+ parent_is_first = first;
+ } else {
+ result.push(parent_is_first);
+ }
+ }
+ result
}
-/// Calculate the indentation at a given treesitter node.
-/// If newline is false, then any "indent" nodes on the line are ignored ("outdent" still applies).
-/// This is because the indentation is only increased starting at the second line of the node.
-fn calculate_indentation(
- query: &IndentQuery,
- node: Option,
- line: usize,
- newline: bool,
-) -> usize {
- let mut increment: isize = 0;
-
- let mut node = match node {
- Some(node) => node,
- None => return 0,
- };
+/// The total indent for some line of code.
+/// This is usually constructed in one of 2 ways:
+/// - Successively add indent captures to get the (added) indent from a single line
+/// - Successively add the indent results for each line
+#[derive(Default)]
+struct Indentation {
+ /// The total indent (the number of indent levels) is defined as max(0, indent-outdent).
+ /// The string that this results in depends on the indent style (spaces or tabs, etc.)
+ indent: usize,
+ outdent: usize,
+}
+impl Indentation {
+ /// Add some other [IndentResult] to this.
+ /// The added indent should be the total added indent from one line
+ fn add_line(&mut self, added: &Indentation) {
+ if added.indent > 0 && added.outdent == 0 {
+ self.indent += 1;
+ } else if added.outdent > 0 && added.indent == 0 {
+ self.outdent += 1;
+ }
+ }
+ /// Add an indent capture to this indent.
+ /// All the captures that are added in this way should be on the same line.
+ fn add_capture(&mut self, added: IndentCaptureType) {
+ match added {
+ IndentCaptureType::Indent => {
+ self.indent = 1;
+ }
+ IndentCaptureType::Outdent => {
+ self.outdent = 1;
+ }
+ }
+ }
+ fn as_string(&self, indent_style: &IndentStyle) -> String {
+ let indent_level = if self.indent >= self.outdent {
+ self.indent - self.outdent
+ } else {
+ log::warn!("Encountered more outdent than indent nodes while calculating indentation: {} outdent, {} indent", self.outdent, self.indent);
+ 0
+ };
+ indent_style.as_str().repeat(indent_level)
+ }
+}
- let mut current_line = line;
- let mut consider_indent = newline;
- let mut increment_from_line: isize = 0;
+/// An indent definition which corresponds to a capture from the indent query
+struct IndentCapture {
+ capture_type: IndentCaptureType,
+ scope: IndentScope,
+}
+#[derive(Clone, Copy)]
+enum IndentCaptureType {
+ Indent,
+ Outdent,
+}
+impl IndentCaptureType {
+ fn default_scope(&self) -> IndentScope {
+ match self {
+ IndentCaptureType::Indent => IndentScope::Tail,
+ IndentCaptureType::Outdent => IndentScope::All,
+ }
+ }
+}
+/// This defines which part of a node an [IndentCapture] applies to.
+/// Each [IndentCaptureType] has a default scope, but the scope can be changed
+/// with `#set!` property declarations.
+#[derive(Clone, Copy)]
+enum IndentScope {
+ /// The indent applies to the whole node
+ All,
+ /// The indent applies to everything except for the first line of the node
+ Tail,
+}
- loop {
- let node_kind = node.kind();
- let start = node.start_position().row;
- if current_line != start {
- // Indent/dedent by at most one per line:
- // .map(|a| { <-- ({ is two scopes
- // let len = 1; <-- indents one level
- // }) <-- }) is two scopes
- if consider_indent || increment_from_line < 0 {
- increment += increment_from_line.signum();
+/// Execute the indent query.
+/// Returns for each node (identified by its id) a list of indent captures for that node.
+fn query_indents(
+ query: &Query,
+ syntax: &Syntax,
+ cursor: &mut QueryCursor,
+ text: RopeSlice,
+ range: std::ops::Range,
+ // Position of the (optional) newly inserted line break.
+ // Given as (line, byte_pos)
+ new_line_break: Option<(usize, usize)>,
+) -> HashMap> {
+ let mut indent_captures: HashMap> = HashMap::new();
+ cursor.set_byte_range(range);
+ // Iterate over all captures from the query
+ for m in cursor.matches(query, syntax.tree().root_node(), RopeProvider(text)) {
+ // Skip matches where not all custom predicates are fulfilled
+ if !query.general_predicates(m.pattern_index).iter().all(|pred| {
+ match pred.operator.as_ref() {
+ "not-kind-eq?" => match (pred.args.get(0), pred.args.get(1)) {
+ (
+ Some(QueryPredicateArg::Capture(capture_idx)),
+ Some(QueryPredicateArg::String(kind)),
+ ) => {
+ let node = m.nodes_for_capture_index(*capture_idx).next();
+ match node {
+ Some(node) => node.kind()!=kind.as_ref(),
+ _ => true,
+ }
+ }
+ _ => {
+ panic!("Invalid indent query: Arguments to \"not-kind-eq?\" must be a capture and a string");
+ }
+ },
+ "same-line?" | "not-same-line?" => {
+ match (pred.args.get(0), pred.args.get(1)) {
+ (
+ Some(QueryPredicateArg::Capture(capt1)),
+ Some(QueryPredicateArg::Capture(capt2))
+ ) => {
+ let get_line_num = |node: Node| {
+ let mut node_line = node.start_position().row;
+ // Adjust for the new line that will be inserted
+ if let Some((line, byte)) = new_line_break {
+ if node_line==line && node.start_byte()>=byte {
+ node_line += 1;
+ }
+ }
+ node_line
+ };
+ let n1 = m.nodes_for_capture_index(*capt1).next();
+ let n2 = m.nodes_for_capture_index(*capt2).next();
+ match (n1, n2) {
+ (Some(n1), Some(n2)) => {
+ let same_line = get_line_num(n1)==get_line_num(n2);
+ same_line==(pred.operator.as_ref()=="same-line?")
+ }
+ _ => true,
+ }
+ }
+ _ => {
+ panic!("Invalid indent query: Arguments to \"{}\" must be 2 captures", pred.operator);
+ }
+ }
+ }
+ _ => {
+ panic!(
+ "Invalid indent query: Unknown predicate (\"{}\")",
+ pred.operator
+ );
+ }
}
- increment_from_line = 0;
- current_line = start;
- consider_indent = true;
+ }) {
+ continue;
}
-
- if query.outdent.contains(node_kind) {
- increment_from_line -= 1;
+ for capture in m.captures {
+ let capture_type = query.capture_names()[capture.index as usize].as_str();
+ let capture_type = match capture_type {
+ "indent" => IndentCaptureType::Indent,
+ "outdent" => IndentCaptureType::Outdent,
+ _ => {
+ // Ignore any unknown captures (these may be needed for predicates such as #match?)
+ continue;
+ }
+ };
+ let scope = capture_type.default_scope();
+ let mut indent_capture = IndentCapture {
+ capture_type,
+ scope,
+ };
+ // Apply additional settings for this capture
+ for property in query.property_settings(m.pattern_index) {
+ match property.key.as_ref() {
+ "scope" => {
+ indent_capture.scope = match property.value.as_deref() {
+ Some("all") => IndentScope::All,
+ Some("tail") => IndentScope::Tail,
+ Some(s) => {
+ panic!("Invalid indent query: Unknown value for \"scope\" property (\"{}\")", s);
+ }
+ None => {
+ panic!(
+ "Invalid indent query: Missing value for \"scope\" property"
+ );
+ }
+ }
+ }
+ _ => {
+ panic!(
+ "Invalid indent query: Unknown property \"{}\"",
+ property.key
+ );
+ }
+ }
+ }
+ indent_captures
+ .entry(capture.node.id())
+ // Most entries only need to contain a single IndentCapture
+ .or_insert_with(|| Vec::with_capacity(1))
+ .push(indent_capture);
}
- if query.indent.contains(node_kind) {
- increment_from_line += 1;
+ }
+ indent_captures
+}
+
+/// Use the syntax tree to determine the indentation for a given position.
+/// This can be used in 2 ways:
+///
+/// - To get the correct indentation for an existing line (new_line=false), not necessarily equal to the current indentation.
+/// - In this case, pos should be inside the first tree-sitter node on that line.
+/// In most cases, this can just be the first non-whitespace on that line.
+/// - To get the indentation for a new line (new_line=true). This behaves like the first usecase if the part of the current line
+/// after pos were moved to a new line.
+///
+/// The indentation is determined by traversing all the tree-sitter nodes containing the position.
+/// Each of these nodes produces some [AddedIndent] for:
+///
+/// - The line of the (beginning of the) node. This is defined by the scope `all` if this is the first node on its line.
+/// - The line after the node. This is defined by:
+/// - The scope `tail`.
+/// - The scope `all` if this node is not the first node on its line.
+/// Intuitively, `all` applies to everything contained in this node while `tail` applies to everything except for the first line of the node.
+/// The indents from different nodes for the same line are then combined.
+/// The [IndentResult] is simply the sum of the [AddedIndent] for all lines.
+///
+/// Specifying which line exactly an [AddedIndent] applies to is important because indents on the same line combine differently than indents on different lines:
+/// ```ignore
+/// some_function(|| {
+/// // Both the function parameters as well as the contained block should be indented.
+/// // Because they are on the same line, this only yields one indent level
+/// });
+/// ```
+///
+/// ```ignore
+/// some_function(
+/// parm1,
+/// || {
+/// // Here we get 2 indent levels because the 'parameters' and the 'block' node begin on different lines
+/// },
+/// );
+/// ```
+pub fn treesitter_indent_for_pos(
+ query: &Query,
+ syntax: &Syntax,
+ indent_style: &IndentStyle,
+ text: RopeSlice,
+ line: usize,
+ pos: usize,
+ new_line: bool,
+) -> Option {
+ let byte_pos = text.char_to_byte(pos);
+ let mut node = syntax
+ .tree()
+ .root_node()
+ .descendant_for_byte_range(byte_pos, byte_pos)?;
+ let mut first_in_line = get_first_in_line(node, byte_pos, new_line);
+ let new_line_break = if new_line {
+ Some((line, byte_pos))
+ } else {
+ None
+ };
+ let query_result = crate::syntax::PARSER.with(|ts_parser| {
+ let mut ts_parser = ts_parser.borrow_mut();
+ let mut cursor = ts_parser.cursors.pop().unwrap_or_else(QueryCursor::new);
+ let query_result = query_indents(
+ query,
+ syntax,
+ &mut cursor,
+ text,
+ byte_pos..byte_pos + 1,
+ new_line_break,
+ );
+ ts_parser.cursors.push(cursor);
+ query_result
+ });
+
+ let mut result = Indentation::default();
+ // We always keep track of all the indent changes on one line, in order to only indent once
+ // even if there are multiple "indent" nodes on the same line
+ let mut indent_for_line = Indentation::default();
+ let mut indent_for_line_below = Indentation::default();
+ loop {
+ // This can safely be unwrapped because `first_in_line` contains
+ // one entry for each ancestor of the node (which is what we iterate over)
+ let is_first = *first_in_line.last().unwrap();
+ // Apply all indent definitions for this node
+ if let Some(definitions) = query_result.get(&node.id()) {
+ for definition in definitions {
+ match definition.scope {
+ IndentScope::All => {
+ if is_first {
+ indent_for_line.add_capture(definition.capture_type);
+ } else {
+ indent_for_line_below.add_capture(definition.capture_type);
+ }
+ }
+ IndentScope::Tail => {
+ indent_for_line_below.add_capture(definition.capture_type);
+ }
+ }
+ }
}
if let Some(parent) = node.parent() {
+ let mut node_line = node.start_position().row;
+ let mut parent_line = parent.start_position().row;
+ if node_line == line && new_line {
+ // Also consider the line that will be inserted
+ if node.start_byte() >= byte_pos {
+ node_line += 1;
+ }
+ if parent.start_byte() >= byte_pos {
+ parent_line += 1;
+ }
+ };
+ if node_line != parent_line {
+ if node_line < line + (new_line as usize) {
+ // Don't add indent for the line below the line of the query
+ result.add_line(&indent_for_line_below);
+ }
+ if node_line == parent_line + 1 {
+ indent_for_line_below = indent_for_line;
+ } else {
+ result.add_line(&indent_for_line);
+ indent_for_line_below = Indentation::default();
+ }
+ indent_for_line = Indentation::default();
+ }
+
node = parent;
+ first_in_line.pop();
} else {
+ result.add_line(&indent_for_line_below);
+ result.add_line(&indent_for_line);
break;
}
}
- if consider_indent || increment_from_line < 0 {
- increment += increment_from_line.signum();
- }
- increment.max(0) as usize
+ Some(result.as_string(indent_style))
}
-// TODO: two usecases: if we are triggering this for a new, blank 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(
+/// Returns the indentation for a new line.
+/// This is done either using treesitter, or if that's not available by copying the indentation from the current line
+#[allow(clippy::too_many_arguments)]
+pub fn indent_for_newline(
language_config: Option<&LanguageConfiguration>,
syntax: Option<&Syntax>,
+ indent_style: &IndentStyle,
+ tab_width: usize,
text: RopeSlice,
- pos: usize,
- line: usize,
- new_line: bool,
-) -> Option {
+ line_before: usize,
+ line_before_end_pos: usize,
+ current_line: usize,
+) -> String {
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);
- // TODO: special case for comments
- // TODO: if preserve_leading_whitespace
- Some(calculate_indentation(query, node, line, new_line))
- } else {
- None
+ if let Some(indent) = treesitter_indent_for_pos(
+ query,
+ syntax,
+ indent_style,
+ text,
+ line_before,
+ line_before_end_pos,
+ true,
+ ) {
+ return indent;
+ };
}
+ let indent_level = indent_level_for_line(text.line(current_line), tab_width);
+ indent_style.as_str().repeat(indent_level)
}
pub fn get_scopes(syntax: Option<&Syntax>, text: RopeSlice, pos: usize) -> Vec<&'static str> {
@@ -326,155 +632,4 @@ mod test {
let line = Rope::from("\t \tfn new"); // 1 tab, 4 spaces, tab
assert_eq!(indent_level_for_line(line.slice(..), tab_width), 3);
}
-
- #[test]
- fn test_suggested_indent_for_line() {
- let doc = Rope::from(
- "
-use std::{
- io::{self, stdout, Stdout, Write},
- path::PathBuf,
- sync::Arc,
- time::Duration,
-}
-mod test {
- fn hello_world() {
- 1 + 1;
-
- let does_indentation_work = 1;
-
- let test_function = function_with_param(this_param,
- that_param
- );
-
- let test_function = function_with_param(
- this_param,
- that_param
- );
-
- let test_function = function_with_proper_indent(param1,
- param2,
- );
-
- let selection = Selection::new(
- changes
- .clone()
- .map(|(start, end, text): (usize, usize, Option)| {
- let len = text.map(|text| text.len()).unwrap() - 1; // minus newline
- let pos = start + len;
- Range::new(pos, pos)
- })
- .collect(),
- 0,
- );
-
- return;
- }
-}
-
-impl MyTrait for YourType
-where
- A: TraitB + TraitC,
- D: TraitE + TraitF,
-{
-
-}
-#[test]
-//
-match test {
- Some(a) => 1,
- None => {
- unimplemented!()
- }
-}
-std::panic::set_hook(Box::new(move |info| {
- hook(info);
-}));
-
-{ { {
- 1
-}}}
-
-pub fn change(document: &Document, changes: I) -> Self
-where
- I: IntoIterator
- + ExactSizeIterator,
-{
- [
- 1,
- 2,
- 3,
- ];
- (
- 1,
- 2
- );
- true
-}
-",
- );
-
- let doc = doc;
- use crate::diagnostic::Severity;
- use crate::syntax::{
- 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()],
- shebangs: vec![],
- language_id: "Rust".to_string(),
- highlight_config: OnceCell::new(),
- config: None,
- //
- injection_regex: None,
- roots: vec![],
- comment_token: None,
- auto_format: false,
- diagnostic_severity: Severity::Warning,
- tree_sitter_library: None,
- language_server: None,
- indent: Some(IndentationConfiguration {
- tab_width: 4,
- unit: String::from(" "),
- }),
- indent_query: OnceCell::new(),
- textobject_query: OnceCell::new(),
- debugger: None,
- }],
- });
-
- // set runtime path so we can find the queries
- let mut runtime = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
- runtime.push("../runtime");
- std::env::set_var("HELIX_RUNTIME", runtime.to_str().unwrap());
-
- let language_config = loader.language_config_for_scope("source.rust").unwrap();
- let highlight_config = language_config.highlight_config(&[]).unwrap();
- let syntax = Syntax::new(&doc, highlight_config, std::sync::Arc::new(loader));
- let text = doc.slice(..);
- let tab_width = 4;
-
- for i in 0..doc.len_lines() {
- let line = text.line(i);
- if let Some(pos) = crate::find_first_non_whitespace_char(line) {
- let indent = indent_level_for_line(line, tab_width);
- assert_eq!(
- suggested_indent_for_pos(
- Some(&language_config),
- Some(&syntax),
- text,
- text.line_to_char(i) + pos,
- i,
- false
- ),
- Some(indent),
- "line {}: \"{}\"",
- i,
- line
- );
- }
- }
- }
}
diff --git a/helix-core/src/lib.rs b/helix-core/src/lib.rs
index 8e5950deb..1f43c2667 100644
--- a/helix-core/src/lib.rs
+++ b/helix-core/src/lib.rs
@@ -33,9 +33,6 @@ pub mod unicode {
pub use unicode_width as width;
}
-static RUNTIME_DIR: once_cell::sync::Lazy =
- once_cell::sync::Lazy::new(runtime_dir);
-
pub fn find_first_non_whitespace_char(line: RopeSlice) -> Option {
line.chars().position(|ch| !ch.is_whitespace())
}
@@ -85,132 +82,6 @@ pub fn find_root(root: Option<&str>, root_markers: &[String]) -> Option std::path::PathBuf {
- 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
- let strategy = choose_base_strategy().expect("Unable to find the config directory!");
- let mut path = strategy.config_dir();
- path.push("helix");
- path
-}
-
-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
-}
-
-// right overrides left
-pub fn merge_toml_values(left: toml::Value, right: toml::Value) -> toml::Value {
- use toml::Value;
-
- fn get_name(v: &Value) -> Option<&str> {
- v.get("name").and_then(Value::as_str)
- }
-
- match (left, right) {
- (Value::Array(mut left_items), Value::Array(right_items)) => {
- left_items.reserve(right_items.len());
- for rvalue in right_items {
- let lvalue = get_name(&rvalue)
- .and_then(|rname| left_items.iter().position(|v| get_name(v) == Some(rname)))
- .map(|lpos| left_items.remove(lpos));
- let mvalue = match lvalue {
- Some(lvalue) => merge_toml_values(lvalue, rvalue),
- None => rvalue,
- };
- left_items.push(mvalue);
- }
- Value::Array(left_items)
- }
- (Value::Table(mut left_map), Value::Table(right_map)) => {
- for (rname, rvalue) in right_map {
- match left_map.remove(&rname) {
- Some(lvalue) => {
- let merged_value = merge_toml_values(lvalue, rvalue);
- left_map.insert(rname, merged_value);
- }
- None => {
- left_map.insert(rname, rvalue);
- }
- }
- }
- Value::Table(left_map)
- }
- // Catch everything else we didn't handle, and use the right value
- (_, value) => value,
- }
-}
-
-#[cfg(test)]
-mod merge_toml_tests {
- use super::merge_toml_values;
-
- #[test]
- fn language_tomls() {
- use toml::Value;
-
- const USER: &str = "
- [[language]]
- name = \"nix\"
- test = \"bbb\"
- indent = { tab-width = 4, unit = \" \", test = \"aaa\" }
- ";
-
- let base: Value = toml::from_slice(include_bytes!("../../languages.toml"))
- .expect("Couldn't parse built-in languages config");
- let user: Value = toml::from_str(USER).unwrap();
-
- let merged = merge_toml_values(base, user);
- let languages = merged.get("language").unwrap().as_array().unwrap();
- let nix = languages
- .iter()
- .find(|v| v.get("name").unwrap().as_str().unwrap() == "nix")
- .unwrap();
- let nix_indent = nix.get("indent").unwrap();
-
- // We changed tab-width and unit in indent so check them if they are the new values
- assert_eq!(
- nix_indent.get("tab-width").unwrap().as_integer().unwrap(),
- 4
- );
- assert_eq!(nix_indent.get("unit").unwrap().as_str().unwrap(), " ");
- // We added a new keys, so check them
- assert_eq!(nix.get("test").unwrap().as_str().unwrap(), "bbb");
- assert_eq!(nix_indent.get("test").unwrap().as_str().unwrap(), "aaa");
- // We didn't change comment-token so it should be same
- assert_eq!(nix.get("comment-token").unwrap().as_str().unwrap(), "#");
- }
-}
-
-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;
diff --git a/helix-core/src/line_ending.rs b/helix-core/src/line_ending.rs
index 8eb426e1e..06ec2a459 100644
--- a/helix-core/src/line_ending.rs
+++ b/helix-core/src/line_ending.rs
@@ -10,12 +10,18 @@ pub const DEFAULT_LINE_ENDING: LineEnding = LineEnding::LF;
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
+ #[cfg(feature = "unicode-lines")]
+ VT, // U+000B -- VerticalTab
+ #[cfg(feature = "unicode-lines")]
+ FF, // U+000C -- FormFeed
+ #[cfg(feature = "unicode-lines")]
+ CR, // U+000D -- CarriageReturn
+ #[cfg(feature = "unicode-lines")]
+ Nel, // U+0085 -- NextLine
+ #[cfg(feature = "unicode-lines")]
+ LS, // U+2028 -- Line Separator
+ #[cfg(feature = "unicode-lines")]
+ PS, // U+2029 -- ParagraphSeparator
}
impl LineEnding {
@@ -32,11 +38,17 @@ impl LineEnding {
match self {
Self::Crlf => "\u{000D}\u{000A}",
Self::LF => "\u{000A}",
+ #[cfg(feature = "unicode-lines")]
Self::VT => "\u{000B}",
+ #[cfg(feature = "unicode-lines")]
Self::FF => "\u{000C}",
+ #[cfg(feature = "unicode-lines")]
Self::CR => "\u{000D}",
+ #[cfg(feature = "unicode-lines")]
Self::Nel => "\u{0085}",
+ #[cfg(feature = "unicode-lines")]
Self::LS => "\u{2028}",
+ #[cfg(feature = "unicode-lines")]
Self::PS => "\u{2029}",
}
}
@@ -45,11 +57,17 @@ impl LineEnding {
pub const fn from_char(ch: char) -> Option {
match ch {
'\u{000A}' => Some(LineEnding::LF),
+ #[cfg(feature = "unicode-lines")]
'\u{000B}' => Some(LineEnding::VT),
+ #[cfg(feature = "unicode-lines")]
'\u{000C}' => Some(LineEnding::FF),
+ #[cfg(feature = "unicode-lines")]
'\u{000D}' => Some(LineEnding::CR),
+ #[cfg(feature = "unicode-lines")]
'\u{0085}' => Some(LineEnding::Nel),
+ #[cfg(feature = "unicode-lines")]
'\u{2028}' => Some(LineEnding::LS),
+ #[cfg(feature = "unicode-lines")]
'\u{2029}' => Some(LineEnding::PS),
// Not a line ending
_ => None,
@@ -65,11 +83,17 @@ impl LineEnding {
match g {
"\u{000D}\u{000A}" => Some(LineEnding::Crlf),
"\u{000A}" => Some(LineEnding::LF),
+ #[cfg(feature = "unicode-lines")]
"\u{000B}" => Some(LineEnding::VT),
+ #[cfg(feature = "unicode-lines")]
"\u{000C}" => Some(LineEnding::FF),
+ #[cfg(feature = "unicode-lines")]
"\u{000D}" => Some(LineEnding::CR),
+ #[cfg(feature = "unicode-lines")]
"\u{0085}" => Some(LineEnding::Nel),
+ #[cfg(feature = "unicode-lines")]
"\u{2028}" => Some(LineEnding::LS),
+ #[cfg(feature = "unicode-lines")]
"\u{2029}" => Some(LineEnding::PS),
// Not a line ending
_ => None,
@@ -101,7 +125,9 @@ pub fn auto_detect_line_ending(doc: &Rope) -> Option {
// 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) => {}
+ None => {}
+ #[cfg(feature = "unicode-lines")]
+ Some(LineEnding::VT) | Some(LineEnding::FF) | Some(LineEnding::PS) => {}
ending => return ending,
}
}
@@ -128,6 +154,19 @@ pub fn get_line_ending(line: &RopeSlice) -> Option {
LineEnding::from_str(g2).or_else(|| LineEnding::from_str(g1))
}
+#[cfg(not(feature = "unicode-lines"))]
+/// Returns the passed line's line ending, if any.
+pub fn get_line_ending_of_str(line: &str) -> Option {
+ if line.ends_with("\u{000D}\u{000A}") {
+ Some(LineEnding::Crlf)
+ } else if line.ends_with('\u{000A}') {
+ Some(LineEnding::LF)
+ } else {
+ None
+ }
+}
+
+#[cfg(feature = "unicode-lines")]
/// Returns the passed line's line ending, if any.
pub fn get_line_ending_of_str(line: &str) -> Option {
if line.ends_with("\u{000D}\u{000A}") {
@@ -211,6 +250,7 @@ mod line_ending_tests {
#[test]
fn str_to_line_ending() {
+ #[cfg(feature = "unicode-lines")]
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));
@@ -220,6 +260,7 @@ mod line_ending_tests {
#[test]
fn rope_slice_to_line_ending() {
let r = Rope::from_str("hello\r\n");
+ #[cfg(feature = "unicode-lines")]
assert_eq!(
LineEnding::from_rope_slice(&r.slice(5..6)),
Some(LineEnding::CR)
@@ -238,6 +279,7 @@ mod line_ending_tests {
#[test]
fn get_line_ending_rope_slice() {
let r = Rope::from_str("Hello\rworld\nhow\r\nare you?");
+ #[cfg(feature = "unicode-lines")]
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));
@@ -247,6 +289,7 @@ mod line_ending_tests {
#[test]
fn get_line_ending_str() {
let text = "Hello\rworld\nhow\r\nare you?";
+ #[cfg(feature = "unicode-lines")]
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));
@@ -257,9 +300,8 @@ mod line_ending_tests {
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);
+ assert_eq!(line_end_char_index(s, 0), 11);
+ assert_eq!(line_end_char_index(s, 1), 15);
+ assert_eq!(line_end_char_index(s, 2), 25);
}
}
diff --git a/helix-core/src/path.rs b/helix-core/src/path.rs
index a66444651..e0c3bef65 100644
--- a/helix-core/src/path.rs
+++ b/helix-core/src/path.rs
@@ -1,9 +1,10 @@
+use etcetera::home_dir;
use std::path::{Component, Path, PathBuf};
/// Replaces users home directory from `path` with tilde `~` if the directory
/// is available, otherwise returns the path unchanged.
pub fn fold_home_dir(path: &Path) -> PathBuf {
- if let Ok(home) = super::home_dir() {
+ if let Ok(home) = home_dir() {
if path.starts_with(&home) {
// it's ok to unwrap, the path starts with home dir
return PathBuf::from("~").join(path.strip_prefix(&home).unwrap());
@@ -20,7 +21,7 @@ pub fn expand_tilde(path: &Path) -> PathBuf {
let mut components = path.components().peekable();
if let Some(Component::Normal(c)) = components.peek() {
if c == &"~" {
- if let Ok(home) = super::home_dir() {
+ if let Ok(home) = home_dir() {
// it's ok to unwrap, the path starts with `~`
return home.join(path.strip_prefix("~").unwrap());
}
diff --git a/helix-core/src/position.rs b/helix-core/src/position.rs
index 93362c775..ce37300a4 100644
--- a/helix-core/src/position.rs
+++ b/helix-core/src/position.rs
@@ -1,8 +1,9 @@
+use std::borrow::Cow;
+
use crate::{
chars::char_is_line_ending,
- graphemes::{ensure_grapheme_boundary_prev, RopeGraphemes},
+ graphemes::{ensure_grapheme_boundary_prev, grapheme_width, RopeGraphemes},
line_ending::line_end_char_index,
- unicode::width::UnicodeWidthChar,
RopeSlice,
};
@@ -77,14 +78,17 @@ pub fn visual_coords_at_pos(text: RopeSlice, pos: usize, tab_width: usize) -> Po
let line_start = text.line_to_char(line);
let pos = ensure_grapheme_boundary_prev(text, pos);
- let col = text
- .slice(line_start..pos)
- .chars()
- .flat_map(|c| match c {
- '\t' => Some(tab_width),
- c => UnicodeWidthChar::width(c),
- })
- .sum();
+
+ let mut col = 0;
+
+ for grapheme in RopeGraphemes::new(text.slice(line_start..pos)) {
+ if grapheme == "\t" {
+ col += tab_width - (col % tab_width);
+ } else {
+ let grapheme = Cow::from(grapheme);
+ col += grapheme_width(&grapheme);
+ }
+ }
Position::new(line, col)
}
diff --git a/helix-core/src/surround.rs b/helix-core/src/surround.rs
index 58eb23cf2..c14456b73 100644
--- a/helix-core/src/surround.rs
+++ b/helix-core/src/surround.rs
@@ -1,3 +1,5 @@
+use std::fmt::Display;
+
use crate::{search, Range, Selection};
use ropey::RopeSlice;
@@ -11,6 +13,27 @@ pub const PAIRS: &[(char, char)] = &[
('（', '）'),
];
+#[derive(Debug, PartialEq)]
+pub enum Error {
+ PairNotFound,
+ CursorOverlap,
+ RangeExceedsText,
+ CursorOnAmbiguousPair,
+}
+
+impl Display for Error {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.write_str(match *self {
+ Error::PairNotFound => "Surround pair not found around all cursors",
+ Error::CursorOverlap => "Cursors overlap for a single surround pair range",
+ Error::RangeExceedsText => "Cursor range exceeds text length",
+ Error::CursorOnAmbiguousPair => "Cursor on ambiguous surround pair",
+ })
+ }
+}
+
+type Result = std::result::Result;
+
/// Given any char in [PAIRS], return the open and closing chars. If not found in
/// [PAIRS] return (ch, ch).
///
@@ -37,31 +60,36 @@ pub fn find_nth_pairs_pos(
ch: char,
range: Range,
n: usize,
-) -> Option<(usize, usize)> {
- if text.len_chars() < 2 || range.to() >= text.len_chars() {
- return None;
+) -> Result<(usize, usize)> {
+ if text.len_chars() < 2 {
+ return Err(Error::PairNotFound);
+ }
+ if range.to() >= text.len_chars() {
+ return Err(Error::RangeExceedsText);
}
let (open, close) = get_pair(ch);
let pos = range.cursor(text);
- if open == close {
+ let (open, close) = if open == close {
if Some(open) == text.get_char(pos) {
// Cursor is directly on match char. We return no match
// because there's no way to know which side of the char
// we should be searching on.
- return None;
+ return Err(Error::CursorOnAmbiguousPair);
}
- Some((
- search::find_nth_prev(text, open, pos, n)?,
- search::find_nth_next(text, close, pos, n)?,
- ))
+ (
+ 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)?,
- ))
- }
+ (
+ find_nth_open_pair(text, open, close, pos, n),
+ find_nth_close_pair(text, open, close, pos, n),
+ )
+ };
+
+ Option::zip(open, close).ok_or(Error::PairNotFound)
}
fn find_nth_open_pair(
@@ -151,17 +179,17 @@ pub fn get_surround_pos(
selection: &Selection,
ch: char,
skip: usize,
-) -> Option> {
+) -> Result> {
let mut change_pos = Vec::new();
for &range in selection {
let (open_pos, close_pos) = find_nth_pairs_pos(text, ch, range, skip)?;
if change_pos.contains(&open_pos) || change_pos.contains(&close_pos) {
- return None;
+ return Err(Error::CursorOverlap);
}
change_pos.extend_from_slice(&[open_pos, close_pos]);
}
- Some(change_pos)
+ Ok(change_pos)
}
#[cfg(test)]
@@ -175,7 +203,7 @@ mod test {
#[allow(clippy::type_complexity)]
fn check_find_nth_pair_pos(
text: &str,
- cases: Vec<(usize, char, usize, Option<(usize, usize)>)>,
+ cases: Vec<(usize, char, usize, Result<(usize, usize)>)>,
) {
let doc = Rope::from(text);
let slice = doc.slice(..);
@@ -196,13 +224,13 @@ mod test {
"some (text) here",
vec![
// cursor on [t]ext
- (6, '(', 1, Some((5, 10))),
- (6, ')', 1, Some((5, 10))),
+ (6, '(', 1, Ok((5, 10))),
+ (6, ')', 1, Ok((5, 10))),
// cursor on so[m]e
- (2, '(', 1, None),
+ (2, '(', 1, Err(Error::PairNotFound)),
// cursor on bracket itself
- (5, '(', 1, Some((5, 10))),
- (10, '(', 1, Some((5, 10))),
+ (5, '(', 1, Ok((5, 10))),
+ (10, '(', 1, Ok((5, 10))),
],
);
}
@@ -213,9 +241,9 @@ mod test {
"(so (many (good) text) here)",
vec![
// cursor on go[o]d
- (13, '(', 1, Some((10, 15))),
- (13, '(', 2, Some((4, 21))),
- (13, '(', 3, Some((0, 27))),
+ (13, '(', 1, Ok((10, 15))),
+ (13, '(', 2, Ok((4, 21))),
+ (13, '(', 3, Ok((0, 27))),
],
);
}
@@ -226,11 +254,11 @@ mod test {
"'so 'many 'good' text' here'",
vec![
// cursor on go[o]d
- (13, '\'', 1, Some((10, 15))),
- (13, '\'', 2, Some((4, 21))),
- (13, '\'', 3, Some((0, 27))),
+ (13, '\'', 1, Ok((10, 15))),
+ (13, '\'', 2, Ok((4, 21))),
+ (13, '\'', 3, Ok((0, 27))),
// cursor on the quotes
- (10, '\'', 1, None),
+ (10, '\'', 1, Err(Error::CursorOnAmbiguousPair)),
],
)
}
@@ -241,8 +269,8 @@ mod test {
"((so)((many) good (text))(here))",
vec![
// cursor on go[o]d
- (15, '(', 1, Some((5, 24))),
- (15, '(', 2, Some((0, 31))),
+ (15, '(', 1, Ok((5, 24))),
+ (15, '(', 2, Ok((0, 31))),
],
)
}
@@ -253,9 +281,9 @@ mod test {
"(so [many {good} text] here)",
vec![
// cursor on go[o]d
- (13, '{', 1, Some((10, 15))),
- (13, '[', 1, Some((4, 21))),
- (13, '(', 1, Some((0, 27))),
+ (13, '{', 1, Ok((10, 15))),
+ (13, '[', 1, Ok((4, 21))),
+ (13, '(', 1, Ok((0, 27))),
],
)
}
@@ -285,11 +313,10 @@ mod test {
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
+ Err(Error::PairNotFound) // different surround chars
);
let selection = Selection::new(
@@ -299,7 +326,15 @@ mod test {
// cursor on [x]x, newli[n]e
assert_eq!(
get_surround_pos(slice, &selection, '(', 1),
- None // overlapping surround chars
+ Err(Error::PairNotFound) // overlapping surround chars
+ );
+
+ let selection =
+ Selection::new(SmallVec::from_slice(&[Range::point(2), Range::point(3)]), 0);
+ // cursor on s[o][m]e
+ assert_eq!(
+ get_surround_pos(slice, &selection, '[', 1),
+ Err(Error::CursorOverlap)
);
}
}
diff --git a/helix-core/src/syntax.rs b/helix-core/src/syntax.rs
index ccf91100f..dde7e90cd 100644
--- a/helix-core/src/syntax.rs
+++ b/helix-core/src/syntax.rs
@@ -1,4 +1,5 @@
use crate::{
+ auto_pairs::AutoPairs,
chars::char_is_line_ending,
diagnostic::Severity,
regex::Regex,
@@ -6,8 +7,6 @@ use crate::{
Rope, RopeSlice, Tendril,
};
-pub use helix_syntax::get_language;
-
use arc_swap::{ArcSwap, Guard};
use slotmap::{DefaultKey as LayerId, HopSlotMap};
@@ -17,12 +16,15 @@ use std::{
collections::{HashMap, HashSet, VecDeque},
fmt,
path::Path,
+ str::FromStr,
sync::Arc,
};
use once_cell::sync::{Lazy, OnceCell};
use serde::{Deserialize, Serialize};
+use helix_loader::grammar::{get_language, load_runtime_file};
+
fn deserialize_regex<'de, D>(deserializer: D) -> Result, D::Error>
where
D: serde::Deserializer<'de>,
@@ -41,8 +43,14 @@ where
.transpose()
}
+pub fn deserialize_auto_pairs<'de, D>(deserializer: D) -> Result, D::Error>
+where
+ D: serde::Deserializer<'de>,
+{
+ Ok(Option::::deserialize(deserializer)?.and_then(AutoPairConfig::into))
+}
+
#[derive(Debug, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
pub struct Configuration {
pub language: Vec,
}
@@ -68,7 +76,7 @@ pub struct LanguageConfiguration {
#[serde(default)]
pub diagnostic_severity: Severity,
- pub tree_sitter_library: Option, // tree-sitter library name, defaults to language_id
+ pub grammar: Option, // tree-sitter grammar name, defaults to language_id
// content_regex
#[serde(default, skip_serializing, deserialize_with = "deserialize_regex")]
@@ -84,11 +92,18 @@ pub struct LanguageConfiguration {
pub indent: Option,
#[serde(skip)]
- pub(crate) indent_query: OnceCell>,
+ pub(crate) indent_query: OnceCell>,
#[serde(skip)]
pub(crate) textobject_query: OnceCell>,
#[serde(skip_serializing_if = "Option::is_none")]
pub debugger: Option,
+
+ /// Automatic insertion of pairs to parentheses, brackets,
+ /// etc. Defaults to true. Optionally, this can be a list of 2-tuples
+ /// to specify a list of characters to pair. This overrides the
+ /// global setting.
+ #[serde(default, skip_serializing, deserialize_with = "deserialize_auto_pairs")]
+ pub auto_pairs: Option,
}
#[derive(Debug, Serialize, Deserialize)]
@@ -162,15 +177,47 @@ pub struct IndentationConfiguration {
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,
- #[serde(default)]
- #[serde(skip_serializing_if = "HashSet::is_empty")]
- pub outdent: HashSet,
+/// Configuration for auto pairs
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields, untagged)]
+pub enum AutoPairConfig {
+ /// Enables or disables auto pairing. False means disabled. True means to use the default pairs.
+ Enable(bool),
+
+ /// The mappings of pairs.
+ Pairs(HashMap),
+}
+
+impl Default for AutoPairConfig {
+ fn default() -> Self {
+ AutoPairConfig::Enable(true)
+ }
+}
+
+impl From<&AutoPairConfig> for Option {
+ fn from(auto_pair_config: &AutoPairConfig) -> Self {
+ match auto_pair_config {
+ AutoPairConfig::Enable(false) => None,
+ AutoPairConfig::Enable(true) => Some(AutoPairs::default()),
+ AutoPairConfig::Pairs(pairs) => Some(AutoPairs::new(pairs.iter())),
+ }
+ }
+}
+
+impl From for Option {
+ fn from(auto_pairs_config: AutoPairConfig) -> Self {
+ (&auto_pairs_config).into()
+ }
+}
+
+impl FromStr for AutoPairConfig {
+ type Err = std::str::ParseBoolError;
+
+ // only do bool parsing for runtime setting
+ fn from_str(s: &str) -> Result {
+ let enable: bool = s.parse()?;
+ Ok(AutoPairConfig::Enable(enable))
+ }
}
#[derive(Debug)]
@@ -178,16 +225,56 @@ pub struct TextObjectQuery {
pub query: Query,
}
+pub enum CapturedNode<'a> {
+ Single(Node<'a>),
+ /// Guarenteed to be not empty
+ Grouped(Vec>),
+}
+
+impl<'a> CapturedNode<'a> {
+ pub fn start_byte(&self) -> usize {
+ match self {
+ Self::Single(n) => n.start_byte(),
+ Self::Grouped(ns) => ns[0].start_byte(),
+ }
+ }
+
+ pub fn end_byte(&self) -> usize {
+ match self {
+ Self::Single(n) => n.end_byte(),
+ Self::Grouped(ns) => ns.last().unwrap().end_byte(),
+ }
+ }
+
+ pub fn byte_range(&self) -> std::ops::Range {
+ self.start_byte()..self.end_byte()
+ }
+}
+
impl TextObjectQuery {
/// Run the query on the given node and return sub nodes which match given
/// capture ("function.inside", "class.around", etc).
+ ///
+ /// Captures may contain multiple nodes by using quantifiers (+, *, etc),
+ /// and support for this is partial and could use improvement.
+ ///
+ /// ```query
+ /// ;; supported:
+ /// (comment)+ @capture
+ ///
+ /// ;; unsupported:
+ /// (
+ /// (comment)+
+ /// (function)
+ /// ) @capture
+ /// ```
pub fn capture_nodes<'a>(
&'a self,
capture_name: &str,
node: Node<'a>,
slice: RopeSlice<'a>,
cursor: &'a mut QueryCursor,
- ) -> Option>> {
+ ) -> Option>> {
self.capture_nodes_any(&[capture_name], node, slice, cursor)
}
@@ -199,28 +286,36 @@ impl TextObjectQuery {
node: Node<'a>,
slice: RopeSlice<'a>,
cursor: &'a mut QueryCursor,
- ) -> Option>> {
+ ) -> Option>> {
let capture_idx = capture_names
.iter()
.find_map(|cap| self.query.capture_index_for_name(cap))?;
- let captures = cursor.captures(&self.query, node, RopeProvider(slice));
+ let captures = cursor.matches(&self.query, node, RopeProvider(slice));
+
+ let nodes = captures.flat_map(move |mat| {
+ let captures = mat.captures.iter().filter(move |c| c.index == capture_idx);
+ let nodes = captures.map(|c| c.node);
+ let pattern_idx = mat.pattern_index;
+ let quantifier = self.query.capture_quantifiers(pattern_idx)[capture_idx as usize];
+
+ let iter: Box> = match quantifier {
+ CaptureQuantifier::OneOrMore | CaptureQuantifier::ZeroOrMore => {
+ let nodes: Vec = nodes.collect();
+ if nodes.is_empty() {
+ Box::new(std::iter::empty())
+ } else {
+ Box::new(std::iter::once(CapturedNode::Grouped(nodes)))
+ }
+ }
+ _ => Box::new(nodes.map(CapturedNode::Single)),
+ };
- captures
- .filter_map(move |(mat, idx)| {
- (mat.captures[idx].index == capture_idx).then(|| mat.captures[idx].node)
- })
- .into()
+ iter
+ });
+ Some(nodes)
}
}
-fn load_runtime_file(language: &str, filename: &str) -> Result {
- 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 =
Lazy::new(|| Regex::new(r";+\s*inherits\s*:?\s*([a-z_,()]+)\s*").unwrap());
@@ -266,21 +361,16 @@ impl LanguageConfiguration {
if highlights_query.is_empty() {
None
} else {
- let language = get_language(
- &crate::RUNTIME_DIR,
- self.tree_sitter_library
- .as_deref()
- .unwrap_or(&self.language_id),
- )
- .map_err(|e| log::info!("{}", e))
- .ok()?;
+ let language = get_language(self.grammar.as_deref().unwrap_or(&self.language_id))
+ .map_err(|e| log::info!("{}", e))
+ .ok()?;
let config = HighlightConfiguration::new(
language,
&highlights_query,
&injections_query,
&locals_query,
)
- .unwrap(); // TODO: avoid panic
+ .unwrap_or_else(|query_error| panic!("Could not parse queries for language {:?}. Are your grammars out of sync? Try running 'hx --grammar fetch' and 'hx --grammar build'. This query could not be parsed: {:?}", self.language_id, query_error));
config.configure(scopes);
Some(Arc::new(config))
@@ -303,13 +393,13 @@ impl LanguageConfiguration {
self.highlight_config.get().is_some()
}
- pub fn indent_query(&self) -> Option<&IndentQuery> {
+ pub fn indent_query(&self) -> Option<&Query> {
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()
+ let lang_name = self.language_id.to_ascii_lowercase();
+ let query_text = read_query(&lang_name, "indents.scm");
+ let lang = self.highlight_config.get()?.as_ref()?.language;
+ Query::new(lang, &query_text).ok()
})
.as_ref()
}
@@ -456,7 +546,7 @@ impl Loader {
pub struct TsParser {
parser: tree_sitter::Parser,
- cursors: Vec,
+ pub cursors: Vec,
}
// could also just use a pool, or a single instance?
@@ -475,9 +565,7 @@ pub struct Syntax {
}
fn byte_range_to_str(range: std::ops::Range, source: RopeSlice) -> Cow {
- let start_char = source.byte_to_char(range.start);
- let end_char = source.byte_to_char(range.end);
- Cow::from(source.slice(start_char..end_char))
+ Cow::from(source.byte_slice(range))
}
impl Syntax {
@@ -1009,8 +1097,8 @@ pub(crate) fn generate_edits(
use std::sync::atomic::{AtomicUsize, Ordering};
use std::{iter, mem, ops, str, usize};
use tree_sitter::{
- Language as Grammar, Node, Parser, Point, Query, QueryCaptures, QueryCursor, QueryError,
- QueryMatch, Range, TextProvider, Tree,
+ CaptureQuantifier, Language as Grammar, Node, Parser, Point, Query, QueryCaptures, QueryCursor,
+ QueryError, QueryMatch, Range, TextProvider, Tree,
};
const CANCELLATION_CHECK_INTERVAL: usize = 100;
@@ -1081,7 +1169,7 @@ struct HighlightIter<'a> {
}
// Adapter to convert rope chunks to bytes
-struct ChunksBytes<'a> {
+pub struct ChunksBytes<'a> {
chunks: ropey::iter::Chunks<'a>,
}
impl<'a> Iterator for ChunksBytes<'a> {
@@ -1091,14 +1179,12 @@ impl<'a> Iterator for ChunksBytes<'a> {
}
}
-struct RopeProvider<'a>(RopeSlice<'a>);
+pub struct RopeProvider<'a>(pub RopeSlice<'a>);
impl<'a> TextProvider<'a> for RopeProvider<'a> {
type I = ChunksBytes<'a>;
fn text(&mut self, node: Node) -> Self::I {
- let start_char = self.0.byte_to_char(node.start_byte());
- let end_char = self.0.byte_to_char(node.end_byte());
- let fragment = self.0.slice(start_char..end_char);
+ let fragment = self.0.byte_slice(node.start_byte()..node.end_byte());
ChunksBytes {
chunks: fragment.chunks(),
}
@@ -1862,6 +1948,50 @@ mod test {
use super::*;
use crate::{Rope, Transaction};
+ #[test]
+ fn test_textobject_queries() {
+ let query_str = r#"
+ (line_comment)+ @quantified_nodes
+ ((line_comment)+) @quantified_nodes_grouped
+ ((line_comment) (line_comment)) @multiple_nodes_grouped
+ "#;
+ let source = Rope::from_str(
+ r#"
+/// a comment on
+/// mutiple lines
+ "#,
+ );
+
+ let loader = Loader::new(Configuration { language: vec![] });
+ let language = get_language("Rust").unwrap();
+
+ let query = Query::new(language, query_str).unwrap();
+ let textobject = TextObjectQuery { query };
+ let mut cursor = QueryCursor::new();
+
+ let config = HighlightConfiguration::new(language, "", "", "").unwrap();
+ let syntax = Syntax::new(&source, Arc::new(config), Arc::new(loader));
+
+ let root = syntax.tree().root_node();
+ let mut test = |capture, range| {
+ let matches: Vec<_> = textobject
+ .capture_nodes(capture, root, source.slice(..), &mut cursor)
+ .unwrap()
+ .collect();
+
+ assert_eq!(
+ matches[0].byte_range(),
+ range,
+ "@{capture} expected {range:?}"
+ )
+ };
+
+ test("quantified_nodes", 1..35);
+ // NOTE: Enable after implementing proper node group capturing
+ // test("quantified_nodes_grouped", 1..35);
+ // test("multiple_nodes_grouped", 1..35);
+ }
+
#[test]
fn test_parser() {
let highlight_names: Vec = [
@@ -1891,17 +2021,13 @@ mod test {
let loader = Loader::new(Configuration { language: vec![] });
- let language = get_language(&crate::RUNTIME_DIR, "Rust").unwrap();
+ let language = get_language("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(),
+ &std::fs::read_to_string("../runtime/grammars/sources/rust/queries/highlights.scm")
+ .unwrap(),
+ &std::fs::read_to_string("../runtime/grammars/sources/rust/queries/injections.scm")
+ .unwrap(),
"", // locals.scm
)
.unwrap();
@@ -1989,7 +2115,7 @@ mod test {
#[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();
+ let contents = load_runtime_file("rust", "indents.scm").unwrap();
assert!(!contents.is_empty());
let results = load_runtime_file("rust", "does-not-exist");
diff --git a/helix-core/src/transaction.rs b/helix-core/src/transaction.rs
index 2e34a9864..daf4a77e8 100644
--- a/helix-core/src/transaction.rs
+++ b/helix-core/src/transaction.rs
@@ -21,7 +21,6 @@ pub enum Assoc {
After,
}
-// ChangeSpec = Change | ChangeSet | Vec
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct ChangeSet {
pub(crate) changes: Vec,
@@ -50,7 +49,6 @@ impl ChangeSet {
}
// TODO: from iter
- //
#[doc(hidden)] // used by lsp to convert to LSP changes
pub fn changes(&self) -> &[Operation] {
@@ -415,8 +413,6 @@ impl ChangeSet {
pub struct Transaction {
changes: ChangeSet,
selection: Option,
- // effects, annotations
- // scroll_into_view
}
impl Transaction {
@@ -440,14 +436,12 @@ impl Transaction {
/// Returns true if applied successfully.
pub fn apply(&self, doc: &mut Rope) -> bool {
- if !self.changes.is_empty() {
- // apply changes to the document
- if !self.changes.apply(doc) {
- return false;
- }
+ if self.changes.is_empty() {
+ return true;
}
- true
+ // apply changes to the document
+ self.changes.apply(doc)
}
/// Generate a transaction that reverts this one.
@@ -475,7 +469,7 @@ impl Transaction {
/// Generate a transaction from a set of changes.
pub fn change(doc: &Rope, changes: I) -> Self
where
- I: IntoIterator
- + Iterator,
+ I: Iterator
- ,
{
let len = doc.len_chars();
@@ -483,12 +477,11 @@ impl Transaction {
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.
-
- // TODO: test for (pos, pos, None) to factor out as nothing
-
let mut last = 0;
for (from, to, tendril) in changes {
+ // Verify ranges are ordered and not overlapping
+ debug_assert!(last <= from);
+
// Retain from last "to" to current "from"
changeset.retain(from - last);
let span = to - from;
@@ -694,7 +687,7 @@ mod test {
let mut doc = Rope::from("hello world!\ntest 123");
let transaction = Transaction::change(
&doc,
- // (1, 1, None) is a useless 0-width delete
+ // (1, 1, None) is a useless 0-width delete that gets factored out
vec![(1, 1, None), (6, 11, Some("void".into())), (12, 17, None)].into_iter(),
);
transaction.apply(&mut doc);
diff --git a/helix-core/tests/data/indent/indent.rs b/helix-core/tests/data/indent/indent.rs
new file mode 120000
index 000000000..2ac16cf96
--- /dev/null
+++ b/helix-core/tests/data/indent/indent.rs
@@ -0,0 +1 @@
+../../../src/indent.rs
\ No newline at end of file
diff --git a/helix-core/tests/data/indent/languages.toml b/helix-core/tests/data/indent/languages.toml
new file mode 100644
index 000000000..f9cef4942
--- /dev/null
+++ b/helix-core/tests/data/indent/languages.toml
@@ -0,0 +1,13 @@
+# This languages.toml should contain definitions for all languages for which we have indent tests
+[[language]]
+name = "rust"
+scope = "source.rust"
+injection-regex = "rust"
+file-types = ["rs"]
+comment-token = "//"
+roots = ["Cargo.toml", "Cargo.lock"]
+indent = { tab-width = 4, unit = " " }
+
+[[grammar]]
+name = "rust"
+source = { git = "https://github.com/tree-sitter/tree-sitter-rust", rev = "a360da0a29a19c281d08295a35ecd0544d2da211" }
diff --git a/helix-core/tests/data/indent/rust.rs b/helix-core/tests/data/indent/rust.rs
new file mode 100644
index 000000000..010745e0d
--- /dev/null
+++ b/helix-core/tests/data/indent/rust.rs
@@ -0,0 +1,105 @@
+use std::{
+ io::{self, stdout, Stdout, Write},
+ path::PathBuf,
+ sync::Arc,
+ time::Duration,
+};
+mod test {
+ fn hello_world() {
+ 1 + 1;
+
+ let does_indentation_work = 1;
+
+ let mut really_long_variable_name_using_up_the_line =
+ really_long_fn_that_should_definitely_go_on_the_next_line();
+ really_long_variable_name_using_up_the_line =
+ really_long_fn_that_should_definitely_go_on_the_next_line();
+ really_long_variable_name_using_up_the_line |=
+ really_long_fn_that_should_definitely_go_on_the_next_line();
+
+ let (
+ a_long_variable_name_in_this_tuple,
+ b_long_variable_name_in_this_tuple,
+ c_long_variable_name_in_this_tuple,
+ d_long_variable_name_in_this_tuple,
+ e_long_variable_name_in_this_tuple,
+ ): (usize, usize, usize, usize, usize) =
+ if really_long_fn_that_should_definitely_go_on_the_next_line() {
+ (
+ 03294239434,
+ 1213412342314,
+ 21231234134,
+ 834534234549898789,
+ 9879234234543853457,
+ )
+ } else {
+ (0, 1, 2, 3, 4)
+ };
+
+ let test_function = function_with_param(this_param,
+ that_param
+ );
+
+ let test_function = function_with_param(
+ this_param,
+ that_param
+ );
+
+ let test_function = function_with_proper_indent(param1,
+ param2,
+ );
+
+ let selection = Selection::new(
+ changes
+ .clone()
+ .map(|(start, end, text): (usize, usize, Option)| {
+ let len = text.map(|text| text.len()).unwrap() - 1; // minus newline
+ let pos = start + len;
+ Range::new(pos, pos)
+ })
+ .collect(),
+ 0,
+ );
+
+ return;
+ }
+}
+
+impl MyTrait for YourType
+where
+ A: TraitB + TraitC,
+ D: TraitE + TraitF,
+{
+
+}
+#[test]
+//
+match test {
+ Some(a) => 1,
+ None => {
+ unimplemented!()
+ }
+}
+std::panic::set_hook(Box::new(move |info| {
+ hook(info);
+}));
+
+{ { {
+ 1
+}}}
+
+pub fn change(document: &Document, changes: I) -> Self
+where
+ I: IntoIterator
- + ExactSizeIterator,
+{
+ [
+ 1,
+ 2,
+ 3,
+ ];
+ (
+ 1,
+ 2
+ );
+ true
+}
diff --git a/helix-core/tests/indent.rs b/helix-core/tests/indent.rs
new file mode 100644
index 000000000..ff04d05f5
--- /dev/null
+++ b/helix-core/tests/indent.rs
@@ -0,0 +1,68 @@
+use helix_core::{
+ indent::{treesitter_indent_for_pos, IndentStyle},
+ syntax::Loader,
+ Syntax,
+};
+use std::path::PathBuf;
+
+#[test]
+fn test_treesitter_indent_rust() {
+ test_treesitter_indent("rust.rs", "source.rust");
+}
+#[test]
+fn test_treesitter_indent_rust_2() {
+ test_treesitter_indent("indent.rs", "source.rust");
+ // TODO Use commands.rs as indentation test.
+ // Currently this fails because we can't align the parameters of a closure yet
+ // test_treesitter_indent("commands.rs", "source.rust");
+}
+
+fn test_treesitter_indent(file_name: &str, lang_scope: &str) {
+ let mut test_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+ test_dir.push("tests/data/indent");
+
+ let mut test_file = test_dir.clone();
+ test_file.push(file_name);
+ let test_file = std::fs::File::open(test_file).unwrap();
+ let doc = ropey::Rope::from_reader(test_file).unwrap();
+
+ let mut config_file = test_dir;
+ config_file.push("languages.toml");
+ let config = std::fs::read(config_file).unwrap();
+ let config = toml::from_slice(&config).unwrap();
+ let loader = Loader::new(config);
+
+ // set runtime path so we can find the queries
+ let mut runtime = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+ runtime.push("../runtime");
+ std::env::set_var("HELIX_RUNTIME", runtime.to_str().unwrap());
+
+ let language_config = loader.language_config_for_scope(lang_scope).unwrap();
+ let highlight_config = language_config.highlight_config(&[]).unwrap();
+ let syntax = Syntax::new(&doc, highlight_config, std::sync::Arc::new(loader));
+ let indent_query = language_config.indent_query().unwrap();
+ let text = doc.slice(..);
+
+ for i in 0..doc.len_lines() {
+ let line = text.line(i);
+ if let Some(pos) = helix_core::find_first_non_whitespace_char(line) {
+ let suggested_indent = treesitter_indent_for_pos(
+ indent_query,
+ &syntax,
+ &IndentStyle::Spaces(4),
+ text,
+ i,
+ text.line_to_char(i) + pos,
+ false,
+ )
+ .unwrap();
+ assert!(
+ line.get_slice(..pos).map_or(false, |s| s == suggested_indent),
+ "Wrong indentation on line {}:\n\"{}\" (original line)\n\"{}\" (suggested indentation)\n",
+ i+1,
+ line.slice(..line.len_chars()-1),
+ suggested_indent,
+ );
+ }
+ }
+}
diff --git a/helix-dap/Cargo.toml b/helix-dap/Cargo.toml
index 24288697e..95a059052 100644
--- a/helix-dap/Cargo.toml
+++ b/helix-dap/Cargo.toml
@@ -19,6 +19,7 @@ serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
thiserror = "1.0"
tokio = { version = "1", features = ["rt", "rt-multi-thread", "io-util", "io-std", "time", "process", "macros", "fs", "parking_lot", "net", "sync"] }
+which = "4.2"
[dev-dependencies]
fern = "0.6"
diff --git a/helix-dap/src/client.rs b/helix-dap/src/client.rs
index 562544296..9498c64c1 100644
--- a/helix-dap/src/client.rs
+++ b/helix-dap/src/client.rs
@@ -105,6 +105,9 @@ impl Client {
args: Vec<&str>,
id: usize,
) -> Result<(Self, UnboundedReceiver)> {
+ // Resolve path to the binary
+ let cmd = which::which(cmd).map_err(|err| anyhow::anyhow!(err))?;
+
let process = Command::new(cmd)
.args(args)
.stdin(Stdio::piped())
diff --git a/helix-syntax/Cargo.toml b/helix-loader/Cargo.toml
similarity index 60%
rename from helix-syntax/Cargo.toml
rename to helix-loader/Cargo.toml
index 855839be0..21b37333a 100644
--- a/helix-syntax/Cargo.toml
+++ b/helix-loader/Cargo.toml
@@ -1,21 +1,23 @@
[package]
-name = "helix-syntax"
+name = "helix-loader"
version = "0.6.0"
+description = "A post-modern text editor."
authors = ["Blaž Hrastnik "]
edition = "2021"
license = "MPL-2.0"
-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]
+anyhow = "1"
+serde = { version = "1.0", features = ["derive"] }
+toml = "0.5"
+etcetera = "0.3"
tree-sitter = "0.20"
libloading = "0.7"
-anyhow = "1"
+once_cell = "1.9"
-[build-dependencies]
+# cloning/compiling tree-sitter grammars
cc = { version = "1" }
threadpool = { version = "1.0" }
-anyhow = "1"
diff --git a/helix-loader/build.rs b/helix-loader/build.rs
new file mode 100644
index 000000000..e0ebd1c48
--- /dev/null
+++ b/helix-loader/build.rs
@@ -0,0 +1,6 @@
+fn main() {
+ println!(
+ "cargo:rustc-env=BUILD_TARGET={}",
+ std::env::var("TARGET").unwrap()
+ );
+}
diff --git a/helix-loader/src/grammar.rs b/helix-loader/src/grammar.rs
new file mode 100644
index 000000000..f0c5ea282
--- /dev/null
+++ b/helix-loader/src/grammar.rs
@@ -0,0 +1,391 @@
+use anyhow::{anyhow, Context, Result};
+use libloading::{Library, Symbol};
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::time::SystemTime;
+use std::{
+ collections::HashSet,
+ path::{Path, PathBuf},
+ process::Command,
+ sync::mpsc::channel,
+};
+use tree_sitter::Language;
+
+#[cfg(unix)]
+const DYLIB_EXTENSION: &str = "so";
+
+#[cfg(windows)]
+const DYLIB_EXTENSION: &str = "dll";
+
+#[derive(Debug, Serialize, Deserialize)]
+struct Configuration {
+ #[serde(rename = "use-grammars")]
+ pub grammar_selection: Option,
+ pub grammar: Vec,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase", untagged)]
+pub enum GrammarSelection {
+ Only { only: HashSet },
+ Except { except: HashSet },
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct GrammarConfiguration {
+ #[serde(rename = "name")]
+ pub grammar_id: String,
+ pub source: GrammarSource,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase", untagged)]
+pub enum GrammarSource {
+ Local {
+ path: String,
+ },
+ Git {
+ #[serde(rename = "git")]
+ remote: String,
+ #[serde(rename = "rev")]
+ revision: String,
+ subpath: Option,
+ },
+}
+
+const BUILD_TARGET: &str = env!("BUILD_TARGET");
+const REMOTE_NAME: &str = "origin";
+
+pub fn get_language(name: &str) -> Result {
+ let name = name.to_ascii_lowercase();
+ let mut library_path = crate::runtime_dir().join("grammars").join(&name);
+ 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_{}", name.replace('-', "_"));
+ let language = unsafe {
+ let language_fn: Symbol 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)
+}
+
+pub fn fetch_grammars() -> Result<()> {
+ // We do not need to fetch local grammars.
+ let mut grammars = get_grammar_configs()?;
+ grammars.retain(|grammar| !matches!(grammar.source, GrammarSource::Local { .. }));
+
+ run_parallel(grammars, fetch_grammar, "fetch")
+}
+
+pub fn build_grammars() -> Result<()> {
+ run_parallel(get_grammar_configs()?, build_grammar, "build")
+}
+
+// Returns the set of grammar configurations the user requests.
+// Grammars are configured in the default and user `languages.toml` and are
+// merged. The `grammar_selection` key of the config is then used to filter
+// down all grammars into a subset of the user's choosing.
+fn get_grammar_configs() -> Result> {
+ let config: Configuration = crate::user_lang_config()
+ .context("Could not parse languages.toml")?
+ .try_into()?;
+
+ let grammars = match config.grammar_selection {
+ Some(GrammarSelection::Only { only: selections }) => config
+ .grammar
+ .into_iter()
+ .filter(|grammar| selections.contains(&grammar.grammar_id))
+ .collect(),
+ Some(GrammarSelection::Except { except: rejections }) => config
+ .grammar
+ .into_iter()
+ .filter(|grammar| !rejections.contains(&grammar.grammar_id))
+ .collect(),
+ None => config.grammar,
+ };
+
+ Ok(grammars)
+}
+
+fn run_parallel(grammars: Vec, job: F, action: &'static str) -> Result<()>
+where
+ F: Fn(GrammarConfiguration) -> Result<()> + std::marker::Send + 'static + Copy,
+{
+ let pool = threadpool::Builder::new().build();
+ let (tx, rx) = channel();
+
+ for grammar in grammars {
+ let tx = tx.clone();
+
+ pool.execute(move || {
+ tx.send(job(grammar)).unwrap();
+ });
+ }
+
+ drop(tx);
+
+ // TODO: print all failures instead of the first one found.
+ rx.iter()
+ .find(|result| result.is_err())
+ .map(|err| err.with_context(|| format!("Failed to {} some grammar(s)", action)))
+ .unwrap_or(Ok(()))
+}
+
+fn fetch_grammar(grammar: GrammarConfiguration) -> Result<()> {
+ if let GrammarSource::Git {
+ remote, revision, ..
+ } = grammar.source
+ {
+ let grammar_dir = crate::runtime_dir()
+ .join("grammars/sources")
+ .join(&grammar.grammar_id);
+
+ fs::create_dir_all(&grammar_dir).context(format!(
+ "Could not create grammar directory {:?}",
+ grammar_dir
+ ))?;
+
+ // create the grammar dir contains a git directory
+ if !grammar_dir.join(".git").is_dir() {
+ git(&grammar_dir, ["init"])?;
+ }
+
+ // ensure the remote matches the configured remote
+ if get_remote_url(&grammar_dir).map_or(true, |s| s != remote) {
+ set_remote(&grammar_dir, &remote)?;
+ }
+
+ // ensure the revision matches the configured revision
+ if get_revision(&grammar_dir).map_or(true, |s| s != revision) {
+ // Fetch the exact revision from the remote.
+ // Supported by server-side git since v2.5.0 (July 2015),
+ // enabled by default on major git hosts.
+ git(
+ &grammar_dir,
+ ["fetch", "--depth", "1", REMOTE_NAME, &revision],
+ )?;
+ git(&grammar_dir, ["checkout", &revision])?;
+
+ println!(
+ "Grammar '{}' checked out at '{}'.",
+ grammar.grammar_id, revision
+ );
+ } else {
+ println!("Grammar '{}' is already up to date.", grammar.grammar_id);
+ }
+ }
+
+ Ok(())
+}
+
+// Sets the remote for a repository to the given URL, creating the remote if
+// it does not yet exist.
+fn set_remote(repository_dir: &Path, remote_url: &str) -> Result {
+ git(
+ repository_dir,
+ ["remote", "set-url", REMOTE_NAME, remote_url],
+ )
+ .or_else(|_| git(repository_dir, ["remote", "add", REMOTE_NAME, remote_url]))
+}
+
+fn get_remote_url(repository_dir: &Path) -> Option {
+ git(repository_dir, ["remote", "get-url", REMOTE_NAME]).ok()
+}
+
+fn get_revision(repository_dir: &Path) -> Option {
+ git(repository_dir, ["rev-parse", "HEAD"]).ok()
+}
+
+// A wrapper around 'git' commands which returns stdout in success and a
+// helpful error message showing the command, stdout, and stderr in error.
+fn git(repository_dir: &Path, args: I) -> Result
+where
+ I: IntoIterator
- ,
+ S: AsRef,
+{
+ let output = Command::new("git")
+ .args(args)
+ .current_dir(repository_dir)
+ .output()?;
+
+ if output.status.success() {
+ Ok(String::from_utf8_lossy(&output.stdout)
+ .trim_end()
+ .to_owned())
+ } else {
+ // TODO: figure out how to display the git command using `args`
+ Err(anyhow!(
+ "Git command failed.\nStdout: {}\nStderr: {}",
+ String::from_utf8_lossy(&output.stdout),
+ String::from_utf8_lossy(&output.stderr),
+ ))
+ }
+}
+
+fn build_grammar(grammar: GrammarConfiguration) -> Result<()> {
+ let grammar_dir = if let GrammarSource::Local { path } = &grammar.source {
+ PathBuf::from(&path)
+ } else {
+ crate::runtime_dir()
+ .join("grammars/sources")
+ .join(&grammar.grammar_id)
+ };
+
+ let grammar_dir_entries = grammar_dir.read_dir().with_context(|| {
+ format!(
+ "Failed to read directory {:?}. Did you use 'hx --grammar fetch'?",
+ grammar_dir
+ )
+ })?;
+
+ if grammar_dir_entries.count() == 0 {
+ return Err(anyhow!(
+ "Directory {:?} is empty. Did you use 'hx --grammar fetch'?",
+ grammar_dir
+ ));
+ };
+
+ let path = match &grammar.source {
+ GrammarSource::Git {
+ subpath: Some(subpath),
+ ..
+ } => grammar_dir.join(subpath),
+ _ => grammar_dir,
+ }
+ .join("src");
+
+ build_tree_sitter_library(&path, grammar)
+}
+
+fn build_tree_sitter_library(src_path: &Path, grammar: GrammarConfiguration) -> Result<()> {
+ let header_path = src_path;
+ 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 = crate::runtime_dir().join("grammars");
+ let mut library_path = parser_lib_path.join(&grammar.grammar_id);
+ library_path.set_extension(DYLIB_EXTENSION);
+
+ let recompile = needs_recompile(&library_path, &parser_path, &scanner_path)
+ .context("Failed to compare source and binary timestamps")?;
+
+ if !recompile {
+ println!("Grammar '{}' is already built.", grammar.grammar_id);
+ return Ok(());
+ }
+
+ println!("Building grammar '{}'", grammar.grammar_id);
+
+ let mut config = cc::Build::new();
+ config
+ .cpp(true)
+ .opt_level(3)
+ .cargo_metadata(false)
+ .host(BUILD_TARGET)
+ .target(BUILD_TARGET);
+ 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")
+ .arg("/utf-8");
+ 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("-O3");
+ 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);
+ if cfg!(all(unix, not(target_os = "macos"))) {
+ command.arg("-Wl,-z,relro,-z,now");
+ }
+ }
+
+ let output = command.output().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,
+) -> Result {
+ 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 mtime(path: &Path) -> Result {
+ Ok(fs::metadata(path)?.modified()?)
+}
+
+/// Gives the contents of a file from a language's `runtime/queries/`
+/// directory
+pub fn load_runtime_file(language: &str, filename: &str) -> Result {
+ let path = crate::RUNTIME_DIR
+ .join("queries")
+ .join(language)
+ .join(filename);
+ std::fs::read_to_string(&path)
+}
diff --git a/helix-loader/src/lib.rs b/helix-loader/src/lib.rs
new file mode 100644
index 000000000..a2c4d96f0
--- /dev/null
+++ b/helix-loader/src/lib.rs
@@ -0,0 +1,161 @@
+pub mod grammar;
+
+use etcetera::base_strategy::{choose_base_strategy, BaseStrategy};
+
+pub static RUNTIME_DIR: once_cell::sync::Lazy =
+ once_cell::sync::Lazy::new(runtime_dir);
+
+pub fn runtime_dir() -> std::path::PathBuf {
+ 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
+ let strategy = choose_base_strategy().expect("Unable to find the config directory!");
+ let mut path = strategy.config_dir();
+ path.push("helix");
+ path
+}
+
+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 fn config_file() -> std::path::PathBuf {
+ config_dir().join("config.toml")
+}
+
+pub fn lang_config_file() -> std::path::PathBuf {
+ config_dir().join("languages.toml")
+}
+
+pub fn log_file() -> std::path::PathBuf {
+ cache_dir().join("helix.log")
+}
+
+/// Default bultin-in languages.toml.
+pub fn default_lang_config() -> toml::Value {
+ toml::from_slice(include_bytes!("../../languages.toml"))
+ .expect("Could not parse bultin-in languages.toml to valid toml")
+}
+
+/// User configured languages.toml file, merged with the default config.
+pub fn user_lang_config() -> Result {
+ let def_lang_conf = default_lang_config();
+ let data = std::fs::read(crate::config_dir().join("languages.toml"));
+ let user_lang_conf = match data {
+ Ok(raw) => {
+ let value = toml::from_slice(&raw)?;
+ merge_toml_values(def_lang_conf, value)
+ }
+ Err(_) => def_lang_conf,
+ };
+
+ Ok(user_lang_conf)
+}
+
+// right overrides left
+pub fn merge_toml_values(left: toml::Value, right: toml::Value) -> toml::Value {
+ use toml::Value;
+
+ fn get_name(v: &Value) -> Option<&str> {
+ v.get("name").and_then(Value::as_str)
+ }
+
+ match (left, right) {
+ (Value::Array(mut left_items), Value::Array(right_items)) => {
+ left_items.reserve(right_items.len());
+ for rvalue in right_items {
+ let lvalue = get_name(&rvalue)
+ .and_then(|rname| left_items.iter().position(|v| get_name(v) == Some(rname)))
+ .map(|lpos| left_items.remove(lpos));
+ let mvalue = match lvalue {
+ Some(lvalue) => merge_toml_values(lvalue, rvalue),
+ None => rvalue,
+ };
+ left_items.push(mvalue);
+ }
+ Value::Array(left_items)
+ }
+ (Value::Table(mut left_map), Value::Table(right_map)) => {
+ for (rname, rvalue) in right_map {
+ match left_map.remove(&rname) {
+ Some(lvalue) => {
+ let merged_value = merge_toml_values(lvalue, rvalue);
+ left_map.insert(rname, merged_value);
+ }
+ None => {
+ left_map.insert(rname, rvalue);
+ }
+ }
+ }
+ Value::Table(left_map)
+ }
+ // Catch everything else we didn't handle, and use the right value
+ (_, value) => value,
+ }
+}
+
+#[cfg(test)]
+mod merge_toml_tests {
+ use super::merge_toml_values;
+
+ #[test]
+ fn language_tomls() {
+ use toml::Value;
+
+ const USER: &str = "
+ [[language]]
+ name = \"nix\"
+ test = \"bbb\"
+ indent = { tab-width = 4, unit = \" \", test = \"aaa\" }
+ ";
+
+ let base: Value = toml::from_slice(include_bytes!("../../languages.toml"))
+ .expect("Couldn't parse built-in languages config");
+ let user: Value = toml::from_str(USER).unwrap();
+
+ let merged = merge_toml_values(base, user);
+ let languages = merged.get("language").unwrap().as_array().unwrap();
+ let nix = languages
+ .iter()
+ .find(|v| v.get("name").unwrap().as_str().unwrap() == "nix")
+ .unwrap();
+ let nix_indent = nix.get("indent").unwrap();
+
+ // We changed tab-width and unit in indent so check them if they are the new values
+ assert_eq!(
+ nix_indent.get("tab-width").unwrap().as_integer().unwrap(),
+ 4
+ );
+ assert_eq!(nix_indent.get("unit").unwrap().as_str().unwrap(), " ");
+ // We added a new keys, so check them
+ assert_eq!(nix.get("test").unwrap().as_str().unwrap(), "bbb");
+ assert_eq!(nix_indent.get("test").unwrap().as_str().unwrap(), "aaa");
+ // We didn't change comment-token so it should be same
+ assert_eq!(nix.get("comment-token").unwrap().as_str().unwrap(), "#");
+ }
+}
diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml
index 39b537063..755f49b5c 100644
--- a/helix-lsp/Cargo.toml
+++ b/helix-lsp/Cargo.toml
@@ -23,5 +23,6 @@ lsp-types = { version = "0.92", features = ["proposed"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
thiserror = "1.0"
-tokio = { version = "1.16", features = ["rt", "rt-multi-thread", "io-util", "io-std", "time", "process", "macros", "fs", "parking_lot", "sync"] }
+tokio = { version = "1.17", features = ["rt", "rt-multi-thread", "io-util", "io-std", "time", "process", "macros", "fs", "parking_lot", "sync"] }
tokio-stream = "0.1.8"
+which = "4.2"
diff --git a/helix-lsp/src/client.rs b/helix-lsp/src/client.rs
index 15cbca0eb..1ce5158be 100644
--- a/helix-lsp/src/client.rs
+++ b/helix-lsp/src/client.rs
@@ -43,6 +43,9 @@ impl Client {
root_markers: Vec,
id: usize,
) -> Result<(Self, UnboundedReceiver<(usize, Call)>, Arc)> {
+ // Resolve path to the binary
+ let cmd = which::which(cmd).map_err(|err| anyhow::anyhow!(err))?;
+
let process = Command::new(cmd)
.args(args)
.stdin(Stdio::piped())
@@ -110,6 +113,10 @@ impl Client {
self.offset_encoding
}
+ pub fn config(&self) -> Option<&Value> {
+ self.config.as_ref()
+ }
+
/// Execute a RPC request on the language server.
async fn request(&self, params: R::Params) -> Result
where
@@ -243,6 +250,13 @@ impl Client {
root_uri: root,
initialization_options: self.config.clone(),
capabilities: lsp::ClientCapabilities {
+ workspace: Some(lsp::WorkspaceClientCapabilities {
+ configuration: Some(true),
+ did_change_configuration: Some(lsp::DynamicRegistrationClientCapabilities {
+ dynamic_registration: Some(false),
+ }),
+ ..Default::default()
+ }),
text_document: Some(lsp::TextDocumentClientCapabilities {
completion: Some(lsp::CompletionClientCapabilities {
completion_item: Some(lsp::CompletionItemCapability {
@@ -327,6 +341,16 @@ impl Client {
self.exit().await
}
+ // -------------------------------------------------------------------------------------------
+ // Workspace
+ // -------------------------------------------------------------------------------------------
+
+ pub fn did_change_configuration(&self, settings: Value) -> impl Future