--- *mini.move* Move any selection in any direction --- --- MIT License Copyright (c) 2023 Evgeni Chasnovski --- Features: --- - Works in two modes: --- - Visual mode. Select text (charwise with |v|, linewise with |V|, and --- blockwise with |CTRL-V|) and press customizable mapping to move in --- all four directions (left, right, down, up). It keeps Visual mode. --- - Normal mode. Press customizable mapping to move current line in all --- four directions (left, right, down, up). --- - Special handling of linewise movement: --- - Vertical movement gets reindented with |=|. --- - Horizontal movement is improved indent/dedent with |>| / |<|. --- - Cursor moves along with selection. --- --- - Provides both mappings and Lua functions for motions. See --- |MiniMove.move_selection()| and |MiniMove.move_line()|. --- --- - Respects |v:count|. Movement mappings can be preceded by a number which --- multiplies command effect. --- --- - All consecutive moves (regardless of direction) can be undone by a single |u|. --- --- - Respects preferred column for vertical movement. It will vertically move --- selection as how cursor is moving (not strictly vertically if target --- column is not present in target line). --- --- Notes: --- - Doesn't allow moving selection outside of current lines (by design). --- --- # Setup ~ --- --- This module needs a setup with `require('mini.move').setup({})` (replace --- `{}` with your `config` table). It will create global Lua table `MiniMove` --- which you can use for scripting or manually (with `:lua MiniMove.*`). --- --- See |MiniMove.config| for available config settings. --- --- You can override runtime config settings (but not `config.mappings`) locally --- to buffer inside `vim.b.minimove_config` which should have same structure --- as `MiniMove.config`. See |mini.nvim-buffer-local-config| for more details. --- --- # Comparisons ~ --- --- - [matze/vim-move](https://github.com/matze/vim-move): --- - Doesn't support vertical movement of charwise and blockwise selections. --- While |mini.move| does. --- - Doesn't support horizontal movement of current line in favor of --- horizontal movement of current character. While |mini.move| supports --- horizontal movement of current line and doesn't support such movement --- of current character. --- - Has extra functionality for certain moves (like move by half page). --- While |mini.move| does not (by design). --- - [booperlv/nvim-gomove](https://github.com/booperlv/nvim-gomove): --- - Doesn't support movement in charwise visual selection. --- While |mini.move| does. --- - Has extra functionality beyond moving text, like duplication. --- While |mini.move| concentrates only on moving functionality. --- --- # Disabling ~ --- --- To disable, set `vim.g.minimove_disable` (globally) or `vim.b.minimove_disable` --- (for a buffer) to `true`. Considering high number of different scenarios --- and customization intentions, writing exact rules for disabling module's --- functionality is left to user. See |mini.nvim-disabling-recipes| for common --- recipes. ---@tag MiniMove ---@alias __move_direction string One of "left", "down", "up", "right". ---@alias __move_opts table|nil Options. Same structure as `options` in |MiniMove.config| --- (with its values as defaults) plus these allowed extra fields: --- - (number) - number of times to try to make a move. --- Default: |v:count1|. ---@diagnostic disable:undefined-field -- Module definition ========================================================== local MiniMove = {} local H = {} --- Module setup --- ---@param config table|nil Module config table. See |MiniMove.config|. --- ---@usage >lua --- require('mini.move').setup() -- use default config --- -- OR --- require('mini.move').setup({}) -- replace {} with your config table --- < MiniMove.setup = function(config) -- TODO: Remove after Neovim=0.9 support is dropped if vim.fn.has('nvim-0.10') == 0 then vim.notify( '(mini.move) Neovim<0.10 is soft deprecated (module works but is not supported).' .. " It will be deprecated after the next 'mini.nvim' release (module might not work)." .. ' Please update your Neovim version.' ) end -- Export module _G.MiniMove = MiniMove -- Setup config config = H.setup_config(config) -- Apply config H.apply_config(config) end --- Defaults ~ ---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section) ---@text # Mappings ~ --- --- Other possible choices of mappings: >lua --- --- -- `HJKL` for moving visual selection (overrides H, L, J in Visual mode) --- require('mini.move').setup({ --- mappings = { --- left = 'H', --- right = 'L', --- down = 'J', --- up = 'K', --- } --- }) --- --- -- Shift + arrows --- require('mini.move').setup({ --- mappings = { --- left = '', --- right = '', --- down = '', --- up = '', --- --- line_left = '', --- line_right = '', --- line_down = '', --- line_up = '', --- } --- }) --- < MiniMove.config = { -- Module mappings. Use `''` (empty string) to disable one. mappings = { -- Move visual selection in Visual mode. Defaults are Alt (Meta) + hjkl. left = '', right = '', down = '', up = '', -- Move current line in Normal mode line_left = '', line_right = '', line_down = '', line_up = '', }, -- Options which control moving behavior options = { -- Automatically reindent selection during linewise vertical move reindent_linewise = true, }, } --minidoc_afterlines_end -- Module functionality ======================================================= --- Move visually selected region in any direction within present lines --- --- Main function powering visual selection move in Visual mode. --- --- Notes: --- - Vertical movement in linewise mode is followed up by reindent with |v_=|. --- - Horizontal movement in linewise mode is same as |v_<| and |v_>|. --- ---@param direction __move_direction ---@param opts __move_opts MiniMove.move_selection = function(direction, opts) if H.is_disabled() or not vim.o.modifiable then return end opts = vim.tbl_deep_extend('force', H.get_config().options, opts or {}) -- This could have been a one-line expression mappings, but there are issues: -- - Initial yanking modifies some register. Not critical, but also not good. -- - Doesn't work at movement edges (first line for `K`, etc.). See -- https://github.com/vim/vim/issues/11786 -- - Results into each movement being a separate undo block, which is -- inconvenient with several back-to-back movements. local cur_mode = vim.fn.mode() -- Act only inside visual mode if not (cur_mode == 'v' or cur_mode == 'V' or cur_mode == '\22') then return end -- Define common predicates local dir_type = (direction == 'up' or direction == 'down') and 'vert' or 'hori' local is_linewise = cur_mode == 'V' -- Make early return in small buffer if vim.api.nvim_buf_line_count(0) == 1 then if is_linewise and dir_type == 'vert' then return end if not is_linewise and vim.fn.getline(1):len() == 0 then return end end -- Cache useful data because it will be reset when executing commands local n_times = opts.n_times or vim.v.count1 local ref_curpos, ref_last_col = vim.fn.getcurpos(), vim.fn.col('$') local is_cursor_on_selection_start = vim.fn.line('.') < vim.fn.line('v') -- Determine if previous action was this type of move local is_moving = vim.deep_equal(H.state, H.get_move_state()) if not is_moving then H.curswant = nil end -- Allow undo of consecutive moves at once (direction doesn't matter) local cmd = H.make_cmd_normal(is_moving) -- Treat horizontal linewise movement specially if is_linewise and dir_type == 'hori' then -- Use indentation as horizontal movement for linewise selection cmd(n_times .. H.indent_keys[direction] .. 'gv') -- Make cursor move along selection H.correct_cursor_col(ref_curpos, ref_last_col) -- Track new state to allow joining in single undo block H.state = H.get_move_state() return end -- Temporarily ensure possibility to put cursor just after line end. -- This allows a more intuitive cursor positioning from and to end of line. -- NOTE: somehow, this should be done before initial cut to take effect. local cache_virtualedit = vim.o.virtualedit if not cache_virtualedit:find('all') then vim.o.virtualedit = 'onemore' end -- Cut selection while saving caching register local cache_z_reg = vim.fn.getreginfo('z') -- - Don't use `"zx` directly to not affect registers 1-9 cmd('"zygv"_x') -- Detect edge selection: last line(s) for vertical and last character(s) -- for horizontal. At this point (after cutting selection) cursor is on the -- edge which can happen in two cases: -- - Move second to last selection towards edge (like in 'abc' move 'b' -- to right or second to last line down). -- - Move edge selection away from edge (like in 'abc' move 'c' to left -- or last line up). -- Use condition that removed selection was further than current cursor -- to distinguish between two cases. local is_edge_selection_hori = dir_type == 'hori' and vim.fn.col('.') < vim.fn.col("'<") local is_edge_selection_vert = dir_type == 'vert' and vim.fn.line('.') < vim.fn.line("'<") local is_edge_selection = is_edge_selection_hori or is_edge_selection_vert -- Use `p` as paste key instead of `P` in cases which might require moving -- selection to place which is unreachable with `P`: right to be line end -- and down to be last line. NOTE: temporary `virtualedit=onemore` solves -- this only for horizontal movement, but not for vertical. local can_go_overline = not is_linewise and direction == 'right' local can_go_overbuf = is_linewise and direction == 'down' local paste_key = (can_go_overline or can_go_overbuf) and 'p' or 'P' -- Restore `curswant` to try move cursor to initial column (just like -- default `hjkl` moves) if dir_type == 'vert' then H.set_curswant(H.curswant) end -- Possibly reduce number of moves by one to not overshoot move local n = n_times - ((paste_key == 'p' or is_edge_selection) and 1 or 0) -- Don't allow movement past last line of block selection (any part) if cur_mode == '\22' and direction == 'down' and vim.fn.line('$') == vim.fn.line("'>") then n = 0 end -- Move cursor if n > 0 then cmd(n .. H.move_keys[direction]) end -- Save curswant. Correct for one less move when using `p` as paste. H.curswant = H.get_curswant() + ((direction == 'right' and paste_key == 'p') and 1 or 0) -- Open just enough folds (but not in linewise mode, as it allows moving -- past folds) if not is_linewise then cmd('zv') end -- Paste cmd('"z' .. paste_key) -- Select newly moved region. Another way is to use something like `gvhoho` -- but it doesn't work well with selections spanning several lines. cmd('`[1v') -- Do extra in case of linewise selection if is_linewise then -- Reindent linewise selection if `=` can do that. -- NOTE: this sometimes doesn't work well with folds (and probably -- `foldmethod=indent`) and linewise mode because it recomputes folds after -- that and the whole "move past fold" doesn't work. if opts.reindent_linewise and dir_type == 'vert' and vim.o.equalprg == '' then cmd('=gv') end -- Move cursor along the selection. NOTE: do this *after* reindent to -- account for its effect. -- - Ensure that cursor is on the right side of selection if is_cursor_on_selection_start then cmd('o') end H.correct_cursor_col(ref_curpos, ref_last_col) end -- Restore intermediate values vim.fn.setreg('z', cache_z_reg) vim.o.virtualedit = cache_virtualedit -- Track new state to allow joining in single undo block H.state = H.get_move_state() end --- Move current line in any direction --- --- Main function powering current line move in Normal mode. --- --- Notes: --- - Vertical movement is followed up by reindent with |v_=|. --- - Horizontal movement is almost the same as |<<| and |>>| with a different --- handling of |v:count| (multiplies shift effect instead of modifying that --- number of lines). --- ---@param direction __move_direction ---@param opts __move_opts MiniMove.move_line = function(direction, opts) if H.is_disabled() or not vim.o.modifiable then return end if vim.api.nvim_buf_line_count(0) == 1 and (direction == 'down' or direction == 'up') then return end opts = vim.tbl_deep_extend('force', H.get_config().options, opts or {}) -- Determine if previous action was this type of move local is_moving = vim.deep_equal(H.state, H.get_move_state()) -- Allow undo of consecutive moves at once (direction doesn't matter) local cmd = H.make_cmd_normal(is_moving) -- Cache useful data because it will be reset when executing commands local n_times = opts.n_times or vim.v.count1 local is_last_line_up = direction == 'up' and vim.fn.line('.') == vim.fn.line('$') local ref_curpos, ref_last_col = vim.fn.getcurpos(), vim.fn.col('$') if direction == 'left' or direction == 'right' then -- Use indentation as horizontal movement. Explicitly call `count1` because -- `<`/`>` use `v:count` to define number of lines. -- Go to first non-blank at the end. local key = H.indent_keys[direction] cmd(string.rep(key .. key, n_times)) -- Make cursor move along selection H.correct_cursor_col(ref_curpos, ref_last_col) -- Track new state to allow joining in single undo block H.state = H.get_move_state() return end -- Cut current line while saving caching register local cache_z_reg = vim.fn.getreginfo('z') -- - Don't use `"zdd` directly to not affect registers 1-9 cmd('"zyy"_dd') -- Move cursor local paste_key = direction == 'up' and 'P' or 'p' local n = n_times - ((paste_key == 'p' or is_last_line_up) and 1 or 0) if n > 0 then cmd(n .. H.move_keys[direction]) end -- Paste cmd('"z' .. paste_key) -- Reindent and put cursor on first non-blank if opts.reindent_linewise and vim.o.equalprg == '' then cmd('==') end -- Move cursor along the selection. NOTE: do this *after* reindent to -- account for its effect. H.correct_cursor_col(ref_curpos, ref_last_col) -- Restore intermediate values vim.fn.setreg('z', cache_z_reg) -- Track new state to allow joining in single undo block H.state = H.get_move_state() end -- Helper data ================================================================ -- Module default config H.default_config = vim.deepcopy(MiniMove.config) H.move_keys = { left = 'h', down = 'j', up = 'k', right = 'l' } H.indent_keys = { left = '<', right = '>' } -- Moving state used to decide when to start new undo block ... H.state = { -- ... on buffer change buf_id = nil, -- ... on text change changedtick = nil, -- ... on cursor move cursor = nil, -- ... on mode change mode = nil, } H.curswant = nil -- Helper functionality ======================================================= -- Settings ------------------------------------------------------------------- H.setup_config = function(config) H.check_type('config', config, 'table', true) config = vim.tbl_deep_extend('force', vim.deepcopy(H.default_config), config or {}) H.check_type('mappings', config.mappings, 'table') H.check_type('mappings.left', config.mappings.left, 'string') H.check_type('mappings.down', config.mappings.down, 'string') H.check_type('mappings.up', config.mappings.up, 'string') H.check_type('mappings.right', config.mappings.right, 'string') H.check_type('mappings.line_left', config.mappings.line_left, 'string') H.check_type('mappings.line_right', config.mappings.line_right, 'string') H.check_type('mappings.line_down', config.mappings.line_down, 'string') H.check_type('mappings.line_up', config.mappings.line_up, 'string') H.check_type('options', config.options, 'table') H.check_type('options.reindent_linewise', config.options.reindent_linewise, 'boolean') return config end --stylua: ignore H.apply_config = function(config) MiniMove.config = config -- Make mappings local maps = config.mappings H.map('x', maps.left, [[lua MiniMove.move_selection('left')]], { desc = 'Move left' }) H.map('x', maps.right, [[lua MiniMove.move_selection('right')]], { desc = 'Move right' }) H.map('x', maps.down, [[lua MiniMove.move_selection('down')]], { desc = 'Move down' }) H.map('x', maps.up, [[lua MiniMove.move_selection('up')]], { desc = 'Move up' }) H.map('n', maps.line_left, [[lua MiniMove.move_line('left')]], { desc = 'Move line left' }) H.map('n', maps.line_right, [[lua MiniMove.move_line('right')]], { desc = 'Move line right' }) H.map('n', maps.line_down, [[lua MiniMove.move_line('down')]], { desc = 'Move line down' }) H.map('n', maps.line_up, [[lua MiniMove.move_line('up')]], { desc = 'Move line up' }) end H.is_disabled = function() return vim.g.minimove_disable == true or vim.b.minimove_disable == true end H.get_config = function(config) return vim.tbl_deep_extend('force', MiniMove.config, vim.b.minimove_config or {}, config or {}) end -- Utilities ------------------------------------------------------------------ H.error = function(msg) error('(mini.move) ' .. msg, 0) end H.check_type = function(name, val, ref, allow_nil) if type(val) == ref or (ref == 'callable' and vim.is_callable(val)) or (allow_nil and val == nil) then return end H.error(string.format('`%s` should be %s, not %s', name, ref, type(val))) end H.map = function(mode, lhs, rhs, opts) if lhs == '' then return end opts = vim.tbl_deep_extend('force', { silent = true }, opts or {}) vim.keymap.set(mode, lhs, rhs, opts) end H.make_cmd_normal = function(include_undojoin) local normal_command = (include_undojoin and 'undojoin | ' or '') .. 'silent keepjumps normal! ' return function(x) -- Caching and restoring data on every command is not necessary but leads -- to a nicer implementation -- Disable 'mini.bracketed' to avoid unwanted entries to its yank history local cache_minibracketed_disable = vim.b.minibracketed_disable local cache_unnamed_register = { points_to = vim.fn.getreginfo('"').points_to } -- Don't track possible put commands into yank history vim.b.minibracketed_disable = true vim.cmd(normal_command .. x) vim.b.minibracketed_disable = cache_minibracketed_disable vim.fn.setreg('"', cache_unnamed_register) end end H.get_move_state = function() return { buf_id = vim.api.nvim_get_current_buf(), changedtick = vim.b.changedtick, cursor = vim.api.nvim_win_get_cursor(0), mode = vim.fn.mode(), } end H.correct_cursor_col = function(ref_curpos, ref_last_col) -- Use `ref_curpos = getcurpos()` instead of `vim.api.nvim_win_get_cursor(0)` -- allows to also account for `virtualedit=all` local col_diff = vim.fn.col('$') - ref_last_col local new_col = math.max(ref_curpos[3] + col_diff, 1) vim.fn.cursor({ vim.fn.line('.'), new_col, ref_curpos[4], ref_curpos[5] + col_diff }) end H.get_curswant = function() return vim.fn.winsaveview().curswant end H.set_curswant = function(x) if x == nil then return end vim.fn.winrestview({ curswant = x }) end return MiniMove