fix: cleanup debounce functionality, may fix #111 and #109

Author: cseickel

lua/neo-tree/sources/filesystem/init.lua

@@ -116,10 +116,10 @@ M.follow = function(callback, force_show)
   end
   utils.debounce("neo-tree-follow", function()
     return follow_internal(callback, force_show)
-  end, 200, utils.debounce_strategy.CALL_LAST_ONLY)
+  end, 100, utils.debounce_strategy.CALL_LAST_ONLY)
 end
 
-local navigate_internal = function(path, path_to_reveal, callback)
+M._navigate_internal = function(path, path_to_reveal, callback)
   log.trace("navigate_internal", path, path_to_reveal)
   local state = get_state()
   state.dirty = false
@@ -138,7 +138,8 @@ local navigate_internal = function(path, path_to_reveal, callback)
     state.position.set(path_to_reveal)
     fs_scan.get_items_async(state, nil, path_to_reveal, callback)
   else
-    local follow_file = state.follow_current_file and manager.get_path_to_reveal()
+    local is_search = utils.truthy(state.search_pattern)
+    local follow_file = not is_search and state.follow_current_file and manager.get_path_to_reveal()
     local handled = false
     if utils.truthy(follow_file) then
       handled = follow_internal(callback, true)
@@ -170,8 +171,8 @@ M.navigate = function(path, path_to_reveal, callback)
   local state = get_state()
   state.in_navigate = true
   utils.debounce("filesystem_navigate", function()
-    navigate_internal(path, path_to_reveal, callback)
-  end, utils.debounce_strategy.CALL_FIRST_AND_LAST, 200)
+    M._navigate_internal(path, path_to_reveal, callback)
+  end, utils.debounce_strategy.CALL_FIRST_AND_LAST, 500)
 end
 
 M.reset_search = function(refresh)
@@ -268,6 +269,7 @@ M.setup = function(config, global_config)
           log.trace("Ignoring vim_buffer_changed event from " .. source)
           return
         end
+        log.trace("refreshing due to vim_buffer_changed event: ", afile)
         manager.refresh(M.name)
       end,
     })

lua/neo-tree/sources/filesystem/lib/filter.lua

@@ -83,7 +83,22 @@ M.show_filter = function(state, search_as_you_type)
       else
         log.trace("Setting search in on_change to: " .. value)
         state.search_pattern = value
-        manager.refresh("filesystem")
+        local len = #value
+        local delay = 500
+
+        if len > 5 then
+          delay = 100
+        elseif len > 3 then
+          delay = 200
+        elseif len > 2 then
+          delay = 400
+        end
+        utils.debounce(
+          "filesystem_filter",
+          fs._navigate_internal,
+          delay,
+          utils.debounce_strategy.CALL_LAST_ONLY
+        )
       end
     end,
   })

lua/neo-tree/sources/manager.lua

@@ -304,11 +304,11 @@ end
 
 ---Refreshes the tree by scanning the filesystem again.
 M.refresh = function(source_name, callback)
-  log.trace(source_name, " refresh")
   local current_tabnr = vim.api.nvim_get_current_tabpage()
   local sd = get_source_data(source_name)
   for _, state in pairs(sd.state_by_tab) do
     if state.tabnr == current_tabnr and state.path and renderer.window_exists(state) then
+      log.trace(source_name, " refresh")
       if type(callback) ~= "function" then
         callback = nil
       end

lua/neo-tree/utils.lua

@@ -34,64 +34,68 @@ M.debounce_strategy = {
 ---@param frequency_in_ms number Miniumum amount of time between invocations of fn.
 ---@param strategy number The debounce_strategy to use, determines which calls to fn are not dropped.
 ---@param callback function Called with the result of executing fn as: callback(success, result)
-M.debounce = function(id, fn, frequency_in_ms, strategy, callback)
-  strategy = strategy or M.debounce_strategy.CALL_FIRST_AND_LAST
+M.debounce = function(id, fn, frequency_in_ms, strategy)
   local fn_data = tracked_functions[id]
+
+  local defer_function = function()
+    fn_data.in_debounce_period = true
+    vim.defer_fn(function()
+      local current_data = tracked_functions[id]
+      local _fn = current_data.fn
+      current_data.fn = nil
+      current_data.in_debounce_period = false
+      if _fn ~= nil then
+        M.debounce(id, _fn, current_data.frequency_in_ms, strategy)
+      end
+    end, frequency_in_ms)
+  end
+
   if fn_data == nil then
     -- first call for this id
     fn_data = {
       id = id,
-      fn = nil,
+      in_debounce_period = false,
+      fn = fn,
       frequency_in_ms = frequency_in_ms,
-      postponed_callback = nil,
-      in_debounce_period = true,
     }
-    if strategy == M.debounce_strategy.CALL_LAST_ONLY then
-      fn_data.in_debounce_period = true
-    end
     tracked_functions[id] = fn_data
-  else
-    if fn_data.in_debounce_period then
-      -- This id was called recently and can't be executed again yet.
-      -- Just keep track of the details for this request so it
-      -- can be executed at the end of the debounce period.
-      -- Last one in wins.
-      fn_data.fn = fn
-      fn_data.frequency_in_ms = frequency_in_ms
-      fn_data.postponed_callback = callback
+    if strategy == M.debounce_strategy.CALL_LAST_ONLY then
+      defer_function()
       return
     end
+  else
+    fn_data.fn = fn
+    fn_data.frequency_in_ms = frequency_in_ms
+  end
+
+  if fn_data.in_debounce_period then
+    -- This id was called recently and can't be executed again yet.
+    -- Last one in wins.
+    return
   end
 
   -- Run the requested function normally.
   -- Use a pcall to ensure the debounce period is still respected even if
   -- this call throws an error.
   fn_data.in_debounce_period = true
   local success, result = pcall(fn)
+  fn_data.fn = nil
+  fn = nil
 
   if not success then
-    log.error("Error in neo-tree.utils.debounce: ", result)
+    log.error(result)
   end
 
-  -- Now schedule the next earliest execution.
-  -- If there are no calls to run the same function between now
-  -- and when this deferred executes, nothing will happen.
-  -- If there are several calls, only the last one in will run.
-  vim.defer_fn(function()
-    local current_data = tracked_functions[id]
-    local _callback = current_data.postponed_callback
-    local _fn = current_data.fn
-    current_data.postponed_callback = nil
-    current_data.fn = nil
-    current_data.in_debounce_period = false
-    if _fn ~= nil then
-      M.debounce(id, _fn, current_data.frequency_in_ms, strategy, _callback)
-    end
-  end, frequency_in_ms)
-
-  -- The callback function is outside the scope of the debounce period
-  if type(callback) == "function" then
-    callback(success, result)
+  if strategy == M.debounce_strategy.CALL_LAST_ONLY then
+    -- We are done with this debounce
+    tracked_functions[id] = nil
+  else
+    -- Now schedule the next earliest execution.
+    -- If there are no calls to run the same function between now
+    -- and when this deferred executes, nothing will happen.
+    -- If there are several calls, only the last one in will run.
+    strategy = M.debounce_strategy.CALL_LAST_ONLY
+    defer_function()
   end
 end