Jonathan Apodaca
46be66c699
Some checks failed
ci / ci (push) Has been cancelled
- range: extmarks/tsquery - mise for dev env - get rid of obsolete modules - implement as single file module
1615 lines
50 KiB
Lua
1615 lines
50 KiB
Lua
require 'luacov'
|
|
|
|
--- @diagnostic disable: undefined-field, need-check-nil
|
|
local Pos = require('u').Pos
|
|
local Range = require('u').Range
|
|
local function withbuf(lines, f)
|
|
vim.go.swapfile = false
|
|
|
|
vim.cmd.new()
|
|
vim.api.nvim_buf_set_lines(0, 0, -1, false, lines)
|
|
local ok, result = pcall(f)
|
|
vim.cmd.bdelete { bang = true }
|
|
if not ok then error(result) end
|
|
end
|
|
|
|
describe('Pos', function()
|
|
it('get a char from a given position', function()
|
|
withbuf({ 'asdf', 'bleh', 'a', '', 'goo' }, function()
|
|
assert.are.same('a', Pos.new(nil, 1, 1):char())
|
|
assert.are.same('d', Pos.new(nil, 1, 3):char())
|
|
assert.are.same('f', Pos.new(nil, 1, 4):char())
|
|
assert.are.same('a', Pos.new(nil, 3, 1):char())
|
|
assert.are.same('', Pos.new(nil, 4, 1):char())
|
|
assert.are.same('o', Pos.new(nil, 5, 3):char())
|
|
end)
|
|
end)
|
|
|
|
it('comparison operators', function()
|
|
local a = Pos.new(0, 0, 0, 0)
|
|
local b = Pos.new(0, 1, 0, 0)
|
|
assert.are.same(a == a, true)
|
|
assert.are.same(a < b, true)
|
|
end)
|
|
|
|
it('get the next position', function()
|
|
withbuf({ 'asdf', 'bleh', 'a', '', 'goo' }, function()
|
|
-- line 1: a => s
|
|
assert.are.same(Pos.new(nil, 1, 2), Pos.new(nil, 1, 1):next())
|
|
-- line 1: d => f
|
|
assert.are.same(Pos.new(nil, 1, 4), Pos.new(nil, 1, 3):next())
|
|
-- line 1 => 2
|
|
assert.are.same(Pos.new(nil, 2, 1), Pos.new(nil, 1, 4):next())
|
|
-- line 3 => 4
|
|
assert.are.same(Pos.new(nil, 4, 1), Pos.new(nil, 3, 1):next())
|
|
-- line 4 => 5
|
|
assert.are.same(Pos.new(nil, 5, 1), Pos.new(nil, 4, 1):next())
|
|
-- end returns nil
|
|
assert.are.same(nil, Pos.new(nil, 5, 3):next())
|
|
end)
|
|
end)
|
|
|
|
it('get the previous position', function()
|
|
withbuf({ 'asdf', 'bleh', 'a', '', 'goo' }, function()
|
|
-- line 1: s => a
|
|
assert.are.same(Pos.new(nil, 1, 1), Pos.new(nil, 1, 2):next(-1))
|
|
-- line 1: f => d
|
|
assert.are.same(Pos.new(nil, 1, 3), Pos.new(nil, 1, 4):next(-1))
|
|
-- line 2 => 1
|
|
assert.are.same(Pos.new(nil, 1, 4), Pos.new(nil, 2, 1):next(-1))
|
|
-- line 4 => 3
|
|
assert.are.same(Pos.new(nil, 3, 1), Pos.new(nil, 4, 1):next(-1))
|
|
-- line 5 => 4
|
|
assert.are.same(Pos.new(nil, 4, 1), Pos.new(nil, 5, 1):next(-1))
|
|
-- beginning returns nil
|
|
assert.are.same(nil, Pos.new(nil, 1, 1):next(-1))
|
|
end)
|
|
end)
|
|
|
|
it('find matching brackets', function()
|
|
withbuf({ 'asdf ({} def <[{}]>) ;lkj' }, function()
|
|
-- outer parens are matched:
|
|
assert.are.same(Pos.new(nil, 1, 20), Pos.new(nil, 1, 6):find_match())
|
|
-- outer parens are matched (backward):
|
|
assert.are.same(Pos.new(nil, 1, 6), Pos.new(nil, 1, 20):find_match())
|
|
-- no potential match returns nil
|
|
assert.are.same(nil, Pos.new(nil, 1, 1):find_match())
|
|
-- watchdog expires before an otherwise valid match is found:
|
|
assert.are.same(nil, Pos.new(nil, 1, 6):find_match(2))
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe('Range', function()
|
|
it('get text in buffer', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local range = Range.from_buf_text()
|
|
local lines = range:lines()
|
|
assert.are.same({
|
|
'line one',
|
|
'and line two',
|
|
}, lines)
|
|
|
|
local text = range:text()
|
|
assert.are.same('line one\nand line two', text)
|
|
end)
|
|
|
|
withbuf({}, function()
|
|
local range = Range.from_buf_text()
|
|
local lines = range:lines()
|
|
assert.are.same({ '' }, lines)
|
|
|
|
local text = range:text()
|
|
assert.are.same('', text)
|
|
end)
|
|
end)
|
|
|
|
it('get from positions: v in single line', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local range = Range.new(Pos.new(nil, 1, 2), Pos.new(nil, 1, 4), 'v')
|
|
local lines = range:lines()
|
|
assert.are.same({ 'ine' }, lines)
|
|
|
|
local text = range:text()
|
|
assert.are.same('ine', text)
|
|
end)
|
|
end)
|
|
|
|
it('get from positions: v across multiple lines', function()
|
|
withbuf({ 'pre line', 'the quick brown fox', 'jumps over a lazy dog', 'post line' }, function()
|
|
local range = Range.new(Pos.new(nil, 2, 5), Pos.new(nil, 3, 5), 'v')
|
|
local lines = range:lines()
|
|
assert.are.same({ 'quick brown fox', 'jumps' }, lines)
|
|
end)
|
|
end)
|
|
|
|
it('get from positions: V', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local range = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, vim.v.maxcol), 'V')
|
|
local lines = range:lines()
|
|
assert.are.same({ 'line one' }, lines)
|
|
|
|
local text = range:text()
|
|
assert.are.same('line one', text)
|
|
end)
|
|
end)
|
|
|
|
it('get from positions: V across multiple lines', function()
|
|
withbuf({ 'pre line', 'the quick brown fox', 'jumps over a lazy dog', 'post line' }, function()
|
|
local range = Range.new(Pos.new(nil, 2, 1), Pos.new(nil, 3, vim.v.maxcol), 'V')
|
|
local lines = range:lines()
|
|
assert.are.same({ 'the quick brown fox', 'jumps over a lazy dog' }, lines)
|
|
end)
|
|
end)
|
|
|
|
it('get from line', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local range = Range.from_line(nil, 1)
|
|
local lines = range:lines()
|
|
assert.are.same({ 'line one' }, lines)
|
|
|
|
local text = range:text()
|
|
assert.are.same('line one', text)
|
|
end)
|
|
end)
|
|
|
|
it('get from lines', function()
|
|
withbuf({ 'line one', 'and line two', 'and line 3' }, function()
|
|
local range = Range.from_lines(nil, 1, 2)
|
|
local lines = range:lines()
|
|
assert.are.same({ 'line one', 'and line two' }, lines)
|
|
|
|
local text = range:text()
|
|
assert.are.same('line one\nand line two', text)
|
|
end)
|
|
end)
|
|
|
|
it('replace within line', function()
|
|
withbuf({ 'pre line', 'the quick brown fox', 'jumps over a lazy dog', 'post line' }, function()
|
|
local range = Range.new(Pos.new(nil, 2, 5), Pos.new(nil, 2, 9), 'v')
|
|
range:replace 'quack'
|
|
|
|
local text = Range.from_line(nil, 2):text()
|
|
assert.are.same('the quack brown fox', text)
|
|
end)
|
|
end)
|
|
|
|
it('delete within line', function()
|
|
withbuf({ 'pre line', 'the quick brown fox', 'jumps over a lazy dog', 'post line' }, function()
|
|
local range = Range.new(Pos.new(nil, 2, 5), Pos.new(nil, 2, 10), 'v')
|
|
range:replace ''
|
|
|
|
local text = Range.from_line(nil, 2):text()
|
|
assert.are.same('the brown fox', text)
|
|
end)
|
|
|
|
withbuf({ 'pre line', 'the quick brown fox', 'jumps over a lazy dog', 'post line' }, function()
|
|
local range = Range.new(Pos.new(nil, 2, 5), Pos.new(nil, 2, 10), 'v')
|
|
range:replace(nil)
|
|
|
|
local text = Range.from_line(nil, 2):text()
|
|
assert.are.same('the brown fox', text)
|
|
end)
|
|
end)
|
|
|
|
it('replace across multiple lines: v', function()
|
|
withbuf({ 'pre line', 'the quick brown fox', 'jumps over a lazy dog', 'post line' }, function()
|
|
local range = Range.new(Pos.new(nil, 2, 5), Pos.new(nil, 3, 5), 'v')
|
|
range:replace 'plane flew'
|
|
|
|
local lines = Range.from_buf_text():lines()
|
|
assert.are.same({
|
|
'pre line',
|
|
'the plane flew over a lazy dog',
|
|
'post line',
|
|
}, lines)
|
|
end)
|
|
end)
|
|
|
|
it('replace a line', function()
|
|
withbuf({ 'pre line', 'the quick brown fox', 'jumps over a lazy dog', 'post line' }, function()
|
|
local range = Range.from_line(nil, 2)
|
|
range:replace 'the rabbit'
|
|
|
|
local lines = Range.from_buf_text():lines()
|
|
assert.are.same({
|
|
'pre line',
|
|
'the rabbit',
|
|
'jumps over a lazy dog',
|
|
'post line',
|
|
}, lines)
|
|
end)
|
|
end)
|
|
|
|
it('replace multiple lines', function()
|
|
withbuf({ 'pre line', 'the quick brown fox', 'jumps over a lazy dog', 'post line' }, function()
|
|
local range = Range.from_lines(nil, 2, 3)
|
|
range:replace 'the rabbit'
|
|
|
|
local lines = Range.from_buf_text():lines()
|
|
assert.are.same({
|
|
'pre line',
|
|
'the rabbit',
|
|
'post line',
|
|
}, lines)
|
|
end)
|
|
end)
|
|
|
|
it('delete single line', function()
|
|
withbuf({ 'pre line', 'the quick brown fox', 'jumps over a lazy dog', 'post line' }, function()
|
|
local range = Range.from_line(nil, 2)
|
|
range:replace(nil) -- delete lines
|
|
|
|
local lines = Range.from_buf_text():lines()
|
|
assert.are.same({
|
|
'pre line',
|
|
'jumps over a lazy dog',
|
|
'post line',
|
|
}, lines)
|
|
end)
|
|
end)
|
|
|
|
it('delete multiple lines', function()
|
|
withbuf({ 'pre line', 'the quick brown fox', 'jumps over a lazy dog', 'post line' }, function()
|
|
local range = Range.from_lines(nil, 2, 3)
|
|
range:replace(nil) -- delete lines
|
|
|
|
local lines = Range.from_buf_text():lines()
|
|
assert.are.same({
|
|
'pre line',
|
|
'post line',
|
|
}, lines)
|
|
end)
|
|
end)
|
|
|
|
it('text object: word', function()
|
|
withbuf({ 'the quick brown fox' }, function()
|
|
vim.fn.setpos('.', { 0, 1, 5, 0 })
|
|
assert.are.same('quick ', Range.from_motion('aw'):text())
|
|
|
|
vim.fn.setpos('.', { 0, 1, 5, 0 })
|
|
assert.are.same('quick', Range.from_motion('iw'):text())
|
|
end)
|
|
end)
|
|
|
|
it('text object: quote', function()
|
|
withbuf({ [[the "quick" brown fox]] }, function()
|
|
vim.fn.setpos('.', { 0, 1, 5, 0 })
|
|
assert.are.same('"quick"', Range.from_motion('a"'):text())
|
|
|
|
vim.fn.setpos('.', { 0, 1, 6, 0 })
|
|
assert.are.same('quick', Range.from_motion('i"'):text())
|
|
end)
|
|
|
|
withbuf({ [[the 'quick' brown fox]] }, function()
|
|
vim.fn.setpos('.', { 0, 1, 5, 0 })
|
|
assert.are.same("'quick'", Range.from_motion([[a']]):text())
|
|
|
|
vim.fn.setpos('.', { 0, 1, 6, 0 })
|
|
assert.are.same('quick', Range.from_motion([[i']]):text())
|
|
end)
|
|
|
|
withbuf({ [[the `quick` brown fox]] }, function()
|
|
vim.fn.setpos('.', { 0, 1, 5, 0 })
|
|
assert.are.same('`quick`', Range.from_motion([[a`]]):text())
|
|
|
|
vim.fn.setpos('.', { 0, 1, 6, 0 })
|
|
assert.are.same('quick', Range.from_motion([[i`]]):text())
|
|
end)
|
|
end)
|
|
|
|
it('text object: block', function()
|
|
withbuf({ 'this is a {', 'block', '} here' }, function()
|
|
vim.fn.setpos('.', { 0, 2, 1, 0 })
|
|
assert.are.same('{\nblock\n}', Range.from_motion('a{'):text())
|
|
|
|
vim.fn.setpos('.', { 0, 2, 1, 0 })
|
|
assert.are.same('block', Range.from_motion('i{'):text())
|
|
end)
|
|
end)
|
|
|
|
it('text object: restores cursor position', function()
|
|
withbuf({ 'this is a {block} here' }, function()
|
|
vim.fn.setpos('.', { 0, 1, 13, 0 })
|
|
assert.are.same('{block}', Range.from_motion('a{'):text())
|
|
assert.are.same(vim.api.nvim_win_get_cursor(0), { 1, 12 })
|
|
end)
|
|
end)
|
|
|
|
it('text object: it (inside HTML tag)', function()
|
|
withbuf({ '<div><span>text</span></div>' }, function()
|
|
vim.cmd.setfiletype 'html'
|
|
vim.fn.setpos('.', { 0, 1, 12, 0 }) -- inside 'text'
|
|
local range = Range.from_motion 'it'
|
|
assert.is_not_nil(range)
|
|
assert.are.same('text', range:text())
|
|
end)
|
|
end)
|
|
|
|
it('from_motion with contains_cursor returns nil when cursor outside range', function()
|
|
withbuf({ 'foo "quoted" bar' }, function()
|
|
vim.fn.setpos('.', { 0, 1, 2, 0 }) -- cursor at 'foo', not in quotes
|
|
local range = Range.from_motion('a"', { contains_cursor = true })
|
|
assert.is_nil(range)
|
|
end)
|
|
end)
|
|
|
|
it('from_motion with pos option', function()
|
|
withbuf({ 'the quick brown fox' }, function()
|
|
vim.fn.setpos('.', { 0, 1, 1, 0 }) -- cursor at start
|
|
local pos = Pos.new(nil, 1, 5) -- position at 'quick'
|
|
local range = Range.from_motion('aw', { pos = pos })
|
|
assert.are.same('quick ', range:text())
|
|
end)
|
|
end)
|
|
|
|
it('from_motion with simple motion (non-text-object)', function()
|
|
withbuf({ 'hello world' }, function()
|
|
vim.fn.setpos('.', { 0, 1, 1, 0 })
|
|
local range = Range.from_motion 'w'
|
|
assert.is_not_nil(range)
|
|
end)
|
|
end)
|
|
|
|
it('from_motion with bufnr option', function()
|
|
local buf1 = vim.api.nvim_create_buf(false, true)
|
|
vim.api.nvim_buf_set_lines(buf1, 0, -1, false, { 'buffer one', 'more text' })
|
|
|
|
local buf2 = vim.api.nvim_create_buf(false, true)
|
|
vim.api.nvim_buf_set_lines(buf2, 0, -1, false, { 'buffer two' })
|
|
vim.api.nvim_set_current_buf(buf2)
|
|
|
|
vim.fn.setpos('.', { buf1, 1, 1, 0 })
|
|
local range = Range.from_motion('aw', { bufnr = buf1 })
|
|
assert.is_not_nil(range)
|
|
assert.are.same(buf1, range.start.bufnr)
|
|
|
|
vim.api.nvim_buf_delete(buf1, { force = true })
|
|
vim.api.nvim_buf_delete(buf2, { force = true })
|
|
end)
|
|
|
|
it('from_motion restores visual selection when started in visual mode', function()
|
|
withbuf({ 'the quick brown fox' }, function()
|
|
-- Enter visual mode first
|
|
vim.fn.setpos('.', { 0, 1, 1, 0 })
|
|
vim.cmd.normal 'vll' -- select 'the' (3 chars)
|
|
|
|
-- Record initial visual marks
|
|
local initial_v = vim.fn.getpos 'v'
|
|
|
|
-- Call from_motion (should save and restore visual selection)
|
|
local range = Range.from_motion 'aw'
|
|
assert.is_not_nil(range)
|
|
|
|
-- Check we're back in visual mode with selection restored
|
|
-- Note: The exact behavior depends on implementation
|
|
local mode = vim.fn.mode()
|
|
assert.is_true(mode == 'v' or mode == 'V' or mode == '\22')
|
|
end)
|
|
end)
|
|
|
|
it('from_tsquery_caps', function()
|
|
withbuf({
|
|
'-- a comment',
|
|
'',
|
|
'function foo(bar) end',
|
|
'',
|
|
'-- a middle comment',
|
|
'',
|
|
'function bar(baz) end',
|
|
'',
|
|
'-- another comment',
|
|
}, function()
|
|
vim.cmd.setfiletype 'lua'
|
|
|
|
--- @param contains_cursor? boolean
|
|
local function get_caps(contains_cursor)
|
|
if contains_cursor == nil then contains_cursor = true end
|
|
return (Range.from_tsquery_caps(
|
|
0,
|
|
'(function_declaration) @f',
|
|
{ contains_cursor = contains_cursor }
|
|
)).f or {}
|
|
end
|
|
|
|
local caps = get_caps(false)
|
|
assert.are.same(#caps, 2)
|
|
assert.are.same(vim.iter(caps):map(function(c) return c:text() end):totable(), {
|
|
'function foo(bar) end',
|
|
'function bar(baz) end',
|
|
})
|
|
|
|
Pos.new(0, 1, 1):save_to_pos '.'
|
|
caps = get_caps()
|
|
assert.are.same(#caps, 0)
|
|
|
|
Pos.new(0, 3, 18):save_to_pos '.'
|
|
caps = get_caps()
|
|
assert.are.same(#caps, 1)
|
|
assert.are.same(caps[1]:text(), 'function foo(bar) end')
|
|
|
|
Pos.new(0, 5, 1):save_to_pos '.'
|
|
caps = get_caps()
|
|
assert.are.same(#caps, 0)
|
|
|
|
Pos.new(0, 7, 1):save_to_pos '.'
|
|
caps = get_caps()
|
|
assert.are.same(#caps, 1)
|
|
assert.are.same(caps[1]:text(), 'function bar(baz) end')
|
|
end)
|
|
end)
|
|
|
|
it('from_tsquery_caps with string array filter', function()
|
|
withbuf({
|
|
'{',
|
|
' sample_key1 = "sample-value1",',
|
|
' sample_key2 = "sample-value2",',
|
|
'}',
|
|
}, function()
|
|
vim.cmd.setfiletype 'lua'
|
|
|
|
-- Place cursor in "sample-value1"
|
|
Pos.new(0, 2, 25):save_to_pos '.'
|
|
|
|
-- Query that captures both keys and values in pairs
|
|
local query = [[
|
|
(field
|
|
name: _ @key
|
|
value: _ @value)
|
|
]]
|
|
|
|
local ranges = Range.from_line(0, 2):tsquery(query)
|
|
|
|
-- Should have both @key and @value captures for the first pair only
|
|
-- (since cursor is in sample-value1)
|
|
assert(ranges, 'Range should not be nil')
|
|
assert(ranges.key, 'Range.key should not be nil')
|
|
assert(ranges.value, 'Range.value should not be nil')
|
|
|
|
-- Should have exactly one key and one value
|
|
assert.are.same(#ranges.key, 1)
|
|
assert.are.same(#ranges.value, 1)
|
|
|
|
-- Check that we got sample-key1 and sample-value1
|
|
assert.are.same(ranges.key[1]:text(), 'sample_key1')
|
|
assert.are.same(ranges.value[1]:text(), '"sample-value1"')
|
|
end)
|
|
|
|
-- Make sure this works when the match is on the last line:
|
|
withbuf({
|
|
'{sample_key1= "sample-value1",',
|
|
'sample_key2= "sample-value2"}',
|
|
}, function()
|
|
vim.cmd.setfiletype 'lua'
|
|
|
|
-- Place cursor in "sample-value1"
|
|
Pos.new(0, 2, 25):save_to_pos '.'
|
|
|
|
-- Query that captures both keys and values in pairs
|
|
local query = [[
|
|
(field
|
|
name: _ @key
|
|
value: _ @value)
|
|
]]
|
|
|
|
local ranges = Range.from_line(0, 2):tsquery(query)
|
|
|
|
-- Should have both @key and @value captures for the first pair only
|
|
-- (since cursor is in sample-value1)
|
|
assert(ranges, 'Range should not be nil')
|
|
assert(ranges.key, 'Range.key should not be nil')
|
|
assert(ranges.value, 'Range.value should not be nil')
|
|
|
|
-- Should have exactly one key and one value
|
|
assert.are.same(#ranges.key, 1)
|
|
assert.are.same(#ranges.value, 1)
|
|
|
|
-- Check that we got sample-key2 and sample-value2
|
|
assert.are.same(ranges.key[1]:text(), 'sample_key2')
|
|
assert.are.same(ranges.value[1]:text(), '"sample-value2"')
|
|
end)
|
|
end)
|
|
|
|
it('should get nearest block', function()
|
|
withbuf({
|
|
'this is a {',
|
|
'block',
|
|
'} here',
|
|
}, function()
|
|
vim.fn.setpos('.', { 0, 2, 1, 0 })
|
|
assert.are.same('{\nblock\n}', Range.find_nearest_brackets():text())
|
|
end)
|
|
|
|
withbuf({
|
|
'this is a {',
|
|
'(block)',
|
|
'} here',
|
|
}, function()
|
|
vim.fn.setpos('.', { 0, 2, 3, 0 })
|
|
assert.are.same('(block)', Range.find_nearest_brackets():text())
|
|
end)
|
|
end)
|
|
|
|
it('line', function()
|
|
withbuf({
|
|
'this is a {',
|
|
'block',
|
|
'} here',
|
|
}, function()
|
|
local range = Range.new(Pos.new(0, 1, 6), Pos.new(0, 2, 5), 'v')
|
|
local lfirst = assert(range:line(1), 'lfirst null')
|
|
assert.are.same('is a {', lfirst:text())
|
|
assert.are.same(Pos.new(0, 1, 6), lfirst.start)
|
|
assert.are.same(Pos.new(0, 1, 11), lfirst.stop)
|
|
assert.are.same('block', range:line(2):text())
|
|
end)
|
|
end)
|
|
|
|
it('from_marks', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local a = Pos.new(nil, 0, 0)
|
|
local b = Pos.new(nil, 1, 1)
|
|
a:save_to_pos "'["
|
|
b:save_to_pos "']"
|
|
|
|
local range = Range.from_marks("'[", "']")
|
|
assert.are.same(range.start, a)
|
|
assert.are.same(range.stop, b)
|
|
assert.are.same(range.mode, 'v')
|
|
end)
|
|
end)
|
|
|
|
it('from_vtext', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
vim.fn.setpos('.', { 0, 1, 3, 0 }) -- cursor at position (1, 3)
|
|
vim.cmd.normal 'v' -- enter visual mode
|
|
vim.cmd.normal 'l' -- select one character to the right
|
|
local range = Range.from_vtext()
|
|
assert.are.same(range.start, Pos.new(nil, 1, 3))
|
|
assert.are.same(range.stop, Pos.new(nil, 1, 4))
|
|
assert.are.same(range.mode, 'v')
|
|
end)
|
|
end)
|
|
|
|
it('from_op_func', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local a = Pos.new(nil, 1, 1)
|
|
local b = Pos.new(nil, 2, 2)
|
|
a:save_to_pos "'["
|
|
b:save_to_pos "']"
|
|
|
|
local range = Range.from_op_func 'char'
|
|
assert.are.same(range.start, a)
|
|
assert.are.same(range.stop, b)
|
|
assert.are.same(range.mode, 'v')
|
|
|
|
range = Range.from_op_func 'line'
|
|
assert.are.same(range.start, a)
|
|
assert.are.same(range.stop, Pos.new(nil, 2, vim.v.maxcol))
|
|
assert.are.same(range.mode, 'V')
|
|
end)
|
|
end)
|
|
|
|
it('from_cmd_args: range=0', function()
|
|
local args = { range = 0 }
|
|
withbuf(
|
|
{ 'line one', 'and line two' },
|
|
function() assert.are.same(Range.from_cmd_args(args), nil) end
|
|
)
|
|
end)
|
|
|
|
it('from_cmd_args: range=1', function()
|
|
local args = { range = 1, line1 = 1 }
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local a = Pos.new(nil, 1, 1)
|
|
local b = Pos.new(nil, 1, vim.v.maxcol)
|
|
|
|
local range = Range.from_cmd_args(args) --[[@as u.Range]]
|
|
assert.are.same(range.start, a)
|
|
assert.are.same(range.stop, b)
|
|
assert.are.same(range.mode, 'V')
|
|
assert.are.same(range:text(), 'line one')
|
|
end)
|
|
end)
|
|
|
|
it('from_cmd_args: range=2: no-visual', function()
|
|
local args = { range = 2, line1 = 1, line2 = 2 }
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local range = Range.from_cmd_args(args) --[[@as u.Range]]
|
|
assert.are.same(range.start, Pos.new(nil, 1, 1))
|
|
assert.are.same(range.stop, Pos.new(nil, 2, vim.v.maxcol))
|
|
assert.are.same(range.mode, 'V')
|
|
assert.are.same(range:text(), 'line one\nand line two')
|
|
end)
|
|
end)
|
|
|
|
it('from_cmd_args: range=2: visual: linewise', function()
|
|
local args = { range = 2, line1 = 1, line2 = 2 }
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local a = Pos.new(nil, 1, 1)
|
|
local b = Pos.new(nil, 2, vim.v.maxcol)
|
|
a:save_to_pos "'<"
|
|
b:save_to_pos "'>"
|
|
local range = Range.from_cmd_args(args) --[[@as u.Range]]
|
|
assert.are.same(range.start, a)
|
|
assert.are.same(range.stop, b)
|
|
assert.are.same(range.mode, 'V')
|
|
assert.are.same(range:text(), 'line one\nand line two')
|
|
end)
|
|
end)
|
|
|
|
it('from_cmd_args: range=2: visual: charwise', function()
|
|
local args = { range = 2, line1 = 1, line2 = 1 }
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
-- Simulate a visual selection:
|
|
local a = Pos.new(nil, 1, 1)
|
|
local b = Pos.new(nil, 1, 4)
|
|
a:save_to_pos "'<"
|
|
b:save_to_pos "'>"
|
|
Range.new(a, b, 'v'):set_visual_selection()
|
|
assert.are.same(vim.fn.mode(), 'v')
|
|
|
|
-- In this simulated setup, we need to force visualmode() to return
|
|
-- 'v' and histget() to return [['<,'>]]:
|
|
|
|
-- visualmode()
|
|
local orig_visualmode = vim.fn.visualmode
|
|
--- @diagnostic disable-next-line: duplicate-set-field
|
|
function vim.fn.visualmode() return 'v' end
|
|
assert.are.same(vim.fn.visualmode(), 'v')
|
|
|
|
-- histget()
|
|
local orig_histget = vim.fn.histget
|
|
--- @diagnostic disable-next-line: duplicate-set-field
|
|
function vim.fn.histget(x, y) return [['<,'>]] end
|
|
|
|
-- Now run the test:
|
|
local range = Range.from_cmd_args(args) --[[@as u.Range]]
|
|
assert.are.same(range.start, a)
|
|
assert.are.same(range.stop, b)
|
|
assert.are.same(range.mode, 'v')
|
|
assert.are.same(range:text(), 'line')
|
|
|
|
-- Reset visualmode() and histget():
|
|
vim.fn.visualmode = orig_visualmode
|
|
vim.fn.histget = orig_histget
|
|
end)
|
|
end)
|
|
|
|
it('find_nearest_quotes', function()
|
|
withbuf({ [[the "quick" brown fox]] }, function()
|
|
vim.fn.setpos('.', { 0, 1, 5, 0 })
|
|
local range = Range.find_nearest_quotes()
|
|
assert.are.same(range.start, Pos.new(nil, 1, 5))
|
|
assert.are.same(range.stop, Pos.new(nil, 1, 11))
|
|
end)
|
|
|
|
withbuf({ [[the 'quick' brown fox]] }, function()
|
|
vim.fn.setpos('.', { 0, 1, 5, 0 })
|
|
local range = Range.find_nearest_quotes()
|
|
assert.are.same(range.start, Pos.new(nil, 1, 5))
|
|
assert.are.same(range.stop, Pos.new(nil, 1, 11))
|
|
end)
|
|
end)
|
|
|
|
it('smallest', function()
|
|
local r1 = Range.new(Pos.new(nil, 1, 2), Pos.new(nil, 1, 4), 'v')
|
|
local r2 = Range.new(Pos.new(nil, 1, 3), Pos.new(nil, 1, 5), 'v')
|
|
local r3 = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 6), 'v')
|
|
local smallest = Range.smallest { r1, r2, r3 }
|
|
assert.are.same(smallest.start, Pos.new(nil, 1, 2))
|
|
assert.are.same(smallest.stop, Pos.new(nil, 1, 4))
|
|
end)
|
|
|
|
it('clone', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local original = Range.from_lines(nil, 0, 1)
|
|
local cloned = original:clone()
|
|
assert.are.same(original.start, cloned.start)
|
|
assert.are.same(original.stop, cloned.stop)
|
|
assert.are.same(original.mode, cloned.mode)
|
|
end)
|
|
end)
|
|
|
|
it('line_count', function()
|
|
withbuf({ 'line one', 'and line two', 'line three' }, function()
|
|
local range = Range.from_lines(nil, 0, 2)
|
|
assert.are.same(range:line_count(), 3)
|
|
end)
|
|
end)
|
|
|
|
it('to_linewise()', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local range = Range.new(Pos.new(nil, 1, 2), Pos.new(nil, 2, 4), 'v')
|
|
local linewise_range = range:to_linewise()
|
|
assert.are.same(linewise_range.start.col, 1)
|
|
assert.are.same(linewise_range.stop.col, vim.v.maxcol)
|
|
assert.are.same(linewise_range.mode, 'V')
|
|
end)
|
|
end)
|
|
|
|
it('is_empty', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local range = Range.new(Pos.new(nil, 1, 1), nil, 'v')
|
|
assert.is_true(range:is_empty())
|
|
|
|
local range2 = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 2), 'v')
|
|
assert.is_false(range2:is_empty())
|
|
end)
|
|
end)
|
|
|
|
it('trim_start', function()
|
|
withbuf({ ' line one', 'line two' }, function()
|
|
local range = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 10), 'v')
|
|
local trimmed = range:trim_start()
|
|
assert.are.same(trimmed.start, Pos.new(nil, 1, 4)) -- should be after the spaces
|
|
end)
|
|
end)
|
|
|
|
it('trim_stop', function()
|
|
withbuf({ 'line one ', 'line two' }, function()
|
|
local range = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 10), 'v')
|
|
local trimmed = range:trim_stop()
|
|
assert.are.same(trimmed.stop, Pos.new(nil, 1, 8)) -- should be before the spaces
|
|
end)
|
|
end)
|
|
|
|
it('contains', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local range = Range.new(Pos.new(nil, 1, 2), Pos.new(nil, 1, 4), 'v')
|
|
local pos = Pos.new(nil, 1, 3)
|
|
assert.is_true(range:contains(pos))
|
|
|
|
pos = Pos.new(nil, 1, 5) -- outside of range
|
|
assert.is_false(range:contains(pos))
|
|
end)
|
|
end)
|
|
|
|
it('difference', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local range_outer = Range.new(Pos.new(nil, 2, 1), Pos.new(nil, 2, 12), 'v')
|
|
local range_inner = Range.new(Pos.new(nil, 2, 5), Pos.new(nil, 2, 8), 'v')
|
|
|
|
assert.are.same(range_outer:text(), 'and line two')
|
|
assert.are.same(range_inner:text(), 'line')
|
|
|
|
local left, right = range_outer:difference(range_inner)
|
|
assert.are.same(left:text(), 'and ')
|
|
assert.are.same(right:text(), ' two')
|
|
|
|
left, right = range_inner:difference(range_outer)
|
|
assert.are.same(left:text(), 'and ')
|
|
assert.are.same(right:text(), ' two')
|
|
|
|
left, right = range_outer:difference(range_outer)
|
|
assert.are.same(left:is_empty(), true)
|
|
assert.are.same(left:text(), '')
|
|
assert.are.same(right:is_empty(), true)
|
|
assert.are.same(right:text(), '')
|
|
end)
|
|
end)
|
|
|
|
it('length', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local range = Range.new(Pos.new(nil, 2, 4), Pos.new(nil, 2, 9), 'v')
|
|
assert.are.same(range:length(), #range:text())
|
|
|
|
range = Range.new(Pos.new(nil, 1, 4), Pos.new(nil, 2, 9), 'v')
|
|
assert.are.same(range:length(), #range:text())
|
|
end)
|
|
end)
|
|
|
|
it('sub', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local range = Range.new(Pos.new(nil, 2, 4), Pos.new(nil, 2, 9), 'v')
|
|
assert.are.same(range:text(), ' line ')
|
|
assert.are.same(range:sub(1, -1):text(), ' line ')
|
|
assert.are.same(range:sub(2, -2):text(), 'line')
|
|
assert.are.same(range:sub(1, 5):text(), ' line')
|
|
assert.are.same(range:sub(2, 5):text(), 'line')
|
|
assert.are.same(range:sub(20, 25):text(), '')
|
|
end)
|
|
end)
|
|
|
|
it('shrink', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local range = Range.new(Pos.new(nil, 2, 3), Pos.new(nil, 3, 5), 'v')
|
|
local shrunk = range:shrink(1)
|
|
assert.are.same(shrunk.start, Pos.new(nil, 2, 4))
|
|
assert.are.same(shrunk.stop, Pos.new(nil, 3, 4))
|
|
end)
|
|
end)
|
|
|
|
it('must_shrink', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local range = Range.new(Pos.new(nil, 2, 3), Pos.new(nil, 3, 5), 'v')
|
|
local shrunk = range:must_shrink(1)
|
|
assert.are.same(shrunk.start, Pos.new(nil, 2, 4))
|
|
assert.are.same(shrunk.stop, Pos.new(nil, 3, 4))
|
|
|
|
assert.has.error(
|
|
function() range:must_shrink(100) end,
|
|
'error in Range:must_shrink: Range:shrink() returned nil'
|
|
)
|
|
end)
|
|
end)
|
|
|
|
it('set_visual_selection', function()
|
|
withbuf({ 'line one', 'and line two' }, function()
|
|
local range = Range.from_lines(nil, 1, 2)
|
|
range:set_visual_selection()
|
|
|
|
assert.are.same(Pos.from_pos 'v', Pos.new(nil, 1, 1))
|
|
-- Since the selection is 'V' (instead of 'v'), the end
|
|
-- selects one character past the end:
|
|
assert.are.same(Pos.from_pos '.', Pos.new(nil, 2, 13))
|
|
end)
|
|
end)
|
|
|
|
it('selections set to past the EOL should not error', function()
|
|
withbuf({ 'Rg SET NAMES' }, function()
|
|
local b = vim.api.nvim_get_current_buf()
|
|
local r = Range.new(Pos.new(b, 1, 4), Pos.new(b, 1, 13), 'v')
|
|
r:replace 'bleh'
|
|
assert.are.same({ 'Rg bleh' }, vim.api.nvim_buf_get_lines(b, 0, -1, false))
|
|
end)
|
|
|
|
withbuf({ 'Rg SET NAMES' }, function()
|
|
local b = vim.api.nvim_get_current_buf()
|
|
local r = Range.new(Pos.new(b, 1, 4), Pos.new(b, 1, 12), 'v')
|
|
r:replace 'bleh'
|
|
assert.are.same({ 'Rg bleh' }, vim.api.nvim_buf_get_lines(b, 0, -1, false))
|
|
end)
|
|
end)
|
|
|
|
it('replace updates Range.stop: same line', function()
|
|
withbuf({ 'The quick brown fox jumps over the lazy dog' }, function()
|
|
local b = vim.api.nvim_get_current_buf()
|
|
local r = Range.new(Pos.new(b, 1, 5), Pos.new(b, 1, 9), 'v')
|
|
|
|
r:replace 'bleh1'
|
|
assert.are.same(
|
|
{ 'The bleh1 brown fox jumps over the lazy dog' },
|
|
vim.api.nvim_buf_get_lines(b, 0, -1, false)
|
|
)
|
|
|
|
r:replace 'bleh2'
|
|
assert.are.same(
|
|
{ 'The bleh2 brown fox jumps over the lazy dog' },
|
|
vim.api.nvim_buf_get_lines(b, 0, -1, false)
|
|
)
|
|
end)
|
|
end)
|
|
|
|
it('replace updates Range.stop: multi-line', function()
|
|
withbuf({
|
|
'The quick brown fox jumps',
|
|
'over the lazy dog',
|
|
}, function()
|
|
local b = vim.api.nvim_get_current_buf()
|
|
local r = Range.new(Pos.new(b, 1, 21), Pos.new(b, 2, 4), 'v')
|
|
assert.are.same({ 'jumps', 'over' }, r:lines())
|
|
|
|
r:replace 'bleh1'
|
|
assert.are.same(
|
|
{ 'The quick brown fox bleh1 the lazy dog' },
|
|
vim.api.nvim_buf_get_lines(b, 0, -1, false)
|
|
)
|
|
assert.are.same({ 'bleh1' }, r:lines())
|
|
|
|
r:replace 'blehGoo2'
|
|
assert.are.same(
|
|
{ 'The quick brown fox blehGoo2 the lazy dog' },
|
|
vim.api.nvim_buf_get_lines(b, 0, -1, false)
|
|
)
|
|
end)
|
|
end)
|
|
|
|
it('replace updates Range.stop: multi-line (blockwise)', function()
|
|
withbuf({
|
|
'The quick brown',
|
|
'fox',
|
|
'jumps',
|
|
'over',
|
|
'the lazy dog',
|
|
}, function()
|
|
local b = vim.api.nvim_get_current_buf()
|
|
local r = Range.new(Pos.new(b, 2, 1), Pos.new(b, 4, vim.v.maxcol), 'V')
|
|
assert.are.same({ 'fox', 'jumps', 'over' }, r:lines())
|
|
|
|
r:replace { 'bleh1', 'bleh2' }
|
|
assert.are.same({
|
|
'The quick brown',
|
|
'bleh1',
|
|
'bleh2',
|
|
'the lazy dog',
|
|
}, vim.api.nvim_buf_get_lines(b, 0, -1, false))
|
|
|
|
r:replace 'blehGoo2'
|
|
assert.are.same({
|
|
'The quick brown',
|
|
'blehGoo2',
|
|
'the lazy dog',
|
|
}, vim.api.nvim_buf_get_lines(b, 0, -1, false))
|
|
end)
|
|
end)
|
|
|
|
it('replace after delete', function()
|
|
withbuf({
|
|
'The quick brown',
|
|
'fox',
|
|
'jumps',
|
|
'over',
|
|
'the lazy dog',
|
|
}, function()
|
|
local b = vim.api.nvim_get_current_buf()
|
|
local r = Range.new(Pos.new(b, 2, 1), Pos.new(b, 4, vim.v.maxcol), 'V')
|
|
assert.are.same({ 'fox', 'jumps', 'over' }, r:lines())
|
|
|
|
r:replace(nil)
|
|
assert.are.same({
|
|
'The quick brown',
|
|
'the lazy dog',
|
|
}, vim.api.nvim_buf_get_lines(b, 0, -1, false))
|
|
|
|
r:replace { 'blehGoo2', '' }
|
|
assert.are.same({
|
|
'The quick brown',
|
|
'blehGoo2',
|
|
'the lazy dog',
|
|
}, vim.api.nvim_buf_get_lines(b, 0, -1, false))
|
|
end)
|
|
end)
|
|
|
|
it('can save to extmark', function()
|
|
withbuf({
|
|
'The quick brown',
|
|
'fox',
|
|
'jumps',
|
|
'over',
|
|
'the lazy dog',
|
|
}, function()
|
|
-- Construct a range over 'fox jumps'
|
|
local r = Range.new(Pos.new(nil, 2, 1), Pos.new(nil, 3, 5), 'v')
|
|
local extrange = r:save_to_extmark()
|
|
assert.are.same({ 'fox', 'jumps' }, extrange:range():lines())
|
|
-- change 'jumps' to 'leaps':
|
|
vim.api.nvim_buf_set_text(extrange.bufnr, 2, 0, 2, 4, { 'leap' })
|
|
assert.are.same({
|
|
'The quick brown',
|
|
'fox',
|
|
'leaps',
|
|
'over',
|
|
'the lazy dog',
|
|
}, vim.api.nvim_buf_get_lines(extrange.bufnr, 0, -1, false))
|
|
assert.are.same({ 'fox', 'leaps' }, extrange:range():lines())
|
|
end)
|
|
end)
|
|
|
|
it('can save linewise extmark', function()
|
|
withbuf({
|
|
'The quick brown',
|
|
'fox',
|
|
'jumps',
|
|
'over',
|
|
'the lazy dog',
|
|
}, function()
|
|
-- Construct a range over 'fox jumps'
|
|
local r = Range.new(Pos.new(nil, 2, 1), Pos.new(nil, 3, vim.v.maxcol), 'V')
|
|
local extrange = r:save_to_extmark()
|
|
assert.are.same({ 'fox', 'jumps' }, extrange:range():lines())
|
|
|
|
local extmark = vim.api.nvim_buf_get_extmark_by_id(
|
|
extrange.bufnr,
|
|
vim.api.nvim_create_namespace 'u.range',
|
|
extrange.id,
|
|
{ details = true }
|
|
)
|
|
local row0, col0, details = unpack(extmark)
|
|
assert.are.same({ 1, 0 }, { row0, col0 })
|
|
assert.are.same({ 3, 0 }, { details.end_row, details.end_col })
|
|
end)
|
|
end)
|
|
|
|
it('discerns range bounds from extmarks beyond the end of the buffer', function()
|
|
local function set_tmp_options(bufnr)
|
|
vim.bo[bufnr].bufhidden = 'delete'
|
|
vim.bo[bufnr].buflisted = false
|
|
vim.bo[bufnr].buftype = 'nowrite'
|
|
end
|
|
|
|
vim.cmd.vnew()
|
|
local left_bufnr = vim.api.nvim_get_current_buf()
|
|
set_tmp_options(left_bufnr)
|
|
local left = Range.from_buf_text(left_bufnr)
|
|
vim.cmd.vnew()
|
|
local right_bufnr = vim.api.nvim_get_current_buf()
|
|
set_tmp_options(left_bufnr)
|
|
local right = Range.from_buf_text(right_bufnr)
|
|
|
|
left:replace {
|
|
'one',
|
|
'two',
|
|
'three',
|
|
}
|
|
local left_all_ext = left:save_to_extmark()
|
|
|
|
right:replace {
|
|
'foo',
|
|
'bar',
|
|
}
|
|
|
|
vim.api.nvim_set_current_buf(right_bufnr)
|
|
vim.cmd [[normal! ggyG]]
|
|
vim.api.nvim_set_current_buf(left_bufnr)
|
|
vim.cmd [[normal! ggVGp]]
|
|
|
|
assert.are.same({ 'foo', 'bar' }, left_all_ext:range():lines())
|
|
vim.api.nvim_buf_delete(left_bufnr, { force = true })
|
|
vim.api.nvim_buf_delete(right_bufnr, { force = true })
|
|
end)
|
|
end)
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Additional coverage tests
|
|
--------------------------------------------------------------------------------
|
|
|
|
describe('Pos additional coverage', function()
|
|
it('__tostring', function()
|
|
withbuf({ 'test' }, function()
|
|
local bufnr = vim.api.nvim_get_current_buf()
|
|
local p = Pos.new(bufnr, 1, 1, 0)
|
|
local s = tostring(p)
|
|
assert.is_true(s:find 'Pos%(1:1%)' ~= nil)
|
|
assert.is_true(s:find('bufnr=' .. bufnr) ~= nil)
|
|
|
|
local p2 = Pos.new(bufnr, 1, 1, 5)
|
|
s = tostring(p2)
|
|
assert.is_true(s:find 'Pos%(1:1%)' ~= nil)
|
|
assert.is_true(s:find 'off=5' ~= nil)
|
|
end)
|
|
end)
|
|
|
|
it('from_eol', function()
|
|
withbuf({ 'hello world' }, function()
|
|
local eol = Pos.from_eol(nil, 1)
|
|
assert.are.same(11, eol.col)
|
|
assert.are.same('hello world', eol:line())
|
|
end)
|
|
end)
|
|
|
|
it(':eol', function()
|
|
withbuf({ 'hello world' }, function()
|
|
local p = Pos.new(nil, 1, 1)
|
|
local eol = p:eol()
|
|
assert.are.same(11, eol.col)
|
|
end)
|
|
end)
|
|
|
|
it('save_to_cursor', function()
|
|
withbuf({ 'line one', 'line two' }, function()
|
|
local p = Pos.new(nil, 2, 5)
|
|
p:save_to_cursor()
|
|
assert.are.same({ 2, 4 }, vim.api.nvim_win_get_cursor(0))
|
|
end)
|
|
end)
|
|
|
|
it('save_to_mark', function()
|
|
withbuf({ 'line one', 'line two' }, function()
|
|
local b = vim.api.nvim_get_current_buf()
|
|
local p = Pos.new(b, 2, 5)
|
|
p:save_to_mark 'a'
|
|
local mark = vim.api.nvim_buf_get_mark(b, 'a')
|
|
assert.are.same({ 2, 4 }, mark)
|
|
end)
|
|
end)
|
|
|
|
it('must_next', function()
|
|
withbuf({ 'abc' }, function()
|
|
local p = Pos.new(nil, 1, 1)
|
|
local next = p:must_next(1)
|
|
assert.are.same(Pos.new(nil, 1, 2), next)
|
|
|
|
assert.has.error(
|
|
function() Pos.new(nil, 1, 3):must_next(1) end,
|
|
'error in Pos:next(): Pos:next() returned nil'
|
|
)
|
|
end)
|
|
end)
|
|
|
|
it('next_while', function()
|
|
withbuf({ 'aaabbb' }, function()
|
|
local p = Pos.new(nil, 1, 1)
|
|
local result = p:next_while(1, function(pos) return pos:char() == 'a' end)
|
|
assert.are.same(Pos.new(nil, 1, 3), result)
|
|
|
|
result = p:next_while(1, function(pos) return pos:char() == 'a' end, true)
|
|
assert.are.same(Pos.new(nil, 1, 3), result)
|
|
|
|
result = p:next_while(1, function() return false end, true)
|
|
assert.are.same(nil, result)
|
|
end)
|
|
end)
|
|
|
|
it('insert_before', function()
|
|
withbuf({ 'world' }, function()
|
|
local p = Pos.new(nil, 1, 1)
|
|
p:insert_before 'hello '
|
|
assert.are.same({ 'hello world' }, vim.api.nvim_buf_get_lines(0, 0, -1, false))
|
|
end)
|
|
end)
|
|
|
|
it('is_invalid', function()
|
|
local invalid = Pos.invalid()
|
|
assert.is_true(invalid:is_invalid())
|
|
|
|
withbuf({ 'test' }, function()
|
|
local valid = Pos.new(nil, 1, 1)
|
|
assert.is_false(valid:is_invalid())
|
|
end)
|
|
end)
|
|
|
|
it('__add with number first', function()
|
|
withbuf({ 'abc' }, function()
|
|
local p = Pos.new(nil, 1, 1)
|
|
local result = 1 + p
|
|
assert.are.same(Pos.new(nil, 1, 2), result)
|
|
end)
|
|
end)
|
|
|
|
it('__sub with number first', function()
|
|
withbuf({ 'abc' }, function()
|
|
local p = Pos.new(nil, 1, 2)
|
|
local result = 1 - p
|
|
assert.are.same(Pos.new(nil, 1, 1), result)
|
|
end)
|
|
end)
|
|
|
|
it('find_next returns nil at end', function()
|
|
withbuf({ 'abc' }, function()
|
|
local p = Pos.new(nil, 1, 3)
|
|
local result = p:find_next(1, 'z')
|
|
assert.are.same(nil, result)
|
|
end)
|
|
end)
|
|
|
|
it('find_match with nested brackets', function()
|
|
withbuf({ '(abc)' }, function()
|
|
local p = Pos.new(nil, 1, 1) -- '('
|
|
local match = p:find_match()
|
|
assert.are.same(Pos.new(nil, 1, 5), match) -- ')'
|
|
end)
|
|
|
|
withbuf({ '{abc}' }, function()
|
|
local p = Pos.new(nil, 1, 1) -- '{'
|
|
local match = p:find_match()
|
|
assert.are.same(Pos.new(nil, 1, 5), match) -- '}'
|
|
end)
|
|
|
|
withbuf({ '(a{b}c)' }, function()
|
|
-- Test nested: ( at pos 1, { at pos 3
|
|
local p = Pos.new(nil, 1, 3) -- '{'
|
|
local match = p:find_match()
|
|
assert.are.same(Pos.new(nil, 1, 5), match) -- '}'
|
|
end)
|
|
end)
|
|
|
|
it('from10', function()
|
|
withbuf({ 'test' }, function()
|
|
local p = Pos.from10(nil, 1, 0)
|
|
assert.are.same(1, p.lnum)
|
|
assert.are.same(1, p.col)
|
|
|
|
p = Pos.from10(nil, 2, 5, 10)
|
|
assert.are.same(2, p.lnum)
|
|
assert.are.same(6, p.col)
|
|
assert.are.same(10, p.off)
|
|
end)
|
|
end)
|
|
|
|
it('as_real with col beyond line length', function()
|
|
withbuf({ 'ab' }, function()
|
|
local p = Pos.new(nil, 1, 100)
|
|
local real = p:as_real()
|
|
assert.are.same(2, real.col)
|
|
end)
|
|
end)
|
|
|
|
it('find_next returns nil when not found', function()
|
|
withbuf({ 'abc' }, function()
|
|
local p = Pos.new(nil, 1, 1)
|
|
local result = p:find_next(1, 'z')
|
|
assert.is_nil(result)
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe('Range additional coverage', function()
|
|
it('__eq', function()
|
|
withbuf({ 'test' }, function()
|
|
local r1 = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 4), 'v')
|
|
local r2 = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 4), 'v')
|
|
assert.is_true(r1 == r2)
|
|
|
|
local r3 = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 5), 'v')
|
|
assert.is_false(r1 == r3)
|
|
|
|
local r4 = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 4), 'V')
|
|
assert.is_false(r1 == r4)
|
|
|
|
assert.is_false(r1 == 'not a range')
|
|
assert.is_false(r1 == nil)
|
|
end)
|
|
end)
|
|
|
|
it('__tostring with nil stop', function()
|
|
withbuf({ 'test' }, function()
|
|
local r = Range.new(Pos.new(nil, 1, 1), nil, 'v')
|
|
local s = tostring(r)
|
|
assert.is_true(s:find 'stop=nil' ~= nil)
|
|
end)
|
|
end)
|
|
|
|
it('__tostring with off != 0', function()
|
|
withbuf({ 'test' }, function()
|
|
local r = Range.new(Pos.new(nil, 1, 1, 5), Pos.new(nil, 1, 4, 3), 'v')
|
|
local s = tostring(r)
|
|
assert.is_true(s:find 'off=5' ~= nil)
|
|
end)
|
|
end)
|
|
|
|
it('__tostring', function()
|
|
withbuf({ 'test' }, function()
|
|
local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 4), 'v')
|
|
local s = tostring(r)
|
|
assert.are.same('v', r.mode)
|
|
assert.is_true(s:find 'Range{' == 1)
|
|
end)
|
|
end)
|
|
|
|
it('from_lines with negative stop_line', function()
|
|
withbuf({ 'a', 'b', 'c', 'd', 'e' }, function()
|
|
local r = Range.from_lines(nil, 1, -1)
|
|
assert.are.same(5, r.stop.lnum)
|
|
|
|
r = Range.from_lines(nil, 1, -2)
|
|
assert.are.same(4, r.stop.lnum)
|
|
end)
|
|
end)
|
|
|
|
it('save_to_pos', function()
|
|
withbuf({ 'hello world' }, function()
|
|
local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 5), 'v')
|
|
r:save_to_pos("'[", "']")
|
|
local start = Pos.from_pos "'["
|
|
local stop = Pos.from_pos "']"
|
|
assert.are.same(1, start.col)
|
|
assert.are.same(5, stop.col)
|
|
end)
|
|
end)
|
|
|
|
it('save_to_marks', function()
|
|
withbuf({ 'hello world' }, function()
|
|
local b = vim.api.nvim_get_current_buf()
|
|
local r = Range.new(Pos.new(b, 1, 1), Pos.new(b, 1, 5), 'v')
|
|
r:save_to_marks('m', 'n')
|
|
local m = vim.api.nvim_buf_get_mark(b, 'm')
|
|
local n = vim.api.nvim_buf_get_mark(b, 'n')
|
|
assert.are.same({ 1, 0 }, m)
|
|
assert.are.same({ 1, 4 }, n)
|
|
end)
|
|
end)
|
|
|
|
it('new swaps start and stop when needed', function()
|
|
withbuf({ 'test' }, function()
|
|
local r = Range.new(Pos.new(nil, 1, 4), Pos.new(nil, 1, 1), 'v')
|
|
assert.are.same(1, r.start.col)
|
|
assert.are.same(4, r.stop.col)
|
|
end)
|
|
end)
|
|
|
|
it('from_marks with MAX_COL', function()
|
|
withbuf({ 'test' }, function()
|
|
local start = Pos.new(nil, 1, 1)
|
|
local stop = Pos.new(nil, 1, vim.v.maxcol)
|
|
start:save_to_pos "'["
|
|
stop:save_to_pos "']"
|
|
local r = Range.from_marks("'[", "']")
|
|
assert.are.same('V', r.mode)
|
|
end)
|
|
end)
|
|
|
|
it('contains returns false for non-Pos/Range', function()
|
|
withbuf({ 'test' }, function()
|
|
local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 4), 'v')
|
|
assert.is_false(r:contains 'string')
|
|
assert.is_false(r:contains(123))
|
|
end)
|
|
end)
|
|
|
|
it('sub with invalid stop', function()
|
|
withbuf({ 'abcdef' }, function()
|
|
local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 6), 'v')
|
|
local sub = r:sub(1, 100)
|
|
assert.is_true(sub:is_empty())
|
|
end)
|
|
end)
|
|
|
|
it('line with negative index', function()
|
|
withbuf({ 'a', 'b', 'c' }, function()
|
|
local r = Range.from_lines(nil, 1, 3)
|
|
local l = r:line(-1)
|
|
assert.are.same('c', l:text())
|
|
|
|
l = r:line(-2)
|
|
assert.are.same('b', l:text())
|
|
end)
|
|
end)
|
|
|
|
it('line returns nil for out of bounds', function()
|
|
withbuf({ 'a', 'b' }, function()
|
|
local r = Range.from_lines(nil, 1, 2)
|
|
assert.is_nil(r:line(10))
|
|
end)
|
|
end)
|
|
|
|
it('trim_start returns range with start=stop when all whitespace', function()
|
|
withbuf({ ' ' }, function()
|
|
local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 3), 'v')
|
|
local trimmed = r:trim_start()
|
|
assert.is_not.same(nil, trimmed)
|
|
assert.are.same(trimmed.start, trimmed.stop)
|
|
end)
|
|
end)
|
|
|
|
it('trim_stop returns range with start=stop when all whitespace', function()
|
|
withbuf({ ' ' }, function()
|
|
local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 3), 'v')
|
|
local trimmed = r:trim_stop()
|
|
assert.is_not.same(nil, trimmed)
|
|
assert.are.same(trimmed.start, trimmed.stop)
|
|
end)
|
|
end)
|
|
|
|
it('smallest returns nil for empty input', function()
|
|
assert.are.same(nil, Range.smallest {})
|
|
assert.are.same(nil, Range.smallest { nil })
|
|
end)
|
|
end)
|
|
|
|
describe('Extmark additional coverage', function()
|
|
it('delete', function()
|
|
withbuf({ 'test' }, function()
|
|
local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 4), 'v')
|
|
local ext = r:save_to_extmark()
|
|
ext:delete()
|
|
-- Should not error
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe('Extmark edge cases', function()
|
|
it('tracks multi-byte characters correctly', function()
|
|
withbuf({ '🚀🌟 hello 你好世界' }, function()
|
|
-- The string is 27 bytes: 🚀(4) + 🌟(4) + space(1) + hello(5) + space(1) + 你(3) + 好(3) + 世(3) + 界(3)
|
|
local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 27), 'v')
|
|
local ext = r:save_to_extmark()
|
|
local ext_range = ext:range()
|
|
assert.are.same('🚀🌟 hello 你好世界', ext_range:text())
|
|
end)
|
|
end)
|
|
|
|
it('clamps start position after buffer shrink', function()
|
|
withbuf({ 'line 1', 'line 2', 'line 3', '' }, function()
|
|
local r = Range.from_buf_text()
|
|
local ext = r:save_to_extmark()
|
|
|
|
-- Delete last line
|
|
vim.api.nvim_buf_set_lines(0, 3, 4, true, {})
|
|
|
|
-- Get range from extmark - should clamp to valid buffer
|
|
local ext_range = ext:range()
|
|
assert.is_true(ext_range.stop.lnum <= 3)
|
|
end)
|
|
end)
|
|
|
|
it('handles zero-width extmark (empty range)', function()
|
|
withbuf({ 'hello world' }, function()
|
|
local r = Range.new(Pos.new(nil, 1, 1), nil, 'v')
|
|
local ext = r:save_to_extmark()
|
|
local ext_range = ext:range()
|
|
assert.is_true(ext_range:is_empty())
|
|
end)
|
|
end)
|
|
|
|
it('handles extmark at buffer start', function()
|
|
withbuf({ 'first', 'second', 'third' }, function()
|
|
local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 5), 'v')
|
|
local ext = r:save_to_extmark()
|
|
local ext_range = ext:range()
|
|
assert.are.same(1, ext_range.start.lnum)
|
|
assert.are.same(1, ext_range.start.col)
|
|
end)
|
|
end)
|
|
|
|
it('handles extmark at buffer end', function()
|
|
withbuf({ 'first', 'second', 'third' }, function()
|
|
local r = Range.new(Pos.new(nil, 3, 1), Pos.new(nil, 3, 5), 'v')
|
|
local ext = r:save_to_extmark()
|
|
local ext_range = ext:range()
|
|
assert.are.same(3, ext_range.stop.lnum)
|
|
assert.are.same(5, ext_range.stop.col)
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe('utils', function()
|
|
local u = require 'u'
|
|
|
|
it('create_delegated_cmd_args', function()
|
|
local args = {
|
|
range = 2,
|
|
line1 = 1,
|
|
line2 = 5,
|
|
count = -1,
|
|
reg = '',
|
|
bang = true,
|
|
fargs = { 'arg1', 'arg2' },
|
|
smods = { silent = true },
|
|
}
|
|
local delegated = u.create_delegated_cmd_args(args)
|
|
assert.are.same({ 1, 5 }, delegated.range)
|
|
assert.are.same(nil, delegated.count)
|
|
assert.are.same(nil, delegated.reg)
|
|
assert.are.same(true, delegated.bang)
|
|
assert.are.same({ 'arg1', 'arg2' }, delegated.args)
|
|
|
|
-- Test range = 1
|
|
args = {
|
|
range = 1,
|
|
line1 = 3,
|
|
line2 = 3,
|
|
count = -1,
|
|
reg = '',
|
|
bang = false,
|
|
fargs = {},
|
|
smods = {},
|
|
}
|
|
delegated = u.create_delegated_cmd_args(args)
|
|
assert.are.same({ 3 }, delegated.range)
|
|
|
|
-- Test range = 0 with count
|
|
args = {
|
|
range = 0,
|
|
line1 = 1,
|
|
line2 = 1,
|
|
count = 5,
|
|
reg = '"',
|
|
bang = false,
|
|
fargs = {},
|
|
smods = {},
|
|
}
|
|
delegated = u.create_delegated_cmd_args(args)
|
|
assert.are.same(nil, delegated.range)
|
|
assert.are.same(5, delegated.count)
|
|
assert.are.same('"', delegated.reg)
|
|
end)
|
|
|
|
it('ucmd with string command', function()
|
|
u.ucmd('TestUcmdString', 'echo "test"', {})
|
|
local cmds = vim.api.nvim_get_commands { builtin = false }
|
|
assert.is_not.same(nil, cmds.TestUcmdString)
|
|
vim.api.nvim_del_user_command 'TestUcmdString'
|
|
end)
|
|
|
|
it('ucmd with function command', function()
|
|
local called = false
|
|
u.ucmd('TestUcmdFunc', function(args)
|
|
called = true
|
|
assert.is_not.same(nil, args)
|
|
end, { range = true })
|
|
|
|
local cmds = vim.api.nvim_get_commands { builtin = false }
|
|
assert.is_not.same(nil, cmds.TestUcmdFunc)
|
|
|
|
vim.cmd.TestUcmdFunc()
|
|
assert.is_true(called)
|
|
|
|
vim.api.nvim_del_user_command 'TestUcmdFunc'
|
|
end)
|
|
end)
|
|
|
|
describe('repeat_', function()
|
|
local u = require 'u'
|
|
|
|
it(
|
|
'is_repeating returns false by default',
|
|
function() assert.is_false(u.repeat_.is_repeating()) end
|
|
)
|
|
|
|
it('run_repeatable executes the function', function()
|
|
local called = false
|
|
u.repeat_.run_repeatable(function() called = true end)
|
|
assert.is_true(called)
|
|
end)
|
|
|
|
it('setup creates keymaps', function()
|
|
u.repeat_.setup()
|
|
local maps = vim.api.nvim_get_keymap 'n'
|
|
local dot_map = vim.iter(maps):find(function(m) return m.lhs == '.' end)
|
|
local u_map = vim.iter(maps):find(function(m) return m.lhs == 'u' end)
|
|
assert.is_not.same(nil, dot_map)
|
|
assert.is_not.same(nil, u_map)
|
|
end)
|
|
end)
|
|
|
|
describe('define_txtobj', function()
|
|
local u = require 'u'
|
|
|
|
it('defines text object keymaps', function()
|
|
u.define_txtobj(
|
|
'aX',
|
|
function() return Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 5), 'v') end
|
|
)
|
|
|
|
local xmaps = vim.api.nvim_get_keymap 'x'
|
|
local omaps = vim.api.nvim_get_keymap 'o'
|
|
|
|
local xmap = vim.iter(xmaps):find(function(m) return m.lhs == 'aX' end)
|
|
local omap_found = vim.iter(omaps):find(function(m) return m.lhs == 'aX' end)
|
|
|
|
assert.is_not.same(nil, xmap)
|
|
assert.is_not.same(nil, omap_found)
|
|
end)
|
|
|
|
it('defines buffer-local text object keymaps', function()
|
|
withbuf({ 'test' }, function()
|
|
local bufnr = vim.api.nvim_get_current_buf()
|
|
u.define_txtobj(
|
|
'aY',
|
|
function() return Range.new(Pos.new(bufnr, 1, 1), Pos.new(bufnr, 1, 4), 'v') end,
|
|
{ buffer = bufnr }
|
|
)
|
|
|
|
local xmaps = vim.api.nvim_buf_get_keymap(bufnr, 'x')
|
|
local omaps = vim.api.nvim_buf_get_keymap(bufnr, 'o')
|
|
|
|
local xmap = vim.iter(xmaps):find(function(m) return m.lhs == 'aY' end)
|
|
local omap_found = vim.iter(omaps):find(function(m) return m.lhs == 'aY' end)
|
|
|
|
assert.is_not.same(nil, xmap)
|
|
assert.is_not.same(nil, omap_found)
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe('Range highlight', function()
|
|
it('highlight creates highlight and returns clear function', function()
|
|
withbuf({ 'hello world' }, function()
|
|
local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 5), 'v')
|
|
local hl = r:highlight('Search', { timeout = 100 })
|
|
assert.is_not.same(nil, hl)
|
|
assert.is_not.same(nil, hl.ns)
|
|
assert.is_not.same(nil, hl.clear)
|
|
hl.clear()
|
|
end)
|
|
end)
|
|
|
|
it('highlight returns nil for empty range', function()
|
|
withbuf({ 'test' }, function()
|
|
local r = Range.new(Pos.new(nil, 1, 1), nil, 'v')
|
|
local hl = r:highlight 'Search'
|
|
assert.is.equal(hl.ns, 0)
|
|
end)
|
|
end)
|
|
|
|
it('highlight with priority option', function()
|
|
withbuf({ 'hello world' }, function()
|
|
local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 5), 'v')
|
|
local hl = r:highlight('Search', { priority = 100 })
|
|
assert.is_not.same(nil, hl)
|
|
hl.clear()
|
|
end)
|
|
end)
|
|
end)
|