Merge pull request #5 from helix-editor/lsp

LSP: mk1

Cargo.toml

@@ -4,6 +4,7 @@ members = [
   "helix-view",
   "helix-term",
   "helix-syntax",
+  "helix-lsp",
 ]
 
 # Build helix-syntax in release mode to make the code path faster in development.

helix-core/src/diagnostic.rs

@@ -0,0 +1,7 @@
+use crate::Range;
+
+pub struct Diagnostic {
+    pub range: (usize, usize),
+    pub line: usize,
+    pub message: String,
+}

helix-core/src/history.rs

@@ -57,37 +57,31 @@ impl History {
         self.cursor == 0
     }
 
-    pub fn undo(&mut self, state: &mut State) {
+    // TODO: I'd like to pass Transaction by reference but it fights with the borrowck
+
+    pub fn undo(&mut self) -> Option<Transaction> {
         if self.at_root() {
             // We're at the root of undo, nothing to do.
-            return;
+            return None;
         }
 
         let current_revision = &self.revisions[self.cursor];
 
-        // TODO: pass the return value through? It should always succeed
-        let success = current_revision.revert.apply(state);
-
-        if !success {
-            panic!("Failed to apply undo!");
-        }
-
         self.cursor = current_revision.parent;
+
+        Some(current_revision.revert.clone())
     }
 
-    pub fn redo(&mut self, state: &mut State) {
+    pub fn redo(&mut self) -> Option<Transaction> {
         let current_revision = &self.revisions[self.cursor];
 
         // for now, simply pick the latest child (linear undo / redo)
         if let Some((index, transaction)) = current_revision.children.last() {
-            let success = transaction.apply(state);
-
-            if !success {
-                panic!("Failed to apply redo!");
-            }
-
             self.cursor = *index;
+
+            return Some(transaction.clone());
         }
+        None
     }
 }
 
@@ -120,17 +114,27 @@ mod test {
         assert_eq!("hello 世界!", state.doc());
 
         // ---
+        fn undo(history: &mut History, state: &mut State) {
+            if let Some(transaction) = history.undo() {
+                transaction.apply(state);
+            }
+        }
+        fn redo(history: &mut History, state: &mut State) {
+            if let Some(transaction) = history.redo() {
+                transaction.apply(state);
+            }
+        }
 
-        history.undo(&mut state);
+        undo(&mut history, &mut state);
         assert_eq!("hello world!", state.doc());
-        history.redo(&mut state);
+        redo(&mut history, &mut state);
         assert_eq!("hello 世界!", state.doc());
-        history.undo(&mut state);
+        undo(&mut history, &mut state);
-        history.undo(&mut state);
+        undo(&mut history, &mut state);
         assert_eq!("hello", state.doc());
 
         // undo at root is a no-op
-        history.undo(&mut state);
+        undo(&mut history, &mut state);
         assert_eq!("hello", state.doc());
     }
 }

helix-core/src/indent.rs

@@ -111,17 +111,17 @@ fn find_first_non_whitespace_char(state: &State, line_num: usize) -> usize {
     start
 }
 
-fn suggested_indent_for_line(state: &State, line_num: usize) -> usize {
+fn suggested_indent_for_line(syntax: Option<&Syntax>, state: &State, line_num: usize) -> usize {
     let line = state.doc.line(line_num);
     let current = indent_level_for_line(line);
 
     let start = find_first_non_whitespace_char(state, line_num);
 
-    suggested_indent_for_pos(state, start)
+    suggested_indent_for_pos(syntax, state, start)
 }
 
-pub fn suggested_indent_for_pos(state: &State, pos: usize) -> usize {
+pub fn suggested_indent_for_pos(syntax: Option<&Syntax>, state: &State, pos: usize) -> usize {
-    if let Some(syntax) = &state.syntax {
+    if let Some(syntax) = syntax {
         let byte_start = state.doc.char_to_byte(pos);
         let node = get_highest_syntax_node_at_bytepos(syntax, byte_start);
 
@@ -163,13 +163,18 @@ mod test {
 ",
         );
 
-        let mut state = State::new(doc);
+        let state = State::new(doc);
-        state.set_language("source.rust", &[]);
+        // TODO: set_language
-
+        let language_config = crate::syntax::LOADER
-        assert_eq!(suggested_indent_for_line(&state, 0), 0); // mod
+            .language_config_for_scope("source.rust")
-        assert_eq!(suggested_indent_for_line(&state, 1), 1); // fn
+            .unwrap();
-        assert_eq!(suggested_indent_for_line(&state, 2), 2); // 1 + 1
+        let highlight_config = language_config.highlight_config(&[]).unwrap().unwrap();
-        assert_eq!(suggested_indent_for_line(&state, 4), 1); // }
+        let syntax = Syntax::new(&state.doc, highlight_config.clone());
-        assert_eq!(suggested_indent_for_line(&state, 5), 0); // }
+
+        assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 0), 0); // mod
+        assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 1), 1); // fn
+        assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 2), 2); // 1 + 1
+        assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 4), 1); // }
+        assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 5), 0); // }
     }
 }

helix-core/src/lib.rs

@@ -1,4 +1,5 @@
 #![allow(unused)]
+mod diagnostic;
 pub mod graphemes;
 mod history;
 pub mod indent;
@@ -22,7 +23,8 @@ pub use selection::Range;
 pub use selection::Selection;
 pub use syntax::Syntax;
 
+pub use diagnostic::Diagnostic;
 pub use history::History;
 pub use state::State;
 
-pub use transaction::{Assoc, Change, ChangeSet, Transaction};
+pub use transaction::{Assoc, Change, ChangeSet, Operation, Transaction};

helix-core/src/selection.rs

@@ -179,6 +179,11 @@ impl Selection {
         }
     }
 
+    /// Constructs a selection holding a single cursor.
+    pub fn point(pos: usize) -> Self {
+        Self::single(pos, pos)
+    }
+
     #[must_use]
     pub fn new(ranges: SmallVec<[Range; 1]>, primary_index: usize) -> Self {
         fn normalize(mut ranges: SmallVec<[Range; 1]>, mut primary_index: usize) -> Selection {

helix-core/src/state.rs

@@ -1,33 +1,14 @@
 use crate::graphemes::{nth_next_grapheme_boundary, nth_prev_grapheme_boundary, RopeGraphemes};
 use crate::syntax::LOADER;
-use crate::{ChangeSet, Position, Range, Rope, RopeSlice, Selection, Syntax};
+use crate::{ChangeSet, Diagnostic, Position, Range, Rope, RopeSlice, Selection, Syntax};
 use anyhow::Error;
 
-use std::path::PathBuf;
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
-pub enum Mode {
-    Normal,
-    Insert,
-    Goto,
-}
-
 /// A state represents the current editor state of a single buffer.
+#[derive(Clone)]
 pub struct State {
     // TODO: fields should be private but we need to refactor commands.rs first
-    /// Path to file on disk.
-    pub path: Option<PathBuf>,
     pub doc: Rope,
     pub selection: Selection,
-    pub mode: Mode,
-
-    pub restore_cursor: bool,
-
-    //
-    pub syntax: Option<Syntax>,
-    /// Pending changes since last history commit.
-    pub changes: ChangeSet,
-    pub old_state: Option<(Rope, Selection)>,
 }
 
 #[derive(Copy, Clone, PartialEq, Eq)]
@@ -46,57 +27,12 @@ pub enum Granularity {
 impl State {
     #[must_use]
     pub fn new(doc: Rope) -> Self {
-        let changes = ChangeSet::new(&doc);
-        let old_state = Some((doc.clone(), Selection::single(0, 0)));
-
         Self {
-            path: None,
             doc,
             selection: Selection::single(0, 0),
-            mode: Mode::Normal,
-            restore_cursor: false,
-            syntax: None,
-            changes,
-            old_state,
         }
     }
 
-    // TODO: passing scopes here is awkward
-    pub fn load(path: PathBuf, scopes: &[String]) -> Result<Self, Error> {
-        use std::{env, fs::File, io::BufReader, path::PathBuf};
-        let _current_dir = env::current_dir()?;
-
-        let doc = Rope::from_reader(BufReader::new(File::open(path.clone())?))?;
-
-        // TODO: create if not found
-
-        let mut state = Self::new(doc);
-
-        if let Some(language_config) = LOADER.language_config_for_file_name(path.as_path()) {
-            let highlight_config = language_config.highlight_config(scopes).unwrap().unwrap();
-            // TODO: config.configure(scopes) is now delayed, is that ok?
-
-            let syntax = Syntax::new(&state.doc, highlight_config.clone());
-
-            state.syntax = Some(syntax);
-        };
-
-        state.path = Some(path);
-
-        Ok(state)
-    }
-
-    pub fn set_language(&mut self, scope: &str, scopes: &[String]) {
-        if let Some(language_config) = LOADER.language_config_for_scope(scope) {
-            let highlight_config = language_config.highlight_config(scopes).unwrap().unwrap();
-            // TODO: config.configure(scopes) is now delayed, is that ok?
-
-            let syntax = Syntax::new(&self.doc, highlight_config.clone());
-
-            self.syntax = Some(syntax);
-        };
-    }
-
     // TODO: doc/selection accessors
 
     // TODO: be able to take either Rope or RopeSlice
@@ -110,16 +46,6 @@ impl State {
         &self.selection
     }
 
-    #[inline]
-    pub fn mode(&self) -> Mode {
-        self.mode
-    }
-
-    #[inline]
-    pub fn path(&self) -> Option<&PathBuf> {
-        self.path.as_ref()
-    }
-
     // pub fn doc<R>(&self, range: R) -> RopeSlice
     // where
     //     R: std::ops::RangeBounds<usize>,

helix-core/src/syntax.rs

@@ -62,11 +62,15 @@ impl LanguageConfiguration {
             })
             .map(Option::as_ref)
     }
+
+    pub fn scope(&self) -> &str {
+        &self.scope
+    }
 }
 
 use once_cell::sync::Lazy;
 
-pub(crate) static LOADER: Lazy<Loader> = Lazy::new(Loader::init);
+pub static LOADER: Lazy<Loader> = Lazy::new(Loader::init);
 
 pub struct Loader {
     // highlight_names ?

helix-core/src/transaction.rs

@@ -5,8 +5,9 @@ use std::convert::TryFrom;
 /// (from, to, replacement)
 pub type Change = (usize, usize, Option<Tendril>);
 
+// TODO: pub(crate)
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) enum Operation {
+pub enum Operation {
     /// Move cursor by n characters.
     Retain(usize),
     /// Delete n characters.
@@ -40,6 +41,12 @@ impl ChangeSet {
     }
 
     // TODO: from iter
+    //
+
+    #[doc(hidden)] // used by lsp to convert to LSP changes
+    pub fn changes(&self) -> &[Operation] {
+        &self.changes
+    }
 
     #[must_use]
     fn len_after(&self) -> usize {
@@ -351,22 +358,6 @@ pub struct Transaction {
     // scroll_into_view
 }
 
-/// Like std::mem::replace() except it allows the replacement value to be mapped from the
-/// original value.
-pub fn take_with<T, F>(mut_ref: &mut T, closure: F)
-where
-    F: FnOnce(T) -> T,
-{
-    use std::{panic, ptr};
-
-    unsafe {
-        let old_t = ptr::read(mut_ref);
-        let new_t = panic::catch_unwind(panic::AssertUnwindSafe(|| closure(old_t)))
-            .unwrap_or_else(|_| ::std::process::abort());
-        ptr::write(mut_ref, new_t);
-    }
-}
-
 impl Transaction {
     /// Create a new, empty transaction.
     pub fn new(state: &mut State) -> Self {
@@ -376,29 +367,21 @@ impl Transaction {
         }
     }
 
+    pub fn changes(&self) -> &ChangeSet {
+        &self.changes
+    }
+
     /// Returns true if applied successfully.
     pub fn apply(&self, state: &mut State) -> bool {
         if !self.changes.is_empty() {
-            // TODO: also avoid mapping the selection if not necessary
-
-            let old_doc = state.doc().clone();
-
             // apply changes to the document
             if !self.changes.apply(&mut state.doc) {
                 return false;
             }
-
-            // Compose this transaction with the previous one
-            take_with(&mut state.changes, |changes| {
-                changes.compose(self.changes.clone()).unwrap()
-            });
-
-            if let Some(syntax) = &mut state.syntax {
-                // TODO: no unwrap
-                syntax.update(&old_doc, &state.doc, &self.changes).unwrap();
-            }
         }
 
+        // TODO: also avoid mapping the selection if not necessary
+
         // update the selection: either take the selection specified in the transaction, or map the
         // current selection through changes.
         state.selection = self

helix-lsp/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "helix-lsp"
+version = "0.1.0"
+authors = ["Blaž Hrastnik <blaz@mxxn.io>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+helix-core = { path = "../helix-core" }
+helix-view = { path = "../helix-view" }
+once_cell = "1.4"
+
+lsp-types = { version = "0.84", features = ["proposed"] }
+smol = "1.2"
+url = "2"
+pathdiff = "0.2"
+shellexpand = "2.0"
+glob = "0.3"
+anyhow = "1"
+serde_json = "1.0"
+serde = { version = "1.0", features = ["derive"] }
+jsonrpc-core = "15.1"
+futures-util = "0.3"
+thiserror = "1"
+log = "0.4"

helix-lsp/src/client.rs

@@ -0,0 +1,355 @@
+use crate::{
+    transport::{Payload, Transport},
+    Call, Error,
+};
+
+type Result<T> = core::result::Result<T, Error>;
+
+use helix_core::{ChangeSet, Transaction};
+use helix_view::Document;
+
+// use std::collections::HashMap;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use jsonrpc_core as jsonrpc;
+use lsp_types as lsp;
+use serde_json::Value;
+
+use smol::{
+    channel::{Receiver, Sender},
+    io::{BufReader, BufWriter},
+    // prelude::*,
+    process::{Child, ChildStderr, Command, Stdio},
+    Executor,
+};
+
+pub struct Client {
+    _process: Child,
+    stderr: BufReader<ChildStderr>,
+
+    outgoing: Sender<Payload>,
+    pub incoming: Receiver<Call>,
+
+    pub request_counter: AtomicU64,
+
+    capabilities: Option<lsp::ServerCapabilities>,
+    // TODO: handle PublishDiagnostics Version
+    // diagnostics: HashMap<lsp::Url, Vec<lsp::Diagnostic>>,
+}
+
+impl Client {
+    pub fn start(ex: &Executor, cmd: &str, args: &[String]) -> Self {
+        let mut process = Command::new(cmd)
+            .args(args)
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()
+            .expect("Failed to start language server");
+        // smol makes sure the process is reaped on drop, but using kill_on_drop(true) maybe?
+
+        // TODO: do we need bufreader/writer here? or do we use async wrappers on unblock?
+        let writer = BufWriter::new(process.stdin.take().expect("Failed to open stdin"));
+        let reader = BufReader::new(process.stdout.take().expect("Failed to open stdout"));
+        let stderr = BufReader::new(process.stderr.take().expect("Failed to open stderr"));
+
+        let (incoming, outgoing) = Transport::start(ex, reader, writer);
+
+        Client {
+            _process: process,
+            stderr,
+
+            outgoing,
+            incoming,
+
+            request_counter: AtomicU64::new(0),
+
+            capabilities: None,
+            // diagnostics: HashMap::new(),
+        }
+    }
+
+    fn next_request_id(&self) -> jsonrpc::Id {
+        let id = self.request_counter.fetch_add(1, Ordering::Relaxed);
+        jsonrpc::Id::Num(id)
+    }
+
+    fn to_params(value: Value) -> Result<jsonrpc::Params> {
+        use jsonrpc::Params;
+
+        let params = match value {
+            Value::Null => Params::None,
+            Value::Bool(_) | Value::Number(_) | Value::String(_) => Params::Array(vec![value]),
+            Value::Array(vec) => Params::Array(vec),
+            Value::Object(map) => Params::Map(map),
+        };
+
+        Ok(params)
+    }
+
+    /// Execute a RPC request on the language server.
+    pub async fn request<R: lsp::request::Request>(&self, params: R::Params) -> Result<R::Result>
+    where
+        R::Params: serde::Serialize,
+        R::Result: core::fmt::Debug, // TODO: temporary
+    {
+        let params = serde_json::to_value(params)?;
+
+        let request = jsonrpc::MethodCall {
+            jsonrpc: Some(jsonrpc::Version::V2),
+            id: self.next_request_id(),
+            method: R::METHOD.to_string(),
+            params: Self::to_params(params)?,
+        };
+
+        let (tx, rx) = smol::channel::bounded::<Result<Value>>(1);
+
+        self.outgoing
+            .send(Payload::Request {
+                chan: tx,
+                value: request,
+            })
+            .await
+            .map_err(|e| Error::Other(e.into()))?;
+
+        let response = rx.recv().await.map_err(|e| Error::Other(e.into()))??;
+
+        let response = serde_json::from_value(response)?;
+
+        // TODO: we should pass request to a sender thread via a channel
+        // so it can't be interleaved
+
+        // TODO: responses can be out of order, we need to register a single shot response channel
+
+        Ok(response)
+    }
+
+    /// Send a RPC notification to the language server.
+    pub async fn notify<R: lsp::notification::Notification>(&self, params: R::Params) -> Result<()>
+    where
+        R::Params: serde::Serialize,
+    {
+        let params = serde_json::to_value(params)?;
+
+        let notification = jsonrpc::Notification {
+            jsonrpc: Some(jsonrpc::Version::V2),
+            method: R::METHOD.to_string(),
+            params: Self::to_params(params)?,
+        };
+
+        self.outgoing
+            .send(Payload::Notification(notification))
+            .await
+            .map_err(|e| Error::Other(e.into()))?;
+
+        Ok(())
+    }
+
+    /// Reply to a language server RPC call.
+    pub async fn reply(
+        &self,
+        id: jsonrpc::Id,
+        result: core::result::Result<Value, jsonrpc::Error>,
+    ) -> 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,
+            }),
+        };
+
+        self.outgoing
+            .send(Payload::Response(output))
+            .await
+            .map_err(|e| Error::Other(e.into()))?;
+
+        Ok(())
+    }
+
+    // -------------------------------------------------------------------------------------------
+    // General messages
+    // -------------------------------------------------------------------------------------------
+
+    pub async fn initialize(&mut self) -> Result<()> {
+        // TODO: delay any requests that are triggered prior to initialize
+
+        #[allow(deprecated)]
+        let params = lsp::InitializeParams {
+            process_id: Some(std::process::id()),
+            root_path: None,
+            // root_uri: Some(lsp_types::Url::parse("file://localhost/")?),
+            root_uri: None, // set to project root in the future
+            initialization_options: None,
+            capabilities: lsp::ClientCapabilities {
+                ..Default::default()
+            },
+            trace: None,
+            workspace_folders: None,
+            client_info: None,
+            locale: None, // TODO
+        };
+
+        let response = self.request::<lsp::request::Initialize>(params).await?;
+        self.capabilities = Some(response.capabilities);
+
+        // next up, notify<initialized>
+        self.notify::<lsp::notification::Initialized>(lsp::InitializedParams {})
+            .await?;
+
+        Ok(())
+    }
+
+    pub async fn shutdown(&self) -> Result<()> {
+        self.request::<lsp::request::Shutdown>(()).await
+    }
+
+    pub async fn exit(&self) -> Result<()> {
+        self.notify::<lsp::notification::Exit>(()).await
+    }
+
+    // -------------------------------------------------------------------------------------------
+    // Text document
+    // -------------------------------------------------------------------------------------------
+
+    pub async fn text_document_did_open(&mut self, doc: &Document) -> Result<()> {
+        self.notify::<lsp::notification::DidOpenTextDocument>(lsp::DidOpenTextDocumentParams {
+            text_document: lsp::TextDocumentItem {
+                uri: lsp::Url::from_file_path(doc.path().unwrap()).unwrap(),
+                language_id: "rust".to_string(), // TODO: hardcoded for now
+                version: doc.version,
+                text: String::from(doc.text()),
+            },
+        })
+        .await
+    }
+
+    fn to_changes(changeset: &ChangeSet) -> Vec<lsp::TextDocumentContentChangeEvent> {
+        let mut iter = changeset.changes().iter().peekable();
+        let mut old_pos = 0;
+
+        let mut changes = Vec::new();
+
+        use crate::util::pos_to_lsp_pos;
+        use helix_core::Operation::*;
+
+        // TEMP
+        let rope = helix_core::Rope::from("");
+        let old_text = rope.slice(..);
+
+        while let Some(change) = iter.next() {
+            let len = match change {
+                Delete(i) | Retain(i) => *i,
+                Insert(_) => 0,
+            };
+            let old_end = old_pos + len;
+
+            match change {
+                Retain(_) => {}
+                Delete(_) => {
+                    let start = pos_to_lsp_pos(&old_text, old_pos);
+                    let end = pos_to_lsp_pos(&old_text, old_end);
+
+                    // a subsequent ins means a replace, consume it
+                    if let Some(Insert(s)) = iter.peek() {
+                        iter.next();
+
+                        // replacement
+                        changes.push(lsp::TextDocumentContentChangeEvent {
+                            range: Some(lsp::Range::new(start, end)),
+                            text: s.into(),
+                            range_length: None,
+                        });
+                    } else {
+                        // deletion
+                        changes.push(lsp::TextDocumentContentChangeEvent {
+                            range: Some(lsp::Range::new(start, end)),
+                            text: "".to_string(),
+                            range_length: None,
+                        });
+                    };
+                }
+                Insert(s) => {
+                    let start = pos_to_lsp_pos(&old_text, old_pos);
+
+                    // insert
+                    changes.push(lsp::TextDocumentContentChangeEvent {
+                        range: Some(lsp::Range::new(start, start)),
+                        text: s.into(),
+                        range_length: None,
+                    });
+                }
+            }
+            old_pos = old_end;
+        }
+
+        changes
+    }
+
+    // TODO: trigger any time history.commit_revision happens
+    pub async fn text_document_did_change(
+        &mut self,
+        doc: &Document,
+        transaction: &Transaction,
+    ) -> Result<()> {
+        // figure out what kind of sync the server supports
+
+        let capabilities = self.capabilities.as_ref().unwrap(); // TODO: needs post init
+
+        let sync_capabilities = match capabilities.text_document_sync {
+            Some(lsp::TextDocumentSyncCapability::Kind(kind)) => kind,
+            Some(lsp::TextDocumentSyncCapability::Options(lsp::TextDocumentSyncOptions {
+                change: Some(kind),
+                ..
+            })) => kind,
+            // None | SyncOptions { changes: None }
+            _ => return Ok(()),
+        };
+
+        let changes = match sync_capabilities {
+            lsp::TextDocumentSyncKind::Full => {
+                vec![lsp::TextDocumentContentChangeEvent {
+                    // range = None -> whole document
+                    range: None,        //Some(Range)
+                    range_length: None, // u64 apparently deprecated
+                    text: "".to_string(),
+                }] // TODO: probably need old_state here too?
+            }
+            lsp::TextDocumentSyncKind::Incremental => Self::to_changes(transaction.changes()),
+            lsp::TextDocumentSyncKind::None => return Ok(()),
+        };
+
+        self.notify::<lsp::notification::DidChangeTextDocument>(lsp::DidChangeTextDocumentParams {
+            text_document: lsp::VersionedTextDocumentIdentifier::new(
+                lsp::Url::from_file_path(doc.path().unwrap()).unwrap(),
+                doc.version,
+            ),
+            content_changes: changes,
+        })
+        .await
+    }
+
+    // TODO: impl into() TextDocumentIdentifier / VersionedTextDocumentIdentifier for Document.
+
+    pub async fn text_document_did_close(&mut self, doc: &Document) -> Result<()> {
+        self.notify::<lsp::notification::DidCloseTextDocument>(lsp::DidCloseTextDocumentParams {
+            text_document: lsp::TextDocumentIdentifier::new(
+                lsp::Url::from_file_path(doc.path().unwrap()).unwrap(),
+            ),
+        })
+        .await
+    }
+
+    // will_save / will_save_wait_until
+
+    pub async fn text_document_did_save(&mut self) -> anyhow::Result<()> {
+        unimplemented!()
+    }
+}

helix-lsp/src/lib.rs

@@ -0,0 +1,117 @@
+mod client;
+mod transport;
+
+pub use jsonrpc_core as jsonrpc;
+pub use lsp_types as lsp;
+
+pub use once_cell::sync::{Lazy, OnceCell};
+
+pub use client::Client;
+pub use lsp::{Position, Url};
+
+use thiserror::Error;
+
+use std::{collections::HashMap, sync::Arc};
+
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("protocol error: {0}")]
+    Rpc(#[from] jsonrpc::Error),
+    #[error("failed to parse: {0}")]
+    Parse(#[from] serde_json::Error),
+    #[error("request timed out")]
+    Timeout,
+    #[error(transparent)]
+    Other(#[from] anyhow::Error),
+}
+
+pub mod util {
+    use super::*;
+
+    pub fn lsp_pos_to_pos(doc: &helix_core::RopeSlice, pos: lsp::Position) -> usize {
+        let line = doc.line_to_char(pos.line as usize);
+        let line_start = doc.char_to_utf16_cu(line);
+        doc.utf16_cu_to_char(pos.character as usize + line_start)
+    }
+    pub fn pos_to_lsp_pos(doc: &helix_core::RopeSlice, pos: usize) -> lsp::Position {
+        let line = doc.char_to_line(pos);
+        let line_start = doc.char_to_utf16_cu(line);
+        let col = doc.char_to_utf16_cu(pos) - line_start;
+
+        lsp::Position::new(line as u32, col as u32)
+    }
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum Notification {
+    PublishDiagnostics(lsp::PublishDiagnosticsParams),
+}
+
+impl Notification {
+    pub fn parse(method: &str, params: jsonrpc::Params) -> Notification {
+        use lsp::notification::Notification as _;
+
+        match method {
+            lsp::notification::PublishDiagnostics::METHOD => {
+                let params: lsp::PublishDiagnosticsParams = params
+                    .parse()
+                    .expect("Failed to parse PublishDiagnostics params");
+
+                // TODO: need to loop over diagnostics and distinguish them by URI
+                Notification::PublishDiagnostics(params)
+            }
+            _ => unimplemented!("unhandled notification: {}", method),
+        }
+    }
+}
+
+pub use jsonrpc::Call;
+
+type LanguageId = String;
+
+pub static REGISTRY: Lazy<Registry> = Lazy::new(Registry::init);
+
+pub struct Registry {
+    inner: HashMap<LanguageId, OnceCell<Arc<Client>>>,
+}
+
+impl Registry {
+    pub fn init() -> Self {
+        Self {
+            inner: HashMap::new(),
+        }
+    }
+
+    pub fn get(&self, id: &str, ex: &smol::Executor) -> Option<Arc<Client>> {
+        // TODO: use get_or_try_init and propagate the error
+        self.inner
+            .get(id)
+            .map(|cell| {
+                cell.get_or_init(|| {
+                    // TODO: lookup defaults for id (name, args)
+
+                    // initialize a new client
+                    let client = Client::start(&ex, "rust-analyzer", &[]);
+                    // TODO: also call initialize().await()
+                    Arc::new(client)
+                })
+            })
+            .cloned()
+    }
+}
+
+// REGISTRY = HashMap<LanguageId, Lazy/OnceCell<Arc<RwLock<Client>>>
+// spawn one server per language type, need to spawn one per workspace if server doesn't support
+// workspaces
+//
+// could also be a client per root dir
+//
+// storing a copy of Option<Arc<RwLock<Client>>> on Document would make the LSP client easily
+// accessible during edit/save callbacks
+//
+// the event loop needs to process all incoming streams, maybe we can just have that be a separate
+// task that's continually running and store the state on the client, then use read lock to
+// retrieve data during render
+// -> PROBLEM: how do you trigger an update on the editor side when data updates?
+//
+// -> The data updates should pull all events until we run out so we don't frequently re-render

helix-lsp/src/transport.rs

@@ -0,0 +1,212 @@
+use std::collections::HashMap;
+
+use log::debug;
+
+use crate::{Error, Notification};
+
+type Result<T> = core::result::Result<T, Error>;
+
+use jsonrpc_core as jsonrpc;
+use serde_json::Value;
+
+use smol::prelude::*;
+
+use smol::{
+    channel::{Receiver, Sender},
+    io::{BufReader, BufWriter},
+    process::{ChildStderr, ChildStdin, ChildStdout},
+    Executor,
+};
+
+pub(crate) enum Payload {
+    Request {
+        chan: Sender<Result<Value>>,
+        value: jsonrpc::MethodCall,
+    },
+    Notification(jsonrpc::Notification),
+    Response(jsonrpc::Output),
+}
+
+use serde::{Deserialize, Serialize};
+/// A type representing all possible values sent from the server to the client.
+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+#[serde(untagged)]
+enum Message {
+    /// A regular JSON-RPC request output (single response).
+    Output(jsonrpc::Output),
+    /// A JSON-RPC request or notification.
+    Call(jsonrpc::Call),
+}
+
+pub(crate) struct Transport {
+    incoming: Sender<jsonrpc::Call>,
+    outgoing: Receiver<Payload>,
+
+    pending_requests: HashMap<jsonrpc::Id, Sender<Result<Value>>>,
+    headers: HashMap<String, String>,
+
+    writer: BufWriter<ChildStdin>,
+    reader: BufReader<ChildStdout>,
+}
+
+impl Transport {
+    pub fn start(
+        ex: &Executor,
+        reader: BufReader<ChildStdout>,
+        writer: BufWriter<ChildStdin>,
+    ) -> (Receiver<jsonrpc::Call>, Sender<Payload>) {
+        let (incoming, rx) = smol::channel::unbounded();
+        let (tx, outgoing) = smol::channel::unbounded();
+
+        let transport = Self {
+            reader,
+            writer,
+            incoming,
+            outgoing,
+            pending_requests: Default::default(),
+            headers: Default::default(),
+        };
+
+        ex.spawn(transport.duplex()).detach();
+
+        (rx, tx)
+    }
+
+    async fn recv(
+        reader: &mut (impl AsyncBufRead + Unpin),
+        headers: &mut HashMap<String, String>,
+    ) -> core::result::Result<Message, std::io::Error> {
+        // read headers
+        loop {
+            let mut header = String::new();
+            // detect pipe closed if 0
+            reader.read_line(&mut header).await?;
+            let header = header.trim();
+
+            if header.is_empty() {
+                break;
+            }
+
+            let parts: Vec<&str> = header.split(": ").collect();
+            if parts.len() != 2 {
+                return Err(std::io::Error::new(
+                    std::io::ErrorKind::Other,
+                    "Failed to parse header",
+                ));
+            }
+            headers.insert(parts[0].to_string(), parts[1].to_string());
+        }
+
+        // find content-length
+        let content_length = headers.get("Content-Length").unwrap().parse().unwrap();
+
+        let mut content = vec![0; content_length];
+        reader.read_exact(&mut content).await?;
+        let msg = String::from_utf8(content).unwrap();
+
+        // read data
+
+        // try parsing as output (server response) or call (server request)
+        let output: serde_json::Result<Message> = serde_json::from_str(&msg);
+
+        Ok(output?)
+    }
+
+    pub async fn send_payload(&mut self, payload: Payload) -> anyhow::Result<()> {
+        match payload {
+            Payload::Request { chan, value } => {
+                self.pending_requests.insert(value.id.clone(), chan);
+
+                let json = serde_json::to_string(&value)?;
+                self.send(json).await
+            }
+            Payload::Notification(value) => {
+                let json = serde_json::to_string(&value)?;
+                self.send(json).await
+            }
+            Payload::Response(error) => {
+                let json = serde_json::to_string(&error)?;
+                self.send(json).await
+            }
+        }
+    }
+
+    pub async fn send(&mut self, request: String) -> anyhow::Result<()> {
+        debug!("-> {}", request);
+
+        // send the headers
+        self.writer
+            .write_all(format!("Content-Length: {}\r\n\r\n", request.len()).as_bytes())
+            .await?;
+
+        // send the body
+        self.writer.write_all(request.as_bytes()).await?;
+
+        self.writer.flush().await?;
+
+        Ok(())
+    }
+
+    async fn recv_msg(&mut self, msg: Message) -> anyhow::Result<()> {
+        match msg {
+            Message::Output(output) => self.recv_response(output).await?,
+            Message::Call(call) => {
+                self.incoming.send(call).await?;
+                // let notification = Notification::parse(&method, params);
+            }
+        };
+        Ok(())
+    }
+
+    async fn recv_response(&mut self, output: jsonrpc::Output) -> anyhow::Result<()> {
+        match output {
+            jsonrpc::Output::Success(jsonrpc::Success { id, result, .. }) => {
+                debug!("<- {}", result);
+
+                let tx = self
+                    .pending_requests
+                    .remove(&id)
+                    .expect("pending_request with id not found!");
+                tx.send(Ok(result)).await?;
+            }
+            jsonrpc::Output::Failure(jsonrpc::Failure { id, error, .. }) => {
+                let tx = self
+                    .pending_requests
+                    .remove(&id)
+                    .expect("pending_request with id not found!");
+                tx.send(Err(error.into())).await?;
+            }
+            msg => unimplemented!("{:?}", msg),
+        }
+        Ok(())
+    }
+
+    pub async fn duplex(mut self) {
+        use futures_util::{select, FutureExt};
+        loop {
+            select! {
+                // client -> server
+                msg = self.outgoing.next().fuse() => {
+                    if msg.is_none() {
+                        break;
+                    }
+                    let msg = msg.unwrap();
+
+                    self.send_payload(msg).await.unwrap();
+                }
+                // server <- client
+                msg = Self::recv(&mut self.reader, &mut self.headers).fuse() => {
+                    if msg.is_err() {
+                        break;
+                    }
+                    let msg = msg.unwrap();
+
+                    debug!("<- {:?}", msg);
+
+                    self.recv_msg(msg).await.unwrap();
+                }
+            }
+        }
+    }
+}

helix-term/Cargo.toml

@@ -14,12 +14,20 @@ path = "src/main.rs"
 [dependencies]
 helix-core = { path = "../helix-core" }
 helix-view = { path = "../helix-view", features = ["term"]}
+helix-lsp = { path = "../helix-lsp"}
 
 anyhow = "1"
 
 smol = "1"
-num_cpus = "1.13"
+num_cpus = "1"
 # tui = { version = "0.12", default-features = false, features = ["crossterm"] }
 tui = { git = "https://github.com/fdehau/tui-rs", default-features = false, features = ["crossterm"] }
 crossterm = { version = "0.18", features = ["event-stream"] }
 clap = { version = "3.0.0-beta.2 ", default-features = false, features = ["std", "cargo"] }
+
+futures-util = "0.3"
+
+# Logging
+fern = "0.6"
+chrono = "0.4"
+log = "0.4"

helix-term/src/application.rs

@@ -1,6 +1,14 @@
 use clap::ArgMatches as Args;
-use helix_core::{indent::TAB_WIDTH, state::Mode, syntax::HighlightEvent, Position, Range, State};
+use helix_core::{indent::TAB_WIDTH, syntax::HighlightEvent, Position, Range, State};
-use helix_view::{commands, keymap, prompt::Prompt, Editor, View};
+use helix_view::{
+    commands,
+    document::Mode,
+    keymap::{self, Keymaps},
+    prompt::Prompt,
+    Document, Editor, Theme, View,
+};
+
+use log::{debug, info};
 
 use std::{
     borrow::Cow,
@@ -15,8 +23,7 @@ use anyhow::Error;
 
 use crossterm::{
     cursor,
-    cursor::position,
+    event::{read, Event, EventStream, KeyCode, KeyEvent},
-    event::{self, read, Event, EventStream, KeyCode, KeyEvent},
     execute, queue,
     terminal::{self, disable_raw_mode, enable_raw_mode},
 };
@@ -25,21 +32,23 @@ use tui::{
     backend::CrosstermBackend,
     buffer::Buffer as Surface,
     layout::Rect,
-    style::{Color, Style},
+    style::{Color, Modifier, Style},
 };
 
-const OFFSET: u16 = 6; // 5 linenr + 1 gutter
+const OFFSET: u16 = 7; // 1 diagnostic + 5 linenr + 1 gutter
 
 type Terminal = tui::Terminal<CrosstermBackend<std::io::Stdout>>;
 
-static EX: smol::Executor = smol::Executor::new();
-
 const BASE_WIDTH: u16 = 30;
 
-pub struct Application {
+pub struct Application<'a> {
     editor: Editor,
     prompt: Option<Prompt>,
     terminal: Renderer,
+
+    keymap: Keymaps,
+    executor: &'a smol::Executor<'a>,
+    language_server: helix_lsp::Client,
 }
 
 struct Renderer {
@@ -75,30 +84,29 @@ impl Renderer {
         self.cache = Surface::empty(area);
     }
 
-    pub fn render_view(&mut self, view: &mut View, viewport: Rect) {
+    pub fn render_view(&mut self, view: &mut View, viewport: Rect, theme: &Theme) {
-        self.render_buffer(view, viewport);
+        self.render_buffer(view, viewport, theme);
-        self.render_statusline(view);
+        self.render_statusline(view, theme);
     }
 
     // TODO: ideally not &mut View but highlights require it because of cursor cache
-    pub fn render_buffer(&mut self, view: &mut View, viewport: Rect) {
+    pub fn render_buffer(&mut self, view: &mut View, viewport: Rect, theme: &Theme) {
         let area = Rect::new(0, 0, self.size.0, self.size.1);
         self.surface.reset(); // reset is faster than allocating new empty surface
 
         //  clear with background color
-        self.surface
+        self.surface.set_style(area, theme.get("ui.background"));
-            .set_style(area, view.theme.get("ui.background"));
 
         // TODO: inefficient, should feed chunks.iter() to tree_sitter.parse_with(|offset, pos|)
-        let source_code = view.state.doc().to_string();
+        let source_code = view.doc.text().to_string();
 
         let last_line = view.last_line();
 
         let range = {
             // calculate viewport byte ranges
-            let start = view.state.doc().line_to_byte(view.first_line);
+            let start = view.doc.text().line_to_byte(view.first_line);
-            let end = view.state.doc().line_to_byte(last_line)
+            let end = view.doc.text().line_to_byte(last_line)
-                + view.state.doc().line(last_line).len_bytes();
+                + view.doc.text().line(last_line).len_bytes();
 
             start..end
         };
@@ -106,7 +114,7 @@ impl Renderer {
         // TODO: range doesn't actually restrict source, just highlight range
         // TODO: cache highlight results
         // TODO: only recalculate when state.doc is actually modified
-        let highlights: Vec<_> = match view.state.syntax.as_mut() {
+        let highlights: Vec<_> = match view.doc.syntax.as_mut() {
             Some(syntax) => {
                 syntax
                     .highlight_iter(source_code.as_bytes(), Some(range), None, |_| None)
@@ -122,6 +130,7 @@ impl Renderer {
         let mut visual_x = 0;
         let mut line = 0u16;
         let visible_selections: Vec<Range> = view
+            .doc
             .state
             .selection()
             .ranges()
@@ -142,15 +151,15 @@ impl Renderer {
                 HighlightEvent::Source { start, end } => {
                     // TODO: filter out spans out of viewport for now..
 
-                    let start = view.state.doc().byte_to_char(start);
+                    let start = view.doc.text().byte_to_char(start);
-                    let end = view.state.doc().byte_to_char(end); // <-- index 744, len 743
+                    let end = view.doc.text().byte_to_char(end); // <-- index 744, len 743
 
-                    let text = view.state.doc().slice(start..end);
+                    let text = view.doc.text().slice(start..end);
 
                     use helix_core::graphemes::{grapheme_width, RopeGraphemes};
 
                     let style = match spans.first() {
-                        Some(span) => view.theme.get(view.theme.scopes()[span.0].as_str()),
+                        Some(span) => theme.get(theme.scopes()[span.0].as_str()),
                         None => Style::default().fg(Color::Rgb(164, 160, 232)), // lavender
                     };
 
@@ -200,6 +209,16 @@ impl Renderer {
                                 style
                             };
 
+                            // ugh, improve with a traverse method
+                            // or interleave highlight spans with selection and diagnostic spans
+                            let style = if view.doc.diagnostics.iter().any(|diagnostic| {
+                                diagnostic.range.0 <= char_index && diagnostic.range.1 > char_index
+                            }) {
+                                style.clone().add_modifier(Modifier::UNDERLINED)
+                            } else {
+                                style
+                            };
+
                             // TODO: paint cursor heads except primary
 
                             self.surface
@@ -207,23 +226,28 @@ impl Renderer {
 
                             visual_x += width;
                         }
-                        // if grapheme == "\t"
 
                         char_index += 1;
                     }
                 }
             }
         }
-        let style: Style = view.theme.get("ui.linenr");
+
+        let style: Style = theme.get("ui.linenr");
+        let warning: Style = theme.get("warning");
         let last_line = view.last_line();
         for (i, line) in (view.first_line..last_line).enumerate() {
+            if view.doc.diagnostics.iter().any(|d| d.line == line) {
+                self.surface.set_stringn(0, i as u16, "●", 1, warning);
+            }
+
             self.surface
-                .set_stringn(0, i as u16, format!("{:>5}", line + 1), 5, style);
+                .set_stringn(1, i as u16, format!("{:>5}", line + 1), 5, style);
         }
     }
 
-    pub fn render_statusline(&mut self, view: &View) {
+    pub fn render_statusline(&mut self, view: &View, theme: &Theme) {
-        let mode = match view.state.mode() {
+        let mode = match view.doc.mode() {
             Mode::Insert => "INS",
             Mode::Normal => "NOR",
             Mode::Goto => "GOTO",
@@ -231,13 +255,20 @@ impl Renderer {
         // statusline
         self.surface.set_style(
             Rect::new(0, self.size.1 - 2, self.size.0, 1),
-            view.theme.get("ui.statusline"),
+            theme.get("ui.statusline"),
         );
         self.surface
             .set_string(1, self.size.1 - 2, mode, self.text_color);
+
+        self.surface.set_string(
+            self.size.0 - 10,
+            self.size.1 - 2,
+            format!("{}", view.doc.diagnostics.len()),
+            self.text_color,
+        );
     }
 
-    pub fn render_prompt(&mut self, view: &View, prompt: &Prompt) {
+    pub fn render_prompt(&mut self, view: &View, prompt: &Prompt, theme: &Theme) {
         // completion
         if !prompt.completion.is_empty() {
             // TODO: find out better way of clearing individual lines of the screen
@@ -256,7 +287,7 @@ impl Renderer {
             }
             self.surface.set_style(
                 Rect::new(0, self.size.1 - col_height - 2, self.size.0, col_height),
-                view.theme.get("ui.statusline"),
+                theme.get("ui.statusline"),
             );
             for (i, command) in prompt.completion.iter().enumerate() {
                 let color = if prompt.completion_selection_index.is_some()
@@ -302,14 +333,14 @@ impl Renderer {
 
     pub fn render_cursor(&mut self, view: &View, prompt: Option<&Prompt>, viewport: Rect) {
         let mut stdout = stdout();
-        match view.state.mode() {
+        match view.doc.mode() {
             Mode::Insert => write!(stdout, "\x1B[6 q"),
             mode => write!(stdout, "\x1B[2 q"),
         };
         let pos = if let Some(prompt) = prompt {
             Position::new(self.size.0 as usize, 2 + prompt.cursor)
         } else {
-            if let Some(path) = view.state.path() {
+            if let Some(path) = view.doc.path() {
                 self.surface.set_string(
                     6,
                     self.size.1 - 1,
@@ -318,10 +349,10 @@ impl Renderer {
                 );
             }
 
-            let cursor = view.state.selection().cursor();
+            let cursor = view.doc.state.selection().cursor();
 
             let mut pos = view
-                .screen_coords_at_pos(&view.state.doc().slice(..), cursor)
+                .screen_coords_at_pos(&view.doc.text().slice(..), cursor)
                 .expect("Cursor is out of bounds.");
             pos.col += viewport.x as usize;
             pos.row += viewport.y as usize;
@@ -332,8 +363,8 @@ impl Renderer {
     }
 }
 
-impl Application {
+impl<'a> Application<'a> {
-    pub fn new(mut args: Args) -> Result<Self, Error> {
+    pub fn new(mut args: Args, executor: &'a smol::Executor<'a>) -> Result<Self, Error> {
         let terminal = Renderer::new()?;
         let mut editor = Editor::new();
 
@@ -341,11 +372,18 @@ impl Application {
             editor.open(file, terminal.size)?;
         }
 
+        let language_server = helix_lsp::Client::start(&executor, "rust-analyzer", &[]);
+
         let mut app = Self {
             editor,
             terminal,
             // TODO; move to state
             prompt: None,
+
+            //
+            keymap: keymap::default(),
+            executor,
+            language_server,
         };
 
         Ok(app)
@@ -354,13 +392,16 @@ impl Application {
     fn render(&mut self) {
         let viewport = Rect::new(OFFSET, 0, self.terminal.size.0, self.terminal.size.1 - 2); // - 2 for statusline and prompt
 
-        if let Some(view) = &mut self.editor.view {
+        // SAFETY: we cheat around the view_mut() borrow because it doesn't allow us to also borrow
-            self.terminal.render_view(view, viewport);
+        // theme. Theme is immutable mutating view won't disrupt theme_ref.
+        let theme_ref = unsafe { &*(&self.editor.theme as *const Theme) };
+        if let Some(view) = self.editor.view_mut() {
+            self.terminal.render_view(view, viewport, theme_ref);
             if let Some(prompt) = &self.prompt {
                 if prompt.should_close {
                     self.prompt = None;
                 } else {
-                    self.terminal.render_prompt(view, prompt);
+                    self.terminal.render_prompt(view, prompt, theme_ref);
                 }
             }
         }
@@ -368,16 +409,19 @@ impl Application {
         self.terminal.draw();
 
         // TODO: drop unwrap
-        self.terminal.render_cursor(
+        self.terminal
-            self.editor.view.as_ref().unwrap(),
+            .render_cursor(self.editor.view().unwrap(), self.prompt.as_ref(), viewport);
-            self.prompt.as_ref(),
-            viewport,
-        );
     }
 
     pub async fn event_loop(&mut self) {
         let mut reader = EventStream::new();
-        let keymap = keymap::default();
+
+        // initialize lsp
+        self.language_server.initialize().await.unwrap();
+        self.language_server
+            .text_document_did_open(&self.editor.view().unwrap().doc)
+            .await
+            .unwrap();
 
         self.render();
 
@@ -386,125 +430,225 @@ impl Application {
                 break;
             }
 
-            // Handle key events
+            use futures_util::{select, FutureExt};
-            match reader.next().await {
+            select! {
-                Some(Ok(Event::Resize(width, height))) => {
+                event = reader.next().fuse() => {
-                    self.terminal.resize(width, height);
+                    self.handle_terminal_events(event).await
+                }
+                call = self.language_server.incoming.next().fuse() => {
+                    self.handle_language_server_message(call).await
+                }
+            }
+        }
+    }
 
-                    // TODO: simplistic ensure cursor in view for now
+    pub async fn handle_terminal_events(
-                    if let Some(view) = &mut self.editor.view {
+        &mut self,
-                        view.size = self.terminal.size;
+        event: Option<Result<Event, crossterm::ErrorKind>>,
-                        view.ensure_cursor_in_view()
+    ) {
-                    };
+        // Handle key events
+        match event {
+            Some(Ok(Event::Resize(width, height))) => {
+                self.terminal.resize(width, height);
+
+                // TODO: simplistic ensure cursor in view for now
+                // TODO: loop over views
+                if let Some(view) = self.editor.view_mut() {
+                    view.size = self.terminal.size;
+                    view.ensure_cursor_in_view()
+                };
+
+                self.render();
+            }
+            Some(Ok(Event::Key(event))) => {
+                // if there's a prompt, it takes priority
+                if let Some(prompt) = &mut self.prompt {
+                    self.prompt
+                        .as_mut()
+                        .unwrap()
+                        .handle_input(event, &mut self.editor);
 
                     self.render();
-                }
+                } else if let Some(view) = self.editor.view_mut() {
-                Some(Ok(Event::Key(event))) => {
+                    let keys = vec![event];
-                    // if there's a prompt, it takes priority
+                    // TODO: sequences (`gg`)
-                    if let Some(prompt) = &mut self.prompt {
+                    // TODO: handle count other than 1
-                        self.prompt
+                    match view.doc.mode() {
-                            .as_mut()
+                        Mode::Insert => {
-                            .unwrap()
+                            if let Some(command) = self.keymap[&Mode::Insert].get(&keys) {
-                            .handle_input(event, &mut self.editor);
+                                let mut cx = helix_view::commands::Context {
-
+                                    view,
-                        self.render();
+                                    executor: self.executor,
-                    } else if let Some(view) = &mut self.editor.view {
+                                    count: 1,
-                        let keys = vec![event];
+                                };
-                        // TODO: sequences (`gg`)
+
-                        // TODO: handle count other than 1
+                                command(&mut cx);
-                        match view.state.mode() {
+                            } else if let KeyEvent {
-                            Mode::Insert => {
+                                code: KeyCode::Char(c),
-                                if let Some(command) = keymap[&Mode::Insert].get(&keys) {
+                                ..
-                                    command(view, 1);
+                            } = event
-                                } else if let KeyEvent {
+                            {
-                                    code: KeyCode::Char(c),
+                                let mut cx = helix_view::commands::Context {
-                                    ..
+                                    view,
-                                } = event
+                                    executor: self.executor,
-                                {
+                                    count: 1,
-                                    commands::insert::insert_char(view, c);
+                                };
-                                }
+                                commands::insert::insert_char(&mut cx, c);
+                            }
+                            view.ensure_cursor_in_view();
+                        }
+                        Mode::Normal => {
+                            if let &[KeyEvent {
+                                code: KeyCode::Char(':'),
+                                ..
+                            }] = keys.as_slice()
+                            {
+                                let prompt = Prompt::new(
+                                    ":".to_owned(),
+                                    |_input: &str| {
+                                        // TODO: i need this duplicate list right now to avoid borrow checker issues
+                                        let command_list = vec![
+                                            String::from("q"),
+                                            String::from("aaa"),
+                                            String::from("bbb"),
+                                            String::from("ccc"),
+                                            String::from("ddd"),
+                                            String::from("eee"),
+                                            String::from("averylongcommandaverylongcommandaverylongcommandaverylongcommandaverylongcommand"),
+                                            String::from("q"),
+                                            String::from("aaa"),
+                                            String::from("bbb"),
+                                            String::from("ccc"),
+                                            String::from("ddd"),
+                                            String::from("eee"),
+                                            String::from("q"),
+                                            String::from("aaa"),
+                                            String::from("bbb"),
+                                            String::from("ccc"),
+                                            String::from("ddd"),
+                                            String::from("eee"),
+                                            String::from("q"),
+                                            String::from("aaa"),
+                                            String::from("bbb"),
+                                            String::from("ccc"),
+                                            String::from("ddd"),
+                                            String::from("eee"),
+                                            String::from("q"),
+                                            String::from("aaa"),
+                                            String::from("bbb"),
+                                            String::from("ccc"),
+                                            String::from("ddd"),
+                                            String::from("eee"),
+                                        ];
+                                        command_list
+                                            .into_iter()
+                                            .filter(|command| command.contains(_input))
+                                            .collect()
+                                    }, // completion
+                                    |editor: &mut Editor, input: &str| match input {
+                                        "q" => editor.should_close = true,
+                                        _ => (),
+                                    },
+                                );
+
+                                self.prompt = Some(prompt);
+
+                            // HAXX: special casing for command mode
+                            } else if let Some(command) = self.keymap[&Mode::Normal].get(&keys) {
+                                let mut cx = helix_view::commands::Context {
+                                    view,
+                                    executor: self.executor,
+                                    count: 1,
+                                };
+                                command(&mut cx);
+
+                                // TODO: simplistic ensure cursor in view for now
                                 view.ensure_cursor_in_view();
                             }
-                            Mode::Normal => {
+                        }
-                                if let &[KeyEvent {
+                        mode => {
-                                    code: KeyCode::Char(':'),
+                            if let Some(command) = self.keymap[&mode].get(&keys) {
-                                    ..
+                                let mut cx = helix_view::commands::Context {
-                                }] = keys.as_slice()
+                                    view,
-                                {
+                                    executor: self.executor,
-                                    let prompt = Prompt::new(
+                                    count: 1,
-                                        ":".to_owned(),
+                                };
-                                        |_input: &str| {
+                                command(&mut cx);
-                                            // TODO: i need this duplicate list right now to avoid borrow checker issues
+
-                                            let command_list = vec![
+                                // TODO: simplistic ensure cursor in view for now
-                                                String::from("q"),
+                                view.ensure_cursor_in_view();
-                                                String::from("aaa"),
-                                                String::from("bbb"),
-                                                String::from("ccc"),
-                                                String::from("ddd"),
-                                                String::from("eee"),
-                                                String::from("averylongcommandaverylongcommandaverylongcommandaverylongcommandaverylongcommand"),
-                                                String::from("q"),
-                                                String::from("aaa"),
-                                                String::from("bbb"),
-                                                String::from("ccc"),
-                                                String::from("ddd"),
-                                                String::from("eee"),
-                                                String::from("q"),
-                                                String::from("aaa"),
-                                                String::from("bbb"),
-                                                String::from("ccc"),
-                                                String::from("ddd"),
-                                                String::from("eee"),
-                                                String::from("q"),
-                                                String::from("aaa"),
-                                                String::from("bbb"),
-                                                String::from("ccc"),
-                                                String::from("ddd"),
-                                                String::from("eee"),
-                                                String::from("q"),
-                                                String::from("aaa"),
-                                                String::from("bbb"),
-                                                String::from("ccc"),
-                                                String::from("ddd"),
-                                                String::from("eee"),
-                                            ];
-                                            command_list
-                                                .into_iter()
-                                                .filter(|command| command.contains(_input))
-                                                .collect()
-                                        }, // completion
-                                        |editor: &mut Editor, input: &str| match input {
-                                            "q" => editor.should_close = true,
-                                            _ => (),
-                                        },
-                                    );
-
-                                    self.prompt = Some(prompt);
-
-                                // HAXX: special casing for command mode
-                                } else if let Some(command) = keymap[&Mode::Normal].get(&keys) {
-                                    command(view, 1);
-
-                                    // TODO: simplistic ensure cursor in view for now
-                                    view.ensure_cursor_in_view();
-                                }
                             }
-                            mode => {
+                        }
-                                if let Some(command) = keymap[&mode].get(&keys) {
+                    }
-                                    command(view, 1);
+                    self.render();
+                }
+            }
+            Some(Ok(Event::Mouse(_))) => (), // unhandled
+            Some(Err(x)) => panic!(x),
+            None => panic!(),
+        };
+    }
 
-                                    // TODO: simplistic ensure cursor in view for now
+    pub async fn handle_language_server_message(&mut self, call: Option<helix_lsp::Call>) {
-                                    view.ensure_cursor_in_view();
+        use helix_lsp::{Call, Notification};
-                                }
+        match call {
-                            }
+            Some(Call::Notification(helix_lsp::jsonrpc::Notification {
+                method, params, ..
+            })) => {
+                let notification = Notification::parse(&method, params);
+                match notification {
+                    Notification::PublishDiagnostics(params) => {
+                        let path = Some(params.uri.to_file_path().unwrap());
+                        let view = self
+                            .editor
+                            .views
+                            .iter_mut()
+                            .find(|view| view.doc.path == path);
+
+                        if let Some(view) = view {
+                            let doc = view.doc.text().slice(..);
+                            let diagnostics = params
+                                .diagnostics
+                                .into_iter()
+                                .map(|diagnostic| {
+                                    use helix_lsp::util::lsp_pos_to_pos;
+                                    let start = lsp_pos_to_pos(&doc, diagnostic.range.start);
+                                    let end = lsp_pos_to_pos(&doc, diagnostic.range.end);
+
+                                    helix_core::Diagnostic {
+                                        range: (start, end),
+                                        line: diagnostic.range.start.line as usize,
+                                        message: diagnostic.message,
+                                        // severity
+                                        // code
+                                        // source
+                                    }
+                                })
+                                .collect();
+
+                            view.doc.diagnostics = diagnostics;
+
+                            // TODO: we want to process all the events in queue, then render. publishDiagnostic tends to send a whole bunch of events
+                            self.render();
                         }
-                        self.render();
                     }
+                    _ => unreachable!(),
                 }
-                Some(Ok(Event::Mouse(_))) => (), // unhandled
-                Some(Err(x)) => panic!(x),
-                None => break,
             }
+            Some(Call::MethodCall(call)) => {
+                debug!("Method not found {}", call.method);
+
+                self.language_server.reply(
+                    call.id,
+                    // TODO: make a Into trait that can cast to Err(jsonrpc::Error)
+                    Err(helix_lsp::jsonrpc::Error {
+                        code: helix_lsp::jsonrpc::ErrorCode::MethodNotFound,
+                        message: "Method not found".to_string(),
+                        data: None,
+                    }),
+                );
+            }
+            _ => unreachable!(),
         }
     }
 

helix-term/src/main.rs

@@ -11,6 +11,39 @@ use anyhow::Error;
 
 static EX: smol::Executor = smol::Executor::new();
 
+fn setup_logging(verbosity: u64) -> Result<(), fern::InitError> {
+    let mut base_config = fern::Dispatch::new();
+
+    // Let's say we depend on something which whose "info" level messages are too
+    // verbose to include in end-user output. If we don't need them,
+    // let's not include them.
+    // .level_for("overly-verbose-target", log::LevelFilter::Warn)
+
+    base_config = match verbosity {
+        0 => base_config.level(log::LevelFilter::Warn),
+        1 => base_config.level(log::LevelFilter::Info),
+        2 => base_config.level(log::LevelFilter::Debug),
+        _3_or_more => base_config.level(log::LevelFilter::Trace),
+    };
+
+    // Separate file config so we can include year, month and day in file logs
+    let file_config = fern::Dispatch::new()
+        .format(|out, message, record| {
+            out.finish(format_args!(
+                "{} {} [{}] {}",
+                chrono::Local::now().format("%Y-%m-%dT%H:%M:%S%.3f"),
+                record.target(),
+                record.level(),
+                message
+            ))
+        })
+        .chain(fern::log_file("helix.log")?);
+
+    base_config.chain(file_config).apply()?;
+
+    Ok(())
+}
+
 fn main() -> Result<(), Error> {
     let args = clap::app_from_crate!()
         .arg(
@@ -20,15 +53,27 @@ fn main() -> Result<(), Error> {
                 .multiple(true)
                 .index(1),
         )
+        .arg(
+            Arg::new("verbose")
+                .about("Increases logging verbosity each use for up to 3 times")
+                .short('v')
+                .takes_value(false)
+                .multiple_occurrences(true),
+        )
         .get_matches();
 
+    let verbosity: u64 = args.occurrences_of("verbose");
+
+    setup_logging(verbosity).expect("failed to initialize logging.");
+
     for _ in 0..num_cpus::get() {
         std::thread::spawn(move || smol::block_on(EX.run(smol::future::pending::<()>())));
     }
 
-    smol::block_on(EX.run(async {
+    let mut app = Application::new(args, &EX).unwrap();
-        Application::new(args).unwrap().run().await;
+
-    }));
+    // we use the thread local executor to spawn the application task separately from the work pool
+    smol::block_on(app.run());
 
     Ok(())
 }

helix-view/Cargo.toml

@@ -19,3 +19,6 @@ helix-core = { path = "../helix-core" }
 tui = { git = "https://github.com/fdehau/tui-rs", default-features = false, features = ["crossterm"], optional = true}
 crossterm = { version = "0.18", features = ["event-stream"], optional = true}
 once_cell = "1.4"
+url = "2"
+
+smol = "1"

helix-view/src/commands.rs

@@ -3,52 +3,65 @@ use helix_core::{
     indent::TAB_WIDTH,
     regex::Regex,
     register, selection,
-    state::{Direction, Granularity, Mode, State},
+    state::{Direction, Granularity, State},
     ChangeSet, Range, Selection, Tendril, Transaction,
 };
 use once_cell::sync::Lazy;
 
 use crate::{
+    document::Mode,
     prompt::Prompt,
     view::{View, PADDING},
 };
 
+pub struct Context<'a, 'b> {
+    pub count: usize,
+    pub view: &'a mut View,
+    pub executor: &'a smol::Executor<'b>,
+}
+
 /// 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(view: &mut View, count: usize);
+pub type Command = fn(cx: &mut Context);
 
-pub fn move_char_left(view: &mut View, count: usize) {
+pub fn move_char_left(cx: &mut Context) {
-    // TODO: use a transaction
+    let selection =
-    let selection = view
+        cx.view
-        .state
+            .doc
-        .move_selection(Direction::Backward, Granularity::Character, count);
+            .state
-    view.state.selection = selection;
+            .move_selection(Direction::Backward, Granularity::Character, cx.count);
+    cx.view.doc.set_selection(selection);
 }
 
-pub fn move_char_right(view: &mut View, count: usize) {
+pub fn move_char_right(cx: &mut Context) {
-    // TODO: use a transaction
+    let selection =
-    view.state.selection =
+        cx.view
-        view.state
+            .doc
-            .move_selection(Direction::Forward, Granularity::Character, count);
+            .state
+            .move_selection(Direction::Forward, Granularity::Character, cx.count);
+    cx.view.doc.set_selection(selection);
 }
 
-pub fn move_line_up(view: &mut View, count: usize) {
+pub fn move_line_up(cx: &mut Context) {
-    // TODO: use a transaction
+    let selection =
-    view.state.selection = view
+        cx.view
-        .state
+            .doc
-        .move_selection(Direction::Backward, Granularity::Line, count);
+            .state
+            .move_selection(Direction::Backward, Granularity::Line, cx.count);
+    cx.view.doc.set_selection(selection);
 }
 
-pub fn move_line_down(view: &mut View, count: usize) {
+pub fn move_line_down(cx: &mut Context) {
-    // TODO: use a transaction
+    let selection =
-    view.state.selection = view
+        cx.view
-        .state
+            .doc
-        .move_selection(Direction::Forward, Granularity::Line, count);
+            .state
+            .move_selection(Direction::Forward, Granularity::Line, cx.count);
+    cx.view.doc.set_selection(selection);
 }
 
-pub fn move_line_end(view: &mut View, _count: usize) {
+pub fn move_line_end(cx: &mut Context) {
-    // TODO: use a transaction
+    let lines = selection_lines(&cx.view.doc.state);
-    let lines = selection_lines(&view.state);
 
     let positions = lines
         .into_iter()
@@ -57,89 +70,80 @@ pub fn move_line_end(view: &mut View, _count: usize) {
 
             // Line end is pos at the start of next line - 1
             // subtract another 1 because the line ends with \n
-            view.state.doc.line_to_char(index + 1).saturating_sub(2)
+            cx.view.doc.text().line_to_char(index + 1).saturating_sub(2)
         })
         .map(|pos| Range::new(pos, pos));
 
     let selection = Selection::new(positions.collect(), 0);
 
-    let transaction = Transaction::new(&mut view.state).with_selection(selection);
+    cx.view.doc.set_selection(selection);
-
-    transaction.apply(&mut view.state);
 }
 
-pub fn move_line_start(view: &mut View, _count: usize) {
+pub fn move_line_start(cx: &mut Context) {
-    let lines = selection_lines(&view.state);
+    let lines = selection_lines(&cx.view.doc.state);
 
     let positions = lines
         .into_iter()
         .map(|index| {
             // adjust all positions to the start of the line.
-            view.state.doc.line_to_char(index)
+            cx.view.doc.text().line_to_char(index)
         })
         .map(|pos| Range::new(pos, pos));
 
     let selection = Selection::new(positions.collect(), 0);
 
-    let transaction = Transaction::new(&mut view.state).with_selection(selection);
+    cx.view.doc.set_selection(selection);
-
-    transaction.apply(&mut view.state);
 }
 
-pub fn move_next_word_start(view: &mut View, count: usize) {
+pub fn move_next_word_start(cx: &mut Context) {
-    let pos = view.state.move_pos(
+    let pos = cx.view.doc.state.move_pos(
-        view.state.selection.cursor(),
+        cx.view.doc.selection().cursor(),
         Direction::Forward,
         Granularity::Word,
-        count,
+        cx.count,
     );
 
-    // TODO: use a transaction
+    cx.view.doc.set_selection(Selection::point(pos));
-    view.state.selection = Selection::single(pos, pos);
 }
 
-pub fn move_prev_word_start(view: &mut View, count: usize) {
+pub fn move_prev_word_start(cx: &mut Context) {
-    let pos = view.state.move_pos(
+    let pos = cx.view.doc.state.move_pos(
-        view.state.selection.cursor(),
+        cx.view.doc.selection().cursor(),
         Direction::Backward,
         Granularity::Word,
-        count,
+        cx.count,
     );
 
-    // TODO: use a transaction
+    cx.view.doc.set_selection(Selection::point(pos));
-    view.state.selection = Selection::single(pos, pos);
 }
 
-pub fn move_next_word_end(view: &mut View, count: usize) {
+pub fn move_next_word_end(cx: &mut Context) {
     let pos = State::move_next_word_end(
-        &view.state.doc().slice(..),
+        &cx.view.doc.text().slice(..),
-        view.state.selection.cursor(),
+        cx.view.doc.selection().cursor(),
-        count,
+        cx.count,
     );
 
-    // TODO: use a transaction
+    cx.view.doc.set_selection(Selection::point(pos));
-    view.state.selection = Selection::single(pos, pos);
 }
 
-pub fn move_file_start(view: &mut View, _count: usize) {
+pub fn move_file_start(cx: &mut Context) {
-    // TODO: use a transaction
+    cx.view.doc.set_selection(Selection::point(0));
-    view.state.selection = Selection::single(0, 0);
 
-    view.state.mode = Mode::Normal;
+    cx.view.doc.mode = Mode::Normal;
 }
 
-pub fn move_file_end(view: &mut View, _count: usize) {
+pub fn move_file_end(cx: &mut Context) {
-    // TODO: use a transaction
+    let text = &cx.view.doc.text();
-    let text = &view.state.doc;
     let last_line = text.line_to_char(text.len_lines().saturating_sub(2));
-    view.state.selection = Selection::single(last_line, last_line);
+    cx.view.doc.set_selection(Selection::point(last_line));
 
-    view.state.mode = Mode::Normal;
+    cx.view.doc.mode = Mode::Normal;
 }
 
-pub fn check_cursor_in_view(view: &mut View) -> bool {
+pub fn check_cursor_in_view(view: &View) -> bool {
-    let cursor = view.state.selection().cursor();
+    let cursor = view.doc.selection().cursor();
-    let line = view.state.doc().char_to_line(cursor);
+    let line = view.doc.text().char_to_line(cursor);
     let document_end = view.first_line + view.size.1.saturating_sub(1) as usize;
 
     if (line > document_end.saturating_sub(PADDING)) | (line < view.first_line + PADDING) {
@@ -148,168 +152,186 @@ pub fn check_cursor_in_view(view: &mut View) -> bool {
     true
 }
 
-pub fn page_up(view: &mut View, _count: usize) {
+pub fn page_up(cx: &mut Context) {
-    if view.first_line < PADDING {
+    if cx.view.first_line < PADDING {
         return;
     }
 
-    view.first_line = view.first_line.saturating_sub(view.size.1 as usize);
+    cx.view.first_line = cx.view.first_line.saturating_sub(cx.view.size.1 as usize);
 
-    if !check_cursor_in_view(view) {
+    if !check_cursor_in_view(cx.view) {
-        let text = view.state.doc();
+        let text = cx.view.doc.text();
-        let pos = text.line_to_char(view.last_line().saturating_sub(PADDING));
+        let pos = text.line_to_char(cx.view.last_line().saturating_sub(PADDING));
-        view.state.selection = Selection::single(pos, pos);
+        cx.view.doc.set_selection(Selection::point(pos));
     }
 }
 
-pub fn page_down(view: &mut View, _count: usize) {
+pub fn page_down(cx: &mut Context) {
-    view.first_line += view.size.1 as usize + PADDING;
+    cx.view.first_line += cx.view.size.1 as usize + PADDING;
 
-    if view.first_line < view.state.doc().len_lines() {
+    if cx.view.first_line < cx.view.doc.text().len_lines() {
-        let text = view.state.doc();
+        let text = cx.view.doc.text();
-        let pos = text.line_to_char(view.first_line as usize);
+        let pos = text.line_to_char(cx.view.first_line as usize);
-        view.state.selection = Selection::single(pos, pos);
+        cx.view.doc.set_selection(Selection::point(pos));
     }
 }
 
-pub fn half_page_up(view: &mut View, _count: usize) {
+pub fn half_page_up(cx: &mut Context) {
-    if view.first_line < PADDING {
+    if cx.view.first_line < PADDING {
         return;
     }
 
-    view.first_line = view.first_line.saturating_sub(view.size.1 as usize / 2);
+    cx.view.first_line = cx
+        .view
+        .first_line
+        .saturating_sub(cx.view.size.1 as usize / 2);
 
-    if !check_cursor_in_view(view) {
+    if !check_cursor_in_view(cx.view) {
-        let text = &view.state.doc;
+        let text = &cx.view.doc.text();
-        let pos = text.line_to_char(view.last_line() - PADDING);
+        let pos = text.line_to_char(cx.view.last_line() - PADDING);
-        view.state.selection = Selection::single(pos, pos);
+        cx.view.doc.set_selection(Selection::point(pos));
     }
 }
 
-pub fn half_page_down(view: &mut View, _count: usize) {
+pub fn half_page_down(cx: &mut Context) {
-    let lines = view.state.doc().len_lines();
+    let lines = cx.view.doc.text().len_lines();
-    if view.first_line < lines.saturating_sub(view.size.1 as usize) {
+    if cx.view.first_line < lines.saturating_sub(cx.view.size.1 as usize) {
-        view.first_line += view.size.1 as usize / 2;
+        cx.view.first_line += cx.view.size.1 as usize / 2;
     }
-    if !check_cursor_in_view(view) {
+    if !check_cursor_in_view(cx.view) {
-        let text = view.state.doc();
+        let text = cx.view.doc.text();
-        let pos = text.line_to_char(view.first_line as usize);
+        let pos = text.line_to_char(cx.view.first_line as usize);
-        view.state.selection = Selection::single(pos, pos);
+        cx.view.doc.set_selection(Selection::point(pos));
     }
 }
 // avoid select by default by having a visual mode switch that makes movements into selects
 
-pub fn extend_char_left(view: &mut View, count: usize) {
+pub fn extend_char_left(cx: &mut Context) {
-    // TODO: use a transaction
+    let selection =
-    let selection = view
+        cx.view
-        .state
+            .doc
-        .extend_selection(Direction::Backward, Granularity::Character, count);
+            .state
-    view.state.selection = selection;
+            .extend_selection(Direction::Backward, Granularity::Character, cx.count);
+    cx.view.doc.set_selection(selection);
 }
 
-pub fn extend_char_right(view: &mut View, count: usize) {
+pub fn extend_char_right(cx: &mut Context) {
-    // TODO: use a transaction
+    let selection =
-    view.state.selection =
+        cx.view
-        view.state
+            .doc
-            .extend_selection(Direction::Forward, Granularity::Character, count);
+            .state
+            .extend_selection(Direction::Forward, Granularity::Character, cx.count);
+    cx.view.doc.set_selection(selection);
 }
 
-pub fn extend_line_up(view: &mut View, count: usize) {
+pub fn extend_line_up(cx: &mut Context) {
-    // TODO: use a transaction
+    let selection =
-    view.state.selection =
+        cx.view
-        view.state
+            .doc
-            .extend_selection(Direction::Backward, Granularity::Line, count);
+            .state
+            .extend_selection(Direction::Backward, Granularity::Line, cx.count);
+    cx.view.doc.set_selection(selection);
 }
 
-pub fn extend_line_down(view: &mut View, count: usize) {
+pub fn extend_line_down(cx: &mut Context) {
-    // TODO: use a transaction
+    let selection =
-    view.state.selection =
+        cx.view
-        view.state
+            .doc
-            .extend_selection(Direction::Forward, Granularity::Line, count);
+            .state
+            .extend_selection(Direction::Forward, Granularity::Line, cx.count);
+    cx.view.doc.set_selection(selection);
 }
 
-pub fn split_selection_on_newline(view: &mut View, _count: usize) {
+pub fn split_selection_on_newline(cx: &mut Context) {
-    let text = &view.state.doc.slice(..);
+    let text = &cx.view.doc.text().slice(..);
     // only compile the regex once
     #[allow(clippy::trivial_regex)]
     static REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"\n").unwrap());
-    // TODO: use a transaction
+    let selection = selection::split_on_matches(text, cx.view.doc.selection(), &REGEX);
-    view.state.selection = selection::split_on_matches(text, view.state.selection(), &REGEX)
+    cx.view.doc.set_selection(selection);
 }
 
-pub fn select_line(view: &mut View, _count: usize) {
+pub fn select_line(cx: &mut Context) {
     // TODO: count
-    let pos = view.state.selection().primary();
+    let pos = cx.view.doc.selection().primary();
-    let text = view.state.doc();
+    let text = cx.view.doc.text();
     let line = text.char_to_line(pos.head);
     let start = text.line_to_char(line);
     let end = text.line_to_char(line + 1).saturating_sub(1);
 
-    // TODO: use a transaction
+    cx.view.doc.set_selection(Selection::single(start, end));
-    view.state.selection = Selection::single(start, end);
 }
 
-pub fn delete_selection(view: &mut View, _count: usize) {
+pub fn delete_selection(cx: &mut Context) {
-    let transaction =
+    let transaction = Transaction::change_by_selection(&cx.view.doc.state, |range| {
-        Transaction::change_by_selection(&view.state, |range| (range.from(), range.to() + 1, None));
+        (range.from(), range.to() + 1, None)
-    transaction.apply(&mut view.state);
+    });
+    cx.view.doc.apply(&transaction);
 
-    append_changes_to_history(view);
+    append_changes_to_history(cx);
 }
 
-pub fn change_selection(view: &mut View, count: usize) {
+pub fn change_selection(cx: &mut Context) {
-    delete_selection(view, count);
+    delete_selection(cx);
-    insert_mode(view, count);
+    insert_mode(cx);
 }
 
-pub fn collapse_selection(view: &mut View, _count: usize) {
+pub fn collapse_selection(cx: &mut Context) {
-    view.state.selection = view
+    let selection = cx
-        .state
+        .view
-        .selection
+        .doc
-        .transform(|range| Range::new(range.head, range.head))
+        .selection()
+        .transform(|range| Range::new(range.head, range.head));
+
+    cx.view.doc.set_selection(selection);
 }
 
-pub fn flip_selections(view: &mut View, _count: usize) {
+pub fn flip_selections(cx: &mut Context) {
-    view.state.selection = view
+    let selection = cx
-        .state
+        .view
-        .selection
+        .doc
-        .transform(|range| Range::new(range.head, range.anchor))
+        .selection()
+        .transform(|range| Range::new(range.head, range.anchor));
+
+    cx.view.doc.set_selection(selection);
 }
 
-fn enter_insert_mode(view: &mut View) {
+fn enter_insert_mode(cx: &mut Context) {
-    view.state.mode = Mode::Insert;
+    cx.view.doc.mode = Mode::Insert;
 
-    append_changes_to_history(view);
+    append_changes_to_history(cx);
 }
 // inserts at the start of each selection
-pub fn insert_mode(view: &mut View, _count: usize) {
+pub fn insert_mode(cx: &mut Context) {
-    enter_insert_mode(view);
+    enter_insert_mode(cx);
 
-    view.state.selection = view
+    let selection = cx
-        .state
+        .view
-        .selection
+        .doc
-        .transform(|range| Range::new(range.to(), range.from()))
+        .selection()
+        .transform(|range| Range::new(range.to(), range.from()));
+    cx.view.doc.set_selection(selection);
 }
 
 // inserts at the end of each selection
-pub fn append_mode(view: &mut View, _count: usize) {
+pub fn append_mode(cx: &mut Context) {
-    enter_insert_mode(view);
+    enter_insert_mode(cx);
-    view.state.restore_cursor = true;
+    cx.view.doc.restore_cursor = true;
 
     // TODO: as transaction
-    let text = &view.state.doc.slice(..);
+    let text = &cx.view.doc.text().slice(..);
-    view.state.selection = view.state.selection.transform(|range| {
+    let selection = cx.view.doc.selection().transform(|range| {
         // TODO: to() + next char
         Range::new(
             range.from(),
             graphemes::next_grapheme_boundary(text, range.to()),
         )
-    })
+    });
+    cx.view.doc.set_selection(selection);
 }
 
 // TODO: I, A, o and O can share a lot of the primitives.
-
+pub fn command_mode(_cx: &mut Context) {
-pub fn command_mode(_view: &mut View, _count: usize) {
     unimplemented!()
 }
 
@@ -329,30 +351,30 @@ fn selection_lines(state: &State) -> Vec<usize> {
 }
 
 // I inserts at the start of each line with a selection
-pub fn prepend_to_line(view: &mut View, count: usize) {
+pub fn prepend_to_line(cx: &mut Context) {
-    enter_insert_mode(view);
+    enter_insert_mode(cx);
 
-    move_line_start(view, count);
+    move_line_start(cx);
 }
 
 // A inserts at the end of each line with a selection
-pub fn append_to_line(view: &mut View, count: usize) {
+pub fn append_to_line(cx: &mut Context) {
-    enter_insert_mode(view);
+    enter_insert_mode(cx);
 
-    move_line_end(view, count);
+    move_line_end(cx);
 }
 
 // o inserts a new line after each line with a selection
-pub fn open_below(view: &mut View, _count: usize) {
+pub fn open_below(cx: &mut Context) {
-    enter_insert_mode(view);
+    enter_insert_mode(cx);
 
-    let lines = selection_lines(&view.state);
+    let lines = selection_lines(&cx.view.doc.state);
 
     let positions: Vec<_> = lines
         .into_iter()
         .map(|index| {
             // adjust all positions to the end of the line/start of the next one.
-            view.state.doc.line_to_char(index + 1)
+            cx.view.doc.text().line_to_char(index + 1)
         })
         .collect();
 
@@ -373,111 +395,119 @@ pub fn open_below(view: &mut View, _count: usize) {
         0,
     );
 
-    let transaction = Transaction::change(&view.state, changes).with_selection(selection);
+    let transaction = Transaction::change(&cx.view.doc.state, changes).with_selection(selection);
 
-    transaction.apply(&mut view.state);
+    cx.view.doc.apply(&transaction);
 }
 
 // O inserts a new line before each line with a selection
 
-fn append_changes_to_history(view: &mut View) {
+fn append_changes_to_history(cx: &mut Context) {
-    if view.state.changes.is_empty() {
+    if cx.view.doc.changes.is_empty() {
         return;
     }
 
-    let new_changeset = ChangeSet::new(view.state.doc());
+    let new_changeset = ChangeSet::new(cx.view.doc.text());
-    let changes = std::mem::replace(&mut view.state.changes, new_changeset);
+    let changes = std::mem::replace(&mut cx.view.doc.changes, new_changeset);
     // Instead of doing this messy merge we could always commit, and based on transaction
     // annotations either add a new layer or compose into the previous one.
-    let transaction = Transaction::from(changes).with_selection(view.state.selection().clone());
+    let transaction = Transaction::from(changes).with_selection(cx.view.doc.selection().clone());
 
-    // HAXX: we need to reconstruct the state as it was before the changes..
+    // increment document version
-    let (doc, selection) = view.state.old_state.take().unwrap();
+    // TODO: needs to happen on undo/redo too
-    let mut old_state = State::new(doc);
+    cx.view.doc.version += 1;
-    old_state.selection = selection;
 
+    // TODO: trigger lsp/documentDidChange with changes
+
+    // HAXX: we need to reconstruct the state as it was before the changes..
+    let old_state = std::mem::replace(&mut cx.view.doc.old_state, cx.view.doc.state.clone());
     // TODO: take transaction by value?
-    view.history.commit_revision(&transaction, &old_state);
+    cx.view
+        .doc
+        .history
+        .commit_revision(&transaction, &old_state);
 
-    // TODO: need to start the state with these vals
+    // TODO: notify LSP of changes
-    // HAXX
-    view.state.old_state = Some((view.state.doc().clone(), view.state.selection.clone()));
 }
 
-pub fn normal_mode(view: &mut View, _count: usize) {
+pub fn normal_mode(cx: &mut Context) {
-    view.state.mode = Mode::Normal;
+    cx.view.doc.mode = Mode::Normal;
 
-    append_changes_to_history(view);
+    append_changes_to_history(cx);
 
     // if leaving append mode, move cursor back by 1
-    if view.state.restore_cursor {
+    if cx.view.doc.restore_cursor {
-        let text = &view.state.doc.slice(..);
+        let text = &cx.view.doc.text().slice(..);
-        view.state.selection = view.state.selection.transform(|range| {
+        let selection = cx.view.doc.selection().transform(|range| {
             Range::new(
                 range.from(),
                 graphemes::prev_grapheme_boundary(text, range.to()),
             )
         });
+        cx.view.doc.set_selection(selection);
 
-        view.state.restore_cursor = false;
+        cx.view.doc.restore_cursor = false;
     }
 }
 
-pub fn goto_mode(view: &mut View, _count: usize) {
+pub fn goto_mode(cx: &mut Context) {
-    view.state.mode = Mode::Goto;
+    cx.view.doc.mode = Mode::Goto;
 }
 
 // NOTE: Transactions in this module get appended to history when we switch back to normal mode.
 pub mod insert {
     use super::*;
     // TODO: insert means add text just before cursor, on exit we should be on the last letter.
-    pub fn insert_char(view: &mut View, c: char) {
+    pub fn insert_char(cx: &mut Context, c: char) {
         let c = Tendril::from_char(c);
-        let transaction = Transaction::insert(&view.state, c);
+        let transaction = Transaction::insert(&cx.view.doc.state, c);
 
-        transaction.apply(&mut view.state);
+        cx.view.doc.apply(&transaction);
     }
 
-    pub fn insert_tab(view: &mut View, _count: usize) {
+    pub fn insert_tab(cx: &mut Context) {
-        insert_char(view, '\t');
+        insert_char(cx, '\t');
     }
 
-    pub fn insert_newline(view: &mut View, _count: usize) {
+    pub fn insert_newline(cx: &mut Context) {
-        let transaction = Transaction::change_by_selection(&view.state, |range| {
+        let transaction = Transaction::change_by_selection(&cx.view.doc.state, |range| {
-            let indent_level =
+            let indent_level = helix_core::indent::suggested_indent_for_pos(
-                helix_core::indent::suggested_indent_for_pos(&view.state, range.head);
+                cx.view.doc.syntax.as_ref(),
+                &cx.view.doc.state,
+                range.head,
+            );
             let indent = " ".repeat(TAB_WIDTH).repeat(indent_level);
             let mut text = String::with_capacity(1 + indent.len());
             text.push('\n');
             text.push_str(&indent);
             (range.head, range.head, Some(text.into()))
         });
-        transaction.apply(&mut view.state);
+        cx.view.doc.apply(&transaction);
     }
 
     // TODO: handle indent-aware delete
-    pub fn delete_char_backward(view: &mut View, count: usize) {
+    pub fn delete_char_backward(cx: &mut Context) {
-        let text = &view.state.doc.slice(..);
+        let text = &cx.view.doc.text().slice(..);
-        let transaction = Transaction::change_by_selection(&view.state, |range| {
+        let transaction = Transaction::change_by_selection(&cx.view.doc.state, |range| {
             (
-                graphemes::nth_prev_grapheme_boundary(text, range.head, count),
+                graphemes::nth_prev_grapheme_boundary(text, range.head, cx.count),
                 range.head,
                 None,
             )
         });
-        transaction.apply(&mut view.state);
+        cx.view.doc.apply(&transaction);
     }
 
-    pub fn delete_char_forward(view: &mut View, count: usize) {
+    pub fn delete_char_forward(cx: &mut Context) {
-        let text = &view.state.doc.slice(..);
+        let text = &cx.view.doc.text().slice(..);
-        let transaction = Transaction::change_by_selection(&view.state, |range| {
+        let transaction = Transaction::change_by_selection(&cx.view.doc.state, |range| {
             (
                 range.head,
-                graphemes::nth_next_grapheme_boundary(text, range.head, count),
+                graphemes::nth_next_grapheme_boundary(text, range.head, cx.count),
                 None,
             )
         });
-        transaction.apply(&mut view.state);
+        cx.view.doc.apply(&transaction);
     }
 }
 
@@ -487,24 +517,32 @@ pub fn insert_char_prompt(prompt: &mut Prompt, c: char) {
 
 // Undo / Redo
 
-pub fn undo(view: &mut View, _count: usize) {
+pub fn undo(cx: &mut Context) {
-    view.history.undo(&mut view.state);
+    if let Some(revert) = cx.view.doc.history.undo() {
+        cx.view.doc.version += 1;
+        cx.view.doc.apply(&revert);
+    }
 
     // TODO: each command could simply return a Option<transaction>, then the higher level handles storing it?
 }
 
-pub fn redo(view: &mut View, _count: usize) {
+pub fn redo(cx: &mut Context) {
-    view.history.redo(&mut view.state);
+    if let Some(transaction) = cx.view.doc.history.redo() {
+        cx.view.doc.version += 1;
+        cx.view.doc.apply(&transaction);
+    }
 }
 
 // Yank / Paste
 
-pub fn yank(view: &mut View, _count: usize) {
+pub fn yank(cx: &mut Context) {
     // TODO: should selections be made end inclusive?
-    let values = view
+    let values = cx
+        .view
+        .doc
         .state
         .selection()
-        .fragments(&view.state.doc().slice(..))
+        .fragments(&cx.view.doc.text().slice(..))
         .map(|cow| cow.into_owned())
         .collect();
 
@@ -513,7 +551,7 @@ pub fn yank(view: &mut View, _count: usize) {
     register::set(reg, values);
 }
 
-pub fn paste(view: &mut View, _count: usize) {
+pub fn paste(cx: &mut Context) {
     // TODO: allow specifying reg
     let reg = '"';
     if let Some(values) = register::get(reg) {
@@ -545,19 +583,19 @@ pub fn paste(view: &mut View, _count: usize) {
         let transaction = if linewise {
             // paste on the next line
             // TODO: can simply take a range + modifier and compute the right pos without ifs
-            let text = view.state.doc();
+            let text = cx.view.doc.text();
-            Transaction::change_by_selection(&view.state, |range| {
+            Transaction::change_by_selection(&cx.view.doc.state, |range| {
                 let line_end = text.line_to_char(text.char_to_line(range.head) + 1);
                 (line_end, line_end, Some(values.next().unwrap()))
             })
         } else {
-            Transaction::change_by_selection(&view.state, |range| {
+            Transaction::change_by_selection(&cx.view.doc.state, |range| {
                 (range.head + 1, range.head + 1, Some(values.next().unwrap()))
             })
         };
 
-        transaction.apply(&mut view.state);
+        cx.view.doc.apply(&transaction);
-        append_changes_to_history(view);
+        append_changes_to_history(cx);
     }
 }
 
@@ -565,9 +603,9 @@ fn get_lines(view: &View) -> Vec<usize> {
     let mut lines = Vec::new();
 
     // Get all line numbers
-    for range in view.state.selection.ranges() {
+    for range in view.doc.selection().ranges() {
-        let start = view.state.doc.char_to_line(range.from());
+        let start = view.doc.text().char_to_line(range.from());
-        let end = view.state.doc.char_to_line(range.to());
+        let end = view.doc.text().char_to_line(range.to());
 
         for line in start..=end {
             lines.push(line)
@@ -578,29 +616,29 @@ fn get_lines(view: &View) -> Vec<usize> {
     lines
 }
 
-pub fn indent(view: &mut View, _count: usize) {
+pub fn indent(cx: &mut Context) {
-    let lines = get_lines(view);
+    let lines = get_lines(cx.view);
 
     // Indent by one level
     let indent = Tendril::from(" ".repeat(TAB_WIDTH));
 
     let transaction = Transaction::change(
-        &view.state,
+        &cx.view.doc.state,
         lines.into_iter().map(|line| {
-            let pos = view.state.doc.line_to_char(line);
+            let pos = cx.view.doc.text().line_to_char(line);
             (pos, pos, Some(indent.clone()))
         }),
     );
-    transaction.apply(&mut view.state);
+    cx.view.doc.apply(&transaction);
-    append_changes_to_history(view);
+    append_changes_to_history(cx);
 }
 
-pub fn unindent(view: &mut View, _count: usize) {
+pub fn unindent(cx: &mut Context) {
-    let lines = get_lines(view);
+    let lines = get_lines(cx.view);
     let mut changes = Vec::with_capacity(lines.len());
 
     for line_idx in lines {
-        let line = view.state.doc.line(line_idx);
+        let line = cx.view.doc.text().line(line_idx);
         let mut width = 0;
 
         for ch in line.chars() {
@@ -616,18 +654,27 @@ pub fn unindent(view: &mut View, _count: usize) {
         }
 
         if width > 0 {
-            let start = view.state.doc.line_to_char(line_idx);
+            let start = cx.view.doc.text().line_to_char(line_idx);
             changes.push((start, start + width, None))
         }
     }
 
-    let transaction = Transaction::change(&view.state, changes.into_iter());
+    let transaction = Transaction::change(&cx.view.doc.state, changes.into_iter());
 
-    transaction.apply(&mut view.state);
+    cx.view.doc.apply(&transaction);
-    append_changes_to_history(view);
+    append_changes_to_history(cx);
 }
 
-pub fn indent_selection(_view: &mut View, _count: usize) {
+pub fn indent_selection(_cx: &mut Context) {
     // loop over each line and recompute proper indentation
     unimplemented!()
 }
+
+//
+
+pub fn save(cx: &mut Context) {
+    // Spawns an async task to actually do the saving. This way we prevent blocking.
+
+    // TODO: handle save errors somehow?
+    cx.executor.spawn(cx.view.doc.save()).detach();
+}

helix-view/src/document.rs

@@ -0,0 +1,209 @@
+use anyhow::Error;
+use std::future::Future;
+use std::path::PathBuf;
+
+use helix_core::{
+    syntax::LOADER, ChangeSet, Diagnostic, History, Position, Range, Rope, RopeSlice, Selection,
+    State, Syntax, Transaction,
+};
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub enum Mode {
+    Normal,
+    Insert,
+    Goto,
+}
+
+pub struct Document {
+    pub state: State, // rope + selection
+    /// File path on disk.
+    pub path: Option<PathBuf>,
+
+    /// Current editing mode.
+    pub mode: Mode,
+    pub restore_cursor: bool,
+
+    /// Tree-sitter AST tree
+    pub syntax: Option<Syntax>,
+    /// Corresponding language scope name. Usually `source.<lang>`.
+    pub language: Option<String>,
+
+    /// Pending changes since last history commit.
+    pub changes: ChangeSet,
+    pub old_state: State,
+    pub history: History,
+    pub version: i32, // should be usize?
+
+    pub diagnostics: Vec<Diagnostic>,
+}
+
+/// Like std::mem::replace() except it allows the replacement value to be mapped from the
+/// original value.
+fn take_with<T, F>(mut_ref: &mut T, closure: F)
+where
+    F: FnOnce(T) -> T,
+{
+    use std::{panic, ptr};
+
+    unsafe {
+        let old_t = ptr::read(mut_ref);
+        let new_t = panic::catch_unwind(panic::AssertUnwindSafe(|| closure(old_t)))
+            .unwrap_or_else(|_| ::std::process::abort());
+        ptr::write(mut_ref, new_t);
+    }
+}
+
+use url::Url;
+
+impl Document {
+    fn new(state: State) -> Self {
+        let changes = ChangeSet::new(&state.doc);
+        let old_state = state.clone();
+
+        Self {
+            path: None,
+            state,
+            mode: Mode::Normal,
+            restore_cursor: false,
+            syntax: None,
+            language: None,
+            changes,
+            old_state,
+            diagnostics: Vec::new(),
+            version: 0,
+            history: History::default(),
+        }
+    }
+
+    // TODO: passing scopes here is awkward
+    // TODO: async fn?
+    pub fn load(path: PathBuf, scopes: &[String]) -> Result<Self, Error> {
+        use std::{env, fs::File, io::BufReader};
+        let _current_dir = env::current_dir()?;
+
+        let doc = Rope::from_reader(BufReader::new(File::open(path.clone())?))?;
+
+        // TODO: create if not found
+
+        let mut doc = Self::new(State::new(doc));
+
+        if let Some(language_config) = LOADER.language_config_for_file_name(path.as_path()) {
+            let highlight_config = language_config.highlight_config(scopes).unwrap().unwrap();
+            // TODO: config.configure(scopes) is now delayed, is that ok?
+
+            let syntax = Syntax::new(&doc.state.doc, highlight_config.clone());
+
+            doc.syntax = Some(syntax);
+            // TODO: maybe just keep an Arc<> pointer to the language_config?
+            doc.language = Some(language_config.scope().to_string());
+
+            // TODO: this ties lsp support to tree-sitter enabled languages for now. Language
+            // config should use Option<HighlightConfig> to let us have non-tree-sitter configs.
+
+            // TODO: circular dep: view <-> lsp
+            // helix_lsp::REGISTRY;
+            // view should probably depend on lsp
+        };
+
+        // canonicalize path to absolute value
+        doc.path = Some(std::fs::canonicalize(path)?);
+
+        Ok(doc)
+    }
+
+    // TODO: do we need some way of ensuring two save operations on the same doc can't run at once?
+    // or is that handled by the OS/async layer
+    pub fn save(&self) -> impl Future<Output = Result<(), anyhow::Error>> {
+        // we clone and move text + path into the future so that we asynchronously save the current
+        // state without blocking any further edits.
+
+        let text = self.text().clone();
+        let path = self.path.clone().expect("Can't save with no path set!"); // TODO: handle no path
+
+        // TODO: mark changes up to now as saved
+        // TODO: mark dirty false
+
+        async move {
+            use smol::{fs::File, prelude::*};
+            let mut file = File::create(path).await?;
+
+            // write all the rope chunks to file
+            for chunk in text.chunks() {
+                file.write_all(chunk.as_bytes()).await?;
+            }
+            // TODO: flush?
+
+            Ok(())
+        } // and_then(// lsp.send_text_saved_notification())
+    }
+
+    pub fn set_language(&mut self, scope: &str, scopes: &[String]) {
+        if let Some(language_config) = LOADER.language_config_for_scope(scope) {
+            let highlight_config = language_config.highlight_config(scopes).unwrap().unwrap();
+            // TODO: config.configure(scopes) is now delayed, is that ok?
+
+            let syntax = Syntax::new(&self.state.doc, highlight_config.clone());
+
+            self.syntax = Some(syntax);
+        };
+    }
+
+    pub fn set_selection(&mut self, selection: Selection) {
+        // TODO: use a transaction?
+        self.state.selection = selection;
+    }
+
+    pub fn apply(&mut self, transaction: &Transaction) -> bool {
+        let old_doc = self.text().clone();
+
+        let success = transaction.apply(&mut self.state);
+
+        if !transaction.changes().is_empty() {
+            // Compose this transaction with the previous one
+            take_with(&mut self.changes, |changes| {
+                changes.compose(transaction.changes().clone()).unwrap()
+            });
+
+            // TODO: when composing, replace transaction.selection too
+
+            // update tree-sitter syntax tree
+            if let Some(syntax) = &mut self.syntax {
+                // TODO: no unwrap
+                syntax
+                    .update(&old_doc, &self.state.doc, transaction.changes())
+                    .unwrap();
+            }
+
+            // TODO: map state.diagnostics over changes::map_pos too
+        }
+        success
+    }
+
+    #[inline]
+    pub fn mode(&self) -> Mode {
+        self.mode
+    }
+
+    #[inline]
+    pub fn path(&self) -> Option<&PathBuf> {
+        self.path.as_ref()
+    }
+
+    pub fn url(&self) -> Option<Url> {
+        self.path().map(|path| Url::from_file_path(path).unwrap())
+    }
+
+    pub fn text(&self) -> &Rope {
+        &self.state.doc
+    }
+
+    pub fn selection(&self) -> &Selection {
+        &self.state.selection
+    }
+
+    // pub fn slice<R>(&self, range: R) -> RopeSlice where R: RangeBounds {
+    //     self.state.doc.slice
+    // }
+
+    // TODO: transact(Fn) ?
+}

helix-view/src/editor.rs

@@ -1,24 +1,48 @@
-use crate::View;
+use crate::theme::Theme;
+use crate::{Document, View};
 
 use std::path::PathBuf;
 
 use anyhow::Error;
 
 pub struct Editor {
-    pub view: Option<View>,
+    pub views: Vec<View>,
+    pub focus: usize,
     pub should_close: bool,
+    pub theme: Theme, // TODO: share one instance
+}
+
+impl Default for Editor {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 impl Editor {
     pub fn new() -> Self {
+        let theme = Theme::default();
+
         Self {
-            view: None,
+            views: Vec::new(),
+            focus: 0,
             should_close: false,
+            theme,
         }
     }
 
     pub fn open(&mut self, path: PathBuf, size: (u16, u16)) -> Result<(), Error> {
-        self.view = Some(View::open(path, size)?);
+        let pos = self.views.len();
+        let doc = Document::load(path, self.theme.scopes())?;
+        self.views.push(View::new(doc, size)?);
+        self.focus = pos;
         Ok(())
     }
+
+    pub fn view(&self) -> Option<&View> {
+        self.views.get(self.focus)
+    }
+
+    pub fn view_mut(&mut self) -> Option<&mut View> {
+        self.views.get_mut(self.focus)
+    }
 }

helix-view/src/keymap.rs

@@ -1,5 +1,6 @@
 use crate::commands::{self, Command};
-use helix_core::{hashmap, state};
+use crate::document::Mode;
+use helix_core::hashmap;
 use std::collections::HashMap;
 
 // Kakoune-inspired:
@@ -81,14 +82,17 @@ use std::collections::HashMap;
 //          = = align?
 //          + =
 //      }
+//
+//      gd = goto definition
+//      gr = goto reference
 // }
 
 #[cfg(feature = "term")]
 pub use crossterm::event::{KeyCode, KeyEvent as Key, KeyModifiers as Modifiers};
 
 // TODO: could be trie based
-type Keymap = HashMap<Vec<Key>, Command>;
+pub type Keymap = HashMap<Vec<Key>, Command>;
-type Keymaps = HashMap<state::Mode, Keymap>;
+pub type Keymaps = HashMap<Mode, Keymap>;
 
 macro_rules! key {
     ($ch:expr) => {
@@ -128,7 +132,7 @@ macro_rules! ctrl {
 
 pub fn default() -> Keymaps {
     hashmap!(
-        state::Mode::Normal =>
+        Mode::Normal =>
             // as long as you cast the first item, rust is able to infer the other cases
             hashmap!(
                 vec![key!('h')] => commands::move_char_left as Command,
@@ -179,7 +183,7 @@ pub fn default() -> Keymaps {
                 vec![ctrl!('u')] => commands::half_page_up,
                 vec![ctrl!('d')] => commands::half_page_down,
             ),
-            state::Mode::Insert => hashmap!(
+            Mode::Insert => hashmap!(
                 vec![Key {
                     code: KeyCode::Esc,
                     modifiers: Modifiers::NONE
@@ -201,7 +205,7 @@ pub fn default() -> Keymaps {
                     modifiers: Modifiers::NONE
                 }] => commands::insert::insert_tab,
             ),
-            state::Mode::Goto => hashmap!(
+            Mode::Goto => hashmap!(
                 vec![Key {
                     code: KeyCode::Esc,
                     modifiers: Modifiers::NONE

helix-view/src/lib.rs

@@ -1,9 +1,12 @@
 pub mod commands;
+pub mod document;
 pub mod editor;
 pub mod keymap;
 pub mod prompt;
 pub mod theme;
 pub mod view;
 
+pub use document::Document;
 pub use editor::Editor;
+pub use theme::Theme;
 pub use view::View;

helix-view/src/theme.rs

@@ -157,6 +157,8 @@ impl Default for Theme {
             "ui.background" => Style::default().bg(Color::Rgb(59, 34, 76)), // midnight
             "ui.linenr" => Style::default().fg(Color::Rgb(90, 89, 119)), // comet
             "ui.statusline" => Style::default().bg(Color::Rgb(40, 23, 51)), // revolver
+
+            "warning" => Style::default().fg(Color::Rgb(255, 205, 28)),
         };
 
         let scopes = mapping.keys().map(ToString::to_string).collect();

helix-view/src/view.rs

@@ -1,44 +1,39 @@
 use anyhow::Error;
 
-use std::{borrow::Cow, path::PathBuf};
+use std::borrow::Cow;
 
-use crate::theme::Theme;
+use crate::Document;
 use helix_core::{
     graphemes::{grapheme_width, RopeGraphemes},
     indent::TAB_WIDTH,
-    History, Position, RopeSlice, State,
+    Position, RopeSlice,
 };
 use tui::layout::Rect;
 
 pub const PADDING: usize = 5;
 
+// TODO: view should be View { doc: Document(state, history,..) }
+// since we can have multiple views into the same file
 pub struct View {
-    pub state: State,
+    pub doc: Document,
-    pub history: History,
     pub first_line: usize,
     pub size: (u16, u16),
-    pub theme: Theme, // TODO: share one instance
 }
 
 impl View {
-    pub fn open(path: PathBuf, size: (u16, u16)) -> Result<Self, Error> {
+    pub fn new(doc: Document, size: (u16, u16)) -> Result<Self, Error> {
-        let theme = Theme::default();
-        let state = State::load(path, theme.scopes())?;
-
         let view = Self {
-            state,
+            doc,
             first_line: 0,
             size,
-            theme,
-            history: History::default(),
         };
 
         Ok(view)
     }
 
     pub fn ensure_cursor_in_view(&mut self) {
-        let cursor = self.state.selection().cursor();
+        let cursor = self.doc.state.selection().cursor();
-        let line = self.state.doc().char_to_line(cursor);
+        let line = self.doc.text().char_to_line(cursor);
         let document_end = self.first_line + (self.size.1 as usize).saturating_sub(2);
 
         // TODO: side scroll
@@ -58,7 +53,7 @@ impl View {
         let viewport = Rect::new(6, 0, self.size.0, self.size.1 - 2); // - 2 for statusline and prompt
         std::cmp::min(
             self.first_line + (viewport.height as usize),
-            self.state.doc().len_lines() - 1,
+            self.doc.text().len_lines() - 1,
         )
     }
 
@@ -90,4 +85,25 @@ impl View {
 
         Some(Position::new(row, col))
     }
+
+    // pub fn traverse<F>(&self, text: &RopeSlice, start: usize, end: usize, fun: F)
+    // where
+    //     F: Fn(usize, usize),
+    // {
+    //     let start = self.screen_coords_at_pos(text, start);
+    //     let end = self.screen_coords_at_pos(text, end);
+
+    //     match (start, end) {
+    //         // fully on screen
+    //         (Some(start), Some(end)) => {
+    //             // we want to calculate ends of lines for each char..
+    //         }
+    //         // from start to end of screen
+    //         (Some(start), None) => {}
+    //         // from start of screen to end
+    //         (None, Some(end)) => {}
+    //         // not on screen
+    //         (None, None) => return,
+    //     }
+    // }
 }