Delete/change/yank around indentation scope

[drowning-cat]

Idea

https://www.reddit.com/r/neovim/comments/1i8eyyq/remove_outer_indentation_with_miniindentscope

Video

scope.mp4

Description

local function scope_example()
  vim.print(1)
  vim.print(2)
end

After gcS, the text will be:

-- local function scope_example()
vim.print(1)
vim.print(2)
-- end

After dS, the text will be:

vim.print(1)
vim.print(2)

After cS, the text will be:

|
vim.print(1)
vim.print(2)

After yS, the default register will contain (linewise):

local function scope_example()
end

Support for vim.v.operator:

local function scope_outer()
  local function scope_example()
    vim.print(1)
    vim.print(2)
  end
end

After 2dS, the text will be:

local function scope_example()
  vim.print(1)
  vim.print(2)
end

Code

Manual (recommended)

See neovim/neovim#34221

Snacks.scope.get + treesitter

Try using manual first

I won't maintain it

It doesn't work when treesitter isn't applied

Fine, you win

keys = {
  {
    'S',
    mode = 'o',
    desc = 'Delete/Change/Yank/Comment around scope',
    function()
      local operator, count1 = vim.v.operator, vim.v.count1

      if not vim.list_contains({ 'd', 'c', 'y', 'g@' }, operator) then
        return
      end

      local win = vim.api.nvim_get_current_win()

      Snacks.scope.get(function(_scope)
        local buf = _scope.buf

        local row, col = table.unpack(vim.api.nvim_win_get_cursor(win))

        ---@param scope snacks.scope.Scope
        ---@param count integer
        local get_scope = function(scope, count)
          local indent = scope.indent
          -- NOTE: Use inner scope on edge
          -- if row < scope.from then
          if row <= scope.from then
            count = count + 1
          end
          for _ = 2, count do
            repeat
              scope = scope:parent() ---@diagnostic disable-line: cast-local-type
            until not scope or scope.indent < indent
            if not scope then
              return nil
            end
            indent = scope.indent
          end
          return scope
        end

        local scope = get_scope(_scope, count1)

        if not scope then
          return
        end

        local indent_width = scope:inner().indent - scope.indent

        local outer_start1, outer_end1 = scope.from, scope.to
        local inner_start1, inner_end1 = scope:inner().from, scope:inner().to

        local outer_start, outer_end = outer_start1 - 1, outer_end1 - 1
        local inner_start, inner_end = inner_start1 - 1, inner_end1 - 1

        local ns = vim.api.nvim_create_namespace 'scope_border'

        vim.hl.range(buf, ns, 'Substitute', { outer_start, 0 }, { inner_start - 1, -1 })
        vim.hl.range(buf, ns, 'Substitute', { inner_end + 1, 0 }, { outer_end, -1 })

        vim.defer_fn(function()
          vim.api.nvim_buf_clear_namespace(buf, ns, 0, -1)

          -- Yank, Delete, Change, -Comment
          if vim.list_contains({ 'd', 'c', 'y' }, operator) then
            local copy = {
              table.unpack(vim.api.nvim_buf_get_lines(buf, outer_start, inner_start, false)),
              table.unpack(vim.api.nvim_buf_get_lines(buf, inner_end + 1, outer_end + 1, false)),
            }
            vim.fn.setreg(vim.v.register, table.concat(copy, '\n'), 'l')
          end

          if operator == 'y' then
            return
          end

          -- Delete, Change, Comment
          local inner_lines
          if inner_start == inner_end then
            inner_lines = vim.api.nvim_buf_get_lines(buf, inner_start, inner_start + 1, false)
          else
            inner_lines = vim.api.nvim_buf_get_lines(buf, inner_start, inner_end + 1, false)
          end

          ---@param what 'outer'|'inner'
          ---@param with string[]
          local replace_scope = function(what, with)
            vim._with({ lockmarks = true }, function()
              if what == 'outer' then
                vim.api.nvim_buf_set_lines(buf, outer_start, outer_end + 1, false, with)
              end
              if what == 'inner' then
                vim.api.nvim_buf_set_lines(buf, inner_start, inner_end + 1, false, with)
              end
            end)
          end

          local get_indent = function(lnum)
            return Snacks.scope.IdentScope.get_indent(lnum)
          end

          -- Dedent `inner_lines[]`
          for i, line in ipairs(inner_lines) do
            local line_indent = get_indent(inner_start + i)
            inner_lines[i] = vim.text.indent(line_indent - indent_width, line, { expandtab = 1 })
          end

          local cursor_dedent = {
            math.max(1, row - (inner_start - outer_start)),
            math.max(0, col - indent_width),
          }

          if operator == 'd' then
            replace_scope('outer', inner_lines)
            vim.api.nvim_win_set_cursor(win, cursor_dedent)
          end

          if operator == 'c' then
            replace_scope('outer', { '', table.unpack(inner_lines) })
            vim.api.nvim_win_set_cursor(win, { inner_start, 0 })
            vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes('<C-f>', true, false, true), 'n', false)
          end

          if operator == 'g@' then
            replace_scope('inner', inner_lines)
            require('vim._comment').toggle_lines(outer_start1, inner_start1 - 1)
            require('vim._comment').toggle_lines(inner_end1 + 1, outer_end1)
            vim.api.nvim_win_set_cursor(win, { row, cursor_dedent[2] })
          end
        end, 150)
      end, { cursor = false, treesitter = { enabled = true } })
    end,
  },
},

Edge cases

• Works linewise, not charwise.
• Does not handle multi-line edges well.
• gcS undo does not restore the cursor properly (see Restore cursor position when triggering undo neovim/neovim#5989).
• Treesitter skips the scope if either or both of the edge lines are commented out.
• Treesitter gcS only comments the scope, it does not uncomment.

[dpetka2001]

That's really cool!!! Tnx for sharing this 😄

[drowning-cat]

I updated the code, and it should now work as expected. Initially, I only removed the first and last lines, but now the code replaces the current scope with the inner scope. I may also fix a few bugs in the future.

[dpetka2001]

Like I said it's really cool, but I personally don't use this feature much. I also saw that post on Reddit and made an attempt to replicate the behavior. It worked at first, but then something broke. But your solution is much cleaner than what I did (I also just removed the first and last lines insted of current scope and only took the delete operator under consideration).

I have this bookmarked in case I'd like to use it in the future. Maybe I will, maybe not, who knows? But again, thank you for sharing this, because it's always cool to see new and cleaner/better implementations/ideas 😄