parent 9a97982

author Brian Shu <[email protected]> 1611447930 -0500
committer Brian Shu <[email protected]> 1611453550 -0500

started coroutine async pickers

more stuff

removed accidental menu stuff

added wip cancel

stray character

Author: oberblastmeister

lua/telescope/finders.lua

@@ -1,6 +1,8 @@
 local Job = require('plenary.job')
 
+local co = coroutine
 local make_entry = require('telescope.make_entry')
+local Executor = require('telescope.utils').Executor
 local log = require('telescope.log')
 
 local finders = {}
@@ -33,7 +35,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({
@@ -179,13 +181,26 @@ function OneshotJobFinder:new(opts)
       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
+      local exe = Executor.new {}
+      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()
+
+      -- for index = 1, current_count do
+      --   process_result(results[index])
+      -- end
+
+      -- if completed then
+      --   process_complete()
+      -- end
     end
   end)
 
@@ -248,12 +263,43 @@ function StaticFinder:new(opts)
   return setmetatable({ results = results }, self)
 end
 
-function StaticFinder:_find(_, process_result, process_complete)
-  for _, v in ipairs(self.results) do
-    process_result(v)
+local static_find = successive_async(function(results, process_result, process_complete)
+  local exe = Executor.new {}
+  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)
+
+local function exe_cancel_wrap(fn)
+  local exe = Executor.new {}
+
+  local function wrapped(...)
+    exe:close()
+    exe:add(fn, ...)
+    exe:run()
   end
 
+  return wrapped
+end
+
+-- WIP, cancel previous task when we start a new one
+local static_find_cancel = exe_cancel_wrap(co.create(function(results, process_result, process_complete)
+  for _, v in ipairs(results) do
+    process_result(v)
+    co.yield()
+  end
   process_complete()
+end))
+
+function StaticFinder:_find(_, process_result, process_complete)
+  static_find(self.results, process_result, process_complete)
+  -- static_find_cancel(self.results, process_result, process_complete)
 end
 
 

lua/telescope/utils.lua

@@ -202,4 +202,154 @@ 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.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
+
+    if self.mode == "finish" then
+      self:step_finish()
+    else
+      self:step()
+    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
+
+List = {}
+
+function List.new()
+  return {first = 0, last = -1}
+end
+
+function List.pushleft(list, value)
+  local first = list.first - 1
+  list.first = first
+  list[first] = value
+end
+
+function List.pushright (list, value)
+  local last = list.last + 1
+  list.last = last
+  list[last] = value
+end
+
+function List.popleft (list)
+  local first = list.first
+  if first > list.last then return nil end
+  local value = list[first]
+  list[first] = nil        -- to allow garbage collection
+  list.first = first + 1
+  return value
+end
+
+function List.is_empty(list)
+  return list.first > list.last
+end
+
+function List.popright (list)
+  local last = list.last
+  if list.first > last then return nil end
+  local value = list[last]
+  list[last] = nil         -- to allow garbage collection
+  list.last = last - 1
+  return value
+end
+
+function List.len(list)
+  return list.last - list.first
+end
+
+utils.List = List
+
+function successive_async(f)
+  local list = List.new()
+
+  local function wrapped(...)
+    if list == nil then return end
+    -- if List.is_empty(list) or list == nil then return end
+
+    List.pushleft(list, {...})
+    local curr = List.popright(list)
+    f(unpack(curr))
+  end
+
+  local function finish()
+    list = nil 
+  end
+
+  return wrapped
+end
+
 return utils