Refactor: Document type as a wrapper around barebones State.

15 files changed, 396 insertions, 295 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 1d7857d5..29a86a36 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -447,6 +447,7 @@ dependencies = [
  "futures-util",
  "glob",
  "helix-core",
+ "helix-view",
  "jsonrpc-core",
  "lsp-types",
  "pathdiff",
@@ -491,6 +492,7 @@ dependencies = [
  "helix-core",
  "once_cell",
  "tui",
+ "url",
 ]
 
 [[package]]
diff --git a/helix-core/src/indent.rs b/helix-core/src/indent.rs
index 2e1a095e..6b9a1ab1 100644
--- a/helix-core/src/indent.rs
+++ b/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 {
-    if let Some(syntax) = &state.syntax {
+pub fn suggested_indent_for_pos(syntax: Option<&Syntax>, state: &State, pos: usize) -> usize {
+    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);
-        state.set_language("source.rust", &[]);
-
-        assert_eq!(suggested_indent_for_line(&state, 0), 0); // mod
-        assert_eq!(suggested_indent_for_line(&state, 1), 1); // fn
-        assert_eq!(suggested_indent_for_line(&state, 2), 2); // 1 + 1
-        assert_eq!(suggested_indent_for_line(&state, 4), 1); // }
-        assert_eq!(suggested_indent_for_line(&state, 5), 0); // }
+        let state = State::new(doc);
+        // TODO: set_language
+        let language_config = crate::syntax::LOADER
+            .language_config_for_scope("source.rust")
+            .unwrap();
+        let highlight_config = language_config.highlight_config(&[]).unwrap().unwrap();
+        let syntax = Syntax::new(&state.doc, highlight_config.clone());
+
+        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); // }
     }
 }
diff --git a/helix-core/src/state.rs b/helix-core/src/state.rs
index 75e5cd40..7fd620a5 100644
--- a/helix-core/src/state.rs
+++ b/helix-core/src/state.rs
@@ -3,34 +3,11 @@ use crate::syntax::LOADER;
 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.
 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,
-
-    // TODO: move these to a Document wrapper?
-    pub syntax: Option<Syntax>,
-    /// Pending changes since last history commit.
-    pub changes: ChangeSet,
-    pub old_state: Option<(Rope, Selection)>,
-
-    pub version: i64,
-    pub diagnostics: Vec<Diagnostic>,
 }
 
 #[derive(Copy, Clone, PartialEq, Eq)]
@@ -49,60 +26,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,
-            diagnostics: Vec::new(),
-            version: 0,
         }
     }
 
-    // TODO: passing scopes here is awkward
-    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 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);
-        };
-
-        // canonicalize path to absolute value
-        state.path = Some(std::fs::canonicalize(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
@@ -116,16 +45,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>,
diff --git a/helix-core/src/syntax.rs b/helix-core/src/syntax.rs
index 02903637..f4826fb4 100644
--- a/helix-core/src/syntax.rs
+++ b/helix-core/src/syntax.rs
@@ -66,7 +66,7 @@ impl LanguageConfiguration {
 
 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 ?
diff --git a/helix-core/src/transaction.rs b/helix-core/src/transaction.rs
index 6f3956aa..9bd8c615 100644
--- a/helix-core/src/transaction.rs
+++ b/helix-core/src/transaction.rs
@@ -351,22 +351,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 +360,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
diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml
index e4956f0b..351c3b0e 100644
--- a/helix-lsp/Cargo.toml
+++ b/helix-lsp/Cargo.toml
@@ -8,6 +8,7 @@ edition = "2018"
 
 [dependencies]
 helix-core = { path = "../helix-core" }
+helix-view = { path = "../helix-view" }
 
 lsp-types = { version = "0.82", features = ["proposed"] }
 smol = "1.2"
diff --git a/helix-lsp/src/client.rs b/helix-lsp/src/client.rs
index 93e137cb..56413768 100644
--- a/helix-lsp/src/client.rs
+++ b/helix-lsp/src/client.rs
@@ -6,6 +6,7 @@ use crate::{
 type Result<T> = core::result::Result<T, Error>;
 
 use helix_core::{State, Transaction};
+use helix_view::Document;
 
 // use std::collections::HashMap;
 
@@ -190,13 +191,13 @@ impl Client {
     // Text document
     // -------------------------------------------------------------------------------------------
 
-    pub async fn text_document_did_open(&mut self, state: &State) -> Result<()> {
+    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(state.path().unwrap()).unwrap(),
+                uri: lsp::Url::from_file_path(doc.path().unwrap()).unwrap(),
                 language_id: "rust".to_string(), // TODO: hardcoded for now
-                version: state.version,
-                text: String::from(&state.doc),
+                version: doc.version,
+                text: String::from(doc.text()),
             },
         })
         .await
@@ -205,13 +206,13 @@ impl Client {
     // TODO: trigger any time history.commit_revision happens
     pub async fn text_document_did_change(
         &mut self,
-        state: &State,
+        doc: &Document,
         transaction: &Transaction,
     ) -> Result<()> {
         self.notify::<lsp::notification::DidChangeTextDocument>(lsp::DidChangeTextDocumentParams {
             text_document: lsp::VersionedTextDocumentIdentifier::new(
-                lsp::Url::from_file_path(state.path().unwrap()).unwrap(),
-                state.version,
+                lsp::Url::from_file_path(doc.path().unwrap()).unwrap(),
+                doc.version,
             ),
             content_changes: vec![lsp::TextDocumentContentChangeEvent {
                 // range = None -> whole document
@@ -223,12 +224,12 @@ impl Client {
         .await
     }
 
-    // TODO: impl into() TextDocumentIdentifier / VersionedTextDocumentIdentifier for State.
+    // TODO: impl into() TextDocumentIdentifier / VersionedTextDocumentIdentifier for Document.
 
-    pub async fn text_document_did_close(&mut self, state: &State) -> Result<()> {
+    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(state.path().unwrap()).unwrap(),
+                lsp::Url::from_file_path(doc.path().unwrap()).unwrap(),
             ),
         })
         .await
diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs
index a1a6b9ea..b9594b7e 100644
--- a/helix-term/src/application.rs
+++ b/helix-term/src/application.rs
@@ -1,10 +1,11 @@
 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,
+    document::Mode,
     keymap::{self, Keymaps},
     prompt::Prompt,
-    Editor, Theme, View,
+    Document, Editor, Theme, View,
 };
 
 use std::{
@@ -95,15 +96,15 @@ impl Renderer {
         self.surface.set_style(area, 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 end = view.state.doc().line_to_byte(last_line)
-                + view.state.doc().line(last_line).len_bytes();
+            let start = view.doc.text().line_to_byte(view.first_line);
+            let end = view.doc.text().line_to_byte(last_line)
+                + view.doc.text().line(last_line).len_bytes();
 
             start..end
         };
@@ -111,7 +112,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)
@@ -127,6 +128,7 @@ impl Renderer {
         let mut visual_x = 0;
         let mut line = 0u16;
         let visible_selections: Vec<Range> = view
+            .doc
             .state
             .selection()
             .ranges()
@@ -147,10 +149,10 @@ 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 end = view.state.doc().byte_to_char(end); // <-- index 744, len 743
+                    let start = view.doc.text().byte_to_char(start);
+                    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};
 
@@ -207,7 +209,7 @@ impl Renderer {
 
                             // ugh, improve with a traverse method
                             // or interleave highlight spans with selection and diagnostic spans
-                            let style = if view.state.diagnostics.iter().any(|diagnostic| {
+                            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)
@@ -233,7 +235,7 @@ impl Renderer {
         let warning: Style = theme.get("warning");
         let last_line = view.last_line();
         for (i, line) in (view.first_line..last_line).enumerate() {
-            if view.state.diagnostics.iter().any(|d| d.line == line) {
+            if view.doc.diagnostics.iter().any(|d| d.line == line) {
                 self.surface.set_stringn(0, i as u16, "●", 1, warning);
             }
 
@@ -243,7 +245,7 @@ impl Renderer {
     }
 
     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",
@@ -259,7 +261,7 @@ impl Renderer {
         self.surface.set_string(
             self.size.0 - 10,
             self.size.1 - 2,
-            format!("{}", view.state.diagnostics.len()),
+            format!("{}", view.doc.diagnostics.len()),
             self.text_color,
         );
     }
@@ -329,14 +331,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,
@@ -345,10 +347,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;
@@ -416,7 +418,7 @@ impl<'a> Application<'a> {
         let res = self.lsp.initialize().await;
         let res = self
             .lsp
-            .text_document_did_open(&self.editor.view().unwrap().state)
+            .text_document_did_open(&self.editor.view().unwrap().doc)
             .await;
 
         self.render();
@@ -469,7 +471,7 @@ impl<'a> Application<'a> {
                     let keys = vec![event];
                     // TODO: sequences (`gg`)
                     // TODO: handle count other than 1
-                    match view.state.mode() {
+                    match view.doc.mode() {
                         Mode::Insert => {
                             if let Some(command) = self.keymap[&Mode::Insert].get(&keys) {
                                 command(view, 1);
@@ -573,10 +575,10 @@ impl<'a> Application<'a> {
                     .editor
                     .views
                     .iter_mut()
-                    .find(|view| view.state.path == path);
+                    .find(|view| view.doc.path == path);
 
                 if let Some(view) = view {
-                    let doc = view.state.doc().slice(..);
+                    let doc = view.doc.text().slice(..);
                     let diagnostics = params
                         .diagnostics
                         .into_iter()
@@ -596,7 +598,7 @@ impl<'a> Application<'a> {
                         })
                         .collect();
 
-                    view.state.diagnostics = diagnostics;
+                    view.doc.diagnostics = diagnostics;
 
                     self.render();
                 }
diff --git a/helix-view/Cargo.toml b/helix-view/Cargo.toml
index 330ae696..9d53f929 100644
--- a/helix-view/Cargo.toml
+++ b/helix-view/Cargo.toml
@@ -19,3 +19,4 @@ 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"
diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs
index e29d070e..b5350ff4 100644
--- a/helix-view/src/commands.rs
+++ b/helix-view/src/commands.rs
@@ -3,12 +3,13 @@ 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},
 };
@@ -19,36 +20,40 @@ pub type Command = fn(view: &mut View, count: usize);
 
 pub fn move_char_left(view: &mut View, count: usize) {
     // TODO: use a transaction
-    let selection = view
-        .state
-        .move_selection(Direction::Backward, Granularity::Character, count);
-    view.state.selection = selection;
+    let selection =
+        view.doc
+            .state
+            .move_selection(Direction::Backward, Granularity::Character, count);
+    view.doc.state.selection = selection;
 }
 
 pub fn move_char_right(view: &mut View, count: usize) {
     // TODO: use a transaction
-    view.state.selection =
-        view.state
+    view.doc.state.selection =
+        view.doc
+            .state
             .move_selection(Direction::Forward, Granularity::Character, count);
 }
 
 pub fn move_line_up(view: &mut View, count: usize) {
     // TODO: use a transaction
-    view.state.selection = view
-        .state
-        .move_selection(Direction::Backward, Granularity::Line, count);
+    view.doc.state.selection =
+        view.doc
+            .state
+            .move_selection(Direction::Backward, Granularity::Line, count);
 }
 
 pub fn move_line_down(view: &mut View, count: usize) {
     // TODO: use a transaction
-    view.state.selection = view
-        .state
-        .move_selection(Direction::Forward, Granularity::Line, count);
+    view.doc.state.selection =
+        view.doc
+            .state
+            .move_selection(Direction::Forward, Granularity::Line, count);
 }
 
 pub fn move_line_end(view: &mut View, _count: usize) {
     // TODO: use a transaction
-    let lines = selection_lines(&view.state);
+    let lines = selection_lines(&view.doc.state);
 
     let positions = lines
         .into_iter()
@@ -57,89 +62,89 @@ 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)
+            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);
+    let transaction = Transaction::new(&mut view.doc.state).with_selection(selection);
 
-    transaction.apply(&mut view.state);
+    view.doc.apply(&transaction);
 }
 
 pub fn move_line_start(view: &mut View, _count: usize) {
-    let lines = selection_lines(&view.state);
+    let lines = selection_lines(&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)
+            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);
+    let transaction = Transaction::new(&mut view.doc.state).with_selection(selection);
 
-    transaction.apply(&mut view.state);
+    view.doc.apply(&transaction);
 }
 
 pub fn move_next_word_start(view: &mut View, count: usize) {
-    let pos = view.state.move_pos(
-        view.state.selection.cursor(),
+    let pos = view.doc.state.move_pos(
+        view.doc.state.selection.cursor(),
         Direction::Forward,
         Granularity::Word,
         count,
     );
 
     // TODO: use a transaction
-    view.state.selection = Selection::single(pos, pos);
+    view.doc.state.selection = Selection::single(pos, pos);
 }
 
 pub fn move_prev_word_start(view: &mut View, count: usize) {
-    let pos = view.state.move_pos(
-        view.state.selection.cursor(),
+    let pos = view.doc.state.move_pos(
+        view.doc.state.selection.cursor(),
         Direction::Backward,
         Granularity::Word,
         count,
     );
 
     // TODO: use a transaction
-    view.state.selection = Selection::single(pos, pos);
+    view.doc.state.selection = Selection::single(pos, pos);
 }
 
 pub fn move_next_word_end(view: &mut View, count: usize) {
     let pos = State::move_next_word_end(
-        &view.state.doc().slice(..),
-        view.state.selection.cursor(),
+        &view.doc.text().slice(..),
+        view.doc.state.selection.cursor(),
         count,
     );
 
     // TODO: use a transaction
-    view.state.selection = Selection::single(pos, pos);
+    view.doc.state.selection = Selection::single(pos, pos);
 }
 
 pub fn move_file_start(view: &mut View, _count: usize) {
     // TODO: use a transaction
-    view.state.selection = Selection::single(0, 0);
+    view.doc.state.selection = Selection::single(0, 0);
 
-    view.state.mode = Mode::Normal;
+    view.doc.mode = Mode::Normal;
 }
 
 pub fn move_file_end(view: &mut View, _count: usize) {
     // TODO: use a transaction
-    let text = &view.state.doc;
+    let text = &view.doc.text();
     let last_line = text.line_to_char(text.len_lines().saturating_sub(2));
-    view.state.selection = Selection::single(last_line, last_line);
+    view.doc.state.selection = Selection::single(last_line, last_line);
 
-    view.state.mode = Mode::Normal;
+    view.doc.mode = Mode::Normal;
 }
 
 pub fn check_cursor_in_view(view: &mut View) -> bool {
-    let cursor = view.state.selection().cursor();
-    let line = view.state.doc().char_to_line(cursor);
+    let cursor = view.doc.state.selection().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) {
@@ -156,19 +161,19 @@ pub fn page_up(view: &mut View, _count: usize) {
     view.first_line = view.first_line.saturating_sub(view.size.1 as usize);
 
     if !check_cursor_in_view(view) {
-        let text = view.state.doc();
+        let text = view.doc.text();
         let pos = text.line_to_char(view.last_line().saturating_sub(PADDING));
-        view.state.selection = Selection::single(pos, pos);
+        view.doc.state.selection = Selection::single(pos, pos);
     }
 }
 
 pub fn page_down(view: &mut View, _count: usize) {
     view.first_line += view.size.1 as usize + PADDING;
 
-    if view.first_line < view.state.doc().len_lines() {
-        let text = view.state.doc();
+    if view.first_line < view.doc.text().len_lines() {
+        let text = view.doc.text();
         let pos = text.line_to_char(view.first_line as usize);
-        view.state.selection = Selection::single(pos, pos);
+        view.doc.state.selection = Selection::single(pos, pos);
     }
 }
 
@@ -180,79 +185,84 @@ pub fn half_page_up(view: &mut View, _count: usize) {
     view.first_line = view.first_line.saturating_sub(view.size.1 as usize / 2);
 
     if !check_cursor_in_view(view) {
-        let text = &view.state.doc;
+        let text = &view.doc.text();
         let pos = text.line_to_char(view.last_line() - PADDING);
-        view.state.selection = Selection::single(pos, pos);
+        view.doc.state.selection = Selection::single(pos, pos);
     }
 }
 
 pub fn half_page_down(view: &mut View, _count: usize) {
-    let lines = view.state.doc().len_lines();
+    let lines = view.doc.text().len_lines();
     if view.first_line < lines.saturating_sub(view.size.1 as usize) {
         view.first_line += view.size.1 as usize / 2;
     }
     if !check_cursor_in_view(view) {
-        let text = view.state.doc();
+        let text = view.doc.text();
         let pos = text.line_to_char(view.first_line as usize);
-        view.state.selection = Selection::single(pos, pos);
+        view.doc.state.selection = Selection::single(pos, 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) {
     // TODO: use a transaction
-    let selection = view
-        .state
-        .extend_selection(Direction::Backward, Granularity::Character, count);
-    view.state.selection = selection;
+    let selection =
+        view.doc
+            .state
+            .extend_selection(Direction::Backward, Granularity::Character, count);
+    view.doc.state.selection = selection;
 }
 
 pub fn extend_char_right(view: &mut View, count: usize) {
     // TODO: use a transaction
-    view.state.selection =
-        view.state
+    view.doc.state.selection =
+        view.doc
+            .state
             .extend_selection(Direction::Forward, Granularity::Character, count);
 }
 
 pub fn extend_line_up(view: &mut View, count: usize) {
     // TODO: use a transaction
-    view.state.selection =
-        view.state
+    view.doc.state.selection =
+        view.doc
+            .state
             .extend_selection(Direction::Backward, Granularity::Line, count);
 }
 
 pub fn extend_line_down(view: &mut View, count: usize) {
     // TODO: use a transaction
-    view.state.selection =
-        view.state
+    view.doc.state.selection =
+        view.doc
+            .state
             .extend_selection(Direction::Forward, Granularity::Line, count);
 }
 
 pub fn split_selection_on_newline(view: &mut View, _count: usize) {
-    let text = &view.state.doc.slice(..);
+    let text = &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
-    view.state.selection = selection::split_on_matches(text, view.state.selection(), &REGEX)
+    view.doc.state.selection = selection::split_on_matches(text, view.doc.state.selection(), &REGEX)
 }
 
 pub fn select_line(view: &mut View, _count: usize) {
     // TODO: count
-    let pos = view.state.selection().primary();
-    let text = view.state.doc();
+    let pos = view.doc.state.selection().primary();
+    let text = 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
-    view.state.selection = Selection::single(start, end);
+    view.doc.state.selection = Selection::single(start, end);
 }
 
 pub fn delete_selection(view: &mut View, _count: usize) {
-    let transaction =
-        Transaction::change_by_selection(&view.state, |range| (range.from(), range.to() + 1, None));
-    transaction.apply(&mut view.state);
+    let transaction = Transaction::change_by_selection(&view.doc.state, |range| {
+        (range.from(), range.to() + 1, None)
+    });
+    view.doc.apply(&transaction);
 
     append_changes_to_history(view);
 }
@@ -263,21 +273,23 @@ pub fn change_selection(view: &mut View, count: usize) {
 }
 
 pub fn collapse_selection(view: &mut View, _count: usize) {
-    view.state.selection = view
+    view.doc.state.selection = view
+        .doc
         .state
         .selection
         .transform(|range| Range::new(range.head, range.head))
 }
 
 pub fn flip_selections(view: &mut View, _count: usize) {
-    view.state.selection = view
+    view.doc.state.selection = view
+        .doc
         .state
         .selection
         .transform(|range| Range::new(range.head, range.anchor))
 }
 
 fn enter_insert_mode(view: &mut View) {
-    view.state.mode = Mode::Insert;
+    view.doc.mode = Mode::Insert;
 
     append_changes_to_history(view);
 }
@@ -285,7 +297,8 @@ fn enter_insert_mode(view: &mut View) {
 pub fn insert_mode(view: &mut View, _count: usize) {
     enter_insert_mode(view);
 
-    view.state.selection = view
+    view.doc.state.selection = view
+        .doc
         .state
         .selection
         .transform(|range| Range::new(range.to(), range.from()))
@@ -294,11 +307,11 @@ pub fn insert_mode(view: &mut View, _count: usize) {
 // inserts at the end of each selection
 pub fn append_mode(view: &mut View, _count: usize) {
     enter_insert_mode(view);
-    view.state.restore_cursor = true;
+    view.doc.restore_cursor = true;
 
     // TODO: as transaction
-    let text = &view.state.doc.slice(..);
-    view.state.selection = view.state.selection.transform(|range| {
+    let text = &view.doc.text().slice(..);
+    view.doc.state.selection = view.doc.state.selection.transform(|range| {
         // TODO: to() + next char
         Range::new(
             range.from(),
@@ -346,13 +359,13 @@ pub fn append_to_line(view: &mut View, count: usize) {
 pub fn open_below(view: &mut View, _count: usize) {
     enter_insert_mode(view);
 
-    let lines = selection_lines(&view.state);
+    let lines = selection_lines(&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)
+            view.doc.text().line_to_char(index + 1)
         })
         .collect();
 
@@ -373,63 +386,63 @@ pub fn open_below(view: &mut View, _count: usize) {
         0,
     );
 
-    let transaction = Transaction::change(&view.state, changes).with_selection(selection);
+    let transaction = Transaction::change(&view.doc.state, changes).with_selection(selection);
 
-    transaction.apply(&mut view.state);
+    view.doc.apply(&transaction);
 }
 
 // O inserts a new line before each line with a selection
 
 fn append_changes_to_history(view: &mut View) {
-    if view.state.changes.is_empty() {
+    if view.doc.changes.is_empty() {
         return;
     }
 
-    let new_changeset = ChangeSet::new(view.state.doc());
-    let changes = std::mem::replace(&mut view.state.changes, new_changeset);
+    let new_changeset = ChangeSet::new(view.doc.text());
+    let changes = std::mem::replace(&mut 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(view.doc.state.selection().clone());
 
     // increment document version
     // TODO: needs to happen on undo/redo too
-    view.state.version += 1;
+    view.doc.version += 1;
 
     // TODO: trigger lsp/documentDidChange with changes
 
     // HAXX: we need to reconstruct the state as it was before the changes..
-    let (doc, selection) = view.state.old_state.take().unwrap();
+    let (doc, selection) = view.doc.old_state.take().unwrap();
     let mut old_state = State::new(doc);
     old_state.selection = selection;
 
     // TODO: take transaction by value?
-    view.history.commit_revision(&transaction, &old_state);
+    view.doc.history.commit_revision(&transaction, &old_state);
 
     // HAXX
-    view.state.old_state = Some((view.state.doc().clone(), view.state.selection.clone()));
+    view.doc.old_state = Some((view.doc.text().clone(), view.doc.state.selection.clone()));
 }
 
 pub fn normal_mode(view: &mut View, _count: usize) {
-    view.state.mode = Mode::Normal;
+    view.doc.mode = Mode::Normal;
 
     append_changes_to_history(view);
 
     // if leaving append mode, move cursor back by 1
-    if view.state.restore_cursor {
-        let text = &view.state.doc.slice(..);
-        view.state.selection = view.state.selection.transform(|range| {
+    if view.doc.restore_cursor {
+        let text = &view.doc.text().slice(..);
+        view.doc.state.selection = view.doc.state.selection.transform(|range| {
             Range::new(
                 range.from(),
                 graphemes::prev_grapheme_boundary(text, range.to()),
             )
         });
 
-        view.state.restore_cursor = false;
+        view.doc.restore_cursor = false;
     }
 }
 
 pub fn goto_mode(view: &mut View, _count: usize) {
-    view.state.mode = Mode::Goto;
+    view.doc.mode = Mode::Goto;
 }
 
 // NOTE: Transactions in this module get appended to history when we switch back to normal mode.
@@ -438,9 +451,9 @@ pub mod insert {
     // 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) {
         let c = Tendril::from_char(c);
-        let transaction = Transaction::insert(&view.state, c);
+        let transaction = Transaction::insert(&view.doc.state, c);
 
-        transaction.apply(&mut view.state);
+        view.doc.apply(&transaction);
     }
 
     pub fn insert_tab(view: &mut View, _count: usize) {
@@ -448,41 +461,44 @@ pub mod insert {
     }
 
     pub fn insert_newline(view: &mut View, _count: usize) {
-        let transaction = Transaction::change_by_selection(&view.state, |range| {
-            let indent_level =
-                helix_core::indent::suggested_indent_for_pos(&view.state, range.head);
+        let transaction = Transaction::change_by_selection(&view.doc.state, |range| {
+            let indent_level = helix_core::indent::suggested_indent_for_pos(
+                view.doc.syntax.as_ref(),
+                &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);
+        view.doc.apply(&transaction);
     }
 
     // TODO: handle indent-aware delete
     pub fn delete_char_backward(view: &mut View, count: usize) {
-        let text = &view.state.doc.slice(..);
-        let transaction = Transaction::change_by_selection(&view.state, |range| {
+        let text = &view.doc.text().slice(..);
+        let transaction = Transaction::change_by_selection(&view.doc.state, |range| {
             (
                 graphemes::nth_prev_grapheme_boundary(text, range.head, count),
                 range.head,
                 None,
             )
         });
-        transaction.apply(&mut view.state);
+        view.doc.apply(&transaction);
     }
 
     pub fn delete_char_forward(view: &mut View, count: usize) {
-        let text = &view.state.doc.slice(..);
-        let transaction = Transaction::change_by_selection(&view.state, |range| {
+        let text = &view.doc.text().slice(..);
+        let transaction = Transaction::change_by_selection(&view.doc.state, |range| {
             (
                 range.head,
                 graphemes::nth_next_grapheme_boundary(text, range.head, count),
                 None,
             )
         });
-        transaction.apply(&mut view.state);
+        view.doc.apply(&transaction);
     }
 }
 
@@ -493,13 +509,13 @@ pub fn insert_char_prompt(prompt: &mut Prompt, c: char) {
 // Undo / Redo
 
 pub fn undo(view: &mut View, _count: usize) {
-    view.history.undo(&mut view.state);
+    view.doc.history.undo(&mut view.doc.state);
 
     // TODO: each command could simply return a Option<transaction>, then the higher level handles storing it?
 }
 
 pub fn redo(view: &mut View, _count: usize) {
-    view.history.redo(&mut view.state);
+    view.doc.history.redo(&mut view.doc.state);
 }
 
 // Yank / Paste
@@ -507,9 +523,10 @@ pub fn redo(view: &mut View, _count: usize) {
 pub fn yank(view: &mut View, _count: usize) {
     // TODO: should selections be made end inclusive?
     let values = view
+        .doc
         .state
         .selection()
-        .fragments(&view.state.doc().slice(..))
+        .fragments(&view.doc.text().slice(..))
         .map(|cow| cow.into_owned())
         .collect();
 
@@ -550,18 +567,18 @@ 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();
-            Transaction::change_by_selection(&view.state, |range| {
+            let text = view.doc.text();
+            Transaction::change_by_selection(&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(&view.doc.state, |range| {
                 (range.head + 1, range.head + 1, Some(values.next().unwrap()))
             })
         };
 
-        transaction.apply(&mut view.state);
+        view.doc.apply(&transaction);
         append_changes_to_history(view);
     }
 }
@@ -570,9 +587,9 @@ fn get_lines(view: &View) -> Vec<usize> {
     let mut lines = Vec::new();
 
     // Get all line numbers
-    for range in view.state.selection.ranges() {
-        let start = view.state.doc.char_to_line(range.from());
-        let end = view.state.doc.char_to_line(range.to());
+    for range in view.doc.state.selection.ranges() {
+        let start = view.doc.text().char_to_line(range.from());
+        let end = view.doc.text().char_to_line(range.to());
 
         for line in start..=end {
             lines.push(line)
@@ -590,13 +607,13 @@ pub fn indent(view: &mut View, _count: usize) {
     let indent = Tendril::from(" ".repeat(TAB_WIDTH));
 
     let transaction = Transaction::change(
-        &view.state,
+        &view.doc.state,
         lines.into_iter().map(|line| {
-            let pos = view.state.doc.line_to_char(line);
+            let pos = view.doc.text().line_to_char(line);
             (pos, pos, Some(indent.clone()))
         }),
     );
-    transaction.apply(&mut view.state);
+    view.doc.apply(&transaction);
     append_changes_to_history(view);
 }
 
@@ -605,7 +622,7 @@ pub fn unindent(view: &mut View, _count: usize) {
     let mut changes = Vec::with_capacity(lines.len());
 
     for line_idx in lines {
-        let line = view.state.doc.line(line_idx);
+        let line = view.doc.text().line(line_idx);
         let mut width = 0;
 
         for ch in line.chars() {
@@ -621,14 +638,14 @@ pub fn unindent(view: &mut View, _count: usize) {
         }
 
         if width > 0 {
-            let start = view.state.doc.line_to_char(line_idx);
+            let start = 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(&view.doc.state, changes.into_iter());
 
-    transaction.apply(&mut view.state);
+    view.doc.apply(&transaction);
     append_changes_to_history(view);
 }
 
diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs
new file mode 100644
index 00000000..c4b9d081
--- /dev/null
+++ b/helix-view/src/document.rs
@@ -0,0 +1,157 @@
+use anyhow::Error;
+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>,
+
+    /// Pending changes since last history commit.
+    pub changes: ChangeSet,
+    pub history: History,
+    pub version: i64, // should be usize?
+    pub old_state: Option<(Rope, Selection)>,
+
+    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 = Some((state.doc.clone(), Selection::single(0, 0)));
+
+        Self {
+            path: None,
+            state,
+            mode: Mode::Normal,
+            restore_cursor: false,
+            syntax: None,
+            changes,
+            old_state,
+            diagnostics: Vec::new(),
+            version: 0,
+            history: History::default(),
+        }
+    }
+
+    // TODO: passing scopes here is awkward
+    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);
+        };
+
+        // canonicalize path to absolute value
+        doc.path = Some(std::fs::canonicalize(path)?);
+
+        Ok(doc)
+    }
+
+    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);
+        };
+    }
+
+    // TODO: needs to run on undo/redo
+    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()
+            });
+
+            // 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 slice<R>(&self, range: R) -> RopeSlice where R: RangeBounds {
+    //     self.state.doc.slice
+    // }
+}
diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs
index 61abd482..02199255 100644
--- a/helix-view/src/editor.rs
+++ b/helix-view/src/editor.rs
@@ -1,6 +1,5 @@
 use crate::theme::Theme;
-use crate::View;
-use helix_core::State;
+use crate::{Document, View};
 
 use std::path::PathBuf;
 
@@ -27,8 +26,8 @@ impl Editor {
 
     pub fn open(&mut self, path: PathBuf, size: (u16, u16)) -> Result<(), Error> {
         let pos = self.views.len();
-        let state = State::load(path, self.theme.scopes())?;
-        self.views.push(View::new(state, size)?);
+        let doc = Document::load(path, self.theme.scopes())?;
+        self.views.push(View::new(doc, size)?);
         self.focus = pos;
         Ok(())
     }
diff --git a/helix-view/src/keymap.rs b/helix-view/src/keymap.rs
index 82bdbe21..347e7d77 100644
--- a/helix-view/src/keymap.rs
+++ b/helix-view/src/keymap.rs
@@ -1,4 +1,5 @@
 use crate::commands::{self, Command};
+use crate::document::Mode;
 use helix_core::{hashmap, state};
 use std::collections::HashMap;
 
@@ -88,7 +89,7 @@ pub use crossterm::event::{KeyCode, KeyEvent as Key, KeyModifiers as Modifiers};
 
 // TODO: could be trie based
 pub type Keymap = HashMap<Vec<Key>, Command>;
-pub type Keymaps = HashMap<state::Mode, Keymap>;
+pub type Keymaps = HashMap<Mode, Keymap>;
 
 macro_rules! key {
     ($ch:expr) => {
@@ -128,7 +129,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 +180,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 +202,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
diff --git a/helix-view/src/lib.rs b/helix-view/src/lib.rs
index 9abe8a1a..3b923744 100644
--- a/helix-view/src/lib.rs
+++ b/helix-view/src/lib.rs
@@ -1,10 +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;
diff --git a/helix-view/src/view.rs b/helix-view/src/view.rs
index 817714c8..4cf6a2ee 100644
--- a/helix-view/src/view.rs
+++ b/helix-view/src/view.rs
@@ -2,10 +2,11 @@ use anyhow::Error;
 
 use std::borrow::Cow;
 
+use crate::Document;
 use helix_core::{
     graphemes::{grapheme_width, RopeGraphemes},
     indent::TAB_WIDTH,
-    History, Position, RopeSlice, State,
+    Position, RopeSlice,
 };
 use tui::layout::Rect;
 
@@ -14,29 +15,25 @@ 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 first_line: usize,
     pub size: (u16, u16),
-
-    // TODO: Doc fields
-    pub history: History,
 }
 
 impl View {
-    pub fn new(state: State, size: (u16, u16)) -> Result<Self, Error> {
+    pub fn new(doc: Document, size: (u16, u16)) -> Result<Self, Error> {
         let view = Self {
-            state,
+            doc,
             first_line: 0,
             size,
-            history: History::default(),
         };
 
         Ok(view)
     }
 
     pub fn ensure_cursor_in_view(&mut self) {
-        let cursor = self.state.selection().cursor();
-        let line = self.state.doc().char_to_line(cursor);
+        let cursor = self.doc.state.selection().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
@@ -56,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,
         )
     }
 
@@ -88,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,
+        }
+    }
 }