take template as command, fetch pos

Author: pickx

src/core_editor/editor.rs

@@ -1,10 +1,12 @@
 use super::{edit_stack::EditStack, Clipboard, ClipboardMode, LineBuffer};
 #[cfg(feature = "system_clipboard")]
 use crate::core_editor::get_system_clipboard;
+use crate::engine::EditorPosition;
 use crate::enums::{EditType, TextObject, TextObjectScope, TextObjectType, UndoBehavior};
 use crate::prompt::{PromptEditMode, PromptViMode};
 use crate::{core_editor::get_local_clipboard, EditCommand};
 use std::cmp::{max, min};
+use std::num::NonZeroUsize;
 use std::ops::{DerefMut, Range};
 
 /// Stateful editor executing changes to the underlying [`LineBuffer`]
@@ -1112,6 +1114,35 @@ impl Editor {
             self.copy_range(around_range);
         }
     }
+
+    pub(crate) fn editor_position(&self) -> EditorPosition {
+        // TODO: this impl can probably be faster (caching newline locations?)
+
+        let buffer = self.get_buffer();
+
+        let content_len = self.insertion_point().min(buffer.len());
+        let content_until_cursor = &buffer[..content_len];
+
+        // impl note: see `core_editor::line_buffer::insert_newline`:
+        // we don't expect any other char sequence for linebreak.
+        let newline = '\n';
+
+        let line = {
+            let line_one_based = content_until_cursor.matches(newline).count() + 1;
+            NonZeroUsize::new(line_one_based).unwrap()
+        };
+
+        let col = {
+            let col_one_based = if let Some(newline_pos) = content_until_cursor.rfind(newline) {
+                content_until_cursor[newline_pos + 1..].chars().count() + 1
+            } else {
+                content_until_cursor.chars().count() + 1
+            };
+            NonZeroUsize::new(col_one_based).unwrap()
+        };
+
+        EditorPosition { line, col }
+    }
 }
 
 fn insert_clipboard_content_before(line_buffer: &mut LineBuffer, clipboard: &mut dyn Clipboard) {

src/engine.rs

@@ -1,4 +1,8 @@
-use std::path::PathBuf;
+use std::{
+    ffi::OsStr,
+    num::NonZeroUsize,
+    path::{Path, PathBuf},
+};
 
 use itertools::Itertools;
 use nu_ansi_term::{Color, Style};
@@ -47,6 +51,7 @@ use {
         terminal, QueueableCommand,
     },
     std::{
+        ffi::OsString,
         fs::File,
         io,
         io::Result,
@@ -225,6 +230,14 @@ struct BufferEditor {
     temp_file: PathBuf,
 }
 
+/// a position in a buffer.
+/// indexes are one-based (hence the use of non-zero integer types)
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct EditorPosition {
+    pub line: NonZeroUsize,
+    pub col: NonZeroUsize,
+}
+
 impl Drop for Reedline {
     fn drop(&mut self) {
         if self.cursor_shapes.is_some() {
@@ -559,10 +572,6 @@ impl Reedline {
     /// ```
     #[must_use]
     pub fn with_buffer_editor(mut self, editor: Command, temp_file: PathBuf) -> Self {
-        let mut editor = editor;
-        if !editor.get_args().contains(&temp_file.as_os_str()) {
-            editor.arg(&temp_file);
-        }
         self.buffer_editor = Some(BufferEditor {
             command: editor,
             temp_file,
@@ -1359,7 +1368,15 @@ impl Reedline {
                 }
                 Ok(EventStatus::Handled)
             }
-            ReedlineEvent::OpenEditor => self.open_editor().map(|_| EventStatus::Handled),
+            ReedlineEvent::OpenEditor => {
+                if let Some(buffer_editor) = &self.buffer_editor {
+                    let new_buffer = self.open_editor(buffer_editor)?;
+                    self.editor
+                        .set_buffer(new_buffer, UndoBehavior::CreateUndoPoint);
+                }
+
+                Ok(EventStatus::Handled)
+            }
             ReedlineEvent::Resize(width, height) => {
                 self.last_render_snapshot = None;
                 self.painter.handle_resize(width, height);
@@ -1872,30 +1889,69 @@ impl Reedline {
         }
     }
 
-    fn open_editor(&mut self) -> Result<()> {
-        match &mut self.buffer_editor {
-            Some(BufferEditor {
-                ref mut command,
-                ref temp_file,
-            }) => {
-                {
-                    let mut file = File::create(temp_file)?;
-                    write!(file, "{}", self.editor.get_buffer())?;
-                }
-                {
-                    let mut child = command.spawn()?;
-                    child.wait()?;
-                }
+    /// opens the current buffer in the editor described in [`buffer_editor`]
+    /// returns the new buffer, after processing the changes via the editor
+    fn open_editor(&self, buffer_editor: &BufferEditor) -> Result<String> {
+        let mut command = self.render_buffer_editor_command(buffer_editor);
+
+        // flush buffer to temp file, so it can be read by the editor
+        {
+            let mut file = File::create(&buffer_editor.temp_file)?;
+            write!(file, "{}", self.editor.get_buffer())?;
+        }
 
-                let res = std::fs::read_to_string(temp_file)?;
-                let res = res.trim_end().to_string();
+        command.spawn()?.wait()?;
 
-                self.editor.set_buffer(res, UndoBehavior::CreateUndoPoint);
+        // fetch contents of buffer after editor is done
+        let mut buffer = std::fs::read_to_string(&buffer_editor.temp_file)?;
+        let content_len = buffer.trim_end().len();
+        buffer.truncate(content_len);
 
-                Ok(())
-            }
-            _ => Ok(()),
+        Ok(buffer)
+    }
+
+    /// renders the template command described in [`buffer_editor`], if any
+    fn render_buffer_editor_command(&self, buffer_editor: &BufferEditor) -> Command {
+        let mut cmd = Command::new(buffer_editor.command.get_program());
+
+        // TODO: there are more efficient ways to do this.
+        const FILE: &str = "{file}";
+        const LINE: &str = "{line}";
+        const COL: &str = "{col}";
+
+        // kind of a wonky check, but it's enough to know
+        // that we have somewhere to stick that temp_file path in
+        let is_template = buffer_editor
+            .command
+            .get_args()
+            .map(OsStr::to_string_lossy)
+            .any(|arg| arg.contains(FILE));
+
+        if is_template {
+            let pos = self.editor.editor_position();
+
+            // TODO: there are more efficient ways to do this.
+            // e.g. "format args"-style structs
+
+            let file = buffer_editor.temp_file.to_string_lossy();
+            let line = pos.line.to_string();
+            let col = pos.col.to_string();
+
+            let actual_args = buffer_editor
+                .command
+                .get_args()
+                .map(OsStr::to_string_lossy)
+                .map(|arg| arg.replace(FILE, &file))
+                .map(|arg| arg.replace(LINE, &line))
+                .map(|arg| arg.replace(COL, &col));
+
+            cmd.args(actual_args);
+        } else {
+            cmd.args(buffer_editor.command.get_args());
+            cmd.arg(&buffer_editor.temp_file);
         }
+
+        cmd
     }
 
     /// Repaint logic for the history reverse search