fixup! feat(files): make file system actions LSP aware

refactor: Simplify `lsp_fs_hook` code

Author: TheLeoP

lua/mini/files.lua

@@ -2811,61 +2811,46 @@ H.lsp_fs_hook = function(method, diffs)
     end
   end
 
-  local params = { files = files }
   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 grouped_matching_functions = {}
-    for _, filter in ipairs(filters) do
-      local ignore_case = filter.pattern.options and filter.pattern.options.ignoreCase
-      local glob = filter.pattern.glob
+    local filters, filter_configs = {}, client.server_capabilities.workspace.fileOperations[method].filters --[=[@as lsp.FileOperationFilter[]]=]
+    for _, fc in ipairs(filter_configs) do
+      local ignore_case = fc.pattern.options and fc.pattern.options.ignoreCase
+      local glob, matches, scheme = fc.pattern.glob, fc.pattern.matches, fc.scheme
+
       if ignore_case then glob = vim.fn.tolower(glob) end
 
-      local matching_functions = {}
-      table.insert(matching_functions, function(uri)
-        local path = vim.uri_to_fname(uri)
-        return vim.glob.to_lpeg(glob):match(path) ~= nil
-      end)
-      if filter.scheme then
-        table.insert(matching_functions, function(uri) return uri:find('^' .. filter.scheme .. ':') ~= nil end)
-      end
-      if filter.pattern.matches then
-        table.insert(matching_functions, function(uri)
-          local path = vim.uri_to_fname(uri)
-          local type = H.fs_get_type(path)
-          if filter.pattern.matches == 'folder' then return type == 'directory' end
-          if filter.pattern.matches == 'file' then return type == 'file' end
+      local filter_funcs = {}
+      table.insert(filter_funcs, function(uri) return vim.glob.to_lpeg(glob):match((vim.uri_to_fname(uri))) ~= nil end)
+      if scheme then table.insert(filter_funcs, function(uri) return uri:find('^' .. scheme .. ':') ~= nil end) end
+      if matches then
+        table.insert(filter_funcs, function(uri)
+          local type = H.fs_get_type((vim.uri_to_fname(uri))):gsub('directory', 'folder')
+          return matches == type
         end)
       end
-      table.insert(grouped_matching_functions, matching_functions)
+      table.insert(filters, filter_funcs)
     end
 
-    local filtered_params = {
-      files = {},
-    }
-    for _, file in ipairs(params.files) do
+    local filtered_files = {}
+    for _, file in ipairs(files) do
       local uri = file.uri or file.oldUri
-      local matches_any_filter = false
-      for _, matching_functions in ipairs(grouped_matching_functions) do
-        if not matches_any_filter then
-          local matches_current_filter = true
-          for _, matching_function in ipairs(matching_functions) do
-            matches_current_filter = matches_current_filter and matching_function(uri)
-          end
-          matches_any_filter = matches_any_filter or matches_current_filter
-        end
-      end
-      if matches_any_filter then table.insert(filtered_params.files, file) end
+
+      local ok = vim.iter(filters):any(function(f)
+        return vim.iter(f):all(function(func) return func(uri) end)
+      end)
+      if ok then table.insert(filtered_files, file) end
     end
+    local params = { files = filtered_files }
 
     if method:sub(1, 3) == 'did' then
-      client:notify(full_method, filtered_params)
+      client:notify(full_method, params)
     else
-      local response, err = client:request_sync(full_method, filtered_params, timeout)
+      local response, err = client:request_sync(full_method, params, timeout)
       -- TODO(TheLeoP): show error to user?
       if response and response.result then
         vim.lsp.util.apply_workspace_edit(response.result, client.offset_encoding)