diff --git a/Cargo.lock b/Cargo.lock
index 2aedb848..24c277e1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -342,6 +342,7 @@ version = "0.2.0"
dependencies = [
"anyhow",
"crossterm",
+ "futures-util",
"helix-core",
"helix-lsp",
"helix-tui",
@@ -672,9 +673,9 @@ checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
[[package]]
name = "ropey"
-version = "1.2.0"
+version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f3ef16589fdbb3e8fbce3dca944c08e61f39c7f16064b21a257d68ea911a83"
+checksum = "e4b1996ad82fb6b8ac0711329432d80aa1ad5d70a0fe6edd1a9cf6fd2375fbb2"
dependencies = [
"smallvec",
]
diff --git a/book/src/SUMMARY.md b/book/src/SUMMARY.md
index 474c2e70..3ea1fb9a 100644
--- a/book/src/SUMMARY.md
+++ b/book/src/SUMMARY.md
@@ -4,4 +4,5 @@
- [Usage](./usage.md)
- [Configuration](./configuration.md)
- [Keymap](./keymap.md)
+ - [Key Remapping](./remapping.md)
- [Hooks](./hooks.md)
diff --git a/book/src/configuration.md b/book/src/configuration.md
index 649aa21f..51a08e03 100644
--- a/book/src/configuration.md
+++ b/book/src/configuration.md
@@ -1,5 +1,12 @@
# Configuration
+## LSP
+
+To disable language server progress report from being displayed in the status bar add this option to your `config.toml`:
+```toml
+lsp-progress = false
+```
+
## Theme
Use a custom theme by placing a theme.toml in your config directory (i.e ~/.config/helix/theme.toml). The default theme.toml can be found [here](https://github.com/helix-editor/helix/blob/master/theme.toml), and user submitted themes [here](https://github.com/helix-editor/helix/blob/master/contrib/themes).
@@ -32,11 +39,11 @@ Possible modifiers:
| `dim` |
| `italic` |
| `underlined` |
-| `slow\_blink` |
-| `rapid\_blink` |
+| `slow_blink` |
+| `rapid_blink` |
| `reversed` |
| `hidden` |
-| `crossed\_out` |
+| `crossed_out` |
Possible keys:
@@ -87,3 +94,4 @@ Possible keys:
These keys match [tree-sitter scopes](https://tree-sitter.github.io/tree-sitter/syntax-highlighting#theme). We half-follow the common scopes from [macromates language grammars](https://macromates.com/manual/en/language_grammars) with some differences.
For a given highlight produced, styling will be determined based on the longest matching theme key. So it's enough to provide function to highlight `function.macro` and `function.builtin` as well, but you can use more specific scopes to highlight specific cases differently.
+
diff --git a/book/src/install.md b/book/src/install.md
index 0a08af8c..e81034ce 100644
--- a/book/src/install.md
+++ b/book/src/install.md
@@ -4,9 +4,12 @@ We provide pre-built binaries on the [GitHub Releases page](https://github.com/h
## OSX
-TODO: brew tap
+A Homebrew tap is available:
-Please use a pre-built binary release for the time being.
+```
+brew tap helix-editor/helix
+brew install helix
+```
## Linux
diff --git a/book/src/remapping.md b/book/src/remapping.md
new file mode 100644
index 00000000..610d5179
--- /dev/null
+++ b/book/src/remapping.md
@@ -0,0 +1,48 @@
+# Key Remapping
+
+One-way key remapping is temporarily supported via a simple TOML configuration
+file. (More powerful solutions such as rebinding via commands will be
+available in the feature).
+
+To remap keys, write a `config.toml` file in your `helix` configuration
+directory (default `~/.config/helix` in Linux systems) with a structure like
+this:
+
+```toml
+# At most one section each of 'keys.normal', 'keys.insert' and 'keys.select'
+[keys.normal]
+a = "move_char_left" # Maps the 'a' key to the move_char_left command
+w = "move_line_up" # Maps the 'w' key move_line_up
+C-S-esc = "select_line" # Maps Control-Shift-Escape to select_line
+
+[keys.insert]
+A-x = "normal_mode" # Maps Alt-X to enter normal mode
+```
+
+Control, Shift and Alt modifiers are encoded respectively with the prefixes
+`C-`, `S-` and `A-`. Special keys are encoded as follows:
+
+* Backspace => "backspace"
+* Space => "space"
+* Return/Enter => "ret"
+* < => "lt"
+* \> => "gt"
+* \+ => "plus"
+* \- => "minus"
+* ; => "semicolon"
+* % => "percent"
+* Left => "left"
+* Right => "right"
+* Up => "up"
+* Home => "home"
+* End => "end"
+* Page Up => "pageup"
+* Page Down => "pagedown"
+* Tab => "tab"
+* Back Tab => "backtab"
+* Delete => "del"
+* Insert => "ins"
+* Null => "null"
+* Escape => "esc"
+
+Commands can be found in the source code at `../../helix-term/src/commands.rs`
diff --git a/contrib/themes/bogster.toml b/contrib/themes/bogster.toml
index 205e464c..43b422f3 100644
--- a/contrib/themes/bogster.toml
+++ b/contrib/themes/bogster.toml
@@ -31,7 +31,8 @@
"ui.background" = { bg = "#161c23" }
"ui.linenr" = { fg = "#415367" }
"ui.linenr.selected" = { fg = "#e5ded6" } # TODO
-"ui.statusline" = { bg = "#232d38" }
+"ui.statusline" = { fg = "#e5ded6", bg = "#232d38" }
+"ui.statusline.inactive" = { fg = "#c6b8ad", bg = "#232d38" }
"ui.popup" = { bg = "#232d38" }
"ui.window" = { bg = "#232d38" }
"ui.help" = { bg = "#232d38", fg = "#e5ded6" }
@@ -39,7 +40,7 @@
"ui.text" = { fg = "#e5ded6" }
"ui.text.focus" = { fg = "#e5ded6", modifiers= ["bold"] }
-"ui.selection" = { bg = "#540099" }
+"ui.selection" = { bg = "#313f4e" }
"ui.menu.selected" = { fg = "#e5ded6", bg = "#313f4e" }
"warning" = "#dc7759"
diff --git a/contrib/themes/ingrid.toml b/contrib/themes/ingrid.toml
index da333fb8..d32a89d1 100644
--- a/contrib/themes/ingrid.toml
+++ b/contrib/themes/ingrid.toml
@@ -31,7 +31,8 @@
"ui.background" = { bg = "#FFFCFD" }
"ui.linenr" = { fg = "#bbbbbb" }
"ui.linenr.selected" = { fg = "#F3EAE9" } # TODO
-"ui.statusline" = { bg = "#F3EAE9" }
+"ui.statusline" = { fg = "#250E07", bg = "#F3EAE9" }
+"ui.statusline.inactive" = { fg = "#7b91b3", bg = "#F3EAE9" }
"ui.popup" = { bg = "#F3EAE9" }
"ui.window" = { bg = "#D8B8B3" }
"ui.help" = { bg = "#D8B8B3", fg = "#250E07" }
diff --git a/contrib/themes/onedark.toml b/contrib/themes/onedark.toml
index 4c13a217..65f26725 100644
--- a/contrib/themes/onedark.toml
+++ b/contrib/themes/onedark.toml
@@ -36,6 +36,7 @@
"ui.linenr.selected" = { fg = "#ABB2BF" }
"ui.popup" = { bg = "#3E4452" }
"ui.statusline" = { fg = "#ABB2BF", bg = "#2C323C" }
+"ui.statusline.inactive" = { fg = "#ABB2Bf", bg = "#2C323C" }
"ui.selection" = { bg = "#3E4452" }
"ui.text" = { fg = "#ABB2BF", bg = "#282C34" }
"ui.text.focus" = { fg = "#ABB2BF", bg = "#2C323C", modifiers = ['bold'] }
diff --git a/flake.lock b/flake.lock
index 23143851..6f80276a 100644
--- a/flake.lock
+++ b/flake.lock
@@ -34,11 +34,11 @@
"helix": {
"flake": false,
"locked": {
- "lastModified": 1623545930,
- "narHash": "sha256-14ASoYbxXHU/qPGctiUymb4fMRCoih9c7YujjxqEkdU=",
+ "lastModified": 1624077450,
+ "narHash": "sha256-gcL519tetuEv0N+oBP8X3U4bPjwcAgzbPdgwW19qeVI=",
"ref": "master",
- "rev": "9640ed1425f2db904fb42cd0c54dc6fbc05ca292",
- "revCount": 821,
+ "rev": "1c2585202145467f0fde7ad9c571e462081c3656",
+ "revCount": 894,
"submodules": true,
"type": "git",
"url": "https://github.com/helix-editor/helix.git"
@@ -58,11 +58,11 @@
"rustOverlay": "rustOverlay"
},
"locked": {
- "lastModified": 1623591988,
- "narHash": "sha256-a8E5LYKxYjHmBWZsFxKnCBVGsWHFEWrKjeAJkplWrfI=",
+ "lastModified": 1624070370,
+ "narHash": "sha256-sfFqfmerCYvk0jDeP1gfuskz7AaqDsgV8aiQrEUGdsc=",
"owner": "yusdacra",
"repo": "nix-cargo-integration",
- "rev": "8254b71eddd4e85173eddc189174b873fad85360",
+ "rev": "85e6c1ba4c0e3e6dec5a7d1f65bcc036d2ea6ae3",
"type": "github"
},
"original": {
@@ -73,11 +73,11 @@
},
"nixpkgs": {
"locked": {
- "lastModified": 1623324058,
- "narHash": "sha256-Jm9GUTXdjXz56gWDKy++EpFfjrBaxqXlLvTLfgEi8lo=",
+ "lastModified": 1623580589,
+ "narHash": "sha256-Ayp1cjXpwFCkAiWUE46rj9APTltsiEBdIs2+cj+U7+c=",
"owner": "nixos",
"repo": "nixpkgs",
- "rev": "432fc2d9a67f92e05438dff5fdc2b39d33f77997",
+ "rev": "fa0326ce5233f7d592271df52c9d0812bec47b84",
"type": "github"
},
"original": {
@@ -98,11 +98,11 @@
"rustOverlay": {
"flake": false,
"locked": {
- "lastModified": 1623550815,
- "narHash": "sha256-RumRrkE6OTJDndHV4qZNZv8kUGnzwRHZQSyzx29r6/g=",
+ "lastModified": 1624069337,
+ "narHash": "sha256-9mTcx7osE4biF2Hm/GU19s1T3+KvphWj4QaUcJh39lU=",
"owner": "oxalica",
"repo": "rust-overlay",
- "rev": "9824f142cbd7bc3e2a92eefbb79addfff8704cd3",
+ "rev": "67dc2a9543a7c24591e6cb102ad0121c3a704aab",
"type": "github"
},
"original": {
diff --git a/helix-core/Cargo.toml b/helix-core/Cargo.toml
index f8e15bd7..13ac35fb 100644
--- a/helix-core/Cargo.toml
+++ b/helix-core/Cargo.toml
@@ -4,17 +4,19 @@ version = "0.2.0"
authors = ["Blaž Hrastnik <blaz@mxxn.io>"]
edition = "2018"
license = "MPL-2.0"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
+description = "Helix editor core editing primitives"
+categories = ["editor"]
+repository = "https://github.com/helix-editor/helix"
+homepage = "https://helix-editor.com"
+include = ["src/**/*", "README.md"]
[features]
embed_runtime = ["rust-embed"]
[dependencies]
-helix-syntax = { path = "../helix-syntax" }
+helix-syntax = { version = "0.2", path = "../helix-syntax" }
-ropey = "1.2"
+ropey = "1.3"
smallvec = "1.4"
tendril = "0.4.2"
unicode-segmentation = "1.7.1"
diff --git a/helix-core/src/lib.rs b/helix-core/src/lib.rs
index c02d41f8..9ac506a6 100644
--- a/helix-core/src/lib.rs
+++ b/helix-core/src/lib.rs
@@ -90,6 +90,8 @@ pub fn cache_dir() -> std::path::PathBuf {
path
}
+pub use etcetera::home_dir;
+
use etcetera::base_strategy::{choose_base_strategy, BaseStrategy};
pub use ropey::{Rope, RopeSlice};
diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml
index bcd18a38..2c1b813d 100644
--- a/helix-lsp/Cargo.toml
+++ b/helix-lsp/Cargo.toml
@@ -4,11 +4,15 @@ version = "0.2.0"
authors = ["Blaž Hrastnik <blaz@mxxn.io>"]
edition = "2018"
license = "MPL-2.0"
+description = "LSP client implementation for Helix project"
+categories = ["editor"]
+repository = "https://github.com/helix-editor/helix"
+homepage = "https://helix-editor.com"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
-helix-core = { path = "../helix-core" }
+helix-core = { version = "0.2", path = "../helix-core" }
anyhow = "1.0"
futures-executor = "0.3"
@@ -20,4 +24,4 @@ serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
thiserror = "1.0"
tokio = { version = "1.6", features = ["full"] }
-tokio-stream = "0.1.6"
\ No newline at end of file
+tokio-stream = "0.1.6"
diff --git a/helix-lsp/src/client.rs b/helix-lsp/src/client.rs
index 9ca708a7..101d2f9b 100644
--- a/helix-lsp/src/client.rs
+++ b/helix-lsp/src/client.rs
@@ -18,6 +18,7 @@ use tokio::{
#[derive(Debug)]
pub struct Client {
+ id: usize,
_process: Child,
server_tx: UnboundedSender<Payload>,
request_counter: AtomicU64,
@@ -26,7 +27,11 @@ pub struct Client {
}
impl Client {
- pub fn start(cmd: &str, args: &[String]) -> Result<(Self, UnboundedReceiver<Call>)> {
+ pub fn start(
+ cmd: &str,
+ args: &[String],
+ id: usize,
+ ) -> Result<(Self, UnboundedReceiver<(usize, Call)>)> {
let process = Command::new(cmd)
.args(args)
.stdin(Stdio::piped())
@@ -43,9 +48,10 @@ impl Client {
let reader = BufReader::new(process.stdout.take().expect("Failed to open stdout"));
let stderr = BufReader::new(process.stderr.take().expect("Failed to open stderr"));
- let (server_rx, server_tx) = Transport::start(reader, writer, stderr);
+ let (server_rx, server_tx) = Transport::start(reader, writer, stderr, id);
let client = Self {
+ id,
_process: process,
server_tx,
request_counter: AtomicU64::new(0),
@@ -59,6 +65,10 @@ impl Client {
Ok((client, server_rx))
}
+ pub fn id(&self) -> usize {
+ self.id
+ }
+
fn next_request_id(&self) -> jsonrpc::Id {
let id = self.request_counter.fetch_add(1, Ordering::Relaxed);
jsonrpc::Id::Num(id)
@@ -165,31 +175,35 @@ impl Client {
}
/// Reply to a language server RPC call.
- pub async fn reply(
+ pub fn reply(
&self,
id: jsonrpc::Id,
result: core::result::Result<Value, jsonrpc::Error>,
- ) -> Result<()> {
+ ) -> impl Future<Output = Result<()>> {
use jsonrpc::{Failure, Output, Success, Version};
- let output = match result {
- Ok(result) => Output::Success(Success {
- jsonrpc: Some(Version::V2),
- id,
- result,
- }),
- Err(error) => Output::Failure(Failure {
- jsonrpc: Some(Version::V2),
- id,
- error,
- }),
- };
+ let server_tx = self.server_tx.clone();
- self.server_tx
- .send(Payload::Response(output))
- .map_err(|e| Error::Other(e.into()))?;
+ async move {
+ let output = match result {
+ Ok(result) => Output::Success(Success {
+ jsonrpc: Some(Version::V2),
+ id,
+ result,
+ }),
+ Err(error) => Output::Failure(Failure {
+ jsonrpc: Some(Version::V2),
+ id,
+ error,
+ }),
+ };
- Ok(())
+ server_tx
+ .send(Payload::Response(output))
+ .map_err(|e| Error::Other(e.into()))?;
+
+ Ok(())
+ }
}
// -------------------------------------------------------------------------------------------
@@ -229,8 +243,7 @@ impl Client {
..Default::default()
}),
window: Some(lsp::WindowClientCapabilities {
- // TODO: temporarily disabled until we implement handling for window/workDoneProgress/create
- // work_done_progress: Some(true),
+ work_done_progress: Some(true),
..Default::default()
}),
..Default::default()
@@ -259,6 +272,21 @@ impl Client {
self.notify::<lsp::notification::Exit>(())
}
+ /// Tries to shut down the language server but returns
+ /// early if server responds with an error.
+ pub async fn shutdown_and_exit(&self) -> Result<()> {
+ self.shutdown().await?;
+ self.exit().await
+ }
+
+ /// Forcefully shuts down the language server ignoring any errors.
+ pub async fn force_shutdown(&self) -> Result<()> {
+ if let Err(e) = self.shutdown().await {
+ log::warn!("language server failed to terminate gracefully - {}", e);
+ }
+ self.exit().await
+ }
+
// -------------------------------------------------------------------------------------------
// Text document
// -------------------------------------------------------------------------------------------
@@ -465,6 +493,7 @@ impl Client {
&self,
text_document: lsp::TextDocumentIdentifier,
position: lsp::Position,
+ work_done_token: Option<lsp::ProgressToken>,
) -> impl Future<Output = Result<Value>> {
// ) -> Result<Vec<lsp::CompletionItem>> {
let params = lsp::CompletionParams {
@@ -473,9 +502,7 @@ impl Client {
position,
},
// TODO: support these tokens by async receiving and updating the choice list
- work_done_progress_params: lsp::WorkDoneProgressParams {
- work_done_token: None,
- },
+ work_done_progress_params: lsp::WorkDoneProgressParams { work_done_token },
partial_result_params: lsp::PartialResultParams {
partial_result_token: None,
},
@@ -490,15 +517,14 @@ impl Client {
&self,
text_document: lsp::TextDocumentIdentifier,
position: lsp::Position,
+ work_done_token: Option<lsp::ProgressToken>,
) -> impl Future<Output = Result<Value>> {
let params = lsp::SignatureHelpParams {
text_document_position_params: lsp::TextDocumentPositionParams {
text_document,
position,
},
- work_done_progress_params: lsp::WorkDoneProgressParams {
- work_done_token: None,
- },
+ work_done_progress_params: lsp::WorkDoneProgressParams { work_done_token },
context: None,
// lsp::SignatureHelpContext
};
@@ -510,15 +536,14 @@ impl Client {
&self,
text_document: lsp::TextDocumentIdentifier,
position: lsp::Position,
+ work_done_token: Option<lsp::ProgressToken>,
) -> impl Future<Output = Result<Value>> {
let params = lsp::HoverParams {
text_document_position_params: lsp::TextDocumentPositionParams {
text_document,
position,
},
- work_done_progress_params: lsp::WorkDoneProgressParams {
- work_done_token: None,
- },
+ work_done_progress_params: lsp::WorkDoneProgressParams { work_done_token },
// lsp::SignatureHelpContext
};
@@ -531,6 +556,7 @@ impl Client {
&self,
text_document: lsp::TextDocumentIdentifier,
options: lsp::FormattingOptions,
+ work_done_token: Option<lsp::ProgressToken>,
) -> anyhow::Result<Vec<lsp::TextEdit>> {
let capabilities = self.capabilities.as_ref().unwrap();
@@ -545,9 +571,7 @@ impl Client {
let params = lsp::DocumentFormattingParams {
text_document,
options,
- work_done_progress_params: lsp::WorkDoneProgressParams {
- work_done_token: None,
- },
+ work_done_progress_params: lsp::WorkDoneProgressParams { work_done_token },
};
let response = self.request::<lsp::request::Formatting>(params).await?;
@@ -560,6 +584,7 @@ impl Client {
text_document: lsp::TextDocumentIdentifier,
range: lsp::Range,
options: lsp::FormattingOptions,
+ work_done_token: Option<lsp::ProgressToken>,
) -> anyhow::Result<Vec<lsp::TextEdit>> {
let capabilities = self.capabilities.as_ref().unwrap();
@@ -575,9 +600,7 @@ impl Client {
text_document,
range,
options,
- work_done_progress_params: lsp::WorkDoneProgressParams {
- work_done_token: None,
- },
+ work_done_progress_params: lsp::WorkDoneProgressParams { work_done_token },
};
let response = self
@@ -596,15 +619,14 @@ impl Client {
&self,
text_document: lsp::TextDocumentIdentifier,
position: lsp::Position,
+ work_done_token: Option<lsp::ProgressToken>,
) -> impl Future<Output = Result<Value>> {
let params = lsp::GotoDefinitionParams {
text_document_position_params: lsp::TextDocumentPositionParams {
text_document,
position,
},
- work_done_progress_params: lsp::WorkDoneProgressParams {
- work_done_token: None,
- },
+ work_done_progress_params: lsp::WorkDoneProgressParams { work_done_token },
partial_result_params: lsp::PartialResultParams {
partial_result_token: None,
},
@@ -617,30 +639,42 @@ impl Client {
&self,
text_document: lsp::TextDocumentIdentifier,
position: lsp::Position,
+ work_done_token: Option<lsp::ProgressToken>,
) -> impl Future<Output = Result<Value>> {
- self.goto_request::<lsp::request::GotoDefinition>(text_document, position)
+ self.goto_request::<lsp::request::GotoDefinition>(text_document, position, work_done_token)
}
pub fn goto_type_definition(
&self,
text_document: lsp::TextDocumentIdentifier,
position: lsp::Position,
+ work_done_token: Option<lsp::ProgressToken>,
) -> impl Future<Output = Result<Value>> {
- self.goto_request::<lsp::request::GotoTypeDefinition>(text_document, position)
+ self.goto_request::<lsp::request::GotoTypeDefinition>(
+ text_document,
+ position,
+ work_done_token,
+ )
}
pub fn goto_implementation(
&self,
text_document: lsp::TextDocumentIdentifier,
position: lsp::Position,
+ work_done_token: Option<lsp::ProgressToken>,
) -> impl Future<Output = Result<Value>> {
- self.goto_request::<lsp::request::GotoImplementation>(text_document, position)
+ self.goto_request::<lsp::request::GotoImplementation>(
+ text_document,
+ position,
+ work_done_token,
+ )
}
pub fn goto_reference(
&self,
text_document: lsp::TextDocumentIdentifier,
position: lsp::Position,
+ work_done_token: Option<lsp::ProgressToken>,
) -> impl Future<Output = Result<Value>> {
let params = lsp::ReferenceParams {
text_document_position: lsp::TextDocumentPositionParams {
@@ -650,9 +684,7 @@ impl Client {
context: lsp::ReferenceContext {
include_declaration: true,
},
- work_done_progress_params: lsp::WorkDoneProgressParams {
- work_done_token: None,
- },
+ work_done_progress_params: lsp::WorkDoneProgressParams { work_done_token },
partial_result_params: lsp::PartialResultParams {
partial_result_token: None,
},
diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs
index cff62492..49d5527f 100644
--- a/helix-lsp/src/lib.rs
+++ b/helix-lsp/src/lib.rs
@@ -13,7 +13,10 @@ use helix_core::syntax::LanguageConfiguration;
use std::{
collections::{hash_map::Entry, HashMap},
- sync::Arc,
+ sync::{
+ atomic::{AtomicUsize, Ordering},
+ Arc,
+ },
};
use serde::{Deserialize, Serialize};
@@ -181,6 +184,30 @@ pub mod util {
}
}
+#[derive(Debug, PartialEq, Clone)]
+pub enum MethodCall {
+ WorkDoneProgressCreate(lsp::WorkDoneProgressCreateParams),
+}
+
+impl MethodCall {
+ pub fn parse(method: &str, params: jsonrpc::Params) -> Option<MethodCall> {
+ use lsp::request::Request;
+ let request = match method {
+ lsp::request::WorkDoneProgressCreate::METHOD => {
+ let params: lsp::WorkDoneProgressCreateParams = params
+ .parse()
+ .expect("Failed to parse WorkDoneCreate params");
+ Self::WorkDoneProgressCreate(params)
+ }
+ _ => {
+ log::warn!("unhandled lsp request: {}", method);
+ return None;
+ }
+ };
+ Some(request)
+ }
+}
+
#[derive(Debug, PartialEq, Clone)]
pub enum Notification {
PublishDiagnostics(lsp::PublishDiagnosticsParams),
@@ -230,9 +257,10 @@ impl Notification {
#[derive(Debug)]
pub struct Registry {
- inner: HashMap<LanguageId, Arc<Client>>,
+ inner: HashMap<LanguageId, (usize, Arc<Client>)>,
- pub incoming: SelectAll<UnboundedReceiverStream<Call>>,
+ counter: AtomicUsize,
+ pub incoming: SelectAll<UnboundedReceiverStream<(usize, Call)>>,
}
impl Default for Registry {
@@ -245,10 +273,18 @@ impl Registry {
pub fn new() -> Self {
Self {
inner: HashMap::new(),
+ counter: AtomicUsize::new(0),
incoming: SelectAll::new(),
}
}
+ pub fn get_by_id(&mut self, id: usize) -> Option<&Client> {
+ self.inner
+ .values()
+ .find(|(client_id, _)| client_id == &id)
+ .map(|(_, client)| client.as_ref())
+ }
+
pub fn get(&mut self, language_config: &LanguageConfiguration) -> Result<Arc<Client>> {
if let Some(config) = &language_config.language_server {
// avoid borrow issues
@@ -256,16 +292,17 @@ impl Registry {
let s_incoming = &mut self.incoming;
match inner.entry(language_config.scope.clone()) {
- Entry::Occupied(language_server) => Ok(language_server.get().clone()),
+ Entry::Occupied(entry) => Ok(entry.get().1.clone()),
Entry::Vacant(entry) => {
// initialize a new client
- let (mut client, incoming) = Client::start(&config.command, &config.args)?;
+ let id = self.counter.fetch_add(1, Ordering::Relaxed);
+ let (mut client, incoming) = Client::start(&config.command, &config.args, id)?;
// TODO: run this async without blocking
futures_executor::block_on(client.initialize())?;
s_incoming.push(UnboundedReceiverStream::new(incoming));
let client = Arc::new(client);
- entry.insert(client.clone());
+ entry.insert((id, client.clone()));
Ok(client)
}
}
@@ -273,6 +310,84 @@ impl Registry {
Err(Error::LspNotDefined)
}
}
+
+ pub fn iter_clients(&self) -> impl Iterator<Item = &Arc<Client>> {
+ self.inner.values().map(|(_, client)| client)
+ }
+}
+
+#[derive(Debug)]
+pub enum ProgressStatus {
+ Created,
+ Started(lsp::WorkDoneProgress),
+}
+
+impl ProgressStatus {
+ pub fn progress(&self) -> Option<&lsp::WorkDoneProgress> {
+ match &self {
+ ProgressStatus::Created => None,
+ ProgressStatus::Started(progress) => Some(&progress),
+ }
+ }
+}
+
+#[derive(Default, Debug)]
+/// Acts as a container for progress reported by language servers. Each server
+/// has a unique id assigned at creation through [`Registry`]. This id is then used
+/// to store the progress in this map.
+pub struct LspProgressMap(HashMap<usize, HashMap<lsp::ProgressToken, ProgressStatus>>);
+
+impl LspProgressMap {
+ pub fn new() -> Self {
+ Self::default()
+ }
+
+ /// Returns a map of all tokens coresponding to the lanaguage server with `id`.
+ pub fn progress_map(&self, id: usize) -> Option<&HashMap<lsp::ProgressToken, ProgressStatus>> {
+ self.0.get(&id)
+ }
+
+ /// Returns last progress status for a given server with `id` and `token`.
+ pub fn progress(&self, id: usize, token: &lsp::ProgressToken) -> Option<&ProgressStatus> {
+ self.0.get(&id).and_then(|values| values.get(token))
+ }
+
+ /// Checks if progress `token` for server with `id` is created.
+ pub fn is_created(&mut self, id: usize, token: &lsp::ProgressToken) -> bool {
+ self.0
+ .get(&id)
+ .map(|values| values.get(token).is_some())
+ .unwrap_or_default()
+ }
+
+ pub fn create(&mut self, id: usize, token: lsp::ProgressToken) {
+ self.0
+ .entry(id)
+ .or_default()
+ .insert(token, ProgressStatus::Created);
+ }
+
+ /// Ends the progress by removing the `token` from server with `id`, if removed returns the value.
+ pub fn end_progress(
+ &mut self,
+ id: usize,
+ token: &lsp::ProgressToken,
+ ) -> Option<ProgressStatus> {
+ self.0.get_mut(&id).and_then(|vals| vals.remove(token))
+ }
+
+ /// Updates the progess of `token` for server with `id` to `status`, returns the value replaced or `None`.
+ pub fn update(
+ &mut self,
+ id: usize,
+ token: lsp::ProgressToken,
+ status: lsp::WorkDoneProgress,
+ ) -> Option<ProgressStatus> {
+ self.0
+ .entry(id)
+ .or_default()
+ .insert(token, ProgressStatus::Started(status))
+ }
}
// REGISTRY = HashMap<LanguageId, Lazy/OnceCell<Arc<RwLock<Client>>>
diff --git a/helix-lsp/src/transport.rs b/helix-lsp/src/transport.rs
index e8068323..df55bbf6 100644
--- a/helix-lsp/src/transport.rs
+++ b/helix-lsp/src/transport.rs
@@ -1,4 +1,5 @@
use crate::Result;
+use anyhow::Context;
use jsonrpc_core as jsonrpc;
use log::{error, info};
use serde::{Deserialize, Serialize};
@@ -33,7 +34,8 @@ enum ServerMessage {
#[derive(Debug)]
pub struct Transport {
- client_tx: UnboundedSender<jsonrpc::Call>,
+ id: usize,
+ client_tx: UnboundedSender<(usize, jsonrpc::Call)>,
client_rx: UnboundedReceiver<Payload>,
pending_requests: HashMap<jsonrpc::Id, Sender<Result<Value>>>,
@@ -48,11 +50,16 @@ impl Transport {
server_stdout: BufReader<ChildStdout>,
server_stdin: BufWriter<ChildStdin>,
server_stderr: BufReader<ChildStderr>,
- ) -> (UnboundedReceiver<jsonrpc::Call>, UnboundedSender<Payload>) {
+ id: usize,
+ ) -> (
+ UnboundedReceiver<(usize, jsonrpc::Call)>,
+ UnboundedSender<Payload>,
+ ) {
let (client_tx, rx) = unbounded_channel();
let (tx, client_rx) = unbounded_channel();
let transport = Self {
+ id,
server_stdout,
server_stdin,
server_stderr,
@@ -84,7 +91,7 @@ impl Transport {
match (parts.next(), parts.next(), parts.next()) {
(Some("Content-Length"), Some(value), None) => {
- content_length = Some(value.parse().unwrap());
+ content_length = Some(value.parse().context("invalid content length")?);
}
(Some(_), Some(_), None) => {}
_ => {
@@ -97,12 +104,12 @@ impl Transport {
}
}
- let content_length = content_length.unwrap();
+ let content_length = content_length.context("missing content length")?;
//TODO: reuse vector
let mut content = vec![0; content_length];
reader.read_exact(&mut content).await?;
- let msg = String::from_utf8(content).unwrap();
+ let msg = String::from_utf8(content).context("invalid utf8 from server")?;
info!("<- {}", msg);
@@ -156,7 +163,9 @@ impl Transport {
match msg {
ServerMessage::Output(output) => self.process_request_response(output).await?,
ServerMessage::Call(call) => {
- self.client_tx.send(call).unwrap();
+ self.client_tx
+ .send((self.id, call))
+ .context("failed to send a message to server")?;
// let notification = Notification::parse(&method, params);
}
};
diff --git a/helix-syntax/Cargo.toml b/helix-syntax/Cargo.toml
index 472b56c0..3c71fc34 100644
--- a/helix-syntax/Cargo.toml
+++ b/helix-syntax/Cargo.toml
@@ -4,8 +4,11 @@ version = "0.2.0"
authors = ["Blaž Hrastnik <blaz@mxxn.io>"]
edition = "2018"
license = "MPL-2.0"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+description = "Tree-sitter grammars support"
+categories = ["editor"]
+repository = "https://github.com/helix-editor/helix"
+homepage = "https://helix-editor.com"
+include = ["src/**/*", "languages/**/*", "build.rs", "!**/docs/**/*", "!**/test/**/*", "!**/examples/**/*", "!**/build/**/*"]
[dependencies]
tree-sitter = "0.19"
diff --git a/helix-term/Cargo.toml b/helix-term/Cargo.toml
index cda238fe..385af64c 100644
--- a/helix-term/Cargo.toml
+++ b/helix-term/Cargo.toml
@@ -5,6 +5,10 @@ description = "A post-modern text editor."
authors = ["Blaž Hrastnik <blaz@mxxn.io>"]
edition = "2018"
license = "MPL-2.0"
+categories = ["editor", "command-line-utilities"]
+repository = "https://github.com/helix-editor/helix"
+homepage = "https://helix-editor.com"
+include = ["src/**/*", "README.md"]
[package.metadata.nix]
build = true
@@ -18,9 +22,9 @@ name = "hx"
path = "src/main.rs"
[dependencies]
-helix-core = { path = "../helix-core" }
-helix-view = { path = "../helix-view", features = ["term"]}
-helix-lsp = { path = "../helix-lsp"}
+helix-core = { version = "0.2", path = "../helix-core" }
+helix-view = { version = "0.2", path = "../helix-view", features = ["term"]}
+helix-lsp = { version = "0.2", path = "../helix-lsp"}
anyhow = "1"
once_cell = "1.8"
diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs
index 3d043441..ce43808a 100644
--- a/helix-term/src/application.rs
+++ b/helix-term/src/application.rs
@@ -1,7 +1,7 @@
-use helix_lsp::lsp;
+use helix_lsp::{lsp, LspProgressMap};
use helix_view::{document::Mode, Document, Editor, Theme, View};
-use crate::{args::Args, compositor::Compositor, ui};
+use crate::{args::Args, compositor::Compositor, config::Config, ui};
use log::{error, info};
@@ -9,6 +9,7 @@ use std::{
future::Future,
io::{self, stdout, Stdout, Write},
path::PathBuf,
+ pin::Pin,
sync::Arc,
time::Duration,
};
@@ -22,8 +23,7 @@ use crossterm::{
use tui::layout::Rect;
-use futures_util::stream::FuturesUnordered;
-use std::pin::Pin;
+use futures_util::{future, stream::FuturesUnordered};
type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
pub type LspCallback =
@@ -37,16 +37,20 @@ pub struct Application {
editor: Editor,
callbacks: LspCallbacks,
+
+ lsp_progress: LspProgressMap,
+ lsp_progress_enabled: bool,
}
impl Application {
- pub fn new(mut args: Args) -> Result<Self, Error> {
+ pub fn new(mut args: Args, config: Config) -> Result<Self, Error> {
use helix_view::editor::Action;
let mut compositor = Compositor::new()?;
let size = compositor.size();
let mut editor = Editor::new(size);
- compositor.push(Box::new(ui::EditorView::new()));
+ let mut editor_view = Box::new(ui::EditorView::new(config.keys));
+ compositor.push(editor_view);
if !args.files.is_empty() {
let first = &args.files[0]; // we know it's not empty
@@ -73,6 +77,8 @@ impl Application {
editor,
callbacks: FuturesUnordered::new(),
+ lsp_progress: LspProgressMap::new(),
+ lsp_progress_enabled: config.global.lsp_progress,
};
Ok(app)
@@ -108,8 +114,8 @@ impl Application {
event = reader.next() => {
self.handle_terminal_events(event)
}
- Some(call) = self.editor.language_servers.incoming.next() => {
- self.handle_language_server_message(call).await
+ Some((id, call)) = self.editor.language_servers.incoming.next() => {
+ self.handle_language_server_message(call, id).await
}
Some(callback) = &mut self.callbacks.next() => {
self.handle_language_server_callback(callback)
@@ -152,8 +158,12 @@ impl Application {
}
}
- pub async fn handle_language_server_message(&mut self, call: helix_lsp::Call) {
- use helix_lsp::{Call, Notification};
+ pub async fn handle_language_server_message(
+ &mut self,
+ call: helix_lsp::Call,
+ server_id: usize,
+ ) {
+ use helix_lsp::{Call, MethodCall, Notification};
match call {
Call::Notification(helix_lsp::jsonrpc::Notification { method, params, .. }) => {
let notification = match Notification::parse(&method, params) {
@@ -241,64 +251,130 @@ impl Application {
log::warn!("unhandled window/logMessage: {:?}", params);
}
Notification::ProgressMessage(params) => {
- let token = match params.token {
- lsp::NumberOrString::Number(n) => n.to_string(),
- lsp::NumberOrString::String(s) => s,
- };
- let msg = {
- let lsp::ProgressParamsValue::WorkDone(work) = params.value;
- let parts = match work {
- lsp::WorkDoneProgress::Begin(lsp::WorkDoneProgressBegin {
- title,
- message,
- percentage,
- ..
- }) => (Some(title), message, percentage.map(|n| n.to_string())),
- lsp::WorkDoneProgress::Report(lsp::WorkDoneProgressReport {
- message,
- percentage,
- ..
- }) => (None, message, percentage.map(|n| n.to_string())),
- lsp::WorkDoneProgress::End(lsp::WorkDoneProgressEnd {
- message,
- }) => {
- if let Some(message) = message {
- (None, Some(message), None)
- } else {
- self.editor.clear_status();
- return;
- }
+ let lsp::ProgressParams { token, value } = params;
+
+ let lsp::ProgressParamsValue::WorkDone(work) = value;
+ let parts = match &work {
+ lsp::WorkDoneProgress::Begin(lsp::WorkDoneProgressBegin {
+ title,
+ message,
+ percentage,
+ ..
+ }) => (Some(title), message, percentage),
+ lsp::WorkDoneProgress::Report(lsp::WorkDoneProgressReport {
+ message,
+ percentage,
+ ..
+ }) => (None, message, percentage),
+ lsp::WorkDoneProgress::End(lsp::WorkDoneProgressEnd { message }) => {
+ if message.is_some() {
+ (None, message, &None)
+ } else {
+ self.lsp_progress.end_progress(server_id, &token);
+ self.editor.clear_status();
+ return;
}
- };
- match parts {
- (Some(title), Some(message), Some(percentage)) => {
- format!("{}% {} - {}", percentage, title, message)
- }
- (Some(title), None, Some(percentage)) => {
- format!("{}% {}", percentage, title)
- }
- (Some(title), Some(message), None) => {
- format!("{} - {}", title, message)
- }
- (None, Some(message), Some(percentage)) => {
- format!("{}% {}", percentage, message)
- }
- (Some(title), None, None) => title,
- (None, Some(message), None) => message,
- (None, None, Some(percentage)) => format!("{}%", percentage),
- (None, None, None) => "".into(),
}
};
- let status = format!("[{}] {}", token, msg);
- self.editor.set_status(status);
- self.render();
+ let token_d: &dyn std::fmt::Display = match &token {
+ lsp::NumberOrString::Number(n) => n,
+ lsp::NumberOrString::String(s) => s,
+ };
+
+ let status = match parts {
+ (Some(title), Some(message), Some(percentage)) => {
+ format!("[{}] {}% {} - {}", token_d, percentage, title, message)
+ }
+ (Some(title), None, Some(percentage)) => {
+ format!("[{}] {}% {}", token_d, percentage, title)
+ }
+ (Some(title), Some(message), None) => {
+ format!("[{}] {} - {}", token_d, title, message)
+ }
+ (None, Some(message), Some(percentage)) => {
+ format!("[{}] {}% {}", token_d, percentage, message)
+ }
+ (Some(title), None, None) => {
+ format!("[{}] {}", token_d, title)
+ }
+ (None, Some(message), None) => {
+ format!("[{}] {}", token_d, message)
+ }
+ (None, None, Some(percentage)) => {
+ format!("[{}] {}%", token_d, percentage)
+ }
+ (None, None, None) => format!("[{}]", token_d),
+ };
+
+ if let lsp::WorkDoneProgress::End(_) = work {
+ self.lsp_progress.end_progress(server_id, &token);
+ } else {
+ self.lsp_progress.update(server_id, token, work);
+ }
+
+ if self.lsp_progress_enabled {
+ self.editor.set_status(status);
+ self.render();
+ }
}
_ => unreachable!(),
}
}
- Call::MethodCall(call) => {
- error!("Method not found {}", call.method);
+ Call::MethodCall(helix_lsp::jsonrpc::MethodCall {
+ method,
+ params,
+ jsonrpc,
+ id,
+ }) => {
+ let call = match MethodCall::parse(&method, params) {
+ Some(call) => call,
+ None => {
+ error!("Method not found {}", method);
+ return;
+ }
+ };
+ match call {
+ MethodCall::WorkDoneProgressCreate(params) => {
+ self.lsp_progress.create(server_id, params.token);
+
+ let doc = self.editor.documents().find(|doc| {
+ doc.language_server()
+ .map(|server| server.id() == server_id)
+ .unwrap_or_default()
+ });
+ match doc {
+ Some(doc) => {
+ // it's ok to unwrap, we check for the language server before
+ let server = doc.language_server().unwrap();
+ tokio::spawn(server.reply(id, Ok(serde_json::Value::Null)));
+ }
+ None => {
+ if let Some(server) =
+ self.editor.language_servers.get_by_id(server_id)
+ {
+ log::warn!(
+ "missing document with language server id `{}`",
+ server_id
+ );
+ tokio::spawn(server.reply(
+ id,
+ Err(helix_lsp::jsonrpc::Error {
+ code: helix_lsp::jsonrpc::ErrorCode::InternalError,
+ message: "document missing".to_string(),
+ data: None,
+ }),
+ ));
+ } else {
+ log::warn!(
+ "can't find language server with id `{}`",
+ server_id
+ );
+ }
+ }
+ }
+ }
+ }
// self.language_server.reply(
// call.id,
// // TODO: make a Into trait that can cast to Err(jsonrpc::Error)
@@ -330,6 +406,8 @@ impl Application {
self.event_loop().await;
+ self.editor.close_language_servers(None).await;
+
// reset cursor shape
write!(stdout, "\x1B[2 q");
diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs
index 463869f6..07d2999b 100644
--- a/helix-term/src/commands.rs
+++ b/helix-term/src/commands.rs
@@ -11,15 +11,18 @@ use helix_core::{
use helix_view::{
document::{IndentStyle, Mode},
+ input::{KeyCode, KeyEvent},
view::{View, PADDING},
Document, DocumentId, Editor, ViewId,
};
+use anyhow::anyhow;
use helix_lsp::{
lsp,
util::{lsp_pos_to_pos, lsp_range_to_range, pos_to_lsp_pos, range_to_lsp_range},
OffsetEncoding,
};
+use insert::*;
use movement::Movement;
use crate::{
@@ -29,15 +32,15 @@ use crate::{
use crate::application::{LspCallbackWrapper, LspCallbacks};
use futures_util::FutureExt;
-use std::future::Future;
+use std::{fmt, future::Future, path::Display, str::FromStr};
use std::{
borrow::Cow,
path::{Path, PathBuf},
};
-use crossterm::event::{KeyCode, KeyEvent};
use once_cell::sync::Lazy;
+use serde::de::{self, Deserialize, Deserializer};
pub struct Context<'a> {
pub selected_register: helix_view::RegisterSelection,
@@ -50,27 +53,6 @@ pub struct Context<'a> {
}
impl<'a> Context<'a> {
- #[inline]
- pub fn view(&mut self) -> &mut View {
- self.editor.view_mut()
- }
-
- #[inline]
- pub fn doc(&mut self) -> &mut Document {
- let id = self.editor.view().doc;
- &mut self.editor.documents[id]
- }
-
- #[inline]
- pub fn current(&mut self) -> (&mut View, &mut Document) {
- self.editor.current()
- }
-
- #[inline]
- pub fn current_with_registers(&mut self) -> (&mut View, &mut Document, &mut Registers) {
- self.editor.current_with_registers()
- }
-
/// Push a new component onto the compositor.
pub fn push_layer(&mut self, mut component: Box<dyn Component>) {
self.callback = Some(Box::new(|compositor: &mut Compositor| {
@@ -107,6 +89,7 @@ impl<'a> Context<'a> {
self.callbacks.push(callback);
}
+ /// Returns 1 if no explicit count was provided
#[inline]
pub fn count(&self) -> usize {
self.count.map_or(1, |v| v.get())
@@ -132,13 +115,189 @@ fn align_view(doc: &Document, view: &mut View, align: Align) {
view.first_line = line.saturating_sub(relative);
}
-/// A command is a function that takes the current state and a count, and does a side-effect on the
-/// state (usually by creating and applying a transaction).
-pub type Command = fn(cx: &mut Context);
+/// A command is composed of a static name, and a function that takes the current state plus a count,
+/// and does a side-effect on the state (usually by creating and applying a transaction).
+#[derive(Copy, Clone)]
+pub struct Command(&'static str, fn(cx: &mut Context));
-pub fn move_char_left(cx: &mut Context) {
+macro_rules! commands {
+ ( $($name:ident),* ) => {
+ $(
+ #[allow(non_upper_case_globals)]
+ pub const $name: Self = Self(stringify!($name), $name);
+ )*
+
+ pub const COMMAND_LIST: &'static [Self] = &[
+ $( Self::$name, )*
+ ];
+ }
+}
+
+impl Command {
+ pub fn execute(&self, cx: &mut Context) {
+ (self.1)(cx);
+ }
+
+ pub fn name(&self) -> &'static str {
+ self.0
+ }
+
+ commands!(
+ move_char_left,
+ move_char_right,
+ move_line_up,
+ move_line_down,
+ move_line_end,
+ move_line_start,
+ move_first_nonwhitespace,
+ move_next_word_start,
+ move_prev_word_start,
+ move_next_word_end,
+ move_file_start,
+ move_file_end,
+ extend_next_word_start,
+ extend_prev_word_start,
+ extend_next_word_end,
+ find_till_char,
+ find_next_char,
+ extend_till_char,
+ extend_next_char,
+ till_prev_char,
+ find_prev_char,
+ extend_till_prev_char,
+ extend_prev_char,
+ extend_first_nonwhitespace,
+ replace,
+ page_up,
+ page_down,
+ half_page_up,
+ half_page_down,
+ extend_char_left,
+ extend_char_right,
+ extend_line_up,
+ extend_line_down,
+ extend_line_end,
+ extend_line_start,
+ select_all,
+ select_regex,
+ split_selection,
+ split_selection_on_newline,
+ search,
+ search_next,
+ extend_search_next,
+ search_selection,
+ select_line,
+ extend_line,
+ delete_selection,
+ change_selection,
+ collapse_selection,
+ flip_selections,
+ insert_mode,
+ append_mode,
+ command_mode,
+ file_picker,
+ buffer_picker,
+ symbol_picker,
+ prepend_to_line,
+ append_to_line,
+ open_below,
+ open_above,
+ normal_mode,
+ goto_mode,
+ select_mode,
+ exit_select_mode,
+ goto_definition,
+ goto_type_definition,
+ goto_implementation,
+ goto_reference,
+ goto_first_diag,
+ goto_last_diag,
+ goto_next_diag,
+ goto_prev_diag,
+ signature_help,
+ insert_tab,
+ insert_newline,
+ delete_char_backward,
+ delete_char_forward,
+ delete_word_backward,
+ undo,
+ redo,
+ yank,
+ replace_with_yanked,
+ paste_after,
+ paste_before,
+ indent,
+ unindent,
+ format_selections,
+ join_selections,
+ keep_selections,
+ keep_primary_selection,
+ save,
+ completion,
+ hover,
+ toggle_comments,
+ expand_selection,
+ match_brackets,
+ jump_forward,
+ jump_backward,
+ window_mode,
+ rotate_view,
+ hsplit,
+ vsplit,
+ wclose,
+ select_register,
+ space_mode,
+ view_mode,
+ left_bracket_mode,
+ right_bracket_mode
+ );
+}
+
+impl fmt::Debug for Command {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let Command(name, _) = self;
+ f.debug_tuple("Command").field(name).finish()
+ }
+}
+
+impl fmt::Display for Command {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let Command(name, _) = self;
+ f.write_str(name)
+ }
+}
+
+impl std::str::FromStr for Command {
+ type Err = anyhow::Error;
+
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ Command::COMMAND_LIST
+ .iter()
+ .copied()
+ .find(|cmd| cmd.0 == s)
+ .ok_or_else(|| anyhow!("No command named '{}'", s))
+ }
+}
+
+impl<'de> Deserialize<'de> for Command {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ let s = String::deserialize(deserializer)?;
+ s.parse().map_err(de::Error::custom)
+ }
+}
+
+impl PartialEq for Command {
+ fn eq(&self, other: &Self) -> bool {
+ self.name() == other.name()
+ }
+}
+
+fn move_char_left(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc.selection(view.id).transform(|range| {
movement::move_horizontally(text, range, Direction::Backward, count, Movement::Move)
@@ -146,9 +305,9 @@ pub fn move_char_left(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn move_char_right(cx: &mut Context) {
+fn move_char_right(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc.selection(view.id).transform(|range| {
movement::move_horizontally(text, range, Direction::Forward, count, Movement::Move)
@@ -156,9 +315,9 @@ pub fn move_char_right(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn move_line_up(cx: &mut Context) {
+fn move_line_up(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc.selection(view.id).transform(|range| {
movement::move_vertically(text, range, Direction::Backward, count, Movement::Move)
@@ -166,9 +325,9 @@ pub fn move_line_up(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn move_line_down(cx: &mut Context) {
+fn move_line_down(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc.selection(view.id).transform(|range| {
movement::move_vertically(text, range, Direction::Forward, count, Movement::Move)
@@ -176,8 +335,8 @@ pub fn move_line_down(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn move_line_end(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn move_line_end(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let selection = doc.selection(view.id).transform(|range| {
let text = doc.text();
@@ -195,8 +354,8 @@ pub fn move_line_end(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn move_line_start(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn move_line_start(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let selection = doc.selection(view.id).transform(|range| {
let text = doc.text();
@@ -210,8 +369,8 @@ pub fn move_line_start(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn move_first_nonwhitespace(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn move_first_nonwhitespace(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let selection = doc.selection(view.id).transform(|range| {
let text = doc.text();
@@ -232,9 +391,9 @@ pub fn move_first_nonwhitespace(cx: &mut Context) {
// Range::new(if Move { pos } if Extend { range.anchor }, pos)
// since these all really do the same thing
-pub fn move_next_word_start(cx: &mut Context) {
+fn move_next_word_start(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc
@@ -244,9 +403,9 @@ pub fn move_next_word_start(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn move_prev_word_start(cx: &mut Context) {
+fn move_prev_word_start(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc
@@ -256,9 +415,9 @@ pub fn move_prev_word_start(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn move_next_word_end(cx: &mut Context) {
+fn move_next_word_end(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc
@@ -268,23 +427,23 @@ pub fn move_next_word_end(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn move_file_start(cx: &mut Context) {
+fn move_file_start(cx: &mut Context) {
push_jump(cx.editor);
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
doc.set_selection(view.id, Selection::point(0));
}
-pub fn move_file_end(cx: &mut Context) {
+fn move_file_end(cx: &mut Context) {
push_jump(cx.editor);
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text();
let last_line = text.line_to_char(text.len_lines().saturating_sub(2));
doc.set_selection(view.id, Selection::point(last_line));
}
-pub fn extend_next_word_start(cx: &mut Context) {
+fn extend_next_word_start(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc.selection(view.id).transform(|mut range| {
@@ -296,9 +455,9 @@ pub fn extend_next_word_start(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn extend_prev_word_start(cx: &mut Context) {
+fn extend_prev_word_start(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc.selection(view.id).transform(|mut range| {
@@ -309,9 +468,9 @@ pub fn extend_prev_word_start(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn extend_next_word_end(cx: &mut Context) {
+fn extend_next_word_end(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc.selection(view.id).transform(|mut range| {
@@ -348,7 +507,7 @@ where
_ => return,
};
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc.selection(view.id).transform(|mut range| {
@@ -367,7 +526,7 @@ where
})
}
-pub fn find_till_char(cx: &mut Context) {
+fn find_till_char(cx: &mut Context) {
find_char_impl(
cx,
search::find_nth_next,
@@ -376,7 +535,7 @@ pub fn find_till_char(cx: &mut Context) {
)
}
-pub fn find_next_char(cx: &mut Context) {
+fn find_next_char(cx: &mut Context) {
find_char_impl(
cx,
search::find_nth_next,
@@ -385,7 +544,7 @@ pub fn find_next_char(cx: &mut Context) {
)
}
-pub fn extend_till_char(cx: &mut Context) {
+fn extend_till_char(cx: &mut Context) {
find_char_impl(
cx,
search::find_nth_next,
@@ -394,7 +553,7 @@ pub fn extend_till_char(cx: &mut Context) {
)
}
-pub fn extend_next_char(cx: &mut Context) {
+fn extend_next_char(cx: &mut Context) {
find_char_impl(
cx,
search::find_nth_next,
@@ -403,7 +562,7 @@ pub fn extend_next_char(cx: &mut Context) {
)
}
-pub fn till_prev_char(cx: &mut Context) {
+fn till_prev_char(cx: &mut Context) {
find_char_impl(
cx,
search::find_nth_prev,
@@ -412,7 +571,7 @@ pub fn till_prev_char(cx: &mut Context) {
)
}
-pub fn find_prev_char(cx: &mut Context) {
+fn find_prev_char(cx: &mut Context) {
find_char_impl(
cx,
search::find_nth_prev,
@@ -421,7 +580,7 @@ pub fn find_prev_char(cx: &mut Context) {
)
}
-pub fn extend_till_prev_char(cx: &mut Context) {
+fn extend_till_prev_char(cx: &mut Context) {
find_char_impl(
cx,
search::find_nth_prev,
@@ -430,7 +589,7 @@ pub fn extend_till_prev_char(cx: &mut Context) {
)
}
-pub fn extend_prev_char(cx: &mut Context) {
+fn extend_prev_char(cx: &mut Context) {
find_char_impl(
cx,
search::find_nth_prev,
@@ -439,8 +598,8 @@ pub fn extend_prev_char(cx: &mut Context) {
)
}
-pub fn extend_first_nonwhitespace(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn extend_first_nonwhitespace(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let selection = doc.selection(view.id).transform(|range| {
let text = doc.text();
@@ -457,7 +616,7 @@ pub fn extend_first_nonwhitespace(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn replace(cx: &mut Context) {
+fn replace(cx: &mut Context) {
// need to wait for next key
cx.on_next_key(move |cx, event| {
let ch = match event {
@@ -473,7 +632,7 @@ pub fn replace(cx: &mut Context) {
};
if let Some(ch) = ch {
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let transaction =
Transaction::change_by_selection(doc.text(), doc.selection(view.id), |range| {
@@ -497,7 +656,7 @@ pub fn replace(cx: &mut Context) {
fn scroll(cx: &mut Context, offset: usize, direction: Direction) {
use Direction::*;
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let cursor = coords_at_pos(doc.text().slice(..), doc.selection(view.id).cursor());
let doc_last_line = doc.text().len_lines() - 1;
@@ -537,33 +696,33 @@ fn scroll(cx: &mut Context, offset: usize, direction: Direction) {
doc.set_selection(view.id, Selection::point(pos));
}
-pub fn page_up(cx: &mut Context) {
- let view = cx.view();
+fn page_up(cx: &mut Context) {
+ let view = view!(cx.editor);
let offset = view.area.height as usize;
scroll(cx, offset, Direction::Backward);
}
-pub fn page_down(cx: &mut Context) {
- let view = cx.view();
+fn page_down(cx: &mut Context) {
+ let view = view!(cx.editor);
let offset = view.area.height as usize;
scroll(cx, offset, Direction::Forward);
}
-pub fn half_page_up(cx: &mut Context) {
- let view = cx.view();
+fn half_page_up(cx: &mut Context) {
+ let view = view!(cx.editor);
let offset = view.area.height as usize / 2;
scroll(cx, offset, Direction::Backward);
}
-pub fn half_page_down(cx: &mut Context) {
- let view = cx.view();
+fn half_page_down(cx: &mut Context) {
+ let view = view!(cx.editor);
let offset = view.area.height as usize / 2;
scroll(cx, offset, Direction::Forward);
}
-pub fn extend_char_left(cx: &mut Context) {
+fn extend_char_left(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc.selection(view.id).transform(|range| {
movement::move_horizontally(text, range, Direction::Backward, count, Movement::Extend)
@@ -571,9 +730,9 @@ pub fn extend_char_left(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn extend_char_right(cx: &mut Context) {
+fn extend_char_right(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc.selection(view.id).transform(|range| {
movement::move_horizontally(text, range, Direction::Forward, count, Movement::Extend)
@@ -581,9 +740,9 @@ pub fn extend_char_right(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn extend_line_up(cx: &mut Context) {
+fn extend_line_up(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc.selection(view.id).transform(|range| {
movement::move_vertically(text, range, Direction::Backward, count, Movement::Extend)
@@ -591,9 +750,9 @@ pub fn extend_line_up(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn extend_line_down(cx: &mut Context) {
+fn extend_line_down(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc.selection(view.id).transform(|range| {
movement::move_vertically(text, range, Direction::Forward, count, Movement::Extend)
@@ -601,8 +760,8 @@ pub fn extend_line_down(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn extend_line_end(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn extend_line_end(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let selection = doc.selection(view.id).transform(|range| {
let text = doc.text();
@@ -620,8 +779,8 @@ pub fn extend_line_end(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn extend_line_start(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn extend_line_start(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let selection = doc.selection(view.id).transform(|range| {
let text = doc.text();
@@ -635,14 +794,14 @@ pub fn extend_line_start(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn select_all(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn select_all(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let end = doc.text().len_chars().saturating_sub(1);
doc.set_selection(view.id, Selection::single(0, end))
}
-pub fn select_regex(cx: &mut Context) {
+fn select_regex(cx: &mut Context) {
let prompt = ui::regex_prompt(cx, "select:".to_string(), move |view, doc, _, regex| {
let text = doc.text().slice(..);
if let Some(selection) = selection::select_on_matches(text, doc.selection(view.id), ®ex)
@@ -654,7 +813,7 @@ pub fn select_regex(cx: &mut Context) {
cx.push_layer(Box::new(prompt));
}
-pub fn split_selection(cx: &mut Context) {
+fn split_selection(cx: &mut Context) {
let prompt = ui::regex_prompt(cx, "split:".to_string(), move |view, doc, _, regex| {
let text = doc.text().slice(..);
let selection = selection::split_on_matches(text, doc.selection(view.id), ®ex);
@@ -664,8 +823,8 @@ pub fn split_selection(cx: &mut Context) {
cx.push_layer(Box::new(prompt));
}
-pub fn split_selection_on_newline(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn split_selection_on_newline(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
// only compile the regex once
#[allow(clippy::trivial_regex)]
@@ -716,8 +875,8 @@ fn search_impl(doc: &mut Document, view: &mut View, contents: &str, regex: &Rege
}
// TODO: use one function for search vs extend
-pub fn search(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn search(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
// TODO: could probably share with select_on_matches?
@@ -738,10 +897,10 @@ pub fn search(cx: &mut Context) {
cx.push_layer(Box::new(prompt));
}
-// can't search next for ""compose"" for some reason
-pub fn search_next_impl(cx: &mut Context, extend: bool) {
- let (view, doc, registers) = cx.current_with_registers();
+fn search_next_impl(cx: &mut Context, extend: bool) {
+ let (view, doc) = current!(cx.editor);
+ let registers = &mut cx.editor.registers;
if let Some(query) = registers.read('\\') {
let query = query.first().unwrap();
let contents = doc.text().slice(..).to_string();
@@ -750,16 +909,16 @@ pub fn search_next_impl(cx: &mut Context, extend: bool) {
}
}
-pub fn search_next(cx: &mut Context) {
+fn search_next(cx: &mut Context) {
search_next_impl(cx, false);
}
-pub fn extend_search_next(cx: &mut Context) {
+fn extend_search_next(cx: &mut Context) {
search_next_impl(cx, true);
}
-pub fn search_selection(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn search_selection(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let contents = doc.text().slice(..);
let query = doc.selection(view.id).primary().fragment(contents);
let regex = regex::escape(&query);
@@ -773,9 +932,9 @@ pub fn search_selection(cx: &mut Context) {
//
-pub fn select_line(cx: &mut Context) {
+fn select_line(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let pos = doc.selection(view.id).primary();
let text = doc.text();
@@ -788,9 +947,9 @@ pub fn select_line(cx: &mut Context) {
doc.set_selection(view.id, Selection::single(start, end));
}
-pub fn extend_line(cx: &mut Context) {
+fn extend_line(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let pos = doc.selection(view.id).primary();
let text = doc.text();
@@ -830,9 +989,10 @@ fn delete_selection_impl(reg: &mut Register, doc: &mut Document, view_id: ViewId
doc.apply(&transaction, view_id);
}
-pub fn delete_selection(cx: &mut Context) {
+fn delete_selection(cx: &mut Context) {
let reg_name = cx.selected_register.name();
- let (view, doc, registers) = cx.current_with_registers();
+ let (view, doc) = current!(cx.editor);
+ let registers = &mut cx.editor.registers;
let reg = registers.get_or_insert(reg_name);
delete_selection_impl(reg, doc, view.id);
@@ -842,16 +1002,17 @@ pub fn delete_selection(cx: &mut Context) {
exit_select_mode(cx);
}
-pub fn change_selection(cx: &mut Context) {
+fn change_selection(cx: &mut Context) {
let reg_name = cx.selected_register.name();
- let (view, doc, registers) = cx.current_with_registers();
+ let (view, doc) = current!(cx.editor);
+ let registers = &mut cx.editor.registers;
let reg = registers.get_or_insert(reg_name);
delete_selection_impl(reg, doc, view.id);
enter_insert_mode(doc);
}
-pub fn collapse_selection(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn collapse_selection(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let selection = doc
.selection(view.id)
.transform(|range| Range::new(range.head, range.head));
@@ -859,8 +1020,8 @@ pub fn collapse_selection(cx: &mut Context) {
doc.set_selection(view.id, selection);
}
-pub fn flip_selections(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn flip_selections(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let selection = doc
.selection(view.id)
.transform(|range| Range::new(range.head, range.anchor));
@@ -873,8 +1034,8 @@ fn enter_insert_mode(doc: &mut Document) {
}
// inserts at the start of each selection
-pub fn insert_mode(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn insert_mode(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
enter_insert_mode(doc);
let selection = doc
@@ -884,8 +1045,8 @@ pub fn insert_mode(cx: &mut Context) {
}
// inserts at the end of each selection
-pub fn append_mode(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn append_mode(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
enter_insert_mode(doc);
doc.restore_cursor = true;
@@ -918,7 +1079,7 @@ mod cmd {
use ui::completers::{self, Completer};
#[derive(Clone)]
- pub struct Command {
+ pub struct TypableCommand {
pub name: &'static str,
pub alias: Option<&'static str>,
pub doc: &'static str,
@@ -932,11 +1093,11 @@ mod cmd {
if editor.tree.views().count() == 1 && buffers_remaining_impl(editor) {
return;
}
- editor.close(editor.view().id, /* close_buffer */ false);
+ editor.close(view!(editor).id, /* close_buffer */ false);
}
fn force_quit(editor: &mut Editor, args: &[&str], event: PromptEvent) {
- editor.close(editor.view().id, /* close_buffer */ false);
+ editor.close(view!(editor).id, /* close_buffer */ false);
}
fn open(editor: &mut Editor, args: &[&str], event: PromptEvent) {
@@ -978,7 +1139,7 @@ mod cmd {
}
fn write(editor: &mut Editor, args: &[&str], event: PromptEvent) {
- let (view, doc) = editor.current();
+ let (view, doc) = current!(editor);
if let Err(e) = write_impl(view, doc, args.first()) {
editor.set_error(e.to_string());
};
@@ -989,7 +1150,7 @@ mod cmd {
}
fn format(editor: &mut Editor, args: &[&str], event: PromptEvent) {
- let (view, doc) = editor.current();
+ let (view, doc) = current!(editor);
doc.format(view.id)
}
@@ -999,7 +1160,7 @@ mod cmd {
// If no argument, report current indent style.
if args.is_empty() {
- let style = editor.current().1.indent_style;
+ let style = current!(editor).1.indent_style;
editor.set_status(match style {
Tabs => "tabs".into(),
Spaces(1) => "1 space".into(),
@@ -1022,7 +1183,7 @@ mod cmd {
};
if let Some(s) = style {
- let (_, doc) = editor.current();
+ let doc = doc_mut!(editor);
doc.indent_style = s;
} else {
// Invalid argument.
@@ -1038,7 +1199,7 @@ mod cmd {
return;
}
};
- let (view, doc) = editor.current();
+ let (view, doc) = current!(editor);
doc.earlier(view.id, uk)
}
@@ -1050,12 +1211,12 @@ mod cmd {
return;
}
};
- let (view, doc) = editor.current();
+ let (view, doc) = current!(editor);
doc.later(view.id, uk)
}
fn write_quit(editor: &mut Editor, args: &[&str], event: PromptEvent) {
- let (view, doc) = editor.current();
+ let (view, doc) = current!(editor);
if let Err(e) = write_impl(view, doc, args.first()) {
editor.set_error(e.to_string());
return;
@@ -1076,8 +1237,8 @@ mod cmd {
.filter(|doc| doc.is_modified())
.map(|doc| {
doc.relative_path()
- .and_then(|path| path.to_str())
- .unwrap_or("[scratch]")
+ .map(|path| path.to_string_lossy().to_string())
+ .unwrap_or_else(|| "[scratch]".into())
})
.collect();
if !modified.is_empty() {
@@ -1157,113 +1318,113 @@ mod cmd {
quit_all_impl(editor, args, event, true)
}
- pub const COMMAND_LIST: &[Command] = &[
- Command {
+ pub const TYPABLE_COMMAND_LIST: &[TypableCommand] = &[
+ TypableCommand {
name: "quit",
alias: Some("q"),
doc: "Close the current view.",
fun: quit,
completer: None,
},
- Command {
+ TypableCommand {
name: "quit!",
alias: Some("q!"),
doc: "Close the current view.",
fun: force_quit,
completer: None,
},
- Command {
+ TypableCommand {
name: "open",
alias: Some("o"),
doc: "Open a file from disk into the current view.",
fun: open,
completer: Some(completers::filename),
},
- Command {
+ TypableCommand {
name: "write",
alias: Some("w"),
doc: "Write changes to disk. Accepts an optional path (:write some/path.txt)",
fun: write,
completer: Some(completers::filename),
},
- Command {
+ TypableCommand {
name: "new",
alias: Some("n"),
doc: "Create a new scratch buffer.",
fun: new_file,
completer: Some(completers::filename),
},
- Command {
+ TypableCommand {
name: "format",
alias: Some("fmt"),
doc: "Format the file using a formatter.",
fun: format,
completer: None,
},
- Command {
+ TypableCommand {
name: "indent-style",
alias: None,
doc: "Set the indentation style for editing. ('t' for tabs or 1-8 for number of spaces.)",
fun: set_indent_style,
completer: None,
},
- Command {
+ TypableCommand {
name: "earlier",
alias: Some("ear"),
doc: "Jump back to an earlier point in edit history. Accepts a number of steps or a time span.",
fun: earlier,
completer: None,
},
- Command {
+ TypableCommand {
name: "later",
alias: Some("lat"),
doc: "Jump to a later point in edit history. Accepts a number of steps or a time span.",
fun: later,
completer: None,
},
- Command {
+ TypableCommand {
name: "write-quit",
alias: Some("wq"),
doc: "Writes changes to disk and closes the current view. Accepts an optional path (:wq some/path.txt)",
fun: write_quit,
completer: Some(completers::filename),
},
- Command {
+ TypableCommand {
name: "write-quit!",
alias: Some("wq!"),
doc: "Writes changes to disk and closes the current view forcefully. Accepts an optional path (:wq! some/path.txt)",
fun: force_write_quit,
completer: Some(completers::filename),
},
- Command {
+ TypableCommand {
name: "write-all",
alias: Some("wa"),
doc: "Writes changes from all views to disk.",
fun: write_all,
completer: None,
},
- Command {
+ TypableCommand {
name: "write-quit-all",
alias: Some("wqa"),
doc: "Writes changes from all views to disk and close all views.",
fun: write_all_quit,
completer: None,
},
- Command {
+ TypableCommand {
name: "write-quit-all!",
alias: Some("wqa!"),
doc: "Writes changes from all views to disk and close all views forcefully (ignoring unsaved changes).",
fun: force_write_all_quit,
completer: None,
},
- Command {
+ TypableCommand {
name: "quit-all",
alias: Some("qa"),
doc: "Close all views.",
fun: quit_all,
completer: None,
},
- Command {
+ TypableCommand {
name: "quit-all!",
alias: Some("qa!"),
doc: "Close all views forcefully (ignoring unsaved changes).",
@@ -1273,10 +1434,10 @@ mod cmd {
];
- pub static COMMANDS: Lazy<HashMap<&'static str, &'static Command>> = Lazy::new(|| {
+ pub static COMMANDS: Lazy<HashMap<&'static str, &'static TypableCommand>> = Lazy::new(|| {
let mut map = HashMap::new();
- for cmd in COMMAND_LIST {
+ for cmd in TYPABLE_COMMAND_LIST {
map.insert(cmd.name, cmd);
if let Some(alias) = cmd.alias {
map.insert(alias, cmd);
@@ -1287,7 +1448,7 @@ mod cmd {
});
}
-pub fn command_mode(cx: &mut Context) {
+fn command_mode(cx: &mut Context) {
// TODO: completion items should have a info section that would get displayed in
// a popup above the prompt when items are tabbed over
@@ -1302,7 +1463,7 @@ pub fn command_mode(cx: &mut Context) {
if parts.len() <= 1 {
use std::{borrow::Cow, ops::Range};
let end = 0..;
- cmd::COMMAND_LIST
+ cmd::TYPABLE_COMMAND_LIST
.iter()
.filter(|command| command.name.contains(input))
.map(|command| (end.clone(), Cow::Borrowed(command.name)))
@@ -1310,7 +1471,7 @@ pub fn command_mode(cx: &mut Context) {
} else {
let part = parts.last().unwrap();
- if let Some(cmd::Command {
+ if let Some(cmd::TypableCommand {
completer: Some(completer),
..
}) = cmd::COMMANDS.get(parts[0])
@@ -1351,7 +1512,7 @@ pub fn command_mode(cx: &mut Context) {
prompt.doc_fn = Box::new(|input: &str| {
let part = input.split(' ').next().unwrap_or_default();
- if let Some(cmd::Command { doc, .. }) = cmd::COMMANDS.get(part) {
+ if let Some(cmd::TypableCommand { doc, .. }) = cmd::COMMANDS.get(part) {
return Some(doc);
}
@@ -1361,21 +1522,21 @@ pub fn command_mode(cx: &mut Context) {
cx.push_layer(Box::new(prompt));
}
-pub fn file_picker(cx: &mut Context) {
+fn file_picker(cx: &mut Context) {
let root = find_root(None).unwrap_or_else(|| PathBuf::from("./"));
let picker = ui::file_picker(root);
cx.push_layer(Box::new(picker));
}
-pub fn buffer_picker(cx: &mut Context) {
+fn buffer_picker(cx: &mut Context) {
use std::path::{Path, PathBuf};
- let current = cx.editor.view().doc;
+ let current = view!(cx.editor).doc;
let picker = Picker::new(
cx.editor
.documents
.iter()
- .map(|(id, doc)| (id, doc.relative_path().map(Path::to_path_buf)))
+ .map(|(id, doc)| (id, doc.relative_path()))
.collect(),
move |(id, path): &(DocumentId, Option<PathBuf>)| {
// format_fn
@@ -1398,7 +1559,7 @@ pub fn buffer_picker(cx: &mut Context) {
cx.push_layer(Box::new(picker));
}
-pub fn symbol_picker(cx: &mut Context) {
+fn symbol_picker(cx: &mut Context) {
fn nested_to_flat(
list: &mut Vec<lsp::SymbolInformation>,
file: &lsp::TextDocumentIdentifier,
@@ -1417,7 +1578,7 @@ pub fn symbol_picker(cx: &mut Context) {
nested_to_flat(list, file, child);
}
}
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let language_server = match doc.language_server() {
Some(language_server) => language_server,
@@ -1438,7 +1599,7 @@ pub fn symbol_picker(cx: &mut Context) {
let symbols = match symbols {
lsp::DocumentSymbolResponse::Flat(symbols) => symbols,
lsp::DocumentSymbolResponse::Nested(symbols) => {
- let (_view, doc) = editor.current();
+ let (_view, doc) = current!(editor);
let mut flat_symbols = Vec::new();
for symbol in symbols {
nested_to_flat(&mut flat_symbols, &doc.identifier(), symbol)
@@ -1452,7 +1613,7 @@ pub fn symbol_picker(cx: &mut Context) {
|symbol| (&symbol.name).into(),
move |editor: &mut Editor, symbol, _action| {
push_jump(editor);
- let (view, doc) = editor.current();
+ let (view, doc) = current!(editor);
if let Some(range) =
lsp_range_to_range(doc.text(), symbol.location.range, offset_encoding)
@@ -1469,15 +1630,15 @@ pub fn symbol_picker(cx: &mut Context) {
}
// I inserts at the first nonwhitespace character of each line with a selection
-pub fn prepend_to_line(cx: &mut Context) {
+fn prepend_to_line(cx: &mut Context) {
move_first_nonwhitespace(cx);
- let doc = cx.doc();
+ let doc = doc_mut!(cx.editor);
enter_insert_mode(doc);
}
// A inserts at the end of each line with a selection
-pub fn append_to_line(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn append_to_line(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
enter_insert_mode(doc);
let selection = doc.selection(view.id).transform(|range| {
@@ -1497,73 +1658,79 @@ enum Open {
fn open(cx: &mut Context, open: Open) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
enter_insert_mode(doc);
let text = doc.text().slice(..);
+ let contents = doc.text();
let selection = doc.selection(view.id);
let mut ranges = SmallVec::with_capacity(selection.len());
+ let mut offs = 0;
- let changes: Vec<Change> = selection
- .iter()
- .map(|range| {
- let line = text.char_to_line(range.head);
+ let line = match open {
+ // adjust position to the end of the line (next line - 1)
+ Open::Below => line + 1,
+ // adjust position to the end of the previous line (current line - 1)
+ Open::Above => line,
+ };
- let line = match open {
- // adjust position to the end of the line (next line - 1)
- Open::Below => line + 1,
- // adjust position to the end of the previous line (current line - 1)
- Open::Above => line,
- };
+ let mut transaction = Transaction::change_by_selection(contents, selection, |range| {
+ let line = text.char_to_line(range.head);
- let index = doc.text().line_to_char(line).saturating_sub(1);
+ // insert newlines after this index for both Above and Below variants
+ let linend_index = doc.text().line_to_char(line).saturating_sub(1);
- // TODO: share logic with insert_newline for indentation
- let indent_level = indent::suggested_indent_for_pos(
- doc.language_config(),
- doc.syntax(),
- text,
- index,
- true,
- );
- let indent = doc.indent_unit().repeat(indent_level);
- let mut text = String::with_capacity(1 + indent.len());
- text.push_str(doc.line_ending().as_str());
- text.push_str(&indent);
- let text = text.repeat(count);
+ // TODO: share logic with insert_newline for indentation
+ let indent_level = indent::suggested_indent_for_pos(
+ doc.language_config(),
+ doc.syntax(),
+ text,
+ linend_index,
+ true,
+ );
+ let indent = doc.indent_unit().repeat(indent_level);
+ let indent_len = indent.len();
+ let mut text = String::with_capacity(1 + indent_len);
+ text.push('\n');
+ text.push_str(&indent);
+ let text = text.repeat(count);
- // calculate new selection range
- let pos = index + text.chars().count();
- ranges.push(Range::new(pos, pos));
+ // calculate new selection ranges
+ let pos = if line == 0 {
+ 0 // Required since text will have a min len of 1 (\n)
+ } else {
+ offs + linend_index + 1
+ };
+ for i in 0..count {
+ // pos -> beginning of reference line,
+ // + (i * (1+indent_len)) -> beginning of i'th line from pos
+ // + indent_len -> -> indent for i'th line
+ ranges.push(Range::point(pos + (i * (1 + indent_len)) + indent_len));
+ }
- (index, index, Some(text.into()))
- })
- .collect();
+ offs += text.chars().count();
- // TODO: count actually inserts "n" new lines and starts editing on all of them.
- // TODO: append "count" newlines and modify cursors to those lines
+ (linend_index, linend_index, Some(text.into()))
+ });
- let selection = Selection::new(ranges, 0);
-
- let transaction =
- Transaction::change(doc.text(), changes.into_iter()).with_selection(selection);
+ transaction = transaction.with_selection(Selection::new(ranges, selection.primary_index()));
doc.apply(&transaction, view.id);
}
// o inserts a new line after each line with a selection
-pub fn open_below(cx: &mut Context) {
+fn open_below(cx: &mut Context) {
open(cx, Open::Below)
}
// O inserts a new line before each line with a selection
-pub fn open_above(cx: &mut Context) {
+fn open_above(cx: &mut Context) {
open(cx, Open::Above)
}
-pub fn normal_mode(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn normal_mode(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
doc.mode = Mode::Normal;
@@ -1586,13 +1753,13 @@ pub fn normal_mode(cx: &mut Context) {
// Store a jump on the jumplist.
fn push_jump(editor: &mut Editor) {
- let (view, doc) = editor.current();
+ let (view, doc) = current!(editor);
let jump = (doc.id(), doc.selection(view.id).clone());
view.jumps.push(jump);
}
fn switch_to_last_accessed_file(cx: &mut Context) {
- let alternate_file = cx.view().last_accessed_doc;
+ let alternate_file = view!(cx.editor).last_accessed_doc;
if let Some(alt) = alternate_file {
cx.editor.switch(alt, Action::Replace);
} else {
@@ -1600,11 +1767,11 @@ fn switch_to_last_accessed_file(cx: &mut Context) {
}
}
-pub fn goto_mode(cx: &mut Context) {
+fn goto_mode(cx: &mut Context) {
if let Some(count) = cx.count {
push_jump(cx.editor);
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let line_idx = std::cmp::min(count.get() - 1, doc.text().len_lines().saturating_sub(2));
let pos = doc.text().line_to_char(line_idx);
doc.set_selection(view.id, Selection::point(pos));
@@ -1618,7 +1785,8 @@ pub fn goto_mode(cx: &mut Context) {
} = event
{
// TODO: temporarily show GOTO in the mode list
- match (cx.doc().mode, ch) {
+ let doc = doc_mut!(cx.editor);
+ match (doc.mode, ch) {
(_, 'g') => move_file_start(cx),
(_, 'e') => move_file_end(cx),
(_, 'a') => switch_to_last_accessed_file(cx),
@@ -1634,7 +1802,7 @@ pub fn goto_mode(cx: &mut Context) {
(Mode::Select, 's') => extend_first_nonwhitespace(cx),
(_, 't') | (_, 'm') | (_, 'b') => {
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let pos = doc.selection(view.id).cursor();
let line = doc.text().char_to_line(pos);
@@ -1661,12 +1829,12 @@ pub fn goto_mode(cx: &mut Context) {
})
}
-pub fn select_mode(cx: &mut Context) {
- cx.doc().mode = Mode::Select;
+fn select_mode(cx: &mut Context) {
+ doc_mut!(cx.editor).mode = Mode::Select;
}
-pub fn exit_select_mode(cx: &mut Context) {
- cx.doc().mode = Mode::Normal;
+fn exit_select_mode(cx: &mut Context) {
+ doc_mut!(cx.editor).mode = Mode::Normal;
}
fn goto_impl(
@@ -1688,7 +1856,7 @@ fn goto_impl(
let id = editor
.open(PathBuf::from(location.uri.path()), action)
.expect("editor.open failed");
- let (view, doc) = editor.current();
+ let (view, doc) = current!(editor);
let definition_pos = location.range.start;
// TODO: convert inside server
let new_pos =
@@ -1725,8 +1893,8 @@ fn goto_impl(
}
}
-pub fn goto_definition(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn goto_definition(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let language_server = match doc.language_server() {
Some(language_server) => language_server,
None => return,
@@ -1737,7 +1905,7 @@ pub fn goto_definition(cx: &mut Context) {
let pos = pos_to_lsp_pos(doc.text(), doc.selection(view.id).cursor(), offset_encoding);
// TODO: handle fails
- let future = language_server.goto_definition(doc.identifier(), pos);
+ let future = language_server.goto_definition(doc.identifier(), pos, None);
cx.callback(
future,
@@ -1762,8 +1930,8 @@ pub fn goto_definition(cx: &mut Context) {
);
}
-pub fn goto_type_definition(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn goto_type_definition(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let language_server = match doc.language_server() {
Some(language_server) => language_server,
None => return,
@@ -1774,7 +1942,7 @@ pub fn goto_type_definition(cx: &mut Context) {
let pos = pos_to_lsp_pos(doc.text(), doc.selection(view.id).cursor(), offset_encoding);
// TODO: handle fails
- let future = language_server.goto_type_definition(doc.identifier(), pos);
+ let future = language_server.goto_type_definition(doc.identifier(), pos, None);
cx.callback(
future,
@@ -1799,8 +1967,8 @@ pub fn goto_type_definition(cx: &mut Context) {
);
}
-pub fn goto_implementation(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn goto_implementation(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let language_server = match doc.language_server() {
Some(language_server) => language_server,
None => return,
@@ -1811,7 +1979,7 @@ pub fn goto_implementation(cx: &mut Context) {
let pos = pos_to_lsp_pos(doc.text(), doc.selection(view.id).cursor(), offset_encoding);
// TODO: handle fails
- let future = language_server.goto_implementation(doc.identifier(), pos);
+ let future = language_server.goto_implementation(doc.identifier(), pos, None);
cx.callback(
future,
@@ -1836,8 +2004,8 @@ pub fn goto_implementation(cx: &mut Context) {
);
}
-pub fn goto_reference(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn goto_reference(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let language_server = match doc.language_server() {
Some(language_server) => language_server,
None => return,
@@ -1848,7 +2016,7 @@ pub fn goto_reference(cx: &mut Context) {
let pos = pos_to_lsp_pos(doc.text(), doc.selection(view.id).cursor(), offset_encoding);
// TODO: handle fails
- let future = language_server.goto_reference(doc.identifier(), pos);
+ let future = language_server.goto_reference(doc.identifier(), pos, None);
cx.callback(
future,
@@ -1868,15 +2036,15 @@ pub fn goto_reference(cx: &mut Context) {
fn goto_pos(editor: &mut Editor, pos: usize) {
push_jump(editor);
- let (view, doc) = editor.current();
+ let (view, doc) = current!(editor);
doc.set_selection(view.id, Selection::point(pos));
align_view(doc, view, Align::Center);
}
-pub fn goto_first_diag(cx: &mut Context) {
+fn goto_first_diag(cx: &mut Context) {
let editor = &mut cx.editor;
- let (view, doc) = editor.current();
+ let (view, doc) = current!(editor);
let cursor_pos = doc.selection(view.id).cursor();
let diag = if let Some(diag) = doc.diagnostics().first() {
@@ -1888,9 +2056,9 @@ pub fn goto_first_diag(cx: &mut Context) {
goto_pos(editor, diag);
}
-pub fn goto_last_diag(cx: &mut Context) {
+fn goto_last_diag(cx: &mut Context) {
let editor = &mut cx.editor;
- let (view, doc) = editor.current();
+ let (view, doc) = current!(editor);
let cursor_pos = doc.selection(view.id).cursor();
let diag = if let Some(diag) = doc.diagnostics().last() {
@@ -1902,9 +2070,9 @@ pub fn goto_last_diag(cx: &mut Context) {
goto_pos(editor, diag);
}
-pub fn goto_next_diag(cx: &mut Context) {
+fn goto_next_diag(cx: &mut Context) {
let editor = &mut cx.editor;
- let (view, doc) = editor.current();
+ let (view, doc) = current!(editor);
let cursor_pos = doc.selection(view.id).cursor();
let diag = if let Some(diag) = doc
@@ -1923,9 +2091,9 @@ pub fn goto_next_diag(cx: &mut Context) {
goto_pos(editor, diag);
}
-pub fn goto_prev_diag(cx: &mut Context) {
+fn goto_prev_diag(cx: &mut Context) {
let editor = &mut cx.editor;
- let (view, doc) = editor.current();
+ let (view, doc) = current!(editor);
let cursor_pos = doc.selection(view.id).cursor();
let diag = if let Some(diag) = doc
@@ -1945,8 +2113,8 @@ pub fn goto_prev_diag(cx: &mut Context) {
goto_pos(editor, diag);
}
-pub fn signature_help(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn signature_help(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let language_server = match doc.language_server() {
Some(language_server) => language_server,
@@ -1960,7 +2128,7 @@ pub fn signature_help(cx: &mut Context) {
);
// TODO: handle fails
- let future = language_server.text_document_signature_help(doc.identifier(), pos);
+ let future = language_server.text_document_signature_help(doc.identifier(), pos, None);
cx.callback(
future,
@@ -1992,7 +2160,7 @@ pub mod insert {
fn completion(cx: &mut Context, ch: char) {
// if ch matches completion char, trigger completion
- let doc = cx.doc();
+ let doc = doc_mut!(cx.editor);
let language_server = match doc.language_server() {
Some(language_server) => language_server,
None => return,
@@ -2020,7 +2188,7 @@ pub mod insert {
fn signature_help(cx: &mut Context, ch: char) {
// if ch matches signature_help char, trigger
- let doc = cx.doc();
+ let doc = doc_mut!(cx.editor);
let language_server = match doc.language_server() {
Some(language_server) => language_server,
None => return,
@@ -2075,7 +2243,7 @@ pub mod insert {
const POST_HOOKS: &[PostHook] = &[completion, signature_help];
pub fn insert_char(cx: &mut Context, c: char) {
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text();
let selection = doc.selection(view.id);
@@ -2097,7 +2265,7 @@ pub mod insert {
}
pub fn insert_tab(cx: &mut Context) {
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
// TODO: round out to nearest indentation level (for example a line with 3 spaces should
// indent by one to reach 4 spaces).
@@ -2107,7 +2275,7 @@ pub mod insert {
}
pub fn insert_newline(cx: &mut Context) {
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let contents = doc.text();
@@ -2176,7 +2344,7 @@ pub mod insert {
// TODO: handle indent-aware delete
pub fn delete_char_backward(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let transaction =
Transaction::change_by_selection(doc.text(), doc.selection(view.id), |range| {
@@ -2191,7 +2359,7 @@ pub mod insert {
pub fn delete_char_forward(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let transaction =
Transaction::change_by_selection(doc.text(), doc.selection(view.id), |range| {
@@ -2206,7 +2374,7 @@ pub mod insert {
pub fn delete_word_backward(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text().slice(..);
let selection = doc
.selection(view.id)
@@ -2221,21 +2389,23 @@ pub mod insert {
// TODO: each command could simply return a Option<transaction>, then the higher level handles
// storing it?
-pub fn undo(cx: &mut Context) {
- let view_id = cx.view().id;
- cx.doc().undo(view_id);
+fn undo(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
+ let view_id = view.id;
+ doc.undo(view_id);
}
-pub fn redo(cx: &mut Context) {
- let view_id = cx.view().id;
- cx.doc().redo(view_id);
+fn redo(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
+ let view_id = view.id;
+ doc.redo(view_id);
}
// Yank / Paste
-pub fn yank(cx: &mut Context) {
+fn yank(cx: &mut Context) {
// TODO: should selections be made end inclusive?
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let values: Vec<String> = doc
.selection(view.id)
.fragments(doc.text().slice(..))
@@ -2300,9 +2470,10 @@ fn paste_impl(
Some(transaction)
}
-pub fn replace_with_yanked(cx: &mut Context) {
+fn replace_with_yanked(cx: &mut Context) {
let reg_name = cx.selected_register.name();
- let (view, doc, registers) = cx.current_with_registers();
+ let (view, doc) = current!(cx.editor);
+ let registers = &mut cx.editor.registers;
if let Some(values) = registers.read(reg_name) {
if let Some(yank) = values.first() {
@@ -2329,9 +2500,10 @@ pub fn replace_with_yanked(cx: &mut Context) {
// replace => replace
// default insert
-pub fn paste_after(cx: &mut Context) {
+fn paste_after(cx: &mut Context) {
let reg_name = cx.selected_register.name();
- let (view, doc, registers) = cx.current_with_registers();
+ let (view, doc) = current!(cx.editor);
+ let registers = &mut cx.editor.registers;
if let Some(transaction) = registers
.read(reg_name)
@@ -2342,9 +2514,10 @@ pub fn paste_after(cx: &mut Context) {
}
}
-pub fn paste_before(cx: &mut Context) {
+fn paste_before(cx: &mut Context) {
let reg_name = cx.selected_register.name();
- let (view, doc, registers) = cx.current_with_registers();
+ let (view, doc) = current!(cx.editor);
+ let registers = &mut cx.editor.registers;
if let Some(transaction) = registers
.read(reg_name)
@@ -2372,9 +2545,9 @@ fn get_lines(doc: &Document, view_id: ViewId) -> Vec<usize> {
lines
}
-pub fn indent(cx: &mut Context) {
+fn indent(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let lines = get_lines(doc, view.id);
// Indent by one level
@@ -2391,9 +2564,9 @@ pub fn indent(cx: &mut Context) {
doc.append_changes_to_history(view.id);
}
-pub fn unindent(cx: &mut Context) {
+fn unindent(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let lines = get_lines(doc, view.id);
let mut changes = Vec::with_capacity(lines.len());
let tab_width = doc.tab_width();
@@ -2431,8 +2604,8 @@ pub fn unindent(cx: &mut Context) {
doc.append_changes_to_history(view.id);
}
-pub fn format_selections(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn format_selections(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
// via lsp if available
// else via tree-sitter indentation calculations
@@ -2477,9 +2650,9 @@ pub fn format_selections(cx: &mut Context) {
doc.append_changes_to_history(view.id);
}
-pub fn join_selections(cx: &mut Context) {
+fn join_selections(cx: &mut Context) {
use movement::skip_while;
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let text = doc.text();
let slice = doc.text().slice(..);
@@ -2521,7 +2694,7 @@ pub fn join_selections(cx: &mut Context) {
doc.append_changes_to_history(view.id);
}
-pub fn keep_selections(cx: &mut Context) {
+fn keep_selections(cx: &mut Context) {
// keep selections matching regex
let prompt = ui::regex_prompt(cx, "keep:".to_string(), move |view, doc, _, regex| {
let text = doc.text().slice(..);
@@ -2534,8 +2707,8 @@ pub fn keep_selections(cx: &mut Context) {
cx.push_layer(Box::new(prompt));
}
-pub fn keep_primary_selection(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn keep_primary_selection(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let range = doc.selection(view.id).primary();
let selection = Selection::single(range.anchor, range.head);
@@ -2544,14 +2717,14 @@ pub fn keep_primary_selection(cx: &mut Context) {
//
-pub fn save(cx: &mut Context) {
+fn save(cx: &mut Context) {
// Spawns an async task to actually do the saving. This way we prevent blocking.
// TODO: handle save errors somehow?
- tokio::spawn(cx.doc().save());
+ tokio::spawn(doc_mut!(cx.editor).save());
}
-pub fn completion(cx: &mut Context) {
+fn completion(cx: &mut Context) {
// trigger on trigger char, or if user calls it
// (or on word char typing??)
// after it's triggered, if response marked is_incomplete, update on every subsequent keypress
@@ -2588,7 +2761,7 @@ pub fn completion(cx: &mut Context) {
// The prefix still has to satisfy `company-minimum-prefix-length' before that
// happens. The value of nil means no idle completion."
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let language_server = match doc.language_server() {
Some(language_server) => language_server,
@@ -2600,7 +2773,7 @@ pub fn completion(cx: &mut Context) {
let pos = pos_to_lsp_pos(doc.text(), doc.selection(view.id).cursor(), offset_encoding);
// TODO: handle fails
- let future = language_server.completion(doc.identifier(), pos);
+ let future = language_server.completion(doc.identifier(), pos, None);
let trigger_offset = doc.selection(view.id).cursor();
@@ -2641,8 +2814,8 @@ pub fn completion(cx: &mut Context) {
//}
}
-pub fn hover(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn hover(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let language_server = match doc.language_server() {
Some(language_server) => language_server,
@@ -2658,7 +2831,7 @@ pub fn hover(cx: &mut Context) {
);
// TODO: handle fails
- let future = language_server.text_document_hover(doc.identifier(), pos);
+ let future = language_server.text_document_hover(doc.identifier(), pos, None);
cx.callback(
future,
@@ -2691,8 +2864,8 @@ pub fn hover(cx: &mut Context) {
}
// comments
-pub fn toggle_comments(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn toggle_comments(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
let transaction = comment::toggle_line_comments(doc.text(), doc.selection(view.id));
doc.apply(&transaction, view.id);
@@ -2701,8 +2874,8 @@ pub fn toggle_comments(cx: &mut Context) {
// tree sitter node selection
-pub fn expand_selection(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn expand_selection(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
if let Some(syntax) = doc.syntax() {
let text = doc.text().slice(..);
@@ -2711,8 +2884,8 @@ pub fn expand_selection(cx: &mut Context) {
}
}
-pub fn match_brackets(cx: &mut Context) {
- let (view, doc) = cx.current();
+fn match_brackets(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
if let Some(syntax) = doc.syntax() {
let pos = doc.selection(view.id).cursor();
@@ -2725,23 +2898,23 @@ pub fn match_brackets(cx: &mut Context) {
//
-pub fn jump_forward(cx: &mut Context) {
+fn jump_forward(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
if let Some((id, selection)) = view.jumps.forward(count) {
view.doc = *id;
let selection = selection.clone();
- let (view, doc) = cx.current(); // refetch doc
+ let (view, doc) = current!(cx.editor); // refetch doc
doc.set_selection(view.id, selection);
align_view(doc, view, Align::Center);
};
}
-pub fn jump_backward(cx: &mut Context) {
+fn jump_backward(cx: &mut Context) {
let count = cx.count();
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
if let Some((id, selection)) = view.jumps.backward(view.id, doc, count) {
// manually set the alternate_file as we cannot use the Editor::switch function here.
@@ -2750,14 +2923,14 @@ pub fn jump_backward(cx: &mut Context) {
}
view.doc = *id;
let selection = selection.clone();
- let (view, doc) = cx.current(); // refetch doc
+ let (view, doc) = current!(cx.editor); // refetch doc
doc.set_selection(view.id, selection);
align_view(doc, view, Align::Center);
};
}
-pub fn window_mode(cx: &mut Context) {
+fn window_mode(cx: &mut Context) {
cx.on_next_key(move |cx, event| {
if let KeyEvent {
code: KeyCode::Char(ch),
@@ -2775,15 +2948,17 @@ pub fn window_mode(cx: &mut Context) {
})
}
-pub fn rotate_view(cx: &mut Context) {
+fn rotate_view(cx: &mut Context) {
cx.editor.focus_next()
}
// split helper, clear it later
use helix_view::editor::Action;
+
+use self::cmd::TypableCommand;
fn split(cx: &mut Context, action: Action) {
use helix_view::editor::Action;
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let id = doc.id();
let selection = doc.selection(view.id).clone();
let first_line = view.first_line;
@@ -2791,26 +2966,26 @@ fn split(cx: &mut Context, action: Action) {
cx.editor.switch(id, action);
// match the selection in the previous view
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
view.first_line = first_line;
doc.set_selection(view.id, selection);
}
-pub fn hsplit(cx: &mut Context) {
+fn hsplit(cx: &mut Context) {
split(cx, Action::HorizontalSplit);
}
-pub fn vsplit(cx: &mut Context) {
+fn vsplit(cx: &mut Context) {
split(cx, Action::VerticalSplit);
}
-pub fn wclose(cx: &mut Context) {
- let view_id = cx.view().id;
+fn wclose(cx: &mut Context) {
+ let view_id = view!(cx.editor).id;
// close current split
cx.editor.close(view_id, /* close_buffer */ false);
}
-pub fn select_register(cx: &mut Context) {
+fn select_register(cx: &mut Context) {
cx.on_next_key(move |cx, event| {
if let KeyEvent {
code: KeyCode::Char(ch),
@@ -2822,7 +2997,7 @@ pub fn select_register(cx: &mut Context) {
})
}
-pub fn space_mode(cx: &mut Context) {
+fn space_mode(cx: &mut Context) {
cx.on_next_key(move |cx, event| {
if let KeyEvent {
code: KeyCode::Char(ch),
@@ -2844,7 +3019,7 @@ pub fn space_mode(cx: &mut Context) {
})
}
-pub fn view_mode(cx: &mut Context) {
+fn view_mode(cx: &mut Context) {
cx.on_next_key(move |cx, event| {
if let KeyEvent {
code: KeyCode::Char(ch),
@@ -2860,7 +3035,7 @@ pub fn view_mode(cx: &mut Context) {
| 't'
// bottom
| 'b' => {
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
align_view(doc, view, match ch {
'z' | 'c' => Align::Center,
@@ -2870,7 +3045,7 @@ pub fn view_mode(cx: &mut Context) {
});
}
'm' => {
- let (view, doc) = cx.current();
+ let (view, doc) = current!(cx.editor);
let pos = doc.selection(view.id).cursor();
let pos = coords_at_pos(doc.text().slice(..), pos);
@@ -2887,7 +3062,7 @@ pub fn view_mode(cx: &mut Context) {
})
}
-pub fn left_bracket_mode(cx: &mut Context) {
+fn left_bracket_mode(cx: &mut Context) {
cx.on_next_key(move |cx, event| {
if let KeyEvent {
code: KeyCode::Char(ch),
@@ -2903,7 +3078,7 @@ pub fn left_bracket_mode(cx: &mut Context) {
})
}
-pub fn right_bracket_mode(cx: &mut Context) {
+fn right_bracket_mode(cx: &mut Context) {
cx.on_next_key(move |cx, event| {
if let KeyEvent {
code: KeyCode::Char(ch),
diff --git a/helix-term/src/config.rs b/helix-term/src/config.rs
new file mode 100644
index 00000000..9c962299
--- /dev/null
+++ b/helix-term/src/config.rs
@@ -0,0 +1,63 @@
+use serde::Deserialize;
+
+use crate::commands::Command;
+use crate::keymap::Keymaps;
+
+#[derive(Debug, PartialEq, Deserialize)]
+pub struct GlobalConfig {
+ pub lsp_progress: bool,
+}
+
+impl Default for GlobalConfig {
+ fn default() -> Self {
+ Self { lsp_progress: true }
+ }
+}
+
+#[derive(Debug, Default, PartialEq, Deserialize)]
+#[serde(default)]
+pub struct Config {
+ pub global: GlobalConfig,
+ pub keys: Keymaps,
+}
+
+#[test]
+fn parsing_keymaps_config_file() {
+ use helix_core::hashmap;
+ use helix_view::document::Mode;
+ use helix_view::input::{KeyCode, KeyEvent, KeyModifiers};
+
+ let sample_keymaps = r#"
+ [keys.insert]
+ y = "move_line_down"
+ S-C-a = "delete_selection"
+
+ [keys.normal]
+ A-F12 = "move_next_word_end"
+ "#;
+
+ assert_eq!(
+ toml::from_str::<Config>(sample_keymaps).unwrap(),
+ Config {
+ global: Default::default(),
+ keys: Keymaps(hashmap! {
+ Mode::Insert => hashmap! {
+ KeyEvent {
+ code: KeyCode::Char('y'),
+ modifiers: KeyModifiers::NONE,
+ } => Command::move_line_down,
+ KeyEvent {
+ code: KeyCode::Char('a'),
+ modifiers: KeyModifiers::SHIFT | KeyModifiers::CONTROL,
+ } => Command::delete_selection,
+ },
+ Mode::Normal => hashmap! {
+ KeyEvent {
+ code: KeyCode::F(12),
+ modifiers: KeyModifiers::ALT,
+ } => Command::move_next_word_end,
+ },
+ })
+ }
+ );
+}
diff --git a/helix-term/src/keymap.rs b/helix-term/src/keymap.rs
index 1402d29d..24924832 100644
--- a/helix-term/src/keymap.rs
+++ b/helix-term/src/keymap.rs
@@ -1,7 +1,16 @@
-use crate::commands::{self, Command};
+use crate::commands;
+pub use crate::commands::Command;
+use anyhow::{anyhow, Error, Result};
use helix_core::hashmap;
use helix_view::document::Mode;
-use std::collections::HashMap;
+use helix_view::input::{KeyCode, KeyEvent, KeyModifiers};
+use serde::Deserialize;
+use std::{
+ collections::HashMap,
+ fmt::Display,
+ ops::{Deref, DerefMut},
+ str::FromStr,
+};
// Kakoune-inspired:
// mode = {
@@ -92,12 +101,6 @@ use std::collections::HashMap;
// D] = last diagnostic
// }
-// #[cfg(feature = "term")]
-pub use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
-
-pub type Keymap = HashMap<KeyEvent, Command>;
-pub type Keymaps = HashMap<Mode, Keymap>;
-
#[macro_export]
macro_rules! key {
($key:ident) => {
@@ -132,188 +135,207 @@ macro_rules! alt {
};
}
-pub fn default() -> Keymaps {
- let normal = hashmap!(
- key!('h') => commands::move_char_left as Command,
- key!('j') => commands::move_line_down,
- key!('k') => commands::move_line_up,
- key!('l') => commands::move_char_right,
+#[derive(Debug, PartialEq, Deserialize)]
+#[serde(transparent)]
+pub struct Keymaps(pub HashMap<Mode, HashMap<KeyEvent, Command>>);
- key!(Left) => commands::move_char_left,
- key!(Down) => commands::move_line_down,
- key!(Up) => commands::move_line_up,
- key!(Right) => commands::move_char_right,
+impl Deref for Keymaps {
+ type Target = HashMap<Mode, HashMap<KeyEvent, Command>>;
- key!('t') => commands::find_till_char,
- key!('f') => commands::find_next_char,
- key!('T') => commands::till_prev_char,
- key!('F') => commands::find_prev_char,
- // and matching set for select mode (extend)
- //
- key!('r') => commands::replace,
- key!('R') => commands::replace_with_yanked,
-
- key!(Home) => commands::move_line_start,
- key!(End) => commands::move_line_end,
-
- key!('w') => commands::move_next_word_start,
- key!('b') => commands::move_prev_word_start,
- key!('e') => commands::move_next_word_end,
-
- key!('v') => commands::select_mode,
- key!('g') => commands::goto_mode,
- key!(':') => commands::command_mode,
-
- key!('i') => commands::insert_mode,
- key!('I') => commands::prepend_to_line,
- key!('a') => commands::append_mode,
- key!('A') => commands::append_to_line,
- key!('o') => commands::open_below,
- key!('O') => commands::open_above,
- // [<space> ]<space> equivalents too (add blank new line, no edit)
-
-
- key!('d') => commands::delete_selection,
- // TODO: also delete without yanking
- key!('c') => commands::change_selection,
- // TODO: also change delete without yanking
-
- // key!('r') => commands::replace_with_char,
-
- key!('s') => commands::select_regex,
- alt!('s') => commands::split_selection_on_newline,
- key!('S') => commands::split_selection,
- key!(';') => commands::collapse_selection,
- alt!(';') => commands::flip_selections,
- key!('%') => commands::select_all,
- key!('x') => commands::select_line,
- key!('X') => commands::extend_line,
- // or select mode X?
- // extend_to_whole_line, crop_to_whole_line
-
-
- key!('m') => commands::match_brackets,
- // TODO: refactor into
- // key!('m') => commands::select_to_matching,
- // key!('M') => commands::back_select_to_matching,
- // select mode extend equivalents
-
- // key!('.') => commands::repeat_insert,
- // repeat_select
-
- // TODO: figure out what key to use
- // key!('[') => commands::expand_selection, ??
- key!('[') => commands::left_bracket_mode,
- key!(']') => commands::right_bracket_mode,
-
- key!('/') => commands::search,
- // ? for search_reverse
- key!('n') => commands::search_next,
- key!('N') => commands::extend_search_next,
- // N for search_prev
- key!('*') => commands::search_selection,
-
- key!('u') => commands::undo,
- key!('U') => commands::redo,
-
- key!('y') => commands::yank,
- // yank_all
- key!('p') => commands::paste_after,
- // paste_all
- key!('P') => commands::paste_before,
-
- key!('>') => commands::indent,
- key!('<') => commands::unindent,
- key!('=') => commands::format_selections,
- key!('J') => commands::join_selections,
- // TODO: conflicts hover/doc
- key!('K') => commands::keep_selections,
- // TODO: and another method for inverse
-
- // TODO: clashes with space mode
- key!(' ') => commands::keep_primary_selection,
-
- // key!('q') => commands::record_macro,
- // key!('Q') => commands::replay_macro,
-
- // ~ / apostrophe => change case
- // & align selections
- // _ trim selections
-
- // C / altC = copy (repeat) selections on prev/next lines
-
- key!(Esc) => commands::normal_mode,
- key!(PageUp) => commands::page_up,
- key!(PageDown) => commands::page_down,
- ctrl!('b') => commands::page_up,
- ctrl!('f') => commands::page_down,
- ctrl!('u') => commands::half_page_up,
- ctrl!('d') => commands::half_page_down,
-
- ctrl!('w') => commands::window_mode,
-
- // move under <space>c
- ctrl!('c') => commands::toggle_comments,
- key!('K') => commands::hover,
-
- // z family for save/restore/combine from/to sels from register
-
- // supposedly ctrl!('i') but did not work
- key!(Tab) => commands::jump_forward,
- ctrl!('o') => commands::jump_backward,
- // ctrl!('s') => commands::save_selection,
-
- key!(' ') => commands::space_mode,
- key!('z') => commands::view_mode,
-
- key!('"') => commands::select_register,
- );
- // TODO: decide whether we want normal mode to also be select mode (kakoune-like), or whether
- // we keep this separate select mode. More keys can fit into normal mode then, but it's weird
- // because some selection operations can now be done from normal mode, some from select mode.
- let mut select = normal.clone();
- select.extend(
- hashmap!(
- key!('h') => commands::extend_char_left as Command,
- key!('j') => commands::extend_line_down,
- key!('k') => commands::extend_line_up,
- key!('l') => commands::extend_char_right,
-
- key!(Left) => commands::extend_char_left,
- key!(Down) => commands::extend_line_down,
- key!(Up) => commands::extend_line_up,
- key!(Right) => commands::extend_char_right,
-
- key!('w') => commands::extend_next_word_start,
- key!('b') => commands::extend_prev_word_start,
- key!('e') => commands::extend_next_word_end,
-
- key!('t') => commands::extend_till_char,
- key!('f') => commands::extend_next_char,
-
- key!('T') => commands::extend_till_prev_char,
- key!('F') => commands::extend_prev_char,
- key!(Home) => commands::extend_line_start,
- key!(End) => commands::extend_line_end,
- key!(Esc) => commands::exit_select_mode,
- )
- .into_iter(),
- );
-
- hashmap!(
- // as long as you cast the first item, rust is able to infer the other cases
- // TODO: select could be normal mode with some bindings merged over
- Mode::Normal => normal,
- Mode::Select => select,
- Mode::Insert => hashmap!(
- key!(Esc) => commands::normal_mode as Command,
- key!(Backspace) => commands::insert::delete_char_backward,
- key!(Delete) => commands::insert::delete_char_forward,
- key!(Enter) => commands::insert::insert_newline,
- key!(Tab) => commands::insert::insert_tab,
-
- ctrl!('x') => commands::completion,
- ctrl!('w') => commands::insert::delete_word_backward,
- ),
- )
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+impl Default for Keymaps {
+ fn default() -> Keymaps {
+ let normal = hashmap!(
+ key!('h') => Command::move_char_left,
+ key!('j') => Command::move_line_down,
+ key!('k') => Command::move_line_up,
+ key!('l') => Command::move_char_right,
+
+ key!(Left) => Command::move_char_left,
+ key!(Down) => Command::move_line_down,
+ key!(Up) => Command::move_line_up,
+ key!(Right) => Command::move_char_right,
+
+ key!('t') => Command::find_till_char,
+ key!('f') => Command::find_next_char,
+ key!('T') => Command::till_prev_char,
+ key!('F') => Command::find_prev_char,
+ // and matching set for select mode (extend)
+ //
+ key!('r') => Command::replace,
+ key!('R') => Command::replace_with_yanked,
+
+ key!(Home) => Command::move_line_start,
+ key!(End) => Command::move_line_end,
+
+ key!('w') => Command::move_next_word_start,
+ key!('b') => Command::move_prev_word_start,
+ key!('e') => Command::move_next_word_end,
+
+ key!('v') => Command::select_mode,
+ key!('g') => Command::goto_mode,
+ key!(':') => Command::command_mode,
+
+ key!('i') => Command::insert_mode,
+ key!('I') => Command::prepend_to_line,
+ key!('a') => Command::append_mode,
+ key!('A') => Command::append_to_line,
+ key!('o') => Command::open_below,
+ key!('O') => Command::open_above,
+ // [<space> ]<space> equivalents too (add blank new line, no edit)
+
+
+ key!('d') => Command::delete_selection,
+ // TODO: also delete without yanking
+ key!('c') => Command::change_selection,
+ // TODO: also change delete without yanking
+
+ // key!('r') => Command::replace_with_char,
+
+ key!('s') => Command::select_regex,
+ alt!('s') => Command::split_selection_on_newline,
+ key!('S') => Command::split_selection,
+ key!(';') => Command::collapse_selection,
+ alt!(';') => Command::flip_selections,
+ key!('%') => Command::select_all,
+ key!('x') => Command::select_line,
+ key!('X') => Command::extend_line,
+ // or select mode X?
+ // extend_to_whole_line, crop_to_whole_line
+
+
+ key!('m') => Command::match_brackets,
+ // TODO: refactor into
+ // key!('m') => commands::select_to_matching,
+ // key!('M') => commands::back_select_to_matching,
+ // select mode extend equivalents
+
+ // key!('.') => commands::repeat_insert,
+ // repeat_select
+
+ // TODO: figure out what key to use
+ // key!('[') => Command::expand_selection, ??
+ key!('[') => Command::left_bracket_mode,
+ key!(']') => Command::right_bracket_mode,
+
+ key!('/') => Command::search,
+ // ? for search_reverse
+ key!('n') => Command::search_next,
+ key!('N') => Command::extend_search_next,
+ // N for search_prev
+ key!('*') => Command::search_selection,
+
+ key!('u') => Command::undo,
+ key!('U') => Command::redo,
+
+ key!('y') => Command::yank,
+ // yank_all
+ key!('p') => Command::paste_after,
+ // paste_all
+ key!('P') => Command::paste_before,
+
+ key!('>') => Command::indent,
+ key!('<') => Command::unindent,
+ key!('=') => Command::format_selections,
+ key!('J') => Command::join_selections,
+ // TODO: conflicts hover/doc
+ key!('K') => Command::keep_selections,
+ // TODO: and another method for inverse
+
+ // TODO: clashes with space mode
+ key!(' ') => Command::keep_primary_selection,
+
+ // key!('q') => Command::record_macro,
+ // key!('Q') => Command::replay_macro,
+
+ // ~ / apostrophe => change case
+ // & align selections
+ // _ trim selections
+
+ // C / altC = copy (repeat) selections on prev/next lines
+
+ key!(Esc) => Command::normal_mode,
+ key!(PageUp) => Command::page_up,
+ key!(PageDown) => Command::page_down,
+ ctrl!('b') => Command::page_up,
+ ctrl!('f') => Command::page_down,
+ ctrl!('u') => Command::half_page_up,
+ ctrl!('d') => Command::half_page_down,
+
+ ctrl!('w') => Command::window_mode,
+
+ // move under <space>c
+ ctrl!('c') => Command::toggle_comments,
+ key!('K') => Command::hover,
+
+ // z family for save/restore/combine from/to sels from register
+
+ // supposedly ctrl!('i') but did not work
+ key!(Tab) => Command::jump_forward,
+ ctrl!('o') => Command::jump_backward,
+ // ctrl!('s') => Command::save_selection,
+
+ key!(' ') => Command::space_mode,
+ key!('z') => Command::view_mode,
+
+ key!('"') => Command::select_register,
+ );
+ // TODO: decide whether we want normal mode to also be select mode (kakoune-like), or whether
+ // we keep this separate select mode. More keys can fit into normal mode then, but it's weird
+ // because some selection operations can now be done from normal mode, some from select mode.
+ let mut select = normal.clone();
+ select.extend(
+ hashmap!(
+ key!('h') => Command::extend_char_left,
+ key!('j') => Command::extend_line_down,
+ key!('k') => Command::extend_line_up,
+ key!('l') => Command::extend_char_right,
+
+ key!(Left) => Command::extend_char_left,
+ key!(Down) => Command::extend_line_down,
+ key!(Up) => Command::extend_line_up,
+ key!(Right) => Command::extend_char_right,
+
+ key!('w') => Command::extend_next_word_start,
+ key!('b') => Command::extend_prev_word_start,
+ key!('e') => Command::extend_next_word_end,
+
+ key!('t') => Command::extend_till_char,
+ key!('f') => Command::extend_next_char,
+
+ key!('T') => Command::extend_till_prev_char,
+ key!('F') => Command::extend_prev_char,
+ key!(Home) => Command::extend_line_start,
+ key!(End) => Command::extend_line_end,
+ key!(Esc) => Command::exit_select_mode,
+ )
+ .into_iter(),
+ );
+
+ Keymaps(hashmap!(
+ // as long as you cast the first item, rust is able to infer the other cases
+ // TODO: select could be normal mode with some bindings merged over
+ Mode::Normal => normal,
+ Mode::Select => select,
+ Mode::Insert => hashmap!(
+ key!(Esc) => Command::normal_mode as Command,
+ key!(Backspace) => Command::delete_char_backward,
+ key!(Delete) => Command::delete_char_forward,
+ key!(Enter) => Command::insert_newline,
+ key!(Tab) => Command::insert_tab,
+ key!(Left) => Command::move_char_left,
+ key!(Down) => Command::move_line_down,
+ key!(Up) => Command::move_line_up,
+ key!(Right) => Command::move_char_right,
+ key!(PageUp) => Command::page_up,
+ key!(PageDown) => Command::page_down,
+ ctrl!('x') => Command::completion,
+ ctrl!('w') => Command::delete_word_backward,
+ ),
+ ))
+ }
}
diff --git a/helix-term/src/lib.rs b/helix-term/src/lib.rs
index 2fd40358..dc8ec38e 100644
--- a/helix-term/src/lib.rs
+++ b/helix-term/src/lib.rs
@@ -1,8 +1,12 @@
#![allow(unused)]
+#[macro_use]
+extern crate helix_view;
+
pub mod application;
pub mod args;
pub mod commands;
pub mod compositor;
+pub mod config;
pub mod keymap;
pub mod ui;
diff --git a/helix-term/src/main.rs b/helix-term/src/main.rs
index 9d4e1c5b..12176910 100644
--- a/helix-term/src/main.rs
+++ b/helix-term/src/main.rs
@@ -1,10 +1,9 @@
+use anyhow::{Context, Error, Result};
use helix_term::application::Application;
use helix_term::args::Args;
-
+use helix_term::config::Config;
use std::path::PathBuf;
-use anyhow::{Context, Result};
-
fn setup_logging(logpath: PathBuf, verbosity: u64) -> Result<()> {
let mut base_config = fern::Dispatch::new();
@@ -89,10 +88,16 @@ FLAGS:
std::fs::create_dir_all(&conf_dir).ok();
}
+ let config = match std::fs::read_to_string(conf_dir.join("config.toml")) {
+ Ok(config) => toml::from_str(&config)?,
+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => Config::default(),
+ Err(err) => return Err(Error::new(err)),
+ };
+
setup_logging(logpath, args.verbosity).context("failed to initialize logging")?;
// TODO: use the thread local executor to spawn the application task separately from the work pool
- let mut app = Application::new(args).context("unable to create new appliction")?;
+ let mut app = Application::new(args, config).context("unable to create new application")?;
app.run().await.unwrap();
Ok(())
diff --git a/helix-term/src/ui/completion.rs b/helix-term/src/ui/completion.rs
index 00ecce03..06ed966d 100644
--- a/helix-term/src/ui/completion.rs
+++ b/helix-term/src/ui/completion.rs
@@ -89,7 +89,7 @@ impl Completion {
// doc.state = snapshot.clone();
}
PromptEvent::Validate => {
- let (view, doc) = editor.current();
+ let (view, doc) = current!(editor);
// revert state to what it was before the last update
// doc.state = snapshot.clone();
@@ -169,7 +169,7 @@ impl Completion {
pub fn update(&mut self, cx: &mut commands::Context) {
// recompute menu based on matches
let menu = self.popup.contents_mut();
- let (view, doc) = cx.editor.current();
+ let (view, doc) = current!(cx.editor);
// cx.hooks()
// cx.add_hook(enum type, ||)
@@ -233,7 +233,7 @@ impl Component for Completion {
// ---
// option.documentation
- let (view, doc) = cx.editor.current();
+ let (view, doc) = current!(cx.editor);
let language = doc
.language()
.and_then(|scope| scope.strip_prefix("source."))
diff --git a/helix-term/src/ui/editor.rs b/helix-term/src/ui/editor.rs
index d6010e6c..42bb3ba8 100644
--- a/helix-term/src/ui/editor.rs
+++ b/helix-term/src/ui/editor.rs
@@ -11,15 +11,13 @@ use helix_core::{
syntax::{self, HighlightEvent},
Position, Range,
};
-use helix_view::{
- document::{IndentStyle, Mode},
- Document, Editor, Theme, View,
-};
+use helix_view::input::{KeyCode, KeyEvent, KeyModifiers};
+use helix_view::{document::Mode, Document, Editor, Theme, View};
use std::borrow::Cow;
use crossterm::{
cursor,
- event::{read, Event, EventStream, KeyCode, KeyEvent, KeyModifiers},
+ event::{read, Event, EventStream},
};
use tui::{
backend::CrosstermBackend,
@@ -30,7 +28,7 @@ use tui::{
};
pub struct EditorView {
- keymap: Keymaps,
+ keymaps: Keymaps,
on_next_key: Option<Box<dyn FnOnce(&mut commands::Context, KeyEvent)>>,
last_insert: (commands::Command, Vec<KeyEvent>),
completion: Option<Completion>,
@@ -40,16 +38,16 @@ const OFFSET: u16 = 7; // 1 diagnostic + 5 linenr + 1 gutter
impl Default for EditorView {
fn default() -> Self {
- Self::new()
+ Self::new(Keymaps::default())
}
}
impl EditorView {
- pub fn new() -> Self {
+ pub fn new(keymaps: Keymaps) -> Self {
Self {
- keymap: keymap::default(),
+ keymaps,
on_next_key: None,
- last_insert: (commands::normal_mode, Vec::new()),
+ last_insert: (commands::Command::normal_mode, Vec::new()),
completion: None,
}
}
@@ -479,18 +477,15 @@ impl EditorView {
Mode::Select => "SEL",
Mode::Normal => "NOR",
};
- let text_color = if is_focused {
- theme.get("ui.text.focus")
+ let style = if is_focused {
+ theme.get("ui.statusline")
} else {
- theme.get("ui.text")
+ theme.get("ui.statusline.inactive")
};
// statusline
- surface.set_style(
- Rect::new(viewport.x, viewport.y, viewport.width, 1),
- theme.get("ui.statusline"),
- );
+ surface.set_style(Rect::new(viewport.x, viewport.y, viewport.width, 1), style);
if is_focused {
- surface.set_string(viewport.x + 1, viewport.y, mode, text_color);
+ surface.set_string(viewport.x + 1, viewport.y, mode, style);
}
if let Some(path) = doc.relative_path() {
@@ -502,7 +497,7 @@ impl EditorView {
viewport.y,
title,
viewport.width.saturating_sub(6) as usize,
- text_color,
+ style,
);
}
@@ -541,13 +536,13 @@ impl EditorView {
viewport.x + viewport.width.saturating_sub(text_len),
viewport.y,
right_side_text,
- text_color,
+ style,
);
}
fn insert_mode(&self, cx: &mut commands::Context, event: KeyEvent) {
- if let Some(command) = self.keymap[&Mode::Insert].get(&event) {
- command(cx);
+ if let Some(command) = self.keymaps[&Mode::Insert].get(&event) {
+ command.execute(cx);
} else if let KeyEvent {
code: KeyCode::Char(ch),
..
@@ -568,7 +563,7 @@ impl EditorView {
// special handling for repeat operator
key!('.') => {
// first execute whatever put us into insert mode
- (self.last_insert.0)(cxt);
+ self.last_insert.0.execute(cxt);
// then replay the inputs
for key in &self.last_insert.1 {
self.insert_mode(cxt, *key)
@@ -584,8 +579,8 @@ impl EditorView {
// set the register
cxt.selected_register = cxt.editor.selected_register.take();
- if let Some(command) = self.keymap[&mode].get(&event) {
- command(cxt);
+ if let Some(command) = self.keymaps[&mode].get(&event) {
+ command.execute(cxt);
}
}
}
@@ -613,12 +608,13 @@ impl Component for EditorView {
cx.editor.resize(Rect::new(0, 0, width, height - 1));
EventResult::Consumed(None)
}
- Event::Key(mut key) => {
+ Event::Key(key) => {
+ let mut key = KeyEvent::from(key);
canonicalize_key(&mut key);
// clear status
cx.editor.status_msg = None;
- let (view, doc) = cx.editor.current();
+ let (view, doc) = current!(cx.editor);
let mode = doc.mode();
let mut cxt = commands::Context {
@@ -687,7 +683,7 @@ impl Component for EditorView {
return EventResult::Ignored;
}
- let (view, doc) = cx.editor.current();
+ let (view, doc) = current!(cx.editor);
view.ensure_cursor_in_view(doc);
// mode transitions
@@ -699,7 +695,7 @@ impl Component for EditorView {
// how we entered insert mode is important, and we should track that so
// we can repeat the side effect.
- self.last_insert.0 = self.keymap[&mode][&key];
+ self.last_insert.0 = self.keymaps[&mode][&key];
self.last_insert.1.clear();
}
(Mode::Insert, Mode::Normal) => {
diff --git a/helix-term/src/ui/mod.rs b/helix-term/src/ui/mod.rs
index 77e53690..39e11cd6 100644
--- a/helix-term/src/ui/mod.rs
+++ b/helix-term/src/ui/mod.rs
@@ -30,8 +30,9 @@ pub fn regex_prompt(
prompt: String,
fun: impl Fn(&mut View, &mut Document, &mut Registers, Regex) + 'static,
) -> Prompt {
- let view_id = cx.view().id;
- let snapshot = cx.doc().selection(view_id).clone();
+ let (view, doc) = current!(cx.editor);
+ let view_id = view.id;
+ let snapshot = doc.selection(view_id).clone();
Prompt::new(
prompt,
@@ -40,7 +41,7 @@ pub fn regex_prompt(
match event {
PromptEvent::Abort => {
// TODO: also revert text
- let (view, doc) = editor.current();
+ let (view, doc) = current!(editor);
doc.set_selection(view.id, snapshot.clone());
}
PromptEvent::Validate => {
@@ -54,7 +55,8 @@ pub fn regex_prompt(
match Regex::new(input) {
Ok(regex) => {
- let (view, doc, registers) = editor.current_with_registers();
+ let (view, doc) = current!(editor);
+ let registers = &mut editor.registers;
// revert state to what it was before the last update
// TODO: also revert text
@@ -124,10 +126,11 @@ pub mod completers {
use ignore::WalkBuilder;
use std::path::{Path, PathBuf};
- let path = Path::new(input);
+ let is_tilde = input.starts_with('~') && input.len() == 1;
+ let path = helix_view::document::expand_tilde(Path::new(input));
let (dir, file_name) = if input.ends_with('/') {
- (path.into(), None)
+ (path, None)
} else {
let file_name = path
.file_name()
@@ -152,7 +155,16 @@ pub mod completers {
let is_dir = entry.file_type().map_or(false, |entry| entry.is_dir());
let path = entry.path();
- let mut path = path.strip_prefix(&dir).unwrap_or(path).to_path_buf();
+ let mut path = if is_tilde {
+ // if it's a single tilde an absolute path is displayed so that when `TAB` is pressed on
+ // one of the directories the tilde will be replaced with a valid path not with a relative
+ // home directory name.
+ // ~ -> <TAB> -> /home/user
+ // ~/ -> <TAB> -> ~/first_entry
+ path.to_path_buf()
+ } else {
+ path.strip_prefix(&dir).unwrap_or(path).to_path_buf()
+ };
if is_dir {
path.push("");
@@ -182,7 +194,7 @@ pub mod completers {
})
.collect();
- let range = ((input.len() - file_name.len())..);
+ let range = ((input.len().saturating_sub(file_name.len()))..);
matches.sort_unstable_by_key(|(_file, score)| Reverse(*score));
files = matches
diff --git a/helix-term/src/ui/prompt.rs b/helix-term/src/ui/prompt.rs
index 7b8af820..991b328d 100644
--- a/helix-term/src/ui/prompt.rs
+++ b/helix-term/src/ui/prompt.rs
@@ -53,7 +53,16 @@ impl Prompt {
}
pub fn insert_char(&mut self, c: char) {
- self.line.insert(self.cursor, c);
+ let pos = if self.line.is_empty() {
+ 0
+ } else {
+ self.line
+ .char_indices()
+ .nth(self.cursor)
+ .map(|(pos, _)| pos)
+ .unwrap_or_else(|| self.line.len())
+ };
+ self.line.insert(pos, c);
self.cursor += 1;
self.completion = (self.completion_fn)(&self.line);
self.exit_selection();
@@ -79,7 +88,13 @@ impl Prompt {
pub fn delete_char_backwards(&mut self) {
if self.cursor > 0 {
- self.line.remove(self.cursor - 1);
+ let pos = self
+ .line
+ .char_indices()
+ .nth(self.cursor - 1)
+ .map(|(pos, _)| pos)
+ .expect("line is not empty");
+ self.line.remove(pos);
self.cursor -= 1;
self.completion = (self.completion_fn)(&self.line);
}
diff --git a/helix-tui/Cargo.toml b/helix-tui/Cargo.toml
index 7ba16553..89fa755d 100644
--- a/helix-tui/Cargo.toml
+++ b/helix-tui/Cargo.toml
@@ -7,6 +7,10 @@ A library to build rich terminal user interfaces or dashboards
"""
edition = "2018"
license = "MPL-2.0"
+categories = ["editor"]
+repository = "https://github.com/helix-editor/helix"
+homepage = "https://helix-editor.com"
+include = ["src/**/*", "README.md"]
[features]
default = ["crossterm"]
diff --git a/helix-view/Cargo.toml b/helix-view/Cargo.toml
index 593f00e0..7f18e9a2 100644
--- a/helix-view/Cargo.toml
+++ b/helix-view/Cargo.toml
@@ -4,6 +4,10 @@ version = "0.2.0"
authors = ["Blaž Hrastnik <blaz@mxxn.io>"]
edition = "2018"
license = "MPL-2.0"
+description = "UI abstractions for use in backends"
+categories = ["editor"]
+repository = "https://github.com/helix-editor/helix"
+homepage = "https://helix-editor.com"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -13,8 +17,8 @@ default = ["term"]
[dependencies]
anyhow = "1"
-helix-core = { path = "../helix-core" }
-helix-lsp = { path = "../helix-lsp"}
+helix-core = { version = "0.2", path = "../helix-core" }
+helix-lsp = { version = "0.2", path = "../helix-lsp"}
# Conversion traits
tui = { path = "../helix-tui", package = "helix-tui", default-features = false, features = ["crossterm"], optional = true }
@@ -23,6 +27,7 @@ once_cell = "1.8"
url = "2"
tokio = { version = "1", features = ["full"] }
+futures-util = { version = "0.3", features = ["std", "async-await"], default-features = false }
slotmap = "1"
diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs
index fe06d09d..49d270e4 100644
--- a/helix-view/src/document.rs
+++ b/helix-view/src/document.rs
@@ -1,7 +1,11 @@
-use anyhow::{Context, Error};
+use anyhow::{anyhow, Context, Error};
+use serde::de::{self, Deserialize, Deserializer};
use std::cell::Cell;
+use std::collections::HashMap;
+use std::fmt::Display;
use std::future::Future;
use std::path::{Component, Path, PathBuf};
+use std::str::FromStr;
use std::sync::Arc;
use helix_core::{
@@ -15,8 +19,6 @@ use helix_core::{
use crate::{DocumentId, ViewId};
-use std::collections::HashMap;
-
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum Mode {
Normal,
@@ -24,6 +26,40 @@ pub enum Mode {
Insert,
}
+impl Display for Mode {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Mode::Normal => f.write_str("normal"),
+ Mode::Select => f.write_str("select"),
+ Mode::Insert => f.write_str("insert"),
+ }
+ }
+}
+
+impl FromStr for Mode {
+ type Err = Error;
+
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ match s {
+ "normal" => Ok(Mode::Normal),
+ "select" => Ok(Mode::Select),
+ "insert" => Ok(Mode::Insert),
+ _ => Err(anyhow!("Invalid mode '{}'", s)),
+ }
+ }
+}
+
+// toml deserializer doesn't seem to recognize string as enum
+impl<'de> Deserialize<'de> for Mode {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ let s = String::deserialize(deserializer)?;
+ s.parse().map_err(de::Error::custom)
+ }
+}
+
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum IndentStyle {
Tabs,
@@ -105,6 +141,36 @@ where
}
}
+/// Expands tilde `~` into users home directory if avilable, otherwise returns the path
+/// unchanged. The tilde will only be expanded when present as the first component of the path
+/// and only slash follows it.
+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) = helix_core::home_dir() {
+ // it's ok to unwrap, the path starts with `~`
+ return home.join(path.strip_prefix("~").unwrap());
+ }
+ }
+ }
+
+ path.to_path_buf()
+}
+
+/// 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) = helix_core::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());
+ }
+ }
+
+ path.to_path_buf()
+}
+
/// Normalize a path, removing things like `.` and `..`.
///
/// CAUTION: This does not resolve symlinks (unlike
@@ -115,6 +181,7 @@ where
/// needs to improve on.
/// Copied from cargo: https://github.com/rust-lang/cargo/blob/070e459c2d8b79c5b2ac5218064e7603329c92ae/crates/cargo-util/src/paths.rs#L81
pub fn normalize_path(path: &Path) -> PathBuf {
+ let path = expand_tilde(path);
let mut components = path.components().peekable();
let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() {
components.next();
@@ -141,12 +208,17 @@ pub fn normalize_path(path: &Path) -> PathBuf {
ret
}
-// Returns the canonical, absolute form of a path with all intermediate components normalized.
-//
-// This function is used instead of `std::fs::canonicalize` because we don't want to verify
-// here if the path exists, just normalize it's components.
+/// Returns the canonical, absolute form of a path with all intermediate components normalized.
+///
+/// This function is used instead of `std::fs::canonicalize` because we don't want to verify
+/// here if the path exists, just normalize it's components.
pub fn canonicalize_path(path: &Path) -> std::io::Result<PathBuf> {
- std::env::current_dir().map(|current_dir| normalize_path(¤t_dir.join(path)))
+ let normalized = normalize_path(path);
+ if normalized.is_absolute() {
+ Ok(normalized)
+ } else {
+ std::env::current_dir().map(|current_dir| current_dir.join(normalized))
+ }
}
use helix_lsp::lsp;
@@ -210,10 +282,11 @@ impl Document {
pub fn format(&mut self, view_id: ViewId) {
if let Some(language_server) = self.language_server() {
// TODO: await, no blocking
- let transaction = helix_lsp::block_on(
- language_server
- .text_document_formatting(self.identifier(), lsp::FormattingOptions::default()),
- )
+ let transaction = helix_lsp::block_on(language_server.text_document_formatting(
+ self.identifier(),
+ lsp::FormattingOptions::default(),
+ None,
+ ))
.map(|edits| {
helix_lsp::util::generate_transaction_from_edits(
self.text(),
@@ -696,12 +769,19 @@ impl Document {
&self.selections[&view_id]
}
- pub fn relative_path(&self) -> Option<&Path> {
+ pub fn relative_path(&self) -> Option<PathBuf> {
let cwdir = std::env::current_dir().expect("couldn't determine current directory");
- self.path
- .as_ref()
- .map(|path| path.strip_prefix(cwdir).unwrap_or(path))
+ self.path.as_ref().map(|path| {
+ let path = fold_home_dir(path);
+ if path.is_relative() {
+ path
+ } else {
+ path.strip_prefix(cwdir)
+ .map(|p| p.to_path_buf())
+ .unwrap_or(path)
+ }
+ })
}
// pub fn slice<R>(&self, range: R) -> RopeSlice where R: RangeBounds {
diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs
index 24f43c0e..db8ae87a 100644
--- a/helix-view/src/editor.rs
+++ b/helix-view/src/editor.rs
@@ -2,7 +2,9 @@ use crate::{theme::Theme, tree::Tree, Document, DocumentId, RegisterSelection, V
use tui::layout::Rect;
use tui::terminal::CursorKind;
+use futures_util::future;
use std::path::PathBuf;
+use std::time::Duration;
use slotmap::SlotMap;
@@ -101,19 +103,19 @@ impl Editor {
match action {
Action::Replace => {
- let view = self.view();
+ let view = view!(self);
let jump = (
view.doc,
self.documents[view.doc].selection(view.id).clone(),
);
- let view = self.view_mut();
+ let view = view_mut!(self);
view.jumps.push(jump);
view.last_accessed_doc = Some(view.doc);
view.doc = id;
view.first_line = 0;
- let (view, doc) = self.current();
+ let (view, doc) = current!(self);
// initialize selection for view
let selection = doc
@@ -238,27 +240,6 @@ impl Editor {
self.tree.is_empty()
}
- pub fn current(&mut self) -> (&mut View, &mut Document) {
- let view = self.tree.get_mut(self.tree.focus);
- let doc = &mut self.documents[view.doc];
- (view, doc)
- }
-
- pub fn current_with_registers(&mut self) -> (&mut View, &mut Document, &mut Registers) {
- let view = self.tree.get_mut(self.tree.focus);
- let doc = &mut self.documents[view.doc];
- let registers = &mut self.registers;
- (view, doc, registers)
- }
-
- pub fn view(&self) -> &View {
- self.tree.get(self.tree.focus)
- }
-
- pub fn view_mut(&mut self) -> &mut View {
- self.tree.get_mut(self.tree.focus)
- }
-
pub fn ensure_cursor_in_view(&mut self, id: ViewId) {
let view = self.tree.get_mut(id);
let doc = &self.documents[view.doc];
@@ -280,7 +261,7 @@ impl Editor {
pub fn cursor(&self) -> (Option<Position>, CursorKind) {
const OFFSET: u16 = 7; // 1 diagnostic + 5 linenr + 1 gutter
- let view = self.view();
+ let view = view!(self);
let doc = &self.documents[view.doc];
let cursor = doc.selection(view.id).cursor();
if let Some(mut pos) = view.screen_coords_at_pos(doc, doc.text().slice(..), cursor) {
@@ -291,4 +272,22 @@ impl Editor {
(None, CursorKind::Hidden)
}
}
+
+ /// Closes language servers with timeout. The default timeout is 500 ms, use
+ /// `timeout` parameter to override this.
+ pub async fn close_language_servers(
+ &self,
+ timeout: Option<u64>,
+ ) -> Result<(), tokio::time::error::Elapsed> {
+ tokio::time::timeout(
+ Duration::from_millis(timeout.unwrap_or(500)),
+ future::join_all(
+ self.language_servers
+ .iter_clients()
+ .map(|client| client.force_shutdown()),
+ ),
+ )
+ .await
+ .map(|_| ())
+ }
}
diff --git a/helix-view/src/input.rs b/helix-view/src/input.rs
new file mode 100644
index 00000000..ab417819
--- /dev/null
+++ b/helix-view/src/input.rs
@@ -0,0 +1,226 @@
+//! Input event handling, currently backed by crossterm.
+use anyhow::{anyhow, Error};
+use crossterm::event;
+use serde::de::{self, Deserialize, Deserializer};
+use std::fmt;
+
+pub use crossterm::event::{KeyCode, KeyModifiers};
+
+/// Represents a key event.
+// We use a newtype here because we want to customize Deserialize and Display.
+#[derive(Debug, PartialEq, Eq, PartialOrd, Clone, Copy, Hash)]
+pub struct KeyEvent {
+ pub code: KeyCode,
+ pub modifiers: KeyModifiers,
+}
+
+impl fmt::Display for KeyEvent {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
+ f.write_fmt(format_args!(
+ "{}{}{}",
+ if self.modifiers.contains(KeyModifiers::SHIFT) {
+ "S-"
+ } else {
+ ""
+ },
+ if self.modifiers.contains(KeyModifiers::ALT) {
+ "A-"
+ } else {
+ ""
+ },
+ if self.modifiers.contains(KeyModifiers::CONTROL) {
+ "C-"
+ } else {
+ ""
+ },
+ ))?;
+ match self.code {
+ KeyCode::Backspace => f.write_str("backspace")?,
+ KeyCode::Enter => f.write_str("ret")?,
+ KeyCode::Left => f.write_str("left")?,
+ KeyCode::Right => f.write_str("right")?,
+ KeyCode::Up => f.write_str("up")?,
+ KeyCode::Down => f.write_str("down")?,
+ KeyCode::Home => f.write_str("home")?,
+ KeyCode::End => f.write_str("end")?,
+ KeyCode::PageUp => f.write_str("pageup")?,
+ KeyCode::PageDown => f.write_str("pagedown")?,
+ KeyCode::Tab => f.write_str("tab")?,
+ KeyCode::BackTab => f.write_str("backtab")?,
+ KeyCode::Delete => f.write_str("del")?,
+ KeyCode::Insert => f.write_str("ins")?,
+ KeyCode::Null => f.write_str("null")?,
+ KeyCode::Esc => f.write_str("esc")?,
+ KeyCode::Char('<') => f.write_str("lt")?,
+ KeyCode::Char('>') => f.write_str("gt")?,
+ KeyCode::Char('+') => f.write_str("plus")?,
+ KeyCode::Char('-') => f.write_str("minus")?,
+ KeyCode::Char(';') => f.write_str("semicolon")?,
+ KeyCode::Char('%') => f.write_str("percent")?,
+ KeyCode::F(i) => f.write_fmt(format_args!("F{}", i))?,
+ KeyCode::Char(c) => f.write_fmt(format_args!("{}", c))?,
+ };
+ Ok(())
+ }
+}
+
+impl std::str::FromStr for KeyEvent {
+ type Err = Error;
+
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ let mut tokens: Vec<_> = s.split('-').collect();
+ let code = match tokens.pop().ok_or_else(|| anyhow!("Missing key code"))? {
+ "backspace" => KeyCode::Backspace,
+ "space" => KeyCode::Char(' '),
+ "ret" => KeyCode::Enter,
+ "lt" => KeyCode::Char('<'),
+ "gt" => KeyCode::Char('>'),
+ "plus" => KeyCode::Char('+'),
+ "minus" => KeyCode::Char('-'),
+ "semicolon" => KeyCode::Char(';'),
+ "percent" => KeyCode::Char('%'),
+ "left" => KeyCode::Left,
+ "right" => KeyCode::Right,
+ "up" => KeyCode::Down,
+ "home" => KeyCode::Home,
+ "end" => KeyCode::End,
+ "pageup" => KeyCode::PageUp,
+ "pagedown" => KeyCode::PageDown,
+ "tab" => KeyCode::Tab,
+ "backtab" => KeyCode::BackTab,
+ "del" => KeyCode::Delete,
+ "ins" => KeyCode::Insert,
+ "null" => KeyCode::Null,
+ "esc" => KeyCode::Esc,
+ single if single.len() == 1 => KeyCode::Char(single.chars().next().unwrap()),
+ function if function.len() > 1 && function.starts_with('F') => {
+ let function: String = function.chars().skip(1).collect();
+ let function = str::parse::<u8>(&function)?;
+ (function > 0 && function < 13)
+ .then(|| KeyCode::F(function))
+ .ok_or_else(|| anyhow!("Invalid function key '{}'", function))?
+ }
+ invalid => return Err(anyhow!("Invalid key code '{}'", invalid)),
+ };
+
+ let mut modifiers = KeyModifiers::empty();
+ for token in tokens {
+ let flag = match token {
+ "S" => KeyModifiers::SHIFT,
+ "A" => KeyModifiers::ALT,
+ "C" => KeyModifiers::CONTROL,
+ _ => return Err(anyhow!("Invalid key modifier '{}-'", token)),
+ };
+
+ if modifiers.contains(flag) {
+ return Err(anyhow!("Repeated key modifier '{}-'", token));
+ }
+ modifiers.insert(flag);
+ }
+
+ Ok(KeyEvent { code, modifiers })
+ }
+}
+
+impl<'de> Deserialize<'de> for KeyEvent {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ let s = String::deserialize(deserializer)?;
+ s.parse().map_err(de::Error::custom)
+ }
+}
+
+impl From<event::KeyEvent> for KeyEvent {
+ fn from(event::KeyEvent { code, modifiers }: event::KeyEvent) -> KeyEvent {
+ KeyEvent { code, modifiers }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn parsing_unmodified_keys() {
+ assert_eq!(
+ str::parse::<KeyEvent>("backspace").unwrap(),
+ KeyEvent {
+ code: KeyCode::Backspace,
+ modifiers: KeyModifiers::NONE
+ }
+ );
+
+ assert_eq!(
+ str::parse::<KeyEvent>("left").unwrap(),
+ KeyEvent {
+ code: KeyCode::Left,
+ modifiers: KeyModifiers::NONE
+ }
+ );
+
+ assert_eq!(
+ str::parse::<KeyEvent>(",").unwrap(),
+ KeyEvent {
+ code: KeyCode::Char(','),
+ modifiers: KeyModifiers::NONE
+ }
+ );
+
+ assert_eq!(
+ str::parse::<KeyEvent>("w").unwrap(),
+ KeyEvent {
+ code: KeyCode::Char('w'),
+ modifiers: KeyModifiers::NONE
+ }
+ );
+
+ assert_eq!(
+ str::parse::<KeyEvent>("F12").unwrap(),
+ KeyEvent {
+ code: KeyCode::F(12),
+ modifiers: KeyModifiers::NONE
+ }
+ );
+ }
+
+ #[test]
+ fn parsing_modified_keys() {
+ assert_eq!(
+ str::parse::<KeyEvent>("S-minus").unwrap(),
+ KeyEvent {
+ code: KeyCode::Char('-'),
+ modifiers: KeyModifiers::SHIFT
+ }
+ );
+
+ assert_eq!(
+ str::parse::<KeyEvent>("C-A-S-F12").unwrap(),
+ KeyEvent {
+ code: KeyCode::F(12),
+ modifiers: KeyModifiers::SHIFT | KeyModifiers::CONTROL | KeyModifiers::ALT
+ }
+ );
+
+ assert_eq!(
+ str::parse::<KeyEvent>("S-C-2").unwrap(),
+ KeyEvent {
+ code: KeyCode::Char('2'),
+ modifiers: KeyModifiers::SHIFT | KeyModifiers::CONTROL
+ }
+ );
+ }
+
+ #[test]
+ fn parsing_nonsensical_keys_fails() {
+ assert!(str::parse::<KeyEvent>("F13").is_err());
+ assert!(str::parse::<KeyEvent>("F0").is_err());
+ assert!(str::parse::<KeyEvent>("aaa").is_err());
+ assert!(str::parse::<KeyEvent>("S-S-a").is_err());
+ assert!(str::parse::<KeyEvent>("C-A-S-C-1").is_err());
+ assert!(str::parse::<KeyEvent>("FU").is_err());
+ assert!(str::parse::<KeyEvent>("123").is_err());
+ assert!(str::parse::<KeyEvent>("S--").is_err());
+ }
+}
diff --git a/helix-view/src/lib.rs b/helix-view/src/lib.rs
index 7e253320..8b635700 100644
--- a/helix-view/src/lib.rs
+++ b/helix-view/src/lib.rs
@@ -1,13 +1,18 @@
+#[macro_use]
+pub mod macros;
+
pub mod document;
pub mod editor;
+pub mod input;
pub mod register_selection;
pub mod theme;
pub mod tree;
pub mod view;
-use slotmap::new_key_type;
-new_key_type! { pub struct DocumentId; }
-new_key_type! { pub struct ViewId; }
+slotmap::new_key_type! {
+ pub struct DocumentId;
+ pub struct ViewId;
+}
pub use document::Document;
pub use editor::Editor;
diff --git a/helix-view/src/macros.rs b/helix-view/src/macros.rs
new file mode 100644
index 00000000..a06d37e7
--- /dev/null
+++ b/helix-view/src/macros.rs
@@ -0,0 +1,29 @@
+#[macro_export]
+macro_rules! current {
+ ( $( $editor:ident ).+ ) => {{
+ let view = $crate::view_mut!( $( $editor ).+ );
+ let doc = &mut $( $editor ).+ .documents[view.doc];
+ (view, doc)
+ }};
+}
+
+#[macro_export]
+macro_rules! doc_mut {
+ ( $( $editor:ident ).+ ) => {{
+ $crate::current!( $( $editor ).+ ).1
+ }};
+}
+
+#[macro_export]
+macro_rules! view_mut {
+ ( $( $editor:ident ).+ ) => {{
+ $( $editor ).+ .tree.get_mut($( $editor ).+ .tree.focus)
+ }};
+}
+
+#[macro_export]
+macro_rules! view {
+ ( $( $editor:ident ).+ ) => {{
+ $( $editor ).+ .tree.get($( $editor ).+ .tree.focus)
+ }};
+}
diff --git a/theme.toml b/theme.toml
index 903a5e26..a4f40267 100644
--- a/theme.toml
+++ b/theme.toml
@@ -41,7 +41,8 @@
"ui.background" = { bg = "#3b224c" } # midnight
"ui.linenr" = { fg = "#5a5977" } # comet
"ui.linenr.selected" = { fg = "#dbbfef" } # lilac
-"ui.statusline" = { bg = "#281733" } # revolver
+"ui.statusline" = { fg = "#dbbfef", bg = "#281733" } # revolver
+"ui.statusline.inactive" = { fg = "#a4a0e8", bg = "#281733" } # revolver
"ui.popup" = { bg = "#281733" } # revolver
"ui.window" = { bg = "#452859" } # bossa nova
"ui.window" = { bg = "#452859" } # bossa nova