fix: use remote server for executing commands

Author: smjonas

README.md

@@ -1,5 +1,5 @@
 # live-command.nvim
-![version](https://img.shields.io/badge/version-1.2.1-brightgreen)
+![version](https://img.shields.io/badge/version-1.3.0-brightgreen)
 
 Text editing in Neovim with immediate visual feedback: view the effects of any command on your buffer contents live. Preview macros, the `:norm` command & more!
 
@@ -9,24 +9,26 @@ Text editing in Neovim with immediate visual feedback: view the effects of any c
 <p><sub>Theme: <a href="https://github.com/folke/tokyonight.nvim">tokyonight.nvim</a></sub></p>
 
 ## :sparkles: Motivation and Features
-In version 0.8, Neovim has introduced the `command-preview` feature.
-Contrary to what "command preview" suggests, previewing any given
-command does not work out of the box: you need to manually update the buffer text and set
-highlights *for every command*.
+In Neovim version 0.8, the `command-preview` feature has been introduced.
+Despite its name, it does not enable automatic previewing of any command.
+Instead, users must manually update the buffer text and set highlights *for each command*.
 
-This plugin tries to change that: it provides a **simple API for creating previewable commands**
-in Neovim. Just specify the command you want to run and live-command will do all the
-work for you. This includes viewing **individual insertions, changes and deletions** as you
-type.
+This plugin aims to address this issue by offering a **simple API for creating previewable commands**
+in Neovim. Simply provide the command you want to preview and live-command will do all the
+work for you. This includes viewing **individual insertions, changes and deletions** as you type.
+
+After the most recent update, live-command now spawns a separate Neovim instance to execute commands.
+This avoids many issues encountered when running the command directly in the current Neovim instance
+([#6](https://github.com/smjonas/live-command.nvim/issues/6), [#16](https://github.com/smjonas/live-command.nvim/issues/16), [#24](https://github.com/smjonas/live-command.nvim/issues/24), [#28](https://github.com/smjonas/live-command.nvim/issues/28)).
 
 ## Requirements
 Neovim 0.8+
 
 ## :rocket: Getting started
 Install using your favorite package manager and call the setup function with a table of
-commands to create. Here is an example that creates a previewable `:Norm` command:
+commands to create. Here is an example for `lazy.nvim` that creates a previewable `:Norm` command:
 ```lua
-use {
+{
   "smjonas/live-command.nvim",
   -- live-command supports semantic versioning via tags
   -- tag = "1.*",
@@ -50,7 +52,7 @@ Here is a list of available settings:
 | ----------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------
 | cmd         | string   | The name of an existing command to preview.
 | args        | string? \| function(arg: string?, opts: table) -> string | Arguments passed to the command. If a function, takes in the options passed to the command and must return the transformed argument(s) `cmd` will be called with. `opts` has the same structure as the `opts` table passed to the `nvim_create_user_command` callback function. If `nil`, the arguments are supplied from the command-line while the user is typing the command.
-| range       | string?  | The range to prepend to the command. Set this to `""` if you don't want the new command to receive a count, e.g. when turning `:9Reg a` into `:norm 9@a`. If `nil`, the range will be supplied from the command entered. 
+| range       | string?  | The range to prepend to the command. Set this to `""` if you don't want the new command to receive a count, e.g. when turning `:9Reg a` into `:norm 9@a`. If `nil`, the range will be supplied from the command entered.
 
 ### Example
 The following example creates a `:Reg` command which allows you to preview the effects of macros (e.g. `:5Reg a` to run macro `a` five times).

lua/live-command/init.lua

@@ -13,6 +13,9 @@ M.defaults = {
 local should_cache_lines = true
 local cached_lines
 local prev_lazyredraw
+local remote, chan_id
+-- local server_address, chan_id
+local cursor_row, cursor_col
 
 local logs = {}
 local function log(msg, level)
@@ -176,13 +179,14 @@ end
 -- Expose functions to tests
 M._preview_across_lines = get_diff_highlights
 
-local function run_buf_cmd(buf, cmd)
-  vim.api.nvim_buf_call(buf, function()
-    log(function()
-      return ("Previewing command: %s (current line = %d)"):format(cmd, vim.api.nvim_win_get_cursor(0)[1])
-    end)
-    vim.cmd(cmd)
+local function run_cmd(cmd)
+  local cursor_pos = vim.api.nvim_win_get_cursor(0)
+  cursor_row, cursor_col = cursor_pos[1], cursor_pos[2]
+
+  log(function()
+    return ("Previewing command: %s (l=%d,c=%d)"):format(cmd, cursor_row, cursor_col)
   end)
+  return remote.run_cmd(chan_id, cmd, cursor_row, cursor_col)
 end
 
 -- Called when the user is still typing the command or the command arguments
@@ -207,10 +211,11 @@ local function command_preview(opts, preview_ns, preview_buf)
   local prev_errmsg = vim.v.errmsg
   local visible_line_range = { vim.fn.line("w0"), vim.fn.line("w$") }
 
+  local updated_lines
   if opts.line1 == opts.line2 then
-    run_buf_cmd(bufnr, ("%s %s"):format(command.cmd, args))
+    updated_lines = run_cmd(("%s %s"):format(command.cmd, args))
   else
-    run_buf_cmd(bufnr, ("%d,%d%s %s"):format(opts.line1, opts.line2, command.cmd, args))
+    updated_lines = run_cmd(("%d,%d%s %s"):format(opts.line1, opts.line2, command.cmd, args))
   end
 
   vim.v.errmsg = prev_errmsg
@@ -220,7 +225,6 @@ local function command_preview(opts, preview_ns, preview_buf)
     math.max(visible_line_range[2], vim.fn.line("w$")),
   }
 
-  local updated_lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
   local set_lines = function(lines)
     -- TODO: is this worth optimizing?
     vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
@@ -341,6 +345,39 @@ local validate_config = function(config)
   end
 end
 
+local create_autocmds = function()
+  local id = vim.api.nvim_create_augroup("command_preview.nvim", { clear = true })
+
+  vim.api.nvim_create_autocmd("CmdlineEnter", {
+    group = id,
+    callback = remote.on_cmdline_enter,
+  })
+
+  -- We need to be able to tell when the command was cancelled so the buffer lines are refetched next time.
+  vim.api.nvim_create_autocmd("CmdLineLeave", {
+    group = id,
+    -- Schedule wrap to run after a potential command execution
+    callback = vim.schedule_wrap(function()
+      restore_buffer_state()
+    end),
+  })
+
+  vim.api.nvim_create_autocmd("VimLeavePre", {
+    group = id,
+    callback = function()
+      if chan_id then
+        vim.fn.chanclose(chan_id)
+      end
+      remote.shutdown()
+    end,
+  })
+
+  vim.api.nvim_create_autocmd({ "TextChanged", "TextChangedI", "BufEnter" }, {
+    group = id,
+    callback = remote.on_text_changed,
+  })
+end
+
 M.setup = function(user_config)
   if vim.fn.has("nvim-0.8.0") ~= 1 then
     vim.notify(
@@ -353,16 +390,12 @@ M.setup = function(user_config)
   local config = vim.tbl_deep_extend("force", M.defaults, user_config or {})
   validate_config(config)
   create_user_commands(config.commands)
+  remote = require("live-command.remote")
 
-  local id = vim.api.nvim_create_augroup("command_preview.nvim", { clear = true })
-  -- We need to be able to tell when the command was cancelled so the buffer lines are refetched next time.
-  vim.api.nvim_create_autocmd({ "CmdLineLeave" }, {
-    group = id,
-    -- Schedule wrap to run after a potential command execution
-    callback = vim.schedule_wrap(function()
-      restore_buffer_state()
-    end),
-  })
+  remote.init_rpc(function(id)
+    chan_id = id
+  end)
+  create_autocmds()
 
   M.debug = user_config.debug
 
@@ -375,6 +408,6 @@ M.setup = function(user_config)
   end, { nargs = 0 })
 end
 
-M.version = "1.2.1"
+M.version = "1.3.0"
 
 return M

lua/live-command/remote.lua

@@ -0,0 +1,117 @@
+local M = {}
+
+local tmp_file = os.tmpname()
+local tmp_file_watcher
+local uv = vim.loop
+local dirty = true
+
+local watch_tmp_file = function(chan_id)
+  tmp_file_watcher = uv.new_fs_event()
+  tmp_file_watcher:start(
+    tmp_file,
+    {},
+    vim.schedule_wrap(function(_, fname, status)
+      if dirty then
+        -- Open the current file in the remote Nvim instance
+        vim.rpcrequest(
+          chan_id,
+          "nvim_exec",
+          -- Store the current sequence number that can be
+          ("e! %s | lua vim.g._seq_cur = vim.fn.undotree().seq_cur"):format(tmp_file),
+          false
+        )
+        dirty = false
+      end
+    end)
+  )
+end
+
+-- Starts a new Nvim instance and connects to it via RPC
+M.init_rpc = function(on_chan_id)
+  -- Avoid an infinite loop
+  if vim.env.LIVECOMMAND_NVIM_SERVER == "1" then
+    return
+  end
+
+  local server_address = vim.fs.normalize(vim.fn.stdpath("cache")) .. "/live_command_server_%d.pipe"
+  -- Randomize address to allow multiple Neovim instances running live-command at the same time
+  server_address = server_address:format(vim.fn.rand())
+
+  -- Use environment variables from parent process
+  local env = { "LIVECOMMAND_NVIM_SERVER=1" }
+  for k, v in pairs(uv.os_environ()) do
+    table.insert(env, k .. "=" .. v)
+  end
+
+  local handle
+  handle, _ = uv.spawn(
+    vim.v.progpath,
+    {
+      args = { "--listen", server_address, "-n" },
+      env = env,
+      cwd = vim.fn.getcwd(),
+    },
+    vim.schedule_wrap(function(_, _) -- on exit
+      handle:close()
+    end)
+  )
+
+  local basename = vim.fs.basename(server_address)
+  local watcher = uv.new_fs_event()
+  watcher:start(
+    vim.fs.dirname(server_address),
+    {},
+    vim.schedule_wrap(function(_, fname, status)
+      if status.rename and fname == basename then
+        local chan_id = vim.fn.sockconnect("pipe", server_address, { rpc = true })
+        on_chan_id(chan_id)
+        watch_tmp_file(chan_id)
+        watcher:stop()
+      end
+    end)
+  )
+end
+
+M.shutdown = function()
+  if tmp_file_watcher then
+    tmp_file_watcher:stop()
+  end
+end
+
+M.on_text_changed = function()
+  dirty = true
+end
+
+M.on_cmdline_enter = function()
+  if dirty then
+    -- Synchronize buffers by writing out the current buffer contents to a temporary file
+    vim.cmd("keepalt w! " .. tmp_file)
+  end
+end
+
+-- Runs a command on the remote server and returns the updates buffer lines.
+-- This is superior to running vim.cmd from the preview callback in the original Nvim instance
+-- as that has a lot of side effects, e.g. https://github.com/neovim/neovim/issues/21495.
+M.run_cmd = function(chan_id, cmd, cursor_row, cursor_col)
+  -- Restore the buffer state since the last write and move the cursor to the correct position
+  vim.rpcrequest(
+    chan_id,
+    "nvim_exec_lua",
+    ("vim.api.nvim_win_set_cursor(0, {%d, %d})"):format(cursor_row, cursor_col),
+    {}
+  )
+  -- Execute the command asynchronously using rpcnotify as it may block
+  vim.rpcnotify(chan_id, "nvim_exec", cmd, false)
+
+  return vim.rpcrequest(
+    chan_id,
+    "nvim_exec_lua",
+    [[local lines = vim.api.nvim_buf_get_lines(0, 0, -1, false)
+      vim.cmd.undo({count = vim.g._seq_cur})
+      return lines
+    ]],
+    {}
+  )
+end
+
+return M