Something went wrong. Try again.
Library of 45+ independent Lua modules improving Neovim experience with minimal effort nvim-mini.org/mini.nvim
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586local helpers = dofile('tests/helpers.lua')
local child = helpers.new_child_neovim()local expect, eq = helpers.expect, helpers.expect.equalitylocal new_set = MiniTest.new_set
-- Helpers with child processeslocal load_module = function(config) child.mini_load('move', config) endlocal unload_module = function() child.mini_unload('move') endlocal reload_module = function(config) child.mini_reload('move', config) endlocal set_cursor = function(...) return child.set_cursor(...) endlocal get_cursor = function(...) return child.get_cursor(...) endlocal set_lines = function(...) return child.set_lines(...) endlocal get_lines = function(...) return child.get_lines(...) endlocal type_keys = function(...) return child.type_keys(...) end
local get_fold_range = function(line_num) return { child.fn.foldclosed(line_num), child.fn.foldclosedend(line_num) } end
local setup_registers = function() local reginfo_arr = { { reg = '0', info = { regcontents = { '0', '0', '0' }, regtype = '\0221' } }, { reg = '1', info = { regcontents = { '111', '111' }, regtype = 'V' } }, { reg = '2', info = { regcontents = { '222', '222' }, regtype = 'V' } }, { reg = '9', info = { regcontents = { '999', '999' }, regtype = 'V' } }, { reg = '-', info = { regcontents = { '---' }, regtype = 'v' } }, { reg = 'z', info = { regcontents = { 'zzz' }, regtype = 'v' } }, { reg = '"', info = { points_to = 'z' } }, } local ref = {} for _, data in ipairs(reginfo_arr) do child.fn.setreg(data.reg, data.info) ref[data.reg] = child.fn.getreginfo(data.reg) end -- Make sure that 'z' register has proper `isunnamed` field ref['z'] = child.fn.getreginfo('z')
return refend
local validate_state = function(lines, selection) eq(get_lines(), lines) eq({ { child.fn.line('v'), child.fn.col('v') }, { child.fn.line('.'), child.fn.col('.') } }, selection)end
local validate_state1d = function(line, range) validate_state({ line }, { { 1, range[1] }, { 1, range[2] } }) end
local validate_line_state = function(lines, cursor) eq(get_lines(), lines) eq(get_cursor(), cursor)end
-- Output test set ============================================================local T = new_set({ hooks = { pre_case = function() child.setup() load_module() end, post_once = child.stop, }, n_retry = helpers.get_n_retry(1),})
-- Unit tests =================================================================T['setup()'] = new_set()
T['setup()']['creates side effects'] = function() -- Global variable eq(child.lua_get('type(_G.MiniMove)'), 'table')end
T['setup()']['creates `config` field'] = function() eq(child.lua_get('type(_G.MiniMove.config)'), 'table')
-- Check default values local expect_config = function(field, value) eq(child.lua_get('MiniMove.config.' .. field), value) end
-- Check default values expect_config('mappings.left', '<M-h>') expect_config('mappings.right', '<M-l>') expect_config('mappings.down', '<M-j>') expect_config('mappings.up', '<M-k>') expect_config('mappings.line_left', '<M-h>') expect_config('mappings.line_right', '<M-l>') expect_config('mappings.line_down', '<M-j>') expect_config('mappings.line_up', '<M-k>') expect_config('options.reindent_linewise', true)end
T['setup()']['respects `config` argument'] = function() reload_module({ make_global = { 'put' } }) eq(child.lua_get('MiniMove.config.make_global'), { 'put' })end
T['setup()']['validates `config` argument'] = function() unload_module()
local expect_config_error = function(config, name, target_type) expect.error(function() load_module(config) end, vim.pesc(name) .. '.*' .. vim.pesc(target_type)) end
expect_config_error('a', 'config', 'table') expect_config_error({ mappings = 'a' }, 'mappings', 'table') expect_config_error({ mappings = { left = 1 } }, 'mappings.left', 'string') expect_config_error({ mappings = { down = 1 } }, 'mappings.down', 'string') expect_config_error({ mappings = { up = 1 } }, 'mappings.up', 'string') expect_config_error({ mappings = { right = 1 } }, 'mappings.right', 'string') expect_config_error({ mappings = { line_left = 1 } }, 'mappings.line_left', 'string') expect_config_error({ mappings = { line_right = 1 } }, 'mappings.line_right', 'string') expect_config_error({ mappings = { line_down = 1 } }, 'mappings.line_down', 'string') expect_config_error({ mappings = { line_up = 1 } }, 'mappings.line_up', 'string') expect_config_error({ options = 'a' }, 'options', 'table') expect_config_error({ options = { reindent_linewise = 1 } }, 'options.reindent_linewise', 'boolean')end
T['setup()']['properly handles `config.mappings`'] = function() local has_map = function(lhs, pattern) return child.cmd_capture('xmap ' .. lhs):find(pattern) ~= nil end eq(has_map('<M-h>', 'MiniMove'), true)
unload_module() child.api.nvim_del_keymap('x', '<M-h>')
-- Supplying empty string should mean "don't create keymap" load_module({ mappings = { left = '' } }) eq(has_map('<M-h>', 'MiniMove'), false)end
T['move_selection()'] = new_set()
local move = function(direction, opts) child.lua('MiniMove.move_selection(...)', { direction, opts }) end
T['move_selection()']['works charwise horizontally'] = function() -- Test for this many moves because there can be special cases when movement -- involves second or second to last character set_lines({ 'XXabcd' }) set_cursor(1, 0) type_keys('vl') validate_state1d('XXabcd', { 1, 2 })
move('right') validate_state1d('aXXbcd', { 2, 3 }) move('right') validate_state1d('abXXcd', { 3, 4 }) move('right') validate_state1d('abcXXd', { 4, 5 }) move('right') validate_state1d('abcdXX', { 5, 6 }) -- Should allow to try to move past line end without error move('right') validate_state1d('abcdXX', { 5, 6 })
move('left') validate_state1d('abcXXd', { 4, 5 }) move('left') validate_state1d('abXXcd', { 3, 4 }) move('left') validate_state1d('aXXbcd', { 2, 3 }) move('left') validate_state1d('XXabcd', { 1, 2 }) -- Should allow to try to move past line start without error move('left') validate_state1d('XXabcd', { 1, 2 })end
T['move_selection()']['respects `opts.n_times` charwise horizontally'] = function() set_lines({ 'XXabcd' }) set_cursor(1, 0) type_keys('vl') validate_state1d('XXabcd', { 1, 2 })
move('right', { n_times = 3 }) validate_state1d('abcXXd', { 4, 5 }) move('left', { n_times = 2 }) validate_state1d('aXXbcd', { 2, 3 })end
T['move_selection()']['works charwise vertically'] = function() set_lines({ '1XXx', '2a', '3b', '4c', '5d' }) set_cursor(1, 1) type_keys('vl') validate_state({ '1XXx', '2a', '3b', '4c', '5d' }, { { 1, 2 }, { 1, 3 } })
move('down') validate_state({ '1x', '2XXa', '3b', '4c', '5d' }, { { 2, 2 }, { 2, 3 } }) move('down') validate_state({ '1x', '2a', '3XXb', '4c', '5d' }, { { 3, 2 }, { 3, 3 } }) move('down') validate_state({ '1x', '2a', '3b', '4XXc', '5d' }, { { 4, 2 }, { 4, 3 } }) move('down') validate_state({ '1x', '2a', '3b', '4c', '5XXd' }, { { 5, 2 }, { 5, 3 } }) -- Should allow to try to move past last line without error move('down') validate_state({ '1x', '2a', '3b', '4c', '5XXd' }, { { 5, 2 }, { 5, 3 } })
move('up') validate_state({ '1x', '2a', '3b', '4XXc', '5d' }, { { 4, 2 }, { 4, 3 } }) move('up') validate_state({ '1x', '2a', '3XXb', '4c', '5d' }, { { 3, 2 }, { 3, 3 } }) move('up') validate_state({ '1x', '2XXa', '3b', '4c', '5d' }, { { 2, 2 }, { 2, 3 } }) move('up') validate_state({ '1XXx', '2a', '3b', '4c', '5d' }, { { 1, 2 }, { 1, 3 } }) -- Should allow to try to move past first line without error move('up') validate_state({ '1XXx', '2a', '3b', '4c', '5d' }, { { 1, 2 }, { 1, 3 } })end
T['move_selection()']['respects `opts.n_times` charwise vertically'] = function() set_lines({ '1XXx', '2a', '3b', '4c', '5d' }) set_cursor(1, 1) type_keys('vl') validate_state({ '1XXx', '2a', '3b', '4c', '5d' }, { { 1, 2 }, { 1, 3 } })
move('down', { n_times = 3 }) validate_state({ '1x', '2a', '3b', '4XXc', '5d' }, { { 4, 2 }, { 4, 3 } }) move('up', { n_times = 2 }) validate_state({ '1x', '2XXa', '3b', '4c', '5d' }, { { 2, 2 }, { 2, 3 } })end
T['move_selection()']['works with folds charwise'] = function() local setup_folds = function() child.ensure_normal_mode() set_lines({ '1XX', '2aa', '3bb', '4cc', '5YY' })
-- Create fold type_keys('zE') set_cursor(2, 0) type_keys('zf', '2j') end
-- Down setup_folds() set_cursor(1, 1) type_keys('vl') validate_state({ '1XX', '2aa', '3bb', '4cc', '5YY' }, { { 1, 2 }, { 1, 3 } }) eq(get_fold_range(2), { 2, 4 })
-- - When moving "into fold", it should open it move('down') validate_state({ '1', '2XXaa', '3bb', '4cc', '5YY' }, { { 2, 2 }, { 2, 3 } }) eq(get_fold_range(2), { -1, -1 })
-- Up setup_folds() set_cursor(5, 1) type_keys('vl') validate_state({ '1XX', '2aa', '3bb', '4cc', '5YY' }, { { 5, 2 }, { 5, 3 } }) eq(get_fold_range(2), { 2, 4 })
-- - When moving "into fold", it should open it. But it happens only after -- entering fold, so cursor is at the start of fold. Would be nice to -- change so that fold is opened before movement, but it requires some -- extra non-trivial steps. move('up') validate_state({ '1XX', '2YYaa', '3bb', '4cc', '5' }, { { 2, 2 }, { 2, 3 } }) eq(get_fold_range(2), { -1, -1 })end
T['move_selection()']['works charwise vertically on line start/end'] = function() -- Line start set_lines({ 'XXx', 'a', 'b' }) set_cursor(1, 0) type_keys('vl') validate_state({ 'XXx', 'a', 'b' }, { { 1, 1 }, { 1, 2 } })
move('down') validate_state({ 'x', 'XXa', 'b' }, { { 2, 1 }, { 2, 2 } }) move('down') validate_state({ 'x', 'a', 'XXb' }, { { 3, 1 }, { 3, 2 } }) move('up') validate_state({ 'x', 'XXa', 'b' }, { { 2, 1 }, { 2, 2 } }) move('up') validate_state({ 'XXx', 'a', 'b' }, { { 1, 1 }, { 1, 2 } })
child.ensure_normal_mode()
-- Line end set_lines({ 'xXX', 'a', 'b' }) set_cursor(1, 1) type_keys('vl') validate_state({ 'xXX', 'a', 'b' }, { { 1, 2 }, { 1, 3 } })
move('down') validate_state({ 'x', 'aXX', 'b' }, { { 2, 2 }, { 2, 3 } }) move('down') validate_state({ 'x', 'a', 'bXX' }, { { 3, 2 }, { 3, 3 } }) move('up') validate_state({ 'x', 'aXX', 'b' }, { { 2, 2 }, { 2, 3 } }) move('up') validate_state({ 'xXX', 'a', 'b' }, { { 1, 2 }, { 1, 3 } })
child.ensure_normal_mode()
-- Whole line (but in charwise mode) set_lines({ 'XX', '', '' }) set_cursor(1, 0) type_keys('vl') validate_state({ 'XX', '', '' }, { { 1, 1 }, { 1, 2 } })
move('down') validate_state({ '', 'XX', '' }, { { 2, 1 }, { 2, 2 } }) move('down') validate_state({ '', '', 'XX' }, { { 3, 1 }, { 3, 2 } }) move('up') validate_state({ '', 'XX', '' }, { { 2, 1 }, { 2, 2 } }) move('up') validate_state({ 'XX', '', '' }, { { 1, 1 }, { 1, 2 } })end
T['move_selection()']['works blockwise horizontally'] = function() set_lines({ 'XXabcd', 'XXabcd' }) set_cursor(1, 0) type_keys('<C-v>', 'lj') validate_state({ 'XXabcd', 'XXabcd' }, { { 1, 1 }, { 2, 2 } })
move('right') validate_state({ 'aXXbcd', 'aXXbcd' }, { { 1, 2 }, { 2, 3 } }) move('right') validate_state({ 'abXXcd', 'abXXcd' }, { { 1, 3 }, { 2, 4 } }) move('right') validate_state({ 'abcXXd', 'abcXXd' }, { { 1, 4 }, { 2, 5 } }) move('right') validate_state({ 'abcdXX', 'abcdXX' }, { { 1, 5 }, { 2, 6 } }) -- Should allow to try to move past line end without error move('right') validate_state({ 'abcdXX', 'abcdXX' }, { { 1, 5 }, { 2, 6 } })
move('left') validate_state({ 'abcXXd', 'abcXXd' }, { { 1, 4 }, { 2, 5 } }) move('left') validate_state({ 'abXXcd', 'abXXcd' }, { { 1, 3 }, { 2, 4 } }) move('left') validate_state({ 'aXXbcd', 'aXXbcd' }, { { 1, 2 }, { 2, 3 } }) move('left') validate_state({ 'XXabcd', 'XXabcd' }, { { 1, 1 }, { 2, 2 } }) -- Should allow to try to move past line start without error move('left') validate_state({ 'XXabcd', 'XXabcd' }, { { 1, 1 }, { 2, 2 } })end
T['move_selection()']['respects `opts.n_times` blockwise horizontally'] = function() set_lines({ 'XXabcd', 'XXabcd' }) set_cursor(1, 0) type_keys('<C-v>', 'lj') validate_state({ 'XXabcd', 'XXabcd' }, { { 1, 1 }, { 2, 2 } })
move('right', { n_times = 3 }) validate_state({ 'abcXXd', 'abcXXd' }, { { 1, 4 }, { 2, 5 } }) move('left', { n_times = 2 }) validate_state({ 'aXXbcd', 'aXXbcd' }, { { 1, 2 }, { 2, 3 } })end
T['move_selection()']['works blockwise vertically'] = function() set_lines({ '1XXa', '2YYb', '3c', '4d', '5e' }) set_cursor(1, 1) type_keys('<C-v>', 'lj') validate_state({ '1XXa', '2YYb', '3c', '4d', '5e' }, { { 1, 2 }, { 2, 3 } })
move('down') validate_state({ '1a', '2XXb', '3YYc', '4d', '5e' }, { { 2, 2 }, { 3, 3 } }) move('down') validate_state({ '1a', '2b', '3XXc', '4YYd', '5e' }, { { 3, 2 }, { 4, 3 } }) move('down') validate_state({ '1a', '2b', '3c', '4XXd', '5YYe' }, { { 4, 2 }, { 5, 3 } }) -- Should allow to try to move past last line without error and not -- going outside of buffer lines move('down') validate_state({ '1a', '2b', '3c', '4XXd', '5YYe' }, { { 4, 2 }, { 5, 3 } })
move('up') validate_state({ '1a', '2b', '3XXc', '4YYd', '5e' }, { { 3, 2 }, { 4, 3 } }) move('up') validate_state({ '1a', '2XXb', '3YYc', '4d', '5e' }, { { 2, 2 }, { 3, 3 } }) move('up') validate_state({ '1XXa', '2YYb', '3c', '4d', '5e' }, { { 1, 2 }, { 2, 3 } }) -- Should allow to try to move past first line without error move('up') validate_state({ '1XXa', '2YYb', '3c', '4d', '5e' }, { { 1, 2 }, { 2, 3 } })end
T['move_selection()']['respects `opts.n_times` blockwise vertically'] = function() set_lines({ '1XXa', '2YYb', '3c', '4d', '5e' }) set_cursor(1, 1) type_keys('<C-v>', 'lj') validate_state({ '1XXa', '2YYb', '3c', '4d', '5e' }, { { 1, 2 }, { 2, 3 } })
move('down', { n_times = 3 }) validate_state({ '1a', '2b', '3c', '4XXd', '5YYe' }, { { 4, 2 }, { 5, 3 } }) move('up', { n_times = 2 }) validate_state({ '1a', '2XXb', '3YYc', '4d', '5e' }, { { 2, 2 }, { 3, 3 } })end
T['move_selection()']['works with folds blockwise'] = function() local setup_folds = function() child.ensure_normal_mode() set_lines({ '1XX', '2YY', '3aa', '4bb', '5cc', '6XX', '7YY' })
-- Create fold type_keys('zE') set_cursor(3, 0) type_keys('zf', '2j') end
-- Down setup_folds() set_cursor(1, 1) type_keys('<C-v>', 'jl') validate_state({ '1XX', '2YY', '3aa', '4bb', '5cc', '6XX', '7YY' }, { { 1, 2 }, { 2, 3 } }) eq(get_fold_range(3), { 3, 5 })
-- - When moving "into fold", it should open it, but this is determined by -- top-left corner of selection. So in this case whole fold is selected. move('down') validate_state({ '1', '2XX', '3YYaa', '4bb', '5cc', '6XX', '7YY' }, { { 2, 2 }, { 5, 4 } }) eq(get_fold_range(3), { 3, 5 })
-- Up setup_folds() set_cursor(6, 1) type_keys('<C-v>', 'jl') validate_state({ '1XX', '2YY', '3aa', '4bb', '5cc', '6XX', '7YY' }, { { 6, 2 }, { 7, 3 } }) eq(get_fold_range(3), { 3, 5 })
-- - When moving "into fold", it should open it. But it happens only after -- entering fold, so cursor is at the start of fold. Would be nice to -- change so that fold is opened before movement, but it requires some -- extra non-trivial steps. move('up') validate_state({ '1XX', '2YY', '3XXaa', '4YYbb', '5cc', '6', '7' }, { { 3, 2 }, { 4, 3 } }) eq(get_fold_range(2), { -1, -1 })end
T['move_selection()']['works linewise horizontally'] = function() -- Should be the same as indent (`>`) and dedent (`<`) set_lines({ 'aa', ' bb' }) set_cursor(1, 0) type_keys('Vj') validate_state({ 'aa', ' bb' }, { { 1, 1 }, { 2, 1 } })
-- Should also move cursor along selection move('right') validate_state({ '\taa', '\t bb' }, { { 1, 1 }, { 2, 2 } }) move('right') validate_state({ '\t\taa', '\t\t bb' }, { { 1, 1 }, { 2, 3 } })
move('left') validate_state({ '\taa', '\t bb' }, { { 1, 1 }, { 2, 2 } }) move('left') validate_state({ 'aa', ' bb' }, { { 1, 1 }, { 2, 1 } }) move('left') validate_state({ 'aa', 'bb' }, { { 1, 1 }, { 2, 1 } }) -- Should allow to try impossible dedent without error move('left') validate_state({ 'aa', 'bb' }, { { 1, 1 }, { 2, 1 } })end
T['move_selection()']['respects `opts.n_times` linewise horizontally'] = function() set_lines({ 'aa', ' bb' }) set_cursor(1, 0) type_keys('Vj') validate_state({ 'aa', ' bb' }, { { 1, 1 }, { 2, 1 } })
move('right', { n_times = 3 }) validate_state({ '\t\t\taa', '\t\t\t bb' }, { { 1, 1 }, { 2, 4 } }) move('left', { n_times = 2 }) validate_state({ '\taa', '\t bb' }, { { 1, 1 }, { 2, 2 } })end
T['move_selection()']['linewise horizontally moves cursor along selection in edge cases'] = function() -- Empty line set_lines({ 'aa', '' }) set_cursor(1, 0) type_keys('Vj') validate_state({ 'aa', '' }, { { 1, 1 }, { 2, 1 } })
move('right') validate_state({ '\taa', '' }, { { 1, 1 }, { 2, 1 } }) move('left') validate_state({ 'aa', '' }, { { 1, 1 }, { 2, 1 } })
child.ensure_normal_mode()
-- Past line end with default 'virtualedit' set_lines({ 'aa', 'bb' }) set_cursor(1, 0) type_keys('Vj$') validate_state({ 'aa', 'bb' }, { { 1, 1 }, { 2, 3 } })
move('right') validate_state({ '\taa', '\tbb' }, { { 1, 1 }, { 2, 4 } }) move('left') validate_state({ 'aa', 'bb' }, { { 1, 1 }, { 2, 3 } })
child.ensure_normal_mode()
-- Extreme past line end with non-default 'virtualedit' child.o.virtualedit = 'all' set_lines({ 'aa', 'bb' }) set_cursor(1, 0) type_keys('Vj10l') validate_state({ 'aa', 'bb' }, { { 1, 1 }, { 2, 3 } }) eq(child.fn.getcurpos(), { 0, 2, 3, 8, 11 })
move('right') validate_state({ '\taa', '\tbb' }, { { 1, 1 }, { 2, 4 } }) eq(child.fn.getcurpos(), { 0, 2, 4, 8, 12 })end
T['move_selection()']['works linewise vertically'] = function() set_lines({ 'XX', 'YY', 'aa', 'bb', 'cc' }) set_cursor(1, 0) type_keys('Vjl') validate_state({ 'XX', 'YY', 'aa', 'bb', 'cc' }, { { 1, 1 }, { 2, 2 } })
-- Should also preserve cursor column move('down') validate_state({ 'aa', 'XX', 'YY', 'bb', 'cc' }, { { 2, 1 }, { 3, 2 } }) move('down') validate_state({ 'aa', 'bb', 'XX', 'YY', 'cc' }, { { 3, 1 }, { 4, 2 } }) move('down') validate_state({ 'aa', 'bb', 'cc', 'XX', 'YY' }, { { 4, 1 }, { 5, 2 } }) -- Should allow to try to move past last line without error move('down') validate_state({ 'aa', 'bb', 'cc', 'XX', 'YY' }, { { 4, 1 }, { 5, 2 } })
move('up') validate_state({ 'aa', 'bb', 'XX', 'YY', 'cc' }, { { 3, 1 }, { 4, 2 } }) move('up') validate_state({ 'aa', 'XX', 'YY', 'bb', 'cc' }, { { 2, 1 }, { 3, 2 } }) move('up') validate_state({ 'XX', 'YY', 'aa', 'bb', 'cc' }, { { 1, 1 }, { 2, 2 } }) -- Should allow to try to move past first line without error move('up') validate_state({ 'XX', 'YY', 'aa', 'bb', 'cc' }, { { 1, 1 }, { 2, 2 } })end
T['move_selection()']['respects `opts.n_times` linewise vertically'] = function() set_lines({ 'XX', 'YY', 'aa', 'bb', 'cc' }) set_cursor(1, 0) type_keys('Vjl') validate_state({ 'XX', 'YY', 'aa', 'bb', 'cc' }, { { 1, 1 }, { 2, 2 } })
move('down', { n_times = 3 }) validate_state({ 'aa', 'bb', 'cc', 'XX', 'YY' }, { { 4, 1 }, { 5, 2 } }) move('up', { n_times = 2 }) validate_state({ 'aa', 'XX', 'YY', 'bb', 'cc' }, { { 2, 1 }, { 3, 2 } })end
T['move_selection()']['works with folds linewise'] = function() local setup_folds = function() child.ensure_normal_mode() set_lines({ '1XX', '2YY', '3aa', '4bb', '5cc', '6XX', '7YY' })
-- Create fold type_keys('zE') set_cursor(3, 0) type_keys('zf', '2j') end
-- Down setup_folds() set_cursor(1, 0) type_keys('Vj') validate_state({ '1XX', '2YY', '3aa', '4bb', '5cc', '6XX', '7YY' }, { { 1, 1 }, { 2, 1 } }) eq(get_fold_range(3), { 3, 5 })
-- - Folds should be moved altogether move('down') validate_state({ '3aa', '4bb', '5cc', '1XX', '2YY', '6XX', '7YY' }, { { 4, 1 }, { 5, 1 } }) eq(get_fold_range(3), { 1, 3 })
-- Up setup_folds() set_cursor(6, 0) type_keys('Vj') validate_state({ '1XX', '2YY', '3aa', '4bb', '5cc', '6XX', '7YY' }, { { 6, 1 }, { 7, 1 } }) eq(get_fold_range(3), { 3, 5 })
-- - Folds should be moved altogether move('up') validate_state({ '1XX', '2YY', '6XX', '7YY', '3aa', '4bb', '5cc' }, { { 3, 1 }, { 4, 1 } }) eq(get_fold_range(5), { 5, 7 })end
--stylua: ignoreT['move_selection()']['reindents linewise vertically'] = function() set_lines({ 'XX', 'YY', 'aa', '\tbb', '\t\tcc', '\tdd', 'ee' }) set_cursor(1, 0) type_keys('Vjl') validate_state({ 'XX', 'YY', 'aa', '\tbb', '\t\tcc', '\tdd', 'ee' }, { { 1, 1 }, { 2, 2 } })
-- Should also move cursor along selection move('down') validate_state({ 'aa', 'XX', 'YY', '\tbb', '\t\tcc', '\tdd', 'ee' }, { { 2, 1 }, { 3, 2 } }) move('down') validate_state({ 'aa', '\tbb', '\tXX', '\tYY', '\t\tcc', '\tdd', 'ee' }, { { 3, 1 }, { 4, 3 } }) move('down') validate_state({ 'aa', '\tbb', '\t\tcc', '\t\tXX', '\t\tYY', '\tdd', 'ee' }, { { 4, 1 }, { 5, 4 } }) move('down') validate_state({ 'aa', '\tbb', '\t\tcc', '\tdd', '\tXX', '\tYY', 'ee' }, { { 5, 1 }, { 6, 3 } }) move('down') validate_state({ 'aa', '\tbb', '\t\tcc', '\tdd', 'ee', 'XX', 'YY' }, { { 6, 1 }, { 7, 2 } })end
T['move_selection()']['respects `opts.reindent_linewise`'] = function() set_lines({ 'XX', '\taa' }) set_cursor(1, 0) type_keys('V') validate_state({ 'XX', '\taa' }, { { 1, 1 }, { 1, 1 } })
-- `false` as argument move('down', { reindent_linewise = false }) validate_state({ '\taa', 'XX' }, { { 2, 1 }, { 2, 1 } })
-- `true` as argument move('up') validate_state({ 'XX', '\taa' }, { { 1, 1 }, { 1, 1 } }) move('down', { reindent_linewise = true }) validate_state({ '\taa', '\tXX' }, { { 2, 1 }, { 2, 2 } })
-- `false` as global move('up') validate_state({ 'XX', '\taa' }, { { 1, 1 }, { 1, 1 } })
child.lua('MiniMove.config.options.reindent_linewise = false') move('down') validate_state({ '\taa', 'XX' }, { { 2, 1 }, { 2, 1 } })end
T['move_selection()']['linewise vertically moves cursor along selection in edge cases'] = function() -- Empty line set_lines({ 'aa', '', 'bb' }) set_cursor(1, 0) type_keys('Vj') validate_state({ 'aa', '', 'bb' }, { { 1, 1 }, { 2, 1 } })
move('down') validate_state({ 'bb', 'aa', '' }, { { 2, 1 }, { 3, 1 } })
child.ensure_normal_mode()
-- Past line end with default 'virtualedit' set_lines({ 'aa', 'bb' }) set_cursor(1, 0) type_keys('V$') validate_state({ 'aa', 'bb' }, { { 1, 1 }, { 1, 3 } })
move('down') validate_state({ 'bb', 'aa' }, { { 2, 1 }, { 2, 3 } })
child.ensure_normal_mode()
-- Extreme past line end non-default 'virtualedit' child.o.virtualedit = 'all' set_lines({ 'aa', 'bb' }) set_cursor(1, 0) type_keys('V10l') validate_state({ 'aa', 'bb' }, { { 1, 1 }, { 1, 3 } }) eq(child.fn.getcurpos(), { 0, 1, 3, 8, 11 })
move('down') validate_state({ 'bb', 'aa' }, { { 2, 1 }, { 2, 3 } }) eq(child.fn.getcurpos(), { 0, 2, 3, 8, 11 })end
T['move_selection()']['linewise vertically respects cursor side of selection'] = function() set_lines({ 'aa', 'bb', 'cc' }) set_cursor(2, 0) type_keys('Vkl') validate_state({ 'aa', 'bb', 'cc' }, { { 2, 1 }, { 1, 2 } })
-- It should put cursor at top line of selection, as it is initially move('down') validate_state({ 'cc', 'aa', 'bb' }, { { 3, 1 }, { 2, 2 } })end
T['move_selection()']['moves cursor respecting initial `curswant`'] = function() set_lines({ 'aaX', 'aa', 'a', '', 'a', 'aa', 'aa' }) set_cursor(1, 2) type_keys('v') validate_state({ 'aaX', 'aa', 'a', '', 'a', 'aa', 'aa' }, { { 1, 3 }, { 1, 3 } })
move('down') validate_state({ 'aa', 'aaX', 'a', '', 'a', 'aa', 'aa' }, { { 2, 3 }, { 2, 3 } }) move('down') validate_state({ 'aa', 'aa', 'aX', '', 'a', 'aa', 'aa' }, { { 3, 2 }, { 3, 2 } }) move('down') validate_state({ 'aa', 'aa', 'a', 'X', 'a', 'aa', 'aa' }, { { 4, 1 }, { 4, 1 } }) move('down') validate_state({ 'aa', 'aa', 'a', '', 'aX', 'aa', 'aa' }, { { 5, 2 }, { 5, 2 } }) move('down') validate_state({ 'aa', 'aa', 'a', '', 'a', 'aaX', 'aa' }, { { 6, 3 }, { 6, 3 } }) move('down') validate_state({ 'aa', 'aa', 'a', '', 'a', 'aa', 'aaX' }, { { 7, 3 }, { 7, 3 } })
move('up') validate_state({ 'aa', 'aa', 'a', '', 'a', 'aaX', 'aa' }, { { 6, 3 }, { 6, 3 } }) move('up') validate_state({ 'aa', 'aa', 'a', '', 'aX', 'aa', 'aa' }, { { 5, 2 }, { 5, 2 } }) move('up') validate_state({ 'aa', 'aa', 'a', 'X', 'a', 'aa', 'aa' }, { { 4, 1 }, { 4, 1 } }) move('up') validate_state({ 'aa', 'aa', 'aX', '', 'a', 'aa', 'aa' }, { { 3, 2 }, { 3, 2 } }) move('up') validate_state({ 'aa', 'aaX', 'a', '', 'a', 'aa', 'aa' }, { { 2, 3 }, { 2, 3 } }) move('up') validate_state({ 'aaX', 'aa', 'a', '', 'a', 'aa', 'aa' }, { { 1, 3 }, { 1, 3 } })
-- Single horizontal move should reset `curswant` move('down') validate_state({ 'aa', 'aaX', 'a', '', 'a', 'aa', 'aa' }, { { 2, 3 }, { 2, 3 } }) move('left') validate_state({ 'aa', 'aXa', 'a', '', 'a', 'aa', 'aa' }, { { 2, 2 }, { 2, 2 } }) move('up') validate_state({ 'aXa', 'aa', 'a', '', 'a', 'aa', 'aa' }, { { 1, 2 }, { 1, 2 } })end
T['move_selection()']['computes `curswant` based on left side'] = function() set_lines({ 'aaXXa', '', 'aaaaa' }) set_cursor(1, 2) type_keys('vl') validate_state({ 'aaXXa', '', 'aaaaa' }, { { 1, 3 }, { 1, 4 } })
move('down') validate_state({ 'aaa', 'XX', 'aaaaa' }, { { 2, 1 }, { 2, 2 } }) move('down') validate_state({ 'aaa', '', 'aaXXaaa' }, { { 3, 3 }, { 3, 4 } })end
T['move_selection()']['updates `curswant` when moving horizontally'] = function() -- Charwise set_lines({ 'abXcd', 'efgh' }) set_cursor(1, 2) type_keys('v') validate_state({ 'abXcd', 'efgh' }, { { 1, 3 }, { 1, 3 } })
move('right') validate_state({ 'abcXd', 'efgh' }, { { 1, 4 }, { 1, 4 } }) move('down') validate_state({ 'abcd', 'efgXh' }, { { 2, 4 }, { 2, 4 } }) move('left') validate_state({ 'abcd', 'efXgh' }, { { 2, 3 }, { 2, 3 } }) move('up') validate_state({ 'abXcd', 'efgh' }, { { 1, 3 }, { 1, 3 } })end
T['move_selection()']['works with multibyte characters'] = function() set_lines({ 'ыыXXы', '', 'ыыыыы' }) set_cursor(1, 4) type_keys('vl') validate_state({ 'ыыXXы', '', 'ыыыыы' }, { { 1, 5 }, { 1, 6 } })
move('down') validate_state({ 'ыыы', 'XX', 'ыыыыы' }, { { 2, 1 }, { 2, 2 } }) move('down') validate_state({ 'ыыы', '', 'ыыXXыыы' }, { { 3, 5 }, { 3, 6 } })end
T['move_selection()']['works in small buffers'] = function() local validate = function(line_before, vis_mode, direction, line_after) child.ensure_normal_mode() set_lines({ line_before }) set_cursor(1, 1) type_keys(vis_mode) move(direction) eq(get_lines(), { line_after or line_before }) end
-- Should do nothing in empty buffer for _, vis_mode in ipairs({ 'v', 'V', '<C-v>' }) do for _, direction in ipairs({ 'up', 'down', 'left', 'right' }) do validate('', vis_mode, direction) end end
-- Should work only horizontally in single line buffer validate('abc', 'v', 'up', 'abc') validate('abc', 'v', 'down', 'abc') validate('abc', 'V', 'up', 'abc') validate('abc', 'V', 'down', 'abc') validate('abc', '<C-v>', 'up', 'abc') validate('abc', '<C-v>', 'down', 'abc')
validate('abc', 'v', 'left', 'bac') validate('abc', 'v', 'right', 'acb') validate('\tabc', 'V', 'left', 'abc') validate('abc', 'V', 'right', '\tabc') validate('abc', '<C-v>', 'left', 'bac') validate('abc', '<C-v>', 'right', 'acb')end
T['move_selection()']['has no side effects'] = function() set_lines({ 'aaa', 'bbb' })
-- Shouldn't modify any possibly affected registers local reginfo_ref = setup_registers()
-- Shouldn't modify 'virtualedit' child.o.virtualedit = 'block,insert'
-- Shouldn't affect yank history from 'mini.bracketed' child.cmd('au TextYankPost * lua if not vim.b.minibracketed_disable then _G.been_here = true end')
local validate = function() for reg, info in pairs(reginfo_ref) do eq(child.fn.getreginfo(reg), info) end eq(child.o.virtualedit, 'block,insert') eq(child.lua_get('_G.been_here'), vim.NIL) eq(child.lua_get('vim.b.minibracketed_disable'), vim.NIL) end
-- Perform linewise move set_cursor(1, 0) type_keys('V') move('down') validate_state({ 'bbb', 'aaa' }, { { 2, 1 }, { 2, 1 } }) validate() child.ensure_normal_mode()
-- Perform charwise move set_cursor(1, 1) type_keys('v') move('down') validate_state({ 'bb', 'abaa' }, { { 2, 2 }, { 2, 2 } }) validate()end
T['move_selection()']['works with `virtualedit=all`'] = function() child.o.virtualedit = 'all'
set_lines({ 'abX', '' }) set_cursor(1, 2) type_keys('v')
move('right') validate_state({ 'ab X', '' }, { { 1, 4 }, { 1, 4 } }) move('down') validate_state({ 'ab ', ' X' }, { { 2, 4 }, { 2, 4 } })end
T['move_selection()']['works silently'] = function() -- Horizontal movement should not add "x lines >ed y times" message set_lines({ 'aa', 'bb', 'cc' }) set_cursor(1, 0) type_keys('V2j') validate_state({ 'aa', 'bb', 'cc' }, { { 1, 1 }, { 3, 1 } })
child.cmd('messages clear') move('right') validate_state({ '\taa', '\tbb', '\tcc' }, { { 1, 1 }, { 3, 2 } }) eq(child.cmd_capture('messages'), '')
move('left') validate_state({ 'aa', 'bb', 'cc' }, { { 1, 1 }, { 3, 1 } }) eq(child.cmd_capture('messages'), '')
child.ensure_normal_mode() child.cmd('messages clear')
-- Reindent when moving vertically linewise should not add "x lines to -- indent" messages set_lines({ 'aa', 'bb', 'cc', '\tdd' }) set_cursor(1, 0) type_keys('V2j') validate_state({ 'aa', 'bb', 'cc', '\tdd' }, { { 1, 1 }, { 3, 1 } })
move('down') validate_state({ '\tdd', '\taa', '\tbb', '\tcc' }, { { 2, 1 }, { 4, 2 } }) eq(child.cmd_capture('messages'), '')end
T['move_selection()']['undos all movements at once'] = function() set_lines({ 'aXbc', 'defg' }) set_cursor(1, 1) type_keys('v') validate_state({ 'aXbc', 'defg' }, { { 1, 2 }, { 1, 2 } })
move('down') move('right') move('right') move('up') move('left') validate_state({ 'abXc', 'defg' }, { { 1, 3 }, { 1, 3 } })
type_keys('<Esc>', 'u') validate_state({ 'aXbc', 'defg' }, { { 1, 2 }, { 1, 2 } })end
T['move_selection()']['starts separate undo block on outer cursor move'] = function() set_lines({ 'aXbc', 'defg' }) set_cursor(1, 1) type_keys('v') validate_state({ 'aXbc', 'defg' }, { { 1, 2 }, { 1, 2 } })
move('down') validate_state({ 'abc', 'dXefg' }, { { 2, 2 }, { 2, 2 } }) type_keys('l') validate_state({ 'abc', 'dXefg' }, { { 2, 2 }, { 2, 3 } }) move('right') validate_state({ 'abc', 'dfXeg' }, { { 2, 3 }, { 2, 4 } })
type_keys('<Esc>', 'u') validate_state({ 'abc', 'dXefg' }, { { 2, 2 }, { 2, 2 } }) type_keys('u') validate_state({ 'aXbc', 'defg' }, { { 1, 2 }, { 1, 2 } })end
T['move_selection()']['does not create unnecessary jumps'] = function() set_lines({ '1Xa', '2b', '3c', '4d' }) set_cursor(1, 1) type_keys('m`') type_keys('v')
move('down') move('down') move('down') validate_state({ '1a', '2b', '3c', '4Xd' }, { { 4, 2 }, { 4, 2 } })
-- In jump list there should be only single entry eq(#child.fn.getjumplist()[1], 1)end
T['move_selection()']["silently respects 'nomodifiable'"] = function() set_lines({ 'aa', ' bb', 'cc' }) set_cursor(2, 0) type_keys('V')
local validate = function() validate_state({ 'aa', ' bb', 'cc' }, { { 2, 1 }, { 2, 1 } }) eq(child.cmd_capture('messages'), '') end validate()
child.o.modifiable = false
move('left') validate() move('right') validate() move('up') validate() move('down') validate()end
T['move_selection()']['respects `vim.{g,b}.minimove_disable`'] = new_set({ parametrize = { { 'g' }, { 'b' } },}, { test = function(var_type) child[var_type].minimove_disable = true
set_lines({ 'aaa', 'bbb' }) set_cursor(1, 0) type_keys('V') validate_state({ 'aaa', 'bbb' }, { { 1, 1 }, { 1, 1 } })
move('down') validate_state({ 'aaa', 'bbb' }, { { 1, 1 }, { 1, 1 } })
child[var_type].minimove_disable = false move('down') validate_state({ 'bbb', 'aaa' }, { { 2, 1 }, { 2, 1 } }) end,})
T['move_line()'] = new_set()
local move_line = function(direction, opts) child.lua('MiniMove.move_line(...)', { direction, opts }) end
T['move_line()']['works vertically'] = function() set_lines({ 'XX', 'aa', 'bb', 'cc' }) set_cursor(1, 1) validate_line_state({ 'XX', 'aa', 'bb', 'cc' }, { 1, 1 })
-- Should also preserve cursor column move_line('down') validate_line_state({ 'aa', 'XX', 'bb', 'cc' }, { 2, 1 }) move_line('down') validate_line_state({ 'aa', 'bb', 'XX', 'cc' }, { 3, 1 }) move_line('down') validate_line_state({ 'aa', 'bb', 'cc', 'XX' }, { 4, 1 }) -- Should allow to try to move_line past last line without error move_line('down') validate_line_state({ 'aa', 'bb', 'cc', 'XX' }, { 4, 1 })
move_line('up') validate_line_state({ 'aa', 'bb', 'XX', 'cc' }, { 3, 1 }) move_line('up') validate_line_state({ 'aa', 'XX', 'bb', 'cc' }, { 2, 1 }) move_line('up') validate_line_state({ 'XX', 'aa', 'bb', 'cc' }, { 1, 1 }) -- Should allow to try to move_line past first line without error move_line('up') validate_line_state({ 'XX', 'aa', 'bb', 'cc' }, { 1, 1 })end
T['move_line()']['respects `opts.n_times` vertically'] = function() set_lines({ 'XX', 'aa', 'bb', 'cc' }) set_cursor(1, 1) validate_line_state({ 'XX', 'aa', 'bb', 'cc' }, { 1, 1 })
move_line('down', { n_times = 3 }) validate_line_state({ 'aa', 'bb', 'cc', 'XX' }, { 4, 1 }) move_line('up', { n_times = 2 }) validate_line_state({ 'aa', 'XX', 'bb', 'cc' }, { 2, 1 })end
T['move_line()']['works vertically with folds'] = function() local setup_folds = function() child.ensure_normal_mode() set_lines({ '1XX', '2aa', '3bb', '4cc', '5XX' })
-- Create fold type_keys('zE') set_cursor(2, 0) type_keys('zf', '2j') end
-- Down setup_folds() set_cursor(1, 0) validate_line_state({ '1XX', '2aa', '3bb', '4cc', '5XX' }, { 1, 0 }) eq(get_fold_range(2), { 2, 4 })
-- - Folds should be moved altogether move_line('down') validate_line_state({ '2aa', '3bb', '4cc', '1XX', '5XX' }, { 4, 0 }) eq(get_fold_range(1), { 1, 3 })
-- Up setup_folds() set_cursor(5, 0) validate_line_state({ '1XX', '2aa', '3bb', '4cc', '5XX' }, { 5, 0 }) eq(get_fold_range(2), { 2, 4 })
-- - Folds should be moved altogether move_line('up') validate_line_state({ '1XX', '5XX', '2aa', '3bb', '4cc' }, { 2, 0 }) eq(get_fold_range(3), { 3, 5 })end
--stylua: ignoreT['move_line()']['reindents while moving cursor along'] = function() set_lines({ 'XX', 'aa', '\tbb', '\t\tcc', '\tdd', 'ee' }) set_cursor(1, 1) -- As `get_cursor()` treats '\t' as single character, use 1 and 2 instead of -- relying on computing visible cursor position with 'shiftwidth' validate_line_state({ 'XX', 'aa', '\tbb', '\t\tcc', '\tdd', 'ee' }, { 1, 1 })
-- Should also move cursor along selection move_line('down') validate_line_state({ 'aa', 'XX', '\tbb', '\t\tcc', '\tdd', 'ee' }, { 2, 1 }) move_line('down') validate_line_state({ 'aa', '\tbb', '\tXX', '\t\tcc', '\tdd', 'ee' }, { 3, 2 }) move_line('down') validate_line_state({ 'aa', '\tbb', '\t\tcc', '\t\tXX', '\tdd', 'ee' }, { 4, 3 }) move_line('down') validate_line_state({ 'aa', '\tbb', '\t\tcc', '\tdd', '\tXX', 'ee' }, { 5, 2 }) move_line('down') validate_line_state({ 'aa', '\tbb', '\t\tcc', '\tdd', 'ee', 'XX' }, { 6, 1 })end
T['move_line()']['respects `opts.reindent_linewise`'] = function() set_lines({ 'XX', '\taa' }) set_cursor(1, 1) validate_line_state({ 'XX', '\taa' }, { 1, 1 })
-- `false` as argument move_line('down', { reindent_linewise = false }) validate_line_state({ '\taa', 'XX' }, { 2, 1 })
-- `true` as argument move_line('up') validate_line_state({ 'XX', '\taa' }, { 1, 1 }) move_line('down', { reindent_linewise = true }) validate_line_state({ '\taa', '\tXX' }, { 2, 2 })
-- `false` as global move_line('up') validate_line_state({ 'XX', '\taa' }, { 1, 1 })
child.lua('MiniMove.config.options.reindent_linewise = false') move_line('down') validate_line_state({ '\taa', 'XX' }, { 2, 1 })end
T['move_line()']['works horizontally'] = function() -- Should be the same as indent (`>`) and dedent (`<`) set_lines({ ' aa' }) set_cursor(1, 1) validate_line_state({ ' aa' }, { 1, 1 })
-- Should also move cursor along selection move_line('right') validate_line_state({ '\t aa' }, { 1, 2 }) move_line('right') validate_line_state({ '\t\t aa' }, { 1, 3 })
move_line('left') validate_line_state({ '\t aa' }, { 1, 2 }) move_line('left') validate_line_state({ ' aa' }, { 1, 1 }) move_line('left') validate_line_state({ 'aa' }, { 1, 0 }) -- Should allow to try impossible dedent without error move_line('left') validate_line_state({ 'aa' }, { 1, 0 })end
T['move_line()']['respects `opts.n_times` horizontally'] = function() set_lines({ 'aa' }) set_cursor(1, 0) validate_line_state({ 'aa' }, { 1, 0 })
move_line('right', { n_times = 3 }) validate_line_state({ '\t\t\taa' }, { 1, 3 }) move_line('left', { n_times = 2 }) validate_line_state({ '\taa' }, { 1, 1 })end
T['move_line()']['works in small buffers'] = function() local validate = function(line_before, direction, line_after) set_lines({ line_before }) set_cursor(1, 0) move_line(direction) eq(get_lines(), { line_after or line_before }) end
-- Should do nothing in empty buffer validate('', 'up', '') validate('', 'down', '') validate('', 'left', '') validate('', 'right', '')
-- Should work only horizontally in single line buffer validate('abc', 'up', 'abc') validate('abc', 'down', 'abc') validate('\tabc', 'left', 'abc') validate('abc', 'right', '\tabc')end
T['move_line()']['has no side effects'] = function() set_lines({ 'aaa', 'bbb' })
-- Shouldn't modify any possibly affected registers local reginfo_ref = setup_registers()
-- Shouldn't affect yank history from 'mini.bracketed' child.cmd('au TextYankPost * lua if not vim.b.minibracketed_disable then _G.been_here = true end')
-- Perform move set_cursor(1, 0) move_line('down') validate_line_state({ 'bbb', 'aaa' }, { 2, 0 })
-- Check for reg, info in pairs(reginfo_ref) do eq(child.fn.getreginfo(reg), info) end eq(child.lua_get('_G.been_here'), vim.NIL) eq(child.lua_get('vim.b.minibracketed_disable'), vim.NIL)end
T['move_line()']['works silently'] = function() -- Although at the moment single line moves don't produce messages, test it -- to align with 'move_selection()'
-- Horizontal movement should not add "x lines >ed y times" message set_lines({ 'aa' }) set_cursor(1, 0) validate_line_state({ 'aa' }, { 1, 0 })
child.cmd('messages clear') move_line('right') validate_line_state({ '\taa' }, { 1, 1 }) eq(child.cmd_capture('messages'), '')
move_line('left') validate_line_state({ 'aa' }, { 1, 0 }) eq(child.cmd_capture('messages'), '')
child.ensure_normal_mode()
-- Reindent when moving vertically linewise should not add "x lines to -- indent" messages child.cmd('messages clear') set_lines({ 'aa', '\tdd' }) set_cursor(1, 0) validate_line_state({ 'aa', '\tdd' }, { 1, 0 })
move_line('down') validate_line_state({ '\tdd', '\taa' }, { 2, 1 }) eq(child.cmd_capture('messages'), '')end
T['move_line()']['undos all movements at once'] = function() set_lines({ 'aaa', 'bbb', 'ccc', 'ddd' }) set_cursor(1, 0) validate_line_state({ 'aaa', 'bbb', 'ccc', 'ddd' }, { 1, 0 })
move_line('down') move_line('down') move_line('up') move_line('down') validate_line_state({ 'bbb', 'ccc', 'aaa', 'ddd' }, { 3, 0 })
type_keys('<Esc>', 'u') validate_line_state({ 'aaa', 'bbb', 'ccc', 'ddd' }, { 1, 0 })end
T['move_line()']['starts separate undo block on outer cursor move'] = function() set_lines({ 'aaa', 'bbb', 'ccc', 'ddd' }) set_cursor(1, 0) validate_line_state({ 'aaa', 'bbb', 'ccc', 'ddd' }, { 1, 0 })
move_line('down') validate_line_state({ 'bbb', 'aaa', 'ccc', 'ddd' }, { 2, 0 }) type_keys('j') validate_line_state({ 'bbb', 'aaa', 'ccc', 'ddd' }, { 3, 0 }) move_line('down') validate_line_state({ 'bbb', 'aaa', 'ddd', 'ccc' }, { 4, 0 })
type_keys('<Esc>', 'u') validate_line_state({ 'bbb', 'aaa', 'ccc', 'ddd' }, { 3, 0 }) type_keys('u') validate_line_state({ 'aaa', 'bbb', 'ccc', 'ddd' }, { 1, 0 })end
T['move_line()']['does not share undo block with visual moves'] = function() set_lines({ 'aaa', 'bbb', 'ccc', 'ddd' }) set_cursor(1, 0) type_keys('V') validate_state({ 'aaa', 'bbb', 'ccc', 'ddd' }, { { 1, 1 }, { 1, 1 } })
move('down') validate_state({ 'bbb', 'aaa', 'ccc', 'ddd' }, { { 2, 1 }, { 2, 1 } })
type_keys('<Esc>') move_line('down') validate_line_state({ 'bbb', 'ccc', 'aaa', 'ddd' }, { 3, 0 })
type_keys('u') validate_line_state({ 'bbb', 'aaa', 'ccc', 'ddd' }, { 2, 0 }) type_keys('u') validate_line_state({ 'aaa', 'bbb', 'ccc', 'ddd' }, { 1, 0 })end
T['move_line()']['does not create unnecessary jumps'] = function() set_lines({ 'aa', 'bb', 'cc', 'dd' }) set_cursor(1, 1) type_keys('m`')
move_line('down') move_line('down') move_line('down') validate_line_state({ 'bb', 'cc', 'dd', 'aa' }, { 4, 1 })
-- In jump list there should be only single entry eq(#child.fn.getjumplist()[1], 1)end
T['move_line()']["silently respects 'nomodifiable'"] = function() set_lines({ 'aa', ' bb', 'cc' }) set_cursor(2, 0)
local validate = function() validate_line_state({ 'aa', ' bb', 'cc' }, { 2, 0 }) eq(child.cmd_capture('messages'), '') end validate()
child.o.modifiable = false
move_line('left') validate() move_line('right') validate() move_line('up') validate() move_line('down') validate()end
T['move_line()']['respects `vim.{g,b}.minimove_disable`'] = new_set({ parametrize = { { 'g' }, { 'b' } },}, { test = function(var_type) child[var_type].minimove_disable = true
set_lines({ 'aaa', 'bbb' }) set_cursor(1, 0) validate_line_state({ 'aaa', 'bbb' }, { 1, 0 })
move_line('down') validate_line_state({ 'aaa', 'bbb' }, { 1, 0 })
child[var_type].minimove_disable = false move_line('down') validate_line_state({ 'bbb', 'aaa' }, { 2, 0 }) end,})
-- Integration tests ==========================================================T['Mappings'] = new_set()
T['Mappings']['left/right'] = new_set()
T['Mappings']['left/right']['works charwise'] = function() set_lines({ 'XXabcd' }) set_cursor(1, 0) type_keys('vl') validate_state1d('XXabcd', { 1, 2 })
type_keys('<M-l>') validate_state1d('aXXbcd', { 2, 3 }) -- Supports `v:count` type_keys('2<M-l>') validate_state1d('abcXXd', { 4, 5 }) -- Can allow overshoot without error type_keys('2<M-l>') validate_state1d('abcdXX', { 5, 6 })
type_keys('<M-h>') validate_state1d('abcXXd', { 4, 5 }) -- Supports `v:count` type_keys('2<M-h>') validate_state1d('aXXbcd', { 2, 3 }) -- Can allow overshoot without error type_keys('2<M-h>') validate_state1d('XXabcd', { 1, 2 })end
T['Mappings']['left/right']['works blockwise'] = function() set_lines({ 'XXabcd', 'XXabcd' }) set_cursor(1, 0) type_keys('<C-v>', 'lj') validate_state({ 'XXabcd', 'XXabcd' }, { { 1, 1 }, { 2, 2 } })
type_keys('<M-l>') validate_state({ 'aXXbcd', 'aXXbcd' }, { { 1, 2 }, { 2, 3 } }) -- Supports `v:count` type_keys('2<M-l>') validate_state({ 'abcXXd', 'abcXXd' }, { { 1, 4 }, { 2, 5 } }) -- Should allow overshoot without error type_keys('2<M-l>') validate_state({ 'abcdXX', 'abcdXX' }, { { 1, 5 }, { 2, 6 } })
type_keys('<M-h>') validate_state({ 'abcXXd', 'abcXXd' }, { { 1, 4 }, { 2, 5 } }) -- Supports `v:count` type_keys('2<M-h>') validate_state({ 'aXXbcd', 'aXXbcd' }, { { 1, 2 }, { 2, 3 } }) -- Should allow overshoot without error type_keys('2<M-h>') validate_state({ 'XXabcd', 'XXabcd' }, { { 1, 1 }, { 2, 2 } })end
T['Mappings']['left/right']['works linewise'] = function() set_lines({ ' aa', 'bb' }) set_cursor(1, 0) type_keys('Vjl') validate_state({ ' aa', 'bb' }, { { 1, 1 }, { 2, 2 } })
type_keys('<M-l>') validate_state({ '\t aa', '\tbb' }, { { 1, 1 }, { 2, 3 } }) -- Supports `v:count` type_keys('2<M-l>') validate_state({ '\t\t\t aa', '\t\t\tbb' }, { { 1, 1 }, { 2, 5 } })
type_keys('<M-h>') validate_state({ '\t\t aa', '\t\tbb' }, { { 1, 1 }, { 2, 4 } }) -- Supports `v:count` type_keys('2<M-h>') validate_state({ ' aa', 'bb' }, { { 1, 1 }, { 2, 2 } }) -- Should allow overshoot without error type_keys('2<M-h>') validate_state({ 'aa', 'bb' }, { { 1, 1 }, { 2, 2 } })end
T['Mappings']['left/right']['works with multicursor'] = function() if child.fn.has('nvim-0.13') == 0 then MiniTest.skip('Multicursor is available in Neovim>=0.13') end
-- Charwise local lines_before = { 'XXab', 'XXcd' } local lines_after = { 'aXXb', 'cXXd' } local keys = { 'Qj', 'vl', '<M-l>', '<Esc>' } child.validate_mc_edit(lines_before, { 1, 0 }, keys, lines_after, { 2, 2 }, { { 1, 2 } }) keys = { 'Qj', 'vl', '<M-h>', '<Esc>' } child.validate_mc_edit(lines_after, { 1, 1 }, keys, lines_before, { 2, 1 }, { { 1, 1 } })
-- Blockwise lines_before = { 'XXab', 'XXcd', 'YYef', 'YYgh' } lines_after = { 'aXXb', 'cXXd', 'eYYf', 'gYYh' } keys = { 'Qjj', '<C-v>jl', '<M-l>', '<Esc>' } child.validate_mc_edit(lines_before, { 1, 0 }, keys, lines_after, { 4, 2 }, { { 2, 2 } }) keys = { 'Qjj', '<C-v>jl', '<M-h>', '<Esc>' } child.validate_mc_edit(lines_after, { 1, 1 }, keys, lines_before, { 4, 1 }, { { 2, 1 } })
-- Linewise lines_before = { 'aa', 'bb' } lines_after = { '\taa', '\tbb' } keys = { 'Qj', 'V', '<M-l>', '<Esc>' } child.validate_mc_edit(lines_before, { 1, 0 }, keys, lines_after, { 2, 1 }, { { 1, 1 } }) keys = { 'Qj', 'V', '<M-h>', '<Esc>' } child.validate_mc_edit(lines_after, { 1, 1 }, keys, lines_before, { 2, 0 }, { { 1, 0 } })end
T['Mappings']['down/up'] = new_set()
T['Mappings']['down/up']['works charwise'] = function() set_lines({ '1XXx', '2a', '3b', '4c', '5d' }) set_cursor(1, 1) type_keys('vl') validate_state({ '1XXx', '2a', '3b', '4c', '5d' }, { { 1, 2 }, { 1, 3 } })
type_keys('<M-j>') validate_state({ '1x', '2XXa', '3b', '4c', '5d' }, { { 2, 2 }, { 2, 3 } }) -- Supports `v:count` type_keys('2<M-j>') validate_state({ '1x', '2a', '3b', '4XXc', '5d' }, { { 4, 2 }, { 4, 3 } }) -- Should allow overshoot without error type_keys('2<M-j>') validate_state({ '1x', '2a', '3b', '4c', '5XXd' }, { { 5, 2 }, { 5, 3 } })
type_keys('<M-k>') validate_state({ '1x', '2a', '3b', '4XXc', '5d' }, { { 4, 2 }, { 4, 3 } }) -- Supports `v:count` type_keys('2<M-k>') validate_state({ '1x', '2XXa', '3b', '4c', '5d' }, { { 2, 2 }, { 2, 3 } }) -- Should allow overshoot without error type_keys('2<M-k>') validate_state({ '1XXx', '2a', '3b', '4c', '5d' }, { { 1, 2 }, { 1, 3 } })end
T['Mappings']['down/up']['works blockwise'] = function() set_lines({ '1XXa', '2YYb', '3c', '4d', '5e' }) set_cursor(1, 1) type_keys('<C-v>', 'lj') validate_state({ '1XXa', '2YYb', '3c', '4d', '5e' }, { { 1, 2 }, { 2, 3 } })
type_keys('<M-j>') validate_state({ '1a', '2XXb', '3YYc', '4d', '5e' }, { { 2, 2 }, { 3, 3 } }) -- Supports `v:count` type_keys('2<M-j>') validate_state({ '1a', '2b', '3c', '4XXd', '5YYe' }, { { 4, 2 }, { 5, 3 } }) -- Should allow overshoot without error type_keys('2<M-j>') validate_state({ '1a', '2b', '3c', '4XXd', '5YYe' }, { { 4, 2 }, { 5, 3 } })
type_keys('<M-k>') validate_state({ '1a', '2b', '3XXc', '4YYd', '5e' }, { { 3, 2 }, { 4, 3 } }) -- Supports `v:count` type_keys('2<M-k>') validate_state({ '1XXa', '2YYb', '3c', '4d', '5e' }, { { 1, 2 }, { 2, 3 } }) -- Should allow overshoot without error type_keys('2<M-k>') validate_state({ '1XXa', '2YYb', '3c', '4d', '5e' }, { { 1, 2 }, { 2, 3 } })end
T['Mappings']['down/up']['works linewise'] = function() set_lines({ 'XX', 'YY', 'aa', 'bb', 'cc' }) set_cursor(1, 0) type_keys('Vj') validate_state({ 'XX', 'YY', 'aa', 'bb', 'cc' }, { { 1, 1 }, { 2, 1 } })
type_keys('<M-j>') validate_state({ 'aa', 'XX', 'YY', 'bb', 'cc' }, { { 2, 1 }, { 3, 1 } }) -- Supports `v:count` type_keys('2<M-j>') validate_state({ 'aa', 'bb', 'cc', 'XX', 'YY' }, { { 4, 1 }, { 5, 1 } }) -- Should allow overshoot without error type_keys('2<M-j>') validate_state({ 'aa', 'bb', 'cc', 'XX', 'YY' }, { { 4, 1 }, { 5, 1 } })
type_keys('<M-k>') validate_state({ 'aa', 'bb', 'XX', 'YY', 'cc' }, { { 3, 1 }, { 4, 1 } }) -- Supports `v:count` type_keys('2<M-k>') validate_state({ 'XX', 'YY', 'aa', 'bb', 'cc' }, { { 1, 1 }, { 2, 1 } }) -- Should allow overshoot without error type_keys('2<M-k>') validate_state({ 'XX', 'YY', 'aa', 'bb', 'cc' }, { { 1, 1 }, { 2, 1 } })end
T['Mappings']['down/up']['works with multicursor'] = function() if child.fn.has('nvim-0.13') == 0 then MiniTest.skip('Multicursor is available in Neovim>=0.13') end
-- Charwise local lines_before = { 'XXab', 'cd', 'YYef', 'gh' } local lines_after = { 'ab', 'XXcd', 'ef', 'YYgh' } local keys = { 'Qjj', 'vl', '<M-j>', '<Esc>' } child.validate_mc_edit(lines_before, { 1, 0 }, keys, lines_after, { 4, 1 }, { { 2, 1 } }) keys = { 'Qjj', 'vl', '<M-k>', '<Esc>' } child.validate_mc_edit(lines_after, { 2, 0 }, keys, lines_before, { 3, 1 }, { { 1, 1 } })
-- Blockwise lines_before = { 'XXab', 'YYcd', '', 'UUef', 'VVgh', '' } lines_after = { 'ab', 'XXcd', 'YY', 'ef', 'UUgh', 'VV' } keys = { 'Qjjj', '<C-v>jl', '<M-j>', '<Esc>' } child.validate_mc_edit(lines_before, { 1, 0 }, keys, lines_after, { 6, 1 }, { { 3, 1 } }) keys = { 'Qjjj', '<C-v>kl', '<M-k>', '<Esc>' } child.validate_mc_edit(lines_after, { 3, 0 }, keys, lines_before, { 5, 1 }, { { 2, 1 } })
-- Linewise lines_before = { 'aa', 'bb', 'cc', 'dd' } lines_after = { 'bb', 'aa', 'dd', 'cc' } keys = { 'Qjj', 'V', '<M-j>', '<Esc>' } child.validate_mc_edit(lines_before, { 1, 0 }, keys, lines_after, { 4, 0 }, { { 2, 0 } }) keys = { 'Qjj', 'V', '<M-k>', '<Esc>' } child.validate_mc_edit(lines_after, { 2, 0 }, keys, lines_before, { 3, 0 }, { { 1, 0 } })end
T['Mappings']['line_left/line_right'] = new_set()
T['Mappings']['line_left/line_right']['works'] = function() -- Should be the same as indent (`>`) and dedent (`<`) set_lines({ ' aa' }) set_cursor(1, 1) validate_line_state({ ' aa' }, { 1, 1 })
type_keys('<M-l>') validate_line_state({ '\t aa' }, { 1, 2 }) type_keys('2<M-l>') validate_line_state({ '\t\t\t aa' }, { 1, 4 })
type_keys('<M-h>') validate_line_state({ '\t\t aa' }, { 1, 3 }) type_keys('2<M-h>') validate_line_state({ ' aa' }, { 1, 1 }) -- Should allow to try impossible dedent without error type_keys('2<M-h>') validate_line_state({ 'aa' }, { 1, 0 })end
T['Mappings']['line_left/line_right']['works with multicursor'] = function() if child.fn.has('nvim-0.13') == 0 then MiniTest.skip('Multicursor is available in Neovim>=0.13') end
local lines_before = { 'aa', 'bb', 'cc' } local lines_after = { '\taa', 'bb', '\tcc' } local keys = { 'Qjj', '<M-l>' } child.validate_mc_edit(lines_before, { 1, 0 }, keys, lines_after, { 3, 1 }, { { 1, 1 } }) keys = { 'Qjj', '<M-h>' } child.validate_mc_edit(lines_after, { 1, 1 }, keys, lines_before, { 3, 0 }, { { 1, 0 } })end
T['Mappings']['line_down/line_up'] = new_set()
T['Mappings']['line_down/line_up']['works'] = function() set_lines({ 'XX', 'aa', 'bb', 'cc' }) set_cursor(1, 1) validate_line_state({ 'XX', 'aa', 'bb', 'cc' }, { 1, 1 })
type_keys('<M-j>') validate_line_state({ 'aa', 'XX', 'bb', 'cc' }, { 2, 1 }) -- Supports `v:count` type_keys('2<M-j>') validate_line_state({ 'aa', 'bb', 'cc', 'XX' }, { 4, 1 }) -- Should allow overshoot without error type_keys('2<M-j>') validate_line_state({ 'aa', 'bb', 'cc', 'XX' }, { 4, 1 })
type_keys('<M-k>') validate_line_state({ 'aa', 'bb', 'XX', 'cc' }, { 3, 1 }) -- Supports `v:count` type_keys('2<M-k>') validate_line_state({ 'XX', 'aa', 'bb', 'cc' }, { 1, 1 }) -- Should allow overshoot without error type_keys('2<M-k>') validate_line_state({ 'XX', 'aa', 'bb', 'cc' }, { 1, 1 })end
T['Mappings']['line_down/line_up']['works with multicursor'] = function() if child.fn.has('nvim-0.13') == 0 then MiniTest.skip('Multicursor is available in Neovim>=0.13') end
-- Linewise local lines_before = { 'aa', 'bb', 'cc', 'dd' } local lines_after = { 'bb', 'aa', 'dd', 'cc' } local keys = { 'Qjj', '<M-j>' } child.validate_mc_edit(lines_before, { 1, 0 }, keys, lines_after, { 4, 0 }, { { 2, 0 } }) keys = { 'Qjj', '<M-k>' } child.validate_mc_edit(lines_after, { 2, 0 }, keys, lines_before, { 3, 0 }, { { 1, 0 } })end
return T