feat: opening new files and not having a 1-tick delay

Author: wllfaria

glyph-config/src/lib.rs

@@ -7,7 +7,7 @@ use dirs::DIRS;
 use glyph_core::command::{Context, MappableCommand};
 use glyph_core::editor::Mode;
 use glyph_core::highlights::HighlightGroup;
-use glyph_runtime::keymap::{LuaKeymapOpts, LuaMappableCommand};
+use glyph_runtime::keymap::{LuaKeymap, LuaKeymapOpts, LuaMappableCommand};
 use glyph_runtime::statusline::StatuslineConfig;
 use glyph_runtime::RuntimeMessage;
 use glyph_trie::Trie;
@@ -199,6 +199,16 @@ pub struct KeymapConfig<'cfg> {
     pub options: KeymapOptions,
 }
 
+impl<'cfg> From<LuaKeymap<'cfg>> for KeymapConfig<'cfg> {
+    fn from(lua_keymap: LuaKeymap<'cfg>) -> KeymapConfig<'cfg> {
+        KeymapConfig {
+            mode: lua_keymap.mode,
+            command: lua_keymap.command.into(),
+            options: lua_keymap.options.into(),
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct Config<'cfg> {
     cursor: CursorConfig,
@@ -280,19 +290,22 @@ fn handle_setup_messages(messages: Vec<RuntimeMessage>) -> SetupMessagesResult {
 
     for message in messages {
         match message {
-            RuntimeMessage::Error(error) => println!("{error:?}"),
+            RuntimeMessage::Error(error) => panic!("{error:?}"),
             RuntimeMessage::UpdateHighlightGroup(name, group) => _ = highlight_groups.insert(name, group),
             RuntimeMessage::UserCommandCreate(name, callback) => _ = user_commands.insert(name, callback),
             RuntimeMessage::SetKeymap(lua_keymap) => {
-                let keymap = KeymapConfig {
-                    mode: lua_keymap.mode,
-                    command: lua_keymap.command.into(),
-                    options: lua_keymap.options.into(),
-                };
                 let mode_maps = keymaps.get_mut(&lua_keymap.mode).unwrap();
-                mode_maps.add_word(&lua_keymap.keys, keymap);
+                let keys = lua_keymap.keys.clone();
+                let keymap = KeymapConfig::from(lua_keymap);
+                mode_maps.add_word(keys, keymap);
             }
+            // Some runtime messages are ignored here as we don't want to handle them within
+            // configuration context.
+            //
+            // Only messages that change configuration values should be considered when loading
+            // configuration.
             RuntimeMessage::Quit(_) => {}
+            RuntimeMessage::OpenFile(_) => {}
             RuntimeMessage::Write(_) => {}
         };
     }

glyph-core/src/editor.rs

@@ -166,7 +166,16 @@ impl Editor {
         assert!(self.documents.contains_key(&id));
 
         match action {
-            OpenAction::Replace => todo!(),
+            OpenAction::Replace => {
+                let tab = self.focused_tab_mut();
+                let window = tab
+                    .tree
+                    .get_window_mut(tab.tree.focus())
+                    .expect("no active window on the editor");
+
+                window.document = id;
+                window.id
+            }
             OpenAction::SplitVertical => {
                 let tab = self.focused_tab_mut();
 

glyph-core/src/syntax.rs

@@ -57,7 +57,7 @@ impl Highlighter {
     pub fn add_document(&mut self, document: &Document) {
         let parser = self.get_or_create_parser(document.language());
 
-        let tree = parser.and_then(|p| p.parse(document.text().slice(..).to_string(), None));
+        let tree = parser.and_then(|p| p.parse(document.text().to_string(), None));
 
         let mut syntax = Syntax {
             language: document.language(),
@@ -67,9 +67,12 @@ impl Highlighter {
         };
 
         if let Some(ref tree) = syntax.tree {
+            // let mut file = std::fs::File::create("tree.sexp").unwrap();
+            // print_highlights_sexp(tree, document.language(), &document.text().to_string(), &mut file).unwrap();
+
             let mut cursor = tree_sitter::QueryCursor::new();
             let root = tree.root_node();
-            let language = self.get_ts_language(document.language()).unwrap();
+            let language = get_ts_language(document.language()).unwrap();
 
             let query = self.queries.entry(document.language()).or_insert(
                 tree_sitter::Query::new(&language.into(), &get_ts_query(document.language()).unwrap()).unwrap(),
@@ -143,7 +146,7 @@ impl Highlighter {
             return self.parsers.get_mut(&language);
         }
 
-        if let Some(ts_language) = self.get_ts_language(language) {
+        if let Some(ts_language) = get_ts_language(language) {
             let mut parser = Parser::new();
             parser.set_language(&ts_language.into()).ok();
             self.parsers.insert(language, parser);
@@ -152,20 +155,70 @@ impl Highlighter {
 
         None
     }
+}
 
-    fn get_ts_language(&self, language: LanguageId) -> Option<impl Into<Language>> {
-        match language {
-            LanguageId::Rust => Some(tree_sitter_rust::LANGUAGE),
-            LanguageId::Lua => Some(tree_sitter_lua::LANGUAGE),
-            _ => None,
-        }
+fn get_ts_language(language: LanguageId) -> Option<impl Into<Language>> {
+    match language {
+        LanguageId::Rust => Some(tree_sitter_rust::LANGUAGE),
+        LanguageId::Lua => Some(tree_sitter_lua::LANGUAGE),
+        _ => None,
     }
 }
 
 fn get_ts_query(language: LanguageId) -> Option<String> {
     match language {
-        LanguageId::Rust => Some(tree_sitter_rust::HIGHLIGHTS_QUERY.to_string()),
+        LanguageId::Rust => {
+            let highlights = include_str!("../../languages/queries/rust/highlights.scm");
+            Some(highlights.to_string())
+        }
         LanguageId::Lua => Some(tree_sitter_lua::HIGHLIGHTS_QUERY.to_string()),
         _ => None,
     }
 }
+
+// fn print_highlights_sexp<W: std::io::Write>(
+//     tree: &Tree,
+//     language_id: LanguageId,
+//     source_code: &str,
+//     writer: &mut W,
+// ) -> std::io::Result<()> {
+//     let Some(language) = get_ts_language(language_id) else {
+//         return Ok(());
+//     };
+//
+//     let Some(query) = get_ts_query(language_id) else {
+//         return Ok(());
+//     };
+//
+//     let Ok(query) = tree_sitter::Query::new(&language.into(), &query) else {
+//         return Ok(());
+//     };
+//
+//     let mut query_cursor = tree_sitter::QueryCursor::new();
+//     let mut matches = query_cursor.matches(&query, tree.root_node(), source_code.as_bytes());
+//
+//     let mut nodes_with_captures = Vec::new();
+//     while let Some(match_) = matches.next() {
+//         for capture in match_.captures {
+//             let node = capture.node;
+//             let capture_name = &query.capture_names()[capture.index as usize];
+//             nodes_with_captures.push((node, capture_name));
+//         }
+//     }
+//
+//     nodes_with_captures.sort_by_key(|(node, _)| (node.start_position(), node.end_position()));
+//
+//     for (node, capture_name) in nodes_with_captures {
+//         let text = &source_code[node.start_byte()..node.end_byte()];
+//         writeln!(
+//             writer,
+//             "({} \"{}\" @{})",
+//             node.kind(),
+//             text.replace('"', "\\\""),
+//             capture_name
+//         )?;
+//         //writeln!(writer, "@{}", capture_name)?;
+//     }
+//
+//     Ok(())
+// }

glyph-runtime/src/editor.rs

@@ -31,6 +31,12 @@ pub fn setup_editor_api(
         lua.create_function(move |lua: &Lua, args: Table| editor_write(lua, args, sender.clone()))?,
     )?;
 
+    let sender = runtime_sender.clone();
+    core.set(
+        "editor_open_file",
+        lua.create_function(move |_: &Lua, filename: mlua::String| editor_open_file(filename, sender.clone()))?,
+    )?;
+
     Ok(())
 }
 
@@ -74,3 +80,12 @@ fn editor_write(
 
     Ok(())
 }
+
+fn editor_open_file(
+    filename: mlua::String,
+    runtime_sender: UnboundedSender<RuntimeMessage<'static>>,
+) -> mlua::Result<()> {
+    let filename = filename.to_string_lossy();
+    runtime_sender.send(RuntimeMessage::OpenFile(filename)).ok();
+    Ok(())
+}

glyph-runtime/src/lib.rs

@@ -40,6 +40,7 @@ pub enum RuntimeMessage<'msg> {
     Error(String),
     Quit(QuitOptions),
     Write(WriteOptions),
+    OpenFile(String),
 }
 
 pub fn setup_lua_runtime(

glyph-term/src/layers/editor_layer.rs

@@ -333,10 +333,14 @@ impl EditorLayer {
             Mode::Command => match key_event.code {
                 KeyCode::Char(ch) => editor.command.push(ch),
                 KeyCode::Enter => {
-                    if let Some(command) = config.user_commands.get(&editor.command) {
-                        let window = editor.focused_tab().tree.focus();
-                        let document = editor.focused_tab().tree.window(window).document;
-                        command.call::<()>(usize::from(document) as i64).ok();
+                    if editor.command.is_empty() {
+                        return Ok(None);
+                    }
+
+                    let pieces = editor.command.split_whitespace().collect::<Vec<_>>();
+
+                    if let Some(command) = config.user_commands.get(pieces[0]) {
+                        command.call::<()>(&pieces[1..]).unwrap();
                         editor.command.clear();
                         editor.set_mode(Mode::Normal);
                     }

glyph-term/src/ui/line_number.rs

@@ -106,7 +106,16 @@ impl LineNumberDrawer for RelativeLineDrawer {
             let diff = cursor.y().abs_diff(line);
             let style = if diff == 0 { current_line_style } else { style };
 
-            write!(&mut line_str, "{:>width$}", diff, width = line_size).unwrap();
+            write!(&mut line_str, "{:>width$} ", diff, width = line_size).unwrap();
+            buffer.set_string(x, area.y + row as u16, &line_str, *style);
+        }
+
+        let remaining = area.height as usize - (end - start);
+        for line in 0..remaining {
+            line_str.clear();
+            use std::fmt::Write;
+            let row = end - start + line;
+            write!(&mut line_str, "{diff:>width$} ", diff = "~", width = line_size).unwrap();
             buffer.set_string(x, area.y + row as u16, &line_str, *style);
         }
     }
@@ -141,7 +150,7 @@ impl LineNumberDrawer for RelativeNumberedLineDrawer {
             let style = if diff == 0 { current_line_style } else { style };
             let diff = if diff == 0 { cursor.y() + 1 } else { diff };
 
-            write!(&mut line_str, "{:>width$}", diff, width = line_size).unwrap();
+            write!(&mut line_str, "{:>width$} ", diff, width = line_size).unwrap();
             buffer.set_string(x, area.y + row as u16, &line_str, *style);
         }
 
@@ -150,7 +159,7 @@ impl LineNumberDrawer for RelativeNumberedLineDrawer {
             line_str.clear();
             use std::fmt::Write;
             let row = end - start + line;
-            write!(&mut line_str, "{diff:>width$}", diff = "~", width = 6).unwrap();
+            write!(&mut line_str, "{diff:>width$} ", diff = "~", width = line_size).unwrap();
             buffer.set_string(x, area.y + row as u16, &line_str, *style);
         }
     }

glyph/src/glyph.rs

@@ -36,8 +36,10 @@ where
     runtime_receiver: ReceiverStream<RuntimeMessage<'static>>,
 }
 
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, PartialOrd, Ord)]
 pub enum ControlFlow {
     Break,
+    Continue,
 }
 
 #[derive(Debug)]
@@ -145,14 +147,13 @@ where
                 Some(event) = input_stream.next() => {
                     self.handle_event(event?)?;
                     self.draw_frame()?;
-                    None
+                    ControlFlow::Continue
                 }
-                Some(message) = self.runtime_receiver.next() => self.handle_runtime_message(message),
+                Some(message) = self.runtime_receiver.next() => self.handle_runtime_message(message)?,
             };
 
-            match control_flow {
-                Some(ControlFlow::Break) => break Ok(()),
-                None => {}
+            if control_flow == ControlFlow::Break {
+                break Ok(());
             }
         }
     }
@@ -167,20 +168,19 @@ where
         self.renderer.handle_event(&event, &mut context, &self.config)
     }
 
-    fn handle_runtime_message(&mut self, message: RuntimeMessage) -> Option<ControlFlow> {
+    fn handle_runtime_message(&mut self, message: RuntimeMessage) -> Result<ControlFlow, io::Error> {
         match message {
             RuntimeMessage::UpdateHighlightGroup(_, _) => todo!(),
             RuntimeMessage::SetKeymap(_) => todo!(),
             RuntimeMessage::UserCommandCreate(_, _) => todo!(),
             RuntimeMessage::Error(_) => todo!(),
             RuntimeMessage::Quit(options) => match (options.force, options.all) {
-                (true, true) => return Some(ControlFlow::Break),
+                (true, true) => return Ok(ControlFlow::Break),
                 (true, false) => todo!(),
                 (false, true) => {}
                 (false, false) => {
-                    let should_quit = self.editor.write().close_active_window();
-                    if should_quit {
-                        return Some(ControlFlow::Break);
+                    if self.editor.write().close_active_window() {
+                        return Ok(ControlFlow::Break);
                     }
                 }
             },
@@ -195,11 +195,27 @@ where
                     let window = tab.tree.window(window);
                     let document = window.document;
                     editor.write_document(document);
+                    drop(editor);
+                    self.draw_frame()?;
                 }
             },
+            RuntimeMessage::OpenFile(filename) => {
+                let mut editor = self.editor.write();
+                if filename.is_empty() {
+                    editor.new_file(OpenAction::Replace);
+                    return Ok(ControlFlow::Continue);
+                }
+                let text = std::fs::read_to_string(&filename).expect("TODO: handle this error");
+                let (_, document) = editor.new_file_with_document(filename, text, OpenAction::Replace);
+                let document = editor.document(document);
+                self.highlighter.add_document(document);
+
+                drop(editor);
+                self.draw_frame()?;
+            }
         };
 
-        None
+        Ok(ControlFlow::Continue)
     }
 
     fn draw_frame(&mut self) -> Result<(), std::io::Error> {