Initial commit
This commit is contained in:
718
nvim/lua/darcula/haven/init.lua
Normal file
718
nvim/lua/darcula/haven/init.lua
Normal file
@@ -0,0 +1,718 @@
|
||||
-- The MIT License (MIT)
|
||||
--
|
||||
-- Copyright © 2026 Scott E. Graves <scott.e.graves@protonmail.com>
|
||||
--
|
||||
-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software
|
||||
-- and associated documentation files (the “Software”), to deal in the Software without restriction,
|
||||
-- including without limitation the rights to use, copy, modify, merge, publish, distribute,
|
||||
-- sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
|
||||
-- furnished to do so, subject to the following conditions:
|
||||
--
|
||||
-- The above copyright notice and this permission notice shall be included in all copies or
|
||||
-- substantial portions of the Software.
|
||||
--
|
||||
-- THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
|
||||
-- BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
-- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
-- DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
--
|
||||
require("darcula.utils.string")
|
||||
require("darcula.utils.table")
|
||||
|
||||
local Path = require("plenary.path")
|
||||
local action_state = require("telescope.actions.state")
|
||||
local actions = require("telescope.actions")
|
||||
local conf = require("telescope.config").values
|
||||
local finders = require("telescope.finders")
|
||||
local utils = require("darcula.utils")
|
||||
local global_state = require("telescope.state")
|
||||
local utils_os = require("darcula.utils.os")
|
||||
local utils_path = require("darcula.utils.path")
|
||||
local pickers = require("telescope.pickers")
|
||||
local plenary_filetype = require("plenary.filetype")
|
||||
local previewer_utils = require("telescope.previewers.utils")
|
||||
local previewers = require("telescope.previewers")
|
||||
local scan = require("plenary.scandir")
|
||||
|
||||
local M = {}
|
||||
|
||||
local active_saves = {}
|
||||
local changed_lookup = {}
|
||||
local haven_config = {
|
||||
enabled = true,
|
||||
exclusions = {
|
||||
function(path, _)
|
||||
if utils_os.is_windows then
|
||||
return path:lower():starts_with(
|
||||
(vim.fn.eval("$VIMRUNTIME") .. utils_path.directory_sep):lower()
|
||||
)
|
||||
end
|
||||
return path:starts_with(
|
||||
vim.fn.eval("$VIMRUNTIME") .. utils_path.directory_sep
|
||||
)
|
||||
end,
|
||||
function(path, _)
|
||||
if utils_os.is_windows then
|
||||
return path:lower():starts_with(
|
||||
(vim.fn.stdpath("data") .. utils_path.directory_sep):lower()
|
||||
)
|
||||
end
|
||||
return path:starts_with(
|
||||
vim.fn.stdpath("data") .. utils_path.directory_sep
|
||||
)
|
||||
end,
|
||||
function(path, _)
|
||||
if utils_os.is_windows then
|
||||
return path:lower():starts_with(
|
||||
(vim.fs.joinpath(vim.fn.eval("$XDG_CONFIG_HOME"), "coc") ..
|
||||
utils_path.directory_sep):lower()
|
||||
)
|
||||
end
|
||||
return path:starts_with(
|
||||
vim.fs.joinpath(vim.fn.eval("$XDG_CONFIG_HOME"), "coc") ..
|
||||
utils_path.directory_sep
|
||||
)
|
||||
end,
|
||||
function(path, _)
|
||||
if utils_os.is_windows then
|
||||
return path:lower():ends_with(
|
||||
(utils_path.directory_sep ..
|
||||
".git" .. utils_path.directory_sep .. "COMMIT_EDITMSG"):lower()
|
||||
)
|
||||
end
|
||||
return path:ends_with(
|
||||
utils_path.directory_sep ..
|
||||
".git" .. utils_path.directory_sep .. "COMMIT_EDITMSG"
|
||||
)
|
||||
end,
|
||||
function(path, config)
|
||||
if utils_os.is_windows then
|
||||
return path:lower():starts_with(
|
||||
(config.haven_path .. utils_path.directory_sep):lower()
|
||||
)
|
||||
end
|
||||
return path:starts_with(config.haven_path .. utils_path.directory_sep)
|
||||
end
|
||||
},
|
||||
haven_path = vim.fs.joinpath(vim.fn.stdpath("data"), "nvim-haven"),
|
||||
inclusions = {},
|
||||
max_history_count = 200,
|
||||
save_timeout = 10000
|
||||
}
|
||||
local line_ending = utils.iff(utils_os.is_windows, "\r\n", "\n")
|
||||
local ns_previewer = vim.api.nvim_create_namespace("telescope.previewers")
|
||||
|
||||
local print_message = function(is_error, msg)
|
||||
vim.notify(
|
||||
msg,
|
||||
utils.iff(is_error, "error", "info"),
|
||||
{
|
||||
title = "nvim-haven"
|
||||
}
|
||||
)
|
||||
end
|
||||
|
||||
local diff_strings = function(a, b)
|
||||
return vim.text.diff(a, b, {algorithm = "minimal"})
|
||||
end
|
||||
|
||||
local create_save_file_path = function(buf_info)
|
||||
local encode = function(str)
|
||||
return str:gsub("\r?\n", "\r\n"):gsub(
|
||||
"([^%w%-%.%_%~ ])",
|
||||
function(c)
|
||||
return string.format("%%%02X", string.byte(c))
|
||||
end
|
||||
):gsub(" ", "+")
|
||||
end
|
||||
|
||||
return vim.fs.joinpath(
|
||||
haven_config.haven_path,
|
||||
encode(buf_info.name) .. ".save"
|
||||
)
|
||||
end
|
||||
|
||||
local save_change_file = function(buf_info, lines, save_file)
|
||||
active_saves[save_file] = nil
|
||||
|
||||
local file, err = io.open(save_file, "a")
|
||||
if file == nil then
|
||||
print_message(true, err)
|
||||
return
|
||||
end
|
||||
|
||||
local file_entry =
|
||||
vim.json.encode(
|
||||
{
|
||||
date = os.time(),
|
||||
ft = plenary_filetype.detect(buf_info.name, {}),
|
||||
lines = lines
|
||||
}
|
||||
)
|
||||
_, err = file:write(file_entry .. line_ending)
|
||||
if err ~= nil then
|
||||
print_message(true, err)
|
||||
end
|
||||
file:close()
|
||||
end
|
||||
|
||||
local save_change_file_entries = function(entries, save_file)
|
||||
active_saves[save_file] = nil
|
||||
|
||||
local file, err = io.open(save_file, "w+")
|
||||
if file == nil then
|
||||
print_message(true, err)
|
||||
return
|
||||
end
|
||||
|
||||
for _, entry in pairs(entries) do
|
||||
_, err = file:write(vim.json.encode(entry) .. line_ending)
|
||||
if err ~= nil then
|
||||
print_message(true, err)
|
||||
end
|
||||
end
|
||||
file:close()
|
||||
end
|
||||
|
||||
local read_change_file = function(save_file)
|
||||
local file, err = io.open(save_file, "r")
|
||||
if file == nil then
|
||||
return nil, err
|
||||
end
|
||||
|
||||
local save_data
|
||||
save_data, err = file:read("a")
|
||||
if err ~= nil then
|
||||
return nil, err
|
||||
end
|
||||
file:close()
|
||||
|
||||
local entries =
|
||||
vim.json.decode(
|
||||
"[" .. table.concat(save_data:split(line_ending), ",") .. "]"
|
||||
)
|
||||
if #entries > haven_config.max_history_count then
|
||||
while #entries > haven_config.max_history_count do
|
||||
table.remove(entries, 1)
|
||||
end
|
||||
save_change_file_entries(entries, save_file)
|
||||
end
|
||||
|
||||
return entries
|
||||
end
|
||||
|
||||
local process_file_changed = function(buf_info)
|
||||
local save_file = create_save_file_path(buf_info)
|
||||
local changed_data = changed_lookup[save_file]
|
||||
local immediate = vim.fn.filereadable(save_file) == 0
|
||||
|
||||
local update_changed_lookup = function()
|
||||
changed_lookup[save_file] = {
|
||||
changed = buf_info.changed,
|
||||
changedtick = buf_info.changedtick
|
||||
}
|
||||
end
|
||||
|
||||
if
|
||||
not immediate and
|
||||
(changed_data == nil or
|
||||
(buf_info.changed == 0 and changed_data.changed == 0) or
|
||||
buf_info.changedtick == changed_data.changedtick)
|
||||
then
|
||||
update_changed_lookup()
|
||||
return
|
||||
end
|
||||
|
||||
if active_saves[save_file] ~= nil then
|
||||
active_saves[save_file].timer:stop()
|
||||
active_saves[save_file] = nil
|
||||
end
|
||||
|
||||
update_changed_lookup()
|
||||
|
||||
local lines = vim.api.nvim_buf_get_lines(buf_info.bufnr, 0, -1, true)
|
||||
|
||||
local entries, _ = read_change_file(save_file)
|
||||
if entries ~= nil then
|
||||
if
|
||||
diff_strings(
|
||||
table.concat(entries[#entries].lines, line_ending),
|
||||
table.concat(lines, line_ending)
|
||||
):len() == 0
|
||||
then
|
||||
return
|
||||
end
|
||||
entries = nil
|
||||
end
|
||||
|
||||
local saved = false
|
||||
local do_save = function()
|
||||
if not saved then
|
||||
saved = true
|
||||
save_change_file(buf_info, lines, save_file)
|
||||
end
|
||||
end
|
||||
|
||||
if immediate then
|
||||
do_save()
|
||||
else
|
||||
active_saves[save_file] = {
|
||||
timer = vim.defer_fn(do_save, haven_config.save_timeout),
|
||||
do_save = do_save
|
||||
}
|
||||
end
|
||||
end
|
||||
|
||||
local check_requirements = function()
|
||||
if vim.o.modifiable ~= 0 and vim.o.buftype ~= "nofile" then
|
||||
local buf_info = vim.fn.getbufinfo(vim.fn.bufname())
|
||||
if buf_info ~= nil and #buf_info > 0 then
|
||||
buf_info = buf_info[1]
|
||||
if buf_info.name:len() ~= 0 and vim.fn.filereadable(buf_info.name) ~= 0 then
|
||||
if changed_lookup[create_save_file_path(buf_info)] == nil then
|
||||
for _, is_included in pairs(haven_config.inclusions) do
|
||||
if is_included(buf_info.name, haven_config) then
|
||||
return true, buf_info
|
||||
end
|
||||
end
|
||||
|
||||
for _, is_excluded in pairs(haven_config.exclusions) do
|
||||
if is_excluded(buf_info.name, haven_config) then
|
||||
return false
|
||||
end
|
||||
end
|
||||
end
|
||||
return true, buf_info
|
||||
end
|
||||
end
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
local handle_buffer_changed = function()
|
||||
local ok, buf_info = check_requirements()
|
||||
if ok and buf_info ~= nil then
|
||||
process_file_changed(buf_info)
|
||||
end
|
||||
end
|
||||
|
||||
local handle_vim_leave = function()
|
||||
for _, active in pairs(active_saves) do
|
||||
if active.timer ~= nil then
|
||||
active.timer:stop()
|
||||
end
|
||||
active.do_save()
|
||||
end
|
||||
active_saves = {}
|
||||
changed_lookup = {}
|
||||
end
|
||||
|
||||
local setup_autocmds = function()
|
||||
local group_id =
|
||||
vim.api.nvim_create_augroup("nvim-haven-internal", {clear = true})
|
||||
if haven_config.enabled then
|
||||
vim.api.nvim_create_autocmd(
|
||||
"BufEnter",
|
||||
{
|
||||
group = group_id,
|
||||
pattern = "*",
|
||||
callback = handle_buffer_changed
|
||||
}
|
||||
)
|
||||
vim.api.nvim_create_autocmd(
|
||||
"BufWritePost",
|
||||
{
|
||||
group = group_id,
|
||||
pattern = "*",
|
||||
callback = handle_buffer_changed
|
||||
}
|
||||
)
|
||||
vim.api.nvim_create_autocmd(
|
||||
"InsertLeave",
|
||||
{
|
||||
group = group_id,
|
||||
pattern = "*",
|
||||
callback = handle_buffer_changed
|
||||
}
|
||||
)
|
||||
vim.api.nvim_create_autocmd(
|
||||
"TextChanged",
|
||||
{
|
||||
group = group_id,
|
||||
pattern = "*",
|
||||
callback = handle_buffer_changed
|
||||
}
|
||||
)
|
||||
vim.api.nvim_create_autocmd(
|
||||
"VimLeave",
|
||||
{
|
||||
group = group_id,
|
||||
pattern = "*",
|
||||
callback = handle_vim_leave
|
||||
}
|
||||
)
|
||||
else
|
||||
vim.api.nvim_del_augroup_by_id(group_id)
|
||||
end
|
||||
end
|
||||
|
||||
local apply_diff_to_lines = function(diff, source_lines)
|
||||
local diff_lines = diff:split(line_ending)
|
||||
local changes = {}
|
||||
local current_diff
|
||||
|
||||
for _, line in pairs(diff_lines) do
|
||||
if line:len() > 0 then
|
||||
if line:starts_with("@@") and line:ends_with("@@") then
|
||||
local diff_range = line:sub(3, -1):sub(1, -3):split(" ")[1]:split(",")
|
||||
if #diff_range == 1 then
|
||||
table.insert(diff_range, "1")
|
||||
end
|
||||
|
||||
local diff_start = math.abs(tonumber(diff_range[1], 10))
|
||||
local diff_count = tonumber(diff_range[2], 10)
|
||||
if diff_count == 0 then
|
||||
diff_start = diff_start + 1
|
||||
end
|
||||
|
||||
current_diff = {
|
||||
diff = {line},
|
||||
next = diff_start + diff_count,
|
||||
start = diff_start
|
||||
}
|
||||
table.insert(changes, current_diff)
|
||||
elseif current_diff ~= nil then
|
||||
table.insert(current_diff.diff, line)
|
||||
end
|
||||
else
|
||||
current_diff = nil
|
||||
end
|
||||
end
|
||||
|
||||
local actual_line = 1
|
||||
local buffer_lines = {}
|
||||
local diff_rows = {}
|
||||
local source_line = 1
|
||||
for _, change in pairs(changes) do
|
||||
while source_line < change.start do
|
||||
table.insert(buffer_lines, source_lines[source_line])
|
||||
actual_line = actual_line + 1
|
||||
source_line = source_line + 1
|
||||
end
|
||||
|
||||
table.insert(diff_rows, actual_line)
|
||||
for _, change_diff_lines in pairs(change.diff) do
|
||||
table.insert(buffer_lines, change_diff_lines)
|
||||
actual_line = actual_line + 1
|
||||
end
|
||||
|
||||
source_line = change.next
|
||||
end
|
||||
|
||||
while source_line <= #source_lines do
|
||||
table.insert(buffer_lines, source_lines[source_line])
|
||||
actual_line = actual_line + 1
|
||||
source_line = source_line + 1
|
||||
end
|
||||
|
||||
return buffer_lines, diff_rows
|
||||
end
|
||||
|
||||
local show_picker = function(entries)
|
||||
global_state.set_global_key("selected_entry", nil)
|
||||
|
||||
local jump_state
|
||||
|
||||
local jump_to_line = function(self, bufnr, lnum)
|
||||
pcall(vim.api.nvim_buf_clear_namespace, bufnr, ns_previewer, 0, -1)
|
||||
if lnum and lnum > 0 then
|
||||
pcall(
|
||||
vim.api.nvim_buf_add_highlight,
|
||||
bufnr,
|
||||
ns_previewer,
|
||||
"TelescopePreviewLine",
|
||||
lnum - 1,
|
||||
0,
|
||||
-1
|
||||
)
|
||||
pcall(vim.api.nvim_win_set_cursor, self.state.winid, {lnum, 0})
|
||||
vim.api.nvim_buf_call(
|
||||
bufnr,
|
||||
function()
|
||||
vim.cmd "norm! zz"
|
||||
end
|
||||
)
|
||||
end
|
||||
end
|
||||
|
||||
local do_forward_jump = function()
|
||||
if jump_state ~= nil and #jump_state.diff_rows > 0 then
|
||||
jump_state.cur =
|
||||
utils.iff(
|
||||
(jump_state.cur + 1) <= #jump_state.diff_rows,
|
||||
jump_state.cur + 1,
|
||||
#jump_state.diff_rows
|
||||
)
|
||||
jump_to_line(
|
||||
jump_state.self,
|
||||
jump_state.self.state.bufnr,
|
||||
jump_state.diff_rows[jump_state.cur]
|
||||
)
|
||||
end
|
||||
end
|
||||
|
||||
local do_reverse_jump = function()
|
||||
if jump_state ~= nil and #jump_state.diff_rows > 0 then
|
||||
jump_state.cur =
|
||||
utils.iff((jump_state.cur - 1) > 0, jump_state.cur - 1, 1)
|
||||
jump_to_line(
|
||||
jump_state.self,
|
||||
jump_state.self.state.bufnr,
|
||||
jump_state.diff_rows[jump_state.cur]
|
||||
)
|
||||
end
|
||||
end
|
||||
|
||||
pickers.new(
|
||||
{},
|
||||
{
|
||||
prompt_title = "File History",
|
||||
previewer = previewers.new_buffer_previewer(
|
||||
{
|
||||
define_preview = function(self, entry)
|
||||
jump_state = nil
|
||||
if entry.index < #entries then
|
||||
local previous_lines = entries[entry.index + 1].lines
|
||||
local buffer_lines, diff_rows =
|
||||
apply_diff_to_lines(
|
||||
diff_strings(
|
||||
table.concat(previous_lines, line_ending),
|
||||
table.concat(entry.value.lines, line_ending)
|
||||
),
|
||||
previous_lines
|
||||
)
|
||||
previous_lines = nil
|
||||
|
||||
vim.api.nvim_buf_set_lines(
|
||||
self.state.bufnr,
|
||||
0,
|
||||
-1,
|
||||
false,
|
||||
buffer_lines
|
||||
)
|
||||
previewer_utils.regex_highlighter(self.state.bufnr, "diff")
|
||||
|
||||
jump_state = {self = self, cur = 0, diff_rows = diff_rows}
|
||||
vim.schedule(
|
||||
function()
|
||||
do_forward_jump()
|
||||
end
|
||||
)
|
||||
else
|
||||
vim.api.nvim_buf_set_lines(
|
||||
self.state.bufnr,
|
||||
0,
|
||||
-1,
|
||||
false,
|
||||
entry.value.lines
|
||||
)
|
||||
previewer_utils.highlighter(self.state.bufnr, entry.value.ft, {})
|
||||
end
|
||||
end
|
||||
}
|
||||
),
|
||||
sorter = conf.generic_sorter({}),
|
||||
finder = finders.new_table(
|
||||
{
|
||||
results = entries,
|
||||
entry_maker = function(item)
|
||||
return {
|
||||
value = item,
|
||||
ordinal = tostring(item.date),
|
||||
display = os.date("%m-%d-%Y %H:%M:%S", item.date)
|
||||
}
|
||||
end
|
||||
}
|
||||
),
|
||||
attach_mappings = function(prompt_bufnr, map)
|
||||
actions.select_default:replace(
|
||||
function()
|
||||
actions.close(prompt_bufnr)
|
||||
local selection = action_state.get_selected_entry()
|
||||
if selection ~= nil then
|
||||
vim.api.nvim_buf_set_lines(0, 0, -1, false, selection.value.lines)
|
||||
end
|
||||
end
|
||||
)
|
||||
map("i", "<c-l>", do_forward_jump)
|
||||
map("n", "<c-l>", do_forward_jump)
|
||||
map("i", "<c-h>", do_reverse_jump)
|
||||
map("n", "<c-h>", do_reverse_jump)
|
||||
return true
|
||||
end
|
||||
}
|
||||
):find()
|
||||
end
|
||||
|
||||
M.setup = function(config)
|
||||
if config == nil then
|
||||
config = {}
|
||||
end
|
||||
|
||||
if config.exclusions ~= nil then
|
||||
for _, e in pairs(config.exclusions) do
|
||||
if type(e) ~= "function" then
|
||||
print_message(
|
||||
true,
|
||||
"'exclusions' contains an entry that is not a function. Skipping all exclusions until this is corrected:"
|
||||
)
|
||||
table.print_table(e)
|
||||
break
|
||||
end
|
||||
table.insert(haven_config.exclusions, e)
|
||||
end
|
||||
end
|
||||
haven_config.enabled = vim.F.if_nil(config.enabled, haven_config.enabled)
|
||||
haven_config.haven_path =
|
||||
vim.F.if_nil(config.haven_path, haven_config.haven_path)
|
||||
|
||||
if config.inclusions ~= nil then
|
||||
for _, e in pairs(config.inclusions) do
|
||||
if type(e) ~= "function" then
|
||||
print_message(
|
||||
true,
|
||||
"'inclusions' contains an entry that is not a function. Skipping this inclusion until it is corrected:"
|
||||
)
|
||||
table.print_table(e)
|
||||
end
|
||||
table.insert(haven_config.inclusions, e)
|
||||
end
|
||||
end
|
||||
|
||||
haven_config.max_history_count =
|
||||
vim.F.if_nil(config.max_history_count, haven_config.max_history_count)
|
||||
if haven_config.max_history_count < 10 then
|
||||
print_message(
|
||||
true,
|
||||
"'max_history_count' too low: " .. haven_config.max_history_count
|
||||
)
|
||||
haven_config.max_history_count = 100
|
||||
print_message(
|
||||
true,
|
||||
"reset 'max_history_count': " .. haven_config.max_history_count
|
||||
)
|
||||
elseif haven_config.max_history_count > 500 then
|
||||
print_message(
|
||||
true,
|
||||
"'max_history_count' too high: " .. haven_config.max_history_count
|
||||
)
|
||||
haven_config.max_history_count = 500
|
||||
print_message(
|
||||
true,
|
||||
"reset 'max_history_count': " .. haven_config.max_history_count
|
||||
)
|
||||
end
|
||||
|
||||
haven_config.save_timeout =
|
||||
vim.F.if_nil(config.save_timeout, haven_config.save_timeout)
|
||||
if haven_config.save_timeout < 135 then
|
||||
print_message(true, "'save_timeout' too low: " .. haven_config.save_timeout)
|
||||
haven_config.save_timeout = 135
|
||||
print_message(true, "reset 'save_timeout': " .. haven_config.save_timeout)
|
||||
elseif haven_config.save_timeout > 10000 then
|
||||
print_message(
|
||||
true,
|
||||
"'save_timeout' too high: " .. haven_config.save_timeout
|
||||
)
|
||||
haven_config.save_timeout = 10000
|
||||
print_message(true, "reset 'save_timeout': " .. haven_config.save_timeout)
|
||||
end
|
||||
|
||||
if vim.fn.mkdir(haven_config.haven_path, "p") == 0 then
|
||||
print_message(true, "directory create failed: " .. haven_config.haven_path)
|
||||
haven_config.enabled = false
|
||||
return
|
||||
end
|
||||
|
||||
if vim.fn.isdirectory(haven_config.haven_path) == 0 then
|
||||
print_message(true, "directory not found: " .. haven_config.haven_path)
|
||||
haven_config.enabled = false
|
||||
return
|
||||
end
|
||||
|
||||
setup_autocmds()
|
||||
end
|
||||
|
||||
M.clean = function()
|
||||
local decode = function(str)
|
||||
if str == nil then
|
||||
return ""
|
||||
end
|
||||
|
||||
return str:gsub("+", " "):gsub(
|
||||
"%%(%x%x)",
|
||||
function(x)
|
||||
return string.char(tonumber(x, 16))
|
||||
end
|
||||
)
|
||||
end
|
||||
|
||||
local history_files =
|
||||
scan.scan_dir(haven_config.haven_path, {hidden = true, depth = 1})
|
||||
for _, history_file in ipairs(history_files) do
|
||||
local source_path =
|
||||
Path:new(
|
||||
decode(Path:new(history_file):make_relative(haven_config.haven_path)):sub(
|
||||
1,
|
||||
-6
|
||||
)
|
||||
)
|
||||
if not source_path:exists() then
|
||||
local history_path = Path:new(history_file)
|
||||
print("removing: " .. history_path:absolute())
|
||||
history_path:rm()
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
M.disable = function()
|
||||
if haven_config.enabled then
|
||||
haven_config.enabled = false
|
||||
setup_autocmds()
|
||||
handle_vim_leave()
|
||||
end
|
||||
end
|
||||
|
||||
M.enable = function()
|
||||
if not haven_config.enabled then
|
||||
haven_config.enabled = true
|
||||
handle_buffer_changed()
|
||||
setup_autocmds()
|
||||
end
|
||||
end
|
||||
|
||||
M.history = function(bufname)
|
||||
bufname = vim.F.if_nil(bufname, vim.fn.bufname())
|
||||
local buf_info = vim.fn.getbufinfo(bufname)
|
||||
if buf_info ~= nil and #buf_info > 0 then
|
||||
buf_info = buf_info[1]
|
||||
local save_file = create_save_file_path(buf_info)
|
||||
if vim.fn.filereadable(save_file) ~= 0 then
|
||||
local entries, err = read_change_file(save_file)
|
||||
if entries == nil then
|
||||
print_message(true, err)
|
||||
return
|
||||
end
|
||||
|
||||
show_picker(table.reverse(entries))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
_G.Nvim_Haven_Clean = M.clean
|
||||
_G.Nvim_Haven_Disable = M.disable
|
||||
_G.Nvim_Haven_Enable = M.enable
|
||||
_G.Nvim_Haven_History = M.history
|
||||
|
||||
return M
|
||||
Reference in New Issue
Block a user