dotfiles/init.lua
2024-02-25 09:27:42 +09:00

946 lines
24 KiB
Lua
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

----GENERAL SETTINGS
local opt = vim.opt
vim.g.mapleader = " "
opt.helplang = "ja", "en"
opt.tabstop = 2
opt.shiftwidth = 2
opt.expandtab = true
opt.list = true
opt.listchars = { tab = "»-", trail = "-", eol = "", extends = "»", precedes = "«", nbsp = "%" }
opt.wrap = true
opt.signcolumn = "yes"
opt.smartcase = true
opt.ignorecase = true
opt.wrapscan = true
opt.hidden = true
opt.startofline = false
opt.showmatch = true
opt.matchtime = 1
opt.guicursor = ""
opt.cursorline = true
opt.wildmenu = true
opt.number = true
opt.showcmd = true
opt.autoread = true
opt.hlsearch = true
opt.backspace:append({ "indent", "eol", "start" })
opt.showtabline = 1
opt.laststatus = 3
opt.ambiwidth = "single"
opt.confirm = true
opt.pumblend = 0
opt.winblend = 0
opt.mouse = "a"
opt.cmdheight = 2
opt.timeout = true
opt.ttimeout = true
opt.ttimeoutlen = 10
opt.clipboard:append({ "unnamedplus" })
opt.termguicolors = true
opt.showmode = false
opt.completeopt:append({ "menuone", "noinsert" })
opt.backup = false
opt.swapfile = false
opt.encoding = "utf-8"
opt.fileencodings = { "utf-8", "iso-2022-jp", "cp932", "euc-jp", "sjis" }
vim.opt.shortmess:append("I")
vim.cmd("set completeopt-=preview")
----ADVANCED SETTINGS
--KEEP CURSOR
vim.api.nvim_create_autocmd({ "BufReadPost" }, {
pattern = { "*" },
callback = function()
vim.api.nvim_exec('silent! normal! g`"zv', false)
end,
})
----KEY MAPPING
--EDIT
vim.keymap.set("n", "ew", ":<C-u>w<CR>")
vim.keymap.set("n", "eq", ":<C-u>wq<CR>")
vim.keymap.set("n", "Q", ":<C-u>quit!<CR>")
vim.keymap.set("n", "<leader>q", ":<C-u>bd<CR>")
vim.keymap.set("n", "<C-s>", ":<C-u>%s///cg<Left><Left><Left><Left>")
vim.keymap.set("n", "<C-c>", ":<C-u>echo wordcount()['chars']<CR>")
--TAB
vim.keymap.set("n", "<leader><TAB>", ":bprev<CR>", { silent = true })
vim.keymap.set("n", "<leader>t", ":tabclose<CR>", { silent = true })
vim.keymap.set("n", "]b", ":bnext<CR>", { silent = true })
--SPLIT
vim.keymap.set("n", "sv", ":<C-u>vsplit<CR>", { silent = true })
vim.keymap.set("n", "sp", ":<C-u>split<CR>", { silent = true })
--NOP
vim.keymap.set("n", "<MiddleMouse>", "<Nop>")
vim.keymap.set("n", "<2-MiddleMouse>", "<Nop>")
vim.keymap.set("n", "<3-MiddleMouse>", "<Nop>")
vim.keymap.set("n", "<4-MiddleMouse>", "<Nop>")
vim.keymap.set("i", "<1-MiddleMouse>", "<Nop>")
vim.keymap.set("i", "<2-MiddleMouse>", "<Nop>")
vim.keymap.set("i", "<3-MiddleMouse>", "<Nop>")
vim.keymap.set("i", "<4-MiddleMouse>", "<Nop>")
vim.keymap.set("n", "qq", "<Nop>")
vim.keymap.set("v", "qq", "<Nop")
vim.keymap.set("n", "gg", "<Nop>")
vim.keymap.set("n", "ZZ", "<Nop>")
vim.keymap.set("n", "ZQ", "<Nop>")
vim.keymap.set("n", "<C-z>", "<Nop>")
vim.keymap.set("n", "<F1>", "<Nop>")
vim.keymap.set("n", "x", '"_x')
vim.keymap.set("v", "x", '"_x')
vim.keymap.set("n", "s", '"_s')
--MOVE
vim.keymap.set("n", "k", "gk")
vim.keymap.set("n", "j", "gj")
vim.keymap.set("n", "<UP>", "gk")
vim.keymap.set("n", "<DOWN>", "gj")
vim.keymap.set("n", "O", ":<C-u>call append(expand('.'), '')<CR>j")
vim.keymap.set("n", "sh", "<C-w>h")
vim.keymap.set("n", "sj", "<C-w>j")
vim.keymap.set("n", "sk", "<C-w>k")
vim.keymap.set("n", "sl", "<C-w>l")
vim.keymap.set("n", "sH", "<C-w>H")
vim.keymap.set("n", "sJ", "<C-w>J")
vim.keymap.set("n", "sK", "<C-w>K")
vim.keymap.set("n", "sL", "<C-w>L")
--COPY
vim.keymap.set("n", "p", "]p")
vim.keymap.set("n", "P", "]P")
vim.keymap.set("n", "]p", "p")
vim.keymap.set("n", "]P", "P")
----PLUGINS
--MANAGER
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
vim.fn.system({
"git",
"clone",
"--filter=blob:none",
"https://github.com/folke/lazy.nvim.git",
"--branch=stable",
lazypath,
})
end
vim.opt.rtp:prepend(lazypath)
require("lazy").setup({
defaults = { lazy = true },
{ "nvim-lualine/lualine.nvim", event = "VeryLazy" },
{ "nvim-telescope/telescope.nvim", cmd = "Telescope" },
{
"nvim-telescope/telescope-fzf-native.nvim",
build = "cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=Release && cmake --build build --config Release && cmake --install build --prefix build",
cmd = "Telescope",
},
{ "nvim-telescope/telescope-file-browser.nvim", event = "VeryLazy" },
{ "lewis6991/gitsigns.nvim", config = true, event = "VeryLazy" },
{ "ryanoasis/vim-devicons", event = "VeryLazy" },
{ "nvim-tree/nvim-web-devicons", event = "VeryLazy" },
{ "williamboman/mason.nvim", event = "BufRead", cmd = { "Mason", "MasonInstall" } },
{ "williamboman/mason-lspconfig.nvim", event = "LspAttach" },
{ "jay-babu/mason-null-ls.nvim", event = "LspAttach" },
{ "jay-babu/mason-nvim-dap.nvim", event = "LspAttach" },
{ "neovim/nvim-lspconfig", event = "BufReadPre" },
{ "nvimtools/none-ls.nvim", event = "LspAttach" },
{ "mfussenegger/nvim-dap", event = "LspAttach" },
{ "rcarriga/nvim-dap-ui", event = "LspAttach" },
{ "theHamsta/nvim-dap-virtual-text", config = true, event = "LspAttach" },
{ "suketa/nvim-dap-ruby", config = true, ft = "ruby" },
{ "leoluz/nvim-dap-go", ft = "go" },
{ "mxsdev/nvim-dap-vscode-js", ft = "javascript" },
{ "mfussenegger/nvim-dap-python", ft = "python" },
{ "nvimdev/lspsaga.nvim", event = "LspAttach" },
{ "is0n/jaq-nvim", event = "LspAttach" },
{ "j-hui/fidget.nvim", config = true, event = "LspAttach" },
{ "sainnhe/edge", event = "VeryLazy" },
{ "nvim-lua/plenary.nvim", event = "VeryLazy" },
{ "stevearc/dressing.nvim", event = "VeryLazy" },
{ "hrsh7th/nvim-cmp", event = "VeryLazy" },
{ "hrsh7th/cmp-nvim-lsp", event = "LspAttach" },
{ "hrsh7th/cmp-buffer", event = "InsertEnter" },
{ "hrsh7th/cmp-path", event = "InsertEnter" },
{ "hrsh7th/cmp-vsnip", event = "InsertEnter" },
{ "hrsh7th/cmp-cmdline", event = "ModeChanged" },
{ "hrsh7th/cmp-nvim-lsp-signature-help", event = "LspAttach" },
{ "hrsh7th/cmp-nvim-lsp-document-symbol", event = "LspAttach" },
{ "hrsh7th/cmp-calc", event = "InsertEnter" },
{ "onsails/lspkind.nvim", event = "LspAttach" },
{ "hrsh7th/vim-vsnip", event = "InsertEnter" },
{ "hrsh7th/vim-vsnip-integ", event = "InsertEnter" },
{ "rafamadriz/friendly-snippets", event = "InsertEnter" },
{ "nvim-treesitter/nvim-treesitter", event = "VeryLazy" },
{ "nvim-treesitter/nvim-treesitter-refactor", event = "VeryLazy" },
{ "yioneko/nvim-yati", event = "VeryLazy" },
{ "windwp/nvim-autopairs", config = true, event = "InsertEnter" },
{ "windwp/nvim-ts-autotag", config = true, event = "InsertEnter" },
{ "HiPhish/rainbow-delimiters.nvim", event = "VeryLazy" },
{ "andymass/vim-matchup", event = "VeryLazy" },
{ "lambdalisue/suda.vim", cmd = { "SudaWrite", "SudaRead" } },
{ "jghauser/mkdir.nvim", event = "ModeChanged" },
{ "shellRaining/hlchunk.nvim", config = true, event = "UIEnter" },
{ "kevinhwang91/nvim-hlslens", event = "VeryLazy" },
{ "akinsho/git-conflict.nvim", version = "*", config = true },
{ "numToStr/Comment.nvim", config = true, event = "VeryLazy" },
{ "rhysd/clever-f.vim", event = "VeryLazy" },
{ "echasnovski/mini.surround", event = "ModeChanged" },
{ "echasnovski/mini.ai", event = "ModeChanged" },
{ "mvllow/modes.nvim", event = "VeryLazy" },
{ "monaqa/dial.nvim", event = "VeryLazy" },
{ "tpope/vim-repeat", event = "VeryLazy" },
{ "nvim-zh/colorful-winsep.nvim", config = true, event = "WinNew" },
{ "vim-jp/vimdoc-ja", ft = "help" },
--non-lazy
{ "vim-denops/denops.vim", lazy = false },
{ "yuki-yano/fuzzy-motion.vim", lazy = false },
{ "lambdalisue/gin.vim", lazy = false },
{ "rbtnn/vim-ambiwidth", lazy = false },
{ "lambdalisue/kensaku-search.vim", lazy = false },
{ "lambdalisue/kensaku.vim", lazy = false },
{ "brenoprata10/nvim-highlight-colors", lazy = false },
--disable default plugins
performance = {
rtp = {
disable_plugins = {
"netrw",
"netrwPlugin",
"netrwSettings",
"netrwFileHandlers",
"gzip",
"zip",
"zipPlugin",
"tar",
"tarPlugin",
"getscript",
"getscriptPlugin",
"vimball",
"vimballPlugin",
"2html_plugin",
"logipat",
"rrhelper",
"spellfile_plugin",
"sql_completion",
},
},
},
})
--lualine
require("lualine").setup({
options = {
icons_enabled = true,
component_separators = { left = "", right = "" },
section_separators = { left = "", right = "" },
disabled_filetypes = { "TelescopePrompt" },
always_divide_middle = true,
colored = false,
globalstatus = true,
},
sections = {
lualine_a = { "" },
lualine_b = { "branch", "diff" },
lualine_c = {
{
"filename",
path = 1,
file_status = true,
shorting_target = 40,
symbols = {
modified = "[+]",
readonly = "[RO]",
unnamed = "Untitled",
},
},
},
lualine_x = { "filetype" },
lualine_y = {
{
"diagnostics",
source = { "nvim-lsp" },
},
{ "progress" },
{ "location" },
},
lualine_z = { "" },
},
inactive_sections = {
lualine_a = {},
lualine_b = {},
lualine_c = { "filename" },
lualine_x = { "location" },
lualine_y = {},
lualine_z = {},
},
tabline = {},
extensions = {},
})
--telescope
require("telescope").setup({
defaults = {
borderchars = { "", "", "", "", "", "", "", "" },
color_devicons = true,
file_ignore_patterns = { "node_modules", ".git", ".cache", ".svg", ".npm", "go" },
mappings = {
i = {
["<esc>"] = require("telescope.actions").close,
},
},
},
vimgrep_arguments = {
"rg",
"--color=never",
"--no-heading",
"--smart-case",
"-uu",
},
extensions = {
fzf = {
fuzzy = true,
override_generic_sorter = true,
override_file_sorter = true,
case_mode = "smart_case",
},
},
})
vim.keymap.set("n", "<leader>.", "<cmd>Telescope find_files hidden=true<CR>")
vim.keymap.set("n", "<leader>,", "<cmd>Telescope oldfiles<CR>")
vim.keymap.set("n", "<leader>l", "<cmd>Telescope live_grep grep_open_files=true<CR>")
vim.keymap.set("n", "<leader>k", "<cmd>Telescope live_grep<CR>")
vim.keymap.set("n", "<leader>b", "<cmd>Telescope buffers<CR>")
vim.keymap.set("n", "<leader>h", "<cmd>Telescope help_tags<CR>")
vim.keymap.set("n", "<leader>y", "<cmd>Telescope registers<CR>")
vim.keymap.set("n", "<leader>n", "<cmd>Telescope lsp_references<CR>")
vim.keymap.set("n", "<leader>m", "<cmd>Telescope diagnostics<CR>")
vim.keymap.set("n", "<leader>x", "<cmd>Telescope lsp_document_symbols<CR>")
vim.keymap.set("n", "<leader>f", "<cmd>Telescope file_browser<CR>")
local fb_actions = require("telescope").extensions.file_browser.actions
local previewers = require("telescope.previewers")
local Job = require("plenary.job")
local new_maker = function(filepath, bufnr, opts)
filepath = vim.fn.expand(filepath)
Job:new({
command = "file",
args = { "--mime-type", "-b", filepath },
on_exit = function(j)
local mime_type = vim.split(j:result()[1], "/")[1]
if mime_type == "text" then
previewers.buffer_previewer_maker(filepath, bufnr, opts)
else
vim.schedule(function()
vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, { "BINARY" })
end)
end
end,
}):sync()
end
--LSP
require("lspsaga").setup({
symbol_in_winbar = {
enable = false,
},
ui = {
border = "single",
title = false,
},
lightbulb = {
enable = false,
},
})
local on_attach = function(client, bufnr)
client.server_capabilities.documentFormattingProvider = false
local set = vim.keymap.set
set("n", "K", "<cmd>Lspsaga hover_doc<CR>")
set("n", "<leader>1", "<cmd>Lspsaga finder<CR>")
set("n", "<leader>2", "<cmd>Lspsaga rename<CR>")
set("n", "<leader>3", "<cmd>Lspsaga code_action<CR>")
set("n", "<leader>4", "<cmd>Lspsaga show_line_diagnostics<CR>")
set("n", "<leader>5", "<cmd>Lspsaga peek_definition<CR>")
set("n", "<leader>[", "<cmd>Lspsaga diagnostic_jump_prev<CR>")
set("n", "<leaaer>]", "<cmd>Lspsaga diagnostic_jump_next<CR>")
end
vim.diagnostic.config({ virtual_text = false })
local capabilities = vim.lsp.protocol.make_client_capabilities()
capabilities.textDocument.completion.completionItem.snippetSupport = true
require("mason").setup()
require("mason-null-ls").setup({
ensure_installed = { "prettierd", "rubocop", "black", "goimports", "stylua", "shfmt" },
handlers = {},
})
require("mason-nvim-dap").setup({
ensure_installed = {},
handlers = {},
})
require("mason-lspconfig").setup()
require("mason-lspconfig").setup_handlers({
function(server_name)
require("lspconfig")[server_name].setup({
on_attach = on_attach,
capabilities = capabilities,
})
end,
})
--none-ls
local status, null_ls = pcall(require, "null-ls")
if not status then
return
end
null_ls.setup({
sources = {
null_ls.builtins.formatting.prettierd,
null_ls.builtins.diagnostics.rubocop,
null_ls.builtins.formatting.rubocop,
null_ls.builtins.formatting.black,
null_ls.builtins.formatting.goimports,
null_ls.builtins.formatting.stylua,
null_ls.builtins.formatting.shfmt,
},
debug = false,
})
vim.keymap.set("n", "<leader>p", function()
vim.lsp.buf.format({ async = true })
end)
--DAP
local function map(mode, lhs, rhs, opts)
local options = { noremap = true }
if opts then
options = vim.tbl_extend("force", options, opts)
end
vim.api.nvim_set_keymap(mode, lhs, rhs, options)
end
map("n", "<leader>6", ":lua require'dap'.continue()<CR>", { silent = true })
map("n", "<leader>7", ":lua require'dap'.step_over()<CR>", { silent = true })
map("n", "<leader>8", ":lua require'dap'.step_into()<CR>", { silent = true })
map("n", "<leader>9", ":lua require'dap'.step_out()<CR>", { silent = true })
map("n", "<leader>;", ":lua require'dap'.toggle_breakpoint()<CR>", { silent = true })
map("n", "<leader>'", ":lua require'dap'.set_breakpoint(vim.fn.input('Breakpoint condition: '))<CR>", { silent = true })
map(
"n",
"<leader>i",
":lua require'dap'.set_breakpoint(nil, nil, vim.fn.input('Log point message: '))<CR>",
{ silent = true }
)
map("n", "<leader>d", ":lua require'dapui'.toggle()<CR>", { silent = true })
map("n", "<leader><leader>d", ":lua require'dapui'.eval()<CR>", { silent = true })
---DAP-UI
require("dapui").setup({
icons = { expanded = "", collapsed = "", current_frame = "" },
mappings = {
expand = { "<CR>", "<2-LeftMouse>" },
open = "o",
remove = "d",
edit = "e",
repl = "r",
toggle = "t",
},
expand_lines = vim.fn.has("nvim-0.7") == 1,
layouts = {
{
elements = {
{ id = "scopes", size = 0.25 },
"breakpoints",
"stacks",
"watches",
},
size = 40,
position = "left",
},
{
elements = {
"repl",
},
size = 0.25,
position = "bottom",
},
},
controls = {
enabled = true,
element = "repl",
icons = {
pause = "",
play = "",
step_into = "",
step_over = "",
step_out = "",
step_back = "",
run_last = "",
terminate = "",
},
},
floating = {
max_height = nil,
max_width = nil,
border = "single",
mappings = {
close = { "q", "<Esc>" },
},
},
windows = { indent = 1 },
render = {
max_type_length = nil,
max_value_lines = 100,
},
})
--nvim-dap-vscode-js
local dap = require("dap")
dap.adapters["pwa-node"] = {
type = "server",
host = "localhost",
port = "${port}",
executable = {
command = "node",
args = {
vim.fn.stdpath("data") .. "/mason/packages/js-debug-adapter/js-debug/src/dapDebugServer.js",
"${port}",
},
-- command = "js-debug-adapter",
-- args = { "${port}" },
},
}
for _, language in ipairs({ "typescript", "javascript" }) do
dap.configurations[language] = {
{
type = "pwa-node",
request = "launch",
name = "Launch Current File (pwa-node)",
cwd = "${workspaceFolder}",
args = { "${file}" },
sourceMaps = true,
protocol = "inspector",
},
{
type = "pwa-node",
request = "launch",
name = "Launch Current File (Typescript)",
cwd = "${workspaceFolder}",
runtimeArgs = { "--loader=ts-node/esm" },
program = "${file}",
runtimeExecutable = "node",
-- args = { '${file}' },
sourceMaps = true,
protocol = "inspector",
outFiles = { "${workspaceFolder}/**/**/*", "!**/node_modules/**" },
skipFiles = { "<node_internals>/**", "node_modules/**" },
resolveSourceMapLocations = {
"${workspaceFolder}/**",
"!**/node_modules/**",
},
},
}
end
--nvim-dap-go
require("dap-go").setup({
delve = {
path = ".local/share/nvim/mason/packages/delve/dlv",
},
})
--nvim-dap-python
require("dap-python").setup(vim.fn.stdpath("data") .. "/mason/packages/debugpy/venv/bin/python")
---jaq-nvim
require("jaq-nvim").setup({
cmds = {
internal = {
lua = "luafile %",
vim = "source %",
},
external = {
python = "python3 %",
go = "go run %",
sh = "sh %",
ruby = "ruby %",
java = "java %",
javascript = "node %",
},
},
behavior = {
default = "float",
startinsert = false,
wincmd = false,
autosave = false,
},
ui = {
float = {
border = "none",
winhl = "Normal",
borderhl = "FloatBorder",
winblend = 0,
height = 0.8,
width = 0.8,
x = 0.5,
y = 0.5,
},
terminal = {
position = "bot",
size = 10,
line_no = false,
},
quickfix = {
position = "bot",
size = 10,
},
},
})
vim.keymap.set("n", "<leader>j", ":<C-u>Jaq<CR>", { silent = true })
--nvim-cmp
local cmp = require("cmp")
local lspkind = require("lspkind")
cmp.setup({
snippet = {
expand = function(args)
vim.fn["vsnip#anonymous"](args.body)
end,
},
window = {
completion = cmp.config.window.bordered({
border = "none",
}),
documentation = cmp.config.window.bordered({
border = "none",
}),
},
mapping = cmp.mapping.preset.insert({
["<Tab>"] = cmp.mapping.select_next_item(),
["<S-Tab>"] = cmp.mapping.select_prev_item(),
["<C-b>"] = cmp.mapping.scroll_docs(-4),
["<C-f>"] = cmp.mapping.scroll_docs(4),
["<C-Space>"] = cmp.mapping.complete(),
["<C-e>"] = cmp.mapping.abort(),
["<CR>"] = cmp.mapping.confirm({ select = true }),
}),
formatting = {
format = lspkind.cmp_format({
mode = "symbol",
maxwidth = 50,
ellipsis_char = "...",
}),
},
sources = cmp.config.sources({
{ name = "nvim_lsp", max_item_count = 15, keyword_length = 2 },
{ name = "vsnip", max_item_count = 15, keyword_length = 2 },
{ name = "nvim_lsp_signature_help" },
{ name = "calc" },
{ name = "buffer", max_item_count = 15, keyword_length = 2 },
}),
})
cmp.setup.cmdline({ "/", "?" }, {
mapping = cmp.mapping.preset.cmdline(),
sources = cmp.config.sources({
{ name = "nvim_lsp_document_symbol" },
}, {
{ name = "buffer" },
}),
})
cmp.setup.cmdline(":", {
mapping = cmp.mapping.preset.cmdline(),
sources = cmp.config.sources({
{ name = "path" },
}, {
{ name = "cmdline", keyword_length = 2 },
}),
})
local capabilities = require("cmp_nvim_lsp").default_capabilities()
vim.cmd("let g:vsnip_filetypes = {}")
--nvim-treesitter
require("nvim-treesitter.configs").setup({
highlight = {
enable = true,
disable = { "help", "markdown", "toml" },
},
refactor = {
highlight_defintions = {
enable = true,
},
},
yati = {
enable = true,
},
autotag = {
enable = true,
},
matchup = {
enable = true,
enable_quotes = true,
},
ensure_installed = "all",
})
--nvim-ts-autotag
vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
underline = true,
virtual_text = {
spacing = 5,
severity_limit = "Warning",
},
update_in_insert = true,
})
--rainbow-delimiters
require("rainbow-delimiters.setup").setup()
--dressing
require("dressing").setup({
input = {
border = "single",
},
builtin = {
border = "single",
},
})
--modes
require("modes").setup({
colors = {
copy = "#FFEE55",
delete = "#DC669B",
insert = "#55AAEE",
visual = "#DD5522",
},
})
--colorful-winsep
require("colorful-winsep").setup({
highlight = {
bg = "",
fg = "#E8AEAA",
},
})
--nvim-highlight-colors
require("nvim-highlight-colors").setup({
render = "background",
enable_named_colors = false,
enable_tailwind = true,
})
--nvim-hlslens
require("hlslens").setup()
local kopts = { noremap = true, silent = true }
vim.keymap.set(
"n",
"n",
[[<Cmd>execute('normal! ' . v:count1 . 'n')<CR><Cmd>lua require('hlslens').start()<CR>]],
kopts
)
vim.keymap.set(
"n",
"N",
[[<Cmd>execute('normal! ' . v:count1 . 'N')<CR><Cmd>lua require('hlslens').start()<CR>]],
kopts
)
vim.keymap.set("n", "*", [[*<cmd>lua require('hlslens').start()<CR>]], kopts)
vim.keymap.set("n", "#", [[#<cmd>lua require('hlslens').start()<CR>]], kopts)
vim.keymap.set("n", "g*", [[g*<cmd>lua require('hlslens').start()<CR>]], kopts)
vim.keymap.set("n", "g#", [[g#<cmd>lua require('hlslens').start()<CR>]], kopts)
vim.keymap.set("n", "<ESC>", ":nohl<CR><ESC>", kopts)
--fuzzy-motion
vim.keymap.set("n", "S", "<cmd>FuzzyMotion<CR>")
vim.cmd("let g:fuzzy_motion_matchers = ['kensaku', 'fzf']")
--kensaku-search
vim.keymap.set("c", "<CR>", "<Plug>(kensaku-search-replace)<CR>")
--clever-f
vim.cmd("let g:clever_f_across_no_line = 1")
vim.cmd("let g:clever_f_ignore_case = 1")
vim.cmd("let g:clever_f_smart_case = 1")
vim.cmd("let g:clever_f_chars_match_any_signs = ';'")
vim.cmd("let g:clever_f_use_migemo = 1")
--mini.surround
require("mini.surround").setup({
mappings = {
highlight = "sx",
},
custom_surroundings = {
["{"] = {
input = { "%b{}", "^.().*().$" },
output = { left = "{", right = "}" },
},
["}"] = {
input = { "%b{}", "^.%{().*()%}.$" },
output = { left = "{{", right = "}}" },
},
["("] = {
input = { "%b()", "^.().*().$" },
output = { left = "(", right = ")" },
},
[")"] = {
input = { "%b()", "^.%(().*()%).$" },
output = { left = "((", right = "))" },
},
["["] = {
input = { "%b[]", "^.().*().$" },
output = { left = "[", right = "]" },
},
["]"] = {
input = { "%b[]", "^.%[().*()%].$" },
output = { left = "[[", right = "]]" },
},
["<"] = {
input = { "%b<>", "^.().*().$" },
output = { left = "<", right = ">" },
},
[">"] = {
input = { "%b[]", "^.<().*()>.$" },
output = { left = "<<", right = ">>" },
},
["j"] = {
input = function()
local ok, val = pcall(vim.fn.getchar)
if not ok then
return
end
local char = vim.fn.nr2char(val)
local dict = {
["("] = { "().-()" },
["{"] = { "().-()" },
["["] = { "「().-()」" },
["]"] = { "『().-()』" },
["<"] = { "().-()" },
['"'] = { "”().-()”" },
}
if char == "b" then
local ret = {}
for _, v in pairs(dict) do
table.insert(ret, v)
end
return { ret }
end
if dict[char] then
return dict[char]
end
error("%s is unsupported surroundings in Japanese")
end,
output = function()
local ok, val = pcall(vim.fn.getchar)
if not ok then
return
end
local char = vim.fn.nr2char(val)
local dict = {
["("] = { left = "", right = "" },
["{"] = { left = "", right = "" },
["["] = { left = "", right = "" },
["]"] = { left = "", right = "" },
["<"] = { left = "", right = "" },
['"'] = { left = "", right = "" },
}
if not dict[char] then
error("%s is unsupported surroundings in Japanese")
end
return dict[char]
end,
},
},
})
--mini.ai
require("mini.ai").setup({
custom_textobjects = {
["{"] = { "%b{}", "^.().*().$" },
["}"] = { "%b{}", "^.%{().*()%}.$" },
["("] = { "%b()", "^.().*().$" },
[")"] = { "%b()", "^.%(().*()%).$" },
["["] = { "%b[]", "^.().*().$" },
["]"] = { "%b[]", "^.%[().*()%].$" },
[""] = { "%b<", "^.().*().$" },
[">"] = { "%b", "^.().*().$" },
["j"] = function()
local ok, val = pcall(vim.fn.getchar)
if not ok then
return
end
local char = vim.fn.nr2char(val)
local dict = {
["("] = { "().-()" },
["{"] = { "().-()" },
["["] = { "「().-()」" },
["]"] = { "『().-()』" },
["<"] = { "().-()" },
['"'] = { "”().-()”" },
}
if char == "b" then
local ret = {}
for _, v in pairs(dict) do
table.insert(ret, v)
end
return { ret }
end
if dict[char] then
return dict[char]
end
error("%s is unsupported textobjects in Japanese")
end,
},
})
--dial
vim.keymap.set("n", "<C-a>", require("dial.map").inc_normal(), { noremap = true })
vim.keymap.set("n", "<C-x>", require("dial.map").dec_normal(), { noremap = true })
vim.keymap.set("v", "<C-a>", require("dial.map").inc_visual(), { noremap = true })
vim.keymap.set("v", "<C-x>", require("dial.map").dec_visual(), { noremap = true })
vim.keymap.set("v", "g<C-a>", require("dial.map").inc_gvisual(), { noremap = true })
vim.keymap.set("v", "g<C-x>", require("dial.map").dec_gvisual(), { noremap = true })
--gin
vim.keymap.set("n", "<leader>gs", ":<C-u>GitStatus<CR>", { silent = true })
vim.keymap.set("n", "<leader>ga", ":<C-u>Gin add .<CR>", { silent = true })
vim.keymap.set("n", "<leader>gc", ":<C-u>Gin commit -m ")
vim.keymap.set("n", "<leader>gp", ":<C-u>Gin push<CR>")
--OTHER SETTINGS
vim.cmd("colorscheme edge")