aboutsummaryrefslogtreecommitdiff
path: root/helix-view/src
diff options
context:
space:
mode:
Diffstat (limited to 'helix-view/src')
-rw-r--r--helix-view/src/document.rs112
-rw-r--r--helix-view/src/editor.rs49
-rw-r--r--helix-view/src/input.rs226
-rw-r--r--helix-view/src/lib.rs11
-rw-r--r--helix-view/src/macros.rs29
5 files changed, 383 insertions, 44 deletions
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(&current_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)
+ }};
+}