feat(files): make file system actions LSP aware

Author: TheLeoP

lua/mini/files.lua

@@ -2742,19 +2742,125 @@ H.fs_actions_apply = function(fs_actions)
   end
 end
 
+H.lsp_will_fs_do_methods = {
+  create = 'willCreate',
+  delete = 'willDelete',
+  rename = 'willRename',
+}
+
+H.lsp_will_fs_do = function(action, params)
+  local method = H.lsp_will_fs_do_methods[action]
+  local full_method = 'workspace/' .. method .. 'Files'
+  local clients = vim.lsp.get_clients({ method = full_method })
+
+  -- TODO(TheLeoP): configurable timeout
+  local timeout = 1000
+  for _, client in ipairs(clients) do
+    local filters = client.server_capabilities.workspace.fileOperations[method].filters --[=[@as lsp.FileOperationFilter[]]=]
+    local matching_functions = {}
+    for _, filter in ipairs(filters) do
+      local ignore_case = filter.pattern.options and filter.pattern.options.ignoreCase
+      local glob = filter.pattern.glob
+      if ignore_case then glob = glob:lower() end
+
+      table.insert(matching_functions, function(uri)
+        local path = vim.uri_to_fname(uri)
+        return vim.glob.to_lpeg(glob):match(path)
+      end)
+      if filter.scheme then
+        table.insert(matching_functions, function(uri) return uri:find('^' .. filter.scheme .. ':') ~= nil end)
+      end
+    end
+
+    local filtered_params = {
+      files = {},
+    }
+    for _, file in ipairs(params.files) do
+      local uri = file.uri or file.oldUri
+      local matches = true
+      for _, matching_function in ipairs(matching_functions) do
+        matches = matches and matching_function(uri)
+      end
+      if matches then table.insert(filtered_params.files, file) end
+    end
+
+    local response, err = client:request_sync(full_method, filtered_params, timeout)
+    if response and response.result then vim.lsp.util.apply_workspace_edit(response.result, client.offset_encoding) end
+  end
+end
+
+H.lsp_did_fs_do_methods = {
+  create = 'didCreate',
+  delete = 'didDelete',
+  rename = 'didRename',
+}
+
+H.lsp_did_fs_do = function(action, params)
+  local method = H.lsp_did_fs_do_methods[action]
+  local full_method = 'workspace/' .. method .. 'Files'
+
+  local clients = vim.lsp.get_clients({ method = full_method })
+  for _, client in ipairs(clients) do
+    local filters = client.server_capabilities.workspace.fileOperations[method].filters --[=[@as lsp.FileOperationFilter[]]=]
+    local matching_functions = {}
+    for _, filter in ipairs(filters) do
+      local ignore_case = filter.pattern.options and filter.pattern.options.ignoreCase
+      local glob = filter.pattern.glob
+      if ignore_case then glob = glob:lower() end
+
+      table.insert(matching_functions, function(uri)
+        local path = vim.uri_to_fname(uri)
+        return vim.glob.to_lpeg(glob):match(path)
+      end)
+      if filter.scheme then
+        table.insert(matching_functions, function(uri) return uri:find('^' .. filter.scheme .. ':') ~= nil end)
+      end
+    end
+
+    local filtered_params = {
+      files = {},
+    }
+    for _, file in ipairs(params.files) do
+      local uri = file.uri or file.oldUri
+      local matches = true
+      for _, matching_function in ipairs(matching_functions) do
+        matches = matches and matching_function(uri)
+      end
+      if matches then table.insert(filtered_params.files, file) end
+    end
+
+    client:notify(full_method, filtered_params)
+  end
+end
+
 H.fs_do = {}
 
 H.fs_do.create = function(_, path)
   -- Don't override existing path
   if H.fs_is_present_path(path) then return H.warn_existing_path(path, 'create') end
 
+  -- TODO(TheLeoP): should we explicitly check permissions before willXxx
+  -- requests? It seems like Windows has different permissinon rules for
+  -- creating/deleting/moving files and `libuv` doesn't provide an absraction
+  -- for them
+  local lsp_params = {
+    files = { {
+      uri = vim.uri_from_fname(path),
+    } },
+  }
+  H.lsp_will_fs_do('create', lsp_params)
+
   -- Create parent directory allowing nested names
   vim.fn.mkdir(H.fs_get_parent(path), 'p')
 
   -- Create
   local fs_type = path:sub(-1) == '/' and 'directory' or 'file'
   if fs_type == 'directory' then return vim.fn.mkdir(path) == 1 end
-  return vim.fn.writefile({}, path) == 0
+  local success = vim.fn.writefile({}, path) == 0
+
+  if success then H.lsp_did_fs_do('create', lsp_params) end
+
+  return success
 end
 
 H.fs_do.copy = function(from, to)
@@ -2784,19 +2890,42 @@ H.fs_do.copy = function(from, to)
 end
 
 H.fs_do.delete = function(from, to)
+  local lsp_params = { {
+    files = {
+      uri = vim.uri_from_fname(from),
+    },
+  } }
+  H.lsp_will_fs_do('delete', lsp_params)
+
   -- Act based on whether delete is permanent or not
-  if to == nil then return vim.fn.delete(from, 'rf') == 0 end
-  pcall(vim.fn.delete, to, 'rf')
-  -- Move to trash but skip renaming loaded buffer (same as with permanent
-  -- delete). This also skips triggering extra autocommands that can have
-  -- unwanted side effects (like loading LSP in the new "trash" project).
-  return H.fs_do.move(from, to, true)
+  local success
+  if to == nil then success = vim.fn.delete(from, 'rf') == 0 end
+  if to ~= nil then
+    pcall(vim.fn.delete, to, 'rf')
+    -- Move to trash but skip renaming loaded buffer (same as with permanent
+    -- delete). This also skips triggering extra autocommands that can have
+    -- unwanted side effects (like loading LSP in the new "trash" project).
+    success = H.fs_do.move(from, to, true)
+  end
+
+  if success then H.lsp_did_fs_do('delete', lsp_params) end
+
+  return success
 end
 
-H.fs_do.move = function(from, to, skip_buf_rename)
+H.fs_do.move = function(from, to, is_trash_delete)
   -- Don't override existing path
   if H.fs_is_present_path(to) then return H.warn_existing_path(from, 'move or rename') end
 
+  if not is_trash_delete then
+    H.lsp_will_fs_do('rename', {
+      files = { {
+        oldUri = vim.uri_from_fname(from),
+        newUri = vim.uri_from_fname(to),
+      } },
+    })
+  end
+
   -- Move while allowing to create directory
   vim.fn.mkdir(H.fs_get_parent(to), 'p')
   local success, _, err_code = vim.loop.fs_rename(from, to)
@@ -2815,12 +2944,21 @@ H.fs_do.move = function(from, to, skip_buf_rename)
   H.replace_path_in_index(from, to)
 
   -- Rename in loaded buffers
-  if not skip_buf_rename then
+  if not is_trash_delete then
     for _, buf_id in ipairs(vim.api.nvim_list_bufs()) do
       H.rename_loaded_buffer(buf_id, from, to)
     end
   end
 
+  if not is_trash_delete then
+    H.lsp_did_fs_do('rename', {
+      files = { {
+        oldUri = vim.uri_from_fname(from),
+        newUri = vim.uri_from_fname(to),
+      } },
+    })
+  end
+
   return success
 end