feat: add kickstart nixcats

kickstart/lua/custom/plugins/init.lua

@@ -0,0 +1,5 @@
+-- You can add your own plugins here or in other files in this directory!
+--  I promise not to create any merge conflicts in this directory :)
+--
+-- See the kickstart.nvim README for more information
+return {}

kickstart/lua/kickstart/health.lua

@@ -0,0 +1,52 @@
+--[[
+--
+-- This file is not required for your own configuration,
+-- but helps people determine if their system is setup correctly.
+--
+--]]
+
+local check_version = function()
+  local verstr = string.format('%s.%s.%s', vim.version().major, vim.version().minor, vim.version().patch)
+  if not vim.version.cmp then
+    vim.health.error(string.format("Neovim out of date: '%s'. Upgrade to latest stable or nightly", verstr))
+    return
+  end
+
+  if vim.version.cmp(vim.version(), { 0, 9, 4 }) >= 0 then
+    vim.health.ok(string.format("Neovim version is: '%s'", verstr))
+  else
+    vim.health.error(string.format("Neovim out of date: '%s'. Upgrade to latest stable or nightly", verstr))
+  end
+end
+
+local check_external_reqs = function()
+  -- Basic utils: `git`, `make`, `unzip`
+  for _, exe in ipairs { 'git', 'make', 'unzip', 'rg' } do
+    local is_executable = vim.fn.executable(exe) == 1
+    if is_executable then
+      vim.health.ok(string.format("Found executable: '%s'", exe))
+    else
+      vim.health.warn(string.format("Could not find executable: '%s'", exe))
+    end
+  end
+
+  return true
+end
+
+return {
+  check = function()
+    vim.health.start 'kickstart.nvim'
+
+    vim.health.info [[NOTE: Not every warning is a 'must-fix' in `:checkhealth`
+
+  Fix only warnings for plugins and languages you intend to use.
+    Mason will give warnings for languages that are not installed.
+    You do not need to install, unless you want to use those languages!]]
+
+    local uv = vim.uv or vim.loop
+    vim.health.info('System Information: ' .. vim.inspect(uv.os_uname()))
+
+    check_version()
+    check_external_reqs()
+  end,
+}

kickstart/lua/kickstart/plugins/autopairs.lua

@@ -0,0 +1,18 @@
+-- autopairs
+-- https://github.com/windwp/nvim-autopairs
+
+return {
+  'windwp/nvim-autopairs',
+  -- NOTE: nixCats: return true only if category is enabled, else false
+  enabled = require('nixCatsUtils').enableForCategory("kickstart-autopairs"),
+  event = 'InsertEnter',
+  -- Optional dependency
+  dependencies = { 'hrsh7th/nvim-cmp' },
+  config = function()
+    require('nvim-autopairs').setup {}
+    -- If you want to automatically add `(` after selecting a function or method
+    local cmp_autopairs = require 'nvim-autopairs.completion.cmp'
+    local cmp = require 'cmp'
+    cmp.event:on('confirm_done', cmp_autopairs.on_confirm_done())
+  end,
+}

kickstart/lua/kickstart/plugins/debug.lua

@@ -0,0 +1,100 @@
+-- debug.lua
+--
+-- Shows how to use the DAP plugin to debug your code.
+--
+-- Primarily focused on configuring the debugger for Go, but can
+-- be extended to other languages as well. That's why it's called
+-- kickstart.nvim and not kitchen-sink.nvim ;)
+
+return {
+  'mfussenegger/nvim-dap',
+  -- NOTE: nixCats: return true only if category is enabled, else false
+  enabled = require('nixCatsUtils').enableForCategory("kickstart-debug"),
+  dependencies = {
+    -- Creates a beautiful debugger UI
+    'rcarriga/nvim-dap-ui',
+
+    -- Required dependency for nvim-dap-ui
+    'nvim-neotest/nvim-nio',
+
+    -- Installs the debug adapters for you
+    -- NOTE: nixCats: dont use mason on nix. We can already download stuff just fine.
+    { 'williamboman/mason.nvim', enabled = require('nixCatsUtils').lazyAdd(true, false) },
+    { 'jay-babu/mason-nvim-dap.nvim', enabled = require('nixCatsUtils').lazyAdd(true, false) },
+
+    -- Add your own debuggers here
+    'leoluz/nvim-dap-go',
+  },
+  config = function()
+    local dap = require 'dap'
+    local dapui = require 'dapui'
+
+    -- NOTE: nixCats: dont use mason on nix. We can already download stuff just fine.
+    if not require('nixCatsUtils').isNixCats then
+      require('mason-nvim-dap').setup {
+        -- Makes a best effort to setup the various debuggers with
+        -- reasonable debug configurations
+        automatic_installation = true,
+
+        -- You can provide additional configuration to the handlers,
+        -- see mason-nvim-dap README for more information
+        handlers = {},
+
+        -- You'll need to check that you have the required things installed
+        -- online, please don't ask me how to install them :)
+        ensure_installed = {
+          -- Update this to ensure that you have the debuggers for the langs you want
+          'delve',
+        },
+      }
+    end
+
+    -- Basic debugging keymaps, feel free to change to your liking!
+    vim.keymap.set('n', '<F5>', dap.continue, { desc = 'Debug: Start/Continue' })
+    vim.keymap.set('n', '<F1>', dap.step_into, { desc = 'Debug: Step Into' })
+    vim.keymap.set('n', '<F2>', dap.step_over, { desc = 'Debug: Step Over' })
+    vim.keymap.set('n', '<F3>', dap.step_out, { desc = 'Debug: Step Out' })
+    vim.keymap.set('n', '<leader>b', dap.toggle_breakpoint, { desc = 'Debug: Toggle Breakpoint' })
+    vim.keymap.set('n', '<leader>B', function()
+      dap.set_breakpoint(vim.fn.input 'Breakpoint condition: ')
+    end, { desc = 'Debug: Set Breakpoint' })
+
+    -- Dap UI setup
+    -- For more information, see |:help nvim-dap-ui|
+    dapui.setup {
+      -- Set icons to characters that are more likely to work in every terminal.
+      --    Feel free to remove or use ones that you like more! :)
+      --    Don't feel like these are good choices.
+      icons = { expanded = '▾', collapsed = '▸', current_frame = '*' },
+      controls = {
+        icons = {
+          pause = '⏸',
+          play = '▶',
+          step_into = '⏎',
+          step_over = '⏭',
+          step_out = '⏮',
+          step_back = 'b',
+          run_last = '▶▶',
+          terminate = '⏹',
+          disconnect = '⏏',
+        },
+      },
+    }
+
+    -- Toggle to see last session result. Without this, you can't see session output in case of unhandled exception.
+    vim.keymap.set('n', '<F7>', dapui.toggle, { desc = 'Debug: See last session result.' })
+
+    dap.listeners.after.event_initialized['dapui_config'] = dapui.open
+    dap.listeners.before.event_terminated['dapui_config'] = dapui.close
+    dap.listeners.before.event_exited['dapui_config'] = dapui.close
+
+    -- Install golang specific config
+    require('dap-go').setup {
+      delve = {
+        -- On Windows delve must be run attached or it crashes.
+        -- See https://github.com/leoluz/nvim-dap-go/blob/main/README.md#configuring
+        detached = vim.fn.has 'win32' == 0,
+      },
+    }
+  end,
+}

kickstart/lua/kickstart/plugins/gitsigns.lua

@@ -0,0 +1,63 @@
+-- Adds git related signs to the gutter, as well as utilities for managing changes
+-- NOTE: gitsigns is already included in init.lua but contains only the base
+-- config. This will add also the recommended keymaps.
+
+return {
+  {
+    'lewis6991/gitsigns.nvim',
+    -- NOTE: nixCats: return true only if category is enabled, else false
+    enabled = require('nixCatsUtils').enableForCategory("kickstart-gitsigns"),
+    opts = {
+      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, { desc = 'Jump to next git [c]hange' })
+
+        map('n', '[c', function()
+          if vim.wo.diff then
+            vim.cmd.normal { '[c', bang = true }
+          else
+            gitsigns.nav_hunk 'prev'
+          end
+        end, { desc = 'Jump to previous git [c]hange' })
+
+        -- Actions
+        -- visual mode
+        map('v', '<leader>hs', function()
+          gitsigns.stage_hunk { vim.fn.line '.', vim.fn.line 'v' }
+        end, { desc = 'stage git hunk' })
+        map('v', '<leader>hr', function()
+          gitsigns.reset_hunk { vim.fn.line '.', vim.fn.line 'v' }
+        end, { desc = 'reset git hunk' })
+        -- normal mode
+        map('n', '<leader>hs', gitsigns.stage_hunk, { desc = 'git [s]tage hunk' })
+        map('n', '<leader>hr', gitsigns.reset_hunk, { desc = 'git [r]eset hunk' })
+        map('n', '<leader>hS', gitsigns.stage_buffer, { desc = 'git [S]tage buffer' })
+        map('n', '<leader>hu', gitsigns.undo_stage_hunk, { desc = 'git [u]ndo stage hunk' })
+        map('n', '<leader>hR', gitsigns.reset_buffer, { desc = 'git [R]eset buffer' })
+        map('n', '<leader>hp', gitsigns.preview_hunk, { desc = 'git [p]review hunk' })
+        map('n', '<leader>hb', gitsigns.blame_line, { desc = 'git [b]lame line' })
+        map('n', '<leader>hd', gitsigns.diffthis, { desc = 'git [d]iff against index' })
+        map('n', '<leader>hD', function()
+          gitsigns.diffthis '@'
+        end, { desc = 'git [D]iff against last commit' })
+        -- Toggles
+        map('n', '<leader>tb', gitsigns.toggle_current_line_blame, { desc = '[T]oggle git show [b]lame line' })
+        map('n', '<leader>tD', gitsigns.toggle_deleted, { desc = '[T]oggle git show [D]eleted' })
+      end,
+    },
+  },
+}

kickstart/lua/kickstart/plugins/indent_line.lua

@@ -0,0 +1,11 @@
+return {
+  { -- Add indentation guides even on blank lines
+    'lukas-reineke/indent-blankline.nvim',
+    -- NOTE: nixCats: return true only if category is enabled, else false
+    enabled = require('nixCatsUtils').enableForCategory("kickstart-indent_line"),
+    -- Enable `lukas-reineke/indent-blankline.nvim`
+    -- See `:help ibl`
+    main = 'ibl',
+    opts = {},
+  },
+}

kickstart/lua/kickstart/plugins/lint.lua

@@ -0,0 +1,57 @@
+return {
+
+  { -- Linting
+    'mfussenegger/nvim-lint',
+    -- NOTE: nixCats: return true only if category is enabled, else false
+    enabled = require('nixCatsUtils').enableForCategory("kickstart-lint"),
+    event = { 'BufReadPre', 'BufNewFile' },
+    config = function()
+      local lint = require 'lint'
+      lint.linters_by_ft = {
+        markdown = { 'markdownlint' },
+      }
+
+      -- To allow other plugins to add linters to require('lint').linters_by_ft,
+      -- instead set linters_by_ft like this:
+      -- lint.linters_by_ft = lint.linters_by_ft or {}
+      -- lint.linters_by_ft['markdown'] = { 'markdownlint' }
+      --
+      -- However, note that this will enable a set of default linters,
+      -- which will cause errors unless these tools are available:
+      -- {
+      --   clojure = { "clj-kondo" },
+      --   dockerfile = { "hadolint" },
+      --   inko = { "inko" },
+      --   janet = { "janet" },
+      --   json = { "jsonlint" },
+      --   markdown = { "vale" },
+      --   rst = { "vale" },
+      --   ruby = { "ruby" },
+      --   terraform = { "tflint" },
+      --   text = { "vale" }
+      -- }
+      --
+      -- You can disable the default linters by setting their filetypes to nil:
+      -- lint.linters_by_ft['clojure'] = nil
+      -- lint.linters_by_ft['dockerfile'] = nil
+      -- lint.linters_by_ft['inko'] = nil
+      -- lint.linters_by_ft['janet'] = nil
+      -- lint.linters_by_ft['json'] = nil
+      -- lint.linters_by_ft['markdown'] = nil
+      -- lint.linters_by_ft['rst'] = nil
+      -- lint.linters_by_ft['ruby'] = nil
+      -- lint.linters_by_ft['terraform'] = nil
+      -- lint.linters_by_ft['text'] = nil
+
+      -- Create autocommand which carries out the actual linting
+      -- on the specified events.
+      local lint_augroup = vim.api.nvim_create_augroup('lint', { clear = true })
+      vim.api.nvim_create_autocmd({ 'BufEnter', 'BufWritePost', 'InsertLeave' }, {
+        group = lint_augroup,
+        callback = function()
+          require('lint').try_lint()
+        end,
+      })
+    end,
+  },
+}

kickstart/lua/kickstart/plugins/neo-tree.lua

@@ -0,0 +1,27 @@
+-- Neo-tree is a Neovim plugin to browse the file system
+-- https://github.com/nvim-neo-tree/neo-tree.nvim
+
+return {
+  'nvim-neo-tree/neo-tree.nvim',
+  -- NOTE: nixCats: return true only if category is enabled, else false
+  enabled = require('nixCatsUtils').enableForCategory("kickstart-neo-tree"),
+  version = '*',
+  dependencies = {
+    'nvim-lua/plenary.nvim',
+    'nvim-tree/nvim-web-devicons', -- not strictly required, but recommended
+    'MunifTanjim/nui.nvim',
+  },
+  cmd = 'Neotree',
+  keys = {
+    { '\\', ':Neotree reveal<CR>', { desc = 'NeoTree reveal' } },
+  },
+  opts = {
+    filesystem = {
+      window = {
+        mappings = {
+          ['\\'] = 'close_window',
+        },
+      },
+    },
+  },
+}

kickstart/lua/nixCatsUtils/init.lua

@@ -0,0 +1,129 @@
+--[[
+  This directory is the luaUtils template.
+  You can choose what things from it that you would like to use.
+  And then delete the rest.
+  Everything in this directory is optional.
+--]]
+
+local M = {}
+
+--[[
+  This file is for making your config still work WITHOUT nixCats.
+  When you don't use nixCats to load your config,
+  you wont have the nixCats plugin.
+
+  The setup function defined here defines a mock nixCats plugin when nixCats wasnt used to load the config.
+  This will help avoid indexing errors when the nixCats plugin doesnt exist.
+
+  NOTE: If you only ever use nixCats to load your config, you don't need this file.
+--]]
+
+---@type boolean
+M.isNixCats = vim.g[ [[nixCats-special-rtp-entry-nixCats]] ] ~= nil
+
+---@class nixCatsSetupOpts
+---@field non_nix_value boolean|nil
+
+---This function will setup a mock nixCats plugin when not using nix
+---It will help prevent you from running into indexing errors without a nixCats plugin from nix.
+---If you loaded the config via nix, it does nothing
+---non_nix_value defaults to true if not provided or is not a boolean.
+---@param v nixCatsSetupOpts
+function M.setup(v)
+  if not M.isNixCats then
+    local nixCats_default_value
+    if type(v) == "table" and type(v.non_nix_value) == "boolean" then
+      nixCats_default_value = v.non_nix_value
+    else
+      nixCats_default_value = true
+    end
+    local mk_with_meta = function (tbl)
+      return setmetatable(tbl, {
+        __call = function(_, attrpath)
+          local strtable = {}
+          if type(attrpath) == "table" then
+              strtable = attrpath
+          elseif type(attrpath) == "string" then
+              for key in attrpath:gmatch("([^%.]+)") do
+                  table.insert(strtable, key)
+              end
+          else
+              print("function requires a table of strings or a dot separated string")
+              return
+          end
+          return vim.tbl_get(tbl, unpack(strtable));
+        end
+      })
+    end
+    package.preload['nixCats'] = function ()
+      local ncsub = {
+        get = function(_) return nixCats_default_value end,
+        cats = mk_with_meta({
+          nixCats_config_location = vim.fn.stdpath('config'),
+          wrapRc = false,
+        }),
+        settings = mk_with_meta({
+          nixCats_config_location = vim.fn.stdpath('config'),
+          configDirName = os.getenv("NVIM_APPNAME") or "nvim",
+          wrapRc = false,
+        }),
+        petShop = mk_with_meta({}),
+        extra = mk_with_meta({}),
+        pawsible = mk_with_meta({
+          allPlugins = {
+            start = {},
+            opt = {},
+          },
+        }),
+        configDir = vim.fn.stdpath('config'),
+        packageBinPath = os.getenv('NVIM_WRAPPER_PATH_NIX') or vim.v.progpath
+      }
+      return setmetatable(ncsub, {__call = function(_, cat) return ncsub.get(cat) end})
+    end
+    _G.nixCats = require('nixCats')
+  end
+end
+
+---allows you to guarantee a boolean is returned, and also declare a different
+---default value than specified in setup when not using nix to load the config
+---@overload fun(v: string|string[]): boolean
+---@overload fun(v: string|string[], default: boolean): boolean
+function M.enableForCategory(v, default)
+  if M.isNixCats or default == nil then
+    if nixCats(v) then
+      return true
+    else
+      return false
+    end
+  else
+    return default
+  end
+end
+
+---if nix, return value of nixCats(v) else return default
+---Exists to specify a different non_nix_value than the one in setup()
+---@param v string|string[]
+---@param default any
+---@return any
+function M.getCatOrDefault(v, default)
+  if M.isNixCats then
+    return nixCats(v)
+  else
+    return default
+  end
+end
+
+---for conditionally disabling build steps on nix, as they are done via nix
+---I should probably have named it dontAddIfCats or something.
+---@overload fun(v: any): any|nil
+---Will return the second value if nix, otherwise the first
+---@overload fun(v: any, o: any): any
+function M.lazyAdd(v, o)
+  if M.isNixCats then
+    return o
+  else
+    return v
+  end
+end
+
+return M

kickstart/lua/nixCatsUtils/lazyCat.lua

@@ -0,0 +1,119 @@
+--[[
+  This directory is the luaUtils template.
+  You can choose what things from it that you would like to use.
+  And then delete the rest.
+  Everything in this directory is optional.
+--]]
+
+local M = {}
+-- NOTE: If you don't use lazy.nvim, you don't need this file.
+
+---lazy.nvim wrapper
+---@overload fun(nixLazyPath: string|nil, lazySpec: any, opts: table)
+---@overload fun(nixLazyPath: string|nil, opts: table)
+function M.setup(nixLazyPath, lazySpec, opts)
+  local lazySpecs = nil
+  local lazyCFG = nil
+  if opts == nil and type(lazySpec) == "table" and lazySpec.spec then
+    lazyCFG = lazySpec
+  else
+    lazySpecs = lazySpec
+    lazyCFG = opts
+  end
+
+  local function regularLazyDownload()
+    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', -- latest stable release
+        lazypath,
+      }
+    end
+    return lazypath
+  end
+
+  local isNixCats = vim.g[ [[nixCats-special-rtp-entry-nixCats]] ] ~= nil
+  local lazypath
+  if not isNixCats then
+    -- No nixCats? Not nix. Do it normally
+    lazypath = regularLazyDownload()
+    vim.opt.rtp:prepend(lazypath)
+  else
+    local nixCats = require('nixCats')
+    -- Else, its nix, so we wrap lazy with a few extra config options
+    lazypath = nixLazyPath
+    -- and also we probably dont have to download lazy either
+    if lazypath == nil then
+      lazypath = regularLazyDownload()
+    end
+
+    local oldPath
+    local lazypatterns
+    local fallback
+    if type(lazyCFG) == "table" and type(lazyCFG.dev) == "table" then
+      lazypatterns = lazyCFG.dev.patterns
+      fallback = lazyCFG.dev.fallback
+      oldPath = lazyCFG.dev.path
+    end
+
+    local myNeovimPackages = nixCats.vimPackDir .. "/pack/myNeovimPackages"
+
+    local newLazyOpts = {
+      performance = {
+        rtp = {
+          reset = false,
+        },
+      },
+      dev = {
+        path = function(plugin)
+          local path = nil
+          if type(oldPath) == "string" and vim.fn.isdirectory(oldPath .. "/" .. plugin.name) == 1 then
+            path = oldPath .. "/" .. plugin.name
+          elseif type(oldPath) == "function" then
+            path = oldPath(plugin)
+            if type(path) ~= "string" then
+              path = nil
+            end
+          end
+          if path == nil then
+            if vim.fn.isdirectory(myNeovimPackages .. "/start/" .. plugin.name) == 1 then
+              path = myNeovimPackages .. "/start/" .. plugin.name
+            elseif vim.fn.isdirectory(myNeovimPackages .. "/opt/" .. plugin.name) == 1 then
+              path = myNeovimPackages .. "/opt/" .. plugin.name
+            else
+              path = "~/projects/" .. plugin.name
+            end
+          end
+          return path
+        end,
+        patterns = lazypatterns or { "" },
+        fallback = fallback == nil and true or fallback,
+      }
+    }
+    lazyCFG = vim.tbl_deep_extend("force", lazyCFG or {}, newLazyOpts)
+    -- do the reset we disabled without removing important stuff
+    local cfgdir = nixCats.configDir
+    vim.opt.rtp = {
+      cfgdir,
+      nixCats.nixCatsPath,
+      nixCats.pawsible.allPlugins.ts_grammar_path,
+      vim.fn.stdpath("data") .. "/site",
+      lazypath,
+      vim.env.VIMRUNTIME,
+      vim.fn.fnamemodify(vim.v.progpath, ":p:h:h") .. "/lib/nvim",
+      cfgdir .. "/after",
+    }
+  end
+
+  if lazySpecs then
+    require('lazy').setup(lazySpecs, lazyCFG)
+  else
+    require('lazy').setup(lazyCFG)
+  end
+end
+
+return M