change to new code

.gitignore

@@ -1,8 +0,0 @@
-tt.*
-.tests
-doc/tags
-debug
-.repro
-foo.*
-*.log
-data

.neoconf.json

@@ -1,15 +0,0 @@
-{
-	"neodev": {
-		"library": {
-			"enabled": true,
-			"plugins": true
-		}
-	},
-	"neoconf": {
-		"plugins": {
-			"lua_ls": {
-				"enabled": true
-			}
-		}
-	}
-}

.stylua.toml

@@ -1,6 +0,0 @@
-column_width = 120
-line_endings = "Unix"
-indent_type = "Spaces"
-indent_width = 2
-quote_style = "AutoPreferDouble"
-call_parentheses = "Always"

after/ftplugin/latex.lua

@@ -1 +0,0 @@
-vim.cmd([[runtime! ftplugin/tex.lua]])

after/ftplugin/tex.lua

@@ -1,3 +0,0 @@
-vim.opt_local.wrap = true
-vim.opt_local.breakindent = true
-vim.opt_local.breakindentopt = "shift:2"

after/ftplugin/text.lua

@@ -1,11 +0,0 @@
-vim.opt_local.tabstop = 4
-vim.opt_local.softtabstop = 4
-vim.opt_local.shiftwidth = 4
-vim.opt_local.expandtab = false
-vim.opt_local.wrap = true
--- disable indentation
-vim.opt_local.autoindent = false
-vim.opt_local.smartindent = false
-vim.opt_local.cindent = false
--- vim.opt_local.indentexpr = ""
--- vim.opt_local.paste = true

init.lua

@@ -1,3 +1,193 @@
-local ray = require("rayandrew")
+-- Set <space> as the leader key
+-- See `:help mapleader`
+--  NOTE: Must happen before plugins are loaded (otherwise wrong leader will be used)
+vim.g.mapleader = ' '
+vim.g.maplocalleader = ' '
 
-ray.setup()
+-- Set to true if you have a Nerd Font installed and selected in the terminal
+vim.g.have_nerd_font = true
+
+-- [[ Setting options ]]
+-- See `:help vim.opt`
+-- NOTE: You can change these options as you wish!
+--  For more options, you can see `:help option-list`
+
+vim.opt.number = true
+vim.opt.relativenumber = true
+
+-- Enable mouse mode, can be useful for resizing splits for example!
+vim.opt.mouse = 'a'
+
+-- Don't show the mode, since it's already in the status line
+vim.opt.showmode = false
+
+-- Sync clipboard between OS and Neovim.
+--  Schedule the setting after `UiEnter` because it can increase startup-time.
+--  Remove this option if you want your OS clipboard to remain independent.
+--  See `:help 'clipboard'`
+vim.schedule(function()
+  vim.opt.clipboard = 'unnamedplus'
+end)
+
+-- Enable break indent
+vim.opt.breakindent = true
+
+-- Save undo history
+vim.opt.undofile = true
+
+-- Case-insensitive searching UNLESS \C or one or more capital letters in the search term
+vim.opt.ignorecase = true
+vim.opt.smartcase = true
+
+-- Keep signcolumn on by default
+vim.opt.signcolumn = 'yes'
+
+-- Decrease update time
+vim.opt.updatetime = 250
+
+-- Decrease mapped sequence wait time
+-- Displays which-key popup sooner
+vim.opt.timeoutlen = 300
+
+-- Configure how new splits should be opened
+vim.opt.splitright = true
+vim.opt.splitbelow = true
+
+-- Sets how neovim will display certain whitespace characters in the editor.
+--  See `:help 'list'`
+--  and `:help 'listchars'`
+vim.opt.list = true
+vim.opt.listchars = { tab = '» ', trail = '·', nbsp = '␣' }
+
+-- Preview substitutions live, as you type!
+vim.opt.inccommand = 'split'
+
+-- Show which line your cursor is on
+vim.opt.cursorline = true
+
+-- Minimal number of screen lines to keep above and below the cursor.
+-- vim.opt.scrolloff = 10
+
+-- [[ Basic Keymaps ]]
+--  See `:help vim.keymap.set()`
+
+-- Clear highlights on search when pressing <Esc> in normal mode
+--  See `:help hlsearch`
+vim.keymap.set('n', '<Esc>', '<cmd>nohlsearch<CR>')
+
+-- Diagnostic keymaps
+vim.keymap.set('n', '<leader>q', vim.diagnostic.setloclist, { desc = 'Open diagnostic [Q]uickfix list' })
+
+-- Exit terminal mode in the builtin terminal with a shortcut that is a bit easier
+-- for people to discover. Otherwise, you normally need to press <C-\><C-n>, which
+-- is not what someone will guess without a bit more experience.
+--
+-- NOTE: This won't work in all terminal emulators/tmux/etc. Try your own mapping
+-- or just use <C-\><C-n> to exit terminal mode
+vim.keymap.set('t', '<Esc><Esc>', '<C-\\><C-n>', { desc = 'Exit terminal mode' })
+
+-- [[ Basic Autocommands ]]
+--  See `:help lua-guide-autocommands`
+
+-- Highlight when yanking (copying) text
+--  Try it with `yap` in normal mode
+--  See `:help vim.highlight.on_yank()`
+vim.api.nvim_create_autocmd('TextYankPost', {
+  desc = 'Highlight when yanking (copying) text',
+  group = vim.api.nvim_create_augroup('kickstart-highlight-yank', { clear = true }),
+  callback = function()
+    vim.highlight.on_yank()
+  end,
+})
+
+-- [[ Install `lazy.nvim` plugin manager ]]
+--    See `:help lazy.nvim.txt` or https://github.com/folke/lazy.nvim for more info
+local lazypath = vim.fn.stdpath 'data' .. '/lazy/lazy.nvim'
+if not vim.uv.fs_stat(lazypath) then
+  local lazyrepo = 'https://github.com/folke/lazy.nvim.git'
+  local out = vim.fn.system { 'git', 'clone', '--filter=blob:none', '--branch=stable', lazyrepo, lazypath }
+  if vim.v.shell_error ~= 0 then
+    error('Error cloning lazy.nvim:\n' .. out)
+  end
+end ---@diagnostic disable-next-line: undefined-field
+vim.opt.rtp:prepend(lazypath)
+
+-- [[ Configure and install plugins ]]
+require('lazy').setup({
+  'tpope/vim-sleuth', -- Detect tabstop and shiftwidth automatically
+
+  { -- Useful plugin to show you pending keybinds.
+    'folke/which-key.nvim',
+    event = 'VimEnter', -- Sets the loading event to 'VimEnter'
+    config = function() -- This is the function that runs, AFTER loading
+      require('which-key').setup()
+
+      -- Document existing key chains
+      require('which-key').add {
+        { '<leader>c', group = '[C]ode' },
+        { '<leader>d', group = '[D]ocument' },
+        { '<leader>r', group = '[R]ename' },
+        { '<leader>s', group = '[S]earch' },
+        { '<leader>w', group = '[W]orkspace' },
+        { '<leader>t', group = '[T]oggle' },
+        { '<leader>h', group = 'Git [H]unk', mode = { 'n', 'v' } },
+      }
+    end,
+  },
+
+  -- Highlight todo, notes, etc in comments
+  { 'folke/todo-comments.nvim', event = 'VimEnter', dependencies = { 'nvim-lua/plenary.nvim' }, opts = { signs = false } },
+
+  { import = 'rayandrew.plugins' },
+}, {
+  checker = {
+    enabled = true,
+    notify = false,
+    frequency = 3600 * 12,
+  },
+  change_detection = {
+    enabled = true,
+    notify = false,
+  },
+  ui = {
+    -- If you are using a Nerd Font: set icons to an empty table which will use the
+    -- default lazy.nvim defined Nerd Font icons, otherwise define a unicode icons table
+    icons = vim.g.have_nerd_font and {} or {
+      cmd = '⌘',
+      config = '🛠',
+      event = '📅',
+      ft = '📂',
+      init = '⚙',
+      keys = '🗝',
+      plugin = '🔌',
+      runtime = '💻',
+      require = '🌙',
+      source = '📄',
+      start = '🚀',
+      task = '📌',
+      lazy = '💤 ',
+    },
+  },
+  performance = {
+    cache = {
+      enabled = true,
+    },
+    reset_packpath = true,
+    rtp = {
+      -- disable some rtp plugins
+      disabled_plugins = {
+        'gzip',
+        -- "matchit",
+        -- "matchparen",
+        'netrwPlugin',
+        'tarPlugin',
+        'tohtml',
+        'tutor',
+        'zipPlugin',
+      },
+    },
+  },
+})
+
+-- The line beneath this is called `modeline`. See `:help modeline`
+-- vim: ts=2 sts=2 sw=2 et

lazy-lock.json

@@ -1,68 +1,68 @@
 {
-  "LuaSnip": { "branch": "master", "commit": "ce0a05ab4e2839e1c48d072c5236cce846a387bc" },
+  "LuaSnip": { "branch": "master", "commit": "b84eeb3641b08324287587b426ec974b888390d9" },
-  "bufresize.nvim": { "branch": "master", "commit": "3b19527ab936d6910484dcc20fb59bdb12322d8b" },
+  "adwaita.nvim": { "branch": "main", "commit": "c9379097755701ab597140bafd097fbaff3dd517" },
-  "chezmoi.nvim": { "branch": "main", "commit": "e5d2b2f534d2a1701ea2f9a8849732b28ea4c8c3" },
+  "aerial.nvim": { "branch": "master", "commit": "e75a3df2c20b3a98c786f5e61587d74a7a6b61d6" },
-  "chezmoi.vim": { "branch": "main", "commit": "abf37336437867cbd99ce2f8849b717415391cc3" },
+  "baleia.nvim": { "branch": "main", "commit": "fb3aff021b2b64ef820d0230d2c22ebfaf71bb6a" },
-  "cloak.nvim": { "branch": "main", "commit": "648aca6d33ec011dc3166e7af3b38820d01a71e4" },
   "cmp-nvim-lsp": { "branch": "main", "commit": "39e2eda76828d88b773cc27a3f61d2ad782c922d" },
-  "conform.nvim": { "branch": "master", "commit": "25d48271e3d4404ba017cb92a37d3a681c1ad149" },
+  "cmp-path": { "branch": "main", "commit": "91ff86cd9c29299a64f968ebb45846c485725f23" },
-  "copilot.vim": { "branch": "release", "commit": "25f73977033c597d530c7ab0e211d99b60927d2d" },
+  "cmp_luasnip": { "branch": "master", "commit": "05a9ab28b53f71d1aece421ef32fee2cb857a843" },
-  "everforest": { "branch": "main", "commit": "8fdccd1e45088be3309aaf82072b1f7fec2f6f2c" },
+  "compile-mode.nvim": { "branch": "latest", "commit": "8608fce76777d01b820ffe355a7881fc74209b82" },
-  "focus.nvim": { "branch": "master", "commit": "4135f976afe5d6e1fe66dff121db9d06643f439f" },
+  "conform.nvim": { "branch": "master", "commit": "eff40c4f5fdf7ae8f269b258047d1bd7cee50f02" },
-  "fzf": { "branch": "master", "commit": "af4917dbb643a7991c50091ec55ec25acb7d28cb" },
+  "copilot-cmp": { "branch": "master", "commit": "b6e5286b3d74b04256d0a7e3bd2908eabec34b44" },
-  "fzf.vim": { "branch": "master", "commit": "f7c7b44764a601e621432b98c85709c9a53a7be8" },
+  "copilot.lua": { "branch": "master", "commit": "86537b286f18783f8b67bccd78a4ef4345679625" },
-  "gitsigns.nvim": { "branch": "main", "commit": "f074844b60f9e151970fbcdbeb8a2cd52b6ef25a" },
+  "diffview.nvim": { "branch": "main", "commit": "4516612fe98ff56ae0415a259ff6361a89419b0a" },
-  "glow.nvim": { "branch": "main", "commit": "238070a686c1da3bccccf1079700eb4b5e19aea4" },
+  "fidget.nvim": { "branch": "main", "commit": "d855eed8a06531a7e8fd0684889b2943f373c469" },
+  "friendly-snippets": { "branch": "main", "commit": "00ebcaa159e817150bd83bfe2d51fa3b3377d5c4" },
+  "fzf-lua": { "branch": "main", "commit": "e9413dc2b6e8ab7f62385c972df1dceba483492d" },
+  "git-conflict.nvim": { "branch": "main", "commit": "bfd9fe6fba9a161fc199771d85996236a0d0faad" },
+  "gitsigns.nvim": { "branch": "main", "commit": "58bd9e98d8e3c5a1c98af312e85247ee1afd3ed2" },
   "gruber-darker.nvim": { "branch": "main", "commit": "1793c0929ca965430410f7ec578272a4af9226ee" },
   "harpoon": { "branch": "master", "commit": "ccae1b9bec717ae284906b0bf83d720e59d12b91" },
-  "hydra.nvim": { "branch": "master", "commit": "55de54543d673824435930ecf533256eea2e565b" },
+  "hybrid.nvim": { "branch": "master", "commit": "8838621a2e299582a0af5b8b96d5515f27b5d058" },
-  "image.nvim": { "branch": "master", "commit": "61c76515cfc3cdac8123ece9e9761b20c3dc1315" },
+  "hydra.nvim": { "branch": "main", "commit": "8578056a2226ed49fc608167edc143a87f75d809" },
-  "indent-blankline.nvim": { "branch": "master", "commit": "65e20ab94a26d0e14acac5049b8641336819dfc7" },
+  "indent-blankline.nvim": { "branch": "master", "commit": "3fe94b8034dd5241cb882bb73847303b58857ecf" },
+  "kanagawa.nvim": { "branch": "master", "commit": "e5f7b8a804360f0a48e40d0083a97193ee4fcc87" },
   "lazy.nvim": { "branch": "main", "commit": "077102c5bfc578693f12377846d427f49bc50076" },
-  "lsp-zero.nvim": { "branch": "v3.x", "commit": "56db3d5ce5476b183783160e6045f7337ba12b83" },
+  "lazydev.nvim": { "branch": "main", "commit": "491452cf1ca6f029e90ad0d0368848fac717c6d2" },
-  "lualine.nvim": { "branch": "master", "commit": "544dd1583f9bb27b393f598475c89809c4d5e86b" },
+  "lsp_signature.nvim": { "branch": "master", "commit": "a38da0a61c172bb59e34befc12efe48359884793" },
-  "markdown-preview.nvim": { "branch": "master", "commit": "a923f5fc5ba36a3b17e289dc35dc17f66d0548ee" },
+  "luvit-meta": { "branch": "main", "commit": "ce76f6f6cdc9201523a5875a4471dcfe0186eb60" },
-  "mason-lspconfig.nvim": { "branch": "main", "commit": "ba9c2f0b93deb48d0a99ae0e8d8dd36f7cc286d6" },
+  "markview.nvim": { "branch": "main", "commit": "9e5275f3b7507da51deab9bc985e9154d0b6af28" },
+  "mason-lspconfig.nvim": { "branch": "main", "commit": "62360f061d45177dda8afc1b0fd1327328540301" },
   "mason-tool-installer.nvim": { "branch": "main", "commit": "c5e07b8ff54187716334d585db34282e46fa2932" },
   "mason.nvim": { "branch": "main", "commit": "e2f7f9044ec30067bc11800a9e266664b88cda22" },
-  "meh": { "branch": "master", "commit": "41dd74e2d5afc6c1e975b01c84512a8951a39569" },
+  "mini-git": { "branch": "main", "commit": "c5daa5556c1798b6ef6595a3011af3ca5f7a2fd8" },
+  "mini.ai": { "branch": "main", "commit": "a9b992b13d22a8db8df6beac25afa59a10b5584d" },
   "mini.bufremove": { "branch": "main", "commit": "1ee294a97e091d3cf967974df622c0d887890dc2" },
-  "mini.comment": { "branch": "main", "commit": "03c13e37318bdb18481311c0ac1adc9ed731caf1" },
+  "mini.icons": { "branch": "main", "commit": "fe63fe080e76d80713557e5f0c65bc15b14b152d" },
+  "mini.indentscope": { "branch": "main", "commit": "1222393d9c5e8d92b913ccab6701a7164b21781c" },
+  "mini.statusline": { "branch": "main", "commit": "ec7e2c509c7262fef85a28a772f60ebe146297db" },
+  "mini.surround": { "branch": "main", "commit": "57caca9525cec0ea771a67326b0ee637d056078a" },
   "multicursors.nvim": { "branch": "main", "commit": "782820896b1691ed664e4c24f1cd9793dcb33dfb" },
-  "nabla.nvim": { "branch": "master", "commit": "27a6ea9ed7452bb9e0b19eb0942b5bcf7d051b2f" },
+  "neo-tree.nvim": { "branch": "main", "commit": "8c75e8a2949cd6cd35525799200a8d34471ee9eb" },
-  "neo-tree.nvim": { "branch": "v3.x", "commit": "29f7c215332ba95e470811c380ddbce2cebe2af4" },
+  "neogit": { "branch": "master", "commit": "2b74a777b963dfdeeabfabf84d5ba611666adab4" },
   "nui.nvim": { "branch": "main", "commit": "61574ce6e60c815b0a0c4b5655b8486ba58089a1" },
-  "nvim-bqf": { "branch": "main", "commit": "1b24dc6050c34e8cd377b6b4cd6abe40509e0187" },
+  "numb.nvim": { "branch": "master", "commit": "3f7d4a74bd456e747a1278ea1672b26116e0824d" },
-  "nvim-cmp": { "branch": "main", "commit": "d818fd0624205b34e14888358037fb6f5dc51234" },
+  "nvim-autopairs": { "branch": "master", "commit": "e38c5d837e755ce186ae51d2c48e1b387c4425c6" },
-  "nvim-lint": { "branch": "master", "commit": "efc6fc83f0772283e064c53a8f9fb5645bde0bc0" },
+  "nvim-cmp": { "branch": "main", "commit": "ae644feb7b67bf1ce4260c231d1d4300b19c6f30" },
-  "nvim-lspconfig": { "branch": "master", "commit": "fdc44768a09a65140aa00c92872a5381ad486485" },
+  "nvim-lspconfig": { "branch": "master", "commit": "6c505d4220b521f3b0e7b645f6ce45fa914d0eed" },
-  "nvim-spectre": { "branch": "master", "commit": "ba7fb777edff6c1fbbeffd343e113af64c04e90a" },
+  "nvim-osc52": { "branch": "main", "commit": "04cfaba1865ae5c53b6f887c3ca7304973824fb2" },
-  "nvim-surround": { "branch": "main", "commit": "ec2dc7671067e0086cdf29c2f5df2dd909d5f71f" },
+  "nvim-treesitter": { "branch": "master", "commit": "e28614cb1a5712166afef80081f68c28db92e3e0" },
-  "nvim-treesitter": { "branch": "master", "commit": "65310b64eee19a6e74e1b6f607a9f46f751290fe" },
+  "nvim-ufo": { "branch": "main", "commit": "7dcb8fea3e7b3ccdb50f2c3ae7c248cdf6fe1ae1" },
-  "nvim-treesitter-context": { "branch": "master", "commit": "2aba92ceb1479485953007f4d5adf34d0b66917e" },
+  "nvim-web-devicons": { "branch": "master", "commit": "3722e3d1fb5fe1896a104eb489e8f8651260b520" },
-  "nvim-treesitter-textobjects": { "branch": "master", "commit": "34867c69838078df7d6919b130c0541c0b400c47" },
-  "nvim-ts-context-commentstring": { "branch": "main", "commit": "6b5f95aa4d24f2c629a74f2c935c702b08dbde62" },
-  "nvim-web-devicons": { "branch": "master", "commit": "5be6c4e685618b99c3210a69375b38a1202369b4" },
   "oil.nvim": { "branch": "master", "commit": "fcca212c2e966fc3dec1d4baf888e670631d25d1" },
+  "outline.nvim": { "branch": "main", "commit": "2175b6da5b7b5be9de14fd3f54383a17f5e4609c" },
   "plenary.nvim": { "branch": "master", "commit": "a3e3bc82a3f95c5ed0d7201546d5d2c19b20d683" },
-  "rasmus": { "branch": "main", "commit": "86d608bd1d12a53b39d9b4b2847cd7c3ea81d473" },
+  "promise-async": { "branch": "main", "commit": "119e8961014c9bfaf1487bf3c2a393d254f337e2" },
+  "rainbow-delimiters.nvim": { "branch": "master", "commit": "a727bd368e70808125b7cf589328cc595faf3d5a" },
   "readline.nvim": { "branch": "main", "commit": "5cb27349bc01cdcdb3d3494e5337d8b3834aef1a" },
-  "rose-pine": { "branch": "main", "commit": "e4b08d74b7272cb21e4e9c71b8b9e0830fd722fe" },
+  "sg.nvim": { "branch": "master", "commit": "8bdd4d19da2268072708d5fe18fda9c23e16509d" },
-  "smart-splits.nvim": { "branch": "master", "commit": "209c136a5bee236094245196986ce94920dd3fdf" },
-  "snakemake": { "branch": "main", "commit": "e8735c1477a2a82110757ba86bbd1ccbcaf327ba" },
-  "symbols-outline.nvim": { "branch": "master", "commit": "564ee65dfc9024bdde73a6621820866987cbb256" },
   "telescope-fzf-native.nvim": { "branch": "main", "commit": "cf48d4dfce44e0b9a2e19a008d6ec6ea6f01a83b" },
-  "telescope.nvim": { "branch": "master", "commit": "10b8a82b042caf50b78e619d92caf0910211973d" },
+  "telescope-ui-select.nvim": { "branch": "master", "commit": "6e51d7da30bd139a6950adf2a47fda6df9fa06d2" },
+  "telescope.nvim": { "branch": "0.1.x", "commit": "a0bbec21143c7bc5f8bb02e0005fa0b982edc026" },
   "todo-comments.nvim": { "branch": "main", "commit": "8f45f353dc3649cb9b44cecda96827ea88128584" },
-  "trouble.nvim": { "branch": "main", "commit": "6efc446226679fda0547c0fd6a7892fd5f5b15d8" },
+  "typewriter": { "branch": "main", "commit": "d1b3aa53d4805120674b26554e027d5f10350419" },
   "undotree": { "branch": "master", "commit": "56c684a805fe948936cda0d1b19505b84ad7e065" },
-  "venn.nvim": { "branch": "main", "commit": "b09c2f36ddf70b498281845109bedcf08a7e0de0" },
+  "vim-sleuth": { "branch": "master", "commit": "1cc4557420f215d02c4d2645a748a816c220e99b" },
-  "vim-dispatch": { "branch": "master", "commit": "4c695bc052cad2ae6b980aebbe48d046466e27ae" },
-  "vim-fugitive": { "branch": "master", "commit": "0444df68cd1cdabc7453d6bd84099458327e5513" },
-  "vim-illuminate": { "branch": "master", "commit": "5eeb7951fc630682c322e88a9bbdae5c224ff0aa" },
-  "vim-startuptime": { "branch": "master", "commit": "ac2cccb5be617672add1f4f3c0a55ce99ba34e01" },
   "vim-tmux-navigator": { "branch": "master", "commit": "5b3c701686fb4e6629c100ed32e827edf8dad01e" },
-  "vimtex": { "branch": "master", "commit": "5ac62e0315c6f54f53a7d6da7c485cf8e9cf7240" },
+  "which-key.nvim": { "branch": "main", "commit": "6c1584eb76b55629702716995cca4ae2798a9cca" }
-  "which-key.nvim": { "branch": "main", "commit": "6c1584eb76b55629702716995cca4ae2798a9cca" },
-  "zen-mode.nvim": { "branch": "main", "commit": "29b292bdc58b76a6c8f294c961a8bf92c5a6ebd6" }
 }

lua/rayandrew/autocmds.lua

@@ -1,127 +0,0 @@
--- Taken from
--- https://github.com/LazyVim/LazyVim/blob/566049aa4a26a86219dd1ad1624f9a1bf18831b6/lua/lazyvim/config/autocmds.lua
-
-local augroup = require("rayandrew.util").augroup
-
-local autocmd = vim.api.nvim_create_autocmd
-
--- Check if we need to reload the file when it changed
-autocmd({ "FocusGained", "TermClose", "TermLeave" }, {
-  group = augroup("checktime"),
-  command = "checktime",
-})
-
--- Highlight on yank
-autocmd("TextYankPost", {
-  group = augroup("highlight_yank"),
-  callback = function()
-    vim.highlight.on_yank()
-  end,
-})
-
--- resize splits if window got resized
-autocmd({ "VimResized" }, {
-  group = augroup("resize_splits"),
-  callback = function()
-    vim.cmd("tabdo wincmd =")
-  end,
-})
-
--- go to last loc when opening a buffer
-autocmd("BufReadPost", {
-  group = augroup("last_loc"),
-  callback = function()
-    local exclude = { "gitcommit" }
-    local buf = vim.api.nvim_get_current_buf()
-    if vim.tbl_contains(exclude, vim.bo[buf].filetype) then
-      return
-    end
-    local mark = vim.api.nvim_buf_get_mark(buf, '"')
-    local lcount = vim.api.nvim_buf_line_count(buf)
-    if mark[1] > 0 and mark[1] <= lcount then
-      pcall(vim.api.nvim_win_set_cursor, 0, mark)
-    end
-  end,
-})
-
--- close some filetypes with <q>
-autocmd("FileType", {
-  group = augroup("close_with_q"),
-  pattern = {
-    "PlenaryTestPopup",
-    "help",
-    "lspinfo",
-    "man",
-    "notify",
-    "qf",
-    "spectre_panel",
-    "startuptime",
-    "tsplayground",
-    "neotest-output",
-    "checkhealth",
-    "neotest-summary",
-    "neotest-output-panel",
-  },
-  callback = function(event)
-    vim.bo[event.buf].buflisted = false
-    vim.keymap.set("n", "q", "<cmd>close<cr>", { buffer = event.buf, silent = true })
-  end,
-})
-
--- wrap and check for spell in text filetypes
-autocmd("FileType", {
-  group = augroup("wrap_spell"),
-  pattern = { "gitcommit", "markdown" },
-  callback = function()
-    vim.opt_local.wrap = true
-    vim.opt_local.spell = true
-  end,
-})
-
--- Auto create dir when saving a file, in case some intermediate directory does not exist
-autocmd({ "BufWritePre" }, {
-  group = augroup("auto_create_dir"),
-  callback = function(event)
-    if event.match:match("^%w%w+://") then
-      return
-    end
-    local file = vim.loop.fs_realpath(event.match) or event.match
-    vim.fn.mkdir(vim.fn.fnamemodify(file, ":p:h"), "p")
-  end,
-})
-
--- autocmd({ "BufWritePre" }, {
---   group = augroup("remove_trailing_whitespace"),
---   pattern = "*",
---   callback = function()
---     if vim.b.disable_whitespace or vim.g.disable_whitespace then
---       return
---     end
---     vim.cmd([[%s/\s\+$//e]])
---   end,
---   -- command = [[%s/\s\+$//e]],
--- })
-
--- vim.api.nvim_create_autocmd({ "WinNew", "WinClosed", "WinEnter" }, {
---   group = vim.api.nvim_create_augroup("on_demand_wrap", {}),
---   callback = function()
---     local should_wrap = vim.api.nvim_win_get_width(0) ~= vim.o.columns
---     vim.api.nvim_win_set_option(0, "wrap", should_wrap)
---   end,
--- })
-
-autocmd({ "VimLeave" }, {
-  callback = function()
-    vim.fn.jobstart('notify-send "hello"', { detach = true })
-  end,
-})
-
--- set *.smk and Snakefile to filetype=snakemake
-autocmd({ "BufRead", "BufNewFile" }, {
-  group = augroup("snakemake_filetype"),
-  pattern = { "*.smk", "Snakefile" },
-  callback = function()
-    vim.bo.filetype = "snakemake"
-    vim.bo.commentstring = "# %s"
-  end,
-})

lua/rayandrew/commands.lua

@@ -1,7 +1,7 @@
 --- [[ Conform ]] commands
 
 -- https://github.com/stevearc/conform.nvim/blob/master/doc/recipes.md#lazy-loading-with-lazynvim
-vim.api.nvim_create_user_command("FormatDisable", function(args)
+vim.api.nvim_create_user_command('FormatDisable', function(args)
   if args.bang then
     -- FormatDisable! will disable formatting just for this buffer
     vim.b.disable_autoformat = true
@@ -9,48 +9,137 @@ vim.api.nvim_create_user_command("FormatDisable", function(args)
     vim.g.disable_autoformat = true
   end
 end, {
-  desc = "Disable autoformat-on-save",
+  desc = 'Disable autoformat-on-save',
   bang = true,
 })
 
 -- https://github.com/stevearc/conform.nvim/blob/master/doc/recipes.md#lazy-loading-with-lazynvim
-vim.api.nvim_create_user_command("FormatEnable", function()
+vim.api.nvim_create_user_command('FormatEnable', function()
   vim.b.disable_autoformat = false
   vim.g.disable_autoformat = false
 end, {
-  desc = "Re-enable autoformat-on-save",
+  desc = 'Re-enable autoformat-on-save',
 })
 
 -- https://github.com/stevearc/conform.nvim/blob/master/doc/recipes.md#format-command
-vim.api.nvim_create_user_command("Format", function(args)
+vim.api.nvim_create_user_command('Format', function(args)
   local range = nil
   if args.count ~= -1 then
     local end_line = vim.api.nvim_buf_get_lines(0, args.line2 - 1, args.line2, true)[1]
     range = {
       start = { args.line1, 0 },
-      ["end"] = { args.line2, end_line:len() },
+      ['end'] = { args.line2, end_line:len() },
     }
   end
-  require("conform").format({ async = true, lsp_fallback = true, range = range })
+  require('conform').format { async = true, lsp_fallback = true, range = range }
 end, { range = true })
 
---- [[ WhiteSpace ]] commands
+local function run_command(cmd)
+  local job_id
+  local output = {}
 
--- vim.api.nvim_create_user_command("RemoveWhiteSpaceEnable", function()
+  local function on_stdout(_, data, _)
---   vim.b.disable_whitespace = false
+    if data then
---   vim.g.disable_whitespace = false
+      for _, line in ipairs(data) do
--- end, {
+        table.insert(output, line)
---   desc = "Re-enable whitespace removal on save",
+      end
--- })
+    end
---
+  end
--- vim.api.nvim_create_user_command("RemoveWhiteSpaceDisable", function(args)
+
---   if args.bang then
+  local function on_exit(_, exit_code, _)
---     -- RemoveWhiteSpaceDisable! will disable whitespace removal just for this buffer
+    if exit_code == 0 then
---     vim.b.disable_whitespace = true
+      vim.fn.setqflist({}, ' ', {
---   else
+        title = 'Command Output',
---     vim.g.disable_whitespace = true
+        lines = output,
+        efm = '%f:%l:%c: %m',
+      })
+      vim.cmd 'copen'
+    else
+      print('Command exited with code ' .. exit_code)
+    end
+  end
+
+  job_id = vim.fn.jobstart(cmd, {
+    stdout_buffered = true,
+    on_stdout = on_stdout,
+    on_exit = on_exit,
+  })
+
+  if job_id <= 0 then
+    print 'Failed to start job'
+  end
+end
+
+local function run_shell_command(shell_cmd)
+  local job_id
+  local output = {}
+
+  local function on_stdout(_, data, _)
+    if data then
+      for _, line in ipairs(data) do
+        -- Trim leading and trailing whitespace
+        line = line:gsub('^%s*(.-)%s*$', '%1')
+        if line ~= '' then
+          table.insert(output, 'shell_output:1:1: ' .. line)
+        end
+      end
+    end
+  end
+
+  local function on_exit(_, exit_code, _)
+    if exit_code == 0 then
+      vim.fn.setqflist({}, ' ', {
+        title = 'Shell Command Output',
+        lines = output,
+        efm = '%f:%l:%c: %m',
+      })
+      vim.cmd 'copen'
+    else
+      print('Shell command exited with code ' .. exit_code)
+    end
+  end
+
+  -- Run the command using a shell
+  job_id = vim.fn.jobstart({ 'sh', '-c', shell_cmd }, {
+    stdout_buffered = true,
+    on_stdout = on_stdout,
+    on_exit = on_exit,
+  })
+
+  if job_id <= 0 then
+    print 'Failed to start job'
+  end
+end
+
+-- create compile command similar to emacs
+vim.api.nvim_create_user_command('Compile', function(args)
+  -- get command from args
+  -- print(vim.inspect(args))
+  local cmd = args.args
+  local oil = require 'oil'
+  local get_current_dir = oil.get_current_dir(vim.api.nvim_get_current_buf())
+  -- local ok, get_current_dir = pcall(require('oil').get_current_dir, vim.api.nvim_get_current_buf())
+  -- if not ok then
+  --   get_current_dir = vim.fn.getcwd()
   -- end
--- end, {
+  local cmd = {
---   desc = "Disable whitespace removal on save",
+    'cd',
---   bang = true,
+    get_current_dir,
--- })
+    '&&',
+  }
+
+  -- append args.fargs table to cmd_table
+  vim.list_extend(cmd, args.fargs)
+
+  local shell_cmd = table.concat(cmd, ' ')
+  print('Executing command: ' .. shell_cmd)
+
+  run_shell_command(shell_cmd)
+
+  -- print('Executing command: ' .. table.concat(cmd, ''))
+
+  -- run_command(cmd)
+end, {
+  nargs = '*',
+  desc = 'Run compile command',
+})

lua/rayandrew/filetype.lua

@@ -1,53 +0,0 @@
--- using nvim autocommands
-
-local autocmd = vim.api.nvim_create_autocmd
-local augroup = require("rayandrew.util").augroup
-
-local M = {}
-
-function M.setup()
-  local group = augroup("filetype")
-  -- set tabs=4 and use tabs in txt files
-  autocmd("filetype", {
-    pattern = "text",
-    -- pattern = "BufEnter *.txt",
-    group = group,
-    callback = function()
-      vim.bo.tabstop = 4
-      vim.bo.softtabstop = 4
-      vim.bo.shiftwidth = 4
-      vim.bo.expandtab = false
-      vim.opt_local.wrap = true
-      -- disable indentation
-      vim.opt_local.autoindent = false
-      vim.opt_local.smartindent = false
-      vim.opt_local.cindent = false
-      vim.opt_local.indentexpr = ""
-      vim.opt_local.paste = true
-    end,
-  })
-
-  -- tex/latex wrap true
-  autocmd("filetype", {
-    pattern = "tex",
-    group = group,
-    callback = function()
-      vim.opt_local.wrap = true
-      vim.opt_local.breakindent = true
-      vim.opt_local.breakindentopt = "shift:2"
-    end,
-  })
-
-  autocmd("filetype", {
-    pattern = "latex",
-    group = group,
-    callback = function()
-      -- set wrap and breakindent
-      vim.opt_local.wrap = true
-      vim.opt_local.breakindent = true
-      vim.opt_local.breakindentopt = "shift:2"
-    end,
-  })
-end
-
-return M

lua/rayandrew/init.lua

@@ -1,15 +0,0 @@
-local M = {}
-
-function M.setup()
-  require("rayandrew.set")
-  require("rayandrew.lazy")
-  require("rayandrew.autocmds")
-  require("rayandrew.remap")
-  require("rayandrew.theme").setup()
-  require("rayandrew.commands")
-  require("rayandrew.neovide")
-  -- require("rayandrew.filetype").setup()
-  -- require("rayandrew.statusline").setup()
-end
-
-return M

lua/rayandrew/lazy.lua

@@ -1,53 +0,0 @@
-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
-
-vim.opt.rtp:prepend(lazypath)
-
-require("rayandrew.util").setup()
-
-require("lazy").setup({
-  spec = {
-    { import = "rayandrew.plugins" },
-  },
-  defaults = {
-    lazy = false,
-    version = false,
-  },
-  checker = {
-    enabled = true,
-    notify = false,
-    frequency = 3600 * 12,
-  },
-  change_detection = {
-    enabled = true,
-    notify = false,
-  },
-  performance = {
-    cache = {
-      enabled = true,
-    },
-    reset_packpath = true,
-    rtp = {
-      -- disable some rtp plugins
-      disabled_plugins = {
-        "gzip",
-        -- "matchit",
-        -- "matchparen",
-        "netrwPlugin",
-        "tarPlugin",
-        "tohtml",
-        "tutor",
-        "zipPlugin",
-      },
-    },
-  },
-})

lua/rayandrew/neovide.lua

@@ -1,5 +0,0 @@
-if vim.g.neovide then
-  -- set the font
-  vim.o.guifont = "InconsolataGo Nerd Font Mono:h18"
-  vim.cmd("cd ~/Personal")
-end

lua/rayandrew/plugins/editor.lua

@@ -1,252 +0,0 @@
-return {
-  {
-    "folke/todo-comments.nvim",
-    cmd = { "TodoTrouble", "TodoTelescope" },
-    event = { "BufReadPost", "BufNewFile" },
-    config = true,
-    -- stylua: ignore
-    keys = {
-      { "]t",         function() require("todo-comments").jump_next() end, desc = "Next todo comment" },
-      { "[t",         function() require("todo-comments").jump_prev() end, desc = "Previous todo comment" },
-      { "<leader>xt", "<cmd>TodoTrouble<cr>",                              desc = "Todo (Trouble)" },
-      { "<leader>xT", "<cmd>TodoTrouble keywords=TODO,FIX,FIXME<cr>",      desc = "Todo/Fix/Fixme (Trouble)" },
-      { "<leader>st", "<cmd>TodoTelescope<cr>",                            desc = "Todo" },
-      { "<leader>sT", "<cmd>TodoTelescope keywords=TODO,FIX,FIXME<cr>",    desc = "Todo/Fix/Fixme" },
-    },
-  },
-
-  {
-    "jbyuki/venn.nvim",
-    keys = {
-      {
-        "<leader>nv",
-        function()
-          function Toggle_venn()
-            local venn_enabled = vim.inspect(vim.b.venn_enabled)
-            if venn_enabled == "nil" then
-              vim.b.venn_enabled = true
-              vim.cmd([[setlocal ve=all]])
-              -- draw a line on HJKL keystrokes
-              vim.api.nvim_buf_set_keymap(0, "n", "J", "<C-v>j:VBox<CR>", { noremap = true })
-              vim.api.nvim_buf_set_keymap(0, "n", "K", "<C-v>k:VBox<CR>", { noremap = true })
-              vim.api.nvim_buf_set_keymap(0, "n", "L", "<C-v>l:VBox<CR>", { noremap = true })
-              vim.api.nvim_buf_set_keymap(0, "n", "H", "<C-v>h:VBox<CR>", { noremap = true })
-              -- draw a box by pressing "f" with visual selection
-              vim.api.nvim_buf_set_keymap(0, "v", "f", ":VBox<CR>", { noremap = true })
-            else
-              vim.cmd([[setlocal ve=]])
-              vim.cmd([[mapclear <buffer>]])
-              vim.b.venn_enabled = nil
-            end
-          end
-
-          Toggle_venn()
-        end,
-        desc = "Open Venn panel",
-      },
-    },
-  },
-
-  {
-    "ellisonleao/glow.nvim",
-    config = true,
-    cmd = "Glow",
-    ft = "markdown",
-    keys = {
-      {
-        "<leader>pm",
-        "<cmd>Glow<cr>",
-        desc = "Preview Markdown",
-      },
-    },
-  },
-
-  {
-    "jbyuki/nabla.nvim",
-    lazy = true,
-    -- ft = { "tex", "latex", "markdown" },
-    -- opts = {
-    --   autogen = true, -- auto-regenerate ASCII art when exiting insert mode
-    --   silent = true, -- silents error messages
-    -- },
-    -- config = function()
-    --   local nabla = require("nabla")
-    --   nabla.enable_virt()
-    -- end,
-    keys = {
-      {
-        "<leader>pe",
-        function()
-          require("nabla").toggle_virt()
-        end,
-        desc = "Preview Math Equation",
-      },
-    },
-  },
-
-  {
-    "lervag/vimtex",
-    config = function()
-      -- vim.g.vimtex_compiler_progname = "nvr"
-      -- vim.g.vimtex_view_method = "zathura"
-    end,
-  },
-
-  {
-    "3rd/image.nvim",
-    enabled = not vim.g.neovide,
-    opts = {
-      backend = "kitty",
-      integrations = {
-        markdown = {
-          enabled = true,
-          clear_in_insert_mode = false,
-          download_remote_images = true,
-          only_render_image_at_cursor = false,
-          filetypes = { "markdown", "vimwiki" }, -- markdown extensions (ie. quarto) can go here
-        },
-        neorg = {
-          enabled = true,
-          clear_in_insert_mode = false,
-          download_remote_images = true,
-          only_render_image_at_cursor = false,
-          filetypes = { "norg" },
-        },
-      },
-      max_width = nil,
-      max_height = nil,
-      max_width_window_percentage = nil,
-      max_height_window_percentage = 50,
-      window_overlap_clear_enabled = false, -- toggles images when windows are overlapped
-      window_overlap_clear_ft_ignore = { "cmp_menu", "cmp_docs", "" },
-      editor_only_render_when_focused = false, -- auto show/hide images when the editor gains/looses focus
-      tmux_show_only_in_active_window = false, -- auto show/hide images in the correct Tmux window (needs visual-activity off)
-      hijack_file_patterns = { "*.png", "*.jpg", "*.jpeg", "*.gif", "*.webp" }, -- render image files as images when opened
-    },
-    config = true,
-  },
-
-  {
-    "laytan/cloak.nvim",
-    event = {
-      "BufEnter .env",
-      "BufEnter .env.*",
-    },
-    cmd = {
-      "CloakEnable",
-      "CloakDisable",
-      "CloakToggle",
-    },
-    opts = {
-      enabled = true,
-      cloak_character = "*",
-      -- The applied highlight group (colors) on the cloaking, see `:h highlight`.
-      highlight_group = "Comment",
-      patterns = {
-        {
-          file_pattern = {
-            ".env",
-            ".env.*",
-            ".dev.vars",
-          },
-          cloak_pattern = "=.+",
-        },
-      },
-    },
-    config = function(_, opts)
-      require("cloak").setup(opts)
-    end,
-  },
-
-  -- chezmoi
-  {
-    "alker0/chezmoi.vim",
-    lazy = false,
-    init = function()
-      -- This option is required.
-      vim.g["chezmoi#use_tmp_buffer"] = true
-      -- add other options here if needed.
-    end,
-  },
-
-  {
-    "xvzc/chezmoi.nvim",
-    dependencies = { "nvim-lua/plenary.nvim" },
-    -- branch = "refactor",
-    opts = {
-      edit = {
-        watch = true, -- Set true to automatically apply on save.
-        force = true, -- Set true to force apply. Works only when watch = true.
-      },
-      notification = {
-        on_open = false, -- vim.notify when start editing chezmoi-managed file.
-        on_save = true, -- vim.notify on apply.
-        on_watch = true,
-      },
-    },
-    config = function(_, opts)
-      -- local chezmoi_dir = os.getenv("HOME") .. "/.config/dotfiles"
-      local dotfiles_dir = os.getenv("HOME") .. "/Code/dotfiles"
-      local chezmoi_dir = dotfiles_dir .. "/chezmoi"
-      local Util = require("rayandrew.util")
-      local telescope_ok, telescope = pcall(require, "telescope")
-      if telescope_ok then
-        telescope.load_extension("chezmoi")
-        -- check if current directory is a chezmoi directory
-        local cwd = vim.fn.getcwd()
-        if cwd == chezmoi_dir then
-          Util.map("n", "<leader>ff", telescope.extensions.chezmoi.find_files, { noremap = true, silent = true })
-          Util.map("n", "<leader>fc", Util.telescope("files", { cwd = false }), { noremap = true, silent = true })
-        else
-          Util.map("n", "<leader>fc", telescope.extensions.chezmoi.find_files, { noremap = true, silent = true })
-          Util.map("n", "<leader>ff", Util.telescope("files", { cwd = false }), { noremap = true, silent = true })
-        end
-      end
-
-      vim.api.nvim_create_autocmd({ "BufRead", "BufNewFile" }, {
-        -- pattern = { os.getenv("HOME") .. "/.local/share/chezmoi/*" },
-        pattern = { chezmoi_dir .. "/*" },
-        -- pattern = { require("chezmoi").source_path },
-        callback = function()
-          -- invoke with vim.schedule() for better startup time
-          vim.schedule(require("chezmoi.commands.__edit").watch)
-        end,
-      })
-    end,
-  },
-
-  {
-    "snakemake/snakemake",
-    ft = "snakemake",
-    config = function(plugin)
-      vim.opt.rtp:append(plugin.dir .. "/misc/vim")
-    end,
-  },
-
-  {
-    "iamcco/markdown-preview.nvim",
-    cmd = { "MarkdownPreviewToggle", "MarkdownPreview", "MarkdownPreviewStop" },
-    ft = { "markdown" },
-    build = function()
-      vim.fn["mkdp#util#install"]()
-    end,
-  },
-
-  {
-    "smoka7/multicursors.nvim",
-    event = "VeryLazy",
-    dependencies = {
-      "smoka7/hydra.nvim",
-    },
-    opts = {},
-    cmd = { "MCstart", "MCvisual", "MCclear", "MCpattern", "MCvisualPattern", "MCunderCursor" },
-    keys = {
-      {
-        mode = { "v", "n" },
-        "<c-d>",
-        "<cmd>MCstart<cr>",
-        desc = "Create a selection for selected text or word under the cursor",
-      },
-    },
-  },
-}

lua/rayandrew/plugins/file.lua

@@ -1,217 +0,0 @@
-local Util = require("rayandrew.util")
-
-return {
-  ------------------------------
-  --     File Management
-  ------------------------------
-
-  {
-    "nvim-neo-tree/neo-tree.nvim",
-    branch = "v3.x",
-    cmd = "Neotree",
-    dependencies = {
-      "nvim-lua/plenary.nvim",
-      "nvim-tree/nvim-web-devicons", -- not strictly required, but recommended
-      "MunifTanjim/nui.nvim",
-      "3rd/image.nvim",              -- Optional image support in preview window: See `# Preview Mode` for more information
-    },
-    opts = {
-      sources = { "filesystem", "buffers", "git_status", "document_symbols" },
-      open_files_do_not_replace_types = { "terminal", "Trouble", "trouble", "qf", "Outline" },
-      filesystem = {
-        bind_to_cwd = false,
-        follow_current_file = { enabled = true },
-        use_libuv_file_watcher = true,
-        hijack_netrw_behavior = "open_current",
-      },
-      window = {
-        mappings = {
-          ["<space>"] = "none",
-          -- ["C"] = "copy",
-          ["C"] = {
-            "copy",
-            config = {
-              show_path = "absolute", -- "none", "relative", "absolute"
-            },
-          },
-          ["R"] = "rename",
-          ["y"] = function(state)
-            local node = state.tree:get_node()
-            -- get relative path
-            local filepath = node:get_id()
-            local filename = vim.fn.fnamemodify(filepath, ":.")
-            -- local filename = node.name
-            vim.fn.setreg("+", filename)
-            vim.notify("Copied: " .. filename)
-          end,
-          ["Y"] = function(state)
-            local node = state.tree:get_node()
-            local filepath = node:get_id()
-            vim.fn.setreg("+", filepath)
-            vim.notify("Copied: " .. filepath)
-          end,
-          ["O"] = {
-            command = function(state)
-              local node = state.tree:get_node()
-              local filepath = node.path
-              local osType = os.getenv("OS")
-
-              local command
-
-              if osType == "Windows_NT" then
-                command = "start " .. filepath
-              elseif osType == "Darwin" then
-                command = "open " .. filepath
-              else
-                command = "xdg-open " .. filepath
-              end
-              os.execute(command)
-            end,
-            desc = "open_with_system_defaults",
-          },
-        },
-      },
-      default_component_configs = {
-        indent = {
-          with_expanders = true, -- if nil and file nesting is enabled, will enable expanders
-          expander_collapsed = "",
-          expander_expanded = "",
-          expander_highlight = "NeoTreeExpander",
-        },
-      },
-    },
-    keys = {
-      -- {
-      --   "<leader>E",
-      --   function()
-      --     vim.cmd("Neotree toggle position=current")
-      --   end,
-      --   desc = "Toggle NeoTree as Buffer",
-      -- },
-      {
-        "<leader>fe",
-        function()
-          vim.cmd("Neotree toggle")
-        end,
-        desc = "Toggle NeoTree",
-      },
-    },
-    deactivate = function()
-      vim.cmd([[Neotree close]])
-    end,
-    -- init = function()
-    --   if vim.fn.argc(-1) == 1 then
-    --     local stat = vim.loop.fs_stat(vim.fn.argv(0))
-    --     if stat and stat.type == "directory" then
-    --       require("neo-tree")
-    --     end
-    --   end
-    -- end,
-    config = function(_, opts)
-      local function on_move(data)
-        -- Util.lsp.on_rename(data.source, data.destination)
-      end
-
-      local events = require("neo-tree.events")
-      opts.event_handlers = opts.event_handlers or {}
-      vim.list_extend(opts.event_handlers, {
-        { event = events.FILE_MOVED,   handler = on_move },
-        { event = events.FILE_RENAMED, handler = on_move },
-      })
-      require("neo-tree").setup(opts)
-      vim.api.nvim_create_autocmd("TermClose", {
-        pattern = "*lazygit",
-        callback = function()
-          if package.loaded["neo-tree.sources.git_status"] then
-            require("neo-tree.sources.git_status").refresh()
-          end
-        end,
-      })
-    end,
-  },
-
-  {
-    "stevearc/oil.nvim",
-    dependencies = { "nvim-tree/nvim-web-devicons" },
-    cmd = { "Oil" },
-    keys = {
-      -- {
-      --   "<leader>e",
-      --   function()
-      --     -- disable in oil filetype
-      --     if vim.bo.filetype == "oil" then
-      --       return
-      --     end
-      --     require("oil").open_float()
-      --   end,
-      --   desc = "Open current directory",
-      -- },
-      {
-        "<leader>fE",
-        function()
-          -- disable in oil filetype
-          if vim.bo.filetype == "oil" then
-            return
-          end
-          require("oil").open(".")
-        end,
-        desc = "Open current directory",
-      },
-    },
-    opts = {
-      columns = {
-        -- "icon",
-        -- "permissions",
-        -- "size",
-        -- "mtime",
-      },
-      default_file_explorer = true,
-      restore_win_options = true,
-      float = {
-        padding = 2,
-        max_width = 240,
-        max_height = 70,
-        -- width = 0.2,
-        -- max_height = 0.5,
-        border = "rounded",
-        win_options = {
-          winblend = 10,
-        },
-      },
-      keymaps = {
-        ["<C-i>"] = {
-          callback = function()
-            if vim.bo.filetype == "oil" then
-              local oil = require("oil")
-              vim.g.oil_show_info = not vim.g.oil_show_info
-              if vim.g.oil_show_info then
-                oil.set_columns({
-                  "permissions",
-                  "size",
-                  "mtime",
-                  "icon",
-                })
-              else
-                oil.set_columns({})
-              end
-              return
-            end
-          end,
-          desc = "Toggle info",
-        },
-        ["q"] = "actions.close",
-        ["<C-h>"] = "actions.toggle_hidden",
-        ["?"] = "actions.show_help",
-      },
-    },
-    init = function()
-      vim.g.oil_show_info = false
-      if vim.fn.argc() == 1 then
-        local stat = vim.loop.fs_stat(vim.fn.argv(0))
-        if stat and stat.type == "directory" then
-          require("oil")
-        end
-      end
-    end,
-  },
-}

lua/rayandrew/plugins/general.lua

@@ -1,70 +0,0 @@
-return {
-  { "folke/lazy.nvim", version = "*" },
-  { "nvim-lua/plenary.nvim", lazy = true },
-
-  {
-    "dstein64/vim-startuptime",
-    cmd = "StartupTime",
-    init = function()
-      vim.g.startuptime_tries = 10
-    end,
-  },
-
-  ------------------------------
-  --      Color Scheme
-  ------------------------------
-  {
-    "rose-pine/neovim",
-    name = "rose-pine",
-    lazy = true,
-  },
-
-  {
-    "davidosomething/vim-colors-meh",
-    name = "meh",
-    lazy = true,
-  },
-
-  {
-    "kvrohit/rasmus.nvim",
-    name = "rasmus",
-    lazy = true,
-  },
-
-  {
-    "neanias/everforest-nvim",
-    lazy = true,
-    name = "everforest",
-    opts = {
-      background = "hard",
-    },
-  },
-
-  {
-    "thimc/gruber-darker.nvim",
-    lazy = true,
-    opts = {
-      transparent = true,
-    },
-  },
-
-
-  { "junegunn/fzf.vim", dependencies = { "junegunn/fzf" } },
-
-  -- {
-  --   "f-person/auto-dark-mode.nvim",
-  --   config = {
-  --     update_interval = 1000,
-  --     set_dark_mode = function()
-  --       vim.o.background = "dark"
-  --       -- vim.api.nvim_set_option("background", "dark")
-  --       -- vim.cmd("colorscheme gruvbox")
-  --     end,
-  --     set_light_mode = function()
-  --       vim.o.background = "light"
-  --       -- vim.api.nvim_set_option("background", "light")
-  --       -- vim.cmd("colorscheme gruvbox")
-  --     end,
-  --   },
-  -- },
-}

lua/rayandrew/plugins/lsp.lua

@@ -1,240 +1,256 @@
-------------------------------
---    LSP CONFIGURATION     --
-------------------------------
-
-local tools = require("rayandrew.tools")
-local slow_format_filetypes = {}
-
 return {
   {
-    {
+    -- Main LSP Configuration
-      "VonHeikemen/lsp-zero.nvim",
+    'neovim/nvim-lspconfig',
-      branch = "v3.x",
-      lazy = true,
-      config = false,
-      init = function()
-        -- Disable automatic setup, we are doing it manually
-        vim.g.lsp_zero_extend_cmp = 0
-        vim.g.lsp_zero_extend_lspconfig = 0
-      end,
-    },
-
-    {
-      "williamboman/mason.nvim",
-      lazy = false,
-      config = true,
-    },
-
-    -- Autocompletion
-    {
-      "hrsh7th/nvim-cmp",
-      event = "InsertEnter",
     dependencies = {
-        { "L3MON4D3/LuaSnip" },
+      -- Automatically install LSPs and related tools to stdpath for Neovim
+      { 'williamboman/mason.nvim', config = true }, -- NOTE: Must be loaded before dependants
+      'williamboman/mason-lspconfig.nvim',
+      'WhoIsSethDaniel/mason-tool-installer.nvim',
+
+      -- Useful status updates for LSP.
+      -- NOTE: `opts = {}` is the same as calling `require('fidget').setup({})`
+      { 'j-hui/fidget.nvim', opts = {} },
+
+      -- Allows extra capabilities provided by nvim-cmp
+      'hrsh7th/cmp-nvim-lsp',
+
+      {
+        'ray-x/lsp_signature.nvim',
+        event = 'VeryLazy',
+        -- config = function(_, opts)
+        --   require('lsp_signature').setup(opts)
+        -- end,
+      },
+
+      -- { 'SmiteshP/nvim-navic', opts = {
+      --   auto_attach = true,
+      -- } },
     },
     config = function()
-        -- Here is where you configure the autocompletion settings.
+      -- Brief aside: **What is LSP?**
-        local lsp_zero = require("lsp-zero")
+      --
-        lsp_zero.extend_cmp()
+      -- LSP is an initialism you've probably heard, but might not understand what it is.
+      --
+      -- LSP stands for Language Server Protocol. It's a protocol that helps editors
+      -- and language tooling communicate in a standardized fashion.
+      --
+      -- In general, you have a "server" which is some tool built to understand a particular
+      -- language (such as `gopls`, `lua_ls`, `rust_analyzer`, etc.). These Language Servers
+      -- (sometimes called LSP servers, but that's kind of like ATM Machine) are standalone
+      -- processes that communicate with some "client" - in this case, Neovim!
+      --
+      -- LSP provides Neovim with features like:
+      --  - Go to definition
+      --  - Find references
+      --  - Autocompletion
+      --  - Symbol Search
+      --  - and more!
+      --
+      -- Thus, Language Servers are external tools that must be installed separately from
+      -- Neovim. This is where `mason` and related plugins come into play.
+      --
+      -- If you're wondering about lsp vs treesitter, you can check out the wonderfully
+      -- and elegantly composed help section, `:help lsp-vs-treesitter`
 
-        -- And you can configure cmp even more, if you want to.
+      --  This function gets run when an LSP attaches to a particular buffer.
-        local cmp = require("cmp")
+      --    That is to say, every time a new file is opened that is associated with
-        local cmp_action = lsp_zero.cmp_action()
+      --    an lsp (for example, opening `main.rs` is associated with `rust_analyzer`) this
+      --    function will be executed to configure the current buffer
+      vim.api.nvim_create_autocmd('LspAttach', {
+        group = vim.api.nvim_create_augroup('kickstart-lsp-attach', { clear = true }),
+        callback = function(event)
+          -- NOTE: Remember that Lua is a real programming language, and as such it is possible
+          -- to define small helper and utility functions so you don't have to repeat yourself.
+          --
+          -- In this case, we create a function that lets us more easily define mappings specific
+          -- for LSP related items. It sets the mode, buffer and description for us each time.
+          local map = function(keys, func, desc)
+            vim.keymap.set('n', keys, func, { buffer = event.buf, desc = 'LSP: ' .. desc })
+          end
 
-        cmp.setup({
+          -- -- Jump to the definition of the word under your cursor.
-          formatting = lsp_zero.cmp_format(),
+          -- --  This is where a variable was first declared, or where a function is defined, etc.
-          mapping = cmp.mapping.preset.insert({
+          -- --  To jump back, press <C-t>.
-            ["<C-Space>"] = cmp.mapping.complete(),
+          -- map('gd', require('telescope.builtin').lsp_definitions, '[G]oto [D]efinition')
-            ["<C-u>"] = cmp.mapping.scroll_docs(-4),
+          --
-            ["<C-d>"] = cmp.mapping.scroll_docs(4),
+          -- -- Find references for the word under your cursor.
-            ["<C-f>"] = cmp_action.luasnip_jump_forward(),
+          -- map('gr', require('telescope.builtin').lsp_references, '[G]oto [R]eferences')
-            ["<C-b>"] = cmp_action.luasnip_jump_backward(),
+          --
-          }),
+          -- -- Jump to the implementation of the word under your cursor.
+          -- --  Useful when your language has ways of declaring types without an actual implementation.
+          -- map('gI', require('telescope.builtin').lsp_implementations, '[G]oto [I]mplementation')
+          --
+          -- -- Jump to the type of the word under your cursor.
+          -- --  Useful when you're not sure what type a variable is and you want to see
+          -- --  the definition of its *type*, not where it was *defined*.
+          -- map('<leader>D', require('telescope.builtin').lsp_type_definitions, 'Type [D]efinition')
+          --
+          -- -- Fuzzy find all the symbols in your current document.
+          -- --  Symbols are things like variables, functions, types, etc.
+          -- map('<leader>ds', require('telescope.builtin').lsp_document_symbols, '[D]ocument [S]ymbols')
+          --
+          -- -- Fuzzy find all the symbols in your current workspace.
+          -- --  Similar to document symbols, except searches over your entire project.
+          -- map('<leader>ws', require('telescope.builtin').lsp_dynamic_workspace_symbols, '[W]orkspace [S]ymbols')
+
+          -- fzf lua
+          map('gd', require('fzf-lua').lsp_definitions, '[G]oto [D]efinition')
+          map('gr', require('fzf-lua').lsp_references, '[G]oto [R]eferences')
+          map('gI', require('fzf-lua').lsp_implementations, '[G]oto [I]mplementation')
+          map('<leader>D', require('fzf-lua').lsp_typedefs, 'Type [D]efinition')
+          map('<leader>ds', require('fzf-lua').lsp_document_symbols, '[D]ocument [S]ymbols')
+          map('<leader>ws', require('fzf-lua').lsp_live_workspace_symbols, '[W]orkspace [S]ymbols')
+
+          -- Rename the variable under your cursor.
+          --  Most Language Servers support renaming across files, etc.
+          map('<leader>rn', vim.lsp.buf.rename, '[R]e[n]ame')
+
+          -- Execute a code action, usually your cursor needs to be on top of an error
+          -- or a suggestion from your LSP for this to activate.
+          map('<leader>ca', vim.lsp.buf.code_action, '[C]ode [A]ction')
+
+          -- WARN: This is not Goto Definition, this is Goto Declaration.
+          --  For example, in C this would take you to the header.
+          map('gD', vim.lsp.buf.declaration, '[G]oto [D]eclaration')
+
+          -- The following two autocommands are used to highlight references of the
+          -- word under your cursor when your cursor rests there for a little while.
+          --    See `:help CursorHold` for information about when this is executed
+          --
+          -- When you move your cursor, the highlights will be cleared (the second autocommand).
+          local client = vim.lsp.get_client_by_id(event.data.client_id)
+          if client and client.supports_method(vim.lsp.protocol.Methods.textDocument_documentHighlight) then
+            local highlight_augroup = vim.api.nvim_create_augroup('kickstart-lsp-highlight', { clear = false })
+            vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {
+              buffer = event.buf,
+              group = highlight_augroup,
+              callback = vim.lsp.buf.document_highlight,
             })
+
+            vim.api.nvim_create_autocmd({ 'CursorMoved', 'CursorMovedI' }, {
+              buffer = event.buf,
+              group = highlight_augroup,
+              callback = vim.lsp.buf.clear_references,
+            })
+
+            vim.api.nvim_create_autocmd('LspDetach', {
+              group = vim.api.nvim_create_augroup('kickstart-lsp-detach', { clear = true }),
+              callback = function(event2)
+                vim.lsp.buf.clear_references()
+                vim.api.nvim_clear_autocmds { group = 'kickstart-lsp-highlight', buffer = event2.buf }
               end,
+            })
+          end
+
+          -- The following code creates a keymap to toggle inlay hints in your
+          -- code, if the language server you are using supports them
+          --
+          -- This may be unwanted, since they displace some of your code
+          if client and client.supports_method(vim.lsp.protocol.Methods.textDocument_inlayHint) then
+            map('<leader>th', function()
+              vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled { bufnr = event.buf })
+            end, '[T]oggle Inlay [H]ints')
+          end
+
+          require('lsp_signature').on_attach({}, event.buf)
+
+          -- if client and client.server_capabilities.documentSymbolProvider then
+          --   local navic = require 'nvim-navic'
+          --   navic.attach(client, event.buf)
+          -- end
+        end,
+      })
+
+      -- LSP servers and clients are able to communicate to each other what features they support.
+      --  By default, Neovim doesn't support everything that is in the LSP specification.
+      --  When you add nvim-cmp, luasnip, etc. Neovim now has *more* capabilities.
+      --  So, we create new capabilities with nvim cmp, and then broadcast that to the servers.
+      local capabilities = vim.lsp.protocol.make_client_capabilities()
+      capabilities = vim.tbl_deep_extend('force', capabilities, require('cmp_nvim_lsp').default_capabilities())
+
+      -- Enable the following language servers
+      --  Feel free to add/remove any LSPs that you want here. They will automatically be installed.
+      --
+      --  Add any additional override configuration in the following tables. Available keys are:
+      --  - cmd (table): Override the default command used to start the server
+      --  - filetypes (table): Override the default list of associated filetypes for the server
+      --  - capabilities (table): Override fields in capabilities. Can be used to disable certain LSP features.
+      --  - settings (table): Override the default settings passed when initializing the server.
+      --        For example, to see the options for `lua_ls`, you could go to: https://luals.github.io/wiki/settings/
+      local servers = {
+        clangd = {},
+        -- gopls = {},
+        pyright = {},
+        rust_analyzer = {},
+        -- ... etc. See `:help lspconfig-all` for a list of all the pre-configured LSPs
+        --
+        -- Some languages (like typescript) have entire language plugins that can be useful:
+        --    https://github.com/pmizio/typescript-tools.nvim
+        --
+        -- But for many setups, the LSP (`tsserver`) will work just fine
+        -- tsserver = {},
+        --
+
+        lua_ls = {
+          -- cmd = {...},
+          -- filetypes = { ...},
+          -- capabilities = {},
+          settings = {
+            Lua = {
+              completion = {
+                callSnippet = 'Replace',
               },
-
+              -- You can toggle below to ignore Lua_LS's noisy `missing-fields` warnings
-    -- LSP
+              -- diagnostics = { disable = { 'missing-fields' } },
-    {
-      "neovim/nvim-lspconfig",
-      cmd = { "LspInfo", "LspInstall", "LspStart" },
-      event = { "BufReadPre", "BufNewFile" },
-      dependencies = {
-        { "hrsh7th/cmp-nvim-lsp" },
-        { "williamboman/mason-lspconfig.nvim" },
             },
-      config = function()
+          },
-        -- This is where all the LSP shenanigans will live
+        },
-        local lsp_zero = require("lsp-zero")
+      }
-        lsp_zero.extend_lspconfig()
 
-        lsp_zero.on_attach(function(client, bufnr)
+      -- Ensure the servers and tools above are installed
-          -- see :help lsp-zero-keybindings
+      --  To check the current status of installed tools and/or manually install
-          -- to learn the available actions
+      --  other tools, you can run
-          lsp_zero.default_keymaps({ buffer = bufnr, preserve_mappings = true })
+      --    :Mason
-        end)
+      --
+      --  You can press `g?` for help in this menu.
+      require('mason').setup()
 
-        require("mason-lspconfig").setup({
+      -- You can add other tools here that you want Mason to install
-          ensure_installed = {},
+      -- for you, so that they are available from within Neovim.
+      local ensure_installed = vim.tbl_keys(servers or {})
+      vim.list_extend(ensure_installed, {
+        'stylua', -- Used to format Lua code
+      })
+      require('mason-tool-installer').setup { ensure_installed = ensure_installed }
+
+      require('mason-lspconfig').setup {
         handlers = {
-            lsp_zero.default_setup,
+          function(server_name)
-            lua_ls = function()
+            local server = servers[server_name] or {}
-              -- (Optional) Configure lua language server for neovim
+            -- This handles overriding only values explicitly passed
-              local lua_opts = lsp_zero.nvim_lua_ls()
+            -- by the server configuration above. Useful when disabling
-              require("lspconfig").lua_ls.setup(lua_opts)
+            -- certain features of an LSP (for example, turning off formatting for tsserver)
+            server.capabilities = vim.tbl_deep_extend('force', {}, capabilities, server.capabilities or {})
+            require('lspconfig')[server_name].setup(server)
           end,
         },
-        })
+      }
     end,
   },
-  },
 
-  -- Formatter
+  -- LSP Plugins
   {
-    "stevearc/conform.nvim",
+    -- `lazydev` configures Lua LSP for your Neovim config, runtime and plugins
-    event = { "BufWritePre" },
+    -- used for completion, annotations and signatures of Neovim apis
-    cmd = { "ConformInfo" },
+    'folke/lazydev.nvim',
-    keys = {
+    ft = 'lua',
-      {
-        -- Customize or remove this keymap to your liking
-        "<leader>cf",
-        function()
-          require("conform").format({ async = true, lsp_fallback = true })
-        end,
-        mode = "",
-        desc = "Format buffer",
-      },
-    },
     opts = {
-      formatters_by_ft = tools.formatters,
+      library = {
-      format_on_save = function(bufnr)
+        -- Load luvit types when the `vim.uv` word is found
-        if vim.g.disable_autoformat or vim.b[bufnr].disable_autoformat then
+        { path = 'luvit-meta/library', words = { 'vim%.uv' } },
-          return
-        end
-
-        if slow_format_filetypes[vim.bo[bufnr].filetype] then
-          return
-        end
-        local function on_format(err)
-          if err and err:match("timeout$") then
-            slow_format_filetypes[vim.bo[bufnr].filetype] = true
-          end
-        end
-
-        return { timeout_ms = 200, lsp_fallback = true }, on_format
-      end,
-      format_after_save = function(bufnr)
-        if not slow_format_filetypes[vim.bo[bufnr].filetype] then
-          return
-        end
-        return { lsp_fallback = true }
-      end,
-      formatters = {
-        shfmt = {
-          prepend_args = { "-i", "2" },
       },
     },
   },
-    init = function()
+  { 'Bilal2453/luvit-meta', lazy = true },
-      -- If you want the formatexpr, here is the place to set it
-      vim.o.formatexpr = "v:lua.require'conform'.formatexpr()"
-    end,
-  },
-
-  {
-    "folke/trouble.nvim",
-    cmd = { "TroubleToggle", "Trouble" },
-    opts = { use_diagnostic_signs = true },
-    keys = {
-      {
-        "<leader>xx",
-        "<cmd>TroubleToggle document_diagnostics<cr>",
-        desc = "Document Diagnostics (Trouble)",
-      },
-      {
-        "<leader>xX",
-        "<cmd>TroubleToggle workspace_diagnostics<cr>",
-        desc = "Workspace Diagnostics (Trouble)",
-      },
-      {
-        "<leader>xL",
-        "<cmd>TroubleToggle loclist<cr>",
-        desc = "Location List (Trouble)",
-      },
-      {
-        "<leader>xQ",
-        "<cmd>TroubleToggle quickfix<cr>",
-        desc = "Quickfix List (Trouble)",
-      },
-      {
-        "[q",
-        function()
-          if require("trouble").is_open() then
-            require("trouble").previous({ skip_groups = true, jump = true })
-          else
-            local ok, err = pcall(vim.cmd.cprev)
-            if not ok then
-              vim.notify(err, vim.log.levels.ERROR)
-            end
-          end
-        end,
-        desc = "Previous trouble/quickfix item",
-      },
-      {
-        "]q",
-        function()
-          if require("trouble").is_open() then
-            require("trouble").next({ skip_groups = true, jump = true })
-          else
-            local ok, err = pcall(vim.cmd.cnext)
-            if not ok then
-              vim.notify(err, vim.log.levels.ERROR)
-            end
-          end
-        end,
-        desc = "Next trouble/quickfix item",
-      },
-    },
-  },
-
-  { -- Linter integration
-    "mfussenegger/nvim-lint",
-    event = "VeryLazy",
-    config = function()
-      local lint = require("lint")
-      lint.linters_by_ft = tools.linters
-
-      lint.linters.shellcheck.args = { "--shell=bash", "--format=json", "-" }
-      lint.linters.markdownlint.args = {
-        "--disable=no-trailing-spaces", -- not disabled in config, so it's enabled for formatting
-        "--disable=no-multiple-blanks",
-      }
-      lint.linters["editorconfig-checker"].args = {
-        "-no-color",
-        "-disable-max-line-length", -- only rule of thumb
-        "-disable-trim-trailing-whitespace", -- will be formatted anyway
-      }
-    end,
-  },
-
-  { -- auto-install missing linters & formatters
-    "WhoIsSethDaniel/mason-tool-installer.nvim",
-    event = "VeryLazy",
-    keys = {
-      { "<leader>pM", vim.cmd.MasonToolsUpdate, desc = " Mason Update" },
-    },
-    dependencies = { "williamboman/mason.nvim", "williamboman/mason-lspconfig.nvim" },
-    config = function()
-      local tools_to_install = tools.getToolsToInstall()
-
-      require("mason-tool-installer").setup({
-        ensure_installed = tools_to_install,
-        run_on_start = false, -- triggered manually, since not working with lazy-loading
-      })
-
-      -- clean unused & install missing
-      vim.defer_fn(vim.cmd.MasonToolsInstall, 500)
-      vim.defer_fn(vim.cmd.MasonToolsClean, 1000) -- delayed, so noice.nvim is loaded before
-    end,
-  },
 }

lua/rayandrew/plugins/telescope.lua

@@ -1,143 +1,91 @@
-------------------------------
---         Telescope        --
-------------------------------
-
 return {
-
+  { -- Fuzzy Finder (files, lsp, etc)
-  {
+    'nvim-telescope/telescope.nvim',
-    "nvim-telescope/telescope.nvim",
+    event = 'VimEnter',
-    cmd = "Telescope",
+    branch = '0.1.x',
     dependencies = {
-      "nvim-lua/plenary.nvim",
+      'nvim-lua/plenary.nvim',
-      {
+      { -- If encountering errors, see telescope-fzf-native README for installation instructions
-        "nvim-telescope/telescope-fzf-native.nvim",
+        'nvim-telescope/telescope-fzf-native.nvim',
-        -- NOTE: If you are having trouble with this installation,
+
-        --       refer to the README for telescope-fzf-native for more instructions.
+        -- `build` is used to run some command when the plugin is installed/updated.
-        build = "make",
+        -- This is only run then, not every time Neovim starts up.
+        build = 'make',
+
+        -- `cond` is a condition used to determine whether this plugin should be
+        -- installed and loaded.
         cond = function()
-          return vim.fn.executable("make") == 1
+          return vim.fn.executable 'make' == 1
         end,
       },
+      { 'nvim-telescope/telescope-ui-select.nvim' },
+
+      -- Useful for getting pretty icons, but requires a Nerd Font.
+      { 'nvim-tree/nvim-web-devicons', enabled = vim.g.have_nerd_font },
     },
-    version = false,
+    config = function()
-    opts = {
+      -- [[ Configure Telescope ]]
-      pickers = {
+      -- See `:help telescope` and `:help telescope.setup()`
-        buffers = {
+      require('telescope').setup {
+        -- You can put your default mappings / updates / etc. in here
+        --  All the info you're looking for is in `:help telescope.setup()`
+        --
+        defaults = {
           mappings = {
             i = {
-              ["<c-d>"] = function(prompt_bufnr)
+              ['<c-g>'] = 'close',
-                local actions = require("telescope.actions")
+              ['<c-[>'] = 'close',
-                actions.delete_buffer(prompt_bufnr)
+              ['<c-enter>'] = 'to_fuzzy_refine',
-                actions.move_to_top(prompt_bufnr)
-              end,
-              ["<c-u>"] = false,
-            },
-            n = {
-              ["d"] = "delete_buffer",
             },
           },
         },
-      },
+        -- pickers = {}
-    },
+        extensions = {
-    keys = {
+          ['ui-select'] = {
-      {
+            require('telescope.themes').get_dropdown(),
-        "<leader>sp",
-        function()
-          local Util = require("rayandrew.util")
-          local fn = Util.telescope("live_grep", { cwd = vim.loop.cwd() })
-          fn()
-        end,
-        desc = "Find in Files (Grep)",
-      },
-      {
-        "<leader>ps",
-        function()
-          local Util = require("rayandrew.util")
-          local fn = Util.telescope("grep_string", {
-            search = vim.fn.input("Grep > "),
-          })
-          fn()
-        end,
-        desc = "Find in Files (Grep)",
-      },
-      {
-        "<leader>bb",
-        function()
-          local Util = require("rayandrew.util")
-          local fn = Util.telescope("buffers")
-          fn()
-        end,
-        desc = "List all opened buffers",
-      },
-      {
-        "<leader>fF",
-        function()
-          local utils = require("telescope.utils")
-          local Util = require("rayandrew.util")
-          local fn = Util.telescope("files", { cwd = utils.buffer_dir() })
-          fn()
-        end,
-        desc = "Find Files (root dir)",
-      },
-      {
-        "<leader>ff",
-        function()
-          local Util = require("rayandrew.util")
-          local fn = Util.telescope("files", { cwd = false })
-          fn()
-        end,
-        desc = "Find Files (cwd)",
-      },
-      {
-        "<leader>fh",
-        function()
-          local Util = require("rayandrew.util")
-          local fn = Util.telescope("files", { cwd = false, hidden = true })
-          fn()
-        end,
-        desc = "Find Files with Hidden (cwd)",
-      },
-      {
-        "<space>sm",
-        function()
-          local Util = require("rayandrew.util")
-          local fn = Util.telescope("man_pages")
-          fn()
-        end,
-        desc = "Find Manual",
-      },
-      {
-        "<space>sh",
-        function()
-          local Util = require("rayandrew.util")
-          local fun = Util.telescope("help_tags")
-          fun()
-        end,
-        desc = "Find Help Tags",
-      },
-      {
-        "<space>/",
-        function()
-          -- require("telescope.builtin").current_buffer_fuzzy_find(require("telescope.themes").get_dropdown({
-          --   winblend = 10,
-          --   previewer = false,
-          -- }))
-          local Util = require("rayandrew.util")
-          local fn = Util.telescope("current_buffer_fuzzy_find", {
-            winblend = 10,
-            previewer = false,
-          })
-          fn()
-        end,
-      },
-      {
-        "<space>sd",
-        function()
-          local Util = require("rayandrew.util")
-          local fn = Util.telescope("diagnostics")
-          fn()
-        end,
-      },
           },
         },
       }
+
+      -- Enable Telescope extensions if they are installed
+      pcall(require('telescope').load_extension, 'fzf')
+      pcall(require('telescope').load_extension, 'ui-select')
+
+      -- See `:help telescope.builtin`
+      local builtin = require 'telescope.builtin'
+      -- vim.keymap.set('n', '<leader>sh', builtin.help_tags, { desc = '[S]earch [H]elp' })
+      -- vim.keymap.set('n', '<leader>sk', builtin.keymaps, { desc = '[S]earch [K]eymaps' })
+      -- vim.keymap.set('n', '<leader>sf', builtin.find_files, { desc = '[S]earch [F]iles' })
+      -- vim.keymap.set('n', '<leader>ss', builtin.builtin, { desc = '[S]earch [S]elect Telescope' })
+      -- vim.keymap.set('n', '<leader>sw', builtin.grep_string, { desc = '[S]earch current [W]ord' })
+      -- vim.keymap.set('n', '<leader>sg', builtin.live_grep, { desc = '[S]earch by [G]rep' })
+      -- vim.keymap.set('n', '<leader>sd', builtin.diagnostics, { desc = '[S]earch [D]iagnostics' })
+      -- vim.keymap.set('n', '<leader>sr', builtin.resume, { desc = '[S]earch [R]esume' })
+      -- vim.keymap.set('n', '<leader>s.', builtin.oldfiles, { desc = '[S]earch Recent Files ("." for repeat)' })
+      -- vim.keymap.set('n', '<leader><leader>', builtin.buffers, { desc = '[ ] Find existing buffers' })
+
+      -- Slightly advanced example of overriding default behavior and theme
+      -- vim.keymap.set('n', '<leader>/', function()
+      --   -- You can pass additional configuration to Telescope to change the theme, layout, etc.
+      --   builtin.current_buffer_fuzzy_find(require('telescope.themes').get_dropdown {
+      --     winblend = 10,
+      --     previewer = false,
+      --   })
+      -- end, { desc = '[/] Fuzzily search in current buffer' })
+
+      -- It's also possible to pass additional configuration options.
+      --  See `:help telescope.builtin.live_grep()` for information about particular keys
+      vim.keymap.set('n', '<leader>s/', function()
+        builtin.live_grep {
+          grep_open_files = true,
+          prompt_title = 'Live Grep in Open Files',
+        }
+      end, { desc = '[S]earch [/] in Open Files' })
+
+      -- Shortcut for searching your Neovim configuration files
+      -- vim.keymap.set('n', '<leader>sn', function()
+      --   builtin.find_files { cwd = vim.fn.stdpath 'config' }
+      -- end, { desc = '[S]earch [N]eovim files' })
+    end,
+  },
+}

lua/rayandrew/plugins/treesitter.lua

@@ -1,140 +1,32 @@
 return {
-  ------------------------------
+  { -- Highlight, edit, and navigate code
-  --         TreeSitter
+    'nvim-treesitter/nvim-treesitter',
-  ------------------------------
+    build = ':TSUpdate',
-  {
-    "nvim-treesitter/nvim-treesitter",
-    version = false, -- last release is way too old and doesn't work on Windows
-    build = ":TSUpdate",
-    event = { "VeryLazy" },
-    lazy = vim.fn.argc(-1) == 0, -- load treesitter early when opening a file from the cmdline
-    init = function(plugin)
-      -- PERF: add nvim-treesitter queries to the rtp and it's custom query predicates early
-      -- This is needed because a bunch of plugins no longer `require("nvim-treesitter")`, which
-      -- no longer trigger the **nvim-treesitter** module to be loaded in time.
-      -- Luckily, the only things that those plugins need are the custom queries, which we make available
-      -- during startup.
-      require("lazy.core.loader").add_to_rtp(plugin)
-      require("nvim-treesitter.query_predicates")
-    end,
-    cmd = { "TSUpdateSync", "TSUpdate", "TSInstall" },
-    keys = {
-      { "<c-space>", desc = "Increment Selection" },
-      { "<bs>", desc = "Decrement Selection", mode = "x" },
-    },
-    ---@type TSConfig
-    ---@diagnostic disable-next-line: missing-fields
     opts = {
-      highlight = { enable = true },
+      ensure_installed = { 'bash', 'c', 'diff', 'html', 'lua', 'luadoc', 'markdown', 'markdown_inline', 'query', 'vim', 'vimdoc' },
-      indent = { enable = true },
+      -- Autoinstall languages that are not installed
-      ensure_installed = {
+      auto_install = true,
-        "bash",
+      highlight = {
-        "c",
-        "diff",
-        "html",
-        "javascript",
-        "jsdoc",
-        "json",
-        "jsonc",
-        "lua",
-        "luadoc",
-        "luap",
-        "markdown",
-        "markdown_inline",
-        "python",
-        "query",
-        "regex",
-        "toml",
-        "tsx",
-        "typescript",
-        "vim",
-        "vimdoc",
-        "xml",
-        "yaml",
-      },
-      incremental_selection = {
         enable = true,
-        keymaps = {
+        -- Some languages depend on vim's regex highlighting system (such as Ruby) for indent rules.
-          init_selection = "<C-space>",
+        --  If you are experiencing weird indenting issues, add the language to
-          node_incremental = "<C-space>",
+        --  the list of additional_vim_regex_highlighting and disabled languages for indent.
-          scope_incremental = false,
+        additional_vim_regex_highlighting = { 'ruby' },
-          node_decremental = "<bs>",
       },
+      indent = { enable = true, disable = { 'ruby' } },
     },
-      textobjects = {
-        move = {
-          enable = true,
-          goto_next_start = { ["]f"] = "@function.outer", ["]c"] = "@class.outer" },
-          goto_next_end = { ["]F"] = "@function.outer", ["]C"] = "@class.outer" },
-          goto_previous_start = { ["[f"] = "@function.outer", ["[c"] = "@class.outer" },
-          goto_previous_end = { ["[F"] = "@function.outer", ["[C"] = "@class.outer" },
-        },
-      },
-    },
-    ---@param opts TSConfig
     config = function(_, opts)
-      if type(opts.ensure_installed) == "table" then
+      -- [[ Configure Treesitter ]] See `:help nvim-treesitter`
-        ---@type table<string, boolean>
+
-        local added = {}
+      ---@diagnostic disable-next-line: missing-fields
-        opts.ensure_installed = vim.tbl_filter(function(lang)
+      require('nvim-treesitter.configs').setup(opts)
-          if added[lang] then
+
-            return false
+      -- There are additional nvim-treesitter modules that you can use to interact
-          end
+      -- with nvim-treesitter. You should go explore a few and see what interests you:
-          added[lang] = true
+      --
-          return true
+      --    - Incremental selection: Included, see `:help nvim-treesitter-incremental-selection-mod`
-        end, opts.ensure_installed)
+      --    - Show your current context: https://github.com/nvim-treesitter/nvim-treesitter-context
-      end
+      --    - Treesitter + textobjects: https://github.com/nvim-treesitter/nvim-treesitter-textobjects
-      require("nvim-treesitter.configs").setup(opts)
-      -- vim.schedule(function()
-      --   require("lazy").load({ plugins = { "nvim-treesitter-textobjects" } })
-      -- end)
     end,
   },
-
-  -- {
-  --   "nvim-treesitter/playground",
-  -- },
-  {
-    "nvim-treesitter/nvim-treesitter-textobjects",
-    lazy = true,
-    config = function()
-      -- When in diff mode, we want to use the default
-      -- vim text objects c & C instead of the treesitter ones.
-      local move = require("nvim-treesitter.textobjects.move") ---@type table<string,fun(...)>
-      local configs = require("nvim-treesitter.configs")
-      for name, fn in pairs(move) do
-        if name:find("goto") == 1 then
-          move[name] = function(q, ...)
-            if vim.wo.diff then
-              local config = configs.get_module("textobjects.move")[name] ---@type table<string,string>
-              for key, query in pairs(config or {}) do
-                if q == query and key:find("[%]%[][cC]") then
-                  vim.cmd("normal! " .. key)
-                  return
-                end
-              end
-            end
-            return fn(q, ...)
-          end
-        end
-      end
-    end,
-  },
-
-  {
-    "nvim-treesitter/nvim-treesitter-context",
-    opts = {
-      multiline_threshold = 1,
-    },
-    config = true,
-  },
-
-  {
-    "simrat39/symbols-outline.nvim",
-    opts = {},
-    cmd = { "SymbolsOutline", "SymbolsOutlineOpen", "SymbolsOutlineClose" },
-    keys = {
-      { "<leader>so", "<cmd>SymbolsOutline<CR>", desc = "Symbols Outline" },
-    },
-  },
 }

lua/rayandrew/plugins/ui.lua

@@ -1,142 +0,0 @@
-------------------------------
---      User Interface
-------------------------------
-
-return {
-  {
-    "nvim-lualine/lualine.nvim",
-    event = "VeryLazy",
-    opts = function()
-      local icons = require("rayandrew.theme").icons
-      local Util = require("rayandrew.util")
-
-      return {
-        options = {
-          theme = "auto",
-          globalstatus = true,
-          disabled_filetypes = { statusline = { "dashboard", "alpha" } },
-        },
-        sections = {
-          lualine_a = {
-            {
-              "mode",
-              fmt = function(str)
-                return str:sub(1, 1)
-              end,
-            },
-          },
-          lualine_b = { "branch" },
-          lualine_c = {
-            {
-              "diagnostics",
-              symbols = {
-                error = icons.diagnostics.Error,
-                warn = icons.diagnostics.Warn,
-                info = icons.diagnostics.Info,
-                hint = icons.diagnostics.Hint,
-              },
-            },
-            { "filetype", icon_only = true, separator = "", padding = { left = 1, right = 0 } },
-            { "filename", path = 1, symbols = { modified = "  ", readonly = "", unnamed = "" } },
-          },
-          lualine_x = {
-            { require("lazy.status").updates, cond = require("lazy.status").has_updates, color = Util.fg("Special") },
-            {
-              "diff",
-              symbols = {
-                added = icons.git.added,
-                modified = icons.git.modified,
-                removed = icons.git.removed,
-              },
-            },
-          },
-          lualine_y = {},
-          lualine_z = {
-            function()
-              return " " .. os.date("%R")
-            end,
-          },
-        },
-        extensions = { "neo-tree", "lazy" },
-      }
-    end,
-  },
-
-  {
-    "lukas-reineke/indent-blankline.nvim",
-    main = "ibl",
-    event = { "BufReadPost", "BufNewFile" },
-    opts = {
-      -- char = "▏",
-      indent = {
-        char = "│",
-      },
-      exclude = {
-        filetypes = {
-          "help",
-          "alpha",
-          "dashboard",
-          "neo-tree",
-          "Trouble",
-          "lazy",
-          "mason",
-          "notify",
-          "toggleterm",
-          "lazyterm",
-          "qf",
-        },
-        buftypes = {
-          "terminal",
-          "nofile",
-          "quickfix",
-          "prompt",
-        },
-      },
-      scope = {
-        enabled = true,
-      },
-      -- show_trailing_blankline_indent = false,
-    },
-  },
-
-  { "kevinhwang91/nvim-bqf", ft = "qf" },
-
-  -- icons
-  { "nvim-tree/nvim-web-devicons", lazy = true },
-
-  {
-    "lewis6991/gitsigns.nvim",
-    event = { "BufReadPre", "BufNewFile" },
-    opts = {
-      signs = {
-        add = { text = "▎" },
-        change = { text = "▎" },
-        delete = { text = "" },
-        topdelete = { text = "" },
-        changedelete = { text = "▎" },
-        untracked = { text = "▎" },
-      },
-      on_attach = function(buffer)
-        local gs = package.loaded.gitsigns
-
-        local function map(mode, l, r, desc)
-          vim.keymap.set(mode, l, r, { buffer = buffer, desc = desc })
-        end
-
-        -- stylua: ignore start
-        map("n", "]h", gs.next_hunk, "Next Hunk")
-        map("n", "[h", gs.prev_hunk, "Prev Hunk")
-        map({ "n", "v" }, "<leader>ghs", ":Gitsigns stage_hunk<CR>", "Stage Hunk")
-        map({ "n", "v" }, "<leader>ghr", ":Gitsigns reset_hunk<CR>", "Reset Hunk")
-        map("n", "<leader>ghS", gs.stage_buffer, "Stage Buffer")
-        map("n", "<leader>ghu", gs.undo_stage_hunk, "Undo Stage Hunk")
-        map("n", "<leader>ghR", gs.reset_buffer, "Reset Buffer")
-        map("n", "<leader>ghp", gs.preview_hunk, "Preview Hunk")
-        map("n", "<leader>ghb", function() gs.blame_line({ full = true }) end, "Blame Line")
-        map("n", "<leader>ghd", gs.diffthis, "Diff This")
-        map("n", "<leader>ghD", function() gs.diffthis("~") end, "Diff This ~")
-        map({ "o", "x" }, "ih", ":<C-U>Gitsigns select_hunk<CR>", "GitSigns Select Hunk")
-      end,
-    },
-  },
-}

lua/rayandrew/plugins/utilities.lua

@@ -1,391 +0,0 @@
-------------------------------
---      Utilities
-------------------------------
-
-return {
-  {
-    "nvim-focus/focus.nvim",
-    version = "*",
-    opts = {},
-    cmd = { "FocusToggle", "FocusSplitNicely", "FocusSplitCycle", "FocusSplitCycleReverse" },
-    keys = {
-      {
-        "<space>wf",
-        "<cmd>FocusToggle<CR>",
-        desc = "Toggle Focus",
-      },
-    },
-  },
-
-  {
-    "kylechui/nvim-surround",
-    version = "*",
-    event = "VeryLazy",
-    opts = {},
-  },
-
-  {
-    "RRethy/vim-illuminate",
-    event = { "BufReadPost", "BufNewFile" },
-    opts = {
-      delay = 200,
-      large_file_cutoff = 2000,
-      large_file_overrides = {
-        providers = { "lsp" },
-      },
-    },
-    config = function(_, opts)
-      require("illuminate").configure(opts)
-
-      local function map(key, dir, buffer)
-        vim.keymap.set("n", key, function()
-          require("illuminate")["goto_" .. dir .. "_reference"](false)
-        end, {
-          desc = dir:sub(1, 1):upper() .. dir:sub(2) .. " Reference",
-          buffer = buffer,
-        })
-      end
-
-      map("]]", "next")
-      map("[[", "prev")
-
-      -- also set it after loading ftplugins, since a lot overwrite [[ and ]]
-      vim.api.nvim_create_autocmd("FileType", {
-        callback = function()
-          local buffer = vim.api.nvim_get_current_buf()
-          map("]]", "next", buffer)
-          map("[[", "prev", buffer)
-        end,
-      })
-    end,
-    keys = {
-      { "]]", desc = "Next Reference" },
-      { "[[", desc = "Prev Reference" },
-    },
-  },
-
-  -- comments
-  {
-    "echasnovski/mini.comment",
-    event = "VeryLazy",
-    dependencies = {
-      { "JoosepAlviste/nvim-ts-context-commentstring", lazy = true },
-    },
-    opts = {
-      options = {
-        custom_commentstring = function()
-          return require("ts_context_commentstring.internal").calculate_commentstring() or vim.bo.commentstring
-        end,
-      },
-    },
-  },
-
-  -- RSI compatibility
-  -- {
-  --   "tpope/vim-rsi",
-  -- },
-  {
-    "assistcontrol/readline.nvim",
-    event = "VeryLazy",
-    keys = {
-      {
-        "<M-f>",
-        function()
-          require("readline").forward_word()
-        end,
-        mode = "!",
-      },
-      {
-        "<M-b>",
-        function()
-          require("readline").backward_word()
-        end,
-        mode = "!",
-      },
-      {
-        "<M-d>",
-        function()
-          require("readline").kill_word()
-        end,
-        mode = "!",
-      },
-      {
-        "<M-BS>",
-        function()
-          require("readline").backward_kill_word()
-        end,
-        mode = "!",
-      },
-      {
-        "<C-w>",
-        function()
-          require("readline").unix_word_rubout()
-        end,
-        mode = "!",
-      },
-      {
-        "<C-k>",
-        function()
-          require("readline").kill_line()
-        end,
-        mode = "!",
-      },
-      {
-        "<C-u>",
-        function()
-          require("readline").backward_kill_line()
-        end,
-        mode = "!",
-      },
-      {
-        "<C-a>",
-        function()
-          require("readline").beginning_of_line()
-        end,
-        mode = "!",
-      },
-      {
-        "<C-e>",
-        function()
-          require("readline").end_of_line()
-        end,
-        mode = "!",
-      },
-      { "<C-f>", "<Right>", mode = "!" }, -- forward-char
-      { "<C-b>", "<Left>", mode = "!" }, -- backward-char
-      { "<C-n>", "<Down>", mode = "!" }, -- next-line
-      { "<C-p>", "<Up>", mode = "!" }, -- previous-line
-      { "<C-d>", "<Delete>", mode = "!" }, -- delete-char
-      { "<C-h>", "<BS>", mode = "!" }, -- backward-delete-char
-      { "<C-g>", "<Esc>", mode = "!" }, -- abort
-    },
-  },
-
-  {
-    "tpope/vim-fugitive",
-    cmd = { "Git" },
-  },
-
-  {
-    "theprimeagen/harpoon",
-    event = "VeryLazy",
-    keys = {
-      {
-        "<leader>ha",
-        function()
-          local mark = require("harpoon.mark")
-          mark.add_file()
-          vim.print("Added to Harpoon " .. vim.fn.expand("%"))
-        end,
-        desc = "Harpoon Add File",
-      },
-      {
-        "<leader>he",
-        function()
-          local ui = require("harpoon.ui")
-          ui.toggle_quick_menu()
-        end,
-        desc = "Harpoon UI",
-      },
-      {
-        "<leader>h1",
-        function()
-          local ui = require("harpoon.ui")
-          ui.nav_file(1)
-        end,
-      },
-      {
-        "<leader>h2",
-        function()
-          local ui = require("harpoon.ui")
-          ui.nav_file(2)
-        end,
-      },
-      {
-        "<leader>h3",
-        function()
-          local ui = require("harpoon.ui")
-          ui.nav_file(3)
-        end,
-      },
-      {
-        "<leader>h4",
-        function()
-          local ui = require("harpoon.ui")
-          ui.nav_file(4)
-        end,
-      },
-      {
-        "<leader>h5",
-        function()
-          local ui = require("harpoon.ui")
-          ui.nav_file(5)
-        end,
-      },
-    },
-  },
-
-  {
-    "github/copilot.vim",
-    init = function()
-      -- vim.g.copilot_no_tab_map = true
-      -- vim.g.copilot_assume_mapped = true
-      -- vim.g.copilot_tab_fallback = ""
-      vim.g.copilot_filetypes = {
-        ["*"] = true,
-        ["text"] = false,
-      }
-    end,
-  },
-
-  {
-    "mbbill/undotree",
-    cmd = { "UndotreeToggle" },
-  },
-
-  {
-    "folke/which-key.nvim",
-    event = "VeryLazy",
-    opts = {
-      plugins = { spelling = true },
-      defaults = {
-        mode = { "n", "v" },
-        ["g"] = { name = "+goto" },
-        ["gz"] = { name = "+surround" },
-        ["]"] = { name = "+next" },
-        ["["] = { name = "+prev" },
-        ["<leader><tab>"] = { name = "+tabs" },
-        ["<leader>b"] = { name = "+buffer" },
-        ["<leader>c"] = { name = "+code" },
-        ["<leader>f"] = { name = "+file/find" },
-        ["<leader>g"] = { name = "+git" },
-        ["<leader>n"] = { name = "+note" },
-        ["<leader>gh"] = { name = "+hunks" },
-        ["<leader>q"] = { name = "+quit/session" },
-        ["<leader>s"] = { name = "+search" },
-        ["<leader>u"] = { name = "+ui" },
-        ["<leader>w"] = { name = "+windows" },
-        ["<leader>x"] = { name = "+diagnostics/quickfix" },
-      },
-    },
-    config = function(_, opts)
-      local wk = require("which-key")
-      wk.setup(opts)
-      wk.register(opts.defaults)
-    end,
-  },
-
-  -- zen
-  {
-    "folke/zen-mode.nvim",
-    opts = {
-      window = {
-        width = 100,
-      },
-      plugins = {
-        tmux = {
-          enabled = true,
-        },
-      },
-      on_open = function()
-        vim.wo.wrap = false
-        vim.wo.number = false
-        vim.wo.rnu = false
-        vim.wo.signcolumn = "no"
-      end,
-      on_close = function()
-        vim.wo.wrap = true
-        vim.wo.number = true
-        vim.wo.rnu = true
-        vim.wo.signcolumn = "yes"
-      end,
-    },
-    keys = {
-      {
-        "<leader>z",
-        function()
-          require("zen-mode").toggle()
-          require("rayandrew.theme").recolor()
-        end,
-      },
-    },
-  },
-
-  -- Tmux
-  {
-    "mrjones2014/smart-splits.nvim",
-    lazy = true,
-    -- event = "VeryLazy",
-    dependencies = {
-      {
-        "kwkarlwang/bufresize.nvim",
-        opts = {},
-      },
-    },
-    config = function()
-      require("smart-splits").setup({
-        resize_mode = {
-          hooks = {
-            on_leave = require("bufresize").register,
-          },
-        },
-      })
-    end,
-  },
-
-  {
-    "christoomey/vim-tmux-navigator",
-    cmd = {
-      "TmuxNavigateLeft",
-      "TmuxNavigateDown",
-      "TmuxNavigateUp",
-      "TmuxNavigateRight",
-    },
-    keys = { "<C-h>", "<C-j>", "<C-k>", "<C-l>" },
-    config = function()
-      vim.g.tmux_navigator_no_wrap = 1
-    end,
-  },
-
-  -- search/replace in multiple files
-  {
-    "nvim-pack/nvim-spectre",
-    cmd = "Spectre",
-    opts = { open_cmd = "noswapfile vnew" },
-    keys = {
-      {
-        "<leader>sr",
-        function()
-          require("spectre").open()
-        end,
-        desc = "Replace in files (Spectre)",
-      },
-    },
-  },
-
-  -- buffer remove
-  {
-    "echasnovski/mini.bufremove",
-    -- stylua: ignore
-    keys = {
-      { "<leader>bd", function() require("mini.bufremove").delete(0, false) end, desc = "Delete Buffer" },
-      { "<leader>bD", function() require("mini.bufremove").delete(0, true) end, desc = "Delete Buffer (Force)" },
-    },
-  },
-
-  {
-    "tpope/vim-dispatch",
-    commands = { "Make", "Dispatch", "Copen" },
-    keys = {
-      {
-        "<leader>cc",
-        function()
-          local input = vim.fn.input("Command: ")
-          vim.cmd("Dispatch " .. input)
-        end,
-        desc = "AsyncRun",
-      },
-      { "<leader>ck", desc = "AsyncStop" },
-    },
-  },
-}

lua/rayandrew/remap.lua

@@ -1,213 +0,0 @@
-local Util = require("rayandrew.util")
-
-------------------------------
---        Buffers
-------------------------------
-
-Util.map("n", "<leader>fs", "<cmd>w<cr><esc>", { desc = "Save file" })
-
--- Util.map({ "i", "v", "n", "s" }, "<C-s>", "<cmd>w<cr><esc>", { desc = "Save file" })
-
--- Move Lines
-Util.map("n", "<C-j>", "<cmd>m .+1<cr>==", { desc = "Move down" })
-Util.map("n", "<C-k>", "<cmd>m .-2<cr>==", { desc = "Move up" })
-Util.map("i", "<C-j>", "<esc><cmd>m .+1<cr>==gi", { desc = "Move down" })
-Util.map("i", "<C-k>", "<esc><cmd>m .-2<cr>==gi", { desc = "Move up" })
-Util.map("v", "<C-j>", ":m '>+1<cr>gv=gv", { desc = "Move down" })
-Util.map("v", "<C-k>", ":m '<-2<cr>gv=gv", { desc = "Move up" })
-
-------------------------------
---   Windowing + Navigation
-------------------------------
-
--- better up/down
-Util.map({ "n", "x" }, "j", "v:count == 0 ? 'gj' : 'j'", { expr = true, silent = true })
-Util.map({ "n", "x" }, "k", "v:count == 0 ? 'gk' : 'k'", { expr = true, silent = true })
-
--- resize
-Util.map("n", "<C-Up>", "<cmd>resize +2<cr>", { desc = "Increase window height" })
-Util.map("n", "<C-Down>", "<cmd>resize -2<cr>", { desc = "Decrease window height" })
-Util.map("n", "<C-Left>", "<cmd>vertical resize -2<cr>", { desc = "Decrease window width" })
-Util.map("n", "<C-Right>", "<cmd>vertical resize +2<cr>", { desc = "Increase window width" })
-
--- split
-Util.map("n", "<leader>ws", "<cmd>split<cr>", { desc = "[W]indow Horizontal [S]plit" }) -- split horizontal
-Util.map("n", "<leader>wv", "<cmd>vsplit<cr>", { desc = "[W]indow [V]ertical Split" }) -- split vertical
-
--- move
--- Util.map("n", "<leader>wh", "<cmd>TmuxNavigateLeft<cr>", { desc = "Go to Left [W]indow" })
--- Util.map("n", "<leader>wj", "<cmd>TmuxNavigateDown<cr>", { desc = "Go to [W]indow Below" })
--- Util.map("n", "<leader>wk", "<cmd>TmuxNavigateUp<cr>", { desc = "Go to Top [W]indow" })
--- Util.map("n", "<leader>wl", "<cmd>TmuxNavigateRight<cr>", { desc = "Go to Right [W]indow" })
-
-if Util.has("bufferline.nvim") then
-  Util.map("n", "<S-h>", "<cmd>BufferLineCyclePrev<cr>", { desc = "Prev buffer" })
-  Util.map("n", "<S-l>", "<cmd>BufferLineCycleNext<cr>", { desc = "Next buffer" })
-  Util.map("n", "[b", "<cmd>BufferLineCyclePrev<cr>", { desc = "Prev buffer" })
-  Util.map("n", "]b", "<cmd>BufferLineCycleNext<cr>", { desc = "Next buffer" })
-else
-  Util.map("n", "<S-h>", "<cmd>bprevious<cr>", { desc = "Prev buffer" })
-  Util.map("n", "<S-l>", "<cmd>bnext<cr>", { desc = "Next buffer" })
-  Util.map("n", "[b", "<cmd>bprevious<cr>", { desc = "Prev buffer" })
-  Util.map("n", "]b", "<cmd>bnext<cr>", { desc = "Next buffer" })
-end
-
-Util.map("n", "<leader>wh", function()
-  require("smart-splits").resize_left()
-end, { desc = "Window Resize Left" })
-Util.map("n", "<leader>wj", function()
-  require("smart-splits").resize_down()
-end, { desc = "Window Resize Down" })
-Util.map("n", "<leader>wk", function()
-  require("smart-splits").resize_up()
-end, { desc = "Window Resize Up" })
-Util.map("n", "<leader>wl", function()
-  require("smart-splits").resize_right()
-end, { desc = "Window Resize Right" })
--- moving between splits
--- Util.map("n", "<C-h>", function()
---   require("smart-splits").move_cursor_left()
--- end, { desc = "Focus to Left Window" })
--- Util.map("n", "<C-j>", function()
---   require("smart-splits").move_cursor_down()
--- end, { desc = "Focus to Lower Window" })
--- Util.map("n", "<C-k>", function()
---   require("smart-splits").move_cursor_up()
--- end, { desc = "Focus to Upper Window" })
--- Util.map("n", "<C-l>", function()
---   require("smart-splits").move_cursor_right()
--- end, { desc = "Focus to Right Window" })
--- swapping buffers between windows
-Util.map("n", "<leader><leader>h", function()
-  require("smart-splits").swap_buf_left()
-end, { desc = "Swap Buffer Left" })
-Util.map("n", "<leader><leader>j", function()
-  require("smart-splits").swap_buf_down()
-end, { desc = "Swap Buffer Down" })
-Util.map("n", "<leader><leader>k", function()
-  require("smart-splits").swap_buf_up()
-end, { desc = "Swap Buffer Up" })
-Util.map("n", "<leader><leader>l", function()
-  require("smart-splits").swap_buf_right()
-end, { desc = "Swap Buffer Right" })
-
--- tabs
-Util.map("n", "<leader><tab>l", "<cmd>tablast<cr>", { desc = "Last Tab" })
-Util.map("n", "<leader><tab>f", "<cmd>tabfirst<cr>", { desc = "First Tab" })
-Util.map("n", "<leader><tab><tab>", "<cmd>tabnew<cr>", { desc = "New Tab" })
-Util.map("n", "<leader><tab>]", "<cmd>tabnext<cr>", { desc = "Next Tab" })
-Util.map("n", "<leader><tab>d", "<cmd>tabclose<cr>", { desc = "Close Tab" })
-Util.map("n", "<leader><tab>[", "<cmd>tabprevious<cr>", { desc = "Previous Tab" })
-
--- close
-Util.map("n", "<leader>wq", "<C-w>q", { desc = "[W]indow [Q]uit" }) -- quit
-
-------------------------------
---        Clipboard
-------------------------------
-
-Util.map("x", "<leader>p", [["_dP]])
-
-Util.map({ "n", "v" }, "<leader>y", [["+y]])
-Util.map("n", "<leader>Y", [["+Y]])
-
-Util.map({ "n", "v" }, "<leader>d", [["_d]])
-
-Util.map("i", "<C-c>", "<Esc>")
-
-Util.map("n", "Q", "<nop>")
-
-------------------------------
---        Utilities
-------------------------------
-
-Util.map("n", "<leader>u", vim.cmd.UndotreeToggle)
-
--- better indenting
-Util.map("v", "<", "<gv")
-Util.map("v", ">", ">gv")
-
--- file permission
-Util.map("n", "<leader>x", "<cmd>!chmod +x %<CR>", { silent = true })
-
-Util.map("n", "<leader>mr", "<cmd>CellularAutomaton make_it_rain<CR>")
-
-------------------------------
---        Terminal
-------------------------------
-
--- lazygit
-Util.map("n", "<leader>gg", function()
-  Util.float_term({ "lazygit" }, { cwd = Util.get_root(), esc_esc = false, ctrl_hjkl = false })
-end, { desc = "Lazygit (root dir)" })
-Util.map("n", "<leader>gG", function()
-  Util.float_term({ "lazygit" }, { esc_esc = false, ctrl_hjkl = false })
-end, { desc = "Lazygit (cwd)" })
-
--- float term
-local lazyterm = function()
-  Util.float_term(nil, { cwd = Util.get_root() })
-end
-Util.map("n", "<leader>tt", lazyterm, { desc = "Terminal (root dir)" })
-Util.map("n", "<leader>tT", function()
-  Util.float_term()
-end, { desc = "Terminal (cwd)" })
-Util.map("n", "`", lazyterm, { desc = "Terminal (root dir)" })
-Util.map("n", "<c-/>", lazyterm, { desc = "Terminal (root dir)" })
-Util.map("n", "<c-_>", lazyterm, { desc = "which_key_ignore" })
-
-Util.map("t", "<esc><esc>", "<c-\\><c-n>", { desc = "Enter Normal Mode" })
-Util.map("t", "<C-/>", "<cmd>close<cr>", { desc = "Hide Terminal" })
-Util.map("t", "<c-_>", "<cmd>close<cr>", { desc = "which_key_ignore" })
-
-------------------------------
---        Netrw
-------------------------------
-
--- netrw
--- Util.map("n", "<leader>e", function()
---   vim.cmd("Ex")
--- end)
-
--- remap q to quit buffer in netrw
-vim.api.nvim_create_autocmd("FileType", {
-  pattern = "netrw",
-  command = "nnoremap <buffer> q <cmd>bd<CR>",
-})
-
--- disable ctrl-h and ctrl-l in netrw and change it to TmuxNavigateLeft and TmuxNavigateRight
-vim.api.nvim_create_autocmd("FileType", {
-  pattern = "netrw",
-  command = "nnoremap <buffer> <C-h> <cmd>TmuxNavigateLeft<CR>",
-})
-
-vim.api.nvim_create_autocmd("FileType", {
-  pattern = "netrw",
-  command = "nnoremap <buffer> <C-l> <cmd>TmuxNavigateRight<CR>",
-})
-
--- change refresh netrw to r
-vim.api.nvim_create_autocmd("FileType", {
-  pattern = "netrw",
-  command = "nnoremap <buffer> r <cmd>edit<CR>",
-})
-
-------------------------------
---        Others
-------------------------------
-
--- ufo
-Util.map("n", "zR", function()
-  require("ufo").openAllFolds()
-end)
-Util.map("n", "zM", function()
-  require("ufo").closeAllFolds()
-end)
-
--- lazy
-Util.map("n", "<leader>l", "<cmd>Lazy<cr>", { desc = "Lazy" })
-
--- source file
-Util.map("n", "<leader><leader>s", function()
-  vim.cmd("so")
-end, { desc = "Source File" })

lua/rayandrew/root.lua

@@ -1,205 +0,0 @@
-local lazy_util = require("lazy.util")
-
----@class lazyvim.util.root
----@overload fun(): string
-local M = setmetatable({}, {
-  __call = function(m)
-    return m.get()
-  end,
-})
-
----@class LazyRoot
----@field paths string[]
----@field spec LazyRootSpec
-
----@alias LazyRootFn fun(buf: number): (string|string[])
-
----@alias LazyRootSpec string|string[]|LazyRootFn
-
----@type LazyRootSpec[]
-M.spec = { "lsp", { ".git", "lua" }, "cwd" }
-
-M.detectors = {}
-
-function M.detectors.cwd()
-  return { vim.uv.cwd() }
-end
-
-function M.detectors.lsp(buf)
-  local bufpath = M.bufpath(buf)
-  if not bufpath then
-    return {}
-  end
-  local roots = {} ---@type string[]
-  for _, client in pairs(LazyVim.lsp.get_clients({ bufnr = buf })) do
-    -- only check workspace folders, since we're not interested in clients
-    -- running in single file mode
-    local workspace = client.config.workspace_folders
-    for _, ws in pairs(workspace or {}) do
-      roots[#roots + 1] = vim.uri_to_fname(ws.uri)
-    end
-  end
-  return vim.tbl_filter(function(path)
-    path = lazy_util.norm(path)
-    return path and bufpath:find(path, 1, true) == 1
-  end, roots)
-end
-
----@param patterns string[]|string
-function M.detectors.pattern(buf, patterns)
-  patterns = type(patterns) == "string" and { patterns } or patterns
-  local path = M.bufpath(buf) or vim.uv.cwd()
-  local pattern = vim.fs.find(function(name)
-    for _, p in ipairs(patterns) do
-      if name == p then
-        return true
-      end
-      if p:sub(1, 1) == "*" and name:find(p:sub(2) .. "$") then
-        return true
-      end
-    end
-    return false
-  end, { path = path, upward = true })[1]
-  return pattern and { vim.fs.dirname(pattern) } or {}
-end
-
-function M.bufpath(buf)
-  return M.realpath(vim.api.nvim_buf_get_name(assert(buf)))
-end
-
-function M.cwd()
-  return M.realpath(vim.uv.cwd()) or ""
-end
-
-function M.realpath(path)
-  if path == "" or path == nil then
-    return nil
-  end
-  path = vim.uv.fs_realpath(path) or path
-  return lazy_util.norm(path)
-end
-
----@param spec LazyRootSpec
----@return LazyRootFn
-function M.resolve(spec)
-  if M.detectors[spec] then
-    return M.detectors[spec]
-  elseif type(spec) == "function" then
-    return spec
-  end
-  return function(buf)
-    return M.detectors.pattern(buf, spec)
-  end
-end
-
----@param opts? { buf?: number, spec?: LazyRootSpec[], all?: boolean }
-function M.detect(opts)
-  opts = opts or {}
-  opts.spec = opts.spec or type(vim.g.root_spec) == "table" and vim.g.root_spec or M.spec
-  opts.buf = (opts.buf == nil or opts.buf == 0) and vim.api.nvim_get_current_buf() or opts.buf
-
-  local ret = {} ---@type LazyRoot[]
-  for _, spec in ipairs(opts.spec) do
-    local paths = M.resolve(spec)(opts.buf)
-    paths = paths or {}
-    paths = type(paths) == "table" and paths or { paths }
-    local roots = {} ---@type string[]
-    for _, p in ipairs(paths) do
-      local pp = M.realpath(p)
-      if pp and not vim.tbl_contains(roots, pp) then
-        roots[#roots + 1] = pp
-      end
-    end
-    table.sort(roots, function(a, b)
-      return #a > #b
-    end)
-    if #roots > 0 then
-      ret[#ret + 1] = { spec = spec, paths = roots }
-      if opts.all == false then
-        break
-      end
-    end
-  end
-  return ret
-end
-
-function M.info()
-  local spec = type(vim.g.root_spec) == "table" and vim.g.root_spec or M.spec
-
-  local roots = M.detect({ all = true })
-  local lines = {} ---@type string[]
-  local first = true
-  for _, root in ipairs(roots) do
-    for _, path in ipairs(root.paths) do
-      lines[#lines + 1] = ("- [%s] `%s` **(%s)**"):format(
-        first and "x" or " ",
-        path,
-        type(root.spec) == "table" and table.concat(root.spec, ", ") or root.spec
-      )
-      first = false
-    end
-  end
-  lines[#lines + 1] = "```lua"
-  lines[#lines + 1] = "vim.g.root_spec = " .. vim.inspect(spec)
-  lines[#lines + 1] = "```"
-  LazyVim.info(lines, { title = "LazyVim Roots" })
-  return roots[1] and roots[1].paths[1] or vim.uv.cwd()
-end
-
----@type table<number, string>
-M.cache = {}
-
-function M.setup()
-  vim.api.nvim_create_user_command("LazyRoot", function()
-    LazyVim.root.info()
-  end, { desc = "LazyVim roots for the current buffer" })
-
-  -- FIX: doesn't properly clear cache in neo-tree `set_root` (which should happen presumably on `DirChanged`),
-  -- probably because the event is triggered in the neo-tree buffer, therefore add `BufEnter`
-  -- Maybe this is too frequent on `BufEnter` and something else should be done instead??
-  vim.api.nvim_create_autocmd({ "LspAttach", "BufWritePost", "DirChanged", "BufEnter" }, {
-    group = vim.api.nvim_create_augroup("lazyvim_root_cache", { clear = true }),
-    callback = function(event)
-      M.cache[event.buf] = nil
-    end,
-  })
-end
-
--- returns the root directory based on:
--- * lsp workspace folders
--- * lsp root_dir
--- * root pattern of filename of the current buffer
--- * root pattern of cwd
----@param opts? {normalize?:boolean}
----@return string
-function M.get(opts)
-  local buf = vim.api.nvim_get_current_buf()
-  local ret = M.cache[buf]
-  if not ret then
-    local roots = M.detect({ all = false })
-    ret = roots[1] and roots[1].paths[1] or vim.uv.cwd()
-    M.cache[buf] = ret
-  end
-  if opts and opts.normalize then
-    return ret
-  end
-  return M.is_win() and ret:gsub("/", "\\") or ret
-end
-
-function M.is_win()
-  return vim.uv.os_uname().sysname:find("Windows") ~= nil
-end
-
-function M.git()
-  local root = M.get()
-  local git_root = vim.fs.find(".git", { path = root, upward = true })[1]
-  local ret = git_root and vim.fn.fnamemodify(git_root, ":h") or root
-  return ret
-end
-
----@param opts? {hl_last?: string}
-function M.pretty_path(opts)
-  return ""
-end
-
-return M

lua/rayandrew/set.lua

@@ -1,94 +0,0 @@
-vim.g.mapleader = " "
-vim.g.maplocalleader = "\\"
-
-vim.g.netrw_browse_split = 0
-vim.g.netrw_banner = 0
-vim.g.netrw_winsize = 25
-
-local opt = vim.opt
-
-opt.guicursor = ""
-
-opt.autowrite = true -- Enable auto write
-opt.backup = false
-opt.clipboard = "unnamedplus" -- Sync with system clipboard
-opt.completeopt = "menu,menuone,noselect"
-opt.conceallevel = 3 -- Hide * markup for bold and italic
-opt.confirm = true -- Confirm to save changes before exiting modified buffer
-opt.cursorline = true -- Enable highlighting of the current line
-opt.expandtab = true -- Use spaces instead of tabs
-opt.formatoptions = "jcroqlnt" -- tcqj
-opt.grepformat = "%f:%l:%c:%m"
--- opt.grepformat = { "%f:%l:%c:%m", "%f:%l:%m,%f" }
-opt.grepprg = "rg --vimgrep"
-opt.hlsearch = false
-opt.ignorecase = true -- Ignore case
-opt.incsearch = true
-opt.inccommand = "nosplit" -- preview incremental substitute
-opt.laststatus = 2
-opt.list = true -- Show some invisible characters (tabs...
-opt.mouse = "a" -- Enable mouse mode
-opt.nu = true
-opt.number = true -- Print line number
-opt.pumblend = 10 -- Popup blend
-opt.pumheight = 10 -- Maximum number of entries in a popup
-opt.relativenumber = true -- Relative line numbers
-opt.ruler = false -- Disable ruler
-opt.scrolloff = 4 -- Lines of context
-opt.sessionoptions = { "buffers", "curdir", "tabpages", "winsize" }
-opt.shiftround = true -- Round indent
-opt.shiftwidth = 2 -- Size of an indent
-opt.shortmess:append({ W = true, I = true, c = true })
-opt.showmode = false -- Dont show mode since we have a statusline
-opt.sidescrolloff = 8 -- Columns of context
-opt.signcolumn = "yes" -- Always show the signcolumn, otherwise it would shift the text each time
-opt.smartcase = true -- Don't ignore case with capitals
-opt.smartindent = true -- Insert indents automatically
-opt.softtabstop = 2
-opt.spelllang = { "en" }
-opt.splitbelow = true -- Put new windows below current
-opt.splitright = true -- Put new windows right of current
-opt.swapfile = false
-opt.tabstop = 2 -- Number of spaces tabs count for
-opt.termguicolors = true -- True color support
-opt.timeoutlen = 300
-opt.undodir = os.getenv("HOME") .. "/.vim/undodir" -- Set an undo directory
-opt.undofile = true
-opt.undolevels = 10000
-opt.updatetime = 200 -- Save swap file and trigger CursorHold
-opt.wildmode = "longest:full,full" -- Command-line completion mode
-opt.winminwidth = 5 -- Minimum window width
-opt.wrap = false -- Disable line wrap
-
--- For UFO
--- vim.o.foldcolumn = "1"
-vim.o.foldcolumn = "0"
-vim.o.foldlevel = 99
-vim.o.foldlevelstart = 99
-vim.o.foldenable = true
--- vim.o.fillchars = [[eob: ,fold: ,foldopen:,foldsep: ,foldclose:]]
-
-if vim.fn.has("nvim-0.9.0") == 1 then
-  opt.splitkeep = "screen"
-  opt.shortmess:append({ C = true })
-end
-
--- Fix markdown indentation settings
-vim.g.markdown_recommended_style = 0
-
-opt.isfname:append("@-@")
-
-opt.colorcolumn = "80"
-
--- Error Format
--- error format for location list
-opt.errorformat:append("%f|%l col %c|%m")
--- error format for quickfix
-opt.errorformat:append("%f|%l|%m")
--- error format for grep -rn <pattern> <path>
-opt.errorformat:append("%f:%l:%m")
--- error format for ls
-opt.errorformat:append("%f:%l:%m")
--- error format for ls -la
-opt.errorformat:append("%f:%l:%m,%f")
-opt.errorformat:append("%gggggg")

lua/rayandrew/statusline.lua

@@ -1,132 +0,0 @@
--- credit goes to
--- https://nuxsh.is-a.dev/blog/custom-nvim-statusline.html
-
-local M = {}
-
-local modes = {
-  ["n"] = "NORMAL",
-  ["no"] = "NORMAL",
-  ["v"] = "VISUAL",
-  ["V"] = "VISUAL LINE",
-  [""] = "VISUAL BLOCK",
-  ["s"] = "SELECT",
-  ["S"] = "SELECT LINE",
-  [""] = "SELECT BLOCK",
-  ["i"] = "INSERT",
-  ["ic"] = "INSERT",
-  ["R"] = "REPLACE",
-  ["Rv"] = "VISUAL REPLACE",
-  ["c"] = "COMMAND",
-  ["cv"] = "VIM EX",
-  ["ce"] = "EX",
-  ["r"] = "PROMPT",
-  ["rm"] = "MOAR",
-  ["r?"] = "CONFIRM",
-  ["!"] = "SHELL",
-  ["t"] = "TERMINAL",
-}
-
-local function mode()
-  local current_mode = vim.api.nvim_get_mode().mode
-  return string.format(" %s ", modes[current_mode]):upper()
-end
-
-local function filepath()
-  local fpath = vim.fn.fnamemodify(vim.fn.expand("%"), ":~:.:h")
-  if fpath == "" or fpath == "." then
-    return " "
-  end
-
-  return string.format(" %%<%s/", fpath)
-end
-
-local function update_mode_colors()
-  local current_mode = vim.api.nvim_get_mode().mode
-  local mode_color = "%#StatusLineAccent#"
-  if current_mode == "n" then
-    mode_color = "%#StatuslineAccent#"
-  elseif current_mode == "i" or current_mode == "ic" then
-    mode_color = "%#StatuslineInsertAccent#"
-  elseif current_mode == "v" or current_mode == "V" or current_mode == "" then
-    mode_color = "%#StatuslineVisualAccent#"
-  elseif current_mode == "R" then
-    mode_color = "%#StatuslineReplaceAccent#"
-  elseif current_mode == "c" then
-    mode_color = "%#StatuslineCmdLineAccent#"
-  elseif current_mode == "t" then
-    mode_color = "%#StatuslineTerminalAccent#"
-  end
-  return mode_color
-end
-
-local function filename()
-  local fname = vim.fn.expand("%:t")
-  if fname == "" then
-    return ""
-  end
-  return fname .. " "
-end
-
-function M.render_active()
-  local parts = {
-    "%#Statusline#",
-    update_mode_colors(),
-    mode(),
-    "%#Normal# ",
-    "%=%#StatusLineExtra#",
-    filepath(),
-    filename(),
-  }
-
-  local statusline = table.concat(parts, "")
-
-  return statusline
-end
-
-function M.render_inactive()
-  local parts = {
-    "%#Statusline#",
-    "%#Normal# ",
-    "%=%#StatusLineExtra#",
-  }
-  local statusline = table.concat(parts, "")
-  return statusline
-end
-
--- function M.render(opts)
---   opts = opts or {}
---   local active = opts.active or false
---   local statusline = ""
---   if active then
---     statusline = M.render_active()
---   else
---     statusline = M.render_inactive()
---   end
---   vim.opt_local.statusline = statusline
--- end
-
-function M.setup()
-  local augroup = require("rayandrew.util").augroup
-  local autocmd = vim.api.nvim_create_autocmd
-
-  -- Statusline
-  autocmd({ "BufEnter", "BufWinEnter", "WinEnter" }, {
-    group = augroup("statusline-enter"),
-    pattern = "*",
-    callback = function()
-      vim.opt_local.statusline = "%!v:lua.require('rayandrew.statusline').render_active()"
-    end,
-    -- command = [[lua require("rayandrew.statusline").render({ active = true })]],
-  })
-
-  autocmd({ "BufLeave", "BufWinLeave", "WinLeave" }, {
-    group = augroup("statusline-leave"),
-    pattern = "*",
-    callback = function()
-      vim.opt_local.statusline = "%!v:lua.require('rayandrew.statusline').render_inactive()"
-    end,
-    -- command = [[lua require("rayandrew.statusline").render({ active = false })]],
-  })
-end
-
-return M

lua/rayandrew/theme.lua

@@ -1,104 +0,0 @@
-local M = {}
-
--- M.colorscheme = "rose-pine"
--- M.colorscheme = "meh"
--- M.colorscheme = "rasmus"
--- M.colorscheme = "everforest"
-M.colorscheme = "gruber-darker"
-M.background = "dark"
--- M.colorscheme = ""
-
-function M.setup()
-  -- taken from https://github.com/LazyVim/LazyVim/blob/566049aa4a26a86219dd1ad1624f9a1bf18831b6/lua/lazyvim/config/init.lua#L117C3-L129C5
-  require("lazy.core.util").try(function()
-    if M.colorscheme == "" then
-      return
-    end
-
-    if type(M.colorscheme) == "function" then
-      M.colorscheme()
-    else
-      vim.cmd.colorscheme(M.colorscheme)
-    end
-
-    if M.background == "" then
-      return
-    end
-
-    vim.o.background = M.background
-  end, {
-    msg = "Could not load your colorscheme",
-    on_error = function(msg)
-      require("lazy.core.util").error(msg)
-      vim.cmd.colorscheme("habamax")
-    end,
-  })
-end
-
-M.icons = {
-  dap = {
-    Stopped = { "󰁕 ", "DiagnosticWarn", "DapStoppedLine" },
-    Breakpoint = " ",
-    BreakpointCondition = " ",
-    BreakpointRejected = { " ", "DiagnosticError" },
-    LogPoint = ".>",
-  },
-  diagnostics = {
-    Error = " ",
-    Warn = " ",
-    Hint = " ",
-    Info = " ",
-  },
-  git = {
-    added = " ",
-    modified = " ",
-    removed = " ",
-  },
-  kinds = {
-    Array = " ",
-    Boolean = " ",
-    Class = " ",
-    Color = " ",
-    Constant = " ",
-    Constructor = " ",
-    Copilot = " ",
-    Enum = " ",
-    EnumMember = " ",
-    Event = " ",
-    Field = " ",
-    File = " ",
-    Folder = " ",
-    Function = " ",
-    Interface = " ",
-    Key = " ",
-    Keyword = " ",
-    Method = " ",
-    Module = " ",
-    Namespace = " ",
-    Null = " ",
-    Number = " ",
-    Object = " ",
-    Operator = " ",
-    Package = " ",
-    Property = " ",
-    Reference = " ",
-    Snippet = " ",
-    String = " ",
-    Struct = " ",
-    Text = " ",
-    TypeParameter = " ",
-    Unit = " ",
-    Value = " ",
-    Variable = " ",
-  },
-}
-
-function M.recolor(color)
-  color = color or M.colorscheme
-  vim.cmd.colorscheme(color)
-
-  vim.api.nvim_set_hl(0, "Normal", { bg = "none" })
-  vim.api.nvim_set_hl(0, "NormalFloat", { bg = "none" })
-end
-
-return M

lua/rayandrew/tools.lua

@@ -1,104 +0,0 @@
-local M = {}
-
-local lsps = {
-  lua = { "lua-language-server" },
-  python = { "pyright" },
-  rust = { "rust_analyzer" },
-}
-
--- https://github.com/chrisgrieser/.config/blob/7dc36c350976010b32ece078edd581687634811a/nvim/lua/plugins/linter-formatter.lua#L214-L234
-M.linters = {
-  lua = { "selene" },
-  css = { "stylelint" },
-  sh = { "shellcheck" },
-  markdown = { "markdownlint", "vale" },
-  yaml = { "yamllint" },
-  python = { "pylint" },
-  gitcommit = {},
-  json = {},
-  javascript = {},
-  typescript = {},
-  toml = {},
-  applescript = {},
-  bib = {},
-}
-
--- https://github.com/chrisgrieser/.config/blob/7dc36c350976010b32ece078edd581687634811a/nvim/lua/plugins/linter-formatter.lua#L214-L234
--- PENDING https://github.com/mfussenegger/nvim-lint/issues/355
-for ft, _ in pairs(M.linters) do
-  table.insert(M.linters[ft], "codespell")
-  table.insert(M.linters[ft], "editorconfig-checker")
-end
-
--- https://github.com/chrisgrieser/.config/blob/7dc36c350976010b32ece078edd581687634811a/nvim/lua/plugins/linter-formatter.lua#L214-L234
-M.formatters = {
-  lua = { "stylua" },
-  python = { "isort", "black" },
-  javascript = { "biome" },
-  typescript = { "biome" },
-  json = { "biome" },
-  jsonc = { "biome" },
-  nix = { "alejandra" },
-  yaml = { "prettier" },
-  html = { "prettier" },
-  rust = { "rustfmt" },
-  markdown = {
-    "markdown-toc",
-    "markdownlint",
-    -- "injected",
-  },
-  css = { "stylelint", "prettier" },
-  sh = { "shellcheck", "shfmt" },
-  bib = { "trim_whitespace", "bibtex-tidy" },
-  ["_"] = { "trim_whitespace", "trim_newlines", "squeeze_blanks" },
-  -- ["*"] = { "codespell" },
-}
-
-M.debuggers = {}
-
-M.dontInstall = {
-  -- installed externally due to its plugins: https://github.com/williamboman/mason.nvim/issues/695
-  "stylelint",
-  -- not real formatters, but pseudo-formatters from conform.nvim
-  "trim_whitespace",
-  "trim_newlines",
-  "squeeze_blanks",
-  "injected",
-  "alejandra",
-  "nixpkgs_fmt",
-}
-
----given the linter- and formatter-list of nvim-lint and conform.nvim, extract a
----list of all tools that need to be auto-installed
----@param myLinters object[]
----@param myFormatters object[]
----@param myDebuggers string[]
----@param ignoreTools string[]
----@return string[] tools
----@nodiscard
-function toolsToAutoinstall(myLinters, myFormatters, myDebuggers, ignoreTools)
-  -- get all linters, formatters, & debuggers and merge them into one list
-  local lspList = vim.tbl_flatten(vim.tbl_values(lsps))
-  local linterList = vim.tbl_flatten(vim.tbl_values(myLinters))
-  local formatterList = vim.tbl_flatten(vim.tbl_values(myFormatters))
-  local tools = vim.list_extend(linterList, formatterList)
-  vim.list_extend(tools, lspList)
-  vim.list_extend(tools, myDebuggers)
-
-  -- only unique tools
-  table.sort(tools)
-  tools = vim.fn.uniq(tools)
-
-  -- remove exceptions not to install
-  tools = vim.tbl_filter(function(tool)
-    return not vim.tbl_contains(ignoreTools, tool)
-  end, tools)
-  return tools
-end
-
-function M.getToolsToInstall()
-  local tools = toolsToAutoinstall(M.linters, M.formatters, M.debuggers, M.dontInstall)
-  return tools
-end
-
-return M

lua/rayandrew/util.lua

@@ -1,265 +0,0 @@
-local root = require("rayandrew.root")
-
--- shamelessly copied from
--- https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/util/init.lua
-
-local M = {}
-
-function M.augroup(name)
-  return vim.api.nvim_create_augroup("rayandrew_" .. name, { clear = true })
-end
-
----@param on_attach fun(client, buffer)
-function M.on_attach(on_attach)
-  vim.api.nvim_create_autocmd("LspAttach", {
-    callback = function(args)
-      local buffer = args.buf
-      local client = vim.lsp.get_client_by_id(args.data.client_id)
-      on_attach(client, buffer)
-    end,
-  })
-end
-
-function M.fg(name)
-  ---@type {foreground?:number}?
-  local hl = vim.api.nvim_get_hl and vim.api.nvim_get_hl(0, { name = name }) or vim.api.nvim_get_hl_by_name(name, true)
-  local fg = hl and hl.fg or hl.foreground
-  return fg and { fg = string.format("#%06x", fg) }
-end
-
-function M.map(mode, lhs, rhs, opts)
-  local has_handler, handler = pcall(require, "lazy.core.handler")
-  if has_handler then
-    local keys = handler.handlers.keys
-    ---@cast keys LazyKeysHandler
-    -- do not create the keymap if a lazy keys handler exists
-    if not keys.active[keys.parse({ lhs, mode = mode }).id] then
-      opts = opts or {}
-      opts.silent = opts.silent ~= false
-      vim.keymap.set(mode, lhs, rhs, opts)
-    end
-    return
-  end
-
-  vim.keymap.set(mode, lhs, rhs, opts)
-end
-
-M.root_patterns = { ".git", "lua" }
-
--- returns the root directory based on:
--- * lsp workspace folders
--- * lsp root_dir
--- * root pattern of filename of the current buffer
--- * root pattern of cwd
----@return string
-function M.get_root()
-  ---@type string?
-  local path = vim.api.nvim_buf_get_name(0)
-  path = path ~= "" and vim.loop.fs_realpath(path) or nil
-  ---@type string[]
-  local roots = {}
-  if path then
-    for _, client in pairs(vim.lsp.get_active_clients({ bufnr = 0 })) do
-      local workspace = client.config.workspace_folders
-      local paths = workspace
-          and vim.tbl_map(function(ws)
-            return vim.uri_to_fname(ws.uri)
-          end, workspace)
-        or client.config.root_dir and { client.config.root_dir }
-        or {}
-      for _, p in ipairs(paths) do
-        local r = vim.loop.fs_realpath(p)
-        if path:find(r, 1, true) then
-          roots[#roots + 1] = r
-        end
-      end
-    end
-  end
-  table.sort(roots, function(a, b)
-    return #a > #b
-  end)
-  ---@type string?
-  local root = roots[1]
-  if not root then
-    path = path and vim.fs.dirname(path) or vim.loop.cwd()
-    ---@type string?
-    root = vim.fs.find(M.root_patterns, { path = path, upward = true })[1]
-    root = root and vim.fs.dirname(root) or vim.loop.cwd()
-  end
-  ---@cast root string
-  return root
-end
-
--- function M.telescope(builtin, opts)
---   local params = { builtin = builtin, opts = opts }
---   return function()
---     builtin = params.builtin
---     opts = params.opts
---     opts = vim.tbl_deep_extend("force", { cwd = M.get_root() }, opts or {})
---     if builtin == "files" then
---       if vim.loop.fs_stat((opts.cwd or vim.loop.cwd()) .. "/.git") then
---         opts.show_untracked = true
---         builtin = "git_files"
---       else
---         builtin = "find_files"
---       end
---     end
---     if opts.cwd and opts.cwd ~= vim.loop.cwd() then
---       opts.attach_mappings = function(_, map)
---         map("i", "<a-c>", function()
---           local action_state = require("telescope.actions.state")
---           local line = action_state.get_current_line()
---           M.telescope(
---             params.builtin,
---             vim.tbl_deep_extend("force", {}, params.opts or {}, { cwd = false, default_text = line })
---           )()
---         end)
---         return true
---       end
---     end
---
---     require("telescope.builtin")[builtin](opts)
---   end
--- end
-
--- this will return a function that calls telescope.
--- cwd will default to lazyvim.util.get_root
--- for `files`, git_files or find_files will be chosen depending on .git
----@param builtin string
----@param opts? lazyvim.util.telescope.opts
-function M.telescope(builtin, opts)
-  local params = { builtin = builtin, opts = opts }
-  return function()
-    builtin = params.builtin
-    opts = params.opts
-    opts = vim.tbl_deep_extend("force", { cwd = M.get_root() }, opts or {}) --[[@as lazyvim.util.telescope.opts]]
-    if builtin == "files" then
-      if
-        vim.uv.fs_stat((opts.cwd or vim.uv.cwd()) .. "/.git")
-        and not vim.uv.fs_stat((opts.cwd or vim.uv.cwd()) .. "/.ignore")
-        and not vim.uv.fs_stat((opts.cwd or vim.uv.cwd()) .. "/.rgignore")
-      then
-        if opts.show_untracked == nil then
-          opts.show_untracked = true
-        end
-        builtin = "git_files"
-      else
-        builtin = "find_files"
-      end
-    end
-    if opts.cwd and opts.cwd ~= vim.uv.cwd() then
-      local function open_cwd_dir()
-        local action_state = require("telescope.actions.state")
-        local line = action_state.get_current_line()
-        M.telescope(
-          params.builtin,
-          vim.tbl_deep_extend("force", {}, params.opts or {}, { cwd = false, default_text = line })
-        )()
-      end
-      ---@diagnostic disable-next-line: inject-field
-      opts.attach_mappings = function(_, map)
-        -- opts.desc is overridden by telescope, until it's changed there is this fix
-        map("i", "<a-c>", open_cwd_dir, { desc = "Open cwd Directory" })
-        return true
-      end
-    end
-
-    require("telescope.builtin")[builtin](opts)
-  end
-end
-
----@type table<string, LazyFloat>
-local terminals = {}
-
-function M.float_term(cmd, opts)
-  opts = vim.tbl_deep_extend("force", {
-    ft = "lazyterm",
-    size = { width = 0.9, height = 0.9 },
-  }, opts or {}, { persistent = true })
-  ---@cast opts LazyCmdOptions|{interactive?:boolean, esc_esc?:false}
-
-  local termkey = vim.inspect({
-    cmd = cmd or "shell",
-    cwd = opts.cwd,
-    env = opts.env,
-    count = vim.v.count1,
-  })
-
-  if terminals[termkey] and terminals[termkey]:buf_valid() then
-    terminals[termkey]:toggle()
-  else
-    terminals[termkey] = require("lazy.util").float_term(cmd, opts)
-    local buf = terminals[termkey].buf
-    vim.b[buf].lazyterm_cmd = cmd
-    if opts.esc_esc == false then
-      vim.keymap.set("t", "<esc>", "<esc>", { buffer = buf, nowait = true })
-    end
-    if opts.ctrl_hjkl == false then
-      vim.keymap.set("t", "<c-h>", "<c-h>", { buffer = buf, nowait = true })
-      vim.keymap.set("t", "<c-j>", "<c-j>", { buffer = buf, nowait = true })
-      vim.keymap.set("t", "<c-k>", "<c-k>", { buffer = buf, nowait = true })
-      vim.keymap.set("t", "<c-l>", "<c-l>", { buffer = buf, nowait = true })
-    end
-
-    vim.api.nvim_create_autocmd("BufEnter", {
-      buffer = buf,
-      callback = function()
-        vim.cmd.startinsert()
-      end,
-    })
-  end
-
-  return terminals[termkey]
-end
-
-function M.has(plugin)
-  return require("lazy.core.config").spec.plugins[plugin] ~= nil
-end
-
-function M.on_very_lazy(fn)
-  vim.api.nvim_create_autocmd("User", {
-    pattern = "VeryLazy",
-    callback = function()
-      fn()
-    end,
-  })
-end
-
-function M.lazy_file()
-  -- This autocmd will only trigger when a file was loaded from the cmdline.
-  -- It will render the file as quickly as possible.
-  vim.api.nvim_create_autocmd("BufReadPost", {
-    once = true,
-    callback = function(event)
-      -- Skip if we already entered vim
-      if vim.v.vim_did_enter == 1 then
-        return
-      end
-
-      -- Try to guess the filetype (may change later on during Neovim startup)
-      local ft = vim.filetype.match({ buf = event.buf })
-      if ft then
-        -- Add treesitter highlights and fallback to syntax
-        local lang = vim.treesitter.language.get_lang(ft)
-        if not (lang and pcall(vim.treesitter.start, event.buf, lang)) then
-          vim.bo[event.buf].syntax = ft
-        end
-
-        -- Trigger early redraw
-        vim.cmd([[redraw]])
-      end
-    end,
-  })
-
-  -- Add support for the LazyFile event
-  local Event = require("lazy.core.handler.event")
-
-  Event.mappings.LazyFile = { id = "LazyFile", event = M.lazy_file_events }
-  Event.mappings["User LazyFile"] = Event.mappings.LazyFile
-end
-
-function M.setup()
-  -- M.lazy_file()
-end
-
-return M

stylua.toml

@@ -1,3 +0,0 @@
-indent_type = "Spaces"
-indent_width = 2
-column_width = 120