fe4c1d0e31
* refactor(types): extract inline anonymous types into named classes
Problem: several functions used inline `{...}` table types in their
`@param` and `@return` annotations, making them hard to read and
impossible to reference from other modules.
Solution: extract each into a named `---@class`: `pending.Metadata`,
`pending.TaskFields`, `pending.CompletionItem`, `pending.SystemResult`,
and `pending.OAuthClientOpts`.
* refactor(sync): extract shared utilities into `sync/util.lua`
Problem: sync epilogue code (`s:save()`, `_recompute_counts()`,
`buffer.render()`) and `fmt_counts` were duplicated across `gcal.lua`
and `gtasks.lua`. The concurrency guard lived in `oauth.lua`, coupling
non-OAuth backends to the OAuth module.
Solution: create `sync/util.lua` with `async`, `system`, `with_guard`,
`finish`, and `fmt_counts`. Delegate from `oauth.lua` and replace
duplicated code in both backends. Add per-backend `auth()` and
`auth_complete()` methods to `gcal.lua` and `gtasks.lua`.
* feat(sync): auto-discover backends, per-backend auth, S3 backend
Problem: sync backends were hardcoded in `SYNC_BACKENDS` list in
`init.lua`, auth routed directly through `oauth.google_client`, and
adding a non-OAuth backend required editing multiple files.
Solution: replace hardcoded list with `discover_backends()` that globs
`lua/pending/sync/*.lua` at runtime. Rewrite `M.auth()` to dispatch
to per-backend `auth()` methods with `vim.ui.select` fallback. Add
`lua/pending/sync/s3.lua` with push/pull/sync via AWS CLI, per-task
merge by `_s3_sync_id` (UUID), and `pending.S3Config` type.
83 lines
1.8 KiB
Lua
83 lines
1.8 KiB
Lua
local log = require('pending.log')
|
|
|
|
---@class pending.SystemResult
|
|
---@field code integer
|
|
---@field stdout string
|
|
---@field stderr string
|
|
|
|
---@class pending.CountPart
|
|
---@field [1] integer
|
|
---@field [2] string
|
|
|
|
---@class pending.sync.util
|
|
local M = {}
|
|
|
|
local _sync_in_flight = false
|
|
|
|
---@param fn fun(): nil
|
|
function M.async(fn)
|
|
coroutine.resume(coroutine.create(fn))
|
|
end
|
|
|
|
---@param args string[]
|
|
---@param opts? table
|
|
---@return pending.SystemResult
|
|
function M.system(args, opts)
|
|
local co = coroutine.running()
|
|
if not co then
|
|
return vim.system(args, opts or {}):wait() --[[@as pending.SystemResult]]
|
|
end
|
|
vim.system(args, opts or {}, function(result)
|
|
vim.schedule(function()
|
|
coroutine.resume(co, result)
|
|
end)
|
|
end)
|
|
return coroutine.yield() --[[@as { code: integer, stdout: string, stderr: string }]]
|
|
end
|
|
|
|
---@param name string
|
|
---@param fn fun(): nil
|
|
function M.with_guard(name, fn)
|
|
if _sync_in_flight then
|
|
log.warn(name .. ': Sync already in progress — please wait.')
|
|
return
|
|
end
|
|
_sync_in_flight = true
|
|
local ok, err = pcall(fn)
|
|
_sync_in_flight = false
|
|
if not ok then
|
|
log.error(name .. ': ' .. tostring(err))
|
|
end
|
|
end
|
|
|
|
---@return boolean
|
|
function M.sync_in_flight()
|
|
return _sync_in_flight
|
|
end
|
|
|
|
---@param s pending.Store
|
|
function M.finish(s)
|
|
s:save()
|
|
require('pending')._recompute_counts()
|
|
local buffer = require('pending.buffer')
|
|
if buffer.bufnr() and vim.api.nvim_buf_is_valid(buffer.bufnr()) then
|
|
buffer.render(buffer.bufnr())
|
|
end
|
|
end
|
|
|
|
---@param parts pending.CountPart[]
|
|
---@return string
|
|
function M.fmt_counts(parts)
|
|
local items = {}
|
|
for _, p in ipairs(parts) do
|
|
if p[1] > 0 then
|
|
table.insert(items, p[1] .. ' ' .. p[2])
|
|
end
|
|
end
|
|
if #items == 0 then
|
|
return 'nothing to do'
|
|
end
|
|
return table.concat(items, ' | ')
|
|
end
|
|
|
|
return M
|