[WIP] async pickers take 2 using libuv uv_idle_t

lua/telescope/builtin/files.lua

@@ -185,6 +185,23 @@ local function prepare_match(entry, kind)
   return entries
 end
 
+files.scan_dir = function(opts)
+
+  local scan = require'plenary.scandir'
+
+  local results = scan.scan_dir('/home/brian', { hidden = true })
+
+  pickers.new(opts, {
+    prompt_title = 'Files',
+    finder = finders.new_table {
+      results = results,
+      entry_maker = make_entry.gen_from_file(opts),
+    },
+    sorter = conf.generic_sorter(opts),
+    previewer = conf.file_previewer(opts),
+  }):find()
+end
+
 files.treesitter = function(opts)
   opts.show_line = utils.get_default(opts.show_line, true)
 

lua/telescope/finders.lua

@@ -1,6 +1,9 @@
 local Job = require('plenary.job')
 
+local co = coroutine
+local utils = require('telescope.utils')
 local make_entry = require('telescope.make_entry')
+local Executor = require('telescope.utils').Executor
 local log = require('telescope.log')
 
 local finders = {}
@@ -14,6 +17,66 @@ local _callable_obj = function()
   return obj
 end
 
+local static_find
+do
+  local exe = Executor.new {
+    -- run_task_amount = 2000,
+  }
+  static_find = function(results, process_result, process_complete)
+    if #exe.tasks ~= 0 then
+      exe:close()
+    end
+    exe:add(co.create(function(results)
+      for _, v in ipairs(results) do
+        process_result(v)
+        co.yield()
+      end
+      process_complete()
+    end), results)
+
+    exe:run()
+  end
+end
+
+local static_find_no_cancel = function(results, process_result, process_complete)
+  local exe = Executor.new {}
+  exe:add(co.create(function()
+    for _, v in ipairs(results) do
+      process_result(v)
+      co.yield()
+    end
+    process_complete()
+  end))
+end
+
+local job_find
+do
+  local exe = Executor.new {
+    -- kind of like fps
+
+    -- run_task_amount = 1000,
+    -- run_task_amount = 3000,
+    -- run_task_amount = 1,
+  }
+  job_find = function(results, process_result, process_complete, current_count, completed)
+    if #exe.tasks ~= 0 then
+      exe:close()
+    end
+
+    exe:add(co.create(function(results)
+      for index = 1, current_count do
+        process_result(results[index])
+        co.yield()
+      end
+
+      if completed then
+        process_complete()
+      end
+    end), results)
+
+    exe:run()
+  end
+end
 
 --[[ =============================================================
 
@@ -33,7 +96,7 @@ local JobFinder = _callable_obj()
 function JobFinder:new(opts)
   opts = opts or {}
 
-> assert(not opts.results, "`results` should be used with finder.new_table")
+  assert(not opts.results, "`results` should be used with finder.new_table")
   assert(not opts.static, "`static` should be used with finder.new_oneshot_job")
 
   local obj = setmetatable({
@@ -177,15 +240,11 @@ function OneshotJobFinder:new(opts)
     while true do
       finder, _, process_result, process_complete = coroutine.yield()
       num_execution = num_execution + 1
-
       local current_count = num_results
-      for index = 1, current_count do
-        process_result(results[index])
-      end
 
-      if completed then
-        process_complete()
-      end
+      -- static_find(results, process_result, process_complete)
+      -- static_find_no_cancel(results, process_result, process_complete)
+      job_find(results, process_result, process_complete, current_count, completed)
     end
   end)
 
@@ -249,11 +308,7 @@ function StaticFinder:new(opts)
 end
 
 function StaticFinder:_find(_, process_result, process_complete)
-  for _, v in ipairs(self.results) do
-    process_result(v)
-  end
-
-  process_complete()
+  static_find(self.results, process_result, process_complete)
 end
 
 

lua/telescope/pickers.lua

@@ -1,4 +1,5 @@
 local a = vim.api
+local co = coroutine
 local popup = require('popup')
 
 require('telescope')

lua/telescope/utils.lua

@@ -202,4 +202,172 @@ function utils.get_os_command_output(cmd)
   return Job:new({ command = command, args = cmd }):sync()
 end
 
+local uv = vim.loop
+local co = coroutine
+
+local Executor = {}
+Executor.__index = Executor
+
+function Executor.new(opts)
+  opts = opts or {}
+
+  local self = setmetatable({}, Executor)
+
+  self.tasks = opts.tasks or {}
+  self.mode = opts.mode or "next"
+  self.index = opts.start_idx or 1
+  self.run_task_amount = opts.run_task_amount or 1
+  self.idle = uv.new_idle()
+
+  return self
+end
+
+function Executor:run()
+  self.idle:start(vim.schedule_wrap(function()
+    if #self.tasks == 0 then
+      self.idle:stop()
+      return
+    end
+
+    for _ = 1, self.run_task_amount do
+      if self.mode == "finish" then
+        self:step_finish()
+      else
+        self:step()
+      end
+    end
+  end))
+end
+
+function Executor:close()
+  self.idle:stop()
+  self.tasks = {}
+end
+
+function Executor:step_finish()
+  if #self.tasks == 0 then return end
+  local curr_task = self.tasks[self.index]
+  if curr_task == nil then
+    self.index = 1
+    curr_task = self.tasks[self.index]
+  end
+
+  local _, _ = co.resume(curr_task)
+  if co.status(curr_task) == "dead" then
+    table.remove(self.tasks, self.index)
+
+    self.index = self.index + 1
+  end
+end
+
+function Executor:step()
+  if #self.tasks == 0 then return end
+  local curr_task = self.tasks[self.index]
+  if curr_task == nil then
+    self.index = 1
+    curr_task = self.tasks[self.index]
+  end
+
+  local _, _ = co.resume(curr_task[1], unpack(curr_task[2]))
+  if co.status(curr_task[1]) == "dead" then
+    table.remove(self.tasks, self.index)
+  end
+
+  self.index = self.index + 1
+end
+
+function Executor:get_current_task()
+  return self.tasks[self.index]
+end
+
+function Executor:remove_task(idx)
+  table.remove(self.tasks, idx)
+end
+
+function Executor:add(task, ...)
+  table.insert(self.tasks, {task, {...}})
+end
+
+utils.Executor = Executor
+
+VecDeque = {}
+VecDeque.__index = VecDeque
+
+function VecDeque.new()
+  return setmetatable({first = 0, last = -1}, VecDeque)
+end
+
+function VecDeque:pushleft(value)
+  local first = self.first - 1
+  self.first = first
+  self[first] = value
+end
+
+function VecDeque:pushright(value)
+  local last = self.last + 1
+  self.last = last
+  self[last] = value
+end
+
+function VecDeque:popleft()
+  local first = self.first
+  if first > self.last then return nil end
+  local value = self[first]
+  self[first] = nil        -- to allow garbage collection
+  self.first = first + 1
+  return value
+end
+
+function VecDeque:is_empty()
+  return self.first > self.last
+end
+
+function VecDeque:popright()
+  local last = self.last
+  if self.first > last then return nil end
+  local value = self[last]
+  self[last] = nil         -- to allow garbage collection
+  self.last = last - 1
+  return value
+end
+
+function VecDeque:len()
+  return self.last - self.first
+end
+
+utils.VecDeque = VecDeque
+
+function utils.successive_async(f)
+  local vecdeque = VecDeque.new()
+
+  local function wrapped(...)
+    if vecdeque == nil then return end
+
+    vecdeque:pushleft({...})
+    local curr = vecdeque:popright()
+    f(unpack(curr))
+  end
+
+  local function finish()
+    vecdeque = nil 
+  end
+
+  return wrapped
+end
+
+function utils.exe_cancel_wrap(fn)
+  local exe = Executor.new {}
+  exe:add(fn)
+
+  local function wrapped(...)
+    print(#{...})
+    exe.idle:stop()
+    exe.tasks[1][1] = fn
+    exe.tasks[1][2] = {...}
+    exe:run()
+  end
+
+  return wrapped
+end
+
 return utils