fix: use remote server for executing commands

smjonas · smjonas · commit fe96417a6d0b · 2023-04-20T14:39:45.000+02:00
diff --git a/README.md b/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).
diff --git a/lua/live-command/init.lua b/lua/live-command/init.lua
@@ -10,6 +10,14 @@ M.defaults = {
   },
 }
 
+local api = vim.api
+---@class Remote
+local remote
+
+---@type number?
+local chan_id
+
+local cursor_row, cursor_col
 local should_cache_lines = true
 local cached_lines
 local prev_lazyredraw
@@ -85,6 +93,7 @@ local function add_inline_highlights(line, cached_lns, updated_lines, undo_delet
       -- Observation: when changing "line" to "tes", there should not be an offset (-2)
       -- after changing "lin" to "t" (because we are not modifying the line)
       highlight.column = highlight.column + col_offset
+      highlight.hunk = nil
       table.insert(highlights, highlight)
 
       if defer then
@@ -176,13 +185,15 @@ 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)
+---@param cmd string
+local function run_cmd(cmd)
+  local cursor_pos = 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
@@ -194,11 +205,11 @@ local function command_preview(opts, preview_ns, preview_buf)
   local args = opts.cmd_args
   local command = opts.command
 
-  local bufnr = vim.api.nvim_get_current_buf()
+  local bufnr = api.nvim_get_current_buf()
   if should_cache_lines then
     prev_lazyredraw = vim.o.lazyredraw
     vim.o.lazyredraw = true
-    cached_lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
+    cached_lines = api.nvim_buf_get_lines(bufnr, 0, -1, false)
     should_cache_lines = false
   end
 
@@ -207,10 +218,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,12 +232,11 @@ 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)
+    api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
     if preview_buf then
-      vim.api.nvim_buf_set_lines(preview_buf, 0, -1, false, lines)
+      api.nvim_buf_set_lines(preview_buf, 0, -1, false, lines)
     end
   end
 
@@ -255,7 +266,7 @@ local function command_preview(opts, preview_ns, preview_buf)
   for _, hl in ipairs(highlights) do
     local hl_group = command.hl_groups[hl.kind]
     if hl_group ~= false then
-      vim.api.nvim_buf_add_highlight(
+      api.nvim_buf_add_highlight(
         bufnr,
         preview_ns,
         hl_group,
@@ -285,7 +296,7 @@ end
 local create_user_commands = function(commands)
   for name, command in pairs(commands) do
     local args, range
-    vim.api.nvim_create_user_command(name, function(opts)
+    api.nvim_create_user_command(name, function(opts)
       local range_string = range and range
         or (
           opts.range == 2 and ("%s,%s"):format(opts.line1, opts.line2)
@@ -341,7 +352,51 @@ local validate_config = function(config)
   end
 end
 
+local create_autocmds = function()
+  local id = api.nvim_create_augroup("command_preview.nvim", { clear = true })
+
+  api.nvim_create_autocmd("CmdlineEnter", {
+    group = id,
+    callback = function()
+      remote.sync(chan_id)
+    end,
+  })
+
+  -- We need to be able to tell when the command was cancelled so the buffer lines are refetched next time.
+  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),
+  })
+
+  api.nvim_create_autocmd("VimLeavePre", {
+    group = id,
+    callback = function()
+      if chan_id then
+        vim.fn.chanclose(chan_id)
+      end
+    end,
+  })
+
+  api.nvim_create_autocmd({ "TextChanged", "TextChangedI", "BufEnter" }, {
+    group = id,
+    callback = remote.on_buffer_updated,
+  })
+
+  api.nvim_create_autocmd("BufWritePost", {
+    group = id,
+    callback = remote.on_buffer_saved,
+  })
+end
+
 M.setup = function(user_config)
+  -- Avoid an infinite loop when invoked from a child process
+  if vim.env.LIVECOMMAND_NVIM_SERVER == "1" then
+    return
+  end
+
   if vim.fn.has("nvim-0.8.0") ~= 1 then
     vim.notify(
       "[live-command] This plugin requires at least Neovim 0.8. Please upgrade your Neovim version.",
@@ -353,20 +408,16 @@ 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
 
-  vim.api.nvim_create_user_command("LiveCommandLog", function()
+  api.nvim_create_user_command("LiveCommandLog", function()
     local msg = ("live-command log\n================\n\n%s%s"):format(
       logs.ERROR and "[ERROR]\n" .. table.concat(logs.ERROR, "\n") .. (logs.TRACE and "\n" or "") or "",
       logs.TRACE and "[TRACE]\n" .. table.concat(logs.TRACE, "\n") or ""
@@ -375,6 +426,6 @@ M.setup = function(user_config)
   end, { nargs = 0 })
 end
 
-M.version = "1.2.1"
+M.version = "1.3.0"
 
 return M
diff --git a/lua/live-command/remote.lua b/lua/live-command/remote.lua
@@ -0,0 +1,153 @@
+---@class Remote
+local M = {}
+
+local tmp_file = os.tmpname()
+local uv = vim.loop
+local dirty = true
+
+---@type number
+local reference_time
+
+local REFERENCE_TIME_OFFSET = 1
+
+---@param server_address string
+---@param on_chan_id fun(chan_id:number)
+---@param num_retries number
+local try_connect = function(server_address, on_chan_id, num_retries)
+  local ok, chan_id
+  for i = 0, num_retries do
+    ok, chan_id = pcall(vim.fn.sockconnect, "pipe", server_address, { rpc = true })
+    if ok then
+      reference_time = uv.fs_stat(tmp_file).mtime.sec
+      assert(reference_time)
+      on_chan_id(chan_id)
+      return true
+    end
+    if i ~= num_retries then
+      vim.wait(10)
+    end
+  end
+  return false
+end
+
+--- Starts a new Nvim instance and connects to it via RPC.
+---@param on_chan_id fun(chan_id: number)
+M.init_rpc = function(on_chan_id)
+  local basename = vim.fs.normalize(vim.fn.stdpath("cache"))
+  local server_address = basename .. "/live_command_server.pipe"
+
+  -- Try to connect to an existing server that has already been spawned
+  local success = try_connect(server_address, on_chan_id, 1)
+  if success then
+    return
+  end
+
+  -- 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)
+  )
+  assert(handle)
+  success = try_connect(server_address, on_chan_id, 100)
+  if not success then
+    vim.notify("[live-command.nvim] failed to connect to remote Neovim instance after 1000 ms", vim.log.levels.ERROR)
+  end
+end
+
+-- The global dirty flag indicates that other spawned Nvim instances need to reload the
+-- temp file. The flag is encoded by increasing the modified time of the temp file.
+local set_global_dirty_flag = function()
+  local stat = uv.fs_stat(tmp_file)
+  uv.fs_utime(tmp_file, stat.atime.nsec, reference_time + REFERENCE_TIME_OFFSET)
+  local new_stat = uv.fs_stat(tmp_file)
+  assert(new_stat.atime.nsec == stat.atime.nsec)
+end
+
+---@return boolean
+local check_global_dirty_flag = function()
+  local stat = uv.fs_stat(tmp_file)
+  local x = stat.mtime.sec == reference_time + REFERENCE_TIME_OFFSET
+  if x then
+    print("DIRRY")
+  end
+  return x
+end
+
+M.on_buffer_updated = function()
+  dirty = true
+end
+
+M.on_buffer_saved = function()
+  -- Writing a buffer to disk sets the global dirty flag
+  if dirty then
+    set_global_dirty_flag()
+  end
+end
+
+---@param chan_id number?
+M.sync = function(chan_id)
+  -- Child instance has not been created yet
+  if not chan_id then
+    return
+  end
+
+  dirty = dirty or check_global_dirty_flag()
+  if dirty then
+    print("dirty")
+    -- Synchronize buffers by writing out the current buffer contents to a temporary file.
+    -- Remove A and F option values to not affect the alternate file and the buffer name.
+    vim.cmd("let c=&cpoptions | set cpoptions-=A | set cpoptions-=F | silent w! " .. tmp_file .. " | let &cpoptions=c")
+    vim.rpcrequest(
+      chan_id,
+      "nvim_exec",
+      -- Store the current sequence number that can be reverted back to
+      ("e! %s | lua vim.g._seq_cur = vim.fn.undotree().seq_cur"):format(tmp_file),
+      false
+    )
+    dirty = false
+  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.
+---@param chan_id number
+---@param cmd string
+---@param cursor_row number
+---@param cursor_col number
+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
