codemp-nvim/lua/codemp/buffers.lua

154 lines
5.1 KiB
Lua
Raw Normal View History

local utils = require('codemp.utils')
2024-08-24 01:56:27 +02:00
local session = require('codemp.session')
2024-08-24 01:57:42 +02:00
---@type table<integer, string>
local id_buffer_map = {}
2024-08-24 01:57:42 +02:00
---@type table<string, integer>
local buffer_id_map = {}
2024-08-24 01:57:42 +02:00
---@type table<string, string>
local user_buffer_name = {}
local ticks = {}
2024-08-24 01:57:42 +02:00
---@param name string name of buffer to attach to
---@param buffer integer buffer to use for attaching (will clear content)
2024-08-24 01:57:42 +02:00
---@param content? string if provided, set this content after attaching
---@param nowait? boolean skip waiting for initial content sync
2024-08-24 01:57:42 +02:00
---@return BufferController
local function attach(name, buffer, content, nowait)
2024-08-24 01:57:42 +02:00
if buffer_id_map[name] ~= nil then
error("already attached to buffer " .. name)
end
2024-09-06 19:40:52 +02:00
vim.api.nvim_set_option_value('fileformat', 'unix', { buf = buffer })
vim.api.nvim_buf_set_name(buffer, name)
2024-08-24 01:56:27 +02:00
local controller = session.workspace:attach_buffer(name):await()
if not nowait then
controller:poll():await() -- wait for current state to get synched
end
-- TODO map name to uuid
id_buffer_map[buffer] = name
buffer_id_map[name] = buffer
ticks[buffer] = 0
-- hook serverbound callbacks
-- TODO breaks when deleting whole lines at buffer end
vim.api.nvim_buf_attach(buffer, false, {
on_bytes = function(_, buf, tick, start_row, start_col, start_offset, old_end_row, old_end_col, old_end_byte_len, new_end_row, new_end_col, new_byte_len)
if tick <= ticks[buf] then return end
if id_buffer_map[buf] == nil then return true end -- unregister callback handler
2024-09-06 03:53:52 +02:00
if CODEMP.config.debug then print(string.format(
"start(row:%s, col:%s) offset:%s end(row:%s, col:%s new(row:%s, col:%s)) len(old:%s, new:%s)",
start_row, start_col, start_offset, old_end_row, old_end_col, new_end_row, new_end_col, old_end_byte_len, new_byte_len
2024-09-06 03:53:52 +02:00
)) end
local change_content
if new_byte_len == 0 then
change_content = ""
else
change_content = table.concat(
vim.api.nvim_buf_get_text(buf, start_row, start_col, start_row + new_end_row, start_col + new_end_col, {}),
'\n'
)
end
2024-09-06 03:53:52 +02:00
if CODEMP.config.debug then
print(string.format("sending: %s %s %s %s -- '%s'", start_row, start_col, start_row + new_end_row, start_col + new_end_col, change_content))
end
controller:send(start_offset, start_offset + old_end_byte_len, change_content):await()
end,
})
local async = vim.loop.new_async(vim.schedule_wrap(function ()
while true do
2024-08-17 01:56:09 +02:00
local event = controller:try_recv():await()
if event == nil then break end
ticks[buffer] = vim.api.nvim_buf_get_changedtick(buffer)
2024-09-06 03:53:52 +02:00
if CODEMP.config.debug then
print(" ~~ applying change ~~ " .. event.first .. ".." .. event.last .. "::[" .. event.content .. "]")
end
utils.buffer.set_content(buffer, event.content, event.first, event.last)
if event.hash ~= nil then
if utils.hash(utils.buffer.get_content(buffer)) ~= event.hash then
-- OUT OF SYNC!
-- TODO this may be destructive! we should probably prompt the user before doing this
print(" /!\\ out of sync, resynching...")
2024-08-17 01:56:09 +02:00
utils.buffer.set_content(buffer, controller:content():await())
return
end
end
end
end))
2024-08-17 01:56:09 +02:00
local remote_content = controller:content():await()
if content ~= nil then
-- TODO this may happen too soon!!
local _ = controller:send(0, #remote_content, content) -- no need to await
else
ticks[buffer] = vim.api.nvim_buf_get_changedtick(buffer)
utils.buffer.set_content(buffer, remote_content)
end
2024-09-05 04:37:48 +02:00
controller:callback(function (_controller) async:send() end)
vim.defer_fn(function() async:send() end, 500) -- force a try_recv after 500ms
2024-09-06 19:58:03 +02:00
local filetype = vim.filetype.match({ buf = buffer })
vim.api.nvim_set_option_value("filetype", filetype, { buf = buffer })
print(" ++ attached to buffer " .. name)
require('codemp.window').update()
2024-08-15 01:22:48 +02:00
return controller
end
---@param name string
2024-08-24 01:57:42 +02:00
--TODO this should happen at the level above (Workspace) but accesses tables on this level, badly designed!
2024-08-08 04:34:23 +02:00
local function detach(name)
local buffer = buffer_id_map[name]
id_buffer_map[buffer] = nil
buffer_id_map[name] = nil
2024-08-24 01:56:27 +02:00
session.workspace:detach_buffer(name)
vim.api.nvim_buf_delete(buffer, {})
print(" -- detached from buffer " .. name)
require('codemp.window').update()
end
2024-08-24 01:57:42 +02:00
---@param buffer? integer if provided, sync given buffer id, otherwise sync current buf
local function sync(buffer)
if buffer == nil then
buffer = vim.api.nvim_get_current_buf()
end
local name = id_buffer_map[buffer]
if name ~= nil then
2024-08-24 01:56:27 +02:00
local controller = session.workspace:get_buffer(name)
if controller ~= nil then
ticks[buffer] = vim.api.nvim_buf_get_changedtick(buffer)
utils.buffer.set_content(buffer, controller:content():await())
print(" :: synched buffer " .. name)
return
end
end
print(" !! buffer not managed")
end
2024-09-06 15:13:36 +02:00
local function create(buffer)
if buffer == nil then
buffer = vim.fn.expand("%p")
end
if session.workspace == nil then
error("join a workspace first")
end
session.workspace:create_buffer(buffer):await()
print(" ++ created buffer " .. buffer)
require('codemp.window').update()
2024-09-06 15:13:36 +02:00
end
return {
sync = sync,
attach = attach,
detach = detach,
2024-09-06 15:13:36 +02:00
create = create,
map = id_buffer_map,
map_rev = buffer_id_map,
ticks = ticks,
users = user_buffer_name,
}