add readme

LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

README.md

@@ -1,7 +1,59 @@
-# neovim config in progress
+# viminal2
 
-```lua
+This is my second attempt at creating a Neovim configuration intended for
-local test = test
+NixOS. The [first](https://github.com/youwen5/viminal) was configured using
+[Nixvim](https://github.com/nix-community/nixvim). This mostly worked, except
+you often had to escape into raw Lua strings to get precise customization.
+
+Enter [nixCats](https://github.com/BirdeeHub/nixCats-nvim). It provides the
+tools needed to mix Nix and Lua in your configurations. For advanced users,
+configuring Neovim with Nix expressions doesn't really make sense, since the
+whole point of Neovim is to be extremely hackable ("hyperextensible") and it
+provides ergonomic Lua bindings for that purpose.
+
+This setup provides not just a usable but a "great" Neovim configuration for
+NixOS. That is, it has features that make it _better_ on _all distros_, not
+just on NixOS. Why? Instead of using ad-hoc package managers written for Neovim
+like `lazy.nvim`, `Mason`, etc, all external dependencies are fetched and built
+by Nix. Mason and lazy are good for what they are meant for, but Nix can make
+strong guarantees that practically no other package management tool can,
+period. Namely, it can ensure the presence of runtime dependencies (like `rg`,
+`fd`, LSPs, formatters, etc), and guarantee builds are successful. If your
+editor works today, it'll work tomorrow. It won't break from system upgrades or
+files randomly getting broken. Nix is purpose built to handle pretty much
+everything that a text editor's plugins shouldn't, and it's a perfect match.
+
+## Try it
+
+You can test drive the configuration (even if you aren't on NixOS) if you have
+the Nix package manager available (with flakes).
+
+```bash
+nix run 'github:youwen5/viminal2'
 ```
 
-[test](lsdjkfsdf)
+## Design
+
+As this is my second configuration from scratch (if you count Nixvim as "from
+scratch"), I wanted to do it right (so I could stop wasting my time configuring
+my editor).
+
+For completion, I use [blink.cmp](https://github.com/Saghen/blink.cmp). This
+plugin is much, much faster than `nvim-cmp` thanks to optimized `SIMD`
+instructions (and Rust), has a better fuzzy search, and comes with more out of
+the box.
+
+`lz.n` is used to load plugins after they have been downloaded by Nix. `lz.n`
+is a lazy loading plugin by the authors of `Rocks.nvim`, a plugin manager based
+on Luarocks. As they are designed to be decoupled, `Rocks.nvim` can simply be
+replaced by Nix. Most plugins are lazy loaded, but generally performance is
+good enough that it is not even strictly necessary.
+
+The keybinds have gotten a lot more idiosyncratic. Instead of focusing on
+mnemonic keys that can be easily committed to memory, highly efficient ones
+were chosen instead.
+
+## License
+
+Feel free to copy any code from here or use it as an example. It's [public
+domain](./LICENSE).

flake.nix

@@ -1,22 +1,3 @@
-# Copyright (c) 2023 BirdeeHub
-# Licensed under the MIT license
-
-# This is an empty nixCats config.
-# you may import this template directly into your nvim folder
-# and then add plugins to categories here,
-# and call the plugins with their default functions
-# within your lua, rather than through the nvim package manager's method.
-# Use the help, and the example repository https://github.com/BirdeeHub/nixCats-nvim
-
-# It allows for easy adoption of nix,
-# while still providing all the extra nix features immediately.
-# Configure in lua, check for a few categories, set a few settings,
-# output packages with combinations of those categories and settings.
-
-# All the same options you make here will be automatically exported in a form available
-# in home manager and in nixosModules, as well as from other flakes.
-# each section is tagged with its relevant help section.
-
 {
   description = "A Lua-natic's neovim flake, with extra cats! nixCats!";
 
@@ -38,20 +19,7 @@
       url = "github:linrongbin16/lsp-progress.nvim";
       flake = false;
     };
-
-    # see :help nixCats.flake.inputs
-    # If you want your plugin to be loaded by the standard overlay,
-    # i.e. if it wasnt on nixpkgs, but doesnt have an extra build step.
-    # Then you should name it "plugins-something"
-    # If you wish to define a custom build step not handled by nixpkgs,
-    # then you should name it in a different format, and deal with that in the
-    # overlay defined for custom builds in the overlays directory.
-    # for specific tags, branches and commits, see:
-    # https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-flake.html#examples
-
   };
-
-  # see :help nixCats.flake.outputs
   outputs =
     {
       self,
@@ -63,40 +31,21 @@
       inherit (nixCats) utils;
       luaPath = "${./.}";
       forEachSystem = utils.eachSystem nixpkgs.lib.platforms.all;
-      # the following extra_pkg_config contains any values
-      # which you want to pass to the config set of nixpkgs
-      # import nixpkgs { config = extra_pkg_config; inherit system; }
-      # will not apply to module imports
-      # as that will have your system values
       extra_pkg_config = {
         # allowUnfree = true;
       };
-      # sometimes our overlays require a ${system} to access the overlay.
-      # management of this variable is one of the harder parts of using flakes.
-
-      # so I have done it here in an interesting way to keep it out of the way.
-
-      # First, we will define just our overlays per system.
-      # later we will pass them into the builder, and the resulting pkgs set
-      # will get passed to the categoryDefinitions and packageDefinitions
-      # which follow this section.
-
-      # this allows you to use ${pkgs.system} whenever you want in those sections
-      # without fear.
       inherit
         (forEachSystem (
           system:
           let
-            # see :help nixCats.flake.outputs.overlays
+            dependencyOverlays = (import ./nix/overlays.nix) ++ [
-            dependencyOverlays = # (import ./overlays inputs) ++
+              # This overlay grabs all the inputs named in the format
-              [
+              # `plugins-<pluginName>`
-                # This overlay grabs all the inputs named in the format
+              # Once we add this overlay to our nixpkgs, we are able to
-                # `plugins-<pluginName>`
+              # use `pkgs.neovimPlugins`, which is a set of our plugins.
-                # Once we add this overlay to our nixpkgs, we are able to
+              (utils.standardPluginOverlay inputs)
-                # use `pkgs.neovimPlugins`, which is a set of our plugins.
+              # add any flake overlays here.
-                (utils.standardPluginOverlay inputs)
+            ];
-                # add any flake overlays here.
-              ];
           in
           # these overlays will be wrapped with ${system}
           # and we will call the same utils.eachSystem function
@@ -119,27 +68,9 @@
           ...
         }@packageDef:
         {
-          # to define and use a new category, simply add a new list to a set here, 
+          # lspsAndRuntimeDeps: this section is for dependencies that should be
-          # and later, you will include categoryname = true; in the set you
+          # available at RUN TIME for plugins. Will be available to PATH within
-          # provide when you build the package using this builder function.
+          # neovim terminal this includes LSPs
-          # see :help nixCats.flake.outputs.packageDefinitions for info on that section.
-
-          # propagatedBuildInputs:
-          # this section is for dependencies that should be available
-          # at BUILD TIME for plugins. WILL NOT be available to PATH
-          # However, they WILL be available to the shell 
-          # and neovim path when using nix develop
-          propagatedBuildInputs = {
-            general =
-              with pkgs;
-              [
-              ];
-          };
-
-          # lspsAndRuntimeDeps:
-          # this section is for dependencies that should be available
-          # at RUN TIME for plugins. Will be available to PATH within neovim terminal
-          # this includes LSPs
           lspsAndRuntimeDeps = {
             general = with pkgs; [
               # essential
@@ -151,12 +82,14 @@
               lua-language-server
               nixd
               nixfmt-rfc-style
-			  nodePackages_latest.prettier
+              nodePackages_latest.prettier
-			  taplo
+              taplo
-			  typstyle
+              typstyle
-			  rustfmt
+              rustfmt
-			  black
+              black
-			  stylua
+              stylua
+              marksman
+              tinymist
             ];
           };
 
@@ -188,6 +121,7 @@
                   vim
                   bash
                   make
+                  gitcommit
                 ])
               ))
             ];
@@ -219,7 +153,7 @@
               trouble-nvim
               lualine-nvim
               mini-ai
-			  mini-hipatterns
+              mini-hipatterns
               mini-surround
               mini-notify
               mini-starter
@@ -231,8 +165,8 @@
               gitsigns-nvim
               diffview-nvim
               barbecue-nvim
-			  undotree
+              undotree
-			  conform-nvim
+              conform-nvim
             ];
           };
 
@@ -243,67 +177,19 @@
               # libgit2
             ];
           };
-
-          # environmentVariables:
-          # this section is for environmentVariables that should be available
-          # at RUN TIME for plugins. Will be available to path within neovim terminal
-          # environmentVariables = {
-          #   test = {
-          #     CATTESTVAR = "It worked!";
-          #   };
-          # };
-
-          # If you know what these are, you can provide custom ones by category here.
-          # If you dont, check this link out:
-          # https://github.com/NixOS/nixpkgs/blob/master/pkgs/build-support/setup-hooks/make-wrapper.sh
-          # extraWrapperArgs = {
-          #   test = [
-          #     ''--set CATTESTVAR2 "It worked again!"''
-          #   ];
-          # };
-
-          # lists of the functions you would have passed to
-          # python.withPackages or lua.withPackages
-
-          # get the path to this python environment
-          # in your lua config via
-          # vim.g.python3_host_prog
-          # or run from nvim terminal via :!<packagename>-python3
-          # extraPython3Packages = {
-          #   test = (_: [ ]);
-          # };
-          # # populates $LUA_PATH and $LUA_CPATH
-          # extraLuaPackages = {
-          #   test = [ (_: [ ]) ];
-          # };
         };
-
-      # And then build a package with specific categories from above here:
-      # All categories you wish to include must be marked true,
-      # but false may be omitted.
-      # This entire set is also passed to nixCats for querying within the lua.
-
-      # see :help nixCats.flake.outputs.packageDefinitions
       packageDefinitions = {
-        # These are the names of your packages
-        # you can include as many as you wish.
         nvim =
           { pkgs, ... }:
           {
-            # they contain a settings set defined above
-            # see :help nixCats.flake.outputs.settings
             settings = {
               wrapRc = true;
-              # IMPORTANT:
-              # your alias may not conflict with your other packages.
               aliases = [
                 "vim"
                 "vi"
               ];
-              # neovim-unwrapped = inputs.neovim-nightly-overlay.packages.${pkgs.system}.neovim;
+              neovim-unwrapped = pkgs.neovim-unwrapped;
             };
-            # and a set of categories that you want
-            # (and other information to pass to lua)
             categories = {
               general = true;
               gitPlugins = true;
@@ -315,12 +201,8 @@
             };
           };
       };
-      # In this section, the main thing you will need to do is change the default package name
-      # to the name of the packageDefinitions entry you wish to use as the default.
       defaultPackageName = "nvim";
     in
-
-    # see :help nixCats.flake.outputs.exports
     forEachSystem (
       system:
       let
@@ -333,20 +215,11 @@
             ;
         } categoryDefinitions packageDefinitions;
         defaultPackage = nixCatsBuilder defaultPackageName;
-        # this is just for using utils such as pkgs.mkShell
-        # The one used to build neovim is resolved inside the builder
-        # and is passed to our categoryDefinitions and packageDefinitions
         pkgs = import nixpkgs { inherit system; };
       in
       {
-        # these outputs will be wrapped with ${system} by utils.eachSystem
-
-        # this will make a package out of each of the packageDefinitions defined above
-        # and set the default package to the one passed in here.
         packages = utils.mkAllWithDefault defaultPackage;
 
-        # choose your package for devShell
-        # and add whatever else you want in it.
         devShells = {
           default = pkgs.mkShell {
             name = defaultPackageName;
@@ -362,16 +235,10 @@
       }
     )
     // {
-
-      # these outputs will be NOT wrapped with ${system}
-
-      # this will make an overlay out of each of the packageDefinitions defined above
-      # and set the default overlay to the one named here.
       overlays = utils.makeOverlays luaPath {
         inherit nixpkgs dependencyOverlays extra_pkg_config;
       } categoryDefinitions packageDefinitions defaultPackageName;
 
-      # we also export a nixos module to allow reconfiguration from configuration.nix
       nixosModules.default = utils.mkNixosModules {
         inherit
           defaultPackageName
@@ -383,7 +250,6 @@
           nixpkgs
           ;
       };
-      # and the same for home manager
       homeModule = utils.mkHomeModules {
         inherit
           defaultPackageName

lua/keymaps.lua

@@ -57,3 +57,5 @@ vim.keymap.set({ "n", "v" }, "<leader>cbf", function()
     vim.b[0].disable_autoformat = true
   end
 end, { desc = "Disable autoformat on save buffer" })
+
+vim.keymap.set("i", "<Tab>", require("scripts.intellitab").indent)

lua/lsp/init.lua

@@ -1,26 +1,28 @@
 local lspconfig = require("lspconfig")
 
 lspconfig.lua_ls.setup({
-    settings = {
+  settings = {
-        Lua = {
+    Lua = {
-            runtime = {
+      runtime = {
-                -- Tell the language server which version of Lua you're using (most likely LuaJIT in the case of Neovim)
+        -- Tell the language server which version of Lua you're using (most likely LuaJIT in the case of Neovim)
-                version = "LuaJIT",
+        version = "LuaJIT",
-            },
+      },
-            diagnostics = {
+      diagnostics = {
-                -- Get the language server to recognize the `vim` global
+        -- Get the language server to recognize the `vim` global
-                globals = { "vim", "nixCats", "MiniBufremove" },
+        globals = { "vim", "nixCats", "MiniBufremove" },
-            },
+      },
-            workspace = {
+      workspace = {
-                -- Make the server aware of Neovim runtime files
+        -- Make the server aware of Neovim runtime files
-                library = vim.api.nvim_get_runtime_file("", true),
+        library = vim.api.nvim_get_runtime_file("", true),
-            },
+      },
-            -- Do not send telemetry data containing a randomized but unique identifier
+      -- Do not send telemetry data containing a randomized but unique identifier
-            telemetry = {
+      telemetry = {
-                enable = false,
+        enable = false,
-            },
+      },
-        },
     },
+  },
 })
 
 lspconfig.nixd.setup({})
+lspconfig.marksman.setup({})
+lspconfig.tinymist.setup({})

lua/plugins/autopairs.lua

@@ -0,0 +1,7 @@
+return {
+  "nvim-autopairs",
+  event = "BufEnter",
+  after = function()
+    require("nvim-autopairs").setup()
+  end,
+}

lua/plugins/gitsigns.lua

@@ -0,0 +1,60 @@
+return {
+  "gitsigns.nvim",
+  event = "BufEnter",
+  after = function()
+    require("gitsigns").setup({
+      on_attach = function(bufnr)
+        local gitsigns = require("gitsigns")
+
+        local function map(mode, l, r, opts)
+          opts = opts or {}
+          opts.buffer = bufnr
+          vim.keymap.set(mode, l, r, opts)
+        end
+
+        -- Navigation
+        map("n", "]c", function()
+          if vim.wo.diff then
+            vim.cmd.normal({ "]c", bang = true })
+          else
+            gitsigns.nav_hunk("next")
+          end
+        end)
+
+        map("n", "[c", function()
+          if vim.wo.diff then
+            vim.cmd.normal({ "[c", bang = true })
+          else
+            gitsigns.nav_hunk("prev")
+          end
+        end)
+
+        -- Actions
+        map("n", "<leader>gs", gitsigns.stage_hunk)
+        map("n", "<leader>gr", gitsigns.reset_hunk)
+        map("v", "<leader>gs", function()
+          gitsigns.stage_hunk({ vim.fn.line("."), vim.fn.line("v") })
+        end)
+        map("v", "<leader>gr", function()
+          gitsigns.reset_hunk({ vim.fn.line("."), vim.fn.line("v") })
+        end)
+        map("n", "<leader>gS", gitsigns.stage_buffer)
+        map("n", "<leader>gu", gitsigns.undo_stage_hunk)
+        map("n", "<leader>gR", gitsigns.reset_buffer)
+        map("n", "<leader>gp", gitsigns.preview_hunk)
+        map("n", "<leader>gb", function()
+          gitsigns.blame_line({ full = true })
+        end)
+        map("n", "<leader>gb", gitsigns.toggle_current_line_blame)
+        map("n", "<leader>gd", gitsigns.diffthis)
+        map("n", "<leader>gD", function()
+          gitsigns.diffthis("~")
+        end)
+        map("n", "<leader>gtd", gitsigns.toggle_deleted)
+
+        -- Text object
+        map({ "o", "x" }, "ih", ":<C-U>Gitsigns select_hunk<CR>")
+      end,
+    })
+  end,
+}

lua/plugins/lsp-progress.lua

@@ -0,0 +1,51 @@
+return {
+  "lsp-progress",
+  after = function()
+    require("lsp-progress").setup({
+      client_format = function(client_name, spinner, series_messages)
+        if #series_messages == 0 then
+          return nil
+        end
+        return {
+          name = client_name,
+          body = spinner .. " " .. table.concat(series_messages, ", "),
+        }
+      end,
+      format = function(client_messages)
+        --- @param name string
+        --- @param msg string?
+        --- @return string
+        local function stringify(name, msg)
+          return msg and string.format("%s %s", name, msg) or name
+        end
+
+        local sign = "󰆧" -- nf-fa-gear \uf013
+        local lsp_clients = vim.lsp.get_clients()
+        local messages_map = {}
+        for _, climsg in ipairs(client_messages) do
+          messages_map[climsg.name] = climsg.body
+        end
+
+        if #lsp_clients > 0 then
+          table.sort(lsp_clients, function(a, b)
+            return a.name < b.name
+          end)
+          local builder = {}
+          for _, cli in ipairs(lsp_clients) do
+            if type(cli) == "table" and type(cli.name) == "string" and string.len(cli.name) > 0 then
+              if messages_map[cli.name] then
+                table.insert(builder, stringify(cli.name, messages_map[cli.name]))
+              else
+                table.insert(builder, stringify(cli.name))
+              end
+            end
+          end
+          if #builder > 0 then
+            return sign .. " " .. table.concat(builder, ", ")
+          end
+        end
+        return ""
+      end,
+    })
+  end,
+}

lua/plugins/lz-spec.lua

@@ -5,65 +5,10 @@ return {
   require("plugins.harpoon"),
   require("plugins.lualine"),
   require("plugins.conform"),
-  {
+  require("plugins.lsp-progress"),
-    "lsp-progress",
+  require("plugins.gitsigns"),
-    after = function()
+  require("plugins.autopairs"),
-      require("lsp-progress").setup({
-        client_format = function(client_name, spinner, series_messages)
-          if #series_messages == 0 then
-            return nil
-          end
-          return {
-            name = client_name,
-            body = spinner .. " " .. table.concat(series_messages, ", "),
-          }
-        end,
-        format = function(client_messages)
-          --- @param name string
-          --- @param msg string?
-          --- @return string
-          local function stringify(name, msg)
-            return msg and string.format("%s %s", name, msg) or name
-          end
-
-          local sign = "󰆧" -- nf-fa-gear \uf013
-          local lsp_clients = vim.lsp.get_clients()
-          local messages_map = {}
-          for _, climsg in ipairs(client_messages) do
-            messages_map[climsg.name] = climsg.body
-          end
-
-          if #lsp_clients > 0 then
-            table.sort(lsp_clients, function(a, b)
-              return a.name < b.name
-            end)
-            local builder = {}
-            for _, cli in ipairs(lsp_clients) do
-              if type(cli) == "table" and type(cli.name) == "string" and string.len(cli.name) > 0 then
-                if messages_map[cli.name] then
-                  table.insert(builder, stringify(cli.name, messages_map[cli.name]))
-                else
-                  table.insert(builder, stringify(cli.name))
-                end
-              end
-            end
-            if #builder > 0 then
-              return sign .. " " .. table.concat(builder, ", ")
-            end
-          end
-          return ""
-        end,
-      })
-    end,
-  },
   { "telescope-ui-select.nvim", priority = 70 },
-  {
-    "nvim-autopairs",
-    event = "BufEnter",
-    after = function()
-      require("nvim-autopairs").setup()
-    end,
-  },
   {
     "nvim-lspconfig",
     event = "BufEnter",
@@ -111,6 +56,7 @@ return {
   },
   {
     "typst-preview",
+    filetypes = { "*.typ" },
     after = function()
       require("typst-preview").setup({
         dependencies_bin = {
@@ -220,66 +166,6 @@ return {
       require("mini.hipatterns").setup()
     end,
   },
-  {
-    "gitsigns.nvim",
-    event = "BufEnter",
-    after = function()
-      require("gitsigns").setup({
-        on_attach = function(bufnr)
-          local gitsigns = require("gitsigns")
-
-          local function map(mode, l, r, opts)
-            opts = opts or {}
-            opts.buffer = bufnr
-            vim.keymap.set(mode, l, r, opts)
-          end
-
-          -- Navigation
-          map("n", "]c", function()
-            if vim.wo.diff then
-              vim.cmd.normal({ "]c", bang = true })
-            else
-              gitsigns.nav_hunk("next")
-            end
-          end)
-
-          map("n", "[c", function()
-            if vim.wo.diff then
-              vim.cmd.normal({ "[c", bang = true })
-            else
-              gitsigns.nav_hunk("prev")
-            end
-          end)
-
-          -- Actions
-          map("n", "<leader>gs", gitsigns.stage_hunk)
-          map("n", "<leader>gr", gitsigns.reset_hunk)
-          map("v", "<leader>gs", function()
-            gitsigns.stage_hunk({ vim.fn.line("."), vim.fn.line("v") })
-          end)
-          map("v", "<leader>gr", function()
-            gitsigns.reset_hunk({ vim.fn.line("."), vim.fn.line("v") })
-          end)
-          map("n", "<leader>gS", gitsigns.stage_buffer)
-          map("n", "<leader>gu", gitsigns.undo_stage_hunk)
-          map("n", "<leader>gR", gitsigns.reset_buffer)
-          map("n", "<leader>gp", gitsigns.preview_hunk)
-          map("n", "<leader>gb", function()
-            gitsigns.blame_line({ full = true })
-          end)
-          map("n", "<leader>gb", gitsigns.toggle_current_line_blame)
-          map("n", "<leader>gd", gitsigns.diffthis)
-          map("n", "<leader>gD", function()
-            gitsigns.diffthis("~")
-          end)
-          map("n", "<leader>gtd", gitsigns.toggle_deleted)
-
-          -- Text object
-          map({ "o", "x" }, "ih", ":<C-U>Gitsigns select_hunk<CR>")
-        end,
-      })
-    end,
-  },
   {
     "neogit",
     cmd = "Neogit",

lua/scripts/intellitab.lua

@@ -7,66 +7,66 @@ local v = vim.api
 local treesitter = require("nvim-treesitter")
 
 local function get_line_indent(line, sw)
-	local indent = 0
+  local indent = 0
 
-	for c in line:gmatch("%s") do
+  for c in line:gmatch("%s") do
-		if c == "\t" then
+    if c == "\t" then
-			indent = indent + sw
+      indent = indent + sw
-		else
+    else
-			indent = indent + 1
+      indent = indent + 1
-		end
+    end
-	end
+  end
 
-	return indent
+  return indent
 end
 
 local function indent()
-	local cursor = v.nvim_win_get_cursor(0)
+  local cursor = v.nvim_win_get_cursor(0)
-	local line = v.nvim_buf_get_lines(0, cursor[1] - 1, cursor[1], false)[1]
+  local line = v.nvim_buf_get_lines(0, cursor[1] - 1, cursor[1], false)[1]
 
-	local indentexpr = v.nvim_buf_get_option(0, "indentexpr")
+  local indentexpr = v.nvim_get_option_value("indentexpr", { buf = 0 })
-	local expand = v.nvim_buf_get_option(0, "expandtab")
+  local expand = v.nvim_get_option_value("expandtab", { buf = 0 })
-	local shiftwidth = v.nvim_eval("shiftwidth()")
+  local shiftwidth = v.nvim_eval("shiftwidth()")
-	local tab_char = v.nvim_replace_termcodes("<Tab>", true, true, true)
+  local tab_char = v.nvim_replace_termcodes("<Tab>", true, true, true)
-	local indent_goal
+  local indent_goal
 
-	if treesitter ~= nil and treesitter.get_indent ~= nil then
+  if treesitter ~= nil and treesitter.get_indent ~= nil then
-		indent_goal = treesitter.get_indent(line)
+    indent_goal = treesitter.get_indent(line)
-	end
+  end
 
-	if indent_goal == nil or indent_goal < 0 then
+  if indent_goal == nil or indent_goal < 0 then
-		if indentexpr ~= "" then
+    if indentexpr ~= "" then
-			indent_goal = v.nvim_eval(indentexpr)
+      indent_goal = v.nvim_eval(indentexpr)
-		elseif v.nvim_buf_get_option(0, "cindent") then
+    elseif v.nvim_get_option_value("cindent", { buf = 0 }) then
-			indent_goal = v.nvim_call_function("cindent", { cursor[1] })
+      indent_goal = v.nvim_call_function("cindent", { cursor[1] })
-		else
+    else
-			indent_goal = v.nvim_call_function("indent", { cursor[1] })
+      indent_goal = v.nvim_call_function("indent", { cursor[1] })
-		end
+    end
-	end
+  end
 
-	if indent_goal == -1 and cursor[1] ~= 1 then
+  if indent_goal == -1 and cursor[1] ~= 1 then
-		local prev_line = v.nvim_buf_get_lines(0, cursor[1] - 2, cursor[1] - 1, false)[1]
+    local prev_line = v.nvim_buf_get_lines(0, cursor[1] - 2, cursor[1] - 1, false)[1]
-		indent_goal = get_line_indent(prev_line, shiftwidth)
+    indent_goal = get_line_indent(prev_line, shiftwidth)
-	end
+  end
 
-	-- Reset the cursor, since the functions are free to move it
+  -- Reset the cursor, since the functions are free to move it
-	v.nvim_win_set_cursor(0, cursor)
+  v.nvim_win_set_cursor(0, cursor)
 
-	if cursor[2] == 0 and line == "" and indent_goal ~= nil and indent_goal > 0 then
+  if cursor[2] == 0 and line == "" and indent_goal ~= nil and indent_goal > 0 then
-		local i = 0
+    local i = 0
-		while i < indent_goal do
+    while i < indent_goal do
-			if expand then
+      if expand then
-				v.nvim_feedkeys(" ", "n", true)
+        v.nvim_feedkeys(" ", "n", true)
-				i = i + 1
+        i = i + 1
-			else
+      else
-				v.nvim_feedkeys(tab_char, "n", true)
+        v.nvim_feedkeys(tab_char, "n", true)
-				i = i + shiftwidth
+        i = i + shiftwidth
-			end
+      end
-		end
+    end
-		print(i, indent_goal)
+    print(i, indent_goal)
-	else
+  else
-		v.nvim_feedkeys(tab_char, "n", true)
+    v.nvim_feedkeys(tab_char, "n", true)
-	end
+  end
 end
 
 return { indent = indent }

nix/overlays.nix

@@ -0,0 +1,3 @@
+# Overlays for building custom non-trivial plugins
+
+[ (self: super: { }) ]