Jonathan Apodaca
9f5fdb4f2b
All checks were successful
NeoVim tests / plenary-tests (push) Successful in 9s
584 lines
19 KiB
Lua
584 lines
19 KiB
Lua
local Range = require 'u.range'
|
|
local Pos = require 'u.pos'
|
|
local withbuf = loadfile './spec/withbuf.lua'()
|
|
|
|
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, Pos.MAX_COL), '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, Pos.MAX_COL), '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('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, Pos.MAX_COL))
|
|
assert.are.same(range.mode, 'V')
|
|
end)
|
|
end)
|
|
|
|
it('from_cmd_args', function()
|
|
local args = { range = 1 }
|
|
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_cmd_args(args)
|
|
assert.are.same(range.start, a)
|
|
assert.are.same(range.stop, b)
|
|
assert.are.same(range.mode, 'v')
|
|
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, Pos.MAX_COL)
|
|
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('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, Pos.MAX_COL), '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, Pos.MAX_COL), '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)
|
|
end)
|