mvim - mini neovim config

init.lua

-- minimal vim
--
-- it's pure vim, with plugins for things that I wish were defaults:
--  - mini.files for an editable :Ex file explorer
--  - quicker for an editable quickfixlist (bonus: prettier)
--  - mini.diff+mini.git for displaying git diff hunks

-- +----------+
-- | PACKAGES |
-- +----------+

-- TODO: use vim.pack.add when it's in the v0.12
-- Put this at the top of 'init.lua'
local path_package = vim.fn.stdpath('data') .. '/site'
local mini_path = path_package .. '/pack/deps/start/mini.nvim'
if not vim.loop.fs_stat(mini_path) then
  vim.cmd('echo "Installing `mini.nvim`" | redraw')
  local clone_cmd = {
    'git', 'clone', '--filter=blob:none',
    '--branch', 'stable',
    'https://github.com/nvim-mini/mini.nvim', mini_path
  }
  vim.fn.system(clone_cmd)
  vim.cmd('packadd mini.nvim | helptags ALL')
  vim.cmd('echo "Installed `mini.nvim`" | redraw')
end

local quicker_path = path_package .. '/pack/deps/start/quicker.nvim'
if not vim.loop.fs_stat(quicker_path) then
  vim.cmd('echo "Installing `quicker.nvim`" | redraw')
  local clone_cmd = {
    'git', 'clone', '--filter=blob:none',
    'https://github.com/stevearc/quicker.nvim', quicker_path
  }
  vim.fn.system(clone_cmd)
  vim.cmd('packadd quicker.nvim | helptags ALL')
  vim.cmd('echo "Installed `quicker.nvim`" | redraw')
end

require("mini.diff").setup()
require("mini.git").setup()
require("mini.files").setup()
vim.keymap.set("n", "<leader>e", MiniFiles.open, {})
require("quicker").setup()

-- +---------+
-- | OPTIONS |
-- +---------+
-- to generate these titles, use "boxes -d stone"

-- need the leader to be space
vim.g.mapleader = " "
vim.g.maplocalleader = " "

-- minimalism
vim.o.laststatus = 2
vim.o.cmdheight = 1 -- tried at zero but handy when typing numbers e.g. 80G in insert mode
vim.opt.list = false
vim.opt.listchars = { space = "⋅", tab = "→ " }

-- behaviour i like
vim.o.splitright = true
vim.o.splitbelow = true
vim.o.undofile = true
vim.o.wrap = false
vim.o.tabstop = 2 -- how wide the tab is
vim.o.shiftwidth = 2 -- how much to shift by when tab pressed
vim.o.expandtab = true -- spaces by default
vim.o.foldlevelstart = 99 -- disable folds
vim.opt.isfname:append("32") -- need for 'gf' to work with files that contain spaces (ASCII 32)

-- some shell stuff, huh???
vim.g.shell = "/bin/zsh"
vim.o.termguicolors = true -- setting this explicitly as otherwise opening a neovim tab in tmux via send-keys

-- local init.lua! for more: `:h exrc`
vim.o.exrc = true
vim.o.secure = true

-- +-----------+
-- | FUNCTIONS |
-- +-----------+
                                                    
-- save if not exists
function save_if_not_exists()
	local path = vim.fn.expand("%:p:h") -- Get the directory of the current file
	if vim.fn.isdirectory(path) == 0 then
		vim.fn.mkdir(path, "p") -- Create the directory if it doesn't exist
	end
	vim.cmd("write") -- Save the file
end

function exec_to_buffer()
	vim.ui.input({ prompt = "$ " }, function(c)
		if not c or c == "" then
			return
		end
		c = vim.fn.expandcmd(c)
		vim.cmd("noswapfile vnew")
		vim.bo.buftype = "nofile"
		vim.bo.bufhidden = "wipe"
		vim.api.nvim_buf_set_lines(0, 0, -1, false, vim.fn.systemlist(c))
	end)
end

local function get_selection()
  vim.cmd('noau normal! "vy"')
  return vim.fn.getreg('v')
end

local function search_files(text)
  local files = vim.fn.glob("**/*" .. text .."*", false, true)

  local entries = {}
  for _, f in pairs(files) do
    table.insert(entries, {
      filename = f,
      lnum = 1,
      col = 1
    })
  end

  vim.fn.setqflist(entries, "r")
  vim.cmd("copen")
  vim.cmd("wincmd j")
end

-- +-------------+
-- | KEYBINDINGS |
-- +-------------+

-- more convenient clipboard!
vim.keymap.set({ "n", "v" }, "<leader>c", '"+', { silent = true })

-- backspace to go to "last" file
vim.keymap.set("n", "<BS>", ":b#<CR>", { silent = true })

-- copying keeps selection
vim.keymap.set("n", "gy", "`[v`]", { silent = true })
vim.keymap.set("n", "gp", "`[v`]", { silent = true })

-- convenient selection
vim.keymap.set({ "n", "v" }, "<leader>y", [["+y]])
vim.keymap.set({ "n", "v" }, "<leader>p", [["+p]])

-- quickfix list
vim.keymap.set("n", "]c", ":cn<CR>", { silent = true })
vim.keymap.set("n", "[c", ":cp<CR>", { silent = true })
vim.keymap.set("n", "<leader>q", ":copen<CR>", { silent = true })
-- location list
vim.keymap.set("n", "]l", ":ln<CR>", { silent = true })
vim.keymap.set("n", "[l", ":lp<CR>", { silent = true })
vim.keymap.set("n", "<leader>l", ":lopen<CR>", { silent = true })

-- escape in the terminal
vim.keymap.set("t", "<ESC>", [[<C-\><C-n>]])
-- insert on terminal open
vim.api.nvim_create_autocmd({ "TermOpen" }, {
	callback = function()
		vim.cmd([[startinsert]])
	end,
})

-- lets you execute any command and get the output in a tmp buffer
vim.keymap.set("n", "<leader>c", exec_to_buffer)

vim.api.nvim_create_user_command("W", save_if_not_exists, { nargs = 0 })

-- LSP
-- vim.keymap.set("n", "gd", require("dom.go_to_definition"))
vim.keymap.set("n", "gr", vim.lsp.buf.references)
vim.keymap.set("n", "<leader>rn", vim.lsp.buf.rename)
vim.keymap.set("n", "<leader>a", vim.lsp.buf.code_action)
vim.keymap.set("n", "[d", vim.diagnostic.goto_prev)
vim.keymap.set("n", "]d", vim.diagnostic.goto_next)
vim.keymap.set("n", "K", vim.lsp.buf.hover)

-- quick open
vim.keymap.set("n", "<leader>o", [[:!open "%"<CR>]], { silent = true, desc = "Open file in default app" })

vim.cmd.cabbrev[[ei e ~/.config/mvim/init.lua]]
vim.cmd.cabbrev[[ep e .nvim.lua]]
vim.cmd.cabbrev[[es e .dt/scratch]]
vim.cmd.cabbrev[[en e ~/notes/]]
-- vim.keymap.set("n", "<leader>ot", ":e .dt/tasks<CR>", { silent = true, desc = "Open tasks" })
-- vim.keymap.set("n", "<leader>op", ":e .dt/playbook.md<CR>", { silent = true, desc = "Open Playbook" })

vim.cmd[[cabbrev G grep]]

vim.api.nvim_create_user_command("F", function (opts) search_files(opts.args) end, {nargs = 1})

vim.api.nvim_create_user_command("Todo", function ()
  vim.cmd("vimgrep /TODO/ **")
  vim.cmd("copen")
end,
{nargs = 0})

-- https://github.com/FractalCodeRicardo/dev-config/blob/master/nvim/lua/my/terminal.lua

vim.cmd.cabbrev[[cbox .!boxes -d stone<CR>gpgc]]

-- +---------------+
-- | ERROR FORMATS |
-- +---------------+

_G.ef = {
  go_test = "%*[^\"]\"%f\"%*\\D%l: %m,\"%f\"%*\\D%l: %m,%-Gg%\\?make[%*\\d]: *** [%f:%l:%m,%-Gg%\\?make: *** [%f:%l:%m,%-G%f:%l: (Each undeclared identifier is reported only once,%-G%f:%l: for each function it appears in.),%-GIn file included from %f:%l:%c:,%-GIn file included from %f:%l:%c\\,,%-GIn file included from %f:%l:%c,%-GIn file included from %f:%l,%-G%*[ ]from %f:%l:%c,%-G%*[ ]from %f:%l:,%-G%*[ ]from %f:%l\\,,%-G%*[ ]from %f:%l,%f:%l:%c:%m,%f(%l):%m,%f:%l:%m,\"%f\"\\, line %l%*\\D%c%*[^ ] %m,%D%*\\a[%*\\d]: Entering directory %*[`']%f',%X%*\\a[%*\\d]: Leaving directory %*[`']%f',%D%*\\a: Entering directory %*[`']%f',%X%*\\a: Leaving directory %*[`']%f',%DMaking %*\\a in %f,%f|%l| %m",
  go_build = [[%A%f:%l:%c:\ %m,%-G%.%#]],
}

-- +---------+
-- | RUNNERS |
-- +---------+

_G.runner = ""
local runners = {
  run = {"make run", ef.go_build},
  test = {"make test", ef.go_test},
}

function set_runner(name)
  local runner = runners[name]
  if not runner then return end
  _G.runner = name
  vim.o.makeprg = runner[1]
  vim.o.errorformat = runner[2]
end

function _G._runner_status()
  if runner == "" then return "" end
  return "<" .. runner .. ">"
end

vim.api.nvim_create_user_command("Make", function(opts)
  if opts.args ~= "" then
    set_runner(opts.args)
  end
  vim.cmd.make()
end, {
  nargs = "?",
  complete = function(ArgLead, CmdLine)
    local args = vim.split(CmdLine, "%s+", { trimempty = true })
    if #args >= 2 then return {} end
    local keys = {}
    for key, _ in pairs(runners) do
        table.insert(keys, key)
    end
    return keys
  end,
})

vim.cmd.cabbrev[[M Make]]

-- +--------------+
-- | MAKE ON SAVE |
-- +--------------+


local make_on_save = false
vim.api.nvim_create_user_command("MakeOnSave", function()
  make_on_save = not make_on_save
  vim.cmd.redrawstatus()
end, {})

vim.api.nvim_create_autocmd('BufWritePost', {
  group = vim.api.nvim_create_augroup('make_on_save', { clear = true }),
  pattern = '*',
  callback = function(ctx)
    if make_on_save then
      vim.cmd.make()
    end
  end,
})

function _G._make_on_save_status()
  if make_on_save then
    return "¤"
  end
  return ""
end

-- +-------------+
-- | STATUS LINE |
-- +-------------+

function _G._status()
  local qf_list = vim.fn.getqflist()
  local count = #qf_list
  return string.format("q=%d", count)
end

local statusline = {
  '%t%m',
  '%=',
  '%y',
  ' ',
  '%{%v:lua._status()%}',
  ' ',
  '%{%v:lua._runner_status()%}',
  ' ',
  '%{%v:lua._make_on_save_status()%}',
  ' ',
}

vim.o.statusline = table.concat(statusline, '')

-- +--------------+
-- | EXPERIMENTAL |
-- +--------------+