333 lines
7.6 KiB
Lua
333 lines
7.6 KiB
Lua
local Job = require('plenary.job')
|
|
|
|
local make_entry = require('telescope.make_entry')
|
|
local log = require('telescope.log')
|
|
|
|
local finders = {}
|
|
|
|
local _callable_obj = function()
|
|
local obj = {}
|
|
|
|
obj.__index = obj
|
|
obj.__call = function(t, ...) return t:_find(...) end
|
|
|
|
return obj
|
|
end
|
|
|
|
|
|
--[[ =============================================================
|
|
|
|
JobFinder
|
|
|
|
Uses an external Job to get results. Processes results as they arrive.
|
|
|
|
For more information about how Jobs are implemented, checkout 'plenary.job'
|
|
|
|
-- ============================================================= ]]
|
|
local JobFinder = _callable_obj()
|
|
|
|
--- Create a new finder command
|
|
---
|
|
---@param opts table Keys:
|
|
-- fn_command function The function to call
|
|
function JobFinder:new(opts)
|
|
opts = opts or {}
|
|
|
|
> 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({
|
|
entry_maker = opts.entry_maker or make_entry.from_string,
|
|
fn_command = opts.fn_command,
|
|
cwd = opts.cwd,
|
|
writer = opts.writer,
|
|
|
|
-- Maximum number of results to process.
|
|
-- Particularly useful for live updating large queries.
|
|
maximum_results = opts.maximum_results,
|
|
}, self)
|
|
|
|
return obj
|
|
end
|
|
|
|
function JobFinder:_find(prompt, process_result, process_complete)
|
|
log.trace("Finding...")
|
|
|
|
if self.job and not self.job.is_shutdown then
|
|
log.debug("Shutting down old job")
|
|
self.job:shutdown()
|
|
end
|
|
|
|
local on_output = function(_, line, _)
|
|
if not line or line == "" then
|
|
return
|
|
end
|
|
|
|
if self.entry_maker then
|
|
line = self.entry_maker(line)
|
|
end
|
|
|
|
process_result(line)
|
|
end
|
|
|
|
local opts = self:fn_command(prompt)
|
|
if not opts then return end
|
|
|
|
local writer = nil
|
|
if opts.writer and Job.is_job(opts.writer) then
|
|
writer = opts.writer
|
|
elseif opts.writer then
|
|
writer = Job:new(opts.writer)
|
|
end
|
|
|
|
self.job = Job:new {
|
|
command = opts.command,
|
|
args = opts.args,
|
|
cwd = opts.cwd or self.cwd,
|
|
|
|
maximum_results = self.maximum_results,
|
|
|
|
writer = writer,
|
|
|
|
enable_recording = false,
|
|
|
|
on_stdout = on_output,
|
|
on_stderr = on_output,
|
|
|
|
on_exit = function()
|
|
process_complete()
|
|
end,
|
|
}
|
|
|
|
self.job:start()
|
|
end
|
|
|
|
local OneshotJobFinder = _callable_obj()
|
|
|
|
function OneshotJobFinder:new(opts)
|
|
opts = opts or {}
|
|
|
|
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({
|
|
fn_command = opts.fn_command,
|
|
entry_maker = opts.entry_maker or make_entry.from_string,
|
|
|
|
cwd = opts.cwd,
|
|
writer = opts.writer,
|
|
|
|
maximum_results = opts.maximum_results,
|
|
|
|
_started = false,
|
|
}, self)
|
|
|
|
obj._find = coroutine.wrap(function(finder, _, process_result, process_complete)
|
|
local num_execution = 1
|
|
local num_results = 0
|
|
|
|
local results = setmetatable({}, {
|
|
__newindex = function(t, k, v)
|
|
rawset(t, k, v)
|
|
process_result(v)
|
|
end
|
|
})
|
|
|
|
local job_opts = finder:fn_command(prompt)
|
|
if not job_opts then
|
|
error(debug.trackeback("expected `job_opts` from fn_command"))
|
|
end
|
|
|
|
local writer = nil
|
|
if job_opts.writer and Job.is_job(job_opts.writer) then
|
|
writer = job_opts.writer
|
|
elseif job_opts.writer then
|
|
writer = Job:new(job_opts.writer)
|
|
end
|
|
|
|
local on_output = function(_, line)
|
|
-- This will call the metamethod, process_result
|
|
num_results = num_results + 1
|
|
results[num_results] = finder.entry_maker(line)
|
|
end
|
|
|
|
local completed = false
|
|
local job = Job:new {
|
|
command = job_opts.command,
|
|
args = job_opts.args,
|
|
cwd = job_opts.cwd or finder.cwd,
|
|
|
|
maximum_results = finder.maximum_results,
|
|
|
|
writer = writer,
|
|
|
|
enable_recording = false,
|
|
|
|
on_stdout = on_output,
|
|
on_stderr = on_output,
|
|
|
|
on_exit = function()
|
|
process_complete()
|
|
completed = true
|
|
end,
|
|
}
|
|
|
|
job:start()
|
|
|
|
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
|
|
end
|
|
end)
|
|
|
|
return obj
|
|
end
|
|
|
|
function OneshotJobFinder:old_find(_, process_result, process_complete)
|
|
local first_run = false
|
|
|
|
if not self._started then
|
|
first_run = true
|
|
|
|
self._started = true
|
|
|
|
end
|
|
|
|
-- First time we get called, start on up that job.
|
|
-- Every time after that, just use the results LUL
|
|
if not first_run then
|
|
return
|
|
end
|
|
end
|
|
|
|
|
|
|
|
--[[ =============================================================
|
|
Static Finders
|
|
|
|
A static finder has results that never change.
|
|
They are passed in directly as a result.
|
|
-- ============================================================= ]]
|
|
local StaticFinder = _callable_obj()
|
|
|
|
function StaticFinder:new(opts)
|
|
assert(opts, "Options are required. See documentation for usage")
|
|
|
|
local input_results
|
|
if vim.tbl_islist(opts) then
|
|
input_results = opts
|
|
else
|
|
input_results = opts.results
|
|
end
|
|
|
|
local entry_maker = opts.entry_maker or make_entry.gen_from_string()
|
|
|
|
assert(input_results)
|
|
assert(input_results, "Results are required for static finder")
|
|
assert(type(input_results) == 'table', "self.results must be a table")
|
|
|
|
local results = {}
|
|
for k, v in ipairs(input_results) do
|
|
local entry = entry_maker(v)
|
|
entry.index = k
|
|
|
|
table.insert(results, entry)
|
|
end
|
|
|
|
return setmetatable({ results = results }, self)
|
|
end
|
|
|
|
function StaticFinder:_find(_, process_result, process_complete)
|
|
for _, v in ipairs(self.results) do
|
|
process_result(v)
|
|
end
|
|
|
|
process_complete()
|
|
end
|
|
|
|
|
|
-- local
|
|
|
|
|
|
--- Return a new Finder
|
|
--
|
|
-- Use at your own risk.
|
|
-- This opts dictionary is likely to change, but you are welcome to use it right now.
|
|
-- I will try not to change it needlessly, but I will change it sometimes and I won't feel bad.
|
|
finders._new = function(opts)
|
|
if opts.results then
|
|
print("finder.new is deprecated with `results`. You should use `finder.new_table`")
|
|
return StaticFinder:new(opts)
|
|
end
|
|
|
|
return JobFinder:new(opts)
|
|
end
|
|
|
|
finders.new_job = function(command_generator, entry_maker, maximum_results)
|
|
return JobFinder:new {
|
|
fn_command = function(_, prompt)
|
|
local command_list = command_generator(prompt)
|
|
if command_list == nil then
|
|
return nil
|
|
end
|
|
|
|
local command = table.remove(command_list, 1)
|
|
|
|
return {
|
|
command = command,
|
|
args = command_list,
|
|
}
|
|
end,
|
|
|
|
entry_maker = entry_maker,
|
|
maximum_results = maximum_results,
|
|
}
|
|
end
|
|
|
|
---@param command_list string[] Command list to execute.
|
|
---@param opts table
|
|
--- @key entry_maker function Optional: function(line: string) => table
|
|
--- @key cwd string
|
|
finders.new_oneshot_job = function(command_list, opts)
|
|
opts = opts or {}
|
|
|
|
command_list = vim.deepcopy(command_list)
|
|
|
|
local command = table.remove(command_list, 1)
|
|
|
|
return OneshotJobFinder:new {
|
|
entry_maker = opts.entry_maker or make_entry.gen_from_string(),
|
|
|
|
cwd = opts.cwd,
|
|
maximum_results = opts.maximum_results,
|
|
|
|
fn_command = function()
|
|
return {
|
|
command = command,
|
|
args = command_list,
|
|
}
|
|
end,
|
|
}
|
|
end
|
|
|
|
--- Used to create a finder for a Lua table.
|
|
-- If you only pass a table of results, then it will use that as the entries.
|
|
--
|
|
-- If you pass a table, and then a function, it's used as:
|
|
-- results table, the results to run on
|
|
-- entry_maker function, the function to convert results to entries.
|
|
finders.new_table = function(t)
|
|
return StaticFinder:new(t)
|
|
end
|
|
|
|
return finders
|