네오빔 환경설정 구성기록(1)

vim.keymap.set('n', 'q:', common.command_menu)

function M.command_menu(hist_size)
  if hist_size then
    hist_size = tonumber(hist_size)
  else
    hist_size = 20
  end
  
  local histories = vim.fn.execute('history cmd -' .. hist_size .. ',')
  local lines = vim.split(histories, "\n", { trimempty = true })
  -- skip first row
  lines = vim.list_slice(lines, 2)
  -- extract  part
  local extract_ = function(line)
    for _, cmd in line:sub(2):gmatch('%s+(%d*)%s+(.+)') do
      return cmd
    end
  end
  lines = chain.from(lines)
    :apply(extract_)
    :get()
  local select = function()
    return vim.fn.line(".")
  end
  local execute = function(item)
    vim.cmd(lines[item])
  end

  local win, buf = buf_util.floating_window(lines)
  buf_util.add_floating_window_callback(win, buf, select, execute)
end

local common = require('common')
local b_local = { buffer = 0 }

local bufnr = vim.api.nvim_get_current_buf()

vim.bo[bufnr].tabstop = 2
vim.bo[bufnr].shiftwidth = 2
vim.bo[bufnr].softtabstop = 2

common.add_snippet("begin", "BEGIN {\n  ${1:content}\n}", b_local)
common.add_snippet("end", "END {\n  ${1:content}\n}", b_local)
common.add_snippet("for", "for (${1:i = 1; i <= NF; i++}) {}", b_local)
common.add_snippet("forarr", 'for (idx in arr) { print "idx: " idx " arr[idx]: " arr[idx] }', b_local)
common.add_snippet("split", "split(${1:str}, ${2:arr}, ${3:sep})", b_local)
common.add_snippet("strip", 'function strip(str) {\n  gsub(/^\\s|\\s\\$/, "", str)\n  return str\n}', b_local)
common.add_snippet("gsub", "gsub(${1:regex}, ${2:replace}, ${3:str})", b_local)
common.add_snippet("rindex", "function rindex(hay, needle,    arr, lastToken) {\n  lastToken = arr[split(hay, arr, needle)]\n  return length(hay) - length(needle) - length(lastToken) + 1\n}", b_local)
common.add_snippet("include", '@include "common"', b_local)

-- ~/.config/nvim/lua/util/lua.lua
local M = {}

function M.filter(tbl, predicate)
  local filtered = {}
  for _, v in ipairs(tbl) do
    if predicate(v) then
      table.insert(filtered, v)
    end
  end
  return filtered
end

function M.filter_dict(tbl, predicate)
  local filtered = {}
  for k, v in pairs(tbl) do
    if predicate(v) then
      filtered[k] = v
    end
  end
  return filtered
end

function M.map(tbl, mapper)
  local mapped = {}
  for _, v in ipairs(tbl) do
    table.insert(mapped, mapper(v))
  end
  return mapped
end

function M.map_dict(tbl, mapper)
  local mapped = {}
  for k, v in pairs(tbl) do
    mapped[k] = mapper(v)
  end
  return mapped
end

function M.apply(tbl, mapper)
  for i, v in ipairs(tbl) do
    tbl[i] = mapper(v)
  end
  return tbl
end

function M.apply_dict(tbl, mapper)
  for k, v in pairs(tbl) do
    tbl[k] = mapper(v)
  end
  return tbl
end

return M

-- ~/.config/nvim/lua/util/chain.lua
local M  = {}

local Chain = {}
Chain.__index = Chain -- 메타테이블 설정: Chain 테이블에서 메소드를 찾도록 함

-- 생성자 함수 (새로운 Chain 인스턴스를 만듭니다)
function Chain.new(data)
  local self = {
    _data = data or {} -- 내부적으로 데이터를 저장할 필드
  }
  return setmetatable(self, Chain)
end

-- 필터링 메소드
function Chain:filter(predicate)
  local new_data = {}
  for _, v in ipairs(self._data) do
    if predicate(v) then -- filter는 키와 값 모두 받도록 유연하게
      table.insert(new_data, v)
    end
  end
  self._data = new_data -- 필터링된 데이터로 업데이트
  return self           -- 중요: self를 반환하여 체이닝 가능하게 함
end

-- 필터링 메소드
function Chain:filter_dict(predicate)
  local new_data = {}
  for k, v in pairs(self._data) do
    if predicate(v) then -- filter는 키와 값 모두 받도록 유연하게
      new_data[k] = v
    end
  end
  self._data = new_data -- 필터링된 데이터로 업데이트
  return self           -- 중요: self를 반환하여 체이닝 가능하게 함
end

-- 매핑 메소드 (새로운 값을 생성)
function Chain:map(mapper)
  local new_data = {}
  for i, v in ipairs(self._data) do
    new_data[i] = mapper(v) -- map은 값만 받도록 단순하게
  end
  self._data = new_data
  return self
end

-- 매핑 메소드 (새로운 값을 생성)
function Chain:map_dict(mapper)
  local new_data = {}
  for k, v in pairs(self._data) do
    new_data[k] = mapper(v) -- map은 값만 받도록 단순하게
  end
  self._data = new_data
  return self
end

-- 적용 메소드 (데이터를 제자리에서 수정)
function Chain:apply(mapper)
  for i, v in ipairs(self._data) do
    self._data[i] = mapper(v)
  end
  return self
end

-- 적용 메소드 (데이터를 제자리에서 수정)
function Chain:apply_dict(mapper)
  for k, v in pairs(self._data) do
    self._data[k] = mapper(v)
  end
  return self
end

-- 현재 데이터를 가져오는 메소드 (체이닝의 끝)
function Chain:get()
  return self._data
end

function M.from(tbl)
  return Chain.new(tbl)
end

return M

-- ~/.config/nvim/lua/util/buf.lua

local M = {}

function M.floating_window(lines, field)
  local max_line_width = 0
  local contents = {}

  -- set content-extracting function
  local get_content = function(line) return line end
  if field and field ~= "" then
    get_content = function(line) return line[field] end
  end

  for _, line in ipairs(lines) do
    local content = get_content(line)
    table.insert(contents, content)
    max_line_width = math.max(max_line_width, vim.fn.strwidth(content))
  end

  local buf = vim.api.nvim_create_buf(false, true)

  vim.api.nvim_buf_set_lines(buf, 0, -1, false, contents)

  local width = math.max(max_line_width + 2, 80)
  local height = math.max(#lines, 20)

  local win = vim.api.nvim_open_win(buf, true, {
    relative = 'editor',
    width = width,
    height = height,
    row = math.floor((vim.o.lines - height) / 2),
    col = math.floor((vim.o.columns - width) / 2),
    style = 'minimal',
    border = 'rounded',
  })

  vim.api.nvim_buf_set_option(buf, 'modifiable', false)
  vim.cmd("setlocal cursorline")

  return win, buf
end

function M.add_floating_window_callback(win, buf, pre_callback, post_callback)
  local item = nil
  vim.keymap.set('n', '<CR>', function()
    if pre_callback then
      item = pre_callback()
    end
    vim.api.nvim_win_close(win, true)
    if post_callback then
      post_callback(item)
    end
  end, { buffer = buf })
end

return M

-- ~/.config/nvim/lua/common/init.lua

-- Buffer menu popup
function M.buffer_menu(search_text)
  local buf_listed = function(buf) return buf.listed == 1 end
  local bufnr_relpath = function(buf)
    return {
      bufnr = buf.bufnr,
      path = vim.fn.fnamemodify(buf.name, ":.:~")
    }
  end
  local search_match = function(buf) return buf.path:match(search_text) end
  local buffers = chain.from(vim.fn.getbufinfo())
    :filter(buf_listed)
    :apply(bufnr_relpath)
    :get()

  if search_text and search_text ~= "" then
    buffers = chain.from(buffers)
      :filter(search_match)
      :get()
    if #buffers == 0 then
      local empty_msg = "there is no buffer with name matching <" .. search_text .. ">"
      local win, buf = buf_util.floating_window({empty_msg})
      buf_util.add_floating_window_callback(win, buf)
      return
    end
  end

  local select_buffer = function ()
    return buffers[vim.fn.line(".")]
  end

  local load_buffer = function (item)
    vim.cmd("buffer! " .. item.bufnr)
  end

  local win, buf = buf_util.floating_window(buffers, 'path')
  buf_util.add_floating_window_callback(win, buf, select_buffer, load_buffer)

end

-- load scripts
local common = require('common')
vim.keymap.set('n', '<leader><leader><leader>', common.buffer_menu)
vim.api.nvim_create_user_command(
  'BufferMenu',
  function(opts)
    local search_text = opts.fargs[1]
    common.buffer_menu(search_text)
  end,
  {
    nargs = 1,
    desc = "Open buffer menu with optional search text"
  }
)
vim.keymap.set('n', '<leader><leader>s', ':BufferMenu ')