0e0568769d
* refactor(store): convert singleton to Store.new() factory
Problem: store.lua used module-level _data singleton, making
project-local stores impossible and creating hidden global state.
Solution: introduce Store metatable with all operations as instance
methods. M.new(path) constructs an instance; M.resolve_path()
searches upward for .pending.json and falls back to
config.get().data_path. Singleton module API is removed.
* refactor(diff): accept store instance as parameter
Problem: diff.apply called store singleton methods directly, coupling
it to global state and preventing use with project-local stores.
Solution: change signature to apply(lines, s, hidden_ids?) where s is
a pending.Store instance. All store operations now go through s.
* refactor(buffer): add set_store/store accessors, drop singleton dep
Problem: buffer.lua imported store directly and called singleton
methods, preventing it from working with per-project store instances.
Solution: add module-level _store, M.set_store(s), and M.store()
accessors. open() and render() use _store instead of the singleton.
init.lua will call buffer.set_store(s) before buffer.open().
* refactor(complete,health,sync,plugin): update callers to store instance API
Problem: complete.lua, health.lua, sync/gcal.lua, and plugin/pending.lua
all called singleton store methods directly.
Solution: complete.lua uses buffer.store() for category lookups;
health.lua uses store.new(store.resolve_path()) and reports the
resolved path; gcal.lua calls require('pending').store() for task
access; plugin tab-completion creates ephemeral store instances via
store.new(store.resolve_path()). Add 'init' to the subcommands list.
* feat(init): thread Store instance through init, add :Pending init
Problem: init.lua called singleton store methods throughout, and there
was no way to create a project-local .pending.json file.
Solution: add module-level _store and private get_store() that
lazy-constructs via store.new(store.resolve_path()). Add public
M.store() accessor used by specs and sync backends. M.open() calls
buffer.set_store(get_store()) before buffer.open(). All store
callsites converted to get_store():method(). goto_file() and
add_here() derive the data directory from get_store().path.
Add M.init() which creates .pending.json in cwd and dispatches from
M.command() as ':Pending init'.
* test: update all specs for Store instance API
Problem: every spec used the old singleton API (store.unload(),
store.load(), store.add(), etc.) and diff.apply(lines, hidden).
Solution: lower-level specs (store, diff, views, complete, file) use
s = store.new(path); s:load() directly. Higher-level specs (archive,
edit, filter, status, sync) reset package.loaded['pending'] in
before_each and use pending.store() to access the live instance.
diff.apply calls updated to diff.apply(lines, s, hidden_ids).
* docs(pending): document :Pending init and store resolution
Add *pending-store-resolution* section explaining upward .pending.json
discovery and fallback to the global data_path. Document :Pending init
under COMMANDS. Add a cross-reference from the data_path config field.
* ci: format
* ci: remove unused variable
76 lines
2.2 KiB
Lua
76 lines
2.2 KiB
Lua
local M = {}
|
|
|
|
---@return nil
|
|
function M.check()
|
|
vim.health.start('pending.nvim')
|
|
|
|
local ok, config = pcall(require, 'pending.config')
|
|
if not ok then
|
|
vim.health.error('Failed to load pending.config')
|
|
return
|
|
end
|
|
|
|
local cfg = config.get()
|
|
vim.health.ok('Config loaded')
|
|
|
|
local store_ok, store = pcall(require, 'pending.store')
|
|
if not store_ok then
|
|
vim.health.error('Failed to load pending.store')
|
|
return
|
|
end
|
|
|
|
local resolved_path = store.resolve_path()
|
|
vim.health.info('Store path: ' .. resolved_path)
|
|
if resolved_path ~= cfg.data_path then
|
|
vim.health.info('(project-local store; global path: ' .. cfg.data_path .. ')')
|
|
end
|
|
|
|
local data_dir = vim.fn.fnamemodify(resolved_path, ':h')
|
|
if vim.fn.isdirectory(data_dir) == 1 then
|
|
vim.health.ok('Data directory exists: ' .. data_dir)
|
|
else
|
|
vim.health.warn('Data directory does not exist yet: ' .. data_dir)
|
|
end
|
|
|
|
if vim.fn.filereadable(resolved_path) == 1 then
|
|
local s = store.new(resolved_path)
|
|
local load_ok, err = pcall(function()
|
|
s:load()
|
|
end)
|
|
if load_ok then
|
|
local tasks = s:tasks()
|
|
vim.health.ok('Data file loaded: ' .. #tasks .. ' tasks')
|
|
local recur = require('pending.recur')
|
|
local invalid_count = 0
|
|
for _, task in ipairs(tasks) do
|
|
if task.recur and not recur.validate(task.recur) then
|
|
invalid_count = invalid_count + 1
|
|
vim.health.warn('Task ' .. task.id .. ' has invalid recurrence spec: ' .. task.recur)
|
|
end
|
|
end
|
|
if invalid_count == 0 then
|
|
vim.health.ok('All recurrence specs are valid')
|
|
end
|
|
else
|
|
vim.health.error('Failed to load data file: ' .. tostring(err))
|
|
end
|
|
else
|
|
vim.health.info('No data file yet (will be created on first save)')
|
|
end
|
|
|
|
local sync_paths = vim.fn.globpath(vim.o.runtimepath, 'lua/pending/sync/*.lua', false, true)
|
|
if #sync_paths == 0 then
|
|
vim.health.info('No sync backends found')
|
|
else
|
|
for _, path in ipairs(sync_paths) do
|
|
local name = vim.fn.fnamemodify(path, ':t:r')
|
|
local bok, backend = pcall(require, 'pending.sync.' .. name)
|
|
if bok and type(backend.health) == 'function' then
|
|
vim.health.start('pending.nvim: sync/' .. name)
|
|
backend.health()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return M
|