path: root/dot_config/herdr/plugins/github/herdr-splits-d880c4924f2b/tests/test_nav.lua

local T
local expect = MiniTest.expect
local child = MiniTest.new_child_neovim()

local source = debug.getinfo(1, 'S').source
local root = vim.fn.fnamemodify(source:sub(2), ':p:h:h')

T = MiniTest.new_set({
  hooks = {
    pre_case = function()
      child.restart({ '--noplugin', '-u', 'NONE', '-i', 'NONE' })
      child.cmd('set runtimepath^=' .. vim.fn.fnameescape(root))
    end,
    post_case = function()
      child.stop()
    end,
  },
})

T['moves through native horizontal and vertical splits without delegation'] = function()
  local result = child.lua_func(function()
    local calls = {}
    package.loaded['herdr-splits.herdr'] = {
      focus_pane = function(direction) calls[#calls + 1] = direction end,
      is_in_session = function() return false end,
    }
    package.loaded['herdr-splits.nav'] = nil
    local nav = require('herdr-splits.nav')

    vim.o.splitright = true
    vim.cmd('vsplit')
    local horizontal = vim.api.nvim_tabpage_list_wins(0)
    table.sort(horizontal, function(a, b)
      return vim.api.nvim_win_get_position(a)[2] < vim.api.nvim_win_get_position(b)[2]
    end)
    vim.api.nvim_set_current_win(horizontal[1])
    nav.move_cursor('right')
    local moved_right = vim.api.nvim_get_current_win() == horizontal[2]

    vim.cmd('only')
    vim.o.splitbelow = true
    vim.cmd('split')
    local vertical = vim.api.nvim_tabpage_list_wins(0)
    table.sort(vertical, function(a, b)
      return vim.api.nvim_win_get_position(a)[1] < vim.api.nvim_win_get_position(b)[1]
    end)
    vim.api.nvim_set_current_win(vertical[1])
    nav.move_cursor('down')
    local moved_down = vim.api.nvim_get_current_win() == vertical[2]

    return { moved_right = moved_right, moved_down = moved_down, calls = calls }
  end)

  expect.equality(result, { moved_right = true, moved_down = true, calls = {} })
end

T['applies typed navigation counts without wrapping or delegation'] = function()
  child.lua_func(function()
    _G.nav_delegations = {}
    package.loaded['herdr-splits.herdr'] = {
      is_in_session = function() return false end,
      focus_pane = function(direction)
        _G.nav_delegations[#_G.nav_delegations + 1] = direction
        return true
      end,
    }
    package.loaded['herdr-splits.nav'] = nil
    local nav = require('herdr-splits.nav')

    vim.o.splitright = true
    for _ = 1, 3 do
      vim.cmd('vsplit')
    end
    _G.nav_count_wins = vim.api.nvim_tabpage_list_wins(0)
    table.sort(_G.nav_count_wins, function(a, b)
      return vim.api.nvim_win_get_position(a)[2] < vim.api.nvim_win_get_position(b)[2]
    end)
    vim.api.nvim_set_current_win(_G.nav_count_wins[1])
    vim.keymap.set('n', 'x', function()
      nav.move_cursor('right', { at_edge = 'stop' })
    end)
  end)

  child.type_keys('2x')
  local after_two = child.lua_get('vim.api.nvim_get_current_win() == _G.nav_count_wins[3]')
  child.type_keys('5x')
  local exhausted_at_last = child.lua_get('vim.api.nvim_get_current_win() == _G.nav_count_wins[4]')
  child.type_keys('5x')
  local stayed_at_last = child.lua_get('vim.api.nvim_get_current_win() == _G.nav_count_wins[4]')
  local delegations = child.lua_get('_G.nav_delegations')

  expect.equality({
    after_two = after_two,
    exhausted_at_last = exhausted_at_last,
    stayed_at_last = stayed_at_last,
    delegations = delegations,
  }, {
    after_two = true,
    exhausted_at_last = true,
    stayed_at_last = true,
    delegations = {},
  })
end

T['delegates normal floats but not embedded floats'] = function()
  local result = child.lua_func(function()
    local calls = {}
    package.loaded['herdr-splits.herdr'] = {
      focus_pane = function(direction)
        calls[#calls + 1] = direction
        return true
      end,
      is_in_session = function() return false end,
    }
    package.loaded['herdr-splits.nav'] = nil
    local nav = require('herdr-splits.nav')

    local normal = vim.api.nvim_open_win(vim.api.nvim_create_buf(false, true), true, {
      relative = 'editor', row = 1, col = 1, width = 12, height = 3, zindex = 50,
    })
    nav.move_cursor('right')
    local normal_stayed = vim.api.nvim_get_current_win() == normal

    vim.api.nvim_open_win(vim.api.nvim_create_buf(false, true), true, {
      relative = 'editor', row = 2, col = 2, width = 12, height = 3, zindex = 49,
    })
    nav.move_cursor('left')

    return { calls = calls, normal_stayed = normal_stayed }
  end)

  expect.equality(result, {
    calls = { 'right' },
    normal_stayed = true,
  })
end

T['applies no-session stop, wrap, and callback edge behavior'] = function()
  local result = child.lua_func(function()
    package.loaded['herdr-splits.herdr'] = {
      is_in_session = function() return false end,
    }
    package.loaded['herdr-splits.nav'] = nil
    local nav = require('herdr-splits.nav')

    local function horizontal_pair()
      vim.cmd('only')
      vim.o.splitright = true
      vim.cmd('vsplit')
      local wins = vim.api.nvim_tabpage_list_wins(0)
      table.sort(wins, function(a, b)
        return vim.api.nvim_win_get_position(a)[2] < vim.api.nvim_win_get_position(b)[2]
      end)
      vim.api.nvim_set_current_win(wins[1])
      return wins
    end

    local stop_wins = horizontal_pair()
    nav.move_cursor('left', { at_edge = 'stop' })
    local stopped = vim.api.nvim_get_current_win() == stop_wins[1]

    local wrap_wins = horizontal_pair()
    nav.move_cursor('left', { at_edge = 'wrap' })
    local wrapped = vim.api.nvim_get_current_win() == wrap_wins[2]

    local callback_wins = horizontal_pair()
    local callback = {}
    nav.move_cursor('left', {
      at_edge = function(ctx)
        callback.direction = ctx.direction
        callback.is_sidebar = ctx.is_sidebar
        callback.has_split = type(ctx.split) == 'function'
        callback.has_wrap = type(ctx.wrap) == 'function'
        ctx.wrap()
      end,
    })
    callback.wrapped = vim.api.nvim_get_current_win() == callback_wins[2]

    return {
      stopped = stopped,
      wrapped = wrapped,
      callback = callback,
    }
  end)

  expect.equality(result, {
    stopped = true,
    wrapped = true,
    callback = {
      direction = 'left',
      is_sidebar = false,
      has_split = true,
      has_wrap = true,
      wrapped = true,
    },
  })
end

T['creates local edge splits and preserves split preferences'] = function()
  local result = child.lua_func(function()
    package.loaded['herdr-splits.herdr'] = {
      is_in_session = function() return false end,
    }
    package.loaded['herdr-splits.nav'] = nil
    local nav = require('herdr-splits.nav')
    local cases = {}

    local function exercise(direction, preference)
      vim.cmd('only')
      vim.o.splitright = preference
      vim.o.splitbelow = preference
      local before = #vim.api.nvim_tabpage_list_wins(0)
      local original = vim.api.nvim_get_current_win()

      nav.move_cursor(direction, { at_edge = 'split' })

      local current = vim.api.nvim_get_current_win()
      local original_position = vim.api.nvim_win_get_position(original)
      local current_position = vim.api.nvim_win_get_position(current)
      local placement_matches_preference
      if direction == 'left' or direction == 'right' then
        if preference then
          placement_matches_preference = current_position[2] > original_position[2]
        else
          placement_matches_preference = current_position[2] < original_position[2]
        end
      elseif preference then
        placement_matches_preference = current_position[1] > original_position[1]
      else
        placement_matches_preference = current_position[1] < original_position[1]
      end

      cases[#cases + 1] = {
        direction = direction,
        preference = preference,
        created_one = #vim.api.nvim_tabpage_list_wins(0) == before + 1,
        focused_new = current ~= original,
        placement_matches_preference = placement_matches_preference,
        splitright_restored = vim.o.splitright == preference,
        splitbelow_restored = vim.o.splitbelow == preference,
      }
    end

    for _, direction in ipairs({ 'left', 'right', 'up', 'down' }) do
      exercise(direction, false)
      exercise(direction, true)
    end
    return cases
  end)

  local expected = {}
  for _, direction in ipairs({ 'left', 'right', 'up', 'down' }) do
    for _, preference in ipairs({ false, true }) do
      expected[#expected + 1] = {
        direction = direction,
        preference = preference,
        created_one = true,
        focused_new = true,
        placement_matches_preference = true,
        splitright_restored = true,
        splitbelow_restored = true,
      }
    end
  end
  expect.equality(result, expected)
end

T['uses Herdr neighbors and falls back locally on focus or edge failures'] = function()
  local result = child.lua_func(function()
    local edge_queue = { false, false, '<nil>' }
    local focus_queue = { true, false }
    local calls = {}
    package.loaded['herdr-splits.herdr'] = {
      is_in_session = function() return true end,
      unzoom_enabled = function() return false end,
      current_pane_at_edge = function(direction)
        calls[#calls + 1] = 'edge:' .. direction
        local value = table.remove(edge_queue, 1)
        if value == '<nil>' then return nil end
        return value
      end,
      focus_pane = function(direction)
        calls[#calls + 1] = 'focus:' .. direction
        return table.remove(focus_queue, 1)
      end,
    }
    package.loaded['herdr-splits.nav'] = nil
    local nav = require('herdr-splits.nav')

    local function at_left()
      vim.cmd('only')
      vim.o.splitright = true
      vim.cmd('vsplit')
      local wins = vim.api.nvim_tabpage_list_wins(0)
      table.sort(wins, function(a, b)
        return vim.api.nvim_win_get_position(a)[2] < vim.api.nvim_win_get_position(b)[2]
      end)
      vim.api.nvim_set_current_win(wins[1])
      return wins
    end

    local success_wins = at_left()
    nav.move_cursor('left')
    local focus_success_stays = vim.api.nvim_get_current_win() == success_wins[1]

    local failure_wins = at_left()
    nav.move_cursor('left')
    local focus_failure_wraps = vim.api.nvim_get_current_win() == failure_wins[2]

    local unknown_wins = at_left()
    nav.move_cursor('left')
    local unknown_wraps = vim.api.nvim_get_current_win() == unknown_wins[2]

    return {
      focus_success_stays = focus_success_stays,
      focus_failure_wraps = focus_failure_wraps,
      unknown_wraps = unknown_wraps,
      calls = calls,
    }
  end)

  expect.equality(result, {
    focus_success_stays = true,
    focus_failure_wraps = true,
    unknown_wraps = true,
    calls = {
      'edge:left', 'focus:left',
      'edge:left', 'focus:left',
      'edge:left',
    },
  })
end

T['unzooms and retries native movement before querying Herdr edges'] = function()
  local result = child.lua_func(function()
    local calls = {}
    local start_win = vim.api.nvim_get_current_win()
    package.loaded['herdr-splits.herdr'] = {
      is_in_session = function() return true end,
      unzoom_enabled = function() return true end,
      current_pane_is_zoomed = function()
        calls[#calls + 1] = 'zoomed'
        return true
      end,
      unzoom = function()
        calls[#calls + 1] = 'unzoom'
        local old_splitright = vim.o.splitright
        vim.o.splitright = true
        vim.cmd('vsplit')
        vim.api.nvim_set_current_win(start_win)
        vim.o.splitright = old_splitright
        return true
      end,
      current_pane_at_edge = function()
        calls[#calls + 1] = 'edge'
        return false
      end,
      focus_pane = function()
        calls[#calls + 1] = 'focus'
        return true
      end,
    }
    package.loaded['herdr-splits.nav'] = nil
    require('herdr-splits.nav').move_cursor('right')

    return {
      moved = vim.api.nvim_get_current_win() ~= start_win,
      windows = #vim.api.nvim_tabpage_list_wins(0),
      calls = calls,
    }
  end)

  expect.equality(result, { moved = true, windows = 2, calls = { 'zoomed', 'unzoom' } })
end

T['wraps through the reverse Herdr neighbor unless nav_at_edge stops it'] = function()
  local result = child.lua_func(function()
    local mode = 'wrap'
    local calls = {}
    package.loaded['herdr-splits.herdr'] = {
      is_in_session = function() return true end,
      unzoom_enabled = function() return false end,
      current_pane_at_edge = function(direction)
        calls[#calls + 1] = 'edge:' .. direction
        return direction == 'left'
      end,
      nav_at_edge = function() return mode end,
      focus_pane = function(direction)
        calls[#calls + 1] = 'focus:' .. direction
        return true
      end,
    }
    package.loaded['herdr-splits.nav'] = nil
    local nav = require('herdr-splits.nav')

    local function at_left()
      vim.cmd('only')
      vim.o.splitright = true
      vim.cmd('vsplit')
      local wins = vim.api.nvim_tabpage_list_wins(0)
      table.sort(wins, function(a, b)
        return vim.api.nvim_win_get_position(a)[2] < vim.api.nvim_win_get_position(b)[2]
      end)
      vim.api.nvim_set_current_win(wins[1])
      return wins
    end

    local herdr_wrap_wins = at_left()
    nav.move_cursor('left')
    local herdr_wrap_stays = vim.api.nvim_get_current_win() == herdr_wrap_wins[1]

    mode = 'stop'
    local local_wrap_wins = at_left()
    nav.move_cursor('left')
    local local_wraps = vim.api.nvim_get_current_win() == local_wrap_wins[2]

    return { herdr_wrap_stays = herdr_wrap_stays, local_wraps = local_wraps, calls = calls }
  end)

  expect.equality(result, {
    herdr_wrap_stays = true,
    local_wraps = true,
    calls = { 'edge:left', 'edge:right', 'focus:right', 'edge:left' },
  })
end

T['command-line window delegates to Herdr at the screen edge and never wincmds'] = function()
  local result = child.lua_func(function()
    local calls = {}
    local edge = false
    local nav_mode = 'wrap'
    package.loaded['herdr-splits.win'] = {
      is_command_line_window = function() return true end,
      is_floating = function() return false end,
      is_embedded_floating_window = function() return false end,
      is_ignored_or_preview = function() return false end,
      dir_keys = { left = 'h', right = 'l', up = 'k', down = 'j' },
      dir_keys_reverse = { left = 'l', right = 'h', up = 'j', down = 'k' },
      reverse_direction = { left = 'right', right = 'left', up = 'down', down = 'up' },
    }
    package.loaded['herdr-splits.herdr'] = {
      is_in_session = function() return true end,
      current_pane_at_edge = function(direction)
        calls[#calls + 1] = 'edge:' .. direction
        return edge
      end,
      nav_at_edge = function() return nav_mode end,
      focus_pane = function(direction)
        calls[#calls + 1] = 'focus:' .. direction
        return true
      end,
    }
    package.loaded['herdr-splits.nav'] = nil
    local nav = require('herdr-splits.nav')

    -- single window: will_wrap is true in every direction, mirroring the
    -- full-width/bottom command-line window geometry.
    vim.cmd('only')

    edge = false
    nav.move_cursor('left')
    local c1 = vim.deepcopy(calls); calls = {}

    edge = true
    nav_mode = 'wrap'
    nav.move_cursor('right')
    local c2 = vim.deepcopy(calls); calls = {}

    nav_mode = 'stop'
    nav.move_cursor('right')
    local c3 = vim.deepcopy(calls)

    return { neighbor = c1, wrap_reverse = c2, stop_noop = c3 }
  end)

  expect.equality(result, {
    neighbor = { 'edge:left', 'focus:left' },
    wrap_reverse = { 'edge:right', 'focus:left' },
    stop_noop = { 'edge:right' },
  })
end

T['command-line window no-ops silently when not at a screen edge'] = function()
  local result = child.lua_func(function()
    package.loaded['herdr-splits.win'] = {
      is_command_line_window = function() return true end,
      is_floating = function() return false end,
      is_embedded_floating_window = function() return false end,
      is_ignored_or_preview = function() return false end,
      dir_keys = { left = 'h', right = 'l', up = 'k', down = 'j' },
      dir_keys_reverse = { left = 'l', right = 'h', up = 'j', down = 'k' },
      reverse_direction = { left = 'right', right = 'left', up = 'down', down = 'up' },
    }
    local focused = {}
    package.loaded['herdr-splits.herdr'] = {
      is_in_session = function() return true end,
      current_pane_at_edge = function() return false end,
      nav_at_edge = function() return 'wrap' end,
      focus_pane = function(d) focused[#focused + 1] = d; return true end,
    }
    package.loaded['herdr-splits.nav'] = nil
    local nav = require('herdr-splits.nav')

    vim.o.splitright = true
    vim.cmd('vsplit')
    local wins = vim.api.nvim_tabpage_list_wins(0)
    table.sort(wins, function(a, b)
      return vim.api.nvim_win_get_position(a)[2] < vim.api.nvim_win_get_position(b)[2]
    end)
    -- left window: 'right' has a Neovim neighbor -> will_wrap == false
    vim.api.nvim_set_current_win(wins[1])
    nav.move_cursor('right')
    return { stayed = vim.api.nvim_get_current_win() == wins[1], focused = focused }
  end)

  -- Without the guard, wincmd l would move to wins[2]; with it, silent no-op.
  expect.equality(result, { stayed = true, focused = {} })
end

return T