ElKowar/dots-of-war
1
0
Fork 0
mirror of https://github.com/elkowar/dots-of-war.git synced 2024-12-25 13:42:23 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity

Move to new structure of lazy.vim

Browse source
This commit is contained in:
Leon Kowarschick 2023-10-06 13:24:40 +02:00
parent d308c62308
commit f3111fdcaa
Signed by: ElKowar
GPG key ID: 72C759DA738DE3A2
38 changed files with 1256 additions and 1191 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
nvim/.config/nvim/.gitignore vendored
View file

@ -1,2 +1,3 @@
lua lua
plugin plugin
lua-old

2
nvim/.config/nvim/.nfnl.fnl Normal file
View file

@ -0,0 +1,2 @@
{}

78
nvim/.config/nvim/fnl/dots/colors.fnl
View file

@ -1,40 +1,38 @@
(module dots.colors {:bg_main (if (= "epix" (vim.fn.hostname)) "#1d2021" "#282828")
{} :bg_second (if (= "epix" (vim.fn.hostname)) "#181A1B" "#1d2021")
{:bg_main (if (= "epix" (vim.fn.hostname)) "#1d2021" "#282828") :dark0_hard "#1d2021"
:bg_second (if (= "epix" (vim.fn.hostname)) "#181A1B" "#1d2021") :dark0 "#282828"
:dark0_hard "#1d2021" :dark0_soft "#32302f"
:dark0 "#282828" :dark1 "#3c3836"
:dark0_soft "#32302f" :dark2 "#504945"
:dark1 "#3c3836" :dark3 "#665c54"
:dark2 "#504945" :dark4 "#7c6f64"
:dark3 "#665c54" :light0_hard "#f9f5d7"
:dark4 "#7c6f64" :light0 "#fbf1c7"
:light0_hard "#f9f5d7" :light0_soft "#f2e5bc"
:light0 "#fbf1c7" :light1 "#ebdbb2"
:light0_soft "#f2e5bc" :light2 "#d5c4a1"
:light1 "#ebdbb2" :light3 "#bdae93"
:light2 "#d5c4a1" :light4 "#a89984"
:light3 "#bdae93" :bright_red "#fb4934"
:light4 "#a89984" :bright_green "#b8bb26"
:bright_red "#fb4934" :bright_yellow "#fabd2f"
:bright_green "#b8bb26" :bright_blue "#83a598"
:bright_yellow "#fabd2f" :bright_purple "#d3869b"
:bright_blue "#83a598" :bright_aqua "#8ec07c"
:bright_purple "#d3869b" :bright_orange "#fe8019"
:bright_aqua "#8ec07c" :neutral_red "#cc241d"
:bright_orange "#fe8019" :neutral_green "#98971a"
:neutral_red "#cc241d" :neutral_yellow "#d79921"
:neutral_green "#98971a" :neutral_blue "#458588"
:neutral_yellow "#d79921" :neutral_purple "#b16286"
:neutral_blue "#458588" :neutral_aqua "#689d6a"
:neutral_purple "#b16286" :neutral_orange "#d65d0e"
:neutral_aqua "#689d6a" :faded_red "#9d0006"
:neutral_orange "#d65d0e" :faded_green "#79740e"
:faded_red "#9d0006" :faded_yellow "#b57614"
:faded_green "#79740e" :faded_blue "#076678"
:faded_yellow "#b57614" :faded_purple "#8f3f71"
:faded_blue "#076678" :faded_aqua "#427b58"
:faded_purple "#8f3f71" :faded_orange "#af3a03"
:faded_aqua "#427b58" :gray "#928374"}
:faded_orange "#af3a03"
:gray "#928374"})

115
nvim/.config/nvim/fnl/dots/help-thingy.fnl
View file

@ -1,67 +1,68 @@
(module dots.help-thingy (fn help-thingy-kram []
{autoload {utils dots.utils (local {: autoload} (require :nfnl.module))
a aniseed.core (local utils (autoload :dots.utils))
str aniseed.string (local a (autoload :aniseed.core))
popup popup (local str (autoload :aniseed.string))
ts nvim-treesitter} (local popup (autoload :popup))
require-macros [macros]}) (local ts (autoload :nvim-treesitter))
(defn pop [text ft] (defn pop [text ft]
"Open a popup with the given text and filetype" "Open a popup with the given text and filetype"
(var width 20) (var width 20)
(each [_ line (ipairs text)] (each [_ line (ipairs text)]
(set width (math.max width (length line)))) (set width (math.max width (length line))))
(let [bufnr (vim.api.nvim_create_buf false true)] (let [bufnr (vim.api.nvim_create_buf false true)]
(vim.api.nvim_buf_set_option bufnr :bufhidden "wipe") (vim.api.nvim_buf_set_option bufnr :bufhidden "wipe")
(vim.api.nvim_buf_set_option bufnr :filetype ft) (vim.api.nvim_buf_set_option bufnr :filetype ft)
(vim.api.nvim_buf_set_lines bufnr 0 -1 true text) (vim.api.nvim_buf_set_lines bufnr 0 -1 true text)
(popup.create bufnr {:padding [1 1 1 1] :width width}))) (popup.create bufnr {:padding [1 1 1 1] :width width})))
(defn get-current-word [] (defn get-current-word []
"Return the word the cursor is currently hovering over" "Return the word the cursor is currently hovering over"
(let [col (. (vim.api.nvim_win_get_cursor 0) 2) (let [col (. (vim.api.nvim_win_get_cursor 0) 2)
line (vim.api.nvim_get_current_line)] line (vim.api.nvim_get_current_line)]
(.. (vim.fn.matchstr (line:sub 1 (+ col 1)) "\\k*$") (.. (vim.fn.matchstr (line:sub 1 (+ col 1)) "\\k*$")
(string.sub (vim.fn.matchstr (line:sub (+ col 1)) "^\\k*") (string.sub (vim.fn.matchstr (line:sub (+ col 1)) "^\\k*")
2)))) 2))))
(def helpfiles-path (str.join "/" (a.butlast (str.split vim.o.helpfile "/")))) (def helpfiles-path (str.join "/" (a.butlast (str.split vim.o.helpfile "/"))))
(def tags (def tags
(var entries {}) (var entries {})
(each [line _ (io.lines (.. helpfiles-path "/tags"))] (each [line _ (io.lines (.. helpfiles-path "/tags"))]
(let [[key file address] (str.split line "\t")] (let [[key file address] (str.split line "\t")]
(tset entries key {:file (.. helpfiles-path "/" file) :address address}))) (tset entries key {:file (.. helpfiles-path "/" file) :address address})))
entries) entries)
(defn find-help-tag-for [topic] (defn find-help-tag-for [topic]
(or (. tags topic) (or (. tags topic)
(. tags (.. topic "()")) (. tags (.. topic "()"))
(. tags (.. (string.gsub topic "vim%.api%." "") "()")) (. tags (.. (string.gsub topic "vim%.api%." "") "()"))
(. tags (.. (string.gsub topic "vim%.fn%." "") "()")) (. tags (.. (string.gsub topic "vim%.fn%." "") "()"))
(. tags (.. (string.gsub topic "fn%." "") "()")) (. tags (.. (string.gsub topic "fn%." "") "()"))
(. tags (.. (string.gsub topic "vim%.o%." "") "()")) (. tags (.. (string.gsub topic "vim%.o%." "") "()"))
(. tags (.. (string.gsub topic "vim%.b%." "") "()")) (. tags (.. (string.gsub topic "vim%.b%." "") "()"))
(. tags (.. (string.gsub topic "vim%.g%." "") "()")))) (. tags (.. (string.gsub topic "vim%.g%." "") "()"))))
(defn help-for-tag [tag] (defn help-for-tag [tag]
(var data nil) (var data nil)
(each [line _ (io.lines tag.file)] (each [line _ (io.lines tag.file)]
(if (= nil data) (if (= nil data)
(when (~= -1 (vim.fn.match line (tag.address:sub 2))) (when (~= -1 (vim.fn.match line (tag.address:sub 2)))
(set data [line])) (set data [line]))
(if (or (> 2 (length data)) (if (or (> 2 (length data))
(= "" line) (= "" line)
(= " " (line:sub 1 1)) (= " " (line:sub 1 1))
(= "\t" (line:sub 1 1)) (= "\t" (line:sub 1 1))
(= "<" (line:sub 1 1))) (= "<" (line:sub 1 1)))
(table.insert data line) (table.insert data line)
(lua "return data"))))) (lua "return data")))))
(fn _G.get_help [] (fn _G.get_help []
(if-let [help-tag (find-help-tag-for (get-current-word))] (if-let [help-tag (find-help-tag-for (get-current-word))]
(pop (help-for-tag help-tag) :help))) (pop (help-for-tag help-tag) :help)))
(utils.keymap :n :ML ":call v:lua.get_help()<CR>") (utils.keymap :n :ML ":call v:lua.get_help()<CR>"))
[]

32
nvim/.config/nvim/fnl/dots/keybinds.fnl
View file

@ -1,14 +1,12 @@
(module dots.keybinds (import-macros {: al} :macros)
{autoload {a aniseed.core (al a nfnl.core)
str aniseed.string (al str nfnl.string)
nvim aniseed.nvim (al utils dots.utils)
utils dots.utils (al wk which-key)
wk which-key ; (al treesitter-selection nvim-treesitter.incremental_selection)
treesitter-selection nvim-treesitter.incremental_selection (al lspactions lspactions)
lspactions lspactions (al glance glance)
glance glance (al crates crates)
crates crates}
require-macros [macros]})
; undo autopairs fuckup ; undo autopairs fuckup
(set vim.g.AutoPairsShortcutBackInsert "<M-b>") (set vim.g.AutoPairsShortcutBackInsert "<M-b>")
@ -52,7 +50,7 @@
;(utils.keymap [:n] :j "gj") ;(utils.keymap [:n] :j "gj")
;(utils.keymap [:n] :k "gk") ;(utils.keymap [:n] :k "gk")
(defn open-selection-zotero [] (fn open-selection-zotero []
(let [(_ _ sel) (utils.get-selection)] (let [(_ _ sel) (utils.get-selection)]
(vim.cmd (.. "silent !xdg-open zotero://select/items/@" (str.join sel))))) (vim.cmd (.. "silent !xdg-open zotero://select/items/@" (str.join sel)))))
@ -62,21 +60,21 @@
(fn rebind [s desc] [s desc]) (fn rebind [s desc] [s desc])
(defn format [] (fn format []
(if (a.some #$1.server_capabilities.documentFormattingProvider (vim.lsp.get_active_clients)) (if (a.some #$1.server_capabilities.documentFormattingProvider (vim.lsp.get_active_clients))
(vim.lsp.buf.format {:async true}) (vim.lsp.buf.format {:async true})
(vim.cmd "Neoformat"))) (vim.cmd "Neoformat")))
(defn open-rename [] (fn open-rename []
(vim.api.nvim_feedkeys (.. ":IncRename " (vim.fn.expand "<cword>")) "n" "")) (vim.api.nvim_feedkeys (.. ":IncRename " (vim.fn.expand "<cword>")) "n" ""))
(defn toggle-lsp-lines [] (fn toggle-lsp-lines []
(let [lsp-lines (require "lsp_lines")] (let [lsp-lines (require "lsp_lines")]
(vim.diagnostic.config {:virtual_lines (not (. (vim.diagnostic.config) :virtual_lines))}) (vim.diagnostic.config {:virtual_lines (not (. (vim.diagnostic.config) :virtual_lines))})
; TODO: this doesn't seem to work... ; TODO: this doesn't seem to work...
(vim.diagnostic.config {:virtual_text (not (. (vim.diagnostic.config) :virtual_lines))}))) (vim.diagnostic.config {:virtual_text (not (. (vim.diagnostic.config) :virtual_lines))})))
(defn toggle-lsp-lines-current [] (fn toggle-lsp-lines-current []
(let [lsp-lines (require "lsp_lines")] (let [lsp-lines (require "lsp_lines")]
(vim.diagnostic.config {:virtual_lines {:only_current_line true}}))) (vim.diagnostic.config {:virtual_lines {:only_current_line true}})))
@ -191,5 +189,5 @@
:mode "v"}) :mode "v"})
(set nvim.o.timeoutlen 200) (set vim.o.timeoutlen 200)

267
nvim/.config/nvim/fnl/dots/plugins.fnl
View file

@ -1,267 +0,0 @@
(module dots.plugins
{autoload {a aniseed.core
lazy lazy}
require-macros [macros]})
(defn- safe-req-conf [name]
"safely require a plugins configuration module, prepending 'dots.plugins.' to the given module name"
(let [(ok? val-or-err) (pcall require (.. "dots.plugins." name))]
(when (not ok?)
(print (.. "Plugin config error: " val-or-err)))))
(defn setup-lazy [...]
(let [pkgs [...]]
(local args [])
(for [i 1 (a.count pkgs) 2]
(let [name (. pkgs i)
opts (. pkgs (+ i 1))]
(table.insert args (a.assoc opts 1 name))))
(lazy.setup args {:colorscheme "gruvbox8"})))
(macro cfg [config-mod opts]
(let [a (require "aniseed.core")]
(a.assoc (or opts {})
:opt `false
:config `#(require ,config-mod))))
(macro setup [name opts]
`((. (require ,name) :setup) ,opts))
(setup-lazy
; TODO sort me pls
; sorted from here!
:Olical/aniseed {:branch "develop"}
; :lewis6991/impatient.nvim {}
:nvim-lua/plenary.nvim {}
:norcalli/nvim.lua {}
:lifepillar/vim-gruvbox8 {:lazy false :priority 1000 :config #(require "dots.plugins.gruvbox8")}
:kyazdani42/nvim-web-devicons {}
:folke/which-key.nvim {}
:folke/todo-comments.nvim {:lazy true
:event "VeryLazy"
:config #(require "dots.plugins.todo-comments")}
:Famiu/feline.nvim {:config #(require "dots.plugins.feline")}
:akinsho/nvim-bufferline.lua {:config #(require "dots.plugins.bufferline")
:tag "v1.1.1"}
:ckipp01/nvim-jenkinsfile-linter {:dependencies ["nvim-lua/plenary.nvim"]}
:psliwka/vim-smoothie {}
:norcalli/nvim-colorizer.lua {:event "VeryLazy"
:lazy true
:config #(require "dots.plugins.nvim-colorizer")}
:nathanaelkane/vim-indent-guides {:cmd ["IndentGuidesToggle"]}
:luukvbaal/stabilize.nvim {:config #(setup :stabilize)}
:stevearc/dressing.nvim {:config #(setup :dressing)}
:tweekmonster/startuptime.vim {:cmd ["StartupTime"]}
:folke/noice.nvim {:config #(require "dots.plugins.noice")
:dependencies [:MunifTanjim/nui.nvim]}
:folke/persistence.nvim {:config #(require "dots.plugins.persistence")}
:folke/zen-mode.nvim {:config #(require "dots.plugins.zen-mode")
:cmd ["ZenMode"]}
:folke/twilight.nvim {:config #(require "dots.plugins.twilight")}
:moll/vim-bbye {:lazy true :cmd [:Bdelete :Bwipeout]}
:nvim-telescope/telescope.nvim {:config #(require "dots.plugins.telescope")
:cmd ["Telescope"]
:dependencies [:nvim-lua/popup.nvim
:nvim-lua/plenary.nvim]}
:petertriho/nvim-scrollbar {:event "VeryLazy"
:lazy true
:config #(setup :scrollbar)}
"https://git.sr.ht/~whynothugo/lsp_lines.nvim" {:config #(do (setup :lsp_lines)
(vim.diagnostic.config {:virtual_lines false}))}
; editing and movement <<<
:jiangmiao/auto-pairs {}
:tpope/vim-repeat {}
:preservim/nerdcommenter {:event "VeryLazy"
:lazy true
:priority 1000}
:godlygeek/tabular {:cmd ["Tabularize"]}
:tpope/vim-surround {}
:hauleth/sad.vim {}
:wellle/targets.vim {} ; more text objects. IE: cin (change in next parens). generally better handling of surrounding objects.
:mg979/vim-visual-multi {:lazy true :event "VeryLazy"}
:tommcdo/vim-exchange {}
:phaazon/hop.nvim {:lazy true
:event "VeryLazy"
:config #(setup "hop" {:keys "jfkdls;amvieurow"})}
;:justinmk/vim-sneak {:lazy true}
;:config #(require "dots.plugins.sneak")}
; >>>
; treesitter <<<
:nvim-treesitter/nvim-treesitter {:config #(require "dots.plugins.treesitter")
:lazy true
:event ["VeryLazy"]
:build ":TSUpdate"}
:RRethy/nvim-treesitter-textsubjects {:dependencies [:nvim-treesitter/nvim-treesitter]
:lazy true
:event ["VeryLazy"]}
:JoosepAlviste/nvim-ts-context-commentstring {:event ["VeryLazy"]
:lazy true
:dependencies [:nvim-treesitter/nvim-treesitter]}
:nvim-treesitter/playground {:event ["VeryLazy"]
:lazy true
:dependencies [:nvim-treesitter/nvim-treesitter]}
; >>>
; debugger <<<
:rcarriga/nvim-dap-ui {:lazy true
:config #(setup :dapui)
:dependencies [:mfussenegger/nvim-dap]}
:mfussenegger/nvim-dap {:lazy true}
:nvim-telescope/telescope-dap.nvim {:lazy true
:dependencies [:nvim-telescope/telescope.nvim
:mfussenegger/nvim-dap]}
; >>>
; git stuff <<<
:ldelossa/gh.nvim {:lazy true
:config #(do ((. (require "litee.lib") :setup))
((. (require "litee.gh") :setup)))
:dependencies [:ldelossa/litee.nvim]}
:pwntester/octo.nvim {:lazy true
:dependencies [:nvim-lua/plenary.nvim
:nvim-telescope/telescope.nvim
:kyazdani42/nvim-web-devicons]
:config #(setup :octo)}
:sindrets/diffview.nvim {:cmd ["DiffviewOpen" "DiffviewToggleFiles"]
:config #(require "dots.plugins.diffview")}
:lewis6991/gitsigns.nvim {:dependencies [:vim-gruvbox8
:petertriho/nvim-scrollbar]
:config #(require "dots.plugins.gitsigns")}
:ruanyl/vim-gh-line {}
:rhysd/conflict-marker.vim {}
:tpope/vim-fugitive {:lazy true :event "VeryLazy"}
:TimUntersberger/neogit {:config #(require "dots.plugins.neogit")
:cmd ["Neogit"]}
; >>>
; lsp <<<
:ray-x/lsp_signature.nvim {:event :BufEnter}
:weilbith/nvim-code-action-menu {:cmd "CodeActionMenu"
:config #(set vim.g.code_action_menu_show_details false)}
:folke/trouble.nvim {:lazy true
:config #(require "dots.plugins.trouble")
:cmd ["Trouble" "TroubleClose" "TroubleRefresh" "TroubleToggle"]}
; :elkowar/trouble.nvim {:branch "fix_error_on_nil_window"
; :config #(require "dots.plugins.trouble")
; :cmd ["Trouble" "TroubleClose" "TroubleRefresh" "TroubleToggle"]}
:simrat39/symbols-outline.nvim {:lazy true
:cmd ["SymbolsOutline" "SymbolsOutlineClose" "SymbolsOutlineOpen"]
:config #(require "dots.plugins.symbols-outline")}
:neovim/nvim-lspconfig {:event "VeryLazy"
:lazy true}
:smjonas/inc-rename.nvim {:config #(setup :inc_rename {:input_buffer_type "dressing"})}
:dnlhc/glance.nvim {:lazy true :config #(require "dots.plugins.glance")}
; >>>
; cmp <<<
:hrsh7th/vim-vsnip {:lazy true :event ["VeryLazy"]}
:hrsh7th/vim-vsnip-integ {:lazy true :event ["VeryLazy"]}
:rafamadriz/friendly-snippets {}
:hrsh7th/nvim-cmp {:lazy true
:event ["VeryLazy"]
:dependencies [[:hrsh7th/cmp-nvim-lsp]
[:hrsh7th/cmp-buffer]
[:hrsh7th/cmp-vsnip]
[:hrsh7th/cmp-nvim-lua]
[:hrsh7th/cmp-calc]
[:hrsh7th/cmp-path]
[:hrsh7th/cmp-nvim-lsp-signature-help]
[:davidsierradz/cmp-conventionalcommits]
[:hrsh7th/cmp-omni]]
:config #(require "dots.plugins.cmp")}
; >>>
; code-related ----------------------------------------- <<<
;:github/copilot.vim {:cmd ["Copilot"]}
:zbirenbaum/copilot.lua {:cmd "Copilot"
:event "InsertEnter"
:config #(require "dots.plugins.copilot")}
:monkoose/nvlime {:ft ["lisp"] :dependencies [:monkoose/parsley]}
:tpope/vim-sleuth {}
:editorconfig/editorconfig-vim {}
:pechorin/any-jump.vim {}
:sbdchd/neoformat {}
:elkowar/antifennel-nvim {:config #(set vim.g.antifennel_executable "/home/leon/tmp/antifennel/antifennel")}
:Olical/conjure {:ft ["fennel"]}
:eraserhd/parinfer-rust {:build "cargo build --release"}
:lervag/vimtex {:ft ["latex" "tex"]
:config #(require :dots.plugins.vimtex)}
:kmonad/kmonad-vim {}
:elkowar/yuck.vim {:ft ["yuck"]}
:cespare/vim-toml {:ft ["toml"]}
:bduggan/vim-raku {:ft ["raku"]}
:LnL7/vim-nix {:ft ["nix"]}
:kevinoid/vim-jsonc {}
:pangloss/vim-javascript {:ft ["javascript"]} ; syntax highlighting JS
:ianks/vim-tsx {:ft ["typescript-react"]}
:leafgarland/typescript-vim {:ft ["typescript" "typescript-react" "javascript"]}
:HerringtonDarkholme/yats.vim {} ; typescript syntax highlighting
:mxw/vim-jsx {}
:mattn/emmet-vim {:lazy true
:config #(require "dots.plugins.emmet")}
:purescript-contrib/purescript-vim {:ft ["purescript"]}
:derekelkins/agda-vim {:ft ["agda"]}
:neovimhaskell/haskell-vim { :ft ["haskell"]}
:monkoose/nvlime {:ft ["lisp"] :dependencies ["monkoose/parsley"] :config #(set vim.g.vlime_overlay "slimv")}
:rust-lang/rust.vim {:ft ["rust"]
:dependencies ["mattn/webapi-vim"]
:config #(do (set vim.g.rustfmt_fail_silently 1))}
:simrat39/rust-tools.nvim {:ft ["rust" "toml"]
:dependencies ["nvim-lua/popup.nvim" "nvim-lua/plenary.nvim"]}
:Saecki/crates.nvim {:dependencies ["nvim-lua/plenary.nvim"]
:dir "/Users/leon/tmp/crates.nvim"
:event ["BufRead Cargo.toml"]
:lazy true
:config #(require :dots.plugins.crates)}
:qnighy/lalrpop.vim {}
:edwinb/idris2-vim {:ft ["idris2"]}
:vmchale/ats-vim {:ft ["ats" "dats" "sats"]}
:bakpakin/fennel.vim {:ft ["fennel"]}
:evanleck/vim-svelte {})
; >>>
;(require "packer_compiled")
; vim:foldmarker=<<<,>>>

100
nvim/.config/nvim/fnl/dots/plugins/bufferline.fnl
View file

@ -1,57 +1,59 @@
(module dots.plugins.bufferline (import-macros {: al} :macros)
{autoload {a aniseed.core (al a nfnl.core)
nvim aniseed.nvim (al utils dots.utils)
utils dots.utils (al colors dots.colors)
colors dots.colors (al bufferline bufferline)
bufferline bufferline}
require-macros [macros]})
; :h bufferline-lua-highlights (fn setup []
(let [selected {:guibg colors.neutral_aqua :guifg colors.bg_main :gui "NONE"} ; :h bufferline-lua-highlights
visible {:guibg colors.dark1 :guifg colors.neutral_aqua}] (let [selected {:guibg colors.neutral_aqua :guifg colors.bg_main :gui "NONE"}
(bufferline.setup visible {:guibg colors.dark1 :guifg colors.neutral_aqua}]
{:options (bufferline.setup
{:diagnostics "nvim_lsp" {:options
:diagnostics_indicator (fn [cnt lvl diagnostics-dict] (.. " (" cnt ")")) {:diagnostics "nvim_lsp"
:show_buffer_close_icons false :diagnostics_indicator (fn [cnt lvl diagnostics-dict] (.. " (" cnt ")"))
:show_buffer_icons false :show_buffer_close_icons false
:show_close_icon false :show_buffer_icons false
:show_tab_indicators false :show_close_icon false
:enforce_regular_tabs false :show_tab_indicators false
:tab_size 10} :enforce_regular_tabs false
:tab_size 10}
; https://github.com/akinsho/nvim-bufferline.lua/blob/4ebab39af2376b850724dd29c29579c8e024abe6/lua/bufferline/config.lua#L74 ; https://github.com/akinsho/nvim-bufferline.lua/blob/4ebab39af2376b850724dd29c29579c8e024abe6/lua/bufferline/config.lua#L74
:highlights :highlights
{:fill {:guibg colors.bg_main :guifg colors.light0} {:fill {:guibg colors.bg_main :guifg colors.light0}
:background visible :background visible
:buffer_visible visible :buffer_visible visible
:buffer_selected selected :buffer_selected selected
:modified visible :modified_selected selected :modified_visible visible :modified visible :modified_selected selected :modified_visible visible
:info visible :info_selected selected :info_visible visible :info visible :info_selected selected :info_visible visible
:warning visible :warning_selected selected :warning_visible visible :warning visible :warning_selected selected :warning_visible visible
:error visible :error_selected selected :error_visible visible :error visible :error_selected selected :error_visible visible
:duplicate visible :duplicate_selected selected :duplicate_visible visible :duplicate visible :duplicate_selected selected :duplicate_visible visible
:diagnostic {:guibg colors.dark1 :guifg colors.neutral_red} :diagnostic {:guibg colors.dark1 :guifg colors.neutral_red}
:diagnostic_visible {:guibg colors.dark1 :guifg colors.neutral_red} :diagnostic_visible {:guibg colors.dark1 :guifg colors.neutral_red}
:diagnostic_selected {:guibg colors.neutral_aqua :guifg colors.faded_redu} :diagnostic_selected {:guibg colors.neutral_aqua :guifg colors.faded_redu}
:info_diagnostic {:guibg colors.dark1 :guifg colors.neutral_blue} :info_diagnostic {:guibg colors.dark1 :guifg colors.neutral_blue}
:info_diagnostic_visible {:guibg colors.dark1 :guifg colors.neutral_blue} :info_diagnostic_visible {:guibg colors.dark1 :guifg colors.neutral_blue}
:info_diagnostic_selected {:guibg colors.neutral_aqua :guifg colors.faded_blue} :info_diagnostic_selected {:guibg colors.neutral_aqua :guifg colors.faded_blue}
:warning_diagnostic {:guibg colors.dark1 :guifg colors.neutral_yellow} :warning_diagnostic {:guibg colors.dark1 :guifg colors.neutral_yellow}
:warning_diagnostic_visible {:guibg colors.dark1 :guifg colors.neutral_yellow} :warning_diagnostic_visible {:guibg colors.dark1 :guifg colors.neutral_yellow}
:warning_diagnostic_selected {:guibg colors.neutral_aqua :guifg colors.faded_yellow} :warning_diagnostic_selected {:guibg colors.neutral_aqua :guifg colors.faded_yellow}
:error_diagnostic {:guibg colors.dark1 :guifg colors.neutral_red} :error_diagnostic {:guibg colors.dark1 :guifg colors.neutral_red}
:error_diagnostic_visible {:guibg colors.dark1 :guifg colors.neutral_red} :error_diagnostic_visible {:guibg colors.dark1 :guifg colors.neutral_red}
:error_diagnostic_selected {:guibg colors.neutral_aqua :guifg colors.red} :error_diagnostic_selected {:guibg colors.neutral_aqua :guifg colors.red}
:separator visible :separator visible
:indicator_selected {:guibg colors.neutral_aqua :guifg colors.neutral_aqua} :indicator_selected {:guibg colors.neutral_aqua :guifg colors.neutral_aqua}
; stuff I've never seen before :thonk: ; stuff I've never seen before :thonk:
:pick_selected {:guibg colors.bright_red :guifg colors.bright_red} :pick_selected {:guibg colors.bright_red :guifg colors.bright_red}
:tab_selected {:guibg colors.bright_green :guifg colors.bright_green} :tab_selected {:guibg colors.bright_green :guifg colors.bright_green}
:tab {:guibg colors.bright_yellow :guifg colors.bright_yellow}}})) :tab {:guibg colors.bright_yellow :guifg colors.bright_yellow}}})))
[(utils.plugin :akinsho/nvim-bufferline.lua
{:config setup :tag "v1.1.1"})]

123
nvim/.config/nvim/fnl/dots/plugins/cmp.fnl
View file

@ -1,57 +1,74 @@
(module dots.plugins.cmp (import-macros {: al} :macros)
{autoload {a aniseed.core (al a nfnl.core)
cmp cmp}}) (al cmp cmp)
(al utils dots.utils)
; check this for coloring maybe
; https://github.com/hrsh7th/nvim-cmp/blob/ada9ddeff71e82ad0e52c9a280a1e315a8810b9a/lua/cmp/entry.lua#L199
(defn item-formatter [item vim-item]
(let [padding (string.rep " " (- 10 (vim.fn.strwidth vim-item.abbr)))
details (?. item :completion_item :detail)]
(when details
(set vim-item.abbr (.. vim-item.abbr padding " " details))))
vim-item)
(cmp.setup (fn setup []
{:snippet {:expand (fn [args] ((. vim.fn :vsnip#anonymous) args.body))} ; check this for coloring maybe
; https://github.com/hrsh7th/nvim-cmp/blob/ada9ddeff71e82ad0e52c9a280a1e315a8810b9a/lua/cmp/entry.lua#L199
:completion {:autocomplete false} (fn item-formatter [item vim-item]
(let [padding (string.rep " " (- 10 (vim.fn.strwidth vim-item.abbr)))
:mapping (cmp.mapping.preset.insert details (?. item :completion_item :detail)]
{:<C-d> (cmp.mapping.scroll_docs -4) (when details
:<C-f> (cmp.mapping.scroll_docs 4) (set vim-item.abbr (.. vim-item.abbr padding " " details))))
:<C-space> (cmp.mapping.complete) vim-item)
:<esc> #(do (cmp.mapping.close) (vim.cmd "stopinsert"))
:<CR> (cmp.mapping.confirm {:select true})})
:experimental {:custom_menu true}
:sources [{:name "nvim_lsp" :priority 5}
{:name "vsnip" :priority 3}
; {:name "omni"} ; this prints the completion thing, for some reason,....
{:name "nvim_lua"}
{:name "calc"}
{:name "path"}
{:name "nvim_lsp_signature_help"}
{:name "conventionalcommits"}
{:name "crates"}]
;{:name "buffer"}]
:formatting {:format item-formatter}
:sorting {:priority_weight 2
:comparators [#(do (if (and (= 15 ($1:get_kind)) (= 15 ($2:get_kind))) nil
(= 15 ($1:get_kind)) false
(= 15 ($2:get_kind)) true
nil)) ; 15 means "SNIPPET", see https://github.com/hrsh7th/nvim-cmp/blob/main/lua/cmp/types/lsp.lua
cmp.config.compare.offset
cmp.config.compare.exact
cmp.config.compare.score
cmp.config.compare.kind
cmp.config.compare.sort_text
cmp.config.compare.length
cmp.config.compare.order]}})
(cmp.setup.cmdline "/" {:sources [{:name :buffer}]})
(cmp.setup
{:snippet {:expand (fn [args] ((. vim.fn :vsnip#anonymous) args.body))}
:completion {:autocomplete false}
:mapping (cmp.mapping.preset.insert
{:<C-d> (cmp.mapping.scroll_docs -4)
:<C-f> (cmp.mapping.scroll_docs 4)
:<C-space> (cmp.mapping.complete)
:<esc> #(do (cmp.mapping.close) (vim.cmd "stopinsert"))
:<CR> (cmp.mapping.confirm {:select true})})
:experimental {:custom_menu true}
:sources [{:name "nvim_lsp" :priority 5}
{:name "vsnip" :priority 3}
; {:name "omni"} ; this prints the completion thing, for some reason,....
{:name "nvim_lua"}
{:name "calc"}
{:name "path"}
{:name "nvim_lsp_signature_help"}
{:name "conventionalcommits"}
{:name "crates"}]
;{:name "buffer"}]
:formatting {:format item-formatter}
:sorting {:priority_weight 2
:comparators [#(do (if (and (= 15 ($1:get_kind)) (= 15 ($2:get_kind))) nil
(= 15 ($1:get_kind)) false
(= 15 ($2:get_kind)) true
nil)) ; 15 means "SNIPPET", see https://github.com/hrsh7th/nvim-cmp/blob/main/lua/cmp/types/lsp.lua
cmp.config.compare.offset
cmp.config.compare.exact
cmp.config.compare.score
cmp.config.compare.kind
cmp.config.compare.sort_text
cmp.config.compare.length
cmp.config.compare.order]}})
(cmp.setup.cmdline "/" {:sources [{:name :buffer}]}))
[(utils.plugin :hrsh7th/vim-vsnip {:lazy true :event ["VeryLazy"]})
(utils.plugin :hrsh7th/vim-vsnip-integ {:lazy true :event ["VeryLazy"]})
(utils.plugin :rafamadriz/friendly-snippets)
(utils.plugin :hrsh7th/nvim-cmp {:lazy true
:event ["VeryLazy"]
:dependencies [[:hrsh7th/cmp-nvim-lsp]
[:hrsh7th/cmp-buffer]
[:hrsh7th/cmp-vsnip]
[:hrsh7th/cmp-nvim-lua]
[:hrsh7th/cmp-calc]
[:hrsh7th/cmp-path]
[:hrsh7th/cmp-nvim-lsp-signature-help]
[:davidsierradz/cmp-conventionalcommits]
[:hrsh7th/cmp-omni]]
:config setup})]

27
nvim/.config/nvim/fnl/dots/plugins/copilot.fnl
View file

@ -1,11 +1,18 @@
(module dots.plugins.copilot (import-macros {: al} :macros)
{autoload {copilot copilot} (al copilot copilot)
require-macros [macros]}) (al utils dots.utils)
(copilot.setup (fn setup []
{:panel {:enabled false} (copilot.setup
:suggestion {:enabled true {:panel {:enabled false}
:auto_trigger :true :suggestion {:enabled true
:keymap {:accept "<tab>" :auto_trigger :true
:next "<C-l><C-n>"}}}) :keymap {:accept "<tab>"
:next "<C-l><C-n>"}}}))
;:github/copilot.vim {:cmd ["Copilot"]}
;[(utils.plugin :zbirenbaum/copilot.lua
; {:cmd "Copilot"
; :event "InsertEnter"
; :config setup}}))
[]

21
nvim/.config/nvim/fnl/dots/plugins/crates.fnl
View file

@ -1,7 +1,18 @@
(module dots.plugins.crates (import-macros {: al} :macros)
{autoload {a aniseed.core
crates crates}}) (al utils dots.utils)
(al crates crates)
(fn setup []
(crates.setup {:disable_invalid_feature_diagnostic true
:enable_update_available_warning false}))
(crates.setup {:disable_invalid_feature_diagnostic true [(utils.plugin :Saecki/crates.nvim
:enable_update_available_warning false}) {:dependencies ["nvim-lua/plenary.nvim"]
:dir "/Users/leon/tmp/crates.nvim"
:event ["BufRead Cargo.toml"]
:lazy true
:config setup})]

27
nvim/.config/nvim/fnl/dots/plugins/diffview.fnl
View file

@ -1,11 +1,18 @@
(module dots.plugins.diffview (import-macros m :macros)
{autoload {diffview diffview (m.al diffview diffview)
cb diffview.config}}) (m.al cb diffview.config)
(m.al utils dots.utils)
(fn setup []
(diffview.setup
{:diff_binaries false
:file_panel {:width 35
:use_icons false}
:key_bindings {:view {:<leader>dn (cb.diffview_callback "select_next_entry")
:<leader>dp (cb.diffview_callback "select_prev_entry")
:<leader>dd (cb.diffview_callback "toggle_files")}}}))
[(utils.plugin
:sindrets/diffview.nvim
{:cmd ["DiffviewOpen" "DiffviewToggleFiles"]
:config #setup})]
(diffview.setup
{:diff_binaries false
:file_panel {:width 35
:use_icons false}
:key_bindings {:view {:<leader>dn (cb.diffview_callback "select_next_entry")
:<leader>dp (cb.diffview_callback "select_prev_entry")
:<leader>dd (cb.diffview_callback "toggle_files")}}})

3
nvim/.config/nvim/fnl/dots/plugins/emmet.fnl
View file

@ -1,7 +1,8 @@
(module dots.plugins.emmet {}) (import-macros m :macros)
(set vim.g.user_emmet_mode "n") (set vim.g.user_emmet_mode "n")
(set vim.g.user_emmet_leader_key "<leader>e") (set vim.g.user_emmet_leader_key "<leader>e")
(set vim.g.user_emmet_settings {:javascript.jsx {:extends "jsx"} (set vim.g.user_emmet_settings {:javascript.jsx {:extends "jsx"}
:typescript.jsx {:extends "jsx"}}) :typescript.jsx {:extends "jsx"}})
[]

55
nvim/.config/nvim/fnl/dots/plugins/feline.fnl
View file

@ -1,15 +1,13 @@
(module dots.plugins.feline (import-macros m :macros)
{autoload {a aniseed.core (m.al a nfnl.core)
nvim aniseed.nvim (m.al utils dots.utils)
utils dots.utils (m.al str nfnl.string)
str aniseed.string (m.al colors dots.colors)
colors dots.colors (m.al feline feline)
view aniseed.view (m.al feline-git feline.providers.git)
feline feline (m.al feline-lsp feline.providers.lsp)
feline-git feline.providers.git
feline-lsp feline.providers.lsp}
require-macros [macros]})
(fn setup [])
(set vim.opt.termguicolors true) (set vim.opt.termguicolors true)
(local modes (local modes
@ -31,31 +29,31 @@
:V {:text "VISUAL LINE" :color colors.neutral_blue} :V {:text "VISUAL LINE" :color colors.neutral_blue}
"" {:text "VISUAL BLOCK" :color colors.neutral_blue}}) "" {:text "VISUAL BLOCK" :color colors.neutral_blue}})
(def bar-bg colors.bg_main) (local bar-bg colors.bg_main)
(def horiz-separator-color colors.light1) (local horiz-separator-color colors.light1)
(defn or-empty [x] (or x "")) (fn or-empty [x] (or x ""))
(defn spaces [x] (if x (.. " " x " ") "")) (fn spaces [x] (if x (.. " " x " ") ""))
(defn get-current-filepath [] (fn get-current-filepath []
(let [file (utils.shorten-path (vim.fn.bufname) 30 30)] (let [file (utils.shorten-path (vim.fn.bufname) 30 30)]
(if (a.empty? file) "" (if (a.empty? file) ""
nvim.bo.readonly (.. "RO " file) vim.bo.readonly (.. "RO " file)
(and nvim.bo.modifiable nvim.bo.modified) (.. file " ●") (and vim.bo.modifiable vim.bo.modified) (.. file " ●")
(.. file " ")))) (.. file " "))))
(defn vim-mode-hl [use-as-fg?] (fn vim-mode-hl [use-as-fg?]
(let [color (. modes (vim.fn.mode) :color)] (let [color (. modes (vim.fn.mode) :color)]
(if use-as-fg? {:bg bar-bg :fg color} {:bg color :fg bar-bg}))) (if use-as-fg? {:bg bar-bg :fg color} {:bg color :fg bar-bg})))
(defn git-status-provider [] (fn git-status-provider []
(or-empty (utils.keep-if #(~= "master" $1) (or-empty (utils.keep-if #(~= "master" $1)
(?. vim.b :gitsigns_status_dict :head)))) (?. vim.b :gitsigns_status_dict :head))))
(defn vim-mode [] (fn vim-mode []
(.. " " (or (. modes (vim.fn.mode) :text) vim.fn.mode) " ")) (.. " " (or (. modes (vim.fn.mode) :text) vim.fn.mode) " "))
(defn lsp-progress-provider [] (fn lsp-progress-provider []
(let [msgs (vim.lsp.util.get_progress_messages) (let [msgs (vim.lsp.util.get_progress_messages)
s (icollect [_ msg (ipairs msgs)] s (icollect [_ msg (ipairs msgs)]
(when msg.message (when msg.message
@ -64,25 +62,25 @@
(defn lsp-diagnostic-component [kind color] (fn lsp-diagnostic-component [kind color]
{:enabled #(~= 0 (length (vim.diagnostic.get 0 {:severity kind}))) {:enabled #(~= 0 (length (vim.diagnostic.get 0 {:severity kind})))
:provider #(spaces (length (vim.diagnostic.get 0 {:severity kind}))) :provider #(spaces (length (vim.diagnostic.get 0 {:severity kind})))
:left_sep "" :left_sep ""
:right_sep "" :right_sep ""
:hl {:fg bar-bg :bg color}}) :hl {:fg bar-bg :bg color}})
(defn coordinates [] (fn coordinates []
(let [[line col] (vim.api.nvim_win_get_cursor 0)] (let [[line col] (vim.api.nvim_win_get_cursor 0)]
(.. " " line " "))) (.. " " line " ")))
; Fills the bar with an horizontal line ; Fills the bar with an horizontal line
(defn inactive-separator-provider [] (fn inactive-separator-provider []
(if (not= (vim.fn.winnr) (vim.fn.winnr :j)) (if (not= (vim.fn.winnr) (vim.fn.winnr :j))
(string.rep "─" (vim.api.nvim_win_get_width 0)) (string.rep "─" (vim.api.nvim_win_get_width 0))
"")) ""))
(def components {:active {} :inactive {}}) (local components {:active {} :inactive {}})
(tset components.active 1 (tset components.active 1
[{:provider vim-mode :hl #(vim-mode-hl false)} [{:provider vim-mode :hl #(vim-mode-hl false)}
@ -114,3 +112,4 @@
(feline.setup {:theme {:fg colors.light1 :bg colors.bg_main} (feline.setup {:theme {:fg colors.light1 :bg colors.bg_main}
:components components}) :components components})
[(utils.plugin :Famiu/feline.nvim {:config setup})]

41
nvim/.config/nvim/fnl/dots/plugins/gitsigns.fnl
View file

@ -1,20 +1,27 @@
(module dots.plugins.gitsigns (import-macros m :macros)
{autoload {utils dots.utils (m.al utils dots.utils)
colors dots.colors (m.al colors dots.colors)
gitsigns gitsigns}}) (m.al gitsigns gitsigns)
; https://github.com/lewis6991/gitsigns.nvim (fn setup []
(gitsigns.setup (gitsigns.setup
{:signs {:add {:text "▍"} {:signs {:add {:text "▍"}
:change {:text "▍"} :change {:text "▍"}
:delete {:text "▍"} :delete {:text "▍"}
:topdelete {:text "▍"} :topdelete {:text "▍"}
:changedelete {:text "▍"}} :changedelete {:text "▍"}}
:keymaps {:noremap true ; :keymaps {:noremap true
:buffer true} ; :buffer true}
:current_line_blame false :current_line_blame false
:update_debounce 100}) :update_debounce 100})
(let [scrollbar-gitsigns (require "scrollbar.handlers.gitsigns")] (let [scrollbar-gitsigns (require "scrollbar.handlers.gitsigns")]
(scrollbar-gitsigns.setup)) (scrollbar-gitsigns.setup)))
[(utils.plugin
:lewis6991/gitsigns.nvim
{:dependencies [:vim-gruvbox8
:petertriho/nvim-scrollbar]
:config setup})]

11
nvim/.config/nvim/fnl/dots/plugins/glance.fnl
View file

@ -1,5 +1,8 @@
(module dots.plugins.glance (import-macros m :macros)
{autoload {a aniseed.core (m.al a aniseed.core)
glance glance}}) (m.al glance glance)
(m.al utils dots.utils)
(glance.setup) [(utils.plugin
:dnlhc/glance.nvim
{:lazy true :config #(glance.setup)})]

225
nvim/.config/nvim/fnl/dots/plugins/gruvbox8.fnl
View file

@ -1,144 +1,145 @@
(module dots.plugins.gruvbox8 (import-macros {: al} :macros)
{autoload {utils dots.utils (al utils dots.utils)
colors dots.colors} (al colors dots.colors)
require-macros [macros]})
(set vim.g.gruvbox_italics 0)
(set vim.g.gruvbox_italicise_strings 0) (fn setup []
(set vim.g.gruvbox_filetype_hi_groups 1) (set vim.g.gruvbox_italics 0)
(set vim.g.gruvbox_plugin_hi_groups 1) (set vim.g.gruvbox_italicise_strings 0)
(set vim.g.gruvbox_filetype_hi_groups 1)
(set vim.g.gruvbox_plugin_hi_groups 1)
(defn- setup-colors [] (fn setup-colors []
(utils.highlight-add (utils.highlight-add
["GruvboxBlueSign" "GruvboxAquaSign" "GruvboxRedSign" "GruvboxYellowSign" "GruvboxGreenSign" "GruvboxOrangeSign" "GruvboxPurpleSign"] ["GruvboxBlueSign" "GruvboxAquaSign" "GruvboxRedSign" "GruvboxYellowSign" "GruvboxGreenSign" "GruvboxOrangeSign" "GruvboxPurpleSign"]
{:bg "NONE"}) {:bg "NONE"})
; hide empty line ~'s ; hide empty line ~'s
(utils.highlight :EndOfBuffer {:bg "NONE" :fg colors.bg_main}) (utils.highlight :EndOfBuffer {:bg "NONE" :fg colors.bg_main})
(utils.highlight :LineNr {:bg "NONE"}) (utils.highlight :LineNr {:bg "NONE"})
(utils.highlight-add :Pmenu {:bg colors.bg_second}) (utils.highlight-add :Pmenu {:bg colors.bg_second})
(utils.highlight-add :PmenuSel {:bg colors.bright_aqua}) (utils.highlight-add :PmenuSel {:bg colors.bright_aqua})
(utils.highlight-add :PmenuSbar {:bg colors.bg_second}) (utils.highlight-add :PmenuSbar {:bg colors.bg_second})
(utils.highlight-add :PmenuThumb {:bg colors.dark1}) (utils.highlight-add :PmenuThumb {:bg colors.dark1})
(utils.highlight-add :NormalFloat {:bg colors.bg_second}) (utils.highlight-add :NormalFloat {:bg colors.bg_second})
(utils.highlight-add :SignColumn {:bg colors.bg_main}) (utils.highlight-add :SignColumn {:bg colors.bg_main})
(utils.highlight-add :FloatBorder {:bg colors.bg_second}) (utils.highlight-add :FloatBorder {:bg colors.bg_second})
(utils.highlight-add :SpecialComment {:fg colors.dark4}) (utils.highlight-add :SpecialComment {:fg colors.dark4})
(utils.highlight-add (utils.highlight-add
[:LspDiagnosticsSignError :LspDiagnosticsSignWarning :LspDiagnosticsSignInformation :LspDiagnosticsSignHint] [:LspDiagnosticsSignError :LspDiagnosticsSignWarning :LspDiagnosticsSignInformation :LspDiagnosticsSignHint]
{:bg "NONE"}) {:bg "NONE"})
(utils.highlight-add :DiagnosticError {:fg colors.bright_red}) (utils.highlight-add :DiagnosticError {:fg colors.bright_red})
(utils.highlight-add :DiagnosticWarning {:fg colors.bright_orange}) (utils.highlight-add :DiagnosticWarning {:fg colors.bright_orange})
(utils.highlight-add :DiagnosticInformation {:fg colors.bright_aqua}) (utils.highlight-add :DiagnosticInformation {:fg colors.bright_aqua})
(utils.highlight-add :DiagnosticHint {:fg colors.bright_yellow}) (utils.highlight-add :DiagnosticHint {:fg colors.bright_yellow})
(utils.highlight-add :DiagnosticVirtualTextError {:bg "#342828" :fg colors.bright_red}) (utils.highlight-add :DiagnosticVirtualTextError {:bg "#342828" :fg colors.bright_red})
(utils.highlight-add :DiagnosticVirtualTextWarning {:bg "#473027" :fg colors.bright_orange}) (utils.highlight-add :DiagnosticVirtualTextWarning {:bg "#473027" :fg colors.bright_orange})
(utils.highlight-add :DiagnosticVirtualTextWarning {:bg "#3b2c28" :fg colors.bright_orange}) (utils.highlight-add :DiagnosticVirtualTextWarning {:bg "#3b2c28" :fg colors.bright_orange})
(utils.highlight-add :DiagnosticVirtualTextInformation {:bg "#272d2f" :fg colors.bright_aqua}) (utils.highlight-add :DiagnosticVirtualTextInformation {:bg "#272d2f" :fg colors.bright_aqua})
(utils.highlight-add :DiagnosticVirtualTextHint {:bg "#272d2f" :fg colors.bright_yellow}) (utils.highlight-add :DiagnosticVirtualTextHint {:bg "#272d2f" :fg colors.bright_yellow})
(utils.highlight :LspDiagnosticsUnderlineError {:gui "undercurl"}) (utils.highlight :LspDiagnosticsUnderlineError {:gui "undercurl"})
(vim.fn.sign_define :LspDiagnosticsSignError {:text "◆"}) ;(vim.fn.sign_localine :LspDiagnosticsSignError {:text "◆"})
(vim.fn.sign_define :LspDiagnosticsSignWarning {:text "◆"}) ;(vim.fn.sign_localine :LspDiagnosticsSignWarning {:text "◆"})
(vim.fn.sign_define :LspDiagnosticsSignHint {:text "◆"}) ;(vim.fn.sign_localine :LspDiagnosticsSignHint {:text "◆"})
(vim.fn.sign_define :LspDiagnosticsSignInformation {:text "◆"}) ;(vim.fn.sign_localine :LspDiagnosticsSignInformation {:text "◆"})
(utils.highlight :StatusLine {:bg colors.dark1 :fg colors.light0}) (utils.highlight :StatusLine {:bg colors.dark1 :fg colors.light0})
(vim.cmd "highlight link Function GruvboxGreen") (vim.cmd "highlight link Function GruvboxGreen")
(utils.highlight-add :Function {:gui "NONE"})) (utils.highlight-add :Function {:gui "NONE"}))
(defn setup-telescope-theme [] (fn setup-telescope-theme []
(def prompt "blacker") (local prompt "blacker")
(if (if
(= prompt "bright") (= prompt "bright")
(let [promptbg "#689d6a"] (let [promptbg "#689d6a"]
(utils.highlight-add :TelescopePromptBorder {:bg promptbg :fg promptbg}) (utils.highlight-add :TelescopePromptBorder {:bg promptbg :fg promptbg})
(utils.highlight-add :TelescopePromptNormal {:bg promptbg :fg colors.bg_main}) (utils.highlight-add :TelescopePromptNormal {:bg promptbg :fg colors.bg_main})
(utils.highlight-add :TelescopePromptTitle {:bg promptbg :fg colors.dark1})) (utils.highlight-add :TelescopePromptTitle {:bg promptbg :fg colors.dark1}))
(= prompt "dark") (= prompt "dark")
(let [promptbg "#252525"] (let [promptbg "#252525"]
(utils.highlight-add :TelescopePromptBorder {:bg promptbg :fg promptbg}) (utils.highlight-add :TelescopePromptBorder {:bg promptbg :fg promptbg})
(utils.highlight-add :TelescopePromptNormal {:bg promptbg :fg colors.light2}) (utils.highlight-add :TelescopePromptNormal {:bg promptbg :fg colors.light2})
(utils.highlight-add :TelescopePromptPrefix {:bg promptbg :fg colors.neutral_aqua}) (utils.highlight-add :TelescopePromptPrefix {:bg promptbg :fg colors.neutral_aqua})
(utils.highlight-add :TelescopePromptTitle {:bg colors.neutral_blue :fg colors.dark1})) (utils.highlight-add :TelescopePromptTitle {:bg colors.neutral_blue :fg colors.dark1}))
(= prompt "black") (= prompt "black")
(let [promptbg "#212526"] (let [promptbg "#212526"]
(utils.highlight-add :TelescopePromptBorder {:bg promptbg :fg promptbg}) (utils.highlight-add :TelescopePromptBorder {:bg promptbg :fg promptbg})
(utils.highlight-add :TelescopePromptNormal {:bg promptbg :fg colors.light2}) (utils.highlight-add :TelescopePromptNormal {:bg promptbg :fg colors.light2})
(utils.highlight-add :TelescopePromptPrefix {:bg promptbg :fg colors.neutral_aqua}) (utils.highlight-add :TelescopePromptPrefix {:bg promptbg :fg colors.neutral_aqua})
(utils.highlight-add :TelescopePromptTitle {:bg colors.neutral_green :fg colors.dark1})) (utils.highlight-add :TelescopePromptTitle {:bg colors.neutral_green :fg colors.dark1}))
(= prompt "blacker") (= prompt "blacker")
(let [promptbg "#1f2324"] (let [promptbg "#1f2324"]
(utils.highlight-add :TelescopePromptBorder {:bg promptbg :fg promptbg}) (utils.highlight-add :TelescopePromptBorder {:bg promptbg :fg promptbg})
(utils.highlight-add :TelescopePromptNormal {:bg promptbg :fg colors.light2}) (utils.highlight-add :TelescopePromptNormal {:bg promptbg :fg colors.light2})
(utils.highlight-add :TelescopePromptPrefix {:bg promptbg :fg colors.neutral_aqua}) (utils.highlight-add :TelescopePromptPrefix {:bg promptbg :fg colors.neutral_aqua})
(utils.highlight-add :TelescopePromptTitle {:bg colors.neutral_blue :fg colors.dark1}))) (utils.highlight-add :TelescopePromptTitle {:bg colors.neutral_blue :fg colors.dark1})))
(def side "darker") (local side "darker")
(if (if
(= side "brighter") (= side "brighter")
(let [previewbg "#1f2324"] (let [previewbg "#1f2324"]
(utils.highlight-add :TelescopePreviewNormal {:bg previewbg}) (utils.highlight-add :TelescopePreviewNormal {:bg previewbg})
(utils.highlight-add :TelescopePreviewBorder {:bg previewbg :fg previewbg})) (utils.highlight-add :TelescopePreviewBorder {:bg previewbg :fg previewbg}))
(= side "darker") (= side "darker")
(let [previewbg "#1a1e1f"] (let [previewbg "#1a1e1f"]
(utils.highlight-add :TelescopePreviewNormal {:bg previewbg}) (utils.highlight-add :TelescopePreviewNormal {:bg previewbg})
(utils.highlight-add :TelescopePreviewBorder {:bg previewbg :fg previewbg}))) (utils.highlight-add :TelescopePreviewBorder {:bg previewbg :fg previewbg})))
(utils.highlight-add :TelescopeBorder {:bg colors.bg_second :fg colors.bg_second}) (utils.highlight-add :TelescopeBorder {:bg colors.bg_second :fg colors.bg_second}) (utils.highlight-add :TelescopeNormal {:bg colors.bg_second})
(utils.highlight-add :TelescopeNormal {:bg colors.bg_second}) (utils.highlight-add :TelescopePreviewTitle {:bg colors.neutral_green :fg colors.dark1})
(utils.highlight-add :TelescopePreviewTitle {:bg colors.neutral_green :fg colors.dark1}) (utils.highlight-add :TelescopeResultsTitle {:bg colors.neutral_aqua :fg colors.dark1})
(utils.highlight-add :TelescopeResultsTitle {:bg colors.neutral_aqua :fg colors.dark1})
(utils.highlight-add :TelescopeSelection {:bg colors.neutral_aqua :fg colors.dark1})) (utils.highlight-add :TelescopeSelection {:bg colors.neutral_aqua :fg colors.dark1}))
(defn- setup-noice-theme [] (fn setup-noice-theme []
(utils.highlight-add :NoicePopupmenu {:bg colors.bg_second}) (utils.highlight-add :NoicePopupmenu {:bg colors.bg_second})
(utils.highlight-add :NoiceCmdline {:bg "#1f2324"}) (utils.highlight-add :NoiceCmdline {:bg "#1f2324"})
(utils.highlight-add :NoiceCmdlinePopup {:bg "#1f2324"}) (utils.highlight-add :NoiceCmdlinePopup {:bg "#1f2324"})
(utils.highlight-add :NoiceCmdlinePrompt {:bg "#1f2324"}) (utils.highlight-add :NoiceCmdlinePrompt {:bg "#1f2324"})
(utils.highlight-add :NoiceCmdlinePopupBorder {:fg colors.bright_aqua}) (utils.highlight-add :NoiceCmdlinePopupBorder {:fg colors.bright_aqua})
(utils.highlight-add :NoiceCmdlineIcon {:fg colors.bright_aqua})) (utils.highlight-add :NoiceCmdlineIcon {:fg colors.bright_aqua}))
(vim.api.nvim_create_autocmd "ColorScheme" {:pattern "*" :callback setup-colors}) (vim.api.nvim_create_autocmd "ColorScheme" {:pattern "*" :callback setup-colors})
(setup-colors) (setup-colors)
(vim.api.nvim_create_autocmd "ColorScheme" {:pattern "*" :callback setup-telescope-theme}) (vim.api.nvim_create_autocmd "ColorScheme" {:pattern "*" :callback setup-telescope-theme})
(setup-telescope-theme) (setup-telescope-theme)
(vim.api.nvim_create_autocmd "ColorScheme" {:pattern "*" :callback setup-noice-theme}) (vim.api.nvim_create_autocmd "ColorScheme" {:pattern "*" :callback setup-noice-theme})
(setup-noice-theme) (setup-noice-theme)
(vim.api.nvim_create_autocmd (vim.api.nvim_create_autocmd
"ColorScheme" "ColorScheme"
{:pattern "*" {:pattern "*"
:callback :callback
(fn [] (fn []
(utils.highlight-add "GitSignsAdd" {:gui "NONE" :bg "NONE" :fg colors.bright_aqua}) (utils.highlight-add "GitSignsAdd" {:gui "NONE" :bg "NONE" :fg colors.bright_aqua})
(utils.highlight-add "GitSignsDelete" {:gui "NONE" :bg "NONE" :fg colors.neutral_red}) (utils.highlight-add "GitSignsDelete" {:gui "NONE" :bg "NONE" :fg colors.neutral_red})
(utils.highlight-add "GitSignsChange" {:gui "NONE" :bg "NONE" :fg colors.bright_blue}) (utils.highlight-add "GitSignsChange" {:gui "NONE" :bg "NONE" :fg colors.bright_blue})
(utils.highlight-add "ScrollbarGitAdd" {:gui "NONE" :bg "NONE" :fg colors.bright_aqua}) (utils.highlight-add "ScrollbarGitAdd" {:gui "NONE" :bg "NONE" :fg colors.bright_aqua})
(utils.highlight-add "ScrollbarGitDelete" {:gui "NONE" :bg "NONE" :fg colors.neutral_red}) (utils.highlight-add "ScrollbarGitDelete" {:gui "NONE" :bg "NONE" :fg colors.neutral_red})
(utils.highlight-add "ScrollbarGitChange" {:gui "NONE" :bg "NONE" :fg colors.bright_blue}))}) (utils.highlight-add "ScrollbarGitChange" {:gui "NONE" :bg "NONE" :fg colors.bright_blue}))})
(if (= "epix" (vim.fn.hostname)) (if (= "epix" (vim.fn.hostname))
(vim.cmd "colorscheme gruvbox8_hard") (vim.cmd "colorscheme gruvbox8_hard")
(vim.cmd "colorscheme gruvbox8")) (vim.cmd "colorscheme gruvbox8")))
[(utils.plugin :lifepillar/vim-gruvbox8 {:lazy false :priority 1000 :config setup})]

458
nvim/.config/nvim/fnl/dots/plugins/lsp.fnl
View file

@ -1,259 +1,269 @@
(module dots.plugins.lsp (import-macros {: al} :macros)
{autoload {a aniseed.core (al a aniseed.core)
str aniseed.string (al str aniseed.string)
lsp lspconfig (al lsp lspconfig)
lsp-configs lspconfig/configs (al lsp-configs lspconfig/configs)
utils dots.utils (al utils dots.utils)
ltex-ls dots.plugins.ltex-ls (al ltex-ls dots.plugins.ltex-ls)
cmp_nvim_lsp cmp_nvim_lsp} (al cmp_nvim_lsp cmp_nvim_lsp)
require-macros [macros]}) (fn setup []
; TODO check https://github.com/neovim/nvim-lspconfig/blob/master/ADVANCED_README.md for default config for all of them
; TODO check https://github.com/neovim/nvim-lspconfig/blob/master/ADVANCED_README.md for default config for all of them (tset vim.lsp.handlers :textDocument/publishDiagnostics
(vim.lsp.with vim.lsp.diagnostic.on_publish_diagnostics
(tset vim.lsp.handlers :textDocument/publishDiagnostics {:update_in_insert false
(vim.lsp.with vim.lsp.diagnostic.on_publish_diagnostics :virtual_text {:prefix "◆"}
{:update_in_insert false :signs false
:virtual_text {:prefix "◆"} :severity_sort true}))
:signs false
:severity_sort true}))
(fn on_attach [client bufnr] (fn on_attach [client bufnr]
;(pkg lsp_signature.nvim [lsp_signature (require "lsp_signature")] ;(pkg lsp_signature.nvim [lsp_signature (require "lsp_signature")]
;(lsp_signature.on_attach {:bind true ;(lsp_signature.on_attach {:bind true
;:hint_scheme "String" ;:hint_scheme "String"
;:hint_prefix "ƒ " ;:hint_prefix "ƒ "
;:handler_opts {:border "single"} ;:handler_opts {:border "single"}
;:use_lspsaga false ;:use_lspsaga false
;:decorator ["`" "`"]})) ;:decorator ["`" "`"]}))
;(req dots.utils.highlight :LspDiagnosticsUnderlineError {:gui "underline"}) ;(req dots.utils.highlight :LspDiagnosticsUnderlineError {:gui "underline"})
(if client.server_capabilities.documentHighlight (if client.server_capabilities.documentHighlight
(do (do
(utils.highlight "LspReferenceRead" {:gui "underline"}) (utils.highlight "LspReferenceRead" {:gui "underline"})
(utils.highlight "LspReferenceText" {:gui "underline"}) (utils.highlight "LspReferenceText" {:gui "underline"})
(utils.highlight "LspReferenceWrite" {:gui "underline"}) (utils.highlight "LspReferenceWrite" {:gui "underline"})
(vim.api.nvim_exec (vim.api.nvim_exec
"augroup lsp_document_highlight "augroup lsp_document_highlight
autocmd! * <buffer> autocmd! * <buffer>
autocmd CursorHold <buffer> lua vim.lsp.buf.document_highlight() autocmd CursorHold <buffer> lua vim.lsp.buf.document_highlight()
autocmd CursorMoved <buffer> lua vim.lsp.buf.clear_references() autocmd CursorMoved <buffer> lua vim.lsp.buf.clear_references()
augroup END" augroup END"
false)))) false))))
(fn better_root_pattern [patterns except-patterns] (fn better_root_pattern [patterns except-patterns]
"match path if one of the given patterns is matched, EXCEPT if one of the except-patterns is matched" "match path if one of the given patterns is matched, EXCEPT if one of the except-patterns is matched"
(fn [path] (fn [path]
(when (not ((lsp.util.root_pattern except-patterns) path)) (when (not ((lsp.util.root_pattern except-patterns) path))
((lsp.util.root_pattern patterns) path)))) ((lsp.util.root_pattern patterns) path))))
; advertise snippet support ; advertise snippet support
(def default-capabilities (def default-capabilities
(let [capabilities (vim.lsp.protocol.make_client_capabilities)] (let [capabilities (vim.lsp.protocol.make_client_capabilities)]
(set capabilities.textDocument.completion.completionItem.snippetSupport true) (set capabilities.textDocument.completion.completionItem.snippetSupport true)
(cmp_nvim_lsp.default_capabilities capabilities))) (cmp_nvim_lsp.default_capabilities capabilities)))
(fn init-lsp [lsp-name ?opts] (fn init-lsp [lsp-name ?opts]
"initialize a language server with defaults" "initialize a language server with defaults"
(let [merged-opts (a.merge {:on_attach on_attach :capabilities default-capabilities} (or ?opts {}))] (let [merged-opts (a.merge {:on_attach on_attach :capabilities default-capabilities} (or ?opts {}))]
((. lsp lsp-name :setup) merged-opts))) ((. lsp lsp-name :setup) merged-opts)))
(init-lsp :jsonls {:commands {:Format [ #(vim.lsp.buf.range_formatting [] [0 0] [(vim.fn.line "$") 0])]}}) (init-lsp :jsonls {:commands {:Format [ #(vim.lsp.buf.range_formatting [] [0 0] [(vim.fn.line "$") 0])]}})
(init-lsp :denols {:root_dir (better_root_pattern [".git"] ["package.json"])}) (init-lsp :denols {:root_dir (better_root_pattern [".git"] ["package.json"])})
(init-lsp :hls {:settings {:languageServerHaskell {:formattingProvider "stylish-haskell"}}}) (init-lsp :hls {:settings {:languageServerHaskell {:formattingProvider "stylish-haskell"}}})
(init-lsp :ocamllsp) (init-lsp :ocamllsp)
(init-lsp :vimls) (init-lsp :vimls)
(init-lsp :gopls) (init-lsp :gopls)
(init-lsp :bashls) (init-lsp :bashls)
(init-lsp :erlangls) (init-lsp :erlangls)
(init-lsp :yamlls) (init-lsp :yamlls)
(init-lsp :html) (init-lsp :html)
(init-lsp :svelte) (init-lsp :svelte)
(init-lsp :elmls) (init-lsp :elmls)
(init-lsp :texlab) (init-lsp :texlab)
(init-lsp :pyright) (init-lsp :pyright)
;(init-lsp :ltex {:settings {:ltex {:dictionary {:de-DE [":~/.config/ltex-ls/dictionary.txt"]} ;(init-lsp :ltex {:settings {:ltex {:dictionary {:de-DE [":~/.config/ltex-ls/dictionary.txt"]}
;:disabledRules {:de-DE [":~/.config/ltex-ls/disabledRules.txt"]} ;:disabledRules {:de-DE [":~/.config/ltex-ls/disabledRules.txt"]}
;:hiddenFalsePositives {:de-DE [":~/.config/ltex-ls/hiddenFalsePositives.txt"]} ;:hiddenFalsePositives {:de-DE [":~/.config/ltex-ls/hiddenFalsePositives.txt"]}
;:additionalRules {:motherTongue "de-DE"}}}}) ;:additionalRules {:motherTongue "de-DE"}}}})
(init-lsp :vls) (init-lsp :vls)
;(init-lsp :clangd) ;(init-lsp :clangd)
;(init-lsp :ccls) ;(init-lsp :ccls)
(init-lsp :perlls) (init-lsp :perlls)
(init-lsp :powershell_es {:bundle_path "/home/leon/powershell"})
;(ltex-ls.init)
(init-lsp :clangd)
(init-lsp :powershell_es {:bundle_path "/home/leon/powershell"})
;(ltex-ls.init) (init-lsp :cssls {:filestypes ["css" "scss" "less" "stylus"]
:root_dir (lsp.util.root_pattern ["package.json" ".git"])
:settings {:css {:validate true}
:less {:validate true}
:scss {:validate true}}})
(lsp.tsserver.setup {:root_dir (lsp.util.root_pattern "package.json")
:on_attach (fn [client bufnr]
(set client.resolved_capabilities.document_formatting false)
(on_attach client bufnr))})
(init-lsp :clangd) (let [rust-tools (require "rust-tools")
rust-tools-dap (require "rust-tools.dap")
extension-path "/home/leon/.vscode/extensions/vadimcn.vscode-lldb-1.6.8/"
codelldb-path (.. extension-path "adapter/codelldb")
liblldb-path (.. extension-path "lldb/lib/liblldb.so")
features nil]
(rust-tools.setup {:tools {:inlay_hints {:show_parameter_hints false}
;:auto false}
:autoSetHints false}
:dap {:adapter (rust-tools-dap.get_codelldb_adapter codelldb-path liblldb-path)}
:server {:on_attach on_attach
:capabilities default-capabilities
:settings {:rust-analyzer {:cargo {:loadOutDirsFromCheck true
:features (or features "all")
:noDefaultFeatures (~= nil features)}
:procMacro {:enable true}
:diagnostics {:enable false ;; native rust analyzer diagnostics
:experimental {:enable false}}
:checkOnSave {:overrideCommand ["cargo" "clippy" "--workspace" "--message-format=json" "--all-targets" "--all-features"]}}}}}))
;:cmd ["/home/leon/coding/prs/rust-analyzer/target/release/rust-analyzer"]}}))
(when (not lsp.fennel_language_server)
(tset lsp-configs :fennel_language_server
{:default_config {:cmd "/Users/leon/.cargo/bin/fennel-language-server"
:filetypes [:fennel]
:single_file_support true
:root_dir (lsp.util.root_pattern "fnl")
:settings {:fennel {:workspace {:library (vim.api.nvim_list_runtime_paths)}
:diagnostics {:globals [:vim]}}}}}))
(init-lsp :fennel_language_server)
;
;
; (let [sumneko_root_path (.. vim.env.HOME "/.local/share/lua-language-server")
(init-lsp :cssls {:filestypes ["css" "scss" "less" "stylus"] ; sumneko_binary (.. sumneko_root_path "/bin/Linux/lua-language-server"))
:root_dir (lsp.util.root_pattern ["package.json" ".git"]) ; (init-lsp
:settings {:css {:validate true} ; :lua_ls
:less {:validate true} ; {:cmd [sumneko_binary "-E" (.. sumneko_root_path "/main.lua")]
:scss {:validate true}}}) ; :settings {:Lua {:runtime {:version "LuaJIT"
; :path (vim.split package.path ";")}
; :diagnostics {:globals ["vim"]}
; :workspace {:library {(vim.fn.expand "$VIMRUNTIME/lua") true
; (vim.fn.expand "$VIMRUNTIME/lua/vim/lsp") true}}
; :telemetry false}}}))
(lsp.tsserver.setup {:root_dir (lsp.util.root_pattern "package.json") (comment
:on_attach (fn [client bufnr] (when (not lsp.prolog_lsp)
(set client.resolved_capabilities.document_formatting false) (tset lsp-configs :prolog_lsp
(on_attach client bufnr))}) {:default_config {:cmd ["swipl" "-g" "use_module(library(lsp_server))." "-g" "lsp_server:main" "-t" "halt" "--" "stdio"]
:filetypes ["prolog"]
:root_dir (fn [fname] (or (lsp.util.find_git_ancestor fname) (vim.loop.os_homedir)))
:settings {}}}))
(let [rust-tools (require "rust-tools") (lsp.prolog_lsp.setup {}))
rust-tools-dap (require "rust-tools.dap")
extension-path "/home/leon/.vscode/extensions/vadimcn.vscode-lldb-1.6.8/"
codelldb-path (.. extension-path "adapter/codelldb")
liblldb-path (.. extension-path "lldb/lib/liblldb.so")
features nil]
(rust-tools.setup {:tools {:inlay_hints {:show_parameter_hints false}
;:auto false}
:autoSetHints false}
:dap {:adapter (rust-tools-dap.get_codelldb_adapter codelldb-path liblldb-path)}
:server {:on_attach on_attach
:capabilities default-capabilities
:settings {:rust-analyzer {:cargo {:loadOutDirsFromCheck true
:features (or features "all")
:noDefaultFeatures (~= nil features)}
:procMacro {:enable true}
:diagnostics {:enable false ;; native rust analyzer diagnostics
:experimental {:enable false}}
:checkOnSave {:overrideCommand ["cargo" "clippy" "--workspace" "--message-format=json" "--all-targets" "--all-features"]}}}}}))
;:cmd ["/home/leon/coding/prs/rust-analyzer/target/release/rust-analyzer"]}}))
; (let [sumneko_root_path (.. vim.env.HOME "/.local/share/lua-language-server") (comment
; sumneko_binary (.. sumneko_root_path "/bin/Linux/lua-language-server")) (let [ewwls-path "/home/leon/coding/projects/ls-eww/crates/ewwls/target/debug/ewwls"]
; (init-lsp (when (vim.fn.filereadable ewwls-path)
; :lua_ls (when (not lsp.ewwls)
; {:cmd [sumneko_binary "-E" (.. sumneko_root_path "/main.lua")] (set lsp-configs.ewwls
; :settings {:Lua {:runtime {:version "LuaJIT" {:default_config {:cmd [ewwls-path]
; :path (vim.split package.path ";")} :filetypes ["yuck"]
; :diagnostics {:globals ["vim"]} :root_dir (fn [fname] (or (lsp.util.find_git_ancestor fname) (vim.loop.os_homedir)))
; :workspace {:library {(vim.fn.expand "$VIMRUNTIME/lua") true :settings {}}}))
; (vim.fn.expand "$VIMRUNTIME/lua/vim/lsp") true}} (init-lsp :ewwls))))
; :telemetry false}}}))
(comment
(when (not lsp.prolog_lsp)
(tset lsp-configs :prolog_lsp
{:default_config {:cmd ["swipl" "-g" "use_module(library(lsp_server))." "-g" "lsp_server:main" "-t" "halt" "--" "stdio"]
:filetypes ["prolog"]
:root_dir (fn [fname] (or (lsp.util.find_git_ancestor fname) (vim.loop.os_homedir)))
:settings {}}}))
(lsp.prolog_lsp.setup {}))
(comment
(let [ewwls-path "/home/leon/coding/projects/ls-eww/crates/ewwls/target/debug/ewwls"]
(when (vim.fn.filereadable ewwls-path)
(when (not lsp.ewwls)
(set lsp-configs.ewwls
{:default_config {:cmd [ewwls-path]
:filetypes ["yuck"]
:root_dir (fn [fname] (or (lsp.util.find_git_ancestor fname) (vim.loop.os_homedir)))
:settings {}}}))
(init-lsp :ewwls))))
; Idris2 ----------------------------------------------------------- <<<<< ; Idris2 ----------------------------------------------------------- <<<<<
(def autostart-semantic-highlighting true) (def autostart-semantic-highlighting true)
(defn refresh-semantic-highlighting [] (fn refresh-semantic-highlighting []
(when autostart-semantic-highlighting (when autostart-semantic-highlighting
(vim.lsp.buf_request 0 (vim.lsp.buf_request 0
:textDocument/semanticTokens/full :textDocument/semanticTokens/full
{:textDocument (vim.lsp.util.make_text_document_params)} {:textDocument (vim.lsp.util.make_text_document_params)}
nil) nil)
vim.NIL)) vim.NIL))
(when (not lsp.idris2_lsp) (when (not lsp.idris2_lsp)
(set lsp-configs.idris2_lsp (set lsp-configs.idris2_lsp
{:default_config {:default_config
{:cmd [:idris2-lsp] {:cmd [:idris2-lsp]
:filetypes [:idris2] :filetypes [:idris2]
:on_new_config (fn [new-config new-root-dir] :on_new_config (fn [new-config new-root-dir]
(set new-config.cmd {1 :idris2-lsp}) (set new-config.cmd {1 :idris2-lsp})
(set new-config.capabilities.workspace.semanticTokens {:refreshSupport true})) (set new-config.capabilities.workspace.semanticTokens {:refreshSupport true}))
:root_dir (fn [fname] :root_dir (fn [fname]
(local scandir (require :plenary.scandir)) (local scandir (require :plenary.scandir))
(fn find-ipkg-ancestor [fname] (fn find-ipkg-ancestor [fname]
(lsp.util.search_ancestors (lsp.util.search_ancestors
fname fname
(fn [path] (fn [path]
(local res (scandir.scan_dir path {:depth 1 :search_pattern ".+%.ipkg"})) (local res (scandir.scan_dir path {:depth 1 :search_pattern ".+%.ipkg"}))
(when (not (vim.tbl_isempty res)) path)))) (when (not (vim.tbl_isempty res)) path))))
(or (or (find-ipkg-ancestor fname) (or (or (find-ipkg-ancestor fname)
(lsp.util.find_git_ancestor fname)) (lsp.util.find_git_ancestor fname))
(vim.loop.os_homedir))) (vim.loop.os_homedir)))
:settings {}}})) :settings {}}}))
(lsp.idris2_lsp.setup (lsp.idris2_lsp.setup
{:on_attach refresh-semantic-highlighting {:on_attach refresh-semantic-highlighting
:autostart true :autostart true
:handlers {:workspace/semanticTokens/refresh refresh-semantic-highlighting :handlers {:workspace/semanticTokens/refresh refresh-semantic-highlighting
:textDocument/semanticTokens/full :textDocument/semanticTokens/full
(fn [err method result client-id bufnr config] (fn [err method result client-id bufnr config]
(let [client (vim.lsp.get_client_by_id client-id) (let [client (vim.lsp.get_client_by_id client-id)
legend client.server_capabilities.semanticTokensProvider.legend legend client.server_capabilities.semanticTokensProvider.legend
token-types legend.tokenTypes token-types legend.tokenTypes
data result.data data result.data
ns (vim.api.nvim_create_namespace :nvim-lsp-semantic)] ns (vim.api.nvim_create_namespace :nvim-lsp-semantic)]
(vim.api.nvim_buf_clear_namespace bufnr ns 0 (- 1)) (vim.api.nvim_buf_clear_namespace bufnr ns 0 (- 1))
(local tokens {}) (local tokens {})
(var (prev-line prev-start) (values nil 0)) (var (prev-line prev-start) (values nil 0))
(for [i 1 (length data) 5] (for [i 1 (length data) 5]
(local delta-line (. data i)) (local delta-line (. data i))
(set prev-line (set prev-line
(or (and prev-line (+ prev-line delta-line)) (or (and prev-line (+ prev-line delta-line))
delta-line)) delta-line))
(local delta-start (. data (+ i 1))) (local delta-start (. data (+ i 1)))
(set prev-start (or (and (= delta-line 0) (+ prev-start delta-start)) (set prev-start (or (and (= delta-line 0) (+ prev-start delta-start))
delta-start)) delta-start))
(local token-type (. token-types (+ (. data (+ i 3)) 1))) (local token-type (. token-types (+ (. data (+ i 3)) 1)))
(vim.api.nvim_buf_add_highlight bufnr (vim.api.nvim_buf_add_highlight bufnr
ns ns
(.. :LspSemantic_ token-type) (.. :LspSemantic_ token-type)
prev-line prev-line
prev-start prev-start
(+ prev-start (. data (+ i 2)))))))}}) (+ prev-start (. data (+ i 2)))))))}})
(vim.cmd "highlight link LspSemantic_type Include") (vim.cmd "highlight link LspSemantic_type Include")
(vim.cmd "highlight link LspSemantic_function Identifier") (vim.cmd "highlight link LspSemantic_function Identifier")
(vim.cmd "highlight link LspSemantic_struct Number") (vim.cmd "highlight link LspSemantic_struct Number")
(vim.cmd "highlight LspSemantic_variable guifg=gray") (vim.cmd "highlight LspSemantic_variable guifg=gray")
(vim.cmd "highlight link LspSemantic_keyword Structure") (vim.cmd "highlight link LspSemantic_keyword Structure")
; --------------------------------- >>>>> ; --------------------------------- >>>>>
(set vim.opt.signcolumn "yes") (set vim.opt.signcolumn "yes")
; Cleanup links in markdown documentation
(defn- cleanup-markdown [contents]
(if (= contents.kind "markdown")
(tset contents :value (string.gsub contents.value "%[([^%]]+)%]%(([^%)]+)%)" "[%1]")))
contents)
(let [previous-handler (. vim.lsp.handlers :textDocument/hover)]
(tset vim.lsp.handlers :textDocument/hover
(fn [a result b c]
(if (not (and result result.contents))
(previous-handler a result b c)
(let [new-contents (cleanup-markdown result.contents)]
(tset result :contents new-contents)
(previous-handler a result b c))))))
; Cleanup links in markdown documentation
(fn cleanup-markdown [contents]
(if (= contents.kind "markdown")
(tset contents :value (string.gsub contents.value "%[([^%]]+)%]%(([^%)]+)%)" "[%1]")))
contents)
(let [previous-handler (. vim.lsp.handlers :textDocument/hover)]
(tset vim.lsp.handlers :textDocument/hover
(fn [a result b c]
(if (not (and result result.contents))
(previous-handler a result b c)
(let [new-contents (cleanup-markdown result.contents)]
(tset result :contents new-contents)
(previous-handler a result b c)))))))
[(utils.plugin :neovim/nvim-lspconfig {:event "VeryLazy" :lazy true})]
; vim:foldmarker=<<<<<,>>>>> ; vim:foldmarker=<<<<<,>>>>>

32
nvim/.config/nvim/fnl/dots/plugins/ltex-ls.fnl
View file

@ -1,29 +1,29 @@
(module dots.plugins.ltex-ls (import-macros m :macros)
{autoload {a aniseed.core (m.al a aniseed.core)
str aniseed.string (m.al str aniseed.string)
lsp lspconfig (m.al lsp lspconfig)
configs lspconfig/configs (m.al configs lspconfig/configs)
lsputil lspconfig/util (m.al lsputil lspconfig/util)
utils dots.utils (m.al utils dots.utils)
cmp_nvim_lsp cmp_nvim_lsp}}) (m.al cmp_nvim_lsp cmp_nvim_lsp)
(defn cmds [xs] (fn cmds [xs]
(icollect [_ x (ipairs xs)] (icollect [_ x (ipairs xs)]
(.. "\\" x "{}"))) (.. "\\" x "{}")))
(def latex-command-settings (local latex-command-settings
{:dummy (cmds ["texttt" "scripture" "lstref" "figref" "tblref" "secref" "personaltextcite" "personalparencite" "textcite" "parencite" "parencite[]" "game" "acsu" "enquote" "name" "item" "reqref" "gamebtn" "fs" "cs" "appref" "sorty"]) {:dummy (cmds ["texttt" "scripture" "lstref" "figref" "tblref" "secref" "personaltextcite" "personalparencite" "textcite" "parencite" "parencite[]" "game" "acsu" "enquote" "name" "item" "reqref" "gamebtn" "fs" "cs" "appref" "sorty"])
:ignore (cmds ["urlfootnote" "caption" "todo"])}) :ignore (cmds ["urlfootnote" "caption" "todo"])})
(def Dictionary-file {:de-DE [(.. (vim.fn.getenv "HOME") "/.config/ltex-ls/dictionary.txt")]}) (local Dictionary-file {:de-DE [(.. (vim.fn.getenv "HOME") "/.config/ltex-ls/dictionary.txt")]})
(def Disabled-rules-file {:de-DE [(.. (vim.fn.getenv "HOME") "/.config/ltex-ls/disable.txt")]}) (local Disabled-rules-file {:de-DE [(.. (vim.fn.getenv "HOME") "/.config/ltex-ls/disable.txt")]})
(def False-positives-file {:de-DE [(.. (vim.fn.getenv "HOME") "/.config/ltex-ls/false.txt")]}) (local False-positives-file {:de-DE [(.. (vim.fn.getenv "HOME") "/.config/ltex-ls/false.txt")]})
(def latex-command-settings-formatted (local latex-command-settings-formatted
(let [tbl {}] (let [tbl {}]
(each [option commands (pairs latex-command-settings)] (each [option commands (pairs latex-command-settings)]
(each [_ command (ipairs commands)] (each [_ command (ipairs commands)]
@ -107,7 +107,7 @@
(add-to-file filetype lang file value))) (add-to-file filetype lang file value)))
(defn init [] (fn init []
(set configs.ltex (set configs.ltex
{:default_config {:cmd [:ltex-ls] {:default_config {:cmd [:ltex-ls]
:filetypes [:tex :latex :bib] :filetypes [:tex :latex :bib]
@ -153,4 +153,4 @@
(orig-execute-command command))))) (orig-execute-command command)))))
[]

13
nvim/.config/nvim/fnl/dots/plugins/neogit.fnl
View file

@ -1,6 +1,9 @@
(module dots.plugins.neogit (import-macros m :macros)
{autoload {a aniseed.core (m.al neogit neogit)
neogit neogit}}) (m.al utils dots.utils)
[(utils.plugin :TimUntersberger/neogit
{:config #(neogit.setup {:integrations {:diffview true}})
:cmd ["Neogit"]})]
(neogit.setup
{:integrations {:diffview true}})

79
nvim/.config/nvim/fnl/dots/plugins/noice.fnl
View file

@ -1,40 +1,43 @@
(module dots.plugins.noice (import-macros m :macros)
{autoload {a aniseed.core (m.al utils dots.utils)
lazy lazy
noice noice
colors dots.colors
utils dots.utils}
(fn setup []
(m.al a nfnl.core)
(m.al lazy lazy)
(m.al noice noice)
(m.al colors dots.colors)
(noice.setup
{:presets {:inc_rename true
:long_message_to_split true
:bottom_search true}
;:command_palette true}
:lsp {:override {:vim.lsp.util.convert_input_to_markdown_lines true
:vim.lsp.util.stylize_markdown true
:cmp.entry.get_documentation true}}
:views {:cmdline_popup {:border {:style "none" :padding [1 1]}
:position {:row 5 :col "50%"}
:size {:width 60 :height "auto"}}
:popupmenu {:relative "editor"
:border {:style "none" :padding [1 1]}
:position {:row 8 :col "50%"}
:size {:width 60 :height 10}}
:mini {:max_height 5}}
:cmdline {:view "cmdline" ; change to cmdline_popup
:format {:cmdline {:icon ":"}
:lua false
:help false}}
:messages {:view "mini"
:view_error "cmdline_output"
:view_warn "mini"
:view_search "virtualtext"}
:markdown {:hover {"|(%S-)|" vim.cmd.help}}
:routes [{:view "notify" :filter {:event "msg_showmode"}}
{:view "mini"
:filter {:error true :max_height 5}}
{:view "cmdline_output"
:filter {:error true :min_height 6}}]}))
require-macros [macros]}) ;[(utils.plugin :folke/noice.nvim
; {:config setup
(noice.setup ; :dependencies [:MunifTanjim/nui.nvim]}}]}))
{:presets {:inc_rename true []
:long_message_to_split true
:bottom_search true}
;:command_palette true}
:lsp {:override {:vim.lsp.util.convert_input_to_markdown_lines true
:vim.lsp.util.stylize_markdown true
:cmp.entry.get_documentation true}}
:views {:cmdline_popup {:border {:style "none" :padding [1 1]}
:position {:row 5 :col "50%"}
:size {:width 60 :height "auto"}}
:popupmenu {:relative "editor"
:border {:style "none" :padding [1 1]}
:position {:row 8 :col "50%"}
:size {:width 60 :height 10}}
:mini {:max_height 5}}
:cmdline {:view "cmdline_popup" ; change to cmdline
:format {:cmdline {:icon ":"}
:lua false
:help false}}
:messages {:view "mini"
:view_error "cmdline_output"
:view_warn "mini"
:view_search "virtualtext"}
:markdown {:hover {"|(%S-)|" vim.cmd.help}}
:routes [{:view "notify" :filter {:event "msg_showmode"}}
{:view "mini"
:filter {:error true :max_height 5}}
{:view "cmdline_output"
:filter {:error true :min_height 6}}]})

33
nvim/.config/nvim/fnl/dots/plugins/nvim-colorizer.fnl
View file

@ -1,16 +1,23 @@
(module dots.plugins.nvim-colorizer (import-macros m :macros)
{autoload {colorizer colorizer}}) (m.al colorizer colorizer)
(m.al utils dots.utils)
; this really shouldn't be necessary,.. but it is (fn setup []
(set vim.o.termguicolors true) ; this really shouldn't be necessary,.. but it is
(set vim.o.termguicolors true)
(colorizer.setup (colorizer.setup
["*"] ["*"]
{:RGB true {:RGB true
:RRGGBB true :RRGGBB true
:names true :names true
:RRGGBBAA true :RRGGBBAA true
:rgb_fn true :rgb_fn true
:hsl_fn true :hsl_fn true
:mode "background"}) :mode "background"}))
[(utils.plugin :norcalli/nvim-colorizer.lua
{:event "VeryLazy"
:lazy true
:config setup})]

14
nvim/.config/nvim/fnl/dots/plugins/persistence.fnl
View file

@ -1,5 +1,11 @@
(module dots.plugins.persistence (import-macros m :macros)
{autoload {persistence persistence}}) (m.al persistence persistence)
(m.al utils dots.utils)
(persistence.setup
{:dir (vim.fn.expand (.. (vim.fn.stdpath "cache") "/sessions/"))}) (fn setup []
(persistence.setup
{:dir (vim.fn.expand (.. (vim.fn.stdpath "cache") "/sessions/"))}))
[(utils.plugin :folke/persistence.nvim
{:config setup})]

197
nvim/.config/nvim/fnl/dots/plugins/plugins.fnl Normal file
View file

@ -0,0 +1,197 @@
(import-macros {: al} :macros)
(al a nfnl.core)
(al lazy lazy)
(macro setup [name opts]
`((. (require ,name) :setup) ,opts))
(macro plugin [name ?opts]
(if (= nil ?opts)
name
(do (tset ?opts 1 name) ?opts)))
[(plugin :Olical/aniseed)
(plugin :Olical/nfnl)
(plugin :nvim-lua/plenary.nvim)
(plugin :norcalli/nvim.lua)
(plugin :kyazdani42/nvim-web-devicons)
(plugin :folke/which-key.nvim)
(plugin :folke/todo-comments.nvim
{:lazy true
:event "VeryLazy"
:config #(require "dots.plugins.todo-comments")})
(plugin :ckipp01/nvim-jenkinsfile-linter
{:dependencies ["nvim-lua/plenary.nvim"]})
(plugin :psliwka/vim-smoothie)
(plugin :nathanaelkane/vim-indent-guides
{:cmd ["IndentGuidesToggle"]})
(plugin :luukvbaal/stabilize.nvim
{:config #(setup :stabilize)})
(plugin :stevearc/dressing.nvim
{:config #(setup :dressing)})
(plugin :tweekmonster/startuptime.vim
{:cmd ["StartupTime"]})
(plugin :folke/zen-mode.nvim
{:config #(require "dots.plugins.zen-mode")
:cmd ["ZenMode"]})
(plugin :folke/twilight.nvim
{:config #(require "dots.plugins.twilight")})
(plugin :moll/vim-bbye
{:lazy true :cmd [:Bdelete :Bwipeout]})
(plugin :petertriho/nvim-scrollbar
{:event "VeryLazy"
:lazy true
:config #(setup :scrollbar)})
(plugin "https://git.sr.ht/~whynothugo/lsp_lines.nvim"
{:config #(do (setup :lsp_lines)
(vim.diagnostic.config {:virtual_lines false}))})
; editing and movement <<<
(plugin :jiangmiao/auto-pairs)
(plugin :tpope/vim-repeat)
(plugin :preservim/nerdcommenter
{:event "VeryLazy"
:lazy true
:priority 1000})
(plugin :godlygeek/tabular
{:cmd ["Tabularize"]})
(plugin :tpope/vim-surround)
(plugin :hauleth/sad.vim)
(plugin :wellle/targets.vim) ; more text objects. IE: cin (change in next parens). generally better handling of surrounding objects.
(plugin :mg979/vim-visual-multi
{:lazy true :event "VeryLazy"})
(plugin :tommcdo/vim-exchange)
(plugin :phaazon/hop.nvim
{:lazy true
:event "VeryLazy"
:config #(setup "hop" {:keys "jfkdls;amvieurow"})})
; >>>
; debugger <<<
(plugin :rcarriga/nvim-dap-ui
{:lazy true
:config #(setup :dapui)
:dependencies [:mfussenegger/nvim-dap]})
(plugin :mfussenegger/nvim-dap
{:lazy true})
(plugin :nvim-telescope/telescope-dap.nvim
{:lazy true
:dependencies [:nvim-telescope/telescope.nvim
:mfussenegger/nvim-dap]})
; >>>
; git stuff <<<
(plugin :ldelossa/gh.nvim
{:lazy true
:config #(do ((. (require "litee.lib") :setup))
((. (require "litee.gh") :setup)))
:dependencies [:ldelossa/litee.nvim]})
(plugin :pwntester/octo.nvim
{:lazy true
:dependencies [:nvim-lua/plenary.nvim
:nvim-telescope/telescope.nvim
:kyazdani42/nvim-web-devicons]
:config #(setup :octo)})
(plugin :ruanyl/vim-gh-line)
(plugin :rhysd/conflict-marker.vim)
(plugin :tpope/vim-fugitive
{:lazy true :event "VeryLazy"})
; >>>
; lsp <<<
(plugin :ray-x/lsp_signature.nvim
{:event :BufEnter})
(plugin :weilbith/nvim-code-action-menu
{:cmd "CodeActionMenu"
:config #(set vim.g.code_action_menu_show_details false)})
(plugin :folke/trouble.nvim
{:lazy true
:config #(require "dots.plugins.trouble")
:cmd ["Trouble" "TroubleClose" "TroubleRefresh" "TroubleToggle"]})
; :elkowar/trouble.nvim {:branch "fix_error_on_nil_window"
; :config #(require "dots.plugins.trouble")
; :cmd ["Trouble" "TroubleClose" "TroubleRefresh" "TroubleToggle"]}
(plugin :simrat39/symbols-outline.nvim
{:lazy true
:cmd ["SymbolsOutline" "SymbolsOutlineClose" "SymbolsOutlineOpen"]
:config #(require "dots.plugins.symbols-outline")})
(plugin :smjonas/inc-rename.nvim
{:config #(setup :inc_rename {:input_buffer_type "dressing"})})
; >>>
; cmp <<<
; >>>
; code-related ----------------------------------------- <<<
(plugin :monkoose/nvlime
{:ft ["lisp"] :dependencies [:monkoose/parsley]})
(plugin :tpope/vim-sleuth)
(plugin :editorconfig/editorconfig-vim)
(plugin :pechorin/any-jump.vim)
(plugin :sbdchd/neoformat)
(plugin :elkowar/antifennel-nvim
{:config #(set vim.g.antifennel_executable "/home/leon/tmp/antifennel/antifennel")})
(plugin :Olical/conjure {:ft ["fennel"]})
(plugin :eraserhd/parinfer-rust {:build "cargo build --release"})
(plugin :lervag/vimtex
{:ft ["latex" "tex"]
:config #(require :dots.plugins.vimtex)})
(plugin :kmonad/kmonad-vim)
(plugin :elkowar/yuck.vim {:ft ["yuck"]})
(plugin :cespare/vim-toml {:ft ["toml"]})
(plugin :bduggan/vim-raku {:ft ["raku"]})
(plugin :LnL7/vim-nix {:ft ["nix"]})
(plugin :kevinoid/vim-jsonc {})
(plugin :pangloss/vim-javascript {:ft ["javascript"]}) ; syntax highlighting JS
(plugin :ianks/vim-tsx {:ft ["typescript-react"]})
(plugin :leafgarland/typescript-vim {:ft ["typescript" "typescript-react" "javascript"]})
(plugin :HerringtonDarkholme/yats.vim {}) ; typescript syntax highlighting
(plugin :mxw/vim-jsx {})
(plugin :mattn/emmet-vim
{:lazy true
:config #(require "dots.plugins.emmet")})
(plugin :purescript-contrib/purescript-vim {:ft ["purescript"]})
(plugin :derekelkins/agda-vim {:ft ["agda"]})
(plugin :neovimhaskell/haskell-vim { :ft ["haskell"]})
(plugin :monkoose/nvlime
{:ft ["lisp"]
:dependencies ["monkoose/parsley"]
:config #(set vim.g.vlime_overlay "slimv")})
(plugin :rust-lang/rust.vim
{:ft ["rust"]
:dependencies ["mattn/webapi-vim"]
:config #(do (set vim.g.rustfmt_fail_silently 1))})
(plugin :simrat39/rust-tools.nvim
{:ft ["rust" "toml"]
:dependencies ["nvim-lua/popup.nvim" "nvim-lua/plenary.nvim"]})
(plugin :qnighy/lalrpop.vim {})
(plugin :edwinb/idris2-vim {:ft ["idris2"]})
(plugin :vmchale/ats-vim {:ft ["ats" "dats" "sats"]})
(plugin :bakpakin/fennel.vim {:ft ["fennel"]})
(plugin :evanleck/vim-svelte {})]
; >>>
; vim:foldmarker=<<<,>>>

6
nvim/.config/nvim/fnl/dots/plugins/sneak.fnl
View file

@ -1,7 +1,9 @@
(module dots.plugins.sneak (import-macros m :macros)
{autoload {utils dots.utils}}) (m.al utils dots.utils)
(set vim.g.sneak#label 1) (set vim.g.sneak#label 1)
(utils.keymap [:n :o] :<DEL> "<Plug>Sneak_s" {:noremap false}) (utils.keymap [:n :o] :<DEL> "<Plug>Sneak_s" {:noremap false})
(utils.keymap [:n :o] :<S-DEL> "<Plug>Sneak_S" {:noremap false}) (utils.keymap [:n :o] :<S-DEL> "<Plug>Sneak_S" {:noremap false})
[]

7
nvim/.config/nvim/fnl/dots/plugins/symbols-outline.fnl
View file

@ -1,4 +1,5 @@
(module dots.plugins.symbols-outline (import-macros m :macros)
{require {symbols-outline symbols-outline}}) (local symbols-outline (require :symbols-outline))
(symbols-outline.setup {:highlight_hovered_item true :show_guides true}) ; (symbols-outline.setup {:highlight_hovered_item true :show_guides true})
[]

33
nvim/.config/nvim/fnl/dots/plugins/telescope.fnl
View file

@ -1,16 +1,23 @@
(module dots.plugins.telescope (import-macros {: al} :macros)
{autoload {utils dots.utils (al utils dots.utils)
telescope telescope (al telescope telescope)
actions telescope.actions (al actions telescope.actions)
colors dots.colors}}) (al colors dots.colors)
(telescope.setup (fn setup []
{:defaults {:mappings {:i {:<esc> actions.close}} (telescope.setup
:file_ignore_patterns ["Cargo.lock" ".*.snap" "docs/theme/.*" "node%_modules/.*" "target/.*"]} {:defaults {:mappings {:i {:<esc> actions.close}}
:extensions {:ui-select [((. (require "telescope.themes") :get_dropdown))]}}) :file_ignore_patterns ["Cargo.lock" ".*.snap" "docs/theme/.*" "node%_modules/.*" "target/.*"]}
:extensions {:ui-select [((. (require "telescope.themes") :get_dropdown))]}})
(telescope.load_extension "dap")
;(telescope.load_extension "ui-select") (telescope.load_extension "dap")
;(telescope.load_extension "ui-select")
(utils.keymap :n :<C-p> ":Telescope find_files<CR>") (utils.keymap :n :<C-p> ":Telescope find_files<CR>"))
[(utils.plugin :nvim-telescope/telescope.nvim
{:config setup
:cmd ["Telescope"]
:dependencies [:nvim-lua/popup.nvim
:nvim-lua/plenary.nvim]})]

7
nvim/.config/nvim/fnl/dots/plugins/todo-comments.fnl
View file

@ -1,6 +1,6 @@
(module dots.plugins.todo-comments (import-macros m :macros)
{autoload {a aniseed.core (m.al a aniseed.core)
todo-comments todo-comments}}) (m.al todo-comments todo-comments)
(todo-comments.setup (todo-comments.setup
{:keywords {:TODO {:icon " "} {:keywords {:TODO {:icon " "}
@ -9,3 +9,4 @@
:FIX {:icon " " :alt [:FIXME :BUG :FIXIT :ISSUE :PHIX]} :FIX {:icon " " :alt [:FIXME :BUG :FIXIT :ISSUE :PHIX]}
:PERF {:icon " " :alt [:OPTIM :PERFORMANCE :OPTIMIZE]} :PERF {:icon " " :alt [:OPTIM :PERFORMANCE :OPTIMIZE]}
:HACK {:icon " "}}}) :HACK {:icon " "}}})
[]

103
nvim/.config/nvim/fnl/dots/plugins/treesitter.fnl
View file

@ -1,51 +1,64 @@
(module dots.plugins.treesitter (import-macros m :macros)
{autoload {utils dots.utils (m.al utils dots.utils)
a aniseed.core} (m.al a nfnl.core)
require {configs nvim-treesitter.configs}
require-macros [macros]})
(configs.setup (fn setup [])
{:ensure_installed ["rust" "fennel" "commonlisp" "vim" "regex" "lua" "bash" "markdown" "markdown_inline"]
; :ensure_installed "maintained"
:highlight {:enable false
:disable ["fennel" "rust" "haskell"]}
:incremental_selection {:enable false (fn setup1 []
:keymaps {:init_selection "gss" (local configs (require :nvim-treesitter.configs))
:node_incremental "gsl" (configs.setup
:node_decremental "gsh" {:ensure_installed ["rust" "fennel" "commonlisp" "vim" "regex" "lua" "bash" "markdown" "markdown_inline"]
:scope_incremental "gsj" ; :ensure_installed "maintained"
:scope_decremental "gsk"}} :highlight {:enable false
:textsubjects {:enable true :disable ["fennel" "rust" "haskell"]}
:disable ["noice"]
:prev_selection ","
:keymaps {"." "textsubjects-smart"}}
; Might fuck with gitsigns :incremental_selection {:enable false
;:rainbow {:enable true} :keymaps {:init_selection "gss"
;:extended_mode true} :node_incremental "gsl"
:context_commentstring {:enable true :disable ["rust" "fennel"]} :node_decremental "gsh"
:scope_incremental "gsj"
:scope_decremental "gsk"}}
:textsubjects {:enable true
:disable ["noice"]
:prev_selection ","
:keymaps {"." "textsubjects-smart"}}
:playground ; Might fuck with gitsigns
{:enable false ;:rainbow {:enable true}
:disable ["fennel"] ;:extended_mode true}
:updatetime 25 ; Debounced time for highlighting nodes in the playground from source code :context_commentstring {:enable true :disable ["rust" "fennel"]}
:persist_queries false ; Whether the query persists across vim sessions
:keybindings
{:toggle_query_editor "o"
:toggle_hl_groups "i"
:toggle_injected_languages "t"
:toggle_anonymous_nodes "a"
:toggle_language_display "I"
:focus_language "f"
:unfocus_language "F"
:update "R"
:goto_node "<cr>"
:show_help "?"}}})
;:indent {:enable true}
;:disable ["lua"]
:playground
{:enable false
:disable ["fennel"]
:updatetime 25 ; Debounced time for highlighting nodes in the playground from source code
:persist_queries false ; Whether the query persists across vim sessions
:keybindings
{:toggle_query_editor "o"
:toggle_hl_groups "i"
:toggle_injected_languages "t"
:toggle_anonymous_nodes "a"
:toggle_language_display "I"
:focus_language "f"
:unfocus_language "F"
:update "R"
:goto_node "<cr>"
:show_help "?"}}}))
[(utils.plugin :nvim-treesitter/nvim-treesitter
{:config setup
:lazy true
:event ["VeryLazy"]
:build ":TSUpdate"})
(utils.plugin :RRethy/nvim-treesitter-textsubjects
{:dependencies [:nvim-treesitter/nvim-treesitter]
:lazy true
:event ["VeryLazy"]})
(utils.plugin :JoosepAlviste/nvim-ts-context-commentstring
{:event ["VeryLazy"]
:lazy true
:dependencies [:nvim-treesitter/nvim-treesitter]})
(utils.plugin :nvim-treesitter/playground
{:event ["VeryLazy"]
:lazy true
:dependencies [:nvim-treesitter/nvim-treesitter]})]

9
nvim/.config/nvim/fnl/dots/plugins/trouble.fnl
View file

@ -1,7 +1,7 @@
(module dots.plugins.trouble (import-macros m :macros)
{autoload {utils dots.utils (m.al utils dots.utils)
colors dots.colors} (m.al colors dots.colors)
require {trouble trouble}}) (local trouble (require :trouble))
(trouble.setup (trouble.setup
{:icons false {:icons false
@ -25,3 +25,4 @@
(utils.highlight "TroubleSignWarning" {:bg "NONE" :fg colors.bright_yellow}) (utils.highlight "TroubleSignWarning" {:bg "NONE" :fg colors.bright_yellow})
(utils.highlight "TroubleSignInformation" {:bg "NONE" :fg colors.bright_aqua}) (utils.highlight "TroubleSignInformation" {:bg "NONE" :fg colors.bright_aqua})
(utils.highlight "TroubleSignHint" {:bg "NONE" :fg colors.bright_blue}) (utils.highlight "TroubleSignHint" {:bg "NONE" :fg colors.bright_blue})
[]

6
nvim/.config/nvim/fnl/dots/plugins/twilight.fnl
View file

@ -1,5 +1,5 @@
(import-macros m :macros)
(module dots.plugins.twilight (m.al twilight twilight)
{autoload {twilight twilight}})
(twilight.setup) (twilight.setup)
[]

2
nvim/.config/nvim/fnl/dots/plugins/vimtex.fnl
View file

@ -1,4 +1,3 @@
(module dots.plugins.vimtex)
;(set vim.g.vimtex_quickfix_enabled 0) ;(set vim.g.vimtex_quickfix_enabled 0)
@ -40,3 +39,4 @@
[]

5
nvim/.config/nvim/fnl/dots/plugins/zen-mode.fnl
View file

@ -1,7 +1,8 @@
(module dots.plugins (import-macros m :macros)
{autoload {zen-mode zen-mode}}) (m.al zen-mode zen-mode)
(zen-mode.setup (zen-mode.setup
{:window {:options {:wrap true}}}) {:window {:options {:wrap true}}})
[]

107
nvim/.config/nvim/fnl/dots/smart-compe-conjure.fnl
View file

@ -1,61 +1,58 @@
(module dots.smart-compe-conjure (al utils dots.utils)
{autoload {utils dots.utils (al a aniseed.core)
a aniseed.core (al str aniseed.string)
str aniseed.string (al view aniseed.view)
view aniseed.view (al popup popup)
popup popup (al compe compe)
compe compe}
;help dots.help-thingy} (defn setup []
require-macros [macros]}) (def fuck (require "compe_conjure"))
(def fuck (require "compe_conjure")) (def my_source {})
(set my_source.new
(fn []
(setmetatable {} {:__index my_source})))
(set my_source.determine fuck.determine)
(set my_source.get_metadata fuck.get_metadata)
(set my_source.complete fuck.complete)
(set my_source.abort fuck.abort)
(set my_source.documentation
(fn [self args]
(a.println (view.serialise args))
(args.callback
(let [help-tag (help.find-help-tag-for args.completed_item.word)]
(when help-tag
(var lines ["```help"])
(each [_ line (ipairs (help.help-for-tag help-tag))]
(table.insert lines line))
(table.insert lines "```")
lines)))))
(compe.register_source :epic (my_source.new))
(def my_source {}) (compe.setup
(set my_source.new {:enabled true
(fn [] :autocomplete false
(setmetatable {} {:__index my_source}))) :debug false
:min_length 1
(set my_source.determine fuck.determine) :preselect "enable"
(set my_source.get_metadata fuck.get_metadata) :throttle_time 80
(set my_source.complete fuck.complete) :source_timeout 200
(set my_source.abort fuck.abort) :incomplete_delay 400
(set my_source.documentation :max_abbr_width 100
(fn [self args] :max_kind_width 100
(a.println (view.serialise args)) :max_menu_width 100
(args.callback :documentation true
(let [help-tag (help.find-help-tag-for args.completed_item.word)] :source {:path true
(when help-tag :buffer true
(var lines ["```help"]) :calc true
(each [_ line (ipairs (help.help-for-tag help-tag))] :nvim_lsp true
(table.insert lines line)) :nvim_lua true
(table.insert lines "```") :vsnip false
lines))))) :epic true}}))
(compe.register_source :epic (my_source.new))
(compe.setup
{:enabled true
:autocomplete false
:debug false
:min_length 1
:preselect "enable"
:throttle_time 80
:source_timeout 200
:incomplete_delay 400
:max_abbr_width 100
:max_kind_width 100
:max_menu_width 100
:documentation true
:source {:path true
:buffer true
:calc true
:nvim_lsp true
:nvim_lua true
:vsnip false
:epic true}})
[]

116
nvim/.config/nvim/fnl/dots/utils.fnl
View file

@ -1,29 +1,31 @@
(module dots.utils (import-macros {: al} :macros)
{autoload {a aniseed.core (al a nfnl.core)
nvim aniseed.nvim (al str nfnl.string)
str aniseed.string}
require-macros [macros]})
(defn plugin-installed? [name] (fn plugin [name ?opts]
(~= nil (. packer_plugins name))) (if (= nil ?opts)
name
(do
(tset ?opts 1 name)
?opts)))
(defn all [f xs] (fn all [f xs]
(not (a.some #(not (f $1))))) (not (a.some #(not (f $1)))))
(defn single-to-list [x] (fn single-to-list [x]
"Returns the list given to it. If given a single value, wraps it in a list" "Returns the list given to it. If given a single value, wraps it in a list"
(if (a.table? x) x [x])) (if (a.table? x) x [x]))
(defn contains? [list elem] (fn contains? [list elem]
(or (a.some #(= elem $1) list)) false) (or (a.some #(= elem $1) list)) false)
(defn filter-table [f t] (fn filter-table [f t]
(collect [k v (pairs t)] (collect [k v (pairs t)]
(when (f k v) (when (f k v)
(values k v)))) (values k v))))
(defn split-last [s sep] (fn split-last [s sep]
"split a string at the last occurrence of a separator" "split a string at the last occurrence of a separator"
(for [i (length s) 1 -1] (for [i (length s) 1 -1]
(let [c (s:sub i i)] (let [c (s:sub i i)]
@ -33,21 +35,21 @@
(lua "return { left, right }"))))) (lua "return { left, right }")))))
[s]) [s])
(defn find-where [pred xs] (fn find-where [pred xs]
(each [_ x (ipairs xs)] (each [_ x (ipairs xs)]
(when (pred x) (when (pred x)
(lua "return x")))) (lua "return x"))))
(defn find-map [f xs] (fn find-map [f xs]
(each [_ x (ipairs xs)] (each [_ x (ipairs xs)]
(let [res (f x)] (let [res (f x)]
(when (~= nil res) (when (~= nil res)
(lua "return res"))))) (lua "return res")))))
(defn keep-if [f x] (fn keep-if [f x]
(when (f x) x)) (when (f x) x))
(defn map-values [f t] (fn map-values [f t]
"Map over the values of a table, keeping the keys intact" "Map over the values of a table, keeping the keys intact"
(let [tbl {}] (let [tbl {}]
(each [k v (pairs t)] (tset tbl k (f v))) (each [k v (pairs t)] (tset tbl k (f v)))
@ -55,27 +57,25 @@
(defn without-keys [keys t] (fn without-keys [keys t]
(filter-table #(not (contains? keys $1)) t)) (filter-table #(not (contains? keys $1)) t))
(defn keymap [modes from to ?opts] (fn keymap [modes from to ?opts]
"Set a mapping in the given modes, and some optional parameters, defaulting to {:noremap true :silent true}. "Set a mapping in the given modes, and some optional parameters, defaulting to {:noremap true :silent true}.
If :buffer is set, uses buf_set_keymap rather than set_keymap" If :buffer is set, uses buf_set_keymap rather than set_keymap"
(let [full-opts (->> (or ?opts {}) (let [full-opts (->> (or ?opts {})
(a.merge {:noremap true :silent true}) (a.merge {:noremap true :silent true})
(without-keys [:buffer]))] (without-keys [:buffer]))]
(each [_ mode (ipairs (single-to-list modes))] (each [_ mode (ipairs (single-to-list modes))]
(if (-?> ?opts (. :buffer)) (let [keymap-opts (if (-?> ?opts (. :buffer)) (a.assoc full-opts :buffer 0) full-opts)]
(nvim.buf_set_keymap 0 mode from to full-opts) (vim.keymap.set mode from to keymap-opts)))))
(nvim.set_keymap mode from to full-opts)))))
(defn del-keymap [mode from ?buf-local] (fn del-keymap [mode from ?buf-local]
"Remove a keymap. Arguments: mode, mapping, bool if mapping should be buffer-local." "Remove a keymap. Arguments: mode, mapping, bool if mapping should be buffer-local."
(if ?buf-local (vim.keymap.del mode from
(nvim.buf_del_keymap 0 mode from) (if ?buf-local {:buffer 0} {})))
(nvim.del_keymap mode from)))
(defn safe-require [name] (fn safe-require [name]
(xpcall (xpcall
#( #(
;do ;do
@ -86,24 +86,24 @@
(a.println (.. "Error sourcing " name ":\n" (fennel.traceback $1)))))) (a.println (.. "Error sourcing " name ":\n" (fennel.traceback $1))))))
(defn buffer-content [bufnr] (fn buffer-content [bufnr]
"Returns a table of lines in the given buffer" "Returns a table of lines in the given buffer"
(vim.api.nvim_buf_get_lines bufnr 0 -1 false)) (vim.api.nvim_buf_get_lines bufnr 0 -1 false))
(defn surround-if-present [a mid b] (fn surround-if-present [a mid b]
(if mid (if mid
(.. a mid b) (.. a mid b)
"")) ""))
(defn highlight [group-arg colset] (fn highlight [group-arg colset]
(let [default { :fg "NONE" :bg "NONE" :gui "NONE"} (let [default { :fg "NONE" :bg "NONE" :gui "NONE"}
opts (a.merge default colset)] opts (a.merge default colset)]
(each [_ group (ipairs (single-to-list group-arg))] (each [_ group (ipairs (single-to-list group-arg))]
(nvim.command (.. "hi! "group" guifg='"opts.fg"' guibg='"opts.bg"' gui='"opts.gui"'"))))) (vim.cmd (.. "hi! "group" guifg='"opts.fg"' guibg='"opts.bg"' gui='"opts.gui"'")))))
(defn highlight-add [group-arg colset] (fn highlight-add [group-arg colset]
(each [_ group (ipairs (single-to-list group-arg))] (each [_ group (ipairs (single-to-list group-arg))]
(nvim.command (vim.cmd
(.. "hi! " (.. "hi! "
group group
(surround-if-present " guibg='"colset.bg"'") (surround-if-present " guibg='"colset.bg"'")
@ -115,7 +115,7 @@
(defn shorten-path [path seg-length shorten-after] (fn shorten-path [path seg-length shorten-after]
"shorten a filepath by truncating the segments to n characters, if the path exceeds a given length" "shorten a filepath by truncating the segments to n characters, if the path exceeds a given length"
(let [segments (str.split path "/")] (let [segments (str.split path "/")]
(if (or (> shorten-after (length path)) (if (or (> shorten-after (length path))
@ -126,7 +126,7 @@
shortened-segs (a.map #(string.sub $1 1 seg-length) init)] shortened-segs (a.map #(string.sub $1 1 seg-length) init)]
(.. (str.join "/" shortened-segs) "/" filename))))) (.. (str.join "/" shortened-segs) "/" filename)))))
(defn comp [f g] (fn comp [f g]
(fn [...] (fn [...]
(f (g ...)))) (f (g ...))))
@ -138,28 +138,56 @@
(var deferred-funs []) (var deferred-funs [])
(var did-exec-deferred false) (var did-exec-deferred false)
(defn clear-deferred [] (set deferred-funs [])) (fn clear-deferred [] (set deferred-funs []))
; defer a function. If deferred funcs have already been ran, ; defer a function. If deferred funcs have already been ran,
; assume we're reloading config because the user is configuring, and just execute immediately ; assume we're reloading config because the user is configuring, and just execute immediately
(defn defer-to-end [f] (fn defer-to-end [f]
(if did-exec-deferred (if did-exec-deferred
(f) (f)
(table.insert deferred-funs f))) (table.insert deferred-funs f)))
(defn run-deferred [] (fn run-deferred []
(set did-exec-deferred true) (set did-exec-deferred true)
(each [_ f (ipairs deferred-funs)] (each [_ f (ipairs deferred-funs)]
(f))) (f)))
(fn get-selection []
(defn get-selection []
(let [[_ s-start-line s-start-col] (vim.fn.getpos "'<") (let [[_ s-start-line s-start-col] (vim.fn.getpos "'<")
[_ s-end-line s-end-col] (vim.fn.getpos "'>") [_ s-end-line s-end-col] (vim.fn.getpos "'>")
n-lines (+ 1 (math.abs (- s-end-line s-start-line))) n-lines (+ 1 (math.abs (- s-end-line s-start-line)))
lines (vim.api.nvim_buf_get_lines 0 (- s-start-line 1) s-end-line false)] lines (vim.api.nvim_buf_get_lines 0 (- s-start-line 1) s-end-line false)]
(tset lines 1 (string.sub (. lines 1) s-start-col -1)) (if (= nil (. lines 1))
(if (= 1 n-lines) (values s-start-line s-end-line lines)
(tset lines n-lines (string.sub (. lines n-lines) 1 (+ 1 (- s-end-col s-start-col)))) (do
(tset lines n-lines (string.sub (. lines n-lines) 1 s-end-col))) (tset lines 1 (string.sub (. lines 1) s-start-col -1))
(values s-start-line s-end-line lines))) (if (= 1 n-lines)
(tset lines n-lines (string.sub (. lines n-lines) 1 (+ 1 (- s-end-col s-start-col))))
(tset lines n-lines (string.sub (. lines n-lines) 1 s-end-col)))
(values s-start-line s-end-line lines)))))
{: plugin
: plugin-installed?
: all
: single-to-list
: contains?
: filter-table
: split-last
: find-where
: find-map
: keep-if
: map-values
: without-keys
: keymap
: del-keymap
: safe-require
: buffer-content
: surround-if-present
: highlight
: highlight-add
: shorten-path
: comp
: clear-deferred
: defer-to-end
: run-deferred
: get-selection}

31
nvim/.config/nvim/fnl/init.fnl
View file

@ -1,20 +1,27 @@
(module init (import-macros {: al : vim-let} :macros)
{autoload {utils dots.utils (al a nfnl.core)
nvim aniseed.nvim (al utils dots.utils)
a aniseed.core (al str nfnl.string)
str aniseed.string (al colors dots.colors)
colors dots.colors} (local lazy (require :lazy))
require-macros [macros]})
(utils.clear-deferred) (utils.clear-deferred)
;(macro make-errors-epic [f]
; `(xpcall #,f #(let [fennel# (require :aniseed.fennel)]
; (a.println (fennel#.traceback $1)))))
(macro make-errors-epic [f] (macro make-errors-epic [f]
`(xpcall #,f #(let [fennel# (require :aniseed.fennel)] f)
(a.println (fennel#.traceback $1)))))
(when (vim.fn.has "termguicolors") (when (vim.fn.has "termguicolors")
(set vim.opt.termguicolors true)) (set vim.opt.termguicolors true))
(make-errors-epic (require "dots.plugins")) ;(make-errors-epic (require "dots.plugins"))
(vim-let mapleader "\\<Space>")
(vim-let maplocalleader ",")
(lazy.setup {:import "dots.plugins" :install {:colorscheme "gruvbox8"}})
; (require "impatient") ; (require "impatient")
@ -27,8 +34,6 @@
; Basic setup --------------------------------------- foldstart ; Basic setup --------------------------------------- foldstart
(vim-let mapleader "\\<Space>")
(vim-let maplocalleader ",")
(vim.cmd "filetype plugin indent on") (vim.cmd "filetype plugin indent on")
(vim.cmd "syntax on") (vim.cmd "syntax on")
@ -140,7 +145,7 @@
(vim.cmd (vim.cmd
"command! -nargs=1 L :lua print(vim.inspect(<args>))") "command! -nargs=1 L :lua print(vim.inspect(<args>))")
(vim.cmd "Copilot enable") ; (vim.cmd "Copilot enable")
(utils.run-deferred) (utils.run-deferred)

28
nvim/.config/nvim/fnl/macros.fnl
View file

@ -1,3 +1,5 @@
;; [nfnl-macro]
{:augroup {:augroup
(fn [name ...] (fn [name ...]
`(do `(do
@ -6,6 +8,11 @@
,... ,...
(nvim.ex.augroup :END))) (nvim.ex.augroup :END)))
:al
(fn [name thing]
`(local ,name ((. (require :nfnl.module) :autoload) ,(tostring thing))))
:defer :defer
(fn [...] (fn [...]
`(let [utils# (require :dots.utils)] `(let [utils# (require :dots.utils)]
@ -14,8 +21,8 @@
:req :req
(fn [name ...] (fn [name ...]
(let [str (require :aniseed.string) (let [str (require :nfnl.string)
a (require :aniseed.core) a (require :nfnl.core)
segs (str.split (tostring name) "%.") segs (str.split (tostring name) "%.")
mod (str.join "." (a.butlast segs)) mod (str.join "." (a.butlast segs))
func (a.last segs)] func (a.last segs)]
@ -33,19 +40,6 @@
(fn [name] (fn [name]
`(.. "lua require('" *module-name* "')['" ,(tostring name) "']()")) `(.. "lua require('" *module-name* "')['" ,(tostring name) "']()"))
:dbg
(fn [x]
`(let [view# (require "aniseed.view")]
(print (.. `,(tostring x) " => " (view#.serialise ,x)))
,x))
:dbg-call
(fn [x ...]
`(do
(let [a# (require "aniseed.core")]
(a#.println ,...))
(,x ,...)))
:pkg :pkg
(fn [name mappings ...] (fn [name mappings ...]
`(if (~= nil (. packer_plugins `,(tostring name))) `(if (~= nil (. packer_plugins `,(tostring name)))
@ -60,7 +54,7 @@
:each-pair :each-pair
(fn [args ...] (fn [args ...]
(let [[l# r# d#] args] (let [[l# r# d#] args]
`(let [a# (require "aniseed.core") `(let [a# (require "nfnl.core")
data# ,d#] data# ,d#]
(for [i# 1 (a#.count data#) 2] (for [i# 1 (a#.count data#) 2]
(let [,l# (. data# i#) (let [,l# (. data# i#)
@ -69,7 +63,7 @@
:packer-use :packer-use
(fn [...] (fn [...]
(let [a (require "aniseed.core") (let [a (require "nfnl.core")
args [...] args [...]
use-statements []] use-statements []]
(for [i 1 (a.count args) 2] (for [i 1 (a.count args) 2]

19
nvim/.config/nvim/init.lua
View file

@ -1,7 +1,3 @@
-- not even used, but epic. stores the path to the root config directory. -- not even used, but epic. stores the path to the root config directory.
local vim_config_root = vim.fn.expand("<sfile>:p:h") local vim_config_root = vim.fn.expand("<sfile>:p:h")
@ -33,15 +29,22 @@ end
-- Bootstrap essential plugins required for installing and loading the rest. -- Bootstrap essential plugins required for installing and loading the rest.
--ensure("wbthomason", "packer.nvim", "master") --ensure("wbthomason", "packer.nvim", "master")
ensure("Olical", "aniseed", "master") --ensure("Olical", "aniseed", "master")
ensure("Olical", "nfnl", "main")
-- require('nfnl')['compile-all-files']()
require("lua.init")
-- ensure("lewis6991", "impatient.nvim", "main") -- ensure("lewis6991", "impatient.nvim", "main")
-- require("impatient") -- require("impatient")
vim.g["aniseed#env"] = { -- vim.g["aniseed#env"] = {
compile = true -- compile = true
} -- }
--require("aniseed.env").init({compile = true}) --require("aniseed.env").init({compile = true})

14
nvim/.config/nvim/lazy-lock.json
View file

@ -1,6 +1,6 @@
{ {
"agda-vim": { "branch": "master", "commit": "4a0f475aaef756702222bdd5b01e25f814f5691f" }, "agda-vim": { "branch": "master", "commit": "4a0f475aaef756702222bdd5b01e25f814f5691f" },
"aniseed": { "branch": "develop", "commit": "1ed7d5cad835a4aad86ddc5432b71254d4758ada" }, "aniseed": { "branch": "master", "commit": "7bc09736f3651c10d29b82d1a465b7f540614be1" },
"antifennel-nvim": { "branch": "master", "commit": "79261d02213a5093135e5d02431682f04459f0f7" }, "antifennel-nvim": { "branch": "master", "commit": "79261d02213a5093135e5d02431682f04459f0f7" },
"any-jump.vim": { "branch": "master", "commit": "770ef708ae3f13322430fcc663d7dfb864756b9b" }, "any-jump.vim": { "branch": "master", "commit": "770ef708ae3f13322430fcc663d7dfb864756b9b" },
"ats-vim": { "branch": "master", "commit": "8e3e722b6d09ed81313573b4e7b108b265628ff1" }, "ats-vim": { "branch": "master", "commit": "8e3e722b6d09ed81313573b4e7b108b265628ff1" },
@ -16,17 +16,14 @@
"cmp-vsnip": { "branch": "main", "commit": "989a8a73c44e926199bfd05fa7a516d51f2d2752" }, "cmp-vsnip": { "branch": "main", "commit": "989a8a73c44e926199bfd05fa7a516d51f2d2752" },
"conflict-marker.vim": { "branch": "master", "commit": "11a4d42244755505b66b15cd4496a150432eb5e3" }, "conflict-marker.vim": { "branch": "master", "commit": "11a4d42244755505b66b15cd4496a150432eb5e3" },
"conjure": { "branch": "master", "commit": "58c46d1f4999679659a5918284b574c266a7ac83" }, "conjure": { "branch": "master", "commit": "58c46d1f4999679659a5918284b574c266a7ac83" },
"copilot.lua": { "branch": "master", "commit": "1a8032ae496916ccc7a7a52ee79194fbef29f462" },
"crates.nvim": { "branch": "main", "commit": "86b31c92bbcb56d01dff85b07aa008591c848416" },
"diffview.nvim": { "branch": "main", "commit": "0437ef8bfdd67156d87140d692840a3c2824fa20" }, "diffview.nvim": { "branch": "main", "commit": "0437ef8bfdd67156d87140d692840a3c2824fa20" },
"dressing.nvim": { "branch": "master", "commit": "8f4d62b7817455896a3c73cab642002072c114bc" }, "dressing.nvim": { "branch": "master", "commit": "8f4d62b7817455896a3c73cab642002072c114bc" },
"editorconfig-vim": { "branch": "master", "commit": "0d54ea863089fb13be423b4aed6cca35f3a5d778" }, "editorconfig-vim": { "branch": "master", "commit": "0d54ea863089fb13be423b4aed6cca35f3a5d778" },
"emmet-vim": { "branch": "master", "commit": "def5d57a1ae5afb1b96ebe83c4652d1c03640f4d" }, "emmet-vim": { "branch": "master", "commit": "def5d57a1ae5afb1b96ebe83c4652d1c03640f4d" },
"feline.nvim": { "branch": "master", "commit": "3587f57480b88e8009df7b36dc84e9c7ff8f2c49" },
"fennel.vim": { "branch": "master", "commit": "30b9beabad2c4f09b9b284caf5cd5666b6b4dc89" }, "fennel.vim": { "branch": "master", "commit": "30b9beabad2c4f09b9b284caf5cd5666b6b4dc89" },
"friendly-snippets": { "branch": "main", "commit": "43727c2ff84240e55d4069ec3e6158d74cb534b6" }, "friendly-snippets": { "branch": "main", "commit": "43727c2ff84240e55d4069ec3e6158d74cb534b6" },
"gh.nvim": { "branch": "main", "commit": "2b5551656c1b896bf4ae06546eaaab00311f9a18" }, "gh.nvim": { "branch": "main", "commit": "2b5551656c1b896bf4ae06546eaaab00311f9a18" },
"gitsigns.nvim": { "branch": "main", "commit": "292938621016a9eb8f266398383fca5cf531c985" }, "gitsigns.nvim": { "branch": "main", "commit": "ff01d34daaed72f271a8ffa088a7e839a60c640f" },
"glance.nvim": { "branch": "master", "commit": "8ed5cf3b3b1231ea696d88c9efd977027429d869" }, "glance.nvim": { "branch": "master", "commit": "8ed5cf3b3b1231ea696d88c9efd977027429d869" },
"haskell-vim": { "branch": "master", "commit": "f35d02204b4813d1dbe8b0e98cc39701a4b8e15e" }, "haskell-vim": { "branch": "master", "commit": "f35d02204b4813d1dbe8b0e98cc39701a4b8e15e" },
"hop.nvim": { "branch": "master", "commit": "1a1eceafe54b5081eae4cb91c723abd1d450f34b" }, "hop.nvim": { "branch": "master", "commit": "1a1eceafe54b5081eae4cb91c723abd1d450f34b" },
@ -41,9 +38,10 @@
"neoformat": { "branch": "master", "commit": "aedb6f9d3f53d5da229095f7d761d749f8c5c7e0" }, "neoformat": { "branch": "master", "commit": "aedb6f9d3f53d5da229095f7d761d749f8c5c7e0" },
"neogit": { "branch": "master", "commit": "ed99c59d7fda3ba5e2ce9a3adc0a8eb5ebfa6c8f" }, "neogit": { "branch": "master", "commit": "ed99c59d7fda3ba5e2ce9a3adc0a8eb5ebfa6c8f" },
"nerdcommenter": { "branch": "master", "commit": "d2e21d417f6c788b11ae3b90d7ac478930dead36" }, "nerdcommenter": { "branch": "master", "commit": "d2e21d417f6c788b11ae3b90d7ac478930dead36" },
"noice.nvim": { "branch": "main", "commit": "f77689c9b2436bcd70741a20311496233acb4fb9" }, "nfnl": { "branch": "main", "commit": "979dbfc48bcb601a9107764a99f9459cb5bd4051" },
"noice.nvim": { "branch": "main", "commit": "7cf858c30841c9c41601ce58e5bc2023228037ef" },
"nui.nvim": { "branch": "main", "commit": "c8de23342caf8d50b15d6b28368d36a56a69d76f" }, "nui.nvim": { "branch": "main", "commit": "c8de23342caf8d50b15d6b28368d36a56a69d76f" },
"nvim-bufferline.lua": { "branch": "main", "commit": "874f869a24e568980294b3200fc9dd842db65a36" }, "nvim-bufferline.lua": { "branch": "main", "commit": "357cc8f8eeb64702e6fcf2995e3b9becee99a5d3" },
"nvim-cmp": { "branch": "main", "commit": "5dce1b778b85c717f6614e3f4da45e9f19f54435" }, "nvim-cmp": { "branch": "main", "commit": "5dce1b778b85c717f6614e3f4da45e9f19f54435" },
"nvim-code-action-menu": { "branch": "main", "commit": "e4399dbaf6eabff998d3d5f1cbcd8d9933710027" }, "nvim-code-action-menu": { "branch": "main", "commit": "e4399dbaf6eabff998d3d5f1cbcd8d9933710027" },
"nvim-colorizer.lua": { "branch": "master", "commit": "36c610a9717cc9ec426a07c8e6bf3b3abcb139d6" }, "nvim-colorizer.lua": { "branch": "master", "commit": "36c610a9717cc9ec426a07c8e6bf3b3abcb139d6" },
@ -52,7 +50,7 @@
"nvim-jenkinsfile-linter": { "branch": "main", "commit": "6e740a9e42251452cbc79808ea894f5233a93e92" }, "nvim-jenkinsfile-linter": { "branch": "main", "commit": "6e740a9e42251452cbc79808ea894f5233a93e92" },
"nvim-lspconfig": { "branch": "master", "commit": "2b361e043810d5587d9af0787f8ce40da92ec5e9" }, "nvim-lspconfig": { "branch": "master", "commit": "2b361e043810d5587d9af0787f8ce40da92ec5e9" },
"nvim-scrollbar": { "branch": "main", "commit": "35f99d559041c7c0eff3a41f9093581ceea534e8" }, "nvim-scrollbar": { "branch": "main", "commit": "35f99d559041c7c0eff3a41f9093581ceea534e8" },
"nvim-treesitter": { "branch": "master", "commit": "db7adb21e6f17528b0f639f36641ce59d65eb68f" }, "nvim-treesitter": { "branch": "master", "commit": "10bfa4826f2235c600c073a82e0d78718aa7240e" },
"nvim-treesitter-textsubjects": { "branch": "master", "commit": "48b3bf54e32f23e2299c59ff76fa3b0599565b39" }, "nvim-treesitter-textsubjects": { "branch": "master", "commit": "48b3bf54e32f23e2299c59ff76fa3b0599565b39" },
"nvim-ts-context-commentstring": { "branch": "main", "commit": "7241635869b7a8115893ffa67bab3907756caf4f" }, "nvim-ts-context-commentstring": { "branch": "main", "commit": "7241635869b7a8115893ffa67bab3907756caf4f" },
"nvim-web-devicons": { "branch": "master", "commit": "45d0237c427baba8cd05e0ab26d30e2ee58c2c82" }, "nvim-web-devicons": { "branch": "master", "commit": "45d0237c427baba8cd05e0ab26d30e2ee58c2c82" },