353 lines
8.5 KiB
Lua
353 lines
8.5 KiB
Lua
--
|
|
-- Cursor
|
|
--
|
|
|
|
Cursor = {}
|
|
|
|
function Cursor.new(row, col)
|
|
local cursor = {row = row, col = col}
|
|
return setmetatable(cursor, {__index = Cursor})
|
|
end
|
|
|
|
function Cursor.get()
|
|
local _, row, col, _ = unpack(vim.fn.getpos('.'))
|
|
return Cursor.new(row, col)
|
|
end
|
|
|
|
function Cursor:set()
|
|
vim.fn.secursorcharpos({self.row, self.col})
|
|
end
|
|
|
|
function Cursor:is_valid()
|
|
return self.row > 0 and self.col > 0
|
|
end
|
|
|
|
function Cursor:is_string()
|
|
local syn_id = vim.fn.synID(self.row, self.col, false)
|
|
local syn_attr = vim.fn.synIDattr(syn_id, 'name')
|
|
return syn_attr:find('String$')
|
|
end
|
|
|
|
--
|
|
-- BracePair
|
|
--
|
|
|
|
BracePair = {}
|
|
|
|
function BracePair.new(brace_open, brace_close)
|
|
local brace_pair = {open = brace_open, close = brace_close}
|
|
return setmetatable(brace_pair, {__index = BracePair})
|
|
end
|
|
|
|
function BracePair.from_brace(brace)
|
|
for _, brace_pair in ipairs({{'(', ')'}, {'[', ']'}, {'{', '}'}, {'<', '>'}}) do
|
|
if brace_pair[1] == brace or brace_pair[2] == brace then
|
|
return BracePair.new(brace_pair[1], brace_pair[2])
|
|
end
|
|
end
|
|
end
|
|
|
|
function BracePair:escaped()
|
|
local escape_brace = function(brace_raw)
|
|
if brace_raw == '[' or brace_raw == ']' then
|
|
return '\\' .. brace_raw
|
|
else
|
|
return brace_raw
|
|
end
|
|
end
|
|
|
|
return BracePair.new(escape_brace(self.open), escape_brace(self.close))
|
|
end
|
|
|
|
function BracePair:find(backward)
|
|
-- See flags: https://neovim.io/doc/user/builtin.html#search()
|
|
local flags = 'Wcn'
|
|
if backward then
|
|
flags = 'Wbn'
|
|
end
|
|
|
|
local escaped_pair = self:escaped()
|
|
local position = vim.fn.searchpairpos(
|
|
escaped_pair.open,
|
|
'',
|
|
escaped_pair.close,
|
|
flags,
|
|
function()
|
|
local cursor = Cursor:get()
|
|
return cursor:is_string()
|
|
end
|
|
)
|
|
|
|
local cursor = Cursor.new(unpack(position))
|
|
if cursor:is_valid() then
|
|
return cursor
|
|
end
|
|
end
|
|
|
|
--
|
|
-- BraceStack
|
|
--
|
|
|
|
BraceStack = {}
|
|
|
|
function BraceStack.new()
|
|
local stack = {stack = {}}
|
|
return setmetatable(stack, {__index = BraceStack})
|
|
end
|
|
|
|
function BraceStack:update(brace)
|
|
local brace_pair = BracePair.new(brace)
|
|
if brace_pair then
|
|
if brace == brace_pair.close and self:top() == brace_pair.open then
|
|
self:pop()
|
|
else
|
|
self:push(brace)
|
|
end
|
|
end
|
|
end
|
|
|
|
function BraceStack:push(brace)
|
|
table.insert(self.stack, brace)
|
|
end
|
|
|
|
function BraceStack:pop()
|
|
assert(not self:empty())
|
|
return table.remove(self.stack, #self.stack)
|
|
end
|
|
|
|
function BraceStack:empty()
|
|
return #self.stack == 0
|
|
end
|
|
|
|
function BraceStack:top()
|
|
return #self.stack[#self.stack]
|
|
end
|
|
|
|
--
|
|
-- BraceRange
|
|
--
|
|
|
|
BraceRange = {}
|
|
|
|
function BraceRange.new(start_cursor, stop_cursor, brace_pair, brace_params)
|
|
local brace_range = {
|
|
start_cursor = start_cursor,
|
|
stop_cursor = stop_cursor,
|
|
brace_pair = brace_pair,
|
|
brace_params = brace_params,
|
|
}
|
|
|
|
return setmetatable(brace_range, {__index = BraceRange})
|
|
end
|
|
|
|
function BraceRange.find(brace_pair)
|
|
local start_cursor = brace_pair:find(false)
|
|
if start_cursor then
|
|
local stop_cursor = brace_pair:find(true)
|
|
if stop_cursor then
|
|
return BraceRange.new(start_cursor, stop_cursor, brace_pair, {})
|
|
end
|
|
end
|
|
end
|
|
|
|
function BraceRange.find_closest()
|
|
local brace_range_compare = function(brace_range_1, brace_range_2)
|
|
local cursor = Cursor:get()
|
|
|
|
local row_diff1 = cursor.row - brace_range_1.start_cursor.row
|
|
local row_diff2 = cursor.row - brace_range_2.start_cursor.row
|
|
if row_diff1 < row_diff2 then
|
|
return -1
|
|
elseif row_diff1 > row_diff2 then
|
|
return 1
|
|
end
|
|
|
|
local col_diff1 = cursor.col - brace_range_1.start_cursor.col
|
|
local col_diff2 = cursor.col - brace_range_2.start_cursor.col
|
|
if col_diff1 < col_diff2 then
|
|
return -1
|
|
elseif col_diff1 > col_diff2 then
|
|
return 1
|
|
end
|
|
|
|
return 0
|
|
end
|
|
|
|
local brace_ranges = {}
|
|
for _, brace in ipairs({'(', '[', '{', '<'}) do
|
|
local brace_pair = BracePair.from_brace(brace)
|
|
local brace_range = BraceRange.find(brace_pair)
|
|
if brace_range then
|
|
table.insert(brace_ranges, brace_range)
|
|
end
|
|
end
|
|
|
|
if #brace_ranges > 0 then
|
|
return vim.fn.sort(brace_ranges, brace_range_compare)[1]
|
|
end
|
|
end
|
|
|
|
function BraceRange:is_wrapped()
|
|
return self.start_cursor.row ~= self.stop_cursor.row
|
|
end
|
|
|
|
--
|
|
-- Arg
|
|
--
|
|
|
|
Arg = {}
|
|
|
|
function Arg.new(text, brace_pair)
|
|
local arg = {
|
|
text = text,
|
|
brace_pair = brace_pair,
|
|
}
|
|
|
|
return setmetatable(arg, {__index = Arg})
|
|
end
|
|
|
|
function Arg:append(char)
|
|
self.text = self.text .. char
|
|
end
|
|
|
|
--
|
|
-- ArgList
|
|
--
|
|
|
|
ArgList = {}
|
|
|
|
function ArgList.new()
|
|
local arg_list = {
|
|
indent = '',
|
|
prefix = '',
|
|
suffix = '',
|
|
arg = nil,
|
|
args = {},
|
|
}
|
|
|
|
return setmetatable(arg_list, {__index = ArgList})
|
|
end
|
|
|
|
function ArgList:flush()
|
|
if self.arg then
|
|
table.insert(self.args, self.arg)
|
|
self.arg = nil
|
|
end
|
|
end
|
|
|
|
function ArgList:update(char, brace_stack, brace_range, cursor)
|
|
if not cursor:is_string() then
|
|
brace_stack:update(char)
|
|
if brace_stack:empty() and char == ',' then
|
|
self:flush()
|
|
return
|
|
end
|
|
end
|
|
|
|
if self.arg then
|
|
self.arg.append(char)
|
|
else
|
|
self.arg = Arg.new(char, brace_range)
|
|
end
|
|
end
|
|
|
|
function ArgList:parse(brace_range)
|
|
local brace_stack = BraceStack:new()
|
|
|
|
local first_line = vim.fn.getline(brace_range.start_cursor.row)
|
|
self.indent = first_line:match('^(%s*)')
|
|
self.prefix = first_line:sub(#brace_range.indent + 1, brace_range.start_cursor.col)
|
|
|
|
local last_line = vim.fn.getline(brace_range.stop_cursor.row)
|
|
self.suffix = last_line:sub(brace_range.stop_cursor.col)
|
|
|
|
for row = brace_range.start_cursor.row, brace_range.stop_cursor.row do
|
|
local line = vim.fn.getline(row)
|
|
|
|
local start_col = 1
|
|
if row == brace_range.start_cursor.row then
|
|
start_col = brace_range.start_cursor.col + 1
|
|
end
|
|
|
|
local stop_col = #line
|
|
if row == brace_range.stop_cursor.row then
|
|
stop_col = brace_range.stop_cursor.col - 1
|
|
end
|
|
|
|
for col = start_col, stop_col do
|
|
local char = line:sub(col, col)
|
|
self:update(char, brace_stack, brace_range, Cursor.new(row, col))
|
|
end
|
|
end
|
|
|
|
self:flush()
|
|
end
|
|
|
|
local function wrap_brace_range(brace_range, arg_list)
|
|
vim.fn.setline(brace_range.start_cursor.row, arg_list.indent .. arg_list.prefix)
|
|
|
|
-- local cursor_pos = nil
|
|
local row = brace_range.start_cursor.row
|
|
for _, arg in ipairs(arg_list.args) do
|
|
-- local on_last_row = i == #brace_range.params
|
|
|
|
local line = brace_range.indent .. arg.text
|
|
-- if opts.tail_comma or not on_last_row then
|
|
-- line = line .. ','
|
|
-- end
|
|
|
|
-- if on_last_row and not opts.wrap_closing_brace then
|
|
-- line = line .. brace_range.suffix
|
|
-- end
|
|
|
|
vim.fn.append(row, line)
|
|
vim.fn.execute(string.format('%d>', row + 1))
|
|
|
|
-- if param.offset then
|
|
-- cursor_pos = get_cursor_pos()
|
|
-- cursor_pos.col = cursor_pos.col + param.offset
|
|
-- cursor_pos.row = row + 1
|
|
-- end
|
|
|
|
row = row + 1
|
|
end
|
|
|
|
vim.fn.append(row, arg_list.indent .. arg_list.suffix)
|
|
|
|
-- if opts.wrap_closing_brace then
|
|
-- vim.fn.append(row, brace_range.indent .. brace_range.suffix)
|
|
-- end
|
|
--
|
|
-- if cursor_pos then
|
|
-- vim.fn.setcursorcharpos({cursor_pos.row, cursor_pos.col})
|
|
-- end
|
|
end
|
|
|
|
local function unwrap_brace_range(brace_range, arg_list)
|
|
local line = brace_range.indent .. brace_range.prefix
|
|
for i, param in ipairs(brace_range.params) do
|
|
line = line .. param.text
|
|
if i < #brace_range.params then
|
|
line = line .. ', '
|
|
end
|
|
end
|
|
line = line .. brace_range.suffix
|
|
|
|
vim.fn.setline(brace_range.start_cursor.row, line)
|
|
vim.fn.execute(string.format('%d,%dd_', brace_range.start_cursor.row + 1, brace_range.stop_cursor.rowrow2))
|
|
end
|
|
|
|
local function reflow()
|
|
local brace_range = BraceRange.find_closest()
|
|
if brace_range then
|
|
local arg_list = ArgList.new()
|
|
arg_list.parse(brace_range)
|
|
|
|
if brace_range.is_wrapped() then
|
|
unwrap_brace_range(brace_range, arg_list)
|
|
else
|
|
wrap_brace_range(brace_range, arg_list)
|
|
end
|
|
end
|
|
end
|