home: create 'modules/home' folder

Consolidating all modules under the same path, to clear out the
top-level directory.

modules/home/vim/plugin/abbreviations.lua

@@ -0,0 +1,9 @@
+local abbreviations = {
+    -- A few things that are hard to write in ASCII
+    ["(R)"] = "©",
+    ["(TM)"] = "™",
+}
+
+for text, result in pairs(abbreviations) do
+    vim.cmd.abbreviate(text, result)
+end

modules/home/vim/plugin/numbertoggle.lua

@@ -0,0 +1,23 @@
+-- Show lines numbers
+vim.opt.number = true
+
+local numbertoggle = vim.api.nvim_create_augroup("numbertoggle", { clear = true })
+
+-- Toggle numbers between relative and absolute when changing buffers
+vim.api.nvim_create_autocmd({ "BufEnter", "FocusGained", "InsertLeave", "WinEnter" }, {
+    pattern = "*",
+    group = numbertoggle,
+    command = "if &nu | setlocal rnu | endif",
+})
+vim.api.nvim_create_autocmd({ "BufLeave", "FocusLost", "InsertEnter", "WinLeave" }, {
+    pattern = "*",
+    group = numbertoggle,
+    command = "if &nu | setlocal nornu | endif",
+})
+
+-- Never show the sign column in a terminal buffer
+vim.api.nvim_create_autocmd({ "TermOpen" }, {
+    pattern = "*",
+    group = numbertoggle,
+    command = "setlocal nonu nornu",
+})

modules/home/vim/plugin/settings/completion.lua

@@ -0,0 +1,62 @@
+-- Show completion menu in all cases, and don't select anything
+vim.opt.completeopt = { "menu", "menuone", "noselect" }
+
+local cmp = require("cmp")
+local cmp_under_comparator = require("cmp-under-comparator")
+local luasnip = require("luasnip")
+
+cmp.setup({
+    snippet = {
+        expand = function(args)
+            luasnip.lsp_expand(args.body)
+        end,
+    },
+    mapping = {
+        ["<Tab>"] = function(fallback)
+            if luasnip.expand_or_jumpable() then
+                luasnip.expand_or_jump()
+            else
+                fallback()
+            end
+        end,
+        ["<S-Tab>"] = function(fallback)
+            if luasnip.jumpable(-1) then
+                luasnip.jump(-1)
+            else
+                fallback()
+            end
+        end,
+        ["<C-n>"] = cmp.mapping(cmp.mapping.select_next_item({ behavior = cmp.SelectBehavior.Insert }), { "i", "c" }),
+        ["<C-p>"] = cmp.mapping(cmp.mapping.select_prev_item({ behavior = cmp.SelectBehavior.Insert }), { "i", "c" }),
+        ["<C-d>"] = cmp.mapping.scroll_docs(-5),
+        ["<C-f>"] = cmp.mapping.scroll_docs(5),
+        ["<C-y>"] = cmp.mapping.confirm({ behavior = cmp.ConfirmBehavior.Insert, select = false }),
+        ["<C-e>"] = cmp.mapping.abort(),
+    },
+    view = {
+        entries = "native",
+    },
+    sources = {
+        { name = "async_path", priority_weight = 110 },
+        { name = "nvim_lsp", priority_weight = 100 },
+        { name = "nvim_lua", priority_weight = 90 },
+        { name = "luasnip", priority_weight = 80 },
+        { name = "buffer", max_item_count = 5, priority_weight = 50 },
+    },
+    sorting = {
+        priority_weight = 100,
+        comparators = {
+            cmp.config.compare.offset,
+            cmp.config.compare.exact,
+            cmp.config.compare.score,
+            cmp_under_comparator.under,
+            cmp.config.compare.kind,
+            cmp.config.compare.sort_text,
+            cmp.config.compare.length,
+            cmp.config.compare.order,
+        },
+    },
+    experimental = {
+        ghost_text = true,
+    },
+})

modules/home/vim/plugin/settings/dressing.lua

@@ -0,0 +1,6 @@
+local dressing = require("dressing")
+
+dressing.setup({
+    -- Use a relative prompt size
+    prefer_width = 0.4,
+})

modules/home/vim/plugin/settings/fastfold.lua

@@ -0,0 +1,5 @@
+-- Intercept all fold commands
+-- stylua: ignore
+vim.g.fastfold_fold_command_suffixes = {
+    "x", "X", "a", "A", "o", "O", "c", "C", "r", "R", "m", "M", "i", "n", "N",
+}

modules/home/vim/plugin/settings/formatting.lua

@@ -0,0 +1,3 @@
+local lsp_format = require("lsp-format")
+
+lsp_format.setup({})

modules/home/vim/plugin/settings/git.lua

@@ -0,0 +1,58 @@
+local gitsigns = require("gitsigns")
+local wk = require("which-key")
+
+gitsigns.setup({
+    current_line_blame_opts = {
+        -- Show the blame quickly
+        delay = 100,
+    },
+})
+
+local keys = {
+    -- Navigation
+    ["[c"] = { "&diff ? '[c' : '<cmd>Gitsigns prev_hunk<CR>'", "Previous hunk/diff", expr = true },
+    ["]c"] = { "&diff ? ']c' : '<cmd>Gitsigns next_hunk<CR>'", "Next hunk/diff", expr = true },
+
+    -- Commands
+    ["<leader>g"] = {
+        name = "Git",
+        -- Actions
+        b = { gitsigns.toggle_current_line_blame, "Toggle blame virtual text" },
+        d = { gitsigns.diffthis, "Diff buffer" },
+        -- stylua: ignore
+        D = { function() gitsigns.diffthis("~") end, "Diff buffer against last commit" },
+        g = { "<cmd>Git<CR>", "Git status" },
+        h = { gitsigns.toggle_deleted, "Show deleted hunks" },
+        L = { "<cmd>:sp<CR><C-w>T:Gllog --follow -- %:p<CR>", "Current buffer log" },
+        m = { "<Plug>(git-messenger)", "Current line blame" },
+        p = { gitsigns.preview_hunk, "Preview hunk" },
+        r = { gitsigns.reset_hunk, "Restore hunk" },
+        R = { gitsigns.reset_buffer, "Restore buffer" },
+        s = { gitsigns.stage_hunk, "Stage hunk" },
+        S = { gitsigns.stage_buffer, "Stage buffer" },
+        u = { gitsigns.undo_stage_hunk, "Undo stage hunk" },
+        ["["] = { gitsigns.prev_hunk, "Previous hunk" },
+        ["]"] = { gitsigns.next_hunk, "Next hunk" },
+    },
+}
+
+local objects = {
+    ["ih"] = { gitsigns.select_hunk, "Git hunk" },
+}
+
+local visual = {
+    ["ih"] = { gitsigns.select_hunk, "Git hunk" },
+
+    -- Only the actual command can make use of the visual selection...
+    ["<leader>g"] = {
+        name = "Git",
+        p = { ":Gitsigns preview_hunk<CR>", "Preview selection" },
+        r = { ":Gitsigns reset_hunk<CR>", "Restore selection" },
+        s = { ":Gitsigns stage_hunk<CR>", "Stage selection" },
+        u = { ":Gitsigns undo_stage_hunk<CR>", "Undo stage selection" },
+    },
+}
+
+wk.register(keys, { buffer = bufnr })
+wk.register(objects, { buffer = bufnr, mode = "o" })
+wk.register(visual, { buffer = bufnr, mode = "x" })

modules/home/vim/plugin/settings/lsp-lines.lua

@@ -0,0 +1,3 @@
+local lsp_lines = require("lsp_lines")
+
+lsp_lines.setup()

modules/home/vim/plugin/settings/lspconfig.lua

@@ -0,0 +1,61 @@
+local lspconfig = require("lspconfig")
+local lsp = require("ambroisie.lsp")
+local utils = require("ambroisie.utils")
+
+-- Diagnostics
+vim.diagnostic.config({
+    -- Disable virtual test next to affected regions
+    virtual_text = false,
+    -- Also disable virtual diagnostics under the affected regions
+    virtual_lines = false,
+    -- Show diagnostics signs
+    signs = true,
+    -- Underline offending regions
+    underline = true,
+    -- Do not bother me in the middle of insertion
+    update_in_insert = false,
+    -- Show highest severity first
+    severity_sort = true,
+})
+
+-- Inform servers we are able to do completion, snippets, etc...
+local capabilities = require("cmp_nvim_lsp").default_capabilities()
+
+-- C/C++
+if utils.is_executable("clangd") then
+    lspconfig.clangd.setup({
+        capabilities = capabilities,
+        on_attach = lsp.on_attach,
+    })
+end
+
+-- Nix
+if utils.is_executable("nil") then
+    lspconfig.nil_ls.setup({
+        capabilities = capabilities,
+        on_attach = lsp.on_attach,
+    })
+end
+
+if utils.is_executable("rnix-lsp") then
+    lspconfig.rnix.setup({
+        capabilities = capabilities,
+        on_attach = lsp.on_attach,
+    })
+end
+
+-- Python
+if utils.is_executable("pyright") then
+    lspconfig.pyright.setup({
+        capabilities = capabilities,
+        on_attach = lsp.on_attach,
+    })
+end
+
+-- Rust
+if utils.is_executable("rust-analyzer") then
+    lspconfig.rust_analyzer.setup({
+        capabilities = capabilities,
+        on_attach = lsp.on_attach,
+    })
+end

modules/home/vim/plugin/settings/lualine.lua

@@ -0,0 +1,61 @@
+local lualine = require("lualine")
+local utils = require("ambroisie.utils")
+
+local function list_spell_languages()
+    if not vim.opt.spell:get() then
+        return ""
+    end
+
+    return table.concat(vim.opt.spelllang:get(), ", ")
+end
+
+local function list_lsp_clients()
+    local client_names = utils.list_lsp_clients()
+
+    if #client_names == 0 then
+        return ""
+    end
+
+    return "[ " .. table.concat(client_names, " ") .. " ]"
+end
+
+lualine.setup({
+    options = {
+        icons_enabled = false,
+        section_separators = "",
+        component_separators = "|",
+    },
+    sections = {
+        lualine_a = {
+            { "mode" },
+        },
+        lualine_b = {
+            { "FugitiveHead" },
+            { "filename", symbols = { readonly = "🔒" } },
+        },
+        lualine_c = {
+            { list_spell_languages },
+            { "lsp_progress" },
+        },
+        lualine_x = {
+            { list_lsp_clients },
+            {
+                "diagnostics",
+                -- Only use the diagnostics API
+                sources = { "nvim_diagnostic" },
+            },
+        },
+        lualine_y = {
+            { "fileformat" },
+            { "encoding" },
+            { "filetype" },
+        },
+        lualine_z = {
+            "location",
+        },
+    },
+    extensions = {
+        "fugitive",
+        "quickfix",
+    },
+})

modules/home/vim/plugin/settings/luasnip.lua

@@ -0,0 +1 @@
+require("luasnip.loaders.from_vscode").lazy_load()

modules/home/vim/plugin/settings/null-ls.lua

@@ -0,0 +1,138 @@
+local null_ls = require("null-ls")
+local lsp = require("ambroisie.lsp")
+local utils = require("ambroisie.utils")
+
+null_ls.setup({
+    on_attach = lsp.on_attach,
+})
+
+-- Bazel
+null_ls.register({
+    null_ls.builtins.diagnostics.buildifier.with({
+        -- Only used if available
+        condition = utils.is_executable_condition("buildifier"),
+    }),
+    null_ls.builtins.formatting.buildifier.with({
+        -- Only used if available
+        condition = utils.is_executable_condition("buildifier"),
+    }),
+})
+
+-- C, C++
+null_ls.register({
+    null_ls.builtins.formatting.clang_format.with({
+        -- Only used if available, but prefer clangd formatting if available
+        condition = function()
+            return utils.is_executable("clang-format") and not utils.is_executable("clangd")
+        end,
+    }),
+})
+
+-- Haskell
+null_ls.register({
+    null_ls.builtins.formatting.brittany.with({
+        -- Only used if available
+        condition = utils.is_executable_condition("brittany"),
+    }),
+})
+
+-- Nix
+null_ls.register({
+    null_ls.builtins.formatting.nixpkgs_fmt.with({
+        -- Only used if available, but prefer rnix if available
+        condition = function()
+            return utils.is_executable("nixpkgs-fmt")
+                and not utils.is_executable("rnix-lsp")
+                and not utils.is_executable("nil")
+        end,
+    }),
+})
+
+-- Python
+null_ls.register({
+    null_ls.builtins.diagnostics.flake8.with({
+        -- Only used if available, but prefer pflake8 if available
+        condition = function()
+            return utils.is_executable("flake8") and not utils.is_executable("pflake8")
+        end,
+    }),
+    null_ls.builtins.diagnostics.pyproject_flake8.with({
+        -- Only used if available
+        condition = utils.is_executable_condition("pflake8"),
+    }),
+    null_ls.builtins.diagnostics.mypy.with({
+        -- Only used if available
+        condition = utils.is_executable_condition("mypy"),
+    }),
+    null_ls.builtins.diagnostics.pylint.with({
+        -- Only used if available
+        condition = utils.is_executable_condition("pylint"),
+    }),
+    null_ls.builtins.formatting.black.with({
+        extra_args = { "--fast" },
+        -- Only used if available
+        condition = utils.is_executable_condition("black"),
+    }),
+    null_ls.builtins.formatting.isort.with({
+        -- Only used if available
+        condition = utils.is_executable_condition("isort"),
+    }),
+})
+
+-- Shell (non-POSIX)
+null_ls.register({
+    null_ls.builtins.code_actions.shellcheck.with({
+        -- Restrict to bash and zsh
+        filetypes = { "bash", "zsh" },
+        -- Only used if available
+        condition = utils.is_executable_condition("shellcheck"),
+    }),
+    null_ls.builtins.diagnostics.shellcheck.with({
+        -- Show error code in message
+        diagnostics_format = "[#{c}] #{m}",
+        -- Require explicit empty string test, use bash dialect
+        extra_args = { "-s", "bash", "-o", "avoid-nullary-conditions" },
+        -- Restrict to bash and zsh
+        filetypes = { "bash", "zsh" },
+        -- Only used if available
+        condition = utils.is_executable_condition("shellcheck"),
+    }),
+    null_ls.builtins.formatting.shfmt.with({
+        -- Indent with 4 spaces, simplify the code, indent switch cases,
+        -- add space after redirection, use bash dialect
+        extra_args = { "-i", "4", "-s", "-ci", "-sr", "-ln", "bash" },
+        -- Restrict to bash and zsh
+        filetypes = { "bash", "zsh" },
+        -- Only used if available
+        condition = utils.is_executable_condition("shfmt"),
+    }),
+})
+
+-- Shell (POSIX)
+null_ls.register({
+    null_ls.builtins.code_actions.shellcheck.with({
+        -- Restrict to POSIX sh
+        filetypes = { "sh" },
+        -- Only used if available
+        condition = utils.is_executable_condition("shellcheck"),
+    }),
+    null_ls.builtins.diagnostics.shellcheck.with({
+        -- Show error code in message
+        diagnostics_format = "[#{c}] #{m}",
+        -- Require explicit empty string test
+        extra_args = { "-o", "avoid-nullary-conditions" },
+        -- Restrict to POSIX sh
+        filetypes = { "sh" },
+        -- Only used if available
+        condition = utils.is_executable_condition("shellcheck"),
+    }),
+    null_ls.builtins.formatting.shfmt.with({
+        -- Indent with 4 spaces, simplify the code, indent switch cases,
+        -- add space after redirection, use POSIX
+        extra_args = { "-i", "4", "-s", "-ci", "-sr", "-ln", "posix" },
+        -- Restrict to POSIX sh
+        filetypes = { "sh" },
+        -- Only used if available
+        condition = utils.is_executable_condition("shfmt"),
+    }),
+})

modules/home/vim/plugin/settings/ssh.lua

@@ -0,0 +1,17 @@
+if not require("ambroisie.utils").is_ssh() then
+    return
+end
+
+local function copy(lines, _)
+    require("osc52").copy(table.concat(lines, "\n"))
+end
+
+local function paste()
+    return { vim.fn.split(vim.fn.getreg(""), "\n"), vim.fn.getregtype("") }
+end
+
+vim.g.clipboard = {
+    name = "osc52",
+    copy = { ["+"] = copy, ["*"] = copy },
+    paste = { ["+"] = paste, ["*"] = paste },
+}

modules/home/vim/plugin/settings/surround.lua

@@ -0,0 +1,3 @@
+require("nvim-surround").setup({
+    -- No configuration at the moment
+})

modules/home/vim/plugin/settings/telescope.lua

@@ -0,0 +1,24 @@
+local telescope = require("telescope")
+
+telescope.setup({
+    defaults = {
+        mappings = {
+            i = {
+                ["<C-h>"] = "which_key",
+                -- I want the normal readline mappings rather than scrolling
+                ["<C-u>"] = false,
+            },
+        },
+    },
+    extensions = {
+        fzf = {
+            fuzzy = true,
+            override_generic_sorter = true,
+            override_file_sorter = true,
+            case_mode = "smart_case",
+        },
+    },
+})
+
+telescope.load_extension("fzf")
+telescope.load_extension("lsp_handlers")

modules/home/vim/plugin/settings/tree-sitter.lua

@@ -0,0 +1,56 @@
+local ts_config = require("nvim-treesitter.configs")
+ts_config.setup({
+    highlight = {
+        enable = true,
+        -- Avoid duplicate highlighting
+        additional_vim_regex_highlighting = false,
+    },
+    indent = {
+        enable = true,
+    },
+    context_commentstring = {
+        enable = true,
+    },
+    textobjects = {
+        select = {
+            enable = true,
+            -- Jump to matching text objects
+            lookahead = true,
+            keymaps = {
+                ["aa"] = "@parameter.outer",
+                ["ia"] = "@parameter.inner",
+                ["ab"] = "@block.outer",
+                ["ib"] = "@block.inner",
+                ["ac"] = "@class.outer",
+                ["ic"] = "@class.inner",
+                ["af"] = "@function.outer",
+                ["if"] = "@function.inner",
+                ["ak"] = "@comment.outer",
+                ["aS"] = "@statement.outer",
+            },
+        },
+        move = {
+            enable = true,
+            -- Add to jump list
+            set_jumps = true,
+            goto_next_start = {
+                ["]m"] = "@function.outer",
+                ["]S"] = "@statement.outer",
+                ["]]"] = "@class.outer",
+            },
+            goto_next_end = {
+                ["]M"] = "@function.outer",
+                ["]["] = "@class.outer",
+            },
+            goto_previous_start = {
+                ["[m"] = "@function.outer",
+                ["[S"] = "@statement.outer",
+                ["[["] = "@class.outer",
+            },
+            goto_previous_end = {
+                ["[M"] = "@function.outer",
+                ["[]"] = "@class.outer",
+            },
+        },
+    },
+})

modules/home/vim/plugin/settings/which-key.lua

@@ -0,0 +1,2 @@
+local wk = require("which-key")
+wk.setup()

modules/home/vim/plugin/signtoggle.lua

@@ -0,0 +1,20 @@
+local signtoggle = vim.api.nvim_create_augroup("signtoggle", { clear = true })
+
+-- Only show sign column for the currently focused buffer
+vim.api.nvim_create_autocmd({ "BufEnter", "FocusGained", "WinEnter" }, {
+    pattern = "*",
+    group = signtoggle,
+    command = "setlocal signcolumn=yes",
+})
+vim.api.nvim_create_autocmd({ "BufLeave", "FocusLost", "WinLeave" }, {
+    pattern = "*",
+    group = signtoggle,
+    command = "setlocal signcolumn=yes",
+})
+
+-- Never show the sign column in a terminal buffer
+vim.api.nvim_create_autocmd({ "TermOpen" }, {
+    pattern = "*",
+    group = signtoggle,
+    command = "setlocal signcolumn=no",
+})